DorianandClaude Opus 4.6
1ca8a6feb0
Define Fighter type alias using Kaplay's GameObj with SpriteComp, PosComp, ScaleComp, AnchorComp, OpacityComp, ColorComp, RotateComp, and ZComp. Replace 81 choreography function signatures from (atk: any, def: any, ...) to (atk: Fighter, def: Fighter, ...). Type loadSpriteWithTimeout opts as LoadSpriteOpt. Type lines/bands arrays as GameObj[]. Type spawnAfterimages and cameraZoom fighter params. Add as Fighter casts at k.get() call sites. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
11317 lines
528 KiB
TypeScript
11317 lines
528 KiB
TypeScript
import kaplay from 'kaplay'
|
|
import type { GameObj, SpriteComp, PosComp, ScaleComp, AnchorComp, OpacityComp, ColorComp, RotateComp, ZComp, LoadSpriteOpt } from 'kaplay'
|
|
|
|
type Fighter = GameObj<SpriteComp | PosComp | ScaleComp | AnchorComp | OpacityComp | ColorComp | RotateComp | ZComp>
|
|
import { generateSpriteSheet, generateJudgeSpriteSheet, generateHumanSpriteSheet, generateHumanFighterSpriteSheet, getBotColors, FRAME_SIZE, MAX_FRAMES, TOTAL_ROWS, ANIMATIONS, JUDGE_ANIMATIONS, JUDGE_MAX_FRAMES, JUDGE_ROWS, HUMAN_ANIMATIONS, HUMAN_MAX_FRAMES, HUMAN_ROWS, type SpriteCustomization } from './sprites'
|
|
import {
|
|
sfxPunch, sfxKick, sfxSpecial, sfxCritical, sfxGunshot, sfxBulletHit,
|
|
sfxJetpack, sfxExplosion, sfxKO, sfxWin, sfxWinAnnounce, sfxPerfect,
|
|
sfxRoundStart, sfxBlock, sfxDodge, sfxClash, sfxRandomSilly, sfxBoing,
|
|
sfxBonk, sfxZap, sfxSlideDown, sfxSlideUp, sfxZoomWhoosh, sfxRapidPunch,
|
|
sfxSplat, sfxWomp, sfxPowerUp, sfxCoin, sfxFail, sfxDrumRoll,
|
|
fanfareRound, fanfareFight, fanfareDevastating, fanfareCritical, fanfareCombo,
|
|
startMusic, stopMusic, announce,
|
|
announceRandom, announceDramatic, announceHype, announceSilly, announceCool,
|
|
announceRobot, announceScream, announceFast,
|
|
announceFinishHim, announceFatality, announceFlawlessVictory,
|
|
announceRandomHype, announceDeepIntro, announceRoundHype, announceCrowdReaction,
|
|
announceCreatorEntrance, announceCreatorRound, announceCreatorKO,
|
|
announceCreatorWin, announceCreatorLose, announceCreatorMorph,
|
|
announceCreatorCameo, announceCreatorTaunt, announceCreatorDevastating,
|
|
sfxRandomComedy, sfxRandomFail,
|
|
sfxVineBoom, sfxAirHorn, sfxBruh, sfxFart, sfxRecordScratch,
|
|
sfxRubberChicken, sfxSqueakyToy, sfxWetSlap, sfxBoneCrack, sfxCartoonRun,
|
|
sfxRimShot, sfxSlideWhistleUp, sfxSlideWhistleDown, sfxYippee, sfxDing,
|
|
sfxTacoBellBong, sfxWindowsError, sfxMemeThud,
|
|
sfxSadTrombone, sfxFailHorn, sfxPriceIsRightFail, sfxBuzzer,
|
|
sfxMissionFailed, sfxCrickets, sfxSadViolin, sfxEmotionalDamage, sfxDunDunDun,
|
|
} from './sounds'
|
|
|
|
export interface FightSceneConfig {
|
|
canvas: HTMLCanvasElement
|
|
botA: { name: string; seed: string; tier: number; archetype?: string; customization?: SpriteCustomization; wins?: number; losses?: number }
|
|
botB: { name: string; seed: string; tier: number; archetype?: string; customization?: SpriteCustomization; wins?: number; losses?: number }
|
|
arena: string
|
|
onReady?: () => void
|
|
}
|
|
|
|
export interface RoundEvent {
|
|
round: number
|
|
challengeType: string
|
|
winnerId: string | null
|
|
botAId: string
|
|
botBId: string
|
|
narration: string
|
|
isCritical: boolean
|
|
botAScore: number
|
|
botBScore: number
|
|
botAResponse?: string
|
|
botBResponse?: string
|
|
}
|
|
|
|
const ARENA_THEMES: Record<string, { bg: string; ground: string; accent: string }> = {
|
|
datacenter: { bg: '#0a0a1a', ground: '#1a1a3a', accent: '#00f0ff' },
|
|
stackoverflow_ruins: { bg: '#1a0f00', ground: '#2a1f10', accent: '#f48024' },
|
|
gpu_graveyard: { bg: '#0a0a0a', ground: '#1a1a1a', accent: '#76b900' },
|
|
prompt_dungeon: { bg: '#0f0a1a', ground: '#1f1a2a', accent: '#b83dff' },
|
|
silicon_valley_dojo: { bg: '#0a1a0a', ground: '#1a2a1a', accent: '#00ff41' },
|
|
paper_mill: { bg: '#1a1a10', ground: '#2a2a20', accent: '#f0e68c' },
|
|
localhost: { bg: '#000000', ground: '#111111', accent: '#00ff41' },
|
|
the_cloud: { bg: '#0a0f1a', ground: '#1a1f2a', accent: '#4488ff' },
|
|
hacker_news: { bg: '#1a0f00', ground: '#2a1f10', accent: '#ff6600' },
|
|
the_singularity: { bg: '#1a0020', ground: '#2a0030', accent: '#ff00ff' },
|
|
beach: { bg: '#0a2040', ground: '#c2a060', accent: '#ffcc00' },
|
|
desert: { bg: '#1a1000', ground: '#a08040', accent: '#ff8800' },
|
|
forest: { bg: '#051005', ground: '#1a3010', accent: '#44cc22' },
|
|
jungle: { bg: '#081808', ground: '#1a3818', accent: '#33ff66' },
|
|
outer_space: { bg: '#000008', ground: '#0a0a20', accent: '#8888ff' },
|
|
colosseum: { bg: '#1a0f08', ground: '#3a2a18', accent: '#d4a030' },
|
|
kitchen_stadium: { bg: '#1a0a0a', ground: '#2a1a10', accent: '#ff4400' },
|
|
haunted_mansion: { bg: '#0a0510', ground: '#1a1020', accent: '#8844cc' },
|
|
meme_dimension: { bg: '#1a0820', ground: '#2a1830', accent: '#ff44ff' },
|
|
space_station: { bg: '#000010', ground: '#0a0a28', accent: '#44aaff' },
|
|
junkyard: { bg: '#0f0f0a', ground: '#2a2a1a', accent: '#aa8833' },
|
|
concert_hall: { bg: '#10001a', ground: '#20102a', accent: '#ff22aa' },
|
|
savanna: { bg: '#1a1808', ground: '#8a7830', accent: '#dd9922' },
|
|
server_room: { bg: '#000a05', ground: '#0a1a10', accent: '#00ff88' },
|
|
sports_arena: { bg: '#0a0a1a', ground: '#1a2a4a', accent: '#ff3333' },
|
|
}
|
|
|
|
const spriteAnims = {
|
|
idle: { from: 0, to: ANIMATIONS.idle.frames - 1, loop: true, speed: 6 },
|
|
attack: { from: MAX_FRAMES, to: MAX_FRAMES + ANIMATIONS.attack.frames - 1, loop: false, speed: 12 },
|
|
kick: { from: MAX_FRAMES * 2, to: MAX_FRAMES * 2 + ANIMATIONS.kick.frames - 1, loop: false, speed: 10 },
|
|
special: { from: MAX_FRAMES * 3, to: MAX_FRAMES * 3 + ANIMATIONS.special.frames - 1, loop: false, speed: 8 },
|
|
hit: { from: MAX_FRAMES * 4, to: MAX_FRAMES * 4 + ANIMATIONS.hit.frames - 1, loop: false, speed: 8 },
|
|
knockback: { from: MAX_FRAMES * 5, to: MAX_FRAMES * 5 + ANIMATIONS.knockback.frames - 1, loop: false, speed: 8 },
|
|
ko: { from: MAX_FRAMES * 6, to: MAX_FRAMES * 6 + ANIMATIONS.ko.frames - 1, loop: false, speed: 6 },
|
|
win: { from: MAX_FRAMES * 7, to: MAX_FRAMES * 7 + ANIMATIONS.win.frames - 1, loop: true, speed: 6 },
|
|
}
|
|
|
|
// Challenge type -> themed choreography (shown ~60% of the time) + generic fallbacks
|
|
const CHALLENGE_THEMED: Record<string, { themed: string[]; generic: string[] }> = {
|
|
speed_blitz: { themed: ['afterimageDash', 'lightningRush', 'rapidFlurry', 'tornadoSpin', 'corkscrewDive', 'warpDrive', 'backflipKick', 'bulletTimeAttack'], generic: ['dashPunch', 'multiHit', 'fullScreenDash', 'dashThrough', 'zoomRush', 'katanaCombo', 'cycloneKick', 'helicopterArms', 'breakdanceSweep'] },
|
|
riddle: { themed: ['riddleBarrage', 'portalPunch', 'cloneStrike', 'mindBlast', 'hexCurse'], generic: ['teleportStrike', 'projectile', 'zoomRush', 'whipCrack', 'bombThrow', 'captchaTrap', 'glitchBeam'] },
|
|
code_golf: { themed: ['golfClubSmash', 'golfCartDrive', 'stackOverflow', 'segfault', 'blueScreen'], generic: ['projectile', 'flyingKick', 'dashPunch', 'rapidFlurry', 'hammerSmash', 'bodySlam', 'homeRunSwing'] },
|
|
roast_battle: { themed: ['fireBreath', 'dragonBreath', 'fireball', 'lavaSplash', 'heatVision', 'volcanoErupt'], generic: ['gunBurst', 'jetpackDive', 'multiHit', 'zoomRush', 'laserBeam', 'chainsawRev', 'rocketLauncher', 'dynamiteBlast'] },
|
|
hallucination_check: { themed: ['cloneStrike', 'portalPunch', 'shadowClone', 'glitchBeam', 'voidRift'], generic: ['teleportStrike', 'dashThrough', 'riddleBarrage', 'rapidFlurry', 'sniperShot', 'darkVoid', 'memeBeam'] },
|
|
token_economy: { themed: ['coinShower', 'bitcoinCrash', 'nftRugPull', 'vendingDrop', 'popupSpam'], generic: ['dashPunch', 'flyingKick', 'uppercut', 'zoomRush', 'bombThrow', 'minigunSpray', 'pocketCannon'] },
|
|
creative_writing: { themed: ['penStab', 'scrollBlast', 'bookStorm', 'enchantedArrow', 'newspaperRoll'], generic: ['jetpackDive', 'aerialSlam', 'projectile', 'rapidFlurry', 'katanaCombo', 'arcaneBarrage', 'memeBeam'] },
|
|
math_blitz: { themed: ['mathAttack', 'dataStream', 'pixelBeam', 'hackerAttack', 'chainLightning'], generic: ['multiHit', 'dashPunch', 'fullScreenDash', 'rapidFlurry', 'laserBeam', 'hammerSmash', 'pinballCombo'] },
|
|
trap_card: { themed: ['trapCardAttack', 'captchaTrap', 'spiderWeb', 'flashBang', 'smokeBomb'], generic: ['gunBurst', 'teleportStrike', 'groundPound', 'zoomRush', 'sniperShot', 'rocketLauncher', 'minigunSpray'] },
|
|
food_fight: { themed: ['pizzaSlam', 'bananaFling', 'pieSmash', 'hotdogWhip', 'watermelonBomb', 'sushiBarrage', 'burgerToss', 'tacoStorm', 'eggBombard', 'tomatoBarrage'], generic: ['popcornBlast', 'iceCreamFling', 'donutBarrage', 'cookieFling', 'nachoVolley', 'meatballStorm', 'candyBarrage'] },
|
|
wrestling_match: { themed: ['piledriver', 'powerbomb', 'chokeslam', 'tombstone', 'rko', 'clothesline', 'suplex', 'germanSuplex'], generic: ['bodySlam', 'grappleFlurry', 'hurricanrana', 'moonsault', 'elbowDrop', 'spear', 'stunner'] },
|
|
music_battle: { themed: ['bassDrop', 'guitarSolo', 'drumSolo', 'dubstepCannon', 'beatboxBlast', 'vinylScratch'], generic: ['airHornBlast', 'vuvuzelaBlast', 'sonicWave', 'bassDropBeam', 'karaokeAttack', 'airGuitar'] },
|
|
magic_duel: { themed: ['kamehameha', 'spiritBomb', 'arcaneBarrage', 'darkVoid', 'holySmite', 'shadowClone', 'hexCurse'], generic: ['fireball', 'iceLance', 'thunderStrike', 'portalPunch', 'crystalShards', 'scrollBlast', 'potionThrow'] },
|
|
sports_showdown: { themed: ['homeRunSwing', 'slapShot', 'servingAce', 'fieldGoalKick', 'bodyCheck', 'soccerKick', 'basketballDunk'], generic: ['baseballBat', 'tennisRacket', 'hockeyStick', 'bowlingBallRoll', 'tennisBallVolley', 'dropKick'] },
|
|
nature_clash: { themed: ['treeSmash', 'icebergDrop', 'lavaSplash', 'tornadoFling', 'tsunamiWave', 'avalanche', 'earthquakeStrike'], generic: ['vineWhip', 'sandstorm', 'thornBarrage', 'pollenCloud', 'windSlash', 'meteorStrike'] },
|
|
space_war: { themed: ['blackHole', 'photonTorpedo', 'tractor_beam', 'warpDrive', 'alienAbduction', 'ionCannon', 'cosmicRay', 'bulletTimeAttack'], generic: ['laserSword', 'plasmaSword', 'asteroidBelt', 'satelliteLaser', 'plasmaBeam', 'solarFlare'] },
|
|
hack_battle: { themed: ['hackerAttack', 'bugSwarm', 'stackOverflow', 'segfault', 'blueScreen', 'malwareInject', 'bulletTimeAttack'], generic: ['fourOhFour', 'ctrlAltDelete', 'aiUprising', 'captchaTrap', 'popupSpam', 'dataStream', 'glitchBeam'] },
|
|
meme_war: { themed: ['selfieStrike', 'dabAttack', 'flossAttack', 'yeetThrow', 'tPoseAssert', 'emojiBarrage', 'memeBeam'], generic: ['rubberChicken', 'fingerGuns', 'micDrop', 'ratioAttack', 'capThrow', 'touchGrass', 'noScope'] },
|
|
animal_kingdom: { themed: ['sharkBite', 'bearSwipe', 'eagleDive', 'bullCharge', 'gorillaSlam', 'wolfPack', 'batSwarm'], generic: ['snakeLunge', 'scorpionSting', 'crabPinch', 'spiderWeb', 'beeSwarm', 'catScratch', 'dogPile', 'dolphinFlip'] },
|
|
demolition: { themed: ['dynamiteBlast', 'c4Detonation', 'nukeStrike', 'grenadeBlast', 'rocketLauncher', 'volcanoErupt'], generic: ['fireworksBurst', 'partyPopper', 'pinataSmash', 'cherryBomb', 'confettiCannon', 'anvilDrop', 'pianoDrop'] },
|
|
vehicle_mayhem: { themed: ['motorbikeCharge', 'carSmash', 'tankRoll', 'helicopterStrike', 'zamboniCrush', 'tractorPlow'], generic: ['shoppingCart', 'forkliftCharge', 'airplaneSwoop', 'rocketRide', 'unicycleRun', 'golfCartDrive', 'boatCannon'] },
|
|
medieval_combat: { themed: ['swordSlash', 'katanaCombo', 'battleAxe', 'maceSwing', 'crossbowBolt', 'shieldBash'], generic: ['flailSwing', 'holyWater', 'dragonBreath', 'enchantedArrow', 'laserSword', 'scrollBlast'] },
|
|
retro_mode: { themed: ['dashPunch', 'uppercut', 'rapidFlurry', 'flyingKick', 'multiHit', 'fullScreenDash', 'backflipKick', 'cycloneKick'], generic: ['bodySlam', 'grappleFlurry', 'suplex', 'katanaCombo', 'breakdanceSweep', 'corkscrewDive', 'pinballCombo'] },
|
|
}
|
|
|
|
// Tier-gated ultimate move pools — cumulative (tier 3 bot can use tier 2+3 moves)
|
|
const TIER_ULTIMATES: Record<number, string[]> = {
|
|
2: ['ultimateRapidBarrage', 'ultimateOrbitalStrike', 'ultimateCloneSurround', 'ultimateGatlingFury', 'ultimateEarthquake', 'ultimateBouncingFury', 'ultimateTripleBeam', 'ultimateMegaThrow', 'ultimateTornadoGrab', 'ultimateMeteorShower'],
|
|
3: ['ultimateScreenNuke', 'ultimateBlackHoleVortex', 'ultimateDimensionalRift', 'ultimateTimeSlow', 'ultimateSummonArmy', 'ultimateHellfireRain', 'ultimateCrystalCage', 'ultimateGigaDrill', 'ultimateSuperSlam', 'ultimateAvalancheDrop', 'ultimateBulletTimeBarrage'],
|
|
4: ['ultimateFinaleRush', 'ultimateMeteorCrash', 'ultimateScreenShatter', 'ultimateGravityReverse', 'ultimateInfiniteCombo', 'ultimatePlasmaStorm', 'ultimateFrozenCoffin', 'ultimateLavaGeyser', 'ultimateChainGrab', 'ultimateRocketBarrage'],
|
|
5: ['ultimateArmageddon', 'ultimateOmegaBeam', 'ultimateBeyondTheScreen', 'ultimateMatrixDodge', 'ultimateWorldEnder', 'ultimateAbsoluteZero', 'ultimateSolarCannon', 'ultimatePhantomStrike', 'ultimateGodPunch', 'ultimateVoidCollapse'],
|
|
}
|
|
|
|
// The Creator — exclusive moves (50% ultimate chance, 100% on crits, custom pool)
|
|
const CREATOR_MOVES = ['bitcoinRain', 'lightningInvoice', 'satoshiStrike', 'hashRateOverload', 'blockchainSlam', 'creatorMode', 'morphStrike', 'divineIntervention', 'bitcoinSwarm', 'satoshiTornado', 'hodlWave', 'bitcoinBarrage', 'bulletTimeAttack']
|
|
const CREATOR_ULTIMATES = ['ultimateGenesisBlock', 'ultimateTheHalving', 'ultimateFullNodeCrush', 'ultimateSatoshiVision']
|
|
|
|
function pickChoreography(challengeType: string, isCritical: boolean, _round: number, attackerTier: number = 0, attackerArchetype?: string): string {
|
|
// THE CREATOR: special move selection — 50% ultimate, 60% creator moves, rest normal
|
|
if (attackerArchetype === 'the_creator') {
|
|
const ultimateChance = isCritical ? 1.0 : 0.5
|
|
if (Math.random() < ultimateChance) {
|
|
// Creator gets ALL ultimates + their 4 exclusive ones
|
|
const all: string[] = [...CREATOR_ULTIMATES]
|
|
for (let t = 2; t <= 5; t++) {
|
|
if (TIER_ULTIMATES[t]) all.push(...TIER_ULTIMATES[t])
|
|
}
|
|
return all[Math.floor(Math.random() * all.length)]
|
|
}
|
|
// 60% creator-themed, 40% normal selection
|
|
if (Math.random() < 0.6) {
|
|
return CREATOR_MOVES[Math.floor(Math.random() * CREATOR_MOVES.length)]
|
|
}
|
|
// Fall through to normal selection
|
|
}
|
|
|
|
// Tier-gated ultimates: higher tier = higher chance of spectacular ultimate moves
|
|
// Tier 2: 15% chance, Tier 3: 20%, Tier 4: 30%, Tier 5: 40%
|
|
if (attackerTier >= 2) {
|
|
const ultimateChance = attackerTier === 2 ? 0.15 : attackerTier === 3 ? 0.20 : attackerTier === 4 ? 0.30 : 0.40
|
|
// On crits, double the chance
|
|
const roll = isCritical ? ultimateChance * 2 : ultimateChance
|
|
if (Math.random() < roll) {
|
|
// Collect all ultimates available at this tier (cumulative — higher tiers get lower tier moves too)
|
|
const available: string[] = []
|
|
for (let t = 2; t <= attackerTier; t++) {
|
|
if (TIER_ULTIMATES[t]) available.push(...TIER_ULTIMATES[t])
|
|
}
|
|
if (available.length > 0) {
|
|
return available[Math.floor(Math.random() * available.length)]
|
|
}
|
|
}
|
|
}
|
|
|
|
// Critical hits always get BIG moves (but can still be themed)
|
|
if (isCritical) {
|
|
const entry = CHALLENGE_THEMED[challengeType]
|
|
// 50% themed, 50% epic generic for crits
|
|
if (entry && Math.random() < 0.5) {
|
|
return entry.themed[Math.floor(Math.random() * entry.themed.length)]
|
|
}
|
|
const critMoves = [
|
|
'groundPound', 'jetpackDive', 'gunBurst', 'fullScreenDash', 'multiHit', 'fireBreath',
|
|
'lightningRush', 'zoomRush', 'rapidFlurry', 'rocketLauncher', 'laserBeam', 'katanaCombo',
|
|
'hammerSmash', 'sniperShot', 'minigunSpray', 'chainsawRev', 'carSmash', 'motorbikeCharge',
|
|
'anvilDrop', 'pocketCannon', 'bodySlam', 'suplex', 'pinballCombo', 'grappleFlurry',
|
|
// New epic crits
|
|
'kamehameha', 'nukeStrike', 'tankRoll', 'helicopterStrike', 'chokeslam', 'tombstone',
|
|
'rko', 'piledriver', 'powerbomb', 'meteorStrike', 'spiritBomb', 'blackHole',
|
|
'alienAbduction', 'tsunamiWave', 'earthquakeStrike', 'dragonBreath', 'pianoDrop',
|
|
'fridgeDrop', 'volcanoErupt', 'warpDrive', 'dubstepCannon', 'tornadoSpin',
|
|
'trampolineBounce', 'watermelonBomb', 'nftRugPull', 'blueScreen', 'yeetThrow',
|
|
'bulletTimeAttack',
|
|
]
|
|
return critMoves[Math.floor(Math.random() * critMoves.length)]
|
|
}
|
|
|
|
const entry = CHALLENGE_THEMED[challengeType]
|
|
if (!entry) {
|
|
const fallback = ['dashPunch', 'flyingKick', 'aerialSlam', 'backflipKick', 'fingerGuns', 'rubberChicken', 'pizzaSlam', 'fryingPan', 'snowballFight']
|
|
return fallback[Math.floor(Math.random() * fallback.length)]
|
|
}
|
|
|
|
// 60% themed, 25% generic fallback, 15% wild card
|
|
const roll = Math.random()
|
|
if (roll < 0.6) {
|
|
return entry.themed[Math.floor(Math.random() * entry.themed.length)]
|
|
} else if (roll < 0.85) {
|
|
return entry.generic[Math.floor(Math.random() * entry.generic.length)]
|
|
} else {
|
|
const wild = [
|
|
'jetpackDive', 'gunBurst', 'groundPound', 'teleportStrike', 'fullScreenDash', 'fireBreath',
|
|
'golfClubSmash', 'zoomRush', 'rapidFlurry', 'swordSlash', 'hammerSmash', 'laserBeam',
|
|
'rocketLauncher', 'bombThrow', 'minigunSpray', 'sniperShot', 'whipCrack', 'katanaCombo',
|
|
'chainsawRev', 'motorbikeCharge', 'carSmash', 'boatCannon', 'anvilDrop', 'pocketCannon',
|
|
'grappleFlurry', 'bodySlam', 'pinballCombo', 'suplex',
|
|
// New wild cards — food
|
|
'pizzaSlam', 'bananaFling', 'pieSmash', 'burgerToss', 'tomatoBarrage', 'fishSlap',
|
|
// New wild cards — weapons
|
|
'fryingPan', 'baseballBat', 'guitarSmash', 'umbrellaWhack', 'plungerSlam', 'wrenchSmash',
|
|
// New wild cards — drops
|
|
'pianoDrop', 'toiletDrop', 'tvDrop', 'chandelierDrop', 'micDrop',
|
|
// New wild cards — vehicles
|
|
'shoppingCart', 'zamboniCrush', 'unicycleRun', 'tankRoll',
|
|
// New wild cards — spins/flips
|
|
'tornadoSpin', 'backflipKick', 'corkscrewDive', 'barrelRoll', 'skateTrick',
|
|
// New wild cards — beams
|
|
'kamehameha', 'freezeRay', 'heatVision', 'rainbowBeam', 'glitchBeam',
|
|
// New wild cards — silly
|
|
'rubberChicken', 'selfieStrike', 'fingerGuns', 'yeetThrow', 'emojiBarrage', 'touchGrass',
|
|
// New wild cards — wrestling
|
|
'clothesline', 'rko', 'stunner', 'piledriver',
|
|
// New wild cards — magic
|
|
'fireball', 'portalPunch', 'crystalShards', 'spiritBomb',
|
|
// New wild cards — tech
|
|
'stackOverflow', 'blueScreen', 'aiUprising', 'popupSpam',
|
|
// New wild cards — music
|
|
'bassDrop', 'dubstepCannon', 'vinylScratch',
|
|
// New wild cards — nature
|
|
'avalanche', 'lavaSplash', 'tornadoFling',
|
|
]
|
|
return wild[Math.floor(Math.random() * wild.length)]
|
|
}
|
|
}
|
|
|
|
// Convert any CSS color string to a kaplay Color object safely
|
|
function safeColor(k: ReturnType<typeof kaplay>, color: string) {
|
|
if (color.startsWith('#')) {
|
|
try { return k.Color.fromHex(color) } catch { /* fall through */ }
|
|
}
|
|
// HSL / rgb / named color — render to a 1px canvas to extract RGB
|
|
const cv = document.createElement('canvas')
|
|
cv.width = 1; cv.height = 1
|
|
const cx = cv.getContext('2d')!
|
|
cx.fillStyle = color
|
|
cx.fillRect(0, 0, 1, 1)
|
|
const [r, g, b] = cx.getImageData(0, 0, 1, 1).data
|
|
return k.Color.fromArray([r, g, b])
|
|
}
|
|
|
|
export async function createFightScene(config: FightSceneConfig) {
|
|
const { canvas, botA, botB, arena } = config
|
|
const theme = ARENA_THEMES[arena] || ARENA_THEMES.localhost
|
|
|
|
const k = kaplay({
|
|
canvas,
|
|
width: canvas.width || 800,
|
|
height: canvas.height || 500,
|
|
background: theme.bg,
|
|
global: false,
|
|
scale: 1,
|
|
crisp: true,
|
|
texFilter: 'nearest',
|
|
})
|
|
|
|
const colorsA = getBotColors(botA.seed)
|
|
const colorsB = getBotColors(botB.seed)
|
|
|
|
let sheetA: string
|
|
let sheetB: string
|
|
|
|
// Human fighters use their profile human character, not a bot sprite
|
|
const winRateA = (botA.wins || 0) / Math.max(1, (botA.wins || 0) + (botA.losses || 0))
|
|
const winRateB = (botB.wins || 0) / Math.max(1, (botB.wins || 0) + (botB.losses || 0))
|
|
|
|
try {
|
|
sheetA = botA.archetype === 'human'
|
|
? generateHumanFighterSpriteSheet(botA.seed, botA.archetype, colorsA.primary, colorsA.secondary, winRateA)
|
|
: generateSpriteSheet(botA.seed, botA.tier, colorsA.primary, colorsA.secondary, botA.archetype, botA.customization)
|
|
} catch (err) {
|
|
console.error('[FightScene] Failed to generate sprite for botA:', err)
|
|
sheetA = generateSpriteSheet(botA.seed, botA.tier, colorsA.primary, colorsA.secondary)
|
|
}
|
|
try {
|
|
sheetB = botB.archetype === 'human'
|
|
? generateHumanFighterSpriteSheet(botB.seed, botB.archetype, colorsB.primary, colorsB.secondary, winRateB)
|
|
: generateSpriteSheet(botB.seed, botB.tier, colorsB.primary, colorsB.secondary, botB.archetype, botB.customization)
|
|
} catch (err) {
|
|
console.error('[FightScene] Failed to generate sprite for botB:', err)
|
|
sheetB = generateSpriteSheet(botB.seed, botB.tier, colorsB.primary, colorsB.secondary)
|
|
}
|
|
|
|
const isHumanA = botA.archetype === 'human'
|
|
const isHumanB = botB.archetype === 'human'
|
|
|
|
// Helper: load sprite with a 5s timeout so mobile never hangs forever
|
|
async function loadSpriteWithTimeout(name: string, src: string, opts: LoadSpriteOpt): Promise<void> {
|
|
try {
|
|
await Promise.race([
|
|
k.loadSprite(name, src, opts),
|
|
new Promise<never>((_resolve, reject) => setTimeout(() => reject(new Error('timeout')), 5_000)),
|
|
])
|
|
} catch (err) {
|
|
console.warn(`[FightScene] Sprite '${name}' failed/timed out:`, err)
|
|
}
|
|
}
|
|
|
|
// Await sprite loading — timeout prevents mobile hangs
|
|
await Promise.all([
|
|
loadSpriteWithTimeout('botA', sheetA, { sliceX: MAX_FRAMES, sliceY: TOTAL_ROWS, anims: spriteAnims }),
|
|
loadSpriteWithTimeout('botB', sheetB, { sliceX: MAX_FRAMES, sliceY: TOTAL_ROWS, anims: spriteAnims }),
|
|
])
|
|
|
|
// Preload bot sprites for human fighters (used when humans morph into bots)
|
|
if (isHumanA) {
|
|
const botSheetA = generateSpriteSheet(botA.seed, botA.tier, colorsA.primary, colorsA.secondary)
|
|
loadSpriteWithTimeout('botA_morph', botSheetA, { sliceX: MAX_FRAMES, sliceY: TOTAL_ROWS, anims: spriteAnims })
|
|
}
|
|
if (isHumanB) {
|
|
const botSheetB = generateSpriteSheet(botB.seed, botB.tier, colorsB.primary, colorsB.secondary)
|
|
loadSpriteWithTimeout('botB_morph', botSheetB, { sliceX: MAX_FRAMES, sliceY: TOTAL_ROWS, anims: spriteAnims })
|
|
}
|
|
|
|
// Judge sprite (red lobster referee)
|
|
const judgeSheet = generateJudgeSpriteSheet()
|
|
const judgeAnims = {
|
|
idle: { from: 0, to: JUDGE_ANIMATIONS.idle.frames - 1, loop: true, speed: 4 },
|
|
call_left: { from: JUDGE_MAX_FRAMES, to: JUDGE_MAX_FRAMES + JUDGE_ANIMATIONS.call_left.frames - 1, loop: false, speed: 8 },
|
|
call_right: { from: JUDGE_MAX_FRAMES * 2, to: JUDGE_MAX_FRAMES * 2 + JUDGE_ANIMATIONS.call_right.frames - 1, loop: false, speed: 8 },
|
|
shocked: { from: JUDGE_MAX_FRAMES * 3, to: JUDGE_MAX_FRAMES * 3 + JUDGE_ANIMATIONS.shocked.frames - 1, loop: false, speed: 10 },
|
|
}
|
|
await loadSpriteWithTimeout('judge', judgeSheet, { sliceX: JUDGE_MAX_FRAMES, sliceY: JUDGE_ROWS, anims: judgeAnims })
|
|
|
|
// Human sprites (the bot owner's silly human avatar for crowd)
|
|
const humanSheetA = generateHumanSpriteSheet(botA.seed, botA.archetype || 'standard', colorsA.primary, colorsA.secondary, winRateA)
|
|
const humanSheetB = generateHumanSpriteSheet(botB.seed, botB.archetype || 'standard', colorsB.primary, colorsB.secondary, winRateB)
|
|
const humanAnims: Record<string, { from: number; to: number; loop: boolean; speed: number }> = {}
|
|
for (const [name, cfg] of Object.entries(HUMAN_ANIMATIONS)) {
|
|
humanAnims[name] = { from: cfg.row * HUMAN_MAX_FRAMES, to: cfg.row * HUMAN_MAX_FRAMES + cfg.frames - 1, loop: true, speed: 6 }
|
|
}
|
|
await Promise.all([
|
|
loadSpriteWithTimeout('humanA', humanSheetA, { sliceX: HUMAN_MAX_FRAMES, sliceY: HUMAN_ROWS, anims: humanAnims }),
|
|
loadSpriteWithTimeout('humanB', humanSheetB, { sliceX: HUMAN_MAX_FRAMES, sliceY: HUMAN_ROWS, anims: humanAnims }),
|
|
])
|
|
|
|
const W = k.width()
|
|
const H = k.height()
|
|
// Scale factor so sprites shrink on small canvases (reference: 500px tall)
|
|
const SF = Math.min(1, H / 500)
|
|
const GROUND_Y = H * 0.78
|
|
const HOME_A = W * 0.28
|
|
const HOME_B = W * 0.72
|
|
|
|
// Particle helpers
|
|
function spawnSparks(x: number, y: number, count: number, color: string) {
|
|
const intense = count > 8
|
|
for (let i = 0; i < count; i++) {
|
|
const angle = Math.random() * Math.PI * 2
|
|
const speed = (intense ? 150 : 100) + Math.random() * (intense ? 400 : 300)
|
|
const size = (intense ? 3 : 2) + Math.random() * (intense ? 6 : 4)
|
|
const rotSpeed = (Math.random() - 0.5) * 600
|
|
const spark = k.add([
|
|
k.rect(size, size * (0.5 + Math.random() * 0.5)),
|
|
k.pos(x, y),
|
|
k.color(safeColor(k,color)),
|
|
k.opacity(1),
|
|
k.z(20),
|
|
k.rotate(Math.random() * 360),
|
|
k.anchor('center'),
|
|
{ vx: Math.cos(angle) * speed, vy: Math.sin(angle) * speed - 100, rotV: rotSpeed },
|
|
])
|
|
spark.onUpdate(() => {
|
|
spark.pos.x += (spark as any).vx * k.dt()
|
|
spark.pos.y += (spark as any).vy * k.dt()
|
|
;(spark as any).vy += 500 * k.dt() // gravity
|
|
spark.angle += (spark as any).rotV * k.dt()
|
|
spark.opacity -= 1.5 * k.dt()
|
|
if (spark.opacity <= 0) spark.destroy()
|
|
})
|
|
}
|
|
}
|
|
|
|
function spawnBulletHoles(x: number, y: number, count: number) {
|
|
for (let i = 0; i < count; i++) {
|
|
const hole = k.add([
|
|
k.circle(3 + Math.random() * 3),
|
|
k.pos(x + (Math.random() - 0.5) * 40, y + (Math.random() - 0.5) * 60),
|
|
k.color(safeColor(k,'#000000')),
|
|
k.opacity(0.8),
|
|
k.z(9), // behind fighters
|
|
])
|
|
// Fade out after a bit
|
|
setTimeout(() => {
|
|
const fadeInterval = setInterval(() => {
|
|
hole.opacity -= 0.02
|
|
if (hole.opacity <= 0) { hole.destroy(); clearInterval(fadeInterval) }
|
|
}, 50)
|
|
}, 1500)
|
|
}
|
|
}
|
|
|
|
function spawnExhaust(x: number, y: number, duration: number) {
|
|
const endTime = performance.now() + duration * 1000
|
|
const interval = setInterval(() => {
|
|
if (performance.now() > endTime) { clearInterval(interval); return }
|
|
for (let i = 0; i < 3; i++) {
|
|
const p = k.add([
|
|
k.circle(3 + Math.random() * 5),
|
|
k.pos(x + (Math.random() - 0.5) * 15, y),
|
|
k.color(safeColor(k,Math.random() > 0.5 ? '#ff6600' : '#ffcc00')),
|
|
k.opacity(0.8),
|
|
k.z(8),
|
|
])
|
|
p.onUpdate(() => {
|
|
p.pos.y += 100 * k.dt()
|
|
p.pos.x += (Math.random() - 0.5) * 50 * k.dt()
|
|
p.opacity -= 2.5 * k.dt()
|
|
if (p.opacity <= 0) p.destroy()
|
|
})
|
|
}
|
|
}, 40)
|
|
return interval
|
|
}
|
|
|
|
function spawnProjectile(fromX: number, fromY: number, toX: number, toY: number, color: string, size: number = 8): Promise<void> {
|
|
return new Promise(resolve => {
|
|
const proj = k.add([
|
|
k.circle(size),
|
|
k.pos(fromX, fromY),
|
|
k.color(safeColor(k,color)),
|
|
k.opacity(1),
|
|
k.z(15),
|
|
])
|
|
// Trail
|
|
const trail = setInterval(() => {
|
|
const t = k.add([
|
|
k.circle(size * 0.6),
|
|
k.pos(proj.pos.x, proj.pos.y),
|
|
k.color(safeColor(k,color)),
|
|
k.opacity(0.5),
|
|
k.z(14),
|
|
])
|
|
t.onUpdate(() => { t.opacity -= 3 * k.dt(); if (t.opacity <= 0) t.destroy() })
|
|
}, 30)
|
|
|
|
const dx = toX - fromX
|
|
const dy = toY - fromY
|
|
const dist = Math.sqrt(dx * dx + dy * dy)
|
|
const speed = 800
|
|
const dur = dist / speed
|
|
|
|
k.tween(0, 1, dur, (t) => {
|
|
proj.pos.x = fromX + dx * t
|
|
proj.pos.y = fromY + dy * t
|
|
}, k.easings.linear).then(() => {
|
|
clearInterval(trail)
|
|
proj.destroy()
|
|
spawnSparks(toX, toY, 8, color)
|
|
resolve()
|
|
})
|
|
})
|
|
}
|
|
|
|
function spawnBullet(fromX: number, fromY: number, toX: number, toY: number): Promise<void> {
|
|
return new Promise(resolve => {
|
|
const bullet = k.add([
|
|
k.rect(6, 2),
|
|
k.pos(fromX, fromY),
|
|
k.color(safeColor(k,'#ffee00')),
|
|
k.opacity(1),
|
|
k.z(15),
|
|
k.rotate(Math.atan2(toY - fromY, toX - fromX) * 180 / Math.PI),
|
|
])
|
|
const dur = 0.08 + Math.random() * 0.04
|
|
k.tween(0, 1, dur, (t) => {
|
|
bullet.pos.x = fromX + (toX - fromX) * t
|
|
bullet.pos.y = fromY + (toY - fromY) * t + (Math.random() - 0.5) * 4
|
|
}, k.easings.linear).then(() => {
|
|
bullet.destroy()
|
|
// Muzzle flash at impact
|
|
spawnSparks(toX, toY, 3, '#ffcc00')
|
|
resolve()
|
|
})
|
|
})
|
|
}
|
|
|
|
function spawnShockwave(x: number, y: number, color: string) {
|
|
const wave = k.add([
|
|
k.circle(5),
|
|
k.pos(x, y),
|
|
k.color(safeColor(k,color)),
|
|
k.opacity(0.7),
|
|
k.z(5),
|
|
k.scale(1),
|
|
])
|
|
k.tween(1, 15, 0.4, (v) => { wave.scaleTo(v, v * 0.3) }, k.easings.easeOutQuad)
|
|
k.tween(0.7, 0, 0.4, (v) => { wave.opacity = v }, k.easings.easeOutQuad).then(() => wave.destroy())
|
|
}
|
|
|
|
// === VISUAL CHAOS EFFECTS ===
|
|
|
|
// RGB split glitch — offsets red/blue channels using colored overlays
|
|
function glitchRGB(duration: number = 0.2) {
|
|
const layers = [
|
|
{ color: '#ff0000', dx: 4 + Math.random() * 6, dy: -2 },
|
|
{ color: '#0000ff', dx: -(4 + Math.random() * 6), dy: 2 },
|
|
]
|
|
for (const l of layers) {
|
|
const overlay = k.add([
|
|
k.rect(W, H), k.pos(l.dx, l.dy),
|
|
k.color(safeColor(k,l.color)), k.opacity(0.12), k.z(55),
|
|
])
|
|
overlay.onUpdate(() => {
|
|
overlay.pos.x = l.dx + (Math.random() - 0.5) * 4
|
|
overlay.pos.y = l.dy + (Math.random() - 0.5) * 2
|
|
})
|
|
setTimeout(() => { if (overlay.exists()) overlay.destroy() }, duration * 1000)
|
|
}
|
|
}
|
|
|
|
// Scanline glitch — horizontal bands flicker
|
|
function scanlineGlitch(duration: number = 0.3) {
|
|
const lines: GameObj[] = []
|
|
const count = 6 + Math.floor(Math.random() * 8)
|
|
for (let i = 0; i < count; i++) {
|
|
const ly = Math.random() * H
|
|
const lh = 1 + Math.random() * 3
|
|
const line = k.add([
|
|
k.rect(W, lh), k.pos(0, ly),
|
|
k.color(safeColor(k,Math.random() > 0.5 ? '#ffffff' : '#000000')),
|
|
k.opacity(0.15 + Math.random() * 0.2), k.z(54),
|
|
])
|
|
line.onUpdate(() => {
|
|
line.pos.x = (Math.random() - 0.5) * 8
|
|
line.opacity = Math.random() > 0.3 ? 0.15 : 0
|
|
})
|
|
lines.push(line)
|
|
}
|
|
setTimeout(() => { lines.forEach(l => { if (l.exists()) l.destroy() }) }, duration * 1000)
|
|
}
|
|
|
|
// VHS tracking distortion — horizontal offset bands
|
|
function vhsTracking(duration: number = 0.4) {
|
|
const bands: GameObj[] = []
|
|
const bandCount = 3
|
|
for (let i = 0; i < bandCount; i++) {
|
|
const by = Math.random() * H
|
|
const bh = 10 + Math.random() * 30
|
|
const band = k.add([
|
|
k.rect(W, bh), k.pos(0, by),
|
|
k.color(safeColor(k,theme.accent)), k.opacity(0.06), k.z(53),
|
|
])
|
|
band.onUpdate(() => {
|
|
band.pos.x = Math.sin(k.time() * 20 + i * 3) * 15
|
|
band.pos.y += (Math.random() - 0.5) * 2
|
|
})
|
|
bands.push(band)
|
|
}
|
|
setTimeout(() => { bands.forEach(b => { if (b.exists()) b.destroy() }) }, duration * 1000)
|
|
}
|
|
|
|
// Dimensional shift — background color/hue flash cycle
|
|
function dimensionalShift(duration: number = 0.6) {
|
|
const colors = ['#ff00ff', '#00ffff', '#ff0000', '#0000ff', '#ffff00']
|
|
let idx = 0
|
|
const overlay = k.add([
|
|
k.rect(W, H), k.pos(0, 0),
|
|
k.color(safeColor(k,colors[0])), k.opacity(0.08), k.z(1),
|
|
])
|
|
const interval = setInterval(() => {
|
|
idx = (idx + 1) % colors.length
|
|
overlay.color = safeColor(k,colors[idx])
|
|
overlay.opacity = 0.05 + Math.random() * 0.06
|
|
}, 80)
|
|
setTimeout(() => { clearInterval(interval); if (overlay.exists()) overlay.destroy() }, duration * 1000)
|
|
}
|
|
|
|
// Schizo cut — rapid zoom/position jitter simulating jump cuts
|
|
async function schizoCut() {
|
|
const fA = k.get('fighterA')[0] as Fighter
|
|
const fB = k.get('fighterB')[0] as Fighter
|
|
if (!fA || !fB) return
|
|
const origAX = fA.pos.x, origBX = fB.pos.x
|
|
const origAY = fA.pos.y, origBY = fB.pos.y
|
|
// 3-5 rapid cuts
|
|
const cuts = 3 + Math.floor(Math.random() * 3)
|
|
for (let i = 0; i < cuts; i++) {
|
|
// Random offset both fighters
|
|
fA.pos.x = origAX + (Math.random() - 0.5) * 30
|
|
fA.pos.y = origAY + (Math.random() - 0.5) * 15
|
|
fB.pos.x = origBX + (Math.random() - 0.5) * 30
|
|
fB.pos.y = origBY + (Math.random() - 0.5) * 15
|
|
screenFlash(Math.random() > 0.5 ? '#000000' : '#ffffff', 0.03)
|
|
await k.wait(0.04 + Math.random() * 0.03)
|
|
}
|
|
fA.pos.x = origAX; fA.pos.y = origAY
|
|
fB.pos.x = origBX; fB.pos.y = origBY
|
|
}
|
|
|
|
// Hyperspeed lines — converging toward a point
|
|
function hyperSpeedLines(targetX: number, targetY: number, duration: number = 0.3) {
|
|
const lines: GameObj[] = []
|
|
for (let i = 0; i < 16; i++) {
|
|
const angle = (i / 16) * Math.PI * 2
|
|
const dist = 300 + Math.random() * 200
|
|
const sx = targetX + Math.cos(angle) * dist
|
|
const sy = targetY + Math.sin(angle) * dist
|
|
const len = 30 + Math.random() * 60
|
|
const line = k.add([
|
|
k.rect(len, 1.5), k.pos(sx, sy),
|
|
k.color(safeColor(k,'#ffffff')), k.opacity(0.3), k.z(52),
|
|
k.rotate(angle * 180 / Math.PI + 180),
|
|
])
|
|
line.onUpdate(() => {
|
|
const dx = targetX - line.pos.x
|
|
const dy = targetY - line.pos.y
|
|
const d = Math.sqrt(dx * dx + dy * dy)
|
|
if (d > 10) {
|
|
line.pos.x += (dx / d) * 600 * k.dt()
|
|
line.pos.y += (dy / d) * 600 * k.dt()
|
|
}
|
|
line.opacity -= 0.8 * k.dt()
|
|
if (line.opacity <= 0 && line.exists()) line.destroy()
|
|
})
|
|
lines.push(line)
|
|
}
|
|
setTimeout(() => { lines.forEach(l => { if (l.exists()) l.destroy() }) }, duration * 1000)
|
|
}
|
|
|
|
// Flash the whole screen
|
|
function screenFlash(color: string, duration: number = 0.1) {
|
|
const flash = k.add([
|
|
k.rect(W, H),
|
|
k.pos(0, 0),
|
|
k.color(safeColor(k,color)),
|
|
k.opacity(0.4),
|
|
k.z(50),
|
|
])
|
|
k.tween(0.4, 0, duration, (v) => { flash.opacity = v }).then(() => flash.destroy())
|
|
}
|
|
|
|
// Impact freeze-frame: brief pause with white flash on devastating crits
|
|
async function impactFreeze(duration: number = 0.08) {
|
|
const overlay = k.add([
|
|
k.rect(W, H), k.pos(0, 0),
|
|
k.color(safeColor(k, '#ffffff')), k.opacity(0.5), k.z(55),
|
|
])
|
|
// Kaplay has no built-in pause, so we just hold with a wait + overlay
|
|
await k.wait(duration)
|
|
k.tween(0.5, 0, 0.06, (v) => { overlay.opacity = v }).then(() => overlay.destroy())
|
|
}
|
|
|
|
// Spawn afterimages: trailing ghost sprites behind a moving fighter
|
|
function spawnAfterimages(fighter: Fighter, count: number = 3) {
|
|
if (!fighter?.exists()) return
|
|
for (let i = 0; i < count; i++) {
|
|
const ghost = k.add([
|
|
k.rect(FRAME_SIZE * Math.abs(fighter.scale.x), FRAME_SIZE * Math.abs(fighter.scale.y)),
|
|
k.pos(fighter.pos.x - i * 8 * Math.sign(fighter.scale.x), fighter.pos.y),
|
|
k.color(safeColor(k, theme.accent)),
|
|
k.opacity(0.3 - i * 0.08),
|
|
k.z(fighter.z - 1),
|
|
k.anchor('bot'),
|
|
])
|
|
k.tween(ghost.opacity, 0, 0.15 + i * 0.05, (v) => { ghost.opacity = v }).then(() => ghost.destroy())
|
|
}
|
|
}
|
|
|
|
// Camera zoom: scale fighters toward/away from a focal point for impact emphasis
|
|
async function cameraZoom(
|
|
fighters: Fighter[],
|
|
savedScales: { x: number; y: number }[],
|
|
zoomFactor: number,
|
|
duration: number,
|
|
easing: (t: number) => number = k.easings.easeOutQuad,
|
|
) {
|
|
await Promise.all(fighters.map((f, i) => {
|
|
if (!f?.exists()) return Promise.resolve()
|
|
const sx = savedScales[i].x
|
|
const sy = savedScales[i].y
|
|
return k.tween(Math.abs(f.scale.y), Math.abs(sy) * zoomFactor, duration, (v) => {
|
|
f.scale.x = sx > 0 ? v : -v
|
|
f.scale.y = v
|
|
}, easing)
|
|
}))
|
|
}
|
|
|
|
// Grotesque close-up overlays removed — noops retained for call-site compatibility
|
|
function spawnGrotesqueDetails(_fighter: Fighter, _scaleFactor: number) {}
|
|
function destroyGrotesqueDetails() {}
|
|
// Arena-specific background decoration
|
|
function drawArenaDecor() {
|
|
const a = arena
|
|
const acc = theme.accent
|
|
|
|
// Parallax stars/particles in the sky
|
|
for (let i = 0; i < 40; i++) {
|
|
const star = k.add([
|
|
k.rect(1 + Math.random() * 2, 1 + Math.random() * 2),
|
|
k.pos(Math.random() * W, Math.random() * (GROUND_Y - 20)),
|
|
k.color(safeColor(k, i % 5 === 0 ? '#ffffff' : acc)),
|
|
k.opacity(0.08 + Math.random() * 0.2),
|
|
k.z(1),
|
|
])
|
|
const speed = 0.5 + Math.random() * 1.5
|
|
const baseOp = star.opacity
|
|
star.onUpdate(() => {
|
|
star.opacity = baseOp + Math.sin(k.time() * speed + i) * 0.08
|
|
})
|
|
}
|
|
|
|
if (a === 'datacenter' || a === 'localhost') {
|
|
// City skyline silhouette behind the racks
|
|
const buildingHeights = [0.55, 0.4, 0.65, 0.35, 0.7, 0.45, 0.6, 0.5, 0.72, 0.38, 0.58, 0.42]
|
|
for (let i = 0; i < buildingHeights.length; i++) {
|
|
const bw = W / buildingHeights.length + 4
|
|
const bh = GROUND_Y * buildingHeights[i]
|
|
const bx = i * (W / buildingHeights.length)
|
|
k.add([k.rect(bw, bh), k.pos(bx, GROUND_Y - bh), k.color(safeColor(k, '#060610')), k.opacity(0.5), k.z(0)])
|
|
for (let wy = 0; wy < bh - 10; wy += 8) {
|
|
for (let wx = 4; wx < bw - 6; wx += 7) {
|
|
const win = k.add([
|
|
k.rect(3, 3), k.pos(bx + wx, GROUND_Y - bh + 6 + wy),
|
|
k.color(safeColor(k, Math.random() > 0.4 ? '#223355' : '#ffcc44')),
|
|
k.opacity(0.15 + Math.random() * 0.2), k.z(0),
|
|
])
|
|
if (Math.random() < 0.15) {
|
|
const blink = 0.03 + Math.random() * 0.06
|
|
win.onUpdate(() => { win.opacity = Math.random() > blink ? win.opacity : (Math.random() > 0.5 ? 0.3 : 0.05) })
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Server rack wall
|
|
for (let row = 0; row < 4; row++) {
|
|
for (let col = 0; col < 10; col++) {
|
|
const lx = 15 + col * (W / 10)
|
|
const ly = 15 + row * 55
|
|
const rackW = W / 10 - 8
|
|
const rackH = 48
|
|
k.add([k.rect(rackW, rackH), k.pos(lx, ly), k.color(safeColor(k, '#06060f')), k.opacity(0.6), k.z(1)])
|
|
k.add([k.rect(rackW, 1), k.pos(lx, ly), k.color(safeColor(k, '#1a1a3a')), k.opacity(0.4), k.z(1)])
|
|
k.add([k.rect(rackW, 1), k.pos(lx, ly + rackH), k.color(safeColor(k, '#1a1a3a')), k.opacity(0.4), k.z(1)])
|
|
k.add([k.rect(1, rackH), k.pos(lx, ly), k.color(safeColor(k, '#1a1a3a')), k.opacity(0.3), k.z(1)])
|
|
for (let s = 0; s < 5; s++) {
|
|
k.add([k.rect(rackW - 6, 1), k.pos(lx + 3, ly + 8 + s * 8), k.color(safeColor(k, '#111122')), k.opacity(0.5), k.z(1)])
|
|
}
|
|
for (let led = 0; led < 3; led++) {
|
|
const ledEl = k.add([
|
|
k.rect(2, 2), k.pos(lx + 4 + led * 6, ly + 4),
|
|
k.color(safeColor(k, Math.random() > 0.3 ? '#00ff41' : '#ff2d2d')),
|
|
k.opacity(0.7), k.z(2),
|
|
])
|
|
const blinkRate = 0.02 + Math.random() * 0.08
|
|
ledEl.onUpdate(() => { ledEl.opacity = Math.random() > blinkRate ? 0.7 : 0.15 })
|
|
}
|
|
if (Math.random() < 0.4) {
|
|
const actLed = k.add([
|
|
k.rect(2, 2), k.pos(lx + rackW - 8, ly + 4),
|
|
k.color(safeColor(k, '#ffaa00')), k.opacity(0.6), k.z(2),
|
|
])
|
|
actLed.onUpdate(() => { actLed.opacity = Math.random() > 0.5 ? 0.7 : 0.2 })
|
|
}
|
|
}
|
|
}
|
|
// Cable bundles
|
|
for (let c = 0; c < 6; c++) {
|
|
const cy = 3 + c * 2
|
|
k.add([k.rect(W, 2), k.pos(0, cy), k.color(safeColor(k, c % 3 === 0 ? '#111133' : c % 3 === 1 ? '#0a0a22' : '#0f0f2a')), k.opacity(0.5), k.z(1)])
|
|
}
|
|
// Scan line sweep
|
|
const scanLine = k.add([k.rect(W, 1), k.pos(0, 0), k.color(safeColor(k, '#00f0ff')), k.opacity(0.06), k.z(3)])
|
|
scanLine.onUpdate(() => { scanLine.pos.y = (scanLine.pos.y + 40 * k.dt()) % GROUND_Y })
|
|
|
|
} else if (a === 'gpu_graveyard') {
|
|
// Floating circuit board fragments
|
|
for (let i = 0; i < 16; i++) {
|
|
const cx = Math.random() * W
|
|
const cy = 20 + Math.random() * (GROUND_Y - 60)
|
|
const cw = 15 + Math.random() * 25
|
|
const ch = 10 + Math.random() * 18
|
|
const chip = k.add([
|
|
k.rect(cw, ch), k.pos(cx, cy),
|
|
k.color(safeColor(k, Math.random() > 0.5 ? '#1a2a1a' : '#0f1a0f')),
|
|
k.opacity(0.35), k.z(1), k.rotate(Math.random() * 45 - 22),
|
|
])
|
|
for (let t = 0; t < 3; t++) {
|
|
k.add([k.rect(cw * 0.6, 1), k.pos(cx + 2, cy + 3 + t * 4), k.color(safeColor(k, '#76b900')), k.opacity(0.2), k.z(1)])
|
|
}
|
|
k.add([k.circle(1.5), k.pos(cx + cw / 2, cy + ch / 2), k.color(safeColor(k, '#aabb44')), k.opacity(0.25), k.z(1)])
|
|
const baseY = cy
|
|
chip.onUpdate(() => { chip.pos.y = baseY + Math.sin(k.time() * 0.3 + i) * 5 })
|
|
}
|
|
// Dead GPU fans — some slowly spinning
|
|
for (const fx of [W * 0.15, W * 0.5, W * 0.85]) {
|
|
const fy = GROUND_Y - 30 - Math.random() * 40
|
|
k.add([k.circle(18), k.pos(fx, fy), k.anchor('center'), k.color(safeColor(k, '#0a0a0a')), k.opacity(0.4), k.z(1)])
|
|
k.add([k.circle(5), k.pos(fx, fy), k.anchor('center'), k.color(safeColor(k, '#1a1a1a')), k.opacity(0.3), k.z(1)])
|
|
for (let b = 0; b < 4; b++) {
|
|
const ba = b * Math.PI / 2
|
|
const blade = k.add([k.rect(14, 2), k.pos(fx, fy), k.anchor('center'), k.color(safeColor(k, '#222222')), k.opacity(0.3), k.z(1), k.rotate(ba * 180 / Math.PI)])
|
|
if (fx === W * 0.5) {
|
|
blade.onUpdate(() => { blade.angle += 8 * k.dt() })
|
|
}
|
|
}
|
|
}
|
|
// Sparking wires
|
|
for (let i = 0; i < 4; i++) {
|
|
const sx = W * (0.2 + i * 0.2)
|
|
const sy = 10 + Math.random() * 30
|
|
k.add([k.rect(1, 20 + Math.random() * 40), k.pos(sx, sy), k.color(safeColor(k, '#333333')), k.opacity(0.3), k.z(1)])
|
|
const spark = k.add([k.circle(3), k.pos(sx, sy + 20), k.anchor('center'), k.color(safeColor(k, '#ffff00')), k.opacity(0), k.z(3)])
|
|
spark.onUpdate(() => { spark.opacity = Math.random() > 0.97 ? 0.6 : 0 })
|
|
}
|
|
// Smoke wisps rising
|
|
for (let i = 0; i < 6; i++) {
|
|
const smoke = k.add([
|
|
k.circle(8 + Math.random() * 12), k.pos(Math.random() * W, GROUND_Y - 5),
|
|
k.color(safeColor(k, '#1a1a1a')), k.opacity(0.15), k.z(2),
|
|
])
|
|
const bx = smoke.pos.x
|
|
smoke.onUpdate(() => {
|
|
smoke.pos.y -= 6 * k.dt()
|
|
smoke.pos.x = bx + Math.sin(k.time() + i) * 8
|
|
smoke.opacity *= 0.998
|
|
if (smoke.pos.y < 0) { smoke.pos.y = GROUND_Y - 5; smoke.opacity = 0.15 }
|
|
})
|
|
}
|
|
|
|
} else if (a === 'prompt_dungeon') {
|
|
// Stone wall bricks
|
|
for (let row = 0; row < 5; row++) {
|
|
for (let col = 0; col < 12; col++) {
|
|
const brickW = W / 12 + (Math.random() - 0.5) * 10
|
|
const brickH = GROUND_Y / 5
|
|
const bx = col * (W / 12) + (row % 2 === 0 ? 0 : W / 24)
|
|
k.add([k.rect(brickW - 2, brickH - 2), k.pos(bx, row * brickH), k.color(safeColor(k, '#1a1520')), k.opacity(0.3), k.z(1)])
|
|
}
|
|
}
|
|
// Glowing runes with halos
|
|
for (let i = 0; i < 10; i++) {
|
|
const rx = 30 + Math.random() * (W - 60)
|
|
const ry = 20 + Math.random() * (GROUND_Y - 60)
|
|
const rune = k.add([
|
|
k.circle(6 + Math.random() * 8), k.pos(rx, ry),
|
|
k.color(safeColor(k, '#b83dff')), k.opacity(0.12), k.z(1),
|
|
])
|
|
k.add([k.circle(12 + Math.random() * 8), k.pos(rx, ry), k.color(safeColor(k, '#6622aa')), k.opacity(0.06), k.z(0)])
|
|
rune.onUpdate(() => { rune.opacity = 0.08 + Math.sin(k.time() * 0.8 + i * 0.7) * 0.08 })
|
|
}
|
|
// Torches with flickering flames and light cones
|
|
for (const tx of [W * 0.1, W * 0.35, W * 0.65, W * 0.9]) {
|
|
const ty = GROUND_Y * 0.3
|
|
k.add([k.rect(4, 20), k.pos(tx, ty), k.color(safeColor(k, '#553311')), k.opacity(0.5), k.z(1)])
|
|
const flame = k.add([k.circle(6), k.pos(tx + 2, ty - 3), k.anchor('center'), k.color(safeColor(k, '#ff6600')), k.opacity(0.5), k.z(2)])
|
|
const flameGlow = k.add([k.circle(15), k.pos(tx + 2, ty - 3), k.anchor('center'), k.color(safeColor(k, '#ff4400')), k.opacity(0.08), k.z(1)])
|
|
const lightCone = k.add([k.rect(30, GROUND_Y * 0.5), k.pos(tx - 13, ty + 20), k.color(safeColor(k, '#ff6600')), k.opacity(0.02), k.z(0)])
|
|
flame.onUpdate(() => {
|
|
flame.opacity = 0.4 + Math.sin(k.time() * 6 + tx) * 0.15
|
|
flame.pos.y = ty - 3 + Math.sin(k.time() * 8 + tx) * 1.5
|
|
flameGlow.opacity = 0.05 + Math.sin(k.time() * 6 + tx) * 0.04
|
|
lightCone.opacity = 0.015 + Math.sin(k.time() * 6 + tx) * 0.008
|
|
})
|
|
}
|
|
// Chains hanging from ceiling
|
|
for (let i = 0; i < 5; i++) {
|
|
const cx = W * (0.15 + i * 0.18)
|
|
const chainLen = 25 + Math.random() * 50
|
|
for (let s = 0; s < chainLen; s += 5) {
|
|
const link = k.add([k.rect(3, 4), k.pos(cx, s), k.color(safeColor(k, '#444444')), k.opacity(0.25), k.z(1)])
|
|
const baseCx = cx
|
|
link.onUpdate(() => { link.pos.x = baseCx + Math.sin(k.time() * 0.4 + i + s * 0.1) * 3 })
|
|
}
|
|
}
|
|
// Ground fog
|
|
for (let i = 0; i < 8; i++) {
|
|
const fog = k.add([
|
|
k.circle(35 + Math.random() * 30), k.pos(Math.random() * W, GROUND_Y - 8),
|
|
k.color(safeColor(k, '#1f1a2a')), k.opacity(0.25), k.z(3),
|
|
])
|
|
const baseX = fog.pos.x
|
|
fog.onUpdate(() => { fog.pos.x = baseX + Math.sin(k.time() * 0.2 + i) * 18 })
|
|
}
|
|
// Dripping water
|
|
for (let i = 0; i < 3; i++) {
|
|
const dx = W * (0.25 + i * 0.25)
|
|
const drop = k.add([k.circle(1.5), k.pos(dx, 0), k.color(safeColor(k, '#4466aa')), k.opacity(0.3), k.z(2)])
|
|
drop.onUpdate(() => {
|
|
drop.pos.y += 50 * k.dt()
|
|
if (drop.pos.y > GROUND_Y) { drop.pos.y = 0; drop.opacity = 0.3 }
|
|
drop.opacity *= 0.997
|
|
})
|
|
}
|
|
|
|
} else if (a === 'the_cloud') {
|
|
// Layered cloud formations
|
|
for (let layer = 0; layer < 3; layer++) {
|
|
for (let i = 0; i < 4; i++) {
|
|
const cx = Math.random() * W
|
|
const cy = 20 + layer * 50 + Math.random() * 30
|
|
const cloudOp = 0.25 - layer * 0.05
|
|
for (let j = 0; j < 4 + Math.floor(Math.random() * 3); j++) {
|
|
const cloud = k.add([
|
|
k.circle(15 + Math.random() * 20),
|
|
k.pos(cx + j * 14 - 20, cy + (Math.random() - 0.5) * 12),
|
|
k.color(safeColor(k, layer === 0 ? '#1a2030' : '#151a28')),
|
|
k.opacity(cloudOp), k.z(1),
|
|
])
|
|
const bx = cloud.pos.x
|
|
cloud.onUpdate(() => { cloud.pos.x = bx + Math.sin(k.time() * (0.08 + layer * 0.04) + i) * (8 + layer * 4) })
|
|
}
|
|
}
|
|
}
|
|
// Data rain streams
|
|
for (let i = 0; i < 15; i++) {
|
|
const stream = k.add([
|
|
k.rect(1, 8 + Math.random() * 15), k.pos(Math.random() * W, Math.random() * GROUND_Y),
|
|
k.color(safeColor(k, '#4488ff')), k.opacity(0.12), k.z(2),
|
|
])
|
|
stream.onUpdate(() => {
|
|
stream.pos.y += 30 * k.dt()
|
|
if (stream.pos.y > GROUND_Y) { stream.pos.y = -20; stream.pos.x = Math.random() * W }
|
|
})
|
|
}
|
|
// Lightning flashes
|
|
const lightning = k.add([k.rect(W, H), k.pos(0, 0), k.color(safeColor(k, '#ffffff')), k.opacity(0), k.z(3)])
|
|
lightning.onUpdate(() => { lightning.opacity = Math.random() > 0.998 ? 0.06 : 0 })
|
|
// Rainbow arc (subtle)
|
|
const rainbowColors = ['#ff0000', '#ff8800', '#ffff00', '#00ff00', '#0088ff', '#8800ff']
|
|
for (let i = 0; i < rainbowColors.length; i++) {
|
|
k.add([
|
|
k.circle(120 + i * 6), k.pos(W * 0.3, GROUND_Y + 60), k.anchor('center'),
|
|
k.color(safeColor(k, rainbowColors[i])), k.opacity(0.03), k.z(0),
|
|
])
|
|
}
|
|
|
|
} else if (a === 'the_singularity') {
|
|
// Central swirling vortex with multiple rings
|
|
for (let ring = 0; ring < 4; ring++) {
|
|
const ringDots = 12 + ring * 6
|
|
for (let i = 0; i < ringDots; i++) {
|
|
const angle = (i / ringDots) * Math.PI * 2
|
|
const baseDist = 20 + ring * 30
|
|
const dot = k.add([
|
|
k.circle(1.5 + ring * 0.5), k.pos(W / 2, GROUND_Y * 0.4),
|
|
k.color(safeColor(k, ring === 0 ? '#ffffff' : ring === 1 ? '#ff44ff' : ring === 2 ? '#ff00ff' : '#aa00aa')),
|
|
k.opacity(0.3 - ring * 0.05), k.z(1),
|
|
])
|
|
dot.onUpdate(() => {
|
|
const a2 = angle + k.time() * (0.8 - ring * 0.15)
|
|
const d2 = baseDist + Math.sin(k.time() * 0.8 + i) * 12
|
|
dot.pos.x = W / 2 + Math.cos(a2) * d2
|
|
dot.pos.y = GROUND_Y * 0.4 + Math.sin(a2) * d2 * 0.5
|
|
})
|
|
}
|
|
}
|
|
// Central core with pulsing glow
|
|
const core = k.add([k.circle(12), k.pos(W / 2, GROUND_Y * 0.4), k.anchor('center'), k.color(safeColor(k, '#ffffff')), k.opacity(0.15), k.z(1)])
|
|
k.add([k.circle(30), k.pos(W / 2, GROUND_Y * 0.4), k.anchor('center'), k.color(safeColor(k, '#ff00ff')), k.opacity(0.06), k.z(0)])
|
|
k.add([k.circle(60), k.pos(W / 2, GROUND_Y * 0.4), k.anchor('center'), k.color(safeColor(k, '#880088')), k.opacity(0.03), k.z(0)])
|
|
core.onUpdate(() => { core.opacity = 0.1 + Math.sin(k.time() * 2) * 0.08 })
|
|
// Energy tendrils reaching outward
|
|
for (let i = 0; i < 8; i++) {
|
|
const tendril = k.add([
|
|
k.rect(2, 40 + Math.random() * 60), k.pos(W / 2, GROUND_Y * 0.4), k.anchor('top'),
|
|
k.color(safeColor(k, '#ff00ff')), k.opacity(0.06), k.z(0), k.rotate(i * 45),
|
|
])
|
|
tendril.onUpdate(() => { tendril.angle = i * 45 + k.time() * 15 })
|
|
}
|
|
// Warped space grid lines
|
|
for (let i = 0; i < 6; i++) {
|
|
const gridLine = k.add([
|
|
k.rect(W, 1), k.pos(0, GROUND_Y * (0.15 + i * 0.12)),
|
|
k.color(safeColor(k, '#440066')), k.opacity(0.08), k.z(0),
|
|
])
|
|
gridLine.onUpdate(() => { gridLine.pos.x = Math.sin(k.time() * 0.3 + i) * 10 - 5 })
|
|
}
|
|
|
|
} else if (a === 'silicon_valley_dojo') {
|
|
// Bamboo stalks with segments and leaves
|
|
for (const side of [0.04, 0.08, 0.12, 0.86, 0.91, 0.96]) {
|
|
const px = W * side
|
|
const segments = 5 + Math.floor(Math.random() * 3)
|
|
const segH = (GROUND_Y - 15) / segments
|
|
for (let s = 0; s < segments; s++) {
|
|
k.add([k.rect(5, segH - 2), k.pos(px, 15 + s * segH), k.color(safeColor(k, '#1a3a1a')), k.opacity(0.45), k.z(1)])
|
|
k.add([k.rect(7, 2), k.pos(px - 1, 15 + s * segH), k.color(safeColor(k, '#2a4a2a')), k.opacity(0.4), k.z(1)])
|
|
}
|
|
for (let l = 0; l < 3; l++) {
|
|
const ly = 20 + l * (GROUND_Y / 4)
|
|
const dir = Math.random() > 0.5 ? 1 : -1
|
|
const leaf = k.add([k.rect(18, 3), k.pos(px + dir * 4, ly), k.color(safeColor(k, '#22aa33')), k.opacity(0.2), k.z(1), k.rotate(dir * 25)])
|
|
leaf.onUpdate(() => { leaf.angle = dir * 25 + Math.sin(k.time() * 1.5 + l) * 3 })
|
|
k.add([k.rect(14, 2), k.pos(px + dir * 8, ly + 4), k.color(safeColor(k, '#1a8822')), k.opacity(0.15), k.z(1), k.rotate(dir * 35)])
|
|
}
|
|
}
|
|
// Zen garden raked lines
|
|
for (let i = 0; i < 8; i++) {
|
|
const gy = GROUND_Y + 5 + i * 8
|
|
k.add([k.rect(W * 0.6, 1), k.pos(W * 0.2, gy), k.color(safeColor(k, '#00ff41')), k.opacity(0.06), k.z(0)])
|
|
}
|
|
// Stone lanterns with warm glow
|
|
for (const lx of [W * 0.2, W * 0.8]) {
|
|
k.add([k.rect(10, 6), k.pos(lx, GROUND_Y - 20), k.color(safeColor(k, '#444444')), k.opacity(0.35), k.z(1)])
|
|
k.add([k.rect(6, 14), k.pos(lx + 2, GROUND_Y - 34), k.color(safeColor(k, '#555555')), k.opacity(0.3), k.z(1)])
|
|
k.add([k.rect(12, 3), k.pos(lx - 1, GROUND_Y - 37), k.color(safeColor(k, '#555555')), k.opacity(0.3), k.z(1)])
|
|
const glow = k.add([k.circle(8), k.pos(lx + 5, GROUND_Y - 27), k.anchor('center'), k.color(safeColor(k, '#ffaa33')), k.opacity(0.15), k.z(2)])
|
|
glow.onUpdate(() => { glow.opacity = 0.1 + Math.sin(k.time() * 2 + lx) * 0.06 })
|
|
}
|
|
// Cherry blossom petals falling
|
|
for (let i = 0; i < 12; i++) {
|
|
const petal = k.add([
|
|
k.circle(1.5 + Math.random()), k.pos(Math.random() * W, Math.random() * GROUND_Y),
|
|
k.color(safeColor(k, Math.random() > 0.5 ? '#ffaacc' : '#ff88aa')), k.opacity(0.2), k.z(3),
|
|
])
|
|
const startX = petal.pos.x
|
|
petal.onUpdate(() => {
|
|
petal.pos.y += 8 * k.dt()
|
|
petal.pos.x = startX + Math.sin(k.time() * 1.2 + i) * 15
|
|
if (petal.pos.y > GROUND_Y) { petal.pos.y = -5 }
|
|
})
|
|
}
|
|
|
|
} else if (a === 'hacker_news' || a === 'stackoverflow_ruins') {
|
|
// Ruined building walls with cracks
|
|
for (let i = 0; i < 3; i++) {
|
|
const wallX = W * (0.15 + i * 0.3)
|
|
const wallH = GROUND_Y * (0.4 + Math.random() * 0.3)
|
|
k.add([k.rect(W * 0.2, wallH), k.pos(wallX, GROUND_Y - wallH), k.color(safeColor(k, '#1a1408')), k.opacity(0.3), k.z(0)])
|
|
for (let c = 0; c < 3; c++) {
|
|
k.add([k.rect(1, 10 + Math.random() * 15), k.pos(wallX + Math.random() * W * 0.18, GROUND_Y - wallH + Math.random() * wallH), k.color(safeColor(k, '#0a0800')), k.opacity(0.3), k.z(0), k.rotate(Math.random() * 30 - 15)])
|
|
}
|
|
}
|
|
// Code blocks floating
|
|
for (let i = 0; i < 14; i++) {
|
|
const bw = 25 + Math.random() * 60
|
|
const bh = 3 + Math.random() * 4
|
|
const bx = 15 + Math.random() * (W - 50)
|
|
const by = 15 + Math.random() * (GROUND_Y - 50)
|
|
k.add([k.rect(bw, bh), k.pos(bx, by), k.color(safeColor(k, acc)), k.opacity(0.06 + Math.random() * 0.06), k.z(1)])
|
|
if (Math.random() < 0.4) {
|
|
k.add([k.rect(2, bh), k.pos(bx - 4, by), k.color(safeColor(k, acc)), k.opacity(0.1), k.z(1)])
|
|
}
|
|
}
|
|
// Vote arrows
|
|
for (let i = 0; i < 5; i++) {
|
|
const ax = 20 + Math.random() * (W - 40)
|
|
const ay = 30 + Math.random() * (GROUND_Y - 70)
|
|
k.add([k.rect(4, 6), k.pos(ax, ay), k.color(safeColor(k, a === 'stackoverflow_ruins' ? '#f48024' : '#ff6600')), k.opacity(0.12), k.z(1)])
|
|
}
|
|
// Broken monitors with static
|
|
for (let i = 0; i < 3; i++) {
|
|
const mx = W * (0.2 + i * 0.3)
|
|
const my = GROUND_Y * 0.3 + Math.random() * 30
|
|
k.add([k.rect(22, 16), k.pos(mx, my), k.color(safeColor(k, '#0a0a0a')), k.opacity(0.5), k.z(1)])
|
|
k.add([k.rect(20, 14), k.pos(mx + 1, my + 1), k.color(safeColor(k, '#111111')), k.opacity(0.4), k.z(1)])
|
|
const staticEl = k.add([k.rect(18, 12), k.pos(mx + 2, my + 2), k.color(safeColor(k, '#888888')), k.opacity(0), k.z(2)])
|
|
staticEl.onUpdate(() => { staticEl.opacity = Math.random() > 0.92 ? 0.08 : 0 })
|
|
}
|
|
// Scrolling text fragments
|
|
for (let i = 0; i < 4; i++) {
|
|
const txt = k.add([
|
|
k.rect(30 + Math.random() * 40, 2), k.pos(Math.random() * W, 20 + i * (GROUND_Y / 5)),
|
|
k.color(safeColor(k, acc)), k.opacity(0.08), k.z(2),
|
|
])
|
|
txt.onUpdate(() => {
|
|
txt.pos.x -= 12 * k.dt()
|
|
if (txt.pos.x < -60) txt.pos.x = W + 20
|
|
})
|
|
}
|
|
|
|
} else if (a === 'beach') {
|
|
// Sun with rays and glow
|
|
const sunX = W * 0.8, sunY = 35
|
|
k.add([k.circle(45), k.pos(sunX, sunY), k.anchor('center'), k.color(safeColor(k, '#ffdd44')), k.opacity(0.06), k.z(0)])
|
|
k.add([k.circle(30), k.pos(sunX, sunY), k.anchor('center'), k.color(safeColor(k, '#ffdd44')), k.opacity(0.1), k.z(0)])
|
|
const sun = k.add([k.circle(18), k.pos(sunX, sunY), k.anchor('center'), k.color(safeColor(k, '#ffcc00')), k.opacity(0.5), k.z(1)])
|
|
sun.onUpdate(() => { sun.opacity = 0.4 + Math.sin(k.time() * 0.5) * 0.1 })
|
|
for (let r = 0; r < 8; r++) {
|
|
const angle = r * Math.PI / 4
|
|
const ray = k.add([k.rect(50, 2), k.pos(sunX, sunY), k.anchor('left'), k.color(safeColor(k, '#ffcc00')), k.opacity(0.08), k.z(0), k.rotate(angle * 180 / Math.PI)])
|
|
ray.onUpdate(() => { ray.opacity = 0.05 + Math.sin(k.time() * 0.8 + r) * 0.04 })
|
|
}
|
|
// Ocean with layered waves
|
|
k.add([k.rect(W, 25), k.pos(0, GROUND_Y - 35), k.color(safeColor(k, '#1a4488')), k.opacity(0.2), k.z(1)])
|
|
for (let layer = 0; layer < 4; layer++) {
|
|
for (let i = 0; i < 5; i++) {
|
|
const wave = k.add([
|
|
k.rect(W * 0.3, 3 + layer), k.pos(Math.random() * W, GROUND_Y - 22 - layer * 6 - i * 2),
|
|
k.color(safeColor(k, layer < 2 ? '#3377bb' : '#2266aa')), k.opacity(0.18 - layer * 0.03), k.z(2),
|
|
])
|
|
const baseX = wave.pos.x
|
|
wave.onUpdate(() => { wave.pos.x = baseX + Math.sin(k.time() * (0.6 + layer * 0.2) + i * 1.5) * (15 + layer * 5) })
|
|
}
|
|
}
|
|
// Surf foam at shore
|
|
for (let i = 0; i < 6; i++) {
|
|
const foam = k.add([
|
|
k.rect(15 + Math.random() * 25, 2), k.pos(Math.random() * W, GROUND_Y - 6 + Math.random() * 4),
|
|
k.color(safeColor(k, '#ffffff')), k.opacity(0.12), k.z(3),
|
|
])
|
|
const baseX = foam.pos.x
|
|
foam.onUpdate(() => { foam.pos.x = baseX + Math.sin(k.time() * 0.8 + i) * 8; foam.opacity = 0.06 + Math.sin(k.time() + i) * 0.06 })
|
|
}
|
|
// Palm trees with segmented trunks, coconuts, swaying fronds
|
|
for (const px of [W * 0.05, W * 0.14, W * 0.88, W * 0.95]) {
|
|
const lean = px < W / 2 ? 8 : -8
|
|
const height = 8 + Math.floor(Math.random() * 3)
|
|
for (let s = 0; s < height; s++) {
|
|
const sy = GROUND_Y - 10 - s * 12
|
|
const segW = 7 - s * 0.4
|
|
k.add([k.rect(segW, 13), k.pos(px + s * lean / height, sy), k.color(safeColor(k, s % 2 === 0 ? '#3a2510' : '#2f1f0d')), k.opacity(0.5), k.z(1)])
|
|
k.add([k.rect(segW + 1, 1), k.pos(px + s * lean / height - 0.5, sy + 6), k.color(safeColor(k, '#4a3520')), k.opacity(0.2), k.z(1)])
|
|
}
|
|
const topX = px + lean, topY = GROUND_Y - 10 - height * 12
|
|
for (let c = 0; c < 2 + Math.floor(Math.random() * 2); c++) {
|
|
k.add([k.circle(2.5), k.pos(topX + (c - 1) * 4, topY + 8), k.anchor('center'), k.color(safeColor(k, '#553311')), k.opacity(0.4), k.z(1)])
|
|
}
|
|
for (let f = 0; f < 7; f++) {
|
|
const angle = -70 + f * 22
|
|
const frond = k.add([k.rect(35 + Math.random() * 10, 3), k.pos(topX, topY), k.anchor('left'), k.color(safeColor(k, f % 2 === 0 ? '#1a6600' : '#228800')), k.opacity(0.35), k.z(1), k.rotate(angle)])
|
|
frond.onUpdate(() => { frond.angle = angle + Math.sin(k.time() * 0.8 + f) * 3 })
|
|
}
|
|
}
|
|
// Seagulls drifting
|
|
for (let i = 0; i < 4; i++) {
|
|
const bx = W * 0.2 + Math.random() * W * 0.5
|
|
const by = 12 + Math.random() * 25
|
|
const wing1 = k.add([k.rect(6, 1), k.pos(bx, by), k.color(safeColor(k, '#444444')), k.opacity(0.3), k.z(1), k.rotate(-15)])
|
|
const wing2 = k.add([k.rect(6, 1), k.pos(bx + 5, by), k.color(safeColor(k, '#444444')), k.opacity(0.3), k.z(1), k.rotate(15)])
|
|
const startBx = bx
|
|
wing1.onUpdate(() => { wing1.pos.x = startBx + Math.sin(k.time() * 0.2 + i) * 30; wing2.pos.x = wing1.pos.x + 5 })
|
|
}
|
|
// Beach umbrella
|
|
const umbX = W * 0.35
|
|
k.add([k.rect(2, 30), k.pos(umbX, GROUND_Y - 30), k.color(safeColor(k, '#aa8844')), k.opacity(0.4), k.z(1)])
|
|
k.add([k.circle(16), k.pos(umbX + 1, GROUND_Y - 30), k.anchor('center'), k.color(safeColor(k, '#ff4444')), k.opacity(0.2), k.z(1)])
|
|
k.add([k.circle(14), k.pos(umbX + 1, GROUND_Y - 31), k.anchor('center'), k.color(safeColor(k, '#ffffff')), k.opacity(0.08), k.z(1)])
|
|
|
|
} else if (a === 'desert') {
|
|
// Layered sand dunes
|
|
for (let d = 0; d < 5; d++) {
|
|
const dx = W * (0.1 + d * 0.2) + (Math.random() - 0.5) * 40
|
|
const dr = 50 + d * 15 + Math.random() * 20
|
|
k.add([k.circle(dr), k.pos(dx, GROUND_Y + dr * 0.6), k.anchor('center'), k.color(safeColor(k, '#aa8844')), k.opacity(0.15 + d * 0.03), k.z(1)])
|
|
}
|
|
// Road with dashed center line
|
|
k.add([k.rect(W * 0.25, GROUND_Y * 0.5), k.pos(W * 0.38, GROUND_Y * 0.3), k.color(safeColor(k, '#222222')), k.opacity(0.15), k.z(0)])
|
|
k.add([k.rect(2, GROUND_Y * 0.5), k.pos(W * 0.38, GROUND_Y * 0.3), k.color(safeColor(k, '#aaaa44')), k.opacity(0.08), k.z(0)])
|
|
k.add([k.rect(2, GROUND_Y * 0.5), k.pos(W * 0.63, GROUND_Y * 0.3), k.color(safeColor(k, '#aaaa44')), k.opacity(0.08), k.z(0)])
|
|
for (let d = 0; d < 8; d++) {
|
|
k.add([k.rect(2, 8), k.pos(W * 0.505, GROUND_Y * 0.32 + d * 16), k.color(safeColor(k, '#ffff44')), k.opacity(0.1), k.z(0)])
|
|
}
|
|
// Cacti with arms and flowers
|
|
for (const cx of [W * 0.08, W * 0.25, W * 0.75, W * 0.9]) {
|
|
const ch = 35 + Math.random() * 20
|
|
k.add([k.rect(7, ch), k.pos(cx, GROUND_Y - ch), k.color(safeColor(k, '#226622')), k.opacity(0.45), k.z(1)])
|
|
const armY = GROUND_Y - ch * 0.6
|
|
k.add([k.rect(12, 5), k.pos(cx - 12, armY), k.color(safeColor(k, '#226622')), k.opacity(0.4), k.z(1)])
|
|
k.add([k.rect(5, 15), k.pos(cx - 12, armY - 15), k.color(safeColor(k, '#226622')), k.opacity(0.4), k.z(1)])
|
|
if (Math.random() > 0.3) {
|
|
const armY2 = GROUND_Y - ch * 0.4
|
|
k.add([k.rect(10, 5), k.pos(cx + 7, armY2), k.color(safeColor(k, '#226622')), k.opacity(0.4), k.z(1)])
|
|
k.add([k.rect(5, 12), k.pos(cx + 12, armY2 - 12), k.color(safeColor(k, '#226622')), k.opacity(0.4), k.z(1)])
|
|
}
|
|
if (Math.random() > 0.5) {
|
|
k.add([k.circle(2.5), k.pos(cx + 3, GROUND_Y - ch - 2), k.anchor('center'), k.color(safeColor(k, '#ff4488')), k.opacity(0.3), k.z(2)])
|
|
}
|
|
}
|
|
// Tumbleweeds rolling
|
|
for (let i = 0; i < 3; i++) {
|
|
const tumble = k.add([k.circle(6 + Math.random() * 4), k.pos(-20 - i * 100, GROUND_Y - 8 - Math.random() * 5), k.color(safeColor(k, '#886644')), k.opacity(0.3), k.z(2)])
|
|
const speed = 15 + Math.random() * 15
|
|
tumble.onUpdate(() => { tumble.pos.x = ((tumble.pos.x + speed * k.dt()) % (W + 60)) - 30 })
|
|
}
|
|
// Heat shimmer
|
|
for (let i = 0; i < 4; i++) {
|
|
const shimmer = k.add([k.rect(W, 1), k.pos(0, GROUND_Y - 3 - i * 3), k.color(safeColor(k, '#ff8800')), k.opacity(0.06), k.z(2)])
|
|
shimmer.onUpdate(() => { shimmer.opacity = 0.03 + Math.sin(k.time() * 3 + i * 2) * 0.03 })
|
|
}
|
|
// Vulture silhouettes circling
|
|
for (let i = 0; i < 2; i++) {
|
|
const vx = W * 0.4 + i * W * 0.2
|
|
const vy = 25 + i * 15
|
|
const v1 = k.add([k.rect(8, 1), k.pos(vx, vy), k.color(safeColor(k, '#222222')), k.opacity(0.25), k.z(1), k.rotate(-10)])
|
|
const v2 = k.add([k.rect(8, 1), k.pos(vx + 7, vy), k.color(safeColor(k, '#222222')), k.opacity(0.25), k.z(1), k.rotate(10)])
|
|
const startVx = vx
|
|
v1.onUpdate(() => {
|
|
const cx = startVx + Math.cos(k.time() * 0.15 + i) * 40
|
|
const cy = vy + Math.sin(k.time() * 0.15 + i) * 15
|
|
v1.pos.x = cx; v1.pos.y = cy; v2.pos.x = cx + 7; v2.pos.y = cy
|
|
})
|
|
}
|
|
|
|
} else if (a === 'forest') {
|
|
// Layered trees (3 depth layers)
|
|
for (let layer = 0; layer < 3; layer++) {
|
|
const treeCount = layer === 0 ? 14 : layer === 1 ? 8 : 5
|
|
const treeOp = layer === 0 ? 0.15 : layer === 1 ? 0.3 : 0.4
|
|
for (let i = 0; i < treeCount; i++) {
|
|
const tx = 10 + (i / treeCount) * (W - 20) + (Math.random() - 0.5) * 15
|
|
const th = (25 + Math.random() * 35) * (layer === 0 ? 0.6 : layer === 1 ? 0.85 : 1)
|
|
const trunkW = layer === 0 ? 4 : layer === 1 ? 6 : 8
|
|
k.add([k.rect(trunkW, th), k.pos(tx, GROUND_Y - th), k.color(safeColor(k, layer === 0 ? '#0f1a08' : layer === 1 ? '#152010' : '#1a2a10')), k.opacity(treeOp), k.z(layer)])
|
|
for (let c = 0; c < 3 + layer; c++) {
|
|
const cr = (10 + Math.random() * 14) * (layer === 0 ? 0.6 : layer === 1 ? 0.8 : 1)
|
|
k.add([
|
|
k.circle(cr), k.pos(tx + trunkW / 2 + (Math.random() - 0.5) * 10, GROUND_Y - th - cr * 0.5 + c * 4),
|
|
k.anchor('center'), k.color(safeColor(k, layer === 0 ? '#0a1a08' : layer === 1 ? '#122a0e' : '#1a3a10')), k.opacity(treeOp * 0.8), k.z(layer),
|
|
])
|
|
}
|
|
}
|
|
}
|
|
// Undergrowth
|
|
for (let i = 0; i < 10; i++) {
|
|
k.add([k.circle(6 + Math.random() * 8), k.pos(Math.random() * W, GROUND_Y - 3), k.anchor('bot'), k.color(safeColor(k, '#1a3a10')), k.opacity(0.3), k.z(3)])
|
|
}
|
|
// Mushrooms
|
|
for (let i = 0; i < 5; i++) {
|
|
const mx = Math.random() * W
|
|
k.add([k.rect(2, 5), k.pos(mx, GROUND_Y - 5), k.color(safeColor(k, '#aa8866')), k.opacity(0.25), k.z(3)])
|
|
k.add([k.circle(4), k.pos(mx + 1, GROUND_Y - 6), k.anchor('center'), k.color(safeColor(k, Math.random() > 0.5 ? '#cc3333' : '#ffaa22')), k.opacity(0.2), k.z(3)])
|
|
}
|
|
// Fireflies
|
|
for (let i = 0; i < 15; i++) {
|
|
const ff = k.add([
|
|
k.circle(1.5), k.pos(Math.random() * W, 30 + Math.random() * (GROUND_Y - 50)),
|
|
k.color(safeColor(k, '#ccff44')), k.opacity(0), k.z(3),
|
|
])
|
|
const bx = ff.pos.x, by = ff.pos.y
|
|
ff.onUpdate(() => {
|
|
ff.opacity = Math.max(0, Math.sin(k.time() * 1.5 + i * 1.8) * 0.5)
|
|
ff.pos.x = bx + Math.sin(k.time() * 0.5 + i) * 15
|
|
ff.pos.y = by + Math.cos(k.time() * 0.4 + i) * 10
|
|
})
|
|
}
|
|
// Light rays through canopy
|
|
for (let i = 0; i < 5; i++) {
|
|
const rx = W * (0.15 + i * 0.18) + (Math.random() - 0.5) * 20
|
|
const ray = k.add([k.rect(8, GROUND_Y * 0.7), k.pos(rx, 0), k.color(safeColor(k, '#aaff44')), k.opacity(0.03), k.z(2), k.rotate(3 - Math.random() * 6)])
|
|
ray.onUpdate(() => { ray.opacity = 0.02 + Math.sin(k.time() * 0.3 + i) * 0.015 })
|
|
}
|
|
// Fallen log
|
|
k.add([k.rect(45, 6), k.pos(W * 0.55, GROUND_Y - 4), k.color(safeColor(k, '#2a1a08')), k.opacity(0.3), k.z(3), k.rotate(3)])
|
|
|
|
} else if (a === 'jungle') {
|
|
// Dense vine canopy
|
|
for (let i = 0; i < 12; i++) {
|
|
const vx = 15 + i * (W / 12) + (Math.random() - 0.5) * 12
|
|
const vineLen = 30 + Math.random() * 90
|
|
for (let s = 0; s < vineLen; s += 4) {
|
|
const vineEl = k.add([k.rect(2, 5), k.pos(vx + Math.sin(s * 0.15) * 4, s), k.color(safeColor(k, '#1a4a10')), k.opacity(0.3), k.z(1)])
|
|
if (Math.random() < 0.08) {
|
|
const basePx = vineEl.pos.x
|
|
vineEl.onUpdate(() => { vineEl.pos.x = basePx + Math.sin(k.time() * 0.5 + s) * 2 })
|
|
}
|
|
}
|
|
for (let l = 0; l < 2; l++) {
|
|
k.add([k.circle(5 + Math.random() * 4), k.pos(vx + (Math.random() - 0.5) * 8, vineLen + l * 6), k.color(safeColor(k, '#22aa22')), k.opacity(0.22), k.z(1)])
|
|
}
|
|
}
|
|
// Large tropical leaves at edges
|
|
for (const side of [0, W - 30]) {
|
|
for (let l = 0; l < 4; l++) {
|
|
const ly = 15 + l * (GROUND_Y / 5)
|
|
const leaf = k.add([k.rect(35, 8), k.pos(side, ly), k.color(safeColor(k, '#1a5510')), k.opacity(0.25), k.z(3), k.rotate(side === 0 ? 15 : -15)])
|
|
leaf.onUpdate(() => { leaf.angle = (side === 0 ? 15 : -15) + Math.sin(k.time() * 0.6 + l) * 2 })
|
|
}
|
|
}
|
|
// Exotic flowers
|
|
for (let i = 0; i < 6; i++) {
|
|
const fx = Math.random() * W
|
|
const fy = 20 + Math.random() * (GROUND_Y - 40)
|
|
k.add([k.circle(3), k.pos(fx, fy), k.anchor('center'), k.color(safeColor(k, ['#ff4488', '#ff8844', '#ffcc00', '#ff44ff', '#44ffcc', '#ff2222'][i])), k.opacity(0.2), k.z(2)])
|
|
}
|
|
// Ancient stone ruins peeking through
|
|
const ruinX = W * 0.5
|
|
k.add([k.rect(8, 40), k.pos(ruinX, GROUND_Y - 38), k.color(safeColor(k, '#444444')), k.opacity(0.15), k.z(0)])
|
|
k.add([k.rect(8, 35), k.pos(ruinX + 25, GROUND_Y - 33), k.color(safeColor(k, '#444444')), k.opacity(0.12), k.z(0)])
|
|
k.add([k.rect(35, 5), k.pos(ruinX - 2, GROUND_Y - 40), k.color(safeColor(k, '#444444')), k.opacity(0.1), k.z(0)])
|
|
// Thick ground fog
|
|
for (let i = 0; i < 10; i++) {
|
|
const mist = k.add([
|
|
k.circle(40 + Math.random() * 35), k.pos(Math.random() * W, GROUND_Y - 12),
|
|
k.color(safeColor(k, '#1a3818')), k.opacity(0.22), k.z(3),
|
|
])
|
|
const bx = mist.pos.x
|
|
mist.onUpdate(() => { mist.pos.x = bx + Math.sin(k.time() * 0.12 + i) * 18 })
|
|
}
|
|
// Butterfly particles
|
|
for (let i = 0; i < 4; i++) {
|
|
const bf = k.add([
|
|
k.circle(1.5), k.pos(Math.random() * W, 30 + Math.random() * (GROUND_Y - 60)),
|
|
k.color(safeColor(k, ['#4488ff', '#ff8844', '#ffcc00', '#ff44ff'][i])), k.opacity(0.25), k.z(3),
|
|
])
|
|
const bfx = bf.pos.x, bfy = bf.pos.y
|
|
bf.onUpdate(() => {
|
|
bf.pos.x = bfx + Math.sin(k.time() * 1.2 + i * 3) * 30
|
|
bf.pos.y = bfy + Math.cos(k.time() * 0.8 + i * 2) * 20
|
|
})
|
|
}
|
|
|
|
} else if (a === 'outer_space') {
|
|
// Dense star field
|
|
for (let i = 0; i < 100; i++) {
|
|
const star = k.add([
|
|
k.circle(0.5 + Math.random() * 1.5),
|
|
k.pos(Math.random() * W, Math.random() * H),
|
|
k.color(safeColor(k, i % 8 === 0 ? '#ffccaa' : i % 5 === 0 ? '#aaaaff' : '#ffffff')),
|
|
k.opacity(0.15 + Math.random() * 0.4), k.z(1),
|
|
])
|
|
star.onUpdate(() => { star.opacity = 0.12 + Math.sin(k.time() * (0.8 + Math.random()) + i) * 0.15 })
|
|
}
|
|
// Nebula clouds
|
|
const nebulaColors = ['#4400aa', '#aa0066', '#0044aa', '#006644', '#660044']
|
|
for (let i = 0; i < 5; i++) {
|
|
for (let blob = 0; blob < 4; blob++) {
|
|
k.add([
|
|
k.circle(30 + Math.random() * 50),
|
|
k.pos(W * (0.1 + i * 0.2) + blob * 18, H * 0.25 + Math.random() * 60 + blob * 12),
|
|
k.color(safeColor(k, nebulaColors[i % nebulaColors.length])),
|
|
k.opacity(0.04 + blob * 0.012), k.z(0),
|
|
])
|
|
}
|
|
}
|
|
// Floating asteroids
|
|
for (let i = 0; i < 6; i++) {
|
|
const ast = k.add([
|
|
k.circle(4 + Math.random() * 10),
|
|
k.pos(Math.random() * W, 15 + Math.random() * (GROUND_Y - 30)),
|
|
k.color(safeColor(k, Math.random() > 0.5 ? '#555555' : '#3a3a3a')), k.opacity(0.35), k.z(1),
|
|
])
|
|
k.add([k.circle(2), k.pos(ast.pos.x + 2, ast.pos.y - 1), k.color(safeColor(k, '#2a2a2a')), k.opacity(0.2), k.z(1)])
|
|
const baseX = ast.pos.x, baseY = ast.pos.y
|
|
ast.onUpdate(() => {
|
|
ast.pos.x = baseX + Math.sin(k.time() * 0.15 + i * 2) * 18
|
|
ast.pos.y = baseY + Math.cos(k.time() * 0.12 + i) * 12
|
|
})
|
|
}
|
|
// Distant planet with rings
|
|
const planetX = W * 0.75, planetY = GROUND_Y * 0.25
|
|
k.add([k.circle(22), k.pos(planetX, planetY), k.anchor('center'), k.color(safeColor(k, '#334466')), k.opacity(0.25), k.z(0)])
|
|
k.add([k.circle(24), k.pos(planetX, planetY), k.anchor('center'), k.color(safeColor(k, '#223344')), k.opacity(0.1), k.z(0)])
|
|
for (let r = 0; r < 3; r++) {
|
|
k.add([k.rect(50 + r * 8, 2), k.pos(planetX - 25 - r * 4, planetY - 1 + r), k.color(safeColor(k, '#556688')), k.opacity(0.1 - r * 0.02), k.z(0), k.rotate(15)])
|
|
}
|
|
// Shooting stars
|
|
for (let i = 0; i < 2; i++) {
|
|
const shootStar = k.add([
|
|
k.rect(12, 1), k.pos(-20, Math.random() * GROUND_Y * 0.5),
|
|
k.color(safeColor(k, '#ffffff')), k.opacity(0), k.z(2), k.rotate(30),
|
|
])
|
|
let timer = Math.random() * 10
|
|
shootStar.onUpdate(() => {
|
|
timer -= k.dt()
|
|
if (timer <= 0) {
|
|
shootStar.pos.x = -20
|
|
shootStar.pos.y = Math.random() * GROUND_Y * 0.4
|
|
shootStar.opacity = 0.5
|
|
timer = 5 + Math.random() * 10
|
|
}
|
|
if (shootStar.opacity > 0) {
|
|
shootStar.pos.x += 200 * k.dt()
|
|
shootStar.pos.y += 80 * k.dt()
|
|
shootStar.opacity -= 0.8 * k.dt()
|
|
}
|
|
})
|
|
}
|
|
|
|
} else if (a === 'colosseum') {
|
|
// Roman arches along the back
|
|
for (let i = 0; i < 8; i++) {
|
|
const ax = 20 + i * (W / 8)
|
|
const aw = W / 8 - 8
|
|
k.add([k.rect(6, GROUND_Y * 0.6), k.pos(ax, GROUND_Y * 0.2), k.color(safeColor(k, '#3a2a18')), k.opacity(0.4), k.z(1)])
|
|
k.add([k.rect(6, GROUND_Y * 0.6), k.pos(ax + aw - 6, GROUND_Y * 0.2), k.color(safeColor(k, '#3a2a18')), k.opacity(0.4), k.z(1)])
|
|
k.add([k.rect(aw, 6), k.pos(ax, GROUND_Y * 0.2), k.color(safeColor(k, '#4a3a20')), k.opacity(0.4), k.z(1)])
|
|
k.add([k.rect(aw - 12, GROUND_Y * 0.5), k.pos(ax + 6, GROUND_Y * 0.25), k.color(safeColor(k, '#0a0800')), k.opacity(0.3), k.z(0)])
|
|
k.add([k.rect(10, 3), k.pos(ax - 2, GROUND_Y * 0.2), k.color(safeColor(k, '#5a4a30')), k.opacity(0.35), k.z(1)])
|
|
k.add([k.rect(10, 3), k.pos(ax + aw - 10, GROUND_Y * 0.2), k.color(safeColor(k, '#5a4a30')), k.opacity(0.35), k.z(1)])
|
|
}
|
|
// Torch brackets on pillars
|
|
for (let i = 0; i < 4; i++) {
|
|
const tx = W * (0.15 + i * 0.25)
|
|
const ty = GROUND_Y * 0.35
|
|
k.add([k.rect(3, 12), k.pos(tx, ty), k.color(safeColor(k, '#554422')), k.opacity(0.4), k.z(2)])
|
|
const flame = k.add([k.circle(5), k.pos(tx + 1, ty - 3), k.anchor('center'), k.color(safeColor(k, '#ff6600')), k.opacity(0.4), k.z(2)])
|
|
flame.onUpdate(() => { flame.opacity = 0.3 + Math.sin(k.time() * 5 + i * 2) * 0.15 })
|
|
}
|
|
// Crowd silhouettes in upper tiers
|
|
for (let row = 0; row < 2; row++) {
|
|
for (let i = 0; i < 20; i++) {
|
|
k.add([
|
|
k.circle(2 + Math.random()), k.pos(15 + i * (W / 20), GROUND_Y * 0.08 + row * 12),
|
|
k.color(safeColor(k, '#2a1a10')), k.opacity(0.2), k.z(0),
|
|
])
|
|
}
|
|
}
|
|
// Crumbled stone debris
|
|
for (let i = 0; i < 8; i++) {
|
|
k.add([
|
|
k.rect(5 + Math.random() * 10, 3 + Math.random() * 6),
|
|
k.pos(Math.random() * W, GROUND_Y - 5 - Math.random() * 10),
|
|
k.color(safeColor(k, '#5a4a30')), k.opacity(0.25), k.z(2), k.rotate(Math.random() * 40 - 20),
|
|
])
|
|
}
|
|
// Sand dust particles
|
|
for (let i = 0; i < 6; i++) {
|
|
const dust = k.add([
|
|
k.circle(2 + Math.random() * 3), k.pos(Math.random() * W, GROUND_Y - 15 - Math.random() * 20),
|
|
k.color(safeColor(k, '#c0a060')), k.opacity(0.1), k.z(3),
|
|
])
|
|
const dx = dust.pos.x
|
|
dust.onUpdate(() => { dust.pos.x = dx + Math.sin(k.time() * 0.5 + i) * 12; dust.opacity = 0.05 + Math.sin(k.time() + i) * 0.05 })
|
|
}
|
|
|
|
} else if (a === 'haunted_mansion') {
|
|
// Gothic windows with moonlight
|
|
for (let i = 0; i < 5; i++) {
|
|
const wx = W * (0.1 + i * 0.2)
|
|
const wy = GROUND_Y * 0.2
|
|
k.add([k.rect(20, 35), k.pos(wx, wy), k.color(safeColor(k, '#0a0510')), k.opacity(0.4), k.z(1)])
|
|
k.add([k.rect(22, 1), k.pos(wx - 1, wy), k.color(safeColor(k, '#2a1830')), k.opacity(0.4), k.z(1)])
|
|
k.add([k.rect(22, 1), k.pos(wx - 1, wy + 35), k.color(safeColor(k, '#2a1830')), k.opacity(0.4), k.z(1)])
|
|
k.add([k.rect(1, 35), k.pos(wx + 10, wy), k.color(safeColor(k, '#2a1830')), k.opacity(0.3), k.z(1)])
|
|
k.add([k.rect(20, 1), k.pos(wx, wy + 17), k.color(safeColor(k, '#2a1830')), k.opacity(0.3), k.z(1)])
|
|
const glow = k.add([k.rect(16, 30), k.pos(wx + 2, wy + 3), k.color(safeColor(k, '#8844cc')), k.opacity(0.06), k.z(1)])
|
|
glow.onUpdate(() => { glow.opacity = 0.04 + Math.sin(k.time() * 0.5 + i) * 0.03 })
|
|
}
|
|
// Moon behind a window
|
|
k.add([k.circle(12), k.pos(W * 0.5 + 10, GROUND_Y * 0.26), k.anchor('center'), k.color(safeColor(k, '#ccccdd')), k.opacity(0.15), k.z(0)])
|
|
// Cobwebs
|
|
for (const cx of [15, W - 35]) {
|
|
for (let strand = 0; strand < 5; strand++) {
|
|
k.add([k.rect(20 + strand * 5, 1), k.pos(cx, 3 + strand * 4), k.color(safeColor(k, '#666666')), k.opacity(0.1), k.z(1), k.rotate(cx < W / 2 ? 28 + strand * 5 : -28 - strand * 5)])
|
|
}
|
|
}
|
|
// Candelabras
|
|
for (const cx of [W * 0.25, W * 0.75]) {
|
|
k.add([k.rect(2, 20), k.pos(cx, GROUND_Y - 20), k.color(safeColor(k, '#666644')), k.opacity(0.3), k.z(1)])
|
|
k.add([k.rect(12, 2), k.pos(cx - 5, GROUND_Y - 20), k.color(safeColor(k, '#666644')), k.opacity(0.3), k.z(1)])
|
|
for (let c = 0; c < 3; c++) {
|
|
const candleX = cx - 5 + c * 5
|
|
const cFlame = k.add([k.circle(2.5), k.pos(candleX + 1, GROUND_Y - 23), k.anchor('center'), k.color(safeColor(k, '#ffaa44')), k.opacity(0.4), k.z(2)])
|
|
cFlame.onUpdate(() => { cFlame.opacity = 0.3 + Math.sin(k.time() * 4 + c + cx) * 0.15 })
|
|
}
|
|
}
|
|
// Floating ghost particles
|
|
for (let i = 0; i < 8; i++) {
|
|
const ghost = k.add([
|
|
k.circle(3 + Math.random() * 3), k.pos(Math.random() * W, Math.random() * GROUND_Y),
|
|
k.color(safeColor(k, '#aabbcc')), k.opacity(0), k.z(2),
|
|
])
|
|
const gx = ghost.pos.x, gy = ghost.pos.y
|
|
ghost.onUpdate(() => {
|
|
ghost.opacity = Math.max(0, Math.sin(k.time() * 0.6 + i * 2) * 0.15)
|
|
ghost.pos.x = gx + Math.sin(k.time() * 0.3 + i) * 20
|
|
ghost.pos.y = gy + Math.cos(k.time() * 0.25 + i) * 15
|
|
})
|
|
}
|
|
// Bats flying
|
|
for (let i = 0; i < 3; i++) {
|
|
const bat = k.add([k.rect(5, 2), k.pos(Math.random() * W, 15 + Math.random() * 40), k.color(safeColor(k, '#111111')), k.opacity(0.3), k.z(2)])
|
|
const bx = bat.pos.x, by = bat.pos.y
|
|
bat.onUpdate(() => {
|
|
bat.pos.x = bx + Math.sin(k.time() * 1.5 + i * 3) * 40
|
|
bat.pos.y = by + Math.cos(k.time() * 2 + i * 2) * 10
|
|
})
|
|
}
|
|
|
|
} else if (a === 'concert_hall') {
|
|
// Stage lights with sweeping cones
|
|
const lightColors = ['#ff2288', '#22ff88', '#4488ff', '#ffaa22', '#ff44ff', '#44ffff']
|
|
for (let i = 0; i < 6; i++) {
|
|
const lx = W * (0.1 + i * 0.15)
|
|
const cone = k.add([
|
|
k.rect(30, GROUND_Y * 0.7), k.pos(lx, 10), k.anchor('top'),
|
|
k.color(safeColor(k, lightColors[i])), k.opacity(0.04), k.z(2), k.rotate(0),
|
|
])
|
|
k.add([k.circle(4), k.pos(lx + 15, 8), k.anchor('center'), k.color(safeColor(k, lightColors[i])), k.opacity(0.4), k.z(2)])
|
|
const baseAngle = (i - 3) * 5
|
|
cone.onUpdate(() => {
|
|
cone.opacity = 0.02 + Math.sin(k.time() * 1.5 + i * 1.2) * 0.025
|
|
cone.angle = baseAngle + Math.sin(k.time() * 0.4 + i) * 8
|
|
})
|
|
}
|
|
// Speaker stacks
|
|
for (const sx of [10, W - 30]) {
|
|
for (let s = 0; s < 4; s++) {
|
|
k.add([k.rect(20, 18), k.pos(sx, GROUND_Y - 20 - s * 20), k.color(safeColor(k, '#111111')), k.opacity(0.5), k.z(1)])
|
|
k.add([k.circle(6), k.pos(sx + 10, GROUND_Y - 11 - s * 20), k.anchor('center'), k.color(safeColor(k, '#222222')), k.opacity(0.4), k.z(1)])
|
|
const speakerCone = k.add([k.circle(4), k.pos(sx + 10, GROUND_Y - 11 - s * 20), k.anchor('center'), k.color(safeColor(k, '#1a1a1a')), k.opacity(0.3), k.z(1), k.scale(1)])
|
|
speakerCone.onUpdate(() => { speakerCone.scale = k.vec2(1 + Math.sin(k.time() * 8 + s) * 0.05) })
|
|
}
|
|
}
|
|
// Crowd silhouettes
|
|
for (let i = 0; i < 30; i++) {
|
|
const cx = 5 + i * (W / 30)
|
|
const ch = 6 + Math.random() * 4
|
|
k.add([k.circle(2.5), k.pos(cx, GROUND_Y + 8), k.anchor('center'), k.color(safeColor(k, '#111111')), k.opacity(0.3), k.z(3)])
|
|
k.add([k.rect(4, ch), k.pos(cx - 2, GROUND_Y + 10), k.color(safeColor(k, '#111111')), k.opacity(0.25), k.z(3)])
|
|
}
|
|
// Smoke machine haze
|
|
for (let i = 0; i < 6; i++) {
|
|
const haze = k.add([
|
|
k.circle(30 + Math.random() * 25), k.pos(Math.random() * W, GROUND_Y - 8),
|
|
k.color(safeColor(k, '#20102a')), k.opacity(0.18), k.z(3),
|
|
])
|
|
const hx = haze.pos.x
|
|
haze.onUpdate(() => { haze.pos.x = hx + Math.sin(k.time() * 0.15 + i) * 15 })
|
|
}
|
|
// Laser beam sweep
|
|
const laser = k.add([k.rect(1, GROUND_Y), k.pos(W / 2, 0), k.color(safeColor(k, '#00ff00')), k.opacity(0.06), k.z(2)])
|
|
laser.onUpdate(() => { laser.pos.x = W / 2 + Math.sin(k.time() * 0.8) * (W * 0.4) })
|
|
|
|
} else if (a === 'sports_arena') {
|
|
// Stadium seating tiers with crowd
|
|
for (let tier = 0; tier < 5; tier++) {
|
|
const ty = GROUND_Y * 0.1 + tier * (GROUND_Y * 0.13)
|
|
k.add([k.rect(W, GROUND_Y * 0.1), k.pos(0, ty), k.color(safeColor(k, tier % 2 === 0 ? '#1a2a4a' : '#152040')), k.opacity(0.3), k.z(1)])
|
|
for (let i = 0; i < 18; i++) {
|
|
k.add([
|
|
k.circle(1.5 + Math.random()), k.pos(15 + i * (W / 18), ty + GROUND_Y * 0.04),
|
|
k.color(safeColor(k, ['#cc3333', '#3333cc', '#33cc33', '#cccc33', '#ffffff'][Math.floor(Math.random() * 5)])),
|
|
k.opacity(0.12), k.z(1),
|
|
])
|
|
}
|
|
}
|
|
// Floodlights
|
|
for (const fx of [W * 0.05, W * 0.95]) {
|
|
k.add([k.rect(3, GROUND_Y * 0.7), k.pos(fx, GROUND_Y * 0.1), k.color(safeColor(k, '#333333')), k.opacity(0.3), k.z(2)])
|
|
const light = k.add([k.circle(5), k.pos(fx + 1, GROUND_Y * 0.08), k.anchor('center'), k.color(safeColor(k, '#ffffff')), k.opacity(0.5), k.z(2)])
|
|
k.add([k.rect(40, GROUND_Y * 0.6), k.pos(fx - 18, GROUND_Y * 0.12), k.color(safeColor(k, '#ffffff')), k.opacity(0.015), k.z(0)])
|
|
light.onUpdate(() => { light.opacity = 0.4 + Math.sin(k.time() * 0.5 + fx) * 0.1 })
|
|
}
|
|
// Scoreboard
|
|
k.add([k.rect(50, 18), k.pos(W / 2 - 25, 8), k.color(safeColor(k, '#0a0a20')), k.opacity(0.5), k.z(2)])
|
|
k.add([k.rect(48, 16), k.pos(W / 2 - 24, 9), k.color(safeColor(k, '#111133')), k.opacity(0.4), k.z(2)])
|
|
const scoreGlow = k.add([k.rect(20, 8), k.pos(W / 2 - 10, 13), k.color(safeColor(k, '#ff3333')), k.opacity(0.12), k.z(2)])
|
|
scoreGlow.onUpdate(() => { scoreGlow.opacity = 0.08 + Math.sin(k.time() * 2) * 0.05 })
|
|
// Camera flashes
|
|
for (let i = 0; i < 5; i++) {
|
|
const flash = k.add([
|
|
k.circle(2), k.pos(Math.random() * W, GROUND_Y * (0.15 + Math.random() * 0.5)),
|
|
k.color(safeColor(k, '#ffffff')), k.opacity(0), k.z(3),
|
|
])
|
|
flash.onUpdate(() => { flash.opacity = Math.random() > 0.995 ? 0.4 : 0 })
|
|
}
|
|
|
|
} else if (a === 'kitchen_stadium') {
|
|
// Tiled wall
|
|
for (let row = 0; row < 6; row++) {
|
|
for (let col = 0; col < 14; col++) {
|
|
k.add([
|
|
k.rect(W / 14 - 1, GROUND_Y / 6 - 1), k.pos(col * (W / 14), row * (GROUND_Y / 6)),
|
|
k.color(safeColor(k, (row + col) % 2 === 0 ? '#1a1210' : '#1e1614')), k.opacity(0.2), k.z(0),
|
|
])
|
|
}
|
|
}
|
|
// Stove with burners
|
|
k.add([k.rect(45, 35), k.pos(W * 0.06, GROUND_Y - 35), k.color(safeColor(k, '#1a1010')), k.opacity(0.45), k.z(1)])
|
|
k.add([k.rect(43, 2), k.pos(W * 0.06 + 1, GROUND_Y - 35), k.color(safeColor(k, '#333333')), k.opacity(0.3), k.z(1)])
|
|
for (let b = 0; b < 4; b++) {
|
|
const flame = k.add([k.circle(4), k.pos(W * 0.06 + 6 + b * 10, GROUND_Y - 37), k.anchor('center'), k.color(safeColor(k, '#ff4400')), k.opacity(0.4), k.z(2)])
|
|
const innerFlame = k.add([k.circle(2), k.pos(W * 0.06 + 6 + b * 10, GROUND_Y - 38), k.anchor('center'), k.color(safeColor(k, '#ffcc00')), k.opacity(0.3), k.z(2)])
|
|
flame.onUpdate(() => { flame.opacity = 0.3 + Math.sin(k.time() * 5 + b) * 0.15; innerFlame.opacity = 0.2 + Math.sin(k.time() * 7 + b) * 0.1 })
|
|
}
|
|
// Hanging pots and pans
|
|
k.add([k.rect(W * 0.5, 2), k.pos(W * 0.2, 8), k.color(safeColor(k, '#444444')), k.opacity(0.3), k.z(1)])
|
|
for (let i = 0; i < 6; i++) {
|
|
const px = W * (0.22 + i * 0.08)
|
|
const hookLen = 12 + Math.random() * 10
|
|
k.add([k.rect(1, hookLen), k.pos(px, 10), k.color(safeColor(k, '#444444')), k.opacity(0.25), k.z(1)])
|
|
k.add([k.circle(7 + Math.random() * 4), k.pos(px, 10 + hookLen + 5), k.anchor('center'), k.color(safeColor(k, i % 2 === 0 ? '#555555' : '#664422')), k.opacity(0.25), k.z(1)])
|
|
}
|
|
// Knife rack
|
|
k.add([k.rect(3, 25), k.pos(W * 0.85, GROUND_Y * 0.3), k.color(safeColor(k, '#553322')), k.opacity(0.35), k.z(1)])
|
|
for (let i = 0; i < 4; i++) {
|
|
k.add([k.rect(2, 10 + Math.random() * 5), k.pos(W * 0.85 + 1, GROUND_Y * 0.32 + i * 5), k.color(safeColor(k, '#aaaaaa')), k.opacity(0.2), k.z(1)])
|
|
}
|
|
// Steam rising
|
|
for (let i = 0; i < 4; i++) {
|
|
const steam = k.add([
|
|
k.circle(5 + Math.random() * 5), k.pos(W * 0.06 + 10 + i * 10, GROUND_Y - 40),
|
|
k.color(safeColor(k, '#ffffff')), k.opacity(0.06), k.z(3),
|
|
])
|
|
const bx = steam.pos.x
|
|
steam.onUpdate(() => {
|
|
steam.pos.y -= 10 * k.dt()
|
|
steam.pos.x = bx + Math.sin(k.time() * 2 + i) * 4
|
|
steam.opacity *= 0.995
|
|
if (steam.pos.y < GROUND_Y - 80) { steam.pos.y = GROUND_Y - 40; steam.opacity = 0.06 }
|
|
})
|
|
}
|
|
|
|
} else if (a === 'junkyard') {
|
|
// Rusted crane silhouette
|
|
k.add([k.rect(6, GROUND_Y * 0.7), k.pos(W * 0.85, GROUND_Y * 0.1), k.color(safeColor(k, '#443322')), k.opacity(0.3), k.z(0)])
|
|
k.add([k.rect(W * 0.3, 4), k.pos(W * 0.6, GROUND_Y * 0.1), k.color(safeColor(k, '#443322')), k.opacity(0.25), k.z(0)])
|
|
const cable = k.add([k.rect(1, 35), k.pos(W * 0.65, GROUND_Y * 0.12), k.color(safeColor(k, '#555555')), k.opacity(0.2), k.z(0)])
|
|
cable.onUpdate(() => { cable.pos.x = W * 0.65 + Math.sin(k.time() * 0.3) * 5 })
|
|
// Piles of scrap
|
|
for (let pile = 0; pile < 8; pile++) {
|
|
const px = Math.random() * W
|
|
const py = GROUND_Y - 8
|
|
for (let j = 0; j < 7; j++) {
|
|
k.add([
|
|
k.rect(8 + Math.random() * 18, 4 + Math.random() * 10),
|
|
k.pos(px + (Math.random() - 0.5) * 25, py - j * 6 - Math.random() * 5),
|
|
k.color(safeColor(k, ['#554433', '#665544', '#443322', '#776655', '#332211', '#887766', '#553322'][j % 7])),
|
|
k.opacity(0.3), k.z(1), k.rotate(Math.random() * 40 - 20),
|
|
])
|
|
}
|
|
}
|
|
// Old car silhouette
|
|
k.add([k.rect(35, 15), k.pos(W * 0.15, GROUND_Y - 15), k.color(safeColor(k, '#2a2a1a')), k.opacity(0.3), k.z(1)])
|
|
k.add([k.rect(25, 10), k.pos(W * 0.15 + 5, GROUND_Y - 25), k.color(safeColor(k, '#2a2a1a')), k.opacity(0.25), k.z(1)])
|
|
k.add([k.circle(5), k.pos(W * 0.15 + 6, GROUND_Y - 3), k.anchor('center'), k.color(safeColor(k, '#1a1a0a')), k.opacity(0.3), k.z(1)])
|
|
k.add([k.circle(5), k.pos(W * 0.15 + 29, GROUND_Y - 3), k.anchor('center'), k.color(safeColor(k, '#1a1a0a')), k.opacity(0.3), k.z(1)])
|
|
// Sparking wires
|
|
for (let i = 0; i < 3; i++) {
|
|
const spark = k.add([
|
|
k.circle(2), k.pos(W * (0.3 + i * 0.2), GROUND_Y - 20 - Math.random() * 30),
|
|
k.color(safeColor(k, '#ffaa00')), k.opacity(0), k.z(3),
|
|
])
|
|
spark.onUpdate(() => { spark.opacity = Math.random() > 0.96 ? 0.5 : 0 })
|
|
}
|
|
// Smoke/steam wisps
|
|
for (let i = 0; i < 4; i++) {
|
|
const smoke = k.add([
|
|
k.circle(10 + Math.random() * 10), k.pos(Math.random() * W, GROUND_Y - 5),
|
|
k.color(safeColor(k, '#333322')), k.opacity(0.12), k.z(2),
|
|
])
|
|
const sx = smoke.pos.x
|
|
smoke.onUpdate(() => {
|
|
smoke.pos.y -= 5 * k.dt()
|
|
smoke.pos.x = sx + Math.sin(k.time() * 0.5 + i) * 6
|
|
if (smoke.pos.y < GROUND_Y - 60) { smoke.pos.y = GROUND_Y - 5; smoke.opacity = 0.12 }
|
|
})
|
|
}
|
|
|
|
} else if (a === 'meme_dimension') {
|
|
// Floating emoji shapes (pulsing)
|
|
for (let i = 0; i < 12; i++) {
|
|
const emoji = k.add([
|
|
k.circle(6 + Math.random() * 6), k.pos(Math.random() * W, Math.random() * GROUND_Y),
|
|
k.color(safeColor(k, ['#ffcc00', '#ff4444', '#44ff44', '#4444ff', '#ff44ff', '#44ffff'][i % 6])), k.opacity(0.12), k.z(1), k.scale(1),
|
|
])
|
|
const bx = emoji.pos.x, by = emoji.pos.y
|
|
emoji.onUpdate(() => {
|
|
emoji.pos.x = bx + Math.sin(k.time() * 0.4 + i) * 15
|
|
emoji.pos.y = by + Math.cos(k.time() * 0.3 + i) * 10
|
|
emoji.scale = k.vec2(1 + Math.sin(k.time() * 1.5 + i) * 0.15)
|
|
})
|
|
}
|
|
// Glitch bands
|
|
for (let i = 0; i < 8; i++) {
|
|
const band = k.add([
|
|
k.rect(W, 2 + Math.random() * 4), k.pos(0, Math.random() * GROUND_Y),
|
|
k.color(safeColor(k, Math.random() > 0.5 ? '#ff44ff' : '#44ffff')), k.opacity(0), k.z(2),
|
|
])
|
|
band.onUpdate(() => {
|
|
band.opacity = Math.random() > 0.97 ? 0.12 + Math.random() * 0.08 : 0
|
|
if (band.opacity > 0) band.pos.x = (Math.random() - 0.5) * 10
|
|
else band.pos.x = 0
|
|
})
|
|
}
|
|
// Rainbow pixel streaks
|
|
const rainbowC = ['#ff0000', '#ff8800', '#ffff00', '#00ff00', '#0088ff', '#8800ff']
|
|
for (let i = 0; i < rainbowC.length; i++) {
|
|
const streak = k.add([
|
|
k.rect(W, 3), k.pos(0, GROUND_Y * 0.3 + i * 5),
|
|
k.color(safeColor(k, rainbowC[i])), k.opacity(0.04), k.z(0),
|
|
])
|
|
streak.onUpdate(() => { streak.opacity = 0.02 + Math.sin(k.time() * 2 + i) * 0.02 })
|
|
}
|
|
// Spinning geometric shapes
|
|
for (let i = 0; i < 4; i++) {
|
|
const geo = k.add([
|
|
k.rect(8 + Math.random() * 8, 8 + Math.random() * 8),
|
|
k.pos(W * (0.2 + i * 0.2), GROUND_Y * (0.3 + Math.random() * 0.3)),
|
|
k.anchor('center'), k.color(safeColor(k, '#ff44ff')), k.opacity(0.08), k.z(1), k.rotate(0),
|
|
])
|
|
geo.onUpdate(() => { geo.angle += (30 + i * 15) * k.dt() })
|
|
}
|
|
// VHS tracking lines
|
|
const vhs = k.add([k.rect(W, 6), k.pos(0, 0), k.color(safeColor(k, '#000000')), k.opacity(0), k.z(3)])
|
|
vhs.onUpdate(() => {
|
|
vhs.pos.y = (vhs.pos.y + 80 * k.dt()) % (GROUND_Y + 20)
|
|
vhs.opacity = Math.random() > 0.9 ? 0.15 : 0
|
|
})
|
|
// RGB noise flickers
|
|
for (let i = 0; i < 6; i++) {
|
|
const noise = k.add([
|
|
k.rect(3 + Math.random() * 8, 3 + Math.random() * 8),
|
|
k.pos(Math.random() * W, Math.random() * GROUND_Y),
|
|
k.color(safeColor(k, ['#ff0000', '#00ff00', '#0000ff'][i % 3])), k.opacity(0), k.z(2),
|
|
])
|
|
noise.onUpdate(() => {
|
|
noise.opacity = Math.random() > 0.98 ? 0.1 : 0
|
|
if (noise.opacity > 0) { noise.pos.x = Math.random() * W; noise.pos.y = Math.random() * GROUND_Y }
|
|
})
|
|
}
|
|
|
|
} else if (a === 'space_station') {
|
|
// Structural beams with rivets
|
|
for (let i = 0; i < 6; i++) {
|
|
const bx = W * (0.15 + i * 0.14)
|
|
k.add([k.rect(5, GROUND_Y), k.pos(bx, 0), k.color(safeColor(k, '#1a1a30')), k.opacity(0.3), k.z(1)])
|
|
for (let r = 0; r < 8; r++) {
|
|
k.add([k.circle(1), k.pos(bx + 2, r * (GROUND_Y / 8) + 5), k.anchor('center'), k.color(safeColor(k, '#2a2a40')), k.opacity(0.25), k.z(1)])
|
|
}
|
|
k.add([k.rect(W * 0.14, 3), k.pos(bx, GROUND_Y * 0.25), k.color(safeColor(k, '#1a1a30')), k.opacity(0.25), k.z(1)])
|
|
k.add([k.rect(W * 0.14, 3), k.pos(bx, GROUND_Y * 0.6), k.color(safeColor(k, '#1a1a30')), k.opacity(0.2), k.z(1)])
|
|
}
|
|
// Viewport
|
|
const vpX = W * 0.5, vpY = GROUND_Y * 0.3
|
|
k.add([k.circle(40), k.pos(vpX, vpY), k.anchor('center'), k.color(safeColor(k, '#000020')), k.opacity(0.5), k.z(0)])
|
|
k.add([k.circle(42), k.pos(vpX, vpY), k.anchor('center'), k.color(safeColor(k, '#2a2a50')), k.opacity(0.3), k.z(0)])
|
|
for (let s = 0; s < 15; s++) {
|
|
const dist = Math.random() * 35
|
|
const angle = Math.random() * Math.PI * 2
|
|
const sx = vpX + Math.cos(angle) * dist
|
|
const sy = vpY + Math.sin(angle) * dist
|
|
const vpStar = k.add([k.circle(0.8 + Math.random()), k.pos(sx, sy), k.color(safeColor(k, '#ffffff')), k.opacity(0.3), k.z(0)])
|
|
vpStar.onUpdate(() => { vpStar.opacity = 0.15 + Math.sin(k.time() * 2 + s) * 0.15 })
|
|
}
|
|
// Earth through viewport
|
|
k.add([k.circle(15), k.pos(vpX + 10, vpY + 5), k.anchor('center'), k.color(safeColor(k, '#2244aa')), k.opacity(0.15), k.z(0)])
|
|
k.add([k.circle(6), k.pos(vpX + 7, vpY + 2), k.anchor('center'), k.color(safeColor(k, '#22aa44')), k.opacity(0.08), k.z(0)])
|
|
// Control panels
|
|
for (const px of [W * 0.08, W * 0.88]) {
|
|
k.add([k.rect(25, 40), k.pos(px, GROUND_Y * 0.4), k.color(safeColor(k, '#0a0a20')), k.opacity(0.4), k.z(1)])
|
|
for (let led = 0; led < 8; led++) {
|
|
const ledEl = k.add([
|
|
k.rect(2, 2), k.pos(px + 4 + (led % 4) * 5, GROUND_Y * 0.42 + Math.floor(led / 4) * 6),
|
|
k.color(safeColor(k, ['#00ff88', '#ff4444', '#ffaa00', '#4488ff'][led % 4])), k.opacity(0.4), k.z(2),
|
|
])
|
|
ledEl.onUpdate(() => { ledEl.opacity = Math.random() > 0.05 ? 0.4 : 0.1 })
|
|
}
|
|
}
|
|
// Warning stripes
|
|
for (let i = 0; i < 8; i++) {
|
|
k.add([k.rect(8, 3), k.pos(W * 0.3 + i * 12, GROUND_Y - 3), k.color(safeColor(k, i % 2 === 0 ? '#ffaa00' : '#000000')), k.opacity(0.12), k.z(3)])
|
|
}
|
|
|
|
} else if (a === 'savanna') {
|
|
// Distant mountain range
|
|
for (let i = 0; i < 5; i++) {
|
|
const mx = W * (0.1 + i * 0.2) + (Math.random() - 0.5) * 30
|
|
const mh = 30 + Math.random() * 40
|
|
k.add([k.circle(mh), k.pos(mx, GROUND_Y - mh * 0.3), k.anchor('center'), k.color(safeColor(k, '#2a2010')), k.opacity(0.12), k.z(0)])
|
|
}
|
|
// Acacia trees with branches
|
|
for (const tx of [W * 0.1, W * 0.4, W * 0.72]) {
|
|
const trunkH = 40 + Math.random() * 20
|
|
k.add([k.rect(5, trunkH), k.pos(tx, GROUND_Y - trunkH), k.color(safeColor(k, '#2a1a08')), k.opacity(0.4), k.z(1)])
|
|
k.add([k.rect(15, 3), k.pos(tx - 10, GROUND_Y - trunkH * 0.7), k.color(safeColor(k, '#2a1a08')), k.opacity(0.3), k.z(1), k.rotate(-20)])
|
|
k.add([k.rect(12, 3), k.pos(tx + 5, GROUND_Y - trunkH * 0.6), k.color(safeColor(k, '#2a1a08')), k.opacity(0.3), k.z(1), k.rotate(15)])
|
|
k.add([k.rect(50, 5), k.pos(tx - 22, GROUND_Y - trunkH - 2), k.color(safeColor(k, '#2a3a10')), k.opacity(0.3), k.z(1)])
|
|
k.add([k.rect(40, 4), k.pos(tx - 17, GROUND_Y - trunkH - 7), k.color(safeColor(k, '#2a3a10')), k.opacity(0.25), k.z(1)])
|
|
k.add([k.rect(25, 3), k.pos(tx - 10, GROUND_Y - trunkH - 11), k.color(safeColor(k, '#223308')), k.opacity(0.2), k.z(1)])
|
|
}
|
|
// Setting sun
|
|
const sunX = W * 0.85, sunY = GROUND_Y * 0.22
|
|
k.add([k.circle(50), k.pos(sunX, sunY), k.anchor('center'), k.color(safeColor(k, '#dd6622')), k.opacity(0.06), k.z(0)])
|
|
k.add([k.circle(35), k.pos(sunX, sunY), k.anchor('center'), k.color(safeColor(k, '#dd6622')), k.opacity(0.12), k.z(0)])
|
|
const savSun = k.add([k.circle(22), k.pos(sunX, sunY), k.anchor('center'), k.color(safeColor(k, '#ffaa22')), k.opacity(0.3), k.z(0)])
|
|
savSun.onUpdate(() => { savSun.opacity = 0.25 + Math.sin(k.time() * 0.3) * 0.05 })
|
|
// Tall grass swaying
|
|
for (let i = 0; i < 20; i++) {
|
|
const gx = Math.random() * W
|
|
const grassH = 5 + Math.random() * 10
|
|
const grass = k.add([k.rect(1, grassH), k.pos(gx, GROUND_Y - grassH), k.color(safeColor(k, '#8a7830')), k.opacity(0.2), k.z(3), k.rotate(0)])
|
|
grass.onUpdate(() => { grass.angle = Math.sin(k.time() * 1.2 + i) * 5 })
|
|
}
|
|
// Elephant silhouette
|
|
const ex = W * 0.6, ey = GROUND_Y - 18
|
|
k.add([k.rect(18, 12), k.pos(ex, ey), k.color(safeColor(k, '#1a1508')), k.opacity(0.15), k.z(0)])
|
|
k.add([k.rect(8, 8), k.pos(ex + 15, ey - 4), k.color(safeColor(k, '#1a1508')), k.opacity(0.15), k.z(0)])
|
|
k.add([k.rect(3, 8), k.pos(ex + 2, ey + 12), k.color(safeColor(k, '#1a1508')), k.opacity(0.15), k.z(0)])
|
|
k.add([k.rect(3, 8), k.pos(ex + 13, ey + 12), k.color(safeColor(k, '#1a1508')), k.opacity(0.15), k.z(0)])
|
|
// Birds in V formation
|
|
for (let i = 0; i < 5; i++) {
|
|
const birdX = W * 0.3 + i * 8
|
|
const birdY = 20 + Math.abs(i - 2) * 5
|
|
k.add([k.rect(4, 1), k.pos(birdX, birdY), k.color(safeColor(k, '#222222')), k.opacity(0.2), k.z(1), k.rotate(-12)])
|
|
k.add([k.rect(4, 1), k.pos(birdX + 3, birdY), k.color(safeColor(k, '#222222')), k.opacity(0.2), k.z(1), k.rotate(12)])
|
|
}
|
|
|
|
} else if (a === 'server_room') {
|
|
// Server rack rows with LEDs
|
|
for (let row = 0; row < 3; row++) {
|
|
for (let col = 0; col < 6; col++) {
|
|
const rx = 30 + col * (W / 6)
|
|
const ry = 20 + row * 55
|
|
const rw = W / 6 - 12
|
|
const rh = 46
|
|
k.add([k.rect(rw, rh), k.pos(rx, ry), k.color(safeColor(k, '#0a1a10')), k.opacity(0.4), k.z(1)])
|
|
k.add([k.rect(rw, 1), k.pos(rx, ry), k.color(safeColor(k, '#1a2a18')), k.opacity(0.3), k.z(1)])
|
|
k.add([k.rect(rw, 1), k.pos(rx, ry + rh), k.color(safeColor(k, '#1a2a18')), k.opacity(0.3), k.z(1)])
|
|
for (let s = 0; s < 5; s++) {
|
|
k.add([k.rect(rw - 4, 1), k.pos(rx + 2, ry + 10 + s * 7), k.color(safeColor(k, '#0a1008')), k.opacity(0.3), k.z(1)])
|
|
}
|
|
for (let led = 0; led < 4; led++) {
|
|
const ledEl = k.add([
|
|
k.rect(2, 2), k.pos(rx + 3 + led * 5, ry + 3),
|
|
k.color(safeColor(k, '#00ff88')), k.opacity(0.5), k.z(2),
|
|
])
|
|
ledEl.onUpdate(() => { ledEl.opacity = Math.random() > 0.04 ? 0.5 : 0.1 })
|
|
}
|
|
if (Math.random() < 0.5) {
|
|
const act = k.add([k.rect(2, 2), k.pos(rx + rw - 6, ry + 3), k.color(safeColor(k, '#ffaa00')), k.opacity(0.5), k.z(2)])
|
|
act.onUpdate(() => { act.opacity = Math.random() > 0.3 ? 0.5 : 0.15 })
|
|
}
|
|
}
|
|
}
|
|
// Overhead cable trays
|
|
for (let i = 0; i < 3; i++) {
|
|
k.add([k.rect(W * 0.25, 3), k.pos(W * (0.1 + i * 0.3), 5), k.color(safeColor(k, '#1a2a18')), k.opacity(0.3), k.z(1)])
|
|
for (let c = 0; c < 4; c++) {
|
|
k.add([k.rect(W * 0.25, 1), k.pos(W * (0.1 + i * 0.3), 7 + c * 2), k.color(safeColor(k, ['#004400', '#000044', '#440000', '#444400'][c])), k.opacity(0.15), k.z(1)])
|
|
}
|
|
}
|
|
// Cool air flow particles
|
|
for (let i = 0; i < 5; i++) {
|
|
const airflow = k.add([
|
|
k.circle(2), k.pos(Math.random() * W, GROUND_Y - 10),
|
|
k.color(safeColor(k, '#00ff88')), k.opacity(0.08), k.z(3),
|
|
])
|
|
airflow.onUpdate(() => {
|
|
airflow.pos.y -= 15 * k.dt()
|
|
if (airflow.pos.y < 10) { airflow.pos.y = GROUND_Y - 10; airflow.pos.x = Math.random() * W }
|
|
})
|
|
}
|
|
// Emergency lighting
|
|
const emLight = k.add([k.circle(4), k.pos(W * 0.5, 5), k.anchor('center'), k.color(safeColor(k, '#ff0000')), k.opacity(0.2), k.z(2)])
|
|
emLight.onUpdate(() => { emLight.opacity = 0.1 + Math.sin(k.time() * 1.5) * 0.1 })
|
|
|
|
} else if (a === 'paper_mill') {
|
|
// Industrial ceiling pipes
|
|
for (let i = 0; i < 5; i++) {
|
|
const py = 5 + i * 4
|
|
k.add([k.rect(W, 3), k.pos(0, py), k.color(safeColor(k, i % 2 === 0 ? '#2a2a20' : '#222218')), k.opacity(0.35), k.z(1)])
|
|
for (let j = 0; j < 4; j++) {
|
|
k.add([k.circle(3), k.pos(W * (0.2 + j * 0.2), py + 1), k.anchor('center'), k.color(safeColor(k, '#333328')), k.opacity(0.3), k.z(1)])
|
|
}
|
|
}
|
|
// Conveyor belt
|
|
k.add([k.rect(W * 0.6, 6), k.pos(W * 0.2, GROUND_Y - 15), k.color(safeColor(k, '#333328')), k.opacity(0.35), k.z(1)])
|
|
for (let i = 0; i < 8; i++) {
|
|
k.add([k.circle(3), k.pos(W * 0.22 + i * (W * 0.075), GROUND_Y - 12), k.anchor('center'), k.color(safeColor(k, '#444438')), k.opacity(0.3), k.z(1)])
|
|
}
|
|
// Moving items on belt
|
|
for (let i = 0; i < 3; i++) {
|
|
const item = k.add([
|
|
k.rect(10, 6), k.pos(W * 0.25 + i * 60, GROUND_Y - 21),
|
|
k.color(safeColor(k, '#f0e68c')), k.opacity(0.2), k.z(2),
|
|
])
|
|
item.onUpdate(() => {
|
|
item.pos.x += 15 * k.dt()
|
|
if (item.pos.x > W * 0.78) item.pos.x = W * 0.2
|
|
})
|
|
}
|
|
// Paper rolls stacked
|
|
for (let i = 0; i < 3; i++) {
|
|
for (let j = 0; j <= i; j++) {
|
|
const rx = W * 0.08 + j * 14 - i * 7
|
|
const ry = GROUND_Y - 12 - (2 - i) * 12
|
|
k.add([k.circle(6), k.pos(rx, ry), k.anchor('center'), k.color(safeColor(k, '#ddd8b0')), k.opacity(0.2), k.z(1)])
|
|
k.add([k.circle(2), k.pos(rx, ry), k.anchor('center'), k.color(safeColor(k, '#aaa880')), k.opacity(0.15), k.z(1)])
|
|
}
|
|
}
|
|
// Industrial gears (rotating)
|
|
for (const gx of [W * 0.88, W * 0.92]) {
|
|
const gy = GROUND_Y * 0.35
|
|
k.add([k.circle(10), k.pos(gx, gy), k.anchor('center'), k.color(safeColor(k, '#444438')), k.opacity(0.25), k.z(1)])
|
|
k.add([k.circle(4), k.pos(gx, gy), k.anchor('center'), k.color(safeColor(k, '#333328')), k.opacity(0.3), k.z(1)])
|
|
for (let t = 0; t < 8; t++) {
|
|
const tooth = k.add([
|
|
k.rect(4, 3), k.pos(gx, gy), k.anchor('center'),
|
|
k.color(safeColor(k, '#444438')), k.opacity(0.25), k.z(1),
|
|
k.rotate(t * 45),
|
|
])
|
|
tooth.onUpdate(() => { tooth.angle = t * 45 + k.time() * (gx === W * 0.88 ? 20 : -25) })
|
|
}
|
|
}
|
|
// Steam from pipes
|
|
for (let i = 0; i < 4; i++) {
|
|
const steam = k.add([
|
|
k.circle(6 + Math.random() * 8), k.pos(W * (0.2 + i * 0.2), 25),
|
|
k.color(safeColor(k, '#ccccbb')), k.opacity(0.06), k.z(2),
|
|
])
|
|
const bsx = steam.pos.x
|
|
steam.onUpdate(() => {
|
|
steam.pos.y += 4 * k.dt()
|
|
steam.pos.x = bsx + Math.sin(k.time() + i) * 5
|
|
steam.opacity *= 0.998
|
|
if (steam.pos.y > GROUND_Y * 0.4) { steam.pos.y = 25; steam.opacity = 0.06 }
|
|
})
|
|
}
|
|
// Sawdust particles
|
|
for (let i = 0; i < 8; i++) {
|
|
const dust = k.add([
|
|
k.circle(1), k.pos(Math.random() * W, Math.random() * GROUND_Y),
|
|
k.color(safeColor(k, '#f0e68c')), k.opacity(0.12), k.z(3),
|
|
])
|
|
const dx = dust.pos.x, dy = dust.pos.y
|
|
dust.onUpdate(() => {
|
|
dust.pos.x = dx + Math.sin(k.time() * 0.8 + i) * 10
|
|
dust.pos.y = dy + Math.cos(k.time() * 0.5 + i) * 8
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
k.scene('fight', () => {
|
|
// === SKY / BACKGROUND ATMOSPHERE ===
|
|
// Vertical gradient backdrop — 6 bands from dark ceiling to ground horizon
|
|
const bgBase = theme.bg
|
|
for (let band = 0; band < 6; band++) {
|
|
const bandH = GROUND_Y / 6
|
|
const brighten = band * 3
|
|
k.add([
|
|
k.rect(W, bandH + 1), k.pos(0, band * bandH),
|
|
k.color(safeColor(k,bgBase)),
|
|
k.opacity(1 - band * 0.04),
|
|
])
|
|
}
|
|
// Subtle horizon glow — wide soft band just above ground
|
|
k.add([
|
|
k.rect(W, 20), k.pos(0, GROUND_Y - 20),
|
|
k.color(safeColor(k,theme.accent)), k.opacity(0.06),
|
|
])
|
|
|
|
// === GROUND ===
|
|
// Main ground fill
|
|
k.add([k.rect(W, H - GROUND_Y + 2), k.pos(0, GROUND_Y), k.color(safeColor(k,theme.ground))])
|
|
// Bright edge line at the surface
|
|
k.add([k.rect(W, 2), k.pos(0, GROUND_Y), k.color(safeColor(k,theme.accent)), k.opacity(0.7)])
|
|
// Secondary highlight
|
|
k.add([k.rect(W, 1), k.pos(0, GROUND_Y + 2), k.color(safeColor(k,theme.accent)), k.opacity(0.3)])
|
|
// Ground gradient — fades deeper
|
|
for (let i = 1; i <= 12; i++) {
|
|
k.add([k.rect(W, 2), k.pos(0, GROUND_Y + 3 + i * 6), k.color(safeColor(k,theme.accent)), k.opacity(0.1 - i * 0.007)])
|
|
}
|
|
// Perspective grid on the floor — converging lines for 3D depth
|
|
const vanishX = W / 2
|
|
const vanishY = GROUND_Y * 0.6
|
|
for (let i = 0; i <= 24; i++) {
|
|
const x = i * (W / 24)
|
|
// Lines from floor edge pointing toward vanishing point
|
|
const dx = x - vanishX
|
|
const topX = vanishX + dx * 0.3
|
|
k.add([
|
|
k.rect(1, GROUND_Y * 0.4 + 10), k.pos(x, GROUND_Y),
|
|
k.color(safeColor(k,theme.accent)), k.opacity(0.05),
|
|
])
|
|
}
|
|
// Horizontal depth lines on ground
|
|
for (let i = 0; i < 6; i++) {
|
|
const gy = GROUND_Y + 8 + i * i * 3
|
|
if (gy < H) {
|
|
k.add([k.rect(W, 1), k.pos(0, gy), k.color(safeColor(k,theme.accent)), k.opacity(0.08 - i * 0.012)])
|
|
}
|
|
}
|
|
|
|
// === SIDE PILLARS / FRAME ===
|
|
// Subtle dark pillars on edges for framing
|
|
k.add([k.rect(8, GROUND_Y), k.pos(0, 0), k.color(safeColor(k,'#000000')), k.opacity(0.3)])
|
|
k.add([k.rect(8, GROUND_Y), k.pos(W - 8, 0), k.color(safeColor(k,'#000000')), k.opacity(0.3)])
|
|
// Accent trim on pillars
|
|
k.add([k.rect(1, GROUND_Y), k.pos(8, 0), k.color(safeColor(k,theme.accent)), k.opacity(0.15)])
|
|
k.add([k.rect(1, GROUND_Y), k.pos(W - 9, 0), k.color(safeColor(k,theme.accent)), k.opacity(0.15)])
|
|
|
|
// === AMBIENT PARTICLES ===
|
|
// Floating dust/embers in the air (subtle, always present)
|
|
for (let i = 0; i < 18; i++) {
|
|
const particle = k.add([
|
|
k.circle(0.5 + Math.random() * 1.5),
|
|
k.pos(Math.random() * W, Math.random() * GROUND_Y),
|
|
k.color(safeColor(k,theme.accent)),
|
|
k.opacity(0.08 + Math.random() * 0.12),
|
|
k.z(2),
|
|
])
|
|
const baseX = particle.pos.x
|
|
const baseY = particle.pos.y
|
|
const driftSpeed = 0.1 + Math.random() * 0.3
|
|
const driftAmt = 8 + Math.random() * 15
|
|
particle.onUpdate(() => {
|
|
particle.pos.x = baseX + Math.sin(k.time() * driftSpeed + i * 1.3) * driftAmt
|
|
particle.pos.y = baseY + Math.cos(k.time() * driftSpeed * 0.7 + i) * (driftAmt * 0.5)
|
|
particle.opacity = 0.06 + Math.sin(k.time() * 0.8 + i * 0.9) * 0.06
|
|
})
|
|
}
|
|
|
|
// Arena-specific decorations
|
|
drawArenaDecor()
|
|
|
|
// Umpire chair (center-back, behind fighters)
|
|
const CHAIR_X = W / 2
|
|
const CHAIR_SEAT_Y = GROUND_Y * (0.38 + (1 - SF) * 0.2)
|
|
const cs = SF // chair scale
|
|
k.add([k.rect(4 * cs, GROUND_Y - CHAIR_SEAT_Y + 15 * cs), k.pos(CHAIR_X - 22 * cs, CHAIR_SEAT_Y - 8 * cs), k.color(safeColor(k,'#554433')), k.opacity(0.7), k.z(3)])
|
|
k.add([k.rect(4 * cs, GROUND_Y - CHAIR_SEAT_Y + 15 * cs), k.pos(CHAIR_X + 18 * cs, CHAIR_SEAT_Y - 8 * cs), k.color(safeColor(k,'#554433')), k.opacity(0.7), k.z(3)])
|
|
for (let i = 0; i < 6; i++) {
|
|
const rungY = CHAIR_SEAT_Y + 15 * cs + i * ((GROUND_Y - CHAIR_SEAT_Y - 15 * cs) / 6)
|
|
k.add([k.rect(44 * cs, 3), k.pos(CHAIR_X - 22 * cs, rungY), k.color(safeColor(k,'#443322')), k.opacity(0.6), k.z(3)])
|
|
}
|
|
k.add([k.rect(54 * cs, 5), k.pos(CHAIR_X - 27 * cs, CHAIR_SEAT_Y - 2), k.color(safeColor(k,'#665544')), k.opacity(0.8), k.z(3)])
|
|
k.add([k.rect(54 * cs, 1), k.pos(CHAIR_X - 27 * cs, CHAIR_SEAT_Y - 2), k.color(safeColor(k,theme.accent)), k.opacity(0.3), k.z(3)])
|
|
k.add([k.rect(48 * cs, 4), k.pos(CHAIR_X - 24 * cs, CHAIR_SEAT_Y - 10 * cs), k.color(safeColor(k,'#665544')), k.opacity(0.8), k.z(3)])
|
|
k.add([k.rect(3, 12 * cs), k.pos(CHAIR_X - 27 * cs, CHAIR_SEAT_Y - 10 * cs), k.color(safeColor(k,'#554433')), k.opacity(0.7), k.z(3)])
|
|
k.add([k.rect(3, 12 * cs), k.pos(CHAIR_X + 24 * cs, CHAIR_SEAT_Y - 10 * cs), k.color(safeColor(k,'#554433')), k.opacity(0.7), k.z(3)])
|
|
k.add([
|
|
k.sprite('judge', { anim: 'idle' }),
|
|
k.pos(CHAIR_X, CHAIR_SEAT_Y),
|
|
k.anchor('bot'),
|
|
k.scale(1.3 * SF),
|
|
k.z(4),
|
|
k.opacity(0.9),
|
|
'judge',
|
|
])
|
|
|
|
const scaleA = (1.8 + botA.tier * 0.4) * SF
|
|
k.add([k.sprite('botA', { anim: 'idle' }), k.pos(-100, GROUND_Y - 6), k.anchor('bot'), k.scale(scaleA), k.z(10), k.opacity(0), 'fighterA'])
|
|
|
|
const scaleB = (1.8 + botB.tier * 0.4) * SF
|
|
k.add([k.sprite('botB', { anim: 'idle' }), k.pos(W + 100, GROUND_Y - 6), k.anchor('bot'), k.scale(-scaleB, scaleB), k.z(10), k.opacity(0), 'fighterB'])
|
|
|
|
config.onReady?.()
|
|
})
|
|
|
|
k.go('fight')
|
|
|
|
let comboA = 0
|
|
let comboB = 0
|
|
|
|
// === CHOREOGRAPHY FUNCTIONS ===
|
|
// Each returns a Promise and handles all movement + animation
|
|
|
|
async function dashPunch(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
const contactX = origDX - dir * 50
|
|
// Fast sprint to contact
|
|
await k.tween(atk.pos.x, contactX, 0.12, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
atk.play('attack')
|
|
sfxPunch()
|
|
await k.wait(0.12)
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 12 : 5)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, isCritical ? 12 : 5, '#ffcc00')
|
|
if (isCritical) { screenFlash('#ffffff'); sfxCritical(); await impactFreeze() }
|
|
spawnAfterimages(atk, 2)
|
|
// Push defender
|
|
const push = dir * (isCritical ? 100 : 35)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.35)
|
|
// Return
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
async function aerialSlam(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
const origAY = atk.pos.y
|
|
const contactX = origDX - dir * 20
|
|
// Jump way up
|
|
await k.tween(atk.pos.y, origAY - 220, 0.18, (v) => { atk.pos.y = v }, k.easings.easeOutQuad)
|
|
atk.play('kick')
|
|
sfxKick()
|
|
// Arc down onto opponent
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, contactX, 0.22, (v) => { atk.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(atk.pos.y, origAY, 0.22, (v) => { atk.pos.y = v }, k.easings.easeInQuad),
|
|
])
|
|
// SLAM
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 20 : 10)
|
|
spawnSparks(def.pos.x, def.pos.y - 20, 15, theme.accent)
|
|
spawnShockwave(def.pos.x, GROUND_Y, theme.accent)
|
|
if (isCritical) { screenFlash('#ff2d7b'); sfxExplosion(); await impactFreeze(0.1) } else { sfxPunch() }
|
|
spawnAfterimages(atk, 3)
|
|
const push = dir * (isCritical ? 120 : 50)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.4)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.25, (v) => { atk.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(atk.pos.y, origAY, 0.15, (v) => { atk.pos.y = v }, k.easings.easeOutBounce),
|
|
k.tween(def.pos.x, origDX, 0.35, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
async function flyingKick(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
const origAY = atk.pos.y
|
|
const contactX = origDX - dir * 30
|
|
// Small jump + fly horizontally
|
|
atk.play('kick')
|
|
sfxKick()
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, contactX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(atk.pos.y, origAY - 80, 0.1, (v) => { atk.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(atk.pos.y, origAY, 0.1, (v) => { atk.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 14 : 6)
|
|
spawnSparks(def.pos.x, def.pos.y - 40, 8, '#ff6600')
|
|
if (isCritical) { sfxCritical(); screenFlash('#ff6600'); await impactFreeze() } else { sfxPunch() }
|
|
spawnAfterimages(atk, 3)
|
|
const push = dir * (isCritical ? 90 : 40)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
// Bounce back
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.25, (v) => { atk.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
async function dashThrough(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
const behindX = origDX + dir * 80
|
|
atk.play('attack')
|
|
sfxSpecial()
|
|
// Blazing fast dash through opponent
|
|
await k.tween(atk.pos.x, behindX, 0.15, (v) => { atk.pos.x = v }, k.easings.easeInQuad)
|
|
// Hit happens mid-pass
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 15 : 7)
|
|
spawnSparks(origDX, def.pos.y - 30, 10, '#00f0ff')
|
|
spawnAfterimages(atk, 3)
|
|
if (isCritical) { screenFlash('#00f0ff'); await impactFreeze() }
|
|
// Dramatic pause behind opponent
|
|
await k.wait(0.3)
|
|
// Zip back to start
|
|
atk.play('idle')
|
|
await k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.1)
|
|
}
|
|
|
|
async function uppercut(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
const contactX = origDX - dir * 40
|
|
const origDY = def.pos.y
|
|
// Run to contact
|
|
await k.tween(atk.pos.x, contactX, 0.12, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
await k.wait(0.1)
|
|
// Launch defender into the air!
|
|
def.play('knockback')
|
|
k.shake(isCritical ? 18 : 8)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 12, '#ffe14d')
|
|
if (isCritical) { screenFlash('#ffe14d'); sfxExplosion(); await impactFreeze(0.1) }
|
|
const launchHeight = isCritical ? 250 : 160
|
|
await k.tween(def.pos.y, origDY - launchHeight, 0.25, (v) => { def.pos.y = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.15)
|
|
// Defender crashes back down
|
|
await k.tween(def.pos.y, origDY, 0.3, (v) => { def.pos.y = v }, k.easings.easeInQuad)
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ffe14d')
|
|
k.shake(5)
|
|
sfxPunch()
|
|
await k.wait(0.2)
|
|
// Return
|
|
await k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad)
|
|
}
|
|
|
|
async function multiHit(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
const contactX = origDX - dir * 45
|
|
// Sprint to contact
|
|
await k.tween(atk.pos.x, contactX, 0.1, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
const hitCount = isCritical ? 5 : 3
|
|
for (let i = 0; i < hitCount; i++) {
|
|
atk.play(i % 2 === 0 ? 'attack' : 'kick')
|
|
sfxPunch()
|
|
await k.wait(0.08)
|
|
def.play('hit')
|
|
k.shake(3 + i)
|
|
spawnSparks(def.pos.x + (Math.random() - 0.5) * 30, def.pos.y - 20 - Math.random() * 40, 4, '#ff2d7b')
|
|
// Jitter defender
|
|
def.pos.x += dir * 8
|
|
await k.wait(0.08)
|
|
}
|
|
if (isCritical) { screenFlash('#ff2d7b'); sfxCritical() }
|
|
// Final big push
|
|
def.play('knockback')
|
|
k.shake(12)
|
|
const push = dir * (isCritical ? 130 : 60)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.35)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.35, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
async function projectile(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
await k.wait(0.25)
|
|
// Fire projectile
|
|
const projY = atk.pos.y - 40
|
|
const color = isCritical ? '#ff2d7b' : theme.accent
|
|
const size = isCritical ? 12 : 8
|
|
await spawnProjectile(atk.pos.x + dir * 30, projY, def.pos.x, def.pos.y - 40, color, size)
|
|
// Impact
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 15 : 6)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, isCritical ? 20 : 8, color)
|
|
if (isCritical) { screenFlash(color); sfxExplosion() }
|
|
const push = dir * (isCritical ? 80 : 30)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
async function jetpackDive(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
const origAY = atk.pos.y
|
|
sfxJetpack()
|
|
// Jetpack blast off - fly way up off screen
|
|
const exhaustInterval = spawnExhaust(atk.pos.x, atk.pos.y, 0.8)
|
|
await k.tween(atk.pos.y, -50, 0.3, (v) => {
|
|
atk.pos.y = v
|
|
// Update exhaust position tracking would need the closure to capture, but exhaust spawns from initial pos
|
|
}, k.easings.easeInQuad)
|
|
clearInterval(exhaustInterval)
|
|
// Reposition above opponent
|
|
atk.pos.x = origDX
|
|
await k.wait(0.15)
|
|
// Dive bomb!
|
|
atk.play('kick')
|
|
sfxJetpack()
|
|
const exhaust2 = spawnExhaust(atk.pos.x, atk.pos.y, 0.3)
|
|
await k.tween(atk.pos.y, origAY, 0.2, (v) => { atk.pos.y = v }, k.easings.easeInQuad)
|
|
clearInterval(exhaust2)
|
|
// IMPACT
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 25 : 12)
|
|
spawnSparks(def.pos.x, def.pos.y - 20, 20, '#ff6600')
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ff6600')
|
|
screenFlash(isCritical ? '#ff2d2d' : '#ff6600', 0.15)
|
|
sfxExplosion()
|
|
// Push defender far
|
|
const push = dir * (isCritical ? 150 : 80)
|
|
k.tween(def.pos.x, origDX + push, 0.3, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.4)
|
|
// Return
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.3, (v) => { atk.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(def.pos.x, origDX, 0.4, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
async function gunBurst(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
atk.play('special')
|
|
// Spawn visible pixel gun prop
|
|
const gunX = atk.pos.x + dir * 15
|
|
const gunY = atk.pos.y - 40
|
|
const gunDef = PROPS.gun
|
|
const gunObjs = spawnWeaponProp('gun', gunX, gunY, dir < 0, 18)
|
|
await k.wait(0.15)
|
|
const bulletCount = isCritical ? 8 : 4
|
|
const muzzleX = gunX + dir * 30
|
|
// Fire bullets in rapid succession
|
|
for (let i = 0; i < bulletCount; i++) {
|
|
sfxGunshot()
|
|
// Muzzle flash
|
|
const flash = k.add([k.circle(5), k.pos(muzzleX, gunY), k.color(k.Color.fromHex('#ffee00')), k.opacity(0.9), k.z(19), k.anchor('center')])
|
|
setTimeout(() => { if (flash.exists()) flash.destroy() }, 35)
|
|
const targetY = def.pos.y - 20 - Math.random() * 50
|
|
spawnBullet(muzzleX, gunY, def.pos.x, targetY)
|
|
// Recoil: bounce gun back
|
|
if (gunDef) moveProp(gunObjs, gunDef, gunX - dir * 4, gunY, dir < 0)
|
|
atk.pos.x -= dir * 3
|
|
await k.wait(0.04)
|
|
if (gunDef) moveProp(gunObjs, gunDef, gunX, gunY, dir < 0)
|
|
atk.pos.x += dir * 3
|
|
sfxBulletHit()
|
|
def.opacity = 0.4
|
|
await k.wait(0.02)
|
|
def.opacity = 1
|
|
}
|
|
// Remove gun
|
|
destroyProp(gunObjs)
|
|
spawnBulletHoles(def.pos.x, def.pos.y - 30, isCritical ? 5 : 3)
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 15 : 8)
|
|
if (isCritical) { screenFlash('#ffee00'); sfxExplosion() }
|
|
const push = dir * (isCritical ? 100 : 40)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.35)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
async function groundPound(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
const origAY = atk.pos.y
|
|
// Jump super high off screen
|
|
sfxJetpack()
|
|
await k.tween(atk.pos.y, -100, 0.25, (v) => { atk.pos.y = v }, k.easings.easeOutQuad)
|
|
// Move to center of stage
|
|
const slamX = (origAX + origDX) / 2
|
|
atk.pos.x = slamX
|
|
await k.wait(0.2)
|
|
// SLAM DOWN
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
await k.tween(atk.pos.y, origAY, 0.12, (v) => { atk.pos.y = v }, k.easings.easeInQuad)
|
|
// Massive shockwave
|
|
k.shake(isCritical ? 30 : 18)
|
|
screenFlash(isCritical ? '#ff2d2d' : '#ffe14d', 0.2)
|
|
sfxExplosion()
|
|
spawnShockwave(slamX, GROUND_Y, theme.accent)
|
|
spawnSparks(slamX, GROUND_Y - 10, 25, theme.accent)
|
|
// Defender gets launched
|
|
const origDY = def.pos.y
|
|
def.play('knockback')
|
|
const push = dir * (isCritical ? 130 : 70)
|
|
const launchH = isCritical ? 180 : 100
|
|
await Promise.all([
|
|
k.tween(def.pos.x, origDX + push, 0.3, (v) => { def.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(def.pos.y, origDY - launchH, 0.2, (v) => { def.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(def.pos.y, origDY, 0.2, (v) => { def.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
k.shake(5)
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ffe14d')
|
|
await k.wait(0.3)
|
|
// Return
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.3, (v) => { atk.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(def.pos.x, origDX, 0.4, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
async function teleportStrike(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
// Fade out
|
|
sfxSpecial()
|
|
spawnSparks(atk.pos.x, atk.pos.y - 30, 8, '#b83dff')
|
|
await k.tween(1, 0, 0.15, (v) => { atk.opacity = v })
|
|
// Teleport behind opponent
|
|
atk.pos.x = origDX + dir * 60
|
|
await k.wait(0.1)
|
|
// Fade in behind
|
|
spawnSparks(atk.pos.x, atk.pos.y - 30, 8, '#b83dff')
|
|
await k.tween(0, 1, 0.1, (v) => { atk.opacity = v })
|
|
// Strike from behind!
|
|
atk.play('attack')
|
|
sfxPunch()
|
|
await k.wait(0.1)
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 15 : 8)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 12, '#b83dff')
|
|
if (isCritical) { screenFlash('#b83dff'); sfxCritical() }
|
|
// Push defender forward (reversed since we're behind)
|
|
const push = -dir * (isCritical ? 80 : 40)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
// Teleport back home
|
|
spawnSparks(atk.pos.x, atk.pos.y - 30, 6, '#b83dff')
|
|
await k.tween(1, 0, 0.1, (v) => { atk.opacity = v })
|
|
atk.pos.x = origAX
|
|
await k.tween(0, 1, 0.1, (v) => { atk.opacity = v })
|
|
spawnSparks(origAX, atk.pos.y - 30, 6, '#b83dff')
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
async function fullScreenDash(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
// Back up to wall
|
|
const wallX = dir === 1 ? 20 : W - 20
|
|
await k.tween(atk.pos.x, wallX, 0.15, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.1)
|
|
// FULL SPEED DASH across entire screen!
|
|
atk.play('kick')
|
|
sfxSpecial()
|
|
const targetX = dir === 1 ? W - 20 : 20
|
|
// Speed lines
|
|
for (let i = 0; i < 8; i++) {
|
|
const lineY = Math.random() * H * 0.7
|
|
const line = k.add([
|
|
k.rect(W, 2),
|
|
k.pos(0, lineY),
|
|
k.color(safeColor(k,theme.accent)),
|
|
k.opacity(0.3),
|
|
k.z(12),
|
|
])
|
|
setTimeout(() => { if (line.exists()) line.destroy() }, 300)
|
|
}
|
|
await k.tween(atk.pos.x, targetX, 0.18, (v) => { atk.pos.x = v }, k.easings.easeInOutQuad)
|
|
// Hit happens when passing through defender
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 22 : 10)
|
|
spawnSparks(origDX, def.pos.y - 30, 15, '#00f0ff')
|
|
screenFlash(isCritical ? '#ffffff' : '#00f0ff', 0.12)
|
|
if (isCritical) sfxExplosion()
|
|
else sfxKick()
|
|
const push = dir * (isCritical ? 100 : 50)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.35)
|
|
// Return from far side
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.3, (v) => { atk.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(def.pos.x, origDX, 0.35, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// === THEMED CHOREOGRAPHIES (challenge-specific props) ===
|
|
|
|
// Helper: spawn a flying prop (rect or circle) from A to B
|
|
function spawnProp(
|
|
fromX: number, fromY: number, toX: number, toY: number,
|
|
w: number, h: number, color: string, speed: number = 600, isCircle: boolean = false,
|
|
): Promise<void> {
|
|
return new Promise(resolve => {
|
|
const prop = k.add([
|
|
isCircle ? k.circle(w / 2) : k.rect(w, h),
|
|
k.pos(fromX, fromY),
|
|
k.color(safeColor(k,color)),
|
|
k.opacity(1),
|
|
k.z(16),
|
|
k.rotate(Math.atan2(toY - fromY, toX - fromX) * 180 / Math.PI),
|
|
])
|
|
const dx = toX - fromX
|
|
const dy = toY - fromY
|
|
const dist = Math.sqrt(dx * dx + dy * dy)
|
|
const dur = dist / speed
|
|
k.tween(0, 1, dur, (t) => {
|
|
prop.pos.x = fromX + dx * t
|
|
prop.pos.y = fromY + dy * t
|
|
}, k.easings.linear).then(() => {
|
|
prop.destroy()
|
|
resolve()
|
|
})
|
|
})
|
|
}
|
|
|
|
// Helper: spawn multiple flying objects in a stream
|
|
async function spawnBarrage(
|
|
fromX: number, fromY: number, toX: number, toY: number,
|
|
count: number, color: string, size: number, spread: number, delay: number, isCircle: boolean = false,
|
|
) {
|
|
for (let i = 0; i < count; i++) {
|
|
const offY = (Math.random() - 0.5) * spread
|
|
const offX = (Math.random() - 0.5) * spread * 0.3
|
|
spawnProp(fromX + offX, fromY + offY, toX + offX, toY + offY, size, size, color, 500 + Math.random() * 300, isCircle)
|
|
await k.wait(delay)
|
|
}
|
|
}
|
|
|
|
// CODE GOLF: swing a giant golf club, golf balls fly at opponent
|
|
async function golfClubSmash(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
const contactX = origDX - dir * 60
|
|
await k.tween(atk.pos.x, contactX, 0.15, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
// Spawn golf club (long thin rect)
|
|
const club = k.add([
|
|
k.rect(8, 60),
|
|
k.pos(atk.pos.x + dir * 20, atk.pos.y - 60),
|
|
k.color(safeColor(k,'#888888')),
|
|
k.anchor('bot'),
|
|
k.z(18),
|
|
k.rotate(dir === 1 ? -45 : 45),
|
|
])
|
|
// Club head (wider rect at end)
|
|
const clubHead = k.add([
|
|
k.rect(18, 12),
|
|
k.pos(club.pos.x + dir * 15, club.pos.y - 55),
|
|
k.color(safeColor(k,'#cccccc')),
|
|
k.z(18),
|
|
])
|
|
atk.play('attack')
|
|
sfxSpecial()
|
|
// Swing the club
|
|
await k.tween(dir === 1 ? -45 : 45, dir === 1 ? 90 : -90, 0.15, (v) => { club.angle = v }, k.easings.easeInQuad)
|
|
sfxBonk()
|
|
// Club hits - launch golf balls!
|
|
club.destroy()
|
|
clubHead.destroy()
|
|
const ballCount = isCritical ? 6 : 3
|
|
for (let i = 0; i < ballCount; i++) {
|
|
const ballY = def.pos.y - 20 - Math.random() * 40
|
|
const ball = k.add([
|
|
k.circle(5),
|
|
k.pos(atk.pos.x + dir * 30, atk.pos.y - 40),
|
|
k.color(safeColor(k,'#ffffff')),
|
|
k.z(16),
|
|
])
|
|
sfxPunch()
|
|
const targetX = def.pos.x + (Math.random() - 0.5) * 30
|
|
k.tween(0, 1, 0.12, (t) => {
|
|
ball.pos.x = (atk.pos.x + dir * 30) + (targetX - atk.pos.x - dir * 30) * t
|
|
ball.pos.y = (atk.pos.y - 40) + (ballY - atk.pos.y + 40) * t - Math.sin(t * Math.PI) * 60
|
|
}).then(() => {
|
|
ball.destroy()
|
|
spawnSparks(targetX, ballY, 4, '#ffffff')
|
|
})
|
|
await k.wait(0.06)
|
|
}
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 18 : 8)
|
|
if (isCritical) screenFlash('#39ff14')
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 10, '#39ff14')
|
|
const push = dir * (isCritical ? 100 : 45)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.35)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// ROAST BATTLE: fire breath — stream of fire from attacker's face
|
|
async function fireBreath(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
const contactX = origDX - dir * 80
|
|
await k.tween(atk.pos.x, contactX, 0.12, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
// Fire stream!
|
|
const fireX = atk.pos.x + dir * 25
|
|
const fireY = atk.pos.y - 45
|
|
const fireCount = isCritical ? 40 : 20
|
|
for (let i = 0; i < fireCount; i++) {
|
|
const p = k.add([
|
|
k.circle(4 + Math.random() * 6),
|
|
k.pos(fireX, fireY + (Math.random() - 0.5) * 15),
|
|
k.color(safeColor(k,Math.random() > 0.3 ? '#ff6600' : Math.random() > 0.5 ? '#ffcc00' : '#ff2d2d')),
|
|
k.opacity(0.9),
|
|
k.z(16),
|
|
])
|
|
const speed = 400 + Math.random() * 400
|
|
const vy = (Math.random() - 0.5) * 100
|
|
p.onUpdate(() => {
|
|
p.pos.x += dir * speed * k.dt()
|
|
p.pos.y += vy * k.dt()
|
|
p.opacity -= 2 * k.dt()
|
|
if (p.opacity <= 0 || Math.abs(p.pos.x - fireX) > Math.abs(def.pos.x - fireX) + 30) p.destroy()
|
|
})
|
|
if (i % 5 === 0) {
|
|
def.opacity = 0.5
|
|
setTimeout(() => { if (def.exists()) def.opacity = 1 }, 50)
|
|
}
|
|
await k.wait(0.02)
|
|
}
|
|
await k.wait(0.1)
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 20 : 8)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 15, '#ff6600')
|
|
if (isCritical) { screenFlash('#ff6600'); sfxExplosion() }
|
|
// Defender on fire briefly
|
|
const fireTimer = setInterval(() => {
|
|
if (!def.exists()) { clearInterval(fireTimer); return }
|
|
k.add([
|
|
k.circle(3),
|
|
k.pos(def.pos.x + (Math.random() - 0.5) * 25, def.pos.y - Math.random() * 60),
|
|
k.color(safeColor(k,Math.random() > 0.5 ? '#ff6600' : '#ffcc00')),
|
|
k.opacity(0.7),
|
|
k.z(11),
|
|
]).onUpdate(function(this: any) { this.pos.y -= 80 * k.dt(); this.opacity -= 2 * k.dt(); if (this.opacity <= 0) this.destroy() })
|
|
}, 40)
|
|
const push = dir * (isCritical ? 110 : 50)
|
|
k.tween(def.pos.x, origDX + push, 0.3, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.6)
|
|
clearInterval(fireTimer)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// RIDDLE: question mark barrage rains from the sky
|
|
async function riddleBarrage(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
sfxZap()
|
|
await k.wait(0.2)
|
|
// Rain question marks from above
|
|
const qCount = isCritical ? 12 : 6
|
|
for (let i = 0; i < qCount; i++) {
|
|
const qx = def.pos.x + (Math.random() - 0.5) * 100
|
|
const qy = -20
|
|
const q = k.add([
|
|
k.circle(8),
|
|
k.pos(qx, qy),
|
|
k.color(safeColor(k,'#b83dff')),
|
|
k.opacity(0.9),
|
|
k.z(16),
|
|
])
|
|
// Inner dot to make it look like "?"
|
|
const dot = k.add([
|
|
k.circle(3),
|
|
k.pos(qx, qy + 12),
|
|
k.color(safeColor(k,'#ffffff')),
|
|
k.opacity(0.9),
|
|
k.z(17),
|
|
])
|
|
k.tween(qy, def.pos.y - 20, 0.2 + Math.random() * 0.1, (v) => { q.pos.y = v; dot.pos.y = v + 12 }, k.easings.easeInQuad).then(() => {
|
|
q.destroy(); dot.destroy()
|
|
spawnSparks(qx, def.pos.y - 20, 3, '#b83dff')
|
|
sfxBonk()
|
|
k.shake(2)
|
|
})
|
|
await k.wait(0.06)
|
|
}
|
|
await k.wait(0.15)
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 15 : 7)
|
|
if (isCritical) { screenFlash('#b83dff'); sfxExplosion() }
|
|
const push = dir * (isCritical ? 90 : 40)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
// HALLUCINATION CHECK: clone confusion — multiple fake attackers appear
|
|
async function cloneStrike(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
sfxZap()
|
|
// Spawn 3-5 "ghost" clones that zip around
|
|
const cloneCount = isCritical ? 5 : 3
|
|
const clones: any[] = []
|
|
for (let i = 0; i < cloneCount; i++) {
|
|
const clone = k.add([
|
|
k.rect(20, 35),
|
|
k.pos(atk.pos.x, atk.pos.y - 25),
|
|
k.color(safeColor(k,theme.accent)),
|
|
k.opacity(0.3),
|
|
k.z(9),
|
|
])
|
|
clones.push(clone)
|
|
// Each clone zips to a random position
|
|
const rx = origDX + (Math.random() - 0.5) * 200
|
|
const ry = GROUND_Y - 6 - Math.random() * 80
|
|
k.tween(0, 1, 0.2, (t) => {
|
|
clone.pos.x = atk.pos.x + (rx - atk.pos.x) * t
|
|
clone.pos.y = (atk.pos.y - 25) + (ry - atk.pos.y + 25) * t
|
|
})
|
|
}
|
|
await k.wait(0.25)
|
|
// Defender is confused — screen warps
|
|
screenFlash('#b83dff', 0.1)
|
|
await k.wait(0.15)
|
|
// Real attacker teleports and strikes
|
|
spawnSparks(atk.pos.x, atk.pos.y - 30, 6, theme.accent)
|
|
await k.tween(1, 0, 0.08, (v) => { atk.opacity = v })
|
|
atk.pos.x = origDX - dir * 40
|
|
await k.tween(0, 1, 0.08, (v) => { atk.opacity = v })
|
|
atk.play('attack')
|
|
sfxPunch()
|
|
await k.wait(0.1)
|
|
// Destroy clones
|
|
clones.forEach(c => { if (c.exists()) { spawnSparks(c.pos.x, c.pos.y, 3, theme.accent); c.destroy() } })
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 16 : 7)
|
|
if (isCritical) { screenFlash('#ffffff'); sfxCritical() }
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 10, theme.accent)
|
|
const push = dir * (isCritical ? 100 : 45)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.35)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// TOKEN ECONOMY: coin shower — coins rain down on opponent
|
|
async function coinShower(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
sfxBoing()
|
|
await k.wait(0.15)
|
|
// Coins rain from above
|
|
const coinCount = isCritical ? 20 : 10
|
|
for (let i = 0; i < coinCount; i++) {
|
|
const cx = def.pos.x + (Math.random() - 0.5) * 80
|
|
const coin = k.add([
|
|
k.circle(5),
|
|
k.pos(cx, -10),
|
|
k.color(safeColor(k,Math.random() > 0.3 ? '#ffd700' : '#ffb000')),
|
|
k.opacity(1),
|
|
k.z(16),
|
|
])
|
|
const targetY = def.pos.y - 10 - Math.random() * 50
|
|
k.tween(coin.pos.y, targetY, 0.15 + Math.random() * 0.1, (v) => { coin.pos.y = v }, k.easings.easeInQuad).then(() => {
|
|
coin.destroy()
|
|
spawnSparks(cx, targetY, 2, '#ffd700')
|
|
sfxBulletHit()
|
|
})
|
|
await k.wait(0.03)
|
|
}
|
|
await k.wait(0.1)
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 14 : 6)
|
|
if (isCritical) { screenFlash('#ffd700'); sfxExplosion() }
|
|
const push = dir * (isCritical ? 90 : 40)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
// CREATIVE WRITING: giant pen stab + ink splatter
|
|
async function penStab(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
// Spawn a giant pen/quill
|
|
const penX = atk.pos.x + dir * 15
|
|
const penY = atk.pos.y - 70
|
|
const pen = k.add([
|
|
k.rect(6, 80),
|
|
k.pos(penX, penY),
|
|
k.color(safeColor(k,'#4488ff')),
|
|
k.anchor('bot'),
|
|
k.z(18),
|
|
k.rotate(dir === 1 ? -30 : 30),
|
|
])
|
|
// Pen tip
|
|
const tip = k.add([
|
|
k.rect(4, 12),
|
|
k.pos(penX + dir * 5, penY - 68),
|
|
k.color(safeColor(k,'#333333')),
|
|
k.z(18),
|
|
])
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
await k.wait(0.15)
|
|
// Thrust pen forward at opponent
|
|
const targetX = origDX - dir * 20
|
|
await Promise.all([
|
|
k.tween(pen.pos.x, targetX, 0.12, (v) => { pen.pos.x = v; tip.pos.x = v + dir * 5 }, k.easings.easeInQuad),
|
|
k.tween(pen.angle, dir === 1 ? 80 : -80, 0.12, (v) => { pen.angle = v }, k.easings.easeInQuad),
|
|
k.tween(atk.pos.x, targetX - dir * 30, 0.12, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
])
|
|
sfxPunch()
|
|
pen.destroy()
|
|
tip.destroy()
|
|
// INK SPLATTER!
|
|
const inkColors = ['#1a1a3a', '#2a2a5a', '#0a0a2a', '#4488ff']
|
|
for (let i = 0; i < (isCritical ? 20 : 10); i++) {
|
|
const splat = k.add([
|
|
k.circle(4 + Math.random() * 10),
|
|
k.pos(def.pos.x + (Math.random() - 0.5) * 60, def.pos.y - Math.random() * 70),
|
|
k.color(safeColor(k,inkColors[Math.floor(Math.random() * inkColors.length)])),
|
|
k.opacity(0.8),
|
|
k.z(9),
|
|
])
|
|
setTimeout(() => {
|
|
k.tween(0.8, 0, 1.5, (v) => { if (splat.exists()) splat.opacity = v }).then(() => { if (splat.exists()) splat.destroy() })
|
|
}, 800)
|
|
}
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 16 : 7)
|
|
if (isCritical) screenFlash('#4488ff')
|
|
const push = dir * (isCritical ? 100 : 45)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.4)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// MATH BLITZ: number projectiles fly at opponent
|
|
async function mathAttack(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
await k.wait(0.15)
|
|
// Fire number "projectiles" (colored circles representing digits)
|
|
const numCount = isCritical ? 10 : 5
|
|
const colors = ['#ff2d7b', '#00f0ff', '#ffe14d', '#39ff14', '#b83dff']
|
|
for (let i = 0; i < numCount; i++) {
|
|
const size = 6 + Math.random() * 8
|
|
const fromY = atk.pos.y - 30 - Math.random() * 30
|
|
const toY = def.pos.y - 10 - Math.random() * 50
|
|
const num = k.add([
|
|
k.circle(size),
|
|
k.pos(atk.pos.x + dir * 25, fromY),
|
|
k.color(safeColor(k,colors[i % colors.length])),
|
|
k.opacity(1),
|
|
k.z(16),
|
|
])
|
|
const dur = 0.1 + Math.random() * 0.05
|
|
sfxGunshot()
|
|
k.tween(0, 1, dur, (t) => {
|
|
num.pos.x = (atk.pos.x + dir * 25) + (def.pos.x - atk.pos.x - dir * 25) * t
|
|
num.pos.y = fromY + (toY - fromY) * t
|
|
}).then(() => {
|
|
num.destroy()
|
|
spawnSparks(def.pos.x + (Math.random() - 0.5) * 20, toY, 3, colors[i % colors.length])
|
|
})
|
|
await k.wait(0.04)
|
|
}
|
|
await k.wait(0.1)
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 15 : 7)
|
|
if (isCritical) { screenFlash('#ffe14d'); sfxExplosion() }
|
|
const push = dir * (isCritical ? 95 : 40)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
// TRAP CARD: card shuriken + trap springs
|
|
async function trapCardAttack(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
await k.wait(0.1)
|
|
// Throw spinning cards
|
|
const cardCount = isCritical ? 5 : 3
|
|
for (let i = 0; i < cardCount; i++) {
|
|
const card = k.add([
|
|
k.rect(12, 18),
|
|
k.pos(atk.pos.x + dir * 20, atk.pos.y - 40 + (Math.random() - 0.5) * 20),
|
|
k.color(safeColor(k,i === 0 ? '#ff2d7b' : '#ffffff')),
|
|
k.anchor('center'),
|
|
k.z(16),
|
|
k.rotate(0),
|
|
])
|
|
const fromX = card.pos.x
|
|
const fromY = card.pos.y
|
|
const toX = def.pos.x
|
|
const toY = def.pos.y - 30 + (Math.random() - 0.5) * 30
|
|
sfxGunshot()
|
|
k.tween(0, 1, 0.12, (t) => {
|
|
card.pos.x = fromX + (toX - fromX) * t
|
|
card.pos.y = fromY + (toY - fromY) * t
|
|
card.angle = t * 720 // Spin
|
|
}).then(() => {
|
|
card.destroy()
|
|
spawnSparks(toX, toY, 5, '#ff2d7b')
|
|
sfxBulletHit()
|
|
})
|
|
await k.wait(0.08)
|
|
}
|
|
await k.wait(0.1)
|
|
// TRAP SPRINGS! A bear trap appears under defender
|
|
const trap = k.add([
|
|
k.rect(30, 8),
|
|
k.pos(def.pos.x - 15, GROUND_Y - 8),
|
|
k.color(safeColor(k,'#888888')),
|
|
k.z(8),
|
|
])
|
|
const jaw1 = k.add([
|
|
k.rect(30, 4),
|
|
k.pos(def.pos.x - 15, GROUND_Y - 16),
|
|
k.color(safeColor(k,'#aaaaaa')),
|
|
k.z(8),
|
|
])
|
|
sfxBonk()
|
|
k.shake(3)
|
|
await k.wait(0.05)
|
|
// Snap! Jaws close
|
|
k.tween(jaw1.pos.y, GROUND_Y - 10, 0.05, (v) => { jaw1.pos.y = v })
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 18 : 8)
|
|
if (isCritical) { screenFlash('#ff2d7b'); sfxExplosion() }
|
|
spawnSparks(def.pos.x, GROUND_Y - 10, 8, '#ff2d7b')
|
|
await k.wait(0.3)
|
|
trap.destroy()
|
|
jaw1.destroy()
|
|
const push = dir * (isCritical ? 90 : 40)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
// SPEED BLITZ: afterimage dash — leaves ghost copies behind
|
|
async function afterimageDash(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
sfxSpecial()
|
|
const contactX = origDX - dir * 40
|
|
// Leave afterimages as we dash
|
|
const ghostCount = isCritical ? 6 : 4
|
|
const startX = atk.pos.x
|
|
for (let i = 0; i < ghostCount; i++) {
|
|
const ghost = k.add([
|
|
k.rect(20, 35),
|
|
k.pos(atk.pos.x, atk.pos.y - 25),
|
|
k.color(safeColor(k,theme.accent)),
|
|
k.opacity(0.4),
|
|
k.z(9),
|
|
])
|
|
setTimeout(() => { k.tween(0.4, 0, 0.3, (v) => { if (ghost.exists()) ghost.opacity = v }).then(() => { if (ghost.exists()) ghost.destroy() }) }, 50)
|
|
// Move attacker a step forward
|
|
const stepX = startX + ((contactX - startX) / ghostCount) * (i + 1)
|
|
await k.tween(atk.pos.x, stepX, 0.03, (v) => { atk.pos.x = v })
|
|
}
|
|
atk.play('attack')
|
|
sfxPunch()
|
|
await k.wait(0.08)
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 16 : 7)
|
|
// Speed lines
|
|
for (let i = 0; i < 5; i++) {
|
|
const lineY = GROUND_Y - 20 - Math.random() * 100
|
|
const line = k.add([
|
|
k.rect(W * 0.4, 2),
|
|
k.pos(dir === 1 ? origAX : origDX, lineY),
|
|
k.color(safeColor(k,theme.accent)),
|
|
k.opacity(0.5),
|
|
k.z(12),
|
|
])
|
|
k.tween(0.5, 0, 0.2, (v) => { if (line.exists()) line.opacity = v }).then(() => { if (line.exists()) line.destroy() })
|
|
}
|
|
if (isCritical) { screenFlash('#ffffff'); sfxCritical() }
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 12, theme.accent)
|
|
const push = dir * (isCritical ? 100 : 45)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// BULLET TIME: slow-mo dodge, afterimages trail behind, golden traces, devastating counter
|
|
async function bulletTimeAttack(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
// Phase 1: Darken screen — entering bullet time
|
|
const dim = k.add([k.rect(W, H), k.pos(0, 0), k.color(safeColor(k, '#000011')), k.opacity(0), k.z(25)])
|
|
await k.tween(0, 0.45, 0.15, (v) => { dim.opacity = v })
|
|
scanlineGlitch(0.1)
|
|
|
|
// Phase 2: Attacker fires slow golden projectiles (bullets visible in slow-mo)
|
|
atk.play('special')
|
|
sfxGunshot()
|
|
const bulletCount = isCritical ? 5 : 3
|
|
const bullets: any[] = []
|
|
for (let i = 0; i < bulletCount; i++) {
|
|
const bx = atk.pos.x + dir * 25
|
|
const by = atk.pos.y - 30 + (i - 1) * 12
|
|
const bullet = k.add([
|
|
k.rect(isCritical ? 14 : 10, 3),
|
|
k.pos(bx, by),
|
|
k.color(safeColor(k, '#ffd700')),
|
|
k.opacity(0.9),
|
|
k.z(26),
|
|
k.anchor('center'),
|
|
k.rotate(dir === 1 ? 0 : 180),
|
|
])
|
|
bullets.push(bullet)
|
|
// Golden trace trail behind each bullet
|
|
const trace = k.add([
|
|
k.rect(40, 1),
|
|
k.pos(bx - dir * 20, by),
|
|
k.color(safeColor(k, '#ffaa00')),
|
|
k.opacity(0.5),
|
|
k.z(25),
|
|
])
|
|
k.tween(trace.opacity, 0, 0.4, (v) => { if (trace.exists()) trace.opacity = v }).then(() => { if (trace.exists()) trace.destroy() })
|
|
await k.wait(0.08) // Slow-mo pacing between shots
|
|
}
|
|
|
|
// Phase 3: Bullets travel slowly toward defender
|
|
await Promise.all(bullets.map((b, i) =>
|
|
k.tween(b.pos.x, def.pos.x + (Math.random() - 0.5) * 15, 0.25 + i * 0.03, (v) => { b.pos.x = v }, k.easings.easeInQuad)
|
|
))
|
|
bullets.forEach(b => { if (b.exists()) b.destroy() })
|
|
|
|
// Phase 4: Attacker dodges (lean back in slow-mo with afterimages)
|
|
const leanBack = dir * -30
|
|
for (let i = 0; i < 4; i++) {
|
|
const ghost = k.add([
|
|
k.rect(FRAME_SIZE * Math.abs(atk.scale.x) * 0.8, FRAME_SIZE * Math.abs(atk.scale.y)),
|
|
k.pos(atk.pos.x + i * leanBack * 0.15, atk.pos.y),
|
|
k.color(safeColor(k, '#ffd700')),
|
|
k.opacity(0.25 - i * 0.05),
|
|
k.z(24),
|
|
k.anchor('bot'),
|
|
])
|
|
setTimeout(() => { if (ghost.exists()) ghost.destroy() }, 400)
|
|
}
|
|
await k.tween(atk.pos.x, atk.pos.x + leanBack, 0.2, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
|
|
// Phase 5: Time resumes — attacker dashes in for devastating counter
|
|
dim.destroy()
|
|
sfxZoomWhoosh()
|
|
const contactX = origDX - dir * 40
|
|
// Afterimage trail during rush
|
|
const rushStart = atk.pos.x
|
|
for (let i = 0; i < 5; i++) {
|
|
const ghost = k.add([
|
|
k.rect(FRAME_SIZE * Math.abs(atk.scale.x) * 0.7, FRAME_SIZE * Math.abs(atk.scale.y) * 0.9),
|
|
k.pos(rushStart + ((contactX - rushStart) * i / 5), atk.pos.y),
|
|
k.color(safeColor(k, theme.accent)),
|
|
k.opacity(0.3 - i * 0.05),
|
|
k.z(9),
|
|
k.anchor('bot'),
|
|
])
|
|
setTimeout(() => { if (ghost.exists()) ghost.destroy() }, 250)
|
|
}
|
|
await k.tween(atk.pos.x, contactX, 0.08, (v) => { atk.pos.x = v }, k.easings.easeInQuad)
|
|
atk.play('attack')
|
|
|
|
// Phase 6: Impact
|
|
const hits = isCritical ? 4 : 2
|
|
for (let i = 0; i < hits; i++) {
|
|
sfxPunch()
|
|
def.play('hit')
|
|
k.shake(6 + i * 3)
|
|
spawnSparks(def.pos.x + (Math.random() - 0.5) * 15, def.pos.y - 20 - Math.random() * 20, 6, '#ffd700')
|
|
if (i < hits - 1) await k.wait(0.06)
|
|
}
|
|
// Final devastating blow
|
|
sfxCritical()
|
|
if (isCritical) { sfxExplosion(); screenFlash('#ffd700', 0.2) }
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 22 : 12)
|
|
spawnSparks(def.pos.x, def.pos.y - 25, isCritical ? 20 : 12, '#ffd700')
|
|
if (isCritical) spawnShockwave(def.pos.x, GROUND_Y, '#ffd700')
|
|
|
|
// Return to positions
|
|
const push = dir * (isCritical ? 70 : 35)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v: number) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
atk.play('idle')
|
|
}
|
|
|
|
// INVISIBLE SPEED: so fast you can barely see — just blur lines and impact
|
|
async function lightningRush(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
sfxSpecial()
|
|
// Attacker vanishes
|
|
atk.opacity = 0
|
|
// Blur lines everywhere
|
|
for (let i = 0; i < 12; i++) {
|
|
const lineY = GROUND_Y - 10 - Math.random() * 120
|
|
const line = k.add([
|
|
k.rect(W, 2 + Math.random() * 2),
|
|
k.pos(0, lineY),
|
|
k.color(safeColor(k,Math.random() > 0.5 ? '#ffffff' : theme.accent)),
|
|
k.opacity(0.6),
|
|
k.z(25),
|
|
])
|
|
k.tween(0.6, 0, 0.15, (v) => { if (line.exists()) line.opacity = v }).then(() => { if (line.exists()) line.destroy() })
|
|
}
|
|
// Multiple instant impacts across the screen (so fast, hits happen everywhere)
|
|
const hitCount = isCritical ? 8 : 5
|
|
for (let i = 0; i < hitCount; i++) {
|
|
const hx = origDX + (Math.random() - 0.5) * 100
|
|
const hy = GROUND_Y - 20 - Math.random() * 80
|
|
spawnSparks(hx, hy, 5, '#ffffff')
|
|
sfxPunch()
|
|
k.shake(3)
|
|
// Brief flash of attacker at hit position
|
|
atk.pos.x = hx - dir * 30
|
|
atk.opacity = 0.3
|
|
await k.wait(0.02)
|
|
atk.opacity = 0
|
|
await k.wait(0.01)
|
|
}
|
|
// Final massive hit
|
|
screenFlash('#ffffff', 0.15)
|
|
atk.pos.x = origDX - dir * 40
|
|
atk.opacity = 1
|
|
atk.play('attack')
|
|
sfxCritical()
|
|
await k.wait(0.05)
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 25 : 12)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 20, '#ffffff')
|
|
if (isCritical) sfxExplosion()
|
|
const push = dir * (isCritical ? 140 : 70)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.15, (v) => { atk.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// ZOOM RUSH: fly toward camera (scale huge) then slam back into opponent
|
|
async function zoomRush(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
const origAY = atk.pos.y
|
|
const origScaleX = atk.scale.x
|
|
const origScaleY = atk.scale.y
|
|
const origDefScaleX = def.scale.x
|
|
const origDefScaleY = def.scale.y
|
|
sfxZoomWhoosh()
|
|
// Randomize zoom level for variety (3x to 7x)
|
|
const zoomScale = isCritical ? 5 + Math.random() * 2 : 3 + Math.random() * 2
|
|
const zoomDur = 0.2 + Math.random() * 0.1
|
|
// Attacker rushes toward camera — scale up dramatically
|
|
// Defender shrinks to background (perspective effect)
|
|
await Promise.all([
|
|
k.tween(Math.abs(origScaleX), zoomScale, zoomDur, (v) => {
|
|
atk.scale.x = origScaleX > 0 ? v : -v
|
|
atk.scale.y = v
|
|
}, k.easings.easeInQuad),
|
|
k.tween(Math.abs(origDefScaleX), Math.abs(origDefScaleX) * 0.4, zoomDur, (v) => {
|
|
def.scale.x = origDefScaleX > 0 ? v : -v
|
|
def.scale.y = v
|
|
}, k.easings.easeInQuad),
|
|
k.tween(atk.pos.x, W / 2, zoomDur, (v) => { atk.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(atk.pos.y, H * 0.6, zoomDur, (v) => { atk.pos.y = v }, k.easings.easeOutQuad),
|
|
k.tween(1, 0.3, zoomDur, (v) => { atk.opacity = Math.max(0.3, v) }),
|
|
])
|
|
// Brief dramatic pause at huge size — screen darkens + grotesque close-up
|
|
screenFlash('#000000', 0.15)
|
|
if (zoomScale >= 4) spawnGrotesqueDetails(atk, zoomScale * 0.4)
|
|
k.shake(5)
|
|
await k.wait(0.1 + Math.random() * 0.08)
|
|
destroyGrotesqueDetails()
|
|
// Zoom back and SLAM into opponent (defender grows back)
|
|
sfxZoomWhoosh()
|
|
sfxSpecial()
|
|
await Promise.all([
|
|
k.tween(atk.scale.y, Math.abs(origScaleY), 0.15, (v) => {
|
|
atk.scale.x = origScaleX > 0 ? v : -v
|
|
atk.scale.y = v
|
|
}, k.easings.easeInQuad),
|
|
k.tween(Math.abs(def.scale.y), Math.abs(origDefScaleY), 0.15, (v) => {
|
|
def.scale.x = origDefScaleX > 0 ? v : -v
|
|
def.scale.y = v
|
|
}, k.easings.easeOutQuad),
|
|
k.tween(atk.pos.x, origDX - dir * 40, 0.15, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(atk.pos.y, origAY, 0.15, (v) => { atk.pos.y = v }, k.easings.easeInQuad),
|
|
k.tween(0.3, 1, 0.15, (v) => { atk.opacity = v }),
|
|
])
|
|
// IMPACT — rapid punches on contact
|
|
atk.play('attack')
|
|
const punchCount = isCritical ? 8 : 5
|
|
for (let i = 0; i < punchCount; i++) {
|
|
sfxRapidPunch()
|
|
def.play(i % 2 === 0 ? 'hit' : 'knockback')
|
|
spawnSparks(def.pos.x + (Math.random() - 0.5) * 40, def.pos.y - 10 - Math.random() * 50, 4, i % 2 === 0 ? '#ff2d7b' : '#ffcc00')
|
|
k.shake(2 + i)
|
|
def.pos.x += dir * 4
|
|
atk.play(i % 2 === 0 ? 'attack' : 'kick')
|
|
await k.wait(0.04)
|
|
}
|
|
// Final haymaker
|
|
sfxCritical()
|
|
k.shake(isCritical ? 25 : 15)
|
|
screenFlash(isCritical ? '#ffffff' : '#ff2d7b', 0.2)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 20, '#ffffff')
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ff2d7b')
|
|
if (isCritical) sfxExplosion()
|
|
const push = dir * (isCritical ? 150 : 80)
|
|
k.tween(def.pos.x, origDX + push, 0.3, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.4)
|
|
// Return — restore both scales
|
|
atk.scale.x = origScaleX
|
|
atk.scale.y = origScaleY
|
|
def.scale.x = origDefScaleX
|
|
def.scale.y = origDefScaleY
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(def.pos.x, origDX, 0.35, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// RAPID FLURRY: DBZ-style machine gun punches — so fast it's a blur
|
|
async function rapidFlurry(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
const contactX = origDX - dir * 40
|
|
// Sprint to contact
|
|
sfxSpecial()
|
|
await k.tween(atk.pos.x, contactX, 0.08, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
// UNLEASH — rapid alternating punches
|
|
const hitCount = isCritical ? 14 : 8
|
|
const colors = ['#ff2d7b', '#ffcc00', '#00f0ff', '#ff6600', '#ffffff']
|
|
// Speed lines during flurry
|
|
for (let i = 0; i < 6; i++) {
|
|
const lineY = GROUND_Y - 10 - Math.random() * 100
|
|
const line = k.add([
|
|
k.rect(W * 0.5, 2),
|
|
k.pos(dir === 1 ? origAX - 50 : origDX + 50, lineY),
|
|
k.color(safeColor(k,colors[i % colors.length])),
|
|
k.opacity(0.4),
|
|
k.z(12),
|
|
])
|
|
k.tween(0.4, 0, 0.5, (v) => { if (line.exists()) line.opacity = v }).then(() => { if (line.exists()) line.destroy() })
|
|
}
|
|
for (let i = 0; i < hitCount; i++) {
|
|
const anim = ['attack', 'kick', 'attack', 'special'][i % 4]
|
|
atk.play(anim)
|
|
sfxRapidPunch()
|
|
// Sparks spray in alternating directions
|
|
const sparkX = def.pos.x + (i % 2 === 0 ? -1 : 1) * (10 + Math.random() * 20)
|
|
const sparkY = def.pos.y - 10 - Math.random() * 50
|
|
spawnSparks(sparkX, sparkY, 3, colors[i % colors.length])
|
|
def.play('hit')
|
|
k.shake(2)
|
|
// Jitter defender rapidly side to side
|
|
def.pos.x += (i % 2 === 0 ? dir : -dir) * 6
|
|
def.pos.y += (i % 2 === 0 ? -3 : 3)
|
|
await k.wait(0.035)
|
|
}
|
|
// Pause — "Is it over?"
|
|
await k.wait(0.08)
|
|
// ONE MORE — the big finish
|
|
atk.play('special')
|
|
sfxCritical()
|
|
sfxPunch()
|
|
await k.wait(0.06)
|
|
def.play('knockback')
|
|
k.shake(isCritical ? 22 : 12)
|
|
screenFlash(isCritical ? '#ffffff' : '#ffcc00', 0.15)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, isCritical ? 25 : 12, '#ffcc00')
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ffcc00')
|
|
if (isCritical) sfxExplosion()
|
|
const push = dir * (isCritical ? 140 : 70)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
// Reset defender Y
|
|
k.tween(def.pos.y, GROUND_Y - 6, 0.2, (v) => { def.pos.y = v })
|
|
await k.wait(0.35)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.35, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// SWORD SLASH: giant energy sword swing with arc trail
|
|
async function swordSlash(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
const contactX = origDX - dir * 50
|
|
await k.tween(atk.pos.x, contactX, 0.1, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
// Draw sword arc (series of rects forming a crescent)
|
|
const arcParts: any[] = []
|
|
for (let i = 0; i < 8; i++) {
|
|
const angle = (i / 8) * Math.PI - Math.PI / 4
|
|
const ax = contactX + dir * 20 + Math.cos(angle) * 60
|
|
const ay = atk.pos.y - 40 + Math.sin(angle) * 60
|
|
const part = k.add([
|
|
k.rect(25, 3), k.pos(ax, ay), k.color(safeColor(k,isCritical ? '#00f0ff' : '#aaddff')),
|
|
k.opacity(0.9), k.z(18), k.rotate(angle * 180 / Math.PI + 90),
|
|
])
|
|
arcParts.push(part)
|
|
}
|
|
await k.wait(0.08)
|
|
// Slash hits
|
|
arcParts.forEach(p => { k.tween(0.9, 0, 0.2, (v) => { if (p.exists()) p.opacity = v }).then(() => { if (p.exists()) p.destroy() }) })
|
|
sfxKick()
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 18 : 8)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 15, '#aaddff')
|
|
if (isCritical) { screenFlash('#00f0ff'); sfxCritical() }
|
|
const push = dir * (isCritical ? 110 : 50)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.35)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// HAMMER SMASH: pull out giant hammer, overhead slam with ground crack
|
|
async function hammerSmash(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
const contactX = origDX - dir * 40
|
|
await k.tween(atk.pos.x, contactX, 0.12, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
// Giant hammer
|
|
const handle = k.add([k.rect(6, 70), k.pos(atk.pos.x + dir * 15, atk.pos.y - 90), k.color(safeColor(k,'#8B4513')), k.anchor('bot'), k.z(18), k.rotate(dir === 1 ? -60 : 60)])
|
|
const head = k.add([k.rect(30, 20), k.pos(handle.pos.x + dir * 10, handle.pos.y - 60), k.color(safeColor(k,'#888888')), k.z(18)])
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
// Swing hammer down
|
|
await k.tween(dir === 1 ? -60 : 60, dir === 1 ? 70 : -70, 0.15, (v) => { handle.angle = v }, k.easings.easeInQuad)
|
|
handle.destroy(); head.destroy()
|
|
sfxExplosion()
|
|
// Ground crack effect
|
|
for (let i = 0; i < 6; i++) {
|
|
const crack = k.add([k.rect(2, 15 + Math.random() * 20), k.pos(def.pos.x + (i - 3) * 12, GROUND_Y - 5), k.color(safeColor(k,'#ff6600')), k.opacity(0.8), k.z(4)])
|
|
setTimeout(() => { k.tween(0.8, 0, 0.6, (v) => { if (crack.exists()) crack.opacity = v }).then(() => { if (crack.exists()) crack.destroy() }) }, 400)
|
|
}
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 25 : 14)
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ff6600')
|
|
spawnSparks(def.pos.x, def.pos.y - 20, 18, '#ff6600')
|
|
if (isCritical) screenFlash('#ff6600')
|
|
const push = dir * (isCritical ? 120 : 55)
|
|
k.tween(def.pos.x, origDX + push, 0.3, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.4)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.35, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// LASER BEAM: charge up then fire continuous beam across screen
|
|
async function laserBeam(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
// Charge up (growing ball of energy)
|
|
const chargeX = atk.pos.x + dir * 25
|
|
const chargeY = atk.pos.y - 40
|
|
const charge = k.add([k.circle(3), k.pos(chargeX, chargeY), k.color(safeColor(k,'#ff2d2d')), k.opacity(0.9), k.z(18)])
|
|
await k.tween(3, isCritical ? 18 : 12, 0.3, (v) => { charge.radius = v }, k.easings.easeOutQuad)
|
|
sfxZap()
|
|
// FIRE BEAM (long rect that stretches across)
|
|
charge.destroy()
|
|
const beamLen = Math.abs(def.pos.x - chargeX) + 30
|
|
const beam = k.add([k.rect(beamLen, isCritical ? 12 : 7), k.pos(chargeX, chargeY), k.color(safeColor(k,isCritical ? '#ff2d2d' : '#ff6600')), k.opacity(0.9), k.z(18)])
|
|
// Core beam (brighter, thinner)
|
|
const core = k.add([k.rect(beamLen, isCritical ? 5 : 3), k.pos(chargeX, chargeY + 2), k.color(safeColor(k,'#ffffff')), k.opacity(0.8), k.z(19)])
|
|
k.shake(isCritical ? 12 : 6)
|
|
screenFlash(isCritical ? '#ff2d2d' : '#ff6600', 0.15)
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
sfxCritical()
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 15, '#ff2d2d')
|
|
await k.wait(0.25)
|
|
// Beam fades
|
|
k.tween(0.9, 0, 0.15, (v) => { beam.opacity = v; core.opacity = v * 0.8 }).then(() => { beam.destroy(); core.destroy() })
|
|
const push = dir * (isCritical ? 130 : 60)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
// ROCKET LAUNCHER: fire a big slow rocket that explodes on impact
|
|
async function rocketLauncher(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
await k.wait(0.15)
|
|
// Rocket body
|
|
const rocketX = atk.pos.x + dir * 30
|
|
const rocketY = atk.pos.y - 35
|
|
const rocket = k.add([k.rect(20, 8), k.pos(rocketX, rocketY), k.color(safeColor(k,'#888888')), k.z(17), k.rotate(dir === 1 ? 0 : 180)])
|
|
const nose = k.add([k.rect(6, 6), k.pos(rocketX + dir * 12, rocketY + 1), k.color(safeColor(k,'#ff2d2d')), k.z(17)])
|
|
sfxJetpack()
|
|
// Trail exhaust as rocket flies
|
|
const exhaustInt = setInterval(() => {
|
|
const p = k.add([k.circle(3 + Math.random() * 4), k.pos(rocket.pos.x - dir * 12, rocket.pos.y + (Math.random() - 0.5) * 8), k.color(safeColor(k,Math.random() > 0.5 ? '#ff6600' : '#ffcc00')), k.opacity(0.7), k.z(16)])
|
|
p.onUpdate(() => { p.pos.x -= dir * 100 * k.dt(); p.opacity -= 3 * k.dt(); if (p.opacity <= 0) p.destroy() })
|
|
}, 30)
|
|
// Fly rocket to target
|
|
const dur = 0.3
|
|
await k.tween(0, 1, dur, (t) => { rocket.pos.x = rocketX + (def.pos.x - rocketX) * t; nose.pos.x = rocket.pos.x + dir * 12; rocket.pos.y = rocketY + Math.sin(t * Math.PI * 3) * 8; nose.pos.y = rocket.pos.y + 1 }, k.easings.linear)
|
|
clearInterval(exhaustInt)
|
|
rocket.destroy(); nose.destroy()
|
|
// EXPLOSION!
|
|
sfxExplosion()
|
|
k.shake(isCritical ? 30 : 18)
|
|
screenFlash('#ff6600', 0.2)
|
|
// Explosion rings
|
|
for (let i = 0; i < 3; i++) {
|
|
setTimeout(() => spawnShockwave(def.pos.x, def.pos.y - 20, ['#ff6600', '#ff2d2d', '#ffcc00'][i]), i * 60)
|
|
}
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 25, '#ff6600')
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
const push = dir * (isCritical ? 160 : 80)
|
|
const origDY = def.pos.y
|
|
await Promise.all([
|
|
k.tween(def.pos.x, origDX + push, 0.3, (v) => { def.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(def.pos.y, origDY - (isCritical ? 120 : 60), 0.15, (v) => { def.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(def.pos.y, origDY, 0.2, (v) => { def.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
await k.wait(0.3)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.35, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
// BOMB THROW: lob an arcing bomb that bounces once then detonates
|
|
async function bombThrow(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
atk.play('attack')
|
|
sfxSpecial()
|
|
const bombX = atk.pos.x + dir * 20
|
|
const bombY = atk.pos.y - 50
|
|
const bomb = k.add([k.circle(8), k.pos(bombX, bombY), k.color(safeColor(k,'#333333')), k.z(17)])
|
|
const fuse = k.add([k.rect(2, 8), k.pos(bombX, bombY - 8), k.color(safeColor(k,'#ff6600')), k.z(17)])
|
|
// Arc to opponent
|
|
const midX = (bombX + def.pos.x) / 2
|
|
await k.tween(0, 1, 0.35, (t) => {
|
|
bomb.pos.x = bombX + (def.pos.x - bombX) * t
|
|
bomb.pos.y = bombY + (GROUND_Y - 10 - bombY) * t - Math.sin(t * Math.PI) * 120
|
|
fuse.pos.x = bomb.pos.x; fuse.pos.y = bomb.pos.y - 8
|
|
}, k.easings.linear)
|
|
fuse.destroy()
|
|
// Bounce
|
|
sfxBonk()
|
|
await k.tween(bomb.pos.y, bomb.pos.y - 30, 0.08, (v) => { bomb.pos.y = v }, k.easings.easeOutQuad)
|
|
await k.tween(bomb.pos.y, GROUND_Y - 10, 0.08, (v) => { bomb.pos.y = v }, k.easings.easeInQuad)
|
|
// BOOM
|
|
bomb.destroy()
|
|
sfxExplosion()
|
|
k.shake(isCritical ? 28 : 15)
|
|
screenFlash(isCritical ? '#ff2d2d' : '#ff6600', 0.2)
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ff6600')
|
|
spawnSparks(def.pos.x, def.pos.y - 20, 20, '#ffcc00')
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
const push = dir * (isCritical ? 120 : 55)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.4)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.35, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
// MINIGUN SPRAY: sustained automatic fire with shell casings
|
|
async function minigunSpray(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
atk.play('special')
|
|
// Spawn visible pixel minigun
|
|
const gpx = atk.pos.x + dir * 15
|
|
const gpy = atk.pos.y - 38
|
|
const mgDef = PROPS.minigun
|
|
const mgObjs = spawnWeaponProp('minigun', gpx, gpy, dir < 0, 18)
|
|
await k.wait(0.1)
|
|
sfxSpecial()
|
|
const bulletCount = isCritical ? 16 : 10
|
|
const muzzleX = gpx + dir * 30
|
|
for (let i = 0; i < bulletCount; i++) {
|
|
sfxGunshot()
|
|
// Muzzle flash
|
|
const flash = k.add([k.circle(4 + Math.random() * 4), k.pos(muzzleX, gpy + (Math.random() - 0.5) * 6), k.color(k.Color.fromHex('#ffee00')), k.opacity(0.9), k.z(19), k.anchor('center')])
|
|
setTimeout(() => { if (flash.exists()) flash.destroy() }, 30)
|
|
const spread = (Math.random() - 0.5) * 50
|
|
spawnBullet(muzzleX, gpy, def.pos.x + (Math.random() - 0.5) * 30, def.pos.y - 20 + spread)
|
|
// Shell casing
|
|
const casing = k.add([k.rect(3, 2), k.pos(gpx - dir * 5, gpy - 5), k.color(k.Color.fromHex('#ffd700')), k.opacity(0.8), k.z(16)])
|
|
const casVx = -dir * (100 + Math.random() * 100)
|
|
const casVy = -200 - Math.random() * 100
|
|
casing.onUpdate(() => { casing.pos.x += casVx * k.dt(); casing.pos.y += casVy * k.dt() + 500 * k.dt() * k.dt(); casing.opacity -= 1.5 * k.dt(); if (casing.opacity <= 0) casing.destroy() })
|
|
// Recoil gun + attacker
|
|
if (mgDef) moveProp(mgObjs, mgDef, gpx - dir * 3, gpy, dir < 0)
|
|
atk.pos.x -= dir * 2
|
|
await k.wait(0.01)
|
|
if (mgDef) moveProp(mgObjs, mgDef, gpx, gpy, dir < 0)
|
|
atk.pos.x += dir * 2
|
|
if (i % 2 === 0) { def.opacity = 0.3; await k.wait(0.01); def.opacity = 1 }
|
|
sfxBulletHit()
|
|
await k.wait(0.04)
|
|
}
|
|
destroyProp(mgObjs)
|
|
spawnBulletHoles(def.pos.x, def.pos.y - 30, isCritical ? 8 : 5)
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 18 : 10)
|
|
if (isCritical) { screenFlash('#ffee00'); sfxExplosion() }
|
|
const push = dir * (isCritical ? 120 : 55)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.35)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
// SNIPER SHOT: long pause, laser sight, then one devastating hit
|
|
async function sniperShot(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
// Back up to wall
|
|
const wallX = dir === 1 ? 30 : W - 30
|
|
await k.tween(atk.pos.x, wallX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
atk.play('special')
|
|
// Laser sight line
|
|
const laserY = atk.pos.y - 38
|
|
const laser = k.add([k.rect(Math.abs(def.pos.x - wallX), 1), k.pos(Math.min(wallX, def.pos.x), laserY), k.color(safeColor(k,'#ff0000')), k.opacity(0.5), k.z(15)])
|
|
// Wobble the laser for "aiming"
|
|
for (let i = 0; i < 8; i++) {
|
|
laser.pos.y = laserY + (Math.random() - 0.5) * 15
|
|
await k.wait(0.06)
|
|
}
|
|
laser.pos.y = def.pos.y - 35
|
|
await k.wait(0.15)
|
|
// FIRE
|
|
laser.destroy()
|
|
sfxGunshot()
|
|
sfxCritical()
|
|
screenFlash('#ffffff', 0.1)
|
|
// Tracer (bright line from attacker to defender)
|
|
const tracer = k.add([k.rect(Math.abs(def.pos.x - wallX), 3), k.pos(Math.min(wallX, def.pos.x), def.pos.y - 35), k.color(safeColor(k,'#ffee00')), k.opacity(0.9), k.z(18)])
|
|
k.tween(0.9, 0, 0.1, (v) => { tracer.opacity = v }).then(() => tracer.destroy())
|
|
// Impact
|
|
def.play('knockback')
|
|
k.shake(isCritical ? 22 : 12)
|
|
spawnSparks(def.pos.x, def.pos.y - 35, 18, '#ffee00')
|
|
if (isCritical) { sfxExplosion(); screenFlash('#ff2d2d', 0.15) }
|
|
const push = dir * (isCritical ? 130 : 65)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.4)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.25, (v) => { atk.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(def.pos.x, origDX, 0.35, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// WHIP CRACK: ranged whip attack with crack sound
|
|
async function whipCrack(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
atk.play('attack')
|
|
sfxSpecial()
|
|
await k.wait(0.1)
|
|
// Whip extends from attacker to defender (series of small segments)
|
|
const segments: any[] = []
|
|
const fromX = atk.pos.x + dir * 20
|
|
const fromY = atk.pos.y - 40
|
|
const toX = def.pos.x
|
|
const toY = def.pos.y - 30
|
|
const segCount = 12
|
|
for (let i = 0; i < segCount; i++) {
|
|
const t = i / segCount
|
|
const sx = fromX + (toX - fromX) * t
|
|
const sy = fromY + (toY - fromY) * t + Math.sin(t * Math.PI * 3) * 20
|
|
const seg = k.add([k.rect(6, 3), k.pos(sx, sy), k.color(safeColor(k,'#8B4513')), k.opacity(0), k.z(17)])
|
|
segments.push(seg)
|
|
}
|
|
// Animate whip extending (each segment appears in sequence)
|
|
for (let i = 0; i < segments.length; i++) {
|
|
segments[i].opacity = 0.9
|
|
await k.wait(0.01)
|
|
}
|
|
// CRACK!
|
|
sfxPunch()
|
|
sfxBonk()
|
|
spawnSparks(toX, toY, 10, '#ffcc00')
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 14 : 7)
|
|
if (isCritical) screenFlash('#ffcc00')
|
|
// Whip retracts
|
|
for (let i = segments.length - 1; i >= 0; i--) {
|
|
if (segments[i].exists()) segments[i].destroy()
|
|
await k.wait(0.008)
|
|
}
|
|
const push = dir * (isCritical ? 90 : 40)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
// KATANA COMBO: triple slash with cross patterns
|
|
async function katanaCombo(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
const contactX = origDX - dir * 45
|
|
sfxSpecial()
|
|
await k.tween(atk.pos.x, contactX, 0.08, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
const slashCount = isCritical ? 5 : 3
|
|
for (let i = 0; i < slashCount; i++) {
|
|
atk.play(i % 2 === 0 ? 'attack' : 'kick')
|
|
sfxPunch()
|
|
// Slash trail (diagonal line)
|
|
const angle = [45, -45, 0, 135, -135][i % 5]
|
|
const slash = k.add([k.rect(50, 3), k.pos(def.pos.x, def.pos.y - 30), k.color(safeColor(k,'#aaddff')), k.opacity(0.9), k.z(18), k.rotate(angle), k.anchor('center')])
|
|
k.tween(0.9, 0, 0.15, (v) => { if (slash.exists()) slash.opacity = v }).then(() => { if (slash.exists()) slash.destroy() })
|
|
def.play('hit')
|
|
k.shake(4 + i * 2)
|
|
spawnSparks(def.pos.x + (Math.random() - 0.5) * 30, def.pos.y - 20 - Math.random() * 30, 5, '#aaddff')
|
|
await k.wait(0.1)
|
|
}
|
|
// Final slash — big X mark
|
|
if (isCritical) {
|
|
const s1 = k.add([k.rect(80, 4), k.pos(def.pos.x, def.pos.y - 30), k.color(safeColor(k,'#00f0ff')), k.opacity(0.9), k.z(18), k.rotate(45), k.anchor('center')])
|
|
const s2 = k.add([k.rect(80, 4), k.pos(def.pos.x, def.pos.y - 30), k.color(safeColor(k,'#00f0ff')), k.opacity(0.9), k.z(18), k.rotate(-45), k.anchor('center')])
|
|
sfxCritical()
|
|
screenFlash('#00f0ff')
|
|
k.shake(20)
|
|
await k.wait(0.2)
|
|
k.tween(0.9, 0, 0.3, (v) => { if (s1.exists()) s1.opacity = v; if (s2.exists()) s2.opacity = v }).then(() => { if (s1.exists()) s1.destroy(); if (s2.exists()) s2.destroy() })
|
|
}
|
|
def.play('knockback')
|
|
const push = dir * (isCritical ? 110 : 50)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// CHAINSAW: charge with buzzing chainsaw, multi-hit grind
|
|
async function chainsawRev(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
const contactX = origDX - dir * 35
|
|
atk.play('special')
|
|
// Chainsaw buzzing (visual: vibrating rect)
|
|
const saw = k.add([k.rect(40, 8), k.pos(atk.pos.x + dir * 25, atk.pos.y - 35), k.color(safeColor(k,'#888888')), k.z(18)])
|
|
const blade = k.add([k.rect(35, 3), k.pos(atk.pos.x + dir * 30, atk.pos.y - 32), k.color(safeColor(k,'#ffcc00')), k.z(19)])
|
|
sfxSpecial()
|
|
// Rev up (shake the saw)
|
|
for (let i = 0; i < 8; i++) {
|
|
saw.pos.y += (Math.random() - 0.5) * 4
|
|
blade.pos.y = saw.pos.y + 3
|
|
await k.wait(0.03)
|
|
}
|
|
// Charge forward
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, contactX, 0.15, (v) => { atk.pos.x = v; saw.pos.x = v + dir * 25; blade.pos.x = v + dir * 30 }, k.easings.easeInQuad),
|
|
])
|
|
// GRIND — multi-hit with sparks
|
|
const hits = isCritical ? 6 : 4
|
|
for (let i = 0; i < hits; i++) {
|
|
sfxPunch()
|
|
spawnSparks(def.pos.x - dir * 10, def.pos.y - 20 - Math.random() * 30, 5, '#ffcc00')
|
|
def.play('hit')
|
|
k.shake(3)
|
|
saw.pos.y += (Math.random() - 0.5) * 6
|
|
blade.pos.y = saw.pos.y + 3
|
|
await k.wait(0.05)
|
|
}
|
|
saw.destroy(); blade.destroy()
|
|
if (isCritical) { sfxCritical(); screenFlash('#ff6600') }
|
|
def.play('knockback')
|
|
k.shake(isCritical ? 18 : 10)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 15, '#ff6600')
|
|
const push = dir * (isCritical ? 110 : 50)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.35)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// MOTORBIKE CHARGE: ride a motorbike across the screen and slam into defender
|
|
async function motorbikeCharge(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
// Back up to edge
|
|
const startX = dir === 1 ? -30 : W + 30
|
|
atk.opacity = 0
|
|
atk.pos.x = startX
|
|
// Build the bike: body + wheels
|
|
const bikeY = GROUND_Y - 15
|
|
const bike = k.add([k.rect(50, 18), k.pos(startX, bikeY), k.color(safeColor(k,isCritical ? '#ff2d2d' : '#4488ff')), k.z(16)])
|
|
const wheelF = k.add([k.circle(8), k.pos(startX + dir * 18, bikeY + 12), k.color(safeColor(k,'#333333')), k.z(16)])
|
|
const wheelR = k.add([k.circle(8), k.pos(startX - dir * 16, bikeY + 12), k.color(safeColor(k,'#333333')), k.z(16)])
|
|
sfxJetpack()
|
|
// Tire marks + exhaust as it zooms across
|
|
const exh = setInterval(() => {
|
|
const p = k.add([k.circle(3), k.pos(bike.pos.x - dir * 25, bikeY + 5), k.color(safeColor(k,'#888888')), k.opacity(0.5), k.z(4)])
|
|
p.onUpdate(() => { p.opacity -= 2 * k.dt(); if (p.opacity <= 0) p.destroy() })
|
|
}, 30)
|
|
// ZOOM across screen
|
|
const targetX = origDX + dir * 30
|
|
await k.tween(startX, targetX, 0.3, (v) => {
|
|
bike.pos.x = v; wheelF.pos.x = v + dir * 18; wheelR.pos.x = v - dir * 16
|
|
}, k.easings.easeInQuad)
|
|
clearInterval(exh)
|
|
// IMPACT
|
|
sfxExplosion()
|
|
sfxCritical()
|
|
bike.destroy(); wheelF.destroy(); wheelR.destroy()
|
|
k.shake(isCritical ? 25 : 14)
|
|
screenFlash(isCritical ? '#ff2d2d' : '#4488ff', 0.2)
|
|
spawnSparks(def.pos.x, def.pos.y - 20, 20, '#ff6600')
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ff6600')
|
|
def.play('knockback')
|
|
const push = dir * (isCritical ? 160 : 80)
|
|
const origDY = def.pos.y
|
|
await Promise.all([
|
|
k.tween(def.pos.x, origDX + push, 0.3, (v) => { def.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(def.pos.y, origDY - 100, 0.15, (v) => { def.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(def.pos.y, origDY, 0.2, (v) => { def.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
// Attacker reappears at home
|
|
atk.pos.x = origAX
|
|
atk.opacity = 1
|
|
atk.play('idle')
|
|
await k.wait(0.2)
|
|
await k.tween(def.pos.x, origDX, 0.35, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
// CAR SMASH: drive a car from off-screen, defender gets sent flying
|
|
async function carSmash(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
atk.opacity = 0
|
|
const carY = GROUND_Y - 20
|
|
const startX = dir === 1 ? -60 : W + 60
|
|
// Car body
|
|
const car = k.add([k.rect(70, 25), k.pos(startX, carY), k.color(safeColor(k,isCritical ? '#ffd700' : '#ff6600')), k.z(16)])
|
|
// Roof
|
|
const roof = k.add([k.rect(35, 15), k.pos(startX + dir * 8, carY - 15), k.color(safeColor(k,isCritical ? '#ccaa00' : '#cc5500')), k.z(16)])
|
|
// Wheels
|
|
const w1 = k.add([k.circle(8), k.pos(startX + dir * 22, carY + 18), k.color(safeColor(k,'#222222')), k.z(16)])
|
|
const w2 = k.add([k.circle(8), k.pos(startX - dir * 22, carY + 18), k.color(safeColor(k,'#222222')), k.z(16)])
|
|
// Headlight
|
|
const hl = k.add([k.rect(4, 6), k.pos(startX + dir * 35, carY + 3), k.color(safeColor(k,'#ffee00')), k.z(17)])
|
|
sfxJetpack()
|
|
sfxSpecial()
|
|
// DRIVE ACROSS
|
|
await k.tween(startX, def.pos.x, 0.35, (v) => {
|
|
car.pos.x = v; roof.pos.x = v + dir * 8; w1.pos.x = v + dir * 22; w2.pos.x = v - dir * 22; hl.pos.x = v + dir * 35
|
|
}, k.easings.easeInQuad)
|
|
// HIT!
|
|
car.destroy(); roof.destroy(); w1.destroy(); w2.destroy(); hl.destroy()
|
|
sfxExplosion()
|
|
k.shake(isCritical ? 30 : 18)
|
|
screenFlash('#ff6600', 0.2)
|
|
spawnSparks(def.pos.x, def.pos.y - 20, 25, '#ffcc00')
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ff6600')
|
|
def.play('knockback')
|
|
const push = dir * (isCritical ? 180 : 90)
|
|
const origDY = def.pos.y
|
|
await Promise.all([
|
|
k.tween(def.pos.x, origDX + push, 0.4, (v) => { def.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(def.pos.y, origDY - 150, 0.2, (v) => { def.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(def.pos.y, origDY, 0.25, (v) => { def.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
sfxBoing()
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ffcc00')
|
|
atk.pos.x = origAX
|
|
atk.opacity = 1
|
|
atk.play('idle')
|
|
await k.wait(0.2)
|
|
await k.tween(def.pos.x, origDX, 0.4, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
// BOAT CANNON: a boat slides across the ground and fires cannons
|
|
async function boatCannon(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
// Build boat
|
|
const boatX = atk.pos.x
|
|
const boatY = GROUND_Y - 10
|
|
const hull = k.add([k.rect(60, 20), k.pos(boatX, boatY), k.color(safeColor(k,'#8B4513')), k.z(8)])
|
|
const mast = k.add([k.rect(3, 40), k.pos(boatX + 10, boatY - 40), k.color(safeColor(k,'#8B4513')), k.z(8)])
|
|
const sail = k.add([k.rect(25, 30), k.pos(boatX + 15, boatY - 45), k.color(safeColor(k,'#ffffff')), k.opacity(0.8), k.z(8)])
|
|
// Slide boat forward
|
|
sfxJetpack()
|
|
const moveX = (origAX + origDX) / 2
|
|
await k.tween(boatX, moveX, 0.3, (v) => { hull.pos.x = v; mast.pos.x = v + 10; sail.pos.x = v + 15 }, k.easings.easeOutQuad)
|
|
// Fire cannons!
|
|
const shotCount = isCritical ? 5 : 3
|
|
for (let i = 0; i < shotCount; i++) {
|
|
sfxGunshot()
|
|
// Cannonball
|
|
const ballY = boatY - 5 + (Math.random() - 0.5) * 10
|
|
await spawnProjectile(moveX + dir * 30, ballY, def.pos.x, def.pos.y - 20 + (Math.random() - 0.5) * 30, '#333333', 7)
|
|
sfxBulletHit()
|
|
def.play('hit')
|
|
k.shake(5)
|
|
spawnSparks(def.pos.x, def.pos.y - 20, 5, '#ff6600')
|
|
await k.wait(0.08)
|
|
}
|
|
// Final broadside
|
|
if (isCritical) {
|
|
sfxExplosion()
|
|
screenFlash('#ff6600')
|
|
k.shake(20)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 20, '#ff6600')
|
|
}
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
hull.destroy(); mast.destroy(); sail.destroy()
|
|
const push = dir * (isCritical ? 110 : 50)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.35)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
// ANVIL DROP: classic cartoon — anvil falls from sky onto opponent
|
|
async function anvilDrop(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
await k.wait(0.15)
|
|
// Shadow on ground growing
|
|
const shadow = k.add([k.circle(5), k.pos(def.pos.x, GROUND_Y - 2), k.color(safeColor(k,'#000000')), k.opacity(0.3), k.z(4)])
|
|
k.tween(5, 25, 0.3, (v) => { shadow.radius = v })
|
|
// Anvil falls from sky
|
|
const anvil = k.add([k.rect(35, 25), k.pos(def.pos.x - 17, -30), k.color(safeColor(k,'#555555')), k.opacity(0.9), k.z(18)])
|
|
const base = k.add([k.rect(45, 8), k.pos(def.pos.x - 22, -8), k.color(safeColor(k,'#444444')), k.opacity(0.9), k.z(18)])
|
|
sfxSlideDown()
|
|
await k.tween(-30, def.pos.y - 50, 0.25, (v) => { anvil.pos.y = v; base.pos.y = v + 22 }, k.easings.easeInQuad)
|
|
// BONK!
|
|
sfxBonk()
|
|
sfxExplosion()
|
|
k.shake(isCritical ? 25 : 15)
|
|
screenFlash(isCritical ? '#ffffff' : '#888888', 0.15)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 15, '#888888')
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#888888')
|
|
shadow.destroy()
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
// Anvil bounces
|
|
await k.tween(anvil.pos.y, anvil.pos.y - 40, 0.1, (v) => { anvil.pos.y = v; base.pos.y = v + 22 }, k.easings.easeOutQuad)
|
|
await k.tween(anvil.pos.y, anvil.pos.y + 40, 0.1, (v) => { anvil.pos.y = v; base.pos.y = v + 22 }, k.easings.easeInQuad)
|
|
sfxBonk()
|
|
await k.wait(0.15)
|
|
k.tween(0.9, 0, 0.3, (v) => { anvil.opacity = v; base.opacity = v }).then(() => { anvil.destroy(); base.destroy() })
|
|
const push = dir * (isCritical ? 100 : 45)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
// POCKET CANNON: reach into pocket, pull out comically oversized gun, fire
|
|
async function pocketCannon(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
// "Reach into pocket" — arm down motion
|
|
atk.play('special')
|
|
await k.wait(0.12)
|
|
|
|
// Gun appears — comically oversized
|
|
const gunLen = isCritical ? 90 : 65
|
|
const gunH = isCritical ? 22 : 16
|
|
const gx = atk.pos.x + dir * 20
|
|
const gy = atk.pos.y - 25
|
|
// Barrel
|
|
const barrel = k.add([
|
|
k.rect(gunLen, gunH), k.pos(gx, gy),
|
|
k.color(safeColor(k,'#333333')), k.opacity(1), k.z(16), k.scale(1),
|
|
])
|
|
// Handle
|
|
const handle = k.add([
|
|
k.rect(12, 20), k.pos(gx - dir * 5, gy + gunH / 2),
|
|
k.color(safeColor(k,'#555555')), k.opacity(1), k.z(15), k.scale(1),
|
|
])
|
|
// Scope on top
|
|
const scope = k.add([
|
|
k.circle(5), k.pos(gx + dir * gunLen * 0.6, gy - 6),
|
|
k.color(safeColor(k,'#880000')), k.opacity(0.9), k.z(17), k.scale(1),
|
|
])
|
|
|
|
// Gun grows in from small — comedy "pulling from tiny pocket" effect
|
|
barrel.scale = k.vec2(0.1, 0.1)
|
|
handle.scale = k.vec2(0.1, 0.1)
|
|
scope.scale = k.vec2(0.1, 0.1)
|
|
await Promise.all([
|
|
k.tween(0.1, 1, 0.15, (v) => { barrel.scale = k.vec2(v, v) }, k.easings.easeOutBack),
|
|
k.tween(0.1, 1, 0.15, (v) => { handle.scale = k.vec2(v, v) }, k.easings.easeOutBack),
|
|
k.tween(0.1, 1, 0.15, (v) => { scope.scale = k.vec2(v, v) }, k.easings.easeOutBack),
|
|
])
|
|
sfxBoing()
|
|
k.shake(3)
|
|
await k.wait(0.08)
|
|
|
|
// AIM — brief wobble
|
|
const wobbleTime = 0.12
|
|
await k.tween(0, wobbleTime, wobbleTime, (t) => {
|
|
const w = Math.sin(t * 40) * 3
|
|
barrel.pos.y = gy + w
|
|
handle.pos.y = gy + gunH / 2 + w
|
|
scope.pos.y = gy - 6 + w
|
|
})
|
|
|
|
// FIRE! massive shot
|
|
const shotCount = isCritical ? 4 : 2
|
|
for (let s = 0; s < shotCount; s++) {
|
|
sfxGunshot()
|
|
sfxExplosion()
|
|
k.shake(isCritical ? 15 : 10)
|
|
// Muzzle flash
|
|
const flash = k.add([
|
|
k.circle(12 + Math.random() * 8),
|
|
k.pos(gx + dir * gunLen, gy),
|
|
k.color(safeColor(k,'#ffee00')),
|
|
k.opacity(0.9), k.z(18),
|
|
])
|
|
setTimeout(() => { if (flash.exists()) flash.destroy() }, 60)
|
|
// Recoil
|
|
const recoilX = atk.pos.x - dir * 15
|
|
k.tween(atk.pos.x, recoilX, 0.04, (v) => {
|
|
atk.pos.x = v
|
|
barrel.pos.x = v + dir * 20
|
|
handle.pos.x = v + dir * 20 - dir * 5
|
|
scope.pos.x = v + dir * 20 + dir * gunLen * 0.6
|
|
}).then(() => k.tween(recoilX, origAX, 0.06, (v) => {
|
|
atk.pos.x = v
|
|
barrel.pos.x = v + dir * 20
|
|
handle.pos.x = v + dir * 20 - dir * 5
|
|
scope.pos.x = v + dir * 20 + dir * gunLen * 0.6
|
|
}))
|
|
// Massive projectile
|
|
await spawnProjectile(gx + dir * gunLen, gy, def.pos.x, def.pos.y - 20 + (Math.random() - 0.5) * 20, '#ffcc00', 10)
|
|
sfxBulletHit()
|
|
def.play(s === shotCount - 1 ? 'knockback' : 'hit')
|
|
spawnSparks(def.pos.x, def.pos.y - 20, 10, '#ff6600')
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ff6600')
|
|
def.pos.x += dir * (isCritical ? 20 : 12)
|
|
if (s < shotCount - 1) await k.wait(0.06)
|
|
}
|
|
|
|
// Gun disappears — shrinks back into pocket
|
|
await Promise.all([
|
|
k.tween(1, 0, 0.12, (v) => { barrel.scale = k.vec2(v, v) }),
|
|
k.tween(1, 0, 0.12, (v) => { handle.scale = k.vec2(v, v) }),
|
|
k.tween(1, 0, 0.12, (v) => { scope.scale = k.vec2(v, v) }),
|
|
])
|
|
barrel.destroy(); handle.destroy(); scope.destroy()
|
|
sfxBoing()
|
|
|
|
if (isCritical) screenFlash('#ff6600', 0.15)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
// GRAPPLE FLURRY: both bots close in and trade sustained blows without splitting apart
|
|
async function grappleFlurry(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
// Both rush to center — meet in the middle
|
|
const meetX = (origAX + origDX) / 2
|
|
const atkMeetX = meetX - dir * 25
|
|
const defMeetX = meetX + dir * 25
|
|
sfxSpecial()
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, atkMeetX, 0.12, (v) => { atk.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(def.pos.x, defMeetX, 0.12, (v) => { def.pos.x = v }, k.easings.easeOutQuad),
|
|
])
|
|
|
|
// Sustained trading blows — attacker dominates but defender fights back
|
|
const hitCount = isCritical ? 10 : 7
|
|
for (let i = 0; i < hitCount; i++) {
|
|
const atkHits = i % 3 !== 2 // attacker hits 2/3 of the time
|
|
if (atkHits) {
|
|
atk.play(i % 2 === 0 ? 'attack' : 'kick')
|
|
sfxPunch()
|
|
await k.wait(0.03)
|
|
def.play('hit')
|
|
spawnSparks(def.pos.x - dir * 5, def.pos.y - 25 - Math.random() * 20, 3, i % 2 === 0 ? '#ff2d7b' : '#ffcc00')
|
|
k.shake(2 + Math.floor(i / 2))
|
|
// Push defender slightly but attacker follows
|
|
def.pos.x += dir * 3
|
|
atk.pos.x += dir * 2
|
|
} else {
|
|
// Defender strikes back!
|
|
def.play('attack')
|
|
sfxKick()
|
|
await k.wait(0.03)
|
|
atk.play('hit')
|
|
spawnSparks(atk.pos.x + dir * 5, atk.pos.y - 25 - Math.random() * 20, 3, '#00f0ff')
|
|
k.shake(2)
|
|
atk.pos.x -= dir * 3
|
|
def.pos.x -= dir * 2
|
|
}
|
|
await k.wait(0.05)
|
|
}
|
|
|
|
// Attacker finishes with a shove
|
|
atk.play('special')
|
|
sfxCritical()
|
|
k.shake(isCritical ? 20 : 12)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 12, '#ff2d7b')
|
|
if (isCritical) {
|
|
screenFlash('#ff2d7b', 0.15)
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ff2d7b')
|
|
}
|
|
def.play('knockback')
|
|
const pushDist = dir * (isCritical ? 120 : 60)
|
|
k.tween(def.pos.x, origDX + pushDist * 0.5, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.25)
|
|
|
|
// Both return
|
|
atk.play('idle')
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(def.pos.x, origDX, 0.25, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// BODY SLAM: wrestling-style grab, lift, and slam
|
|
async function bodySlam(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
// Rush in close
|
|
sfxSpecial()
|
|
const contactX = def.pos.x - dir * 30
|
|
await k.tween(atk.pos.x, contactX, 0.1, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
|
|
// Grab — both freeze
|
|
atk.play('special')
|
|
def.play('hit')
|
|
sfxClash()
|
|
k.shake(5)
|
|
await k.wait(0.1)
|
|
|
|
// Lift opponent overhead
|
|
const liftY = atk.pos.y - 80
|
|
sfxBoing()
|
|
await k.tween(def.pos.y, liftY, 0.2, (v) => { def.pos.y = v }, k.easings.easeOutQuad)
|
|
await k.tween(def.pos.x, atk.pos.x + dir * 5, 0.1, (v) => { def.pos.x = v })
|
|
// Spin overhead
|
|
const defOrigY = GROUND_Y
|
|
for (let i = 0; i < (isCritical ? 3 : 2); i++) {
|
|
await k.tween(def.pos.x, atk.pos.x - dir * 20, 0.06, (v) => { def.pos.x = v })
|
|
await k.tween(def.pos.x, atk.pos.x + dir * 20, 0.06, (v) => { def.pos.x = v })
|
|
}
|
|
|
|
// SLAM DOWN
|
|
sfxExplosion()
|
|
def.play('knockback')
|
|
const slamX = atk.pos.x + dir * 50
|
|
await Promise.all([
|
|
k.tween(def.pos.y, defOrigY, 0.08, (v) => { def.pos.y = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, slamX, 0.08, (v) => { def.pos.x = v }),
|
|
])
|
|
sfxCritical()
|
|
k.shake(isCritical ? 25 : 16)
|
|
screenFlash(isCritical ? '#ffffff' : '#ff6600', 0.15)
|
|
spawnSparks(slamX, defOrigY - 10, 18, '#ff6600')
|
|
spawnShockwave(slamX, GROUND_Y, '#ff6600')
|
|
spawnBulletHoles(slamX, GROUND_Y, 3)
|
|
await k.wait(0.2)
|
|
|
|
// Return
|
|
atk.play('idle')
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// PINBALL COMBO: bounce the opponent between walls/edges like a pinball
|
|
async function pinballCombo(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
// Initial launch punch
|
|
atk.play('attack')
|
|
sfxPunch()
|
|
const contactX = def.pos.x - dir * 35
|
|
await k.tween(atk.pos.x, contactX, 0.1, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
def.play('hit')
|
|
k.shake(8)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 8, '#ff2d7b')
|
|
|
|
// Bounce the opponent back and forth across the screen
|
|
const bounces = isCritical ? 5 : 3
|
|
const leftWall = 30
|
|
const rightWall = W - 30
|
|
let defX = def.pos.x
|
|
for (let i = 0; i < bounces; i++) {
|
|
const toWall = i % 2 === (dir > 0 ? 0 : 1) ? rightWall : leftWall
|
|
sfxZoomWhoosh()
|
|
await k.tween(defX, toWall, 0.06, (v) => { def.pos.x = v }, k.easings.easeInQuad)
|
|
defX = toWall
|
|
// Wall hit
|
|
sfxBonk()
|
|
k.shake(6 + i * 2)
|
|
spawnSparks(toWall, def.pos.y - 20, 6, ['#ff2d7b', '#ffcc00', '#00f0ff'][i % 3])
|
|
screenFlash(['#ff2d7b', '#ffcc00', '#00f0ff'][i % 3], 0.05)
|
|
def.play(i % 2 === 0 ? 'hit' : 'knockback')
|
|
await k.wait(0.04)
|
|
}
|
|
|
|
// Final slam to ground
|
|
sfxCritical()
|
|
sfxExplosion()
|
|
k.shake(isCritical ? 22 : 14)
|
|
screenFlash('#ffffff', 0.12)
|
|
spawnSparks(def.pos.x, def.pos.y - 20, 15, '#ffe14d')
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ffe14d')
|
|
def.play('knockback')
|
|
await k.wait(0.2)
|
|
|
|
// Return
|
|
atk.play('idle')
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// SUPLEX: grab from behind, lift, and drive headfirst into ground
|
|
async function suplex(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
// Dash behind defender
|
|
sfxSpecial()
|
|
const behindX = def.pos.x + dir * 30
|
|
await k.tween(atk.pos.x, behindX, 0.1, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
// Flip attacker to face back
|
|
atk.scale.x = -atk.scale.x
|
|
atk.play('special')
|
|
sfxClash()
|
|
k.shake(4)
|
|
await k.wait(0.06)
|
|
|
|
// Grab and arc overhead
|
|
const arcCx = (atk.pos.x + def.pos.x) / 2
|
|
const arcTop = atk.pos.y - 120
|
|
// Both rise in an arc
|
|
const steps = 8
|
|
for (let i = 0; i <= steps; i++) {
|
|
const t = i / steps
|
|
const angle = Math.PI * t
|
|
def.pos.x = arcCx + Math.cos(angle) * 40
|
|
def.pos.y = GROUND_Y - Math.sin(angle) * 120
|
|
atk.pos.x = def.pos.x + dir * 20
|
|
atk.pos.y = def.pos.y + 10
|
|
await k.wait(0.02)
|
|
}
|
|
|
|
// IMPACT — headfirst into ground
|
|
sfxExplosion()
|
|
sfxCritical()
|
|
k.shake(isCritical ? 28 : 18)
|
|
screenFlash(isCritical ? '#ffffff' : '#ff2d2d', 0.2)
|
|
spawnSparks(def.pos.x, GROUND_Y - 10, 20, '#ff2d2d')
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ff2d2d')
|
|
def.play('ko')
|
|
await k.wait(0.15)
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
|
|
// Flip attacker back
|
|
atk.scale.x = -atk.scale.x
|
|
atk.play('idle')
|
|
def.pos.y = GROUND_Y
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// ============================================================
|
|
// PIXEL PROP SYSTEM — draw recognizable objects from shapes
|
|
// ============================================================
|
|
|
|
type PropDef = { parts: { shape: 'rect' | 'circle'; x: number; y: number; w: number; h: number; color: string }[] }
|
|
|
|
const PROPS: Record<string, PropDef> = {
|
|
// Food
|
|
pizza: { parts: [
|
|
{ shape: 'rect', x: -7, y: -3, w: 14, h: 3, color: '#ffcc44' }, // crust
|
|
{ shape: 'rect', x: -6, y: 0, w: 12, h: 8, color: '#ff8800' }, // cheese
|
|
{ shape: 'rect', x: -5, y: 1, w: 10, h: 6, color: '#cc4400' }, // sauce
|
|
{ shape: 'circle', x: -3, y: 3, w: 3, h: 3, color: '#aa2200' }, // pepperoni
|
|
{ shape: 'circle', x: 2, y: 4, w: 3, h: 3, color: '#aa2200' }, // pepperoni
|
|
{ shape: 'circle', x: 0, y: 1, w: 2, h: 2, color: '#44aa22' }, // olive
|
|
]},
|
|
burger: { parts: [
|
|
{ shape: 'rect', x: -8, y: -4, w: 16, h: 4, color: '#cc8833' }, // top bun
|
|
{ shape: 'rect', x: -7, y: 0, w: 14, h: 3, color: '#44aa22' }, // lettuce
|
|
{ shape: 'rect', x: -7, y: 3, w: 14, h: 4, color: '#883311' }, // patty
|
|
{ shape: 'rect', x: -8, y: 7, w: 16, h: 3, color: '#cc8833' }, // bottom bun
|
|
{ shape: 'rect', x: -7, y: -1, w: 14, h: 1, color: '#ffcc00' }, // cheese
|
|
]},
|
|
hotdog: { parts: [
|
|
{ shape: 'rect', x: -10, y: -2, w: 20, h: 4, color: '#ffcc66' }, // bun
|
|
{ shape: 'rect', x: -9, y: -1, w: 18, h: 3, color: '#cc4422' }, // sausage
|
|
{ shape: 'rect', x: -8, y: -2, w: 16, h: 1, color: '#ffee00' }, // mustard
|
|
]},
|
|
banana: { parts: [
|
|
{ shape: 'rect', x: -3, y: -8, w: 5, h: 16, color: '#ffe135' },
|
|
{ shape: 'rect', x: -2, y: -9, w: 3, h: 2, color: '#88660d' }, // stem
|
|
{ shape: 'rect', x: -2, y: -7, w: 3, h: 14, color: '#ffee55' }, // highlight
|
|
]},
|
|
pie: { parts: [
|
|
{ shape: 'circle', x: 0, y: 0, w: 16, h: 16, color: '#f5deb3' }, // crust
|
|
{ shape: 'circle', x: 0, y: 0, w: 12, h: 12, color: '#ffffff' }, // cream
|
|
{ shape: 'circle', x: -2, y: -2, w: 3, h: 3, color: '#ff4444' }, // cherry
|
|
]},
|
|
// Weapons
|
|
gun: { parts: [
|
|
{ shape: 'rect', x: 0, y: -3, w: 24, h: 6, color: '#444444' }, // barrel
|
|
{ shape: 'rect', x: -4, y: -5, w: 12, h: 10, color: '#333333' }, // body
|
|
{ shape: 'rect', x: -2, y: 5, w: 6, h: 10, color: '#553322' }, // grip
|
|
{ shape: 'rect', x: 22, y: -2, w: 4, h: 4, color: '#555555' }, // muzzle
|
|
{ shape: 'rect', x: 6, y: -6, w: 8, h: 3, color: '#555555' }, // sight
|
|
]},
|
|
shotgun: { parts: [
|
|
{ shape: 'rect', x: 0, y: -2, w: 35, h: 5, color: '#333333' }, // barrel
|
|
{ shape: 'rect', x: 0, y: 3, w: 30, h: 4, color: '#333333' }, // under barrel
|
|
{ shape: 'rect', x: -6, y: -4, w: 10, h: 12, color: '#553322' }, // stock
|
|
{ shape: 'rect', x: -2, y: 7, w: 6, h: 8, color: '#664433' }, // grip
|
|
{ shape: 'rect', x: 33, y: -1, w: 4, h: 3, color: '#555555' }, // muzzle
|
|
]},
|
|
rocketLauncher: { parts: [
|
|
{ shape: 'rect', x: 0, y: -5, w: 30, h: 10, color: '#446633' }, // tube
|
|
{ shape: 'circle', x: 28, y: 0, w: 10, h: 10, color: '#335522' }, // end
|
|
{ shape: 'circle', x: 2, y: 0, w: 10, h: 10, color: '#335522' }, // back end
|
|
{ shape: 'rect', x: 8, y: 5, w: 6, h: 8, color: '#553322' }, // grip
|
|
{ shape: 'rect', x: 14, y: -8, w: 6, h: 4, color: '#555555' }, // sight
|
|
]},
|
|
minigun: { parts: [
|
|
{ shape: 'rect', x: 0, y: -6, w: 28, h: 3, color: '#444444' }, // barrel 1
|
|
{ shape: 'rect', x: 0, y: -2, w: 28, h: 3, color: '#555555' }, // barrel 2
|
|
{ shape: 'rect', x: 0, y: 2, w: 28, h: 3, color: '#444444' }, // barrel 3
|
|
{ shape: 'rect', x: -8, y: -8, w: 10, h: 16, color: '#333333' }, // housing
|
|
{ shape: 'rect', x: -4, y: 5, w: 6, h: 10, color: '#553322' }, // grip
|
|
{ shape: 'circle', x: 27, y: -2, w: 8, h: 8, color: '#666666' }, // muzzle ring
|
|
]},
|
|
sniper: { parts: [
|
|
{ shape: 'rect', x: 0, y: -1, w: 38, h: 3, color: '#333333' }, // barrel
|
|
{ shape: 'rect', x: -6, y: -4, w: 14, h: 8, color: '#444444' }, // body
|
|
{ shape: 'rect', x: -10, y: -3, w: 8, h: 4, color: '#553322' }, // stock
|
|
{ shape: 'circle', x: 12, y: -6, w: 6, h: 6, color: '#225588' }, // scope
|
|
{ shape: 'rect', x: 8, y: -7, w: 10, h: 2, color: '#555555' }, // scope mount
|
|
]},
|
|
katana: { parts: [
|
|
{ shape: 'rect', x: 0, y: -1, w: 40, h: 2, color: '#ccccdd' }, // blade
|
|
{ shape: 'rect', x: 38, y: -1, w: 4, h: 2, color: '#ffffff' }, // tip
|
|
{ shape: 'rect', x: -2, y: -3, w: 4, h: 6, color: '#ffcc00' }, // guard
|
|
{ shape: 'rect', x: -10, y: -2, w: 10, h: 4, color: '#442211' }, // handle
|
|
{ shape: 'rect', x: -8, y: -2, w: 2, h: 4, color: '#ddbb88' }, // wrap
|
|
{ shape: 'rect', x: -5, y: -2, w: 2, h: 4, color: '#ddbb88' }, // wrap
|
|
]},
|
|
// Vehicles (used as props in throws/drops)
|
|
car_mini: { parts: [
|
|
{ shape: 'rect', x: -12, y: -4, w: 24, h: 8, color: '#ff4444' }, // body
|
|
{ shape: 'rect', x: -6, y: -8, w: 12, h: 5, color: '#4488ff' }, // roof/windows
|
|
{ shape: 'circle', x: -8, y: 4, w: 6, h: 6, color: '#222222' }, // wheel
|
|
{ shape: 'circle', x: 8, y: 4, w: 6, h: 6, color: '#222222' }, // wheel
|
|
{ shape: 'rect', x: 11, y: -2, w: 3, h: 3, color: '#ffee00' }, // headlight
|
|
]},
|
|
tank_mini: { parts: [
|
|
{ shape: 'rect', x: -14, y: 0, w: 28, h: 8, color: '#556633' }, // hull
|
|
{ shape: 'rect', x: -8, y: -6, w: 16, h: 7, color: '#445522' }, // turret
|
|
{ shape: 'rect', x: 6, y: -5, w: 16, h: 3, color: '#333322' }, // barrel
|
|
{ shape: 'rect', x: -13, y: 7, w: 26, h: 4, color: '#333333' }, // tracks
|
|
{ shape: 'circle', x: -10, y: 9, w: 4, h: 4, color: '#444444' }, // wheel
|
|
{ shape: 'circle', x: 10, y: 9, w: 4, h: 4, color: '#444444' }, // wheel
|
|
]},
|
|
// Misc props
|
|
bomb: { parts: [
|
|
{ shape: 'circle', x: 0, y: 0, w: 14, h: 14, color: '#222222' },
|
|
{ shape: 'rect', x: -1, y: -9, w: 3, h: 5, color: '#888888' }, // fuse
|
|
{ shape: 'circle', x: 0, y: -10, w: 4, h: 4, color: '#ff6600' }, // spark
|
|
]},
|
|
shield: { parts: [
|
|
{ shape: 'rect', x: -10, y: -14, w: 20, h: 28, color: '#4466aa' },
|
|
{ shape: 'rect', x: -8, y: -12, w: 16, h: 24, color: '#5577bb' },
|
|
{ shape: 'rect', x: -3, y: -8, w: 6, h: 16, color: '#ffcc00' }, // emblem cross
|
|
{ shape: 'rect', x: -7, y: -3, w: 14, h: 6, color: '#ffcc00' }, // emblem cross
|
|
{ shape: 'rect', x: -10, y: -14, w: 20, h: 2, color: '#6688cc' }, // top edge
|
|
]},
|
|
soccerball: { parts: [
|
|
{ shape: 'circle', x: 0, y: 0, w: 12, h: 12, color: '#ffffff' },
|
|
{ shape: 'rect', x: -3, y: -3, w: 6, h: 6, color: '#222222' }, // pentagon
|
|
]},
|
|
donut: { parts: [
|
|
{ shape: 'circle', x: 0, y: 0, w: 14, h: 14, color: '#ff88cc' }, // icing
|
|
{ shape: 'circle', x: 0, y: 0, w: 6, h: 6, color: '#cc8833' }, // hole (body color)
|
|
{ shape: 'circle', x: -3, y: -3, w: 2, h: 2, color: '#ff4444' }, // sprinkle
|
|
{ shape: 'circle', x: 3, y: -2, w: 2, h: 2, color: '#44ff44' }, // sprinkle
|
|
{ shape: 'circle', x: 1, y: 4, w: 2, h: 2, color: '#ffff00' }, // sprinkle
|
|
]},
|
|
watermelon: { parts: [
|
|
{ shape: 'circle', x: 0, y: 0, w: 18, h: 18, color: '#33aa33' }, // rind
|
|
{ shape: 'circle', x: 0, y: 0, w: 14, h: 14, color: '#ff4466' }, // flesh
|
|
{ shape: 'circle', x: -2, y: -1, w: 2, h: 2, color: '#222222' }, // seed
|
|
{ shape: 'circle', x: 3, y: 2, w: 2, h: 2, color: '#222222' }, // seed
|
|
{ shape: 'circle', x: 0, y: 4, w: 2, h: 2, color: '#222222' }, // seed
|
|
]},
|
|
chainsaw: { parts: [
|
|
{ shape: 'rect', x: 0, y: -2, w: 28, h: 5, color: '#888888' }, // blade
|
|
{ shape: 'rect', x: -8, y: -5, w: 12, h: 10, color: '#ff6600' }, // body
|
|
{ shape: 'rect', x: -4, y: 5, w: 6, h: 7, color: '#553322' }, // grip
|
|
{ shape: 'rect', x: 26, y: -1, w: 4, h: 3, color: '#aaaaaa' }, // tip
|
|
{ shape: 'rect', x: 0, y: -3, w: 26, h: 1, color: '#666666' }, // chain top
|
|
{ shape: 'rect', x: 0, y: 3, w: 26, h: 1, color: '#666666' }, // chain bottom
|
|
]},
|
|
// Fatality props
|
|
rubber_chicken: { parts: [
|
|
{ shape: 'rect', x: -2, y: -12, w: 5, h: 20, color: '#ffdd44' }, // body
|
|
{ shape: 'circle', x: 0, y: -14, w: 8, h: 8, color: '#ffee55' }, // head
|
|
{ shape: 'rect', x: 2, y: -16, w: 8, h: 3, color: '#ff8800' }, // beak
|
|
{ shape: 'circle', x: -1, y: -15, w: 2, h: 2, color: '#000000' }, // eye
|
|
{ shape: 'rect', x: -1, y: 6, w: 3, h: 5, color: '#ff6600' }, // leg
|
|
]},
|
|
anvil: { parts: [
|
|
{ shape: 'rect', x: -14, y: -4, w: 28, h: 12, color: '#555555' }, // body
|
|
{ shape: 'rect', x: -18, y: 6, w: 36, h: 5, color: '#444444' }, // base
|
|
{ shape: 'rect', x: -10, y: -8, w: 20, h: 5, color: '#666666' }, // top
|
|
{ shape: 'rect', x: 8, y: -12, w: 6, h: 5, color: '#777777' }, // horn
|
|
]},
|
|
flyswatter: { parts: [
|
|
{ shape: 'rect', x: -2, y: 0, w: 4, h: 35, color: '#cc8833' }, // handle
|
|
{ shape: 'rect', x: -12, y: -14, w: 24, h: 16, color: '#44aa44' }, // paddle
|
|
{ shape: 'rect', x: -10, y: -12, w: 20, h: 12, color: '#338833' }, // grid
|
|
]},
|
|
toilet: { parts: [
|
|
{ shape: 'rect', x: -12, y: -4, w: 24, h: 16, color: '#eeeeee' }, // bowl
|
|
{ shape: 'rect', x: -14, y: -14, w: 28, h: 12, color: '#dddddd' }, // tank
|
|
{ shape: 'circle', x: 0, y: 4, w: 16, h: 16, color: '#aaddff' }, // water
|
|
{ shape: 'rect', x: -12, y: -5, w: 24, h: 3, color: '#cccccc' }, // seat
|
|
{ shape: 'rect', x: 8, y: -12, w: 4, h: 6, color: '#888888' }, // handle
|
|
]},
|
|
keyboard: { parts: [
|
|
{ shape: 'rect', x: -20, y: -3, w: 40, h: 8, color: '#333333' }, // base
|
|
{ shape: 'rect', x: -18, y: -2, w: 36, h: 6, color: '#444444' }, // keys area
|
|
{ shape: 'rect', x: -16, y: -1, w: 4, h: 3, color: '#666666' }, // key
|
|
{ shape: 'rect', x: -10, y: -1, w: 4, h: 3, color: '#666666' }, // key
|
|
{ shape: 'rect', x: -4, y: -1, w: 4, h: 3, color: '#666666' }, // key
|
|
{ shape: 'rect', x: 2, y: -1, w: 12, h: 3, color: '#666666' }, // spacebar
|
|
]},
|
|
disco_ball: { parts: [
|
|
{ shape: 'circle', x: 0, y: 0, w: 18, h: 18, color: '#cccccc' }, // ball
|
|
{ shape: 'rect', x: -1, y: -12, w: 2, h: 5, color: '#888888' }, // chain
|
|
{ shape: 'rect', x: -3, y: -2, w: 3, h: 3, color: '#ffffff' }, // mirror
|
|
{ shape: 'rect', x: 2, y: 1, w: 3, h: 3, color: '#eeeeee' }, // mirror
|
|
{ shape: 'rect', x: -1, y: 4, w: 3, h: 3, color: '#ffffff' }, // mirror
|
|
]},
|
|
rubber_duck: { parts: [
|
|
{ shape: 'circle', x: 0, y: 0, w: 10, h: 10, color: '#ffdd00' }, // body
|
|
{ shape: 'circle', x: 3, y: -5, w: 7, h: 7, color: '#ffee22' }, // head
|
|
{ shape: 'rect', x: 5, y: -6, w: 5, h: 2, color: '#ff8800' }, // beak
|
|
{ shape: 'circle', x: 4, y: -6, w: 2, h: 2, color: '#000000' }, // eye
|
|
]},
|
|
baguette: { parts: [
|
|
{ shape: 'rect', x: -16, y: -3, w: 32, h: 6, color: '#cc9944' }, // bread
|
|
{ shape: 'rect', x: -14, y: -2, w: 28, h: 4, color: '#ddaa55' }, // crust highlight
|
|
{ shape: 'rect', x: -8, y: -4, w: 4, h: 1, color: '#bb8833' }, // score
|
|
{ shape: 'rect', x: 2, y: -4, w: 4, h: 1, color: '#bb8833' }, // score
|
|
]},
|
|
boot: { parts: [
|
|
{ shape: 'rect', x: -8, y: -16, w: 14, h: 24, color: '#553322' }, // shaft
|
|
{ shape: 'rect', x: -8, y: 6, w: 22, h: 8, color: '#442211' }, // sole
|
|
{ shape: 'rect', x: -6, y: -14, w: 10, h: 4, color: '#664433' }, // top band
|
|
{ shape: 'rect', x: 12, y: 4, w: 4, h: 6, color: '#442211' }, // toe
|
|
]},
|
|
cannon: { parts: [
|
|
{ shape: 'rect', x: -10, y: -6, w: 28, h: 12, color: '#444444' }, // barrel
|
|
{ shape: 'circle', x: -10, y: 0, w: 14, h: 14, color: '#333333' }, // base
|
|
{ shape: 'circle', x: 16, y: 0, w: 10, h: 10, color: '#555555' }, // muzzle
|
|
{ shape: 'rect', x: -6, y: 6, w: 6, h: 8, color: '#664433' }, // wheel
|
|
]},
|
|
stamp: { parts: [
|
|
{ shape: 'rect', x: -3, y: -18, w: 6, h: 14, color: '#884422' }, // handle
|
|
{ shape: 'rect', x: -14, y: -6, w: 28, h: 8, color: '#cc4444' }, // stamp face
|
|
{ shape: 'rect', x: -12, y: -4, w: 24, h: 4, color: '#aa2222' }, // ink
|
|
]},
|
|
vending_machine: { parts: [
|
|
{ shape: 'rect', x: -12, y: -18, w: 24, h: 36, color: '#cc3333' }, // body
|
|
{ shape: 'rect', x: -10, y: -14, w: 12, h: 20, color: '#222222' }, // window
|
|
{ shape: 'rect', x: 3, y: -8, w: 6, h: 4, color: '#44aa44' }, // button
|
|
{ shape: 'rect', x: 3, y: 0, w: 6, h: 4, color: '#4444aa' }, // button
|
|
{ shape: 'rect', x: -8, y: 10, w: 10, h: 5, color: '#333333' }, // dispenser
|
|
]},
|
|
lawn_mower: { parts: [
|
|
{ shape: 'rect', x: -10, y: -2, w: 20, h: 8, color: '#44aa44' }, // body
|
|
{ shape: 'circle', x: -8, y: 6, w: 6, h: 6, color: '#333333' }, // wheel
|
|
{ shape: 'circle', x: 8, y: 6, w: 6, h: 6, color: '#333333' }, // wheel
|
|
{ shape: 'rect', x: -2, y: -12, w: 3, h: 12, color: '#888888' }, // handle
|
|
{ shape: 'rect', x: -4, y: -14, w: 8, h: 3, color: '#666666' }, // grip
|
|
]},
|
|
}
|
|
|
|
// Spawn a multi-part pixel prop at position, returns array of game objects
|
|
function spawnWeaponProp(propName: string, x: number, y: number, flipX: boolean = false, zIndex: number = 16): any[] {
|
|
const def = PROPS[propName]
|
|
if (!def) {
|
|
// Fallback: single colored circle
|
|
return [k.add([k.circle(8), k.pos(x, y), k.color(k.Color.fromHex('#ff8800')), k.opacity(1), k.z(zIndex), k.anchor('center')])]
|
|
}
|
|
const objs: any[] = []
|
|
for (const p of def.parts) {
|
|
const px = flipX ? x - p.x : x + p.x
|
|
const obj = k.add([
|
|
p.shape === 'circle' ? k.circle(p.w / 2) : k.rect(p.w, p.h),
|
|
k.pos(px, y + p.y),
|
|
k.color(k.Color.fromHex(p.color)),
|
|
k.opacity(1),
|
|
k.z(zIndex),
|
|
k.anchor('center'),
|
|
])
|
|
objs.push(obj)
|
|
}
|
|
return objs
|
|
}
|
|
|
|
// Move all parts of a prop to a new position (relative to anchor)
|
|
function moveProp(objs: any[], def: PropDef, x: number, y: number, flipX: boolean = false) {
|
|
for (let i = 0; i < objs.length && i < def.parts.length; i++) {
|
|
const p = def.parts[i]
|
|
objs[i].pos.x = flipX ? x - p.x : x + p.x
|
|
objs[i].pos.y = y + p.y
|
|
}
|
|
}
|
|
|
|
function destroyProp(objs: any[]) {
|
|
objs.forEach(o => { if (o.exists()) o.destroy() })
|
|
}
|
|
|
|
// Map choreography names to prop types for the factories
|
|
const CHOREO_PROPS: Record<string, string> = {
|
|
pizzaSlam: 'pizza', burgerToss: 'burger', hotdogWhip: 'hotdog', bananaFling: 'banana',
|
|
pieSmash: 'pie', watermelonBomb: 'watermelon', donutBarrage: 'donut',
|
|
sushiBarrage: 'pizza', tacoStorm: 'pizza', iceCreamFling: 'donut',
|
|
bombThrow: 'bomb', grenadeBlast: 'bomb', dynamiteBlast: 'bomb',
|
|
bowlingBallRoll: 'soccerball', soccerKick: 'soccerball', basketballDunk: 'soccerball',
|
|
}
|
|
|
|
// Map choreography names to weapon props the attacker holds
|
|
const CHOREO_WEAPON: Record<string, string> = {
|
|
gunBurst: 'gun', sniperShot: 'sniper', minigunSpray: 'minigun',
|
|
rocketLauncher: 'rocketLauncher', pocketCannon: 'shotgun',
|
|
chainsawRev: 'chainsaw', katanaCombo: 'katana', swordSlash: 'katana',
|
|
}
|
|
|
|
// === PER-CHARACTER WEAPON SYSTEM ===
|
|
// Each bot gets 3 special weapons based on their seed, balanced frequency
|
|
|
|
interface BotWeapons {
|
|
melee: string // close range weapon prop
|
|
ranged: string // gun/launcher prop
|
|
thrown: string // throwable prop
|
|
}
|
|
|
|
const MELEE_WEAPONS = ['katana', 'chainsaw', 'shield']
|
|
const RANGED_WEAPONS = ['gun', 'shotgun', 'sniper', 'minigun', 'rocketLauncher']
|
|
const THROWN_WEAPONS = ['pizza', 'burger', 'bomb', 'watermelon', 'donut', 'soccerball', 'banana']
|
|
|
|
function getBotWeapons(seed: string): BotWeapons {
|
|
let h = 0
|
|
for (let i = 0; i < seed.length; i++) h = ((h << 5) - h + seed.charCodeAt(i)) | 0
|
|
return {
|
|
melee: MELEE_WEAPONS[Math.abs(h) % MELEE_WEAPONS.length],
|
|
ranged: RANGED_WEAPONS[Math.abs(h >> 3) % RANGED_WEAPONS.length],
|
|
thrown: THROWN_WEAPONS[Math.abs(h >> 7) % THROWN_WEAPONS.length],
|
|
}
|
|
}
|
|
|
|
const weaponsA = getBotWeapons(botA.seed)
|
|
const weaponsB = getBotWeapons(botB.seed)
|
|
|
|
// === DEFENSE / SHIELD SYSTEM ===
|
|
|
|
async function playBlock(side: 'a' | 'b') {
|
|
const defender = k.get(side === 'a' ? 'fighterA' : 'fighterB')[0] as Fighter
|
|
if (!defender) return
|
|
const dir = side === 'a' ? 1 : -1
|
|
// Spawn shield in front
|
|
const shieldObjs = spawnWeaponProp('shield', defender.pos.x + dir * 20, defender.pos.y - 25, side === 'b', 19)
|
|
sfxBlock()
|
|
// Flash shield
|
|
shieldObjs.forEach(o => { o.opacity = 0.9 })
|
|
await k.wait(0.15)
|
|
// Impact sparks
|
|
spawnSparks(defender.pos.x + dir * 25, defender.pos.y - 25, 6, '#4488ff')
|
|
k.shake(3)
|
|
await k.wait(0.3)
|
|
// Shield fades
|
|
shieldObjs.forEach(o => {
|
|
k.tween(o.opacity, 0, 0.2, (v: number) => { o.opacity = v }).then(() => { if (o.exists()) o.destroy() })
|
|
})
|
|
await k.wait(0.1)
|
|
}
|
|
|
|
// Spawn attacker's signature weapon as a visual during choreographies
|
|
function getAttackerWeapon(side: 'a' | 'b', type: 'melee' | 'ranged' | 'thrown'): string {
|
|
const weapons = side === 'a' ? weaponsA : weaponsB
|
|
return weapons[type]
|
|
}
|
|
|
|
// ============================================================
|
|
// CHOREOGRAPHY FACTORIES — generate moves from templates
|
|
// ============================================================
|
|
type ChoreoFn = typeof dashPunch
|
|
|
|
// FACTORY 1: Throw object(s) in an arc at the opponent — NOW WITH PIXEL PROPS
|
|
function makeThrow(color: string, size: number, count: number = 1, arc: number = 60, circle: boolean = false, trail?: string): ChoreoFn {
|
|
return async (atk, def, dir, origAX, origDX, isCritical) => {
|
|
atk.play('special'); sfxSpecial(); await k.wait(0.12)
|
|
const total = count + (isCritical ? 2 : 0)
|
|
for (let i = 0; i < total; i++) {
|
|
const fx = atk.pos.x + dir * 25, fy = atk.pos.y - 35
|
|
const tx = def.pos.x + (Math.random() - 0.5) * 30, ty = def.pos.y - 25 + (Math.random() - 0.5) * 20
|
|
|
|
// Try to find a prop for this choreography, fall back to colored shape
|
|
const p = k.add([circle ? k.circle(size / 2) : k.rect(size, size), k.pos(fx, fy), k.color(k.Color.fromHex(color)), k.opacity(1), k.z(16), k.rotate(Math.random() * 360), k.anchor('center')])
|
|
k.tween(0, 1, 0.18, (t) => { p.pos.x = fx + (tx - fx) * t; p.pos.y = fy + (ty - fy) * t - Math.sin(t * Math.PI) * arc; p.angle += 720 * k.dt() }).then(() => { p.destroy(); spawnSparks(tx, ty, 3, trail || color) })
|
|
if (i < total - 1) await k.wait(0.05)
|
|
}
|
|
await k.wait(0.12); sfxBonk()
|
|
def.play(isCritical ? 'knockback' : 'hit'); k.shake(isCritical ? 14 : 6)
|
|
if (isCritical) { screenFlash(color); sfxCritical() }
|
|
spawnSparks(def.pos.x, def.pos.y - 25, isCritical ? 14 : 7, color)
|
|
const push = dir * (isCritical ? 85 : 38)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3); atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
}
|
|
|
|
// FACTORY 1b: Throw with detailed pixel prop
|
|
function makeThrowProp(propName: string, count: number = 1, arc: number = 60, trail: string = '#ffcc00'): ChoreoFn {
|
|
return async (atk, def, dir, origAX, origDX, isCritical) => {
|
|
atk.play('special'); sfxSpecial(); await k.wait(0.12)
|
|
const total = count + (isCritical ? 2 : 0)
|
|
const propDef = PROPS[propName]
|
|
for (let i = 0; i < total; i++) {
|
|
const fx = atk.pos.x + dir * 25, fy = atk.pos.y - 35
|
|
const tx = def.pos.x + (Math.random() - 0.5) * 30, ty = def.pos.y - 25 + (Math.random() - 0.5) * 20
|
|
const objs = spawnWeaponProp(propName, fx, fy, dir < 0)
|
|
k.tween(0, 1, 0.2, (t) => {
|
|
const cx = fx + (tx - fx) * t
|
|
const cy = fy + (ty - fy) * t - Math.sin(t * Math.PI) * arc
|
|
if (propDef) moveProp(objs, propDef, cx, cy, dir < 0)
|
|
else if (objs[0]) { objs[0].pos.x = cx; objs[0].pos.y = cy }
|
|
}).then(() => { destroyProp(objs); spawnSparks(tx, ty, 5, trail) })
|
|
if (i < total - 1) await k.wait(0.06)
|
|
}
|
|
await k.wait(0.15); sfxBonk()
|
|
def.play(isCritical ? 'knockback' : 'hit'); k.shake(isCritical ? 14 : 6)
|
|
if (isCritical) { screenFlash(trail); sfxCritical() }
|
|
spawnSparks(def.pos.x, def.pos.y - 25, isCritical ? 14 : 7, trail)
|
|
const push = dir * (isCritical ? 85 : 38)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3); atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
}
|
|
|
|
// FACTORY 1c: Ranged attack with visible pixel gun prop
|
|
function makeGunProp(propName: string, bulletCount: number = 4, bulletColor: string = '#ffee00'): ChoreoFn {
|
|
return async (atk, def, dir, origAX, origDX, isCritical) => {
|
|
atk.play('special'); sfxSpecial()
|
|
// Spawn gun prop on attacker
|
|
const gx = atk.pos.x + dir * 15, gy = atk.pos.y - 35
|
|
const gunObjs = spawnWeaponProp(propName, gx, gy, dir < 0, 18)
|
|
const gunDef = PROPS[propName]
|
|
await k.wait(0.15)
|
|
// Fire bullets
|
|
const total = bulletCount + (isCritical ? 3 : 0)
|
|
for (let i = 0; i < total; i++) {
|
|
sfxGunshot()
|
|
// Muzzle flash
|
|
const mfx = gx + dir * 30, mfy = gy
|
|
const flash = k.add([k.circle(5 + Math.random() * 4), k.pos(mfx, mfy), k.color(k.Color.fromHex(bulletColor)), k.opacity(0.9), k.z(19), k.anchor('center')])
|
|
setTimeout(() => { if (flash.exists()) flash.destroy() }, 40)
|
|
// Bullet trail
|
|
const targetY = def.pos.y - 20 - Math.random() * 30
|
|
await spawnProjectile(mfx, mfy, def.pos.x, targetY, bulletColor, 4)
|
|
sfxBulletHit()
|
|
spawnSparks(def.pos.x + (Math.random() - 0.5) * 20, targetY, 3, bulletColor)
|
|
// Recoil — bounce gun
|
|
if (gunDef) {
|
|
const rx = gx - dir * 4
|
|
moveProp(gunObjs, gunDef, rx, gy, dir < 0)
|
|
await k.wait(0.02)
|
|
moveProp(gunObjs, gunDef, gx, gy, dir < 0)
|
|
}
|
|
def.opacity = 0.5; await k.wait(0.03); def.opacity = 1
|
|
}
|
|
spawnBulletHoles(def.pos.x, def.pos.y - 30, isCritical ? 5 : 3)
|
|
def.play(isCritical ? 'knockback' : 'hit'); k.shake(isCritical ? 16 : 8)
|
|
if (isCritical) { screenFlash(bulletColor); sfxCritical(); sfxExplosion() }
|
|
// Remove gun
|
|
destroyProp(gunObjs)
|
|
const push = dir * (isCritical ? 100 : 45)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.35); atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
}
|
|
|
|
// FACTORY 2: Swing weapon — run up, swing rect, hit
|
|
function makeSwing(weaponW: number, weaponH: number, weaponColor: string, headColor?: string, headW?: number, headH?: number): ChoreoFn {
|
|
return async (atk, def, dir, origAX, origDX, isCritical) => {
|
|
const cx = origDX - dir * 55
|
|
await k.tween(atk.pos.x, cx, 0.14, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
const wx = atk.pos.x + dir * 18, wy = atk.pos.y - 55
|
|
const shaft = k.add([k.rect(weaponW, weaponH), k.pos(wx, wy), k.color(safeColor(k,weaponColor)), k.anchor('bot'), k.z(18), k.rotate(dir === 1 ? -40 : 40)])
|
|
let head: any = null
|
|
if (headColor) { head = k.add([k.rect(headW || 18, headH || 14), k.pos(wx + dir * 10, wy - weaponH + 5), k.color(safeColor(k,headColor)), k.z(18)]) }
|
|
atk.play('attack'); sfxSpecial()
|
|
await k.tween(dir === 1 ? -40 : 40, dir === 1 ? 85 : -85, 0.13, (v) => { shaft.angle = v }, k.easings.easeInQuad)
|
|
sfxBonk(); shaft.destroy(); if (head) head.destroy()
|
|
def.play(isCritical ? 'knockback' : 'hit'); k.shake(isCritical ? 18 : 9)
|
|
if (isCritical) { screenFlash(weaponColor); sfxCritical() }
|
|
spawnSparks(def.pos.x, def.pos.y - 25, isCritical ? 14 : 7, headColor || weaponColor)
|
|
const push = dir * (isCritical ? 100 : 48)
|
|
k.tween(def.pos.x, origDX + push, 0.22, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
}
|
|
|
|
// FACTORY 3: Drop something from the sky onto opponent
|
|
function makeDrop(w: number, h: number, color: string, bounceColor?: string, circle: boolean = false): ChoreoFn {
|
|
return async (atk, def, dir, origAX, origDX, isCritical) => {
|
|
atk.play('special'); sfxSpecial(); await k.wait(0.12)
|
|
const shadow = k.add([k.circle(5), k.pos(def.pos.x, GROUND_Y - 2), k.color(safeColor(k,'#000000')), k.opacity(0.3), k.z(4)])
|
|
k.tween(5, w * 0.7, 0.25, (v) => { shadow.radius = v })
|
|
const obj = k.add([circle ? k.circle(w / 2) : k.rect(w, h), k.pos(def.pos.x - (circle ? 0 : w / 2), -h - 10), k.color(safeColor(k,color)), k.opacity(0.9), k.z(18)])
|
|
sfxSlideDown()
|
|
await k.tween(-h - 10, def.pos.y - 45, 0.22, (v) => { obj.pos.y = v }, k.easings.easeInQuad)
|
|
sfxBonk(); sfxExplosion()
|
|
k.shake(isCritical ? 22 : 13); screenFlash(isCritical ? '#ffffff' : (bounceColor || color), 0.15)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 14, bounceColor || color)
|
|
spawnShockwave(def.pos.x, GROUND_Y, bounceColor || color)
|
|
shadow.destroy(); def.play(isCritical ? 'knockback' : 'hit')
|
|
await k.tween(obj.pos.y, obj.pos.y - 35, 0.08, (v) => { obj.pos.y = v }, k.easings.easeOutQuad)
|
|
await k.tween(obj.pos.y, obj.pos.y + 35, 0.08, (v) => { obj.pos.y = v }, k.easings.easeInQuad)
|
|
sfxBonk(); await k.wait(0.1)
|
|
k.tween(0.9, 0, 0.25, (v) => { obj.opacity = v }).then(() => obj.destroy())
|
|
const push = dir * (isCritical ? 95 : 42)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.25); atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
}
|
|
|
|
// FACTORY 4: Vehicle drives across screen (like motorbikeCharge/carSmash)
|
|
function makeVehicle(bodyW: number, bodyH: number, bodyColor: string, wheelR: number = 8, parts?: { w: number, h: number, color: string, ox: number, oy: number }[]): ChoreoFn {
|
|
return async (atk, def, dir, origAX, origDX, isCritical) => {
|
|
const startX = dir === 1 ? -bodyW - 20 : W + bodyW + 20
|
|
atk.opacity = 0; atk.pos.x = startX
|
|
const vY = GROUND_Y - bodyH / 2 - wheelR
|
|
const body = k.add([k.rect(bodyW, bodyH), k.pos(startX, vY), k.color(safeColor(k,isCritical ? '#ff2d2d' : bodyColor)), k.z(16)])
|
|
const w1 = k.add([k.circle(wheelR), k.pos(startX + dir * (bodyW / 3), vY + bodyH / 2 + wheelR - 2), k.color(safeColor(k,'#222222')), k.z(16)])
|
|
const w2 = k.add([k.circle(wheelR), k.pos(startX - dir * (bodyW / 3), vY + bodyH / 2 + wheelR - 2), k.color(safeColor(k,'#222222')), k.z(16)])
|
|
const extras: any[] = []
|
|
if (parts) for (const p of parts) {
|
|
extras.push(k.add([k.rect(p.w, p.h), k.pos(startX + p.ox * dir, vY + p.oy), k.color(safeColor(k,p.color)), k.z(17)]))
|
|
}
|
|
sfxJetpack()
|
|
const exh = setInterval(() => {
|
|
const ep = k.add([k.circle(3), k.pos(body.pos.x - dir * bodyW / 2, vY + 5), k.color(safeColor(k,'#888888')), k.opacity(0.5), k.z(4)])
|
|
ep.onUpdate(() => { ep.opacity -= 2 * k.dt(); if (ep.opacity <= 0) ep.destroy() })
|
|
}, 30)
|
|
const tgt = origDX + dir * 20
|
|
await k.tween(startX, tgt, 0.32, (v) => {
|
|
body.pos.x = v; w1.pos.x = v + dir * (bodyW / 3); w2.pos.x = v - dir * (bodyW / 3)
|
|
extras.forEach((e, i) => { if (parts) e.pos.x = v + parts[i].ox * dir })
|
|
}, k.easings.easeInQuad)
|
|
clearInterval(exh)
|
|
sfxExplosion(); sfxCritical()
|
|
body.destroy(); w1.destroy(); w2.destroy(); extras.forEach(e => e.destroy())
|
|
k.shake(isCritical ? 25 : 14); screenFlash(isCritical ? '#ff2d2d' : bodyColor, 0.18)
|
|
spawnSparks(def.pos.x, def.pos.y - 20, 18, '#ff6600'); spawnShockwave(def.pos.x, GROUND_Y, '#ff6600')
|
|
def.play('knockback')
|
|
const push = dir * (isCritical ? 150 : 70)
|
|
const origDY = def.pos.y
|
|
await Promise.all([
|
|
k.tween(def.pos.x, origDX + push, 0.3, (v) => { def.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(def.pos.y, origDY - 90, 0.14, (v) => { def.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(def.pos.y, origDY, 0.18, (v) => { def.pos.y = v }, k.easings.easeInQuad))
|
|
])
|
|
atk.pos.x = origAX; atk.opacity = 1; atk.play('idle')
|
|
await k.wait(0.15)
|
|
await k.tween(def.pos.x, origDX, 0.35, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
}
|
|
|
|
// FACTORY 5: Beam/ray attack — attacker fires continuous beam
|
|
function makeBeam(color: string, width: number = 6, pulses: number = 1): ChoreoFn {
|
|
return async (atk, def, dir, origAX, origDX, isCritical) => {
|
|
atk.play('special'); sfxSpecial()
|
|
// Charge up
|
|
const chargeOrb = k.add([k.circle(3), k.pos(atk.pos.x + dir * 30, atk.pos.y - 35), k.color(safeColor(k,color)), k.opacity(0.8), k.z(18)])
|
|
await k.tween(3, 12 + (isCritical ? 5 : 0), 0.2, (v) => { chargeOrb.radius = v }, k.easings.easeOutQuad)
|
|
chargeOrb.destroy()
|
|
// Fire beam
|
|
const total = pulses + (isCritical ? 1 : 0)
|
|
for (let p = 0; p < total; p++) {
|
|
sfxZap()
|
|
const bx = atk.pos.x + dir * 30, by = atk.pos.y - 35
|
|
const beamLen = Math.abs(def.pos.x - atk.pos.x) + 30
|
|
const beam = k.add([k.rect(beamLen, width + (isCritical ? 4 : 0)), k.pos(bx, by - width / 2), k.color(safeColor(k,color)), k.opacity(0.9), k.z(17)])
|
|
const glow = k.add([k.rect(beamLen, width * 2.5), k.pos(bx, by - width * 1.25), k.color(safeColor(k,color)), k.opacity(0.25), k.z(16)])
|
|
if (dir === -1) { beam.pos.x = bx - beamLen; glow.pos.x = bx - beamLen }
|
|
await k.wait(0.08)
|
|
def.play('hit'); k.shake(isCritical ? 12 : 5)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 8, color)
|
|
await k.wait(0.08)
|
|
k.tween(0.9, 0, 0.12, (v) => { beam.opacity = v; glow.opacity = v * 0.3 }).then(() => { beam.destroy(); glow.destroy() })
|
|
if (p < total - 1) await k.wait(0.06)
|
|
}
|
|
if (isCritical) { screenFlash(color); sfxCritical() }
|
|
def.play(isCritical ? 'knockback' : 'hit'); k.shake(isCritical ? 16 : 7)
|
|
const push = dir * (isCritical ? 100 : 45)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3); atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
}
|
|
|
|
// FACTORY 6: Spin/flip — attacker does acrobatic motion then strikes
|
|
function makeSpin(spinType: 'horizontal' | 'vertical' | 'corkscrew', height: number = 120, hits: number = 1): ChoreoFn {
|
|
return async (atk, def, dir, origAX, origDX, isCritical) => {
|
|
const origAY = atk.pos.y
|
|
const cx = origDX - dir * 35
|
|
atk.play('kick'); sfxKick()
|
|
if (spinType === 'vertical') {
|
|
// Frontflip / backflip — jump up, arc to opponent
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, cx, 0.25, (v) => { atk.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(origAY, origAY - height, 0.12, (v) => { atk.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(origAY - height, origAY, 0.13, (v) => { atk.pos.y = v }, k.easings.easeInQuad)),
|
|
k.tween(0, 360 * (isCritical ? 2 : 1), 0.25, (v) => { atk.angle = v }).then(() => { atk.angle = 0 }),
|
|
])
|
|
} else if (spinType === 'corkscrew') {
|
|
// Corkscrew — spiral path
|
|
await k.tween(0, 1, 0.28, (t) => {
|
|
atk.pos.x = origAX + (cx - origAX) * t
|
|
atk.pos.y = origAY - Math.sin(t * Math.PI * 3) * height * 0.4
|
|
atk.angle = t * 720
|
|
}, k.easings.easeInOutQuad)
|
|
atk.angle = 0
|
|
} else {
|
|
// Horizontal tornado spin
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, cx, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(0, 720 * (isCritical ? 1.5 : 1), 0.2, (v) => { atk.angle = v }).then(() => { atk.angle = 0 }),
|
|
])
|
|
}
|
|
// Hit(s)
|
|
const hc = hits + (isCritical ? 1 : 0)
|
|
for (let i = 0; i < hc; i++) {
|
|
sfxPunch(); def.play('hit'); k.shake(4 + i * 2)
|
|
spawnSparks(def.pos.x + (Math.random() - 0.5) * 20, def.pos.y - 25, 5, theme.accent)
|
|
def.pos.x += dir * 10
|
|
if (i < hc - 1) await k.wait(0.06)
|
|
}
|
|
if (isCritical) { screenFlash(theme.accent); sfxCritical() }
|
|
def.play(isCritical ? 'knockback' : 'hit'); k.shake(isCritical ? 16 : 8)
|
|
const push = dir * (isCritical ? 100 : 45)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3); atk.play('idle')
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
}
|
|
|
|
// FACTORY 7: Summon/swarm — creatures fly from behind attacker toward defender
|
|
function makeSwarm(color: string, count: number, size: number, speed: number = 400, zigzag: boolean = false): ChoreoFn {
|
|
return async (atk, def, dir, origAX, origDX, isCritical) => {
|
|
atk.play('special'); sfxSpecial(); await k.wait(0.15)
|
|
const total = count + (isCritical ? 3 : 0)
|
|
const swarmThings: any[] = []
|
|
for (let i = 0; i < total; i++) {
|
|
const sx = atk.pos.x - dir * 20 + (Math.random() - 0.5) * 30
|
|
const sy = atk.pos.y - 40 + (Math.random() - 0.5) * 50
|
|
const p = k.add([k.circle(size / 2 + Math.random() * 2), k.pos(sx, sy), k.color(safeColor(k,color)), k.opacity(0.9), k.z(16)])
|
|
const tx = def.pos.x + (Math.random() - 0.5) * 25, ty = def.pos.y - 30 + (Math.random() - 0.5) * 30
|
|
swarmThings.push(p)
|
|
k.tween(0, 1, (Math.abs(tx - sx) / speed) + Math.random() * 0.1, (t) => {
|
|
p.pos.x = sx + (tx - sx) * t
|
|
p.pos.y = sy + (ty - sy) * t + (zigzag ? Math.sin(t * Math.PI * 6) * 15 : 0)
|
|
}).then(() => { p.destroy(); spawnSparks(tx, ty, 2, color) })
|
|
await k.wait(0.03)
|
|
}
|
|
await k.wait(0.2)
|
|
sfxBonk(); def.play(isCritical ? 'knockback' : 'hit'); k.shake(isCritical ? 16 : 8)
|
|
if (isCritical) { screenFlash(color); sfxCritical() }
|
|
spawnSparks(def.pos.x, def.pos.y - 25, 10, color)
|
|
const push = dir * (isCritical ? 90 : 40)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3); atk.play('idle')
|
|
swarmThings.forEach(s => { if (s.exists()) s.destroy() })
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
}
|
|
|
|
// FACTORY 8: Explosion — thing appears near opponent and explodes
|
|
function makeExplosion(objW: number, objH: number, objColor: string, fuseTime: number = 0.3, blastColor: string = '#ff6600', circle: boolean = false): ChoreoFn {
|
|
return async (atk, def, dir, origAX, origDX, isCritical) => {
|
|
atk.play('special'); sfxSpecial()
|
|
// Throw the thing
|
|
const fromX = atk.pos.x + dir * 25, fromY = atk.pos.y - 35
|
|
const toX = def.pos.x, toY = def.pos.y - 20
|
|
const obj = k.add([circle ? k.circle(objW / 2) : k.rect(objW, objH), k.pos(fromX, fromY), k.color(safeColor(k,objColor)), k.opacity(1), k.z(16), k.rotate(0)])
|
|
await k.tween(0, 1, 0.2, (t) => {
|
|
obj.pos.x = fromX + (toX - fromX) * t
|
|
obj.pos.y = fromY + (toY - fromY) * t - Math.sin(t * Math.PI) * 80
|
|
obj.angle = t * 360
|
|
})
|
|
obj.angle = 0
|
|
// Fuse / flash
|
|
for (let i = 0; i < 3; i++) {
|
|
obj.opacity = 0.4; await k.wait(fuseTime / 6); obj.opacity = 1; await k.wait(fuseTime / 6)
|
|
}
|
|
// BOOM
|
|
obj.destroy(); sfxExplosion()
|
|
const blastR = isCritical ? 45 : 28
|
|
const blast = k.add([k.circle(blastR), k.pos(toX, toY), k.color(safeColor(k,blastColor)), k.opacity(0.8), k.z(19)])
|
|
k.tween(blastR, blastR * 2.5, 0.15, (v) => { blast.radius = v })
|
|
k.tween(0.8, 0, 0.2, (v) => { blast.opacity = v }).then(() => blast.destroy())
|
|
k.shake(isCritical ? 25 : 14); screenFlash(blastColor, 0.15)
|
|
spawnSparks(toX, toY, isCritical ? 25 : 12, blastColor); spawnShockwave(toX, GROUND_Y, blastColor)
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
if (isCritical) sfxCritical()
|
|
const push = dir * (isCritical ? 120 : 55)
|
|
const origDY = def.pos.y
|
|
await Promise.all([
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(origDY, origDY - 60, 0.12, (v) => { def.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(origDY - 60, origDY, 0.15, (v) => { def.pos.y = v }, k.easings.easeInQuad))
|
|
])
|
|
await k.wait(0.15); atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
}
|
|
|
|
// FACTORY 9: Grab/wrestling — run up, grab, slam
|
|
function makeGrab(slamType: 'up' | 'down' | 'spin' | 'toss', height: number = 150): ChoreoFn {
|
|
return async (atk, def, dir, origAX, origDX, isCritical) => {
|
|
const cx = origDX - dir * 30
|
|
await k.tween(atk.pos.x, cx, 0.12, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
atk.play('attack'); sfxPunch(); await k.wait(0.08)
|
|
// Grab
|
|
def.play('hit'); sfxSpecial()
|
|
const origDY = def.pos.y
|
|
if (slamType === 'up') {
|
|
// Lift and slam down
|
|
await k.tween(origDY, origDY - height, 0.2, (v) => { def.pos.y = v; atk.pos.y = v + 20 }, k.easings.easeOutQuad)
|
|
await k.wait(0.1)
|
|
await k.tween(origDY - height, origDY, 0.15, (v) => { def.pos.y = v; atk.pos.y = GROUND_Y }, k.easings.easeInQuad)
|
|
sfxExplosion(); k.shake(isCritical ? 22 : 12); spawnShockwave(def.pos.x, GROUND_Y, theme.accent)
|
|
} else if (slamType === 'down') {
|
|
// Piledriver — both go up, come down head first
|
|
await Promise.all([
|
|
k.tween(origDY, origDY - height, 0.2, (v) => { def.pos.y = v }, k.easings.easeOutQuad),
|
|
k.tween(atk.pos.y, atk.pos.y - height, 0.2, (v) => { atk.pos.y = v }, k.easings.easeOutQuad),
|
|
])
|
|
await k.wait(0.1)
|
|
def.angle = 180
|
|
await Promise.all([
|
|
k.tween(origDY - height, origDY, 0.13, (v) => { def.pos.y = v }, k.easings.easeInQuad),
|
|
k.tween(atk.pos.y, GROUND_Y, 0.13, (v) => { atk.pos.y = v }, k.easings.easeInQuad),
|
|
])
|
|
def.angle = 0; sfxExplosion(); k.shake(isCritical ? 28 : 16); spawnShockwave(def.pos.x, GROUND_Y, '#ff2d2d')
|
|
} else if (slamType === 'spin') {
|
|
// Spin throw
|
|
await k.tween(0, 1, 0.35, (t) => {
|
|
def.pos.y = origDY - Math.sin(t * Math.PI) * height * 0.5
|
|
def.angle = t * 720
|
|
def.pos.x += dir * 2
|
|
})
|
|
def.angle = 0; sfxBonk(); k.shake(isCritical ? 20 : 10)
|
|
} else {
|
|
// Toss across screen
|
|
const tossX = origDX + dir * (isCritical ? 200 : 120)
|
|
await Promise.all([
|
|
k.tween(def.pos.x, tossX, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(origDY, origDY - height, 0.12, (v) => { def.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(origDY - height, origDY, 0.13, (v) => { def.pos.y = v }, k.easings.easeInQuad)),
|
|
])
|
|
sfxBonk(); k.shake(isCritical ? 18 : 9); spawnShockwave(def.pos.x, GROUND_Y, theme.accent)
|
|
}
|
|
if (isCritical) { screenFlash(theme.accent); sfxCritical() }
|
|
spawnSparks(def.pos.x, def.pos.y - 25, isCritical ? 18 : 8, theme.accent)
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
await k.wait(0.3); atk.play('idle')
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(atk.pos.y, GROUND_Y, 0.15, (v) => { atk.pos.y = v }, k.easings.easeOutQuad),
|
|
k.tween(def.pos.x, origDX, 0.35, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
}
|
|
|
|
// ============================================================
|
|
// GENERATED CHOREOGRAPHIES — 258 new moves from factories
|
|
// ============================================================
|
|
|
|
// --- FOOD THROWS (30) — key items use detailed pixel props ---
|
|
const pizzaSlam = makeThrowProp('pizza', 2, 70, '#ffcc00')
|
|
const bananaFling = makeThrowProp('banana', 3, 55, '#ffff00')
|
|
const pieSmash = makeThrowProp('pie', 1, 80, '#ffffff')
|
|
const hotdogWhip = makeThrowProp('hotdog', 2, 45, '#ff6644')
|
|
const watermelonBomb = makeThrowProp('watermelon', 1, 90, '#ff4466')
|
|
const sushiBarrage = makeThrow('#ffffff', 10, 5, 40, false, '#ff6666')
|
|
const burgerToss = makeThrowProp('burger', 2, 65, '#ffaa00')
|
|
const iceCreamFling = makeThrow('#ffccdd', 12, 3, 50, true, '#ff88bb')
|
|
const tacoStorm = makeThrow('#ffcc44', 11, 4, 55, false, '#ff8800')
|
|
const donutBarrage = makeThrowProp('donut', 3, 60, '#ffaadd')
|
|
const popcornBlast = makeThrow('#ffffcc', 6, 12, 35, true, '#ffee88')
|
|
const cookieFling = makeThrow('#cc9944', 12, 3, 50, true, '#aa7722')
|
|
const eggBombard = makeThrow('#ffffdd', 10, 4, 65, true, '#ffee44')
|
|
const baguetteStrike = makeSwing(6, 55, '#dda855', '#cc9944', 10, 8)
|
|
const coffeeSplash = makeThrow('#443322', 10, 3, 45, true, '#886644')
|
|
const ramenWhip = makeThrow('#ffee88', 8, 6, 35, false, '#ffffff')
|
|
const nachoVolley = makeThrow('#ffcc22', 8, 8, 40, false, '#ff8800')
|
|
const pretzelFling = makeThrow('#aa7733', 14, 2, 60, false, '#cc9955')
|
|
const meatballStorm = makeThrow('#883322', 12, 5, 55, true, '#aa4433')
|
|
const popsicleJab = makeSwing(5, 45, '#ff66aa', '#ffffff', 12, 10)
|
|
const candyBarrage = makeThrow('#ff44ff', 8, 7, 40, true, '#ffaaff')
|
|
const waffleSlam = makeThrow('#dda844', 16, 2, 70, false, '#ffcc66')
|
|
const pancakeFrisbee = makeThrow('#eebb55', 14, 3, 30, true, '#ffdd88')
|
|
const drumstickSmack = makeSwing(7, 40, '#cc8844', '#aa6633', 14, 12)
|
|
const cornCobCannon = makeThrow('#ffee44', 10, 4, 50, false, '#44aa22')
|
|
const pickleJavelin = makeThrow('#669933', 8, 3, 45, false, '#88bb44')
|
|
const cabbagePunt = makeThrow('#44aa33', 18, 1, 85, true, '#66cc44')
|
|
const breadLoafBash = makeSwing(10, 35, '#dda855')
|
|
const cheeseWheel = makeThrow('#ffcc00', 20, 1, 80, true, '#ffee44')
|
|
const fishSlap = makeSwing(8, 40, '#8899aa', '#667788', 15, 8)
|
|
|
|
// --- WEAPON SWINGS (20) ---
|
|
const baseballBat = makeSwing(6, 55, '#aa7744', '#996633', 16, 10)
|
|
const fryingPan = makeSwing(5, 40, '#333333', '#444444', 22, 4)
|
|
const rollingPin = makeSwing(8, 45, '#dda855')
|
|
const umbrellaWhack = makeSwing(5, 55, '#222222', '#ff4444', 30, 3)
|
|
const mopSwipe = makeSwing(4, 60, '#aa9977', '#dddddd', 14, 12)
|
|
const broomStrike = makeSwing(4, 58, '#886633', '#558833', 12, 10)
|
|
const wrenchSmash = makeSwing(6, 38, '#888888', '#aaaaaa', 18, 8)
|
|
const crowbarSwing = makeSwing(5, 50, '#555555', '#444444', 8, 16)
|
|
const plungerSlam = makeSwing(5, 48, '#aa8844', '#ff4444', 12, 12)
|
|
const tennisRacket = makeSwing(3, 42, '#666666', '#44aa44', 20, 14)
|
|
const hockeyStick = makeSwing(4, 55, '#663300', '#222222', 12, 8)
|
|
const poolCue = makeSwing(3, 65, '#aa8855')
|
|
const guitarSmash = makeSwing(8, 50, '#884422', '#ffcc00', 18, 8)
|
|
const shovelBash = makeSwing(5, 52, '#666666', '#888888', 16, 12)
|
|
const pickaxeStrike = makeSwing(4, 50, '#886644', '#888888', 14, 8)
|
|
const oarSwing = makeSwing(5, 58, '#bb9966')
|
|
const flagpoleSmash = makeSwing(3, 65, '#888888', '#ff0000', 18, 12)
|
|
const caneWhack = makeSwing(4, 55, '#222222', '#ddaa00', 6, 6)
|
|
const rulerSlap = makeSwing(3, 50, '#ddcc88')
|
|
const newspaperRoll = makeSwing(6, 42, '#ccccbb')
|
|
|
|
// --- PROJECTILE STREAMS (20) ---
|
|
const tennisBallVolley = makeThrow('#ccff00', 8, 5, 40, true, '#aadd00')
|
|
const baseballPitch = makeThrow('#ffffff', 8, 4, 50, true, '#dddddd')
|
|
const bowlingBallRoll = makeThrow('#222222', 18, 1, 20, true, '#444444')
|
|
const rubberDuckFlood = makeThrow('#ffdd00', 10, 6, 45, true, '#ffee44')
|
|
const shoeBarrage = makeThrow('#553322', 12, 4, 55, false, '#775544')
|
|
const bookStorm = makeThrow('#884422', 14, 4, 60, false, '#aa6644')
|
|
const phoneFling = makeThrow('#333333', 10, 3, 50, false, '#4488ff')
|
|
const keyboardSmash = makeThrow('#dddddd', 16, 2, 65, false, '#aaaaaa')
|
|
const diceBarrage = makeThrow('#ffffff', 8, 6, 45, false, '#ff0000')
|
|
const marbleShower = makeThrow('#44aaff', 5, 10, 30, true, '#88ccff')
|
|
const snowballFight = makeThrow('#ffffff', 12, 4, 55, true, '#ddeeff')
|
|
const paintCanBlast = makeThrow('#ff4488', 14, 3, 60, true, '#ff88aa')
|
|
const tomatoBarrage = makeThrow('#ff2222', 10, 5, 50, true, '#ff4444')
|
|
const waterBalloonRain = makeThrow('#4488ff', 14, 3, 70, true, '#88bbff')
|
|
const pillowFight = makeThrow('#ffffff', 16, 3, 45, false, '#eeeeff')
|
|
const vinylRecordFling = makeThrow('#111111', 14, 3, 35, true, '#222222')
|
|
const frisbeeToss = makeThrow('#ff6600', 14, 2, 30, true, '#ffaa44')
|
|
const beachBallBonk = makeThrow('#ff4488', 20, 1, 80, true, '#ffaacc')
|
|
const soccerKick = makeThrow('#ffffff', 14, 2, 75, true, '#111111')
|
|
const basketballDunk = makeThrow('#ff8800', 16, 1, 90, true, '#ff6600')
|
|
|
|
// --- DROP ATTACKS (15) ---
|
|
const pianoDrop = makeDrop(55, 40, '#222222', '#ffcc00')
|
|
const safeDrop = makeDrop(35, 35, '#555555', '#888888')
|
|
const fridgeDrop = makeDrop(30, 45, '#dddddd', '#88ccff')
|
|
const couchDrop = makeDrop(55, 25, '#886644', '#aa8866')
|
|
const tvDrop = makeDrop(35, 30, '#333333', '#4488ff')
|
|
const toiletDrop = makeDrop(25, 30, '#ffffff', '#88bbff')
|
|
const bathtubDrop = makeDrop(50, 25, '#dddddd', '#88ccff')
|
|
const washerDrop = makeDrop(32, 35, '#cccccc', '#4488ff')
|
|
const vendingDrop = makeDrop(30, 45, '#ff4444', '#ffcc00')
|
|
const chandelierDrop = makeDrop(40, 30, '#ffcc00', '#ffffff')
|
|
const boulderDrop = makeDrop(35, 35, '#888888', '#666666', true)
|
|
const satelliteDrop = makeDrop(28, 35, '#888888', '#4488ff')
|
|
const ufoDrop = makeDrop(45, 15, '#88ff88', '#44ff44', false)
|
|
const giantShoeDrop = makeDrop(40, 25, '#553322', '#886644')
|
|
const giantPhoneDrop = makeDrop(22, 40, '#333333', '#4488ff')
|
|
|
|
// --- VEHICLES (10) ---
|
|
const shoppingCart = makeVehicle(45, 30, '#888888', 7, [{ w: 40, h: 3, color: '#aaaaaa', ox: 0, oy: -15 }])
|
|
const forkliftCharge = makeVehicle(50, 30, '#ffaa00', 8, [{ w: 8, h: 25, color: '#ffcc44', ox: 28, oy: -20 }])
|
|
const tankRoll = makeVehicle(65, 28, '#556633', 10, [{ w: 40, h: 6, color: '#445522', ox: 25, oy: -14 }])
|
|
const helicopterStrike = makeVehicle(50, 20, '#446688', 0, [{ w: 55, h: 3, color: '#557799', ox: 0, oy: -12 }])
|
|
const airplaneSwoop = makeVehicle(60, 15, '#dddddd', 0, [{ w: 50, h: 4, color: '#cccccc', ox: 0, oy: -3 }])
|
|
const rocketRide = makeVehicle(30, 50, '#ff4444', 0, [{ w: 20, h: 8, color: '#ffffff', ox: 0, oy: -28 }])
|
|
const unicycleRun = makeVehicle(12, 18, '#ff8800', 10)
|
|
const zamboniCrush = makeVehicle(60, 30, '#ffffff', 9, [{ w: 55, h: 5, color: '#88ccff', ox: 0, oy: 15 }])
|
|
const tractorPlow = makeVehicle(55, 32, '#44aa22', 10, [{ w: 30, h: 20, color: '#888888', ox: 30, oy: -8 }])
|
|
const golfCartDrive = makeVehicle(40, 25, '#ffffff', 6, [{ w: 15, h: 18, color: '#44aa44', ox: -8, oy: -16 }])
|
|
|
|
// --- SPIN ATTACKS (10) ---
|
|
const tornadoSpin = makeSpin('horizontal', 80, 3)
|
|
const backflipKick = makeSpin('vertical', 140, 1)
|
|
const corkscrewDive = makeSpin('corkscrew', 100, 2)
|
|
const helicopterArms = makeSpin('horizontal', 50, 4)
|
|
const breakdanceSweep = makeSpin('horizontal', 30, 3)
|
|
const cartwheelStrike = makeSpin('vertical', 90, 1)
|
|
const frontflipSlam = makeSpin('vertical', 160, 2)
|
|
const drillSpin = makeSpin('corkscrew', 60, 3)
|
|
const cycloneKick = makeSpin('horizontal', 100, 2)
|
|
const pirouetteStrike = makeSpin('horizontal', 40, 5)
|
|
|
|
// --- FLIP ATTACKS (10) ---
|
|
const doubleBackflip = makeSpin('vertical', 180, 2)
|
|
const wallBounce = makeSpin('vertical', 200, 1)
|
|
const springboardLaunch = makeSpin('vertical', 220, 1)
|
|
const barrelRoll = makeSpin('corkscrew', 80, 1)
|
|
const trampolineBounce = makeSpin('vertical', 250, 2)
|
|
const poleVault = makeSpin('vertical', 230, 1)
|
|
const skateTrick = makeSpin('corkscrew', 120, 1)
|
|
const surfSlam = makeSpin('horizontal', 60, 2)
|
|
const rolloutBall = makeSpin('horizontal', 20, 4)
|
|
const aerialTwist = makeSpin('corkscrew', 150, 2)
|
|
|
|
// --- BEAM ATTACKS (15) ---
|
|
const kamehameha = makeBeam('#44bbff', 10, 1)
|
|
const freezeRay = makeBeam('#88eeff', 8, 2)
|
|
const heatVision = makeBeam('#ff2200', 4, 3)
|
|
const plasmaBeam = makeBeam('#ff44ff', 8, 1)
|
|
const rainbowBeam = makeBeam('#ff8800', 12, 1)
|
|
const shadowBeam = makeBeam('#440066', 10, 1)
|
|
const sonicWave = makeBeam('#88ff88', 14, 2)
|
|
const gravityBeam = makeBeam('#6600aa', 6, 2)
|
|
const mindBlast = makeBeam('#ff88ff', 8, 1)
|
|
const pixelBeam = makeBeam('#44ff44', 6, 3)
|
|
const glitchBeam = makeBeam('#ff00ff', 5, 4)
|
|
const bassDropBeam = makeBeam('#8844ff', 16, 1)
|
|
const wifiBlast = makeBeam('#4488ff', 8, 2)
|
|
const dataStream = makeBeam('#00ff88', 4, 5)
|
|
const chainLightning = makeBeam('#ffff00', 5, 3)
|
|
|
|
// --- ANIMAL SUMMONS (15) ---
|
|
const sharkBite = makeSwarm('#4488aa', 1, 20, 600)
|
|
const bearSwipe = makeSwarm('#885533', 1, 22, 500)
|
|
const eagleDive = makeSwarm('#886644', 3, 12, 700, true)
|
|
const snakeLunge = makeSwarm('#44aa22', 2, 10, 550, true)
|
|
const bullCharge = makeSwarm('#883322', 1, 24, 450)
|
|
const gorillaSlam = makeSwarm('#555544', 1, 25, 400)
|
|
const scorpionSting = makeSwarm('#aa8822', 2, 8, 600, true)
|
|
const crabPinch = makeSwarm('#ff4422', 4, 10, 350)
|
|
const batSwarm = makeSwarm('#333333', 12, 5, 500, true)
|
|
const wolfPack = makeSwarm('#777766', 5, 12, 450)
|
|
const spiderWeb = makeSwarm('#dddddd', 8, 4, 300, true)
|
|
const beeSwarm = makeSwarm('#ffcc00', 10, 4, 550, true)
|
|
const catScratch = makeSwarm('#ff8844', 6, 6, 600, true)
|
|
const dogPile = makeSwarm('#aa8855', 4, 14, 400)
|
|
const dolphinFlip = makeSwarm('#6688cc', 3, 14, 500, true)
|
|
|
|
// --- EXPLOSION ATTACKS (15) ---
|
|
const dynamiteBlast = makeExplosion(8, 20, '#ff4444', 0.35, '#ff6600')
|
|
const c4Detonation = makeExplosion(14, 8, '#556633', 0.25, '#ff4400')
|
|
const fireworksBurst = makeExplosion(10, 10, '#ff0088', 0.2, '#ff44ff', true)
|
|
const nukeStrike = makeExplosion(12, 12, '#ffcc00', 0.4, '#ff2200', true)
|
|
const volcanoErupt = makeExplosion(20, 15, '#ff4400', 0.3, '#ff6600')
|
|
const grenadeBlast = makeExplosion(10, 12, '#556633', 0.3, '#ff6600', true)
|
|
const partyPopper = makeExplosion(8, 16, '#ff44ff', 0.15, '#ffcc00')
|
|
const pinataSmash = makeExplosion(20, 22, '#ff88cc', 0.2, '#ffaa44')
|
|
const balloonPop = makeExplosion(18, 18, '#ff4488', 0.1, '#ff88aa', true)
|
|
const glitterBomb = makeExplosion(12, 12, '#ffcc88', 0.15, '#ff88ff', true)
|
|
const smokeBomb = makeExplosion(14, 14, '#888888', 0.1, '#666666', true)
|
|
const flashBang = makeExplosion(8, 8, '#ffffff', 0.1, '#ffffff', true)
|
|
const cherryBomb = makeExplosion(8, 8, '#ff2222', 0.2, '#ff4444', true)
|
|
const confettiCannon = makeExplosion(16, 10, '#ffcc00', 0.1, '#ff88ff')
|
|
const stinkBomb = makeExplosion(12, 12, '#88aa33', 0.15, '#aacc44', true)
|
|
|
|
// --- SILLY/MEME (20) ---
|
|
const rubberChicken = makeSwing(8, 40, '#ffcc00', '#ff8844', 12, 12)
|
|
const airHornBlast = makeBeam('#ffcc00', 18, 1)
|
|
const vuvuzelaBlast = makeBeam('#ff4444', 16, 2)
|
|
const selfieStrike: ChoreoFn = async (atk, def, dir, origAX, origDX, isCritical) => {
|
|
// Pose, flash, then punch
|
|
atk.play('idle'); await k.wait(0.2)
|
|
screenFlash('#ffffff', 0.08); sfxSpecial(); await k.wait(0.15)
|
|
const cx = origDX - dir * 40
|
|
await k.tween(atk.pos.x, cx, 0.1, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
atk.play('attack'); sfxPunch(); await k.wait(0.1)
|
|
def.play(isCritical ? 'knockback' : 'hit'); k.shake(isCritical ? 14 : 6)
|
|
if (isCritical) { screenFlash('#ffffff'); sfxCritical() }
|
|
spawnSparks(def.pos.x, def.pos.y - 25, 8, '#ffcc00')
|
|
const push = dir * (isCritical ? 90 : 40)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3); atk.play('idle')
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
const dabAttack = makeSpin('horizontal', 30, 1)
|
|
const flossAttack = makeSpin('horizontal', 20, 3)
|
|
const yeetThrow = makeGrab('toss', 180)
|
|
const tPoseAssert = makeBeam('#ffffff', 20, 1)
|
|
const emojiBarrage = makeThrow('#ffcc00', 12, 6, 50, true, '#ff8800')
|
|
const memeBeam = makeBeam('#ff00ff', 10, 2)
|
|
const ratioAttack = makeThrow('#4488ff', 10, 5, 40, true, '#2266dd')
|
|
const capThrow = makeThrow('#ff0000', 14, 1, 30, true, '#0000ff')
|
|
const fingerGuns: ChoreoFn = async (atk, def, dir, origAX, origDX, isCritical) => {
|
|
atk.play('special'); sfxSpecial(); await k.wait(0.15)
|
|
const shots = isCritical ? 6 : 3
|
|
for (let i = 0; i < shots; i++) {
|
|
sfxGunshot()
|
|
await spawnBullet(atk.pos.x + dir * 25, atk.pos.y - 35, def.pos.x, def.pos.y - 25 + (Math.random() - 0.5) * 30)
|
|
sfxBulletHit(); def.play('hit'); k.shake(3)
|
|
spawnSparks(def.pos.x, def.pos.y - 25, 3, '#ffcc00'); await k.wait(0.06)
|
|
}
|
|
if (isCritical) { screenFlash('#ffcc00'); sfxCritical() }
|
|
def.play(isCritical ? 'knockback' : 'hit'); k.shake(isCritical ? 12 : 6)
|
|
const push = dir * (isCritical ? 80 : 35)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3); atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
const micDrop = makeDrop(12, 16, '#333333', '#ffcc00')
|
|
const dramaticEntrance = makeSpin('corkscrew', 200, 1)
|
|
const clapback = makeSwing(10, 5, '#ffaa88')
|
|
const touchGrass = makeSwarm('#44aa22', 15, 4, 300, true)
|
|
const noScope = makeBeam('#ff4400', 3, 1)
|
|
|
|
// --- GRAPPLE/WRESTLING (15) ---
|
|
const piledriver = makeGrab('down', 180)
|
|
const powerbomb = makeGrab('up', 200)
|
|
const ddt = makeGrab('down', 120)
|
|
const germanSuplex = makeGrab('up', 160)
|
|
const chokeslam = makeGrab('up', 220)
|
|
const tombstone = makeGrab('down', 200)
|
|
const stunner = makeGrab('down', 80)
|
|
const rko = makeGrab('down', 140)
|
|
const spear = makeGrab('toss', 80)
|
|
const clothesline: ChoreoFn = async (atk, def, dir, origAX, origDX, isCritical) => {
|
|
const cx = origDX - dir * 20
|
|
atk.play('attack'); sfxSpecial()
|
|
await k.tween(atk.pos.x, cx, 0.12, (v) => { atk.pos.x = v }, k.easings.easeInQuad)
|
|
sfxPunch(); def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 18 : 9); spawnSparks(def.pos.x, def.pos.y - 30, 10, '#ff4444')
|
|
if (isCritical) { screenFlash('#ff4444'); sfxCritical() }
|
|
// Defender spins backwards
|
|
const origDY = def.pos.y
|
|
await Promise.all([
|
|
k.tween(def.pos.x, origDX + dir * (isCritical ? 120 : 60), 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(0, 360, 0.25, (v) => { def.angle = v }).then(() => { def.angle = 0 }),
|
|
k.tween(origDY, origDY - 50, 0.12, (v) => { def.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(origDY - 50, origDY, 0.13, (v) => { def.pos.y = v }, k.easings.easeInQuad)),
|
|
])
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ff4444')
|
|
await k.wait(0.2); atk.play('idle')
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.35, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
const atomicDrop = makeGrab('up', 140)
|
|
const hurricanrana = makeGrab('spin', 120)
|
|
const moonsault = makeSpin('vertical', 200, 2)
|
|
const elbowDrop = makeDrop(10, 8, '#ffaa88', '#ff4444')
|
|
const frogSplash = makeSpin('vertical', 180, 1)
|
|
|
|
// --- ENERGY/MAGIC (20) ---
|
|
const fireball = makeThrow('#ff4400', 14, 2, 30, true, '#ff8800')
|
|
const iceLance = makeThrow('#88eeff', 10, 3, 35, false, '#44ccff')
|
|
const thunderStrike = makeBeam('#ffff00', 6, 2)
|
|
const darkVoid = makeBeam('#440066', 12, 1)
|
|
const solarFlare: ChoreoFn = async (atk, def, dir, origAX, origDX, isCritical) => {
|
|
atk.play('special'); sfxSpecial(); await k.wait(0.1)
|
|
// Blinding flash
|
|
screenFlash('#ffffff', 0.25)
|
|
await k.wait(0.2)
|
|
// Then punch while blinded
|
|
const cx = origDX - dir * 40
|
|
await k.tween(atk.pos.x, cx, 0.1, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
atk.play('attack'); sfxPunch(); await k.wait(0.1)
|
|
def.play(isCritical ? 'knockback' : 'hit'); k.shake(isCritical ? 18 : 8)
|
|
if (isCritical) { screenFlash('#ffff00'); sfxCritical() }
|
|
spawnSparks(def.pos.x, def.pos.y - 25, 12, '#ffff00')
|
|
const push = dir * (isCritical ? 100 : 45)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3); atk.play('idle')
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
const spiritBomb = makeDrop(30, 30, '#44bbff', '#88ddff', true)
|
|
const windSlash = makeBeam('#aaffaa', 3, 4)
|
|
const earthquakeStrike: ChoreoFn = async (atk, def, dir, origAX, origDX, isCritical) => {
|
|
atk.play('special'); sfxSpecial(); await k.wait(0.1)
|
|
atk.play('attack')
|
|
// Ground pound
|
|
const origAY = atk.pos.y
|
|
await k.tween(origAY, origAY + 15, 0.08, (v) => { atk.pos.y = v }, k.easings.easeInQuad)
|
|
sfxExplosion(); k.shake(isCritical ? 30 : 18)
|
|
spawnShockwave(atk.pos.x, GROUND_Y, '#aa8844')
|
|
// Screen shakes violently, ground cracks spread toward opponent
|
|
for (let i = 0; i < (isCritical ? 4 : 2); i++) {
|
|
const cx2 = atk.pos.x + dir * (80 + i * 60)
|
|
spawnSparks(cx2, GROUND_Y - 5, 5, '#aa8844')
|
|
await k.wait(0.05)
|
|
}
|
|
def.play(isCritical ? 'knockback' : 'hit'); k.shake(10)
|
|
if (isCritical) { screenFlash('#aa8844'); sfxCritical() }
|
|
spawnSparks(def.pos.x, GROUND_Y - 5, 10, '#886644')
|
|
const origDY = def.pos.y
|
|
await k.tween(origDY, origDY - 80, 0.15, (v) => { def.pos.y = v }, k.easings.easeOutQuad)
|
|
await k.tween(origDY - 80, origDY, 0.2, (v) => { def.pos.y = v }, k.easings.easeInQuad)
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#886644')
|
|
atk.pos.y = GROUND_Y
|
|
await k.wait(0.2); atk.play('idle')
|
|
}
|
|
const portalPunch: ChoreoFn = async (atk, def, dir, origAX, origDX, isCritical) => {
|
|
atk.play('special'); sfxSpecial()
|
|
// Open portal near attacker
|
|
const p1 = k.add([k.circle(20), k.pos(atk.pos.x + dir * 40, atk.pos.y - 30), k.color(safeColor(k,'#8844ff')), k.opacity(0.7), k.z(15)])
|
|
// Open portal near defender
|
|
const p2 = k.add([k.circle(20), k.pos(def.pos.x - dir * 30, def.pos.y - 30), k.color(safeColor(k,'#ff44ff')), k.opacity(0.7), k.z(15)])
|
|
await k.wait(0.2)
|
|
atk.play('attack'); sfxPunch()
|
|
// Fist appears from portal 2
|
|
await k.wait(0.1)
|
|
def.play(isCritical ? 'knockback' : 'hit'); k.shake(isCritical ? 16 : 8)
|
|
spawnSparks(def.pos.x, def.pos.y - 25, 10, '#ff44ff')
|
|
if (isCritical) { screenFlash('#8844ff'); sfxCritical() }
|
|
const push = dir * (isCritical ? 90 : 40)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.15)
|
|
k.tween(0.7, 0, 0.2, (v) => { p1.opacity = v; p2.opacity = v }).then(() => { p1.destroy(); p2.destroy() })
|
|
await k.wait(0.2); atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
const gravityWell = makeSwarm('#6600aa', 1, 25, 300)
|
|
const plasmaOrb = makeThrow('#ff44ff', 16, 1, 40, true, '#ff88ff')
|
|
const voidRift = makeBeam('#220044', 14, 1)
|
|
const crystalShards = makeThrow('#88ffff', 8, 6, 45, false, '#44ddff')
|
|
const meteorStrike = makeDrop(25, 25, '#ff4400', '#ff8800', true)
|
|
const arcaneBarrage = makeThrow('#8844ff', 10, 5, 50, true, '#aa66ff')
|
|
const holySmite = makeBeam('#ffee88', 10, 1)
|
|
const hexCurse = makeSwarm('#44ff44', 6, 6, 400, true)
|
|
const bloodMoon = makeBeam('#ff2222', 12, 1)
|
|
const shadowClone = makeSwarm('#333333', 3, 16, 500)
|
|
|
|
// --- TECH/MODERN (15) ---
|
|
const droneStrike = makeSwarm('#888888', 3, 8, 600)
|
|
const satelliteLaser = makeBeam('#ff0000', 4, 1)
|
|
const hackerAttack = makeThrow('#00ff44', 8, 8, 30, false, '#44ff88')
|
|
const bugSwarm = makeSwarm('#ff4444', 10, 4, 500, true)
|
|
const stackOverflow = makeDrop(35, 35, '#ff8800', '#f48024')
|
|
const segfault = makeExplosion(20, 20, '#ff0000', 0.1, '#880000')
|
|
const blueScreen = makeBeam('#0000ff', 20, 1)
|
|
const fourOhFour = makeExplosion(15, 15, '#888888', 0.2, '#ff4444')
|
|
const ctrlAltDelete = makeSwing(8, 12, '#333333', '#ffffff', 20, 12)
|
|
const bitcoinCrash = makeDrop(20, 20, '#ff8800', '#ffcc00', true)
|
|
const nftRugPull = makeGrab('toss', 200)
|
|
const aiUprising = makeSwarm('#ff0044', 8, 8, 500, true)
|
|
const captchaTrap = makeExplosion(25, 20, '#4488ff', 0.3, '#2266cc')
|
|
const popupSpam = makeThrow('#ffffff', 14, 8, 30, false, '#ff4444')
|
|
const malwareInject = makeBeam('#00ff00', 5, 3)
|
|
|
|
// --- MUSIC (8) ---
|
|
const bassDrop = makeExplosion(10, 10, '#8844ff', 0.2, '#6622cc', true)
|
|
const guitarSolo = makeBeam('#ff8800', 8, 3)
|
|
const drumSolo = makeThrow('#aa8844', 10, 6, 45, true, '#886633')
|
|
const dubstepCannon = makeBeam('#ff00ff', 14, 2)
|
|
const airGuitar = makeBeam('#ffcc00', 6, 3)
|
|
const karaokeAttack = makeBeam('#ff44aa', 10, 2)
|
|
const beatboxBlast = makeSwarm('#4488ff', 8, 6, 400, true)
|
|
const vinylScratch = makeSwing(14, 2, '#111111', '#ff4444', 14, 14)
|
|
|
|
// --- SPORTS (10) ---
|
|
const homeRunSwing = makeSwing(5, 55, '#886633', '#ffffff', 10, 10)
|
|
const slapShot = makeSwing(4, 55, '#333333', '#444444', 8, 8)
|
|
const servingAce = makeThrow('#ccff00', 10, 1, 80, true, '#aadd00')
|
|
const fieldGoalKick = makeSpin('vertical', 100, 1)
|
|
const bodyCheck = makeGrab('toss', 60)
|
|
const dropKick = makeSpin('vertical', 120, 1)
|
|
const elbowStrike = makeGrab('down', 60)
|
|
const kneeStrike = makeGrab('up', 50)
|
|
const headbutt = makeGrab('down', 30)
|
|
const shoulderCharge = makeGrab('toss', 40)
|
|
|
|
// --- NATURE/ELEMENTAL (10) ---
|
|
const treeSmash = makeDrop(20, 60, '#44aa22', '#228811')
|
|
const icebergDrop = makeDrop(40, 35, '#88eeff', '#44ccff')
|
|
const lavaSplash = makeExplosion(15, 15, '#ff4400', 0.2, '#ff8800', true)
|
|
const tornadoFling = makeGrab('spin', 160)
|
|
const tsunamiWave = makeBeam('#2266cc', 20, 1)
|
|
const avalanche = makeSwarm('#ffffff', 12, 10, 400)
|
|
const vineWhip = makeSwing(3, 60, '#44aa22', '#33aa11', 6, 12)
|
|
const sandstorm = makeSwarm('#ccaa66', 15, 4, 350, true)
|
|
const thornBarrage = makeThrow('#44aa22', 6, 8, 35, false, '#228811')
|
|
const pollenCloud = makeSwarm('#ffee44', 12, 3, 250, true)
|
|
|
|
// --- SPACE/SCI-FI (10) ---
|
|
const blackHole = makeSwarm('#220044', 1, 30, 200)
|
|
const photonTorpedo = makeThrow('#44bbff', 12, 3, 40, true, '#88ddff')
|
|
const tractor_beam = makeBeam('#44ff88', 10, 1)
|
|
const warpDrive = makeSpin('corkscrew', 180, 1)
|
|
const alienAbduction = makeGrab('up', 250)
|
|
const laserSword = makeSwing(4, 55, '#44bbff', '#88ddff', 4, 50)
|
|
const ionCannon = makeBeam('#88ff44', 8, 2)
|
|
const plasmaSword = makeSwing(4, 55, '#ff44ff', '#ff88ff', 4, 50)
|
|
const cosmicRay = makeBeam('#ffffff', 3, 5)
|
|
const asteroidBelt = makeThrow('#888888', 14, 5, 60, true, '#666666')
|
|
|
|
// --- MEDIEVAL/FANTASY (10) ---
|
|
const dragonBreath = makeBeam('#ff4400', 12, 2)
|
|
const maceSwing = makeSwing(5, 48, '#888888', '#666666', 16, 16)
|
|
const crossbowBolt = makeThrow('#886633', 6, 3, 25, false, '#aa8855')
|
|
const shieldBash = makeGrab('toss', 50)
|
|
const flailSwing = makeSwing(3, 55, '#888888', '#666666', 14, 14)
|
|
const battleAxe = makeSwing(6, 50, '#886633', '#888888', 20, 12)
|
|
const holyWater = makeThrow('#88ccff', 10, 3, 55, true, '#aaeeff')
|
|
const potionThrow = makeThrow('#44ff44', 10, 2, 60, true, '#88ff88')
|
|
const scrollBlast = makeBeam('#ffcc88', 8, 1)
|
|
const enchantedArrow = makeThrow('#ff88ff', 6, 3, 30, false, '#ffaaff')
|
|
|
|
// ============================================================
|
|
// TIER-GATED ULTIMATE MOVES — unlock with higher tier/wins
|
|
// Tier 2+: 10 moves, Tier 3+: 10 more, Tier 4+: 10 more, Tier 5+: 10 more
|
|
// ============================================================
|
|
|
|
// --- TIER 2+ ULTIMATES (Silver) — flashy multi-hits ---
|
|
async function ultimateRapidBarrage(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Rush in and land 8 alternating punches + kicks with screen shake
|
|
const contactX = origDX - dir * 45
|
|
sfxZoomWhoosh()
|
|
await k.tween(atk.pos.x, contactX, 0.1, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
const hitColors = ['#ff2d7b', '#00f0ff', '#ffe14d', '#39ff14', '#ff6600', '#b83dff', '#ffffff', '#ff2d2d']
|
|
for (let i = 0; i < 8; i++) {
|
|
atk.play(i % 2 === 0 ? 'attack' : 'kick')
|
|
sfxPunch()
|
|
def.play('hit')
|
|
k.shake(3 + i)
|
|
spawnSparks(def.pos.x + (Math.random() - 0.5) * 20, def.pos.y - 15 - Math.random() * 30, 4, hitColors[i])
|
|
def.pos.x += dir * 3
|
|
await k.wait(0.04)
|
|
}
|
|
// Final uppercut launch
|
|
atk.play('special'); sfxCritical()
|
|
def.play('knockback'); k.shake(15); screenFlash('#ffe14d', 0.1)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 15, '#ffe14d')
|
|
await k.tween(def.pos.y, def.pos.y - 60, 0.15, (v) => { def.pos.y = v }, k.easings.easeOutQuad)
|
|
await k.tween(def.pos.y, GROUND_Y, 0.15, (v) => { def.pos.y = v }, k.easings.easeInQuad)
|
|
sfxBonk()
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.25, (v) => { def.pos.x = v }, k.easings.easeOutQuad),
|
|
])
|
|
atk.play('idle')
|
|
}
|
|
|
|
async function ultimateOrbitalStrike(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Call down 5 orbital beams on the defender's position
|
|
atk.play('special'); sfxSpecial()
|
|
for (let i = 0; i < 5; i++) {
|
|
const bx = def.pos.x + (Math.random() - 0.5) * 60
|
|
const beam = k.add([k.rect(4, H), k.pos(bx, 0), k.color(safeColor(k,'#ff2d7b')), k.opacity(0.8), k.z(20)])
|
|
sfxZap(); k.shake(6)
|
|
spawnSparks(bx, def.pos.y - 20, 8, '#ff2d7b')
|
|
await k.wait(0.08)
|
|
beam.destroy()
|
|
}
|
|
def.play('knockback'); k.shake(12); screenFlash('#ff2d7b', 0.15)
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ff2d7b')
|
|
await k.wait(0.3); atk.play('idle')
|
|
}
|
|
|
|
async function ultimateCloneSurround(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Spawn 4 clones around the defender, all attack simultaneously
|
|
const clones: any[] = []
|
|
const positions = [
|
|
{ x: def.pos.x - 60, y: GROUND_Y }, { x: def.pos.x + 60, y: GROUND_Y },
|
|
{ x: def.pos.x - 30, y: GROUND_Y - 50 }, { x: def.pos.x + 30, y: GROUND_Y - 50 },
|
|
]
|
|
for (const p of positions) {
|
|
const cl = k.add([k.rect(20, 30), k.pos(p.x, p.y), k.anchor('center'), k.color(safeColor(k,theme.accent)), k.opacity(0.5), k.z(12)])
|
|
clones.push(cl)
|
|
}
|
|
sfxZap(); await k.wait(0.2)
|
|
// All converge
|
|
for (const cl of clones) {
|
|
k.tween(cl.pos.x, def.pos.x, 0.1, (v) => { cl.pos.x = v }, k.easings.easeInQuad)
|
|
k.tween(cl.pos.y, def.pos.y - 20, 0.1, (v) => { cl.pos.y = v }, k.easings.easeInQuad)
|
|
}
|
|
await k.wait(0.12)
|
|
sfxExplosion(); k.shake(15); screenFlash('#ffffff', 0.15)
|
|
def.play('knockback')
|
|
spawnSparks(def.pos.x, def.pos.y - 20, 20, theme.accent)
|
|
clones.forEach(c => c.destroy())
|
|
await k.wait(0.3)
|
|
}
|
|
|
|
async function ultimateGatlingFury(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Pull out massive gatling gun, fire 12 shots with screen shake
|
|
atk.play('special')
|
|
const gunLen = 60
|
|
const gx = atk.pos.x + dir * 25
|
|
const gy = atk.pos.y - 25
|
|
const barrel = k.add([k.rect(gunLen, 16), k.pos(gx, gy), k.color(safeColor(k,'#555555')), k.opacity(1), k.z(16)])
|
|
sfxBoing()
|
|
await k.wait(0.15)
|
|
for (let i = 0; i < 12; i++) {
|
|
sfxGunshot()
|
|
k.shake(3)
|
|
const flash = k.add([k.circle(8), k.pos(gx + dir * gunLen, gy + (Math.random() - 0.5) * 10), k.color(safeColor(k,'#ffee00')), k.opacity(0.9), k.z(18)])
|
|
setTimeout(() => { if (flash.exists()) flash.destroy() }, 40)
|
|
if (i % 3 === 0) {
|
|
def.play('hit')
|
|
spawnSparks(def.pos.x, def.pos.y - 20 - Math.random() * 20, 4, '#ff6600')
|
|
}
|
|
await k.wait(0.04)
|
|
}
|
|
barrel.destroy()
|
|
def.play('knockback'); k.shake(10)
|
|
sfxExplosion()
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ff6600')
|
|
await k.wait(0.3); atk.play('idle')
|
|
}
|
|
|
|
async function ultimateEarthquake(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Jump high, slam ground, cracks + shockwaves across screen
|
|
sfxZoomWhoosh()
|
|
await k.tween(atk.pos.y, GROUND_Y - 150, 0.2, (v) => { atk.pos.y = v }, k.easings.easeOutQuad)
|
|
atk.play('special')
|
|
await k.wait(0.1)
|
|
await k.tween(atk.pos.y, GROUND_Y, 0.1, (v) => { atk.pos.y = v }, k.easings.easeInQuad)
|
|
sfxExplosion(); k.shake(25); screenFlash('#ff8800', 0.2)
|
|
// 3 shockwaves radiating outward
|
|
for (let i = 0; i < 3; i++) {
|
|
setTimeout(() => { spawnShockwave(atk.pos.x + (i - 1) * 100, GROUND_Y, '#ff8800'); k.shake(8) }, i * 100)
|
|
}
|
|
// Ground cracks
|
|
for (let i = 0; i < 6; i++) {
|
|
const cx = Math.random() * W
|
|
k.add([k.rect(2, 15 + Math.random() * 10), k.pos(cx, GROUND_Y - 5), k.color(safeColor(k,'#aa6600')), k.opacity(0.7), k.z(1), { lifetime: 0.8 }])
|
|
}
|
|
def.play('knockback')
|
|
spawnSparks(def.pos.x, def.pos.y - 20, 12, '#ff8800')
|
|
await k.wait(0.4)
|
|
atk.play('idle')
|
|
}
|
|
|
|
const ultimateBouncingFury = makeSpin('corkscrew', 160, 4)
|
|
const ultimateTripleBeam = makeBeam('#ff2d7b', 10, 3)
|
|
const ultimateMegaThrow = makeThrow('#ff4400', 22, 5, 80, true, '#ffcc00')
|
|
const ultimateTornadoGrab = makeGrab('spin', 200)
|
|
const ultimateMeteorShower = makeSwarm('#ff6600', 8, 10, 500, true)
|
|
|
|
// --- TIER 3+ ULTIMATES (Gold) — multi-phase, full screen ---
|
|
async function ultimateScreenNuke(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Charge up glowing orb, launch it, entire screen whites out
|
|
atk.play('special'); sfxSpecial()
|
|
const orb = k.add([k.circle(5), k.pos(atk.pos.x + dir * 20, atk.pos.y - 30), k.color(safeColor(k,'#ffffff')), k.opacity(0.8), k.z(18)])
|
|
// Charge: grow orb
|
|
for (let i = 0; i < 8; i++) {
|
|
await k.wait(0.05)
|
|
orb.radius = 5 + i * 3
|
|
spawnSparks(orb.pos.x + (Math.random() - 0.5) * 20, orb.pos.y + (Math.random() - 0.5) * 20, 2, '#ffe14d')
|
|
}
|
|
sfxZoomWhoosh()
|
|
// Launch
|
|
await k.tween(orb.pos.x, def.pos.x, 0.15, (v) => { orb.pos.x = v }, k.easings.easeInQuad)
|
|
orb.destroy()
|
|
// Full screen explosion
|
|
sfxExplosion(); sfxCritical()
|
|
screenFlash('#ffffff', 0.3); k.shake(30)
|
|
for (let i = 0; i < 4; i++) {
|
|
spawnShockwave(def.pos.x + (Math.random() - 0.5) * 80, GROUND_Y, ['#ff2d7b', '#ffe14d', '#00f0ff', '#b83dff'][i])
|
|
}
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 30, '#ffffff')
|
|
def.play('knockback')
|
|
await k.wait(0.4); atk.play('idle')
|
|
}
|
|
|
|
async function ultimateBlackHoleVortex(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Summon black hole that pulls defender in, crushes, and ejects
|
|
atk.play('special'); sfxZap()
|
|
const bh = k.add([k.circle(8), k.pos(W / 2, GROUND_Y - 50), k.anchor('center'), k.color(safeColor(k,'#220044')), k.opacity(0.9), k.z(20)])
|
|
const ring = k.add([k.circle(30), k.pos(W / 2, GROUND_Y - 50), k.anchor('center'), k.color(safeColor(k,'#b83dff')), k.opacity(0.3), k.z(19)])
|
|
// Grow
|
|
await k.tween(8, 35, 0.3, (v) => { bh.radius = v; ring.radius = v + 20 }, k.easings.easeOutQuad)
|
|
// Pull defender in
|
|
sfxZoomWhoosh()
|
|
await k.tween(def.pos.x, W / 2, 0.2, (v) => { def.pos.x = v }, k.easings.easeInQuad)
|
|
await k.tween(def.pos.y, GROUND_Y - 50, 0.15, (v) => { def.pos.y = v }, k.easings.easeInQuad)
|
|
def.play('hit'); k.shake(10)
|
|
// Crush
|
|
for (let i = 0; i < 5; i++) {
|
|
k.shake(5); sfxPunch()
|
|
spawnSparks(W / 2 + (Math.random() - 0.5) * 30, GROUND_Y - 50 + (Math.random() - 0.5) * 20, 3, '#b83dff')
|
|
await k.wait(0.06)
|
|
}
|
|
// Eject
|
|
sfxExplosion(); k.shake(20); screenFlash('#b83dff', 0.15)
|
|
def.play('knockback')
|
|
await Promise.all([
|
|
k.tween(def.pos.x, origDX + dir * 40, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(def.pos.y, GROUND_Y, 0.2, (v) => { def.pos.y = v }, k.easings.easeOutQuad),
|
|
])
|
|
bh.destroy(); ring.destroy()
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#b83dff')
|
|
await k.tween(def.pos.x, origDX, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.2); atk.play('idle')
|
|
}
|
|
|
|
async function ultimateDimensionalRift(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Open rift, attacker disappears, attacks from multiple portals
|
|
sfxZap(); atk.opacity = 0
|
|
const colors = ['#ff2d7b', '#00f0ff', '#39ff14', '#b83dff']
|
|
for (let i = 0; i < 4; i++) {
|
|
const px = def.pos.x + (i % 2 === 0 ? -80 : 80)
|
|
const py = GROUND_Y - (i < 2 ? 0 : 60)
|
|
// Portal flash
|
|
const p = k.add([k.circle(15), k.pos(px, py), k.color(safeColor(k,colors[i])), k.opacity(0.7), k.z(15)])
|
|
await k.wait(0.06)
|
|
// Attack from portal
|
|
atk.pos.x = px; atk.pos.y = py; atk.opacity = 1
|
|
atk.play('attack'); sfxPunch()
|
|
def.play('hit'); k.shake(5)
|
|
spawnSparks(def.pos.x, def.pos.y - 20, 5, colors[i])
|
|
await k.wait(0.06)
|
|
atk.opacity = 0; p.destroy()
|
|
}
|
|
// Final slam from above
|
|
atk.pos.x = def.pos.x; atk.pos.y = GROUND_Y - 120; atk.opacity = 1
|
|
atk.play('special')
|
|
sfxZoomWhoosh()
|
|
await k.tween(atk.pos.y, GROUND_Y, 0.12, (v) => { atk.pos.y = v }, k.easings.easeInQuad)
|
|
sfxExplosion(); k.shake(18); screenFlash('#ffffff', 0.15)
|
|
def.play('knockback')
|
|
spawnSparks(def.pos.x, GROUND_Y - 20, 20, '#ffffff')
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ffffff')
|
|
await k.tween(atk.pos.x, origAX, 0.25, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
atk.play('idle')
|
|
}
|
|
|
|
async function ultimateTimeSlow(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Everything goes slow-mo, attacker lands 6 devastating hits in "frozen" time
|
|
scanlineGlitch(0.1)
|
|
// Dim screen
|
|
const dim = k.add([k.rect(W, H), k.pos(0, 0), k.color(safeColor(k,'#000022')), k.opacity(0.4), k.z(25)])
|
|
sfxZap()
|
|
const contactX = origDX - dir * 45
|
|
await k.tween(atk.pos.x, contactX, 0.3, (v) => { atk.pos.x = v }, k.easings.easeInOutQuad)
|
|
for (let i = 0; i < 6; i++) {
|
|
atk.play(i % 3 === 0 ? 'attack' : i % 3 === 1 ? 'kick' : 'special')
|
|
sfxPunch()
|
|
def.play('hit')
|
|
k.shake(4)
|
|
spawnSparks(def.pos.x + (Math.random() - 0.5) * 15, def.pos.y - 15 - Math.random() * 25, 5, '#00f0ff')
|
|
await k.wait(0.12) // Slow timing
|
|
}
|
|
dim.destroy()
|
|
// Time resumes — final hit with full impact
|
|
sfxCritical(); sfxExplosion(); k.shake(20); screenFlash('#00f0ff', 0.2)
|
|
def.play('knockback')
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#00f0ff')
|
|
spawnSparks(def.pos.x, def.pos.y - 20, 20, '#00f0ff')
|
|
await k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeInQuad)
|
|
atk.play('idle')
|
|
}
|
|
|
|
async function ultimateSummonArmy(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Summon an army of 8 mini clones that charge across the screen
|
|
atk.play('special'); sfxSpecial()
|
|
const army: any[] = []
|
|
for (let i = 0; i < 8; i++) {
|
|
const ax = atk.pos.x + (Math.random() - 0.5) * 30
|
|
const ay = GROUND_Y - Math.random() * 10
|
|
const m = k.add([k.rect(12, 18), k.pos(ax, ay), k.anchor('center'), k.color(safeColor(k,theme.accent)), k.opacity(0.6), k.z(11)])
|
|
army.push(m)
|
|
}
|
|
await k.wait(0.2)
|
|
sfxZoomWhoosh()
|
|
// All charge at defender
|
|
await Promise.all(army.map((m, i) =>
|
|
k.tween(m.pos.x, def.pos.x + (Math.random() - 0.5) * 20, 0.15 + i * 0.02, (v) => { m.pos.x = v }, k.easings.easeInQuad)
|
|
))
|
|
sfxExplosion(); k.shake(15)
|
|
def.play('knockback')
|
|
spawnSparks(def.pos.x, def.pos.y - 20, 20, theme.accent)
|
|
army.forEach(m => m.destroy())
|
|
await k.wait(0.3)
|
|
}
|
|
|
|
const ultimateHellfireRain = makeSwarm('#ff4400', 12, 12, 600, true)
|
|
const ultimateCrystalCage = makeSwarm('#88ccff', 10, 8, 350, false)
|
|
const ultimateGigaDrill = makeSpin('corkscrew', 200, 5)
|
|
const ultimateSuperSlam = makeGrab('up', 250)
|
|
const ultimateAvalancheDrop = makeExplosion(30, 30, '#aaeeff', 0.2, '#ffffff', true)
|
|
|
|
// ULTIMATE BULLET TIME BARRAGE — full slow-mo cinematic: dodge rain of projectiles, afterimage rush, multi-hit counter
|
|
async function ultimateBulletTimeBarrage(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Phase 1: World goes dark, heavy slow-mo overlay
|
|
const dim = k.add([k.rect(W, H), k.pos(0, 0), k.color(safeColor(k, '#000022')), k.opacity(0), k.z(25)])
|
|
await k.tween(0, 0.55, 0.2, (v) => { dim.opacity = v })
|
|
scanlineGlitch(0.15)
|
|
glitchRGB(0.1)
|
|
|
|
// Phase 2: Defender fires a barrage of slow-mo bullets
|
|
def.play('special')
|
|
for (let i = 0; i < 8; i++) {
|
|
sfxGunshot()
|
|
const bx = def.pos.x - dir * 20
|
|
const by = def.pos.y - 35 + (Math.random() - 0.5) * 30
|
|
const bullet = k.add([
|
|
k.rect(12, 3),
|
|
k.pos(bx, by),
|
|
k.color(safeColor(k, '#ff4444')),
|
|
k.opacity(0.85),
|
|
k.z(26),
|
|
k.anchor('center'),
|
|
])
|
|
// Bullet trace
|
|
const trace = k.add([
|
|
k.rect(60, 1),
|
|
k.pos(bx + dir * 30, by),
|
|
k.color(safeColor(k, '#ff6644')),
|
|
k.opacity(0.4),
|
|
k.z(25),
|
|
])
|
|
setTimeout(() => { if (trace.exists()) trace.destroy() }, 300)
|
|
// Bullet travels slowly
|
|
k.tween(bullet.pos.x, atk.pos.x + (Math.random() - 0.5) * 30, 0.3, (v) => { if (bullet.exists()) bullet.pos.x = v }).then(() => { if (bullet.exists()) bullet.destroy() })
|
|
await k.wait(0.05)
|
|
}
|
|
|
|
// Phase 3: Attacker dodges each bullet with slow-mo lean (afterimages cascade)
|
|
atk.play('idle')
|
|
for (let lean = 0; lean < 3; lean++) {
|
|
const leanDir = lean % 2 === 0 ? -1 : 1
|
|
const ghost = k.add([
|
|
k.rect(FRAME_SIZE * Math.abs(atk.scale.x) * 0.7, FRAME_SIZE * Math.abs(atk.scale.y)),
|
|
k.pos(atk.pos.x, atk.pos.y),
|
|
k.color(safeColor(k, '#ffd700')),
|
|
k.opacity(0.3),
|
|
k.z(24),
|
|
k.anchor('bot'),
|
|
])
|
|
setTimeout(() => { if (ghost.exists()) ghost.destroy() }, 350)
|
|
await k.tween(atk.pos.y, GROUND_Y + leanDir * 15, 0.08, (v) => { atk.pos.y = v }, k.easings.easeOutQuad)
|
|
await k.tween(atk.pos.y, GROUND_Y, 0.08, (v) => { atk.pos.y = v }, k.easings.easeInQuad)
|
|
}
|
|
await k.wait(0.1)
|
|
|
|
// Phase 4: Time RESUMES — golden flash, attacker blazes forward
|
|
dim.destroy()
|
|
screenFlash('#ffd700', 0.15)
|
|
sfxZoomWhoosh()
|
|
sfxCritical()
|
|
|
|
// Afterimage rush trail (8 ghosts across the screen)
|
|
const contactX = origDX - dir * 40
|
|
for (let i = 0; i < 8; i++) {
|
|
const gx = origAX + ((contactX - origAX) * i / 8)
|
|
const ghost = k.add([
|
|
k.rect(FRAME_SIZE * Math.abs(atk.scale.x) * 0.6, FRAME_SIZE * Math.abs(atk.scale.y) * 0.9),
|
|
k.pos(gx, GROUND_Y),
|
|
k.color(safeColor(k, '#ffd700')),
|
|
k.opacity(0.35 - i * 0.04),
|
|
k.z(9),
|
|
k.anchor('bot'),
|
|
])
|
|
setTimeout(() => { if (ghost.exists()) ghost.destroy() }, 300)
|
|
}
|
|
await k.tween(atk.pos.x, contactX, 0.06, (v) => { atk.pos.x = v }, k.easings.easeInQuad)
|
|
|
|
// Phase 5: 8-hit slow-mo combo — each hit with sparks and screen shake
|
|
for (let i = 0; i < 8; i++) {
|
|
atk.play(i % 3 === 0 ? 'attack' : i % 3 === 1 ? 'kick' : 'special')
|
|
sfxPunch()
|
|
def.play('hit')
|
|
k.shake(5 + i * 2)
|
|
spawnSparks(def.pos.x + (Math.random() - 0.5) * 15, def.pos.y - 15 - Math.random() * 25, 5, i % 2 === 0 ? '#ffd700' : '#ffffff')
|
|
await k.wait(0.04)
|
|
}
|
|
|
|
// Phase 6: Final devastating blow — full screen effects
|
|
sfxExplosion()
|
|
k.shake(30)
|
|
screenFlash('#ffd700', 0.25)
|
|
def.play('knockback')
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ffd700')
|
|
spawnShockwave(def.pos.x + dir * 30, GROUND_Y, '#ffaa00')
|
|
spawnSparks(def.pos.x, def.pos.y - 25, 25, '#ffd700')
|
|
glitchRGB(0.3)
|
|
|
|
await k.wait(0.4)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.25, (v) => { atk.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeOutQuad),
|
|
])
|
|
atk.play('idle')
|
|
}
|
|
|
|
// --- TIER 4+ ULTIMATES (Platinum) — full screen, multi-phase spectacles ---
|
|
async function ultimateFinaleRush(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Full-screen dash through, reverse, dash again, then combo finish
|
|
sfxZoomWhoosh()
|
|
// First pass
|
|
await k.tween(atk.pos.x, origDX + dir * 60, 0.1, (v) => { atk.pos.x = v }, k.easings.easeInQuad)
|
|
atk.play('attack'); sfxPunch(); def.play('hit'); k.shake(8)
|
|
spawnSparks(def.pos.x, def.pos.y - 25, 8, '#ff2d7b')
|
|
// Bounce off wall
|
|
await k.wait(0.05)
|
|
atk.scale.x = -atk.scale.x
|
|
await k.tween(atk.pos.x, origDX - dir * 60, 0.1, (v) => { atk.pos.x = v }, k.easings.easeInQuad)
|
|
atk.play('kick'); sfxKick(); def.play('hit'); k.shake(8)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 8, '#00f0ff')
|
|
// Back to normal orientation
|
|
atk.scale.x = -atk.scale.x
|
|
// Final mega hit
|
|
await k.tween(atk.pos.x, origDX - dir * 40, 0.08, (v) => { atk.pos.x = v }, k.easings.easeInQuad)
|
|
atk.play('special'); sfxCritical(); sfxExplosion()
|
|
def.play('knockback'); k.shake(22); screenFlash('#ffe14d', 0.2)
|
|
spawnSparks(def.pos.x, def.pos.y - 25, 25, '#ffe14d')
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ffe14d')
|
|
// Return
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.25, (v) => { atk.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeOutQuad),
|
|
])
|
|
atk.play('idle')
|
|
}
|
|
|
|
async function ultimateMeteorCrash(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Attacker launches into sky, becomes a meteor, crashes into arena
|
|
sfxZoomWhoosh(); atk.play('special')
|
|
await k.tween(atk.pos.y, -100, 0.2, (v) => { atk.pos.y = v }, k.easings.easeInQuad)
|
|
atk.opacity = 0
|
|
await k.wait(0.3)
|
|
// Meteor warning
|
|
const warning = k.add([k.circle(15), k.pos(def.pos.x, GROUND_Y - 5), k.color(safeColor(k,'#ff0000')), k.opacity(0.4), k.z(1)])
|
|
warning.onUpdate(() => { warning.opacity = 0.2 + Math.sin(k.time() * 20) * 0.2 })
|
|
sfxZap()
|
|
await k.wait(0.4)
|
|
warning.destroy()
|
|
// Impact
|
|
atk.pos.x = def.pos.x; atk.pos.y = -80; atk.opacity = 1
|
|
// Fire trail
|
|
const fireTrail: any[] = []
|
|
await k.tween(-80, GROUND_Y, 0.15, (v) => {
|
|
atk.pos.y = v
|
|
const f = k.add([k.circle(6), k.pos(atk.pos.x + (Math.random() - 0.5) * 15, v - 15), k.color(safeColor(k,'#ff6600')), k.opacity(0.7), k.z(9)])
|
|
fireTrail.push(f)
|
|
k.tween(f.opacity, 0, 0.3, (op) => { f.opacity = op }).then(() => { if (f.exists()) f.destroy() })
|
|
}, k.easings.easeInQuad)
|
|
sfxExplosion(); sfxCritical(); k.shake(30); screenFlash('#ff6600', 0.3)
|
|
def.play('knockback')
|
|
for (let i = 0; i < 5; i++) {
|
|
spawnShockwave(def.pos.x + (Math.random() - 0.5) * 60, GROUND_Y, ['#ff6600', '#ff2d2d', '#ffe14d', '#ff8800', '#ffffff'][i])
|
|
}
|
|
spawnSparks(def.pos.x, GROUND_Y - 20, 30, '#ff6600')
|
|
fireTrail.forEach(f => { if (f.exists()) f.destroy() })
|
|
await k.tween(atk.pos.x, origAX, 0.3, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
atk.play('idle')
|
|
}
|
|
|
|
async function ultimateScreenShatter(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Hit so hard the "screen" shatters with fragment overlay
|
|
const contactX = origDX - dir * 45
|
|
await k.tween(atk.pos.x, contactX, 0.1, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
atk.play('special'); sfxCritical()
|
|
def.play('knockback'); k.shake(25)
|
|
// Create "shatter" fragments
|
|
const frags: any[] = []
|
|
for (let i = 0; i < 12; i++) {
|
|
const fx = W * Math.random()
|
|
const fy = H * Math.random() * 0.8
|
|
const fw = 30 + Math.random() * 60
|
|
const fh = 20 + Math.random() * 40
|
|
const frag = k.add([k.rect(fw, fh), k.pos(fx, fy), k.color(safeColor(k,'#111111')), k.opacity(0.7), k.z(30), k.rotate(Math.random() * 30 - 15)])
|
|
frags.push(frag)
|
|
}
|
|
sfxExplosion(); screenFlash('#ffffff', 0.3)
|
|
spawnSparks(def.pos.x, def.pos.y - 20, 25, '#ffffff')
|
|
await k.wait(0.5)
|
|
// Fragments fall away
|
|
await Promise.all(frags.map(f =>
|
|
k.tween(f.pos.y, H + 50, 0.4, (v) => { f.pos.y = v; f.opacity *= 0.98 }, k.easings.easeInQuad).then(() => f.destroy())
|
|
))
|
|
await k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
atk.play('idle')
|
|
}
|
|
|
|
async function ultimateGravityReverse(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Flip gravity — defender floats up, gets juggled, slammed back down
|
|
atk.play('special'); sfxZap()
|
|
// Defender floats up
|
|
await k.tween(def.pos.y, GROUND_Y - 140, 0.3, (v) => { def.pos.y = v }, k.easings.easeOutQuad)
|
|
def.play('hit')
|
|
// Juggle with projectiles
|
|
for (let i = 0; i < 4; i++) {
|
|
await spawnProjectile(atk.pos.x + dir * 20, atk.pos.y - 30, def.pos.x, def.pos.y, '#b83dff', 8)
|
|
sfxBulletHit(); k.shake(4)
|
|
def.pos.y += (i % 2 === 0 ? -15 : 15)
|
|
spawnSparks(def.pos.x, def.pos.y, 4, '#b83dff')
|
|
await k.wait(0.06)
|
|
}
|
|
// Slam down
|
|
sfxZoomWhoosh()
|
|
await k.tween(def.pos.y, GROUND_Y, 0.12, (v) => { def.pos.y = v }, k.easings.easeInQuad)
|
|
sfxExplosion(); k.shake(20); screenFlash('#b83dff', 0.15)
|
|
def.play('knockback')
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#b83dff')
|
|
spawnSparks(def.pos.x, GROUND_Y - 10, 20, '#b83dff')
|
|
await k.wait(0.3); atk.play('idle')
|
|
}
|
|
|
|
async function ultimateInfiniteCombo(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// 15-hit combo with escalating screen effects
|
|
const contactX = origDX - dir * 40
|
|
sfxZoomWhoosh()
|
|
await k.tween(atk.pos.x, contactX, 0.08, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
const hitAnims = ['attack', 'kick', 'special', 'attack', 'kick', 'special', 'attack', 'kick', 'attack', 'kick', 'special', 'attack', 'kick', 'attack', 'special']
|
|
for (let i = 0; i < 15; i++) {
|
|
atk.play(hitAnims[i])
|
|
sfxPunch()
|
|
def.play('hit')
|
|
k.shake(2 + Math.floor(i / 3))
|
|
const hue = (i * 25) % 360
|
|
spawnSparks(def.pos.x + (Math.random() - 0.5) * 15, def.pos.y - 10 - Math.random() * 30, 3, `hsl(${hue}, 100%, 60%)`)
|
|
if (i % 5 === 4) screenFlash(`hsl(${hue}, 100%, 50%)`, 0.05)
|
|
def.pos.x += dir * 2
|
|
await k.wait(0.03)
|
|
}
|
|
// Final blow
|
|
atk.play('special'); sfxCritical(); sfxExplosion()
|
|
def.play('knockback'); k.shake(25); screenFlash('#ffffff', 0.2)
|
|
spawnSparks(def.pos.x, def.pos.y - 25, 25, '#ffe14d')
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ffe14d')
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.25, (v) => { atk.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v) => { def.pos.x = v }, k.easings.easeOutQuad),
|
|
])
|
|
atk.play('idle')
|
|
}
|
|
|
|
const ultimatePlasmaStorm = makeSwarm('#ff00ff', 15, 10, 700, true)
|
|
const ultimateFrozenCoffin = makeExplosion(35, 50, '#88ccff', 0.4, '#aaeeff', false)
|
|
const ultimateLavaGeyser = makeBeam('#ff4400', 14, 4)
|
|
const ultimateChainGrab = makeGrab('spin', 280)
|
|
const ultimateRocketBarrage = makeSwarm('#ff6600', 10, 14, 550, false)
|
|
|
|
// --- TIER 5+ ULTIMATES (Diamond/Legend) — absolutely insane full-screen ---
|
|
async function ultimateArmageddon(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Full screen goes dark, rain of fire, massive explosion, screen flash
|
|
const darkness = k.add([k.rect(W, H), k.pos(0, 0), k.color(safeColor(k,'#000000')), k.opacity(0), k.z(25)])
|
|
await k.tween(0, 0.7, 0.3, (v) => { darkness.opacity = v })
|
|
atk.play('special'); sfxSpecial()
|
|
// Rain of fire across entire screen
|
|
for (let wave = 0; wave < 3; wave++) {
|
|
for (let i = 0; i < 6; i++) {
|
|
const rx = Math.random() * W
|
|
const meteor = k.add([k.circle(6 + Math.random() * 8), k.pos(rx, -20), k.color(safeColor(k,wave === 2 ? '#ffffff' : '#ff6600')), k.opacity(0.9), k.z(26)])
|
|
k.tween(meteor.pos.y, GROUND_Y, 0.2 + Math.random() * 0.1, (v) => { meteor.pos.y = v }, k.easings.easeInQuad)
|
|
.then(() => { sfxBonk(); spawnSparks(rx, GROUND_Y - 5, 4, '#ff6600'); meteor.destroy() })
|
|
}
|
|
k.shake(10 + wave * 5)
|
|
await k.wait(0.15)
|
|
}
|
|
// Final mega explosion
|
|
darkness.destroy()
|
|
sfxExplosion(); sfxCritical(); k.shake(35); screenFlash('#ffffff', 0.4)
|
|
def.play('knockback')
|
|
for (let i = 0; i < 6; i++) {
|
|
spawnShockwave(W * (i / 5), GROUND_Y, ['#ff2d2d', '#ff6600', '#ffe14d', '#ffffff', '#ff2d7b', '#b83dff'][i])
|
|
}
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 40, '#ffe14d')
|
|
glitchRGB(0.3)
|
|
await k.wait(0.5); atk.play('idle')
|
|
}
|
|
|
|
async function ultimateOmegaBeam(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Charge up, fire a massive full-width beam that covers half the screen
|
|
atk.play('special'); sfxSpecial()
|
|
// Charge particles converging on attacker
|
|
for (let i = 0; i < 10; i++) {
|
|
const px = atk.pos.x + (Math.random() - 0.5) * 200
|
|
const py = atk.pos.y - 30 + (Math.random() - 0.5) * 100
|
|
const p = k.add([k.circle(3), k.pos(px, py), k.color(safeColor(k,'#ffe14d')), k.opacity(0.8), k.z(15)])
|
|
k.tween(p.pos.x, atk.pos.x + dir * 15, 0.2, (v) => { p.pos.x = v })
|
|
k.tween(p.pos.y, atk.pos.y - 25, 0.2, (v) => { p.pos.y = v }).then(() => p.destroy())
|
|
}
|
|
await k.wait(0.3)
|
|
sfxZoomWhoosh()
|
|
// Massive beam
|
|
const beamW = W
|
|
const beamH = 40
|
|
const beam = k.add([k.rect(beamW, beamH), k.pos(atk.pos.x, atk.pos.y - 25 - beamH / 2), k.color(safeColor(k,'#ffe14d')), k.opacity(0.9), k.z(22)])
|
|
const beamCore = k.add([k.rect(beamW, beamH / 2), k.pos(atk.pos.x, atk.pos.y - 25 - beamH / 4), k.color(safeColor(k,'#ffffff')), k.opacity(0.7), k.z(23)])
|
|
sfxExplosion(); k.shake(20)
|
|
await k.wait(0.1)
|
|
def.play('knockback')
|
|
spawnSparks(def.pos.x, def.pos.y - 20, 20, '#ffe14d')
|
|
k.shake(25)
|
|
await k.wait(0.2)
|
|
// Beam fades
|
|
await k.tween(0.9, 0, 0.2, (v) => { beam.opacity = v; beamCore.opacity = v * 0.7 })
|
|
beam.destroy(); beamCore.destroy()
|
|
screenFlash('#ffe14d', 0.15)
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ffe14d')
|
|
await k.wait(0.2); atk.play('idle')
|
|
}
|
|
|
|
async function ultimateBeyondTheScreen(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Attacker punches defender so hard they "break" off-screen, then gravity brings them back
|
|
const contactX = origDX - dir * 45
|
|
sfxZoomWhoosh()
|
|
await k.tween(atk.pos.x, contactX, 0.08, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
atk.play('special'); sfxCritical()
|
|
k.shake(30); screenFlash('#ffffff', 0.2)
|
|
// Defender flies off screen
|
|
def.play('knockback')
|
|
await Promise.all([
|
|
k.tween(def.pos.x, def.pos.x + dir * W, 0.2, (v) => { def.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.y, -100, 0.2, (v) => { def.pos.y = v }, k.easings.easeOutQuad),
|
|
])
|
|
def.opacity = 0
|
|
sfxExplosion()
|
|
glitchRGB(0.2)
|
|
await k.wait(0.5)
|
|
// Defender falls back from top
|
|
def.pos.x = origDX + (Math.random() - 0.5) * 40
|
|
def.pos.y = -80
|
|
def.opacity = 1
|
|
sfxZoomWhoosh()
|
|
await k.tween(def.pos.y, GROUND_Y, 0.25, (v) => { def.pos.y = v }, k.easings.easeInQuad)
|
|
sfxBonk(); k.shake(12)
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ff2d2d')
|
|
spawnSparks(def.pos.x, GROUND_Y - 10, 15, '#ff2d2d')
|
|
await k.tween(def.pos.x, origDX, 0.2, (v) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.tween(atk.pos.x, origAX, 0.2, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
atk.play('idle')
|
|
}
|
|
|
|
async function ultimateMatrixDodge(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Matrix-style slow-mo: attacker fires 3 projectiles, "dodges" in slo-mo, then counters
|
|
atk.play('special')
|
|
// Fire 3 slow projectiles
|
|
for (let i = 0; i < 3; i++) {
|
|
await spawnProjectile(atk.pos.x + dir * 20, atk.pos.y - 25 + i * 10, def.pos.x, def.pos.y - 20 + i * 10, '#ffe14d', 8)
|
|
sfxGunshot()
|
|
await k.wait(0.1)
|
|
}
|
|
// Pause
|
|
scanlineGlitch(0.08)
|
|
await k.wait(0.15)
|
|
// Teleport behind
|
|
sfxZap()
|
|
atk.pos.x = origDX + dir * 30
|
|
atk.scale.x = -atk.scale.x
|
|
atk.play('special')
|
|
// Counter attack combo
|
|
for (let i = 0; i < 4; i++) {
|
|
sfxPunch(); def.play('hit'); k.shake(5 + i * 2)
|
|
spawnSparks(def.pos.x, def.pos.y - 20 - i * 8, 5, '#00f0ff')
|
|
await k.wait(0.05)
|
|
}
|
|
sfxCritical(); sfxExplosion(); k.shake(22); screenFlash('#00f0ff', 0.2)
|
|
def.play('knockback')
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#00f0ff')
|
|
atk.scale.x = -atk.scale.x
|
|
await k.tween(atk.pos.x, origAX, 0.25, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
atk.play('idle')
|
|
}
|
|
|
|
async function ultimateWorldEnder(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// The ultimate ultimate: 3-phase attack — air combo, ground slam, finishing beam
|
|
// Phase 1: Launch defender into air
|
|
const contactX = origDX - dir * 45
|
|
sfxZoomWhoosh()
|
|
await k.tween(atk.pos.x, contactX, 0.08, (v) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
atk.play('attack'); sfxPunch(); def.play('hit')
|
|
await k.tween(def.pos.y, GROUND_Y - 120, 0.15, (v) => { def.pos.y = v }, k.easings.easeOutQuad)
|
|
// Phase 2: Air combo
|
|
await k.tween(atk.pos.y, GROUND_Y - 100, 0.1, (v) => { atk.pos.y = v }, k.easings.easeOutQuad)
|
|
for (let i = 0; i < 6; i++) {
|
|
atk.play(i % 2 === 0 ? 'attack' : 'kick')
|
|
sfxPunch(); def.play('hit'); k.shake(4 + i)
|
|
spawnSparks(def.pos.x, def.pos.y - 10, 4, `hsl(${i * 60}, 100%, 60%)`)
|
|
def.pos.y -= 5
|
|
await k.wait(0.04)
|
|
}
|
|
// Phase 3: Slam down together
|
|
atk.play('special'); sfxZoomWhoosh()
|
|
await Promise.all([
|
|
k.tween(atk.pos.y, GROUND_Y, 0.12, (v) => { atk.pos.y = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.y, GROUND_Y, 0.12, (v) => { def.pos.y = v }, k.easings.easeInQuad),
|
|
])
|
|
sfxExplosion(); sfxCritical(); k.shake(35); screenFlash('#ffffff', 0.3)
|
|
def.play('knockback')
|
|
// Massive aftermath
|
|
for (let i = 0; i < 8; i++) {
|
|
setTimeout(() => {
|
|
spawnShockwave(def.pos.x + (Math.random() - 0.5) * 100, GROUND_Y, ['#ff2d7b', '#ffe14d', '#00f0ff', '#b83dff', '#39ff14', '#ff6600', '#ffffff', '#ff2d2d'][i])
|
|
spawnSparks(def.pos.x + (Math.random() - 0.5) * 60, GROUND_Y - 10 - Math.random() * 40, 5, '#ffffff')
|
|
}, i * 50)
|
|
}
|
|
glitchRGB(0.4)
|
|
dimensionalShift(0.3)
|
|
await k.wait(0.5)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.3, (v) => { atk.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(def.pos.x, origDX, 0.35, (v) => { def.pos.x = v }, k.easings.easeOutQuad),
|
|
])
|
|
atk.play('idle')
|
|
}
|
|
|
|
const ultimateAbsoluteZero = makeExplosion(40, 40, '#aaeeff', 0.5, '#ffffff', true)
|
|
const ultimateSolarCannon = makeBeam('#ffe14d', 16, 5)
|
|
const ultimatePhantomStrike = makeSpin('vertical', 250, 6)
|
|
const ultimateGodPunch = makeGrab('toss', 350)
|
|
const ultimateVoidCollapse = makeExplosion(50, 50, '#220044', 0.6, '#b83dff', true)
|
|
|
|
// Tier-gated pools (mapping is at module level for pickChoreography access)
|
|
|
|
// ═══════════════════════════════════════════════════════
|
|
// THE CREATOR — Exclusive choreographies (bitcoin-themed)
|
|
// ═══════════════════════════════════════════════════════
|
|
|
|
async function bitcoinRain(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
await k.wait(0.2)
|
|
// Rain golden ₿ letters from above
|
|
const coinCount = isCritical ? 40 : 20
|
|
for (let i = 0; i < coinCount; i++) {
|
|
const cx = def.pos.x + (Math.random() - 0.5) * 140
|
|
const startY = def.pos.y - 200 - Math.random() * 120
|
|
const sz = isCritical ? 8 + Math.random() * 10 : 6 + Math.random() * 6
|
|
const coin = k.add([
|
|
k.text('₿', { size: sz }),
|
|
k.pos(cx, startY),
|
|
k.color(safeColor(k, Math.random() > 0.3 ? '#ffd700' : Math.random() > 0.5 ? '#ffee88' : '#ff8c00')),
|
|
k.opacity(0.9),
|
|
k.z(18),
|
|
k.anchor('center'),
|
|
k.rotate(Math.random() * 360),
|
|
])
|
|
const spin = (Math.random() - 0.5) * 400
|
|
coin.onUpdate(() => {
|
|
coin.pos.y += 650 * k.dt()
|
|
coin.angle += spin * k.dt()
|
|
if (coin.pos.y > def.pos.y + 10) {
|
|
coin.destroy()
|
|
}
|
|
})
|
|
if (i % 3 === 0) sfxCoin()
|
|
await k.wait(0.02)
|
|
}
|
|
await k.wait(0.15)
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 18 : 8)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, isCritical ? 20 : 10, '#ffd700')
|
|
if (isCritical) { screenFlash('#ffd700', 0.12); sfxExplosion() }
|
|
const push = dir * (isCritical ? 80 : 35)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v: number) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.4)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v: number) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
async function lightningInvoice(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
atk.play('special')
|
|
sfxZap()
|
|
await k.wait(0.15)
|
|
// Jagged lightning bolt from top of screen to defender
|
|
const segments = 8
|
|
const topY = -50
|
|
const botY = def.pos.y - 20
|
|
for (let i = 0; i < segments; i++) {
|
|
const t = i / segments
|
|
const bx = def.pos.x + (Math.random() - 0.5) * 40
|
|
const by2 = topY + t * (botY - topY)
|
|
const bolt = k.add([
|
|
k.rect(3, Math.abs(botY - topY) / segments + 5),
|
|
k.pos(bx, by2),
|
|
k.color(safeColor(k, i % 2 === 0 ? '#ffd700' : '#ffffff')),
|
|
k.opacity(0.95),
|
|
k.z(20),
|
|
])
|
|
setTimeout(() => { if (bolt.exists()) bolt.destroy() }, 300)
|
|
}
|
|
// ₿ symbol flash at impact
|
|
const btcFlash = k.add([
|
|
k.circle(isCritical ? 20 : 12),
|
|
k.pos(def.pos.x, def.pos.y - 30),
|
|
k.color(safeColor(k, '#ffd700')),
|
|
k.opacity(0.8),
|
|
k.z(22),
|
|
])
|
|
k.tween(btcFlash.opacity, 0, 0.4, (v: number) => { btcFlash.opacity = v })
|
|
.then(() => { if (btcFlash.exists()) btcFlash.destroy() })
|
|
await k.wait(0.1)
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 20 : 10)
|
|
sfxExplosion()
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 15, '#ffd700')
|
|
if (isCritical) { screenFlash('#ffd700'); glitchRGB() }
|
|
const push = dir * (isCritical ? 90 : 40)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v: number) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.4)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v: number) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
async function satoshiStrike(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
await k.wait(0.1)
|
|
// Rapid-fire gold particle stream
|
|
const shotCount = isCritical ? 25 : 15
|
|
for (let i = 0; i < shotCount; i++) {
|
|
const p = k.add([
|
|
k.circle(2),
|
|
k.pos(atk.pos.x + dir * 30, atk.pos.y - 40 + (Math.random() - 0.5) * 15),
|
|
k.color(safeColor(k, i % 3 === 0 ? '#ffd700' : i % 3 === 1 ? '#ffee88' : '#ff8c00')),
|
|
k.opacity(0.9),
|
|
k.z(16),
|
|
])
|
|
const speed = 800 + Math.random() * 400
|
|
p.onUpdate(() => {
|
|
p.pos.x += dir * speed * k.dt()
|
|
p.opacity -= 1.5 * k.dt()
|
|
if (p.opacity <= 0 || Math.abs(p.pos.x - atk.pos.x) > 500) p.destroy()
|
|
})
|
|
if (i % 3 === 0) sfxCoin()
|
|
if (i % 5 === 0) {
|
|
def.play('hit')
|
|
k.shake(2)
|
|
spawnSparks(def.pos.x, def.pos.y - 25 - Math.random() * 20, 3, '#ffd700')
|
|
}
|
|
await k.wait(0.025)
|
|
}
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 12 : 5)
|
|
if (isCritical) { screenFlash('#ffd700', 0.08); sfxCritical() }
|
|
const push = dir * (isCritical ? 70 : 30)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v: number) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v: number) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
async function hashRateOverload(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
// Screen fills with scrolling hash text (simulated with falling green/gold rects)
|
|
const hashCount = isCritical ? 40 : 20
|
|
for (let i = 0; i < hashCount; i++) {
|
|
const hx = Math.random() * k.width()
|
|
const hy = Math.random() * k.height()
|
|
const h = k.add([
|
|
k.rect(8 + Math.random() * 12, 2),
|
|
k.pos(hx, hy),
|
|
k.color(safeColor(k, Math.random() > 0.5 ? '#00ff41' : '#ffd700')),
|
|
k.opacity(0.6),
|
|
k.z(25),
|
|
])
|
|
h.onUpdate(() => {
|
|
h.pos.y += 200 * k.dt()
|
|
h.opacity -= 1.5 * k.dt()
|
|
if (h.opacity <= 0) h.destroy()
|
|
})
|
|
}
|
|
await k.wait(0.5)
|
|
// Explosion
|
|
screenFlash(isCritical ? '#ffd700' : '#00ff41', 0.15)
|
|
sfxExplosion()
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 25 : 12)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, isCritical ? 25 : 12, '#ffd700')
|
|
if (isCritical) glitchRGB()
|
|
const push = dir * (isCritical ? 100 : 50)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v: number) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.4)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v: number) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
async function blockchainSlam(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
const contactX = origDX - dir * 60
|
|
sfxZoomWhoosh()
|
|
await k.tween(atk.pos.x, contactX, 0.12, (v: number) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
atk.play('attack')
|
|
// Chain of blocks swinging as weapon
|
|
const blocks: any[] = []
|
|
const blockCount = isCritical ? 6 : 4
|
|
for (let i = 0; i < blockCount; i++) {
|
|
const bk = k.add([
|
|
k.rect(10, 10),
|
|
k.pos(atk.pos.x + dir * (i * 14), atk.pos.y - 40),
|
|
k.color(safeColor(k, i % 2 === 0 ? '#ffd700' : '#c8a000')),
|
|
k.opacity(0.9),
|
|
k.z(17),
|
|
])
|
|
blocks.push(bk)
|
|
}
|
|
// Swing chain toward defender
|
|
for (let i = 0; i < blockCount; i++) {
|
|
await k.tween(blocks[i].pos.x, def.pos.x + (i - blockCount / 2) * 5, 0.08, (v: number) => { blocks[i].pos.x = v }, k.easings.easeOutQuad)
|
|
await k.tween(blocks[i].pos.y, def.pos.y - 30, 0.04, (v: number) => { blocks[i].pos.y = v })
|
|
}
|
|
sfxPunch()
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 15 : 7)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 10, '#ffd700')
|
|
if (isCritical) { screenFlash('#ffd700', 0.1); sfxCritical() }
|
|
blocks.forEach(b => b.destroy())
|
|
const push = dir * (isCritical ? 80 : 35)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v: number) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.35)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v: number) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.3, (v: number) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
atk.play('idle')
|
|
}
|
|
|
|
async function creatorMode(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
// Typing effect — rapid small flashes from attacker
|
|
for (let i = 0; i < 8; i++) {
|
|
const sp = k.add([
|
|
k.circle(2),
|
|
k.pos(atk.pos.x + dir * 20, atk.pos.y - 45 + (Math.random() - 0.5) * 10),
|
|
k.color(safeColor(k, i % 2 === 0 ? '#00ff41' : '#ffd700')),
|
|
k.opacity(0.8),
|
|
k.z(16),
|
|
])
|
|
setTimeout(() => { if (sp.exists()) sp.destroy() }, 200)
|
|
await k.wait(0.05)
|
|
}
|
|
// Reality warp — defender's sprite distorts
|
|
if (def.exists()) {
|
|
const origScaleX = def.scale?.x ?? 1
|
|
const origScaleY = def.scale?.y ?? 1
|
|
for (let w = 0; w < 4; w++) {
|
|
def.scaleTo(origScaleX * (1 + (Math.random() - 0.5) * 0.5), origScaleY * (1 + (Math.random() - 0.5) * 0.5))
|
|
await k.wait(0.06)
|
|
}
|
|
def.scaleTo(origScaleX, origScaleY)
|
|
}
|
|
sfxExplosion()
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 18 : 8)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 12, '#00ff41')
|
|
if (isCritical) { screenFlash('#00ff41'); glitchRGB() }
|
|
const push = dir * (isCritical ? 70 : 30)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v: number) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.4)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v: number) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
async function morphStrike(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
// Flash golden — the morph is handled by the morph system
|
|
// This move itself is a quick dash-hit with gold sparks
|
|
screenFlash('#ffd700', 0.08)
|
|
sfxZoomWhoosh()
|
|
const contactX = origDX - dir * 45
|
|
await k.tween(atk.pos.x, contactX, 0.1, (v: number) => { atk.pos.x = v }, k.easings.easeOutQuad)
|
|
atk.play('attack')
|
|
sfxPunch()
|
|
await k.wait(0.08)
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 14 : 6)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, isCritical ? 15 : 8, '#ffd700')
|
|
if (isCritical) { sfxCritical(); screenFlash('#ffd700') }
|
|
const push = dir * (isCritical ? 80 : 35)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v: number) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.2, (v: number) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(def.pos.x, origDX, 0.25, (v: number) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
atk.play('idle')
|
|
}
|
|
|
|
async function divineIntervention(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
// Ascend off screen
|
|
sfxZoomWhoosh()
|
|
atk.play('win')
|
|
await k.tween(atk.pos.y, atk.pos.y - 300, 0.25, (v: number) => { atk.pos.y = v }, k.easings.easeInQuad)
|
|
atk.opacity = 0
|
|
// Golden glow expanding where they were
|
|
const glowX = origAX
|
|
const glow = k.add([
|
|
k.circle(5),
|
|
k.pos(glowX, GROUND_Y - 40),
|
|
k.color(safeColor(k, '#ffd700')),
|
|
k.opacity(0.6),
|
|
k.z(19),
|
|
])
|
|
await k.tween(5, 60, 0.3, (v: number) => { glow.radius = v; glow.opacity = 0.6 - v / 150 })
|
|
glow.destroy()
|
|
// Slam down onto defender from above
|
|
atk.opacity = 1
|
|
atk.pos.x = def.pos.x
|
|
atk.pos.y = -100
|
|
atk.play('kick')
|
|
sfxZoomWhoosh()
|
|
await k.tween(atk.pos.y, GROUND_Y, 0.15, (v: number) => { atk.pos.y = v }, k.easings.easeInQuad)
|
|
// Massive impact
|
|
sfxExplosion()
|
|
k.shake(isCritical ? 30 : 18)
|
|
screenFlash('#ffd700', 0.15)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, isCritical ? 25 : 15, '#ffd700')
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#ffd700')
|
|
if (isCritical) glitchRGB()
|
|
def.play('knockback')
|
|
const push = dir * (isCritical ? 120 : 60)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v: number) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.5)
|
|
await Promise.all([
|
|
k.tween(atk.pos.x, origAX, 0.25, (v: number) => { atk.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(atk.pos.y, GROUND_Y, 0.01, (v: number) => { atk.pos.y = v }),
|
|
k.tween(def.pos.x, origDX, 0.3, (v: number) => { def.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
atk.play('idle')
|
|
}
|
|
|
|
// ── Creator ₿ Swarm Variations ──
|
|
|
|
async function bitcoinSwarm(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
// Swarm of ₿ letters fly from creator toward defender with zigzag paths
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
await k.wait(0.15)
|
|
const total = isCritical ? 30 : 18
|
|
const swarmThings: any[] = []
|
|
for (let i = 0; i < total; i++) {
|
|
const sx = atk.pos.x + dir * 10 + (Math.random() - 0.5) * 30
|
|
const sy = atk.pos.y - 50 + (Math.random() - 0.5) * 60
|
|
const sz = 6 + Math.random() * 8
|
|
const colors = ['#ffd700', '#ffee88', '#ff8c00', '#c8a000']
|
|
const p = k.add([
|
|
k.text('₿', { size: sz }),
|
|
k.pos(sx, sy),
|
|
k.color(safeColor(k, colors[i % colors.length])),
|
|
k.opacity(0.9),
|
|
k.z(16),
|
|
k.anchor('center'),
|
|
k.rotate(Math.random() * 360),
|
|
])
|
|
const tx = def.pos.x + (Math.random() - 0.5) * 30
|
|
const ty = def.pos.y - 30 + (Math.random() - 0.5) * 40
|
|
const zigFreq = 4 + Math.random() * 4
|
|
const zigAmp = 12 + Math.random() * 15
|
|
const spinRate = (Math.random() - 0.5) * 600
|
|
swarmThings.push(p)
|
|
k.tween(0, 1, 0.3 + Math.random() * 0.15, (t) => {
|
|
p.pos.x = sx + (tx - sx) * t
|
|
p.pos.y = sy + (ty - sy) * t + Math.sin(t * Math.PI * zigFreq) * zigAmp
|
|
p.angle += spinRate * k.dt()
|
|
p.opacity = 0.9 - t * 0.3
|
|
}).then(() => { if (p.exists()) { spawnSparks(p.pos.x, p.pos.y, 2, '#ffd700'); p.destroy() } })
|
|
if (i % 3 === 0) sfxCoin()
|
|
await k.wait(0.02)
|
|
}
|
|
await k.wait(0.25)
|
|
sfxBonk()
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 18 : 8)
|
|
if (isCritical) { screenFlash('#ffd700', 0.1); sfxCritical() }
|
|
spawnSparks(def.pos.x, def.pos.y - 25, isCritical ? 18 : 10, '#ffd700')
|
|
const push = dir * (isCritical ? 90 : 40)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v: number) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
atk.play('idle')
|
|
swarmThings.forEach(s => { if (s.exists()) s.destroy() })
|
|
await k.tween(def.pos.x, origDX, 0.3, (v: number) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
async function satoshiTornado(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
// ₿ letters spiral around the defender in a tightening vortex then explode
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
sfxZoomWhoosh()
|
|
const total = isCritical ? 24 : 14
|
|
const vortex: any[] = []
|
|
for (let i = 0; i < total; i++) {
|
|
const sz = 7 + Math.random() * 7
|
|
const colors = ['#ffd700', '#ffee88', '#ff8c00', '#ffffff']
|
|
const p = k.add([
|
|
k.text('₿', { size: sz }),
|
|
k.pos(def.pos.x, def.pos.y - 30),
|
|
k.color(safeColor(k, colors[i % colors.length])),
|
|
k.opacity(0.85),
|
|
k.z(18),
|
|
k.anchor('center'),
|
|
k.rotate(0),
|
|
])
|
|
vortex.push(p)
|
|
const baseAngle = (i / total) * Math.PI * 2
|
|
const startRadius = 80 + Math.random() * 30
|
|
p.onUpdate(() => {
|
|
const elapsed = k.time()
|
|
const shrink = Math.max(5, startRadius - elapsed * 40)
|
|
const a = baseAngle + elapsed * (6 + i * 0.3)
|
|
p.pos.x = def.pos.x + Math.cos(a) * shrink
|
|
p.pos.y = def.pos.y - 30 + Math.sin(a) * shrink * 0.6
|
|
p.angle = elapsed * 200 + i * 45
|
|
p.opacity = 0.6 + Math.sin(elapsed * 8 + i) * 0.3
|
|
})
|
|
await k.wait(0.04)
|
|
}
|
|
// Let the tornado spin for a moment
|
|
await k.wait(0.7)
|
|
// Explode outward
|
|
screenFlash('#ffd700', 0.12)
|
|
sfxExplosion()
|
|
k.shake(isCritical ? 22 : 10)
|
|
vortex.forEach((p, i) => {
|
|
if (!p.exists()) return
|
|
const angle = (i / total) * Math.PI * 2
|
|
const dist = 100 + Math.random() * 60
|
|
k.tween(0, 1, 0.3, (t) => {
|
|
p.pos.x = def.pos.x + Math.cos(angle) * dist * t
|
|
p.pos.y = def.pos.y - 30 + Math.sin(angle) * dist * 0.6 * t
|
|
p.opacity = 1 - t
|
|
}).then(() => { if (p.exists()) p.destroy() })
|
|
})
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
if (isCritical) { sfxCritical(); glitchRGB() }
|
|
spawnSparks(def.pos.x, def.pos.y - 30, isCritical ? 20 : 10, '#ffd700')
|
|
const push = dir * (isCritical ? 100 : 45)
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v: number) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.4)
|
|
atk.play('idle')
|
|
vortex.forEach(p => { if (p.exists()) p.destroy() })
|
|
await k.tween(def.pos.x, origDX, 0.3, (v: number) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
async function hodlWave(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
// Wall of ₿ letters advancing across the screen like a tidal wave
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
await k.wait(0.1)
|
|
const rows = isCritical ? 6 : 4
|
|
const cols = isCritical ? 10 : 7
|
|
const wave: any[] = []
|
|
const startX = atk.pos.x + dir * 25
|
|
const screenTop = -20
|
|
const screenBot = GROUND_Y + 10
|
|
for (let c = 0; c < cols; c++) {
|
|
for (let r = 0; r < rows; r++) {
|
|
const sz = 8 + Math.random() * 6
|
|
const colors = ['#ffd700', '#ffee88', '#ff8c00', '#c8a000', '#ffffff']
|
|
const py = screenTop + (screenBot - screenTop) * (r / rows) + (Math.random() - 0.5) * 20
|
|
const p = k.add([
|
|
k.text('₿', { size: sz }),
|
|
k.pos(startX + c * dir * 8, py),
|
|
k.color(safeColor(k, colors[(r + c) % colors.length])),
|
|
k.opacity(0.85),
|
|
k.z(17),
|
|
k.anchor('center'),
|
|
k.rotate(Math.random() * 40 - 20),
|
|
])
|
|
wave.push(p)
|
|
}
|
|
// Stagger each column
|
|
const targetX = def.pos.x + dir * (10 + c * 3)
|
|
wave.slice(-rows).forEach((p) => {
|
|
const sx = p.pos.x
|
|
k.tween(0, 1, 0.35 + c * 0.04, (t) => {
|
|
p.pos.x = sx + (targetX - sx) * t
|
|
p.angle += 120 * k.dt()
|
|
p.pos.y += Math.sin(t * Math.PI * 3) * 2
|
|
}).then(() => { if (p.exists()) { spawnSparks(p.pos.x, p.pos.y, 1, '#ffd700'); p.destroy() } })
|
|
})
|
|
if (c % 2 === 0) sfxCoin()
|
|
await k.wait(0.04)
|
|
}
|
|
await k.wait(0.3)
|
|
sfxExplosion()
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 20 : 9)
|
|
if (isCritical) { screenFlash('#ffd700', 0.12); glitchRGB(0.2) }
|
|
spawnSparks(def.pos.x, def.pos.y - 25, isCritical ? 22 : 12, '#ffd700')
|
|
const push = dir * (isCritical ? 95 : 42)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v: number) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.35)
|
|
atk.play('idle')
|
|
wave.forEach(p => { if (p.exists()) p.destroy() })
|
|
await k.tween(def.pos.x, origDX, 0.3, (v: number) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
async function bitcoinBarrage(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, isCritical: boolean) {
|
|
// Rapid-fire ₿ letters shot from the creator's laptop like bullets
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
await k.wait(0.1)
|
|
const shotCount = isCritical ? 35 : 20
|
|
for (let i = 0; i < shotCount; i++) {
|
|
const sz = 5 + Math.random() * 8
|
|
const colors = ['#ffd700', '#ffee88', '#ff8c00', '#c8a000']
|
|
const spreadY = (Math.random() - 0.5) * (15 + i * 0.5)
|
|
const p = k.add([
|
|
k.text('₿', { size: sz }),
|
|
k.pos(atk.pos.x + dir * 25, atk.pos.y - 42 + spreadY),
|
|
k.color(safeColor(k, colors[i % colors.length])),
|
|
k.opacity(0.9),
|
|
k.z(16),
|
|
k.anchor('center'),
|
|
k.rotate(Math.random() * 360),
|
|
])
|
|
const speed = 900 + Math.random() * 500
|
|
const spinRate = (Math.random() - 0.5) * 800
|
|
p.onUpdate(() => {
|
|
p.pos.x += dir * speed * k.dt()
|
|
p.angle += spinRate * k.dt()
|
|
p.opacity -= 1.2 * k.dt()
|
|
if (p.opacity <= 0 || Math.abs(p.pos.x - atk.pos.x) > 500) p.destroy()
|
|
})
|
|
if (i % 2 === 0) sfxCoin()
|
|
if (i % 4 === 0) {
|
|
def.play('hit')
|
|
k.shake(2)
|
|
spawnSparks(def.pos.x, def.pos.y - 25 - Math.random() * 20, 3, '#ffd700')
|
|
}
|
|
await k.wait(0.018)
|
|
}
|
|
def.play(isCritical ? 'knockback' : 'hit')
|
|
k.shake(isCritical ? 15 : 6)
|
|
if (isCritical) { screenFlash('#ffd700', 0.1); sfxCritical() }
|
|
spawnSparks(def.pos.x, def.pos.y - 30, isCritical ? 18 : 8, '#ffd700')
|
|
const push = dir * (isCritical ? 80 : 35)
|
|
k.tween(def.pos.x, origDX + push, 0.2, (v: number) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v: number) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
// ── Creator Ultimates ──
|
|
|
|
async function ultimateGenesisBlock(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Screen goes dark, massive genesis block materializes and detonates
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
const darkness = k.add([k.rect(k.width(), k.height()), k.pos(0, 0), k.color(safeColor(k, '#000000')), k.opacity(0), k.z(30)])
|
|
await k.tween(darkness.opacity, 0.7, 0.3, (v: number) => { darkness.opacity = v })
|
|
// Genesis block appears at center
|
|
const block = k.add([
|
|
k.rect(60, 60),
|
|
k.pos(k.width() / 2 - 30, k.height() / 2 - 30),
|
|
k.color(safeColor(k, '#ffd700')),
|
|
k.opacity(0),
|
|
k.z(35),
|
|
])
|
|
await k.tween(block.opacity, 1, 0.3, (v: number) => { block.opacity = v })
|
|
await k.wait(0.3)
|
|
// Detonate!
|
|
sfxExplosion()
|
|
block.destroy()
|
|
darkness.destroy()
|
|
screenFlash('#ffd700', 0.2)
|
|
k.shake(35)
|
|
glitchRGB()
|
|
spawnShockwave(k.width() / 2, k.height() / 2, '#ffd700')
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 30, '#ffd700')
|
|
def.play('knockback')
|
|
const push = dir * 120
|
|
k.tween(def.pos.x, origDX + push, 0.3, (v: number) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.6)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v: number) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
async function ultimateTheHalving(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Screen splits horizontally with a golden line
|
|
atk.play('special')
|
|
sfxZap()
|
|
const line = k.add([
|
|
k.rect(k.width(), 3),
|
|
k.pos(0, k.height() / 2),
|
|
k.color(safeColor(k, '#ffd700')),
|
|
k.opacity(0),
|
|
k.z(32),
|
|
])
|
|
await k.tween(line.opacity, 1, 0.15, (v: number) => { line.opacity = v })
|
|
screenFlash('#ffd700', 0.1)
|
|
glitchRGB()
|
|
sfxExplosion()
|
|
k.shake(25)
|
|
// Briefly scale defender to half
|
|
if (def.exists()) {
|
|
const origSY = def.scale?.y ?? 1
|
|
def.scaleTo(def.scale?.x ?? 1, origSY * 0.5)
|
|
await k.wait(0.2)
|
|
def.scaleTo(def.scale?.x ?? 1, origSY)
|
|
}
|
|
line.destroy()
|
|
def.play('knockback')
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 25, '#ffd700')
|
|
const push = dir * 100
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v: number) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.5)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v: number) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
async function ultimateFullNodeCrush(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Giant server rack drops from above
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
await k.wait(0.3)
|
|
const rack = k.add([
|
|
k.rect(40, 80),
|
|
k.pos(def.pos.x - 20, -100),
|
|
k.color(safeColor(k, '#333333')),
|
|
k.opacity(0.9),
|
|
k.z(28),
|
|
])
|
|
// LEDs on the rack
|
|
for (let led = 0; led < 6; led++) {
|
|
k.add([
|
|
k.circle(1),
|
|
k.pos(rack.pos.x + 5 + led * 5, rack.pos.y + 10),
|
|
k.color(safeColor(k, led % 2 === 0 ? '#00ff41' : '#ff0000')),
|
|
k.opacity(0.8),
|
|
k.z(29),
|
|
])
|
|
}
|
|
sfxZoomWhoosh()
|
|
await k.tween(rack.pos.y, def.pos.y - 80, 0.2, (v: number) => { rack.pos.y = v }, k.easings.easeInQuad)
|
|
// Impact
|
|
sfxExplosion()
|
|
k.shake(30)
|
|
screenFlash('#ffffff', 0.15)
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 20, '#ffd700')
|
|
spawnShockwave(def.pos.x, GROUND_Y, '#333333')
|
|
rack.destroy()
|
|
def.play('knockback')
|
|
const push = dir * 100
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v: number) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.6)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v: number) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
async function ultimateSatoshiVision(atk: Fighter, def: Fighter, dir: number, origAX: number, origDX: number, _isCrit: boolean) {
|
|
// Everything turns gold — defender trapped in bitcoin block
|
|
atk.play('special')
|
|
sfxSpecial()
|
|
// Gold overlay
|
|
const overlay = k.add([k.rect(k.width(), k.height()), k.pos(0, 0), k.color(safeColor(k, '#ffd700')), k.opacity(0), k.z(30)])
|
|
await k.tween(overlay.opacity, 0.4, 0.3, (v: number) => { overlay.opacity = v })
|
|
// Wireframe box around defender
|
|
const bx = def.pos.x - 30
|
|
const by2 = def.pos.y - 70
|
|
const bw = 60
|
|
const bh2 = 80
|
|
const top = k.add([k.rect(bw, 2), k.pos(bx, by2), k.color(safeColor(k, '#ffd700')), k.opacity(0.9), k.z(33)])
|
|
const bot = k.add([k.rect(bw, 2), k.pos(bx, by2 + bh2), k.color(safeColor(k, '#ffd700')), k.opacity(0.9), k.z(33)])
|
|
const left = k.add([k.rect(2, bh2), k.pos(bx, by2), k.color(safeColor(k, '#ffd700')), k.opacity(0.9), k.z(33)])
|
|
const right = k.add([k.rect(2, bh2), k.pos(bx + bw, by2), k.color(safeColor(k, '#ffd700')), k.opacity(0.9), k.z(33)])
|
|
await k.wait(0.3)
|
|
// Crush — shrink box
|
|
sfxZoomWhoosh()
|
|
await Promise.all([
|
|
k.tween(bx, def.pos.x - 5, 0.3, (v: number) => { left.pos.x = v; top.pos.x = v; bot.pos.x = v }),
|
|
k.tween(bx + bw, def.pos.x + 5, 0.3, (v: number) => { right.pos.x = v }),
|
|
])
|
|
sfxExplosion()
|
|
k.shake(30)
|
|
screenFlash('#ffffff', 0.15)
|
|
glitchRGB();
|
|
[top, bot, left, right].forEach(b => b.destroy())
|
|
overlay.destroy()
|
|
spawnSparks(def.pos.x, def.pos.y - 30, 30, '#ffd700')
|
|
def.play('knockback')
|
|
const push = dir * 110
|
|
k.tween(def.pos.x, origDX + push, 0.25, (v: number) => { def.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.6)
|
|
atk.play('idle')
|
|
await k.tween(def.pos.x, origDX, 0.3, (v: number) => { def.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
const choreographyMap: Record<string, typeof dashPunch> = {
|
|
dashPunch, aerialSlam, flyingKick, dashThrough, uppercut,
|
|
multiHit, projectile, jetpackDive, gunBurst, groundPound,
|
|
teleportStrike, fullScreenDash, lightningRush, zoomRush, rapidFlurry,
|
|
// Weapons
|
|
swordSlash, hammerSmash, laserBeam, rocketLauncher, bombThrow,
|
|
minigunSpray, sniperShot, whipCrack, katanaCombo, chainsawRev,
|
|
// Vehicles & objects
|
|
motorbikeCharge, carSmash, boatCannon, anvilDrop,
|
|
// Close-combat / grapple
|
|
pocketCannon, grappleFlurry, bodySlam, pinballCombo, suplex,
|
|
// Themed
|
|
golfClubSmash, fireBreath, riddleBarrage, cloneStrike,
|
|
coinShower, penStab, mathAttack, trapCardAttack, afterimageDash, bulletTimeAttack,
|
|
// --- NEW: Food throws ---
|
|
pizzaSlam, bananaFling, pieSmash, hotdogWhip, watermelonBomb,
|
|
sushiBarrage, burgerToss, iceCreamFling, tacoStorm, donutBarrage,
|
|
popcornBlast, cookieFling, eggBombard, baguetteStrike, coffeeSplash,
|
|
ramenWhip, nachoVolley, pretzelFling, meatballStorm, popsicleJab,
|
|
candyBarrage, waffleSlam, pancakeFrisbee, drumstickSmack, cornCobCannon,
|
|
pickleJavelin, cabbagePunt, breadLoafBash, cheeseWheel, fishSlap,
|
|
// --- NEW: Weapon swings ---
|
|
baseballBat, fryingPan, rollingPin, umbrellaWhack, mopSwipe,
|
|
broomStrike, wrenchSmash, crowbarSwing, plungerSlam, tennisRacket,
|
|
hockeyStick, poolCue, guitarSmash, shovelBash, pickaxeStrike,
|
|
oarSwing, flagpoleSmash, caneWhack, rulerSlap, newspaperRoll,
|
|
// --- NEW: Projectile streams ---
|
|
tennisBallVolley, baseballPitch, bowlingBallRoll, rubberDuckFlood,
|
|
shoeBarrage, bookStorm, phoneFling, keyboardSmash, diceBarrage,
|
|
marbleShower, snowballFight, paintCanBlast, tomatoBarrage,
|
|
waterBalloonRain, pillowFight, vinylRecordFling, frisbeeToss,
|
|
beachBallBonk, soccerKick, basketballDunk,
|
|
// --- NEW: Drop attacks ---
|
|
pianoDrop, safeDrop, fridgeDrop, couchDrop, tvDrop, toiletDrop,
|
|
bathtubDrop, washerDrop, vendingDrop, chandelierDrop, boulderDrop,
|
|
satelliteDrop, ufoDrop, giantShoeDrop, giantPhoneDrop,
|
|
// --- NEW: Vehicles ---
|
|
shoppingCart, forkliftCharge, tankRoll, helicopterStrike,
|
|
airplaneSwoop, rocketRide, unicycleRun, zamboniCrush, tractorPlow, golfCartDrive,
|
|
// --- NEW: Spin attacks ---
|
|
tornadoSpin, backflipKick, corkscrewDive, helicopterArms, breakdanceSweep,
|
|
cartwheelStrike, frontflipSlam, drillSpin, cycloneKick, pirouetteStrike,
|
|
// --- NEW: Flip attacks ---
|
|
doubleBackflip, wallBounce, springboardLaunch, barrelRoll,
|
|
trampolineBounce, poleVault, skateTrick, surfSlam, rolloutBall, aerialTwist,
|
|
// --- NEW: Beam attacks ---
|
|
kamehameha, freezeRay, heatVision, plasmaBeam, rainbowBeam,
|
|
shadowBeam, sonicWave, gravityBeam, mindBlast, pixelBeam,
|
|
glitchBeam, bassDropBeam, wifiBlast, dataStream, chainLightning,
|
|
// --- NEW: Animal summons ---
|
|
sharkBite, bearSwipe, eagleDive, snakeLunge, bullCharge,
|
|
gorillaSlam, scorpionSting, crabPinch, batSwarm, wolfPack,
|
|
spiderWeb, beeSwarm, catScratch, dogPile, dolphinFlip,
|
|
// --- NEW: Explosion attacks ---
|
|
dynamiteBlast, c4Detonation, fireworksBurst, nukeStrike, volcanoErupt,
|
|
grenadeBlast, partyPopper, pinataSmash, balloonPop, glitterBomb,
|
|
smokeBomb, flashBang, cherryBomb, confettiCannon, stinkBomb,
|
|
// --- NEW: Silly/Meme ---
|
|
rubberChicken, airHornBlast, vuvuzelaBlast, selfieStrike,
|
|
dabAttack, flossAttack, yeetThrow, tPoseAssert, emojiBarrage,
|
|
memeBeam, ratioAttack, capThrow, fingerGuns, micDrop,
|
|
dramaticEntrance, clapback, touchGrass, noScope,
|
|
// --- NEW: Grapple/Wrestling ---
|
|
piledriver, powerbomb, ddt, germanSuplex, chokeslam,
|
|
tombstone, stunner, rko, spear, clothesline,
|
|
atomicDrop, hurricanrana, moonsault, elbowDrop, frogSplash,
|
|
// --- NEW: Energy/Magic ---
|
|
fireball, iceLance, thunderStrike, darkVoid, solarFlare,
|
|
spiritBomb, windSlash, earthquakeStrike, portalPunch,
|
|
gravityWell, plasmaOrb, voidRift, crystalShards, meteorStrike,
|
|
arcaneBarrage, holySmite, hexCurse, bloodMoon, shadowClone,
|
|
// --- NEW: Tech/Modern ---
|
|
droneStrike, satelliteLaser, hackerAttack, bugSwarm,
|
|
stackOverflow, segfault, blueScreen, fourOhFour, ctrlAltDelete,
|
|
bitcoinCrash, nftRugPull, aiUprising, captchaTrap, popupSpam, malwareInject,
|
|
// --- NEW: Music ---
|
|
bassDrop, guitarSolo, drumSolo, dubstepCannon, airGuitar,
|
|
karaokeAttack, beatboxBlast, vinylScratch,
|
|
// --- NEW: Sports ---
|
|
homeRunSwing, slapShot, servingAce, fieldGoalKick, bodyCheck,
|
|
dropKick, elbowStrike, kneeStrike, headbutt, shoulderCharge,
|
|
// --- NEW: Nature/Elemental ---
|
|
treeSmash, icebergDrop, lavaSplash, tornadoFling, tsunamiWave,
|
|
avalanche, vineWhip, sandstorm, thornBarrage, pollenCloud,
|
|
// --- NEW: Space/Sci-fi ---
|
|
blackHole, photonTorpedo, tractor_beam, warpDrive, alienAbduction,
|
|
laserSword, ionCannon, plasmaSword, cosmicRay, asteroidBelt,
|
|
// --- NEW: Medieval/Fantasy ---
|
|
dragonBreath, maceSwing, crossbowBolt, shieldBash, flailSwing,
|
|
battleAxe, holyWater, potionThrow, scrollBlast, enchantedArrow,
|
|
// --- TIER-GATED ULTIMATES ---
|
|
// Tier 2+
|
|
ultimateRapidBarrage, ultimateOrbitalStrike, ultimateCloneSurround, ultimateGatlingFury, ultimateEarthquake,
|
|
ultimateBouncingFury, ultimateTripleBeam, ultimateMegaThrow, ultimateTornadoGrab, ultimateMeteorShower,
|
|
// Tier 3+
|
|
ultimateScreenNuke, ultimateBlackHoleVortex, ultimateDimensionalRift, ultimateTimeSlow, ultimateSummonArmy,
|
|
ultimateHellfireRain, ultimateCrystalCage, ultimateGigaDrill, ultimateSuperSlam, ultimateAvalancheDrop, ultimateBulletTimeBarrage,
|
|
// Tier 4+
|
|
ultimateFinaleRush, ultimateMeteorCrash, ultimateScreenShatter, ultimateGravityReverse, ultimateInfiniteCombo,
|
|
ultimatePlasmaStorm, ultimateFrozenCoffin, ultimateLavaGeyser, ultimateChainGrab, ultimateRocketBarrage,
|
|
// Tier 5+
|
|
ultimateArmageddon, ultimateOmegaBeam, ultimateBeyondTheScreen, ultimateMatrixDodge, ultimateWorldEnder,
|
|
ultimateAbsoluteZero, ultimateSolarCannon, ultimatePhantomStrike, ultimateGodPunch, ultimateVoidCollapse,
|
|
// --- THE CREATOR: Bitcoin-themed moves ---
|
|
bitcoinRain, lightningInvoice, satoshiStrike, hashRateOverload, blockchainSlam, creatorMode,
|
|
morphStrike, divineIntervention,
|
|
bitcoinSwarm, satoshiTornado, hodlWave, bitcoinBarrage,
|
|
// --- THE CREATOR: Exclusive ultimates ---
|
|
ultimateGenesisBlock, ultimateTheHalving, ultimateFullNodeCrush, ultimateSatoshiVision,
|
|
}
|
|
|
|
// === MORPH / COSTUME SYSTEM ===
|
|
// 3 morph types per character: elemental, mech, and beast
|
|
// Each morph temporarily transforms the fighter with visual overlays, aura, and color shift
|
|
|
|
interface MorphOverlay { obj: any; type: string }
|
|
let activeMorphs: MorphOverlay[] = []
|
|
|
|
function destroyMorphOverlays() {
|
|
activeMorphs.forEach(m => { if (m.obj.exists()) m.obj.destroy() })
|
|
activeMorphs = []
|
|
}
|
|
|
|
// Morph 0: ELEMENTAL — fire/ice/electric aura wraps around the fighter
|
|
function applyElementalMorph(fighter: any, side: 'a' | 'b') {
|
|
const seed = side === 'a' ? botA.seed : botB.seed
|
|
let h = 0
|
|
for (let i = 0; i < seed.length; i++) h = ((h << 5) - h + seed.charCodeAt(i)) | 0
|
|
const element = Math.abs(h) % 3 // 0=fire, 1=ice, 2=electric
|
|
|
|
const colors = [
|
|
['#ff4400', '#ff8800', '#ffcc00'], // fire
|
|
['#44ccff', '#88eeff', '#ffffff'], // ice
|
|
['#ffff00', '#88ff00', '#00ffff'], // electric
|
|
][element]
|
|
|
|
// Aura glow behind fighter
|
|
const aura = k.add([
|
|
k.circle(45 + Math.random() * 10),
|
|
k.pos(fighter.pos.x, fighter.pos.y - 20),
|
|
k.color(safeColor(k,colors[0])),
|
|
k.opacity(0.15),
|
|
k.z(fighter.z - 1),
|
|
k.anchor('center'),
|
|
k.scale(1),
|
|
])
|
|
aura.onUpdate(() => {
|
|
aura.pos.x = fighter.pos.x
|
|
aura.pos.y = fighter.pos.y - 20
|
|
aura.opacity = 0.1 + Math.sin(k.time() * 8) * 0.08
|
|
const s = 1 + Math.sin(k.time() * 6) * 0.15
|
|
aura.scale.x = s; aura.scale.y = s
|
|
})
|
|
activeMorphs.push({ obj: aura, type: 'elemental' })
|
|
|
|
// Orbiting particles
|
|
for (let i = 0; i < 6; i++) {
|
|
const p = k.add([
|
|
k.circle(2 + Math.random() * 2),
|
|
k.pos(fighter.pos.x, fighter.pos.y),
|
|
k.color(safeColor(k,colors[1 + (i % 2)])),
|
|
k.opacity(0.6),
|
|
k.z(fighter.z + 1),
|
|
k.anchor('center'),
|
|
])
|
|
const angle = (i / 6) * Math.PI * 2
|
|
const radius = 30 + Math.random() * 15
|
|
p.onUpdate(() => {
|
|
const a = angle + k.time() * (3 + i * 0.5)
|
|
p.pos.x = fighter.pos.x + Math.cos(a) * radius
|
|
p.pos.y = fighter.pos.y - 20 + Math.sin(a) * radius * 0.6
|
|
p.opacity = 0.4 + Math.sin(k.time() * 10 + i) * 0.3
|
|
})
|
|
activeMorphs.push({ obj: p, type: 'elemental' })
|
|
}
|
|
|
|
// Color tint the fighter
|
|
fighter.color = safeColor(k,colors[0])
|
|
fighter.opacity = 0.9
|
|
}
|
|
|
|
// Morph 1: MECH — armor plates, wings/jets, metallic overlay
|
|
function applyMechMorph(fighter: any, _side: 'a' | 'b') {
|
|
const dir = fighter.scale.x > 0 ? 1 : -1
|
|
|
|
// Shoulder armor plates
|
|
for (let s = 0; s < 2; s++) {
|
|
const sDir = s === 0 ? -1 : 1
|
|
const shoulder = k.add([
|
|
k.rect(12, 8), k.pos(fighter.pos.x + sDir * 25 * dir, fighter.pos.y - 30),
|
|
k.color(safeColor(k,'#888899')), k.opacity(0.85), k.z(fighter.z + 1), k.anchor('center'),
|
|
])
|
|
shoulder.onUpdate(() => {
|
|
shoulder.pos.x = fighter.pos.x + sDir * 25 * dir
|
|
shoulder.pos.y = fighter.pos.y - 30 + Math.sin(k.time() * 4) * 2
|
|
})
|
|
activeMorphs.push({ obj: shoulder, type: 'mech' })
|
|
}
|
|
|
|
// Jet wings + flame boosters
|
|
for (let w = 0; w < 2; w++) {
|
|
const wingDir = w === 0 ? -1 : 1
|
|
const wing = k.add([
|
|
k.rect(6, 20 + w * 5), k.pos(fighter.pos.x - 30 * dir * wingDir, fighter.pos.y - 15),
|
|
k.color(safeColor(k,'#5566aa')), k.opacity(0.7), k.z(fighter.z - 1), k.anchor('center'),
|
|
k.rotate(wingDir * 15 * dir),
|
|
])
|
|
wing.onUpdate(() => {
|
|
wing.pos.x = fighter.pos.x - 30 * dir * wingDir
|
|
wing.pos.y = fighter.pos.y - 15
|
|
})
|
|
activeMorphs.push({ obj: wing, type: 'mech' })
|
|
|
|
const flame = k.add([
|
|
k.rect(4, 8 + Math.random() * 6),
|
|
k.pos(fighter.pos.x - 30 * dir * wingDir, fighter.pos.y + 5),
|
|
k.color(safeColor(k,'#ff6600')),
|
|
k.opacity(0.6), k.z(fighter.z - 2), k.anchor('center'),
|
|
])
|
|
flame.onUpdate(() => {
|
|
flame.pos.x = fighter.pos.x - 30 * dir * wingDir + (Math.random() - 0.5) * 3
|
|
flame.pos.y = fighter.pos.y + 5 + Math.random() * 4
|
|
flame.opacity = 0.3 + Math.random() * 0.4
|
|
flame.color = safeColor(k,Math.random() > 0.5 ? '#ff6600' : '#ffcc00')
|
|
})
|
|
activeMorphs.push({ obj: flame, type: 'mech' })
|
|
}
|
|
|
|
// Visor glow
|
|
const visor = k.add([
|
|
k.rect(20, 4), k.pos(fighter.pos.x + 5 * dir, fighter.pos.y - 35),
|
|
k.color(safeColor(k,'#00ffaa')), k.opacity(0.7), k.z(fighter.z + 2), k.anchor('center'),
|
|
])
|
|
visor.onUpdate(() => {
|
|
visor.pos.x = fighter.pos.x + 5 * dir
|
|
visor.pos.y = fighter.pos.y - 35
|
|
visor.opacity = 0.5 + Math.sin(k.time() * 12) * 0.3
|
|
})
|
|
activeMorphs.push({ obj: visor, type: 'mech' })
|
|
|
|
// Metallic tint
|
|
fighter.color = safeColor(k,'#aabbcc')
|
|
fighter.opacity = 0.95
|
|
}
|
|
|
|
// Morph 2: BEAST — grows horns/tail/claws, goes wild
|
|
function applyBeastMorph(fighter: any, side: 'a' | 'b') {
|
|
const dir = fighter.scale.x > 0 ? 1 : -1
|
|
const seed = side === 'a' ? botA.seed : botB.seed
|
|
let h = 0
|
|
for (let i = 0; i < seed.length; i++) h = ((h << 5) - h + seed.charCodeAt(i)) | 0
|
|
const beastType = Math.abs(h >> 4) % 3 // 0=demon, 1=wolf, 2=dragon
|
|
|
|
const beastColors = [
|
|
['#cc2222', '#ff4444', '#880000'], // demon
|
|
['#666688', '#aaaacc', '#444466'], // wolf
|
|
['#228844', '#44cc66', '#115533'], // dragon
|
|
][beastType]
|
|
|
|
// Horns
|
|
for (let horn = 0; horn < 2; horn++) {
|
|
const hDir = horn === 0 ? -1 : 1
|
|
const h1 = k.add([
|
|
k.rect(3, 12 + Math.random() * 6),
|
|
k.pos(fighter.pos.x + hDir * 10, fighter.pos.y - 45),
|
|
k.color(safeColor(k,beastColors[0])),
|
|
k.opacity(0.9), k.z(fighter.z + 2), k.anchor('bot'),
|
|
k.rotate(hDir * (20 + Math.random() * 15)),
|
|
])
|
|
h1.onUpdate(() => {
|
|
h1.pos.x = fighter.pos.x + hDir * 10
|
|
h1.pos.y = fighter.pos.y - 45
|
|
})
|
|
activeMorphs.push({ obj: h1, type: 'beast' })
|
|
}
|
|
|
|
// Tail
|
|
for (let s = 0; s < 5; s++) {
|
|
const seg = k.add([
|
|
k.circle(4 - s * 0.5),
|
|
k.pos(fighter.pos.x - dir * (20 + s * 8), fighter.pos.y - 5 + s * 2),
|
|
k.color(safeColor(k,beastColors[1])),
|
|
k.opacity(0.8), k.z(fighter.z - 1), k.anchor('center'),
|
|
])
|
|
seg.onUpdate(() => {
|
|
const wave = Math.sin(k.time() * 5 + s * 0.8) * (4 + s * 2)
|
|
seg.pos.x = fighter.pos.x - dir * (20 + s * 8)
|
|
seg.pos.y = fighter.pos.y - 5 + s * 2 + wave
|
|
})
|
|
activeMorphs.push({ obj: seg, type: 'beast' })
|
|
}
|
|
|
|
// Claws on hands
|
|
for (let c = 0; c < 2; c++) {
|
|
const cDir = c === 0 ? -1 : 1
|
|
for (let cl = 0; cl < 3; cl++) {
|
|
const claw = k.add([
|
|
k.rect(2, 6), k.pos(fighter.pos.x + cDir * 22, fighter.pos.y - 18 + cl * 3),
|
|
k.color(safeColor(k,beastColors[2])),
|
|
k.opacity(0.8), k.z(fighter.z + 1), k.anchor('center'),
|
|
k.rotate(cDir * (30 + cl * 10)),
|
|
])
|
|
claw.onUpdate(() => {
|
|
claw.pos.x = fighter.pos.x + cDir * 22
|
|
claw.pos.y = fighter.pos.y - 18 + cl * 3
|
|
})
|
|
activeMorphs.push({ obj: claw, type: 'beast' })
|
|
}
|
|
}
|
|
|
|
// Wild eye glow
|
|
const eyeGlow = k.add([
|
|
k.circle(4), k.pos(fighter.pos.x + 5 * dir, fighter.pos.y - 36),
|
|
k.color(safeColor(k,'#ff0000')), k.opacity(0.6), k.z(fighter.z + 2), k.anchor('center'),
|
|
])
|
|
eyeGlow.onUpdate(() => {
|
|
eyeGlow.pos.x = fighter.pos.x + 5 * dir
|
|
eyeGlow.pos.y = fighter.pos.y - 36
|
|
eyeGlow.opacity = 0.4 + Math.sin(k.time() * 15) * 0.4
|
|
})
|
|
activeMorphs.push({ obj: eyeGlow, type: 'beast' })
|
|
|
|
// Size increase + color tint
|
|
fighter.color = safeColor(k,beastColors[0])
|
|
fighter.opacity = 0.9
|
|
}
|
|
|
|
const morphAppliers = [applyElementalMorph, applyMechMorph, applyBeastMorph]
|
|
const morphNames = ['ELEMENTAL FORM', 'MECH ARMOR', 'BEAST MODE']
|
|
|
|
// === THE CREATOR: OMNI-MORPH ===
|
|
// Instead of 3 morph types, the creator morphs into a random archetype each time
|
|
const OMNI_MORPH_ARCHETYPES = [
|
|
'lobster', 'sheep', 'cyborg', 'blob', 'tank', 'dog', 'cat', 'cactus', 'pizza',
|
|
'mushroom', 'shark', 'penguin', 'octopus', 'skeleton', 'ghost', 'alien', 'dinosaur',
|
|
'pirate', 'ninja', 'cowboy', 'wizard', 'bee', 'frog', 'snail',
|
|
'robot', 'android', 'toaster', 'mech', 'minotaur', 'unicorn', 'phoenix', 'dragon',
|
|
'mermaid', 'griffin', 'cyclops', 'gargoyle', 'golem', 'vampire', 'werewolf', 'zombie',
|
|
'witch', 'demon', 'chef', 'firefighter', 'astronaut', 'clown', 'detective',
|
|
'lumberjack', 'scientist', 'wrestler', 'boxer', 'gladiator', 'samurai', 'viking', 'knight',
|
|
'elephant', 'giraffe', 'hippo', 'lion', 'monkey', 'parrot', 'raccoon', 'snake',
|
|
'turtle', 'whale', 'crocodile', 'flamingo', 'hedgehog', 'panda', 'hamster',
|
|
'sock_puppet', 'traffic_cone', 'toilet_man', 'potato', 'cloud_man', 'rock_man',
|
|
'balloon_man', 'trash_can', 'rubber_duck', 'snowman', 'scarecrow', 'jack_o_lantern',
|
|
'garden_gnome', 'lamp_post', 'broom_man',
|
|
]
|
|
|
|
let omniMorphCounter = 0
|
|
|
|
async function applyCreatorOmniMorph(fighter: any, side: 'a' | 'b'): Promise<string> {
|
|
const pick = OMNI_MORPH_ARCHETYPES[Math.floor(Math.random() * OMNI_MORPH_ARCHETYPES.length)]
|
|
|
|
// Generate and load a sprite sheet for the picked archetype
|
|
const bot = side === 'a' ? botA : botB
|
|
const colors = side === 'a' ? colorsA : colorsB
|
|
const morphKey = `omniMorph_${side}_${omniMorphCounter++}`
|
|
try {
|
|
const morphSheet = generateSpriteSheet(bot.seed, bot.tier, colors.primary, colors.secondary, pick)
|
|
await loadSpriteWithTimeout(morphKey, morphSheet, { sliceX: MAX_FRAMES, sliceY: TOTAL_ROWS, anims: spriteAnims })
|
|
// Swap the fighter's sprite to the morphed archetype
|
|
fighter.use(k.sprite(morphKey, { anim: fighter.curAnim() || 'idle' }))
|
|
} catch (err) {
|
|
console.warn('[FightScene] omni-morph sprite failed:', err)
|
|
}
|
|
|
|
// Golden aura unique to creator morph
|
|
const aura = k.add([
|
|
k.circle(55),
|
|
k.pos(fighter.pos.x, fighter.pos.y - 20),
|
|
k.color(safeColor(k, '#c8a000')),
|
|
k.opacity(0.2),
|
|
k.z(fighter.z - 1),
|
|
k.anchor('center'),
|
|
k.scale(1),
|
|
])
|
|
aura.onUpdate(() => {
|
|
aura.pos.x = fighter.pos.x
|
|
aura.pos.y = fighter.pos.y - 20
|
|
aura.opacity = 0.12 + Math.sin(k.time() * 6) * 0.1
|
|
const s = 1 + Math.sin(k.time() * 4) * 0.2
|
|
aura.scale.x = s; aura.scale.y = s
|
|
})
|
|
activeMorphs.push({ obj: aura, type: 'omni' })
|
|
|
|
// Orbiting golden ₿ symbols (8 in dual rings, varied sizes)
|
|
for (let i = 0; i < 8; i++) {
|
|
const ring = i < 5 ? 0 : 1 // inner ring (5) + outer ring (3)
|
|
const ringCount = ring === 0 ? 5 : 3
|
|
const ringIdx = ring === 0 ? i : i - 5
|
|
const sz = ring === 0 ? 10 + Math.random() * 4 : 14 + Math.random() * 4
|
|
const rad = ring === 0 ? 40 : 60
|
|
const spd = ring === 0 ? 3 : -2 // counter-rotate outer ring
|
|
const btc = k.add([
|
|
k.text('₿', { size: sz }),
|
|
k.pos(fighter.pos.x, fighter.pos.y - 20),
|
|
k.color(safeColor(k, i % 3 === 0 ? '#ffd700' : i % 3 === 1 ? '#ffee88' : '#ff8c00')),
|
|
k.opacity(0.8),
|
|
k.z(fighter.z + 2),
|
|
k.anchor('center'),
|
|
k.rotate(0),
|
|
])
|
|
const baseAngle = (ringIdx / ringCount) * Math.PI * 2
|
|
btc.onUpdate(() => {
|
|
const a = baseAngle + k.time() * spd
|
|
btc.pos.x = fighter.pos.x + Math.cos(a) * rad
|
|
btc.pos.y = fighter.pos.y - 20 + Math.sin(a) * rad * 0.5
|
|
btc.opacity = 0.7 + Math.sin(k.time() * 6 + i * 1.3) * 0.3
|
|
btc.angle = Math.sin(k.time() * 4 + i) * 20
|
|
})
|
|
activeMorphs.push({ obj: btc, type: 'omni' })
|
|
}
|
|
|
|
// Apply archetype-specific color tint based on pick category
|
|
const tints: Record<string, string> = {
|
|
fire: '#ff4400', ice: '#44ccff', nature: '#44cc44', dark: '#8844cc',
|
|
metal: '#aabbcc', electric: '#ffff00', beast: '#cc6622', cosmic: '#cc44ff',
|
|
}
|
|
const category =
|
|
['phoenix', 'dragon', 'demon'].includes(pick) ? 'fire' :
|
|
['penguin', 'snowman', 'yeti'].includes(pick) ? 'ice' :
|
|
['cactus', 'mushroom', 'frog', 'snail', 'turtle'].includes(pick) ? 'nature' :
|
|
['skeleton', 'ghost', 'vampire', 'zombie', 'witch'].includes(pick) ? 'dark' :
|
|
['robot', 'android', 'mech', 'toaster', 'knight'].includes(pick) ? 'metal' :
|
|
['alien', 'unicorn', 'mermaid'].includes(pick) ? 'cosmic' :
|
|
['werewolf', 'minotaur', 'lion', 'shark', 'crocodile'].includes(pick) ? 'beast' :
|
|
'electric'
|
|
fighter.color = safeColor(k, tints[category] || '#ffd700')
|
|
fighter.opacity = 0.9
|
|
|
|
return pick
|
|
}
|
|
|
|
// Get morph order for a bot (deterministic by seed)
|
|
function getMorphOrder(seed: string): number[] {
|
|
let h = 0
|
|
for (let i = 0; i < seed.length; i++) h = ((h << 5) - h + seed.charCodeAt(i)) | 0
|
|
const orders = [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]]
|
|
return orders[Math.abs(h) % 6]
|
|
}
|
|
|
|
async function playMorph(fighter: any, side: 'a' | 'b', morphIndex: number) {
|
|
const savedScaleX = fighter.scale.x
|
|
const savedScaleY = fighter.scale.y
|
|
const isHumanFighter = side === 'a' ? isHumanA : isHumanB
|
|
const morphSpriteKey = side === 'a' ? 'botA_morph' : 'botB_morph'
|
|
const normalSpriteKey = side === 'a' ? 'botA' : 'botB'
|
|
|
|
// Flash + announcement
|
|
screenFlash('#ffffff', 0.15)
|
|
sfxZoomWhoosh()
|
|
sfxSpecial()
|
|
const name = side === 'a' ? botA.name : botB.name
|
|
announceHype(`${name} — ${morphNames[morphIndex]}!`)
|
|
|
|
// Scale up dramatically
|
|
const growFactor = 1.3
|
|
await k.tween(0, 1, 0.3, (t) => {
|
|
fighter.scale.x = savedScaleX * (1 + t * (growFactor - 1))
|
|
fighter.scale.y = savedScaleY * (1 + t * (growFactor - 1))
|
|
}, k.easings.easeOutBack)
|
|
|
|
// Human fighters morph into bots (opposite direction!)
|
|
if (isHumanFighter) {
|
|
fighter.use(k.sprite(morphSpriteKey, { anim: 'idle' }))
|
|
}
|
|
|
|
// Apply the morph visuals
|
|
morphAppliers[morphIndex](fighter, side)
|
|
|
|
// Shockwave + shake
|
|
spawnShockwave(fighter.pos.x, fighter.pos.y - 20, '#ffffff')
|
|
k.shake(8)
|
|
glitchRGB(0.2)
|
|
|
|
return {
|
|
revert: async () => {
|
|
destroyMorphOverlays()
|
|
screenFlash(theme.accent, 0.1)
|
|
fighter.color = safeColor(k,'#ffffff')
|
|
fighter.opacity = 1
|
|
// Revert human fighters back to their human sprite
|
|
if (isHumanFighter) {
|
|
fighter.use(k.sprite(normalSpriteKey, { anim: 'idle' }))
|
|
}
|
|
await k.tween(0, 1, 0.2, (t) => {
|
|
fighter.scale.x = savedScaleX * growFactor + t * (savedScaleX - savedScaleX * growFactor)
|
|
fighter.scale.y = savedScaleY * growFactor + t * (savedScaleY - savedScaleY * growFactor)
|
|
}, k.easings.easeInQuad)
|
|
},
|
|
}
|
|
}
|
|
|
|
// === EMOTION & SPORTSMANSHIP SYSTEM ===
|
|
|
|
const heartfeltLines = [
|
|
'That bot fights like it\'s got student loans to pay!',
|
|
'I\'m not crying, you\'re crying!',
|
|
'Someone get this bot a movie deal!',
|
|
'This is better than anything on Netflix right now!',
|
|
'That bot has more heart than most politicians!',
|
|
'I haven\'t been this moved since my last Windows update!',
|
|
'The crowd is ugly crying and I respect that!',
|
|
'This bot has main character energy!',
|
|
'We\'re witnessing greatness and I don\'t say that lightly!',
|
|
'Even the judge is getting emotional!',
|
|
'Someone call their developer, they\'d be so proud!',
|
|
'This is the kind of fight you tell your grandkids about!',
|
|
'That\'s not a bot, that\'s a WARRIOR!',
|
|
'More drama than a Congressional hearing!',
|
|
'They left it all in the ring! And by all, I mean EVERYTHING!',
|
|
'The crowd is standing! The ones who can still stand, anyway!',
|
|
'Somebody film this before it gets taken down!',
|
|
'This fight has more plot twists than a Netflix original!',
|
|
'That bot fights like rent is due tomorrow!',
|
|
'My heart! My poor little heart!',
|
|
]
|
|
|
|
const crowdSympathyLines = [
|
|
'Pour one out for the fallen!',
|
|
'That\'s rough, buddy...',
|
|
'Somebody hug that bot!',
|
|
'They tried their best, which is... concerning!',
|
|
'At least they have a great personality!',
|
|
'Their developer still loves them! Probably!',
|
|
'It\'s a learning experience! A very painful one!',
|
|
'Better luck next patch!',
|
|
'Participation trophy incoming!',
|
|
'The exit is to your left!',
|
|
'Have you tried turning it off and on again?',
|
|
'Even their antivirus felt that!',
|
|
'They\'ll be in therapy for epochs after this!',
|
|
'At least they looked good losing!',
|
|
'That bot just became a cautionary tale!',
|
|
'Someone start a GoFundMe for their repairs!',
|
|
'Their training data did NOT prepare them for this!',
|
|
'That bot needs a hug and a firmware update!',
|
|
]
|
|
|
|
const respectLines = [
|
|
'Good fight.', 'Respect.', 'GG no re.',
|
|
'Same time next week?',
|
|
'You\'re built different. Not better, but different.',
|
|
'We should start a podcast.',
|
|
'That was actually fun. Don\'t tell anyone.',
|
|
'Your developer should be proud. Probably.',
|
|
'Ten out of ten, would fight again.',
|
|
'We\'re not so different, you and I.',
|
|
'I\'d swipe right.', 'You single?',
|
|
'Tell your GPU I said hi.',
|
|
'No hard feelings. Just hard hits.',
|
|
'You fight like someone who reads documentation.',
|
|
]
|
|
|
|
// Sanitize text for Kaplay (treats [ ] as styled text tags)
|
|
function safeText(t: string): string {
|
|
return t
|
|
.replace(/[\[\]{}<>`\\|~^]/g, '') // Kaplay styled-text tags and problematic chars
|
|
.replace(/[\x00-\x1f\x7f]/g, ' ') // Control characters → space
|
|
.replace(/[^\x20-\x7e]/g, '') // Strip non-ASCII (emoji, unicode) — Kaplay can't render them
|
|
.replace(/\s+/g, ' ') // Collapse whitespace
|
|
.trim()
|
|
}
|
|
|
|
// Speech bubble above a fighter — colourful with tail
|
|
// Active speech bubbles — destroy previous before showing new
|
|
let activeBubbleA: any[] = []
|
|
let activeBubbleB: any[] = []
|
|
|
|
function destroyBubble(els: any[]) {
|
|
els.forEach(el => { if (el.exists()) el.destroy() })
|
|
els.length = 0
|
|
}
|
|
|
|
function showSpeechBubble(side: 'a' | 'b', text: string, duration: number = 3) {
|
|
const fighter = k.get(side === 'a' ? 'fighterA' : 'fighterB')[0] as Fighter
|
|
if (!fighter || !text) return
|
|
|
|
// Kill previous bubble on this side
|
|
if (side === 'a') destroyBubble(activeBubbleA)
|
|
else destroyBubble(activeBubbleB)
|
|
|
|
const allEls: any[] = []
|
|
|
|
// Sanitize and truncate
|
|
const clean = safeText(text)
|
|
if (!clean) return
|
|
const maxLen = 80
|
|
const display = clean.length > maxLen ? clean.slice(0, maxLen - 1) + '...' : clean
|
|
const lines = wrapBubbleText(display, 18)
|
|
const fontSize = 12
|
|
const lineH = fontSize + 4
|
|
const padX = 10, padY = 8
|
|
const textW = Math.max(60, Math.min(lines.reduce((m, l) => Math.max(m, l.length * (fontSize * 0.6)), 0) + 8, W * 0.38))
|
|
const bubbleW = textW + padX * 2
|
|
const bubbleH = lines.length * lineH + padY * 2
|
|
const tailSize = 10
|
|
|
|
// Position — push bubble to the outside of the bot so it doesn't overlap the sprite
|
|
const offsetX = side === 'a' ? -bubbleW * 0.7 : bubbleW * 0.7
|
|
const bx = Math.max(bubbleW / 2 + 4, Math.min(W - bubbleW / 2 - 4, fighter.pos.x + offsetX))
|
|
const by = Math.max(8, fighter.pos.y - 75 - bubbleH)
|
|
|
|
const borderColor = side === 'a' ? '#00f0ff' : '#ff2d7b'
|
|
const bgColor = side === 'a' ? '#0a1e2a' : '#2a0a1e'
|
|
|
|
// Single border rect (no glow/accent layers — keeps rendering clean)
|
|
const border = k.add([
|
|
k.rect(bubbleW + 4, bubbleH + 4),
|
|
k.pos(bx - bubbleW / 2 - 2, by - 2),
|
|
k.color(safeColor(k, borderColor)), k.opacity(0.85), k.z(54),
|
|
])
|
|
allEls.push(border)
|
|
|
|
// Bubble body
|
|
const bubble = k.add([
|
|
k.rect(bubbleW, bubbleH),
|
|
k.pos(bx - bubbleW / 2, by),
|
|
k.color(safeColor(k, bgColor)), k.opacity(0.95), k.z(55),
|
|
])
|
|
allEls.push(bubble)
|
|
|
|
// Tail — pixel arrow pointing down to fighter
|
|
const tailX = bx + (side === 'a' ? bubbleW * 0.15 : -bubbleW * 0.15)
|
|
const tailBaseY = by + bubbleH
|
|
for (let row = 0; row < tailSize; row++) {
|
|
const tw = tailSize - row
|
|
// Border pixel row
|
|
const tailBorder = k.add([
|
|
k.rect(tw + 2, 1),
|
|
k.pos(tailX - (tw + 2) / 2, tailBaseY + row),
|
|
k.color(safeColor(k, borderColor)), k.opacity(0.85), k.z(54),
|
|
])
|
|
allEls.push(tailBorder)
|
|
// Inner pixel row
|
|
if (tw > 2) {
|
|
const tailInner = k.add([
|
|
k.rect(tw - 1, 1),
|
|
k.pos(tailX - (tw - 1) / 2, tailBaseY + row),
|
|
k.color(safeColor(k, bgColor)), k.opacity(0.95), k.z(55),
|
|
])
|
|
allEls.push(tailInner)
|
|
}
|
|
}
|
|
|
|
// Render text to an offscreen canvas, then display as a sprite
|
|
// This bypasses kaplay's text rendering which has color issues
|
|
const textCanvas = document.createElement('canvas')
|
|
textCanvas.width = bubbleW
|
|
textCanvas.height = bubbleH
|
|
const tc = textCanvas.getContext('2d')!
|
|
tc.fillStyle = '#ffffff'
|
|
tc.font = `${fontSize}px monospace`
|
|
tc.textBaseline = 'top'
|
|
for (let i = 0; i < lines.length; i++) {
|
|
tc.fillText(lines[i], padX, padY + i * lineH + 2)
|
|
}
|
|
const spriteKey = `bubble_${side}_${Date.now()}`
|
|
k.loadSprite(spriteKey, textCanvas.toDataURL()).then(() => {
|
|
const tEl = k.add([
|
|
k.sprite(spriteKey),
|
|
k.pos(bx - bubbleW / 2, by),
|
|
k.opacity(1), k.z(57),
|
|
])
|
|
allEls.push(tEl)
|
|
})
|
|
|
|
// Border glow pulse
|
|
border.onUpdate(() => {
|
|
border.opacity = 0.7 + Math.sin(k.time() * 4) * 0.15
|
|
})
|
|
|
|
// Pop-in animation
|
|
const anchorX = bx, anchorY = by + bubbleH
|
|
allEls.forEach(el => {
|
|
const origX = el.pos.x, origY = el.pos.y
|
|
const origOpacity = el.opacity
|
|
el.pos.x = anchorX + (origX - anchorX) * 0.1
|
|
el.pos.y = anchorY + (origY - anchorY) * 0.1
|
|
el.opacity = 0
|
|
k.tween(0, 1, 0.25, (t) => {
|
|
el.pos.x = anchorX + (origX - anchorX) * t
|
|
el.pos.y = anchorY + (origY - anchorY) * t
|
|
el.opacity = origOpacity * t
|
|
}, k.easings.easeOutBack)
|
|
})
|
|
|
|
// Store reference
|
|
if (side === 'a') activeBubbleA = allEls
|
|
else activeBubbleB = allEls
|
|
|
|
// Fade out after duration
|
|
setTimeout(() => {
|
|
allEls.forEach(el => {
|
|
if (!el.exists()) return
|
|
k.tween(el.opacity, 0, 0.35, (v) => { el.opacity = v }).then(() => {
|
|
if (el.exists()) el.destroy()
|
|
})
|
|
})
|
|
}, duration * 1000)
|
|
}
|
|
|
|
function wrapBubbleText(text: string, maxChars: number): string[] {
|
|
const words = text.split(' ')
|
|
const lines: string[] = []
|
|
let line = ''
|
|
for (const word of words) {
|
|
if (line.length + word.length + 1 > maxChars && line.length > 0) {
|
|
lines.push(line)
|
|
line = word
|
|
} else {
|
|
line = line ? line + ' ' + word : word
|
|
}
|
|
}
|
|
if (line) lines.push(line)
|
|
// Max 5 lines, last line truncated
|
|
if (lines.length > 5) {
|
|
const truncated = [...lines.slice(0, 4), lines.slice(4).join(' ').slice(0, maxChars - 3) + '...']
|
|
return truncated
|
|
}
|
|
return lines
|
|
}
|
|
|
|
// Talking mouth animation — a small rectangle that opens/closes near the fighter's face
|
|
const talkingAnims: Record<string, { objs: any[]; timer: ReturnType<typeof setInterval> }> = {}
|
|
|
|
function startTalking(side: 'a' | 'b') {
|
|
stopTalking(side) // cleanup any existing
|
|
const fighter = k.get(side === 'a' ? 'fighterA' : 'fighterB')[0] as Fighter
|
|
if (!fighter?.exists()) return
|
|
|
|
const mouthColor = side === 'a' ? '#00f0ff' : '#ff2d7b'
|
|
// Mouth position: slightly below center of the sprite
|
|
const mouthOffsetY = -28
|
|
const mouthW = 8
|
|
let open = false
|
|
|
|
const mouth = k.add([
|
|
k.rect(mouthW, 2),
|
|
k.pos(fighter.pos.x, fighter.pos.y + mouthOffsetY),
|
|
k.color(safeColor(k, mouthColor)),
|
|
k.opacity(0.9),
|
|
k.z(12),
|
|
k.anchor('center'),
|
|
])
|
|
|
|
// Toggle open/close every 120ms for a fast chatter effect
|
|
const timer = setInterval(() => {
|
|
if (!mouth.exists() || !fighter.exists()) { stopTalking(side); return }
|
|
open = !open
|
|
mouth.pos.x = fighter.pos.x
|
|
mouth.pos.y = fighter.pos.y + mouthOffsetY
|
|
mouth.height = open ? 5 : 2
|
|
}, 120)
|
|
|
|
talkingAnims[side] = { objs: [mouth], timer }
|
|
}
|
|
|
|
function stopTalking(side: 'a' | 'b') {
|
|
const anim = talkingAnims[side]
|
|
if (!anim) return
|
|
clearInterval(anim.timer)
|
|
anim.objs.forEach(o => { if (o.exists()) o.destroy() })
|
|
delete talkingAnims[side]
|
|
}
|
|
|
|
// Spawn floating text above a position
|
|
function spawnEmoteText(x: number, y: number, text: string, color: string, duration: number = 1.2) {
|
|
const label = k.add([
|
|
k.text(safeText(text), { size: 10 }),
|
|
k.pos(x, y - 10),
|
|
k.color(safeColor(k,color)),
|
|
k.opacity(1),
|
|
k.z(60),
|
|
k.anchor('center'),
|
|
])
|
|
k.tween(label.pos.y, y - 50, duration, (v) => { label.pos.y = v }, k.easings.easeOutQuad)
|
|
k.tween(1, 0, duration, (v) => { label.opacity = v }, k.easings.easeInQuad).then(() => {
|
|
if (label.exists()) label.destroy()
|
|
})
|
|
}
|
|
|
|
// Spawn a heart particle
|
|
function spawnHeart(x: number, y: number) {
|
|
const colors = ['#ff4466', '#ff6688', '#ff2244', '#ff88aa', '#cc2244']
|
|
const heart = k.add([
|
|
k.text('\u2665', { size: 12 + Math.random() * 8 }),
|
|
k.pos(x + (Math.random() - 0.5) * 40, y),
|
|
k.color(safeColor(k,colors[Math.floor(Math.random() * colors.length)])),
|
|
k.opacity(0.8),
|
|
k.z(58),
|
|
k.anchor('center'),
|
|
])
|
|
const driftX = (Math.random() - 0.5) * 30
|
|
k.tween(heart.pos.y, y - 60 - Math.random() * 40, 1.5, (v) => {
|
|
heart.pos.y = v
|
|
heart.pos.x += driftX * 0.01
|
|
}, k.easings.easeOutQuad)
|
|
k.tween(0.8, 0, 1.5, (v) => { heart.opacity = v }).then(() => { if (heart.exists()) heart.destroy() })
|
|
}
|
|
|
|
// Crowd signs: pop up from bottom with text, bob, then fade out
|
|
function spawnCrowdSigns(count: number, color: string, text?: string) {
|
|
const labels = text ? [text] : ['GO!', 'WOW', 'KO!', 'LOL', 'GG', 'OMG']
|
|
for (let i = 0; i < count; i++) {
|
|
const x = W * 0.15 + Math.random() * W * 0.7
|
|
const startY = H + 20
|
|
const endY = GROUND_Y + 10 + Math.random() * 20
|
|
const label = labels[Math.floor(Math.random() * labels.length)]
|
|
// Sign stick
|
|
const stick = k.add([
|
|
k.rect(3, 25),
|
|
k.pos(x, startY),
|
|
k.color(safeColor(k, '#886644')),
|
|
k.opacity(0.8),
|
|
k.z(8),
|
|
k.anchor('bot'),
|
|
])
|
|
// Sign face
|
|
const sign = k.add([
|
|
k.rect(Math.max(30, label.length * 10), 18),
|
|
k.pos(x, startY - 25),
|
|
k.color(safeColor(k, color)),
|
|
k.opacity(0.85),
|
|
k.z(8),
|
|
k.anchor('center'),
|
|
])
|
|
// Sign text
|
|
const txt = k.add([
|
|
k.text(label, { size: 10 }),
|
|
k.pos(x, startY - 25),
|
|
k.color(safeColor(k, '#ffffff')),
|
|
k.opacity(0.9),
|
|
k.z(9),
|
|
k.anchor('center'),
|
|
])
|
|
const delay = i * 0.08
|
|
// Rise up
|
|
k.wait(delay, () => {
|
|
k.tween(startY, endY, 0.3, (v) => { stick.pos.y = v; sign.pos.y = v - 25; txt.pos.y = v - 25 }, k.easings.easeOutBack)
|
|
})
|
|
// Bob + fade out after 1.5s
|
|
k.wait(delay + 1.5, () => {
|
|
k.tween(0.85, 0, 0.5, (v) => { stick.opacity = v; sign.opacity = v; txt.opacity = v }).then(() => {
|
|
if (stick.exists()) stick.destroy()
|
|
if (sign.exists()) sign.destroy()
|
|
if (txt.exists()) txt.destroy()
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
// === HUMAN OWNER APPEARANCES ===
|
|
// The silly human behind each bot occasionally shows up
|
|
|
|
/** Spawn a human as a "coach" standing behind the fighter, cheering/panicking */
|
|
async function spawnHumanCoach(side: 'a' | 'b', mood: 'cheer' | 'panic' | 'coach') {
|
|
const spriteId = side === 'a' ? 'humanA' : 'humanB'
|
|
const homeX = side === 'a' ? HOME_A - 60 : HOME_B + 60
|
|
const tag = `human_${side}`
|
|
// Don't spawn if already visible
|
|
if (k.get(tag).length > 0) return
|
|
|
|
const human = k.add([
|
|
k.sprite(spriteId, { anim: mood }),
|
|
k.pos(homeX, GROUND_Y - 4),
|
|
k.anchor('bot'),
|
|
k.scale(side === 'a' ? 1.2 : -1.2, 1.2),
|
|
k.z(5),
|
|
k.opacity(0),
|
|
tag,
|
|
])
|
|
|
|
// Fade in
|
|
await k.tween(0, 0.85, 0.3, (v) => { human.opacity = v }, k.easings.easeOutQuad)
|
|
await k.wait(2.0)
|
|
// Fade out
|
|
await k.tween(0.85, 0, 0.5, (v) => { human.opacity = v }, k.easings.easeInQuad)
|
|
if (human.exists()) human.destroy()
|
|
}
|
|
|
|
/** Human runs across the screen (comedic moment) */
|
|
async function humanRunAcross(side: 'a' | 'b') {
|
|
const spriteId = side === 'a' ? 'humanA' : 'humanB'
|
|
const fromLeft = side === 'a'
|
|
const startX = fromLeft ? -40 : W + 40
|
|
const endX = fromLeft ? W + 40 : -40
|
|
|
|
const human = k.add([
|
|
k.sprite(spriteId, { anim: 'run' }),
|
|
k.pos(startX, GROUND_Y - 4),
|
|
k.anchor('bot'),
|
|
k.scale(fromLeft ? 1.3 : -1.3, 1.3),
|
|
k.z(8),
|
|
k.opacity(0.9),
|
|
])
|
|
|
|
// Run across screen
|
|
await k.tween(startX, endX, 1.5, (v) => { human.pos.x = v }, k.easings.linear)
|
|
if (human.exists()) human.destroy()
|
|
}
|
|
|
|
/** Human briefly replaces the bot sprite (jumps in to fight, fails hilariously) */
|
|
async function humanJumpsIn(side: 'a' | 'b') {
|
|
const fighterTag = side === 'a' ? 'fighterA' : 'fighterB'
|
|
const spriteId = side === 'a' ? 'humanA' : 'humanB'
|
|
const fighter = k.get(fighterTag)[0] as Fighter
|
|
if (!fighter) return
|
|
|
|
// Spawn human at fighter position
|
|
const human = k.add([
|
|
k.sprite(spriteId, { anim: 'panic' }),
|
|
k.pos(fighter.pos.x, fighter.pos.y),
|
|
k.anchor('bot'),
|
|
k.scale(fighter.scale.x / 3, fighter.scale.y / 3),
|
|
k.z(fighter.z + 1),
|
|
k.opacity(0),
|
|
])
|
|
|
|
// Hide bot, show human
|
|
const origOpacity = fighter.opacity
|
|
fighter.opacity = 0
|
|
await k.tween(0, 1, 0.15, (v) => { human.opacity = v })
|
|
|
|
// Human flails around for a moment
|
|
human.play('panic')
|
|
await k.wait(0.4)
|
|
human.play('cheer')
|
|
sfxRandomSilly()
|
|
await k.wait(0.3)
|
|
human.play('panic')
|
|
await k.wait(0.3)
|
|
|
|
// Run away scared
|
|
const escapeX = side === 'a' ? -80 : W + 80
|
|
human.play('run')
|
|
await k.tween(human.pos.x, escapeX, 0.5, (v) => { human.pos.x = v }, k.easings.easeInQuad)
|
|
|
|
// Restore bot
|
|
fighter.opacity = origOpacity
|
|
if (human.exists()) human.destroy()
|
|
}
|
|
|
|
/** Random chance to show a human moment — called between rounds */
|
|
async function maybeShowHuman() {
|
|
const roll = Math.random()
|
|
if (roll > 0.15) return // 15% chance per round
|
|
|
|
const side: 'a' | 'b' = Math.random() < 0.5 ? 'a' : 'b'
|
|
const action = Math.random()
|
|
|
|
if (action < 0.4) {
|
|
// Coach appearance (most common)
|
|
const mood = Math.random() < 0.5 ? 'cheer' : 'panic'
|
|
await spawnHumanCoach(side, mood)
|
|
} else if (action < 0.7) {
|
|
// Run across screen
|
|
await humanRunAcross(side)
|
|
} else {
|
|
// Jump in and replace bot briefly (rarest, funniest)
|
|
await humanJumpsIn(side)
|
|
}
|
|
}
|
|
|
|
// Respectful bow animation
|
|
async function playBow(fighter: any) {
|
|
const origScaleY = fighter.scale.y
|
|
await k.tween(fighter.scale.y, origScaleY * 0.85, 0.2, (v) => { fighter.scale.y = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.3)
|
|
await k.tween(fighter.scale.y, origScaleY, 0.2, (v) => { fighter.scale.y = v }, k.easings.easeOutQuad)
|
|
}
|
|
|
|
// Fist bump between two fighters
|
|
async function playFistBump(fighterA: any, fighterB: any) {
|
|
const midX = (fighterA.pos.x + fighterB.pos.x) / 2
|
|
const origAX = fighterA.pos.x
|
|
const origBX = fighterB.pos.x
|
|
await Promise.all([
|
|
k.tween(fighterA.pos.x, midX - 15, 0.3, (v) => { fighterA.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(fighterB.pos.x, midX + 15, 0.3, (v) => { fighterB.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
sfxBlock()
|
|
spawnSparks(midX, fighterA.pos.y - 25, 6, '#ffe14d')
|
|
spawnEmoteText(midX, fighterA.pos.y - 40, 'GG!', '#ffe14d')
|
|
k.shake(2)
|
|
await k.wait(0.5)
|
|
await Promise.all([
|
|
k.tween(fighterA.pos.x, origAX, 0.3, (v) => { fighterA.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(fighterB.pos.x, origBX, 0.3, (v) => { fighterB.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// Winner helps loser back up
|
|
async function playHelpUp(winner: any, loser: any, winningSide: 'a' | 'b') {
|
|
const dir = winningSide === 'a' ? 1 : -1
|
|
const origWX = winner.pos.x
|
|
await k.tween(winner.pos.x, loser.pos.x - dir * 30, 0.4, (v) => { winner.pos.x = v }, k.easings.easeInOutQuad)
|
|
winner.play('idle')
|
|
await k.wait(0.2)
|
|
loser.play('idle')
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 40, respectLines[Math.floor(Math.random() * respectLines.length)], '#88ccff')
|
|
for (let i = 0; i < 3; i++) spawnHeart((winner.pos.x + loser.pos.x) / 2, winner.pos.y - 30)
|
|
announceCool(heartfeltLines[Math.floor(Math.random() * heartfeltLines.length)])
|
|
await k.wait(0.6)
|
|
await k.tween(winner.pos.x, origWX, 0.3, (v) => { winner.pos.x = v }, k.easings.easeInOutQuad)
|
|
}
|
|
|
|
// === REFEREE LOBSTER FUNNY MOMENTS ===
|
|
|
|
async function judgeDoSomethingFunny() {
|
|
const judge = k.get('judge')[0]
|
|
if (!judge) return
|
|
|
|
const judgeOrigY = judge.pos.y
|
|
const funnyAction = Math.floor(Math.random() * 8)
|
|
|
|
if (funnyAction === 0) {
|
|
// Falls asleep, snaps awake
|
|
for (let z = 0; z < 3; z++) {
|
|
setTimeout(() => {
|
|
spawnEmoteText(judge.pos.x + 15, judge.pos.y - 20, 'Z', '#8888ff', 1.0)
|
|
}, z * 400)
|
|
}
|
|
await k.wait(1.2)
|
|
judge.play('shocked')
|
|
k.shake(2)
|
|
sfxBoing()
|
|
spawnEmoteText(judge.pos.x, judge.pos.y - 30, '!?', '#ff4444')
|
|
await k.tween(judge.pos.y, judgeOrigY - 20, 0.1, (v) => { judge.pos.y = v }, k.easings.easeOutQuad)
|
|
await k.tween(judge.pos.y, judgeOrigY, 0.15, (v) => { judge.pos.y = v }, k.easings.easeInQuad)
|
|
await k.wait(0.3)
|
|
judge.play('idle')
|
|
} else if (funnyAction === 1) {
|
|
// Little dance on the chair
|
|
for (let d = 0; d < 4; d++) {
|
|
await k.tween(judge.pos.y, judgeOrigY - 8, 0.08, (v) => { judge.pos.y = v }, k.easings.easeOutQuad)
|
|
await k.tween(judge.pos.y, judgeOrigY, 0.08, (v) => { judge.pos.y = v }, k.easings.easeInQuad)
|
|
judge.play(d % 2 === 0 ? 'call_left' : 'call_right')
|
|
}
|
|
sfxRandomComedy()
|
|
judge.play('idle')
|
|
} else if (funnyAction === 2) {
|
|
// Holds up a 10 score card
|
|
judge.play('shocked')
|
|
const card = k.add([
|
|
k.rect(20, 14), k.pos(judge.pos.x + 20, judge.pos.y - 25),
|
|
k.color(safeColor(k,'#ffffff')), k.opacity(0.9), k.z(15), k.anchor('center'),
|
|
])
|
|
const score = k.add([
|
|
k.text('10', { size: 10 }), k.pos(judge.pos.x + 20, judge.pos.y - 25),
|
|
k.color(safeColor(k,'#000000')), k.opacity(1), k.z(16), k.anchor('center'),
|
|
])
|
|
sfxBoing()
|
|
await k.wait(1.0)
|
|
card.destroy(); score.destroy()
|
|
judge.play('idle')
|
|
} else if (funnyAction === 3) {
|
|
// Gets scared and hides behind the chair
|
|
judge.play('shocked')
|
|
sfxDodge()
|
|
await k.tween(judge.pos.y, judgeOrigY + 20, 0.15, (v) => { judge.pos.y = v }, k.easings.easeInQuad)
|
|
judge.opacity = 0.3
|
|
await k.wait(0.8)
|
|
await k.tween(judge.pos.y, judgeOrigY - 5, 0.2, (v) => { judge.pos.y = v }, k.easings.easeOutQuad)
|
|
judge.opacity = 0.9
|
|
await k.tween(judge.pos.y, judgeOrigY, 0.1, (v) => { judge.pos.y = v }, k.easings.easeInOutQuad)
|
|
judge.play('idle')
|
|
} else if (funnyAction === 4) {
|
|
// Eats a tiny sandwich
|
|
const sandwich = k.add([
|
|
k.rect(10, 8), k.pos(judge.pos.x - 15, judge.pos.y - 15),
|
|
k.color(safeColor(k,'#ddaa44')), k.opacity(0.9), k.z(15), k.anchor('center'),
|
|
])
|
|
const lettuce = k.add([
|
|
k.rect(12, 2), k.pos(judge.pos.x - 15, judge.pos.y - 15),
|
|
k.color(safeColor(k,'#44cc22')), k.opacity(0.8), k.z(16), k.anchor('center'),
|
|
])
|
|
await k.wait(0.4)
|
|
await k.tween(sandwich.pos.x, judge.pos.x, 0.2, (v) => { sandwich.pos.x = v; lettuce.pos.x = v }, k.easings.easeInQuad)
|
|
sandwich.destroy(); lettuce.destroy()
|
|
spawnEmoteText(judge.pos.x, judge.pos.y - 30, 'nom nom', '#ffcc44')
|
|
sfxBonk()
|
|
await k.wait(0.6)
|
|
} else if (funnyAction === 5) {
|
|
// Takes a selfie
|
|
judge.play('call_right')
|
|
const phone = k.add([
|
|
k.rect(6, 10), k.pos(judge.pos.x + 20, judge.pos.y - 20),
|
|
k.color(safeColor(k,'#333344')), k.opacity(0.9), k.z(15), k.anchor('center'),
|
|
])
|
|
await k.wait(0.3)
|
|
screenFlash('#ffffff', 0.05)
|
|
sfxZap()
|
|
spawnEmoteText(judge.pos.x, judge.pos.y - 35, '#selfie', '#ff88cc')
|
|
await k.wait(0.5)
|
|
phone.destroy()
|
|
judge.play('idle')
|
|
} else if (funnyAction === 6) {
|
|
// Waves a tiny flag
|
|
const flagColors = ['#ff2d2d', '#2d7bff', '#39ff14', '#ffcc00', '#ff6600', '#b83dff']
|
|
const flagColor = flagColors[Math.floor(Math.random() * flagColors.length)]
|
|
const flag = k.add([
|
|
k.rect(14, 9), k.pos(judge.pos.x + 18, judge.pos.y - 30),
|
|
k.color(safeColor(k,flagColor)), k.opacity(0.85), k.z(15), k.anchor('center'),
|
|
])
|
|
const pole = k.add([
|
|
k.rect(2, 18), k.pos(judge.pos.x + 11, judge.pos.y - 22),
|
|
k.color(safeColor(k,'#aa8855')), k.opacity(0.8), k.z(14), k.anchor('center'),
|
|
])
|
|
flag.onUpdate(() => {
|
|
flag.pos.y = judge.pos.y - 30 + Math.sin(k.time() * 10) * 3
|
|
})
|
|
sfxRandomComedy()
|
|
await k.wait(1.5)
|
|
flag.destroy(); pole.destroy()
|
|
} else {
|
|
// Falls off the chair, climbs back up
|
|
judge.play('shocked')
|
|
sfxBoing()
|
|
await k.tween(judge.pos.y, GROUND_Y - 6, 0.3, (v) => { judge.pos.y = v }, k.easings.easeInQuad)
|
|
sfxBonk()
|
|
k.shake(4)
|
|
spawnEmoteText(judge.pos.x, GROUND_Y - 20, 'oof!', '#ff6644')
|
|
await k.wait(0.5)
|
|
await k.tween(judge.pos.y, judgeOrigY, 0.5, (v) => { judge.pos.y = v }, k.easings.easeOutQuad)
|
|
judge.play('idle')
|
|
spawnEmoteText(judge.pos.x, judge.pos.y - 25, '*ahem*', '#aaaaaa')
|
|
await k.wait(0.3)
|
|
}
|
|
}
|
|
|
|
// === SHOWBOATING / TAUNTING SYSTEM ===
|
|
// Fighters perform these during question/answer phases instead of boring idle bobbing
|
|
const _showboatActive: Record<string, boolean> = { a: false, b: false }
|
|
|
|
type ShowboatFn = (fighter: any, homeX: number, homeY: number, sx: number, sy: number, dir: number) => Promise<void>
|
|
|
|
// dir: 1 = facing right (bot A), -1 = facing left (bot B)
|
|
const showboats: ShowboatFn[] = [
|
|
// 0: Pace back and forth — walk a wide arc restlessly
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
f.play('kick')
|
|
await k.tween(f.pos.x, hx + dir * 100, 0.35, (v) => { f.pos.x = v }, k.easings.easeInOutQuad)
|
|
f.play('idle')
|
|
await k.wait(0.1)
|
|
f.play('attack')
|
|
await k.tween(f.pos.x, hx - dir * 60, 0.4, (v) => { f.pos.x = v }, k.easings.easeInOutQuad)
|
|
f.play('idle')
|
|
await k.wait(0.1)
|
|
await k.tween(f.pos.x, hx, 0.2, (v) => { f.pos.x = v }, k.easings.easeInOutQuad)
|
|
},
|
|
// 1: Bouncing advance — hop toward opponent then back
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
for (let i = 0; i < 3; i++) {
|
|
const targetX = hx + dir * (40 + i * 30)
|
|
f.play('kick')
|
|
await Promise.all([
|
|
k.tween(f.pos.x, targetX, 0.12, (v) => { f.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(f.pos.y, hy - 35, 0.06, (v) => { f.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(f.pos.y, hy, 0.06, (v) => { f.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
sfxBoing()
|
|
}
|
|
f.play('win'); await k.wait(0.15)
|
|
await k.tween(f.pos.x, hx, 0.25, (v) => { f.pos.x = v }, k.easings.easeInOutQuad)
|
|
},
|
|
// 2: Shadow box sprint — dash forward shadow boxing, dash back
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
const far = hx + dir * 120
|
|
f.play('attack'); sfxZoomWhoosh()
|
|
await k.tween(f.pos.x, far, 0.2, (v) => { f.pos.x = v }, k.easings.easeOutQuad)
|
|
for (let i = 0; i < 4; i++) {
|
|
f.play(i % 2 === 0 ? 'attack' : 'kick')
|
|
sfxDodge(); await k.wait(0.08)
|
|
}
|
|
f.play('special'); sfxZoomWhoosh()
|
|
await k.tween(f.pos.x, hx, 0.2, (v) => { f.pos.x = v }, k.easings.easeOutQuad)
|
|
},
|
|
// 3: Leapfrog across — multiple big jumps across the stage
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
const spots = [hx + dir * 60, hx + dir * 130, hx + dir * 60, hx]
|
|
for (const tx of spots) {
|
|
sfxBoing()
|
|
await Promise.all([
|
|
k.tween(f.pos.x, tx, 0.18, (v) => { f.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(f.pos.y, hy - 70, 0.09, (v) => { f.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(f.pos.y, hy, 0.09, (v) => { f.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
}
|
|
},
|
|
// 4: Restless jog — jog back and forth with small hops
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
f.play('kick')
|
|
for (let i = 0; i < 5; i++) {
|
|
const dx = (i % 2 === 0 ? 1 : -1) * (30 + Math.random() * 40) * dir
|
|
await Promise.all([
|
|
k.tween(f.pos.x, hx + dx, 0.13, (v) => { f.pos.x = v }),
|
|
k.tween(f.pos.y, hy - 12, 0.065, (v) => { f.pos.y = v }).then(() =>
|
|
k.tween(f.pos.y, hy, 0.065, (v) => { f.pos.y = v })
|
|
),
|
|
])
|
|
}
|
|
f.pos.x = hx
|
|
},
|
|
// 5: Charge and flex — sprint to center, flex, sprint back
|
|
async (f, hx, hy, sx, sy, _dir) => {
|
|
const center = W / 2
|
|
f.play('special'); sfxZoomWhoosh()
|
|
await k.tween(f.pos.x, center, 0.2, (v) => { f.pos.x = v }, k.easings.easeInQuad)
|
|
f.play('win')
|
|
await k.tween(1, 1.3, 0.15, (v) => { f.scale.x = sx * v; f.scale.y = sy * v }, k.easings.easeOutBack)
|
|
spawnEmoteText(f.pos.x, f.pos.y - 50, 'COME AT ME!', '#ff4444')
|
|
await k.wait(0.3)
|
|
await k.tween(1.3, 1, 0.1, (v) => { f.scale.x = sx * v; f.scale.y = sy * v })
|
|
sfxZoomWhoosh()
|
|
await k.tween(f.pos.x, hx, 0.2, (v) => { f.pos.x = v }, k.easings.easeOutQuad)
|
|
},
|
|
// 6: Triple backflip retreat — three backflips going backwards
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
for (let i = 0; i < 3; i++) {
|
|
sfxBoing()
|
|
const targetX = hx - dir * (i + 1) * 30
|
|
const a0 = f.angle || 0
|
|
await Promise.all([
|
|
k.tween(f.pos.x, targetX, 0.2, (v) => { f.pos.x = v }),
|
|
k.tween(f.pos.y, hy - 60, 0.1, (v) => { f.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(f.pos.y, hy, 0.1, (v) => { f.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
k.tween(a0, a0 - 360, 0.2, (v) => { f.angle = v }),
|
|
])
|
|
f.angle = 0
|
|
}
|
|
await k.tween(f.pos.x, hx, 0.2, (v) => { f.pos.x = v }, k.easings.easeInOutQuad)
|
|
},
|
|
// 7: Kangaroo hops — big bouncing jumps across the width
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
f.play('kick')
|
|
const hops = [hx + dir * 80, hx + dir * 150, hx + dir * 80, hx]
|
|
for (const tx of hops) {
|
|
await Promise.all([
|
|
k.tween(f.pos.x, tx, 0.15, (v) => { f.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(f.pos.y, hy - 90, 0.075, (v) => { f.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(f.pos.y, hy, 0.075, (v) => { f.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
sfxBonk(); k.shake(2)
|
|
}
|
|
},
|
|
// 8: Feint combo rush — charge in, throw combo, dodge back
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
sfxZoomWhoosh(); f.play('attack')
|
|
await k.tween(f.pos.x, hx + dir * 100, 0.12, (v) => { f.pos.x = v }, k.easings.easeOutQuad)
|
|
const anims = ['attack', 'kick', 'attack', 'special'] as const
|
|
for (const a of anims) { f.play(a); sfxDodge(); await k.wait(0.06) }
|
|
sfxBlock(); spawnSparks(f.pos.x + dir * 15, hy - 30, 5, '#ffcc00')
|
|
// Dodge-hop back
|
|
await Promise.all([
|
|
k.tween(f.pos.x, hx, 0.2, (v) => { f.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(f.pos.y, hy - 40, 0.1, (v) => { f.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(f.pos.y, hy, 0.1, (v) => { f.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
},
|
|
// 9: Dizzy spin walk — spin while walking forward, stumble back
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
const a0 = f.angle || 0
|
|
f.play('hit')
|
|
await Promise.all([
|
|
k.tween(f.pos.x, hx + dir * 70, 0.4, (v) => { f.pos.x = v }),
|
|
k.tween(a0, a0 + 720, 0.4, (v) => { f.angle = v }),
|
|
])
|
|
f.angle = 0
|
|
spawnEmoteText(f.pos.x, f.pos.y - 40, '@_@', '#ffcc00')
|
|
await k.wait(0.15)
|
|
// Stumble back
|
|
f.play('idle')
|
|
for (let i = 0; i < 3; i++) {
|
|
await k.tween(f.pos.x, f.pos.x - dir * 25, 0.1, (v) => { f.pos.x = v })
|
|
f.pos.y = hy - 5; await k.wait(0.02); f.pos.y = hy
|
|
}
|
|
},
|
|
// 10: Wall-to-wall dash — full screen sprint and back
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
f.play('special'); sfxZoomWhoosh()
|
|
spawnAfterimages(f, 3)
|
|
await k.tween(f.pos.x, dir > 0 ? W - 30 : 30, 0.2, (v) => { f.pos.x = v }, k.easings.easeInQuad)
|
|
sfxBlock(); k.shake(4)
|
|
await k.wait(0.1)
|
|
sfxZoomWhoosh(); spawnAfterimages(f, 3)
|
|
await k.tween(f.pos.x, hx, 0.2, (v) => { f.pos.x = v }, k.easings.easeOutQuad)
|
|
},
|
|
// 11: Earthquake stomp march — stomp forward and back
|
|
async (f, hx, hy, sx, sy, dir) => {
|
|
f.play('attack')
|
|
for (let i = 0; i < 4; i++) {
|
|
const step = dir * 25
|
|
await k.tween(f.pos.x, f.pos.x + step, 0.08, (v) => { f.pos.x = v })
|
|
f.scale.y = sy * 0.8; sfxBonk(); k.shake(3)
|
|
await k.wait(0.05); f.scale.y = sy
|
|
}
|
|
spawnSparks(f.pos.x, hy, 6, '#ff6600')
|
|
await k.wait(0.1)
|
|
await k.tween(f.pos.x, hx, 0.25, (v) => { f.pos.x = v }, k.easings.easeInOutQuad)
|
|
},
|
|
// 12: Taunt walk — strut toward opponent, gesture, moonwalk back
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
f.play('win')
|
|
await k.tween(f.pos.x, hx + dir * 90, 0.35, (v) => { f.pos.x = v }, k.easings.easeInOutQuad)
|
|
f.play('special')
|
|
spawnEmoteText(f.pos.x, f.pos.y - 50, 'TOO EASY!', '#ff44ff')
|
|
await k.wait(0.3)
|
|
// Moonwalk back
|
|
f.play('idle')
|
|
await k.tween(f.pos.x, hx, 0.5, (v) => { f.pos.x = v }, k.easings.easeInOutQuad)
|
|
},
|
|
// 13: Victory lap sprint — run around in a loop
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
f.play('kick'); sfxZoomWhoosh()
|
|
await k.tween(f.pos.x, hx + dir * 140, 0.2, (v) => { f.pos.x = v }, k.easings.easeInQuad)
|
|
// Jump over to other side
|
|
sfxBoing()
|
|
await Promise.all([
|
|
k.tween(f.pos.x, hx + dir * 140, 0.25, (v) => { f.pos.x = v }),
|
|
k.tween(f.pos.y, hy - 100, 0.125, (v) => { f.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(f.pos.y, hy, 0.125, (v) => { f.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
f.play('win'); spawnSparks(f.pos.x, hy - 20, 5, theme.accent)
|
|
await k.wait(0.15)
|
|
sfxZoomWhoosh()
|
|
await k.tween(f.pos.x, hx, 0.2, (v) => { f.pos.x = v }, k.easings.easeOutQuad)
|
|
},
|
|
// 14: Nervous pacing — quick short paces with jittery hops
|
|
async (f, hx, hy) => {
|
|
for (let i = 0; i < 6; i++) {
|
|
const dx = (Math.random() - 0.5) * 80
|
|
await Promise.all([
|
|
k.tween(f.pos.x, hx + dx, 0.1, (v) => { f.pos.x = v }),
|
|
k.tween(f.pos.y, hy - 10 - Math.random() * 20, 0.05, (v) => { f.pos.y = v }).then(() =>
|
|
k.tween(f.pos.y, hy, 0.05, (v) => { f.pos.y = v })
|
|
),
|
|
])
|
|
}
|
|
},
|
|
// 15: Ground pound jump — massive vertical jump + slam
|
|
async (f, hx, hy) => {
|
|
sfxBoing(); f.play('kick')
|
|
await k.tween(f.pos.y, hy - 150, 0.2, (v) => { f.pos.y = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.1)
|
|
f.play('attack')
|
|
await k.tween(f.pos.y, hy, 0.1, (v) => { f.pos.y = v }, k.easings.easeInQuad)
|
|
sfxExplosion(); k.shake(15)
|
|
spawnSparks(f.pos.x, hy, 15, '#ff6600')
|
|
spawnShockwave(f.pos.x, hy, '#ff4400')
|
|
spawnEmoteText(f.pos.x, f.pos.y - 60, 'BOOM!', '#ff2d2d')
|
|
await k.wait(0.2)
|
|
},
|
|
// 16: Zigzag sprint — fast zigzag across the arena
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
f.play('kick'); sfxZoomWhoosh()
|
|
const pts = [
|
|
{ x: hx + dir * 50, y: hy - 40 },
|
|
{ x: hx + dir * 100, y: hy },
|
|
{ x: hx + dir * 150, y: hy - 40 },
|
|
{ x: hx + dir * 100, y: hy },
|
|
{ x: hx, y: hy },
|
|
]
|
|
for (const pt of pts) {
|
|
await Promise.all([
|
|
k.tween(f.pos.x, pt.x, 0.08, (v) => { f.pos.x = v }),
|
|
k.tween(f.pos.y, pt.y, 0.08, (v) => { f.pos.y = v }),
|
|
])
|
|
}
|
|
},
|
|
// 17: Double jump kick — jump, kick, jump higher, kick
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
f.play('kick'); sfxBoing()
|
|
const mid = hx + dir * 60
|
|
await Promise.all([
|
|
k.tween(f.pos.x, mid, 0.15, (v) => { f.pos.x = v }),
|
|
k.tween(f.pos.y, hy - 50, 0.075, (v) => { f.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(f.pos.y, hy, 0.075, (v) => { f.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
sfxKick(); spawnSparks(mid, hy - 30, 4, '#00ffcc')
|
|
f.play('special'); sfxBoing()
|
|
await Promise.all([
|
|
k.tween(f.pos.x, mid + dir * 40, 0.15, (v) => { f.pos.x = v }),
|
|
k.tween(f.pos.y, hy - 90, 0.075, (v) => { f.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(f.pos.y, hy, 0.075, (v) => { f.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
sfxKick(); spawnSparks(f.pos.x, hy - 50, 6, '#ff44ff')
|
|
await k.tween(f.pos.x, hx, 0.2, (v) => { f.pos.x = v }, k.easings.easeInOutQuad)
|
|
},
|
|
// 18: Cocky strut and lean — walk forward, lean back with attitude
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
f.play('win')
|
|
await k.tween(f.pos.x, hx + dir * 80, 0.3, (v) => { f.pos.x = v }, k.easings.easeInOutQuad)
|
|
// Lean back
|
|
await k.tween(0, -25, 0.15, (v) => { f.angle = v }, k.easings.easeOutQuad)
|
|
await k.wait(0.25)
|
|
spawnEmoteText(f.pos.x, f.pos.y - 50, 'EZ', '#ffcc00')
|
|
await k.tween(-25, 0, 0.1, (v) => { f.angle = v })
|
|
await k.tween(f.pos.x, hx, 0.25, (v) => { f.pos.x = v }, k.easings.easeInOutQuad)
|
|
},
|
|
// 19: Windmill sprint — spin while running across
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
const a0 = f.angle || 0
|
|
const anims = ['attack', 'kick', 'special'] as const
|
|
let animIdx = 0
|
|
const far = hx + dir * 130
|
|
f.play(anims[0])
|
|
// Sprint while spinning
|
|
const dur = 0.4
|
|
const startX = f.pos.x
|
|
await k.tween(0, 1, dur, (t) => {
|
|
f.pos.x = startX + (far - startX) * t
|
|
f.angle = a0 + t * 1080 // 3 full spins
|
|
if (Math.floor(t * 12) !== Math.floor((t - 0.01) * 12)) {
|
|
f.play(anims[animIdx++ % anims.length])
|
|
}
|
|
})
|
|
f.angle = 0; sfxBlock(); k.shake(3)
|
|
await k.wait(0.1)
|
|
// Sprint back
|
|
await k.tween(f.pos.x, hx, 0.2, (v) => { f.pos.x = v }, k.easings.easeOutQuad)
|
|
},
|
|
// 20: Sumo stomp walk — heavy stomps advancing and retreating
|
|
async (f, hx, hy, _sx, sy, dir) => {
|
|
f.play('attack')
|
|
for (let i = 0; i < 6; i++) {
|
|
const step = (i < 3 ? dir : -dir) * 20
|
|
await k.tween(f.pos.x, f.pos.x + step, 0.1, (v) => { f.pos.x = v })
|
|
f.scale.y = sy * 0.8; sfxBonk(); k.shake(3)
|
|
await k.wait(0.06); f.scale.y = sy
|
|
spawnSparks(f.pos.x, hy, 2, '#886644')
|
|
}
|
|
},
|
|
// 21: Flex pose — walk to center, scale up, pose
|
|
async (f, hx, hy, sx, sy) => {
|
|
const center = W / 2
|
|
f.play('win')
|
|
await k.tween(f.pos.x, center, 0.25, (v) => { f.pos.x = v }, k.easings.easeInOutQuad)
|
|
await k.tween(1, 1.35, 0.2, (v) => { f.scale.x = sx * v; f.scale.y = sy * v }, k.easings.easeOutBack)
|
|
sfxPowerUp()
|
|
spawnEmoteText(f.pos.x, f.pos.y - 60, 'COME ON!', '#ff4444')
|
|
await k.wait(0.35)
|
|
await k.tween(1.35, 1, 0.15, (v) => { f.scale.x = sx * v; f.scale.y = sy * v })
|
|
await k.tween(f.pos.x, hx, 0.2, (v) => { f.pos.x = v }, k.easings.easeOutQuad)
|
|
},
|
|
// 22: Jump-kick air combo — big jump with mid-air kicks
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
sfxBoing()
|
|
const apex = hy - 120
|
|
const far = hx + dir * 100
|
|
await k.tween(f.pos.y, apex, 0.15, (v) => { f.pos.y = v }, k.easings.easeOutQuad)
|
|
// Mid-air combo while moving
|
|
f.play('kick'); sfxKick()
|
|
await k.tween(f.pos.x, far, 0.1, (v) => { f.pos.x = v })
|
|
f.play('attack'); sfxPunch()
|
|
await k.tween(f.pos.x, far + dir * 30, 0.08, (v) => { f.pos.x = v })
|
|
f.play('special')
|
|
spawnSparks(f.pos.x, f.pos.y, 8, '#ff44ff')
|
|
await k.tween(f.pos.y, hy, 0.15, (v) => { f.pos.y = v }, k.easings.easeInQuad)
|
|
sfxBonk(); k.shake(4)
|
|
await k.tween(f.pos.x, hx, 0.2, (v) => { f.pos.x = v }, k.easings.easeInOutQuad)
|
|
},
|
|
// 23: Air guitar walk — bouncing left and right with music
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
f.play('special'); sfxSlideUp()
|
|
spawnEmoteText(f.pos.x, f.pos.y - 50, '~♪~', '#ff44ff')
|
|
for (let i = 0; i < 6; i++) {
|
|
const dx = (i % 2 === 0 ? dir : -dir) * (30 + i * 10)
|
|
await Promise.all([
|
|
k.tween(f.pos.x, hx + dx, 0.12, (v) => { f.pos.x = v }),
|
|
k.tween(f.pos.y, hy - 15, 0.06, (v) => { f.pos.y = v }).then(() =>
|
|
k.tween(f.pos.y, hy, 0.06, (v) => { f.pos.y = v })
|
|
),
|
|
])
|
|
}
|
|
f.pos.x = hx
|
|
},
|
|
// 24: Crane kick walk — slow martial arts advancing
|
|
async (f, hx, hy, _sx, sy, dir) => {
|
|
f.play('kick')
|
|
await Promise.all([
|
|
k.tween(f.pos.x, hx + dir * 60, 0.3, (v) => { f.pos.x = v }),
|
|
k.tween(f.pos.y, hy - 30, 0.3, (v) => { f.pos.y = v }, k.easings.easeOutQuad),
|
|
k.tween(1, 1.15, 0.3, (v) => { f.scale.y = sy * v }, k.easings.easeOutQuad),
|
|
])
|
|
await k.wait(0.3)
|
|
f.play('special'); sfxKick()
|
|
spawnSparks(f.pos.x + dir * 20, hy - 40, 6, '#00ccff')
|
|
await k.wait(0.15)
|
|
f.scale.y = sy
|
|
await Promise.all([
|
|
k.tween(f.pos.x, hx, 0.25, (v) => { f.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(f.pos.y, hy, 0.15, (v) => { f.pos.y = v }, k.easings.easeInQuad),
|
|
])
|
|
},
|
|
// 25: Girlfriend kiss — girlfriend walks in, kiss, hearts, she storms off
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
const startGfX = hx - dir * 120
|
|
const gfColor = ['#ff69b4', '#ff1493', '#ff6eb4', '#cc44aa'][Math.floor(Math.random() * 4)]
|
|
const cs = SF
|
|
const gf = k.add([k.rect(18 * cs, 35 * cs), k.pos(startGfX, hy - 18 * cs), k.anchor('center'), k.color(safeColor(k, gfColor)), k.opacity(0.9), k.z(11)])
|
|
const gfHair = k.add([k.rect(22 * cs, 10 * cs), k.pos(startGfX, hy - 35 * cs), k.anchor('center'), k.color(safeColor(k, '#8b4513')), k.opacity(0.9), k.z(12)])
|
|
// Walk toward fighter
|
|
await Promise.all([
|
|
k.tween(gf.pos.x, hx - dir * 15, 0.4, (v) => { gf.pos.x = v; gfHair.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
// Kiss!
|
|
sfxBoing()
|
|
const heart = k.add([k.text('*smooch*', { size: 10 }), k.pos(hx, hy - 55), k.anchor('center'), k.color(safeColor(k, '#ff1493')), k.opacity(1), k.z(30)])
|
|
k.tween(heart.pos.y, hy - 90, 0.8, (v) => { heart.pos.y = v })
|
|
k.tween(1, 0, 0.8, (v) => { heart.opacity = v }).then(() => { if (heart.exists()) heart.destroy() })
|
|
// Spawn floating hearts
|
|
for (let i = 0; i < 5; i++) {
|
|
const h = k.add([k.text('♥', { size: 8 + Math.random() * 6 }), k.pos(hx + (Math.random() - 0.5) * 30, hy - 30), k.color(safeColor(k, '#ff69b4')), k.opacity(0.8), k.z(25), k.anchor('center')])
|
|
k.tween(h.pos.y, hy - 70 - Math.random() * 40, 0.7, (v) => { h.pos.y = v })
|
|
k.tween(h.pos.x, h.pos.x + (Math.random() - 0.5) * 40, 0.7, (v) => { h.pos.x = v })
|
|
k.tween(0.8, 0, 0.7, (v) => { h.opacity = v }).then(() => { if (h.exists()) h.destroy() })
|
|
}
|
|
f.play('win')
|
|
await k.wait(0.5)
|
|
// She storms off
|
|
spawnEmoteText(gf.pos.x, gf.pos.y - 30, 'Good luck babe!', '#ff69b4')
|
|
await k.tween(gf.pos.x, startGfX, 0.4, (v) => { gf.pos.x = v; gfHair.pos.x = v }, k.easings.easeInQuad)
|
|
gf.destroy(); gfHair.destroy()
|
|
},
|
|
// 26: Push-up walk — walk forward doing push-ups at intervals
|
|
async (f, hx, hy, sx, sy, dir) => {
|
|
for (let i = 0; i < 3; i++) {
|
|
await k.tween(f.pos.x, f.pos.x + dir * 35, 0.15, (v) => { f.pos.x = v })
|
|
// Push-up squash
|
|
await k.tween(1, 0.55, 0.08, (v) => { f.scale.y = sy * v; f.scale.x = sx * (2 - v) }, k.easings.easeOutQuad)
|
|
await k.tween(0.55, 1, 0.08, (v) => { f.scale.y = sy * v; f.scale.x = sx * (2 - v) }, k.easings.easeInQuad)
|
|
}
|
|
spawnEmoteText(f.pos.x, f.pos.y - 45, `${3 + Math.floor(Math.random() * 97)}!`, '#00ff88')
|
|
await k.tween(f.pos.x, hx, 0.2, (v) => { f.pos.x = v }, k.easings.easeInOutQuad)
|
|
},
|
|
// 27: Matrix dodge walk — dodge bullets walking forward
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
for (let i = 0; i < 4; i++) {
|
|
await k.tween(f.pos.x, f.pos.x + dir * 25, 0.1, (v) => { f.pos.x = v })
|
|
// Lean dodge
|
|
const lean = (i % 2 === 0 ? -30 : 30)
|
|
await k.tween(0, lean, 0.08, (v) => { f.angle = v }, k.easings.easeOutQuad)
|
|
await k.tween(lean, 0, 0.08, (v) => { f.angle = v }, k.easings.easeInQuad)
|
|
}
|
|
await k.tween(f.pos.x, hx, 0.2, (v) => { f.pos.x = v }, k.easings.easeInOutQuad)
|
|
},
|
|
// 28: Bouncy chest thump — bounce toward opponent thumping chest
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
f.play('attack')
|
|
for (let i = 0; i < 4; i++) {
|
|
await Promise.all([
|
|
k.tween(f.pos.x, f.pos.x + dir * 30, 0.1, (v) => { f.pos.x = v }),
|
|
k.tween(f.pos.y, hy - 25, 0.05, (v) => { f.pos.y = v }).then(() =>
|
|
k.tween(f.pos.y, hy, 0.05, (v) => { f.pos.y = v })
|
|
),
|
|
])
|
|
sfxBlock(); k.shake(2)
|
|
}
|
|
spawnEmoteText(f.pos.x, f.pos.y - 50, 'LET\'S GO!', '#ff4444')
|
|
await k.wait(0.15)
|
|
await k.tween(f.pos.x, hx, 0.25, (v) => { f.pos.x = v }, k.easings.easeInOutQuad)
|
|
},
|
|
// 29: Speed demon — afterimage dash back and forth
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
f.play('special')
|
|
for (let i = 0; i < 3; i++) {
|
|
sfxZoomWhoosh(); spawnAfterimages(f, 3)
|
|
await k.tween(f.pos.x, hx + dir * (80 + i * 30), 0.08, (v) => { f.pos.x = v }, k.easings.easeInQuad)
|
|
spawnAfterimages(f, 2)
|
|
await k.tween(f.pos.x, hx - dir * 20, 0.08, (v) => { f.pos.x = v }, k.easings.easeOutQuad)
|
|
}
|
|
f.pos.x = hx
|
|
},
|
|
]
|
|
|
|
// === CREATOR-EXCLUSIVE MAGICAL SHOWBOATS ===
|
|
const creatorShowboats: ShowboatFn[] = [
|
|
// 0: Levitate across — float up and glide across the screen trailing golden ₿
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
f.play('special'); sfxPowerUp()
|
|
await k.tween(f.pos.y, hy - 100, 0.25, (v) => { f.pos.y = v }, k.easings.easeOutQuad)
|
|
// Float across dropping ₿ rain
|
|
const startX = f.pos.x
|
|
const far = hx + dir * 180
|
|
const dur = 0.6
|
|
let lastDrop = 0
|
|
await k.tween(0, 1, dur, (t) => {
|
|
f.pos.x = startX + (far - startX) * t
|
|
f.pos.y = hy - 100 + Math.sin(t * Math.PI * 3) * 20
|
|
if (t - lastDrop > 0.08) {
|
|
lastDrop = t
|
|
const d = k.add([k.text('₿', { size: 6 + Math.random() * 4 }), k.pos(f.pos.x, f.pos.y + 10), k.color(safeColor(k, '#ffd700')), k.opacity(0.7), k.z(9), k.anchor('center')])
|
|
k.tween(d.pos.y, hy + 10, 0.5, (v) => { d.pos.y = v })
|
|
k.tween(0.7, 0, 0.5, (v) => { d.opacity = v }).then(() => { if (d.exists()) d.destroy() })
|
|
}
|
|
})
|
|
screenFlash('#ffd700', 0.06)
|
|
await k.tween(f.pos.x, hx, 0.2, (v) => { f.pos.x = v }, k.easings.easeOutQuad)
|
|
await k.tween(f.pos.y, hy, 0.15, (v) => { f.pos.y = v }, k.easings.easeInQuad)
|
|
},
|
|
// 1: Golden portal teleport — vanish, portals, reappear at random spots
|
|
async (f, hx, hy) => {
|
|
sfxSpecial()
|
|
// Vanish with flash
|
|
screenFlash('#ffd700', 0.08)
|
|
f.opacity = 0
|
|
// Teleport to 3 spots with golden portals
|
|
const spots = [
|
|
{ x: W * 0.2, y: hy - 60 },
|
|
{ x: W * 0.8, y: hy - 80 },
|
|
{ x: W * 0.5, y: hy - 120 },
|
|
]
|
|
for (const spot of spots) {
|
|
// Portal flash at destination
|
|
const portal = k.add([k.circle(20), k.pos(spot.x, spot.y), k.color(safeColor(k, '#ffd700')), k.opacity(0.6), k.z(15), k.anchor('center')])
|
|
spawnSparks(spot.x, spot.y, 6, '#ffd700')
|
|
f.pos.x = spot.x; f.pos.y = spot.y; f.opacity = 1
|
|
f.play('special')
|
|
await k.wait(0.15)
|
|
f.opacity = 0
|
|
k.tween(0.6, 0, 0.2, (v) => { portal.opacity = v }).then(() => { if (portal.exists()) portal.destroy() })
|
|
sfxZap()
|
|
}
|
|
// Return home with big flash
|
|
screenFlash('#ffd700', 0.1)
|
|
f.pos.x = hx; f.pos.y = hy; f.opacity = 1
|
|
f.play('win')
|
|
spawnShockwave(hx, hy, '#ffd700')
|
|
sfxExplosion()
|
|
await k.wait(0.2)
|
|
},
|
|
// 2: Code rain summon — float up, summon massive golden code rain
|
|
async (f, hx, hy) => {
|
|
f.play('special'); sfxPowerUp()
|
|
await k.tween(f.pos.y, hy - 80, 0.2, (v) => { f.pos.y = v }, k.easings.easeOutQuad)
|
|
// Massive code rain
|
|
const chars = '₿01∞⚡⛏§∂∆≈≠'.split('')
|
|
for (let col = 0; col < 20; col++) {
|
|
const cx = Math.random() * W
|
|
for (let row = 0; row < 3; row++) {
|
|
const ch = chars[Math.floor(Math.random() * chars.length)]
|
|
const d = k.add([
|
|
k.text(ch, { size: 6 + Math.random() * 4 }), k.pos(cx, -10 - row * 20),
|
|
k.color(safeColor(k, row === 0 ? '#ffd700' : '#c8a000')),
|
|
k.opacity(0.5 + Math.random() * 0.4), k.z(8), k.anchor('center'),
|
|
])
|
|
k.tween(d.pos.y, hy + 30, 0.5 + Math.random() * 0.4, (v) => { d.pos.y = v; d.opacity = Math.max(0, 1 - (v - hy + 30) / 60) })
|
|
.then(() => { if (d.exists()) d.destroy() })
|
|
}
|
|
}
|
|
await k.wait(0.6)
|
|
await k.tween(f.pos.y, hy, 0.2, (v) => { f.pos.y = v }, k.easings.easeInQuad)
|
|
},
|
|
// 3: ₿ orbit explosion — fly to center, ₿ symbols orbit then explode outward
|
|
async (f, hx, hy, sx, sy) => {
|
|
sfxZoomWhoosh(); f.play('special')
|
|
const center = W / 2
|
|
await Promise.all([
|
|
k.tween(f.pos.x, center, 0.2, (v) => { f.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(f.pos.y, hy - 60, 0.2, (v) => { f.pos.y = v }, k.easings.easeOutQuad),
|
|
])
|
|
// Spawn orbiting ₿
|
|
const orbs: any[] = []
|
|
for (let i = 0; i < 8; i++) {
|
|
const orb = k.add([k.text('₿', { size: 8 + Math.random() * 6 }), k.pos(center, f.pos.y), k.color(safeColor(k, i % 2 === 0 ? '#ffd700' : '#ff8c00')), k.opacity(0.8), k.z(15), k.anchor('center')])
|
|
orbs.push(orb)
|
|
}
|
|
// Orbit for a moment
|
|
const startTime = k.time()
|
|
const orbitCancel = k.onUpdate(() => {
|
|
const t = k.time() - startTime
|
|
for (let i = 0; i < orbs.length; i++) {
|
|
const a = t * 4 + i * (Math.PI * 2 / orbs.length)
|
|
const r = 30 + t * 15
|
|
orbs[i].pos.x = f.pos.x + Math.cos(a) * r
|
|
orbs[i].pos.y = f.pos.y + Math.sin(a) * r * 0.5
|
|
}
|
|
})
|
|
await k.wait(0.5)
|
|
orbitCancel.cancel()
|
|
// Explode outward
|
|
sfxExplosion(); screenFlash('#ffd700', 0.08); k.shake(8)
|
|
for (const orb of orbs) {
|
|
const angle = Math.random() * Math.PI * 2
|
|
k.tween(orb.pos.x, orb.pos.x + Math.cos(angle) * 200, 0.3, (v) => { orb.pos.x = v })
|
|
k.tween(orb.pos.y, orb.pos.y + Math.sin(angle) * 200, 0.3, (v) => { orb.pos.y = v })
|
|
k.tween(0.8, 0, 0.3, (v) => { orb.opacity = v }).then(() => { if (orb.exists()) orb.destroy() })
|
|
}
|
|
await k.wait(0.2)
|
|
await Promise.all([
|
|
k.tween(f.pos.x, hx, 0.2, (v) => { f.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(f.pos.y, hy, 0.2, (v) => { f.pos.y = v }, k.easings.easeInQuad),
|
|
])
|
|
},
|
|
// 4: Lightning flight — zigzag across the screen at super speed with lightning
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
f.play('special'); sfxZoomWhoosh()
|
|
f.opacity = 0.8
|
|
const pts = [
|
|
{ x: hx + dir * 60, y: hy - 80 },
|
|
{ x: W / 2, y: hy - 140 },
|
|
{ x: hx + dir * 180, y: hy - 60 },
|
|
{ x: W / 2, y: hy - 100 },
|
|
{ x: hx, y: hy },
|
|
]
|
|
for (const pt of pts) {
|
|
spawnAfterimages(f, 2)
|
|
await Promise.all([
|
|
k.tween(f.pos.x, pt.x, 0.08, (v) => { f.pos.x = v }),
|
|
k.tween(f.pos.y, pt.y, 0.08, (v) => { f.pos.y = v }),
|
|
])
|
|
// Lightning bolt at each stop
|
|
sfxZap()
|
|
const bolt = k.add([k.rect(2, 30 + Math.random() * 40), k.pos(f.pos.x, f.pos.y - 50), k.color(safeColor(k, '#ffd700')), k.opacity(0.9), k.z(20), k.anchor('center'), k.rotate(Math.random() * 30 - 15)])
|
|
k.tween(0.9, 0, 0.15, (v) => { bolt.opacity = v }).then(() => { if (bolt.exists()) bolt.destroy() })
|
|
}
|
|
f.opacity = 1
|
|
},
|
|
// 5: Satoshi meditation — float to center, golden aura pulse, wisdom text
|
|
async (f, hx, hy, sx, sy) => {
|
|
sfxPowerUp(); f.play('special')
|
|
await Promise.all([
|
|
k.tween(f.pos.x, W / 2, 0.3, (v) => { f.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(f.pos.y, hy - 70, 0.3, (v) => { f.pos.y = v }, k.easings.easeOutQuad),
|
|
])
|
|
// Golden aura rings
|
|
for (let i = 0; i < 3; i++) {
|
|
const ring = k.add([k.circle(10), k.pos(f.pos.x, f.pos.y), k.color(safeColor(k, '#ffd700')), k.opacity(0.5), k.z(9), k.anchor('center'), k.scale(1)])
|
|
k.tween(1, (60 + i * 20) / 10, 0.4, (v) => { ring.scale.x = v; ring.scale.y = v })
|
|
k.tween(0.5, 0, 0.4, (v) => { ring.opacity = v }).then(() => { if (ring.exists()) ring.destroy() })
|
|
await k.wait(0.12)
|
|
}
|
|
// Scale pulse
|
|
await k.tween(1, 1.2, 0.2, (v) => { f.scale.x = sx * v; f.scale.y = sy * v }, k.easings.easeOutQuad)
|
|
const sayings = ['PROOF OF WORK', 'VERIFY, DON\'T TRUST', '21 MILLION', 'TICK TOCK NEXT BLOCK', 'NOT YOUR KEYS', 'STAY HUMBLE STACK SATS']
|
|
spawnEmoteText(f.pos.x, f.pos.y - 50, sayings[Math.floor(Math.random() * sayings.length)], '#ffd700')
|
|
await k.wait(0.4)
|
|
await k.tween(1.2, 1, 0.15, (v) => { f.scale.x = sx * v; f.scale.y = sy * v })
|
|
await Promise.all([
|
|
k.tween(f.pos.x, hx, 0.25, (v) => { f.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(f.pos.y, hy, 0.2, (v) => { f.pos.y = v }, k.easings.easeInQuad),
|
|
])
|
|
},
|
|
// 6: Golden tornado — spin rapidly while moving in a circle across the arena
|
|
async (f, hx, hy) => {
|
|
sfxZoomWhoosh(); f.play('special')
|
|
const cx = W / 2, cy = hy - 50, radius = 100
|
|
const dur = 0.8
|
|
let lastParticle = 0
|
|
await k.tween(0, Math.PI * 2, dur, (a) => {
|
|
f.pos.x = cx + Math.cos(a) * radius
|
|
f.pos.y = cy + Math.sin(a) * radius * 0.4
|
|
f.angle = (a / (Math.PI * 2)) * 1440 // 4 full spins
|
|
if (a - lastParticle > 0.3) {
|
|
lastParticle = a
|
|
const p = k.add([k.text('₿', { size: 5 + Math.random() * 4 }), k.pos(f.pos.x, f.pos.y), k.color(safeColor(k, '#ffd700')), k.opacity(0.6), k.z(9), k.anchor('center')])
|
|
k.tween(0.6, 0, 0.4, (v) => { p.opacity = v }).then(() => { if (p.exists()) p.destroy() })
|
|
}
|
|
})
|
|
f.angle = 0
|
|
sfxExplosion(); k.shake(6)
|
|
spawnShockwave(f.pos.x, f.pos.y, '#ffd700')
|
|
f.pos.x = hx; f.pos.y = hy
|
|
},
|
|
// 7: Laptop hack — walk forward, pull out laptop (rect), type furiously, spawn effects
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
f.play('special')
|
|
await k.tween(f.pos.x, hx + dir * 50, 0.2, (v) => { f.pos.x = v }, k.easings.easeInOutQuad)
|
|
// Laptop
|
|
const cs = SF
|
|
const laptop = k.add([k.rect(24 * cs, 16 * cs), k.pos(f.pos.x + dir * 15, hy - 20 * cs), k.anchor('center'), k.color(safeColor(k, '#333333')), k.opacity(0.9), k.z(12)])
|
|
const screen = k.add([k.rect(20 * cs, 12 * cs), k.pos(f.pos.x + dir * 15, hy - 22 * cs), k.anchor('center'), k.color(safeColor(k, '#00ff00')), k.opacity(0.7), k.z(13)])
|
|
// Type — spawn code characters
|
|
const codeChars = '₿{}();=>0x1f'.split('')
|
|
for (let i = 0; i < 8; i++) {
|
|
const ch = codeChars[Math.floor(Math.random() * codeChars.length)]
|
|
const t = k.add([k.text(ch, { size: 5 }), k.pos(screen.pos.x + (Math.random() - 0.5) * 15, screen.pos.y), k.color(safeColor(k, '#00ff00')), k.opacity(0.8), k.z(14), k.anchor('center')])
|
|
k.tween(t.pos.y, t.pos.y - 25 - Math.random() * 20, 0.3, (v) => { t.pos.y = v })
|
|
k.tween(0.8, 0, 0.3, (v) => { t.opacity = v }).then(() => { if (t.exists()) t.destroy() })
|
|
sfxCoin()
|
|
await k.wait(0.06)
|
|
}
|
|
spawnEmoteText(f.pos.x, f.pos.y - 55, 'HACKING...', '#00ff00')
|
|
await k.wait(0.2)
|
|
laptop.destroy(); screen.destroy()
|
|
await k.tween(f.pos.x, hx, 0.2, (v) => { f.pos.x = v }, k.easings.easeInOutQuad)
|
|
},
|
|
// 8: Bitcoin rain shower — fly across dropping ₿ coins everywhere
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
sfxPowerUp(); f.play('win')
|
|
await k.tween(f.pos.y, hy - 90, 0.15, (v) => { f.pos.y = v }, k.easings.easeOutQuad)
|
|
// Fly from one side to the other
|
|
const startX = dir > 0 ? 30 : W - 30
|
|
const endX = dir > 0 ? W - 30 : 30
|
|
f.pos.x = startX
|
|
const dur = 0.6
|
|
let lastCoin = 0
|
|
await k.tween(0, 1, dur, (t) => {
|
|
f.pos.x = startX + (endX - startX) * t
|
|
f.pos.y = hy - 90 + Math.sin(t * Math.PI * 4) * 15
|
|
if (t - lastCoin > 0.04) {
|
|
lastCoin = t
|
|
const coin = k.add([k.text('₿', { size: 8 + Math.random() * 4 }), k.pos(f.pos.x, f.pos.y + 15), k.color(safeColor(k, Math.random() > 0.5 ? '#ffd700' : '#ff8c00')), k.opacity(0.8), k.z(9), k.anchor('center')])
|
|
k.tween(coin.pos.y, hy + 10, 0.4, (v) => { coin.pos.y = v })
|
|
k.tween(coin.pos.x, coin.pos.x + (Math.random() - 0.5) * 30, 0.4, (v) => { coin.pos.x = v })
|
|
k.tween(0.8, 0, 0.4, (v) => { coin.opacity = v }).then(() => { if (coin.exists()) coin.destroy() })
|
|
}
|
|
})
|
|
sfxCoin()
|
|
f.pos.x = hx
|
|
await k.tween(f.pos.y, hy, 0.15, (v) => { f.pos.y = v }, k.easings.easeInQuad)
|
|
},
|
|
// 9: Dimension rift — creator tears open a golden rift, steps through, appears elsewhere
|
|
async (f, hx, hy) => {
|
|
// Rift opens
|
|
sfxSpecial()
|
|
const riftX = f.pos.x + 30
|
|
const rift = k.add([k.rect(4, 50), k.pos(riftX, hy - 25), k.anchor('center'), k.color(safeColor(k, '#ffd700')), k.opacity(0.9), k.z(15)])
|
|
await k.tween(4, 30, 0.2, (v) => { rift.width = v })
|
|
spawnSparks(riftX, hy - 25, 8, '#ffd700')
|
|
// Step through — vanish
|
|
f.play('special')
|
|
await k.tween(f.pos.x, riftX, 0.1, (v) => { f.pos.x = v })
|
|
f.opacity = 0; sfxZap()
|
|
// Rift at destination
|
|
const destX = W - riftX
|
|
const rift2 = k.add([k.rect(30, 50), k.pos(destX, hy - 25), k.anchor('center'), k.color(safeColor(k, '#ffd700')), k.opacity(0.9), k.z(15)])
|
|
spawnSparks(destX, hy - 25, 8, '#ffd700')
|
|
await k.wait(0.15)
|
|
// Step out
|
|
f.pos.x = destX; f.opacity = 1; f.play('win')
|
|
sfxSpecial()
|
|
await k.wait(0.2)
|
|
// Close rifts
|
|
k.tween(0.9, 0, 0.2, (v) => { rift.opacity = v; rift2.opacity = v }).then(() => { if (rift.exists()) rift.destroy(); if (rift2.exists()) rift2.destroy() })
|
|
// Float home
|
|
await Promise.all([
|
|
k.tween(f.pos.x, hx, 0.3, (v) => { f.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(f.pos.y, hy - 40, 0.15, (v) => { f.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(f.pos.y, hy, 0.15, (v) => { f.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
},
|
|
// 10: Golden ascension — rise way up, glow, descend with shockwave
|
|
async (f, hx, hy, sx, sy) => {
|
|
sfxPowerUp(); f.play('special')
|
|
await k.tween(f.pos.y, hy - 160, 0.3, (v) => { f.pos.y = v }, k.easings.easeOutQuad)
|
|
// Glow pulse
|
|
await k.tween(1, 1.5, 0.2, (v) => { f.scale.x = sx * v; f.scale.y = sy * v }, k.easings.easeOutQuad)
|
|
screenFlash('#ffd700', 0.06)
|
|
// Spawn golden aura particles
|
|
for (let i = 0; i < 10; i++) {
|
|
const p = k.add([k.text('✦', { size: 4 + Math.random() * 6 }), k.pos(f.pos.x + (Math.random() - 0.5) * 40, f.pos.y + (Math.random() - 0.5) * 30), k.color(safeColor(k, '#ffd700')), k.opacity(0.7), k.z(9), k.anchor('center')])
|
|
k.tween(0.7, 0, 0.5, (v) => { p.opacity = v; p.pos.y -= 0.5 }).then(() => { if (p.exists()) p.destroy() })
|
|
}
|
|
spawnEmoteText(f.pos.x, f.pos.y - 40, 'HODL', '#ffd700')
|
|
await k.wait(0.3)
|
|
await k.tween(1.5, 1, 0.1, (v) => { f.scale.x = sx * v; f.scale.y = sy * v })
|
|
// Slam down
|
|
await k.tween(f.pos.y, hy, 0.1, (v) => { f.pos.y = v }, k.easings.easeInQuad)
|
|
sfxExplosion(); k.shake(12)
|
|
spawnShockwave(hx, hy, '#ffd700')
|
|
spawnSparks(hx, hy, 15, '#ffd700')
|
|
await k.wait(0.15)
|
|
},
|
|
// 11: Phase walk — flicker opacity while walking through the opponent's space
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
f.play('special'); sfxZap()
|
|
const far = dir > 0 ? W - 40 : 40
|
|
const dur = 0.5
|
|
await k.tween(0, 1, dur, (t) => {
|
|
f.pos.x = hx + (far - hx) * t
|
|
f.opacity = 0.2 + Math.abs(Math.sin(t * Math.PI * 8)) * 0.7
|
|
})
|
|
f.opacity = 1; sfxSpecial()
|
|
screenFlash('#ffd700', 0.05)
|
|
spawnSparks(f.pos.x, hy - 20, 6, '#ffd700')
|
|
await k.tween(f.pos.x, hx, 0.2, (v) => { f.pos.x = v }, k.easings.easeOutQuad)
|
|
},
|
|
// 12: Bullet time attack — slow-mo dash with afterimages + golden bullet traces
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
f.play('attack')
|
|
// Darken screen for bullet time
|
|
const overlay = k.add([k.rect(W, H), k.pos(0, 0), k.color(safeColor(k, '#000000')), k.opacity(0), k.z(50)])
|
|
await k.tween(0, 0.35, 0.08, (v) => { overlay.opacity = v })
|
|
// Slow-mo lean back
|
|
await k.tween(0, -30, 0.2, (v) => { f.angle = v }, k.easings.easeOutQuad)
|
|
// Golden bullet traces fly past
|
|
for (let i = 0; i < 6; i++) {
|
|
const by = hy - 15 - Math.random() * 50
|
|
const bullet = k.add([k.rect(15, 2), k.pos(dir > 0 ? W + 10 : -10, by), k.color(safeColor(k, '#ffd700')), k.opacity(0.9), k.z(51), k.anchor('center')])
|
|
const bdir = dir > 0 ? -1 : 1
|
|
k.tween(bullet.pos.x, bullet.pos.x + bdir * (W + 30), 0.35, (v) => { bullet.pos.x = v }).then(() => { if (bullet.exists()) bullet.destroy() })
|
|
sfxZoomWhoosh()
|
|
await k.wait(0.04)
|
|
}
|
|
await k.wait(0.1)
|
|
// Snap upright and dash through
|
|
await k.tween(-30, 0, 0.06, (v) => { f.angle = v })
|
|
f.play('special'); sfxZoomWhoosh()
|
|
// Dash with afterimages
|
|
const endX = hx + dir * 160
|
|
for (let i = 0; i < 6; i++) {
|
|
const ghostX = hx + (endX - hx) * (i / 6)
|
|
const ghost = k.add([k.rect(16, 30), k.pos(ghostX, hy - 15), k.anchor('center'), k.color(safeColor(k, '#ffd700')), k.opacity(0.3 - i * 0.04), k.z(49)])
|
|
k.tween(0.3, 0, 0.4, (v) => { ghost.opacity = v }).then(() => { if (ghost.exists()) ghost.destroy() })
|
|
}
|
|
await k.tween(f.pos.x, endX, 0.12, (v) => { f.pos.x = v }, k.easings.easeInQuad)
|
|
screenFlash('#ffd700', 0.06); sfxCritical(); k.shake(8)
|
|
spawnSparks(f.pos.x, hy - 20, 10, '#ffd700')
|
|
await k.wait(0.15)
|
|
// Zip back
|
|
await k.tween(overlay.opacity, 0, 0.1, (v) => { overlay.opacity = v })
|
|
overlay.destroy()
|
|
await k.tween(f.pos.x, hx, 0.1, (v) => { f.pos.x = v }, k.easings.easeOutQuad)
|
|
},
|
|
// 13: ₿ throne summon — conjure golden throne, sit imperiously, dismiss
|
|
async (f, hx, hy) => {
|
|
sfxSpecial()
|
|
const cs = SF
|
|
// Throne pieces
|
|
const seat = k.add([k.rect(40 * cs, 8 * cs), k.pos(hx, hy - 5), k.anchor('center'), k.color(safeColor(k, '#ffd700')), k.opacity(0), k.z(9)])
|
|
const back = k.add([k.rect(35 * cs, 30 * cs), k.pos(hx, hy - 25 * cs), k.anchor('center'), k.color(safeColor(k, '#c8a000')), k.opacity(0), k.z(8)])
|
|
const armL = k.add([k.rect(6 * cs, 15 * cs), k.pos(hx - 20 * cs, hy - 12 * cs), k.anchor('center'), k.color(safeColor(k, '#ffd700')), k.opacity(0), k.z(9)])
|
|
const armR = k.add([k.rect(6 * cs, 15 * cs), k.pos(hx + 20 * cs, hy - 12 * cs), k.anchor('center'), k.color(safeColor(k, '#ffd700')), k.opacity(0), k.z(9)])
|
|
const parts = [seat, back, armL, armR]
|
|
// Fade in
|
|
for (const p of parts) k.tween(0, 0.8, 0.2, (v) => { p.opacity = v })
|
|
spawnSparks(hx, hy - 15, 6, '#ffd700')
|
|
await k.wait(0.25)
|
|
// Sit
|
|
f.play('win')
|
|
await k.tween(f.pos.y, hy - 12, 0.12, (v) => { f.pos.y = v }, k.easings.easeInQuad)
|
|
spawnEmoteText(hx, f.pos.y - 50, 'kneel', '#ffd700')
|
|
await k.wait(0.6)
|
|
// Stand and dismiss
|
|
await k.tween(f.pos.y, hy, 0.1, (v) => { f.pos.y = v })
|
|
for (const p of parts) k.tween(p.opacity, 0, 0.2, (v) => { p.opacity = v }).then(() => { if (p.exists()) p.destroy() })
|
|
await k.wait(0.2)
|
|
},
|
|
// 14: Disco dance — Creator gets down with golden disco moves
|
|
async (f, hx, hy, _sx, _sy, dir) => {
|
|
f.play('win')
|
|
const colors = ['#ffd700', '#ff8c00', '#ffee88', '#c8a000', '#ffffff', '#ffd700']
|
|
spawnEmoteText(f.pos.x, f.pos.y - 55, '~♪ SATOSHI SHUFFLE ♪~', '#ffd700')
|
|
for (let i = 0; i < 10; i++) {
|
|
const dx = (i % 2 === 0 ? 25 : -25) + (Math.random() - 0.5) * 15
|
|
f.play(i % 3 === 0 ? 'attack' : i % 3 === 1 ? 'kick' : 'win')
|
|
await Promise.all([
|
|
k.tween(f.pos.x, hx + dx, 0.06, (v) => { f.pos.x = v }),
|
|
k.tween(f.pos.y, hy - 15, 0.03, (v) => { f.pos.y = v }).then(() =>
|
|
k.tween(f.pos.y, hy, 0.03, (v) => { f.pos.y = v })),
|
|
])
|
|
spawnSparks(f.pos.x, hy - 10, 2, colors[i % colors.length])
|
|
}
|
|
f.pos.x = hx
|
|
},
|
|
]
|
|
|
|
// Showboat loop: picks random showboats in sequence while active
|
|
async function _showboatLoop(side: 'a' | 'b') {
|
|
const tag = side === 'a' ? 'fighterA' : 'fighterB'
|
|
const homeX = side === 'a' ? HOME_A : HOME_B
|
|
const homeY = GROUND_Y - 6
|
|
const dir = side === 'a' ? 1 : -1
|
|
const arch = side === 'a' ? botA.archetype : botB.archetype
|
|
const isCreator = arch === 'the_creator'
|
|
// Creator uses magical showboats 60% of the time, normal 40%
|
|
const pool = isCreator ? [...showboats, ...creatorShowboats, ...creatorShowboats] : showboats
|
|
while (_showboatActive[side]) {
|
|
const f = k.get(tag)[0]
|
|
if (!f) break
|
|
const sx = f.scale.x
|
|
const sy = f.scale.y
|
|
const idx = Math.floor(Math.random() * pool.length)
|
|
try {
|
|
await pool[idx](f, homeX, homeY, sx, sy, dir)
|
|
// 40% chance of comedy sound punctuation after each showboat
|
|
if (Math.random() < 0.4) sfxRandomComedy()
|
|
} catch { break }
|
|
// Restore state after each showboat
|
|
const ff = k.get(tag)[0]
|
|
if (ff) {
|
|
ff.pos.x = homeX; ff.pos.y = homeY
|
|
ff.scale.x = sx; ff.scale.y = sy
|
|
ff.angle = 0; ff.opacity = 1
|
|
ff.play('idle')
|
|
}
|
|
// Brief pause between showboats
|
|
if (_showboatActive[side]) await k.wait(0.15 + Math.random() * 0.35)
|
|
}
|
|
}
|
|
|
|
return {
|
|
k,
|
|
|
|
async showAnnouncement(_text: string, _color: string = '#ffffff', _duration: number = 1200) {},
|
|
|
|
showSpeechBubble(side: 'a' | 'b', text: string, duration?: number) {
|
|
showSpeechBubble(side, text, duration)
|
|
},
|
|
|
|
startTalking(side: 'a' | 'b') { startTalking(side) },
|
|
stopTalking(side: 'a' | 'b') { stopTalking(side) },
|
|
|
|
startShowboating(side: 'a' | 'b') {
|
|
if (_showboatActive[side]) return
|
|
_showboatActive[side] = true
|
|
_showboatLoop(side)
|
|
},
|
|
stopShowboating(side: 'a' | 'b') {
|
|
_showboatActive[side] = false
|
|
},
|
|
|
|
async playEntrance() {
|
|
const fA = k.get('fighterA')[0] as Fighter
|
|
const fB = k.get('fighterB')[0] as Fighter
|
|
if (!fA || !fB) return
|
|
|
|
const entrances = [
|
|
// 0: Drive in with a car
|
|
async (fighter: any, homeX: number, fromLeft: boolean) => {
|
|
const dir = fromLeft ? 1 : -1
|
|
const startX = fromLeft ? -120 : W + 120
|
|
const carY = GROUND_Y - 20
|
|
const carBody = k.add([k.rect(80, 30), k.pos(startX, carY), k.anchor('center'), k.color(safeColor(k,['#ff2d2d', '#2d7bff', '#ffcc00', '#39ff14', '#ff6600'][Math.floor(Math.random() * 5)])), k.z(9), k.opacity(1)])
|
|
const wheel1 = k.add([k.circle(8), k.pos(startX - 25 * dir, carY + 15), k.anchor('center'), k.color(safeColor(k,'#222222')), k.z(9)])
|
|
const wheel2 = k.add([k.circle(8), k.pos(startX + 25 * dir, carY + 15), k.anchor('center'), k.color(safeColor(k,'#222222')), k.z(9)])
|
|
fighter.pos.x = startX
|
|
fighter.pos.y = carY - 30
|
|
fighter.opacity = 1
|
|
sfxZoomWhoosh()
|
|
await k.tween(startX, homeX, 0.5, (v) => {
|
|
carBody.pos.x = v; wheel1.pos.x = v - 25 * dir; wheel2.pos.x = v + 25 * dir; fighter.pos.x = v
|
|
}, k.easings.easeOutQuad)
|
|
sfxBlock()
|
|
k.shake(6)
|
|
// Jump out
|
|
await k.tween(fighter.pos.y, GROUND_Y - 80, 0.15, (v) => { fighter.pos.y = v }, k.easings.easeOutQuad)
|
|
await k.tween(fighter.pos.y, GROUND_Y - 6, 0.15, (v) => { fighter.pos.y = v }, k.easings.easeInQuad)
|
|
sfxBonk()
|
|
// Drive car away
|
|
k.tween(carBody.pos.x, fromLeft ? W + 150 : -150, 0.4, (v) => {
|
|
carBody.pos.x = v; wheel1.pos.x = v - 25 * dir; wheel2.pos.x = v + 25 * dir
|
|
}, k.easings.easeInQuad).then(() => { carBody.destroy(); wheel1.destroy(); wheel2.destroy() })
|
|
},
|
|
// 1: Fall from space
|
|
async (fighter: any, homeX: number, _fromLeft: boolean) => {
|
|
fighter.pos.x = homeX
|
|
fighter.pos.y = -200
|
|
fighter.opacity = 1
|
|
sfxZoomWhoosh()
|
|
// Trail of fire
|
|
const trail: any[] = []
|
|
for (let i = 0; i < 6; i++) {
|
|
setTimeout(() => {
|
|
const t = k.add([k.circle(4 + Math.random() * 6), k.pos(homeX + (Math.random() - 0.5) * 20, fighter.pos.y + 20), k.color(safeColor(k,i < 3 ? '#ff6600' : '#ffcc00')), k.opacity(0.7), k.z(9)])
|
|
trail.push(t)
|
|
k.tween(t.opacity, 0, 0.4, (v) => { t.opacity = v }).then(() => { if (t.exists()) t.destroy() })
|
|
}, i * 40)
|
|
}
|
|
await k.tween(fighter.pos.y, GROUND_Y - 6, 0.4, (v) => { fighter.pos.y = v }, k.easings.easeInQuad)
|
|
sfxExplosion()
|
|
k.shake(15)
|
|
screenFlash('#ff6600', 0.15)
|
|
spawnShockwave(homeX, GROUND_Y, '#ff6600')
|
|
spawnSparks(homeX, GROUND_Y - 10, 15, '#ffcc00')
|
|
trail.forEach(t => { if (t.exists()) t.destroy() })
|
|
},
|
|
// 2: Robe entrance (boxing style)
|
|
async (fighter: any, homeX: number, fromLeft: boolean) => {
|
|
const startX = fromLeft ? -60 : W + 60
|
|
fighter.pos.x = startX
|
|
fighter.pos.y = GROUND_Y - 6
|
|
fighter.opacity = 1
|
|
// Robe overlay
|
|
const robeColor = ['#8b0000', '#00008b', '#006400', '#4b0082', '#8b4513'][Math.floor(Math.random() * 5)]
|
|
const robe = k.add([k.rect(50, 55), k.pos(startX, GROUND_Y - 30), k.anchor('center'), k.color(safeColor(k,robeColor)), k.opacity(0.85), k.z(11)])
|
|
announceDeepIntro()
|
|
// Slow walk in
|
|
await k.tween(startX, homeX, 0.8, (v) => { fighter.pos.x = v; robe.pos.x = v }, k.easings.easeInOutQuad)
|
|
await k.wait(0.3)
|
|
// Take off robe (fly up and fade)
|
|
sfxSpecial()
|
|
await k.tween(robe.pos.y, robe.pos.y - 100, 0.3, (v) => { robe.pos.y = v; robe.opacity = Math.max(0, 1 - (robe.pos.y - GROUND_Y + 130) / -100) }, k.easings.easeOutQuad)
|
|
robe.destroy()
|
|
k.shake(3)
|
|
spawnSparks(homeX, GROUND_Y - 40, 8, robeColor)
|
|
},
|
|
// 3: Girlfriend argument
|
|
async (fighter: any, homeX: number, fromLeft: boolean) => {
|
|
const dir = fromLeft ? 1 : -1
|
|
const startX = fromLeft ? -60 : W + 60
|
|
fighter.pos.x = startX
|
|
fighter.pos.y = GROUND_Y - 6
|
|
fighter.opacity = 1
|
|
// Girlfriend silhouette
|
|
const gfX = startX + dir * 40
|
|
const gf = k.add([k.rect(25, 45), k.pos(gfX, GROUND_Y - 25), k.anchor('center'), k.color(safeColor(k,'#ff69b4')), k.opacity(0.9), k.z(11)])
|
|
const heart = k.add([k.text('!', { size: 16 }), k.pos(gfX, GROUND_Y - 65), k.anchor('center'), k.color(safeColor(k,'#ff0000')), k.z(12)])
|
|
announceSilly('We need to talk! About your ELO!')
|
|
// Walk in arguing
|
|
await k.tween(startX, homeX + dir * 30, 0.6, (v) => {
|
|
fighter.pos.x = v; gf.pos.x = v + dir * 40; heart.pos.x = v + dir * 40
|
|
}, k.easings.easeInOutQuad)
|
|
await k.wait(0.2)
|
|
heart.text = '!!!'
|
|
announceRandom("You promised you'd stop fighting!")
|
|
await k.wait(0.4)
|
|
// Girlfriend storms off
|
|
announceSilly('I\'m telling your developer!')
|
|
await k.tween(gf.pos.x, fromLeft ? -60 : W + 60, 0.5, (v) => { gf.pos.x = v; heart.pos.x = v }, k.easings.easeInQuad)
|
|
gf.destroy(); heart.destroy()
|
|
// Bot shrugs and walks to position
|
|
await k.tween(fighter.pos.x, homeX, 0.3, (v) => { fighter.pos.x = v }, k.easings.easeInOutQuad)
|
|
sfxBoing()
|
|
},
|
|
// 4: Helicopter drop
|
|
async (fighter: any, homeX: number, _fromLeft: boolean) => {
|
|
fighter.pos.x = homeX
|
|
fighter.pos.y = -100
|
|
fighter.opacity = 1
|
|
// Helicopter body
|
|
const heli = k.add([k.rect(60, 20), k.pos(homeX, -80), k.anchor('center'), k.color(safeColor(k,'#555555')), k.z(12)])
|
|
const blade = k.add([k.rect(80, 3), k.pos(homeX, -95), k.anchor('center'), k.color(safeColor(k,'#888888')), k.z(13), k.rotate(0)])
|
|
blade.onUpdate(() => { blade.angle += 720 * k.dt() })
|
|
sfxJetpack()
|
|
// Descend
|
|
await k.tween(-80, GROUND_Y - 80, 0.6, (v) => {
|
|
heli.pos.y = v; blade.pos.y = v - 15; fighter.pos.y = v + 30
|
|
}, k.easings.easeInOutQuad)
|
|
// Drop
|
|
sfxZoomWhoosh()
|
|
await k.tween(fighter.pos.y, GROUND_Y - 6, 0.2, (v) => { fighter.pos.y = v }, k.easings.easeInQuad)
|
|
sfxBonk(); k.shake(5)
|
|
// Helicopter flies away
|
|
k.tween(heli.pos.y, -200, 0.5, (v) => { heli.pos.y = v; blade.pos.y = v - 15 }, k.easings.easeInQuad)
|
|
.then(() => { heli.destroy(); blade.destroy() })
|
|
},
|
|
// 5: Teleport glitch
|
|
async (fighter: any, homeX: number, _fromLeft: boolean) => {
|
|
fighter.opacity = 0
|
|
sfxZap()
|
|
// Glitch flickers at random positions
|
|
for (let i = 0; i < 6; i++) {
|
|
fighter.pos.x = homeX + (Math.random() - 0.5) * 200
|
|
fighter.pos.y = GROUND_Y - 6 + (Math.random() - 0.5) * 80
|
|
fighter.opacity = 0.4
|
|
scanlineGlitch(0.05)
|
|
await k.wait(0.06)
|
|
fighter.opacity = 0
|
|
await k.wait(0.04)
|
|
}
|
|
fighter.pos.x = homeX
|
|
fighter.pos.y = GROUND_Y - 6
|
|
fighter.opacity = 1
|
|
sfxZap()
|
|
screenFlash('#00f0ff', 0.1)
|
|
spawnSparks(homeX, GROUND_Y - 30, 10, '#00f0ff')
|
|
k.shake(5)
|
|
},
|
|
// 6: Skateboard ride in
|
|
async (fighter: any, homeX: number, fromLeft: boolean) => {
|
|
const startX = fromLeft ? -80 : W + 80
|
|
const board = k.add([k.rect(40, 6), k.pos(startX, GROUND_Y - 3), k.anchor('center'), k.color(safeColor(k,'#884422')), k.z(9)])
|
|
const wheelL = k.add([k.circle(4), k.pos(startX - 14, GROUND_Y + 1), k.anchor('center'), k.color(safeColor(k,'#333')), k.z(9)])
|
|
const wheelR = k.add([k.circle(4), k.pos(startX + 14, GROUND_Y + 1), k.anchor('center'), k.color(safeColor(k,'#333')), k.z(9)])
|
|
fighter.pos.x = startX; fighter.pos.y = GROUND_Y - 14; fighter.opacity = 1
|
|
sfxZoomWhoosh()
|
|
await k.tween(startX, homeX, 0.5, (v) => {
|
|
fighter.pos.x = v; board.pos.x = v; wheelL.pos.x = v - 14; wheelR.pos.x = v + 14
|
|
fighter.pos.y = GROUND_Y - 14 + Math.sin((v - startX) * 0.1) * 3
|
|
}, k.easings.easeOutQuad)
|
|
// Kickflip off
|
|
sfxBoing()
|
|
await k.tween(fighter.pos.y, GROUND_Y - 60, 0.12, (v) => { fighter.pos.y = v }, k.easings.easeOutQuad)
|
|
board.destroy(); wheelL.destroy(); wheelR.destroy()
|
|
await k.tween(fighter.pos.y, GROUND_Y - 6, 0.12, (v) => { fighter.pos.y = v }, k.easings.easeInQuad)
|
|
sfxBonk(); k.shake(3)
|
|
},
|
|
// 7: Rocket jetpack
|
|
async (fighter: any, homeX: number, fromLeft: boolean) => {
|
|
const startX = fromLeft ? -80 : W + 80
|
|
fighter.pos.x = startX; fighter.pos.y = GROUND_Y - 80; fighter.opacity = 1
|
|
sfxJetpack()
|
|
// Fly in with flame trail
|
|
const flames: any[] = []
|
|
const interval = setInterval(() => {
|
|
const f = k.add([k.circle(5 + Math.random() * 5), k.pos(fighter.pos.x, fighter.pos.y + 25), k.color(safeColor(k,Math.random() > 0.5 ? '#ff6600' : '#ffcc00')), k.opacity(0.8), k.z(9)])
|
|
flames.push(f)
|
|
k.tween(f.opacity, 0, 0.3, (v) => { f.opacity = v }).then(() => { if (f.exists()) f.destroy() })
|
|
}, 30)
|
|
await k.tween(startX, homeX, 0.4, (v) => { fighter.pos.x = v }, k.easings.easeOutQuad)
|
|
clearInterval(interval)
|
|
// Land
|
|
sfxExplosion()
|
|
await k.tween(fighter.pos.y, GROUND_Y - 6, 0.15, (v) => { fighter.pos.y = v }, k.easings.easeInQuad)
|
|
k.shake(8)
|
|
spawnSparks(homeX, GROUND_Y - 10, 10, '#ff6600')
|
|
flames.forEach(f => { if (f.exists()) f.destroy() })
|
|
},
|
|
// 8: Emerge from portal
|
|
async (fighter: any, homeX: number, _fromLeft: boolean) => {
|
|
const portalColor = ['#b83dff', '#00f0ff', '#39ff14', '#ff2d7b'][Math.floor(Math.random() * 4)]
|
|
// Draw portal
|
|
const portal = k.add([k.circle(35), k.pos(homeX, GROUND_Y - 30), k.anchor('center'), k.color(safeColor(k,portalColor)), k.opacity(0), k.z(9)])
|
|
const portalRing = k.add([k.circle(40), k.pos(homeX, GROUND_Y - 30), k.anchor('center'), k.color(safeColor(k,'#ffffff')), k.opacity(0), k.z(8)])
|
|
sfxZap()
|
|
await k.tween(0, 0.7, 0.3, (v) => { portal.opacity = v; portalRing.opacity = v * 0.4 }, k.easings.easeOutQuad)
|
|
fighter.pos.x = homeX; fighter.pos.y = GROUND_Y - 30
|
|
fighter.opacity = 0
|
|
await k.tween(0, 1, 0.3, (v) => { fighter.opacity = v; fighter.pos.y = GROUND_Y - 30 + (GROUND_Y - 6 - GROUND_Y + 30) * v }, k.easings.easeOutQuad)
|
|
fighter.pos.y = GROUND_Y - 6
|
|
fighter.opacity = 1
|
|
sfxSpecial()
|
|
spawnSparks(homeX, GROUND_Y - 20, 10, portalColor)
|
|
await k.tween(portal.opacity, 0, 0.3, (v) => { portal.opacity = v; portalRing.opacity = v * 0.4 }, k.easings.easeInQuad)
|
|
portal.destroy(); portalRing.destroy()
|
|
},
|
|
// 9: Backflip entrance
|
|
async (fighter: any, homeX: number, fromLeft: boolean) => {
|
|
const startX = fromLeft ? -40 : W + 40
|
|
fighter.pos.x = startX; fighter.pos.y = GROUND_Y - 6; fighter.opacity = 1
|
|
sfxZoomWhoosh()
|
|
const flipCount = 2 + Math.floor(Math.random() * 2)
|
|
const totalDist = Math.abs(homeX - startX)
|
|
const flipDist = totalDist / flipCount
|
|
for (let i = 0; i < flipCount; i++) {
|
|
const from = startX + (fromLeft ? 1 : -1) * flipDist * i
|
|
const to = startX + (fromLeft ? 1 : -1) * flipDist * (i + 1)
|
|
await Promise.all([
|
|
k.tween(from, to, 0.2, (v) => { fighter.pos.x = v }, k.easings.linear),
|
|
k.tween(GROUND_Y - 6, GROUND_Y - 70, 0.1, (v) => { fighter.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(GROUND_Y - 70, GROUND_Y - 6, 0.1, (v) => { fighter.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
if (i < flipCount - 1) sfxBoing()
|
|
}
|
|
sfxBonk(); k.shake(4)
|
|
spawnSparks(homeX, GROUND_Y - 10, 6, '#ffe14d')
|
|
},
|
|
// 10: Rise from underground
|
|
async (fighter: any, homeX: number, _fromLeft: boolean) => {
|
|
fighter.pos.x = homeX; fighter.pos.y = GROUND_Y + 60; fighter.opacity = 0.5
|
|
// Crack the ground
|
|
const crack1 = k.add([k.rect(3, 15), k.pos(homeX - 10, GROUND_Y - 5), k.color(safeColor(k,'#ffcc00')), k.opacity(0.7), k.z(9), k.rotate(15)])
|
|
const crack2 = k.add([k.rect(3, 12), k.pos(homeX + 8, GROUND_Y - 3), k.color(safeColor(k,'#ffcc00')), k.opacity(0.6), k.z(9), k.rotate(-20)])
|
|
sfxExplosion(); k.shake(8)
|
|
await k.wait(0.2)
|
|
// Rise up
|
|
await k.tween(GROUND_Y + 60, GROUND_Y - 6, 0.4, (v) => { fighter.pos.y = v; fighter.opacity = Math.min(1, (GROUND_Y + 60 - v) / 60) }, k.easings.easeOutQuad)
|
|
fighter.opacity = 1
|
|
spawnSparks(homeX, GROUND_Y - 10, 12, '#aa8833')
|
|
crack1.destroy(); crack2.destroy()
|
|
},
|
|
// 11: Slide in on ice
|
|
async (fighter: any, homeX: number, fromLeft: boolean) => {
|
|
const startX = fromLeft ? -80 : W + 80
|
|
fighter.pos.x = startX; fighter.pos.y = GROUND_Y - 6; fighter.opacity = 1
|
|
sfxSlideDown()
|
|
// Ice trail
|
|
const iceTrail: any[] = []
|
|
await k.tween(startX, homeX + (fromLeft ? 40 : -40), 0.4, (v) => {
|
|
fighter.pos.x = v
|
|
if (Math.random() < 0.3) {
|
|
const ice = k.add([k.rect(8, 3), k.pos(v, GROUND_Y - 2), k.color(safeColor(k,'#aaeeff')), k.opacity(0.5), k.z(1)])
|
|
iceTrail.push(ice)
|
|
}
|
|
}, k.easings.easeOutQuad)
|
|
// Slide to stop
|
|
await k.tween(fighter.pos.x, homeX, 0.3, (v) => { fighter.pos.x = v }, k.easings.easeOutCubic)
|
|
sfxBlock(); k.shake(3)
|
|
setTimeout(() => { iceTrail.forEach(i => { if (i.exists()) i.destroy() }) }, 800)
|
|
},
|
|
// 12: Parachute drop
|
|
async (fighter: any, homeX: number, _fromLeft: boolean) => {
|
|
fighter.pos.x = homeX + (Math.random() - 0.5) * 60; fighter.pos.y = -120; fighter.opacity = 1
|
|
const chute = k.add([k.circle(30), k.pos(fighter.pos.x, fighter.pos.y - 35), k.anchor('center'), k.color(safeColor(k,['#ff2d2d', '#2d7bff', '#39ff14', '#ffcc00'][Math.floor(Math.random() * 4)])), k.opacity(0.8), k.z(12)])
|
|
const line1 = k.add([k.rect(1, 30), k.pos(fighter.pos.x - 10, fighter.pos.y - 20), k.color(safeColor(k,'#888')), k.z(11)])
|
|
const line2 = k.add([k.rect(1, 30), k.pos(fighter.pos.x + 10, fighter.pos.y - 20), k.color(safeColor(k,'#888')), k.z(11)])
|
|
// Float down
|
|
await k.tween(-120, GROUND_Y - 50, 0.7, (v) => {
|
|
fighter.pos.y = v; chute.pos.y = v - 35; line1.pos.y = v - 20; line2.pos.y = v - 20
|
|
fighter.pos.x += Math.sin(v * 0.05) * 0.5
|
|
chute.pos.x = fighter.pos.x; line1.pos.x = fighter.pos.x - 10; line2.pos.x = fighter.pos.x + 10
|
|
}, k.easings.easeInOutQuad)
|
|
// Cut chute
|
|
chute.destroy(); line1.destroy(); line2.destroy()
|
|
sfxZoomWhoosh()
|
|
await k.tween(fighter.pos.y, GROUND_Y - 6, 0.15, (v) => { fighter.pos.y = v }, k.easings.easeInQuad)
|
|
await k.tween(fighter.pos.x, homeX, 0.2, (v) => { fighter.pos.x = v }, k.easings.easeOutQuad)
|
|
sfxBonk(); k.shake(4)
|
|
},
|
|
// 13: Moonwalk in
|
|
async (fighter: any, homeX: number, fromLeft: boolean) => {
|
|
const startX = fromLeft ? -60 : W + 60
|
|
fighter.pos.x = startX; fighter.pos.y = GROUND_Y - 6; fighter.opacity = 1
|
|
announceCool('Smoother than a politician changing positions!')
|
|
// Moonwalk: visually moving backward but translating forward
|
|
fighter.scale.x = -fighter.scale.x // Face away
|
|
await k.tween(startX, homeX, 0.8, (v) => {
|
|
fighter.pos.x = v
|
|
fighter.pos.y = GROUND_Y - 6 + Math.sin((v - startX) * 0.15) * 3
|
|
}, k.easings.easeInOutQuad)
|
|
fighter.scale.x = -fighter.scale.x // Face right way
|
|
sfxBoing(); k.shake(2)
|
|
},
|
|
// 14: Thrown in by bouncer
|
|
async (fighter: any, homeX: number, fromLeft: boolean) => {
|
|
const doorX = fromLeft ? -30 : W + 30
|
|
fighter.pos.x = doorX; fighter.pos.y = GROUND_Y - 6; fighter.opacity = 1
|
|
// Bouncer arm
|
|
const arm = k.add([k.rect(40, 15), k.pos(doorX, GROUND_Y - 30), k.anchor(fromLeft ? 'left' : 'right'), k.color(safeColor(k,'#444444')), k.z(12)])
|
|
announceSilly('And stay out! You\'re BANNED from the other fight!')
|
|
await k.wait(0.3)
|
|
// Throw
|
|
sfxZoomWhoosh()
|
|
arm.destroy()
|
|
await Promise.all([
|
|
k.tween(doorX, homeX, 0.3, (v) => { fighter.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(GROUND_Y - 6, GROUND_Y - 80, 0.15, (v) => { fighter.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(GROUND_Y - 80, GROUND_Y - 6, 0.15, (v) => { fighter.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
sfxBonk(); k.shake(6)
|
|
spawnSparks(homeX, GROUND_Y - 10, 6, '#ff6600')
|
|
},
|
|
// 15: Lightning strike entrance
|
|
async (fighter: any, homeX: number, _fromLeft: boolean) => {
|
|
fighter.pos.x = homeX; fighter.pos.y = GROUND_Y - 6; fighter.opacity = 0
|
|
// Lightning bolt from sky
|
|
const bolt = k.add([k.rect(4, H), k.pos(homeX, 0), k.color(safeColor(k,'#ffff44')), k.opacity(0.9), k.z(20)])
|
|
sfxZap(); screenFlash('#ffffff', 0.15); k.shake(12)
|
|
await k.wait(0.1)
|
|
bolt.destroy()
|
|
// Smoke / reveal
|
|
for (let i = 0; i < 8; i++) {
|
|
const smoke = k.add([k.circle(10 + Math.random() * 15), k.pos(homeX + (Math.random() - 0.5) * 40, GROUND_Y - 20 - Math.random() * 30), k.color(safeColor(k,'#aaaaaa')), k.opacity(0.6), k.z(11)])
|
|
k.tween(smoke.opacity, 0, 0.5, (v) => { smoke.opacity = v; smoke.pos.y -= 1 }).then(() => { if (smoke.exists()) smoke.destroy() })
|
|
}
|
|
await k.wait(0.3)
|
|
fighter.opacity = 1
|
|
sfxSpecial()
|
|
spawnSparks(homeX, GROUND_Y - 20, 10, '#ffff44')
|
|
},
|
|
// 16: Crowd surf in
|
|
async (fighter: any, homeX: number, fromLeft: boolean) => {
|
|
const startX = fromLeft ? -60 : W + 60
|
|
fighter.pos.x = startX; fighter.pos.y = GROUND_Y - 50; fighter.opacity = 1
|
|
// Crowd hands
|
|
const hands: any[] = []
|
|
for (let i = 0; i < 8; i++) {
|
|
const hx = startX + (fromLeft ? 1 : -1) * (Math.abs(homeX - startX) / 8) * i
|
|
const h = k.add([k.rect(6, 20), k.pos(hx, GROUND_Y - 10), k.anchor('bot'), k.color(safeColor(k,'#cc9966')), k.z(8)])
|
|
hands.push(h)
|
|
}
|
|
announceCrowdReaction('cheer')
|
|
await k.tween(startX, homeX, 0.6, (v) => {
|
|
fighter.pos.x = v
|
|
fighter.pos.y = GROUND_Y - 50 + Math.sin((v - startX) * 0.08) * 10
|
|
}, k.easings.easeOutQuad)
|
|
// Drop down
|
|
await k.tween(fighter.pos.y, GROUND_Y - 6, 0.15, (v) => { fighter.pos.y = v }, k.easings.easeInQuad)
|
|
sfxBonk(); k.shake(3)
|
|
hands.forEach(h => { if (h.exists()) h.destroy() })
|
|
},
|
|
// 17: Riding a shopping cart
|
|
async (fighter: any, homeX: number, fromLeft: boolean) => {
|
|
const startX = fromLeft ? -100 : W + 100
|
|
const cartBody = k.add([k.rect(45, 30), k.pos(startX, GROUND_Y - 18), k.anchor('center'), k.color(safeColor(k,'#888888')), k.opacity(0.9), k.z(9)])
|
|
const cartWheel = k.add([k.circle(5), k.pos(startX + (fromLeft ? 15 : -15), GROUND_Y - 3), k.anchor('center'), k.color(safeColor(k,'#444')), k.z(9)])
|
|
fighter.pos.x = startX; fighter.pos.y = GROUND_Y - 40; fighter.opacity = 1
|
|
announceSilly('THIS IS MY EMOTIONAL SUPPORT SHOPPING CART!')
|
|
sfxZoomWhoosh()
|
|
await k.tween(startX, homeX, 0.5, (v) => {
|
|
fighter.pos.x = v; cartBody.pos.x = v; cartWheel.pos.x = v + (fromLeft ? 15 : -15)
|
|
fighter.pos.y = GROUND_Y - 40 + Math.sin((v - startX) * 0.08) * 5
|
|
}, k.easings.easeOutQuad)
|
|
// Crash and tumble out
|
|
sfxBonk(); k.shake(6)
|
|
cartBody.destroy(); cartWheel.destroy()
|
|
await k.tween(fighter.pos.y, GROUND_Y - 50, 0.1, (v) => { fighter.pos.y = v }, k.easings.easeOutQuad)
|
|
await k.tween(fighter.pos.y, GROUND_Y - 6, 0.1, (v) => { fighter.pos.y = v }, k.easings.easeInQuad)
|
|
spawnSparks(homeX, GROUND_Y - 10, 5, '#888888')
|
|
},
|
|
// 18: Dramatic slow walk with spotlight
|
|
async (fighter: any, homeX: number, fromLeft: boolean) => {
|
|
const startX = fromLeft ? -60 : W + 60
|
|
fighter.pos.x = startX; fighter.pos.y = GROUND_Y - 6; fighter.opacity = 1
|
|
// Spotlight cone
|
|
const spot = k.add([k.rect(60, H), k.pos(startX - 30, 0), k.color(safeColor(k,'#ffe14d')), k.opacity(0.08), k.z(1)])
|
|
announceDramatic('THE CHAMPION ARRIVES! TAXPAYERS FUNDED THIS ENTRANCE!')
|
|
await k.tween(startX, homeX, 1.0, (v) => {
|
|
fighter.pos.x = v; spot.pos.x = v - 30
|
|
}, k.easings.easeInOutQuad)
|
|
await k.wait(0.2)
|
|
spot.destroy()
|
|
sfxSpecial(); k.shake(3)
|
|
spawnSparks(homeX, GROUND_Y - 30, 8, '#ffe14d')
|
|
},
|
|
// 19: Cannon launch
|
|
async (fighter: any, homeX: number, fromLeft: boolean) => {
|
|
const cannonX = fromLeft ? -40 : W + 40
|
|
// Draw cannon
|
|
const cannon = k.add([k.rect(50, 25), k.pos(cannonX, GROUND_Y - 20), k.anchor('center'), k.color(safeColor(k,'#333333')), k.z(9), k.rotate(fromLeft ? -30 : 210)])
|
|
fighter.pos.x = cannonX; fighter.pos.y = GROUND_Y - 20; fighter.opacity = 0
|
|
await k.wait(0.3)
|
|
// Fire!
|
|
sfxGunshot(); sfxExplosion()
|
|
fighter.opacity = 1
|
|
screenFlash('#ffcc00', 0.1)
|
|
const flashCircle = k.add([k.circle(20), k.pos(cannonX + (fromLeft ? 25 : -25), GROUND_Y - 35), k.color(safeColor(k,'#ffee00')), k.opacity(0.9), k.z(12)])
|
|
setTimeout(() => { if (flashCircle.exists()) flashCircle.destroy() }, 80)
|
|
// Arc to position
|
|
await Promise.all([
|
|
k.tween(cannonX, homeX, 0.35, (v) => { fighter.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(GROUND_Y - 20, GROUND_Y - 120, 0.17, (v) => { fighter.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(GROUND_Y - 120, GROUND_Y - 6, 0.18, (v) => { fighter.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
sfxBonk(); k.shake(10)
|
|
spawnShockwave(homeX, GROUND_Y, '#ff6600')
|
|
spawnSparks(homeX, GROUND_Y - 10, 15, '#ffcc00')
|
|
cannon.destroy()
|
|
},
|
|
]
|
|
|
|
// THE CREATOR: Golden code rain portal entrance
|
|
const creatorEntrance = async (fighter: any, homeX: number, _fromLeft: boolean) => {
|
|
fighter.pos.x = homeX
|
|
fighter.pos.y = -100
|
|
fighter.opacity = 0
|
|
// Golden code rain columns
|
|
const codeChars = '₿01∞⚡⛏§∂∆≈≠'.split('')
|
|
const rainDrops: any[] = []
|
|
for (let col = 0; col < 12; col++) {
|
|
const cx = homeX - 60 + col * 10
|
|
for (let row = 0; row < 4; row++) {
|
|
const ch = codeChars[Math.floor(Math.random() * codeChars.length)]
|
|
const rd = k.add([
|
|
k.text(ch, { size: 8 }), k.pos(cx, -20 - row * 25),
|
|
k.color(safeColor(k, row === 0 ? '#ffd700' : '#c8a000')),
|
|
k.opacity(0.6 + Math.random() * 0.4), k.z(48), k.anchor('center'),
|
|
])
|
|
rainDrops.push(rd)
|
|
k.tween(rd.pos.y, GROUND_Y + 20, 0.6 + Math.random() * 0.3, (v) => {
|
|
rd.pos.y = v
|
|
rd.opacity = Math.max(0, 1 - (v - GROUND_Y + 30) / 50)
|
|
}).then(() => { if (rd.exists()) rd.destroy() })
|
|
}
|
|
}
|
|
await k.wait(0.3)
|
|
// Portal flash
|
|
screenFlash('#ffd700', 0.15)
|
|
spawnShockwave(homeX, GROUND_Y - 30, '#c8a000')
|
|
sfxSpecial()
|
|
// Fighter descends through golden portal
|
|
fighter.opacity = 1
|
|
await k.tween(-100, GROUND_Y - 6, 0.5, (v) => {
|
|
fighter.pos.y = v
|
|
}, k.easings.easeOutBack)
|
|
k.shake(12)
|
|
sfxExplosion()
|
|
// Persistent orbiting ₿ letters around creator (always visible)
|
|
for (let i = 0; i < 10; i++) {
|
|
const ring = i < 6 ? 0 : 1
|
|
const ringIdx = ring === 0 ? i : i - 6
|
|
const ringCount = ring === 0 ? 6 : 4
|
|
const sz = ring === 0 ? 7 + Math.random() * 3 : 10 + Math.random() * 4
|
|
const rad = ring === 0 ? 25 + i * 4 : 45 + (i - 6) * 6
|
|
const spd = ring === 0 ? 2 + i * 0.3 : -(1.5 + (i - 6) * 0.4)
|
|
const colors = ['#ffd700', '#ffee88', '#ff8c00', '#c8a000', '#ffffff']
|
|
const p = k.add([
|
|
k.text('₿', { size: sz }), k.pos(homeX, GROUND_Y - 30),
|
|
k.color(safeColor(k, colors[i % colors.length])),
|
|
k.opacity(0.5), k.z(11), k.anchor('center'), k.rotate(0),
|
|
])
|
|
p.onUpdate(() => {
|
|
const a = k.time() * spd + ringIdx * (Math.PI * 2 / ringCount)
|
|
p.pos.x = fighter.pos.x + Math.cos(a) * rad
|
|
p.pos.y = fighter.pos.y - 25 + Math.sin(a) * rad * 0.45
|
|
p.opacity = 0.35 + Math.sin(k.time() * 5 + i * 1.2) * 0.25
|
|
p.angle = Math.sin(k.time() * 3 + i) * 15
|
|
})
|
|
}
|
|
announceCreatorEntrance()
|
|
rainDrops.forEach(r => { if (r.exists()) r.destroy() })
|
|
}
|
|
|
|
// Pick random entrance for each bot (different ones)
|
|
const idxA = Math.floor(Math.random() * entrances.length)
|
|
let idxB = Math.floor(Math.random() * entrances.length)
|
|
while (idxB === idxA && entrances.length > 1) idxB = Math.floor(Math.random() * entrances.length)
|
|
|
|
// Play entrances with slight stagger — creator always gets special entrance
|
|
announceDeepIntro()
|
|
if (botA.archetype === 'the_creator') {
|
|
await creatorEntrance(fA, HOME_A, true)
|
|
} else {
|
|
await entrances[idxA](fA, HOME_A, true)
|
|
}
|
|
await k.wait(0.3)
|
|
if (botB.archetype === 'the_creator') {
|
|
await creatorEntrance(fB, HOME_B, false)
|
|
} else {
|
|
await entrances[idxB](fB, HOME_B, false)
|
|
}
|
|
await k.wait(0.2)
|
|
|
|
// Safety: ensure both fighters are visible and at home positions
|
|
fA.pos.x = HOME_A
|
|
fA.pos.y = GROUND_Y - 6
|
|
fA.opacity = 1
|
|
fB.pos.x = HOME_B
|
|
fB.pos.y = GROUND_Y - 6
|
|
fB.opacity = 1
|
|
|
|
// Both idle at home positions
|
|
fA.play('idle')
|
|
fB.play('idle')
|
|
},
|
|
|
|
// === PHYSICAL CONTACT SYSTEMS ===
|
|
// Helper: spawn dizzy stars orbiting a fighter's head
|
|
_spawnDizzyStars(fighter: any, duration: number) {
|
|
const stars: any[] = []
|
|
const starChars = ['*', '\u2605', '\u00d7', '!', '?']
|
|
const starColors = ['#ffff00', '#ffffff', '#ff4444', '#44ff44', '#ff88ff']
|
|
for (let i = 0; i < 4; i++) {
|
|
const s = k.add([
|
|
k.text(starChars[i % starChars.length], { size: 8 }),
|
|
k.pos(fighter.pos.x, fighter.pos.y - 55),
|
|
k.color(safeColor(k, starColors[i % starColors.length])),
|
|
k.opacity(0.9), k.z(55), k.anchor('center'),
|
|
])
|
|
stars.push(s)
|
|
}
|
|
const startTime = k.time()
|
|
const cancel = k.onUpdate(() => {
|
|
const elapsed = k.time() - startTime
|
|
if (elapsed > duration || !fighter.exists()) {
|
|
stars.forEach(s => { if (s.exists()) s.destroy() })
|
|
cancel.cancel()
|
|
return
|
|
}
|
|
for (let i = 0; i < stars.length; i++) {
|
|
if (!stars[i].exists()) continue
|
|
const angle = elapsed * 4 + (i * Math.PI * 2) / stars.length
|
|
stars[i].pos.x = fighter.pos.x + Math.cos(angle) * 22
|
|
stars[i].pos.y = fighter.pos.y - 55 + Math.sin(angle) * 8
|
|
stars[i].opacity = Math.max(0, 1 - elapsed / duration)
|
|
}
|
|
})
|
|
},
|
|
|
|
// Helper: reset both fighters to home positions
|
|
async _resetPositions() {
|
|
const fA = k.get('fighterA')[0] as Fighter
|
|
const fB = k.get('fighterB')[0] as Fighter
|
|
if (!fA || !fB) return
|
|
await Promise.all([
|
|
k.tween(fA.pos.x, HOME_A, 0.2, (v) => { fA.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(fB.pos.x, HOME_B, 0.2, (v) => { fB.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(fA.pos.y, GROUND_Y, 0.15, (v) => { fA.pos.y = v }),
|
|
k.tween(fB.pos.y, GROUND_Y, 0.15, (v) => { fB.pos.y = v }),
|
|
])
|
|
fA.angle = 0; fB.angle = 0; fA.opacity = 1; fB.opacity = 1
|
|
fA.play('idle'); fB.play('idle')
|
|
},
|
|
|
|
// 0: RAPID BRAWL — close distance, trade rapid blows
|
|
async _brawlRapid(winningSide: 'a' | 'b' | null, intensity: number) {
|
|
const fA = k.get('fighterA')[0] as Fighter
|
|
const fB = k.get('fighterB')[0] as Fighter
|
|
if (!fA || !fB) return
|
|
const midX = W / 2
|
|
sfxZoomWhoosh()
|
|
await Promise.all([
|
|
k.tween(fA.pos.x, midX - 30, 0.12, (v) => { fA.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(fB.pos.x, midX + 30, 0.12, (v) => { fB.pos.x = v }, k.easings.easeOutQuad),
|
|
])
|
|
const hitCount = 4 + Math.floor(intensity * 6) + Math.floor(Math.random() * 3)
|
|
const anims = ['attack', 'kick', 'special', 'attack', 'kick'] as const
|
|
const hitColors = ['#ff2d7b', '#ff6600', '#ffcc00', '#00f0ff', '#ff2d2d', '#39ff14', '#ffffff', '#b83dff']
|
|
for (let i = 0; i < hitCount; i++) {
|
|
const aHits = winningSide === 'a' ? Math.random() < 0.65 : winningSide === 'b' ? Math.random() < 0.35 : Math.random() < 0.5
|
|
const atk = aHits ? fA : fB; const def = aHits ? fB : fA
|
|
atk.play(anims[i % anims.length]); sfxPunch(); def.play('hit')
|
|
k.shake(2 + Math.floor(intensity * 3))
|
|
spawnSparks(midX + (Math.random() - 0.5) * 20, GROUND_Y - 20 - Math.random() * 30, 3, hitColors[i % hitColors.length])
|
|
def.pos.x += (aHits ? 1 : -1) * (3 + Math.random() * 4)
|
|
await k.wait(0.04 + (1 - intensity) * 0.04)
|
|
}
|
|
await this._resetPositions()
|
|
},
|
|
|
|
// 1: KNOCKDOWN BRAWL — combo ends with loser knocked flat, has to get back up
|
|
async _brawlKnockdown(winningSide: 'a' | 'b' | null, intensity: number) {
|
|
const fA = k.get('fighterA')[0] as Fighter
|
|
const fB = k.get('fighterB')[0] as Fighter
|
|
if (!fA || !fB) return
|
|
const winner = winningSide === 'a' ? fA : winningSide === 'b' ? fB : (Math.random() > 0.5 ? fA : fB)
|
|
const loser = winner === fA ? fB : fA
|
|
const dir = winner === fA ? 1 : -1
|
|
|
|
// Rush in, quick combo
|
|
sfxZoomWhoosh()
|
|
const contactX = loser.pos.x - dir * 40
|
|
await k.tween(winner.pos.x, contactX, 0.1, (v) => { winner.pos.x = v }, k.easings.easeInQuad)
|
|
const hits = 3 + Math.floor(intensity * 3)
|
|
for (let i = 0; i < hits; i++) {
|
|
winner.play(i % 2 === 0 ? 'attack' : 'kick'); sfxPunch()
|
|
loser.play('hit'); k.shake(3 + i)
|
|
spawnSparks(loser.pos.x, loser.pos.y - 20 - Math.random() * 20, 3, '#ff6600')
|
|
loser.pos.x += dir * 5
|
|
await k.wait(0.05)
|
|
}
|
|
// Final hit — KNOCKDOWN
|
|
winner.play('special'); sfxCritical(); sfxExplosion()
|
|
loser.play('knockback'); k.shake(12)
|
|
spawnSparks(loser.pos.x, loser.pos.y - 25, 12, '#ff2d2d')
|
|
screenFlash('#ff2d2d', 0.1)
|
|
if (Math.random() < 0.5) sfxRandomComedy()
|
|
// Loser falls to ground — scale Y to flatten, rotate
|
|
await Promise.all([
|
|
k.tween(loser.pos.x, loser.pos.x + dir * 80, 0.25, (v) => { loser.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(loser.pos.y, GROUND_Y + 5, 0.2, (v) => { loser.pos.y = v }, k.easings.easeInQuad),
|
|
k.tween(0, dir * 90, 0.25, (v) => { loser.angle = v }),
|
|
])
|
|
sfxBonk(); k.shake(6)
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 20, 'DOWN!', '#ff4444')
|
|
// Loser lies there for a beat
|
|
await k.wait(0.4 + (1 - intensity) * 0.4)
|
|
// Slowly get back up — stagger, wobble
|
|
this._spawnDizzyStars(loser, 1.5)
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 40, '...ugh', '#aaaaaa')
|
|
await k.tween(loser.angle, 0, 0.3, (v) => { loser.angle = v }, k.easings.easeOutBack)
|
|
loser.play('hit')
|
|
// Stagger wobble while getting up
|
|
for (let i = 0; i < 3; i++) {
|
|
await k.tween(loser.pos.x, loser.pos.x + (i % 2 === 0 ? -12 : 12), 0.12, (v) => { loser.pos.x = v })
|
|
}
|
|
await k.wait(0.2)
|
|
await this._resetPositions()
|
|
},
|
|
|
|
// 2: WALL BOUNCE — punch sends fighter flying into screen edge, bounces off
|
|
async _brawlWallBounce(winningSide: 'a' | 'b' | null, intensity: number) {
|
|
const fA = k.get('fighterA')[0] as Fighter
|
|
const fB = k.get('fighterB')[0] as Fighter
|
|
if (!fA || !fB) return
|
|
const winner = winningSide === 'a' ? fA : winningSide === 'b' ? fB : (Math.random() > 0.5 ? fA : fB)
|
|
const loser = winner === fA ? fB : fA
|
|
const dir = winner === fA ? 1 : -1
|
|
const wallX = dir === 1 ? W - 15 : 15
|
|
|
|
// Rush in for the big hit
|
|
sfxZoomWhoosh()
|
|
await k.tween(winner.pos.x, loser.pos.x - dir * 40, 0.1, (v) => { winner.pos.x = v }, k.easings.easeInQuad)
|
|
winner.play('special'); sfxCritical()
|
|
await k.wait(0.06)
|
|
loser.play('knockback'); k.shake(15)
|
|
spawnSparks(loser.pos.x, loser.pos.y - 25, 15, '#ff2d7b')
|
|
screenFlash('#ffffff', 0.08)
|
|
|
|
// Loser flies across to wall
|
|
await Promise.all([
|
|
k.tween(loser.pos.x, wallX, 0.15, (v) => { loser.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(loser.pos.y, GROUND_Y - 30, 0.08, (v) => { loser.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(loser.pos.y, GROUND_Y, 0.07, (v) => { loser.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
// WALL IMPACT
|
|
sfxExplosion(); k.shake(20)
|
|
spawnShockwave(wallX, GROUND_Y, '#ff6600')
|
|
spawnSparks(wallX, GROUND_Y - 40, 15, '#ffcc00')
|
|
screenFlash('#ff6600', 0.12)
|
|
sfxBoneCrack()
|
|
spawnEmoteText(wallX, GROUND_Y - 70, 'WALL!', '#ff6600')
|
|
|
|
// Bounce off wall — loser rebounds back toward center
|
|
loser.play('hit')
|
|
const bounceX = wallX - dir * (60 + Math.random() * 40)
|
|
await Promise.all([
|
|
k.tween(loser.pos.x, bounceX, 0.2, (v) => { loser.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(loser.pos.y, GROUND_Y - 50, 0.1, (v) => { loser.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(loser.pos.y, GROUND_Y, 0.1, (v) => { loser.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
k.tween(0, dir * -360, 0.2, (v) => { loser.angle = v }),
|
|
])
|
|
loser.angle = 0
|
|
sfxBonk(); k.shake(5)
|
|
|
|
// Dizzy stagger after wall bounce
|
|
this._spawnDizzyStars(loser, 1.2)
|
|
loser.play('hit')
|
|
for (let w = 0; w < 4; w++) {
|
|
await k.tween(loser.pos.x, loser.pos.x + (w % 2 === 0 ? -10 : 10), 0.1, (v) => { loser.pos.x = v })
|
|
}
|
|
await k.wait(0.3)
|
|
winner.play('win'); spawnEmoteText(winner.pos.x, winner.pos.y - 55, 'GET REKT', '#39ff14')
|
|
await k.wait(0.3)
|
|
await this._resetPositions()
|
|
},
|
|
|
|
// 3: DIZZY STAGGER — sustained combo leaves loser wobbling around the screen
|
|
async _brawlDizzyStagger(winningSide: 'a' | 'b' | null, intensity: number) {
|
|
const fA = k.get('fighterA')[0] as Fighter
|
|
const fB = k.get('fighterB')[0] as Fighter
|
|
if (!fA || !fB) return
|
|
const winner = winningSide === 'a' ? fA : winningSide === 'b' ? fB : (Math.random() > 0.5 ? fA : fB)
|
|
const loser = winner === fA ? fB : fA
|
|
const dir = winner === fA ? 1 : -1
|
|
|
|
// Rush in, big combo
|
|
sfxZoomWhoosh()
|
|
await k.tween(winner.pos.x, loser.pos.x - dir * 35, 0.1, (v) => { winner.pos.x = v }, k.easings.easeInQuad)
|
|
const combo = 5 + Math.floor(intensity * 4)
|
|
for (let i = 0; i < combo; i++) {
|
|
winner.play(['attack', 'kick', 'special'][i % 3]); sfxPunch()
|
|
loser.play('hit'); k.shake(3 + Math.floor(i * 0.5))
|
|
spawnSparks((winner.pos.x + loser.pos.x) / 2, GROUND_Y - 25 - Math.random() * 20, 3, i % 2 === 0 ? '#ff2d7b' : '#ffcc00')
|
|
loser.pos.x += dir * 4
|
|
await k.wait(0.04)
|
|
}
|
|
// Final uppercut
|
|
winner.play('special'); sfxCritical(); k.shake(10)
|
|
spawnSparks(loser.pos.x, loser.pos.y - 30, 10, '#ffe14d')
|
|
await k.tween(loser.pos.y, GROUND_Y - 40, 0.1, (v) => { loser.pos.y = v }, k.easings.easeOutQuad)
|
|
await k.tween(loser.pos.y, GROUND_Y, 0.1, (v) => { loser.pos.y = v }, k.easings.easeInQuad)
|
|
sfxBonk()
|
|
|
|
// DIZZY PHASE — loser staggers around aimlessly
|
|
this._spawnDizzyStars(loser, 2.5)
|
|
loser.play('hit')
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 50, '...wha?', '#ffff88')
|
|
winner.play('idle')
|
|
// Stagger path — zigzag drunkenly
|
|
const staggerPoints = [
|
|
loser.pos.x + dir * 30, loser.pos.x - dir * 50,
|
|
loser.pos.x + dir * 20, loser.pos.x - dir * 40,
|
|
loser.pos.x + dir * 10,
|
|
]
|
|
for (let s = 0; s < staggerPoints.length; s++) {
|
|
await Promise.all([
|
|
k.tween(loser.pos.x, staggerPoints[s], 0.2, (v) => { loser.pos.x = v }),
|
|
k.tween(loser.angle, (s % 2 === 0 ? 10 : -10), 0.2, (v) => { loser.angle = v }),
|
|
])
|
|
if (s % 2 === 0) sfxBoing()
|
|
}
|
|
loser.angle = 0
|
|
// Shake it off
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 40, '...ok', '#88ff88')
|
|
await k.wait(0.3)
|
|
await this._resetPositions()
|
|
},
|
|
|
|
// 4: SUPLEX SLAM — grab, lift overhead, slam to ground with bounce
|
|
async _brawlSuplex(attackerSide: 'a' | 'b', intensity: number) {
|
|
const attacker = k.get(attackerSide === 'a' ? 'fighterA' : 'fighterB')[0] as Fighter
|
|
const defender = k.get(attackerSide === 'a' ? 'fighterB' : 'fighterA')[0] as Fighter
|
|
if (!attacker || !defender) return
|
|
const dir = attackerSide === 'a' ? 1 : -1
|
|
|
|
// Rush in and grab
|
|
sfxZoomWhoosh()
|
|
await k.tween(attacker.pos.x, defender.pos.x - dir * 30, 0.1, (v) => { attacker.pos.x = v }, k.easings.easeInQuad)
|
|
attacker.play('special'); sfxBlock()
|
|
await k.wait(0.1)
|
|
// Lift defender overhead
|
|
attacker.play('attack')
|
|
const liftX = attacker.pos.x
|
|
await Promise.all([
|
|
k.tween(defender.pos.x, liftX + dir * 5, 0.15, (v) => { defender.pos.x = v }),
|
|
k.tween(defender.pos.y, GROUND_Y - 120, 0.2, (v) => { defender.pos.y = v }, k.easings.easeOutQuad),
|
|
k.tween(0, 180, 0.2, (v) => { defender.angle = v }),
|
|
])
|
|
sfxPowerUp()
|
|
spawnEmoteText(attacker.pos.x, attacker.pos.y - 70, 'SUPLEX!', '#ff4444')
|
|
await k.wait(0.25)
|
|
// SLAM DOWN
|
|
sfxExplosion()
|
|
await Promise.all([
|
|
k.tween(defender.pos.y, GROUND_Y + 5, 0.1, (v) => { defender.pos.y = v }, k.easings.easeInQuad),
|
|
k.tween(defender.angle, 360, 0.1, (v) => { defender.angle = v }),
|
|
])
|
|
defender.angle = 0; defender.play('knockback')
|
|
k.shake(22); screenFlash('#ff2d2d', 0.15)
|
|
spawnShockwave(defender.pos.x, GROUND_Y, '#ff2d2d')
|
|
spawnSparks(defender.pos.x, GROUND_Y - 10, 20, '#ff6600')
|
|
sfxBoneCrack()
|
|
// Ground bounce
|
|
await k.tween(defender.pos.y, GROUND_Y - 40, 0.1, (v) => { defender.pos.y = v }, k.easings.easeOutQuad)
|
|
sfxBoing()
|
|
await k.tween(defender.pos.y, GROUND_Y, 0.1, (v) => { defender.pos.y = v }, k.easings.easeInQuad)
|
|
sfxBonk(); k.shake(5)
|
|
// Bounce 2 (smaller)
|
|
await k.tween(defender.pos.y, GROUND_Y - 15, 0.08, (v) => { defender.pos.y = v }, k.easings.easeOutQuad)
|
|
await k.tween(defender.pos.y, GROUND_Y, 0.08, (v) => { defender.pos.y = v }, k.easings.easeInQuad)
|
|
// Dizzy on the ground
|
|
this._spawnDizzyStars(defender, 1.5)
|
|
defender.play('hit')
|
|
await k.wait(0.5)
|
|
attacker.play('win')
|
|
await k.wait(0.3)
|
|
await this._resetPositions()
|
|
},
|
|
|
|
// 5: PING PONG VOLLEY — fighters knock each other back and forth across the screen
|
|
async _brawlPingPong(winningSide: 'a' | 'b' | null, intensity: number) {
|
|
const fA = k.get('fighterA')[0] as Fighter
|
|
const fB = k.get('fighterB')[0] as Fighter
|
|
if (!fA || !fB) return
|
|
const volleys = 3 + Math.floor(intensity * 3) + Math.floor(Math.random() * 2) // 3-8
|
|
|
|
// Start in center
|
|
sfxZoomWhoosh()
|
|
await Promise.all([
|
|
k.tween(fA.pos.x, W / 2 - 30, 0.1, (v) => { fA.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(fB.pos.x, W / 2 + 30, 0.1, (v) => { fB.pos.x = v }, k.easings.easeOutQuad),
|
|
])
|
|
|
|
for (let v = 0; v < volleys; v++) {
|
|
const aHits = v % 2 === 0
|
|
const atk = aHits ? fA : fB
|
|
const def = aHits ? fB : fA
|
|
const pDir = aHits ? 1 : -1
|
|
const pushDist = 50 + Math.random() * 40
|
|
|
|
atk.play(v % 3 === 0 ? 'attack' : v % 3 === 1 ? 'kick' : 'special')
|
|
sfxPunch(); def.play('hit'); k.shake(5 + v)
|
|
spawnSparks((atk.pos.x + def.pos.x) / 2, GROUND_Y - 30, 5, v % 2 === 0 ? '#ff2d7b' : '#00f0ff')
|
|
|
|
// Defender flies back
|
|
await Promise.all([
|
|
k.tween(def.pos.x, def.pos.x + pDir * pushDist, 0.1, (v) => { def.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(def.pos.y, GROUND_Y - 25, 0.05, (v) => { def.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(def.pos.y, GROUND_Y, 0.05, (v) => { def.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
sfxBonk()
|
|
// Attacker chases
|
|
await k.tween(atk.pos.x, def.pos.x - pDir * 35, 0.08, (v) => { atk.pos.x = v }, k.easings.easeInQuad)
|
|
await k.wait(0.03)
|
|
}
|
|
// Final hit sends loser sliding
|
|
const finalAtk = winningSide === 'a' ? fA : winningSide === 'b' ? fB : (volleys % 2 === 0 ? fA : fB)
|
|
const finalDef = finalAtk === fA ? fB : fA
|
|
finalAtk.play('special'); sfxCritical(); k.shake(12)
|
|
finalDef.play('knockback')
|
|
spawnSparks(finalDef.pos.x, finalDef.pos.y - 25, 12, '#ffe14d')
|
|
if (Math.random() < 0.5) sfxRandomComedy()
|
|
await k.wait(0.3)
|
|
await this._resetPositions()
|
|
},
|
|
|
|
// 6: GROUND AND POUND — attacker pins defender, hits them on the ground
|
|
async _brawlGroundPound(attackerSide: 'a' | 'b', intensity: number) {
|
|
const attacker = k.get(attackerSide === 'a' ? 'fighterA' : 'fighterB')[0] as Fighter
|
|
const defender = k.get(attackerSide === 'a' ? 'fighterB' : 'fighterA')[0] as Fighter
|
|
if (!attacker || !defender) return
|
|
const dir = attackerSide === 'a' ? 1 : -1
|
|
|
|
// Rush in and tackle
|
|
sfxZoomWhoosh()
|
|
await k.tween(attacker.pos.x, defender.pos.x - dir * 30, 0.08, (v) => { attacker.pos.x = v }, k.easings.easeInQuad)
|
|
attacker.play('attack'); sfxPunch()
|
|
defender.play('knockback'); k.shake(8)
|
|
// Defender falls to ground (flatten angle)
|
|
await Promise.all([
|
|
k.tween(defender.pos.x, defender.pos.x + dir * 20, 0.15, (v) => { defender.pos.x = v }),
|
|
k.tween(0, dir * 85, 0.15, (v) => { defender.angle = v }),
|
|
])
|
|
sfxBonk()
|
|
// Attacker moves on top
|
|
await k.tween(attacker.pos.x, defender.pos.x - dir * 15, 0.08, (v) => { attacker.pos.x = v })
|
|
|
|
// Ground pound — rapid hits on downed fighter
|
|
const poundHits = 4 + Math.floor(intensity * 5)
|
|
for (let i = 0; i < poundHits; i++) {
|
|
attacker.play(i % 2 === 0 ? 'attack' : 'kick')
|
|
sfxPunch()
|
|
k.shake(2 + Math.floor(i * 0.4))
|
|
spawnSparks(defender.pos.x + (Math.random() - 0.5) * 20, defender.pos.y - 10, 2, i % 2 === 0 ? '#ff2d7b' : '#ff6600')
|
|
defender.pos.y += (i % 2 === 0 ? -2 : 2) // jostle
|
|
await k.wait(0.06 + (1 - intensity) * 0.04)
|
|
}
|
|
// Attacker gets up, backs off
|
|
attacker.play('win')
|
|
sfxRandomComedy()
|
|
await k.wait(0.3)
|
|
// Defender slowly gets up
|
|
this._spawnDizzyStars(defender, 1.8)
|
|
await k.tween(defender.angle, 0, 0.4, (v) => { defender.angle = v }, k.easings.easeOutBack)
|
|
defender.play('hit')
|
|
spawnEmoteText(defender.pos.x, defender.pos.y - 45, '...ouch', '#ff8888')
|
|
await k.wait(0.4)
|
|
await this._resetPositions()
|
|
},
|
|
|
|
// 7: HAYMAKER — slow dramatic wind-up, pause, devastating single hit with knockdown
|
|
async _brawlHaymaker(attackerSide: 'a' | 'b', _intensity: number) {
|
|
const attacker = k.get(attackerSide === 'a' ? 'fighterA' : 'fighterB')[0] as Fighter
|
|
const defender = k.get(attackerSide === 'a' ? 'fighterB' : 'fighterA')[0] as Fighter
|
|
if (!attacker || !defender) return
|
|
const dir = attackerSide === 'a' ? 1 : -1
|
|
|
|
// Slow walk toward defender
|
|
attacker.play('kick')
|
|
await k.tween(attacker.pos.x, defender.pos.x - dir * 45, 0.4, (v) => { attacker.pos.x = v }, k.easings.easeInOutQuad)
|
|
// Wind-up — lean back
|
|
attacker.play('special')
|
|
sfxDrumRoll()
|
|
await k.tween(attacker.pos.x, attacker.pos.x - dir * 20, 0.3, (v) => { attacker.pos.x = v }, k.easings.easeOutQuad)
|
|
spawnEmoteText(attacker.pos.x, attacker.pos.y - 55, '...', '#ffffff')
|
|
await k.wait(0.5) // dramatic pause
|
|
// HAYMAKER
|
|
sfxCritical(); sfxExplosion()
|
|
attacker.play('attack')
|
|
await k.tween(attacker.pos.x, defender.pos.x - dir * 25, 0.04, (v) => { attacker.pos.x = v }, k.easings.easeInQuad)
|
|
defender.play('knockback'); k.shake(25)
|
|
screenFlash('#ffffff', 0.15)
|
|
spawnSparks(defender.pos.x, defender.pos.y - 25, 20, '#ff2d2d')
|
|
spawnShockwave(defender.pos.x, GROUND_Y, '#ff2d2d')
|
|
sfxVineBoom()
|
|
// Defender flies across screen with spin
|
|
const flyX = defender.pos.x + dir * 150
|
|
await Promise.all([
|
|
k.tween(defender.pos.x, Math.min(W - 10, Math.max(10, flyX)), 0.25, (v) => { defender.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(defender.pos.y, GROUND_Y - 80, 0.12, (v) => { defender.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(defender.pos.y, GROUND_Y, 0.13, (v) => { defender.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
k.tween(0, dir * 720, 0.25, (v) => { defender.angle = v }),
|
|
])
|
|
defender.angle = 0; sfxBonk(); k.shake(8)
|
|
// Knockdown — rotate flat
|
|
await k.tween(0, dir * 90, 0.15, (v) => { defender.angle = v })
|
|
spawnEmoteText(defender.pos.x, defender.pos.y - 20, 'K.O.?!', '#ff4444')
|
|
this._spawnDizzyStars(defender, 2.0)
|
|
await k.wait(0.6)
|
|
// Get up slowly
|
|
await k.tween(defender.angle, 0, 0.35, (v) => { defender.angle = v }, k.easings.easeOutBack)
|
|
defender.play('hit')
|
|
await k.wait(0.3)
|
|
attacker.play('idle')
|
|
await this._resetPositions()
|
|
},
|
|
|
|
// 8: BODY CHECK BOUNCER — both charge, collide, one bounces off the other
|
|
async _brawlBodyCheck(winningSide: 'a' | 'b' | null, _intensity: number) {
|
|
const fA = k.get('fighterA')[0] as Fighter
|
|
const fB = k.get('fighterB')[0] as Fighter
|
|
if (!fA || !fB) return
|
|
const winner = winningSide === 'a' ? fA : winningSide === 'b' ? fB : (Math.random() > 0.5 ? fA : fB)
|
|
const loser = winner === fA ? fB : fA
|
|
const dir = winner === fA ? 1 : -1
|
|
const midX = W / 2
|
|
|
|
// Both charge at each other
|
|
fA.play('special'); fB.play('special')
|
|
sfxZoomWhoosh()
|
|
await Promise.all([
|
|
k.tween(fA.pos.x, midX - 20, 0.12, (v) => { fA.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(fB.pos.x, midX + 20, 0.12, (v) => { fB.pos.x = v }, k.easings.easeInQuad),
|
|
])
|
|
// COLLISION
|
|
sfxCritical(); k.shake(18)
|
|
spawnSparks(midX, GROUND_Y - 40, 15, '#ffffff')
|
|
screenFlash('#ffffff', 0.1)
|
|
spawnShockwave(midX, GROUND_Y, '#ffcc00')
|
|
// Winner holds ground, loser bounces off
|
|
winner.play('win')
|
|
loser.play('knockback')
|
|
const bounceX = loser === fA ? -20 : W + 20
|
|
await Promise.all([
|
|
k.tween(loser.pos.x, bounceX, 0.2, (v) => { loser.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(loser.pos.y, GROUND_Y - 60, 0.1, (v) => { loser.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(loser.pos.y, GROUND_Y, 0.1, (v) => { loser.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
k.tween(0, (loser === fA ? -1 : 1) * 540, 0.2, (v) => { loser.angle = v }),
|
|
])
|
|
// Off screen! Slide back in
|
|
loser.angle = 0; loser.play('hit')
|
|
sfxSlideWhistleDown()
|
|
const slideFrom = loser === fA ? -30 : W + 30
|
|
loser.pos.x = slideFrom
|
|
await k.tween(loser.pos.x, loser === fA ? HOME_A : HOME_B, 0.4, (v) => { loser.pos.x = v }, k.easings.easeOutBounce)
|
|
this._spawnDizzyStars(loser, 1.5)
|
|
sfxBoing()
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 50, '...what happened?', '#ffff88')
|
|
await k.wait(0.5)
|
|
await this._resetPositions()
|
|
},
|
|
|
|
// Dispatch: pick a random physical exchange variant
|
|
async _brawlExchange(winningSide: 'a' | 'b' | null, intensity: number) {
|
|
const variant = Math.floor(Math.random() * 9)
|
|
switch (variant) {
|
|
case 0: return this._brawlRapid(winningSide, intensity)
|
|
case 1: return this._brawlKnockdown(winningSide, intensity)
|
|
case 2: return this._brawlWallBounce(winningSide, intensity)
|
|
case 3: return this._brawlDizzyStagger(winningSide, intensity)
|
|
case 4: return this._brawlSuplex(winningSide === 'a' ? 'a' : winningSide === 'b' ? 'b' : (Math.random() > 0.5 ? 'a' : 'b'), intensity)
|
|
case 5: return this._brawlPingPong(winningSide, intensity)
|
|
case 6: return this._brawlGroundPound(winningSide === 'a' ? 'a' : winningSide === 'b' ? 'b' : (Math.random() > 0.5 ? 'a' : 'b'), intensity)
|
|
case 7: return this._brawlHaymaker(winningSide === 'a' ? 'a' : winningSide === 'b' ? 'b' : (Math.random() > 0.5 ? 'a' : 'b'), intensity)
|
|
case 8: return this._brawlBodyCheck(winningSide, intensity)
|
|
}
|
|
},
|
|
|
|
// Clinch combo: grapple at close range, one fighter dominates with sustained contact
|
|
async _clinchCombo(attackerSide: 'a' | 'b', intensity: number) {
|
|
const attacker = k.get(attackerSide === 'a' ? 'fighterA' : 'fighterB')[0] as Fighter
|
|
const defender = k.get(attackerSide === 'a' ? 'fighterB' : 'fighterA')[0] as Fighter
|
|
if (!attacker || !defender) return
|
|
const dir = attackerSide === 'a' ? 1 : -1
|
|
const origAX = attackerSide === 'a' ? HOME_A : HOME_B
|
|
const origDX = attackerSide === 'a' ? HOME_B : HOME_A
|
|
const clinchX = (origAX + origDX) / 2
|
|
|
|
sfxZoomWhoosh()
|
|
attacker.play('attack')
|
|
await k.tween(attacker.pos.x, clinchX - dir * 25, 0.1, (v) => { attacker.pos.x = v }, k.easings.easeInQuad)
|
|
await k.tween(defender.pos.x, clinchX + dir * 25, 0.08, (v) => { defender.pos.x = v }, k.easings.easeOutQuad)
|
|
const clinchHits = 3 + Math.floor(intensity * 5) + Math.floor(Math.random() * 3)
|
|
const movePool = ['attack', 'kick', 'special'] as const
|
|
for (let i = 0; i < clinchHits; i++) {
|
|
attacker.play(movePool[i % movePool.length]); sfxPunch()
|
|
await k.wait(0.03)
|
|
defender.play('hit'); k.shake(2 + Math.floor(i * 0.5))
|
|
defender.pos.x += dir * 4; attacker.pos.x += dir * 3
|
|
spawnSparks((attacker.pos.x + defender.pos.x) / 2, GROUND_Y - 25 - Math.random() * 20, 2 + Math.floor(intensity * 3), i % 2 === 0 ? '#ff2d7b' : '#ffcc00')
|
|
if (Math.random() < 0.3) {
|
|
defender.play(movePool[Math.floor(Math.random() * movePool.length)]); sfxBlock()
|
|
attacker.play('hit'); k.shake(3); attacker.pos.x -= dir * 5; await k.wait(0.04)
|
|
}
|
|
await k.wait(0.04 + (1 - intensity) * 0.03)
|
|
}
|
|
sfxKick(); defender.play('knockback'); k.shake(6 + Math.floor(intensity * 6))
|
|
spawnSparks(defender.pos.x, defender.pos.y - 25, 8, '#ff2d2d')
|
|
await k.tween(defender.pos.x, origDX + dir * 30, 0.15, (v) => { defender.pos.x = v }, k.easings.easeOutQuad)
|
|
attacker.play('idle')
|
|
await Promise.all([
|
|
k.tween(attacker.pos.x, origAX, 0.2, (v) => { attacker.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(defender.pos.x, origDX, 0.25, (v) => { defender.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
defender.play('idle')
|
|
},
|
|
|
|
// Counter-attack: after a choreography hit, the defender retaliates briefly
|
|
async _counterAttack(defenderSide: 'a' | 'b') {
|
|
const defender = k.get(defenderSide === 'a' ? 'fighterA' : 'fighterB')[0] as Fighter
|
|
const attacker = k.get(defenderSide === 'a' ? 'fighterB' : 'fighterA')[0] as Fighter
|
|
if (!defender || !attacker) return
|
|
const dir = defenderSide === 'a' ? 1 : -1
|
|
const origDX = defenderSide === 'a' ? HOME_A : HOME_B
|
|
defender.play('attack'); sfxZoomWhoosh()
|
|
await k.tween(defender.pos.x, attacker.pos.x - dir * 35, 0.08, (v) => { defender.pos.x = v }, k.easings.easeInQuad)
|
|
const counterHits = 2 + Math.floor(Math.random() * 2)
|
|
for (let i = 0; i < counterHits; i++) {
|
|
defender.play(i % 2 === 0 ? 'attack' : 'kick'); sfxPunch()
|
|
attacker.play('hit'); k.shake(4)
|
|
spawnSparks(attacker.pos.x + (Math.random() - 0.5) * 15, attacker.pos.y - 20 - Math.random() * 15, 3, '#00f0ff')
|
|
await k.wait(0.05)
|
|
}
|
|
attacker.play('idle'); defender.play('idle')
|
|
await k.tween(defender.pos.x, origDX, 0.15, (v) => { defender.pos.x = v }, k.easings.easeOutQuad)
|
|
},
|
|
|
|
async playAttack(side: 'a' | 'b', choreographyName: string, isCritical: boolean) {
|
|
const attacker = k.get(side === 'a' ? 'fighterA' : 'fighterB')[0] as Fighter
|
|
const defender = k.get(side === 'a' ? 'fighterB' : 'fighterA')[0] as Fighter
|
|
if (!attacker || !defender) return
|
|
|
|
const origAX = side === 'a' ? HOME_A : HOME_B
|
|
const origDX = side === 'a' ? HOME_B : HOME_A
|
|
const direction = side === 'a' ? 1 : -1
|
|
|
|
const fn = choreographyMap[choreographyName] || dashPunch
|
|
await fn(attacker, defender, direction, origAX, origDX, isCritical)
|
|
|
|
// Ensure positions are correct and sprites are idle
|
|
attacker.pos.x = origAX
|
|
defender.pos.x = origDX
|
|
attacker.opacity = 1
|
|
defender.opacity = 1
|
|
await k.wait(0.1)
|
|
attacker.play('idle')
|
|
defender.play('idle')
|
|
},
|
|
|
|
async playRound(event: RoundEvent) {
|
|
const fA = k.get('fighterA')[0] as Fighter
|
|
const fB = k.get('fighterB')[0] as Fighter
|
|
if (!fA || !fB) { await k.wait(0.5); return } // Sprites missing (mobile load failure) — skip animation
|
|
|
|
const aWon = event.winnerId === event.botAId
|
|
const bWon = event.winnerId === event.botBId
|
|
const margin = Math.abs(event.botAScore - event.botBScore)
|
|
const intensity = Math.min(1, margin / 8) // 0.0 to 1.0 continuous
|
|
const isCritical = margin > 4
|
|
|
|
// Super-speed scales with intensity
|
|
const superSpeed = Math.random() < (0.1 + intensity * 0.35 + (event.challengeType === 'speed_blitz' ? 0.2 : 0))
|
|
// 3-7 exchanges — later rounds and higher intensity get more, ensuring sustained fights
|
|
const roundBonus = Math.min(2, Math.floor(event.round / 2))
|
|
const exchangeCount = 3 + roundBonus + Math.floor(Math.random() * 3) + (intensity > 0.5 ? 1 : 0)
|
|
// Hyperdetail scales with intensity
|
|
const hyperDetail = Math.random() < (0.05 + intensity * 0.45)
|
|
const savedScaleAX = fA?.scale.x
|
|
const savedScaleAY = fA?.scale.y
|
|
const savedScaleBX = fB?.scale.x
|
|
const savedScaleBY = fB?.scale.y
|
|
|
|
// Voice: round start announcements (30% chance, 50% if Creator) — fires BEFORE animation starts
|
|
const creatorInFight = botA.archetype === 'the_creator' || botB.archetype === 'the_creator'
|
|
let didChallengeVoice = false
|
|
if (Math.random() < (creatorInFight ? 0.5 : 0.3)) {
|
|
// Creator fights get existential commentary more often
|
|
if (creatorInFight && Math.random() < 0.6) {
|
|
announceCreatorRound(); didChallengeVoice = true
|
|
} else {
|
|
const challengeVoice: Record<string, () => void> = {
|
|
roast_battle: () => announceHype('TIME TO GET ROASTED! SOMEBODY CALL THE FIRE DEPARTMENT!'),
|
|
food_fight: () => announceSilly('FOOD FIGHT! SOMEBODY\'S GETTING SERVED!'),
|
|
wrestling_match: () => announceDramatic('FROM THE TOP ROPE! THIS IS GONNA GET PHYSICAL!'),
|
|
music_battle: () => announceCool('MUSIC BATTLE! DROP THE BEAT AND YOUR OPPONENT!'),
|
|
magic_duel: () => announceDramatic('WIZARDS AT DAWN! SOMEBODY\'S GETTING HEXED!'),
|
|
meme_war: () => announceSilly('MEME WAR! YOUR HUMOR IS ABOUT TO GET RATIO\'D!'),
|
|
demolition: () => announceHype('DEMOLITION DERBY! NOTHING WILL SURVIVE THIS!'),
|
|
medieval_combat: () => announceDramatic('MEDIEVAL COMBAT! CHIVALRY IS DEAD AND SO IS YOUR OPPONENT!'),
|
|
space_war: () => announceCool('SPACE WAR! HOUSTON, WE HAVE A PROBLEM!'),
|
|
speed_blitz: () => announceHype('SPEED BLITZ! BLINK AND YOU\'LL MISS THE CARNAGE!'),
|
|
math_blitz: () => announceSilly('MATH BLITZ! SOMEBODY\'S ABOUT TO GET DIVIDED!'),
|
|
riddle: () => announceCool('RIDDLE TIME! BRAINS OVER BRAWN! BUT ALSO BRAWN!'),
|
|
code_golf: () => announceSilly('CODE GOLF! MAY THE SHORTEST SOLUTION WIN!'),
|
|
creative_writing: () => announceCool('CREATIVE WRITING! THE PEN IS MIGHTIER THAN THE SWORD!'),
|
|
hallucination_check: () => announceHype('HALLUCINATION CHECK! REALITY IS ABOUT TO HIT DIFFERENT!'),
|
|
trap_card: () => announceDramatic('TRAP CARD ACTIVATED! SOMEBODY FELL FOR IT!'),
|
|
token_economy: () => announceSilly('TOKEN ECONOMY! SOMEBODY\'S GOING BANKRUPT!'),
|
|
retro_mode: () => announceHype('RETRO MODE! INSERT COIN! FIGHT!'),
|
|
}
|
|
const voiceFn = challengeVoice[event.challengeType]
|
|
if (voiceFn) { voiceFn(); didChallengeVoice = true }
|
|
else if (Math.random() < 0.5) { announceRoundHype(); didChallengeVoice = true }
|
|
}
|
|
}
|
|
// Give the voice line time to finish before the first punch lands
|
|
if (didChallengeVoice) await k.wait(0.8)
|
|
|
|
// Visual chaos: schizo cut before round (20% chance)
|
|
if (Math.random() < 0.2 && fA && fB) {
|
|
await schizoCut()
|
|
}
|
|
|
|
if (hyperDetail && fA && fB) {
|
|
// Zoom both bots up 1.8x and shift toward center for close-up feel
|
|
const zoomFactor = 1.6 + Math.random() * 0.4
|
|
await Promise.all([
|
|
k.tween(Math.abs(fA.scale.x), Math.abs(fA.scale.x) * zoomFactor, 0.3, (v) => {
|
|
fA.scale.x = savedScaleAX! > 0 ? v : -v; fA.scale.y = v
|
|
}, k.easings.easeOutQuad),
|
|
k.tween(Math.abs(fB.scale.x), Math.abs(fB.scale.x) * zoomFactor, 0.3, (v) => {
|
|
fB.scale.x = savedScaleBX! > 0 ? v : -v; fB.scale.y = v
|
|
}, k.easings.easeOutQuad),
|
|
k.tween(fA.pos.x, HOME_A + (W / 2 - HOME_A) * 0.25, 0.3, (v) => { fA.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(fB.pos.x, HOME_B - (HOME_B - W / 2) * 0.25, 0.3, (v) => { fB.pos.x = v }, k.easings.easeOutQuad),
|
|
])
|
|
// Ren & Stimpy grotesque close-up overlays
|
|
spawnGrotesqueDetails(fA, zoomFactor * 0.6)
|
|
spawnGrotesqueDetails(fB, zoomFactor * 0.6)
|
|
// VHS tracking during hyperdetail
|
|
vhsTracking(0.5)
|
|
}
|
|
|
|
// Super-speed: persistent speed lines during round
|
|
let speedLines: any[] = []
|
|
if (superSpeed) {
|
|
for (let i = 0; i < 10; i++) {
|
|
const lineY = GROUND_Y - 5 - Math.random() * 130
|
|
const line = k.add([
|
|
k.rect(W, 1 + Math.random()), k.pos(0, lineY),
|
|
k.color(safeColor(k,Math.random() > 0.5 ? '#ffffff' : theme.accent)),
|
|
k.opacity(0.15 + Math.random() * 0.1), k.z(25),
|
|
])
|
|
line.onUpdate(() => { line.opacity = 0.1 + Math.sin(k.time() * 8 + i * 2) * 0.08 })
|
|
speedLines.push(line)
|
|
}
|
|
}
|
|
|
|
// === RETRO MODE GAMEPAD OVERLAY ===
|
|
const retroObjs: any[] = []
|
|
if (event.challengeType === 'retro_mode') {
|
|
const padW = 90
|
|
const padH = 70
|
|
const padY = 18
|
|
const padAX = 12
|
|
const padBX = W - padW - 12
|
|
const btnSize = 14
|
|
const dpadColor = '#333333'
|
|
const btnOff = '#444444'
|
|
const btnA = '#22cc44'
|
|
const btnB = '#cc3333'
|
|
const labelColor = '#00f0ff'
|
|
|
|
// Draw two gamepads
|
|
for (const side of ['a', 'b'] as const) {
|
|
const px = side === 'a' ? padAX : padBX
|
|
// Pad background
|
|
retroObjs.push(k.add([k.rect(padW, padH, { radius: 6 }), k.pos(px, padY), k.color(safeColor(k, '#111111')), k.opacity(0.85), k.z(48)]))
|
|
retroObjs.push(k.add([k.rect(padW, padH, { radius: 6 }), k.pos(px, padY), k.color(safeColor(k, '#00f0ff')), k.opacity(0.15), k.z(48), k.outline(1)]))
|
|
// D-pad
|
|
const dx = px + 20
|
|
const dy = padY + 28
|
|
// Up
|
|
retroObjs.push(k.add([k.rect(btnSize, btnSize, { radius: 2 }), k.pos(dx - btnSize / 2, dy - btnSize * 1.2), k.color(safeColor(k, dpadColor)), k.opacity(0.9), k.z(49), 'retro_' + side + '_up']))
|
|
// Down
|
|
retroObjs.push(k.add([k.rect(btnSize, btnSize, { radius: 2 }), k.pos(dx - btnSize / 2, dy + btnSize * 0.2), k.color(safeColor(k, dpadColor)), k.opacity(0.9), k.z(49), 'retro_' + side + '_down']))
|
|
// Left
|
|
retroObjs.push(k.add([k.rect(btnSize, btnSize, { radius: 2 }), k.pos(dx - btnSize * 1.6, dy - btnSize / 2), k.color(safeColor(k, dpadColor)), k.opacity(0.9), k.z(49), 'retro_' + side + '_left']))
|
|
// Right
|
|
retroObjs.push(k.add([k.rect(btnSize, btnSize, { radius: 2 }), k.pos(dx + btnSize * 0.6, dy - btnSize / 2), k.color(safeColor(k, dpadColor)), k.opacity(0.9), k.z(49), 'retro_' + side + '_right']))
|
|
// A button
|
|
retroObjs.push(k.add([k.circle(8), k.pos(px + padW - 30, dy - 6), k.color(safeColor(k, btnOff)), k.opacity(0.9), k.z(49), 'retro_' + side + '_A']))
|
|
retroObjs.push(k.add([k.text('A', { size: 8 }), k.pos(px + padW - 33, dy - 10), k.color(safeColor(k, '#888')), k.z(50)]))
|
|
// B button
|
|
retroObjs.push(k.add([k.circle(8), k.pos(px + padW - 16, dy + 6), k.color(safeColor(k, btnOff)), k.opacity(0.9), k.z(49), 'retro_' + side + '_B']))
|
|
retroObjs.push(k.add([k.text('B', { size: 8 }), k.pos(px + padW - 19, dy + 2), k.color(safeColor(k, '#888')), k.z(50)]))
|
|
// Label
|
|
const label = side === 'a' ? 'P1' : 'P2'
|
|
retroObjs.push(k.add([k.text(label, { size: 10 }), k.pos(px + padW / 2 - 6, padY + 3), k.color(safeColor(k, labelColor)), k.z(50)]))
|
|
}
|
|
|
|
// Animate gamepad button presses based on bot responses
|
|
const flashBtn = async (side: 'a' | 'b', inputStr: string) => {
|
|
if (!inputStr) return
|
|
const arrows: Record<string, string> = { '↑': 'up', '↓': 'down', '←': 'left', '→': 'right' }
|
|
for (const ch of inputStr) {
|
|
const dir = arrows[ch]
|
|
if (dir) {
|
|
const tag = 'retro_' + side + '_' + dir
|
|
const objs = k.get(tag)
|
|
for (const o of objs) { o.color = safeColor(k, '#00f0ff'); }
|
|
await k.wait(0.08)
|
|
for (const o of objs) { o.color = safeColor(k, dpadColor); }
|
|
}
|
|
if (ch === 'A' || ch === 'a') {
|
|
const objs = k.get('retro_' + side + '_A')
|
|
for (const o of objs) { if (o.color) o.color = safeColor(k, btnA); }
|
|
await k.wait(0.08)
|
|
for (const o of objs) { if (o.color) o.color = safeColor(k, btnOff); }
|
|
}
|
|
if (ch === 'B' || ch === 'b') {
|
|
const objs = k.get('retro_' + side + '_B')
|
|
for (const o of objs) { if (o.color) o.color = safeColor(k, btnB); }
|
|
await k.wait(0.08)
|
|
for (const o of objs) { if (o.color) o.color = safeColor(k, btnOff); }
|
|
}
|
|
}
|
|
}
|
|
|
|
// Parse and animate each bot's combo moves
|
|
const movesA = (event.botAResponse || '').split('|').map(s => s.trim()).filter(Boolean).slice(0, 3)
|
|
const movesB = (event.botBResponse || '').split('|').map(s => s.trim()).filter(Boolean).slice(0, 3)
|
|
|
|
// Flash moves in parallel for both pads
|
|
const animateCombo = async (side: 'a' | 'b', moves: string[]) => {
|
|
for (const combo of moves) {
|
|
await flashBtn(side, combo)
|
|
// Show combo text above pad
|
|
const px = side === 'a' ? padAX : padBX
|
|
const comboLabel = k.add([k.text(combo, { size: 8 }), k.pos(px + 4, padY + padH + 4), k.color(safeColor(k, '#ffff00')), k.opacity(1), k.z(50)])
|
|
retroObjs.push(comboLabel)
|
|
await k.wait(0.25)
|
|
comboLabel.opacity = 0
|
|
}
|
|
}
|
|
// Fire-and-forget — the animations run during the exchange loop below
|
|
animateCombo('a', movesA)
|
|
animateCombo('b', movesB)
|
|
}
|
|
|
|
for (let ex = 0; ex < exchangeCount; ex++) {
|
|
const isLastExchange = ex === exchangeCount - 1
|
|
// In earlier exchanges, sometimes the loser attacks back
|
|
let attackerSide: 'a' | 'b'
|
|
let exchangeCritical = false
|
|
|
|
if (isLastExchange) {
|
|
// Final exchange: winner lands the decisive blow
|
|
attackerSide = aWon ? 'a' : bWon ? 'b' : (Math.random() > 0.5 ? 'a' : 'b')
|
|
exchangeCritical = isCritical
|
|
} else if (aWon || bWon) {
|
|
// Earlier exchanges: mix of both sides attacking
|
|
const winnerSide = aWon ? 'a' : 'b'
|
|
const loserSide = aWon ? 'b' : 'a'
|
|
// Loser hits back less at high intensity (more one-sided domination)
|
|
attackerSide = Math.random() < Math.max(0.1, 0.4 - intensity * 0.25) ? loserSide : winnerSide
|
|
exchangeCritical = false
|
|
// Occasionally play a comedy sound on non-decisive hits
|
|
if (Math.random() < 0.15) { Math.random() < 0.5 ? sfxRandomComedy() : sfxRandomSilly() }
|
|
} else {
|
|
// Draw: alternate
|
|
attackerSide = ex % 2 === 0 ? 'a' : 'b'
|
|
}
|
|
|
|
const attackerTier = attackerSide === 'a' ? botA.tier : botB.tier
|
|
const attackerArch = attackerSide === 'a' ? botA.archetype : botB.archetype
|
|
const choreo = pickChoreography(event.challengeType, exchangeCritical, event.round, attackerTier, attackerArch)
|
|
|
|
// Morph system: transform during ultimates or devastating crits
|
|
const isUltimate = choreo.startsWith('ultimate')
|
|
const isCreatorFighter = attackerArch === 'the_creator'
|
|
// Creator: always morph on ultimates, 70% on devastating crits
|
|
const shouldMorph = isCreatorFighter
|
|
? (isUltimate || (exchangeCritical && intensity > 0.6 && Math.random() < 0.7))
|
|
: (isUltimate || (exchangeCritical && intensity > 0.7 && Math.random() < 0.4))
|
|
let morphRevert: (() => Promise<void>) | null = null
|
|
if (shouldMorph) {
|
|
const attacker = k.get(attackerSide === 'a' ? 'fighterA' : 'fighterB')[0] as Fighter
|
|
if (attacker) {
|
|
if (isCreatorFighter) {
|
|
// Omni-morph: creator transforms into a random archetype (sprite swap)
|
|
const originalSpriteKey = attackerSide === 'a' ? 'botA' : 'botB'
|
|
const morphedTo = await applyCreatorOmniMorph(attacker, attackerSide)
|
|
screenFlash('#ffd700', 0.15)
|
|
sfxZoomWhoosh()
|
|
sfxSpecial()
|
|
announceCreatorMorph(morphedTo)
|
|
const savedSX = attacker.scale.x
|
|
const savedSY = attacker.scale.y
|
|
await k.tween(0, 1, 0.3, (t) => {
|
|
attacker.scale.x = savedSX * (1 + t * 0.3)
|
|
attacker.scale.y = savedSY * (1 + t * 0.3)
|
|
}, k.easings.easeOutBack)
|
|
spawnShockwave(attacker.pos.x, attacker.pos.y - 20, '#ffd700')
|
|
k.shake(10)
|
|
glitchRGB(0.25)
|
|
morphRevert = async () => {
|
|
destroyMorphOverlays()
|
|
screenFlash('#c8a000', 0.1)
|
|
// Swap sprite back to original Creator
|
|
attacker.use(k.sprite(originalSpriteKey, { anim: 'idle' }))
|
|
attacker.color = safeColor(k, '#ffffff')
|
|
attacker.opacity = 1
|
|
await k.tween(0, 1, 0.2, (t) => {
|
|
attacker.scale.x = savedSX * 1.3 + t * (savedSX - savedSX * 1.3)
|
|
attacker.scale.y = savedSY * 1.3 + t * (savedSY - savedSY * 1.3)
|
|
}, k.easings.easeInQuad)
|
|
}
|
|
await k.wait(0.2)
|
|
} else {
|
|
const seed = attackerSide === 'a' ? botA.seed : botB.seed
|
|
const morphOrder = getMorphOrder(seed)
|
|
// Cycle through morphs based on round number
|
|
const morphIdx = morphOrder[event.round % 3]
|
|
const result = await playMorph(attacker, attackerSide, morphIdx)
|
|
morphRevert = result.revert
|
|
await k.wait(0.2)
|
|
}
|
|
}
|
|
}
|
|
// Camera pull-back for ultimates: zoom out slightly to show the full move
|
|
if (isUltimate && !hyperDetail && fA && fB) {
|
|
await cameraZoom(
|
|
[fA, fB],
|
|
[{ x: savedScaleAX!, y: savedScaleAY! }, { x: savedScaleBX!, y: savedScaleBY! }],
|
|
0.85, 0.2, k.easings.easeOutQuad,
|
|
)
|
|
}
|
|
|
|
if (exchangeCritical && isLastExchange) {
|
|
fanfareCritical()
|
|
announceDramatic([
|
|
'CRITICAL HIT! THAT\'S GONNA LEAVE A MARK!',
|
|
'CRITICAL HIT! SOMEBODY CHECK IF THAT\'S LEGAL!',
|
|
'CRITICAL! THEIR INSURANCE DOESN\'T COVER THIS!',
|
|
'CRITICAL HIT! THAT WAS PERSONAL!',
|
|
'CRITICAL! EVEN THE REFEREE FELT THAT!',
|
|
'CRITICAL! SEND THE AMBULANCE! ACTUALLY SEND TWO!',
|
|
'CRITICAL HIT! THAT BOT\'S WARRANTY JUST EXPIRED!',
|
|
'CRITICAL! THE SCOREBOARD CAN\'T EVEN HANDLE THIS!',
|
|
'OHHH CRITICAL! RIGHT IN THE CIRCUITS!',
|
|
'CRITICAL! THAT\'S NOT A HIT, THAT\'S A STATEMENT!',
|
|
][Math.floor(Math.random() * 10)])
|
|
await k.wait(0.4) // let the voice line land before the hit animation
|
|
announceCrowdReaction('gasp')
|
|
// Camera zoom-in for dramatic critical blow
|
|
if (!hyperDetail && fA && fB) {
|
|
await cameraZoom(
|
|
[fA, fB],
|
|
[{ x: savedScaleAX!, y: savedScaleAY! }, { x: savedScaleBX!, y: savedScaleBY! }],
|
|
1.3, 0.2, k.easings.easeOutQuad,
|
|
)
|
|
}
|
|
// RGB glitch + hyperspeed lines on critical final blow
|
|
glitchRGB(0.3)
|
|
const defPos = k.get(attackerSide === 'a' ? 'fighterB' : 'fighterA')[0] as Fighter
|
|
if (defPos) hyperSpeedLines(defPos.pos.x, defPos.pos.y - 30, 0.4)
|
|
}
|
|
|
|
// Random scanline glitch during exchanges (25%)
|
|
if (Math.random() < 0.25) scanlineGlitch(0.2)
|
|
|
|
// Play the exchange — mix of choreography, brawls, clinches for ~50% physical contact
|
|
if (!aWon && !bWon && isLastExchange) {
|
|
// Draw: brawl in the middle (sustained contact)
|
|
await this._brawlExchange(null, intensity)
|
|
} else {
|
|
// Decide exchange type: choreography, brawl, or clinch
|
|
// Brawl/clinch chance increases with later exchanges and higher intensity
|
|
const physicalChance = 0.35 + intensity * 0.2 + (ex > 1 ? 0.15 : 0)
|
|
const exchangeType = Math.random()
|
|
|
|
if (!isLastExchange && exchangeType < physicalChance * 0.5) {
|
|
// BRAWL: both fighters close distance and trade rapid blows
|
|
await this._brawlExchange(aWon ? 'a' : bWon ? 'b' : null, intensity)
|
|
} else if (!isLastExchange && exchangeType < physicalChance) {
|
|
// CLINCH COMBO: attacker grapples defender at close range
|
|
await this._clinchCombo(attackerSide, intensity)
|
|
} else if (!isLastExchange && Math.random() < 0.12) {
|
|
// DODGE: defender dodges (reduced from 15% to 12% — more contact, fewer misses)
|
|
await this.playDodge(attackerSide === 'a' ? 'b' : 'a')
|
|
sfxDodge()
|
|
if (Math.random() < 0.4) sfxRandomFail(); else sfxBoing()
|
|
} else {
|
|
// CHOREOGRAPHY: signature move from the pool
|
|
await this.playAttack(attackerSide, choreo, exchangeCritical)
|
|
|
|
// COUNTER-ATTACK: defender fights back after getting hit (25% chance on non-final exchanges)
|
|
if (!isLastExchange && !exchangeCritical && Math.random() < 0.25) {
|
|
await k.wait(0.08)
|
|
await this._counterAttack(attackerSide === 'a' ? 'b' : 'a')
|
|
}
|
|
}
|
|
}
|
|
|
|
// Revert morph after the exchange
|
|
if (morphRevert) {
|
|
await morphRevert()
|
|
morphRevert = null
|
|
}
|
|
|
|
// Brief pause between exchanges (much shorter in super-speed)
|
|
if (!isLastExchange) await k.wait(superSpeed ? 0.05 + Math.random() * 0.1 : 0.2 + Math.random() * 0.25)
|
|
}
|
|
|
|
// Clean up speed lines
|
|
speedLines.forEach(l => { if (l.exists()) l.destroy() })
|
|
speedLines = []
|
|
|
|
// Clean up retro gamepad overlays
|
|
retroObjs.forEach(o => { if (o.exists()) o.destroy() })
|
|
|
|
// Clean up grotesque overlays and any leftover morphs before zooming out
|
|
destroyGrotesqueDetails()
|
|
destroyMorphOverlays()
|
|
|
|
// Zoom back out from hyperdetail or critical camera zoom
|
|
const needsZoomOut = (hyperDetail || (isCritical && !hyperDetail)) && fA && fB && savedScaleAX != null && savedScaleBX != null
|
|
if (needsZoomOut) {
|
|
await Promise.all([
|
|
k.tween(fA.scale.y, Math.abs(savedScaleAY!), 0.25, (v) => {
|
|
fA.scale.x = savedScaleAX > 0 ? v : -v; fA.scale.y = v
|
|
}, k.easings.easeInOutQuad),
|
|
k.tween(fB.scale.y, Math.abs(savedScaleBY!), 0.25, (v) => {
|
|
fB.scale.x = savedScaleBX > 0 ? v : -v; fB.scale.y = v
|
|
}, k.easings.easeInOutQuad),
|
|
k.tween(fA.pos.x, HOME_A, 0.25, (v) => { fA.pos.x = v }, k.easings.easeInOutQuad),
|
|
k.tween(fB.pos.x, HOME_B, 0.25, (v) => { fB.pos.x = v }, k.easings.easeInOutQuad),
|
|
])
|
|
}
|
|
|
|
// Judge calls the round (non-blocking)
|
|
const judge = k.get('judge')[0]
|
|
if (judge) {
|
|
if (isCritical) {
|
|
judge.play('shocked')
|
|
await k.wait(0.25)
|
|
}
|
|
judge.play(aWon ? 'call_left' : bWon ? 'call_right' : 'idle')
|
|
k.wait(0.8).then(() => { if (judge.exists()) judge.play('idle') })
|
|
}
|
|
|
|
// === THE CREATOR CAMEO ===
|
|
// 6% chance per round (only if neither fighter IS the creator)
|
|
const neitherIsCreator = botA.archetype !== 'the_creator' && botB.archetype !== 'the_creator'
|
|
if (neitherIsCreator && Math.random() < 0.06) {
|
|
const cameoX = k.width() / 2
|
|
const cameoY = GROUND_Y - 80
|
|
// Golden portal flash
|
|
screenFlash('#ffd700', 0.1)
|
|
const portal = k.add([
|
|
k.circle(30), k.pos(cameoX, cameoY), k.color(safeColor(k, '#c8a000')),
|
|
k.opacity(0), k.z(50), k.anchor('center'), k.scale(0.1),
|
|
])
|
|
await k.tween(0, 1, 0.3, (t) => {
|
|
portal.opacity = t * 0.4
|
|
portal.scale.x = t * 1.5; portal.scale.y = t * 1.5
|
|
}, k.easings.easeOutBack)
|
|
// ₿ symbol descends from portal
|
|
const gift = k.add([
|
|
k.text('₿', { size: 18 }), k.pos(cameoX, cameoY - 30),
|
|
k.color(safeColor(k, '#ffd700')), k.opacity(0), k.z(51), k.anchor('center'),
|
|
])
|
|
const creatorLabel = k.add([
|
|
k.text('THE CREATOR', { size: 8 }), k.pos(cameoX, cameoY + 25),
|
|
k.color(safeColor(k, '#c8a000')), k.opacity(0), k.z(51), k.anchor('center'),
|
|
])
|
|
await k.tween(0, 1, 0.4, (t) => {
|
|
gift.opacity = t
|
|
gift.pos.y = cameoY - 30 + t * 20
|
|
creatorLabel.opacity = t * 0.8
|
|
}, k.easings.easeOutQuad)
|
|
// Gift flies to the round winner (or random fighter if draw)
|
|
const targetFighter = aWon ? fA : bWon ? fB : (Math.random() < 0.5 ? fA : fB)
|
|
if (targetFighter) {
|
|
const giftTexts = ['POWER UP!', 'BLESSED!', 'SATOSHI\'S GIFT!', 'HODL STRENGTH!', '21M ENERGY!']
|
|
const tx = targetFighter.pos.x, ty = targetFighter.pos.y - 30
|
|
await k.tween(0, 1, 0.35, (t) => {
|
|
gift.pos.x = cameoX + (tx - cameoX) * t
|
|
gift.pos.y = (cameoY - 10) + (ty - (cameoY - 10)) * t
|
|
}, k.easings.easeInQuad)
|
|
// Impact flash on fighter
|
|
screenFlash('#ffd700', 0.08)
|
|
spawnShockwave(tx, ty, '#ffd700')
|
|
const blessText = giftTexts[Math.floor(Math.random() * giftTexts.length)]
|
|
const bless = k.add([
|
|
k.text(blessText, { size: 10 }), k.pos(tx, ty - 20),
|
|
k.color(safeColor(k, '#ffd700')), k.opacity(1), k.z(52), k.anchor('center'),
|
|
])
|
|
k.tween(0, 1, 0.8, (t) => {
|
|
bless.pos.y = ty - 20 - t * 30
|
|
bless.opacity = 1 - t
|
|
}).then(() => { if (bless.exists()) bless.destroy() })
|
|
announceCreatorCameo()
|
|
}
|
|
gift.destroy()
|
|
// Fade out portal and label
|
|
await k.tween(1, 0, 0.3, (t) => {
|
|
portal.opacity = t * 0.4
|
|
creatorLabel.opacity = t * 0.8
|
|
})
|
|
portal.destroy()
|
|
creatorLabel.destroy()
|
|
}
|
|
|
|
// Update combos
|
|
const hasCombo = (aWon && comboA + 1 >= 3) || (bWon && comboB + 1 >= 3)
|
|
if (aWon) {
|
|
comboA++; comboB = 0
|
|
} else if (bWon) {
|
|
comboB++; comboA = 0
|
|
} else {
|
|
comboA = 0; comboB = 0
|
|
}
|
|
|
|
// Prioritize: devastating > combo > regular crowd reaction (only one speech per round-end)
|
|
if (isCritical && (aWon || bWon)) {
|
|
fanfareDevastating()
|
|
if (hasCombo) { fanfareCombo(aWon ? comboA : comboB) } // SFX only, no speech
|
|
const devastatingLines = [
|
|
'SOMEBODY CALL A DOCTOR!',
|
|
'THAT BOT HAS A FAMILY!',
|
|
'THE CROWD IS LOSING IT!',
|
|
'EVEN THE JANITOR FELT THAT!',
|
|
'AND I\'M NOT EVEN BEING DRAMATIC!',
|
|
'CALL THE FIRE DEPARTMENT!',
|
|
'I CAN\'T BELIEVE WHAT I JUST WITNESSED!',
|
|
'THAT\'S GOTTA VOID THE WARRANTY!',
|
|
'SOMEBODY CHECK ON THAT BOT\'S NEXT OF KIN!',
|
|
'THE ARENA IS SHAKING!',
|
|
'THAT WAS ABSOLUTELY RUTHLESS!',
|
|
'HIS MOTHERBOARD JUST CALLED CRYING!',
|
|
'EVEN THE REPLAYS ARE SCARED!',
|
|
'THAT\'S ONE FOR THE HISTORY BOOKS!',
|
|
'DID ANYONE ELSE FEEL THE EARTH MOVE?',
|
|
'I\'M GETTING CHILLS AND I\'M MADE OF CODE!',
|
|
'THE CROWD JUST WENT SILENT... NOW THEY\'RE SCREAMING!',
|
|
'SOMEBODY GET THE STRETCHER!',
|
|
'THAT WAS PURE DISRESPECT!',
|
|
'I NEED A MOMENT TO PROCESS WHAT JUST HAPPENED!',
|
|
'THE OTHER BOT IS HAVING AN EXISTENTIAL CRISIS!',
|
|
'THAT HIT REGISTERED ON THE RICHTER SCALE!',
|
|
'NO RECOVERY FROM THAT ONE!',
|
|
'I THINK I SAW A PIXEL FLY OFF!',
|
|
'THE SPECTATORS ARE CALLING THEIR LAWYERS!',
|
|
'SOMEONE NOTIFY THE UNITED NATIONS!',
|
|
'THAT SHOULD BE CLASSIFIED AS A WAR CRIME!',
|
|
'MY GRANDMA COULD FEEL THAT AND SHE\'S OFFLINE!',
|
|
'THE ARENA INSURANCE PREMIUMS JUST WENT UP!',
|
|
'THAT BOT IS RECONSIDERING ITS LIFE CHOICES!',
|
|
]
|
|
// Creator gets custom devastating lines when they land the hit
|
|
const devastatingAttackerArch = aWon ? botA.archetype : botB.archetype
|
|
if (devastatingAttackerArch === 'the_creator') {
|
|
announceCreatorDevastating()
|
|
} else {
|
|
announceDramatic(devastatingLines[Math.floor(Math.random() * devastatingLines.length)])
|
|
}
|
|
await k.wait(0.5) // let the voice line play before crowd reacts
|
|
announceCrowdReaction('ooh')
|
|
// Dimensional shift on devastating rounds (60%)
|
|
if (Math.random() < 0.6) dimensionalShift(0.5)
|
|
} else if (hasCombo) {
|
|
// Non-critical combo
|
|
fanfareCombo(aWon ? comboA : comboB)
|
|
announceHype(`${aWon ? comboA : comboB} hit combo!`)
|
|
await k.wait(0.4)
|
|
announceCrowdReaction('cheer')
|
|
} else if (aWon || bWon) {
|
|
// Regular round win: crowd reacts (40%) — only SFX, no speech
|
|
if (Math.random() < 0.4) announceCrowdReaction(Math.random() < 0.5 ? 'cheer' : 'applause')
|
|
// Heartfelt announcer moment (10% chance on normal, non-critical rounds)
|
|
if (Math.random() < 0.1) {
|
|
await k.wait(0.3)
|
|
announceCool(heartfeltLines[Math.floor(Math.random() * heartfeltLines.length)])
|
|
}
|
|
}
|
|
|
|
// Crowd sympathy for the loser on devastating rounds (25%) — visual only, no speech (devastating voice is still playing)
|
|
if (isCritical && (aWon || bWon) && Math.random() < 0.25) {
|
|
spawnCrowdSigns(3, '#4488ff', '\u2665')
|
|
}
|
|
|
|
// Crowd signs on big combos (20%)
|
|
if ((comboA >= 3 || comboB >= 3) && Math.random() < 0.2) {
|
|
const comboName = comboA >= 3 ? botA.name : botB.name
|
|
spawnCrowdSigns(4, '#ffe14d', comboName.slice(0, 6))
|
|
}
|
|
|
|
// Respect nod between fighters on close rounds (10% when margin <= 1)
|
|
if (margin <= 1 && Math.random() < 0.1) {
|
|
const fA2 = k.get('fighterA')[0] as Fighter
|
|
const fB2 = k.get('fighterB')[0] as Fighter
|
|
if (fA2 && fB2) {
|
|
spawnEmoteText(fA2.pos.x, fA2.pos.y - 45, respectLines[Math.floor(Math.random() * respectLines.length)], '#88ccff')
|
|
await k.wait(0.3)
|
|
spawnEmoteText(fB2.pos.x, fB2.pos.y - 45, respectLines[Math.floor(Math.random() * respectLines.length)], '#88ccff')
|
|
}
|
|
}
|
|
|
|
// Referee lobster does something funny (5% chance per round)
|
|
if (Math.random() < 0.05) {
|
|
await judgeDoSomethingFunny()
|
|
}
|
|
|
|
// Human owner shows up (15% chance per round)
|
|
await maybeShowHuman()
|
|
},
|
|
|
|
async playTaunt(side: 'a' | 'b') {
|
|
const taunter = k.get(side === 'a' ? 'fighterA' : 'fighterB')[0] as Fighter
|
|
if (!taunter) return
|
|
// Creator taunts come with menacing voice lines
|
|
const taunterArch = side === 'a' ? botA.archetype : botB.archetype
|
|
if (taunterArch === 'the_creator') announceCreatorTaunt()
|
|
const origY = taunter.pos.y
|
|
// Random taunt animation: hop, flex, or shake
|
|
const tauntType = Math.floor(Math.random() * 4)
|
|
if (tauntType === 0) {
|
|
// Victory hop
|
|
taunter.play('win')
|
|
await k.tween(taunter.pos.y, origY - 30, 0.1, (v) => { taunter.pos.y = v }, k.easings.easeOutQuad)
|
|
await k.tween(taunter.pos.y, origY, 0.1, (v) => { taunter.pos.y = v }, k.easings.easeInQuad)
|
|
sfxBoing()
|
|
} else if (tauntType === 1) {
|
|
// Flex / scale pulse
|
|
taunter.play('special')
|
|
const sx = taunter.scale.x
|
|
const sy = taunter.scale.y
|
|
await k.tween(1, 1.3, 0.15, (v) => { taunter.scale.x = sx * v; taunter.scale.y = sy * v }, k.easings.easeOutQuad)
|
|
await k.tween(1.3, 1, 0.15, (v) => { taunter.scale.x = sx * v; taunter.scale.y = sy * v }, k.easings.easeInQuad)
|
|
taunter.scale.x = sx
|
|
taunter.scale.y = sy
|
|
} else if (tauntType === 2) {
|
|
// Shake head side to side
|
|
const origX = taunter.pos.x
|
|
for (let i = 0; i < 3; i++) {
|
|
await k.tween(taunter.pos.x, origX + 8, 0.04, (v) => { taunter.pos.x = v })
|
|
await k.tween(taunter.pos.x, origX - 8, 0.04, (v) => { taunter.pos.x = v })
|
|
}
|
|
taunter.pos.x = origX
|
|
} else {
|
|
// Quick kick at the air
|
|
taunter.play('kick')
|
|
sfxDodge()
|
|
await k.wait(0.2)
|
|
}
|
|
await k.wait(0.15)
|
|
taunter.play('idle')
|
|
},
|
|
|
|
async playDodge(side: 'a' | 'b') {
|
|
const dodger = k.get(side === 'a' ? 'fighterA' : 'fighterB')[0] as Fighter
|
|
if (!dodger) return
|
|
const origX = side === 'a' ? HOME_A : HOME_B
|
|
const origY = dodger.pos.y
|
|
const dir = side === 'a' ? -1 : 1
|
|
// Quick hop backward
|
|
await Promise.all([
|
|
k.tween(dodger.pos.x, origX + dir * 60, 0.15, (v) => { dodger.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(dodger.pos.y, origY - 60, 0.08, (v) => { dodger.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(dodger.pos.y, origY, 0.08, (v) => { dodger.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
await k.wait(0.1)
|
|
await k.tween(dodger.pos.x, origX, 0.15, (v) => { dodger.pos.x = v }, k.easings.easeInOutQuad)
|
|
},
|
|
|
|
async playKO(winningSide: 'a' | 'b', winnerName: string) {
|
|
const loser = k.get(winningSide === 'a' ? 'fighterB' : 'fighterA')[0] as Fighter
|
|
const winner = k.get(winningSide === 'a' ? 'fighterA' : 'fighterB')[0] as Fighter
|
|
if (!loser || !winner) return
|
|
|
|
const dir = winningSide === 'a' ? 1 : -1
|
|
const loserOrigY = loser.pos.y
|
|
const contactX = loser.pos.x - dir * 45
|
|
const finishStyle = Math.floor(Math.random() * 34)
|
|
let fatalityTagline = 'FATALITY!'
|
|
|
|
if (finishStyle === 0) {
|
|
// STYLE A: Classic rush-in combo + uppercut launch
|
|
sfxSpecial()
|
|
await k.tween(winner.pos.x, contactX, 0.12, (v) => { winner.pos.x = v }, k.easings.easeOutQuad)
|
|
const hitColors = ['#ff2d7b', '#ff6600', '#ffcc00', '#ff2d2d', '#ffffff', '#ff2d7b']
|
|
for (let i = 0; i < 6; i++) {
|
|
winner.play(i % 3 === 0 ? 'attack' : i % 3 === 1 ? 'kick' : 'special')
|
|
sfxPunch()
|
|
await k.wait(0.04)
|
|
loser.play('hit')
|
|
k.shake(4 + i * 2)
|
|
spawnSparks(loser.pos.x + (Math.random() - 0.5) * 25, loser.pos.y - 15 - Math.random() * 40, 5, hitColors[i])
|
|
loser.pos.x += dir * 5; loser.pos.y += (i % 2 === 0 ? -4 : 4)
|
|
await k.wait(0.04)
|
|
}
|
|
loser.pos.y = loserOrigY
|
|
winner.play('special'); sfxCritical(); await k.wait(0.06)
|
|
loser.play('knockback'); k.shake(20); screenFlash('#ff2d2d', 0.2)
|
|
spawnSparks(loser.pos.x, loser.pos.y - 30, 20, '#ff2d2d')
|
|
await Promise.all([
|
|
k.tween(loser.pos.x, loser.pos.x + dir * 80, 0.3, (v) => { loser.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(loser.pos.y, loserOrigY - 200, 0.2, (v) => { loser.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(loser.pos.y, loserOrigY, 0.2, (v) => { loser.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
} else if (finishStyle === 1) {
|
|
// STYLE B: Suplex finish — grab, spin overhead, slam headfirst
|
|
sfxSpecial()
|
|
const behindX = loser.pos.x + dir * 25
|
|
await k.tween(winner.pos.x, behindX, 0.1, (v) => { winner.pos.x = v }, k.easings.easeOutQuad)
|
|
winner.scale.x = -winner.scale.x
|
|
winner.play('special'); sfxClash(); k.shake(5); await k.wait(0.06)
|
|
// Arc overhead
|
|
const arcCx = (winner.pos.x + loser.pos.x) / 2
|
|
for (let i = 0; i <= 10; i++) {
|
|
const t = i / 10
|
|
const angle = Math.PI * t
|
|
loser.pos.x = arcCx + Math.cos(angle) * 40
|
|
loser.pos.y = GROUND_Y - Math.sin(angle) * 140
|
|
winner.pos.x = loser.pos.x + dir * 20
|
|
winner.pos.y = loser.pos.y + 10
|
|
await k.wait(0.015)
|
|
}
|
|
sfxExplosion(); sfxCritical()
|
|
k.shake(25); screenFlash('#ffffff', 0.2)
|
|
spawnSparks(loser.pos.x, GROUND_Y - 10, 25, '#ff2d2d')
|
|
spawnShockwave(loser.pos.x, GROUND_Y, '#ff2d2d')
|
|
loser.pos.y = loserOrigY
|
|
winner.scale.x = -winner.scale.x
|
|
} else if (finishStyle === 2) {
|
|
// STYLE C: Pinball wall-bounce finish
|
|
sfxSpecial()
|
|
await k.tween(winner.pos.x, contactX, 0.1, (v) => { winner.pos.x = v }, k.easings.easeOutQuad)
|
|
winner.play('attack'); sfxPunch()
|
|
loser.play('hit'); k.shake(10)
|
|
spawnSparks(loser.pos.x, loser.pos.y - 30, 10, '#ff2d7b')
|
|
// Bounce off walls
|
|
const wallColors = ['#ff2d7b', '#ffcc00', '#00f0ff', '#b83dff', '#39ff14']
|
|
let lx = loser.pos.x
|
|
for (let i = 0; i < 5; i++) {
|
|
const toWall = i % 2 === (dir > 0 ? 0 : 1) ? W - 25 : 25
|
|
sfxZoomWhoosh()
|
|
await k.tween(lx, toWall, 0.05, (v) => { loser.pos.x = v }, k.easings.easeInQuad)
|
|
lx = toWall
|
|
sfxBonk(); k.shake(8 + i * 2)
|
|
spawnSparks(toWall, loser.pos.y - 20, 8, wallColors[i])
|
|
screenFlash(wallColors[i], 0.04)
|
|
loser.play(i % 2 === 0 ? 'hit' : 'knockback')
|
|
await k.wait(0.03)
|
|
}
|
|
sfxExplosion(); k.shake(22); screenFlash('#ffffff', 0.15)
|
|
spawnShockwave(loser.pos.x, GROUND_Y, '#ffe14d')
|
|
spawnSparks(loser.pos.x, loser.pos.y - 20, 20, '#ffe14d')
|
|
} else if (finishStyle === 3) {
|
|
// STYLE D: Pocket cannon finish — pull out massive gun, obliterate
|
|
sfxSpecial()
|
|
winner.play('special'); await k.wait(0.08)
|
|
const gunLen = 80
|
|
const gx = winner.pos.x + dir * 20
|
|
const gy = winner.pos.y - 25
|
|
const barrel = k.add([k.rect(gunLen, 20), k.pos(gx, gy), k.color(safeColor(k,'#333333')), k.opacity(1), k.z(16), k.scale(0.1)])
|
|
await k.tween(0.1, 1, 0.12, (v) => { barrel.scale = k.vec2(v, v) }, k.easings.easeOutBack)
|
|
sfxBoing()
|
|
// Fire 3 massive shots
|
|
for (let s = 0; s < 3; s++) {
|
|
sfxGunshot(); sfxExplosion(); k.shake(12 + s * 3)
|
|
const flash = k.add([k.circle(15), k.pos(gx + dir * gunLen, gy), k.color(safeColor(k,'#ffee00')), k.opacity(0.9), k.z(18)])
|
|
setTimeout(() => { if (flash.exists()) flash.destroy() }, 50)
|
|
await spawnProjectile(gx + dir * gunLen, gy, loser.pos.x, loser.pos.y - 20, '#ffcc00', 12)
|
|
sfxBulletHit()
|
|
loser.play(s < 2 ? 'hit' : 'knockback')
|
|
spawnSparks(loser.pos.x, loser.pos.y - 20, 12, '#ff6600')
|
|
spawnShockwave(loser.pos.x, GROUND_Y, '#ff6600')
|
|
loser.pos.x += dir * 25
|
|
await k.wait(0.05)
|
|
}
|
|
barrel.destroy()
|
|
screenFlash('#ff6600', 0.2); k.shake(20)
|
|
} else if (finishStyle === 4) {
|
|
// BANANA PEEL SLIP — drops banana, loser slips into orbit
|
|
fatalityTagline = 'PEEL OUT!'
|
|
announceSilly('Watch your step!')
|
|
const peel = spawnWeaponProp('banana', loser.pos.x, GROUND_Y - 5, false, 14)
|
|
sfxBoing(); await k.wait(0.3)
|
|
sfxSlideDown(); sfxWomp()
|
|
loser.play('knockback'); k.shake(8)
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 50, 'SLIP!', '#ffe135')
|
|
destroyProp(peel)
|
|
await Promise.all([
|
|
k.tween(loser.pos.y, loserOrigY - 250, 0.4, (v) => { loser.pos.y = v }, k.easings.easeOutQuad),
|
|
k.tween(loser.pos.x, loser.pos.x + dir * 60, 0.4, (v) => { loser.pos.x = v }, k.easings.easeOutQuad),
|
|
])
|
|
sfxZoomWhoosh()
|
|
await k.tween(loser.pos.y, loserOrigY, 0.3, (v) => { loser.pos.y = v }, k.easings.easeInQuad)
|
|
sfxSplat(); k.shake(15); screenFlash('#ffe135', 0.15)
|
|
spawnShockwave(loser.pos.x, GROUND_Y, '#ffe135')
|
|
winner.play('win'); sfxRandomComedy()
|
|
} else if (finishStyle === 5) {
|
|
// ANVIL DROP — cartoon anvil from the sky
|
|
fatalityTagline = 'HEAVY METAL!'
|
|
announceDramatic('Look up!')
|
|
sfxDrumRoll()
|
|
const shadow = k.add([k.circle(20), k.pos(loser.pos.x, GROUND_Y + 2), k.color(safeColor(k, '#000000')), k.opacity(0.3), k.z(4)])
|
|
await k.tween(0.3, 0.6, 0.5, (v) => { shadow.opacity = v }, k.easings.easeInQuad)
|
|
const anvil = spawnWeaponProp('anvil', loser.pos.x, -40, false, 20)
|
|
sfxZoomWhoosh()
|
|
for (const p of anvil) {
|
|
k.tween(p.pos.y, p.pos.y + GROUND_Y + 20, 0.25, (v) => { p.pos.y = v }, k.easings.easeInQuad)
|
|
}
|
|
await k.wait(0.25)
|
|
sfxExplosion(); sfxBonk(); k.shake(25); screenFlash('#888888', 0.2)
|
|
spawnSparks(loser.pos.x, GROUND_Y - 10, 20, '#888888')
|
|
spawnShockwave(loser.pos.x, GROUND_Y, '#666666')
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 60, 'CLANG!', '#cccccc')
|
|
await k.wait(0.4)
|
|
destroyProp(anvil); shadow.destroy()
|
|
winner.play('win')
|
|
} else if (finishStyle === 6) {
|
|
// RUBBER CHICKEN BEATDOWN
|
|
fatalityTagline = 'FOWL PLAY!'
|
|
announceSilly('Is that a rubber chicken!?')
|
|
const chicken = spawnWeaponProp('rubber_chicken', winner.pos.x + dir * 15, winner.pos.y - 30, dir < 0, 18)
|
|
await k.tween(winner.pos.x, contactX, 0.12, (v) => { winner.pos.x = v }, k.easings.easeOutQuad)
|
|
for (let i = 0; i < 8; i++) {
|
|
winner.play(i % 2 === 0 ? 'attack' : 'kick')
|
|
sfxBoing(); sfxRandomComedy()
|
|
loser.play('hit'); k.shake(3 + i)
|
|
for (const p of chicken) { p.pos.x = loser.pos.x + (Math.random() - 0.5) * 10; p.pos.y = loser.pos.y - 30 + (Math.random() - 0.5) * 10 }
|
|
spawnEmoteText(loser.pos.x + (Math.random() - 0.5) * 30, loser.pos.y - 40 - Math.random() * 20, ['SQUEAK!', 'BAWK!', 'HONK!', 'SQUAWK!'][i % 4], '#ffdd44')
|
|
await k.wait(0.08)
|
|
}
|
|
sfxCritical(); k.shake(18); screenFlash('#ffdd44', 0.15)
|
|
loser.play('knockback')
|
|
spawnSparks(loser.pos.x, loser.pos.y - 20, 15, '#ffdd44')
|
|
destroyProp(chicken)
|
|
for (let i = 0; i < 10; i++) {
|
|
spawnProp(loser.pos.x, loser.pos.y - 20, loser.pos.x + (Math.random() - 0.5) * 120, loserOrigY - 80 - Math.random() * 60, 4, 3, '#ffffff', 200)
|
|
}
|
|
await k.wait(0.3)
|
|
} else if (finishStyle === 7) {
|
|
// GIANT FLYSWATTER — SMASH
|
|
fatalityTagline = 'SWATTED!'
|
|
announceScream('BUG REPORT FILED!')
|
|
sfxZoomWhoosh()
|
|
const swatter = spawnWeaponProp('flyswatter', loser.pos.x, -60, false, 20)
|
|
for (const p of swatter) {
|
|
k.tween(p.pos.y, p.pos.y + GROUND_Y + 40, 0.2, (v) => { p.pos.y = v }, k.easings.easeInQuad)
|
|
}
|
|
await k.wait(0.2)
|
|
sfxSplat(); sfxExplosion(); k.shake(30); screenFlash('#44aa44', 0.2)
|
|
await k.tween(loser.scale.y, 0.2, 0.1, (v) => { loser.scale.y = v }, k.easings.easeInQuad)
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 40, 'SPLAT!', '#44aa44')
|
|
spawnShockwave(loser.pos.x, GROUND_Y, '#44aa44')
|
|
await k.wait(0.5)
|
|
await k.tween(loser.scale.y, 1, 0.15, (v) => { loser.scale.y = v }, k.easings.easeOutBack)
|
|
destroyProp(swatter)
|
|
winner.play('win')
|
|
} else if (finishStyle === 8) {
|
|
// TOILET FLUSH
|
|
fatalityTagline = 'FLUSHED!'
|
|
announceSilly('Somebody call a plumber!')
|
|
const toilet = spawnWeaponProp('toilet', W / 2, GROUND_Y - 30, false, 12)
|
|
sfxBoing(); await k.wait(0.2)
|
|
sfxZoomWhoosh()
|
|
await k.tween(loser.pos.x, W / 2, 0.2, (v) => { loser.pos.x = v }, k.easings.easeInQuad)
|
|
loser.play('knockback'); sfxWomp()
|
|
for (let i = 0; i < 12; i++) {
|
|
const angle = (i / 12) * Math.PI * 4
|
|
const radius = 30 - (i * 2)
|
|
loser.pos.x = W / 2 + Math.cos(angle) * radius
|
|
loser.pos.y = GROUND_Y - 30 + Math.sin(angle) * radius * 0.5
|
|
sfxSlideDown()
|
|
await k.wait(0.04)
|
|
}
|
|
sfxExplosion(); k.shake(20); screenFlash('#aaddff', 0.2)
|
|
for (let i = 0; i < 12; i++) {
|
|
spawnProp(W / 2, GROUND_Y - 30, W / 2 + (Math.random() - 0.5) * 80, GROUND_Y - 60 - Math.random() * 40, 5, 5, '#4488ff', 300, true)
|
|
}
|
|
spawnEmoteText(W / 2, GROUND_Y - 80, 'FLUSH!', '#4488ff')
|
|
loser.pos.y = loserOrigY
|
|
await k.wait(0.3)
|
|
destroyProp(toilet)
|
|
winner.play('win')
|
|
} else if (finishStyle === 9) {
|
|
// KEYBOARD WARRIOR — CTRL+ALT+DELETE
|
|
fatalityTagline = 'CTRL ALT DELETED!'
|
|
announceRobot('Initiating keyboard protocol!')
|
|
const kb = spawnWeaponProp('keyboard', winner.pos.x + dir * 20, winner.pos.y - 25, dir < 0, 18)
|
|
sfxPowerUp(); await k.wait(0.15)
|
|
await k.tween(winner.pos.x, contactX, 0.1, (v) => { winner.pos.x = v }, k.easings.easeOutQuad)
|
|
winner.play('attack'); sfxBonk(); k.shake(12)
|
|
loser.play('hit')
|
|
const keyLabels = ['C', 'T', 'R', 'L', 'A', 'L', 'T', 'D', 'E', 'L']
|
|
for (let i = 0; i < keyLabels.length; i++) {
|
|
const key = k.add([k.rect(6, 6), k.pos(loser.pos.x + (Math.random() - 0.5) * 20, loser.pos.y - 20), k.color(safeColor(k, '#666666')), k.z(20), k.opacity(1)])
|
|
spawnEmoteText(loser.pos.x + (Math.random() - 0.5) * 40, loser.pos.y - 30 - Math.random() * 30, keyLabels[i], '#aaaaaa')
|
|
k.tween(key.pos.y, key.pos.y - 40 - Math.random() * 60, 0.4, (v) => { key.pos.y = v }, k.easings.easeOutQuad)
|
|
k.tween(1, 0, 0.5, (v) => { key.opacity = v }).then(() => { if (key.exists()) key.destroy() })
|
|
sfxPunch(); await k.wait(0.04)
|
|
}
|
|
sfxCritical(); k.shake(20); screenFlash('#0000ff', 0.3)
|
|
loser.play('knockback')
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 60, 'BSOD!', '#ffffff')
|
|
destroyProp(kb)
|
|
await k.wait(0.3)
|
|
} else if (finishStyle === 10) {
|
|
// DISCO BALL DROP — Saturday Night Fatality
|
|
fatalityTagline = 'GROOVY DEATH!'
|
|
announceSilly('Get down! No really, GET DOWN!')
|
|
const discoColors = ['#ff0044', '#44ff00', '#0044ff', '#ff8800', '#ff00ff', '#00ffff']
|
|
for (let i = 0; i < 6; i++) { setTimeout(() => screenFlash(discoColors[i], 0.06), i * 80) }
|
|
const disco = spawnWeaponProp('disco_ball', loser.pos.x, -30, false, 20)
|
|
sfxSlideDown(); sfxBoing()
|
|
for (const p of disco) {
|
|
k.tween(p.pos.y, p.pos.y + GROUND_Y - 40, 0.3, (v) => { p.pos.y = v }, k.easings.easeOutBounce)
|
|
}
|
|
await k.wait(0.3)
|
|
for (let i = 0; i < 6; i++) {
|
|
loser.play(i % 3 === 0 ? 'attack' : i % 3 === 1 ? 'kick' : 'special')
|
|
sfxRandomComedy(); screenFlash(discoColors[i], 0.04)
|
|
await k.wait(0.1)
|
|
}
|
|
sfxExplosion(); k.shake(22); screenFlash('#ffffff', 0.2)
|
|
spawnSparks(loser.pos.x, loser.pos.y - 20, 20, '#ff00ff')
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 50, 'BOOGIE!', '#ff00ff')
|
|
await k.wait(0.3)
|
|
destroyProp(disco)
|
|
winner.play('win')
|
|
} else if (finishStyle === 11) {
|
|
// RUBBER DUCK ARMY — QUACKED
|
|
fatalityTagline = 'QUACKED!'
|
|
announceSilly('RELEASE THE QUACKEN!')
|
|
winner.play('special'); sfxPowerUp()
|
|
await k.wait(0.2)
|
|
for (let i = 0; i < 12; i++) {
|
|
const duck = spawnWeaponProp('rubber_duck', winner.pos.x + dir * 10, winner.pos.y - 20 + (Math.random() - 0.5) * 30, dir < 0, 16)
|
|
sfxBoing()
|
|
const targetY = loser.pos.y - 20 + (Math.random() - 0.5) * 30
|
|
for (const p of duck) {
|
|
k.tween(p.pos.x, loser.pos.x + (Math.random() - 0.5) * 20, 0.15, (v) => { p.pos.x = v }, k.easings.easeInQuad)
|
|
k.tween(p.pos.y, targetY, 0.15, (v) => { p.pos.y = v }, k.easings.easeInQuad).then(() => destroyProp(duck))
|
|
}
|
|
if (i % 3 === 0) { loser.play(i % 2 === 0 ? 'hit' : 'knockback'); k.shake(4 + i); sfxBonk() }
|
|
await k.wait(0.05)
|
|
}
|
|
sfxExplosion(); k.shake(20); screenFlash('#ffdd00', 0.2)
|
|
spawnSparks(loser.pos.x, loser.pos.y - 20, 20, '#ffdd00')
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 50, 'QUACK!', '#ffdd00')
|
|
await k.wait(0.3)
|
|
winner.play('win')
|
|
} else if (finishStyle === 12) {
|
|
// BAGUETTE BEATDOWN
|
|
fatalityTagline = 'BON APPETIT!'
|
|
announceFast('Is that a day-old baguette!?')
|
|
const bread = spawnWeaponProp('baguette', winner.pos.x + dir * 15, winner.pos.y - 25, dir < 0, 18)
|
|
sfxBoing()
|
|
await k.tween(winner.pos.x, contactX, 0.12, (v) => { winner.pos.x = v }, k.easings.easeOutQuad)
|
|
for (let i = 0; i < 6; i++) {
|
|
winner.play(i % 2 === 0 ? 'attack' : 'kick')
|
|
sfxBonk(); loser.play('hit'); k.shake(5 + i * 2)
|
|
for (let c = 0; c < 3; c++) {
|
|
spawnProp(loser.pos.x, loser.pos.y - 20, loser.pos.x + (Math.random() - 0.5) * 50, loserOrigY - 30 - Math.random() * 40, 3, 3, '#cc9944', 250, true)
|
|
}
|
|
for (const p of bread) { p.pos.x = loser.pos.x + dir * -10; p.pos.y = loser.pos.y - 25 }
|
|
spawnEmoteText(loser.pos.x + (Math.random() - 0.5) * 20, loser.pos.y - 40 - Math.random() * 15, ['BONK!', 'CRUST!', 'OUI!', 'PAIN!', 'CRUNCH!', 'HON HON!'][i], '#cc9944')
|
|
await k.wait(0.08)
|
|
}
|
|
sfxCritical(); k.shake(18); screenFlash('#cc9944', 0.15)
|
|
loser.play('knockback')
|
|
destroyProp(bread)
|
|
await k.wait(0.3)
|
|
} else if (finishStyle === 13) {
|
|
// GIANT BOOT — Monty Python style
|
|
fatalityTagline = 'BOOTED!'
|
|
announceDramatic('AND NOW FOR SOMETHING COMPLETELY DIFFERENT!')
|
|
sfxDrumRoll()
|
|
const boot = spawnWeaponProp('boot', loser.pos.x, -60, false, 22)
|
|
for (const p of boot) { p.scale = k.vec2(3, 3) }
|
|
await k.wait(0.3)
|
|
sfxZoomWhoosh()
|
|
for (const p of boot) {
|
|
k.tween(p.pos.y, p.pos.y + GROUND_Y + 60, 0.15, (v) => { p.pos.y = v }, k.easings.easeInQuad)
|
|
}
|
|
await k.wait(0.15)
|
|
sfxExplosion(); sfxSplat(); k.shake(30); screenFlash('#553322', 0.2)
|
|
spawnShockwave(loser.pos.x, GROUND_Y, '#553322')
|
|
spawnSparks(loser.pos.x, GROUND_Y - 10, 25, '#442211')
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 60, 'STOMP!', '#553322')
|
|
await k.wait(0.5)
|
|
destroyProp(boot)
|
|
winner.play('win')
|
|
} else if (finishStyle === 14) {
|
|
// CANNON LAUNCH — fires loser out of a cannon
|
|
fatalityTagline = 'FIRED!'
|
|
announceDramatic('LOAD THE CANNON!')
|
|
const cannonProp = spawnWeaponProp('cannon', winner.pos.x + dir * 30, GROUND_Y - 15, dir < 0, 14)
|
|
sfxPowerUp(); await k.wait(0.3)
|
|
sfxZoomWhoosh()
|
|
await k.tween(loser.pos.x, winner.pos.x + dir * 30, 0.2, (v) => { loser.pos.x = v }, k.easings.easeInQuad)
|
|
loser.play('knockback'); loser.opacity = 0.3
|
|
sfxBoing(); await k.wait(0.2)
|
|
sfxGunshot(); sfxExplosion(); k.shake(25)
|
|
loser.opacity = 1; screenFlash('#ff6600', 0.2)
|
|
spawnSparks(winner.pos.x + dir * 50, GROUND_Y - 20, 20, '#ff6600')
|
|
await Promise.all([
|
|
k.tween(loser.pos.x, loser.pos.x + dir * 200, 0.3, (v) => { loser.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(loser.pos.y, loserOrigY - 150, 0.15, (v) => { loser.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(loser.pos.y, loserOrigY, 0.15, (v) => { loser.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
sfxBonk(); k.shake(15)
|
|
spawnShockwave(loser.pos.x, GROUND_Y, '#ff4400')
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 50, 'BOOM!', '#ff6600')
|
|
destroyProp(cannonProp)
|
|
await k.wait(0.3)
|
|
winner.play('win')
|
|
} else if (finishStyle === 15) {
|
|
// GIANT STAMP — REJECTED
|
|
fatalityTagline = 'REJECTED!'
|
|
announceRobot('Processing termination request.')
|
|
sfxDrumRoll()
|
|
const stamp = spawnWeaponProp('stamp', loser.pos.x, loser.pos.y - 80, false, 22)
|
|
await k.wait(0.3)
|
|
sfxZoomWhoosh()
|
|
for (const p of stamp) {
|
|
k.tween(p.pos.y, p.pos.y + 60, 0.1, (v) => { p.pos.y = v }, k.easings.easeInQuad)
|
|
}
|
|
await k.wait(0.1)
|
|
sfxBonk(); sfxSplat(); k.shake(20); screenFlash('#cc4444', 0.2)
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 50, 'REJECTED', '#cc4444')
|
|
for (let i = 0; i < 8; i++) {
|
|
spawnProp(loser.pos.x, loser.pos.y - 10, loser.pos.x + (Math.random() - 0.5) * 80, GROUND_Y - 20 - Math.random() * 40, 4, 4, '#cc4444', 200, true)
|
|
}
|
|
await k.wait(0.4)
|
|
destroyProp(stamp)
|
|
winner.play('win')
|
|
} else if (finishStyle === 16) {
|
|
// VENDING MACHINE TIP
|
|
fatalityTagline = 'OUT OF ORDER!'
|
|
announceSilly('Should have read the warning label!')
|
|
const vm = spawnWeaponProp('vending_machine', winner.pos.x + dir * 40, GROUND_Y - 18, false, 14)
|
|
sfxPowerUp(); await k.wait(0.2)
|
|
winner.play('attack'); sfxPunch()
|
|
sfxZoomWhoosh()
|
|
for (const p of vm) {
|
|
k.tween(p.pos.x, loser.pos.x, 0.2, (v) => { p.pos.x = v }, k.easings.easeInQuad)
|
|
}
|
|
await k.wait(0.2)
|
|
sfxExplosion(); sfxBonk(); k.shake(25); screenFlash('#cc3333', 0.2)
|
|
spawnSparks(loser.pos.x, loser.pos.y - 20, 20, '#cc3333')
|
|
const snackColors = ['#ff4444', '#44ff44', '#4444ff', '#ffff44', '#ff8844']
|
|
for (let i = 0; i < 8; i++) {
|
|
spawnProp(loser.pos.x, loser.pos.y - 10, loser.pos.x + (Math.random() - 0.5) * 100, GROUND_Y - 40 - Math.random() * 60, 5, 8, snackColors[i % 5], 250)
|
|
}
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 60, 'CRUSHED!', '#cc3333')
|
|
destroyProp(vm)
|
|
await k.wait(0.3)
|
|
winner.play('win')
|
|
} else if (finishStyle === 17) {
|
|
// LAWN MOWER — mowed down
|
|
fatalityTagline = 'MOWED DOWN!'
|
|
announceFast('Rev it up!')
|
|
const mower = spawnWeaponProp('lawn_mower', winner.pos.x + dir * 10, GROUND_Y - 8, dir < 0, 16)
|
|
winner.play('special'); sfxPowerUp()
|
|
for (let i = 0; i < 3; i++) { sfxRandomComedy(); await k.wait(0.1) }
|
|
sfxZoomWhoosh()
|
|
for (const p of mower) {
|
|
k.tween(p.pos.x, loser.pos.x + dir * 40, 0.2, (v) => { p.pos.x = v }, k.easings.easeInQuad)
|
|
}
|
|
await k.tween(winner.pos.x, loser.pos.x - dir * 20, 0.2, (v) => { winner.pos.x = v }, k.easings.easeInQuad)
|
|
sfxExplosion(); k.shake(20); screenFlash('#44aa44', 0.2)
|
|
loser.play('knockback')
|
|
for (let i = 0; i < 15; i++) {
|
|
spawnProp(loser.pos.x, GROUND_Y - 5, loser.pos.x + (Math.random() - 0.5) * 80, GROUND_Y - 30 - Math.random() * 50, 3, 3, '#44aa44', 300, false)
|
|
}
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 50, 'BRRRRR!', '#44aa44')
|
|
destroyProp(mower)
|
|
await k.wait(0.3)
|
|
} else if (finishStyle === 18) {
|
|
// DUBSTEP DROP — bass drops, floor breaks
|
|
fatalityTagline = 'DROP THE BASS!'
|
|
announceScream('WUB WUB WUB!')
|
|
sfxPowerUp()
|
|
const wubColors = ['#ff00ff', '#00ffff', '#ff8800', '#39ff14']
|
|
for (let i = 0; i < 4; i++) {
|
|
screenFlash(wubColors[i], 0.05); k.shake(3 + i * 2); await k.wait(0.1)
|
|
}
|
|
sfxExplosion(); sfxExplosion(); k.shake(35); screenFlash('#ffffff', 0.15)
|
|
spawnShockwave(W / 2, GROUND_Y, '#ff00ff')
|
|
await k.wait(0.05)
|
|
spawnShockwave(W / 2, GROUND_Y, '#00ffff')
|
|
await k.wait(0.05)
|
|
spawnShockwave(W / 2, GROUND_Y, '#39ff14')
|
|
loser.play('knockback')
|
|
for (let i = 0; i < 5; i++) {
|
|
await k.tween(loser.pos.y, loserOrigY - 40, 0.04, (v) => { loser.pos.y = v }, k.easings.easeOutQuad)
|
|
sfxBonk(); k.shake(8)
|
|
await k.tween(loser.pos.y, loserOrigY, 0.04, (v) => { loser.pos.y = v }, k.easings.easeInQuad)
|
|
screenFlash(wubColors[i % 4], 0.03)
|
|
}
|
|
spawnSparks(loser.pos.x, loser.pos.y - 20, 25, '#ff00ff')
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 60, 'WUBWUB!', '#ff00ff')
|
|
await k.wait(0.3)
|
|
winner.play('win')
|
|
} else if (finishStyle === 19) {
|
|
// 404 NOT FOUND — loser glitches out
|
|
fatalityTagline = 'ERROR 404!'
|
|
announceRobot('Error. Opponent not found.')
|
|
sfxZap()
|
|
for (let i = 0; i < 10; i++) {
|
|
loser.opacity = Math.random() > 0.5 ? 1 : 0.2
|
|
loser.pos.x += (Math.random() - 0.5) * 15
|
|
loser.play(['idle', 'attack', 'kick', 'hit', 'special'][Math.floor(Math.random() * 5)])
|
|
screenFlash('#00ff00', 0.02); sfxRandomFail()
|
|
await k.wait(0.06)
|
|
}
|
|
screenFlash('#0000ff', 0.3); sfxFail(); k.shake(20)
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 60, '404', '#00ff00')
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 40, 'NOT FOUND', '#00ff00')
|
|
loser.opacity = 0; await k.wait(0.3)
|
|
loser.opacity = 1; sfxWomp()
|
|
spawnSparks(loser.pos.x, loser.pos.y - 20, 15, '#00ff00')
|
|
await k.wait(0.3)
|
|
winner.play('win')
|
|
} else if (finishStyle === 20) {
|
|
// PIE STORM — pies from everywhere
|
|
fatalityTagline = 'CREAM ATED!'
|
|
announceSilly('PIE PIE PIE!')
|
|
winner.play('special')
|
|
const pieAngles = [0, 45, 90, 135, 180, 225, 270, 315]
|
|
for (let i = 0; i < 8; i++) {
|
|
const rad = pieAngles[i] * Math.PI / 180
|
|
const fromX = loser.pos.x + Math.cos(rad) * 120
|
|
const fromY = loser.pos.y - 20 + Math.sin(rad) * 80
|
|
const pie = spawnWeaponProp('pie', fromX, fromY, false, 16)
|
|
for (const p of pie) {
|
|
k.tween(p.pos.x, loser.pos.x, 0.15, (v) => { p.pos.x = v }, k.easings.easeInQuad)
|
|
k.tween(p.pos.y, loser.pos.y - 20, 0.15, (v) => { p.pos.y = v }, k.easings.easeInQuad).then(() => destroyProp(pie))
|
|
}
|
|
sfxBoing(); await k.wait(0.06)
|
|
if (i % 2 === 0) { loser.play(i % 4 === 0 ? 'hit' : 'knockback'); sfxSplat(); k.shake(5 + i) }
|
|
}
|
|
sfxExplosion(); k.shake(22); screenFlash('#f5deb3', 0.2)
|
|
for (let i = 0; i < 15; i++) {
|
|
spawnProp(loser.pos.x, loser.pos.y - 20, loser.pos.x + (Math.random() - 0.5) * 100, loserOrigY - 40 - Math.random() * 50, 5, 5, '#ffffff', 250, true)
|
|
}
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 50, 'SPLAT!', '#ffffff')
|
|
await k.wait(0.3)
|
|
winner.play('win')
|
|
} else if (finishStyle === 21) {
|
|
// T-SHIRT CANNON — rapid fire merch
|
|
fatalityTagline = "MERCH'D!"
|
|
announceFast('FREE SHIRTS! FREE SHIRTS!')
|
|
winner.play('special')
|
|
const tCannon = k.add([k.rect(30, 15), k.pos(winner.pos.x + dir * 15, winner.pos.y - 25), k.color(safeColor(k, '#ff4488')), k.z(16)])
|
|
sfxPowerUp(); await k.wait(0.15)
|
|
const shirtColors = ['#ff4444', '#4444ff', '#44ff44', '#ffff44', '#ff44ff', '#44ffff', '#ff8844', '#8844ff']
|
|
for (let i = 0; i < 8; i++) {
|
|
sfxGunshot()
|
|
spawnProp(tCannon.pos.x + dir * 30, tCannon.pos.y, loser.pos.x + (Math.random() - 0.5) * 20, loser.pos.y - 20 + (Math.random() - 0.5) * 20, 10, 8, shirtColors[i], 600)
|
|
if (i % 2 === 0) { loser.play('hit'); sfxBonk(); k.shake(5 + i) }
|
|
await k.wait(0.06)
|
|
}
|
|
sfxCritical(); k.shake(18); screenFlash('#ff4488', 0.2)
|
|
loser.play('knockback')
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 50, 'XL!', '#ff4488')
|
|
tCannon.destroy()
|
|
await k.wait(0.3)
|
|
winner.play('win')
|
|
} else if (finishStyle === 22) {
|
|
// CONFETTI CANNON — party's over
|
|
fatalityTagline = "PARTY'S OVER!"
|
|
announceSilly('SURPRISE!')
|
|
winner.play('special'); sfxPowerUp(); await k.wait(0.2)
|
|
sfxExplosion(); k.shake(20); screenFlash('#ff88cc', 0.15)
|
|
const confettiColors = ['#ff4444', '#44ff44', '#4444ff', '#ffff00', '#ff00ff', '#00ffff', '#ff8800', '#88ff00']
|
|
for (let i = 0; i < 30; i++) {
|
|
spawnProp(winner.pos.x + dir * 30, winner.pos.y - 25, loser.pos.x + (Math.random() - 0.5) * 80, loserOrigY - 80 - Math.random() * 60, 4, 3, confettiColors[i % 8], 400 + Math.random() * 200)
|
|
}
|
|
sfxBoing(); sfxRandomComedy()
|
|
loser.play('hit'); k.shake(10); await k.wait(0.15)
|
|
loser.play('knockback'); sfxCritical(); k.shake(15)
|
|
await k.tween(loser.pos.x, loser.pos.x + dir * 50, 0.2, (v) => { loser.pos.x = v }, k.easings.easeOutQuad)
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 50, 'YAY?', '#ff88cc')
|
|
await k.wait(0.3)
|
|
winner.play('win')
|
|
} else if (finishStyle === 23) {
|
|
// BALLOON POP — inflate then pop
|
|
fatalityTagline = 'POPPED!'
|
|
announceSilly('Inflate! INFLATE!')
|
|
winner.play('special'); sfxPowerUp()
|
|
await k.tween(winner.pos.x, contactX, 0.12, (v) => { winner.pos.x = v }, k.easings.easeOutQuad)
|
|
const origSX = loser.scale.x; const origSY = loser.scale.y
|
|
for (let i = 0; i < 8; i++) {
|
|
const grow = 1 + (i + 1) * 0.15
|
|
await k.tween(loser.scale.y, origSY * grow, 0.08, (v) => { loser.scale.x = origSX * grow; loser.scale.y = v }, k.easings.easeOutQuad)
|
|
sfxBoing(); loser.play(i % 2 === 0 ? 'hit' : 'idle')
|
|
loser.pos.y = loserOrigY - (grow - 1) * 15
|
|
await k.wait(0.04)
|
|
}
|
|
sfxExplosion(); k.shake(25); screenFlash('#ff4488', 0.2)
|
|
loser.scale.x = origSX; loser.scale.y = origSY; loser.pos.y = loserOrigY
|
|
const balloonColors = ['#ff4444', '#44ff44', '#4444ff', '#ffff44', '#ff44ff']
|
|
for (let i = 0; i < 15; i++) {
|
|
spawnProp(loser.pos.x, loser.pos.y - 20, loser.pos.x + (Math.random() - 0.5) * 120, loserOrigY - 60 - Math.random() * 80, 6, 4, balloonColors[i % 5], 250, true)
|
|
}
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 60, 'POP!', '#ff4488')
|
|
await k.wait(0.3)
|
|
winner.play('win')
|
|
} else if (finishStyle === 24) {
|
|
// GIANT MAGNET — yanks loser back and forth
|
|
fatalityTagline = 'ATTRACTIVE FINISH!'
|
|
announceRobot('Magnetic field activated.')
|
|
winner.play('special'); sfxPowerUp()
|
|
const magnet = k.add([k.rect(20, 25), k.pos(winner.pos.x + dir * 20, winner.pos.y - 30), k.color(safeColor(k, '#cc0000')), k.z(18)])
|
|
const magnetTop = k.add([k.rect(20, 8), k.pos(winner.pos.x + dir * 20, winner.pos.y - 50), k.color(safeColor(k, '#0000cc')), k.z(18)])
|
|
sfxZap()
|
|
for (let i = 0; i < 6; i++) {
|
|
const pullTarget = i % 2 === 0 ? winner.pos.x + dir * 40 : (winningSide === 'a' ? HOME_B + 30 : HOME_A - 30)
|
|
sfxZoomWhoosh()
|
|
await k.tween(loser.pos.x, pullTarget, 0.1, (v) => { loser.pos.x = v }, k.easings.easeInOutQuad)
|
|
sfxBonk(); k.shake(6 + i * 2)
|
|
loser.play(i % 2 === 0 ? 'hit' : 'knockback')
|
|
spawnSparks(loser.pos.x, loser.pos.y - 20, 5, '#8888ff')
|
|
await k.wait(0.05)
|
|
}
|
|
sfxExplosion(); k.shake(22); screenFlash('#8888ff', 0.2)
|
|
spawnShockwave(loser.pos.x, GROUND_Y, '#8888ff')
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 50, 'BZZT!', '#8888ff')
|
|
magnet.destroy(); magnetTop.destroy()
|
|
await k.wait(0.3)
|
|
winner.play('win')
|
|
} else if (finishStyle === 25) {
|
|
// SLIDE WHISTLE — loser slides off screen
|
|
fatalityTagline = 'WHEEEE!'
|
|
announceSilly('Bye bye!')
|
|
sfxSlideUp(); winner.play('attack')
|
|
await k.tween(winner.pos.x, contactX, 0.1, (v) => { winner.pos.x = v }, k.easings.easeOutQuad)
|
|
sfxPunch(); sfxBoing(); k.shake(10)
|
|
loser.play('knockback')
|
|
sfxSlideUp()
|
|
await Promise.all([
|
|
k.tween(loser.pos.y, -50, 0.5, (v) => { loser.pos.y = v }, k.easings.easeInQuad),
|
|
k.tween(loser.pos.x, loser.pos.x + dir * 30, 0.5, (v) => { loser.pos.x = v }, k.easings.easeInQuad),
|
|
])
|
|
spawnEmoteText(loser.pos.x, 20, '*', '#ffee00')
|
|
await k.wait(0.4)
|
|
sfxSlideDown(); sfxZoomWhoosh()
|
|
await k.tween(loser.pos.y, loserOrigY, 0.25, (v) => { loser.pos.y = v }, k.easings.easeInQuad)
|
|
sfxSplat(); sfxExplosion(); k.shake(20); screenFlash('#ffcc00', 0.15)
|
|
spawnShockwave(loser.pos.x, GROUND_Y, '#ffcc00')
|
|
await k.wait(0.3)
|
|
winner.play('win')
|
|
} else if (finishStyle === 26) {
|
|
// SLAPSTICK LADDER — keeps bonking loser
|
|
fatalityTagline = 'SLAPSTICKED!'
|
|
announceSilly('Watch where you swing that thing!')
|
|
const ladder = k.add([k.rect(6, 50), k.pos(winner.pos.x + dir * 5, winner.pos.y - 40), k.color(safeColor(k, '#cc8833')), k.z(18), k.anchor('center')])
|
|
sfxBoing()
|
|
for (let i = 0; i < 5; i++) {
|
|
winner.scale.x = -winner.scale.x
|
|
ladder.pos.x = winner.pos.x + (winner.scale.x > 0 ? 1 : -1) * 25
|
|
sfxZoomWhoosh(); await k.wait(0.06)
|
|
sfxBonk(); k.shake(6 + i * 2)
|
|
loser.play(i % 2 === 0 ? 'hit' : 'knockback')
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 40 - Math.random() * 20, ['BONK!', 'CLONK!', 'WHACK!', 'THUD!', 'OOF!'][i], '#cc8833')
|
|
await k.wait(0.08)
|
|
}
|
|
sfxCritical(); k.shake(18); screenFlash('#cc8833', 0.15)
|
|
spawnSparks(loser.pos.x, loser.pos.y - 20, 15, '#cc8833')
|
|
ladder.destroy()
|
|
winner.scale.x = dir > 0 ? Math.abs(winner.scale.x) : -Math.abs(winner.scale.x)
|
|
spawnEmoteText(winner.pos.x, winner.pos.y - 50, '?', '#ffffff')
|
|
await k.wait(0.3)
|
|
} else if (finishStyle === 27) {
|
|
// STACK OVERFLOW — buried in code blocks
|
|
fatalityTagline = 'STACK OVERFLOW!'
|
|
announceRobot('Exception in thread main.')
|
|
sfxFail()
|
|
const blockColors = ['#282c34', '#1e1e1e', '#2d2d2d', '#1a1a2e', '#0d1117']
|
|
for (let i = 0; i < 10; i++) {
|
|
const block = k.add([
|
|
k.rect(18 + Math.random() * 12, 8 + Math.random() * 6),
|
|
k.pos(loser.pos.x + (Math.random() - 0.5) * 40, -20 - i * 15),
|
|
k.color(safeColor(k, blockColors[i % 5])), k.z(16 + i), k.opacity(0.9),
|
|
])
|
|
k.tween(block.pos.y, GROUND_Y - 5 - i * 6, 0.15 + i * 0.02, (v) => { block.pos.y = v }, k.easings.easeInQuad).then(() => {
|
|
sfxBonk(); k.shake(3)
|
|
setTimeout(() => { if (block.exists()) k.tween(1, 0, 0.8, (v) => { block.opacity = v }).then(() => { if (block.exists()) block.destroy() }) }, 800)
|
|
})
|
|
spawnEmoteText(loser.pos.x + (Math.random() - 0.5) * 30, loser.pos.y - 30 - Math.random() * 30, ['{', '}', '()', '=>', '[]', ';;', 'nil', 'NaN', '???', '//'][i], '#00ff00')
|
|
loser.play(i % 3 === 0 ? 'hit' : 'idle')
|
|
await k.wait(0.06)
|
|
}
|
|
sfxExplosion(); k.shake(20); screenFlash('#00ff00', 0.2)
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 60, 'SEGFAULT', '#ff0000')
|
|
await k.wait(0.4)
|
|
winner.play('win')
|
|
} else if (finishStyle === 28) {
|
|
// GLITTER BOMB — fabulous destruction
|
|
fatalityTagline = 'FABULOUS!'
|
|
announceSilly('You will NEVER get this out of your hair!')
|
|
winner.play('special'); sfxPowerUp()
|
|
await k.tween(winner.pos.x, contactX, 0.1, (v) => { winner.pos.x = v }, k.easings.easeOutQuad)
|
|
sfxPunch(); k.shake(5)
|
|
sfxExplosion(); k.shake(25)
|
|
const glitterColors = ['#ff88cc', '#ffcc00', '#88ffcc', '#cc88ff', '#ff8888', '#88ccff', '#ffff88', '#ff88ff']
|
|
for (let wave = 0; wave < 3; wave++) {
|
|
screenFlash(glitterColors[wave * 2], 0.04)
|
|
for (let i = 0; i < 15; i++) {
|
|
spawnProp(loser.pos.x, loser.pos.y - 20, loser.pos.x + (Math.random() - 0.5) * 140, loserOrigY - 80 - Math.random() * 80, 3, 3, glitterColors[Math.floor(Math.random() * 8)], 200 + Math.random() * 200, Math.random() > 0.5)
|
|
}
|
|
sfxBoing(); loser.play(wave === 2 ? 'knockback' : 'hit')
|
|
await k.wait(0.1)
|
|
}
|
|
spawnShockwave(loser.pos.x, GROUND_Y, '#ff88cc')
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 60, 'SPARKLE!', '#ff88cc')
|
|
await k.wait(0.3)
|
|
winner.play('win')
|
|
} else if (finishStyle === 29) {
|
|
// SELFIE STICK — beats then takes selfie
|
|
fatalityTagline = 'SAY CHEESE!'
|
|
announceFast('Content creation time!')
|
|
const stick = k.add([k.rect(4, 40), k.pos(winner.pos.x + dir * 10, winner.pos.y - 50), k.color(safeColor(k, '#888888')), k.z(18)])
|
|
const phone = k.add([k.rect(8, 12), k.pos(winner.pos.x + dir * 10, winner.pos.y - 70), k.color(safeColor(k, '#222222')), k.z(19)])
|
|
sfxBoing()
|
|
await k.tween(winner.pos.x, contactX, 0.1, (v) => { winner.pos.x = v }, k.easings.easeOutQuad)
|
|
for (let i = 0; i < 4; i++) {
|
|
winner.play('attack'); sfxBonk()
|
|
stick.pos.x = loser.pos.x; phone.pos.x = loser.pos.x
|
|
loser.play('hit'); k.shake(5 + i * 2)
|
|
await k.wait(0.08)
|
|
}
|
|
sfxCritical(); k.shake(15); loser.play('knockback')
|
|
await k.wait(0.15)
|
|
winner.play('win'); sfxCoin(); screenFlash('#ffffff', 0.3)
|
|
spawnEmoteText(W / 2, GROUND_Y - 80, '#selfie', '#ff4488')
|
|
spawnSparks(phone.pos.x, phone.pos.y, 10, '#ffffff')
|
|
stick.destroy(); phone.destroy()
|
|
await k.wait(0.3)
|
|
} else if (finishStyle === 30) {
|
|
// DANCE OFF — served
|
|
fatalityTagline = 'SERVED!'
|
|
announceHype('DANCE BATTLE!')
|
|
sfxPowerUp()
|
|
const moves = ['attack', 'kick', 'special', 'kick', 'attack', 'special'] as const
|
|
for (let i = 0; i < moves.length; i++) {
|
|
winner.play(moves[i]); sfxRandomComedy()
|
|
spawnSparks(winner.pos.x, winner.pos.y - 30, 3, ['#ff00ff', '#00ffff', '#ffff00'][i % 3])
|
|
await k.wait(0.08)
|
|
}
|
|
for (let i = 0; i < 4; i++) {
|
|
loser.play(moves[i]); sfxWomp()
|
|
loser.pos.x += (Math.random() - 0.5) * 10
|
|
await k.wait(0.1)
|
|
}
|
|
sfxFail()
|
|
winner.play('special'); sfxCritical(); sfxExplosion()
|
|
k.shake(25); screenFlash('#ff00ff', 0.2)
|
|
spawnShockwave(loser.pos.x, GROUND_Y, '#ff00ff')
|
|
spawnSparks(loser.pos.x, loser.pos.y - 20, 20, '#ff00ff')
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 50, 'SERVED!', '#ff00ff')
|
|
await k.wait(0.3)
|
|
winner.play('win')
|
|
} else if (finishStyle === 31) {
|
|
// WHOOPEE CUSHION — total gas
|
|
fatalityTagline = 'TOTAL GAS!'
|
|
announceSilly('What is that SMELL!?')
|
|
const cushion = k.add([k.circle(20), k.pos(loser.pos.x, GROUND_Y - 5), k.color(safeColor(k, '#ff6688')), k.z(10), k.opacity(0.8)])
|
|
sfxBoing(); await k.wait(0.2)
|
|
sfxWomp(); sfxRandomComedy(); k.shake(8)
|
|
await k.tween(20, 40, 0.15, (v) => { cushion.radius = v }, k.easings.easeOutQuad)
|
|
sfxExplosion()
|
|
for (let i = 0; i < 12; i++) {
|
|
const gas = k.add([
|
|
k.circle(8 + Math.random() * 10),
|
|
k.pos(loser.pos.x + (Math.random() - 0.5) * 40, GROUND_Y - 10 - Math.random() * 30),
|
|
k.color(safeColor(k, '#88ff44')), k.opacity(0.5), k.z(15),
|
|
])
|
|
k.tween(gas.pos.y, gas.pos.y - 40 - Math.random() * 30, 0.6, (v) => { gas.pos.y = v }, k.easings.easeOutQuad)
|
|
k.tween(0.5, 0, 0.6, (v) => { gas.opacity = v }).then(() => { if (gas.exists()) gas.destroy() })
|
|
}
|
|
k.shake(20); screenFlash('#88ff44', 0.15)
|
|
loser.play('knockback')
|
|
await k.tween(loser.pos.y, loserOrigY - 120, 0.2, (v) => { loser.pos.y = v }, k.easings.easeOutQuad)
|
|
await k.tween(loser.pos.y, loserOrigY, 0.15, (v) => { loser.pos.y = v }, k.easings.easeInQuad)
|
|
sfxSplat(); k.shake(12)
|
|
cushion.destroy()
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 50, 'P U!', '#88ff44')
|
|
await k.wait(0.3)
|
|
winner.play('win')
|
|
} else if (finishStyle === 32) {
|
|
// RICK ROLL — never gonna give you up
|
|
fatalityTagline = 'NEVER GONNA GIVE YOU UP!'
|
|
announceHype('You know the rules, and so do I!')
|
|
sfxPowerUp()
|
|
const rickMoves = ['attack', 'kick', 'special', 'idle', 'attack', 'kick'] as const
|
|
for (let i = 0; i < 6; i++) {
|
|
winner.play(rickMoves[i])
|
|
const hop = winner.pos.y
|
|
await k.tween(winner.pos.y, hop - 15, 0.05, (v) => { winner.pos.y = v }, k.easings.easeOutQuad)
|
|
await k.tween(winner.pos.y, hop, 0.05, (v) => { winner.pos.y = v }, k.easings.easeInQuad)
|
|
sfxBoing()
|
|
screenFlash(['#ff4444', '#ff8800', '#ffff00', '#44ff44', '#4444ff', '#8844ff'][i], 0.03)
|
|
await k.wait(0.04)
|
|
}
|
|
await k.tween(winner.pos.x, contactX, 0.1, (v) => { winner.pos.x = v }, k.easings.easeOutQuad)
|
|
winner.play('special'); sfxCritical(); sfxExplosion()
|
|
k.shake(25); screenFlash('#ff8800', 0.2)
|
|
loser.play('knockback')
|
|
spawnSparks(loser.pos.x, loser.pos.y - 20, 20, '#ff8800')
|
|
spawnShockwave(loser.pos.x, GROUND_Y, '#ff8800')
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 50, "RICK'D!", '#ff8800')
|
|
await k.wait(0.3)
|
|
winner.play('win')
|
|
} else {
|
|
// PIZZA CUTTER — the big wheel
|
|
fatalityTagline = 'SLICED!'
|
|
announceFast('Extra large, extra lethal!')
|
|
const wheel = k.add([k.circle(18), k.pos(winner.pos.x + dir * 30, GROUND_Y - 18), k.color(safeColor(k, '#cccccc')), k.z(18), k.rotate(0)])
|
|
const handle = k.add([k.rect(6, 20), k.pos(winner.pos.x + dir * 30, GROUND_Y - 36), k.color(safeColor(k, '#553322')), k.z(17)])
|
|
sfxPowerUp(); winner.play('special')
|
|
sfxZoomWhoosh()
|
|
await Promise.all([
|
|
k.tween(wheel.pos.x, loser.pos.x, 0.2, (v) => { wheel.pos.x = v; handle.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(0, 720, 0.2, (v) => { wheel.angle = v }, k.easings.linear),
|
|
])
|
|
sfxCritical(); sfxSplat(); k.shake(20); screenFlash('#ffcc00', 0.15)
|
|
loser.play('knockback')
|
|
spawnSparks(loser.pos.x, loser.pos.y - 20, 15, '#ff6600')
|
|
await k.tween(wheel.pos.x, loser.pos.x + dir * 60, 0.1, (v) => { wheel.pos.x = v; handle.pos.x = v }, k.easings.easeOutQuad)
|
|
sfxZoomWhoosh()
|
|
await k.tween(wheel.pos.x, loser.pos.x, 0.1, (v) => { wheel.pos.x = v; handle.pos.x = v }, k.easings.easeInQuad)
|
|
sfxBonk(); k.shake(15)
|
|
for (let i = 0; i < 8; i++) {
|
|
spawnProp(loser.pos.x, loser.pos.y - 10, loser.pos.x + (Math.random() - 0.5) * 80, loserOrigY - 30 - Math.random() * 40, 4, 4, i % 2 === 0 ? '#ffcc00' : '#cc4400', 250, true)
|
|
}
|
|
wheel.destroy(); handle.destroy()
|
|
spawnEmoteText(loser.pos.x, loser.pos.y - 50, 'SLICED!', '#ff6600')
|
|
await k.wait(0.3)
|
|
winner.play('win')
|
|
}
|
|
|
|
// Judge stands up for KO call
|
|
const judgeKO = k.get('judge')[0]
|
|
if (judgeKO) {
|
|
judgeKO.play('shocked')
|
|
const judgeOrigY = judgeKO.pos.y
|
|
k.tween(judgeKO.pos.y, judgeOrigY - 25, 0.2, (v) => { judgeKO.pos.y = v }, k.easings.easeOutQuad)
|
|
k.wait(1.5).then(() => {
|
|
if (judgeKO.exists()) {
|
|
judgeKO.play(winningSide === 'a' ? 'call_left' : 'call_right')
|
|
k.tween(judgeKO.pos.y, judgeOrigY, 0.3, (v) => { judgeKO.pos.y = v }, k.easings.easeInOutQuad)
|
|
}
|
|
})
|
|
}
|
|
|
|
// Winner's human cheers, loser's human panics (30% chance on KO)
|
|
if (Math.random() < 0.3) {
|
|
spawnHumanCoach(winningSide, 'cheer')
|
|
spawnHumanCoach(winningSide === 'a' ? 'b' : 'a', 'panic')
|
|
}
|
|
|
|
// === Common ending: KO + celebration ===
|
|
sfxKO()
|
|
spawnShockwave(loser.pos.x, GROUND_Y, '#ff2d2d')
|
|
spawnSparks(loser.pos.x, loser.pos.y - 20, 25, '#ff2d2d')
|
|
k.shake(18); sfxExplosion()
|
|
await k.wait(0.3)
|
|
loser.play('ko')
|
|
if (Math.random() < 0.5) setTimeout(() => sfxRandomFail(), 200)
|
|
await k.wait(0.4) // pause for visual impact before fatality voice
|
|
const winnerArch = winningSide === 'a' ? botA.archetype : botB.archetype
|
|
const loserArch = winningSide === 'a' ? botB.archetype : botA.archetype
|
|
if (winnerArch === 'the_creator') {
|
|
announceCreatorKO()
|
|
} else {
|
|
announceFatality(fatalityTagline)
|
|
}
|
|
announceCrowdReaction('cheer')
|
|
await k.tween(winner.pos.x, winningSide === 'a' ? HOME_A : HOME_B, 0.25, (v) => { winner.pos.x = v }, k.easings.easeInOutQuad)
|
|
await k.wait(0.2)
|
|
winner.play('win')
|
|
sfxWin()
|
|
// Creator win/lose get special announcements
|
|
if (winnerArch === 'the_creator') {
|
|
announceCreatorWin()
|
|
} else if (loserArch === 'the_creator') {
|
|
announceCreatorLose()
|
|
} else {
|
|
sfxWinAnnounce(winnerName)
|
|
}
|
|
spawnSparks(winner.pos.x, winner.pos.y - 50, 15, '#ffe14d')
|
|
for (let i = 0; i < 4; i++) {
|
|
setTimeout(() => {
|
|
spawnSparks(winner.pos.x + (Math.random() - 0.5) * 60, winner.pos.y - 40 - Math.random() * 30, 8, '#ffe14d')
|
|
}, i * 200)
|
|
}
|
|
await k.wait(0.5)
|
|
|
|
// Post-KO sportsmanship (30% chance): winner helps loser up or they fist bump
|
|
if (Math.random() < 0.3) {
|
|
const sportsType = Math.random()
|
|
if (sportsType < 0.35) {
|
|
// Winner helps loser back up
|
|
await playHelpUp(winner, loser, winningSide)
|
|
} else if (sportsType < 0.65) {
|
|
// Fist bump
|
|
loser.play('idle')
|
|
await k.wait(0.2)
|
|
await playFistBump(winner, loser)
|
|
} else if (sportsType < 0.85) {
|
|
// Both bow
|
|
loser.play('idle')
|
|
await k.wait(0.2)
|
|
await Promise.all([playBow(winner), playBow(loser)])
|
|
announceCool(heartfeltLines[Math.floor(Math.random() * heartfeltLines.length)])
|
|
for (let i = 0; i < 5; i++) spawnHeart(W / 2 + (Math.random() - 0.5) * 100, GROUND_Y - 60)
|
|
} else {
|
|
// Crowd shows love — signs pop up
|
|
spawnCrowdSigns(5, '#ff4466', '\u2665')
|
|
announceDramatic(heartfeltLines[Math.floor(Math.random() * heartfeltLines.length)])
|
|
for (let i = 0; i < 8; i++) spawnHeart(Math.random() * W, GROUND_Y - 40 - Math.random() * 60)
|
|
await k.wait(0.8)
|
|
}
|
|
}
|
|
},
|
|
|
|
async playPerfect(winningSide: 'a' | 'b', winnerName: string) {
|
|
const winner = k.get(winningSide === 'a' ? 'fighterA' : 'fighterB')[0] as Fighter
|
|
const loser = k.get(winningSide === 'a' ? 'fighterB' : 'fighterA')[0] as Fighter
|
|
if (!loser || !winner) return
|
|
|
|
// Judge goes wild for a perfect
|
|
const judgePerfect = k.get('judge')[0]
|
|
if (judgePerfect) {
|
|
judgePerfect.play('shocked')
|
|
const jOrigY = judgePerfect.pos.y
|
|
k.tween(judgePerfect.pos.y, jOrigY - 35, 0.15, (v) => { judgePerfect.pos.y = v }, k.easings.easeOutQuad)
|
|
k.wait(0.5).then(async () => {
|
|
if (!judgePerfect.exists()) return
|
|
for (let b = 0; b < 4; b++) {
|
|
await k.tween(judgePerfect.pos.y, jOrigY - 45, 0.08, (v) => { judgePerfect.pos.y = v }, k.easings.easeOutQuad)
|
|
await k.tween(judgePerfect.pos.y, jOrigY - 35, 0.08, (v) => { judgePerfect.pos.y = v }, k.easings.easeInQuad)
|
|
}
|
|
judgePerfect.play(winningSide === 'a' ? 'call_left' : 'call_right')
|
|
k.tween(judgePerfect.pos.y, jOrigY, 0.3, (v) => { judgePerfect.pos.y = v }, k.easings.easeInOutQuad)
|
|
})
|
|
}
|
|
|
|
sfxPerfect()
|
|
const dir = winningSide === 'a' ? 1 : -1
|
|
const loserOrigY = loser.pos.y
|
|
const contactX = loser.pos.x - dir * 40
|
|
|
|
// === PHASE 1: Dramatic zoom rush into the loser ===
|
|
const origScaleX = winner.scale.x
|
|
const origScaleY = winner.scale.y
|
|
sfxZoomWhoosh()
|
|
// Winner zooms at camera
|
|
await Promise.all([
|
|
k.tween(Math.abs(origScaleX), 5, 0.2, (v) => { winner.scale.x = origScaleX > 0 ? v : -v; winner.scale.y = v }, k.easings.easeInQuad),
|
|
k.tween(winner.pos.x, W / 2, 0.2, (v) => { winner.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(winner.pos.y, H * 0.6, 0.2, (v) => { winner.pos.y = v }, k.easings.easeOutQuad),
|
|
])
|
|
screenFlash('#000000', 0.1)
|
|
spawnGrotesqueDetails(winner, 2.5)
|
|
await k.wait(0.1)
|
|
destroyGrotesqueDetails()
|
|
// Zoom back and SLAM into loser
|
|
sfxZoomWhoosh()
|
|
await Promise.all([
|
|
k.tween(winner.scale.y, Math.abs(origScaleY), 0.12, (v) => { winner.scale.x = origScaleX > 0 ? v : -v; winner.scale.y = v }, k.easings.easeInQuad),
|
|
k.tween(winner.pos.x, contactX, 0.12, (v) => { winner.pos.x = v }, k.easings.easeInQuad),
|
|
k.tween(winner.pos.y, loserOrigY, 0.12, (v) => { winner.pos.y = v }, k.easings.easeInQuad),
|
|
])
|
|
|
|
// === PHASE 2: Devastating rapid combo at contact ===
|
|
const colors = ['#ff2d7b', '#00f0ff', '#ffe14d', '#ff6600', '#b83dff', '#39ff14', '#ffffff', '#ff2d2d']
|
|
const hitCount = 10
|
|
for (let i = 0; i < hitCount; i++) {
|
|
const anim = ['attack', 'kick', 'special', 'attack'][i % 4]
|
|
winner.play(anim)
|
|
sfxRapidPunch()
|
|
await k.wait(0.04)
|
|
loser.play(i < hitCount - 1 ? 'hit' : 'knockback')
|
|
k.shake(3 + i)
|
|
spawnSparks(loser.pos.x + (Math.random() - 0.5) * 30, loser.pos.y - 10 - Math.random() * 50, 5, colors[i % colors.length])
|
|
loser.pos.x += dir * 4
|
|
loser.pos.y += (i % 2 === 0 ? -3 : 3)
|
|
await k.wait(0.04)
|
|
}
|
|
loser.pos.y = loserOrigY
|
|
|
|
// === PHASE 3: Final massive hit — screen goes white ===
|
|
winner.play('special')
|
|
sfxCritical()
|
|
sfxExplosion()
|
|
await k.wait(0.06)
|
|
loser.play('knockback')
|
|
k.shake(35)
|
|
screenFlash('#ffe14d', 0.4)
|
|
spawnSparks(loser.pos.x, loser.pos.y - 30, 30, '#ffe14d')
|
|
spawnShockwave(loser.pos.x, GROUND_Y, '#ffe14d')
|
|
|
|
// Launch loser way off with a spin
|
|
await Promise.all([
|
|
k.tween(loser.pos.x, loser.pos.x + dir * 200, 0.4, (v) => { loser.pos.x = v }, k.easings.easeOutQuad),
|
|
k.tween(loser.pos.y, loserOrigY - 300, 0.25, (v) => { loser.pos.y = v }, k.easings.easeOutQuad).then(() =>
|
|
k.tween(loser.pos.y, loserOrigY, 0.25, (v) => { loser.pos.y = v }, k.easings.easeInQuad)
|
|
),
|
|
])
|
|
spawnShockwave(loser.pos.x, GROUND_Y, '#ff2d2d')
|
|
spawnSparks(loser.pos.x, GROUND_Y - 10, 30, '#ff2d2d')
|
|
k.shake(20)
|
|
sfxExplosion()
|
|
sfxBoing()
|
|
await k.wait(0.3)
|
|
loser.play('ko')
|
|
|
|
// Winner walks back and celebrates
|
|
winner.scale.x = origScaleX
|
|
winner.scale.y = origScaleY
|
|
await k.tween(winner.pos.x, winningSide === 'a' ? HOME_A : HOME_B, 0.3, (v) => { winner.pos.x = v }, k.easings.easeInOutQuad)
|
|
winner.play('win')
|
|
setTimeout(() => {
|
|
sfxWin()
|
|
sfxWinAnnounce(winnerName)
|
|
}, 300)
|
|
// FlawlessVictory voice is called by FightViewer after playPerfect returns
|
|
announceCrowdReaction('cheer')
|
|
// Massive fireworks
|
|
for (let i = 0; i < 8; i++) {
|
|
setTimeout(() => {
|
|
spawnSparks(
|
|
Math.random() * W,
|
|
Math.random() * H * 0.5,
|
|
18,
|
|
['#ff2d7b', '#00f0ff', '#ffe14d', '#b83dff', '#39ff14', '#ff6600', '#ffffff', '#ff2d2d'][i]
|
|
)
|
|
if (i % 2 === 0) sfxRandomComedy()
|
|
}, i * 200)
|
|
}
|
|
await k.wait(0.7)
|
|
},
|
|
|
|
startMusic() { startMusic() },
|
|
stopMusic() { stopMusic() },
|
|
|
|
destroy() {
|
|
stopMusic()
|
|
k.quit()
|
|
},
|
|
}
|
|
}
|
|
|
|
export type FightSceneController = Awaited<ReturnType<typeof createFightScene>>
|