class Towers { constructor(scene) { this.scene = scene; this.towers = []; this.towerTypes = [{ key: 'towers', frame: 0, name: 'Shock', baseCost: 50, range: 3, fireRate: 1250, projectileColor: 0xd7ce3f, damage: 1.5, baseStunDuration: 300, fenceFrame: 3, pulseFrame: 6, boosterFrame: 9, advancedFrame: 12 }, { key: 'towers', frame: 1, name: 'Frost', baseCost: 50, range: 3, fireRate: 2000, projectileColor: 0xADD8E6, baseSlowDuration: 300, damage: .7, fenceFrame: 4, pulseFrame: 7, boosterFrame: 10, advancedFrame: 13 }, { key: 'towers', frame: 2, name: 'Flame', baseCost: 50, range: 3, fireRate: 100, projectileColor: 0xFF0000, damage: 0.11, dotDuration: 1000, fenceFrame: 5, pulseFrame: 8, boosterFrame: 11, advancedFrame: 14 }]; this.pendingFenceTower = null; } createTowerMenu() { const menuY = this.scene.cameras.main.height - 50 + 75; // Moved down by 75 pixels this.scene.towerMenuItems = []; this.towerTypes.forEach((tower, index) => { const x = this.scene.cameras.main.width / 4 * (index + 1) - 40; // Adjusted x position const costText = this.scene.add.text(x, menuY, `${tower.name}\n$${tower.baseCost}`, { fontFamily: 'Arial, sans-serif', fontSize: '24px', fontStyle: 'bold', align: 'right', stroke: '#000000', strokeThickness: 4, shadow: { offsetX: 2, offsetY: 2, color: '#000000', blur: 2, stroke: true, fill: true } }).setOrigin(1, 0.5).setScrollFactor(0); // Apply gradient fill let gradient; switch (tower.name) { case 'Shock': gradient = costText.context.createLinearGradient(0, 0, 0, costText.height); gradient.addColorStop(0, '#FFD700'); gradient.addColorStop(1, '#FFA500'); break; case 'Frost': gradient = costText.context.createLinearGradient(0, 0, 0, costText.height); gradient.addColorStop(0, '#00FFFF'); gradient.addColorStop(1, '#1E90FF'); break; case 'Flame': gradient = costText.context.createLinearGradient(0, 0, 0, costText.height); gradient.addColorStop(0, '#FF4500'); gradient.addColorStop(1, '#8B0000'); break; } costText.setFill(gradient); const icon = this.scene.add.image(x + 60, menuY - 30, tower.key, tower.frame) .setScale(1.5) // Increase scale by 50% .setInteractive({ draggable: true }) .setScrollFactor(0); icon.on('dragstart', () => { this.scene.towerPreview.setTexture(tower.key, tower.frame).setVisible(true); this.scene.currentTower = tower; }); this.scene.towerMenuItems.push({ icon, costText, tower }); }); } updateTowerPreview(pointer) { if (this.scene.towerPreview.visible || this.pendingFenceTower) { const worldPoint = this.scene.cameras.main.getWorldPoint(pointer.x, pointer.y); const pointerTileX = this.scene.map.worldToTileX(worldPoint.x); const pointerTileY = this.scene.map.worldToTileY(worldPoint.y); const previewObject = this.pendingFenceTower || this.scene.towerPreview; previewObject.setPosition( this.scene.map.tileToWorldX(pointerTileX) + this.scene.map.tileWidth / 2, this.scene.map.tileToWorldY(pointerTileY) + this.scene.map.tileHeight / 2 ); const canPlace = this.pendingFenceTower ? this.canPlaceFencePartner(pointerTileX, pointerTileY) : this.canPlaceTower(pointerTileX, pointerTileY); previewObject.setTint(canPlace ? 0x00ff00 : 0xff0000); if (this.pendingFenceTower) { this.updateFencePlacementHighlights(pointerTileX, pointerTileY); } } } updateFencePlacementHighlights(currentTileX, currentTileY) { this.clearHighlightTiles(); const originalTower = this.pendingFenceTower.originalTower; this.createHighlightTiles(originalTower.x, originalTower.y, currentTileX, currentTileY); } createHighlightTiles(originX, originY, currentTileX, currentTileY) { this.highlightTiles = this.highlightTiles || []; const highlightPositions = []; // Highlight horizontal tiles for (let x = originX - 4; x <= originX + 4; x++) { if (x !== originX && this.canPlaceFencePartner(x, originY)) { highlightPositions.push({ x, y: originY }); } } // Highlight vertical tiles for (let y = originY - 3; y <= originY + 3; y++) { if (y !== originY && this.canPlaceFencePartner(originX, y)) { highlightPositions.push({ x: originX, y }); } } highlightPositions.forEach(pos => { const highlightTile = this.scene.add.rectangle( this.scene.map.tileToWorldX(pos.x) + this.scene.map.tileWidth / 2, this.scene.map.tileToWorldY(pos.y) + this.scene.map.tileHeight / 2, this.scene.map.tileWidth, this.scene.map.tileHeight, 0x00ff00, 0.3 ); this.highlightTiles.push(highlightTile); }); } clearHighlightTiles() { if (this.highlightTiles) { this.highlightTiles.forEach(tile => tile.destroy()); this.highlightTiles = []; } } canPlaceTower(tileX, tileY, isFencePartner = false) { const tile = this.scene.towerPlacementLayer.getTileAt(tileX, tileY); if (!tile) { return false; } if (!isFencePartner && this.scene.gold < this.getCurrentTowerCost(this.scene.currentTower)) { return false; } // Check for overlapping with existing towers for (let tower of this.towers) { const towerWidth = tower.width || 1; const towerHeight = tower.height || 1; // Check if the new tower's tile overlaps with any existing tower if (tileX >= tower.x && tileX < tower.x + towerWidth && tileY >= tower.y && tileY < tower.y + towerHeight) { return false; } } return true; } getCurrentTowerCost(tower) { return Math.floor(tower.baseCost * this.scene.towerCostMultiplier); } placeTower(pointer) { if (this.scene.towerPreview.visible || this.pendingFenceTower) { const worldPoint = this.scene.cameras.main.getWorldPoint(pointer.x, pointer.y); const pointerTileX = this.scene.map.worldToTileX(worldPoint.x); const pointerTileY = this.scene.map.worldToTileY(worldPoint.y); if (this.pendingFenceTower) { if (this.canPlaceFencePartner(pointerTileX, pointerTileY)) { this.placeFencePartner(pointerTileX, pointerTileY); } else { console.log('Cannot place fence partner here'); } } else if (this.canPlaceTower(pointerTileX, pointerTileY)) { const tower = this.scene.add.image( this.scene.map.tileToWorldX(pointerTileX) + this.scene.map.tileWidth / 2, this.scene.map.tileToWorldY(pointerTileY) + this.scene.map.tileHeight, this.scene.currentTower.key, this.scene.currentTower.frame ).setOrigin(0.5, 1); tower.setDepth(pointerTileY); this.towers.push({ x: pointerTileX, y: pointerTileY, sprite: tower, type: { ...this.scene.currentTower }, lastFired: 0, upgrades: [] }); const cost = this.getCurrentTowerCost(this.scene.currentTower); this.scene.gold -= cost; this.scene.updateGoldDisplay(); this.scene.towerCostMultiplier *= 1.25; this.updateTowerCosts(); console.log(`Tower placed at (${pointerTileX}, ${pointerTileY})`); console.log('Current towers:', this.towers); this.checkForTowerMerge(pointerTileX, pointerTileY, this.scene.currentTower); } this.scene.towerPreview.setVisible(false); } } checkForTowerMerge(tileX, tileY, towerType) { console.log(`Checking for tower merge at (${tileX}, ${tileY})`); // Check for basic tower merging only if the tower is not upgraded if (towerType.key === 'towers') { const adjacentTowers = [ this.getTowerAt(tileX, tileY - 1), this.getTowerAt(tileX, tileY + 1) ]; for (const adjacentTower of adjacentTowers) { if (adjacentTower && adjacentTower.type.key === towerType.key && adjacentTower.type.frame === towerType.frame && adjacentTower.upgrades.length === 0) { this.mergeTowers(tileX, tileY, adjacentTower); return; // Exit after merging } } } // Check for super tower merging if (towerType.key === 'advancedTowers') { const leftTower = this.getTowerAt(tileX - 1, tileY); const rightTower = this.getTowerAt(tileX + 1, tileY); if (leftTower && leftTower.type.key === 'advancedTowers' && leftTower.type.frame === towerType.frame) { this.mergeSuperTower(tileX - 1, tileY, tileX, tileY); return; // Exit after merging } else if (rightTower && rightTower.type.key === 'advancedTowers' && rightTower.type.frame === towerType.frame) { this.mergeSuperTower(tileX, tileY, tileX + 1, tileY); return; // Exit after merging } } } mergeTowers(tileX, tileY, adjacentTower) { const topY = Math.min(tileY, adjacentTower.y); const bottomY = Math.max(tileY, adjacentTower.y); const towerX = tileX; this.removeTower(tileX, topY); this.removeTower(tileX, bottomY); const advancedTowerFrame = this.scene.currentTower.advancedFrame; const mergedTowerSprite = this.scene.add.image( this.scene.map.tileToWorldX(towerX) + this.scene.map.tileWidth / 2, this.scene.map.tileToWorldY(bottomY) + this.scene.map.tileHeight - (this.scene.map.tileHeight / 2), 'towers', advancedTowerFrame ).setOrigin(0.5, 1); this.towers.push({ x: towerX, y: topY, width: 1, height: 2, sprite: mergedTowerSprite, type: { ...this.scene.currentTower, key: 'advancedTowers', frame: advancedTowerFrame, range: this.scene.currentTower.range * 2, damage: this.scene.currentTower.damage * 2, fireRate: this.scene.currentTower.fireRate * 0.75, name: `Advanced ${this.scene.currentTower.name}`, isAdvanced: true }, lastFired: 0, upgrades: [] }); console.log(`Merged tower created at (${towerX}, ${topY})`); console.log('Current towers after merge:', this.towers); this.checkForTowerMerge(towerX, topY, this.towers[this.towers.length - 1].type); } mergeSuperTower(leftTileX, leftTileY, rightTileX, rightTileY) { const leftTower = this.getTowerAt(leftTileX, leftTileY); const rightTower = this.getTowerAt(rightTileX, rightTileY); if (!leftTower || !rightTower) return; this.removeTower(leftTileX, leftTileY); this.removeTower(rightTileX, rightTileY); const superTowerFrame = leftTower.type.name.includes('Shock') ? 0 : leftTower.type.name.includes('Frost') ? 1 : 2; const superTowerSprite = this.scene.add.image( this.scene.map.tileToWorldX(leftTileX) + this.scene.map.tileWidth, this.scene.map.tileToWorldY(leftTileY) + this.scene.map.tileHeight * 2, // Move down by one tile 'superTowers', superTowerFrame ).setOrigin(0.5, 1); this.towers.push({ x: leftTileX, y: leftTileY, width: 2, height: 2, sprite: superTowerSprite, type: { ...leftTower.type, key: 'superTowers', frame: superTowerFrame, range: 5, // Set range to 5 tiles damage: 2.5, // Reduced damage to 2.5 fireRate: 5000, // Set fire rate to 5 seconds (5000 ms) dotDuration: 3000, // 3 seconds DOT duration name: `Super ${leftTower.type.name.replace('Advanced ', '')}`, isSuper: true }, lastFired: 0, upgrades: [] }); console.log(`Super tower created at (${leftTileX}, ${leftTileY})`); console.log('Current towers after super merge:', this.towers); } removeTower(tileX, tileY) { console.log(`Attempting to remove tower at (${tileX}, ${tileY})`); const towerIndex = this.towers.findIndex(tower => { if (tower.width && tower.height) { return tileX >= tower.x && tileX < tower.x + tower.width && tileY >= tower.y && tileY < tower.y + tower.height; } else { return tower.x === tileX && tower.y === tileY; } }); if (towerIndex !== -1) { console.log(`Removing tower at index ${towerIndex}`); this.towers[towerIndex].sprite.destroy(); this.towers.splice(towerIndex, 1); } else { console.log(`No tower found at (${tileX}, ${tileY})`); } } updateTowerCosts() { this.scene.towerMenuItems.forEach(item => { const currentCost = this.getCurrentTowerCost(item.tower); item.costText.setText(`${item.tower.name}\n$${currentCost}`); }); } getTowerAt(tileX, tileY) { console.log(`Searching for tower at (${tileX}, ${tileY})`); console.log('Current towers:', this.towers); const tower = this.towers.find(tower => { if (tower.width && tower.height) { const inRangeX = tileX >= tower.x && tileX < tower.x + tower.width; const inRangeY = tileY >= tower.y && tileY < tower.y + tower.height; console.log(`Checking tower at (${tower.x}, ${tower.y}) with width ${tower.width} and height ${tower.height}`); console.log(`In range X: ${inRangeX}, In range Y: ${inRangeY}`); return inRangeX && inRangeY; } else { const matches = tower.x === tileX && tower.y === tileY; console.log(`Checking tower at (${tower.x}, ${tower.y})`); console.log(`Matches: ${matches}`); return matches; } }); console.log(`getTowerAt(${tileX}, ${tileY}):`, tower); return tower; } findEnemyInRange(tower) { let closestEnemy = null; let closestDistance = Infinity; const towerRange = tower.type.range * this.scene.map.tileWidth; this.scene.enemies.getChildren().forEach(enemy => { const distance = Phaser.Math.Distance.Between( tower.sprite.x, tower.sprite.y, enemy.x, enemy.y ); if (distance <= towerRange && distance < closestDistance) { closestEnemy = enemy; closestDistance = distance; } }); return closestEnemy; } fireTower(tower, enemy, time) { if (tower.upgrades.includes('pulse')) { this.firePulse(tower); } else if (tower.upgrades.includes('fence')) { this.fireFence(tower); } else if (tower.upgrades.includes('boost')) { this.applyBoost(tower); } else { let projectile; switch (tower.type.name) { case 'Shock': case 'Advanced Shock': case 'Super Shock': case 'Shock: Pulse': case 'Shock: Fence': case 'Shock: Booster': projectile = this.scene.add.star(tower.sprite.x, tower.sprite.y - 32, 5, 5, 10, 0xd7ce3f); break; case 'Frost': case 'Advanced Frost': case 'Super Frost': case 'Frost: Pulse': case 'Frost: Fence': case 'Frost: Booster': projectile = this.scene.add.circle(tower.sprite.x, tower.sprite.y - 32, 5, 0xADD8E6); break; case 'Flame': case 'Advanced Flame': case 'Super Flame': case 'Flame: Pulse': case 'Flame: Fence': case 'Flame: Booster': projectile = this.scene.add.rectangle(tower.sprite.x, tower.sprite.y - 32, 20, 5, 0xFF0000); projectile.setAngle(90); // Rotate the rectangle by 90 degrees break; default: projectile = this.scene.add.circle(tower.sprite.x, tower.sprite.y - 32, 10, tower.type.projectileColor); } this.scene.physics.add.existing(projectile); this.scene.projectiles.add(projectile); projectile.tower = tower; projectile.target = enemy; tower.lastFired = time; // Adjust the size of the physics body to match the new shape projectile.body.setSize(projectile.width, projectile.height); // Use boosted range for projectile speed const boostedRange = tower.type.range * this.scene.map.tileWidth; const speed = boostedRange * 2; // Adjust this multiplier as needed this.scene.physics.moveTo(projectile, enemy.x, enemy.y, speed); } } firePulse(tower) { const pulseRadius = this.scene.map.tileWidth * tower.type.range; const pulseY = tower.sprite.y - tower.sprite.height / 2 + 15; let enemiesInRange = false; this.scene.enemies.getChildren().forEach(enemy => { const distance = Phaser.Math.Distance.Between(tower.sprite.x, pulseY, enemy.x, enemy.y); if (distance <= pulseRadius) { enemiesInRange = true; enemy.health -= tower.type.damage; // Highlight the enemy enemy.setTint(tower.type.projectileColor); this.scene.tweens.add({ targets: enemy, alpha: 0.5, yoyo: true, duration: 100, onComplete: () => { if (enemy.active) { enemy.clearTint(); enemy.setAlpha(1); } } }); if (tower.type.name.includes('Shock')) { this.scene.stunEnemy(enemy, tower.type.stunDuration); } else if (tower.type.name.includes('Frost')) { this.scene.slowEnemy(enemy, tower.type.slowDuration); } else if (tower.type.name.includes('Flame')) { this.scene.applyDotToEnemy(enemy, tower.type.dotDuration, tower); } if (enemy.health <= 0) { this.scene.destroyEnemy(enemy); } else { enemy.healthBar.width = (enemy.health / enemy.maxHealth) * 32; } } }); let hitEnemies = this.scene.enemies.getChildren().filter(enemy => { const distance = Phaser.Math.Distance.Between(tower.sprite.x, pulseY, enemy.x, enemy.y); return distance <= pulseRadius; }); if (hitEnemies.length > 0) { hitEnemies.forEach(enemy => { enemy.health -= tower.type.damage; enemy.setTint(tower.type.projectileColor); this.scene.tweens.add({ targets: enemy, alpha: 0.5, yoyo: true, duration: 100, onComplete: () => { if (enemy.active) { enemy.clearTint(); enemy.setAlpha(1); } } }); if (tower.type.name.includes('Shock')) { this.scene.stunEnemy(enemy, tower.type.baseStunDuration); } if (enemy.health <= 0) { this.scene.destroyEnemy(enemy); } else { enemy.healthBar.width = (enemy.health / enemy.maxHealth) * 32; } }); const pulse = this.scene.add.circle(tower.sprite.x, pulseY, pulseRadius, tower.type.projectileColor, 0.2); this.scene.tweens.add({ targets: pulse, alpha: 0, scale: 1.5, duration: 1000, onComplete: () => pulse.destroy() }); } return hitEnemies.length > 0; } // Add this method to adjust fire rate for pulse towers adjustPulseFireRate(tower) { if (tower.type.name.includes('Flame')) { tower.type.fireRate *= 2.5; // Increase fire rate (decrease frequency) for Flame pulse towers } } fireFence(tower) { if (!tower.fencePartner) { // If this is the first fence node, do nothing until a partner is placed return; } const dx = tower.fencePartner.sprite.x - tower.sprite.x; const dy = tower.fencePartner.sprite.y - tower.sprite.y; const length = Math.sqrt(dx * dx + dy * dy); const shortenAmount = 10; // 10 pixels from each end, 20 pixels total const startX = tower.sprite.x + (dx / length) * shortenAmount; const startY = tower.sprite.y + (dy / length) * shortenAmount - 30; const endX = tower.fencePartner.sprite.x - (dx / length) * shortenAmount; const endY = tower.fencePartner.sprite.y - (dy / length) * shortenAmount - 30; const fenceLine = new Phaser.Geom.Line(startX, startY, endX, endY); // Determine the fence color based on tower type let fenceColor; switch (tower.type.name) { case 'Shock: Fence': fenceColor = 0xFFFF00; // Yellow for shock break; case 'Frost: Fence': fenceColor = 0x00FFFF; // Cyan for frost break; case 'Flame: Fence': fenceColor = 0xFF4500; // OrangeRed for flame break; default: fenceColor = 0xFFFFFF; // White as default } // Update or create the fence line graphics if (!tower.fenceGraphics) { tower.fenceGraphics = this.scene.add.graphics(); } tower.fenceGraphics.clear(); tower.fenceGraphics.lineStyle(2, fenceColor, 1); tower.fenceGraphics.strokeLineShape(fenceLine); this.scene.enemies.getChildren().forEach(enemy => { if (Phaser.Geom.Intersects.LineToRectangle(fenceLine, enemy.getBounds())) { enemy.health -= tower.type.damage; // Use the tower's damage directly switch (tower.type.name) { case 'Shock: Fence': const fenceStunDuration = 500; // Shorter stun duration for fences this.scene.stunEnemy(enemy, fenceStunDuration); break; case 'Frost: Fence': const fenceSlowDuration = 1000; // 1 second slow duration for frost fences this.scene.slowEnemy(enemy, fenceSlowDuration); break; case 'Flame: Fence': const flameFenceDotDuration = 3000; // 3 seconds for flame fences this.scene.applyDotToEnemy(enemy, flameFenceDotDuration, tower); break; } if (enemy.health <= 0) { this.scene.destroyEnemy(enemy); } } }); } applyBoost(tower) { const boostRadius = tower.type.range * this.scene.map.tileWidth; const boostPercentage = 1 + (tower.boostLevel || 1) * 0.1; // 10% increase per level this.towers.forEach(otherTower => { if (otherTower !== tower && !otherTower.upgrades.includes('boost')) { const distance = Phaser.Math.Distance.Between(tower.sprite.x, tower.sprite.y, otherTower.sprite.x, otherTower.sprite.y); if (distance <= boostRadius) { if (!otherTower.boostedBy) otherTower.boostedBy = new Set(); otherTower.boostedBy.add(tower); this.recalculateBoosts(otherTower); } else if (otherTower.boostedBy && otherTower.boostedBy.has(tower)) { otherTower.boostedBy.delete(tower); this.recalculateBoosts(otherTower); } } }); } recalculateBoosts(tower) { if (!tower.originalStats) { tower.originalStats = { damage: tower.type.damage, range: tower.type.range, fireRate: tower.type.fireRate }; } let damageBoost = 1; let rangeBoost = 1; let fireRateBoost = 1; tower.boostedBy.forEach(boostTower => { const boostPercentage = 1 + (boostTower.boostLevel || 1) * 0.1; switch (boostTower.type.name) { case 'Damage Booster': damageBoost *= boostPercentage; break; case 'Range Booster': rangeBoost *= boostPercentage; break; case 'Fire Rate Booster': fireRateBoost *= boostPercentage; break; } }); tower.type.damage = tower.originalStats.damage * damageBoost; tower.type.range = tower.originalStats.range * rangeBoost; tower.type.fireRate = tower.originalStats.fireRate / fireRateBoost; console.log(`Recalculated boosts for ${tower.type.name}: Damage ${damageBoost.toFixed(2)}x, Range ${rangeBoost.toFixed(2)}x, Fire Rate ${fireRateBoost.toFixed(2)}x`); } removeBoost(tower) { if (tower.originalStats) { tower.type.damage = tower.originalStats.damage; tower.type.range = tower.originalStats.range; tower.type.fireRate = tower.originalStats.fireRate; } if (tower.boostedBy && tower.boostedBy.size > 0) { this.recalculateBoosts(tower); } else { delete tower.boostedBy; delete tower.originalStats; } } upgradeBoostTower(tower) { if (!tower.boostLevel) tower.boostLevel = 1; if (tower.boostLevel >= 5) return; // Cap at 50% boost (5 levels) const upgradeCost = this.getBoostUpgradeCost(tower.boostLevel); if (this.scene.gold >= upgradeCost) { this.scene.gold -= upgradeCost; tower.boostLevel++; this.scene.updateGoldDisplay(); console.log(`Boost tower upgraded to level ${tower.boostLevel}`); // Recalculate boosts for all affected towers this.towers.forEach(otherTower => { if (otherTower.boostedBy && otherTower.boostedBy.has(tower)) { this.recalculateBoosts(otherTower); } }); } else { console.log("Not enough gold to upgrade Boost tower"); } } getBoostUpgradeCost(currentLevel) { switch (currentLevel) { case 1: return 100; case 2: return 500; case 3: return 1000; case 4: return 2000; default: return Infinity; // Prevent further upgrades } } showTowerInfo(pointer) { const worldPoint = this.scene.cameras.main.getWorldPoint(pointer.x, pointer.y); const pointerTileX = this.scene.map.worldToTileX(worldPoint.x); const pointerTileY = this.scene.map.worldToTileY(worldPoint.y); const clickedTower = this.getTowerAt(pointerTileX, pointerTileY); if (clickedTower) { if (this.scene.towerInfoPanel) { this.scene.towerInfoPanel.destroy(); } const towerType = clickedTower.type; let infoHTML = `

${towerType.name}

Damage: ${towerType.damage.toFixed(2)}

Range: ${towerType.range}

Fire Rate: ${towerType.fireRate}ms

`; if (towerType.name.includes('Shock')) { const scaledStunDuration = towerType.baseStunDuration * (towerType.damage / 1.5); infoHTML += `

Stun Duration: ${scaledStunDuration.toFixed(2)}ms

`; } if (towerType.name.includes('Frost')) { const scaledSlowDuration = towerType.baseSlowDuration * (towerType.damage / 0.7); infoHTML += `

Slow Duration: ${scaledSlowDuration.toFixed(2)}ms

`; } if (towerType.name.includes('Flame')) { infoHTML += `

DOT Duration: ${towerType.dotDuration}ms

`; const tickDamage = towerType.damage * 0.1; infoHTML += `

DOT Tick Damage: ${tickDamage.toFixed(2)}

`; } if (clickedTower.upgrades.includes('boost')) { const boostLevel = clickedTower.boostLevel || 1; const boostPercentage = boostLevel * 10; infoHTML += `

Boost Level: ${boostLevel} (${boostPercentage}% boost)

`; } infoHTML += `

`; // Adjust the position if the tower is close to the bottom of the screen let infoY = pointer.y; if (pointer.y > this.scene.cameras.main.height - 350) { infoY = pointer.y - 350; } this.scene.towerInfoPanel = this.scene.add.dom(pointer.x, infoY).createFromHTML(infoHTML); this.scene.towerInfoPanel.setOrigin(0, 0).setScrollFactor(0); // Add upgrade buttons for basic towers that haven't been upgraded if (towerType.key === 'towers' && clickedTower.upgrades.length === 0) { const upgradeOptions = ['Pulse', 'Fence', 'Boost']; upgradeOptions.forEach((upgrade, index) => { const upgradeButton = this.scene.add.text(pointer.x, infoY + this.scene.towerInfoPanel.height + 10 + (index * 30), `Upgrade to ${upgrade}`, { fontSize: '16px', fill: '#ffffff', backgroundColor: '#4CAF50', padding: { x: 10, y: 5 } }).setOrigin(0, 0).setScrollFactor(0).setInteractive(); upgradeButton.on('pointerdown', () => { console.log(`Upgrade to ${upgrade} clicked`); this.upgradeTower(clickedTower, upgrade.toLowerCase()); this.hideTowerInfo(pointer); this.showTowerInfo(pointer); }); this.scene.towerInfoPanel[`${upgrade.toLowerCase()}UpgradeButton`] = upgradeButton; }); } else if (clickedTower.upgrades.includes('boost') && (clickedTower.boostLevel || 1) < 5) { const upgradeCost = this.getBoostUpgradeCost(clickedTower.boostLevel || 1); const upgradeButton = this.scene.add.text(pointer.x, infoY + this.scene.towerInfoPanel.height + 10, `Upgrade Boost (Cost: ${upgradeCost})`, { fontSize: '16px', fill: '#ffffff', backgroundColor: '#4CAF50', padding: { x: 10, y: 5 } }).setOrigin(0, 0).setScrollFactor(0).setInteractive(); upgradeButton.on('pointerdown', () => { console.log('Upgrade Boost clicked'); this.upgradeBoostTower(clickedTower); this.hideTowerInfo(pointer); this.showTowerInfo(pointer); }); this.scene.towerInfoPanel.boostUpgradeButton = upgradeButton; } } } hideTowerInfo(pointer) { const worldPoint = this.scene.cameras.main.getWorldPoint(pointer.x, pointer.y); const pointerTileX = this.scene.map.worldToTileX(worldPoint.x); const pointerTileY = this.scene.map.worldToTileY(worldPoint.y); const clickedTower = this.getTowerAt(pointerTileX, pointerTileY); if (!clickedTower && this.scene.towerInfoPanel) { ['pulse', 'fence', 'boost'].forEach(upgrade => { if (this.scene.towerInfoPanel[`${upgrade}UpgradeButton`]) { this.scene.towerInfoPanel[`${upgrade}UpgradeButton`].destroy(); } }); this.scene.towerInfoPanel.destroy(); this.scene.towerInfoPanel = null; } } upgradeTower(tower, upgradeType) { if (tower.upgrades.length === 0) { tower.upgrades.push(upgradeType); console.log(`Tower upgraded to ${upgradeType}`); // Update tower properties based on upgrade type switch (upgradeType) { case 'pulse': tower.type.range = 2; // Set pulse tower range to 2 tiles tower.type.damage *= 1.2; if (tower.type.baseStunDuration) tower.type.baseStunDuration *= 1.2; if (tower.type.baseSlowDuration) tower.type.baseSlowDuration *= 1.2; this.adjustPulseFireRate(tower); // Adjust fire rate for pulse towers break; case 'fence': tower.type.range *= 2; tower.type.damage = 2; // Increased damage to 2 for fence towers tower.type.fireRate = 800; // Set fire rate to 1 second (1000 ms) if (tower.type.baseStunDuration) tower.type.baseStunDuration *= 0.8; if (tower.type.baseSlowDuration) tower.type.baseSlowDuration *= 0.8; break; case 'boost': tower.type.range *= 1.2; tower.type.fireRate *= 0.8; if (tower.type.baseStunDuration) tower.type.baseStunDuration *= 1.1; if (tower.type.baseSlowDuration) tower.type.baseSlowDuration *= 1.1; tower.boostApplied = false; // Initialize boostApplied flag break; } // Update tower name based on upgrade type tower.type.name = this.getUpgradedTowerName(tower); // Change the tower's appearance if (upgradeType === 'boost') { tower.sprite.setFrame(tower.type.boosterFrame); } else { tower.sprite.setFrame(tower.type[`${upgradeType}Frame`]); } if (upgradeType === 'fence') { this.initiateFencePartner(tower); tower.fenceGraphics = null; // Initialize fenceGraphics } } } getUpgradedTowerName(tower) { const baseName = tower.type.name.replace('Advanced ', '').replace('Super ', ''); if (tower.upgrades.includes('pulse')) { return `${baseName}: Pulse`; } else if (tower.upgrades.includes('fence')) { return `${baseName}: Fence`; } else if (tower.upgrades.includes('boost')) { if (baseName.includes('Shock')) { return 'Damage Booster'; } else if (baseName.includes('Frost')) { return 'Range Booster'; } else if (baseName.includes('Flame')) { return 'Fire Rate Booster'; } } return tower.type.name; } initiateFencePartner(tower) { this.pendingFenceTower = this.scene.add.image(0, 0, tower.type.key, tower.type.frame) .setAlpha(0.5) .setVisible(true); this.pendingFenceTower.originalTower = tower; // Create initial highlight tiles this.createHighlightTiles(tower.x, tower.y, tower.x, tower.y); // Enable placement of fence partner this.scene.input.on('pointerup', this.placeFencePartner, this); } canPlaceFencePartner(tileX, tileY) { const originalTower = this.pendingFenceTower.originalTower; const dx = Math.abs(tileX - originalTower.x); const dy = Math.abs(tileY - originalTower.y); // Check if the placement is within 4 tiles horizontally or 3 tiles vertically of the original tower // and ensure it's not diagonal (either dx or dy must be 0) const isWithinRange = ((dx <= 4 && dy === 0) || (dy <= 3 && dx === 0)) && (dx > 0 || dy > 0); // Check if there's a path between the two towers const hasPathBetween = this.checkPathBetweenTowers(originalTower.x, originalTower.y, tileX, tileY); return isWithinRange && hasPathBetween && this.canPlaceTower(tileX, tileY, true); } checkPathBetweenTowers(x1, y1, x2, y2) { const dx = Math.sign(x2 - x1); const dy = Math.sign(y2 - y1); let currentX = x1 + dx; let currentY = y1 + dy; while (currentX !== x2 || currentY !== y2) { const tile = this.scene.layer.getTileAt(currentX, currentY); if (!tile || tile.collides) { return true; // Found a path tile between the towers } currentX += dx; currentY += dy; } return false; // No path found between the towers } placeFencePartner(pointer) { if (!this.pendingFenceTower) return; const worldPoint = this.scene.cameras.main.getWorldPoint(pointer.x, pointer.y); const pointerTileX = this.scene.map.worldToTileX(worldPoint.x); const pointerTileY = this.scene.map.worldToTileY(worldPoint.y); if (this.canPlaceFencePartner(pointerTileX, pointerTileY)) { const partnerSprite = this.scene.add.image( this.scene.map.tileToWorldX(pointerTileX) + this.scene.map.tileWidth / 2, this.scene.map.tileToWorldY(pointerTileY) + this.scene.map.tileHeight, 'towers', this.pendingFenceTower.originalTower.type.fenceFrame ).setOrigin(0.5, 1); const partner = { x: pointerTileX, y: pointerTileY, sprite: partnerSprite, type: { ...this.pendingFenceTower.originalTower.type }, lastFired: 0, upgrades: ['fence'] }; this.towers.push(partner); this.pendingFenceTower.originalTower.fencePartner = partner; partner.fencePartner = this.pendingFenceTower.originalTower; // Remove the old white fence line if it exists if (this.pendingFenceTower.originalTower.fenceLink) { this.pendingFenceTower.originalTower.fenceLink.destroy(); } // The colored fence line will be created in the fireFence method this.pendingFenceTower.originalTower.fenceGraphics = null; partner.fenceGraphics = null; // Clean up this.pendingFenceTower.destroy(); this.pendingFenceTower = null; this.scene.input.off('pointerup', this.placeFencePartner, this); // Clear highlight tiles this.clearHighlightTiles(); console.log('Fence partner placed successfully'); } else { console.log('Cannot place fence partner here'); } } } class LoadingScene extends Phaser.Scene { constructor() { super('LoadingScene'); } preload() { this.load.image('loadingImage', 'https://play.rosebud.ai/assets/Escapeoftheclones.png?MrP6'); this.load.image('helpImage', 'https://play.rosebud.ai/assets/helppic.png?J9iB'); // Load all other assets here this.load.image('tiles', 'https://play.rosebud.ai/assets/GroundTileset.png?yIMZ'); this.load.tilemapTiledJSON('map', 'https://play.rosebud.ai/assets/EOTCmap.json?jii8'); this.load.spritesheet('enemy', 'https://play.rosebud.ai/assets/LanistaSprite.png?tr4C', { frameWidth: 32, frameHeight: 32 }); this.load.spritesheet('towers', 'https://play.rosebud.ai/assets/Techtowers.png?ACex', { frameWidth: 32, frameHeight: 64 }); this.load.spritesheet('superTowers', 'https://play.rosebud.ai/assets/Supertowers.png?4w49', { frameWidth: 64, frameHeight: 96 }); this.load.image('castle', 'https://play.rosebud.ai/assets/Manhole.png?TlPk'); this.load.image('lab', 'https://play.rosebud.ai/assets/lab.png?Zo7r'); } create() { const loadingImage = this.add.image(this.cameras.main.width / 2, this.cameras.main.height / 2, 'loadingImage'); loadingImage.setOrigin(0.5); // Scale the image to fit the screen while maintaining aspect ratio const scaleX = this.cameras.main.width / loadingImage.width; const scaleY = this.cameras.main.height / loadingImage.height; const scale = Math.min(scaleX, scaleY); loadingImage.setScale(scale); // Set up a timer to transition after exactly 3 seconds this.time.delayedCall(1000, this.startGameScene, [], this); } startGameScene() { this.cameras.main.fadeOut(1000); this.time.delayedCall(1000, () => { this.scene.start('Game'); }); } } class Game extends Phaser.Scene { constructor() { super('Game'); this.layer = null; this.towerPlacementLayer = null; this.targetX = 26; this.targetY = 16; this.towerPreview = null; this.gold = 150; this.goldText = null; this.projectiles = null; this.currentRound = 0; this.nextRoundButton = null; this.enemies = null; this.enemySpawnTimer = null; this.enemiesRemaining = 0; this.towerCostMultiplier = 1; this.castle = null; this.playerHealth = 10; this.playerHealthBar = null; this.playerHealthText = null; this.gameSpeed = 1; this.fastForwardButton = null; this.gameOverText = null; this.isGameOver = false; this.restartButton = null; this.towerMenuItems = []; this.autoStartTimer = null; this.towerInfoPanel = null; // Bind methods to maintain correct 'this' context this.toggleGameSpeed = this.toggleGameSpeed.bind(this); this.restartGame = this.restartGame.bind(this); this.startRound = this.startRound.bind(this); } create() { this.initializeGame(); this.createHelpButton(); } initializeGame() { this.resetGameState(); this.createMap(); this.createAnimations(); this.createStartButton(); this.placeCastle(); this.createFastForwardButton(); this.createRestartButton(); this.createGoldDisplay(); this.towerPreview = this.add.image(0, 0, 'towers', 0).setAlpha(0.5).setVisible(false); this.towers = new Towers(this); this.towers.createTowerMenu(); this.input.on('pointermove', this.towers.updateTowerPreview, this.towers); this.input.on('pointerup', this.towers.placeTower, this.towers); this.input.on('pointerdown', this.towers.showTowerInfo, this.towers); this.input.on('pointerdown', this.towers.hideTowerInfo, this.towers); this.projectiles = this.physics.add.group(); this.enemies = this.physics.add.group(); } resetGameState() { this.gold = 150; this.currentRound = 0; this.enemiesRemaining = 0; this.towerCostMultiplier = 1; this.playerHealth = 10; this.gameSpeed = 1; this.isGameOver = false; if (this.enemySpawnTimer) { this.enemySpawnTimer.remove(); this.enemySpawnTimer = null; } if (this.projectiles && this.projectiles.clear) { this.projectiles.clear(true, true); } if (this.enemies && this.enemies.clear) { this.enemies.clear(true, true); } if (this.playerHealthBar) { this.playerHealthBar.destroy(); this.playerHealthBar = null; } if (this.playerHealthText) { this.playerHealthText.destroy(); this.playerHealthText = null; } if (this.castle) { this.castle.destroy(); this.castle = null; } if (this.fastForwardButton) { this.fastForwardButton.destroy(); this.fastForwardButton = null; } if (this.goldDisplay) { this.goldDisplay.destroy(); this.goldDisplay = null; } if (this.gameOverText) { this.gameOverText.destroy(); this.gameOverText = null; } if (this.autoStartTimer) { this.autoStartTimer.remove(); this.autoStartTimer = null; } if (this.towerInfoPanel) { this.towerInfoPanel.destroy(); this.towerInfoPanel = null; } if (this.helpImage) { this.hideHelpImage(); } this.time.timeScale = 1; } createGoldDisplay() { const goldContainer = document.createElement('div'); goldContainer.style.position = 'absolute'; goldContainer.style.left = '-60px'; goldContainer.style.top = '500px'; goldContainer.style.padding = '10px'; goldContainer.style.backgroundColor = 'rgba(0, 0, 0, 0.7)'; goldContainer.style.borderRadius = '10px'; goldContainer.style.color = '#FFD700'; goldContainer.style.fontFamily = 'Arial, sans-serif'; goldContainer.style.fontSize = '24px'; goldContainer.style.fontWeight = 'bold'; goldContainer.style.boxShadow = '0 0 10px rgba(255, 215, 0, 0.5)'; goldContainer.innerHTML = `💰${this.gold}`; this.goldDisplay = this.add.dom(0, 0, goldContainer); this.goldDisplay.setOrigin(0); this.goldDisplay.setScrollFactor(0); } createMap() { const map = this.make.tilemap({ key: 'map' }); const tileset = map.addTilesetImage('GroundTileset', 'tiles'); if (!tileset) { console.error('Failed to load tileset. Check if the tileset name matches in Tiled and in the code.'); return; } this.layer = map.createLayer('Ground', tileset, 0, 0); this.towerPlacementLayer = map.createLayer('TowerPlacment', tileset, 0, 0); if (!this.layer || !this.towerPlacementLayer) { console.error('Failed to create layers. Check if the layer names are correct.'); return; } this.towerPlacementLayer.setVisible(false); this.layer.setCollisionFromCollisionGroup(); this.physics.world.setBounds(0, 0, map.widthInPixels, map.heightInPixels); const zoomX = this.cameras.main.width / map.widthInPixels; const zoomY = this.cameras.main.height / map.heightInPixels; const zoom = Math.min(zoomX, zoomY); this.cameras.main.setBounds(0, 0, map.widthInPixels, map.heightInPixels); this.cameras.main.setZoom(zoom); this.cameras.main.centerOn(map.widthInPixels / 2, map.heightInPixels / 2); this.map = map; const startTile = [0, 3]; // This is the spawn location const labX = startTile[0] * this.map.tileWidth + this.map.tileWidth / 2; const labY = startTile[1] * this.map.tileHeight + this.map.tileHeight / 2; this.lab = this.add.image(labX, labY, 'lab'); this.lab.setOrigin(0.5, 1); // Scale the lab image to fit one tile const scaleX = this.map.tileWidth / this.lab.width; const scaleY = this.map.tileHeight / this.lab.height; const scale = Math.min(scaleX, scaleY); this.lab.setScale(2); // Ensure the lab is rendered above the tilemap this.lab.setDepth(1); } createFastForwardButton() { const castleX = this.targetX * this.map.tileWidth + this.map.tileWidth / 2; const castleY = this.targetY * this.map.tileHeight + this.map.tileHeight / 2; this.fastForwardButton = this.add.text(castleX - 130, castleY + this.castle.height / 2 + 30, '1x', { fontSize: '20px', fontFamily: 'Arial, sans-serif', fontWeight: 'bold', fill: '#ffffff', padding: { x: 10, y: 5 } }) .setOrigin(0.5) .setInteractive({ useHandCursor: true }) .on('pointerdown', this.toggleGameSpeed, this) .setScrollFactor(0); // Add background and style for fast forward button const ffButtonWidth = this.fastForwardButton.width + 20; const ffButtonHeight = this.fastForwardButton.height + 10; const ffButtonBackground = this.add.graphics(); ffButtonBackground.fillStyle(0x4a4a4a, 1); ffButtonBackground.fillRoundedRect( this.fastForwardButton.x - ffButtonWidth / 2, this.fastForwardButton.y - ffButtonHeight / 2, ffButtonWidth, ffButtonHeight, 5 ); ffButtonBackground.setScrollFactor(0); this.fastForwardButton.setDepth(1); // Add hover effect for fast forward button this.fastForwardButton.on('pointerover', () => { this.fastForwardButton.setStyle({ fill: '#ffff00' }); ffButtonBackground.clear(); ffButtonBackground.fillStyle(0x6a6a6a, 1); ffButtonBackground.fillRoundedRect( this.fastForwardButton.x - ffButtonWidth / 2, this.fastForwardButton.y - ffButtonHeight / 2, ffButtonWidth, ffButtonHeight, 5 ); }); this.fastForwardButton.on('pointerout', () => { this.fastForwardButton.setStyle({ fill: '#ffffff' }); ffButtonBackground.clear(); ffButtonBackground.fillStyle(0x4a4a4a, 1); ffButtonBackground.fillRoundedRect( this.fastForwardButton.x - ffButtonWidth / 2, this.fastForwardButton.y - ffButtonHeight / 2, ffButtonWidth, ffButtonHeight, 5 ); }); } toggleGameSpeed() { if (this.gameSpeed === 1) { this.gameSpeed = 2; } else if (this.gameSpeed === 2) { this.gameSpeed = 4; } else { this.gameSpeed = 1; } this.fastForwardButton.setText(`${this.gameSpeed}x`); this.time.timeScale = this.gameSpeed; // Update enemy speeds this.enemies.getChildren().forEach(enemy => { if (enemy.moveTween) { enemy.moveTween.timeScale = this.gameSpeed; } }); } placeCastle() { const castleX = this.targetX * this.map.tileWidth + this.map.tileWidth / 2; const castleY = this.targetY * this.map.tileHeight + this.map.tileHeight / 2; this.castle = this.add.image(castleX, castleY, 'castle'); this.castle.setOrigin(0.5, 0.5); this.castle.setScale(1); // Add player health bar this.playerHealthBar = this.add.rectangle( castleX, castleY - this.castle.height / 2 - 10, 64, 10, 0x00ff00 ); this.playerHealthBar.setOrigin(0.5, 0.5); // Add player health text this.playerHealthText = this.add.text( castleX, castleY - this.castle.height / 2 - 25, `${this.playerHealth}/10`, { fontSize: '16px', fill: '#ffffff' } ).setOrigin(0.5, 0.5); } createRestartButton() { const castleX = this.targetX * this.map.tileWidth + this.map.tileWidth / 2; const castleY = this.targetY * this.map.tileHeight + this.map.tileHeight / 2; this.createFastForwardButton(); this.restartButton = this.add.text(castleX - 30, castleY + this.castle.height / 2 + 30, 'Restart', { fontSize: '20px', fontFamily: 'Arial, sans-serif', fontWeight: 'bold', fill: '#ffffff', padding: { x: 14, y: 7 } }) .setOrigin(0.5) .setInteractive({ useHandCursor: true }) .on('pointerdown', this.restartGame) .setScrollFactor(0); // Add background and style const buttonWidth = this.restartButton.width + 28; const buttonHeight = this.restartButton.height + 14; const buttonBackground = this.add.graphics(); buttonBackground.fillStyle(0x4a4a4a, 1); buttonBackground.fillRoundedRect( this.restartButton.x - buttonWidth / 2, this.restartButton.y - buttonHeight / 2, buttonWidth, buttonHeight, 10 ); buttonBackground.setScrollFactor(0); this.restartButton.setDepth(1); // Add hover effect this.restartButton.on('pointerover', () => { this.restartButton.setStyle({ fill: '#ffff00' }); buttonBackground.clear(); buttonBackground.fillStyle(0x6a6a6a, 1); buttonBackground.fillRoundedRect( this.restartButton.x - buttonWidth / 2, this.restartButton.y - buttonHeight / 2, buttonWidth, buttonHeight, 15 ); }); this.restartButton.on('pointerout', () => { this.restartButton.setStyle({ fill: '#ffffff' }); buttonBackground.clear(); buttonBackground.fillStyle(0x4a4a4a, 1); buttonBackground.fillRoundedRect( this.restartButton.x - buttonWidth / 2, this.restartButton.y - buttonHeight / 2, buttonWidth, buttonHeight, 15 ); }); } restartGame() { // Simulate clicking twice this.simulateRestart(); this.time.delayedCall(100, () => { this.simulateRestart(); }); } simulateRestart() { // Stop all running timers and tweens this.time.removeAllEvents(); this.tweens.killAll(); // Clear all game objects this.towers.towers.forEach(tower => { if (tower.sprite) tower.sprite.destroy(); if (tower.fenceGraphics) tower.fenceGraphics.destroy(); if (tower.fenceLink) tower.fenceLink.destroy(); }); this.towers.towers = []; this.enemies.clear(true, true); this.projectiles.clear(true, true); // Remove all health bars and other game objects this.children.list.forEach(child => { if (child instanceof Phaser.GameObjects.Rectangle || child instanceof Phaser.GameObjects.Graphics || child instanceof Phaser.GameObjects.Line) { if (child !== this.playerHealthBar) { child.destroy(); } } }); // Destroy tower menu items this.towerMenuItems.forEach(item => { if (item.icon) item.icon.destroy(); if (item.costText) item.costText.destroy(); }); this.towerMenuItems = []; // Clear all pending timers and tweens this.towers.towers.forEach(tower => { if (tower.boostTimer) tower.boostTimer.remove(); }); // Reset the tower placement layer if (this.towerPlacementLayer && this.towerPlacementLayer.tilemapLayer) { this.towerPlacementLayer.tilemapLayer.getTilesWithin().forEach(tile => { if (tile.properties) { tile.properties.hasTower = false; } }); } else { console.log('Warning: towerPlacementLayer is not properly initialized'); } // Reset game state this.resetGameState(); // Recreate necessary game elements this.createStartButton(); this.towers.createTowerMenu(); this.placeCastle(); this.createFastForwardButton(); this.createRestartButton(); this.createGoldDisplay(); // Reset game speed this.time.timeScale = 1; this.gameSpeed = 1; // Remove game over text if it exists if (this.gameOverText) { this.gameOverText.destroy(); this.gameOverText = null; } // Re-enable input events this.input.on('pointermove', this.towers.updateTowerPreview, this.towers); this.input.on('pointerup', this.towers.placeTower, this.towers); console.log('Game restarted'); } createStartButton() { if (this.nextRoundButton) { this.nextRoundButton.destroy(); } const buttonHtml = this.createStylishButton('Start Round 1'); const startButton = this.add.dom(this.cameras.main.centerX, this.cameras.main.centerY) .createFromHTML(buttonHtml) .setOrigin(0.5) .addListener('click') .setScrollFactor(0); startButton.on('click', () => this.startRound()); this.nextRoundButton = startButton; // Set up auto-start timer this.autoStartTimer = this.time.delayedCall(5000, () => { if (this.nextRoundButton) { this.startRound(); } }, [], this); } createStylishButton(text) { return ` `; } createAnimations() { ['down', 'up', 'right', 'left'].forEach((direction, index) => { this.anims.create({ key: `walk-${direction}`, frames: this.anims.generateFrameNumbers('enemy', { start: index * 9, end: index * 9 + 5 }), frameRate: 30, repeat: -1, duration: 4860 }); }); ['down', 'up', 'right', 'left'].forEach((direction, index) => { this.anims.create({ key: `run-${direction}`, frames: this.anims.generateFrameNumbers('enemy', { frames: [ index * 9, index * 9 + 1, index * 9 + 6, index * 9 + 3, index * 9 + 4, index * 9 + 7 ] }), frameRate: 30, repeat: -1, duration: 3120 }); }); } startRound() { if (this.isGameOver) return; this.cleanupRoundTransition(); this.currentRound++; console.log(`Starting Round ${this.currentRound}`); this.enemiesRemaining = this.currentRound; this.spawnEnemy(); if (this.enemiesRemaining > 1) { this.enemySpawnTimer = this.time.addEvent({ delay: 1500, callback: this.spawnEnemy, callbackScope: this, repeat: this.enemiesRemaining - 2 }); } } cleanupRoundTransition() { if (this.nextRoundButton) { this.nextRoundButton.destroy(); this.nextRoundButton = null; } if (this.autoStartTimer) { this.autoStartTimer.remove(); this.autoStartTimer = null; } } spawnEnemy() { if (this.isGameOver) return; const startTile = [0, 2]; const enemyX = startTile[0] * this.map.tileWidth + this.map.tileWidth / 2; const enemyY = startTile[1] * this.map.tileHeight + this.map.tileHeight / 2; const enemy = this.physics.add.sprite(enemyX, enemyY, 'enemy'); this.enemies.add(enemy); const collisionSize = this.map.tileWidth; enemy.body.setSize(collisionSize, collisionSize); const offsetX = (enemy.width - collisionSize) / 2; const offsetY = (enemy.height - collisionSize) / 2; enemy.body.setOffset(offsetX, offsetY); this.physics.add.collider(enemy, this.layer); enemy.health = 5 + this.currentRound; enemy.maxHealth = enemy.health; enemy.isSlowed = false; enemy.healthBar = this.add.rectangle( enemy.x, enemy.y - enemy.height / 2 - 5, 32, 5, 0xff0000 ); enemy.path = this.findPath(startTile[0], startTile[1]); this.moveEnemyAlongPath(enemy); console.log('Enemy spawned at:', enemyX, enemyY); } findPath(startX, startY) { const graph = new Graph(this.map.width, this.map.height, this.layer); const start = graph.grid[startY][startX]; const end = graph.grid[this.targetY][this.targetX]; const astar = new AStarFinder(); return astar.findPath(start, end, graph); } moveEnemyAlongPath(enemy) { if (!enemy.active || this.isGameOver || enemy.stunned) return; if (!enemy.path || enemy.path.length === 0) { if (enemy.remainingPath && enemy.remainingPath.length > 0) { enemy.path = enemy.remainingPath; enemy.remainingPath = null; } else { console.log('Enemy reached the target!'); this.damagePlayer(enemy); return; } } const current = enemy.path[0]; const next = enemy.path[1] || enemy.path[0]; const nextX = next[0] * this.map.tileWidth + this.map.tileWidth / 2; const nextY = next[1] * this.map.tileHeight + this.map.tileHeight / 2; let direction; if (next[0] > current[0]) direction = 'right'; else if (next[0] < current[0]) direction = 'left'; else if (next[1] > current[1]) direction = 'down'; else direction = 'up'; enemy.play(`walk-${direction}`, true); const baseDuration = 571; let duration = enemy.isSlowed ? baseDuration * 2 : baseDuration; if (enemy.moveTween) { enemy.moveTween.stop(); } enemy.moveTween = this.tweens.add({ targets: [enemy, enemy.healthBar], x: nextX, y: { value: nextY, ease: 'Linear', duration: duration, onUpdate: () => { if (enemy.active) { enemy.healthBar.y = enemy.y - enemy.height / 2 - 5; } } }, duration: duration, ease: 'Linear', onComplete: () => { if (enemy.active) { enemy.path.shift(); enemy.currentPathIndex = (enemy.currentPathIndex || 0) + 1; if (enemy.path.length > 0) { this.moveEnemyAlongPath(enemy); } else { this.damagePlayer(enemy); } } } }); enemy.moveTween.timeScale = this.gameSpeed; } damagePlayer(enemy) { console.log('Player damaged!'); this.playerHealth -= 1; this.updatePlayerHealth(); this.removeEnemy(enemy); if (this.playerHealth <= 0 && !this.isGameOver) { this.gameOver(); } } updatePlayerHealth() { this.playerHealthBar.width = (this.playerHealth / 10) * 64; this.playerHealthText.setText(`${this.playerHealth}/10`); } gameOver() { console.log('Game Over!'); this.isGameOver = true; // Stop all running timers this.time.removeAllEvents(); // Stop all tweens this.tweens.killAll(); this.gameOverText = this.add.text(this.cameras.main.centerX, this.cameras.main.centerY, `GAME OVER!\nYou reached Round ${this.currentRound}`, { fontSize: '48px', fill: '#ffffff', align: 'center' }).setOrigin(0.5).setScrollFactor(0); // Remove event listeners this.input.off('pointermove', this.towers.updateTowerPreview, this.towers); this.input.off('pointerup', this.towers.placeTower, this.towers); // Disable the next round button if it exists if (this.nextRoundButton) { this.nextRoundButton.disableInteractive(); this.nextRoundButton.setVisible(false); } } update(time, delta) { if (this.isGameOver) return; this.enemies.getChildren().forEach(enemy => { if (enemy.active && enemy.healthBar) { enemy.healthBar.x = enemy.x; enemy.healthBar.y = enemy.y - enemy.height / 2 - 5; enemy.healthBar.width = (enemy.health / enemy.maxHealth) * 32; } }); this.towers.towers.forEach(tower => { if (tower && tower.type && tower.upgrades) { if (tower.upgrades.includes('pulse')) { if (time > tower.lastFired + tower.type.fireRate / this.gameSpeed) { const enemiesInRange = this.towers.firePulse(tower); if (enemiesInRange) { tower.lastFired = time; } } } else if (tower.upgrades.includes('fence')) { if (time > tower.lastFired + tower.type.fireRate / this.gameSpeed) { this.towers.fireFence(tower); tower.lastFired = time; } } else if (tower.upgrades.includes('boost')) { if (time > tower.lastFired + tower.type.fireRate / this.gameSpeed) { this.towers.applyBoost(tower); tower.lastFired = time; } } else { if (time > tower.lastFired + tower.type.fireRate / this.gameSpeed) { const enemyInRange = this.towers.findEnemyInRange(tower); if (enemyInRange) { this.towers.fireTower(tower, enemyInRange, time); tower.lastFired = time; } } } } }); // Reapply boosts every second if (time > (this.lastBoostUpdate || 0) + 1000) { this.towers.towers.forEach(tower => { if (tower.upgrades && tower.upgrades.includes('boost')) { this.towers.applyBoost(tower); } }); this.lastBoostUpdate = time; } this.projectiles.getChildren().forEach(projectile => { if (projectile.target && projectile.target.active) { const angle = Phaser.Math.Angle.Between(projectile.x, projectile.y, projectile.target.x, projectile.target.y); projectile.setRotation(angle); this.physics.moveTo(projectile, projectile.target.x, projectile.target.y, 200 * this.gameSpeed); } else { projectile.destroy(); } }); this.physics.overlap(this.projectiles, this.enemies, this.hitEnemy, null, this); } hitEnemy(projectile, enemy) { projectile.destroy(); enemy.health -= projectile.tower.type.damage; if (projectile.tower.type.name.includes('Shock')) { const scaledStunDuration = projectile.tower.type.baseStunDuration * (projectile.tower.type.damage / 1.5); this.stunEnemy(enemy, scaledStunDuration); } else if (projectile.tower.type.name.includes('Frost')) { const scaledSlowDuration = projectile.tower.type.baseSlowDuration * (projectile.tower.type.damage / 0.7); this.slowEnemy(enemy, scaledSlowDuration); } else if (projectile.tower.type.name.includes('Flame')) { this.applyDotToEnemy(enemy, projectile.tower.type.dotDuration, projectile.tower); } // Apply super tower effects if (projectile.tower.type.isSuper) { switch (projectile.tower.type.name) { case 'Super Shock': this.applyChainLightning(enemy, projectile.tower); break; case 'Super Frost': this.applyFreezingNova(enemy, projectile.tower); break; case 'Super Flame': this.applyExplosiveFireball(enemy, projectile.tower); break; } } if (enemy.health <= 0) { this.destroyEnemy(enemy); } } applyChainLightning(primaryTarget, tower) { const chainRange = tower.type.range * this.map.tileWidth; const maxJumps = 3; const chainDamage = tower.type.damage; const scaledStunDuration = tower.type.baseStunDuration * (tower.type.damage / 1.5); let currentTarget = primaryTarget; let jumps = 0; let hitTargets = [primaryTarget]; // Stun and damage the primary target primaryTarget.health -= chainDamage; this.stunEnemy(primaryTarget, scaledStunDuration); if (primaryTarget.health <= 0) { this.destroyEnemy(primaryTarget); } while (jumps < maxJumps) { const nextTarget = this.findNearestEnemy(currentTarget, chainRange, hitTargets); if (!nextTarget) break; nextTarget.health -= chainDamage; this.createLightningEffect(currentTarget, nextTarget); this.stunEnemy(nextTarget, scaledStunDuration); if (nextTarget.health <= 0) { this.destroyEnemy(nextTarget); } hitTargets.push(nextTarget); currentTarget = nextTarget; jumps++; } } applyFreezingNova(target, tower) { const novaRange = tower.type.range * this.map.tileWidth; const scaledFreezeDuration = tower.type.baseSlowDuration * (tower.type.damage / 0.7) * 2; // Doubled for super tower effect this.enemies.getChildren().forEach(enemy => { if (enemy !== target && Phaser.Math.Distance.Between(target.x, target.y, enemy.x, enemy.y) <= novaRange) { this.slowEnemy(enemy, scaledFreezeDuration); enemy.setTint(0x00FFFF); } }); this.createFreezingNovaEffect(target, novaRange); } applyExplosiveFireball(target, tower) { const explosionRange = tower.type.range * this.map.tileWidth; const explosionDamage = tower.type.damage; const burnDuration = tower.type.dotDuration; this.enemies.getChildren().forEach(enemy => { if (Phaser.Math.Distance.Between(target.x, target.y, enemy.x, enemy.y) <= explosionRange) { enemy.health -= explosionDamage; this.applyDotToEnemy(enemy, burnDuration, tower); if (enemy.health <= 0) { this.destroyEnemy(enemy); } } }); this.createExplosionEffect(target, explosionRange); this.createBurningGroundEffect(target, explosionRange); } findNearestEnemy(source, range, excludeList = []) { let nearestEnemy = null; let nearestDistance = Infinity; this.enemies.getChildren().forEach(enemy => { if (!excludeList.includes(enemy)) { const distance = Phaser.Math.Distance.Between(source.x, source.y, enemy.x, enemy.y); if (distance <= range && distance < nearestDistance) { nearestEnemy = enemy; nearestDistance = distance; } } }); return nearestEnemy; } createLightningEffect(source, target) { const lightning = this.add.line(0, 0, source.x, source.y, target.x, target.y, 0xFFFF00); lightning.setLineWidth(2); this.tweens.add({ targets: lightning, alpha: 0, duration: 200, ease: 'Power2', onComplete: () => lightning.destroy() }); } createFreezingNovaEffect(center, radius) { const nova = this.add.circle(center.x, center.y, radius, 0x00FFFF, 0.3); this.tweens.add({ targets: nova, scale: 1.2, alpha: 0, duration: 500, ease: 'Power2', onComplete: () => nova.destroy() }); } createExplosionEffect(center, radius) { const explosion = this.add.circle(center.x, center.y, radius, 0xFF0000, 0.5); this.tweens.add({ targets: explosion, scale: 1.5, alpha: 0, duration: 300, ease: 'Power2', onComplete: () => explosion.destroy() }); } createBurningGroundEffect(center, radius) { const burningGround = this.add.circle(center.x, center.y, radius, 0xFF4500, 0.3); this.tweens.add({ targets: burningGround, alpha: 0, duration: 3000, ease: 'Power2', onComplete: () => burningGround.destroy() }); } stunEnemy(enemy, duration) { if (enemy.stunTimer) { enemy.stunTimer.remove(false); } enemy.setTint(0xFFFF00); enemy.stunned = true; if (enemy.moveTween) { enemy.moveTween.stop(); enemy.remainingPath = enemy.path.slice(enemy.currentPathIndex); } enemy.stunTimer = this.time.delayedCall(duration / this.gameSpeed, () => { if (enemy.active) { enemy.clearTint(); enemy.stunned = false; this.moveEnemyAlongPath(enemy); } }); } slowEnemy(enemy, duration) { if (enemy.slowTimer) { enemy.slowTimer.remove(false); } enemy.setTint(0x00FFFF); enemy.isSlowed = true; if (enemy.moveTween) { enemy.moveTween.timeScale = 0.5; } enemy.slowTimer = this.time.delayedCall(duration / this.gameSpeed, () => { if (enemy.active) { this.removeSlowEffect(enemy); } }); } removeSlowEffect(enemy) { enemy.clearTint(); enemy.isSlowed = false; if (enemy.moveTween) { enemy.moveTween.timeScale = 1; } else { this.moveEnemyAlongPath(enemy); } } applyDotToEnemy(enemy, duration, tower) { if (enemy.dotTimer) { enemy.dotTimer.remove(); } enemy.setTint(0xFF0000); const tickInterval = 300; // Apply damage every 300ms const totalTicks = duration / tickInterval; const tickDamage = tower && tower.type ? tower.type.damage * 0.1 : 0.1; // 10% of tower's current damage per tick, or 0.1 if tower is undefined enemy.dotTimer = this.time.addEvent({ delay: tickInterval, callback: () => { if (enemy.active) { enemy.health -= tickDamage; if (enemy.health <= 0) { this.destroyEnemy(enemy); } } }, repeat: totalTicks - 1 }); this.time.delayedCall(duration, () => { if (enemy.active) { enemy.clearTint(); } }); } destroyEnemy(enemy) { this.removeEnemy(enemy); this.gold += 20; this.updateGoldDisplay(); console.log('Enemy destroyed! +20 gold'); } removeEnemy(enemy) { if (enemy.healthBar) enemy.healthBar.destroy(); if (enemy.moveTween) enemy.moveTween.stop(); enemy.destroy(); this.enemiesRemaining--; this.checkRoundEnd(); } checkRoundEnd() { if (this.enemiesRemaining <= 0 && this.enemies.getChildren().length === 0 && !this.isGameOver) { this.endRound(); } } endRound() { console.log(`Round ${this.currentRound} completed!`); if (!this.isGameOver) { this.cleanupRoundTransition(); this.createNextRoundButton(); } } createNextRoundButton() { if (this.isGameOver) return; const buttonHtml = this.createStylishButton(`Start Round ${this.currentRound + 1}`); this.nextRoundButton = this.add.dom(this.cameras.main.centerX, this.cameras.main.centerY) .createFromHTML(buttonHtml) .setOrigin(0.5) .addListener('click') .setScrollFactor(0); this.nextRoundButton.on('click', this.startRound); // Set up auto-start timer this.autoStartTimer = this.time.delayedCall(5000, () => { if (this.nextRoundButton) { this.startRound(); } }, [], this); } updateGoldDisplay() { if (this.goldDisplay) { const goldContainer = this.goldDisplay.node; goldContainer.innerHTML = `💰${this.gold}`; } } createHelpButton() { const helpButton = this.add.text(10, this.cameras.main.height - 10, '?', { fontSize: '32px', fontStyle: 'bold', backgroundColor: '#4CAF50', padding: { x: 10, y: 5 }, borderRadius: 5 }) .setOrigin(+2, 1) .setInteractive({ useHandCursor: true }) .on('pointerdown', this.showHelpImage, this) .setScrollFactor(0); // Add hover effect helpButton.on('pointerover', () => helpButton.setStyle({ fill: '#ffff00' })); helpButton.on('pointerout', () => helpButton.setStyle({ fill: '#ffffff' })); } showHelpImage() { if (this.helpImage) { this.hideHelpImage(); return; } this.helpImage = this.add.image(this.cameras.main.centerX, this.cameras.main.centerY, 'helpImage') .setOrigin(0.5) .setScrollFactor(0); // Scale the image to fit the screen while maintaining aspect ratio const scaleX = this.cameras.main.width / this.helpImage.width; const scaleY = this.cameras.main.height / this.helpImage.height; const scale = Math.min(scaleX, scaleY) * 0.9; // 90% of the screen size this.helpImage.setScale(scale); // Add close button this.closeButton = this.add.text(this.cameras.main.centerX + (this.helpImage.displayWidth / 2) - 20, this.cameras.main.centerY - (this.helpImage.displayHeight / 2) + 20, 'X', { fontSize: '24px', fontStyle: 'bold', backgroundColor: '#ff0000', padding: { x: 10, y: 5 }, borderRadius: 5 }) .setOrigin(1, 0) .setInteractive({ useHandCursor: true }) .on('pointerdown', this.hideHelpImage, this) .setScrollFactor(0); // Add hover effect for close button this.closeButton.on('pointerover', () => this.closeButton.setStyle({ fill: '#ffff00' })); this.closeButton.on('pointerout', () => this.closeButton.setStyle({ fill: '#ffffff' })); } hideHelpImage() { if (this.helpImage) { this.helpImage.destroy(); this.helpImage = null; } if (this.closeButton) { this.closeButton.destroy(); this.closeButton = null; } } } class Graph { constructor(width, height, layer) { this.width = width; this.height = height; this.grid = []; for (let y = 0; y < height; y++) { this.grid[y] = []; for (let x = 0; x < width; x++) { const tile = layer.getTileAt(x, y); this.grid[y][x] = new Node(x, y, tile && !tile.collides); } } } getNeighbors(node) { const ret = []; const { x, y } = node; if (this.grid[y - 1] && this.grid[y - 1][x]) { ret.push(this.grid[y - 1][x]); } if (this.grid[y + 1] && this.grid[y + 1][x]) { ret.push(this.grid[y + 1][x]); } if (this.grid[y][x - 1]) { ret.push(this.grid[y][x - 1]); } if (this.grid[y][x + 1]) { ret.push(this.grid[y][x + 1]); } return ret.filter(node => node.walkable); } } class Node { constructor(x, y, walkable) { this.x = x; this.y = y; this.walkable = walkable; } } class AStarFinder { constructor() {} findPath(startNode, endNode, graph) { const openList = []; const closedList = new Set(); startNode.g = 0; startNode.h = this.heuristic(startNode, endNode); startNode.f = startNode.h; openList.push(startNode); while (openList.length > 0) { const currentNode = this.getLowestFNode(openList); if (currentNode === endNode) { return this.reconstructPath(currentNode); } this.removeFromArray(openList, currentNode); closedList.add(currentNode); const neighbors = graph.getNeighbors(currentNode); for (const neighbor of neighbors) { if (closedList.has(neighbor)) { continue; } const tentativeG = currentNode.g + 1; if (!openList.includes(neighbor)) { openList.push(neighbor); } else if (tentativeG >= neighbor.g) { continue; } neighbor.parent = currentNode; neighbor.g = tentativeG; neighbor.h = this.heuristic(neighbor, endNode); neighbor.f = neighbor.g + neighbor.h; } } return null; } heuristic(nodeA, nodeB) { return Math.abs(nodeA.x - nodeB.x) + Math.abs(nodeA.y - nodeB.y); } getLowestFNode(list) { return list.reduce((lowest, node) => (!lowest || node.f < lowest.f ? node : lowest)); } removeFromArray(array, element) { const index = array.indexOf(element); if (index !== -1) { array.splice(index, 1); } } reconstructPath(node) { const path = []; let currentNode = node; while (currentNode.parent) { path.unshift([currentNode.x, currentNode.y]); currentNode = currentNode.parent; } return path; } } 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: 600 }, physics: { default: 'arcade', arcade: { gravity: { y: 0 }, debug: false } }, scene: [LoadingScene, Game], dom: { createContainer: true }, plugins: { scene: [{ key: 'DOMPlugin', plugin: Phaser.Plugins.ScenePlugin.DOMElementsPlugin, mapping: 'dom' }] } }; window.phaserGame = new Phaser.Game(config);