Play
Creation History
User prompt
Backup last playable version. Remove rotate things.
User prompt
Fix the rotated grid layout so the cells are arranged horizontally, making the play area wider rather than taller. Enemies should spawn from the left side, but not inside blocked gray cells. Instead, they must enter through open gaps (path cells) and move directly towards the right side goal point. Adjust the spawn positions so enemies correctly detect and use the valid path from left to right, avoiding the gray blocked cells entirely. Make sure the pathfinding recognizes the first accessible blue cell as their entry point. Keep the whole system consistent and aligned after rotation.
User prompt
Rotate the entire cell grid (the main game board made of cells) by 90 degrees clockwise. After rotation, enemies should enter from the left side of the screen and aim to reach the right side. Update the spawn point to the new left edge, and set the new goal (damage point) to the right edge. Make sure the pathfinding system updates correctly so enemies navigate from left to right, not top to bottom anymore. Keep all grid sizes and cell positions consistent, only change the orientation and entry/exit logic.
User prompt
Turret towers should rotate towards the targeted enemy while shooting, for visual effect only, without moving their base position. The top edge (front face) of the tower graphic should face the enemy, matching the defined front direction from previous adjustments. This rotation behavior should be applied only to Cannon, Sniper, and Turret towers, and no other towers. ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
Add new asset use circle shape and replace with "Score" text.
User prompt
Add new asset as a coin and replace with "Gold" text. Add new asset as a heart and replace with "Lives" text.
User prompt
Made 2x bigger electricChain asset
User prompt
Please fix the bug: 'TypeError: setTimeout is not a function' in or related to this line: 'setTimeout(_createNextChain, 100); // 100ms delay between chains' Line Number: 187 ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
When a hit is registered and the element is "electric" (from the Sentinel tower), automatically spawn the "electricChain" asset starting from the initially hit enemy. The electricChain should bounce sequentially to all nearby enemies one by one, as if the electric effect jumps from one enemy to the next. After each contact with an enemy, the chain should visually move to the next nearby enemy, then finally disappear after finishing all jumps. It should always stay on the front layer (above all other effects and enemies) to clearly show the chaining effect. The chain must not appear all at once; it should dynamically travel and hit each nearby target in order before disappearing. ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
When an enemy is hit, check if the hit source is from a Sentinel tower and if the electric element is currently selected. If yes, replace the default hit effect with the new electric chain effect asset. The electric chain effect should visually connect the hit enemy to nearby enemies using the electric chain asset we created (the 10x10 white square). This effect should display quickly and then disappear, giving the feeling of a chain lightning. If the hit source is not Sentinel with electric selected, use the default hit effect as usual. Make sure that only one type of hit effect is active depending on the current element (ice, electric, fire). ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
Create a new asset for the electric damage effect. The base asset should be a simple white square shape, 10x10 pixels in size. This asset will be used to visually represent the electric "chain" effect between enemies. When an enemy is hit with electric damage, this asset should appear briefly as a fast-moving line connecting to nearby enemies, visually showing the chain lightning effect before quickly fading out. The shape should be kept minimal and clean, no glow or extra effects, only a pure white square shape as base. ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
Check the code carefully to find and remove any leftover or hidden slow effects that might still be applied from other sources besides the Malware Sentinel's bullet type. Make sure that the slow effect is only applied when the Malware Sentinel is using Ice bullets. When using Electric bullets, it should only deliver chain lightning damage to nearby enemies (25% base damage). When using Fire bullets, it should only apply the burn effect that deals 25% base damage over 5 seconds. Absolutely no slow effect should be active when Electric or Fire bullets are selected. Remove or disable any global or residual slow logic that might still be triggering. In short: • Ice → Only applies slow effect (25% for 2 seconds). • Electric → Only applies chain lightning to nearby enemies. • Fire → Only applies burn effect (25% base damage over 5 sec). No overlap between effects. Only one element’s effect can be active at a time. ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
Sentinel's all element attack still using slow effect. Don't do that. just ice attack will slow effect. ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
Set sentinel default attack as a ice. Remove purple default attack style. ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
Don't use any tint for element bullet asset in game ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
Make sure that only one bullet effect is active at a time on the Malware Sentinel. When a new element (Ice, Electric, or Fire) is selected, the previous bullet effect must be completely disabled. Example: If Ice was selected before and then switched to Electric, the slow effect from Ice should no longer be applied. Only the current selected element’s effect should work at all times ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
Define the attack effects of the Malware Sentinel based on its bullet type. • Ice bullet: On hit, applies a 25% slow effect to the enemy for 2 seconds. • Electric bullet: On hit, deals an additional 25% of base damage to nearby enemies around the main target. • Fire bullet: On hit, applies a burn effect to the enemy, dealing an extra 25% of base damage over 5 seconds (total burn damage equals 125% of base damage over the duration). While burning, each normal bullet hit still deals its regular base damage instantly, and the burn damage is added separately as damage over time. ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
Make 3 new asset for bullet but only use from sentinel tower. Ice fire and electric bullet. Each button "fire,ice,electric" whenever player choose with button, change bullet type. ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
They have their tint on button when we click. Make their tint with white brightness not other color. ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
They overlap eachother also, do padding vertically ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
They overlap with upgrade and sell buttons. move they left side little bit.
User prompt
scale them 3x the three newly added special ability buttons (Ice, Electric, Fire) ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
In the tower info section, add 3 small vertical buttons next to the Upgrade and Sell buttons. These buttons should only appear in the Malware Sentinel tower info panel. Create 3 new assets for these buttons, each around 30x30 pixels. For now, use a simple white square shape for each. Each button gives a special elemental attack mode to the Malware Sentinel tower. These modes can be selected after the tower is placed. First button (Ice): When this mode is active, every hit applies a slow effect to the enemy. This slow effect is short, and if multiple hits stack, it can slow up to 2 seconds total. Second button (Electric): When active, each attack also deals area damage to enemies near the main target, dealing 25% of base damage as splash. Third button (Fire): When active, each hit applies a burning effect that deals extra damage over time. The burn lasts 5 seconds and deals total extra damage equal to 25% of the base damage. These buttons visually appear only on Malware Sentinel, not on other towers. After selecting an elemental mode, the tower's attack visuals and effects should change accordingly. ↪💡 Consider importing and using the following plugins: @upit/tween.v1
User prompt
Downsize of font from upgrade and sell buttons %5
User prompt
Tower information box now using notification asset. Change with towerinfopanel asset.
/****
* Plugins
****/
var tween = LK.import("@upit/tween.v1");
/****
* Classes
****/
var Bullet = Container.expand(function (startX, startY, targetEnemy, damage, speed, elementalType) {
var self = Container.call(this);
self.targetEnemy = targetEnemy;
self.damage = damage || 10;
self.speed = speed || 5;
self.x = startX;
self.y = startY;
self.elementalType = elementalType || null;
// Choose bullet asset based on elemental type
var bulletAssetId = 'bullet';
if (elementalType === 'ice') {
bulletAssetId = 'bulletIce';
} else if (elementalType === 'electric') {
bulletAssetId = 'bulletElectric';
} else if (elementalType === 'fire') {
bulletAssetId = 'bulletFire';
}
var bulletGraphics = self.attachAsset(bulletAssetId, {
anchorX: 0.5,
anchorY: 0.5
});
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 === '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);
}
// Handle elemental mode effects for Malware Sentinel
if (self.elementalType && !self.targetEnemy.isImmune) {
if (self.elementalType === 'ice') {
// Ice mode: apply 25% slow effect for 2 seconds
var slowEffect = new EffectIndicator(self.targetEnemy.x, self.targetEnemy.y, 'ice');
game.addChild(slowEffect);
if (!self.targetEnemy.slowed) {
self.targetEnemy.originalSpeed = self.targetEnemy.speed;
self.targetEnemy.speed *= 0.75; // 25% slow (reduce speed by 25%)
self.targetEnemy.slowed = true;
self.targetEnemy.slowDuration = 120; // 2 seconds at 60 FPS
} else {
// Reset duration if already slowed
self.targetEnemy.slowDuration = 120; // 2 seconds at 60 FPS
}
} else if (self.elementalType === 'electric') {
// Electric mode: create sequential chain lightning effect
var splashDamage = self.damage * 0.25; // 25% of base damage
var splashRange = 80; // Splash range in pixels
var nearbyEnemies = [];
// Find all nearby enemies
for (var i = 0; i < enemies.length; i++) {
var nearbyEnemy = enemies[i];
if (nearbyEnemy !== self.targetEnemy) {
var dx = nearbyEnemy.x - self.targetEnemy.x;
var dy = nearbyEnemy.y - self.targetEnemy.y;
var distance = Math.sqrt(dx * dx + dy * dy);
if (distance <= splashRange) {
nearbyEnemies.push(nearbyEnemy);
}
}
}
if (nearbyEnemies.length > 0) {
// Limit to 3 chains maximum
var _createNextChain = function createNextChain() {
if (chainIndex >= maxChains || chainIndex >= nearbyEnemies.length) {
return; // Stop chaining
}
var targetEnemy = nearbyEnemies[chainIndex];
var dx = targetEnemy.x - currentEnemy.x;
var dy = targetEnemy.y - currentEnemy.y;
var distance = Math.sqrt(dx * dx + dy * dy);
// Create electric chain effect
var chainContainer = new Container();
chainContainer.x = currentEnemy.x;
chainContainer.y = currentEnemy.y;
game.addChild(chainContainer);
// Calculate number of chain segments based on distance
var numSegments = Math.max(1, Math.floor(distance / 10));
var deltaX = dx / numSegments;
var deltaY = dy / numSegments;
// Create chain segments
for (var j = 0; j < numSegments; j++) {
var chainSegment = chainContainer.attachAsset('electricChain', {
anchorX: 0.5,
anchorY: 0.5
});
chainSegment.x = deltaX * j;
chainSegment.y = deltaY * j;
chainSegment.tint = 0xFFFFFF;
chainSegment.alpha = 0.9;
}
// Animate the chain effect
tween(chainContainer, {
alpha: 0,
scaleX: 1.5,
scaleY: 1.5
}, {
duration: 150,
easing: tween.easeOut,
onFinish: function onFinish() {
chainContainer.destroy();
}
});
// Apply damage to target enemy
targetEnemy.health -= splashDamage;
if (targetEnemy.health <= 0) {
targetEnemy.health = 0;
} else {
targetEnemy.healthBar.width = targetEnemy.health / targetEnemy.maxHealth * 70;
}
// Set up next chain
currentEnemy = targetEnemy;
chainIndex++;
// Continue the chain after a short delay
if (chainIndex < maxChains && chainIndex < nearbyEnemies.length) {
LK.setTimeout(_createNextChain, 100); // 100ms delay between chains
}
}; // Start the chain sequence
// Create sequential chain effect starting from the initially hit enemy
var currentEnemy = self.targetEnemy;
var chainIndex = 0;
var maxChains = Math.min(nearbyEnemies.length, 3);
_createNextChain();
}
} else if (self.elementalType === 'fire') {
// Fire mode: apply burning effect dealing 25% of base damage over 5 seconds
var fireEffect = new EffectIndicator(self.targetEnemy.x, self.targetEnemy.y, 'fire');
game.addChild(fireEffect);
self.targetEnemy.burning = true;
// Calculate burn damage per frame: 25% of base damage over 300 frames (5 seconds)
self.targetEnemy.burnDamage = self.damage * 0.25 / 300; // Total 25% damage over 5 seconds
self.targetEnemy.burnDuration = 300; // 5 seconds at 60 FPS
}
}
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,
font: 'Consolas'
});
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 = false; // Keep debug numbers hidden
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;
debugArrows[a].visible = false; // Hide debug arrows from view
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);
numberLabel.visible = false; // Hide debug numbers from view
};
});
// 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 '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;
case 'ice':
effectGraphics.tint = 0x87CEEB;
effectGraphics.width = effectGraphics.height = CELL_SIZE;
break;
case 'electric':
effectGraphics.tint = 0xFFFF00;
effectGraphics.width = effectGraphics.height = CELL_SIZE;
break;
case 'fire':
effectGraphics.tint = 0xFF4500;
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 asset for this enemy type
var assetId = 'enemy';
if (self.isBoss) {
// Use specific boss assets for different boss types
switch (self.type) {
case 'normal':
assetId = 'boss_armored';
break;
case 'fast':
assetId = 'boss_spider';
break;
case 'immune':
assetId = 'boss_demon';
break;
case 'flying':
assetId = 'boss_dragon';
break;
case 'swarm':
assetId = 'boss_giant';
break;
default:
assetId = 'boss_armored';
}
} else if (self.type !== 'normal') {
assetId = 'enemy_' + self.type;
}
var enemyGraphics = self.attachAsset(assetId, {
anchorX: 0.5,
anchorY: 0.5
});
// Add slow continuous self-rotation for enemy and enemy_flying types only
if (self.type === 'normal' || self.type === 'flying') {
// Start continuous rotation animation
tween(enemyGraphics, {
rotation: Math.PI * 2
}, {
duration: 8000,
// 8 seconds for full rotation
easing: tween.linear,
onFinish: function onFinish() {
// Reset rotation and start again for continuous loop
enemyGraphics.rotation = 0;
tween(enemyGraphics, {
rotation: Math.PI * 2
}, {
duration: 8000,
easing: tween.linear,
onFinish: arguments.callee // Recursively call this function for infinite loop
});
}
});
}
// Scale up boss enemies
if (self.isBoss) {
enemyGraphics.scaleX = 1.8;
enemyGraphics.scaleY = 1.8;
}
// 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 || 'enemy', {
anchorX: 0.5,
anchorY: 0.5
});
// Apply shadow effect
shadowGraphics.tint = 0x000000; // Black shadow
shadowGraphics.alpha = 0.4; // Semi-transparent
// If this is a boss, scale up the shadow to match
if (self.isBoss) {
shadowGraphics.scaleX = 1.8;
shadowGraphics.scaleY = 1.8;
}
// 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;
}
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
}
}
}
// Handle burning effect
if (self.burning) {
// Visual indication of burning status
if (!self.burnEffect) {
self.burnEffect = true;
}
// Apply burn damage every frame
if (LK.ticks % 1 === 0) {
self.health -= self.burnDamage;
if (self.health <= 0) {
self.health = 0;
}
self.healthBar.width = self.health / self.maxHealth * 70;
}
self.burnDuration--;
if (self.burnDuration <= 0) {
self.burning = false;
self.burnEffect = false;
}
}
}
// Set tint based on effect status
if (self.isImmune) {
enemyGraphics.tint = 0xFFFFFF;
} else if (self.burning && self.poisoned && self.slowed) {
// Combine all three effects
enemyGraphics.tint = 0xFF6600; // Orange-red for fire + poison + slow
} else if (self.burning && self.poisoned) {
// Combine fire and poison
enemyGraphics.tint = 0xFF8000; // Orange for fire + poison
} else if (self.burning && self.slowed) {
// Combine fire and slow
enemyGraphics.tint = 0xFF4080; // Red-purple for fire + slow
} else if (self.poisoned && self.slowed) {
// Combine poison (0x00FFAA) and slow (0x9900FF) colors
// Simple average: R: (0+153)/2=76, G: (255+0)/2=127, B: (170+255)/2=212
enemyGraphics.tint = 0x4C7FD4;
} else if (self.burning) {
enemyGraphics.tint = 0xFF4500; // Orange-red for burning
} else if (self.poisoned) {
enemyGraphics.tint = 0x00FFAA;
} else if (self.slowed) {
enemyGraphics.tint = 0x9900FF;
} 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,
font: 'Consolas'
});
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,
font: 'Consolas'
});
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];
// Create vertical layout: walls on left/right edges and top/bottom buffer zones
var cellType = i <= 4 || i >= gridWidth - 4 || j === 0 || j === gridHeight - 1 ? 1 : 0;
// Create spawn and goal areas in the middle columns
var midPoint = Math.floor(gridWidth / 2);
if (j > midPoint - 3 && j <= midPoint + 3) {
if (i === 0) {
cellType = 2;
self.spawns.push(cell);
} else if (i <= 4) {
cellType = 0;
} else if (i === gridHeight - 1) {
cellType = 3;
self.goals.push(cell);
} else if (i >= gridHeight - 4) {
cellType = 0;
}
}
cell.type = cellType;
cell.x = i;
cell.y = j;
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 (i > 3 && i <= 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]);
}
}
}
};
self.updateEnemy = function (enemy) {
var cell = grid.getCell(enemy.cellX, enemy.cellY);
if (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 (x position is at least 5)
var hasReachedEntryArea = enemy.currentCellX >= 4;
// If enemy hasn't reached the entry area yet, just move right horizontally
if (!hasReachedEntryArea) {
// Move directly rightward
enemy.currentCellX += enemy.speed;
// Rotate enemy graphic to face rightward (0 radians = 0 degrees)
var angle = 0;
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.currentCellX >= 4) {
enemy.cellX = Math.round(enemy.currentCellX);
enemy.cellY = Math.round(enemy.currentCellY);
}
return false;
}
// After reaching entry area, handle flying enemies differently
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 normal pathfinding enemies
if (!enemy.currentTarget) {
enemy.currentTarget = cell.targets[0];
}
if (enemy.currentTarget) {
if (cell.score < enemy.currentTarget.score) {
enemy.currentTarget = cell;
}
var ox = enemy.currentTarget.x - enemy.currentCellX;
var oy = enemy.currentTarget.y - enemy.currentCellY;
var dist = Math.sqrt(ox * ox + oy * oy);
if (dist < enemy.speed) {
enemy.cellX = Math.round(enemy.currentCellX);
enemy.cellY = Math.round(enemy.currentCellY);
enemy.currentTarget = undefined;
return;
}
var angle = Math.atan2(oy, ox);
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;
};
});
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,
font: 'Consolas'
});
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;
// 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,
font: 'Consolas'
});
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';
// Increase size of base for easier touch
// Get appropriate asset for this tower type
var assetId = 'towerCannon'; // default
switch (self.towerType) {
case 'default':
assetId = 'towerCannon';
break;
case 'rapid':
assetId = 'towerTurret';
break;
case 'sniper':
assetId = 'towerSniper';
break;
case 'slow':
assetId = 'towerSentinel';
break;
case 'poison':
assetId = 'towerBeacon';
break;
case 'splash':
assetId = 'towerObelisk';
break;
}
var baseGraphics = self.attachAsset(assetId, {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 1.3,
scaleY: 1.3
});
// Remove tints to show original tower assets
var towerCost = getTowerCost(self.towerType);
// Convert tower type to themed name for shadow display
var shadowDisplayName = '';
switch (self.towerType) {
case 'default':
shadowDisplayName = 'Cannon';
break;
case 'rapid':
shadowDisplayName = 'Turret';
break;
case 'sniper':
shadowDisplayName = 'Sniper';
break;
case 'splash':
shadowDisplayName = 'Obelisk';
break;
case 'slow':
shadowDisplayName = 'Sentinel';
break;
case 'poison':
shadowDisplayName = 'Beacon';
break;
default:
shadowDisplayName = self.towerType.charAt(0).toUpperCase() + self.towerType.slice(1);
}
// Add shadow for tower type label
var typeLabelShadow = new Text2(shadowDisplayName, {
size: 35,
fill: 0x000000,
weight: 800,
font: 'Consolas'
});
typeLabelShadow.anchor.set(0.5, 0.5);
typeLabelShadow.x = 4;
typeLabelShadow.y = 100 + 4;
self.addChild(typeLabelShadow);
// Convert tower type to themed name for display
var displayName = '';
switch (self.towerType) {
case 'default':
displayName = 'Cannon';
break;
case 'rapid':
displayName = 'Turret';
break;
case 'sniper':
displayName = 'Sniper';
break;
case 'splash':
displayName = 'Obelisk';
break;
case 'slow':
displayName = 'Sentinel';
break;
case 'poison':
displayName = 'Beacon';
break;
default:
displayName = self.towerType.charAt(0).toUpperCase() + self.towerType.slice(1);
}
// Add tower type label
var typeLabel = new Text2(displayName, {
size: 35,
fill: 0xFFFFFF,
weight: 800,
font: 'Consolas'
});
typeLabel.anchor.set(0.5, 0.5);
typeLabel.y = 100; // Position 10 pixels below previous position
self.addChild(typeLabel);
// Add tower details text
var detailText = '';
switch (self.towerType) {
case 'default':
detailText = 'Single, slow';
break;
case 'rapid':
detailText = 'Faster, low damage';
break;
case 'sniper':
detailText = 'High damage, range, slow';
break;
case 'splash':
detailText = 'AOE damage, single shot';
break;
case 'slow':
detailText = 'Changeable mods';
break;
case 'poison':
detailText = 'Boosts range, fire rate';
break;
default:
detailText = 'Tower description';
}
// Add shadow for detail text
var detailTextShadow = new Text2(detailText, {
size: 20,
fill: 0x000000,
weight: 600,
font: 'Consolas'
});
detailTextShadow.anchor.set(0.5, 0.5);
detailTextShadow.x = 2;
detailTextShadow.y = 135 + 2;
self.addChild(detailTextShadow);
// Add detail text
var detailLabel = new Text2(detailText, {
size: 20,
fill: 0xCCCCCC,
weight: 600,
font: 'Consolas'
});
detailLabel.anchor.set(0.5, 0.5);
detailLabel.y = 135;
self.addChild(detailLabel);
// Add cost shadow
var costLabelShadow = new Text2(towerCost, {
size: 50,
fill: 0x000000,
weight: 800,
font: 'Consolas'
});
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,
font: 'Consolas'
});
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 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
var baseRange;
switch (self.id) {
case 'sniper':
// Sniper: base 5, +0.8 per level, but final upgrade gets a huge boost
if (self.level === self.maxLevel) {
baseRange = 12 * CELL_SIZE; // Significantly increased range for max level
} else {
baseRange = (5 + (self.level - 1) * 0.8) * CELL_SIZE;
}
break;
case 'rapid':
// Rapid: base 2.5, +0.5 per level
baseRange = (2.5 + (self.level - 1) * 0.5) * CELL_SIZE;
break;
case 'slow':
// Slow: base 3.5, +0.5 per level
baseRange = (3.5 + (self.level - 1) * 0.5) * CELL_SIZE;
break;
case 'poison':
// Poison (Support): base 3.2, +0.5 per level
baseRange = (3.2 + (self.level - 1) * 0.5) * CELL_SIZE;
break;
default:
// Default: base 3, +0.5 per level
baseRange = (3 + (self.level - 1) * 0.5) * CELL_SIZE;
break;
}
// Apply range buff if this tower is buffed by a support tower
var rangeBuff = self._rangeBuff || 1.0;
return baseRange * rangeBuff;
};
self.cellsInRange = [];
self.fireRate = 60;
self.bulletSpeed = 5;
self.damage = 10;
self.lastFired = 0;
self.targetEnemy = null;
self.elementalMode = 'ice'; // Default to ice mode for Malware Sentinel
switch (self.id) {
case 'rapid':
self.fireRate = 30;
self.damage = 5;
self.range = 2.5 * CELL_SIZE;
self.bulletSpeed = 7;
break;
case 'sniper':
self.fireRate = 90;
self.damage = 25;
self.range = 5 * CELL_SIZE;
self.bulletSpeed = 25;
break;
case 'slow':
self.fireRate = 50;
self.damage = 8;
self.range = 3.5 * CELL_SIZE;
self.bulletSpeed = 5;
break;
case 'poison':
self.fireRate = 70;
self.damage = 12;
self.range = 3.2 * CELL_SIZE;
self.bulletSpeed = 5;
break;
}
// Get appropriate asset for this tower type
var assetId = 'towerCannon'; // default
switch (self.id) {
case 'default':
assetId = 'towerCannon';
break;
case 'rapid':
assetId = 'towerTurret';
break;
case 'sniper':
assetId = 'towerSniper';
break;
case 'slow':
assetId = 'towerSentinel';
break;
case 'poison':
assetId = 'towerBeacon';
break;
case 'splash':
assetId = 'towerObelisk';
break;
}
var baseGraphics = self.attachAsset('towerpreview', {
anchorX: 0.5,
anchorY: 0.5
});
baseGraphics.width = CELL_SIZE * 2;
baseGraphics.height = CELL_SIZE * 2;
baseGraphics.alpha = 0; // Hide tower base background completely
var towerGraphics = self.attachAsset(assetId, {
anchorX: 0.5,
anchorY: 0.5
});
// Remove tower tints to show original tower assets
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);
var gunGraphics = gunContainer.attachAsset('defense', {
anchorX: 0.5,
anchorY: 0.5
});
gunGraphics.alpha = 0; // Hide grey tower square by setting alpha to 0
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 '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 () {
// Support tower (poison type) provides buffs instead of attacking
if (self.id === 'poison') {
// Calculate buff multiplier based on level: 1.1x at level 1 to 2.0x at level 6
var buffMultiplier = 1.1 + (self.level - 1) / (self.maxLevel - 1) * 0.9; // Linear scale from 1.1 to 2.0
// Apply buffs to towers within range
for (var i = 0; i < towers.length; i++) {
var tower = towers[i];
if (tower !== self && tower.id !== 'poison') {
// Don't buff self or other support towers
var dx = tower.x - self.x;
var dy = tower.y - self.y;
var distance = Math.sqrt(dx * dx + dy * dy);
if (distance <= self.getRange()) {
// Apply buff by modifying tower properties temporarily
if (!tower._originalFireRate) {
tower._originalFireRate = tower.fireRate;
}
if (!tower._originalRange) {
tower._originalRange = tower.getRange();
}
// Apply fire rate buff (lower fireRate = faster firing)
tower.fireRate = Math.max(5, Math.floor(tower._originalFireRate / buffMultiplier));
// Store range buff for getRange method to use
tower._rangeBuff = buffMultiplier;
tower._isBuffed = true;
} else {
// Remove buff if tower is out of range
if (tower._isBuffed) {
tower.fireRate = tower._originalFireRate || tower.fireRate;
tower._rangeBuff = 1.0;
tower._isBuffed = false;
}
}
}
}
return; // Support towers don't attack
}
// Normal attack behavior for non-support towers
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);
// Rotate towers that should face their targets (Cannon, Sniper, and Turret)
if (self.id === 'default' || self.id === 'sniper' || self.id === 'rapid') {
// Adjust angle so bottom edge (PI radians) points towards target
// Add PI/2 to rotate the reference point from right edge to bottom edge
var adjustedAngle = angle + Math.PI / 2;
// Store the target rotation for smooth animation
if (towerGraphics.targetRotation === undefined) {
towerGraphics.targetRotation = adjustedAngle;
towerGraphics.rotation = adjustedAngle;
} else {
// Only rotate if the angle difference is significant
if (Math.abs(adjustedAngle - towerGraphics.targetRotation) > 0.05) {
tween.stop(towerGraphics, {
rotation: true
});
// Calculate the shortest angle to rotate
var currentRotation = towerGraphics.rotation;
var angleDiff = adjustedAngle - 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;
}
towerGraphics.targetRotation = adjustedAngle;
tween(towerGraphics, {
rotation: currentRotation + angleDiff
}, {
duration: 200,
easing: tween.easeOut
});
}
}
}
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 () {
// Support towers (poison type) don't fire bullets
if (self.id === 'poison') {
return;
}
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;
// Determine elemental type for bullet
var elementalType = null;
if (self.id === 'slow' && self.elementalMode) {
elementalType = self.elementalMode;
}
var bullet = new Bullet(bulletX, bulletY, self.targetEnemy, self.damage, self.bulletSpeed, elementalType);
// 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;
}
// Apply elemental mode effects for Malware Sentinel
if (self.id === 'slow' && self.elementalMode) {
bullet.elementalMode = self.elementalMode;
bullet.sourceTowerLevel = self.level;
}
// Customize bullet appearance based on tower type
switch (self.id) {
case 'rapid':
bullet.children[0].tint = 0x00AAFF;
bullet.children[0].width = 20;
bullet.children[0].height = 20;
break;
case 'sniper':
bullet.children[0].tint = 0xFF5500;
bullet.children[0].width = 15;
bullet.children[0].height = 15;
break;
case 'slow':
// No default tint for Malware Sentinel bullets - elemental assets handle appearance
bullet.children[0].width = 35;
bullet.children[0].height = 35;
break;
}
game.addChild(bullet);
bullets.push(bullet);
self.targetEnemy.bulletsTargetingThis.push(bullet);
// --- 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;
self.x = grid.x + gridX * CELL_SIZE + CELL_SIZE / 2;
self.y = grid.y + gridY * CELL_SIZE + CELL_SIZE / 2;
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();
// Hide tower base background after placement
baseGraphics.alpha = 0;
baseGraphics.visible = false;
};
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;
var previewGraphics = self.attachAsset('towerpreview', {
anchorX: 0.5,
anchorY: 0.5
});
previewGraphics.width = CELL_SIZE * 2;
previewGraphics.height = CELL_SIZE * 2;
previewGraphics.alpha = 0.5; // Show grey tower square during preview with transparency
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;
switch (self.towerType) {
case 'rapid':
previewGraphics.tint = 0x00AAFF;
break;
case 'sniper':
previewGraphics.tint = 0xFF5500;
break;
case 'slow':
previewGraphics.tint = 0x9900FF;
break;
case 'poison':
previewGraphics.tint = 0x00FFAA;
break;
default:
previewGraphics.tint = 0xAAAAAA;
}
if (!self.canPlace || !self.hasEnoughGold) {
previewGraphics.tint = 0xFF0000;
}
};
self.updatePlacementStatus = function () {
var validGridPlacement = true;
if (self.gridX <= 4 || self.gridX + 1 >= grid.cells.length - 4) {
validGridPlacement = false;
} else {
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 || cell.type !== 0) {
validGridPlacement = false;
break;
}
}
if (!validGridPlacement) {
break;
}
}
}
self.blockedByEnemy = false;
if (validGridPlacement) {
for (var i = 0; i < enemies.length; i++) {
var enemy = enemies[i];
if (enemy.currentCellX < 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 && !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);
self.x = grid.x + self.gridX * CELL_SIZE + CELL_SIZE / 2;
self.y = grid.y + self.gridY * CELL_SIZE + CELL_SIZE / 2;
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('towerInfoPanel', {
anchorX: 0.5,
anchorY: 0.5
});
menuBackground.width = 2048;
menuBackground.height = 500;
menuBackground.tint = 0x444444;
menuBackground.alpha = 0.9;
// Convert tower ID to themed name
var towerDisplayName = '';
switch (self.tower.id) {
case 'default':
towerDisplayName = 'Antivirus Cannon';
break;
case 'rapid':
towerDisplayName = 'Adblocker Turret';
break;
case 'sniper':
towerDisplayName = 'Quarantine Sniper';
break;
case 'splash':
towerDisplayName = 'Firewall Obelisk';
break;
case 'slow':
towerDisplayName = 'Malware Sentinel';
break;
case 'poison':
towerDisplayName = 'Restore Beacon';
break;
default:
towerDisplayName = self.tower.id.charAt(0).toUpperCase() + self.tower.id.slice(1) + ' Tower';
}
var towerTypeText = new Text2(towerDisplayName, {
size: 80,
fill: 0xFFFFFF,
weight: 800,
font: 'Consolas'
});
towerTypeText.anchor.set(0, 0);
towerTypeText.x = -840;
towerTypeText.y = -160;
self.addChild(towerTypeText);
var statsText;
if (self.tower.id === 'poison') {
// For support towers, show buff multipliers instead of damage/fire rate
var buffMultiplier = 1.1 + (self.tower.level - 1) / (self.tower.maxLevel - 1) * 0.9; // Linear scale from 1.1 to 2.0
var fireRateBuffPercent = Math.round((buffMultiplier - 1) * 100);
var rangeBuffPercent = Math.round((buffMultiplier - 1) * 100);
var rangeCells = (self.tower.getRange() / CELL_SIZE).toFixed(1);
statsText = new Text2('Level: ' + self.tower.level + '/' + self.tower.maxLevel + '\nFire Rate Buff: +' + fireRateBuffPercent + '%\nRange Buff: +' + rangeBuffPercent + '%\nRange: ' + rangeCells + ' cells', {
size: 70,
fill: 0xFFFFFF,
weight: 400,
font: 'Consolas'
});
} else {
var rangeCells = (self.tower.getRange() / CELL_SIZE).toFixed(1);
statsText = new Text2('Level: ' + self.tower.level + '/' + self.tower.maxLevel + '\nDamage: ' + self.tower.damage + '\nFire Rate: ' + (60 / self.tower.fireRate).toFixed(1) + '/s\nRange: ' + rangeCells + ' cells', {
size: 70,
fill: 0xFFFFFF,
weight: 400,
font: 'Consolas'
});
}
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: 46,
fill: 0xFFFFFF,
weight: 800,
font: 'Consolas'
});
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: 46,
fill: 0xFFFFFF,
weight: 800,
font: 'Consolas'
});
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,
font: 'Consolas'
});
closeText.anchor.set(0.5, 0.5);
closeButton.addChild(closeText);
closeButton.x = menuBackground.width / 2 - 57;
closeButton.y = -menuBackground.height / 2 + 57;
// Add elemental mode buttons for Malware Sentinel only
var elementalButtons = null;
if (self.tower.id === 'slow') {
elementalButtons = new Container();
buttonsContainer.addChild(elementalButtons);
// Ice button
var iceButton = new Container();
elementalButtons.addChild(iceButton);
var iceBackground = iceButton.attachAsset('iceButton', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 3,
scaleY: 3
});
iceBackground.tint = self.tower.elementalMode === 'ice' ? 0xFFFFFF : 0xCCCCCC;
iceButton.x = -350;
iceButton.y = -120;
// Electric button
var electricButton = new Container();
elementalButtons.addChild(electricButton);
var electricBackground = electricButton.attachAsset('electricButton', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 3,
scaleY: 3
});
electricBackground.tint = self.tower.elementalMode === 'electric' ? 0xFFFFFF : 0xCCCCCC;
electricButton.x = -350;
electricButton.y = -20;
// Fire button
var fireButton = new Container();
elementalButtons.addChild(fireButton);
var fireBackground = fireButton.attachAsset('fireButton', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 3,
scaleY: 3
});
fireBackground.tint = self.tower.elementalMode === 'fire' ? 0xFFFFFF : 0xCCCCCC;
fireButton.x = -350;
fireButton.y = 80;
// Button click handlers
iceButton.down = function () {
// Clear all elemental effects from all enemies before switching
for (var i = 0; i < enemies.length; i++) {
var enemy = enemies[i];
// Clear electric and fire effects
enemy.burning = false;
enemy.burnEffect = false;
enemy.burnDamage = 0;
enemy.burnDuration = 0;
// Note: Don't clear slow effects as they can come from other towers too
}
self.tower.elementalMode = self.tower.elementalMode === 'ice' ? null : 'ice';
iceBackground.tint = self.tower.elementalMode === 'ice' ? 0xFFFFFF : 0xCCCCCC;
electricBackground.tint = 0xCCCCCC;
fireBackground.tint = 0xCCCCCC;
};
electricButton.down = function () {
// Clear all elemental effects from all enemies before switching
for (var i = 0; i < enemies.length; i++) {
var enemy = enemies[i];
// Clear fire effects
enemy.burning = false;
enemy.burnEffect = false;
enemy.burnDamage = 0;
enemy.burnDuration = 0;
// Note: Don't clear slow effects as they can come from other towers too
}
self.tower.elementalMode = self.tower.elementalMode === 'electric' ? null : 'electric';
electricBackground.tint = self.tower.elementalMode === 'electric' ? 0xFFFFFF : 0xCCCCCC;
iceBackground.tint = 0xCCCCCC;
fireBackground.tint = 0xCCCCCC;
};
fireButton.down = function () {
// Clear all elemental effects from all enemies before switching
for (var i = 0; i < enemies.length; i++) {
var enemy = enemies[i];
// Clear fire effects (in case switching from fire to fire to disable)
enemy.burning = false;
enemy.burnEffect = false;
enemy.burnDamage = 0;
enemy.burnDuration = 0;
// Note: Don't clear slow effects as they can come from other towers too
}
self.tower.elementalMode = self.tower.elementalMode === 'fire' ? null : 'fire';
fireBackground.tint = self.tower.elementalMode === 'fire' ? 0xFFFFFF : 0xCCCCCC;
iceBackground.tint = 0xCCCCCC;
electricBackground.tint = 0xCCCCCC;
};
}
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));
}
if (self.tower.id === 'poison') {
// For support towers, show buff multipliers instead of damage/fire rate
var buffMultiplier = 1.1 + (self.tower.level - 1) / (self.tower.maxLevel - 1) * 0.9; // Linear scale from 1.1 to 2.0
var fireRateBuffPercent = Math.round((buffMultiplier - 1) * 100);
var rangeBuffPercent = Math.round((buffMultiplier - 1) * 100);
var rangeCells = (self.tower.getRange() / CELL_SIZE).toFixed(1);
statsText.setText('Level: ' + self.tower.level + '/' + self.tower.maxLevel + '\nFire Rate Buff: +' + fireRateBuffPercent + '%\nRange Buff: +' + rangeBuffPercent + '%\nRange: ' + rangeCells + ' cells');
} else {
var rangeCells = (self.tower.getRange() / CELL_SIZE).toFixed(1);
statsText.setText('Level: ' + self.tower.level + '/' + self.tower.maxLevel + '\nDamage: ' + self.tower.damage + '\nFire Rate: ' + (60 / self.tower.fireRate).toFixed(1) + '/s\nRange: ' + rangeCells + ' cells');
}
buttonText.setText('Upgrade: ' + upgradeCost + ' gold');
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);
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,
font: 'Consolas'
});
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,
font: 'Consolas'
});
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) {
self.gameStarted = true;
currentWave = 0;
waveTimer = nextWaveTime;
startBlock.tint = 0x00FF00;
startText.setText("Started!");
startTextShadow.setText("Started!");
// Make sure shadow position remains correct after text change
startTextShadow.x = 4;
startTextShadow.y = 4;
var notification = game.addChild(new Notification("Game started! Wave 1 incoming!"));
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,
font: 'Consolas'
});
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,
font: 'Consolas'
});
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,
font: 'Consolas'
});
waveNumShadow.anchor.set(1.0, 1.0);
waveNumShadow.x = blockWidth / 2 - 16 + 5;
waveNumShadow.y = block.height / 2 - 12 + 5;
marker.addChildAt(waveNumShadow, 0);
// Main wave number text - 20% larger than before
var waveNum = new Text2((i + 1).toString(), {
size: 48,
fill: 0xFFFFFF,
weight: 800,
font: 'Consolas'
});
waveNum.anchor.set(1.0, 1.0);
waveNum.x = blockWidth / 2 - 16;
waveNum.y = block.height / 2 - 12;
marker.addChildAt(waveNum, 0);
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 notification = game.addChild(new Notification("Wave " + currentWave + " (" + waveType + " - " + enemyCount + " enemies) incoming!"));
notification.x = 2048 / 2;
notification.y = grid.height - 150;
}
}
}
};
self.handleWaveProgression();
};
return self;
});
/****
* Initialize Game
****/
var game = new LK.Game({
backgroundColor: 0x333333
});
/****
* Game Code
****/
// Orbitron font is loaded externally via Google Fonts
// LK engine handles web fonts automatically when specified in Text2 objects
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
var goldContainer = new Container();
var coinAsset = goldContainer.attachAsset('coin', {
anchorX: 0.5,
anchorY: 0.5
});
coinAsset.x = -50;
var goldText = new Text2(gold.toString(), {
size: 60,
fill: 0xFFD700,
weight: 800,
font: 'Consolas'
});
goldText.anchor.set(0.5, 0.5);
goldText.x = 20;
goldContainer.addChild(goldText);
var livesContainer = new Container();
var heartAsset = livesContainer.attachAsset('heart', {
anchorX: 0.5,
anchorY: 0.5
});
heartAsset.x = -50;
var livesText = new Text2(lives.toString(), {
size: 60,
fill: 0x00FF00,
weight: 800,
font: 'Consolas'
});
livesText.anchor.set(0.5, 0.5);
livesText.x = 20;
livesContainer.addChild(livesText);
var scoreContainer = new Container();
var scoreCircleAsset = scoreContainer.attachAsset('scoreCircle', {
anchorX: 0.5,
anchorY: 0.5
});
scoreCircleAsset.x = -50;
var scoreText = new Text2(score.toString(), {
size: 60,
fill: 0xFFFFFF,
weight: 800,
font: 'Consolas'
});
scoreText.anchor.set(0.5, 0.5);
scoreText.x = 20;
scoreContainer.addChild(scoreText);
var topMargin = 50;
var centerX = 2048 / 2;
var spacing = 400;
LK.gui.top.addChild(goldContainer);
LK.gui.top.addChild(livesContainer);
LK.gui.top.addChild(scoreContainer);
livesContainer.x = 0;
livesContainer.y = topMargin;
goldContainer.x = -spacing;
goldContainer.y = topMargin;
scoreContainer.x = spacing;
scoreContainer.y = topMargin;
function updateUI() {
goldText.setText(gold.toString());
livesText.setText(lives.toString());
scoreText.setText(score.toString());
}
function setGold(value) {
gold = value;
updateUI();
}
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;
// Grid positioning restored to original values for top-down view
grid.pathFind();
grid.renderDebug();
debugLayer.addChild(grid);
game.addChild(debugLayer); // Layer 0: Cell/grid
game.addChild(enemyLayer);
game.addChild(towerLayer); // Layer 2: Towers (top layer)
var offset = 0;
var towerPreview = new TowerPreview();
game.addChild(towerPreview);
towerPreview.visible = false;
var isDragging = false;
function wouldBlockPath(gridX, gridY) {
var cells = [];
for (var i = 0; i < 2; i++) {
for (var j = 0; j < 2; j++) {
var cell = grid.getCell(gridX + i, gridY + j);
if (cell) {
cells.push({
cell: cell,
originalType: cell.type
});
cell.type = 1;
}
}
}
var blocked = grid.pathFind();
for (var i = 0; i < cells.length; i++) {
cells[i].cell.type = cells[i].originalType;
}
grid.pathFind();
grid.renderDebug();
return blocked;
}
function getTowerCost(towerType) {
var cost = 5;
switch (towerType) {
case 'rapid':
cost = 15;
break;
case 'sniper':
cost = 25;
break;
case 'slow':
cost = 45;
break;
case 'poison':
cost = 55;
break;
case 'splash':
cost = 65;
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();
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];
// Use exact turret size for hover detection
var hoverWidth = tower.width;
var hoverHeight = tower.height;
if (x >= tower.x - hoverWidth / 2 && x <= tower.x + hoverWidth / 2 && y >= tower.y - hoverHeight / 2 && y <= tower.y + hoverHeight / 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("Cannot build here!"));
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();
}
}
}
};
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', 'slow', 'poison', 'splash'];
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;
}
// 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;
// All enemy types now spawn in the middle 6 tiles at the top edge (vertical layout)
var gridHeight = 29 + 6;
var midPoint = Math.floor(gridHeight / 2); // ~17
// Find a row that isn't occupied by another enemy that's not yet in view
var availableRows = [];
for (var row = midPoint - 3; row < midPoint + 3; row++) {
var rowOccupied = false;
// Check if any enemy is already in this row but not yet in view
for (var e = 0; e < enemies.length; e++) {
if (enemies[e].cellY === row && enemies[e].currentCellX < 4) {
rowOccupied = true;
break;
}
}
if (!rowOccupied) {
availableRows.push(row);
}
}
// If all rows are occupied, use original random method
var spawnY;
if (availableRows.length > 0) {
// Choose a random unoccupied row
spawnY = availableRows[Math.floor(Math.random() * availableRows.length)];
} else {
// Fallback to random if all rows are occupied
spawnY = midPoint - 3 + Math.floor(Math.random() * 6); // y from ~14 to ~20
}
var spawnX = -1 - Math.random() * 5; // Random distance left of the grid for spreading
enemy.cellX = 5; // Position after entry
enemy.cellY = spawnY;
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;
}
}
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);
// 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();
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();
}
if (currentWave >= totalWaves && enemies.length === 0 && !waveInProgress) {
LK.showYouWin();
}
}; ===================================================================
--- original.js
+++ change.js
@@ -712,22 +712,22 @@
*/
for (var i = 0; i < gridWidth; i++) {
for (var j = 0; j < gridHeight; j++) {
var cell = self.cells[i][j];
- // Create horizontal layout: walls on top/bottom edges and left/right buffer zones
- var cellType = j <= 4 || j >= gridHeight - 4 || i === 0 || i === gridWidth - 1 ? 1 : 0;
- // Create spawn and goal areas in the middle rows
- var midPoint = Math.floor(gridHeight / 2);
- if (i > midPoint - 3 && i <= midPoint + 3) {
- if (j === 0) {
+ // Create vertical layout: walls on left/right edges and top/bottom buffer zones
+ var cellType = i <= 4 || i >= gridWidth - 4 || j === 0 || j === gridHeight - 1 ? 1 : 0;
+ // Create spawn and goal areas in the middle columns
+ var midPoint = Math.floor(gridWidth / 2);
+ if (j > midPoint - 3 && j <= midPoint + 3) {
+ if (i === 0) {
cellType = 2;
self.spawns.push(cell);
- } else if (j <= 4) {
+ } else if (i <= 4) {
cellType = 0;
- } else if (j === gridWidth - 1) {
+ } else if (i === gridHeight - 1) {
cellType = 3;
self.goals.push(cell);
- } else if (j >= gridWidth - 4) {
+ } else if (i >= gridHeight - 4) {
cellType = 0;
}
}
cell.type = cellType;
@@ -742,9 +742,9 @@
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 <= gridWidth - 4) {
+ if (i > 3 && i <= gridHeight - 4) {
var debugCell = new DebugCell();
self.addChild(debugCell);
debugCell.cell = cell;
debugCell.x = i * CELL_SIZE;
@@ -816,9 +816,9 @@
}
for (var a = 0; a < enemies.length; a++) {
var enemy = enemies[a];
// Skip enemies that haven't entered the viewable area yet
- if (enemy.currentCellX < 4) {
+ if (enemy.currentCellY < 4) {
continue;
}
// Skip flying enemies from path check as they can fly over obstacles
if (enemy.isFlying) {
@@ -861,16 +861,16 @@
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
+ // Check if the enemy has reached the entry area (x position is at least 5)
+ var hasReachedEntryArea = enemy.currentCellX >= 4;
+ // If enemy hasn't reached the entry area yet, just move right horizontally
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;
+ // Move directly rightward
+ enemy.currentCellX += enemy.speed;
+ // Rotate enemy graphic to face rightward (0 radians = 0 degrees)
+ var angle = 0;
if (enemy.children[0] && enemy.children[0].targetRotation === undefined) {
enemy.children[0].targetRotation = angle;
enemy.children[0].rotation = angle;
} else if (enemy.children[0]) {
@@ -901,9 +901,9 @@
// 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) {
+ if (enemy.currentCellX >= 4) {
enemy.cellX = Math.round(enemy.currentCellX);
enemy.cellY = Math.round(enemy.currentCellY);
}
return false;
@@ -1930,9 +1930,9 @@
}
};
self.updatePlacementStatus = function () {
var validGridPlacement = true;
- if (self.gridY <= 4 || self.gridY + 1 >= grid.cells[0].length - 4) {
+ if (self.gridX <= 4 || self.gridX + 1 >= grid.cells.length - 4) {
validGridPlacement = false;
} else {
for (var i = 0; i < 2; i++) {
for (var j = 0; j < 2; j++) {
@@ -1950,9 +1950,9 @@
self.blockedByEnemy = false;
if (validGridPlacement) {
for (var i = 0; i < enemies.length; i++) {
var enemy = enemies[i];
- if (enemy.currentCellY < 4) {
+ if (enemy.currentCellX < 4) {
continue;
}
// Only check non-flying enemies, flying enemies can pass over towers
if (!enemy.isFlying) {
@@ -3088,38 +3088,38 @@
enemy.maxHealth = Math.round(enemy.maxHealth * healthMultiplier);
enemy.health = enemy.maxHealth;
// Increment speed slightly with wave number
//enemy.speed = enemy.speed + currentWave * 0.002;
- // All enemy types now spawn in the middle 6 tiles at the left edge (horizontal layout)
- var gridWidth = 24;
- var midPoint = Math.floor(gridWidth / 2); // ~12
- // Find a column that isn't occupied by another enemy that's not yet in view
- var availableColumns = [];
- for (var col = midPoint - 3; col < midPoint + 3; col++) {
- var colOccupied = false;
- // Check if any enemy is already in this column but not yet in view
+ // All enemy types now spawn in the middle 6 tiles at the top edge (vertical layout)
+ var gridHeight = 29 + 6;
+ var midPoint = Math.floor(gridHeight / 2); // ~17
+ // Find a row that isn't occupied by another enemy that's not yet in view
+ var availableRows = [];
+ for (var row = midPoint - 3; row < midPoint + 3; row++) {
+ var rowOccupied = false;
+ // Check if any enemy is already in this row but not yet in view
for (var e = 0; e < enemies.length; e++) {
- if (enemies[e].cellX === col && enemies[e].currentCellY < 4) {
- colOccupied = true;
+ if (enemies[e].cellY === row && enemies[e].currentCellX < 4) {
+ rowOccupied = true;
break;
}
}
- if (!colOccupied) {
- availableColumns.push(col);
+ if (!rowOccupied) {
+ availableRows.push(row);
}
}
- // If all columns are occupied, use original random method
- var spawnX;
- if (availableColumns.length > 0) {
- // Choose a random unoccupied column
- spawnX = availableColumns[Math.floor(Math.random() * availableColumns.length)];
+ // If all rows are occupied, use original random method
+ var spawnY;
+ if (availableRows.length > 0) {
+ // Choose a random unoccupied row
+ spawnY = availableRows[Math.floor(Math.random() * availableRows.length)];
} else {
- // Fallback to random if all columns are occupied
- spawnX = midPoint - 3 + Math.floor(Math.random() * 6); // x from ~9 to ~15
+ // Fallback to random if all rows are occupied
+ spawnY = midPoint - 3 + Math.floor(Math.random() * 6); // y from ~14 to ~20
}
- var spawnY = -1 - Math.random() * 5; // Random distance above the grid for spreading
- enemy.cellX = spawnX;
- enemy.cellY = 5; // Position after entry
+ var spawnX = -1 - Math.random() * 5; // Random distance left of the grid for spreading
+ enemy.cellX = 5; // Position after entry
+ enemy.cellY = spawnY;
enemy.currentCellX = spawnX;
enemy.currentCellY = spawnY;
enemy.waveNumber = currentWave;
enemies.push(enemy);
Images
:quality(85)/https://cdn.frvr.ai/671be23a3de176b9ade21311.png%3F3)
:quality(85)/https://cdn.frvr.ai/686546068041868302dc6a7d.png%3F3)
top-down view, futuristic digital defense turret, heavy energy core, metallic cyberpunk style, blue glowing lines, anti-virus cannon. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/6865464c8041868302dc6a92.png%3F3)
top-down view, transformable virus defense tower, modular energy panels, electric fire ice modes, adaptive cyber node design, neon highlights. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/6865472d8041868302dc6ab7.png%3F3)
top-down view, futuristic support beacon tower, energy rings, radiant aura effect, soft blue and white glow, advanced tech support node. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/686547708041868302dc6ac2.png%3F3)
top-down view, small rapid-fire digital turret, multiple mini barrels, bright cyan glowing circuits, compact and fast look. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/686547ab8041868302dc6ace.png%3F3)
top-down view, high-tech energy obelisk, emits area energy pulses, holographic fire shield patterns, black and red glowing accents. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/686548a28041868302dc6af3.png%3F3)
top-down view, futuristic sniper defense tower, mechanical turret base, integrated long-range scope with green targeting reticle, high-tech cyberpunk machine parts, sleek tower design, circular top down, symmetrical. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/686553c08041868302dc6b68.png%3F3)
topdown view, simple digital virus blob, glowing green core, minimal circuit-like lines on surface, smooth rounded shape, fits motherboard environment, futuristic style. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/6865541d8041868302dc6b7f.png%3F3)
topdown view, robust digital virus, armored segments, red glowing core, strong angular shape, protective shell feel, minimal circuit accents, fits motherboard environment. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/686554ae8041868302dc6b9c.png%3F3)
topdown view, small compact digital virus, dark purple core, clustered cell-like form, tiny spiky details, designed to appear in groups, minimal yet recognizable, fits motherboard environment. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/686554f98041868302dc6ba7.png%3F3)
topdown view, sleek digital projectile, bright neon core, streamlined shape, subtle circuit-like lines, glowing edge, minimal futuristic design, fits motherboard environment. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/686555d68041868302dc6bb3.png%3F3)
topdown view, sleek fast-moving digital virus, straight vertical shape, bright cyan core, smooth streamlined body, minimal circuit-like lines, futuristic minimal design, fits motherboard environment In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/686557448041868302dc6bd4.png%3F3)
simple hexagon outline, empty center, solid white border, no glow, no fill, minimal style, flat design, 10x10 pixel, icon design, on transparent background, topdown view. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/686574b88041868302dc6d6e.png%3F3)
futuristic square tile, 3D look, topdown view, subtle shadowed edges, slightly beveled borders, solid clean style, metallic or sci-fi surface, not flat, looks like a cube seen from above, 76x76 pixel, on transparent background. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/686577638041868302dc6d92.png%3F3)
topdown view, glitchy digital virus, distorted edges, purple-blue core, semi-transparent parts, digital glitch effect around edges, ethereal appearance, fits motherboard environment, vectorel draw. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/686579418041868302dc6dad.png%3F3)
giant worm-like virus creature, segmented body, glowing circuit patterns, top-down view, menacing style, glitch effects, sci-fi, dark purple and neon accents, symmetrical, circular.. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/686579e48041868302dc6dc5.png%3F3)
sleek spectral virus entity, flowing energy trails, ghostly and translucent, topdown view, neon blue and white accents, glitch particles, sci-fi, circular, symmetrical. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68657a3c8041868302dc6dd1.png%3F3)
multi-headed virus monster, branching tendrils, glowing core, topdown view, blue and purple neon, organic digital fusion style, symmetrical, circular. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68657a7e8041868302dc6ddd.png%3F3)
massive cube-shaped virus, distorted glitch surfaces, holographic data streams, topdown view, green and black colors, digital corruption texture, symmetrical, circular. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68658a578041868302dc6f05.png%3F3)
top-down view, simple minimal white square icon, centered electric bolt symbol inside, clear sharp lines, no background, clean style, for game UI button, 30x30 px, yellow black. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68658ac88041868302dc6f1a.png%3F3)
:quality(85)/https://cdn.frvr.ai/68658af78041868302dc6f28.png%3F3)
top-down view, simple minimal white square icon, centered ice crystal or snowflake symbol inside, clear sharp lines, no background, clean style, for game UI button, 30x30 px, black border, blue. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68658f268041868302dc6f61.png%3F3)
blue electric shock circular. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68658f798041868302dc6f72.png%3F3)
30x30 fire circular. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68658fc28041868302dc6f7b.png%3F3)
30x30, ice cube, symmetrical, circular. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/6865953fda98a9448332d360.png%3F3)
30x30 lightning chain. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68659819da98a9448332d384.png%3F3)
golden coin, simple clean shape, subtle beveled edges, slight 3D top-down look, small shadow for depth, no text, no shine or sparkle, minimal design, matches futuristic tech UI style. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/686598f5da98a9448332d3a4.png%3F3)
Green, simple shield icon, clean minimal futuristic design, top-down view, 76x76 pixels, matches sci-fi circuit board theme, no text, no glow, no effects, just flat shape. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68659a12da98a9448332d3bb.png%3F3)
white, simple digital badge icon, clean futuristic circuit look, top-down view, 76x76 pixels, no text, no glow, flat lines only. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68666bf190890decacdd92b8.png%3F3)
Topdown view, flying red demonic virus boss, evil-looking, sharp edges, glowing red core, cyber style, futuristic tech details, no background, circular, symmetrical. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68667d5490890decacdd9300.png%3F3)
inventory background cell border square. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/68668ecd90890decacdd935f.png%3F3)
golden star icon, minimalistic, clean flat style, topdown perspective, no shadows, smooth edges, soft glow effect, transparent background. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/6866929790890decacdd937e.png%3F3)
circle, tiny green neon border, gray fill, simple. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/6866934490890decacdd938a.png%3F3)
premium quality rectangular button background, 500x150 px, clean futuristic tech design, subtle gradients, beveled edges, slight inner glow, dark metallic blue tones, minimal and elegant, no text, no icon, transparent background. In-Game asset. 2d. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/6866939890890decacdd9395.png%3F3)
premium quality rectangular button background, 500x150 px, clean futuristic tech design, subtle gradients, beveled edges, slight inner glow, dark metallic white tones, minimal and elegant, no text, no icon, transparent background. In-Game asset. 2d. High contrast. No shadows
Sounds & Music
Used plugins
@upit/tween
