class Example extends Phaser.Scene { constructor() { super(); } init() { this.playerState = { level: 1, maxLevel: 10, // Maximum level cap isPaused: false, facing: 'right', isMunching: false, munchStartTime: 0, munchDuration: 250, hasCrabArms: false, crabArms: null, hasKey: false, score: 0, idle: { timer: 0, isAnimComplete: false, nextIdleTime: 0 }, movement: { isGridMoving: false, isMoving: false, targetX: null, targetY: null, isRecovering: false, recoveryEndTime: 0, lastCollisionTime: 0 } }; this.gameOver = false; this.debug = false; } preload() { this.load.audio('thruster', 'https://play.rosebud.ai/assets/thruster_loop.wav?E0Nf'); this.load.audio('unlock', 'https://play.rosebud.ai/assets/unlock.wav?N5kP'); this.load.audio('win', 'https://play.rosebud.ai/assets/Win.wav?EMoy'); this.load.audio('torch', 'https://play.rosebud.ai/assets/torch.wav?P0dK'); this.load.audio('button-click', 'https://play.rosebud.ai/assets/button_click_00.wav?UEjP'); this.load.audio('charge-up', 'https://play.rosebud.ai/assets/Charge-Up.wav?XEmK'); this.load.audio('blocking', 'https://play.rosebud.ai/assets/Blocking Move 001.wav?6UER'); this.load.audio('fanfare', 'https://play.rosebud.ai/assets/Fanfare.wav?txqj'); this.load.audio('bgm', 'https://play.rosebud.ai/assets/numba.mp3?gr7S'); this.load.audio('charmed', 'https://play.rosebud.ai/assets/charmed_00.wav?EH0L'); this.load.audio('coin', 'https://play.rosebud.ai/assets/sound_coin.wav?lzSX'); this.load.audio('jump', 'https://play.rosebud.ai/assets/sound_jump.wav?M4rE'); this.load.audio('hit', 'https://play.rosebud.ai/assets/sound_hit.wav?csYl'); this.load.audio('gameover', 'https://play.rosebud.ai/assets/gameover.wav?hW7n'); this.load.image('background', 'https://play.rosebud.ai/assets/stars.png?k7sq'); this.load.spritesheet('castle', 'https://play.rosebud.ai/assets/castle.png?8q3Y', { frameWidth: 16, frameHeight: 16, startFrame: 0, endFrame: 29 // 6x5 = 30 frames total }); this.load.spritesheet('orb', 'https://play.rosebud.ai/assets/orb.png?pzdM', { frameWidth: 16, frameHeight: 16 }); this.load.spritesheet('silver_key', 'https://play.rosebud.ai/assets/silver_key.png?sRrl', { frameWidth: 16, frameHeight: 16 }); // Load cartridge sprite this.load.spritesheet('cartridge', 'https://play.rosebud.ai/assets/cartridge_small.png?8aWj', { frameWidth: 15.25, frameHeight: 16, spacing: 0, margin: 0, endFrame: 61 }); this.load.spritesheet('cyplop', 'https://play.rosebud.ai/assets/cyplop_adult_green.png?MkZ6', { frameWidth: 16, frameHeight: 16 }); this.load.spritesheet('hearts', 'https://play.rosebud.ai/assets/hearts.png?w43B', { frameWidth: 16, frameHeight: 16 }); this.load.spritesheet('muncher', 'https://play.rosebud.ai/assets/muncher.png?aaYt', { frameWidth: 32, frameHeight: 32 }); this.load.spritesheet('tree', 'https://play.rosebud.ai/assets/tree_swaying.png?tbwP', { frameWidth: 16, frameHeight: 16 }); this.load.spritesheet('chest', 'https://play.rosebud.ai/assets/chest_sparkle.png?cldw', { frameWidth: 16, frameHeight: 16 }); this.load.spritesheet('torch', 'https://play.rosebud.ai/assets/torch.png?Apxt', { frameWidth: 16, frameHeight: 16 }); this.load.spritesheet('health_potion', 'https://play.rosebud.ai/assets/health_potion.png?w5bn', { frameWidth: 16, frameHeight: 16 }); this.load.spritesheet('red_crab', 'https://play.rosebud.ai/assets/red_crab.png?vac5', { frameWidth: 16, frameHeight: 16 }); // Load map features sprite sheet this.load.spritesheet('map_features', 'https://play.rosebud.ai/assets/map_features.png?dNMs', { frameWidth: 16, frameHeight: 16 }); } create() { // Create thruster sound this.thrusterSound = this.sound.add('thruster', { volume: 0.5, loop: true }); // Clean up existing event listeners if they exist if (this.input && this.input.keyboard) { this.input.keyboard.removeAllKeys(true); } // Setup background music if not already playing // Play fanfare and wait for it to complete before starting BGM const fanfare = this.sound.add('fanfare', { volume: 0.7 }); fanfare.play(); fanfare.once('complete', () => { if (!this.sound.get('bgm') || this.registry.get('startBGM')) { const bgm = this.sound.add('bgm', { loop: true, volume: 1.0 }); bgm.play(); // Clear the flag after starting BGM this.registry.remove('startBGM'); } }); // Create tiling background this.background = this.add.tileSprite(0, 0, 800, 600, 'background') .setOrigin(0) .setScrollFactor(0) .setDepth(-1); // Retrieve stored values if they exist if (this.registry.has('score')) { this.playerState.score = this.registry.get('score'); this.registry.remove('score'); } if (this.registry.has('level')) { this.playerState.level = this.registry.get('level'); this.registry.remove('level'); } // Check for paused state from level transition if (this.registry.has('isPaused')) { this.playerState.isPaused = true; this.registry.remove('isPaused'); // Wait a brief moment for scene to render, then unpause this.time.delayedCall(100, () => { this.playerState.isPaused = false; }); } // Initialize grid properties first // Initialize grid properties first this.gridSize = 21; this.cellSize = 16; const gridWidth = this.gridSize * this.cellSize; const gridHeight = this.gridSize * this.cellSize; this.startX = (800 - gridWidth) / 2; this.startY = (600 - gridHeight) / 2; // Initialize game state this.health = 3; this.hearts = []; this.anims.create({ key: 'heart-full', frames: this.anims.generateFrameNumbers('hearts', { start: 0, end: 5 }), frameRate: 12, repeat: -1 }); this.anims.create({ key: 'heart-break', frames: this.anims.generateFrameNumbers('hearts', { start: 6, end: 11 }), frameRate: 12, repeat: 0 }); for (let i = 0; i < 3; i++) { const heart = this.add.sprite(25 + i * 20, 575, 'hearts'); heart.setScrollFactor(0); heart.setScale(1); heart.play('heart-full'); this.hearts.push(heart); } // Create level counter in top left this.levelText = this.add.text(20, 20, 'Level: 1', { fontSize: '24px', fill: '#fff', fontFamily: 'Arial' }).setScrollFactor(0).setDepth(100); // Create score text at the top right this.scoreText = this.add.text(780, 20, 'Score: 0', { fontSize: '24px', fill: '#fff', fontFamily: 'Arial' }).setOrigin(1, 0).setScrollFactor(0).setDepth(100); this.cameras.main.setBackgroundColor('#000000'); // Create background tiles for each cell for (let y = 0; y < this.gridSize; y++) { for (let x = 0; x < this.gridSize; x++) { this.add.sprite( this.startX + (x * this.cellSize) + this.cellSize / 2, this.startY + (y * this.cellSize) + this.cellSize / 2, 'castle', 15 // Using frame 15 for background ); } } this.anims.create({ key: 'tree-sway', frames: this.anims.generateFrameNumbers('tree', { start: 0, end: 3 }), frameRate: 8, repeat: -1 }); // Get tree positions let treePositions = []; for (let i = 0; i < this.gridSize; i++) { for (let j = 0; j < this.gridSize; j++) { if (i === 0 || i === this.gridSize - 1 || j === 0 || j === this.gridSize - 1) { treePositions.push({ x: this.startX + i * this.cellSize + this.cellSize / 2, y: this.startY + j * this.cellSize + this.cellSize / 2 }); } } } // Create health potion animation this.anims.create({ key: 'potion-full', frames: this.anims.generateFrameNumbers('health_potion', { start: 0, end: 4 }), frameRate: 8, repeat: -1 }); // Add health potion to a random interior cell const potionCell = this.getRandomInteriorCell(); const isFullPotion = Math.random() < 0.5; this.potion = this.physics.add.sprite( this.startX + (potionCell.x * this.cellSize) + this.cellSize / 2, this.startY + (potionCell.y * this.cellSize) + this.cellSize / 2, 'health_potion' ); if (isFullPotion) { this.potion.play('potion-full'); this.potion.isFullPotion = true; } else { this.potion.setFrame(5); this.potion.isFullPotion = false; } // Create orb animation this.anims.create({ key: 'orb-glow', frames: this.anims.generateFrameNumbers('orb', { start: 0, end: 5 }), frameRate: 8, repeat: -1 }); // Calculate number of elements based on current level // Calculate available cells (21x21 grid minus border trees) const totalInteriorCells = (this.gridSize - 2) * (this.gridSize - 2); // 19x19 = 361 interior cells // Calculate space taken by other props const fixedProps = 5; // torch, chest, cartridge, crab (3 parts), potion const enemySpace = 2; // player and cyplop starting positions // Calculate base number of orbs for this level const orbsPerLevel = 5; // Base number of orbs per level const desiredOrbCount = orbsPerLevel * this.playerState.level; // Calculate maximum possible orbs (available cells minus fixed props and enemies) const maxPossibleOrbs = totalInteriorCells - fixedProps - enemySpace; // Use the smaller of the two numbers const orbCount = Math.min(desiredOrbCount, maxPossibleOrbs); const potionCount = Math.min(Math.floor(2 + (this.playerState.level * 0.3)), 5); const chestCount = Math.min(Math.floor(1 + (this.playerState.level * 0.2)), 3); const cyplopCount = this.playerState.level; // Set number of cyplops equal to level const cartridgeCount = Math.min(Math.floor(1 + (this.playerState.level * 0.2)), 3); const crabCount = Math.min(Math.floor(1 + (this.playerState.level * 0.25)), 3); // Store total orbs for collection tracking this.totalOrbs = orbCount; // Add orbs to random interior cells this.orbs = this.physics.add.group(); for (let i = 0; i < orbCount; i++) { const orbCell = this.getRandomInteriorCell(); const orb = this.physics.add.sprite( this.startX + (orbCell.x * this.cellSize) + this.cellSize / 2, this.startY + (orbCell.y * this.cellSize) + this.cellSize / 2, 'orb' ); orb.play('orb-glow'); this.orbs.add(orb); } // Create chest sparkle animation this.anims.create({ key: 'chest-sparkle', frames: this.anims.generateFrameNumbers('chest', { start: 0, end: 2 }), frameRate: 6, repeat: -1 }); // Add chest to a random interior cell const chestCell = this.getRandomInteriorCell(); this.chest = this.physics.add.sprite( this.startX + (chestCell.x * this.cellSize) + this.cellSize / 2, this.startY + (chestCell.y * this.cellSize) + this.cellSize / 2, 'chest' ); this.chest.play('chest-sparkle'); // Create cartridge sprite and animation setup // Create the cartridge animation first this.anims.create({ key: 'cartridge-spin', frames: this.anims.generateFrameNumbers('cartridge', { frames: Array.from({ length: 61 }, (value, index) => index) }), frameRate: 10, repeat: -1 }); // Then create the sprite and play the animation const cartridgeCell = this.getRandomInteriorCell(); this.cartridge = this.physics.add.sprite( this.startX + (cartridgeCell.x * this.cellSize) + this.cellSize / 2, this.startY + (cartridgeCell.y * this.cellSize) + this.cellSize / 2, 'cartridge' ); // Center the sprite and start animation this.cartridge.setOffset(0.5, 0); this.cartridge.anims.play('cartridge-spin', true); // Create torch animation this.anims.create({ key: 'torch-flame', frames: this.anims.generateFrameNumbers('torch', { start: 0, end: 5 }), frameRate: 10, repeat: -1 }); // Add illumination graphics this.illumination = this.add.graphics(); // Add torch to a random interior cell const torchCell = this.getRandomInteriorCell(); this.torch = this.physics.add.sprite( this.startX + (torchCell.x * this.cellSize) + this.cellSize / 2, this.startY + (torchCell.y * this.cellSize) + this.cellSize / 2, 'torch' ); this.torch.play('torch-flame'); // Initialize key and door as null - they will be created after collecting all orbs this.silverKey = null; this.door = null; this.orbsCollected = 0; // totalOrbs will be set based on the orbCount calculated earlier this.levelText.setText('Level: ' + this.playerState.level); this.scoreText.setText('Score: ' + this.playerState.score); // Create crab animations this.anims.create({ key: 'crab-idle', frames: [{ key: 'red_crab', frame: 1 }, // center frame ], frameRate: 8, repeat: 0 }); // Add crab parts to a random interior cell const crabCell = this.getRandomInteriorCell(); // Reset crab arms state when creating new crab this.hasCrabArms = false; this.crabArms = null; this.crab = { leftClaw: this.physics.add.sprite( this.startX + ((crabCell.x - 1) * this.cellSize) + this.cellSize / 2, this.startY + (crabCell.y * this.cellSize) + this.cellSize / 2, 'red_crab' ), body: this.physics.add.sprite( this.startX + (crabCell.x * this.cellSize) + this.cellSize / 2, this.startY + (crabCell.y * this.cellSize) + this.cellSize / 2, 'red_crab' ), rightClaw: this.physics.add.sprite( this.startX + ((crabCell.x + 1) * this.cellSize) + this.cellSize / 2, this.startY + (crabCell.y * this.cellSize) + this.cellSize / 2, 'red_crab' ) }; // Set initial frames for each part this.crab.leftClaw.setFrame(0); // Left claw frame this.crab.body.setFrame(1); // Center frame this.crab.rightClaw.setFrame(2); // Right claw frame // Set up collision handling for each part this.crab.leftClaw.body.setSize(16, 16); this.crab.body.body.setSize(16, 16); this.crab.rightClaw.body.setSize(16, 16); // Initialize crab movement and animation state this.crab.state = { isWalking: false, nextMoveTime: this.time.now + 1000 + Math.random() * 2000, nextWalkTime: this.time.now + 3000 + Math.random() * 3000, currentRow: 0, lastAnimTime: this.time.now, animSpeed: 250, currentClaws: { left: 0, right: 0 }, direction: 1, isFlashing: false, walkDuration: 0, currentCell: { x: Math.floor((this.crab.body.x - this.startX) / this.cellSize), y: Math.floor((this.crab.body.y - this.startY) / this.cellSize) }, currentFrame: 0 }; // Initialize crab parts state this.crab.state.currentFrame = 0; // Add female muncher NPC next to the torch const npcCell = this.getNearbyCell(torchCell, 1); // Get cell 1 space away from torch this.npc = this.physics.add.sprite( this.startX + (npcCell.x * this.cellSize) + this.cellSize / 2, this.startY + (npcCell.y * this.cellSize) + this.cellSize / 2, 'muncher' ); // Set up proper physics for NPC this.npc.body.setCollideWorldBounds(true); this.npc.body.setBounce(0); this.npc.body.setDrag(1000); this.npc.body.setMaxVelocity(160, 160); this.npc.setDepth(1); // Create female muncher idle animation // Create female running animation this.anims.create({ key: 'female-run-right', frames: this.anims.generateFrameNumbers('muncher', { frames: [40, 41] }), frameRate: 8, repeat: -1 }); this.anims.create({ key: 'female-run-left', frames: this.anims.generateFrameNumbers('muncher', { frames: [56, 57] }), frameRate: 8, repeat: -1 }); // Create female idle animation this.anims.create({ key: 'female-idle-right', frames: this.anims.generateFrameNumbers('muncher', { frames: [32, 33, 34, 35, 36, 37, 38, 39] }), frameRate: 8, repeat: 0 }); this.anims.create({ key: 'female-idle-left', frames: this.anims.generateFrameNumbers('muncher', { frames: [48, 49, 50, 51, 52, 53, 54, 55] }), frameRate: 8, repeat: 0 // Play only once when triggered }); // Initialize NPC state this.npc.facing = 'right'; this.npc.setFrame(32); // Set initial standing frame (right-facing) this.npc.body.setImmovable(true); // Initialize NPC animation state this.npc.state = { nextIdleTime: this.time.now + 4000 + Math.random() * 12000, isAnimating: false, isNearPlayer: false, baseFrames: { right: 32, // First frame of right-facing idle left: 48 // First frame of left-facing idle }, lastInteractionTime: this.time.now, interactionCooldown: 1000 }; const playerStartCell = this.getRandomInteriorCell(); let enemyStartCell = this.getRandomInteriorCell(); while (enemyStartCell.x === playerStartCell.x && enemyStartCell.y === playerStartCell.y) { enemyStartCell = this.getRandomInteriorCell(); } this.player = this.physics.add.sprite( this.startX + (playerStartCell.x * this.cellSize) + this.cellSize / 2, this.startY + (playerStartCell.y * this.cellSize) + this.cellSize / 2, 'muncher', 0); this.player.setCollideWorldBounds(true); this.player.body.onWorldBounds = true; this.player.body.setCircle(6); this.player.body.setOffset(10, 10); // Create rolling hills before trees this.hills = this.add.group(); // Calculate starting position for the hills (above the top row of trees) const hillsY = this.startY - this.cellSize; // Add 16 hills across the top using frames 0-15 from the first row for (let i = 0; i < 16; i++) { const hillX = this.startX + i * this.cellSize; const hill = this.add.sprite(hillX + this.cellSize / 2, hillsY + this.cellSize / 2, 'map_features', i); this.hills.add(hill); } // Add stalactites below the bottom row of trees this.stalactites = this.physics.add.staticGroup(); // Stalactite frames are 68-71 (row 5 [4*16], frames 4-7 in a 0-based 16x6 grid) const stalactiteFrames = [68, 69, 70, 71]; // Get bottom row tree positions (y = gridSize - 1) for (let x = 0; x < this.gridSize; x++) { const stalactiteX = this.startX + x * this.cellSize + this.cellSize / 2; const stalactiteY = this.startY + this.gridSize * this.cellSize + this.cellSize / 2; // Randomly select one of the stalactite frames const frame = Phaser.Utils.Array.GetRandom(stalactiteFrames); const stalactite = this.stalactites.create(stalactiteX, stalactiteY, 'map_features', frame); stalactite.body.setSize(16, 16); } // Create trees after hills this.trees = this.physics.add.staticGroup(); treePositions.forEach(pos => { const tree = this.trees.create(pos.x, pos.y, 'tree'); tree.anims.play('tree-sway'); // Store grid position for wind calculations tree.gridX = Math.floor((pos.x - this.startX) / this.cellSize); tree.gridY = Math.floor((pos.y - this.startY) / this.cellSize); tree.windOffset = 0; // Individual tree wind offset tree.baseTimeScale = 0.2; // Base animation speed tree.body.setSize(16, 16); }); this.physics.add.collider(this.player, this.trees); this.physics.add.collider(this.player, this.stalactites); // Set up NPC physics but without collision this.npc.body.setImmovable(true); this.npc.body.isSensor = true; // Makes the body a sensor that detects overlap without collision this.anims.create({ key: 'cyplop-blink', frames: this.anims.generateFrameNumbers('cyplop', { frames: [9, 10, 11] }), frameRate: 8, repeat: 0 }); this.anims.create({ key: 'cyplop-defeat', frames: this.anims.generateFrameNumbers('cyplop', { frames: [12, 13, 14, 15, 16, 17] }), frameRate: 8, repeat: 0 }); this.anims.create({ key: 'cyplop-look-up-blink', frames: this.anims.generateFrameNumbers('cyplop', { frames: [18, 19, 20] }), frameRate: 8, repeat: 0 }); this.anims.create({ key: 'cyplop-look-down-blink', frames: this.anims.generateFrameNumbers('cyplop', { frames: [21, 22, 23] }), frameRate: 8, repeat: 0 }); // Get a random perimeter position (on trees) const perimeterPositions = []; for (let i = 0; i < this.gridSize; i++) { for (let j = 0; j < this.gridSize; j++) { if (i === 0 || i === this.gridSize - 1 || j === 0 || j === this.gridSize - 1) { perimeterPositions.push({ x: this.startX + i * this.cellSize + this.cellSize / 2, y: this.startY + j * this.cellSize + this.cellSize / 2 }); } } } // Select random perimeter position const randomPosition = Phaser.Utils.Array.GetRandom(perimeterPositions); // Create array to store multiple enemies this.enemies = []; // Spawn cyplops equal to current level for (let i = 0; i < cyplopCount; i++) { const randomPosition = Phaser.Utils.Array.GetRandom(perimeterPositions); const enemy = this.physics.add.sprite( randomPosition.x, randomPosition.y, 'cyplop' ); enemy.setFrame(4); enemy.body.setImmovable(true); enemy.body.isSensor = true; enemy.body.setCircle(6); enemy.body.setOffset(2, 2); enemy.state = { lastBlink: this.time.now, nextBlinkTime: 8000 + Math.random() * 8000, hasMovedOnce: false, // Track if cyplop has made its first move isFlashing: false, lastFlashTime: 0, isMoving: false, moveTimer: 0, timerText: this.add.text(0, 0, '', { fontSize: '12px', fill: '#ffffff', align: 'center', backgroundColor: '#000000', padding: { x: 2, y: 2 }, visible: false }), currentCell: { x: enemyStartCell.x, y: enemyStartCell.y }, targetCell: null, nextMoveTime: this.time.now + 4000 + Math.random() * 4000 }; this.physics.add.collider(enemy, this.trees); this.physics.add.overlap(enemy, this.player, this.handlePlayerEnemyCollision, null, this); this.physics.add.overlap(enemy, this.npc, this.handleCyplopNpcCollision, null, this); // Add enemy to array this.enemies.push(enemy); // Add overlap with torch this.physics.add.overlap(enemy, this.torch, this.handleCyplopTorchCollision, null, this); } // Add crab collision handlers this.physics.add.overlap(this.player, this.crab.leftClaw, this.handleCrabClawCollision, this.checkCollisionState, this); this.physics.add.overlap(this.player, this.crab.rightClaw, this.handleCrabClawCollision, this.checkCollisionState, this); this.physics.add.overlap(this.player, this.crab.body, this.handleCrabBodyCollision, this.checkCollisionState, this); // Add crab claws vs cyplop collision handlers this.physics.add.overlap(this.crab.leftClaw, this.enemies, this.handleCrabClawCyplopCollision, null, this); this.physics.add.overlap(this.crab.rightClaw, this.enemies, this.handleCrabClawCyplopCollision, null, this); // Add overlap handlers for props (collectible items) this.physics.add.overlap(this.player, this.cartridge, this.handleCartridgeCollect, null, this); this.physics.add.overlap(this.player, this.potion, this.handlePotionCollect, null, this); this.physics.add.overlap(this.player, this.chest, this.handleChestCollect, null, this); this.physics.add.overlap(this.player, this.torch, this.handleTorchCollect, null, this); this.physics.add.overlap(this.player, this.orbs, this.handleOrbCollect, null, this); this.anims.create({ key: 'idle-right', frames: this.anims.generateFrameNumbers('muncher', { frames: [0, 1, 2, 3, 4, 5, 6, 7] }), frameRate: 8, repeat: -1 }); this.anims.create({ key: 'idle-left', frames: this.anims.generateFrameNumbers('muncher', { frames: [16, 17, 18, 19, 20, 21, 22, 23] }), frameRate: 8, repeat: -1 }); this.anims.create({ key: 'walk-right', frames: this.anims.generateFrameNumbers('muncher', { frames: [8, 9, 8, 9] }), frameRate: 2, repeat: -1 }); this.anims.create({ key: 'walk-left', frames: this.anims.generateFrameNumbers('muncher', { frames: [24, 25, 24, 25] }), frameRate: 2, repeat: -1 }); this.anims.create({ key: 'crouch-right', frames: this.anims.generateFrameNumbers('muncher', { frames: [10, 11] }), frameRate: 4, repeat: -1 }); this.anims.create({ key: 'crouch-left', frames: this.anims.generateFrameNumbers('muncher', { frames: [26, 27] }), frameRate: 4, repeat: -1 }); this.anims.create({ key: 'look-up-right', frames: [{ key: 'muncher', frame: 12 }], frameRate: 1 }); this.anims.create({ key: 'look-down-right', frames: [{ key: 'muncher', frame: 13 }], frameRate: 1 }); this.anims.create({ key: 'look-right', frames: [{ key: 'muncher', frame: 14 }], frameRate: 1 }); this.anims.create({ key: 'look-left-from-right', frames: [{ key: 'muncher', frame: 15 }], frameRate: 1 }); this.anims.create({ key: 'munch-right', frames: [{ key: 'muncher', frame: 1 }], frameRate: 1 }); this.anims.create({ key: 'munch-left', frames: [{ key: 'muncher', frame: 17 }], frameRate: 1 }); this.keys = { up: this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.W), down: this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.S), left: this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.A), right: this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.D), munch: this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.SPACE) }; if (this.textures.exists('muncher')) { this.player.play('idle-right'); } this.gameOverText = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY, 'Game Over\nPress Any Key', { fontSize: '48px', fill: '#fff', align: 'center', strokeThickness: 4, stroke: '#000000' }).setOrigin(0.5).setVisible(false).setDepth(1000); this.input.keyboard.on('keydown', this.handleRestart, this); this.input.keyboard.on('keydown-T', this.handleToggleText, this); } checkCollisionState(player, target) { return !player.isRecovering && !this.gameOver; } handleRestart() { if (this.gameOver && !this.inputDisabled) { // Stop existing BGM if it's playing const bgm = this.sound.get('bgm'); if (bgm) { bgm.stop(); } this.gameOver = false; // Reset rate before restarting scene if (bgm) { bgm.rate = 1.0; } // Set a flag in the registry to indicate we need to start BGM this.registry.set('startBGM', true); this.scene.restart(); } } handleToggleText() { this.debug = !this.debug; // Update timer text visibility for all enemies this.enemies.forEach(enemy => { if (enemy && enemy.state && enemy.state.timerText) { enemy.state.timerText.visible = this.debug; } }); } damageHeart(index) { if (index >= 0 && index < this.hearts.length) { this.hearts[index].visible = false; } } healHeart(index) { if (index >= 0 && index < this.hearts.length) { this.hearts[index].visible = true; this.hearts[index].play('heart-full'); } } getRandomNonCornerPerimeterCell() { const gridSize = this.gridSize; const side = Math.floor(Math.random() * 4); let x, y; do { switch (side) { case 0: // Top x = Math.floor(Math.random() * (gridSize - 2)) + 1; y = 1; break; case 1: // Right x = gridSize - 2; y = Math.floor(Math.random() * (gridSize - 2)) + 1; break; case 2: // Bottom x = Math.floor(Math.random() * (gridSize - 2)) + 1; y = gridSize - 2; break; case 3: // Left x = 1; y = Math.floor(Math.random() * (gridSize - 2)) + 1; break; } } while ((x === 1 && y === 1) || // Top-left corner (x === gridSize - 2 && y === 1) || // Top-right corner (x === 1 && y === gridSize - 2) || // Bottom-left corner (x === gridSize - 2 && y === gridSize - 2)); // Bottom-right corner return { x, y }; } getNearbyCell(baseCell, distance) { // Try to find an empty cell near the base cell const directions = [{ x: distance, y: 0 }, // right { x: -distance, y: 0 }, // left { x: 0, y: distance }, // down { x: 0, y: -distance } // up ]; // Shuffle directions for randomness for (let i = directions.length - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [directions[i], directions[j]] = [directions[j], directions[i]]; } // Try each direction until we find a valid cell for (const dir of directions) { const newX = baseCell.x + dir.x; const newY = baseCell.y + dir.y; // Check if cell is within interior bounds if (newX > 0 && newX < this.gridSize - 1 && newY > 0 && newY < this.gridSize - 1) { return { x: newX, y: newY }; } } // If no valid cell found, return the original cell return baseCell; } getGridPosition(sprite) { return { x: Math.floor((sprite.x - this.startX) / this.cellSize), y: Math.floor((sprite.y - this.startY) / this.cellSize) }; } getCellCenter(gridX, gridY) { return { x: this.startX + (gridX * this.cellSize) + (this.cellSize / 2), y: this.startY + (gridY * this.cellSize) + (this.cellSize / 2) }; } getManhattanDistance(pos1, pos2) { return Math.abs(pos1.x - pos2.x) + Math.abs(pos1.y - pos2.y); } getRandomInteriorCell() { const gridSize = this.gridSize; const x = Math.floor(Math.random() * (gridSize - 2)) + 1; const y = Math.floor(Math.random() * (gridSize - 2)) + 1; return { x, y }; } handlePlayerEnemyCollision(player, enemy) { if (!enemy.isDefeated && !this.player.isInvulnerable && !this.gameOver) { // Set input disabled flag this.inputDisabled = true; this.sound.play('hit'); const damagedHeartIndex = this.health - 1; // Play heart breaking animation if (this.hearts[damagedHeartIndex]) { this.hearts[damagedHeartIndex].play('heart-break'); this.hearts[damagedHeartIndex].once('animationcomplete', () => { this.damageHeart(damagedHeartIndex); }); } this.health--; this.player.isInvulnerable = true; this.player.alpha = 0.5; // Remove crab arms if player has them if (this.hasCrabArms && this.crabArms) { this.crabArms.visual.left.destroy(); this.crabArms.visual.right.destroy(); this.crabArms.hitbox.destroy(); this.hasCrabArms = false; this.crabArms = null; } this.time.delayedCall(1500, () => { this.player.isInvulnerable = false; this.player.alpha = 1; }); if (this.health <= 0) { this.gameOver = true; this.player.setVelocity(0, 0); // Immediately start slowing down background music const bgm = this.sound.get('bgm'); if (bgm) { bgm.rate = 1.0; // Reset rate first this.tweens.add({ targets: bgm, rate: 0.5, volume: 0, duration: 2000, ease: 'Linear', onComplete: () => { bgm.stop(); this.sound.play('gameover'); } }); } // Show game over text with scale animation after a shorter delay this.time.delayedCall(2000, () => { this.inputDisabled = false; this.gameOverText.setVisible(true); this.gameOverText.setScale(0); this.tweens.add({ targets: this.gameOverText, scale: { from: 0, to: 1 }, duration: 1000, ease: 'Back.easeOut' }); }); // Select a random grave marker frame from map_features const graveFrames = [24, 25, 26, 40, 41, 42]; // Grave marker frames // Select a random frame from the array const randomFrame = Phaser.Utils.Array.GetRandom(graveFrames); // Transform player sprite into gravestone and ensure no animations play this.player.anims.stop(); this.player.setTexture('map_features', randomFrame); this.player.setVelocity(0, 0); this.player.body.immovable = true; this.player.alpha = 1; // Ensure grave is fully visible this.player.anims.stop(); this.player.anims.play = function() {}; // Prevent any new animations from playing this.player.play = function() {}; // Also override the sprite's play method // Make all cyplops fly away this.enemies.forEach((enemy, index) => { if (enemy && enemy.active) { // Different angles for each cyplop const angle = (index * Math.PI / this.enemies.length) - (Math.PI / 4); const speed = 300; enemy.setVelocity( Math.cos(angle) * speed, Math.sin(angle) * speed ); // Disable physics interactions enemy.body.checkCollision.none = true; } }); // Stop NPC movement if (this.npc) { this.npc.setVelocity(0, 0); this.npc.body.immovable = true; } } } } handleCyplopNpcCollision(enemy, npc) { if (!enemy.isDefeated && !this.gameOver) { this.gameOver = true; // Set game over state this.gameOverText.setText('Game Over\nPress Any Key'); this.gameOverText.setVisible(true); // Slow down background music over 2 seconds then play game over sound const bgm = this.sound.get('bgm'); if (bgm) { this.tweens.add({ targets: bgm, rate: 0.5, // Slow down to half speed volume: 0, duration: 2000, onComplete: () => { bgm.stop(); this.sound.play('gameover'); } }); } // Stop player movement and turn into gravestone this.player.setVelocity(0, 0); const graveFrames = [24, 25, 26, 40, 41, 42]; // Grave marker frames this.player.setTexture('map_features', Phaser.Utils.Array.GetRandom(graveFrames)); this.player.body.immovable = true; this.player.alpha = 1; // Ensure grave is fully visible this.player.anims.stop(); this.player.anims.play = function() {}; // Prevent any new animations from playing this.player.play = function() {}; // Also override the sprite's play method // Make cyplop run off screen const angle = Math.atan2(-enemy.y, 800 - enemy.x); const speed = 200; enemy.setVelocity(Math.cos(angle) * speed, Math.sin(angle) * speed); // Play blocking sound once if (!enemy.hasPlayedBlockingSound) { this.sound.play('blocking'); enemy.hasPlayedBlockingSound = true; } // Attach torch to cyplop if it exists if (this.torch) { this.torch.isAttached = true; this.torch.attachedToCyplop = true; this.torch.attachedCyplop = enemy; } // Make NPC follow the cyplop this.npc.followTarget = enemy; this.npc.followSpeed = 180; // Slightly slower than cyplop } } handleCyplopTorchCollision(enemy, torch) { // Only proceed if the cyplop isn't defeated and game isn't over if (!enemy.isDefeated && !this.gameOver) { this.gameOver = true; // Slow down background music over 2 seconds then play game over sound const bgm = this.sound.get('bgm'); if (bgm) { this.tweens.add({ targets: bgm, rate: 0.5, // Slow down to half speed volume: 0, duration: 2000, onComplete: () => { bgm.stop(); this.sound.play('gameover'); } }); } // If torch is attached to player or NPC, detach it if (torch.isAttached) { torch.isAttached = false; } // Stop player movement and turn into gravestone this.player.setVelocity(0, 0); this.player.setFrame(Phaser.Math.RND.pick([25, 26, 27, 40, 41, 42])); this.player.body.immovable = true; // Show game over text this.gameOverText.setText('Game Over\nPress Any Key'); this.gameOverText.setVisible(true); // Make cyplop run off screen const angle = Math.atan2(-enemy.y, 800 - enemy.x); const speed = 200; enemy.setVelocity(Math.cos(angle) * speed, Math.sin(angle) * speed); // Attach torch to cyplop and update its properties torch.attachedToCyplop = true; torch.attachedCyplop = enemy; torch.setDepth(enemy.depth + 1); // Disable physics on the torch since it will follow the cyplop if (torch.body) { torch.body.enable = false; } // Make the torch follow the cyplop's position torch.setPosition(enemy.x, enemy.y); } } handleChestCollect(player, chest) { if (this.playerState.isMunching && this.time.now - this.playerState.munchStartTime < this.playerState.munchDuration) { this.playerState.score += 50; this.scoreText.setText('Score: ' + this.playerState.score); chest.destroy(); } } handleOrbCollect(player, orb) { if (this.playerState.isMunching && this.time.now - this.playerState.munchStartTime < this.playerState.munchDuration) { this.sound.play('coin'); this.playerState.score += 10; this.scoreText.setText('Score: ' + this.playerState.score); orb.destroy(); // Increment orbs collected counter this.orbsCollected++; // If all orbs are collected, spawn the key and door if (this.orbsCollected === this.totalOrbs) { // Create the key const keyCell = this.getRandomInteriorCell(); this.silverKey = this.physics.add.sprite( this.startX + (keyCell.x * this.cellSize) + this.cellSize / 2, this.startY + (keyCell.y * this.cellSize) + this.cellSize / 2, 'silver_key' ); // Play win sound when key appears this.sound.play('win'); this.silverKey.isAttached = false; // Create the door const doorCell = this.getRandomNonCornerPerimeterCell(); this.door = this.physics.add.sprite( this.startX + (doorCell.x * this.cellSize) + this.cellSize / 2, this.startY + (doorCell.y * this.cellSize) + this.cellSize / 2, 'castle', 21 // Using frame 21 for locked door ); this.door.body.immovable = true; this.physics.add.overlap(this.player, this.door, this.handleDoorInteraction, null, this); // Add collision handlers for the key and door this.physics.add.overlap(this.player, this.silverKey, this.handleKeyCollect, null, this); this.physics.add.overlap(this.player, this.door, this.handleDoorInteraction, null, this); } } } handleCartridgeCollect(player, cartridge) { if (this.playerState.isMunching && this.time.now - this.playerState.munchStartTime < this.playerState.munchDuration) { this.playerState.score += 10; this.scoreText.setText('Score: ' + this.playerState.score); cartridge.destroy(); } } handlePotionCollect(player, potion) { // Only collect if munching and health isn't full if (this.playerState.isMunching && this.time.now - this.playerState.munchStartTime < this.playerState.munchDuration && this.health < 3) { if (potion.isFullPotion) { // Full potion: Restore all hearts while (this.health < 3) { this.healHeart(this.health); this.health++; } } else { // Half potion: Restore exactly one heart this.healHeart(this.health); this.health++; } potion.destroy(); } } handleCrabClawCollision(player, claw) { if (!player.isInvulnerable) { this.sound.play('hit'); const damagedHeartIndex = this.health - 1; // Play heart breaking animation if (this.hearts[damagedHeartIndex]) { this.hearts[damagedHeartIndex].play('heart-break'); this.hearts[damagedHeartIndex].once('animationcomplete', () => { this.damageHeart(damagedHeartIndex); }); } this.health--; player.isInvulnerable = true; player.alpha = 0.5; this.time.delayedCall(1500, () => { player.isInvulnerable = false; player.alpha = 1; }); if (this.health <= 0) { this.gameOver = true; this.gameOverText.setVisible(true); player.setVelocity(0, 0); player.setAlpha(0.25); // Slow down background music const bgm = this.sound.get('bgm'); if (bgm) { this.tweens.add({ targets: bgm, rate: 0.5, volume: 0, duration: 2000, onComplete: () => { bgm.stop(); this.sound.play('gameover'); } }); } } } } handleCrabBodyCollision(player, body) { // Check if player is munching and is within the munch duration window if (this.playerState.isMunching && this.time.now - this.playerState.munchStartTime < this.playerState.munchDuration && !this.hasCrabArms && this.crab && body.active) { // Play jump sound when munching crab this.sound.play('jump'); // Create crab arms for the player with immediate effect this.hasCrabArms = true; // Create crab arms with proper positioning and cropping this.crabArms = { visual: { left: this.add.sprite(player.x - 16, player.y, 'red_crab') .setOrigin(0.5) .setFrame(0) // Left claw frame .setDepth(player.depth + 1), right: this.add.sprite(player.x + 16, player.y, 'red_crab') .setOrigin(0.5) .setFrame(2) // Right claw frame .setDepth(player.depth + 1) }, hitbox: this.physics.add.sprite(player.x, player.y, null) .setOrigin(0.5) .setVisible(false) }; // Set up the single collision body this.crabArms.hitbox.body.setSize(48, 16); this.crabArms.hitbox.body.enable = true; // Add collision with cyplop and set up crab arms state this.physics.add.overlap(this.crabArms.hitbox, this.enemies, this.handleCrabClawCyplopCollision, null, this); this.crabArms.state = { lastAnimTime: this.time.now, leftClaw: { frame: 0, nextUpdate: this.time.now }, rightClaw: { frame: 2, nextUpdate: this.time.now }, animSpeed: 250 }; // Destroy all parts of the original crab if (this.crab.leftClaw && this.crab.leftClaw.active) this.crab.leftClaw.destroy(); if (this.crab.body && this.crab.body.active) this.crab.body.destroy(); if (this.crab.rightClaw && this.crab.rightClaw.active) this.crab.rightClaw.destroy(); // Initialize animation immediately if (this.time) { this.crabArms.state = { lastAnimTime: this.time.now, leftClaw: { frame: 0, nextUpdate: this.time.now }, rightClaw: { frame: 2, nextUpdate: this.time.now }, animSpeed: 250 }; } } } handleTorchCollect(player, torch) { // Don't allow collection if torch is attached to cyplop if (torch.attachedToCyplop) return; // Play thruster sound if torch is attached and being held if (torch.isAttached && this.keys.munch.isDown) { if (!this.thrusterSound.isPlaying) { this.thrusterSound.play(); } } else { this.thrusterSound.stop(); } // Get current cell positions const playerCellX = Math.floor((player.x - this.startX) / this.cellSize); const playerCellY = Math.floor((player.y - this.startY) / this.cellSize); const torchCellX = Math.floor((torch.x - this.startX) / this.cellSize); const torchCellY = Math.floor((torch.y - this.startY) / this.cellSize); if (!this.keys.munch.isDown && torch.isAttached) { // Play torch sound when dropping torch this.sound.play('torch'); // Drop torch if space is not held and torch is currently attached const centerX = this.startX + (playerCellX * this.cellSize) + (this.cellSize / 2); const centerY = this.startY + (playerCellY * this.cellSize) + (this.cellSize / 2); torch.isAttached = false; torch.setPosition(centerX, centerY); torch.setDepth(0); if (torch.body) { torch.body.enable = true; } } else if (this.keys.munch.isDown) { // Pick up or keep holding the torch when space is held if (!torch.isAttached && playerCellX === torchCellX && playerCellY === torchCellY) { // Play torch sound when picking up torch this.sound.play('torch'); torch.isAttached = true; } if (torch.isAttached) { torch.setDepth(player.depth + 1); } } } handleKeyCollect(player, key) { // Get current cell positions const playerCellX = Math.floor((player.x - this.startX) / this.cellSize); const playerCellY = Math.floor((player.y - this.startY) / this.cellSize); const keyCellX = Math.floor((key.x - this.startX) / this.cellSize); const keyCellY = Math.floor((key.y - this.startY) / this.cellSize); if (!this.keys.munch.isDown && key.isAttached) { // Drop key if space is not held and key is currently attached const centerX = this.startX + (playerCellX * this.cellSize) + (this.cellSize / 2); const centerY = this.startY + (playerCellY * this.cellSize) + (this.cellSize / 2); key.isAttached = false; this.playerState.hasKey = false; key.setPosition(centerX, centerY); key.setDepth(1); // Set key depth above the door if (key.body) { key.body.enable = true; } } else if (this.keys.munch.isDown) { // Pick up or keep holding the key when space is held if (!key.isAttached && playerCellX === keyCellX && playerCellY === keyCellY) { key.isAttached = true; this.playerState.hasKey = true; } if (key.isAttached) { key.setDepth(player.depth + 1); } } } handleDoorInteraction(player, door) { if (!this.npc || !this.silverKey) return; // Get door and NPC positions const doorCellX = Math.floor((door.x - this.startX) / this.cellSize); const doorCellY = Math.floor((door.y - this.startY) / this.cellSize); const npcCellX = Math.floor((this.npc.x - this.startX) / this.cellSize); const npcCellY = Math.floor((this.npc.y - this.startY) / this.cellSize); const playerCellX = Math.floor((player.x - this.startX) / this.cellSize); const playerCellY = Math.floor((player.y - this.startY) / this.cellSize); // Calculate Manhattan distance between door and NPC const npcToDoorDistance = Math.abs(doorCellX - npcCellX) + Math.abs(doorCellY - npcCellY); // Calculate Manhattan distance between player and door const playerToDoorDistance = Math.abs(doorCellX - playerCellX) + Math.abs(doorCellY - playerCellY); // Check conditions: // 1. Player has key and it's attached // 2. Player is at the door (distance <= 1) // 3. NPC is within 2 cells of the door if (this.playerState.hasKey && this.silverKey.isAttached && playerToDoorDistance <= 1 && npcToDoorDistance <= 2) { // Play unlock sound and change door frame this.sound.play('unlock'); this.door.setFrame(20); // Using frame 20 for unlocked door // Add points this.playerState.score += 100; this.scoreText.setText('Score: ' + this.playerState.score); // Wait a moment to show the unlocked door before destroying it this.time.delayedCall(500, () => { door.destroy(); }); // Pause all movement this.playerState.isPaused = true; if (this.player && this.player.body) this.player.setVelocity(0, 0); if (this.enemy && this.enemy.body) this.enemy.setVelocity(0, 0); if (this.npc && this.npc.body) this.npc.setVelocity(0, 0); // Destroy the key as well since it's been used this.silverKey.destroy(); this.playerState.hasKey = false; // Level completion logic this.playerState.level++; // Show level completion message const levelText = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY, `Level ${this.playerState.level - 1} Complete!\nNext Level Starting...`, { fontSize: '32px', fill: '#fff', align: 'center' }).setOrigin(0.5); // Wait 2 seconds then start next level this.time.delayedCall(2000, () => { levelText.destroy(); // Preserve score and level, but restart scene const currentScore = this.playerState.score; const currentLevel = this.playerState.level; // Store the values we want to preserve this.registry.set('score', currentScore); this.registry.set('level', currentLevel); // Keep isPaused true when storing it this.registry.set('isPaused', true); // Restart the scene this.scene.restart(); }); } } handleCrabClawCyplopCollision(hitboxOrClaw, cyplop) { if (!cyplop.isDefeated && this.hasCrabArms) { cyplop.isDefeated = true; cyplop.body.enable = false; // Disable physics immediately // Play charge-up sound once this.sound.play('charge-up'); // Add points for defeating cyplop with crab claws this.playerState.score += 250; this.scoreText.setText('Score: ' + this.playerState.score); cyplop.play('cyplop-defeat').once('animationcomplete', () => { cyplop.destroy(); }); // Remove from enemies array const index = this.enemies.indexOf(cyplop); if (index > -1) { this.enemies.splice(index, 1); } } } updateEnemyBehavior() { // Don't update if game is over if (this.gameOver) return; // Update behavior for each enemy this.enemies.forEach(enemy => { if (!enemy || !enemy.active) return; const state = enemy.state; const currentTime = this.time.now; if (this.debug) { const textY = enemy.y - 72; state.timerText.setPosition(enemy.x - state.timerText.width / 2, textY); const timeUntilMove = Math.max(0, (state.nextMoveTime - currentTime) / 1000).toFixed(1); const blinkTime = Math.max(0, (state.nextBlinkTime - (currentTime - state.lastBlink)) / 1000).toFixed(1); state.timerText.setText(`Move: ${timeUntilMove}s\nBlink: ${blinkTime}s`); } const dx = this.player.x - enemy.x; const dy = this.player.y - enemy.y; const threshold = 8; if (enemy && enemy.active) { let currentFrame; if (!enemy.anims || !enemy.anims.isPlaying) { currentFrame = this.getDirectionFrame(dx, dy, threshold); enemy.setFrame(currentFrame); } // Get current frame if it wasn't set above if (typeof currentFrame === 'undefined') { currentFrame = enemy.frame.name; } switch (currentFrame) { case 5: state.moveDir = { x: 1, y: 0 }; break; case 8: state.moveDir = { x: 1, y: 1 }; break; case 7: state.moveDir = { x: 0, y: 1 }; break; case 6: state.moveDir = { x: -1, y: 1 }; break; case 3: state.moveDir = { x: -1, y: 0 }; break; case 0: state.moveDir = { x: -1, y: -1 }; break; case 1: state.moveDir = { x: 0, y: -1 }; break; case 2: state.moveDir = { x: 1, y: -1 }; break; default: state.moveDir = { x: 0, y: 0 }; } } if (currentTime - state.lastBlink > state.nextBlinkTime && !state.isMoving) { if (enemy && enemy.active && enemy.anims) { if (!enemy.anims.isPlaying) { enemy.play('cyplop-blink').once('animationcomplete', () => { const frame = this.getDirectionFrame(dx, dy); enemy.setFrame(frame); }); } state.lastBlink = currentTime; state.nextBlinkTime = 8000 + Math.random() * 8000; } } // Check timing for yellow flashes const timeUntilMove = state.nextMoveTime - currentTime; if (timeUntilMove <= 250 && timeUntilMove > 50 && !state.isFlashing) { state.isFlashing = true; enemy.alpha = 0; // First appear after vanish this.time.delayedCall(50, () => { enemy.alpha = 1; enemy.setTint(0xffff00); // First yellow flash ends this.time.delayedCall(50, () => { enemy.clearTint(); enemy.alpha = 0; // Second appear this.time.delayedCall(50, () => { enemy.alpha = 1; enemy.setTint(0xffff00); // Final return to normal this.time.delayedCall(50, () => { enemy.clearTint(); state.isFlashing = false; }); }); }); }); } if (currentTime > state.nextMoveTime && !state.isMoving) { // Play sound on first move if (!state.hasMovedOnce) { this.sound.play('charmed'); state.hasMovedOnce = true; } const currentX = Math.floor((enemy.x - this.startX) / this.cellSize); const currentY = Math.floor((enemy.y - this.startY) / this.cellSize); state.currentCell = { x: currentX, y: currentY }; const playerCellX = Math.floor((this.player.x - this.startX) / this.cellSize); const playerCellY = Math.floor((this.player.y - this.startY) / this.cellSize); let newX = currentX; let newY = currentY; if (playerCellX > currentX) { newX++; } else if (playerCellX < currentX) { newX--; } if (playerCellY > currentY) { newY++; } else if (playerCellY < currentY) { newY--; } // Check if the target cell is valid and not occupied by another cyplop let isCellOccupied = false; if (newX > 0 && newX < this.gridSize - 1 && newY > 0 && newY < this.gridSize - 1) { // Check if any other cyplop is in or moving to this cell this.enemies.forEach(otherEnemy => { if (otherEnemy !== enemy && otherEnemy.active) { const otherState = otherEnemy.state; const otherTargetCell = otherState.targetCell || { x: Math.floor((otherEnemy.x - this.startX) / this.cellSize), y: Math.floor((otherEnemy.y - this.startY) / this.cellSize) }; if (otherTargetCell.x === newX && otherTargetCell.y === newY) { isCellOccupied = true; } } }); if (!isCellOccupied) { state.targetCell = { x: newX, y: newY }; state.isMoving = true; } else { // If cell is occupied, try to move one more cell in the same direction const nextX = newX + (newX - currentX); const nextY = newY + (newY - currentY); if (nextX > 0 && nextX < this.gridSize - 1 && nextY > 0 && nextY < this.gridSize - 1) { // Check if the next cell is also occupied let isNextCellOccupied = false; this.enemies.forEach(otherEnemy => { if (otherEnemy !== enemy && otherEnemy.active) { const otherState = otherEnemy.state; const otherTargetCell = otherState.targetCell || { x: Math.floor((otherEnemy.x - this.startX) / this.cellSize), y: Math.floor((otherEnemy.y - this.startY) / this.cellSize) }; if (otherTargetCell.x === nextX && otherTargetCell.y === nextY) { isNextCellOccupied = true; } } }); if (!isNextCellOccupied) { state.targetCell = { x: nextX, y: nextY }; state.isMoving = true; } } } } state.nextMoveTime = currentTime + 4000 + Math.random() * 4000; } if (state.isMoving && enemy && enemy.active && enemy.body) { const targetX = this.startX + state.targetCell.x * this.cellSize + this.cellSize / 2; const targetY = this.startY + state.targetCell.y * this.cellSize + this.cellSize / 2; const dx = targetX - enemy.x; const dy = targetY - enemy.y; const distance = Math.sqrt(dx * dx + dy * dy); const speed = 100; if (distance > 1) { if (enemy && enemy.active && enemy.body) { const normalizedDx = dx / distance; const normalizedDy = dy / distance; enemy.setVelocity(normalizedDx * speed, normalizedDy * speed); } } else { if (enemy && enemy.active && enemy.body) { enemy.setVelocity(0, 0); } enemy.setPosition(targetX, targetY); state.currentCell = { ...state.targetCell }; state.targetCell = null; state.isMoving = false; } } }); } getDirectionFrame(dx, dy, threshold) { const angle = Math.atan2(dy, dx); const degrees = Phaser.Math.RadToDeg(angle); if (degrees >= -22.5 && degrees <= 22.5) return 5; if (degrees > 22.5 && degrees <= 67.5) return 8; if (degrees > 67.5 && degrees <= 112.5) return 7; if (degrees > 112.5 && degrees <= 157.5) return 6; if (degrees > 157.5 || degrees <= -157.5) return 3; if (degrees > -157.5 && degrees <= -112.5) return 0; if (degrees > -112.5 && degrees <= -67.5) return 1; if (degrees > -67.5 && degrees <= -22.5) return 2; return 4; } update() { if (this.gameOver || this.playerState.isPaused) { return; } // Update background parallax with precise position tracking if (!this.backgroundPos) { this.backgroundPos = { x: 0, y: 0 }; } // Use sine wave for x-axis movement this.backgroundPos.x = Math.sin(this.time.now / 2000) * 100; // Slower, wider movement this.backgroundPos.y -= 0.27 * this.game.loop.delta / 16; // Apply tracked positions to tile sprite this.background.tilePositionX = Math.round(this.backgroundPos.x * 100) / 100; this.background.tilePositionY = Math.round(this.backgroundPos.y * 100) / 100; const speed = this.playerState.movement.isRecovering ? 80 : 160; // Handle recovery state if (this.playerState.movement.isRecovering) { if (this.time.now > this.playerState.movement.recoveryEndTime) { this.playerState.movement.isRecovering = false; this.player.alpha = 1; } else { this.player.alpha = 0.6 + (Math.sin(this.time.now / 100) * 0.4); } } // Only process new movement if we're not already moving if (!this.playerState.movement.isGridMoving) { this.playerState.movement.moveX = 0; this.playerState.movement.moveY = 0; // Simplified movement priority system const horizontal = this.keys.left.isDown || this.keys.right.isDown; const vertical = this.keys.up.isDown || this.keys.down.isDown; if (horizontal && vertical) { // Alternate between horizontal and vertical movement const shouldMoveVertical = this.time.now % 400 >= 200; if (shouldMoveVertical) { if (this.keys.up.isDown) { this.playerState.movement.moveY = -1; } else if (this.keys.down.isDown) { this.playerState.movement.moveY = 1; } } else { if (this.keys.left.isDown) { this.playerState.movement.moveX = -1; this.playerState.facing = 'left'; } else if (this.keys.right.isDown) { this.playerState.movement.moveX = 1; this.playerState.facing = 'right'; } } } else { // Normal cardinal direction movement if (this.keys.left.isDown) { this.playerState.movement.moveX = -1; this.playerState.facing = 'left'; } else if (this.keys.right.isDown) { this.playerState.movement.moveX = 1; this.playerState.facing = 'right'; } if (this.keys.up.isDown) { this.playerState.movement.moveY = -1; } else if (this.keys.down.isDown) { this.playerState.movement.moveY = 1; } } // If we have movement input, set the target position if (this.playerState.movement.moveX !== 0 || this.playerState.movement.moveY !== 0) { // Calculate the next grid position // Use exact pixel positions instead of grid calculations const currentCellX = Math.floor((this.player.x - this.startX) / this.cellSize); const currentCellY = Math.floor((this.player.y - this.startY) / this.cellSize); const nextCellX = currentCellX + this.playerState.movement.moveX; const nextCellY = currentCellY + this.playerState.movement.moveY; const nextX = this.startX + (nextCellX * this.cellSize) + (this.cellSize / 2); const nextY = this.startY + (nextCellY * this.cellSize) + (this.cellSize / 2); // Convert to grid coordinates to check bounds // Use the already calculated nextCellX and nextCellY for bounds checking const nextGridX = nextCellX; const nextGridY = nextCellY; // Check if the next position is within bounds and not blocked by trees let canMove = true; this.trees.children.iterate((tree) => { const treeCellX = Math.floor((tree.x - this.startX) / this.cellSize); const treeCellY = Math.floor((tree.y - this.startY) / this.cellSize); if (treeCellX === nextGridX && treeCellY === nextGridY) { canMove = false; return false; // Exit iteration } }); if (nextGridX > 0 && nextGridX < this.gridSize - 1 && nextGridY > 0 && nextGridY < this.gridSize - 1 && canMove) { this.playerState.movement.targetX = nextX; this.playerState.movement.targetY = nextY; this.playerState.movement.isGridMoving = true; this.playerState.movement.isMoving = true; // Always play the walking animation when starting grid movement const targetAnim = `walk-${this.playerState.facing}`; this.player.play(targetAnim, true); } } } // If we're moving to a target position if (this.playerState.movement.isGridMoving && this.playerState.movement.targetX !== null && this.playerState.movement.targetY !== null) { const dx = this.playerState.movement.targetX - this.player.x; const dy = this.playerState.movement.targetY - this.player.y; const distance = Math.sqrt(dx * dx + dy * dy); // Check for props to munch while moving if (this.keys.munch.isDown) { this.playerState.isMunching = true; this.playerState.munchStartTime = this.time.now; // Check each active orb this.orbs.children.iterate(orb => { if (orb && orb.active) { const orbDist = Phaser.Math.Distance.Between(this.player.x, this.player.y, orb.x, orb.y); if (orbDist < this.cellSize / 2) { this.handleOrbCollect(this.player, orb); } } }); // Check distance to potion if (this.potion && this.potion.active) { const potionDist = Phaser.Math.Distance.Between(this.player.x, this.player.y, this.potion.x, this.potion.y); if (potionDist < this.cellSize / 2) { this.handlePotionCollect(this.player, this.potion); } } // Check distance to chest if (this.chest && this.chest.active) { const chestDist = Phaser.Math.Distance.Between(this.player.x, this.player.y, this.chest.x, this.chest.y); if (chestDist < this.cellSize / 2) { this.handleChestCollect(this.player, this.chest); } } // Check distance to cartridge if (this.cartridge && this.cartridge.active) { const cartridgeDist = Phaser.Math.Distance.Between(this.player.x, this.player.y, this.cartridge.x, this.cartridge.y); if (cartridgeDist < this.cellSize / 2) { this.handleCartridgeCollect(this.player, this.cartridge); } } // Check distance to crab body for collecting arms if (this.crab && this.crab.body && this.crab.body.active) { const crabDist = Phaser.Math.Distance.Between(this.player.x, this.player.y, this.crab.body.x, this.crab.body.y); if (crabDist < this.cellSize / 2) { this.handleCrabBodyCollision(this.player, this.crab.body); } } } // Remove redundant prop checking code since it's already handled above // Check if we're passing over cell center while holding space if (this.keys.munch.isDown) { const currentCellX = Math.floor((this.player.x - this.startX) / this.cellSize); const currentCellY = Math.floor((this.player.y - this.startY) / this.cellSize); const cellCenterX = this.startX + (currentCellX * this.cellSize) + (this.cellSize / 2); const cellCenterY = this.startY + (currentCellY * this.cellSize) + (this.cellSize / 2); const distToCenter = Math.sqrt( Math.pow(this.player.x - cellCenterX, 2) + Math.pow(this.player.y - cellCenterY, 2) ); if (distToCenter < 4) { // If very close to cell center this.player.play(`munch-${this.playerState.facing}`); this.time.delayedCall(250, () => { if (this.playerState.movement.isGridMoving) { // Only reset if still moving this.player.play(`walk-${this.playerState.facing}`); } }); } } if (distance > 1) { // Move towards the target const angle = Math.atan2(dy, dx); const velocityX = Math.cos(angle) * speed; const velocityY = Math.sin(angle) * speed; this.player.setVelocity(velocityX, velocityY); } else { // We've reached the target this.player.setPosition(this.playerState.movement.targetX, this.playerState.movement.targetY); this.player.setVelocity(0, 0); this.playerState.movement.isGridMoving = false; this.playerState.movement.targetX = null; this.playerState.movement.targetY = null; } } // Get current velocity values const velocityX = this.player.body.velocity.x; const velocityY = this.player.body.velocity.y; // Handle collisions and prevent sticking if (this.player.body.blocked.left || this.player.body.blocked.right || this.player.body.blocked.up || this.player.body.blocked.down) { // If we hit something while moving to a target, snap to the nearest valid grid position if (this.playerState.movement.isGridMoving) { const currentCellX = Math.floor((this.player.x - this.startX) / this.cellSize); const currentCellY = Math.floor((this.player.y - this.startY) / this.cellSize); this.player.setPosition( this.startX + (currentCellX * this.cellSize) + (this.cellSize / 2), this.startY + (currentCellY * this.cellSize) + (this.cellSize / 2) ); this.playerState.movement.isGridMoving = false; this.playerState.movement.targetX = null; this.playerState.movement.targetY = null; this.player.setVelocity(0, 0); } } if (velocityX === 0 && velocityY === 0 && !this.playerState.movement.isGridMoving && !this.gameOver) { if (this.playerState.movement.isMoving && !this.playerState.isMunching) { this.playerState.movement.isMoving = false; this.playerState.idle.timer = 0; this.player.stop(); this.player.setFrame(this.playerState.facing === 'right' ? 0 : 16); } this.playerState.idle.timer += 1 / 60; if (this.playerState.idle.timer >= 3) { if (!this.playerState.idle.isAnimComplete && !this.player.anims.isPlaying) { this.player.play(`idle-${this.playerState.facing}`, false); this.player.once('animationcomplete', () => { this.playerState.idle.isAnimComplete = true; this.playerState.idle.nextIdleTime = 6 + Math.random() * 6; this.player.setFrame(this.playerState.facing === 'right' ? 0 : 16); }); } else if (this.playerState.idle.isAnimComplete) { if (this.playerState.idle.timer >= 3 + this.playerState.idle.nextIdleTime) { this.playerState.idle.isAnimComplete = false; this.playerState.idle.timer = 3; } } } } else { this.playerState.movement.isMoving = true; this.playerState.idle.isAnimComplete = false; } if (!this.gameOver && (Phaser.Input.Keyboard.JustDown(this.keys.munch) || (this.keys.munch.isDown && this.playerState.movement.isGridMoving))) { if (!this.playerState.isMunching) { this.playerState.isMunching = true; this.playerState.munchStartTime = this.time.now; const currentAnim = this.player.anims.currentAnim; const isWalking = currentAnim && currentAnim.key.startsWith('walk-'); // Play munch animation this.player.play(`munch-${this.playerState.facing}`); // If we're walking, return to walking animation after munching if (isWalking) { this.time.delayedCall(250, () => { if (this.playerState.movement.isGridMoving) { this.player.play(`walk-${this.playerState.facing}`, true); } }); } } // Handle torch pickup/drop through the collect handler if (this.torch) { this.handleTorchCollect(this.player, this.torch); } } else if (Phaser.Input.Keyboard.JustUp(this.keys.munch)) { this.playerState.isMunching = false; this.playerState.munchStartTime = 0; this.playerState.idle.timer = 0; this.playerState.idle.isAnimComplete = false; if (this.playerState.movement.isGridMoving) { this.player.play(`walk-${this.playerState.facing}`, true); } else { this.player.setFrame(this.playerState.facing === 'right' ? 0 : 16); } } this.updateEnemyBehavior(); this.updateTorchIllumination(); this.updateTreeAnimations(); // Only update NPC animation if game isn't over or if NPC is following target if (!this.gameOver || (this.gameOver && this.npc.followTarget)) { this.updateNpcAnimation(); } // Update NPC following behavior during game over if (this.gameOver && this.npc.followTarget && this.npc.followTarget.active) { const target = this.npc.followTarget; const dx = target.x - this.npc.x; const dy = target.y - this.npc.y; const distance = Math.sqrt(dx * dx + dy * dy); if (distance > 32) { // Keep some distance behind const angle = Math.atan2(dy, dx); this.npc.setVelocity( Math.cos(angle) * this.npc.followSpeed, Math.sin(angle) * this.npc.followSpeed ); // Update animation based on movement const facing = dx < 0 ? 'left' : 'right'; this.npc.play(`female-run-${facing}`, true); } } if (!this.gameOver) { this.updateCrabArms(); this.updateCrabAnimation(); } // Update torch position if it exists and is attached to player // Update torch position if attached if (this.torch && this.torch.isAttached) { this.torch.setPosition(this.player.x, this.player.y); // Get current grid positions const torchCellX = Math.floor((this.torch.x - this.startX) / this.cellSize); const torchCellY = Math.floor((this.torch.y - this.startY) / this.cellSize); const npcCellX = Math.floor((this.npc.x - this.startX) / this.cellSize); const npcCellY = Math.floor((this.npc.y - this.startY) / this.cellSize); // Calculate Manhattan distance to torch const manhattanDist = Math.abs(torchCellX - npcCellX) + Math.abs(torchCellY - npcCellY); // Only move if we're more than 1 cell away from torch if (manhattanDist > 1) { // Determine direction to move (prefer horizontal movement first) let moveX = 0; let moveY = 0; if (torchCellX !== npcCellX) { moveX = torchCellX > npcCellX ? 1 : -1; } else if (torchCellY !== npcCellY) { moveY = torchCellY > npcCellY ? 1 : -1; } // Calculate target position in pixels const targetX = this.startX + (npcCellX + moveX) * this.cellSize + this.cellSize / 2; const targetY = this.startY + (npcCellY + moveY) * this.cellSize + this.cellSize / 2; // Move towards target position const dx = targetX - this.npc.x; const dy = targetY - this.npc.y; const distance = Math.sqrt(dx * dx + dy * dy); if (distance > 1) { const speed = 160; // Same speed as player const vx = (dx / distance) * speed; const vy = (dy / distance) * speed; this.npc.setVelocity(vx, vy); } else { this.npc.setPosition(targetX, targetY); this.npc.setVelocity(0, 0); } } else { // We're at desired distance, stop moving this.npc.setVelocity(0, 0); } } // Update key position if attached if (this.silverKey && this.silverKey.isAttached) { this.silverKey.setPosition(this.player.x, this.player.y); } } updateCrabAnimation() { if (!this.crab || !this.crab.state) return; const currentTime = this.time.now; const state = this.crab.state; // Update animation frames if (currentTime - state.lastAnimTime > state.animSpeed) { state.currentRow = (state.currentRow + 1) % 5; // Cycle through 5 rows // Update frames for all parts (same row, different columns) if (this.crab.leftClaw && this.crab.leftClaw.active) this.crab.leftClaw.setFrame(state.currentRow * 3 + 0); if (this.crab.body && this.crab.body.active) this.crab.body.setFrame(state.currentRow * 3 + 1); if (this.crab.rightClaw && this.crab.rightClaw.active) this.crab.rightClaw.setFrame(state.currentRow * 3 + 2); state.lastAnimTime = currentTime; } // Check if it's time to move const timeUntilMove = state.nextMoveTime - currentTime; // Flash warning before movement if (timeUntilMove <= 400 && timeUntilMove > 50 && !state.isFlashing) { state.isFlashing = true; // First flash - 25ms [this.crab.leftClaw, this.crab.body, this.crab.rightClaw].forEach(part => { if (part && part.active) { part.setTint(0x7f7b00); // Half-bright yellow part.setTintFill(0x7f7b00); // Fill with half-bright yellow // First flash ends after 25ms this.time.delayedCall(25, () => { if (part.active) { part.clearTint(); // Second flash - 25ms this.time.delayedCall(25, () => { if (part.active) { part.setTint(0x7f7b00); part.setTintFill(0x7f7b00); this.time.delayedCall(25, () => { if (part.active) { part.clearTint(); // Third flash - 25ms this.time.delayedCall(25, () => { if (part.active) { part.setTint(0x7f7b00); part.setTintFill(0x7f7b00); this.time.delayedCall(25, () => { if (part.active) { part.clearTint(); state.isFlashing = false; } }); } }); } }); } }); } }); } }); } // Handle movement if (currentTime > state.nextMoveTime) { // Calculate next cell position const nextX = state.currentCell.x + state.direction; // Check if next position is valid (not a tree and within bounds) let canMove = true; // Check for all possible obstacles // Check for trees this.trees.children.iterate((tree) => { const objCellX = Math.floor((tree.x - this.startX) / this.cellSize); const objCellY = Math.floor((tree.y - this.startY) / this.cellSize); if (objCellX === nextX && objCellY === state.currentCell.y) { canMove = false; return false; } }); // Check for props (potion, chest, cartridge, torch) const props = [this.potion, this.chest, this.cartridge, this.torch]; props.forEach(prop => { if (prop && prop.active) { const objCellX = Math.floor((prop.x - this.startX) / this.cellSize); const objCellY = Math.floor((prop.y - this.startY) / this.cellSize); if (objCellX === nextX && objCellY === state.currentCell.y) { canMove = false; } } }); // Check for NPC if (this.npc && this.npc.active) { const npcCellX = Math.floor((this.npc.x - this.startX) / this.cellSize); const npcCellY = Math.floor((this.npc.y - this.startY) / this.cellSize); if (npcCellX === nextX && npcCellY === state.currentCell.y) { canMove = false; } } // Check for enemies (cyplops) this.enemies.forEach(enemy => { if (enemy && enemy.active) { const enemyCellX = Math.floor((enemy.x - this.startX) / this.cellSize); const enemyCellY = Math.floor((enemy.y - this.startY) / this.cellSize); if (enemyCellX === nextX && enemyCellY === state.currentCell.y) { canMove = false; } } }); // Check bounds if (nextX <= 0 || nextX >= this.gridSize - 1) { canMove = false; } if (canMove) { // Move all parts to the next cell const newX = this.startX + nextX * this.cellSize + this.cellSize / 2; const currentY = this.crab.body.y; if (this.crab.leftClaw && this.crab.leftClaw.active) this.crab.leftClaw.setPosition(newX - 16, currentY); if (this.crab.body && this.crab.body.active) this.crab.body.setPosition(newX, currentY); if (this.crab.rightClaw && this.crab.rightClaw.active) this.crab.rightClaw.setPosition(newX + 16, currentY); state.currentCell.x = nextX; } else { // Reverse direction state.direction *= -1; } // Set next move time state.nextMoveTime = currentTime + 1000 + Math.random() * 2000; } // Check for walk state changes if (currentTime > state.nextWalkTime) { if (!state.isWalking) { // Start walking state.isWalking = true; state.walkDuration = 1500 + Math.random() * 1500; // Walk for 1.5-3 seconds state.nextWalkTime = currentTime + state.walkDuration; } else { // Stop walking state.isWalking = false; state.nextWalkTime = currentTime + 3000 + Math.random() * 3000; // Wait 3-6 seconds if (this.crab) { // Reset frames to initial state this.crab.leftClaw.setFrame(0); this.crab.body.setFrame(1); this.crab.rightClaw.setFrame(2); } } } // If walking, randomly change claw frames if (state.isWalking) { if (Math.random() < 0.1) { // 10% chance each frame to change claws if (!state.currentClaws) { state.currentClaws = { left: 0, right: 0 }; } state.currentClaws.left = Math.floor(Math.random() * 5); state.currentClaws.right = Math.floor(Math.random() * 5); // Get the current body frame safely let currentBodyFrame = 0; if (this.crab && this.crab.active) { if (this.crab.anims && this.crab.anims.currentFrame) { currentBodyFrame = this.crab.anims.currentFrame.index; } else { currentBodyFrame = state.currentFrame; } } else { currentBodyFrame = state.currentFrame; } // Update frames for each part const leftFrame = state.currentClaws.left * 3 + 0; // First column const bodyFrame = state.currentClaws.left * 3 + 1; // Second column const rightFrame = state.currentClaws.right * 3 + 2; // Third column if (this.crab.leftClaw && this.crab.leftClaw.active) { this.crab.leftClaw.setFrame(leftFrame); } if (this.crab.body && this.crab.body.active) { this.crab.body.setFrame(bodyFrame); } if (this.crab.rightClaw && this.crab.rightClaw.active) { this.crab.rightClaw.setFrame(rightFrame); } // Update state state.currentFrame = bodyFrame; } } } updateTorchIllumination() { this.illumination.clear(); if (!this.torch) return; let torchX = this.torch.x; let torchY = this.torch.y; // Update torch position if attached to cyplop if (this.torch.attachedToCyplop && this.torch.attachedCyplop && this.torch.attachedCyplop.active) { torchX = this.torch.attachedCyplop.x; torchY = this.torch.attachedCyplop.y; this.torch.setPosition(torchX, torchY); } // Get torch grid position const torchCellX = Math.floor((torchX - this.startX) / this.cellSize); const torchCellY = Math.floor((torchY - this.startY) / this.cellSize); // Create radial gradient for torch light this.illumination.fillStyle(0xffaa00, 0.2); // Illuminate cells in a 3-cell radius for (let dy = -3; dy <= 3; dy++) { for (let dx = -3; dx <= 3; dx++) { const distance = Math.sqrt(dx * dx + dy * dy); if (distance <= 3) { const cellX = torchCellX + dx; const cellY = torchCellY + dy; // Check if the cell is within grid bounds if (cellX >= 0 && cellX < this.gridSize && cellY >= 0 && cellY < this.gridSize) { const alpha = 0.4 * (1 - (distance / 3)); this.illumination.fillStyle(0xffaa00, alpha); this.illumination.fillRect( this.startX + cellX * this.cellSize, this.startY + cellY * this.cellSize, this.cellSize, this.cellSize ); } } } } } updateNpcAnimation() { if (this.gameOver) return; // Update facing direction based on player position const dx = this.player.x - this.npc.x; const shouldFaceLeft = dx < 0; // Update facing direction if needed if (shouldFaceLeft && this.npc.facing === 'right') { this.npc.facing = 'left'; } else if (!shouldFaceLeft && this.npc.facing === 'left') { this.npc.facing = 'right'; } // Check player state for movement and torch const isPlayerMoving = this.playerState.movement.isGridMoving; const isPlayerCarryingTorch = this.torch && this.torch.isAttached; const manhattanDistance = Math.abs( Math.floor((this.player.x - this.npc.x) / this.cellSize)) + Math.abs(Math.floor((this.player.y - this.npc.y) / this.cellSize)); // Update NPC state based on player proximity this.npc.state.isNearPlayer = manhattanDistance <= 2; if (isPlayerMoving && isPlayerCarryingTorch) { // Play running animation if (!this.npc.anims.isPlaying || this.npc.anims.currentAnim.key !== `female-run-${this.npc.facing}`) { this.npc.play(`female-run-${this.npc.facing}`, true); this.npc.state.isAnimating = true; } } else { // Handle idle animations if (!this.npc.state.isAnimating && this.time.now > this.npc.state.nextIdleTime) { this.npc.play(`female-idle-${this.npc.facing}`); this.npc.state.isAnimating = true; // Listen for animation completion this.npc.once('animationcomplete', () => { // Update NPC state after animation this.npc.setFrame(this.npc.state.baseFrames[this.npc.facing]); this.npc.state.isAnimating = false; // Adjust idle timing based on proximity to player const baseDelay = this.npc.state.isNearPlayer ? 2000 : 4000; const randomDelay = this.npc.state.isNearPlayer ? 4000 : 12000; this.npc.state.nextIdleTime = this.time.now + baseDelay + Math.random() * randomDelay; }); } } } updateTreeAnimations() { // Wind direction (changes gradually over time) const time = this.time.now / 1000; // Convert to seconds // If we don't have wind state, initialize it if (!this.windState) { this.windState = { baseWindSpeed: 0.2, gustStrength: 0, nextGustTime: time + 5 + Math.random() * 10, gustDuration: 0, calmDuration: 5 + Math.random() * 15 }; } // Update wind gusts if (time > this.windState.nextGustTime) { if (this.windState.gustStrength === 0) { // Start a new gust this.windState.gustStrength = 0.3 + Math.random() * 0.7; // Random gust intensity this.windState.gustDuration = 2 + Math.random() * 4; // Gust lasts 2-6 seconds this.windState.nextGustTime = time + this.windState.gustDuration; } else { // End the gust, enter calm period this.windState.gustStrength = 0; this.windState.nextGustTime = time + this.windState.calmDuration; this.windState.calmDuration = 5 + Math.random() * 15; // Random calm duration } } // Calculate wind properties const windAngle = Math.sin(time * 0.2) * Math.PI; // Wind direction changes slowly // Base wind speed plus gust effect const currentGustEffect = this.windState.gustStrength * Math.sin(time * 2) * 0.5; const windSpeed = (this.windState.baseWindSpeed + currentGustEffect) * (0.2 + Math.sin(time * 0.5) * 0.1); // Slight natural variation this.trees.children.iterate(tree => { // Calculate wind effect based on position and time const windEffect = Math.sin( (tree.gridX * Math.cos(windAngle) + tree.gridY * Math.sin(windAngle) + time * windSpeed + tree.windOffset) * 2 ) * 0.5 + 0.5; // Normalized between 0 and 1 // Apply wind effect to animation speed with gust influence const gustInfluence = this.windState.gustStrength * 0.5; tree.anims.timeScale = (tree.baseTimeScale + (windEffect * 0.3)) * (1 + gustInfluence); // Occasionally reset progress to create more natural movement if (Math.random() < 0.001) { tree.windOffset = Math.random() * Math.PI * 2; } }); } updateCrabArms() { if (this.hasCrabArms && this.crabArms && this.crabArms.state) { const currentTime = this.time.now; // Update positions this.crabArms.visual.left.setPosition(this.player.x - 16, this.player.y); this.crabArms.visual.right.setPosition(this.player.x + 16, this.player.y); this.crabArms.hitbox.setPosition(this.player.x, this.player.y); // Update animations if (currentTime >= this.crabArms.state.leftClaw.nextUpdate) { this.crabArms.state.leftClaw.frame = (this.crabArms.state.leftClaw.frame + 3) % 15; this.crabArms.visual.left.setFrame(this.crabArms.state.leftClaw.frame); this.crabArms.state.leftClaw.nextUpdate = currentTime + this.crabArms.state.animSpeed; } if (currentTime >= this.crabArms.state.rightClaw.nextUpdate) { this.crabArms.state.rightClaw.frame = (this.crabArms.state.rightClaw.frame + 3) % 15; this.crabArms.visual.right.setFrame(this.crabArms.state.rightClaw.frame); this.crabArms.state.rightClaw.nextUpdate = currentTime + this.crabArms.state.animSpeed; } } } shutdown() { // Stop thruster sound if it's playing if (this.thrusterSound) { this.thrusterSound.stop(); } // Clean up graphics and event listeners if (this.illumination) { this.illumination.destroy(); } // Clean up keyboard events if (this.input && this.input.keyboard) { this.input.keyboard.removeAllKeys(true); } // Clean up enemy timer texts this.enemies.forEach(enemy => { if (enemy && enemy.state && enemy.state.timerText) { enemy.state.timerText.destroy(); } }); } } const config = { type: Phaser.AUTO, parent: 'renderDiv', scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH }, width: 800, height: 600, physics: { default: 'arcade', arcade: { gravity: { y: 0 }, debug: false } }, pixelArt: true, scene: Example }; window.phaserGame = new Phaser.Game(config)