Play
:quality(85)/https://cdn.frvr.ai/68895b05cba85a67b70f7b1c.png)
:quality(85)/https://cdn.frvr.ai/68895b7ecba85a67b70f7b3c.png)
#TowerDefenseRemix
# turrets
# waves
#energy
# futuristic
#animals
# robots
# strategy
#tower defense
Creation History
User prompt
muy bien asi que quiero que mejores la interfaz de inicio en la que muestra la historia ya que los textos se salen de la pantalla
User prompt
No estás usando los assets de los iconos de energía escudo y sobre además no me gusta el fondo de estos que es el ui panel así que quitarlo y solo dejar los iconos
User prompt
Quiero que quites la el assets de la barra de progreso ya que no me gusta como se ve además reajusta la posicion del inicio del juego que es la introducción a la misión ya que sale en una esquina de la pantalla y no deja leer lo que dice
User prompt
No es necesario mostrar la barra de progreso pero si hacer más notorio el tiempo que falta para que empieze la otra oleada ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
Vale casi te faltó crear los assets para las imágenes de la energía los escudos y el puntaje además quiero que las balas de las torretas los Sprites sean el doble de grandes
User prompt
Muy bien con gameplay y mapa listos solo falta que mejoremos las interfaces del Game como la barra de progreso de los niveles tiene que ser más futurista y dinámica si como los menús de las torretas y la energía los escudos y el puntaje que están en la parte superior sean assets para yo poner sus respectivas imágenes ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
Muy bien ahora que los enemigos puedan andar sobre todas las celdas en que halla cintas transportadoras
User prompt
Muy bien ahora me gustaría que fueran el doble de grandes los Sprites tanto de las torretas como de los enemigos además que cuando se le da con balas de hielo a los enemigos se pongan azules y cuando se les da con balas de fuego se pongan naranjas ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
Muy bien casi está perfecto solo intenta cumplir esta condiciones y quedará perfecto. 1 que los enchufes estén literalmente al lado de los caminos. 2 que no se sobre pongan un enchufe encima de otro y 3 que la torretas tengan el doble de su rango actual
User prompt
Bien ahora mejoraremos el mapa y la lógica del Spawn y colicion de los enemigos. Básicamente hacer que los enemigos aparezcan en los 2 caminos designados y que los enchufes para poner torretas hallan más osea agregando uno junto a otro de forma vertical
User prompt
Muy bien ya casi está listo arreglemos unos detalles como lo es que los botones de las torretas tengan el mismo diseño de las torretas en cuestión y la previsualización de igual forma los assets de las torretas en cuestión
User prompt
me encanto asi es como buscaba el mapa solo hay que arrglar una cosa y es que la parte superior del mapa los caminos se fusiones o se junten asi de entrada tienen mucho espachio y luego se dividen en los caminos que ya tenemos
User prompt
muy bien ahora nececito que los enchufes esten mas cerca de los caminos literalmente que esten pegados uno al lado del otro
User prompt
sale el texto tower would block the path al querer poner la torreta encima del enchufe
User prompt
sigue sin dejar poner las torretas encima de los enchufes
User prompt
las torretas no deja ponerlas en los enchufes
User prompt
te falta mejorar la distribucion del mapa para que sea logico y ordenado
User prompt
tienes que mejorar la logica de los caminos y enchufes te lo voy a describir de arriba hacia abajo empezando en la parte superior es un camino en la parte central de 6 celdas la cual avanza 3 celdas y se divide en 2 caminos la division es de 2 celdas en dicha devicion hacia abajo son solo enchufes y los caminos de 3 celdas cada uno asi se quedan hasta abajo y a los laterales de los caminos tambien una fila de enchufes hacia abajo
User prompt
mejoremos el a distribucion del mapa y es que el camino en realidad sean 2 caminos de 3 celdas de ancho cada una las cuales por la mitad las separa una columna de encufes bases de las torretas y claramente en los otros extremos del camino las otras columnas de enchufes las bases de las torretas
User prompt
vale me gusta el resultado pero el camino de cinco tapa mucho el dibujo del fondo así que podriamos agregarle transparencia al camino para que asi se vea el fondo
User prompt
me gusta como va quedando el mapa pero creo que el tema de los elementos decorativos y el suelo so se ven tan llamativos para nuestro tower defense asi que lo quiero cambiar por una sola imagen que sera el fondo del entorno
User prompt
los muros que delimitan todo el mapa falta que le crees su propio assets y que ese si sea 1x1
User prompt
me encanta pero quiero que de manera inteligente redistribuyas el mapa siguiendo un orden y logica acorde al objetivo y trama del juego. 1: el juego es un tower defense por ende hay un camino por donde caminan los enemigos hasta llegar a su objetivo y destruirlo ademas a los lados del camino estan las bases o enchufes para poder dejar hay las torretas que destruiran a los enemigos 2: el entorno del mapa es como una fabrica de electicidad pr ende debe tener logica los elementos decorativos del mapa
User prompt
me encanto lo que se hico de pasarlo de un 1x1 a un 2x2 asiq ue lo vamos aplicar en los elementos decorativos del mapa es decir a electronic_chip, metal_crate, battery_pack, scaffolding y metal_pipe
/****
* Plugins
****/
var tween = LK.import("@upit/tween.v1");
/****
* Classes
****/
var Bullet = Container.expand(function (startX, startY, targetEnemy, damage, speed) {
var self = Container.call(this);
self.targetEnemy = targetEnemy;
self.damage = damage || 10;
self.speed = speed || 5;
self.x = startX;
self.y = startY;
var bulletGraphics = self.attachAsset('bullet', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 2,
scaleY: 2
});
self.update = function () {
if (!self.targetEnemy || !self.targetEnemy.parent) {
self.destroy();
return;
}
var dx = self.targetEnemy.x - self.x;
var dy = self.targetEnemy.y - self.y;
var distance = Math.sqrt(dx * dx + dy * dy);
if (distance < self.speed) {
// Apply damage to target enemy
self.targetEnemy.health -= self.damage;
if (self.targetEnemy.health <= 0) {
self.targetEnemy.health = 0;
} else {
self.targetEnemy.healthBar.width = self.targetEnemy.health / self.targetEnemy.maxHealth * 70;
}
// Apply special effects based on bullet type
if (self.type === 'splash') {
// Create visual splash effect
var splashEffect = new EffectIndicator(self.targetEnemy.x, self.targetEnemy.y, 'splash');
game.addChild(splashEffect);
// Splash damage to nearby enemies
var splashRadius = CELL_SIZE * 1.5;
for (var i = 0; i < enemies.length; i++) {
var otherEnemy = enemies[i];
if (otherEnemy !== self.targetEnemy) {
var splashDx = otherEnemy.x - self.targetEnemy.x;
var splashDy = otherEnemy.y - self.targetEnemy.y;
var splashDistance = Math.sqrt(splashDx * splashDx + splashDy * splashDy);
if (splashDistance <= splashRadius) {
// Apply splash damage (50% of original damage)
otherEnemy.health -= self.damage * 0.5;
if (otherEnemy.health <= 0) {
otherEnemy.health = 0;
} else {
otherEnemy.healthBar.width = otherEnemy.health / otherEnemy.maxHealth * 70;
}
}
}
}
} else if (self.type === 'slow') {
// Prevent slow effect on immune enemies
if (!self.targetEnemy.isImmune) {
// Create visual slow effect
var slowEffect = new EffectIndicator(self.targetEnemy.x, self.targetEnemy.y, 'slow');
game.addChild(slowEffect);
// Apply slow effect
// Make slow percentage scale with tower level (default 50%, up to 80% at max level)
var slowPct = 0.5;
if (self.sourceTowerLevel !== undefined) {
// Scale: 50% at level 1, 60% at 2, 65% at 3, 70% at 4, 75% at 5, 80% at 6
var slowLevels = [0.5, 0.6, 0.65, 0.7, 0.75, 0.8];
var idx = Math.max(0, Math.min(5, self.sourceTowerLevel - 1));
slowPct = slowLevels[idx];
}
if (!self.targetEnemy.slowed) {
self.targetEnemy.originalSpeed = self.targetEnemy.speed;
self.targetEnemy.speed *= 1 - slowPct; // Slow by X%
self.targetEnemy.slowed = true;
self.targetEnemy.slowDuration = 180; // 3 seconds at 60 FPS
} else {
self.targetEnemy.slowDuration = 180; // Reset duration
}
}
} else if (self.type === 'poison') {
// Prevent poison effect on immune enemies
if (!self.targetEnemy.isImmune) {
// Create visual poison effect
var poisonEffect = new EffectIndicator(self.targetEnemy.x, self.targetEnemy.y, 'poison');
game.addChild(poisonEffect);
// Apply poison effect
self.targetEnemy.poisoned = true;
self.targetEnemy.poisonDamage = self.damage * 0.2; // 20% of original damage per tick
self.targetEnemy.poisonDuration = 300; // 5 seconds at 60 FPS
}
} else if (self.type === 'sniper') {
// Create visual critical hit effect for sniper
var sniperEffect = new EffectIndicator(self.targetEnemy.x, self.targetEnemy.y, 'sniper');
game.addChild(sniperEffect);
}
self.destroy();
} else {
var angle = Math.atan2(dy, dx);
self.x += Math.cos(angle) * self.speed;
self.y += Math.sin(angle) * self.speed;
}
};
return self;
});
var DebugCell = Container.expand(function () {
var self = Container.call(this);
var cellGraphics = self.attachAsset('cell', {
anchorX: 0.5,
anchorY: 0.5
});
cellGraphics.tint = Math.random() * 0xffffff;
var debugArrows = [];
var numberLabel = new Text2('0', {
size: 30,
fill: 0xFFFFFF,
weight: 800
});
numberLabel.anchor.set(.5, .5);
self.addChild(numberLabel);
self.update = function () {};
self.down = function () {
return;
if (self.cell.type == 0 || self.cell.type == 1) {
self.cell.type = self.cell.type == 1 ? 0 : 1;
if (grid.pathFind()) {
self.cell.type = self.cell.type == 1 ? 0 : 1;
grid.pathFind();
var notification = game.addChild(new Notification("Path is blocked!"));
notification.x = 2048 / 2;
notification.y = grid.height - 50;
}
grid.renderDebug();
}
};
self.removeArrows = function () {
while (debugArrows.length) {
self.removeChild(debugArrows.pop());
}
};
self.render = function (data) {
switch (data.type) {
case 0:
case 2:
{
if (data.pathId != pathId) {
self.removeArrows();
numberLabel.setText("-");
cellGraphics.tint = 0x880000;
return;
}
numberLabel.visible = true;
var tint = Math.floor(data.score / maxScore * 0x88);
var towerInRangeHighlight = false;
if (selectedTower && data.towersInRange && data.towersInRange.indexOf(selectedTower) !== -1) {
towerInRangeHighlight = true;
cellGraphics.tint = 0x0088ff;
} else {
cellGraphics.tint = 0x88 - tint << 8 | tint;
}
while (debugArrows.length > data.targets.length) {
self.removeChild(debugArrows.pop());
}
for (var a = 0; a < data.targets.length; a++) {
var destination = data.targets[a];
var ox = destination.x - data.x;
var oy = destination.y - data.y;
var angle = Math.atan2(oy, ox);
if (!debugArrows[a]) {
debugArrows[a] = LK.getAsset('arrow', {
anchorX: -.5,
anchorY: 0.5
});
debugArrows[a].alpha = .5;
self.addChildAt(debugArrows[a], 1);
}
debugArrows[a].rotation = angle;
}
break;
}
case 1:
{
self.removeArrows();
cellGraphics.tint = 0xaaaaaa;
numberLabel.visible = false;
break;
}
case 3:
{
self.removeArrows();
cellGraphics.tint = 0x008800;
numberLabel.visible = false;
break;
}
}
numberLabel.setText(Math.floor(data.score / 1000) / 10);
};
});
// This update method was incorrectly placed here and should be removed
var EffectIndicator = Container.expand(function (x, y, type) {
var self = Container.call(this);
self.x = x;
self.y = y;
var effectGraphics = self.attachAsset('rangeCircle', {
anchorX: 0.5,
anchorY: 0.5
});
effectGraphics.blendMode = 1;
switch (type) {
case 'splash':
effectGraphics.tint = 0x33CC00;
effectGraphics.width = effectGraphics.height = CELL_SIZE * 1.5;
break;
case 'slow':
effectGraphics.tint = 0x9900FF;
effectGraphics.width = effectGraphics.height = CELL_SIZE;
break;
case 'poison':
effectGraphics.tint = 0x00FFAA;
effectGraphics.width = effectGraphics.height = CELL_SIZE;
break;
case 'sniper':
effectGraphics.tint = 0xFF5500;
effectGraphics.width = effectGraphics.height = CELL_SIZE;
break;
}
effectGraphics.alpha = 0.7;
self.alpha = 0;
// Animate the effect
tween(self, {
alpha: 0.8,
scaleX: 1.5,
scaleY: 1.5
}, {
duration: 200,
easing: tween.easeOut,
onFinish: function onFinish() {
tween(self, {
alpha: 0,
scaleX: 2,
scaleY: 2
}, {
duration: 300,
easing: tween.easeIn,
onFinish: function onFinish() {
self.destroy();
}
});
}
});
return self;
});
// Base enemy class for common functionality
var Enemy = Container.expand(function (type) {
var self = Container.call(this);
self.type = type || 'normal';
self.speed = .01;
self.cellX = 0;
self.cellY = 0;
self.currentCellX = 0;
self.currentCellY = 0;
self.currentTarget = undefined;
self.maxHealth = 100;
self.health = self.maxHealth;
self.bulletsTargetingThis = [];
self.waveNumber = currentWave;
self.isFlying = false;
self.isImmune = false;
self.isBoss = false;
// Check if this is a boss wave
// Check if this is a boss wave
// Apply different stats based on enemy type
switch (self.type) {
case 'fast':
self.speed *= 2; // Twice as fast
self.maxHealth = 100;
break;
case 'immune':
self.isImmune = true;
self.maxHealth = 80;
break;
case 'flying':
self.isFlying = true;
self.maxHealth = 80;
break;
case 'swarm':
self.maxHealth = 50; // Weaker enemies
break;
case 'normal':
default:
// Normal enemy uses default values
break;
}
if (currentWave % 10 === 0 && currentWave > 0 && type !== 'swarm') {
self.isBoss = true;
// Boss enemies have 20x health and are larger
self.maxHealth *= 20;
// Slower speed for bosses
self.speed = self.speed * 0.7;
}
self.health = self.maxHealth;
// Get appropriate robot image asset for this enemy type
var assetId = 'robot_raccoon';
switch (self.type) {
case 'fast':
assetId = 'robot_fox';
break;
case 'immune':
assetId = 'robot_turtle';
break;
case 'flying':
assetId = 'robot_crow';
break;
case 'swarm':
assetId = 'robot_mouse';
break;
}
// Use boss version if this is a boss enemy
if (self.isBoss && self.type !== 'swarm') {
switch (self.type) {
case 'fast':
assetId = 'robot_fox_boss';
break;
case 'immune':
assetId = 'robot_turtle_boss';
break;
case 'flying':
assetId = 'robot_crow_boss';
break;
default:
assetId = 'robot_raccoon_boss';
}
}
var enemyGraphics = self.attachAsset(assetId, {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 2,
scaleY: 2
});
// Boss enemies already use larger image assets, no need to scale
// Fall back to regular enemy asset if specific type asset not found
// Apply tint to differentiate enemy types
/*switch (self.type) {
case 'fast':
enemyGraphics.tint = 0x00AAFF; // Blue for fast enemies
break;
case 'immune':
enemyGraphics.tint = 0xAA0000; // Red for immune enemies
break;
case 'flying':
enemyGraphics.tint = 0xFFFF00; // Yellow for flying enemies
break;
case 'swarm':
enemyGraphics.tint = 0xFF00FF; // Pink for swarm enemies
break;
}*/
// Create shadow for flying enemies
if (self.isFlying) {
// Create a shadow container that will be added to the shadow layer
self.shadow = new Container();
// Clone the enemy graphics for the shadow
var shadowGraphics = self.shadow.attachAsset(assetId, {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 2,
scaleY: 2
});
// Apply shadow effect
shadowGraphics.tint = 0x000000; // Black shadow
shadowGraphics.alpha = 0.4; // Semi-transparent
// Boss shadows already use larger image assets, no need to scale
// Position shadow slightly offset
self.shadow.x = 20; // Offset right
self.shadow.y = 20; // Offset down
// Ensure shadow has the same rotation as the enemy
shadowGraphics.rotation = enemyGraphics.rotation;
}
var healthBarOutline = self.attachAsset('healthBarOutline', {
anchorX: 0,
anchorY: 0.5
});
var healthBarBG = self.attachAsset('healthBar', {
anchorX: 0,
anchorY: 0.5
});
var healthBar = self.attachAsset('healthBar', {
anchorX: 0,
anchorY: 0.5
});
healthBarBG.y = healthBarOutline.y = healthBar.y = -enemyGraphics.height / 2 - 10;
healthBarOutline.x = -healthBarOutline.width / 2;
healthBarBG.x = healthBar.x = -healthBar.width / 2 - .5;
healthBar.tint = 0x00ff00;
healthBarBG.tint = 0xff0000;
self.healthBar = healthBar;
self.update = function () {
if (self.health <= 0) {
self.health = 0;
self.healthBar.width = 0;
}
// Handle slow effect
if (self.isImmune) {
// Immune enemies cannot be slowed or poisoned, clear any such effects
self.slowed = false;
self.slowEffect = false;
self.poisoned = false;
self.poisonEffect = false;
// Reset speed to original if needed
if (self.originalSpeed !== undefined) {
self.speed = self.originalSpeed;
}
} else {
// Handle slow effect
if (self.slowed) {
// Visual indication of slowed status
if (!self.slowEffect) {
self.slowEffect = true;
}
self.slowDuration--;
if (self.slowDuration <= 0) {
self.speed = self.originalSpeed;
self.slowed = false;
self.slowEffect = false;
// Only reset tint if not poisoned
if (!self.poisoned) {
enemyGraphics.tint = 0xFFFFFF; // Reset tint
}
}
}
// Handle poison effect
if (self.poisoned) {
// Visual indication of poisoned status
if (!self.poisonEffect) {
self.poisonEffect = true;
}
// Apply poison damage every 30 frames (twice per second)
if (LK.ticks % 30 === 0) {
self.health -= self.poisonDamage;
if (self.health <= 0) {
self.health = 0;
}
self.healthBar.width = self.health / self.maxHealth * 70;
// Play damage sound when poisoned
LK.getSound('robot_damage').play();
}
self.poisonDuration--;
if (self.poisonDuration <= 0) {
self.poisoned = false;
self.poisonEffect = false;
// Only reset tint if not slowed
if (!self.slowed) {
enemyGraphics.tint = 0xFFFFFF; // Reset tint
}
}
}
}
// Set tint based on effect status
if (self.isImmune) {
enemyGraphics.tint = 0xFFFFFF;
} else if (self.poisoned && self.slowed) {
// Combine fire (orange) and ice (blue) colors when hit by both
enemyGraphics.tint = 0x8A4FFF; // Purple blend of orange and blue
} else if (self.poisoned) {
enemyGraphics.tint = 0xFF8C00; // Orange tint for fire/poison bullets
} else if (self.slowed) {
enemyGraphics.tint = 0x0080FF; // Blue tint for ice/slow bullets
} else {
enemyGraphics.tint = 0xFFFFFF;
}
if (self.currentTarget) {
var ox = self.currentTarget.x - self.currentCellX;
var oy = self.currentTarget.y - self.currentCellY;
if (ox !== 0 || oy !== 0) {
var angle = Math.atan2(oy, ox);
if (enemyGraphics.targetRotation === undefined) {
enemyGraphics.targetRotation = angle;
enemyGraphics.rotation = angle;
} else {
if (Math.abs(angle - enemyGraphics.targetRotation) > 0.05) {
tween.stop(enemyGraphics, {
rotation: true
});
// Calculate the shortest angle to rotate
var currentRotation = enemyGraphics.rotation;
var angleDiff = angle - currentRotation;
// Normalize angle difference to -PI to PI range for shortest path
while (angleDiff > Math.PI) {
angleDiff -= Math.PI * 2;
}
while (angleDiff < -Math.PI) {
angleDiff += Math.PI * 2;
}
enemyGraphics.targetRotation = angle;
tween(enemyGraphics, {
rotation: currentRotation + angleDiff
}, {
duration: 250,
easing: tween.easeOut
});
}
}
}
}
healthBarOutline.y = healthBarBG.y = healthBar.y = -enemyGraphics.height / 2 - 10;
};
return self;
});
var GoldIndicator = Container.expand(function (value, x, y) {
var self = Container.call(this);
var shadowText = new Text2("+" + value, {
size: 45,
fill: 0x000000,
weight: 800
});
shadowText.anchor.set(0.5, 0.5);
shadowText.x = 2;
shadowText.y = 2;
self.addChild(shadowText);
var goldText = new Text2("+" + value, {
size: 45,
fill: 0xFFD700,
weight: 800
});
goldText.anchor.set(0.5, 0.5);
self.addChild(goldText);
self.x = x;
self.y = y;
self.alpha = 0;
self.scaleX = 0.5;
self.scaleY = 0.5;
tween(self, {
alpha: 1,
scaleX: 1.2,
scaleY: 1.2,
y: y - 40
}, {
duration: 50,
easing: tween.easeOut,
onFinish: function onFinish() {
tween(self, {
alpha: 0,
scaleX: 1.5,
scaleY: 1.5,
y: y - 80
}, {
duration: 600,
easing: tween.easeIn,
delay: 800,
onFinish: function onFinish() {
self.destroy();
}
});
}
});
return self;
});
var Grid = Container.expand(function (gridWidth, gridHeight) {
var self = Container.call(this);
self.cells = [];
self.spawns = [];
self.goals = [];
for (var i = 0; i < gridWidth; i++) {
self.cells[i] = [];
for (var j = 0; j < gridHeight; j++) {
self.cells[i][j] = {
score: 0,
pathId: 0,
towersInRange: []
};
}
}
/*
Cell Types
0: Transparent floor
1: Wall
2: Spawn
3: Goal
*/
for (var i = 0; i < gridWidth; i++) {
for (var j = 0; j < gridHeight; j++) {
var cell = self.cells[i][j];
var cellType = i === 0 || i === gridWidth - 1 || j <= 4 || j >= gridHeight - 4 ? 1 : 0;
// Single spawn at top center of 6-cell path (x=9)
if (i === 9 && j === 0) {
cellType = 2;
self.spawns.push(cell);
}
// Dual goals at bottom of each 3-cell path
// Left path goal (center of left path at x=7)
if (i === 7 && j === gridHeight - 1) {
cellType = 3;
self.goals.push(cell);
}
// Right path goal (center of right path at x=16)
if (i === 16 && j === gridHeight - 1) {
cellType = 3;
self.goals.push(cell);
}
cell.type = cellType;
cell.x = i;
cell.y = j;
// Asset customization properties
cell.terrainAsset = null;
cell.decorationAsset = null;
cell.customProperties = {};
cell.upLeft = self.cells[i - 1] && self.cells[i - 1][j - 1];
cell.up = self.cells[i - 1] && self.cells[i - 1][j];
cell.upRight = self.cells[i - 1] && self.cells[i - 1][j + 1];
cell.left = self.cells[i][j - 1];
cell.right = self.cells[i][j + 1];
cell.downLeft = self.cells[i + 1] && self.cells[i + 1][j - 1];
cell.down = self.cells[i + 1] && self.cells[i + 1][j];
cell.downRight = self.cells[i + 1] && self.cells[i + 1][j + 1];
cell.neighbors = [cell.upLeft, cell.up, cell.upRight, cell.right, cell.downRight, cell.down, cell.downLeft, cell.left];
cell.targets = [];
if (j > 3 && j <= gridHeight - 4) {
var debugCell = new DebugCell();
self.addChild(debugCell);
debugCell.cell = cell;
debugCell.x = i * CELL_SIZE;
debugCell.y = j * CELL_SIZE;
cell.debugCell = debugCell;
}
}
}
self.getCell = function (x, y) {
return self.cells[x] && self.cells[x][y];
};
self.pathFind = function () {
var before = new Date().getTime();
var toProcess = self.goals.concat([]);
maxScore = 0;
pathId += 1;
for (var a = 0; a < toProcess.length; a++) {
toProcess[a].pathId = pathId;
}
function processNode(node, targetValue, targetNode) {
if (node && node.type != 1) {
if (node.pathId < pathId || targetValue < node.score) {
node.targets = [targetNode];
} else if (node.pathId == pathId && targetValue == node.score) {
node.targets.push(targetNode);
}
if (node.pathId < pathId || targetValue < node.score) {
node.score = targetValue;
if (node.pathId != pathId) {
toProcess.push(node);
}
node.pathId = pathId;
if (targetValue > maxScore) {
maxScore = targetValue;
}
}
}
}
while (toProcess.length) {
var nodes = toProcess;
toProcess = [];
for (var a = 0; a < nodes.length; a++) {
var node = nodes[a];
var targetScore = node.score + 14142;
if (node.up && node.left && node.up.type != 1 && node.left.type != 1) {
processNode(node.upLeft, targetScore, node);
}
if (node.up && node.right && node.up.type != 1 && node.right.type != 1) {
processNode(node.upRight, targetScore, node);
}
if (node.down && node.right && node.down.type != 1 && node.right.type != 1) {
processNode(node.downRight, targetScore, node);
}
if (node.down && node.left && node.down.type != 1 && node.left.type != 1) {
processNode(node.downLeft, targetScore, node);
}
targetScore = node.score + 10000;
processNode(node.up, targetScore, node);
processNode(node.right, targetScore, node);
processNode(node.down, targetScore, node);
processNode(node.left, targetScore, node);
}
}
for (var a = 0; a < self.spawns.length; a++) {
if (self.spawns[a].pathId != pathId) {
console.warn("Spawn blocked");
return true;
}
}
for (var a = 0; a < enemies.length; a++) {
var enemy = enemies[a];
// Skip enemies that haven't entered the viewable area yet
if (enemy.currentCellY < 4) {
continue;
}
// Skip flying enemies from path check as they can fly over obstacles
if (enemy.isFlying) {
continue;
}
var target = self.getCell(enemy.cellX, enemy.cellY);
if (enemy.currentTarget) {
if (enemy.currentTarget.pathId != pathId) {
if (!target || target.pathId != pathId) {
console.warn("Enemy blocked 1 ");
return true;
}
}
} else if (!target || target.pathId != pathId) {
console.warn("Enemy blocked 2");
return true;
}
}
console.log("Speed", new Date().getTime() - before);
};
self.renderDebug = function () {
for (var i = 0; i < gridWidth; i++) {
for (var j = 0; j < gridHeight; j++) {
var debugCell = self.cells[i][j].debugCell;
if (debugCell) {
debugCell.render(self.cells[i][j]);
}
}
}
};
// Method to set terrain asset for a specific cell
self.setTerrainAsset = function (x, y, assetId) {
var cell = self.getCell(x, y);
if (cell) {
cell.terrainAsset = assetId;
// Could trigger visual update here in the future
}
};
// Method to set decoration asset for a specific cell
self.setDecorationAsset = function (x, y, assetId) {
var cell = self.getCell(x, y);
if (cell) {
cell.decorationAsset = assetId;
// Could trigger visual update here in the future
}
};
// Method to batch update multiple cells
self.setCellAssets = function (cellUpdates) {
for (var i = 0; i < cellUpdates.length; i++) {
var update = cellUpdates[i];
if (update.terrain) {
self.setTerrainAsset(update.x, update.y, update.terrain);
}
if (update.decoration) {
self.setDecorationAsset(update.x, update.y, update.decoration);
}
if (update.properties) {
var cell = self.getCell(update.x, update.y);
if (cell) {
for (var prop in update.properties) {
cell.customProperties[prop] = update.properties[prop];
}
}
}
}
};
self.updateEnemy = function (enemy) {
var cell = grid.getCell(enemy.cellX, enemy.cellY);
if (cell && cell.type == 3) {
return true;
}
if (enemy.isFlying && enemy.shadow) {
enemy.shadow.x = enemy.x + 20; // Match enemy x-position + offset
enemy.shadow.y = enemy.y + 20; // Match enemy y-position + offset
// Match shadow rotation with enemy rotation
if (enemy.children[0] && enemy.shadow.children[0]) {
enemy.shadow.children[0].rotation = enemy.children[0].rotation;
}
}
// Check if the enemy has reached the entry area (y position is at least 5)
var hasReachedEntryArea = enemy.currentCellY >= 4;
// If enemy hasn't reached the entry area yet, just move down vertically
if (!hasReachedEntryArea) {
// Move directly downward
enemy.currentCellY += enemy.speed;
// Rotate enemy graphic to face downward (PI/2 radians = 90 degrees)
var angle = Math.PI / 2;
if (enemy.children[0] && enemy.children[0].targetRotation === undefined) {
enemy.children[0].targetRotation = angle;
enemy.children[0].rotation = angle;
} else if (enemy.children[0]) {
if (Math.abs(angle - enemy.children[0].targetRotation) > 0.05) {
tween.stop(enemy.children[0], {
rotation: true
});
// Calculate the shortest angle to rotate
var currentRotation = enemy.children[0].rotation;
var angleDiff = angle - currentRotation;
// Normalize angle difference to -PI to PI range for shortest path
while (angleDiff > Math.PI) {
angleDiff -= Math.PI * 2;
}
while (angleDiff < -Math.PI) {
angleDiff += Math.PI * 2;
}
// Set target rotation and animate to it
enemy.children[0].targetRotation = angle;
tween(enemy.children[0], {
rotation: currentRotation + angleDiff
}, {
duration: 250,
easing: tween.easeOut
});
}
}
// Update enemy's position
enemy.x = grid.x + enemy.currentCellX * CELL_SIZE;
enemy.y = grid.y + enemy.currentCellY * CELL_SIZE;
// If enemy has now reached the entry area, update cell coordinates
if (enemy.currentCellY >= 4) {
enemy.cellX = Math.round(enemy.currentCellX);
enemy.cellY = Math.round(enemy.currentCellY);
}
return false;
}
// After reaching entry area, all enemies can now move freely on conveyor belt cells
// Handle flying enemies - they can move over all cells including non-conveyor
if (enemy.isFlying) {
// Flying enemies head straight to the closest goal
if (!enemy.flyingTarget) {
// Set flying target to the closest goal
enemy.flyingTarget = self.goals[0];
// Find closest goal if there are multiple
if (self.goals.length > 1) {
var closestDist = Infinity;
for (var i = 0; i < self.goals.length; i++) {
var goal = self.goals[i];
var dx = goal.x - enemy.cellX;
var dy = goal.y - enemy.cellY;
var dist = dx * dx + dy * dy;
if (dist < closestDist) {
closestDist = dist;
enemy.flyingTarget = goal;
}
}
}
}
// Move directly toward the goal
var ox = enemy.flyingTarget.x - enemy.currentCellX;
var oy = enemy.flyingTarget.y - enemy.currentCellY;
var dist = Math.sqrt(ox * ox + oy * oy);
if (dist < enemy.speed) {
// Reached the goal
return true;
}
var angle = Math.atan2(oy, ox);
// Rotate enemy graphic to match movement direction
if (enemy.children[0] && enemy.children[0].targetRotation === undefined) {
enemy.children[0].targetRotation = angle;
enemy.children[0].rotation = angle;
} else if (enemy.children[0]) {
if (Math.abs(angle - enemy.children[0].targetRotation) > 0.05) {
tween.stop(enemy.children[0], {
rotation: true
});
// Calculate the shortest angle to rotate
var currentRotation = enemy.children[0].rotation;
var angleDiff = angle - currentRotation;
// Normalize angle difference to -PI to PI range for shortest path
while (angleDiff > Math.PI) {
angleDiff -= Math.PI * 2;
}
while (angleDiff < -Math.PI) {
angleDiff += Math.PI * 2;
}
// Set target rotation and animate to it
enemy.children[0].targetRotation = angle;
tween(enemy.children[0], {
rotation: currentRotation + angleDiff
}, {
duration: 250,
easing: tween.easeOut
});
}
}
// Update the cell position to track where the flying enemy is
enemy.cellX = Math.round(enemy.currentCellX);
enemy.cellY = Math.round(enemy.currentCellY);
enemy.currentCellX += Math.cos(angle) * enemy.speed;
enemy.currentCellY += Math.sin(angle) * enemy.speed;
enemy.x = grid.x + enemy.currentCellX * CELL_SIZE;
enemy.y = grid.y + enemy.currentCellY * CELL_SIZE;
// Update shadow position if this is a flying enemy
return false;
}
// Handle ground enemies - they can now move freely on any conveyor belt cell
// Find the closest goal and move directly toward it, but only through conveyor belt cells
if (!enemy.groundTarget) {
// Set ground target to the closest goal
enemy.groundTarget = self.goals[0];
// Find closest goal if there are multiple
if (self.goals.length > 1) {
var closestDist = Infinity;
for (var i = 0; i < self.goals.length; i++) {
var goal = self.goals[i];
var dx = goal.x - enemy.cellX;
var dy = goal.y - enemy.cellY;
var dist = dx * dx + dy * dy;
if (dist < closestDist) {
closestDist = dist;
enemy.groundTarget = goal;
}
}
}
}
// Move toward the goal, but only through conveyor belt cells
var targetX = enemy.groundTarget.x;
var targetY = enemy.groundTarget.y;
var ox = targetX - enemy.currentCellX;
var oy = targetY - enemy.currentCellY;
var dist = Math.sqrt(ox * ox + oy * oy);
if (dist < enemy.speed) {
// Reached the goal
return true;
}
// Calculate desired movement direction
var desiredAngle = Math.atan2(oy, ox);
var moveX = Math.cos(desiredAngle) * enemy.speed;
var moveY = Math.sin(desiredAngle) * enemy.speed;
// Check if the desired next position is on a conveyor belt
var nextCellX = Math.round(enemy.currentCellX + moveX);
var nextCellY = Math.round(enemy.currentCellY + moveY);
var nextCell = grid.getCell(nextCellX, nextCellY);
// Only move if the next position is on a conveyor belt (or goal)
if (nextCell && (conveyorBeltPositions[nextCellX + "," + nextCellY] || nextCell.type === 3)) {
enemy.currentCellX += moveX;
enemy.currentCellY += moveY;
// Rotate enemy graphic to match movement direction
if (enemy.children[0] && enemy.children[0].targetRotation === undefined) {
enemy.children[0].targetRotation = desiredAngle;
enemy.children[0].rotation = desiredAngle;
} else if (enemy.children[0]) {
if (Math.abs(desiredAngle - enemy.children[0].targetRotation) > 0.05) {
tween.stop(enemy.children[0], {
rotation: true
});
// Calculate the shortest angle to rotate
var currentRotation = enemy.children[0].rotation;
var angleDiff = desiredAngle - currentRotation;
// Normalize angle difference to -PI to PI range for shortest path
while (angleDiff > Math.PI) {
angleDiff -= Math.PI * 2;
}
while (angleDiff < -Math.PI) {
angleDiff += Math.PI * 2;
}
// Set target rotation and animate to it
enemy.children[0].targetRotation = desiredAngle;
tween(enemy.children[0], {
rotation: currentRotation + angleDiff
}, {
duration: 250,
easing: tween.easeOut
});
}
}
} else {
// If direct path is blocked, try to find alternative route on conveyor belts
// Look for nearby conveyor belt cells to move toward
var directions = [{
dx: 0,
dy: enemy.speed
},
// Down (preferred)
{
dx: enemy.speed,
dy: 0
},
// Right
{
dx: -enemy.speed,
dy: 0
},
// Left
{
dx: 0,
dy: -enemy.speed
},
// Up
{
dx: enemy.speed * 0.7,
dy: enemy.speed * 0.7
},
// Diagonal down-right
{
dx: -enemy.speed * 0.7,
dy: enemy.speed * 0.7
} // Diagonal down-left
];
var moved = false;
for (var i = 0; i < directions.length; i++) {
var testX = enemy.currentCellX + directions[i].dx;
var testY = enemy.currentCellY + directions[i].dy;
var testCellX = Math.round(testX);
var testCellY = Math.round(testY);
var testCell = grid.getCell(testCellX, testCellY);
if (testCell && (conveyorBeltPositions[testCellX + "," + testCellY] || testCell.type === 3)) {
enemy.currentCellX = testX;
enemy.currentCellY = testY;
var angle = Math.atan2(directions[i].dy, directions[i].dx);
// Rotate enemy graphic to match movement direction
if (enemy.children[0] && enemy.children[0].targetRotation === undefined) {
enemy.children[0].targetRotation = angle;
enemy.children[0].rotation = angle;
} else if (enemy.children[0]) {
if (Math.abs(angle - enemy.children[0].targetRotation) > 0.05) {
tween.stop(enemy.children[0], {
rotation: true
});
var currentRotation = enemy.children[0].rotation;
var angleDiff = angle - currentRotation;
while (angleDiff > Math.PI) {
angleDiff -= Math.PI * 2;
}
while (angleDiff < -Math.PI) {
angleDiff += Math.PI * 2;
}
enemy.children[0].targetRotation = angle;
tween(enemy.children[0], {
rotation: currentRotation + angleDiff
}, {
duration: 250,
easing: tween.easeOut
});
}
}
moved = true;
break;
}
}
// If no valid movement found, enemy stays in place (shouldn't happen with proper map design)
}
// Update enemy's position and grid coordinates
enemy.cellX = Math.round(enemy.currentCellX);
enemy.cellY = Math.round(enemy.currentCellY);
enemy.x = grid.x + enemy.currentCellX * CELL_SIZE;
enemy.y = grid.y + enemy.currentCellY * CELL_SIZE;
};
});
var NextWaveButton = Container.expand(function () {
var self = Container.call(this);
var buttonBackground = self.attachAsset('notification', {
anchorX: 0.5,
anchorY: 0.5
});
buttonBackground.width = 300;
buttonBackground.height = 100;
buttonBackground.tint = 0x0088FF;
var buttonText = new Text2("Next Wave", {
size: 50,
fill: 0xFFFFFF,
weight: 800
});
buttonText.anchor.set(0.5, 0.5);
self.addChild(buttonText);
self.enabled = false;
self.visible = false;
self.update = function () {
if (waveIndicator && waveIndicator.gameStarted && currentWave < totalWaves) {
self.enabled = true;
self.visible = true;
buttonBackground.tint = 0x0088FF;
self.alpha = 1;
} else {
self.enabled = false;
self.visible = false;
buttonBackground.tint = 0x888888;
self.alpha = 0.7;
}
};
self.down = function () {
if (!self.enabled) {
return;
}
if (waveIndicator.gameStarted && currentWave < totalWaves) {
currentWave++; // Increment to the next wave directly
waveTimer = 0; // Reset wave timer
waveInProgress = true;
waveSpawned = false;
// Play click sound
LK.getSound('ui_click').play();
// Get the type of the current wave (which is now the next wave)
var waveType = waveIndicator.getWaveTypeName(currentWave);
var enemyCount = waveIndicator.getEnemyCount(currentWave);
var notification = game.addChild(new Notification("Wave " + currentWave + " (" + waveType + " - " + enemyCount + " enemies) activated!"));
notification.x = 2048 / 2;
notification.y = grid.height - 150;
}
};
return self;
});
var Notification = Container.expand(function (message) {
var self = Container.call(this);
var notificationGraphics = self.attachAsset('notification', {
anchorX: 0.5,
anchorY: 0.5
});
var notificationText = new Text2(message, {
size: 50,
fill: 0x000000,
weight: 800
});
notificationText.anchor.set(0.5, 0.5);
notificationGraphics.width = notificationText.width + 30;
self.addChild(notificationText);
self.alpha = 1;
var fadeOutTime = 120;
self.update = function () {
if (fadeOutTime > 0) {
fadeOutTime--;
self.alpha = Math.min(fadeOutTime / 120 * 2, 1);
} else {
self.destroy();
}
};
return self;
});
var SourceTower = Container.expand(function (towerType) {
var self = Container.call(this);
self.towerType = towerType || 'default';
// Get appropriate turret image asset for this tower type
var turretAssetId = 'turret_normal';
switch (self.towerType) {
case 'rapid':
turretAssetId = 'turret_rapid';
break;
case 'sniper':
turretAssetId = 'turret_sniper';
break;
case 'splash':
turretAssetId = 'turret_missile';
break;
case 'slow':
turretAssetId = 'turret_ice';
break;
case 'poison':
turretAssetId = 'turret_fire';
break;
}
// Use actual turret graphics instead of generic tower
var turretGraphics = self.attachAsset(turretAssetId, {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 1.5,
scaleY: 1.5
});
var towerCost = getTowerCost(self.towerType);
// Add shadow for tower type label
var typeLabelShadow = new Text2(self.towerType.charAt(0).toUpperCase() + self.towerType.slice(1), {
size: 50,
fill: 0x000000,
weight: 800
});
typeLabelShadow.anchor.set(0.5, 0.5);
typeLabelShadow.x = 4;
typeLabelShadow.y = -20 + 4;
self.addChild(typeLabelShadow);
// Add tower type label
var towerName = STORY_THEME.DEFENSE_TYPES[self.towerType] || self.towerType;
// Shorten name if too long
if (towerName.length > 12) {
towerName = towerName.split(' ')[0];
}
var typeLabel = new Text2(towerName, {
size: 40,
fill: 0xFFFFFF,
weight: 800
});
typeLabel.anchor.set(0.5, 0.5);
typeLabel.y = -20; // Position above center of tower
self.addChild(typeLabel);
// Add cost shadow
var costLabelShadow = new Text2(towerCost, {
size: 50,
fill: 0x000000,
weight: 800
});
costLabelShadow.anchor.set(0.5, 0.5);
costLabelShadow.x = 4;
costLabelShadow.y = 24 + 12;
self.addChild(costLabelShadow);
// Add cost label
var costLabel = new Text2(towerCost, {
size: 50,
fill: 0xFFD700,
weight: 800
});
costLabel.anchor.set(0.5, 0.5);
costLabel.y = 20 + 12;
self.addChild(costLabel);
self.update = function () {
// Check if player can afford this tower
var canAfford = gold >= getTowerCost(self.towerType);
// Set opacity based on affordability
self.alpha = canAfford ? 1 : 0.5;
};
return self;
});
var StoryIntro = Container.expand(function () {
var self = Container.call(this);
// Dark overlay background
var overlay = self.attachAsset('notification', {
anchorX: 0.5,
anchorY: 0.5
});
overlay.width = 2048;
overlay.height = 2732;
overlay.tint = 0x000000;
overlay.alpha = 0.9;
overlay.x = 2048 / 2;
overlay.y = 2732 / 2;
// Story panel
var panel = new Container();
self.addChild(panel);
panel.x = 2048 / 2;
panel.y = 2732 / 2;
var panelBg = panel.attachAsset('notification', {
anchorX: 0.5,
anchorY: 0.5
});
panelBg.width = 1700;
panelBg.height = 1000;
panelBg.tint = 0x1a1a1a;
// Title text - reduced size and better positioning
var titleText = new Text2("", {
size: 90,
fill: 0xFFD700,
weight: 800
});
titleText.anchor.set(0.5, 0.5);
titleText.y = -350;
panel.addChild(titleText);
// Story text - reduced size and word wrapping enabled
var storyText = new Text2("", {
size: 60,
fill: 0xFFFFFF,
weight: 400,
wordWrap: true,
wordWrapWidth: 1400
});
storyText.anchor.set(0.5, 0.5);
storyText.y = -50;
panel.addChild(storyText);
// Continue button
var continueBtn = new Container();
panel.addChild(continueBtn);
continueBtn.y = 350;
var btnBg = continueBtn.attachAsset('notification', {
anchorX: 0.5,
anchorY: 0.5
});
btnBg.width = 350;
btnBg.height = 100;
btnBg.tint = 0x00AA00;
var btnText = new Text2("Continue", {
size: 50,
fill: 0xFFFFFF,
weight: 800
});
btnText.anchor.set(0.5, 0.5);
continueBtn.addChild(btnText);
// Skip button
var skipBtn = new Container();
panel.addChild(skipBtn);
skipBtn.x = 600;
skipBtn.y = -400;
var skipBg = skipBtn.attachAsset('notification', {
anchorX: 0.5,
anchorY: 0.5
});
skipBg.width = 180;
skipBg.height = 70;
skipBg.tint = 0x666666;
var skipText = new Text2("Skip", {
size: 35,
fill: 0xFFFFFF,
weight: 800
});
skipText.anchor.set(0.5, 0.5);
skipBtn.addChild(skipText);
self.showPage = function (pageIndex) {
if (pageIndex < STORY_INTRO.pages.length) {
var page = STORY_INTRO.pages[pageIndex];
titleText.setText(page.title);
storyText.setText(page.text);
if (pageIndex === STORY_INTRO.pages.length - 1) {
btnText.setText("Start Mission");
btnBg.tint = 0xFF0000;
}
}
};
continueBtn.down = function () {
STORY_INTRO.currentPage++;
if (STORY_INTRO.currentPage >= STORY_INTRO.pages.length) {
self.destroy();
STORY_INTRO.shown = true;
// Start the game
waveIndicator.gameStarted = true;
currentWave = 0;
waveTimer = nextWaveTime;
var notification = game.addChild(new Notification("Defend the Energy Source!"));
notification.x = 2048 / 2;
notification.y = grid.height - 150;
} else {
self.showPage(STORY_INTRO.currentPage);
}
};
skipBtn.down = function () {
self.destroy();
STORY_INTRO.shown = true;
// Start the game
waveIndicator.gameStarted = true;
currentWave = 0;
waveTimer = nextWaveTime;
var notification = game.addChild(new Notification("Defend the Energy Source!"));
notification.x = 2048 / 2;
notification.y = grid.height - 150;
};
// Show first page
self.showPage(0);
return self;
});
var Tower = Container.expand(function (id) {
var self = Container.call(this);
self.id = id || 'default';
self.level = 1;
self.maxLevel = 6;
self.gridX = 0;
self.gridY = 0;
self.range = 3 * CELL_SIZE;
// Standardized method to get the current range of the tower
self.getRange = function () {
// Always calculate range based on tower type and level (DOUBLED)
switch (self.id) {
case 'sniper':
// Sniper: base 10, +1.6 per level, but final upgrade gets a huge boost
if (self.level === self.maxLevel) {
return 24 * CELL_SIZE; // Significantly increased range for max level (doubled)
}
return (10 + (self.level - 1) * 1.6) * CELL_SIZE;
case 'splash':
// Splash: base 4, +0.4 per level (max ~8 blocks at max level)
return (4 + (self.level - 1) * 0.4) * CELL_SIZE;
case 'rapid':
// Rapid: base 5, +1 per level
return (5 + (self.level - 1) * 1) * CELL_SIZE;
case 'slow':
// Slow: base 7, +1 per level
return (7 + (self.level - 1) * 1) * CELL_SIZE;
case 'poison':
// Poison: base 6.4, +1 per level
return (6.4 + (self.level - 1) * 1) * CELL_SIZE;
default:
// Default: base 6, +1 per level
return (6 + (self.level - 1) * 1) * CELL_SIZE;
}
};
self.cellsInRange = [];
self.fireRate = 60;
self.bulletSpeed = 5;
self.damage = 10;
self.lastFired = 0;
self.targetEnemy = null;
switch (self.id) {
case 'rapid':
self.fireRate = 30;
self.damage = 5;
self.range = 5 * CELL_SIZE; // Doubled from 2.5
self.bulletSpeed = 7;
break;
case 'sniper':
self.fireRate = 90;
self.damage = 25;
self.range = 10 * CELL_SIZE; // Doubled from 5
self.bulletSpeed = 25;
break;
case 'splash':
self.fireRate = 75;
self.damage = 15;
self.range = 4 * CELL_SIZE; // Doubled from 2
self.bulletSpeed = 4;
break;
case 'slow':
self.fireRate = 50;
self.damage = 8;
self.range = 7 * CELL_SIZE; // Doubled from 3.5
self.bulletSpeed = 5;
break;
case 'poison':
self.fireRate = 70;
self.damage = 12;
self.range = 6.4 * CELL_SIZE; // Doubled from 3.2
self.bulletSpeed = 5;
break;
}
var baseGraphics = self.attachAsset('tower', {
anchorX: 0.5,
anchorY: 0.5
});
switch (self.id) {
case 'rapid':
baseGraphics.tint = 0x00AAFF;
break;
case 'sniper':
baseGraphics.tint = 0xFF5500;
break;
case 'splash':
baseGraphics.tint = 0x33CC00;
break;
case 'slow':
baseGraphics.tint = 0x9900FF;
break;
case 'poison':
baseGraphics.tint = 0x00FFAA;
break;
default:
baseGraphics.tint = 0xAAAAAA;
}
var levelIndicators = [];
var maxDots = self.maxLevel;
var dotSpacing = baseGraphics.width / (maxDots + 1);
var dotSize = CELL_SIZE / 6;
for (var i = 0; i < maxDots; i++) {
var dot = new Container();
var outlineCircle = dot.attachAsset('towerLevelIndicator', {
anchorX: 0.5,
anchorY: 0.5
});
outlineCircle.width = dotSize + 4;
outlineCircle.height = dotSize + 4;
outlineCircle.tint = 0x000000;
var towerLevelIndicator = dot.attachAsset('towerLevelIndicator', {
anchorX: 0.5,
anchorY: 0.5
});
towerLevelIndicator.width = dotSize;
towerLevelIndicator.height = dotSize;
towerLevelIndicator.tint = 0xCCCCCC;
dot.x = -CELL_SIZE + dotSpacing * (i + 1);
dot.y = CELL_SIZE * 0.7;
self.addChild(dot);
levelIndicators.push(dot);
}
var gunContainer = new Container();
self.addChild(gunContainer);
// Get appropriate turret image asset for this tower type
var turretAssetId = 'turret_normal';
switch (self.id) {
case 'rapid':
turretAssetId = 'turret_rapid';
break;
case 'sniper':
turretAssetId = 'turret_sniper';
break;
case 'splash':
turretAssetId = 'turret_missile';
break;
case 'slow':
turretAssetId = 'turret_ice';
break;
case 'poison':
turretAssetId = 'turret_fire';
break;
}
var gunGraphics = gunContainer.attachAsset(turretAssetId, {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 2,
scaleY: 2
});
self.updateLevelIndicators = function () {
for (var i = 0; i < maxDots; i++) {
var dot = levelIndicators[i];
var towerLevelIndicator = dot.children[1];
if (i < self.level) {
towerLevelIndicator.tint = 0xFFFFFF;
} else {
switch (self.id) {
case 'rapid':
towerLevelIndicator.tint = 0x00AAFF;
break;
case 'sniper':
towerLevelIndicator.tint = 0xFF5500;
break;
case 'splash':
towerLevelIndicator.tint = 0x33CC00;
break;
case 'slow':
towerLevelIndicator.tint = 0x9900FF;
break;
case 'poison':
towerLevelIndicator.tint = 0x00FFAA;
break;
default:
towerLevelIndicator.tint = 0xAAAAAA;
}
}
}
};
self.updateLevelIndicators();
self.refreshCellsInRange = function () {
for (var i = 0; i < self.cellsInRange.length; i++) {
var cell = self.cellsInRange[i];
var towerIndex = cell.towersInRange.indexOf(self);
if (towerIndex !== -1) {
cell.towersInRange.splice(towerIndex, 1);
}
}
self.cellsInRange = [];
var rangeRadius = self.getRange() / CELL_SIZE;
var centerX = self.gridX + 1;
var centerY = self.gridY + 1;
var minI = Math.floor(centerX - rangeRadius - 0.5);
var maxI = Math.ceil(centerX + rangeRadius + 0.5);
var minJ = Math.floor(centerY - rangeRadius - 0.5);
var maxJ = Math.ceil(centerY + rangeRadius + 0.5);
for (var i = minI; i <= maxI; i++) {
for (var j = minJ; j <= maxJ; j++) {
var closestX = Math.max(i, Math.min(centerX, i + 1));
var closestY = Math.max(j, Math.min(centerY, j + 1));
var deltaX = closestX - centerX;
var deltaY = closestY - centerY;
var distanceSquared = deltaX * deltaX + deltaY * deltaY;
if (distanceSquared <= rangeRadius * rangeRadius) {
var cell = grid.getCell(i, j);
if (cell) {
self.cellsInRange.push(cell);
cell.towersInRange.push(self);
}
}
}
}
// grid.renderDebug();
};
self.getTotalValue = function () {
var baseTowerCost = getTowerCost(self.id);
var totalInvestment = baseTowerCost;
var baseUpgradeCost = baseTowerCost; // Upgrade cost now scales with base tower cost
for (var i = 1; i < self.level; i++) {
totalInvestment += Math.floor(baseUpgradeCost * Math.pow(2, i - 1));
}
return totalInvestment;
};
self.upgrade = function () {
if (self.level < self.maxLevel) {
// Exponential upgrade cost: base cost * (2 ^ (level-1)), scaled by tower base cost
var baseUpgradeCost = getTowerCost(self.id);
var upgradeCost;
// Make last upgrade level extra expensive
if (self.level === self.maxLevel - 1) {
upgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.level - 1) * 3.5 / 2); // Half the cost for final upgrade
} else {
upgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.level - 1));
}
if (gold >= upgradeCost) {
setGold(gold - upgradeCost);
self.level++;
// No need to update self.range here; getRange() is now the source of truth
// Apply tower-specific upgrades based on type
if (self.id === 'rapid') {
if (self.level === self.maxLevel) {
// Extra powerful last upgrade (double the effect)
self.fireRate = Math.max(4, 30 - self.level * 9); // double the effect
self.damage = 5 + self.level * 10; // double the effect
self.bulletSpeed = 7 + self.level * 2.4; // double the effect
} else {
self.fireRate = Math.max(15, 30 - self.level * 3); // Fast tower gets faster with upgrades
self.damage = 5 + self.level * 3;
self.bulletSpeed = 7 + self.level * 0.7;
}
} else {
if (self.level === self.maxLevel) {
// Extra powerful last upgrade for all other towers (double the effect)
self.fireRate = Math.max(5, 60 - self.level * 24); // double the effect
self.damage = 10 + self.level * 20; // double the effect
self.bulletSpeed = 5 + self.level * 2.4; // double the effect
} else {
self.fireRate = Math.max(20, 60 - self.level * 8);
self.damage = 10 + self.level * 5;
self.bulletSpeed = 5 + self.level * 0.5;
}
}
self.refreshCellsInRange();
self.updateLevelIndicators();
if (self.level > 1) {
var levelDot = levelIndicators[self.level - 1].children[1];
tween(levelDot, {
scaleX: 1.5,
scaleY: 1.5
}, {
duration: 300,
easing: tween.elasticOut,
onFinish: function onFinish() {
tween(levelDot, {
scaleX: 1,
scaleY: 1
}, {
duration: 200,
easing: tween.easeOut
});
}
});
}
return true;
} else {
var notification = game.addChild(new Notification("Not enough gold to upgrade!"));
notification.x = 2048 / 2;
notification.y = grid.height - 50;
return false;
}
}
return false;
};
self.findTarget = function () {
var closestEnemy = null;
var closestScore = Infinity;
for (var i = 0; i < enemies.length; i++) {
var enemy = enemies[i];
var dx = enemy.x - self.x;
var dy = enemy.y - self.y;
var distance = Math.sqrt(dx * dx + dy * dy);
// Check if enemy is in range
if (distance <= self.getRange()) {
// Handle flying enemies differently - they can be targeted regardless of path
if (enemy.isFlying) {
// For flying enemies, prioritize by distance to the goal
if (enemy.flyingTarget) {
var goalX = enemy.flyingTarget.x;
var goalY = enemy.flyingTarget.y;
var distToGoal = Math.sqrt((goalX - enemy.cellX) * (goalX - enemy.cellX) + (goalY - enemy.cellY) * (goalY - enemy.cellY));
// Use distance to goal as score
if (distToGoal < closestScore) {
closestScore = distToGoal;
closestEnemy = enemy;
}
} else {
// If no flying target yet (shouldn't happen), prioritize by distance to tower
if (distance < closestScore) {
closestScore = distance;
closestEnemy = enemy;
}
}
} else {
// For ground enemies, use the original path-based targeting
// Get the cell for this enemy
var cell = grid.getCell(enemy.cellX, enemy.cellY);
if (cell && cell.pathId === pathId) {
// Use the cell's score (distance to exit) for prioritization
// Lower score means closer to exit
if (cell.score < closestScore) {
closestScore = cell.score;
closestEnemy = enemy;
}
}
}
}
}
if (!closestEnemy) {
self.targetEnemy = null;
}
return closestEnemy;
};
self.update = function () {
self.targetEnemy = self.findTarget();
if (self.targetEnemy) {
var dx = self.targetEnemy.x - self.x;
var dy = self.targetEnemy.y - self.y;
var angle = Math.atan2(dy, dx);
gunContainer.rotation = angle;
if (LK.ticks - self.lastFired >= self.fireRate) {
self.fire();
self.lastFired = LK.ticks;
}
}
};
self.down = function (x, y, obj) {
var existingMenus = game.children.filter(function (child) {
return child instanceof UpgradeMenu;
});
var hasOwnMenu = false;
var rangeCircle = null;
for (var i = 0; i < game.children.length; i++) {
if (game.children[i].isTowerRange && game.children[i].tower === self) {
rangeCircle = game.children[i];
break;
}
}
for (var i = 0; i < existingMenus.length; i++) {
if (existingMenus[i].tower === self) {
hasOwnMenu = true;
break;
}
}
if (hasOwnMenu) {
for (var i = 0; i < existingMenus.length; i++) {
if (existingMenus[i].tower === self) {
hideUpgradeMenu(existingMenus[i]);
}
}
if (rangeCircle) {
game.removeChild(rangeCircle);
}
selectedTower = null;
// grid.renderDebug();
return;
}
for (var i = 0; i < existingMenus.length; i++) {
existingMenus[i].destroy();
}
for (var i = game.children.length - 1; i >= 0; i--) {
if (game.children[i].isTowerRange) {
game.removeChild(game.children[i]);
}
}
selectedTower = self;
var rangeIndicator = new Container();
rangeIndicator.isTowerRange = true;
rangeIndicator.tower = self;
game.addChild(rangeIndicator);
rangeIndicator.x = self.x;
rangeIndicator.y = self.y;
var rangeGraphics = rangeIndicator.attachAsset('rangeCircle', {
anchorX: 0.5,
anchorY: 0.5
});
rangeGraphics.width = rangeGraphics.height = self.getRange() * 2;
rangeGraphics.alpha = 0.3;
var upgradeMenu = new UpgradeMenu(self);
game.addChild(upgradeMenu);
upgradeMenu.x = 2048 / 2;
tween(upgradeMenu, {
y: 2732 - 225
}, {
duration: 200,
easing: tween.backOut
});
// grid.renderDebug();
};
self.isInRange = function (enemy) {
if (!enemy) {
return false;
}
var dx = enemy.x - self.x;
var dy = enemy.y - self.y;
var distance = Math.sqrt(dx * dx + dy * dy);
return distance <= self.getRange();
};
self.fire = function () {
if (self.targetEnemy) {
var potentialDamage = 0;
for (var i = 0; i < self.targetEnemy.bulletsTargetingThis.length; i++) {
potentialDamage += self.targetEnemy.bulletsTargetingThis[i].damage;
}
if (self.targetEnemy.health > potentialDamage) {
var bulletX = self.x + Math.cos(gunContainer.rotation) * 40;
var bulletY = self.y + Math.sin(gunContainer.rotation) * 40;
var bullet = new Bullet(bulletX, bulletY, self.targetEnemy, self.damage, self.bulletSpeed);
// Set bullet type based on tower type
bullet.type = self.id;
// For slow tower, pass level for scaling slow effect
if (self.id === 'slow') {
bullet.sourceTowerLevel = self.level;
}
// Customize bullet appearance based on tower type
switch (self.id) {
case 'rapid':
bullet.children[0].tint = 0x4169E1;
bullet.children[0].scaleX = 2;
bullet.children[0].scaleY = 2;
break;
case 'sniper':
// Replace bullet with laser for sniper
bullet.removeChild(bullet.children[0]);
var laserGraphics = bullet.attachAsset('bullet_laser', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 2,
scaleY: 2
});
laserGraphics.tint = 0xFF0000;
break;
case 'splash':
// Replace bullet with missile for splash
bullet.removeChild(bullet.children[0]);
var missileGraphics = bullet.attachAsset('bullet_missile', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 2,
scaleY: 2
});
missileGraphics.rotation = gunContainer.rotation;
break;
case 'slow':
// Replace bullet with ice projectile
bullet.removeChild(bullet.children[0]);
var iceGraphics = bullet.attachAsset('bullet_ice', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 2,
scaleY: 2
});
break;
case 'poison':
// Replace bullet with fire projectile
bullet.removeChild(bullet.children[0]);
var fireGraphics = bullet.attachAsset('bullet_fire', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 2,
scaleY: 2
});
break;
}
game.addChild(bullet);
bullets.push(bullet);
self.targetEnemy.bulletsTargetingThis.push(bullet);
// Play appropriate sound effect based on tower type
switch (self.id) {
case 'rapid':
LK.getSound('turret_rapid_fire').play();
break;
case 'sniper':
LK.getSound('laser_sniper_fire').play();
break;
case 'splash':
LK.getSound('missile_launch').play();
break;
case 'slow':
LK.getSound('ice_laser_fire').play();
break;
case 'poison':
LK.getSound('fire_laser_fire').play();
break;
default:
LK.getSound('turret_basic_fire').play();
}
// --- Fire recoil effect for gunContainer ---
// Stop any ongoing recoil tweens before starting a new one
tween.stop(gunContainer, {
x: true,
y: true,
scaleX: true,
scaleY: true
});
// Always use the original resting position for recoil, never accumulate offset
if (gunContainer._restX === undefined) {
gunContainer._restX = 0;
}
if (gunContainer._restY === undefined) {
gunContainer._restY = 0;
}
if (gunContainer._restScaleX === undefined) {
gunContainer._restScaleX = 1;
}
if (gunContainer._restScaleY === undefined) {
gunContainer._restScaleY = 1;
}
// Reset to resting position before animating (in case of interrupted tweens)
gunContainer.x = gunContainer._restX;
gunContainer.y = gunContainer._restY;
gunContainer.scaleX = gunContainer._restScaleX;
gunContainer.scaleY = gunContainer._restScaleY;
// Calculate recoil offset (recoil back along the gun's rotation)
var recoilDistance = 8;
var recoilX = -Math.cos(gunContainer.rotation) * recoilDistance;
var recoilY = -Math.sin(gunContainer.rotation) * recoilDistance;
// Animate recoil back from the resting position
tween(gunContainer, {
x: gunContainer._restX + recoilX,
y: gunContainer._restY + recoilY
}, {
duration: 60,
easing: tween.cubicOut,
onFinish: function onFinish() {
// Animate return to original position/scale
tween(gunContainer, {
x: gunContainer._restX,
y: gunContainer._restY
}, {
duration: 90,
easing: tween.cubicIn
});
}
});
}
}
};
self.placeOnGrid = function (gridX, gridY) {
self.gridX = gridX;
self.gridY = gridY;
// Since towers are 2x2, we need to center them on the 2x2 power outlet area
self.x = grid.x + gridX * CELL_SIZE + CELL_SIZE;
self.y = grid.y + gridY * CELL_SIZE + CELL_SIZE;
for (var i = 0; i < 2; i++) {
for (var j = 0; j < 2; j++) {
var cell = grid.getCell(gridX + i, gridY + j);
if (cell) {
cell.type = 1;
}
}
}
self.refreshCellsInRange();
};
return self;
});
var TowerPreview = Container.expand(function () {
var self = Container.call(this);
var towerRange = 3;
var rangeInPixels = towerRange * CELL_SIZE;
self.towerType = 'default';
self.hasEnoughGold = true;
var rangeIndicator = new Container();
self.addChild(rangeIndicator);
var rangeGraphics = rangeIndicator.attachAsset('rangeCircle', {
anchorX: 0.5,
anchorY: 0.5
});
rangeGraphics.alpha = 0.3;
// Initialize with turret graphics instead of generic preview
self.turretGraphics = null;
self.canPlace = false;
self.gridX = 0;
self.gridY = 0;
self.blockedByEnemy = false;
self.update = function () {
var previousHasEnoughGold = self.hasEnoughGold;
self.hasEnoughGold = gold >= getTowerCost(self.towerType);
// Only update appearance if the affordability status has changed
if (previousHasEnoughGold !== self.hasEnoughGold) {
self.updateAppearance();
}
};
self.updateAppearance = function () {
// Use Tower class to get the source of truth for range
var tempTower = new Tower(self.towerType);
var previewRange = tempTower.getRange();
// Clean up tempTower to avoid memory leaks
if (tempTower && tempTower.destroy) {
tempTower.destroy();
}
// Set range indicator using unified range logic
rangeGraphics.width = rangeGraphics.height = previewRange * 2;
// Get appropriate turret image asset for this tower type
var turretAssetId = 'turret_normal';
switch (self.towerType) {
case 'rapid':
turretAssetId = 'turret_rapid';
break;
case 'sniper':
turretAssetId = 'turret_sniper';
break;
case 'splash':
turretAssetId = 'turret_missile';
break;
case 'slow':
turretAssetId = 'turret_ice';
break;
case 'poison':
turretAssetId = 'turret_fire';
break;
}
// Remove old preview graphics and add new turret graphics
if (self.turretGraphics) {
self.removeChild(self.turretGraphics);
}
self.turretGraphics = self.attachAsset(turretAssetId, {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 2,
scaleY: 2
});
// Move turret graphics above range indicator
self.setChildIndex(self.turretGraphics, self.children.length - 1);
// Apply red tint if can't place
if (!self.canPlace || !self.hasEnoughGold) {
self.turretGraphics.tint = 0xFF0000;
}
};
self.updatePlacementStatus = function () {
var validGridPlacement = true;
var onPowerOutlet = true; // Must be on a power outlet
if (self.gridY <= 4 || self.gridY + 1 >= grid.cells[0].length - 4) {
validGridPlacement = false;
} else {
// Check if all 4 cells (2x2) are on power outlets
for (var i = 0; i < 2; i++) {
for (var j = 0; j < 2; j++) {
var cell = grid.getCell(self.gridX + i, self.gridY + j);
if (!cell) {
validGridPlacement = false;
onPowerOutlet = false;
break;
}
// Check if this cell is a power outlet by checking if the top-left corner matches any power outlet location
var isPowerOutlet = false;
for (var k = 0; k < powerOutletLocations.length; k++) {
var outletX = powerOutletLocations[k].x;
var outletY = powerOutletLocations[k].y;
// Check if current cell is within this 2x2 power outlet area
if (self.gridX + i >= outletX && self.gridX + i < outletX + 2 && self.gridY + j >= outletY && self.gridY + j < outletY + 2) {
isPowerOutlet = true;
break;
}
}
if (!isPowerOutlet) {
onPowerOutlet = false;
}
// Check if there's already a tower here - but allow placement on power outlets (type 0)
if (cell.type === 1) {
// This is a wall, can't place here
validGridPlacement = false;
break;
}
}
if (!validGridPlacement) {
break;
}
}
}
self.blockedByEnemy = false;
if (validGridPlacement && onPowerOutlet) {
for (var i = 0; i < enemies.length; i++) {
var enemy = enemies[i];
if (enemy.currentCellY < 4) {
continue;
}
// Only check non-flying enemies, flying enemies can pass over towers
if (!enemy.isFlying) {
if (enemy.cellX >= self.gridX && enemy.cellX < self.gridX + 2 && enemy.cellY >= self.gridY && enemy.cellY < self.gridY + 2) {
self.blockedByEnemy = true;
break;
}
if (enemy.currentTarget) {
var targetX = enemy.currentTarget.x;
var targetY = enemy.currentTarget.y;
if (targetX >= self.gridX && targetX < self.gridX + 2 && targetY >= self.gridY && targetY < self.gridY + 2) {
self.blockedByEnemy = true;
break;
}
}
}
}
}
self.canPlace = validGridPlacement && onPowerOutlet && !self.blockedByEnemy;
self.hasEnoughGold = gold >= getTowerCost(self.towerType);
self.updateAppearance();
};
self.checkPlacement = function () {
self.updatePlacementStatus();
};
self.snapToGrid = function (x, y) {
var gridPosX = x - grid.x;
var gridPosY = y - grid.y;
self.gridX = Math.floor(gridPosX / CELL_SIZE);
self.gridY = Math.floor(gridPosY / CELL_SIZE);
// Match the tower placement logic - 2x2 towers are centered on 2x2 areas
self.x = grid.x + self.gridX * CELL_SIZE + CELL_SIZE;
self.y = grid.y + self.gridY * CELL_SIZE + CELL_SIZE;
self.checkPlacement();
};
return self;
});
var UpgradeMenu = Container.expand(function (tower) {
var self = Container.call(this);
self.tower = tower;
self.y = 2732 + 225;
var menuBackground = self.attachAsset('notification', {
anchorX: 0.5,
anchorY: 0.5
});
menuBackground.width = 2048;
menuBackground.height = 500;
menuBackground.tint = 0x444444;
menuBackground.alpha = 0.9;
var towerTypeText = new Text2(self.tower.id.charAt(0).toUpperCase() + self.tower.id.slice(1) + ' Tower', {
size: 80,
fill: 0xFFFFFF,
weight: 800
});
towerTypeText.anchor.set(0, 0);
towerTypeText.x = -840;
towerTypeText.y = -160;
self.addChild(towerTypeText);
var statsText = new Text2('Level: ' + self.tower.level + '/' + self.tower.maxLevel + '\nDamage: ' + self.tower.damage + '\nFire Rate: ' + (60 / self.tower.fireRate).toFixed(1) + '/s', {
size: 70,
fill: 0xFFFFFF,
weight: 400
});
statsText.anchor.set(0, 0.5);
statsText.x = -840;
statsText.y = 50;
self.addChild(statsText);
var buttonsContainer = new Container();
buttonsContainer.x = 500;
self.addChild(buttonsContainer);
var upgradeButton = new Container();
buttonsContainer.addChild(upgradeButton);
var buttonBackground = upgradeButton.attachAsset('notification', {
anchorX: 0.5,
anchorY: 0.5
});
buttonBackground.width = 500;
buttonBackground.height = 150;
var isMaxLevel = self.tower.level >= self.tower.maxLevel;
// Exponential upgrade cost: base cost * (2 ^ (level-1)), scaled by tower base cost
var baseUpgradeCost = getTowerCost(self.tower.id);
var upgradeCost;
if (isMaxLevel) {
upgradeCost = 0;
} else if (self.tower.level === self.tower.maxLevel - 1) {
upgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.tower.level - 1) * 3.5 / 2);
} else {
upgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.tower.level - 1));
}
buttonBackground.tint = isMaxLevel ? 0x888888 : gold >= upgradeCost ? 0x00AA00 : 0x888888;
var buttonText = new Text2(isMaxLevel ? 'Max Level' : 'Upgrade: ' + upgradeCost + ' gold', {
size: 60,
fill: 0xFFFFFF,
weight: 800
});
buttonText.anchor.set(0.5, 0.5);
upgradeButton.addChild(buttonText);
var sellButton = new Container();
buttonsContainer.addChild(sellButton);
var sellButtonBackground = sellButton.attachAsset('notification', {
anchorX: 0.5,
anchorY: 0.5
});
sellButtonBackground.width = 500;
sellButtonBackground.height = 150;
sellButtonBackground.tint = 0xCC0000;
var totalInvestment = self.tower.getTotalValue ? self.tower.getTotalValue() : 0;
var sellValue = getTowerSellValue(totalInvestment);
var sellButtonText = new Text2('Sell: +' + sellValue + ' gold', {
size: 60,
fill: 0xFFFFFF,
weight: 800
});
sellButtonText.anchor.set(0.5, 0.5);
sellButton.addChild(sellButtonText);
upgradeButton.y = -85;
sellButton.y = 85;
var closeButton = new Container();
self.addChild(closeButton);
var closeBackground = closeButton.attachAsset('notification', {
anchorX: 0.5,
anchorY: 0.5
});
closeBackground.width = 90;
closeBackground.height = 90;
closeBackground.tint = 0xAA0000;
var closeText = new Text2('X', {
size: 68,
fill: 0xFFFFFF,
weight: 800
});
closeText.anchor.set(0.5, 0.5);
closeButton.addChild(closeText);
closeButton.x = menuBackground.width / 2 - 57;
closeButton.y = -menuBackground.height / 2 + 57;
upgradeButton.down = function (x, y, obj) {
if (self.tower.level >= self.tower.maxLevel) {
var notification = game.addChild(new Notification("Tower is already at max level!"));
notification.x = 2048 / 2;
notification.y = grid.height - 50;
return;
}
if (self.tower.upgrade()) {
// Exponential upgrade cost: base cost * (2 ^ (level-1)), scaled by tower base cost
var baseUpgradeCost = getTowerCost(self.tower.id);
if (self.tower.level >= self.tower.maxLevel) {
upgradeCost = 0;
} else if (self.tower.level === self.tower.maxLevel - 1) {
upgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.tower.level - 1) * 3.5 / 2);
} else {
upgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.tower.level - 1));
}
statsText.setText('Level: ' + self.tower.level + '/' + self.tower.maxLevel + '\nDamage: ' + self.tower.damage + '\nFire Rate: ' + (60 / self.tower.fireRate).toFixed(1) + '/s');
buttonText.setText('Upgrade: ' + upgradeCost + ' gold');
// Play upgrade sound
LK.getSound('tower_upgrade').play();
var totalInvestment = self.tower.getTotalValue ? self.tower.getTotalValue() : 0;
var sellValue = Math.floor(totalInvestment * 0.6);
sellButtonText.setText('Sell: +' + sellValue + ' gold');
if (self.tower.level >= self.tower.maxLevel) {
buttonBackground.tint = 0x888888;
buttonText.setText('Max Level');
}
var rangeCircle = null;
for (var i = 0; i < game.children.length; i++) {
if (game.children[i].isTowerRange && game.children[i].tower === self.tower) {
rangeCircle = game.children[i];
break;
}
}
if (rangeCircle) {
var rangeGraphics = rangeCircle.children[0];
rangeGraphics.width = rangeGraphics.height = self.tower.getRange() * 2;
} else {
var newRangeIndicator = new Container();
newRangeIndicator.isTowerRange = true;
newRangeIndicator.tower = self.tower;
game.addChildAt(newRangeIndicator, 0);
newRangeIndicator.x = self.tower.x;
newRangeIndicator.y = self.tower.y;
var rangeGraphics = newRangeIndicator.attachAsset('rangeCircle', {
anchorX: 0.5,
anchorY: 0.5
});
rangeGraphics.width = rangeGraphics.height = self.tower.getRange() * 2;
rangeGraphics.alpha = 0.3;
}
tween(self, {
scaleX: 1.05,
scaleY: 1.05
}, {
duration: 100,
easing: tween.easeOut,
onFinish: function onFinish() {
tween(self, {
scaleX: 1,
scaleY: 1
}, {
duration: 100,
easing: tween.easeIn
});
}
});
}
};
sellButton.down = function (x, y, obj) {
var totalInvestment = self.tower.getTotalValue ? self.tower.getTotalValue() : 0;
var sellValue = getTowerSellValue(totalInvestment);
setGold(gold + sellValue);
// Play sell sound
LK.getSound('tower_sell').play();
var notification = game.addChild(new Notification("Tower sold for " + sellValue + " gold!"));
notification.x = 2048 / 2;
notification.y = grid.height - 50;
var gridX = self.tower.gridX;
var gridY = self.tower.gridY;
for (var i = 0; i < 2; i++) {
for (var j = 0; j < 2; j++) {
var cell = grid.getCell(gridX + i, gridY + j);
if (cell) {
cell.type = 0;
var towerIndex = cell.towersInRange.indexOf(self.tower);
if (towerIndex !== -1) {
cell.towersInRange.splice(towerIndex, 1);
}
}
}
}
if (selectedTower === self.tower) {
selectedTower = null;
}
var towerIndex = towers.indexOf(self.tower);
if (towerIndex !== -1) {
towers.splice(towerIndex, 1);
}
towerLayer.removeChild(self.tower);
grid.pathFind();
// grid.renderDebug();
self.destroy();
for (var i = 0; i < game.children.length; i++) {
if (game.children[i].isTowerRange && game.children[i].tower === self.tower) {
game.removeChild(game.children[i]);
break;
}
}
};
closeButton.down = function (x, y, obj) {
hideUpgradeMenu(self);
selectedTower = null;
// grid.renderDebug();
};
self.update = function () {
if (self.tower.level >= self.tower.maxLevel) {
if (buttonText.text !== 'Max Level') {
buttonText.setText('Max Level');
buttonBackground.tint = 0x888888;
}
return;
}
// Exponential upgrade cost: base cost * (2 ^ (level-1)), scaled by tower base cost
var baseUpgradeCost = getTowerCost(self.tower.id);
var currentUpgradeCost;
if (self.tower.level >= self.tower.maxLevel) {
currentUpgradeCost = 0;
} else if (self.tower.level === self.tower.maxLevel - 1) {
currentUpgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.tower.level - 1) * 3.5 / 2);
} else {
currentUpgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.tower.level - 1));
}
var canAfford = gold >= currentUpgradeCost;
buttonBackground.tint = canAfford ? 0x00AA00 : 0x888888;
var newText = 'Upgrade: ' + currentUpgradeCost + ' gold';
if (buttonText.text !== newText) {
buttonText.setText(newText);
}
};
return self;
});
var WaveIndicator = Container.expand(function () {
var self = Container.call(this);
self.gameStarted = false;
self.waveMarkers = [];
self.waveTypes = [];
self.enemyCounts = [];
self.indicatorWidth = 0;
self.lastBossType = null; // Track the last boss type to avoid repeating
var blockWidth = 400;
var totalBlocksWidth = blockWidth * totalWaves;
var startMarker = new Container();
var startBlock = startMarker.attachAsset('notification', {
anchorX: 0.5,
anchorY: 0.5
});
startBlock.width = blockWidth - 10;
startBlock.height = 70 * 2;
startBlock.tint = 0x00AA00;
// Add shadow for start text
var startTextShadow = new Text2("Start Game", {
size: 50,
fill: 0x000000,
weight: 800
});
startTextShadow.anchor.set(0.5, 0.5);
startTextShadow.x = 4;
startTextShadow.y = 4;
startMarker.addChild(startTextShadow);
var startText = new Text2("Start Game", {
size: 50,
fill: 0xFFFFFF,
weight: 800
});
startText.anchor.set(0.5, 0.5);
startMarker.addChild(startText);
startMarker.x = -self.indicatorWidth;
self.addChild(startMarker);
self.waveMarkers.push(startMarker);
startMarker.down = function () {
if (!self.gameStarted && !STORY_INTRO.shown) {
// Show story intro
var intro = new StoryIntro();
game.addChild(intro);
} else if (!self.gameStarted) {
self.gameStarted = true;
currentWave = 0;
waveTimer = nextWaveTime;
startBlock.tint = 0x00FF00;
startText.setText("Started!");
startTextShadow.setText("Started!");
// Play click sound
LK.getSound('ui_click').play();
// Start battle music
LK.playMusic('battle_theme', {
fade: {
start: 0,
end: 1,
duration: 1000
}
});
// Make sure shadow position remains correct after text change
startTextShadow.x = 4;
startTextShadow.y = 4;
var notification = game.addChild(new Notification("Defend the Energy Source!"));
notification.x = 2048 / 2;
notification.y = grid.height - 150;
}
};
for (var i = 0; i < totalWaves; i++) {
var marker = new Container();
var block = marker.attachAsset('notification', {
anchorX: 0.5,
anchorY: 0.5
});
block.width = blockWidth - 10;
block.height = 70 * 2;
// --- Begin new unified wave logic ---
var waveType = "normal";
var enemyType = "normal";
var enemyCount = 10;
var isBossWave = (i + 1) % 10 === 0;
// Ensure all types appear in early waves
if (i === 0) {
block.tint = 0xAAAAAA;
waveType = "Normal";
enemyType = "normal";
enemyCount = 10;
} else if (i === 1) {
block.tint = 0x00AAFF;
waveType = "Fast";
enemyType = "fast";
enemyCount = 10;
} else if (i === 2) {
block.tint = 0xAA0000;
waveType = "Immune";
enemyType = "immune";
enemyCount = 10;
} else if (i === 3) {
block.tint = 0xFFFF00;
waveType = "Flying";
enemyType = "flying";
enemyCount = 10;
} else if (i === 4) {
block.tint = 0xFF00FF;
waveType = "Swarm";
enemyType = "swarm";
enemyCount = 30;
} else if (isBossWave) {
// Boss waves: cycle through all boss types, last boss is always flying
var bossTypes = ['normal', 'fast', 'immune', 'flying'];
var bossTypeIndex = Math.floor((i + 1) / 10) - 1;
if (i === totalWaves - 1) {
// Last boss is always flying
enemyType = 'flying';
waveType = "Boss Flying";
block.tint = 0xFFFF00;
} else {
enemyType = bossTypes[bossTypeIndex % bossTypes.length];
switch (enemyType) {
case 'normal':
block.tint = 0xAAAAAA;
waveType = "Boss Normal";
break;
case 'fast':
block.tint = 0x00AAFF;
waveType = "Boss Fast";
break;
case 'immune':
block.tint = 0xAA0000;
waveType = "Boss Immune";
break;
case 'flying':
block.tint = 0xFFFF00;
waveType = "Boss Flying";
break;
}
}
enemyCount = 1;
// Make the wave indicator for boss waves stand out
// Set boss wave color to the color of the wave type
switch (enemyType) {
case 'normal':
block.tint = 0xAAAAAA;
break;
case 'fast':
block.tint = 0x00AAFF;
break;
case 'immune':
block.tint = 0xAA0000;
break;
case 'flying':
block.tint = 0xFFFF00;
break;
default:
block.tint = 0xFF0000;
break;
}
} else if ((i + 1) % 5 === 0) {
// Every 5th non-boss wave is fast
block.tint = 0x00AAFF;
waveType = "Fast";
enemyType = "fast";
enemyCount = 10;
} else if ((i + 1) % 4 === 0) {
// Every 4th non-boss wave is immune
block.tint = 0xAA0000;
waveType = "Immune";
enemyType = "immune";
enemyCount = 10;
} else if ((i + 1) % 7 === 0) {
// Every 7th non-boss wave is flying
block.tint = 0xFFFF00;
waveType = "Flying";
enemyType = "flying";
enemyCount = 10;
} else if ((i + 1) % 3 === 0) {
// Every 3rd non-boss wave is swarm
block.tint = 0xFF00FF;
waveType = "Swarm";
enemyType = "swarm";
enemyCount = 30;
} else {
block.tint = 0xAAAAAA;
waveType = "Normal";
enemyType = "normal";
enemyCount = 10;
}
// --- End new unified wave logic ---
// Mark boss waves with a special visual indicator
if (isBossWave && enemyType !== 'swarm') {
// Add a crown or some indicator to the wave marker for boss waves
var bossIndicator = marker.attachAsset('towerLevelIndicator', {
anchorX: 0.5,
anchorY: 0.5
});
bossIndicator.width = 30;
bossIndicator.height = 30;
bossIndicator.tint = 0xFFD700; // Gold color
bossIndicator.y = -block.height / 2 - 15;
// Change the wave type text to indicate boss
waveType = "BOSS";
}
// Store the wave type and enemy count
self.waveTypes[i] = enemyType;
self.enemyCounts[i] = enemyCount;
// Add shadow for wave type - 30% smaller than before
var waveTypeShadow = new Text2(waveType, {
size: 56,
fill: 0x000000,
weight: 800
});
waveTypeShadow.anchor.set(0.5, 0.5);
waveTypeShadow.x = 4;
waveTypeShadow.y = 4;
marker.addChild(waveTypeShadow);
// Add wave type text - 30% smaller than before
var waveTypeText = new Text2(waveType, {
size: 56,
fill: 0xFFFFFF,
weight: 800
});
waveTypeText.anchor.set(0.5, 0.5);
waveTypeText.y = 0;
marker.addChild(waveTypeText);
// Add shadow for wave number - 20% larger than before
var waveNumShadow = new Text2((i + 1).toString(), {
size: 48,
fill: 0x000000,
weight: 800
});
waveNumShadow.anchor.set(1.0, 1.0);
waveNumShadow.x = blockWidth / 2 - 16 + 5;
waveNumShadow.y = block.height / 2 - 12 + 5;
marker.addChild(waveNumShadow);
// Main wave number text - 20% larger than before
var waveNum = new Text2((i + 1).toString(), {
size: 48,
fill: 0xFFFFFF,
weight: 800
});
waveNum.anchor.set(1.0, 1.0);
waveNum.x = blockWidth / 2 - 16;
waveNum.y = block.height / 2 - 12;
marker.addChild(waveNum);
marker.x = -self.indicatorWidth + (i + 1) * blockWidth;
self.addChild(marker);
self.waveMarkers.push(marker);
}
// Get wave type for a specific wave number
self.getWaveType = function (waveNumber) {
if (waveNumber < 1 || waveNumber > totalWaves) {
return "normal";
}
// If this is a boss wave (waveNumber % 10 === 0), and the type is the same as lastBossType
// then we should return a different boss type
var waveType = self.waveTypes[waveNumber - 1];
return waveType;
};
// Get enemy count for a specific wave number
self.getEnemyCount = function (waveNumber) {
if (waveNumber < 1 || waveNumber > totalWaves) {
return 10;
}
return self.enemyCounts[waveNumber - 1];
};
// Get display name for a wave type
self.getWaveTypeName = function (waveNumber) {
var type = self.getWaveType(waveNumber);
var typeName = type.charAt(0).toUpperCase() + type.slice(1);
// Add boss prefix for boss waves (every 10th wave)
if (waveNumber % 10 === 0 && waveNumber > 0 && type !== 'swarm') {
typeName = "BOSS";
}
return typeName;
};
self.positionIndicator = new Container();
var indicator = self.positionIndicator.attachAsset('towerLevelIndicator', {
anchorX: 0.5,
anchorY: 0.5
});
indicator.width = blockWidth - 10;
indicator.height = 16;
indicator.tint = 0xffad0e;
indicator.y = -65;
var indicator2 = self.positionIndicator.attachAsset('towerLevelIndicator', {
anchorX: 0.5,
anchorY: 0.5
});
indicator2.width = blockWidth - 10;
indicator2.height = 16;
indicator2.tint = 0xffad0e;
indicator2.y = 65;
var leftWall = self.positionIndicator.attachAsset('towerLevelIndicator', {
anchorX: 0.5,
anchorY: 0.5
});
leftWall.width = 16;
leftWall.height = 146;
leftWall.tint = 0xffad0e;
leftWall.x = -(blockWidth - 16) / 2;
var rightWall = self.positionIndicator.attachAsset('towerLevelIndicator', {
anchorX: 0.5,
anchorY: 0.5
});
rightWall.width = 16;
rightWall.height = 146;
rightWall.tint = 0xffad0e;
rightWall.x = (blockWidth - 16) / 2;
self.addChild(self.positionIndicator);
self.update = function () {
var progress = waveTimer / nextWaveTime;
var moveAmount = (progress + currentWave) * blockWidth;
for (var i = 0; i < self.waveMarkers.length; i++) {
var marker = self.waveMarkers[i];
marker.x = -moveAmount + i * blockWidth;
}
self.positionIndicator.x = 0;
for (var i = 0; i < totalWaves + 1; i++) {
var marker = self.waveMarkers[i];
if (i === 0) {
continue;
}
var block = marker.children[0];
if (i - 1 < currentWave) {
block.alpha = .5;
}
}
self.handleWaveProgression = function () {
if (!self.gameStarted) {
return;
}
if (currentWave < totalWaves) {
waveTimer++;
if (waveTimer >= nextWaveTime) {
waveTimer = 0;
currentWave++;
waveInProgress = true;
waveSpawned = false;
if (currentWave != 1) {
var waveType = self.getWaveTypeName(currentWave);
var enemyCount = self.getEnemyCount(currentWave);
var robotType = STORY_THEME.ROBOT_TYPES[self.getWaveType(currentWave)] || "Robot";
var notification = game.addChild(new Notification("Wave " + currentWave + ": " + enemyCount + " " + robotType + "(s) detected!"));
notification.x = 2048 / 2;
notification.y = grid.height - 150;
}
}
}
};
self.handleWaveProgression();
};
return self;
});
/****
* Initialize Game
****/
var game = new LK.Game({
backgroundColor: 0x333333
});
/****
* Game Code
****/
// Music for futuristic theme
// Sound effects for futuristic theme
// Energy core
// Robot mice (swarm)
// Robot turtle (immune)
// Robot crow (flying)
// Robot fox (fast)
// Robot raccoon (normal)
// Fire projectile
// Ice projectile
// Laser beam
// Missile
// Energy projectile
// Futuristic platform base
// Fire laser
// Ice laser
// Missile launcher
// Long range laser
// Rapid fire turret
// Normal turret
// ========== TERRAIN AND MAP ASSETS ==========
// Grass terrains
// Stone and rock terrains
// Path terrains
// Water terrains
// Sand and desert terrains
// Forest and nature terrains
// Special terrain decorations
// ========== TOWER ASSETS ==========
// Default tower variations
// Rapid tower variations
// Sniper tower variations
// Splash tower variations
// Slow tower variations
// Poison tower variations
// Tower guns/weapons
// ========== ENEMY ASSETS ==========
// Normal enemy variations
// Fast enemy variations
// Flying enemy variations
// Immune enemy variations
// Swarm enemy variations
// Boss enemy variations
// ========== PROJECTILE ASSETS ==========
// Basic bullets
// Rapid bullets
// Sniper bullets
// Splash bullets
// Slow bullets
// Poison bullets
// ========== UI ASSETS ==========
// Buttons and panels
// Menu backgrounds
// Health bars
// Range indicators
// Level indicators
// Gold and score indicators
// ========== DECORATIVE ASSETS ==========
// Trees and vegetation
// Rocks and obstacles
// Buildings and structures
// ========== PARTICLE AND EFFECT ASSETS ==========
// ========== AUDIO ASSETS ==========
// Tower shooting sounds
// Impact and explosion sounds
// Enemy sounds
// Tower building sounds
// UI sounds
// Gold and scoring sounds
// Game state sounds
// Environmental sounds
// Background music tracks
// ========== LEGACY ASSETS (keeping for compatibility) ==========
// ========== STORY AND THEME CONSTANTS ==========
// Sound effects for futuristic theme
// Music for futuristic theme
// Turret image assets
// Enemy robot image assets
// Boss versions (larger)
// Futuristic UI Assets
var STORY_THEME = {
// Main characters
AGENTS: {
W: {
name: "W",
type: "wolf",
role: "protagonist"
},
A: {
name: "A",
type: "squirrel",
role: "support"
},
P: {
name: "P",
type: "penguin",
role: "support"
},
G: {
name: "G",
type: "gazelle",
role: "support"
}
},
// Antagonist
VILLAIN: {
name: "Dr. Cronos",
type: "gorilla",
description: "semi-bionic gorilla scientist"
},
// Location
LOCATION: {
city: "Animals City",
agency: "FBA",
target: "Central Energy Source"
},
// Enemy types (robots created by Dr. Cronos)
ROBOT_TYPES: {
normal: "Raccoon Robot",
fast: "Fox Robot",
immune: "Turtle Robot",
flying: "Crow Robot",
swarm: "Mouse Robots",
boss: "Giant Robot"
},
// Tower types (futuristic turrets)
DEFENSE_TYPES: {
"default": "Normal Turret",
rapid: "Rapid Fire",
sniper: "Long Laser",
splash: "Missiles",
slow: "Ice Laser",
poison: "Fire Laser"
}
};
// Map customization system
var MAP_ASSETS = {
// Terrain types that can be assigned to cells
TERRAIN: {
factory_floor: "factory_floor",
conveyor_belt: "conveyor_belt",
power_outlet: "power_outlet",
cable_conduit: "cable_conduit",
power_grid: "power_grid",
energy: "crystal_formation"
},
// Decoration types
DECORATIONS: {
metal_crate: "metal_crate",
battery_pack: "battery_pack",
scaffolding: "scaffolding",
electronic_chip: "electronic_chip",
metal_pipe: "metal_pipe",
energy_source: "core_energy"
}
};
// Story introduction system
var STORY_INTRO = {
pages: [{
title: "Mission Briefing",
text: "Agent W, you and your team have been assigned a critical mission.",
image: "fba_logo"
}, {
title: "The Threat",
text: "Dr. Cronos plans to steal all energy from Animals City to create an ultra robot!",
image: "dr_cronos"
}, {
title: "Your Mission",
text: "Defend the Central Energy Source with agents A, P, and G. Stop the robot invasion!",
image: "team_agents"
}],
currentPage: 0,
shown: false
};
var isHidingUpgradeMenu = false;
function hideUpgradeMenu(menu) {
if (isHidingUpgradeMenu) {
return;
}
isHidingUpgradeMenu = true;
tween(menu, {
y: 2732 + 225
}, {
duration: 150,
easing: tween.easeIn,
onFinish: function onFinish() {
menu.destroy();
isHidingUpgradeMenu = false;
}
});
}
var CELL_SIZE = 76;
var pathId = 1;
var maxScore = 0;
var enemies = [];
var towers = [];
var bullets = [];
var defenses = [];
var selectedTower = null;
var gold = 80;
var lives = 20;
var score = 0;
var currentWave = 0;
var totalWaves = 50;
var waveTimer = 0;
var waveInProgress = false;
var waveSpawned = false;
var nextWaveTime = 12000 / 2;
var sourceTower = null;
var enemiesToSpawn = 10; // Default number of enemies per wave
// Create futuristic UI panels instead of simple text
var topMargin = 60;
var centerX = 2048 / 2;
var spacing = 450;
// Energy Panel (Gold)
var energyPanel = new Container();
var energyIcon = energyPanel.attachAsset('ui_energy_icon', {
anchorX: 0.5,
anchorY: 0.5
});
energyIcon.x = -60;
var energyText = new Text2(gold.toString(), {
size: 50,
fill: 0xFFD700,
weight: 800
});
energyText.anchor.set(0.5, 0.5);
energyText.x = 20;
energyPanel.addChild(energyText);
energyPanel.x = -spacing;
energyPanel.y = topMargin;
LK.gui.top.addChild(energyPanel);
// Shield Panel (Lives)
var shieldPanel = new Container();
var shieldIcon = shieldPanel.attachAsset('ui_shield_icon', {
anchorX: 0.5,
anchorY: 0.5
});
shieldIcon.x = -60;
var shieldText = new Text2(lives.toString(), {
size: 50,
fill: 0x00FF00,
weight: 800
});
shieldText.anchor.set(0.5, 0.5);
shieldText.x = 20;
shieldPanel.addChild(shieldText);
shieldPanel.x = 0;
shieldPanel.y = topMargin;
LK.gui.top.addChild(shieldPanel);
// Score Panel
var scorePanel = new Container();
var scoreIcon = scorePanel.attachAsset('ui_score_icon', {
anchorX: 0.5,
anchorY: 0.5
});
scoreIcon.x = -60;
var scoreText = new Text2(score.toString(), {
size: 50,
fill: 0xFF6B6B,
weight: 800
});
scoreText.anchor.set(0.5, 0.5);
scoreText.x = 20;
scorePanel.addChild(scoreText);
scorePanel.x = spacing;
scorePanel.y = topMargin;
LK.gui.top.addChild(scorePanel);
// Store references for updates
var goldText = energyText;
var livesText = shieldText;
// scoreText already defined above
function updateUI() {
goldText.setText(gold.toString());
livesText.setText(lives.toString());
scoreText.setText(score.toString());
// Update wave info
if (waveIndicator && waveIndicator.gameStarted) {
waveInfoText.setText("Wave " + currentWave + " / " + totalWaves);
// Format timer
var totalSeconds = Math.floor((nextWaveTime - waveTimer) / 60);
var minutes = Math.floor(totalSeconds / 60);
var seconds = totalSeconds % 60;
var timeString = (minutes < 10 ? "0" : "") + minutes + ":" + (seconds < 10 ? "0" : "") + seconds;
timerText.setText("Next Wave: " + timeString);
// Make timer more prominent when time is running low
if (totalSeconds <= 10 && totalSeconds > 0) {
// Pulse the timer when less than 10 seconds remain
if (LK.ticks % 30 === 0) {
// Every half second
tween(timerText, {
scaleX: 1.3,
scaleY: 1.3,
tint: 0xFF4444
}, {
duration: 200,
easing: tween.easeOut,
onFinish: function onFinish() {
tween(timerText, {
scaleX: 1,
scaleY: 1,
tint: 0xFFFFFF
}, {
duration: 200,
easing: tween.easeIn
});
}
});
}
} else if (totalSeconds <= 3 && totalSeconds > 0) {
// More intense pulsing for final countdown
if (LK.ticks % 15 === 0) {
// Every quarter second
tween(timerText, {
scaleX: 1.5,
scaleY: 1.5,
tint: 0xFF0000
}, {
duration: 100,
easing: tween.easeOut,
onFinish: function onFinish() {
tween(timerText, {
scaleX: 1,
scaleY: 1,
tint: 0xFFFFFF
}, {
duration: 100,
easing: tween.easeIn
});
}
});
}
}
} else {
waveInfoText.setText("Ready to Start");
timerText.setText("--:--");
}
// Add pulsing effect to icons based on values
if (lives <= 5) {
// Shield critical - pulse red
tween(shieldIcon, {
scaleX: 1.2,
scaleY: 1.2,
tint: 0xFF0000
}, {
duration: 500,
easing: tween.easeInOut,
onFinish: function onFinish() {
tween(shieldIcon, {
scaleX: 1,
scaleY: 1,
tint: 0xFFFFFF
}, {
duration: 500,
easing: tween.easeInOut
});
}
});
}
}
function setGold(value) {
gold = value;
updateUI();
}
var terrainLayer = new Container();
var debugLayer = new Container();
var towerLayer = new Container();
// Create three separate layers for enemy hierarchy
var enemyLayerBottom = new Container(); // For normal enemies
var enemyLayerMiddle = new Container(); // For shadows
var enemyLayerTop = new Container(); // For flying enemies
var enemyLayer = new Container(); // Main container to hold all enemy layers
// Add layers in correct order (bottom first, then middle for shadows, then top)
enemyLayer.addChild(enemyLayerBottom);
enemyLayer.addChild(enemyLayerMiddle);
enemyLayer.addChild(enemyLayerTop);
var grid = new Grid(24, 29 + 6);
grid.x = 150;
grid.y = 200 - CELL_SIZE * 4;
// Intelligently redesigned electrical factory layout with logical flow and improved tower defense gameplay
// Step 1: Add factory floor to ALL cells as base layer (must be first)
var floorTiles = [];
for (var x = 0; x < 24; x++) {
for (var y = 0; y < 35; y++) {
floorTiles.push({
x: x,
y: y,
terrain: "factory_floor"
});
}
}
// Step 2: Add walls around the entire map border
var wallPositions = [];
// Top and bottom walls
for (var x = 0; x < 24; x++) {
wallPositions.push({
x: x,
y: 0,
terrain: "wall"
});
wallPositions.push({
x: x,
y: 34,
terrain: "wall"
});
}
// Left and right walls
for (var y = 1; y < 34; y++) {
wallPositions.push({
x: 0,
y: y,
terrain: "wall"
});
wallPositions.push({
x: 23,
y: y,
terrain: "wall"
});
}
// New path layout: 6-cell central path at top, splitting into dual 3-cell paths
// CENTRAL 6-CELL PATH: x = 6-11 for first 3 rows (y = 0-2)
// LEFT PATH: x = 6, 7, 8 (3 cells wide) from y = 3 onwards
// RIGHT PATH: x = 15, 16, 17 (3 cells wide) from y = 3 onwards
// CENTRAL POWER OUTLETS: x = 11, 12 (2 cells wide between paths)
// LEFT POWER OUTLETS: x = 3, 4 (left of left path)
// RIGHT POWER OUTLETS: x = 19, 20 (right of right path)
var factoryMapLayout = [];
var conveyorBeltPositions = {};
// RIGHT POWER OUTLETS: x = 20, 21 (2 cells wide for 2x2 power outlets)
// Create conveyor belt paths with new layout
for (var y = 0; y <= 34; y++) {
if (y <= 2) {
// Top section: single 6-cell wide path in center
for (var x = 6; x <= 11; x++) {
factoryMapLayout.push({
x: x,
y: y,
terrain: "conveyor_belt"
});
conveyorBeltPositions[x + "," + y] = true;
}
} else {
// After split: LEFT PATH (3 cells wide)
for (var x = 6; x <= 8; x++) {
factoryMapLayout.push({
x: x,
y: y,
terrain: "conveyor_belt"
});
conveyorBeltPositions[x + "," + y] = true;
}
// After split: RIGHT PATH (3 cells wide)
for (var x = 15; x <= 17; x++) {
factoryMapLayout.push({
x: x,
y: y,
terrain: "conveyor_belt"
});
conveyorBeltPositions[x + "," + y] = true;
}
}
}
// Step 4: Add power outlets (2x2) only adjacent to conveyor belts (towers can only go on these)
// Function to check if a position is adjacent to conveyor belt
function isAdjacentToConveyor(x, y) {
// Check all 8 directions
var directions = [{
dx: -1,
dy: 0
}, {
dx: 1,
dy: 0
}, {
dx: 0,
dy: -1
}, {
dx: 0,
dy: 1
}, {
dx: -1,
dy: -1
}, {
dx: 1,
dy: -1
}, {
dx: -1,
dy: 1
}, {
dx: 1,
dy: 1
}];
for (var i = 0; i < directions.length; i++) {
var checkX = x + directions[i].dx;
var checkY = y + directions[i].dy;
if (conveyorBeltPositions[checkX + "," + checkY]) {
return true;
}
}
return false;
}
// Create occupied positions map to prevent overlaps
var occupiedPositions = {};
// Mark conveyor belts as occupied
for (var key in conveyorBeltPositions) {
occupiedPositions[key] = true;
}
// Mark walls as occupied
for (var i = 0; i < wallPositions.length; i++) {
var key = wallPositions[i].x + "," + wallPositions[i].y;
occupiedPositions[key] = true;
}
// Create strategic power outlet columns directly adjacent to conveyor belt paths
var powerOutletLocations = [];
// LEFT SIDE OUTLETS: Directly adjacent to left path (left path is at x = 6-8)
// Place outlets at x = 4 (touching x = 6)
for (var y = 4; y <= 30; y += 3) {
// Every 3 cells to prevent overlap
powerOutletLocations.push({
x: 4,
y: y
});
}
// CENTRAL OUTLETS LEFT: Adjacent to right side of left path (left path ends at x = 8)
// Place outlets at x = 9 (touching x = 8)
for (var y = 5; y <= 30; y += 3) {
// Every 3 cells to prevent overlap, offset by 1
powerOutletLocations.push({
x: 9,
y: y
});
}
// CENTRAL OUTLETS RIGHT: Adjacent to left side of right path (right path starts at x = 15)
// Place outlets at x = 13 (touching x = 15)
for (var y = 4; y <= 30; y += 3) {
// Every 3 cells to prevent overlap
powerOutletLocations.push({
x: 13,
y: y
});
}
// RIGHT SIDE OUTLETS: Directly adjacent to right path (right path ends at x = 17)
// Place outlets at x = 18 (touching x = 17)
for (var y = 5; y <= 30; y += 3) {
// Every 3 cells to prevent overlap, offset by 1
powerOutletLocations.push({
x: 18,
y: y
});
}
// Additional strategic positions directly adjacent to conveyor belt paths
var additionalDefensePositions = [];
// Combine column outlets with additional strategic positions
var allDefensePositions = powerOutletLocations;
// Validate and place power outlets at strategic positions
for (var i = 0; i < allDefensePositions.length; i++) {
var pos = allDefensePositions[i];
var isValidOutlet = true;
var hasAdjacentConveyor = false;
// Check if this 2x2 area is valid for power outlet
for (var dx = 0; dx < 2; dx++) {
for (var dy = 0; dy < 2; dy++) {
var checkX = pos.x + dx;
var checkY = pos.y + dy;
var posKey = checkX + "," + checkY;
// Make sure position is not already occupied
if (occupiedPositions[posKey]) {
isValidOutlet = false;
break;
}
// Check if adjacent to conveyor
if (isAdjacentToConveyor(checkX, checkY)) {
hasAdjacentConveyor = true;
}
}
if (!isValidOutlet) break;
}
// Add power outlet if valid and adjacent to conveyor
if (isValidOutlet && hasAdjacentConveyor) {
powerOutletLocations.push({
x: pos.x,
y: pos.y
});
// Mark all 4 cells as occupied
for (var dx = 0; dx < 2; dx++) {
for (var dy = 0; dy < 2; dy++) {
var posKey = pos.x + dx + "," + (pos.y + dy);
occupiedPositions[posKey] = true;
}
}
}
}
// Add power outlets to the map (single 2x2 sprite each)
for (var i = 0; i < powerOutletLocations.length; i++) {
// Add single power outlet entry for 2x2 area
factoryMapLayout.push({
x: powerOutletLocations[i].x,
y: powerOutletLocations[i].y,
terrain: "power_outlet"
});
}
// Step 5: Add decorations only where nothing else exists (only on factory floor)
var factoryDecorations = [];
// Place energy core below goal area (special case)
// Check if area is clear for energy core (2x2 at position 11,31)
var energyCoreX = 11;
var energyCoreY = 31;
var canPlaceEnergyCore = true;
for (var dx = 0; dx < 2; dx++) {
for (var dy = 0; dy < 2; dy++) {
var posKey = energyCoreX + dx + "," + (energyCoreY + dy);
if (occupiedPositions[posKey]) {
canPlaceEnergyCore = false;
break;
}
}
if (!canPlaceEnergyCore) break;
}
if (canPlaceEnergyCore) {
factoryDecorations.push({
x: 11.5,
// Centered position
y: 31,
decoration: "energy_core"
});
// Mark energy core area as occupied
for (var dx = 0; dx < 2; dx++) {
for (var dy = 0; dy < 2; dy++) {
var posKey = energyCoreX + dx + "," + (energyCoreY + dy);
occupiedPositions[posKey] = true;
}
}
}
// Logically place factory decorations to represent different electrical production zones
var decorationTypes = ["metal_crate", "battery_pack", "electronic_chip", "scaffolding", "metal_pipe"];
// Create production-zone themed decoration layout
var decorationPattern = [
// ELECTRONIC CHIP FABRICATION ZONE (top-right area)
{
x: 21,
y: 5,
type: "electronic_chip"
}, {
x: 21,
y: 9,
type: "electronic_chip"
}, {
x: 13,
y: 7,
type: "electronic_chip"
},
// SCAFFOLDING for factory infrastructure (along walls and support areas)
{
x: 1,
y: 6,
type: "scaffolding"
}, {
x: 1,
y: 15,
type: "scaffolding"
}, {
x: 1,
y: 25,
type: "scaffolding"
}, {
x: 22,
y: 6,
type: "scaffolding"
}, {
x: 22,
y: 15,
type: "scaffolding"
}, {
x: 22,
y: 25,
type: "scaffolding"
},
// BATTERY STORAGE ZONE (left-center area where path turns)
{
x: 1,
y: 17,
type: "battery_pack"
}, {
x: 1,
y: 21,
type: "battery_pack"
}, {
x: 9,
y: 19,
type: "battery_pack"
}, {
x: 11,
y: 21,
type: "battery_pack"
},
// METAL PIPE DISTRIBUTION (connecting different zones)
{
x: 14,
y: 4,
type: "metal_pipe"
}, {
x: 9,
y: 12,
type: "metal_pipe"
}, {
x: 21,
y: 18,
type: "metal_pipe"
}, {
x: 14,
y: 24,
type: "metal_pipe"
}, {
x: 8,
y: 32,
type: "metal_pipe"
}, {
x: 16,
y: 32,
type: "metal_pipe"
},
// METAL CRATES for raw material storage (distributed logically)
{
x: 4,
y: 5,
type: "metal_crate"
}, {
x: 8,
y: 5,
type: "metal_crate"
}, {
x: 1,
y: 11,
type: "metal_crate"
}, {
x: 22,
y: 22,
type: "metal_crate"
}, {
x: 1,
y: 29,
type: "metal_crate"
}, {
x: 21,
y: 29,
type: "metal_crate"
}, {
x: 5,
y: 24,
type: "metal_crate"
}, {
x: 19,
y: 26,
type: "metal_crate"
}];
// Place decorations only if the position is not occupied and has space for 2x2
for (var i = 0; i < decorationPattern.length; i++) {
var decoration = decorationPattern[i];
// Check if 2x2 area is available
var canPlace = true;
for (var dx = 0; dx < 2; dx++) {
for (var dy = 0; dy < 2; dy++) {
var checkX = decoration.x + dx;
var checkY = decoration.y + dy;
var posKey = checkX + "," + checkY;
if (occupiedPositions[posKey]) {
canPlace = false;
break;
}
}
if (!canPlace) break;
}
// Only place if 2x2 area is not occupied (only factory floor exists there)
if (canPlace) {
factoryDecorations.push({
x: decoration.x,
y: decoration.y,
decoration: decoration.type
});
// Mark all 4 cells as occupied
for (var dx = 0; dx < 2; dx++) {
for (var dy = 0; dy < 2; dy++) {
var posKey = decoration.x + dx + "," + (decoration.y + dy);
occupiedPositions[posKey] = true;
}
}
}
}
// Combine all map elements
var allMapElements = floorTiles.concat(wallPositions).concat(factoryMapLayout).concat(factoryDecorations);
// Apply all elements to grid
grid.setCellAssets(allMapElements);
// Clear existing spawn and goal arrays
grid.spawns = [];
grid.goals = [];
// Clear spawn and goal arrays before setting new ones
grid.spawns = [];
grid.goals = [];
// Update cell types for pathfinding - conveyor belts are walkable (type 0), everything else is blocked (type 1)
for (var i = 0; i < 24; i++) {
for (var j = 0; j < 35; j++) {
var cell = grid.getCell(i, j);
if (cell) {
// Default to wall (blocked)
cell.type = 1;
// Check if this cell is a conveyor belt (walkable path)
if (conveyorBeltPositions[i + "," + j]) {
cell.type = 0; // Walkable path
}
// Check if this cell is part of a power outlet (for tower placement)
for (var k = 0; k < powerOutletLocations.length; k++) {
var outletX = powerOutletLocations[k].x;
var outletY = powerOutletLocations[k].y;
// Check if current cell is within this 2x2 power outlet area
if (i >= outletX && i < outletX + 2 && j >= outletY && j < outletY + 2) {
cell.type = 0; // Mark as buildable (not a wall)
break;
}
}
// Set spawns at both paths after split
// Left path spawn (center at x=7)
if (i === 7 && j === 3) {
cell.type = 2; // Spawn
grid.spawns.push(cell);
}
// Right path spawn (center at x=16)
if (i === 16 && j === 3) {
cell.type = 2; // Spawn
grid.spawns.push(cell);
}
// Set goals at bottom center of both 3-cell paths
// Left path goal (center at x=7)
if (i === 7 && j === 33) {
cell.type = 3; // Goal
grid.goals.push(cell);
}
// Right path goal (center at x=16)
else if (i === 16 && j === 33) {
cell.type = 3; // Goal
grid.goals.push(cell);
}
}
}
}
// Add single background image for the entire game area
var backgroundImage = terrainLayer.attachAsset('factory_floor', {
anchorX: 0,
anchorY: 0
});
// Scale and position background to cover the entire game area
backgroundImage.width = 2048;
backgroundImage.height = 2732;
backgroundImage.x = 0;
backgroundImage.y = 0;
// Only render essential gameplay elements: walls, conveyor belt path, power outlets, and energy core
for (var i = 0; i < allMapElements.length; i++) {
var element = allMapElements[i];
var assetId = null;
var shouldRender = false;
// Render walls, conveyor belts, power outlets, and energy core
if (element.terrain === "wall") {
assetId = 'wall';
shouldRender = true;
} else if (element.terrain === "conveyor_belt") {
assetId = 'conveyor_belt';
shouldRender = true;
} else if (element.terrain === "power_outlet") {
assetId = 'power_outlet';
shouldRender = true;
} else if (element.decoration === "energy_source") {
assetId = 'energy_core';
shouldRender = true;
}
if (assetId && shouldRender) {
var asset = terrainLayer.attachAsset(assetId, {
anchorX: 0.5,
anchorY: 0.5
});
// Position the asset
if (element.terrain === "wall") {
// Walls are 1x1 (76x76 pixels), position at center of cell
asset.x = grid.x + element.x * CELL_SIZE + CELL_SIZE / 2;
asset.y = grid.y + element.y * CELL_SIZE + CELL_SIZE / 2;
asset.tint = 0x505050; // Dark gray tint for walls
} else if (element.terrain === "power_outlet") {
// Power outlets are 2x2 (152x152 pixels), position at center of 2x2 area
asset.x = grid.x + element.x * CELL_SIZE + CELL_SIZE;
asset.y = grid.y + element.y * CELL_SIZE + CELL_SIZE;
} else if (element.decoration === "energy_source") {
// Energy core positioning
asset.x = grid.x + element.x * CELL_SIZE;
asset.y = grid.y + element.y * CELL_SIZE;
// Pulsing effect for the energy core
tween(asset, {
scaleX: 1.1,
scaleY: 1.1
}, {
duration: 1000,
easing: tween.easeInOut,
loop: true,
yoyo: true
});
} else {
// Conveyor belt positioning
asset.x = grid.x + element.x * CELL_SIZE + CELL_SIZE / 2;
asset.y = grid.y + element.y * CELL_SIZE + CELL_SIZE / 2;
}
// Apply visual effects
if (element.terrain === "conveyor_belt") {
asset.tint = 0x4169E1; // Blue tint for visibility
asset.alpha = 0.6; // Add transparency to show background
}
}
}
grid.pathFind();
// Remove debug rendering to clear the view
// grid.renderDebug();
// Don't add grid to debug layer since we don't want debug visualization
// debugLayer.addChild(grid);
game.addChild(terrainLayer);
game.addChild(debugLayer);
game.addChild(towerLayer);
game.addChild(enemyLayer);
var offset = 0;
var towerPreview = new TowerPreview();
game.addChild(towerPreview);
towerPreview.visible = false;
var isDragging = false;
function wouldBlockPath(gridX, gridY) {
// Check if any cell in the 2x2 tower area is a conveyor belt (actual path)
for (var i = 0; i < 2; i++) {
for (var j = 0; j < 2; j++) {
var cellX = gridX + i;
var cellY = gridY + j;
// Check if this cell is a conveyor belt (part of the actual path)
if (conveyorBeltPositions[cellX + "," + cellY]) {
// This cell is part of the conveyor belt path, so placing here would block
return true;
}
}
}
// Not blocking any conveyor belt cells
return false;
}
function getTowerCost(towerType) {
var cost = 5;
switch (towerType) {
case 'rapid':
cost = 15;
break;
case 'sniper':
cost = 25;
break;
case 'splash':
cost = 35;
break;
case 'slow':
cost = 45;
break;
case 'poison':
cost = 55;
break;
}
return cost;
}
function getTowerSellValue(totalValue) {
return waveIndicator && waveIndicator.gameStarted ? Math.floor(totalValue * 0.6) : totalValue;
}
function placeTower(gridX, gridY, towerType) {
var towerCost = getTowerCost(towerType);
if (gold >= towerCost) {
var tower = new Tower(towerType || 'default');
tower.placeOnGrid(gridX, gridY);
towerLayer.addChild(tower);
towers.push(tower);
setGold(gold - towerCost);
grid.pathFind();
// grid.renderDebug();
// Play build sound
LK.getSound('tower_build').play();
return true;
} else {
var notification = game.addChild(new Notification("Not enough gold!"));
notification.x = 2048 / 2;
notification.y = grid.height - 50;
return false;
}
}
game.down = function (x, y, obj) {
var upgradeMenuVisible = game.children.some(function (child) {
return child instanceof UpgradeMenu;
});
if (upgradeMenuVisible) {
return;
}
for (var i = 0; i < sourceTowers.length; i++) {
var tower = sourceTowers[i];
if (x >= tower.x - tower.width / 2 && x <= tower.x + tower.width / 2 && y >= tower.y - tower.height / 2 && y <= tower.y + tower.height / 2) {
towerPreview.visible = true;
isDragging = true;
towerPreview.towerType = tower.towerType;
towerPreview.updateAppearance();
// Apply the same offset as in move handler to ensure consistency when starting drag
towerPreview.snapToGrid(x, y - CELL_SIZE * 1.5);
break;
}
}
};
game.move = function (x, y, obj) {
if (isDragging) {
// Shift the y position upward by 1.5 tiles to show preview above finger
towerPreview.snapToGrid(x, y - CELL_SIZE * 1.5);
}
};
game.up = function (x, y, obj) {
var clickedOnTower = false;
for (var i = 0; i < towers.length; i++) {
var tower = towers[i];
var towerLeft = tower.x - tower.width / 2;
var towerRight = tower.x + tower.width / 2;
var towerTop = tower.y - tower.height / 2;
var towerBottom = tower.y + tower.height / 2;
if (x >= towerLeft && x <= towerRight && y >= towerTop && y <= towerBottom) {
clickedOnTower = true;
break;
}
}
var upgradeMenus = game.children.filter(function (child) {
return child instanceof UpgradeMenu;
});
if (upgradeMenus.length > 0 && !isDragging && !clickedOnTower) {
var clickedOnMenu = false;
for (var i = 0; i < upgradeMenus.length; i++) {
var menu = upgradeMenus[i];
var menuWidth = 2048;
var menuHeight = 450;
var menuLeft = menu.x - menuWidth / 2;
var menuRight = menu.x + menuWidth / 2;
var menuTop = menu.y - menuHeight / 2;
var menuBottom = menu.y + menuHeight / 2;
if (x >= menuLeft && x <= menuRight && y >= menuTop && y <= menuBottom) {
clickedOnMenu = true;
break;
}
}
if (!clickedOnMenu) {
for (var i = 0; i < upgradeMenus.length; i++) {
var menu = upgradeMenus[i];
hideUpgradeMenu(menu);
}
for (var i = game.children.length - 1; i >= 0; i--) {
if (game.children[i].isTowerRange) {
game.removeChild(game.children[i]);
}
}
selectedTower = null;
// grid.renderDebug();
}
}
if (isDragging) {
isDragging = false;
if (towerPreview.canPlace) {
if (!wouldBlockPath(towerPreview.gridX, towerPreview.gridY)) {
placeTower(towerPreview.gridX, towerPreview.gridY, towerPreview.towerType);
} else {
var notification = game.addChild(new Notification("Tower would block the path!"));
notification.x = 2048 / 2;
notification.y = grid.height - 50;
}
} else if (towerPreview.blockedByEnemy) {
var notification = game.addChild(new Notification("Cannot build: Enemy in the way!"));
notification.x = 2048 / 2;
notification.y = grid.height - 50;
} else if (towerPreview.visible) {
var notification = game.addChild(new Notification("Towers must be placed on power outlets!"));
notification.x = 2048 / 2;
notification.y = grid.height - 50;
}
towerPreview.visible = false;
if (isDragging) {
var upgradeMenus = game.children.filter(function (child) {
return child instanceof UpgradeMenu;
});
for (var i = 0; i < upgradeMenus.length; i++) {
upgradeMenus[i].destroy();
}
}
}
};
// Wave info text - positioned at top center
var waveInfoText = new Text2("Wave 0 / " + totalWaves, {
size: 40,
fill: 0x00d4ff,
weight: 800
});
waveInfoText.anchor.set(0.5, 0.5);
waveInfoText.x = 2048 / 2;
waveInfoText.y = 150;
game.addChild(waveInfoText);
// Timer text - made larger and more prominent, positioned below wave info
var timerText = new Text2("Next Wave: 00:00", {
size: 55,
fill: 0xFFFFFF,
weight: 800
});
timerText.anchor.set(0.5, 0.5);
timerText.x = 2048 / 2;
timerText.y = 210;
game.addChild(timerText);
var waveIndicator = new WaveIndicator();
waveIndicator.x = 2048 / 2;
waveIndicator.y = 2732 - 80;
game.addChild(waveIndicator);
var nextWaveButtonContainer = new Container();
var nextWaveButton = new NextWaveButton();
nextWaveButton.x = 2048 - 200;
nextWaveButton.y = 2732 - 100 + 20;
nextWaveButtonContainer.addChild(nextWaveButton);
game.addChild(nextWaveButtonContainer);
var towerTypes = ['default', 'rapid', 'sniper', 'splash', 'slow', 'poison'];
var sourceTowers = [];
var towerSpacing = 300; // Increase spacing for larger towers
var startX = 2048 / 2 - towerTypes.length * towerSpacing / 2 + towerSpacing / 2;
var towerY = 2732 - CELL_SIZE * 3 - 90;
for (var i = 0; i < towerTypes.length; i++) {
var tower = new SourceTower(towerTypes[i]);
tower.x = startX + i * towerSpacing;
tower.y = towerY;
towerLayer.addChild(tower);
sourceTowers.push(tower);
}
sourceTower = null;
enemiesToSpawn = 10;
game.update = function () {
if (waveInProgress) {
if (!waveSpawned) {
waveSpawned = true;
// Get wave type and enemy count from the wave indicator
var waveType = waveIndicator.getWaveType(currentWave);
var enemyCount = waveIndicator.getEnemyCount(currentWave);
// Check if this is a boss wave
var isBossWave = currentWave % 10 === 0 && currentWave > 0;
if (isBossWave && waveType !== 'swarm') {
// Boss waves have just 1 enemy regardless of what the wave indicator says
enemyCount = 1;
// Show boss announcement
var notification = game.addChild(new Notification("⚠️ BOSS WAVE! ⚠️"));
notification.x = 2048 / 2;
notification.y = grid.height - 200;
// Play boss alert sound
LK.getSound('boss_alert').play();
// Switch to boss music
LK.playMusic('boss_theme', {
fade: {
start: 0,
end: 1,
duration: 500
}
});
} else {
// Play wave start sound for regular waves
LK.getSound('wave_start').play();
}
// Spawn the appropriate number of enemies
for (var i = 0; i < enemyCount; i++) {
var enemy = new Enemy(waveType);
// Add enemy to the appropriate layer based on type
if (enemy.isFlying) {
// Add flying enemy to the top layer
enemyLayerTop.addChild(enemy);
// If it's a flying enemy, add its shadow to the middle layer
if (enemy.shadow) {
enemyLayerMiddle.addChild(enemy.shadow);
}
} else {
// Add normal/ground enemies to the bottom layer
enemyLayerBottom.addChild(enemy);
}
// Scale difficulty with wave number but don't apply to boss
// as bosses already have their health multiplier
// Use exponential scaling for health
var healthMultiplier = Math.pow(1.12, currentWave); // ~20% increase per wave
enemy.maxHealth = Math.round(enemy.maxHealth * healthMultiplier);
enemy.health = enemy.maxHealth;
// Increment speed slightly with wave number
//enemy.speed = enemy.speed + currentWave * 0.002;
// Spawn enemies alternately on both paths
var leftPathColumns = [6, 7, 8]; // Left path columns
var rightPathColumns = [15, 16, 17]; // Right path columns
// Alternate between left and right paths
var useLeftPath = i % 2 === 0;
var pathColumns = useLeftPath ? leftPathColumns : rightPathColumns;
// Find available columns that aren't occupied by another enemy not yet in view
var availableColumns = [];
for (var c = 0; c < pathColumns.length; c++) {
var col = pathColumns[c];
var columnOccupied = false;
// Check if any enemy is already in this column but not yet in view
for (var e = 0; e < enemies.length; e++) {
if (enemies[e].cellX === col && enemies[e].currentCellY < 4) {
columnOccupied = true;
break;
}
}
if (!columnOccupied) {
availableColumns.push(col);
}
}
// If all columns are occupied, use random selection from path columns
var spawnX;
if (availableColumns.length > 0) {
// Choose a random unoccupied column
spawnX = availableColumns[Math.floor(Math.random() * availableColumns.length)];
} else {
// Fallback to random path column if all are occupied
spawnX = pathColumns[Math.floor(Math.random() * pathColumns.length)];
}
var spawnY = 3 - Math.random() * 5; // Start at spawn row (3) minus random distance for spreading
enemy.cellX = spawnX;
enemy.cellY = 3; // Position at spawn row
enemy.currentCellX = spawnX;
enemy.currentCellY = spawnY;
enemy.waveNumber = currentWave;
enemies.push(enemy);
}
}
var currentWaveEnemiesRemaining = false;
for (var i = 0; i < enemies.length; i++) {
if (enemies[i].waveNumber === currentWave) {
currentWaveEnemiesRemaining = true;
break;
}
}
if (waveSpawned && !currentWaveEnemiesRemaining) {
waveInProgress = false;
waveSpawned = false;
// Return to normal battle music after boss wave
var wasBossWave = currentWave % 10 === 0 && currentWave > 0;
if (wasBossWave) {
LK.playMusic('battle_theme', {
fade: {
start: 0.5,
end: 1,
duration: 1000
}
});
}
}
}
for (var a = enemies.length - 1; a >= 0; a--) {
var enemy = enemies[a];
if (enemy.health <= 0) {
for (var i = 0; i < enemy.bulletsTargetingThis.length; i++) {
var bullet = enemy.bulletsTargetingThis[i];
bullet.targetEnemy = null;
}
// Boss enemies give more gold and score
var goldEarned = enemy.isBoss ? Math.floor(50 + (enemy.waveNumber - 1) * 5) : Math.floor(1 + (enemy.waveNumber - 1) * 0.5);
var goldIndicator = new GoldIndicator(goldEarned, enemy.x, enemy.y);
game.addChild(goldIndicator);
setGold(gold + goldEarned);
// Play destruction sound
LK.getSound('robot_destroyed').play();
// Give more score for defeating a boss
var scoreValue = enemy.isBoss ? 100 : 5;
score += scoreValue;
// Add a notification for boss defeat
if (enemy.isBoss) {
var notification = game.addChild(new Notification("Boss defeated! +" + goldEarned + " gold!"));
notification.x = 2048 / 2;
notification.y = grid.height - 150;
}
updateUI();
// Clean up shadow if it's a flying enemy
if (enemy.isFlying && enemy.shadow) {
enemyLayerMiddle.removeChild(enemy.shadow);
enemy.shadow = null;
}
// Remove enemy from the appropriate layer
if (enemy.isFlying) {
enemyLayerTop.removeChild(enemy);
} else {
enemyLayerBottom.removeChild(enemy);
}
enemies.splice(a, 1);
continue;
}
if (grid.updateEnemy(enemy)) {
// Clean up shadow if it's a flying enemy
if (enemy.isFlying && enemy.shadow) {
enemyLayerMiddle.removeChild(enemy.shadow);
enemy.shadow = null;
}
// Remove enemy from the appropriate layer
if (enemy.isFlying) {
enemyLayerTop.removeChild(enemy);
} else {
enemyLayerBottom.removeChild(enemy);
}
enemies.splice(a, 1);
lives = Math.max(0, lives - 1);
updateUI();
// Play core hit sound
LK.getSound('energy_core_hit').play();
if (lives <= 0) {
LK.showGameOver();
}
}
}
for (var i = bullets.length - 1; i >= 0; i--) {
if (!bullets[i].parent) {
if (bullets[i].targetEnemy) {
var targetEnemy = bullets[i].targetEnemy;
var bulletIndex = targetEnemy.bulletsTargetingThis.indexOf(bullets[i]);
if (bulletIndex !== -1) {
targetEnemy.bulletsTargetingThis.splice(bulletIndex, 1);
}
}
bullets.splice(i, 1);
}
}
if (towerPreview.visible) {
towerPreview.checkPlacement();
}
// Update UI every frame for smooth animations
updateUI();
if (currentWave >= totalWaves && enemies.length === 0 && !waveInProgress) {
// Play victory music
LK.playMusic('victory_theme', {
fade: {
start: 0,
end: 1,
duration: 1000
}
});
LK.getSound('victory_fanfare').play();
LK.showYouWin();
}
};
// Start ambient factory music
LK.playMusic('factory_ambient', {
fade: {
start: 0,
end: 1,
duration: 2000
}
}); ===================================================================
--- original.js
+++ change.js
@@ -1223,61 +1223,63 @@
var panelBg = panel.attachAsset('notification', {
anchorX: 0.5,
anchorY: 0.5
});
- panelBg.width = 1600;
- panelBg.height = 1200;
+ panelBg.width = 1700;
+ panelBg.height = 1000;
panelBg.tint = 0x1a1a1a;
- // Title text
+ // Title text - reduced size and better positioning
var titleText = new Text2("", {
- size: 120,
+ size: 90,
fill: 0xFFD700,
weight: 800
});
titleText.anchor.set(0.5, 0.5);
- titleText.y = -400;
+ titleText.y = -350;
panel.addChild(titleText);
- // Story text
+ // Story text - reduced size and word wrapping enabled
var storyText = new Text2("", {
- size: 80,
+ size: 60,
fill: 0xFFFFFF,
- weight: 400
+ weight: 400,
+ wordWrap: true,
+ wordWrapWidth: 1400
});
storyText.anchor.set(0.5, 0.5);
- storyText.y = 0;
+ storyText.y = -50;
panel.addChild(storyText);
// Continue button
var continueBtn = new Container();
panel.addChild(continueBtn);
- continueBtn.y = 400;
+ continueBtn.y = 350;
var btnBg = continueBtn.attachAsset('notification', {
anchorX: 0.5,
anchorY: 0.5
});
- btnBg.width = 400;
- btnBg.height = 120;
+ btnBg.width = 350;
+ btnBg.height = 100;
btnBg.tint = 0x00AA00;
var btnText = new Text2("Continue", {
- size: 60,
+ size: 50,
fill: 0xFFFFFF,
weight: 800
});
btnText.anchor.set(0.5, 0.5);
continueBtn.addChild(btnText);
// Skip button
var skipBtn = new Container();
panel.addChild(skipBtn);
- skipBtn.x = 700;
- skipBtn.y = -500;
+ skipBtn.x = 600;
+ skipBtn.y = -400;
var skipBg = skipBtn.attachAsset('notification', {
anchorX: 0.5,
anchorY: 0.5
});
- skipBg.width = 200;
- skipBg.height = 80;
+ skipBg.width = 180;
+ skipBg.height = 70;
skipBg.tint = 0x666666;
var skipText = new Text2("Skip", {
- size: 40,
+ size: 35,
fill: 0xFFFFFF,
weight: 800
});
skipText.anchor.set(0.5, 0.5);
@@ -2668,88 +2670,88 @@
/****
* Game Code
****/
-// Futuristic UI Assets
-// Boss versions (larger)
-// Enemy robot image assets
-// Turret image assets
// Music for futuristic theme
// Sound effects for futuristic theme
-// ========== STORY AND THEME CONSTANTS ==========
-// ========== LEGACY ASSETS (keeping for compatibility) ==========
-// Background music tracks
-// Environmental sounds
-// Game state sounds
-// Gold and scoring sounds
-// UI sounds
-// Tower building sounds
-// Enemy sounds
-// Impact and explosion sounds
-// Tower shooting sounds
-// ========== AUDIO ASSETS ==========
-// ========== PARTICLE AND EFFECT ASSETS ==========
-// Buildings and structures
-// Rocks and obstacles
-// Trees and vegetation
-// ========== DECORATIVE ASSETS ==========
-// Gold and score indicators
-// Level indicators
-// Range indicators
-// Health bars
-// Menu backgrounds
-// Buttons and panels
-// ========== UI ASSETS ==========
-// Poison bullets
-// Slow bullets
-// Splash bullets
-// Sniper bullets
-// Rapid bullets
-// Basic bullets
-// ========== PROJECTILE ASSETS ==========
-// Boss enemy variations
-// Swarm enemy variations
-// Immune enemy variations
-// Flying enemy variations
-// Fast enemy variations
-// Normal enemy variations
-// ========== ENEMY ASSETS ==========
-// Tower guns/weapons
-// Poison tower variations
-// Slow tower variations
-// Splash tower variations
-// Sniper tower variations
-// Rapid tower variations
-// Default tower variations
-// ========== TOWER ASSETS ==========
-// Special terrain decorations
-// Forest and nature terrains
-// Sand and desert terrains
-// Water terrains
-// Path terrains
-// Stone and rock terrains
-// Grass terrains
-// ========== TERRAIN AND MAP ASSETS ==========
-// Normal turret
-// Rapid fire turret
-// Long range laser
-// Missile launcher
-// Ice laser
-// Fire laser
-// Futuristic platform base
-// Energy projectile
-// Missile
-// Laser beam
-// Ice projectile
-// Fire projectile
-// Robot raccoon (normal)
-// Robot fox (fast)
-// Robot crow (flying)
-// Robot turtle (immune)
-// Robot mice (swarm)
// Energy core
+// Robot mice (swarm)
+// Robot turtle (immune)
+// Robot crow (flying)
+// Robot fox (fast)
+// Robot raccoon (normal)
+// Fire projectile
+// Ice projectile
+// Laser beam
+// Missile
+// Energy projectile
+// Futuristic platform base
+// Fire laser
+// Ice laser
+// Missile launcher
+// Long range laser
+// Rapid fire turret
+// Normal turret
+// ========== TERRAIN AND MAP ASSETS ==========
+// Grass terrains
+// Stone and rock terrains
+// Path terrains
+// Water terrains
+// Sand and desert terrains
+// Forest and nature terrains
+// Special terrain decorations
+// ========== TOWER ASSETS ==========
+// Default tower variations
+// Rapid tower variations
+// Sniper tower variations
+// Splash tower variations
+// Slow tower variations
+// Poison tower variations
+// Tower guns/weapons
+// ========== ENEMY ASSETS ==========
+// Normal enemy variations
+// Fast enemy variations
+// Flying enemy variations
+// Immune enemy variations
+// Swarm enemy variations
+// Boss enemy variations
+// ========== PROJECTILE ASSETS ==========
+// Basic bullets
+// Rapid bullets
+// Sniper bullets
+// Splash bullets
+// Slow bullets
+// Poison bullets
+// ========== UI ASSETS ==========
+// Buttons and panels
+// Menu backgrounds
+// Health bars
+// Range indicators
+// Level indicators
+// Gold and score indicators
+// ========== DECORATIVE ASSETS ==========
+// Trees and vegetation
+// Rocks and obstacles
+// Buildings and structures
+// ========== PARTICLE AND EFFECT ASSETS ==========
+// ========== AUDIO ASSETS ==========
+// Tower shooting sounds
+// Impact and explosion sounds
+// Enemy sounds
+// Tower building sounds
+// UI sounds
+// Gold and scoring sounds
+// Game state sounds
+// Environmental sounds
+// Background music tracks
+// ========== LEGACY ASSETS (keeping for compatibility) ==========
+// ========== STORY AND THEME CONSTANTS ==========
// Sound effects for futuristic theme
// Music for futuristic theme
+// Turret image assets
+// Enemy robot image assets
+// Boss versions (larger)
+// Futuristic UI Assets
var STORY_THEME = {
// Main characters
AGENTS: {
W: {
Images
:quality(85)/https://cdn.frvr.ai/671be23a3de176b9ade21311.png%3F3)
:quality(85)/https://cdn.frvr.ai/682d8f7dc4e193748a079155.png%3F3)
:quality(85)/https://cdn.frvr.ai/682dc1755a2fa73fef156d33.png%3F3)
White circle with black outline. Blue background.. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/688320e961475c5a25648c89.png%3F3)
Piso de metálico. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/6883a25671447ae2e425a7c9.png%3F3)
quiero un suelo hecho con la textura de una cinta transportadora. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/6883a38a71447ae2e425a7f4.png%3F3)
chip de energia gigante es el nucleo de una central electrica. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/6883a57771447ae2e425a82b.png%3F3)
caja de energia electronica. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/6883a62d71447ae2e425a834.png%3F3)
torreta futurista en escala de grises con aspecto default. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/6883d3fdba1cafc351136e5f.png%3F3)
la entrada sean puertas abiertas y este dicha entrada rozando el borde de la imagen en la parte superior. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68885b97ebee72d34758d027.png%3F3)
Bala electrica futurista. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68885bfdebee72d34758d033.png%3F3)
Rango circular de un radar. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68885d05ebee72d34758d056.png%3F3)
Bala de un rayo láser morado en vertical. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68885d4eebee72d34758d05f.png%3F3)
Bala de hielo futurista. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68885da4ebee72d34758d069.png%3F3)
Bala de fuego futurista. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68885de5ebee72d34758d075.png%3F3)
Misil futurista. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68885ecdebee72d34758d08c.png%3F3)
Torreta futurista electrica. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68885f16ebee72d34758d097.png%3F3)
Torreta futurista sniper morada. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68885f7eebee72d34758d0a6.png%3F3)
Torreta futurista grande verde. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68885fcfebee72d34758d0c0.png%3F3)
Torreta futurista grande de hielo. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68886007ebee72d34758d0cb.png%3F3)
Torreta futurista grande de fuego. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/6888607aebee72d34758d0d5.png%3F3)
Mapache robot naranja. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/688860b9ebee72d34758d0e3.png%3F3)
Fox robot amarillo. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68886101ebee72d34758d0f0.png%3F3)
Tortuga robot verde. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68886181ebee72d34758d108.png%3F3)
Crow robot morado volando. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/688861e6ebee72d34758d115.png%3F3)
Varios Ratones robot rosa. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/688862b1ebee72d34758d129.png%3F3)
Con ojos rojos y aura roja
:quality(85)/https://cdn.frvr.ai/68886323ebee72d34758d136.png%3F3)
Con ojos rojos y aura roja
:quality(85)/https://cdn.frvr.ai/688863aeebee72d34758d144.png%3F3)
Con ojos rojos y aura roja
:quality(85)/https://cdn.frvr.ai/68886c1debee72d34758d18e.png%3F3)
Con ojos rojos y aura roja
:quality(85)/https://cdn.frvr.ai/68886fedebee72d34758d1a9.png%3F3)
Ui panel futurista. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/6888708debee72d34758d1b6.png%3F3)
Barra de progreso de colores. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/6888722febee72d34758d1c6.png%3F3)
Icono de energia. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/688872f9ebee72d34758d1d4.png%3F3)
Icono de escudo futurista. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68887366ebee72d34758d1e2.png%3F3)
Icono de puntaje. In-Game asset. 2d. High contrast. No shadows
Sounds & Music
🎵
robot_damage
Sound effect
🎵
ui_click
Sound effect
🎵
turret_rapid_fire
Sound effect
🎵
laser_sniper_fire
Sound effect
🎵
missile_launch
Sound effect
🎵
ice_laser_fire
Sound effect
🎵
fire_laser_fire
Sound effect
🎵
turret_basic_fire
Sound effect
🎵
tower_upgrade
Sound effect
🎵
tower_sell
Sound effect
🎵
tower_build
Sound effect
🎵
boss_alert
Sound effect
🎵
wave_start
Sound effect
🎵
robot_destroyed
Sound effect
🎶
battle_theme
Music
🎶
boss_theme
Music
🎵
energy_core_hit
Sound effect
🎶
victory_theme
Music
🎵
victory_fanfare
Sound effect
🎶
factory_ambient
Music
Used plugins
@upit/tween
