class Enemy extends Phaser.GameObjects.Rectangle { static color = 0xffffff; // Default white color constructor(scene, x, y, width, height, color) { super(scene, x, y, width, height, color); this.scene = scene; this.health = 1; } move(playerX, playerY) { // Base class does nothing return [{ newX: this.x, newY: this.y, dx: 0, dy: 0 }]; } hit(direction) { this.health--; if (this.health <= 0) { this.setActive(false); this.setVisible(false); } return false; // Return false to indicate no knockback by default } handleCollision(playerX, playerY) { return false; // Return false to indicate no player hit by default } handleSpecialAction(playerX, playerY) { return null; // Return null to indicate no special action by default } } class Sniper extends Enemy { static color = 0xBBBB00; // Yellow color constructor(scene, x, y) { super(scene, x, y, 16, 16, Sniper.color); scene.add.existing(this); this.targetingTurns = 0; this.optimalDistance = 160; // 5 tiles away } move(playerX, playerY) { const tileSize = 32; let dx = 0; let dy = 0; // Calculate distance to player const distanceX = playerX - this.x; const distanceY = playerY - this.y; const distance = Math.sqrt(distanceX * distanceX + distanceY * distanceY); // Determine if we need to move closer or further away if (distance < this.optimalDistance - tileSize) { // Move away from player dx = -Math.sign(distanceX); dy = -Math.sign(distanceY); } else if (distance > this.optimalDistance + tileSize) { // Move towards player dx = Math.sign(distanceX); dy = Math.sign(distanceY); } // Prioritize horizontal or vertical movement if (Math.abs(distanceX) > Math.abs(distanceY)) { dy = 0; } else { dx = 0; } // Return the move return [{ newX: this.x + dx * tileSize, newY: this.y + dy * tileSize, dx: dx, dy: dy }]; } isInLineOfSight(playerX, playerY) { return this.x === playerX || this.y === playerY; } hit() { this.health--; if (this.health <= 0) { this.setActive(false); this.setVisible(false); } return false; // No knockback for Sniper } handleSpecialAction(playerX, playerY) { if (this.isInLineOfSight(playerX, playerY)) { this.targetingTurns++; if (this.targetingTurns >= 2) { return { action: 'fire', direction: { x: Math.sign(playerX - this.x), y: Math.sign(playerY - this.y) } }; } } else { this.targetingTurns = 0; } return null; } } class Roach extends Enemy { static color = 0x0000ff; // Blue color constructor(scene, x, y) { super(scene, x, y, 16, 16, Roach.color); scene.add.existing(this); this.isHorizontalMode = Math.random() < 0.5; } move(playerX, playerY) { const tileSize = 32; let dx = 0; let dy = 0; // First, try to move in the current mode if (this.isHorizontalMode) { if (playerX < this.x) dx = -1; else if (playerX > this.x) dx = 1; } else { if (playerY < this.y) dy = -1; else if (playerY > this.y) dy = 1; } // If no movement in current mode, switch mode and try again if (dx === 0 && dy === 0) { this.isHorizontalMode = !this.isHorizontalMode; if (this.isHorizontalMode) { if (playerX < this.x) dx = -1; else if (playerX > this.x) dx = 1; } else { if (playerY < this.y) dy = -1; else if (playerY > this.y) dy = 1; } } const newX = this.x + dx * tileSize; const newY = this.y + dy * tileSize; return [{ newX, newY, dx, dy }]; } hit() { this.health--; if (this.health <= 0) { this.setActive(false); this.setVisible(false); } } } class Charger extends Enemy { static color = 0x00ff00; // Green color constructor(scene, x, y) { super(scene, x, y, 16, 16, Charger.color); scene.add.existing(this); this.state = 'approach'; this.chargeDirection = { x: 0, y: 0 }; this.moveHorizontal = Math.random() < 0.5; this.stunTurns = 0; } move(playerX, playerY) { const tileSize = 32; let dx = 0; let dy = 0; if (this.state === 'stun') { this.stunTurns--; if (this.stunTurns <= 0) { this.state = 'approach'; this.moveHorizontal = Math.random() < 0.5; } return [{ newX: this.x, newY: this.y, dx: 0, dy: 0 }]; } if (this.state === 'approach') { if (this.x === playerX || this.y === playerY) { this.state = 'charge'; this.chargeDirection.x = Math.sign(playerX - this.x); this.chargeDirection.y = Math.sign(playerY - this.y); } else { if (this.moveHorizontal) { dx = Math.sign(playerX - this.x); } else { dy = Math.sign(playerY - this.y); } this.moveHorizontal = !this.moveHorizontal; } } if (this.state === 'charge') { dx = this.chargeDirection.x; dy = this.chargeDirection.y; } let moves = []; for (let i = 0; i < (this.state === 'charge' ? 2 : 1); i++) { const newX = this.x + dx * tileSize; const newY = this.y + dy * tileSize; moves.push({ newX, newY, dx, dy }); // If charging and hit something, stop the charge if (this.state === 'charge' && ( this.scene.isWallAt(newX, newY) || newX < 0 || newX >= this.scene.sys.game.config.width || newY < 0 || newY >= this.scene.sys.game.config.height )) { this.state = 'approach'; this.moveHorizontal = Math.random() < 0.5; break; } } return moves; } hit() { this.health--; if (this.health <= 0) { this.setActive(false); this.setVisible(false); } else { // If hit, enter stun state this.state = 'stun'; this.stunTurns = 1; } } enterStunState() { this.state = 'stun'; this.stunTurns = 1; } } class EliteCharger extends Charger { static color = 0x006400; // Darker green color constructor(scene, x, y) { super(scene, x, y); this.scene = scene; this.initX = x; this.initY = y; this.health = 2; // Elite Chargers have more health this.container = this.scene.add.container(this.initX, this.initY); this.scene.add.existing(this.container); this.body = this.scene.add.rectangle(0, 0, 16, 16, EliteCharger.color); this.container.add(this.body); this.shield = this.scene.add.rectangle(0, -8, 16, 4, 0xFF0000); this.shield.setOrigin(0.5, 1); this.container.add(this.shield); this.lastMovementDirection = { x: 0, y: -1 }; // Initially facing up this.updateShieldPosition(); } setActive(active) { super.setActive(active); if (this.container) { this.container.setActive(active); this.body.setActive(active); this.shield.setActive(active); } } setVisible(visible) { super.setVisible(visible); if (this.container) { this.container.setVisible(visible); } } updateShieldPosition() { if (this.shield) { const { x, y } = this.lastMovementDirection; this.shield.setPosition(x * 8, y * 8); // Set rotation based on direction if (x === 1) this.shield.setRotation(Math.PI / 2); else if (x === -1) this.shield.setRotation(-Math.PI / 2); else if (y === 1) this.shield.setRotation(Math.PI); else if (y === -1) this.shield.setRotation(0); } } getDirection() { if (this.state === 'charge') { return this.chargeDirection; } else { const dx = this.scene.playerGroup.x - this.x; const dy = this.scene.playerGroup.y - this.y; const length = Math.sqrt(dx * dx + dy * dy); return { x: dx / length, y: dy / length }; } } move(playerX, playerY) { const moves = super.move(playerX, playerY); if (moves.length > 0) { const lastMove = moves[moves.length - 1]; if (lastMove.dx !== 0 || lastMove.dy !== 0) { this.lastMovementDirection = { x: lastMove.dx, y: lastMove.dy }; } } this.updateShieldPosition(); return moves.map(move => ({ ...move, newX: this.x + move.dx * 32, newY: this.y + move.dy * 32 })); } get x() { return this.container ? this.container.x : this.initX; } set x(value) { if (this.container) { this.container.x = value; } else { this.initX = value; } } get y() { return this.container ? this.container.y : this.initY; } set y(value) { if (this.container) { this.container.y = value; } else { this.initY = value; } } hit(direction) { const shieldDirection = this.lastMovementDirection; const dot = direction.x * shieldDirection.x + direction.y * shieldDirection.y; if (dot < -0.5) { // Shield blocks frontal attacks (dot product is negative for opposite directions) return false; } this.health--; if (this.health <= 0) { this.setActive(false); this.setVisible(false); } else { // If hit, enter stun state this.state = 'stun'; this.stunTurns = 1; } return this.health > 0; // Return true for knockback if still alive } enterStunState() { super.enterStunState(); // When stunned, the shield should face the direction of the last movement this.updateShieldPosition(); } } class Crab extends Enemy { static color = 0x8B0000; // Dark red color constructor(scene, x, y) { super(scene, x, y, 16, 16, Crab.color); scene.add.existing(this); this.setRotation(Math.PI / 4); // Rotate 45 degrees this.health = 2; // Crabs now have 2 HP this.skipNextTurn = false; } move(playerX, playerY) { if (this.skipNextTurn) { this.skipNextTurn = false; return [{ newX: this.x, newY: this.y, dx: 0, dy: 0 }]; } const tileSize = 32; let dx = 0; let dy = 0; // Check if the player is in attack range (any of the 8 surrounding tiles) if (Math.abs(this.x - playerX) <= tileSize && Math.abs(this.y - playerY) <= tileSize) { // Attack the player return [{ newX: this.x, newY: this.y, dx: 0, dy: 0, attack: true }]; } // Determine diagonal movement direction if (this.x < playerX) dx = 1; else if (this.x > playerX) dx = -1; if (this.y < playerY) dy = 1; else if (this.y > playerY) dy = -1; // If we're in the same column, move diagonally away from the player's row if (this.x === playerX) { dx = (Math.random() < 0.5) ? -1 : 1; } // If we're in the same row, move diagonally away from the player's column if (this.y === playerY) { dy = (Math.random() < 0.5) ? -1 : 1; } // Ensure diagonal movement if (dx === 0 || dy === 0) { return [{ newX: this.x, newY: this.y, dx: 0, dy: 0 }]; } // Move diagonally return [{ newX: this.x + dx * tileSize, newY: this.y + dy * tileSize, dx: dx, dy: dy }]; } hit(direction) { this.health--; this.skipNextTurn = true; if (this.health <= 0) { this.setActive(false); this.setVisible(false); } return this.health > 0; // Return true for knockback if still alive } handleCollision(playerX, playerY) { const tileSize = 32; if (Math.abs(this.x - playerX) <= tileSize && Math.abs(this.y - playerY) <= tileSize) { return true; // Crab attacks if player is in any of the 8 surrounding tiles } return false; } } class EnemySpawner extends Phaser.GameObjects.Container { constructor(scene, x, y, enemyType) { super(scene, x, y); this.enemyType = enemyType; this.ghostEnemy = scene.add.rectangle(0, 0, 16, 16, enemyType.enemy.color, 0.5); this.countdownText = scene.add.text(0, 0, '', { fontSize: '24px', fill: '#fff', stroke: '#000', strokeThickness: 3 }); this.countdownText.setOrigin(0.5); this.add([this.ghostEnemy, this.countdownText]); this.countdown = Phaser.Math.Between(3, 6); this.updateCountdownDisplay(); } updateCountdownDisplay() { this.countdownText.setText(this.countdown.toString()); } decreaseCountdown() { this.countdown--; this.updateCountdownDisplay(); return this.countdown <= 0; } } class TurnBasedShooter extends Phaser.Scene { constructor() { super(); this.enemyTypes = [{ enemy: Roach, points: 1, minimumWave: 1 }, { enemy: Charger, points: 3, minimumWave: 3 }, { enemy: Crab, points: 4, minimumWave: 7 }, { enemy: Sniper, points: 4, minimumWave: 5 }, { enemy: EliteCharger, points: 6, minimumWave: 7 }]; this.enemiesMoving = false; this.inputBuffer = null; } preload() { this.load.image('heart', 'https://play.rosebud.ai/assets/Heart.png?lLtV'); } createWalls() { const { width, height } = this.sys.game.config; const tileSize = 32; this.walls = this.add.group(); // Create border walls for (let x = 0; x < width; x += tileSize) { this.createWall(x, 0); this.createWall(x, height - tileSize); } for (let y = tileSize; y < height - tileSize; y += tileSize) { this.createWall(0, y); this.createWall(width - tileSize, y); } // Create some sporadic walls const numWalls = 10; for (let i = 0; i < numWalls; i++) { const x = Phaser.Math.Between(2, Math.floor(width / tileSize) - 3) * tileSize; const y = Phaser.Math.Between(2, Math.floor(height / tileSize) - 3) * tileSize; this.createWall(x, y); } } createWall(x, y) { const wall = this.add.rectangle(x + 16, y + 16, 32, 32, 0x808080); wall.setStrokeStyle(1, 0x000000); this.walls.add(wall); } create() { const { width, height } = this.sys.game.config; const tileSize = 32; // Create grid for (let y = 0; y < height; y += tileSize) { for (let x = 0; x < width; x += tileSize) { const tile = this.add.rectangle(x + tileSize / 2, y + tileSize / 2, tileSize, tileSize, 0xffffff); tile.setStrokeStyle(1, 0x808080); } } // Create walls this.createWalls(); // Create player const playerSize = 16; // Half the size of a tile const playerX = Math.floor(width / 2 / tileSize) * tileSize + tileSize / 2; const playerY = Math.floor(height / 2 / tileSize) * tileSize + tileSize / 2; this.player = this.add.rectangle(0, 0, playerSize, playerSize, 0xff0000); // Create facing indicator this.facingIndicator = this.add.rectangle( playerSize / 2 + 8, 0, 16, 2, 0xff0000 ); // Group player and facing indicator this.playerGroup = this.add.container(playerX, playerY, [this.player, this.facingIndicator]); // Create enemies this.enemies = []; const gridWidth = Math.floor(width / tileSize); const gridHeight = Math.floor(height / tileSize); // Set up player hearts this.hearts = 3; this.heartSprites = []; for (let i = 0; i < this.hearts; i++) { const heart = this.add.image(10 + i * 40, 10, 'heart'); heart.setScale(0.1); // Adjust this value to resize the heart image this.heartSprites.push(heart); } // Set up input this.cursors = this.input.keyboard.createCursorKeys(); this.wasd = this.input.keyboard.addKeys({ up: Phaser.Input.Keyboard.KeyCodes.W, down: Phaser.Input.Keyboard.KeyCodes.S, left: Phaser.Input.Keyboard.KeyCodes.A, right: Phaser.Input.Keyboard.KeyCodes.D }); this.canMove = true; this.currentRotation = 0; this.enemiesMoving = false; // Set up key press listeners this.input.keyboard.on('keydown-LEFT', this.movePlayer.bind(this, -1, 0)); this.input.keyboard.on('keydown-RIGHT', this.movePlayer.bind(this, 1, 0)); this.input.keyboard.on('keydown-UP', this.movePlayer.bind(this, 0, -1)); this.input.keyboard.on('keydown-DOWN', this.movePlayer.bind(this, 0, 1)); this.input.keyboard.on('keydown-A', this.movePlayer.bind(this, -1, 0)); this.input.keyboard.on('keydown-D', this.movePlayer.bind(this, 1, 0)); this.input.keyboard.on('keydown-W', this.movePlayer.bind(this, 0, -1)); this.input.keyboard.on('keydown-S', this.movePlayer.bind(this, 0, 1)); // Set up rotation listeners this.input.keyboard.on('keydown-Q', this.rotatePlayer.bind(this, -1)); this.input.keyboard.on('keydown-E', this.rotatePlayer.bind(this, 1)); // Set up fire listener this.input.keyboard.on('keydown-SPACE', this.fireProjectile, this); // Initialize wave system this.currentWave = 0; this.enemySpawners = []; // Add wave number text this.waveText = this.add.text(400, 10, 'Wave 1', { fontSize: '32px', fill: '#fff', stroke: '#000', strokeThickness: 4 }); this.waveText.setOrigin(0.5, 0); this.startNextWave(); // Initialize God Mode this.godMode = false; this.godModeText = this.add.text(780, 10, '', { fontSize: '16px', fill: '#fff', stroke: '#000', strokeThickness: 2 }).setOrigin(1, 0); // Add God Mode toggle listener this.input.keyboard.on('keydown-G', this.toggleGodMode, this); } selectEnemyTypesForWave() { const availableEnemies = this.enemyTypes.filter(et => et.minimumWave <= this.currentWave); const numTypes = Phaser.Math.Between(2, Math.min(4, availableEnemies.length)); const selectedTypes = []; while (selectedTypes.length < numTypes && availableEnemies.length > 0) { const index = Phaser.Math.Between(0, availableEnemies.length - 1); selectedTypes.push(availableEnemies[index]); availableEnemies.splice(index, 1); } return selectedTypes.length > 0 ? selectedTypes : [this.enemyTypes[0]]; } calculateWavePointTotal() { // This is a simple formula, you can adjust it to make the game harder or easier return Math.floor(5 + this.currentWave * 1.5); } startNextWave() { this.currentWave++; const totalWavePoints = this.calculateWavePointTotal(); // Update wave text this.waveText.setText(`Wave ${this.currentWave}`); // Clear any existing spawners this.enemySpawners.forEach(spawner => spawner.destroy()); this.enemySpawners = []; // Select enemy types for this wave const waveEnemyTypes = this.selectEnemyTypesForWave(); // Create new spawners const { width, height } = this.sys.game.config; const tileSize = 32; const gridWidth = Math.floor(width / tileSize); const gridHeight = Math.floor(height / tileSize); let currentPoints = 0; while (currentPoints < totalWavePoints) { let spawnerX, spawnerY; do { const spawnerTileX = Phaser.Math.Between(1, gridWidth - 2); const spawnerTileY = Phaser.Math.Between(1, gridHeight - 2); spawnerX = spawnerTileX * tileSize + tileSize / 2; spawnerY = spawnerTileY * tileSize + tileSize / 2; } while (this.isWallAt(spawnerX, spawnerY)); // Choose a random enemy type from selected types for this wave const enemyType = Phaser.Math.RND.pick(waveEnemyTypes); const spawner = new EnemySpawner(this, spawnerX, spawnerY, enemyType); this.add.existing(spawner); this.enemySpawners.push(spawner); currentPoints += enemyType.points; } } movePlayer(dx, dy) { if (!this.canMove || (this.enemiesMoving && this.enemies.length > 0)) { this.inputBuffer = { type: 'move', dx, dy }; return; } const tileSize = 32; const newX = this.playerGroup.x + dx * tileSize; const newY = this.playerGroup.y + dy * tileSize; if (!this.isWallAt(newX, newY) && !this.isEnemyAt(newX, newY)) { this.canMove = false; this.tweens.add({ targets: this.playerGroup, x: newX, y: newY, duration: 100, onComplete: () => { this.updateSpawnersAndEnemies(); this.canMove = true; if (this.enemies.length === 0) { this.enemiesMoving = false; } this.executeBufferedInput(); } }); } else { this.executeBufferedInput(); } } isEnemyAt(x, y) { const tileSize = 32; return this.enemies.some(enemy => enemy.active && Math.abs(enemy.x - x) < tileSize / 2 && Math.abs(enemy.y - y) < tileSize / 2 ); } isWallAt(x, y) { const tileSize = 32; const halfTile = tileSize / 2; return this.walls.getChildren().some(wall => Math.abs(wall.x - x) < tileSize && Math.abs(wall.y - y) < tileSize ); } rotatePlayer(direction) { if (!this.canMove || (this.enemiesMoving && this.enemies.length > 0)) { this.inputBuffer = { type: 'rotate', direction }; return; } this.canMove = false; let newRotation = this.currentRotation + direction * 90; newRotation = ((newRotation % 360) + 360) % 360; let rotationDiff = newRotation - this.currentRotation; if (rotationDiff > 180) rotationDiff -= 360; if (rotationDiff < -180) rotationDiff += 360; this.currentRotation = newRotation; this.tweens.add({ targets: this.playerGroup, angle: `+=${rotationDiff}`, duration: 100, onComplete: () => { this.updateSpawnersAndEnemies(); this.canMove = true; if (this.enemies.length === 0) { this.enemiesMoving = false; } this.executeBufferedInput(); } }); } moveEnemy() { if (this.enemiesMoving) return; // Prevent multiple simultaneous enemy movements this.enemiesMoving = true; const tileSize = 32; const desiredMoves = new Map(); const occupiedTiles = new Set(); let playerHitThisTurn = false; let moveMade = false; // Step 1: Calculate desired moves for all enemies this.enemies.forEach(enemy => { if (!enemy.active) return; // Handle collisions (e.g., Crab's attack) if (enemy.handleCollision(this.playerGroup.x, this.playerGroup.y) && !playerHitThisTurn) { this.playerHit(); playerHitThisTurn = true; return; } // Handle special actions (e.g., Sniper's projectile) const specialAction = enemy.handleSpecialAction(this.playerGroup.x, this.playerGroup.y); if (specialAction) { if (specialAction.action === 'fire') { this.fireSniperProjectile(enemy, specialAction.direction); } return; } const moves = enemy.move(this.playerGroup.x, this.playerGroup.y); moves.forEach(({ newX, newY, dx, dy }) => { if (newX === this.playerGroup.x && newY === this.playerGroup.y && !playerHitThisTurn) { this.playerHit(); playerHitThisTurn = true; return; } const newTile = `${newX},${newY}`; if (!desiredMoves.has(newTile)) { desiredMoves.set(newTile, []); } desiredMoves.get(newTile).push({ enemy, newX, newY, dx, dy }); }); // Mark current position as occupied occupiedTiles.add(`${enemy.x},${enemy.y}`); }); // Step 2: Resolve conflicts and apply moves desiredMoves.forEach((moves, tile) => { if (!occupiedTiles.has(tile)) { // Tile is not occupied, choose one enemy randomly if there's a conflict const chosenMove = Phaser.Math.RND.pick(moves); const { enemy, newX, newY, dx, dy } = chosenMove; if ((dx !== 0 || dy !== 0) && !this.isWallAt(newX, newY)) { this.moveEnemyToTile(enemy, newX, newY); occupiedTiles.delete(`${enemy.x},${enemy.y}`); occupiedTiles.add(tile); moveMade = true; // If it's a Charger or EliteCharger in charge state, it might have a second move if ((enemy instanceof Charger || enemy instanceof EliteCharger) && enemy.state === 'charge') { const secondNewX = newX + dx * tileSize; const secondNewY = newY + dy * tileSize; const secondTile = `${secondNewX},${secondNewY}`; if (!occupiedTiles.has(secondTile) && !this.isWallAt(secondNewX, secondNewY)) { // Check if the second move would hit the player if (secondNewX === this.playerGroup.x && secondNewY === this.playerGroup.y) { if (!playerHitThisTurn) { this.playerHit(); playerHitThisTurn = true; } enemy.enterStunState(); } else { this.moveEnemyToTile(enemy, secondNewX, secondNewY, 100); occupiedTiles.delete(tile); occupiedTiles.add(secondTile); } } else { enemy.enterStunState(); } } } } else { // Conflict or tile is occupied, enemies stay in place moves.forEach(({ enemy }) => { if ((enemy instanceof Charger || enemy instanceof EliteCharger) && enemy.state === 'charge') { enemy.enterStunState(); } }); } }); if (!moveMade) { this.enemiesMoving = false; } } moveEnemyToTile(enemy, newX, newY, delay = 0) { if (newX !== enemy.x || newY !== enemy.y) { let target; if (enemy instanceof EliteCharger) { if (enemy.container) { target = enemy.container; } else { console.error('EliteCharger container is undefined', enemy); this.checkEnemyMovementComplete(); return; } } else { target = enemy; } this.tweens.add({ targets: target, x: newX, y: newY, duration: 100, delay: delay, onComplete: () => { if (enemy instanceof EliteCharger) { enemy.updateShieldPosition(); } this.checkEnemyMovementComplete(); } }); } else { // If the enemy didn't actually move, we need to check if all tweens are done this.time.delayedCall(delay + 100, () => { this.checkEnemyMovementComplete(); }); } } checkEnemyMovementComplete() { if (this.tweens.getAllTweens().filter(tween => tween.isPlaying()).length === 0) { this.enemiesMoving = false; this.executeBufferedInput(); } } playerHit() { if (this.godMode) return; // Ignore damage if God Mode is active this.hearts--; if (this.hearts >= 0) { this.heartSprites[this.hearts].setVisible(false); } if (this.hearts <= 0) { this.gameOver(); } } gameOver() { this.add.text(400, 300, 'Game Over', { fontSize: '64px', fill: '#fff', stroke: '#000', strokeThickness: 6 }).setOrigin(0.5); this.canMove = false; } fireProjectile() { if (!this.canMove || (this.enemiesMoving && this.enemies.length > 0)) { this.inputBuffer = { type: 'fire' }; return; } this.canMove = false; // Disable movement during firing const direction = this.getFacingDirection(); const tileSize = 32; let hitPosition = { x: this.playerGroup.x, y: this.playerGroup.y }; let hitEnemy = false; let hitWall = false; // Calculate the end position of the hitscan while ( hitPosition.x >= 0 && hitPosition.x <= this.sys.game.config.width && hitPosition.y >= 0 && hitPosition.y <= this.sys.game.config.height && !hitEnemy && !hitWall ) { hitPosition.x += direction.x * tileSize; hitPosition.y += direction.y * tileSize; // Check if we've hit a wall if (this.isWallAt(hitPosition.x, hitPosition.y)) { hitWall = true; break; } // Check if we've hit an enemy for (let enemy of this.enemies) { if ( enemy.active && Math.abs(hitPosition.x - enemy.x) < tileSize / 2 && Math.abs(hitPosition.y - enemy.y) < tileSize / 2 ) { this.hitEnemy(enemy); hitEnemy = true; break; } } } // Adjust hit position if we hit a wall if (hitWall) { hitPosition.x -= direction.x * tileSize / 2; hitPosition.y -= direction.y * tileSize / 2; } // Visualize the projectile const line = this.add.line(0, 0, this.playerGroup.x, this.playerGroup.y, hitPosition.x, hitPosition.y, 0xffff00) .setOrigin(0, 0) .setDepth(1); // Use a timer to simulate the projectile's travel time this.time.delayedCall(100, () => { line.destroy(); this.updateSpawnersAndEnemies(); this.canMove = true; // Re-enable player movement }, [], this); } updateSpawnersAndEnemies() { let allSpawnersActivated = true; this.enemySpawners.forEach((spawner, index) => { if (spawner.decreaseCountdown()) { // Spawn enemy const EnemyClass = spawner.enemyType.enemy; const enemy = new EnemyClass(this, spawner.x, spawner.y); this.enemies.push(enemy); // Remove spawner spawner.destroy(); this.enemySpawners[index] = null; } else { allSpawnersActivated = false; } }); // Remove destroyed spawners this.enemySpawners = this.enemySpawners.filter(spawner => spawner !== null); // Move existing enemies this.moveEnemy(); // Remove inactive enemies this.enemies = this.enemies.filter(enemy => enemy.active); // Check if all spawners are activated and all enemies are defeated to start next wave if (allSpawnersActivated && this.enemySpawners.length === 0 && this.enemies.length === 0) { this.startNextWave(); } } getFacingDirection() { const angle = (this.currentRotation + 360) % 360; if (angle === 0) return { x: 1, y: 0 }; // Right if (angle === 90) return { x: 0, y: 1 }; // Down if (angle === 180) return { x: -1, y: 0 }; // Left if (angle === 270) return { x: 0, y: -1 }; // Up return { x: 0, y: 0 }; // Default, shouldn't happen } hitEnemy(enemy) { const direction = this.getFacingDirection(); const knockback = enemy.hit(direction); if (knockback) { const tileSize = 32; const newX = enemy.x + direction.x * tileSize; const newY = enemy.y + direction.y * tileSize; if (!this.isWallAt(newX, newY) && !this.isEnemyAt(newX, newY)) { const target = enemy instanceof EliteCharger ? enemy.container : enemy; this.tweens.add({ targets: target, x: newX, y: newY, duration: 100, onComplete: () => { if (enemy instanceof EliteCharger) { enemy.updateShieldPosition(); } } }); } } } fireSniperProjectile(sniper, direction) { const tileSize = 32; let projectileX = sniper.x; let projectileY = sniper.y; const line = this.add.line(0, 0, projectileX, projectileY, projectileX, projectileY, 0xFF0000) .setOrigin(0, 0) .setDepth(1); const moveProjectile = () => { projectileX += direction.x * tileSize; projectileY += direction.y * tileSize; if (this.isWallAt(projectileX, projectileY)) { line.destroy(); return; } if (projectileX === this.playerGroup.x && projectileY === this.playerGroup.y) { this.playerHit(); line.destroy(); return; } line.setTo(sniper.x, sniper.y, projectileX, projectileY); this.time.delayedCall(100, moveProjectile); }; moveProjectile(); } toggleGodMode() { this.godMode = !this.godMode; this.godModeText.setText(this.godMode ? 'God Mode On' : ''); } update() { // Update method is now empty as movement is handled by key press events } executeBufferedInput() { if (this.inputBuffer && !this.enemiesMoving) { const bufferedInput = this.inputBuffer; this.inputBuffer = null; // Clear the buffer before executing switch (bufferedInput.type) { case 'move': this.movePlayer(bufferedInput.dx, bufferedInput.dy); break; case 'rotate': this.rotatePlayer(bufferedInput.direction); break; case 'fire': this.fireProjectile(); break; } } } } const container = document.getElementById('renderDiv'); const config = { type: Phaser.AUTO, parent: 'renderDiv', pixelArt: true, scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, }, width: 800, height: 608, physics: { default: 'arcade', arcade: { gravity: { y: 0 } } }, scene: TurnBasedShooter }; window.phaserGame = new Phaser.Game(config);