/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");

/**** 
* Classes
****/ 
var AreaDamage = Container.expand(function (centerX, centerY, radius, damage, excludeEnemy) {
	var self = Container.call(this);
	self.x = centerX;
	self.y = centerY;
	self.radius = radius;
	self.damage = damage;
	self.excludeEnemy = excludeEnemy;
	self.lifetime = 5; // Frames to exist
	// Create visual effect
	var assetName = radius > 100 ? 'largeAreaDamage' : 'smallAreaDamage';
	var visualEffect = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	visualEffect.alpha = 0.6;
	// Animate the visual effect
	tween(visualEffect, {
		alpha: 0,
		scaleX: 1.2,
		scaleY: 1.2
	}, {
		duration: 2000,
		easing: tween.easeOut
	});
	self.update = function () {
		// Deal damage to all enemies in radius
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			if (enemy === self.excludeEnemy) continue; // Skip the original target
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance <= self.radius) {
				enemy.takeDamage(self.damage);
			}
		}
		self.lifetime--;
		if (self.lifetime <= 0) {
			self.shouldDestroy = true;
		}
	};
	return self;
});
var Bullet = Container.expand(function (startX, startY, damage, target, bulletType) {
	var self = Container.call(this);
	self.x = startX;
	self.y = startY;
	self.speed = 8;
	self.damage = damage || 1;
	self.target = target;
	self.bulletType = bulletType || 'bullet';
	var bulletGraphics = self.attachAsset(self.bulletType, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		if (self.target && self.target.parent) {
			// Calculate direction to target
			var dx = self.target.x - self.x;
			var dy = self.target.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance > 5) {
				// Move towards target
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			} else {
				// Close enough to target
				if (self.target.takeDamage) {
					self.target.takeDamage(self.damage);
				}
				self.shouldDestroy = true;
			}
		} else {
			// Target is gone, destroy bullet
			self.shouldDestroy = true;
		}
	};
	return self;
});
var Defender = Container.expand(function (type, level) {
	var self = Container.call(this);
	self.type = type || 'green';
	self.level = level || 1;
	self.shootTimer = 0;
	self.shootInterval = 60; // 1 second at 60fps
	self.damage = 1;
	var assetNames = {
		'green': 'archer',
		'yellow': 'spearFighter',
		'red': 'musketeer',
		'orange': 'cannon',
		'blue': 'skyMage',
		'black': 'darkMage'
	};
	var defenderGraphics = self.attachAsset(assetNames[self.type], {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		// Check if linked die just finished rolling
		if (self.linkedDie && self.linkedDie.justFinishedRolling) {
			self.shoot();
		}
	};
	self.shoot = function () {
		var die = self.linkedDie;
		if (die && enemies.length > 0 && die.justFinishedRolling) {
			// Find nearest enemy
			var nearestEnemy = null;
			var shortestDistance = Infinity;
			for (var e = 0; e < enemies.length; e++) {
				var enemy = enemies[e];
				var dx = enemy.x - self.x;
				var dy = enemy.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < shortestDistance) {
					shortestDistance = distance;
					nearestEnemy = enemy;
				}
			}
			if (nearestEnemy) {
				var shots = die.getRollValue();
				var bulletTypes = {
					'green': 'arrow',
					'yellow': 'spear',
					'red': 'musketBall',
					'orange': 'cannonBall',
					'blue': 'blueMagic',
					'black': 'darkMagic'
				};
				var bulletType = bulletTypes[self.type] || 'bullet';
				// Set damage based on defender type
				var bulletDamage = self.damage;
				if (self.type === 'red') {
					bulletDamage = 2; // Musketeer deals 2 damage
				} else if (self.type === 'blue') {
					bulletDamage = 2; // Sky mage deals 2 damage
				}
				// Fire bullets in sequence with 0.3 second intervals
				for (var i = 0; i < shots; i++) {
					LK.setTimeout(function (shotIndex) {
						return function () {
							// Find target again (in case original target was destroyed)
							var currentTarget = nearestEnemy;
							if (!currentTarget || !currentTarget.parent) {
								// Find new nearest enemy
								for (var e = 0; e < enemies.length; e++) {
									var enemy = enemies[e];
									var dx = enemy.x - self.x;
									var dy = enemy.y - self.y;
									var distance = Math.sqrt(dx * dx + dy * dy);
									if (!currentTarget || distance < Math.sqrt((currentTarget.x - self.x) * (currentTarget.x - self.x) + (currentTarget.y - self.y) * (currentTarget.y - self.y))) {
										currentTarget = enemy;
									}
								}
							}
							if (currentTarget && currentTarget.parent) {
								var bullet = new Bullet(self.x, self.y - 40, bulletDamage, currentTarget, bulletType);
								bullets.push(bullet);
								game.addChild(bullet);
								LK.getSound('shoot').play();
							}
						};
					}(i), i * 300); // 300ms = 0.3 seconds
				}
				die.justFinishedRolling = false;
			}
		}
	};
	return self;
});
var Die = Container.expand(function (type, level) {
	var self = Container.call(this);
	self.type = type || 'green';
	self.level = level || 1;
	self.rollTimer = 0;
	self.rollInterval = 180; // 3 seconds at 60fps
	self.lastRoll = 1;
	self.isDragging = false;
	self.justFinishedRolling = false;
	self.originalPosition = {
		x: 0,
		y: 0
	};
	var assetNames = {
		'green': 'greenDie',
		'yellow': 'yellowDie',
		'red': 'redDie',
		'orange': 'orangeDie',
		'blue': 'blueDie',
		'black': 'blackDie'
	};
	var dieGraphics = self.attachAsset(assetNames[self.type], {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var levelText = new Text2(self.level.toString(), {
		size: 40,
		fill: 0xFFFFFF
	});
	levelText.anchor.set(0.5, 0.5);
	levelText.x = 0;
	levelText.y = -20;
	self.addChild(levelText);
	var rollText = new Text2(self.lastRoll.toString(), {
		size: 60,
		fill: 0xFFFFFF
	});
	rollText.anchor.set(0.5, 0.5);
	rollText.x = 0;
	rollText.y = 20;
	self.addChild(rollText);
	self.down = function (x, y, obj) {
		self.isDragging = true;
		self.originalPosition.x = self.x;
		self.originalPosition.y = self.y;
		draggedDie = self;
	};
	self.update = function () {
		self.rollTimer++;
		// Blue dice rotate every 2 seconds (120 ticks), others every 3 seconds (180 ticks)
		var currentInterval = self.rollInterval;
		if (self.type === 'blue') {
			currentInterval = 120; // 2 seconds for blue dice
		}
		if (self.rollTimer >= currentInterval) {
			self.rollTimer = 0;
			self.lastRoll = Math.floor(Math.random() * 6) + 1;
			var displayValue = self.lastRoll + (self.level - 1) * 2;
			rollText.setText(displayValue.toString());
			self.justFinishedRolling = true;
			// Add rolling animation
			tween(dieGraphics, {
				rotation: Math.PI * 2
			}, {
				duration: 500,
				easing: tween.easeOut
			});
		}
	};
	self.getRollValue = function () {
		return self.lastRoll + (self.level - 1) * 2;
	};
	self.updateLevel = function (newLevel) {
		self.level = newLevel;
		levelText.setText(self.level.toString());
	};
	return self;
});
var Enemy = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type || 'troll';
	// Set stats based on enemy type
	var enemyStats = {
		'troll': {
			health: 5,
			speed: 1,
			goldValue: Math.floor(Math.random() * 5) + 3,
			// 3-7 gold
			asset: 'troll'
		},
		'skeleton': {
			health: 10,
			speed: 1.5,
			goldValue: Math.floor(Math.random() * 7) + 5,
			// 5-11 gold
			asset: 'skeleton'
		}
	};
	var stats = enemyStats[self.type] || enemyStats['troll'];
	self.health = stats.health;
	self.maxHealth = stats.health;
	self.speed = stats.speed;
	self.goldValue = stats.goldValue;
	var enemyGraphics = self.attachAsset(stats.asset, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var healthBar = new Text2(self.health.toString(), {
		size: 30,
		fill: 0xFF0000
	});
	healthBar.anchor.set(0.5, 0.5);
	healthBar.x = 0;
	healthBar.y = -80;
	self.addChild(healthBar);
	self.update = function () {
		self.y += self.speed;
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		healthBar.setText(self.health.toString());
		if (self.health <= 0) {
			self.die();
		}
	};
	self.die = function () {
		gold += self.goldValue;
		goldText.setText('Gold: ' + gold);
		LK.getSound('enemyDie').play();
		LK.effects.flashObject(self, 0xFF0000, 500);
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x2F5233
});

/**** 
* Game Code
****/ 
// Game variables
var gold = 10;
var enemies = [];
var bullets = [];
var dice = [];
var defenders = [];
var wallSlots = [];
var diceSlots = [];
var draggedDie = null;
var trashArea = null;
var enemySpawnTimer = 0;
var enemySpawnInterval = 300; // 5 seconds initially
var gameTimer = 0; // Track game time in ticks
var dicesPurchased = 0; // Track number of dice purchased for pricing
// UI elements
var goldText = new Text2('Gold: 10', {
	size: 60,
	fill: 0xFFFF00
});
goldText.anchor.set(0, 0);
goldText.x = 150;
goldText.y = 50;
LK.gui.topLeft.addChild(goldText);
// Create wall
var wall = game.addChild(LK.getAsset('wall', {
	anchorX: 0.5,
	anchorY: 1,
	x: 1024,
	y: 1900
}));
// Create wall slots (9 defensive positions)
for (var i = 0; i < 9; i++) {
	var slot = game.addChild(LK.getAsset('wallSlot', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 200 + i * 200,
		y: 1900 - 75
	}));
	wallSlots.push(slot);
}
// Create dice grid (3x3)
var diceGridStartX = 824; // Center on screen (1024 - 200)
var diceGridStartY = 2100;
for (var row = 0; row < 3; row++) {
	for (var col = 0; col < 3; col++) {
		var slot = game.addChild(LK.getAsset('diceSlot', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: diceGridStartX + col * 200,
			y: diceGridStartY + row * 200
		}));
		slot.isEmpty = true;
		slot.gridIndex = row * 3 + col;
		diceSlots.push(slot);
	}
}
// Create trash area to the left of dice grid
trashArea = game.addChild(LK.getAsset('trashArea', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 524,
	// Left of dice grid
	y: 2200
}));
// Buy button
var buyButton = game.addChild(LK.getAsset('buyButton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1600,
	y: 2200
}));
// Price display text
var priceText = new Text2('Price: 10', {
	size: 40,
	fill: 0xFFFFFF
});
priceText.anchor.set(0.5, 0);
priceText.x = 1600;
priceText.y = 2400;
game.addChild(priceText);
buyButton.down = function (x, y, obj) {
	var currentPrice = 10 + dicesPurchased * 5;
	if (gold >= currentPrice) {
		buyDie();
	}
};
function buyDie() {
	var emptySlot = null;
	for (var i = 0; i < diceSlots.length; i++) {
		if (diceSlots[i].isEmpty) {
			emptySlot = diceSlots[i];
			break;
		}
	}
	if (emptySlot) {
		var currentPrice = 10 + dicesPurchased * 5;
		gold -= currentPrice;
		dicesPurchased++;
		goldText.setText('Gold: ' + gold);
		// Update price display for next purchase
		var nextPrice = 10 + dicesPurchased * 5;
		priceText.setText('Price: ' + nextPrice);
		var dieTypes = ['green', 'yellow', 'red', 'orange', 'blue', 'black'];
		var weights = [30, 30, 20, 20, 10, 10]; // Common, Common, Rare, Rare, Legendary, Legendary
		var randomType = getWeightedRandom(dieTypes, weights);
		var newDie = new Die(randomType, 1);
		newDie.x = emptySlot.x;
		newDie.y = emptySlot.y;
		newDie.slotIndex = emptySlot.gridIndex;
		dice.push(newDie);
		game.addChild(newDie);
		emptySlot.isEmpty = false;
		emptySlot.occupiedBy = newDie;
		// Create corresponding defender
		createDefender(newDie);
	}
}
function getWeightedRandom(items, weights) {
	var totalWeight = 0;
	for (var i = 0; i < weights.length; i++) {
		totalWeight += weights[i];
	}
	var random = Math.random() * totalWeight;
	var currentWeight = 0;
	for (var i = 0; i < items.length; i++) {
		currentWeight += weights[i];
		if (random <= currentWeight) {
			return items[i];
		}
	}
	return items[0];
}
function createDefender(die) {
	var defender = new Defender(die.type, die.level);
	var wallSlot = wallSlots[die.slotIndex % 9];
	defender.x = wallSlot.x;
	defender.y = wallSlot.y;
	defender.linkedDie = die;
	defenders.push(defender);
	game.addChild(defender);
}
function spawnEnemy() {
	var enemyType = 'troll';
	// After 20 seconds (1200 ticks), start spawning skeletons occasionally
	if (gameTimer > 1200) {
		// 30% chance for skeleton, 70% for troll
		if (Math.random() < 0.3) {
			enemyType = 'skeleton';
		}
	}
	var enemy = new Enemy(enemyType);
	enemy.x = Math.random() * 1800 + 124; // Random X position
	enemy.y = -100; // Start above screen
	enemies.push(enemy);
	game.addChild(enemy);
}
function handleMove(x, y, obj) {
	if (draggedDie) {
		draggedDie.x = x;
		draggedDie.y = y;
	}
}
function handleUp(x, y, obj) {
	if (draggedDie) {
		var merged = false;
		var trashed = false;
		// Check if dropped on trash area
		if (draggedDie.intersects(trashArea)) {
			// Destroy die and give 5 gold
			gold += 5;
			goldText.setText('Gold: ' + gold);
			// Remove die from slot
			var slot = diceSlots[draggedDie.slotIndex];
			slot.isEmpty = true;
			slot.occupiedBy = null;
			// Remove corresponding defender
			for (var i = defenders.length - 1; i >= 0; i--) {
				if (defenders[i].linkedDie === draggedDie) {
					defenders[i].destroy();
					defenders.splice(i, 1);
					break;
				}
			}
			// Remove die
			draggedDie.destroy();
			dice.splice(dice.indexOf(draggedDie), 1);
			trashed = true;
		}
		if (!trashed) {
			// Check for merge with other dice
			for (var i = 0; i < dice.length; i++) {
				var otherDie = dice[i];
				if (otherDie !== draggedDie && otherDie.type === draggedDie.type && otherDie.level === draggedDie.level && draggedDie.intersects(otherDie)) {
					// Merge dice
					mergeDice(draggedDie, otherDie);
					merged = true;
					break;
				}
			}
			if (!merged) {
				// Return to original position
				draggedDie.x = draggedDie.originalPosition.x;
				draggedDie.y = draggedDie.originalPosition.y;
			}
		}
		draggedDie = null;
	}
}
function mergeDice(die1, die2) {
	// Remove die1 from game
	var slot1 = diceSlots[die1.slotIndex];
	slot1.isEmpty = true;
	slot1.occupiedBy = null;
	// Remove corresponding defender
	for (var i = defenders.length - 1; i >= 0; i--) {
		if (defenders[i].linkedDie === die1) {
			defenders[i].destroy();
			defenders.splice(i, 1);
			break;
		}
	}
	die1.destroy();
	dice.splice(dice.indexOf(die1), 1);
	// Upgrade die2
	die2.updateLevel(die2.level + 1);
	// Update corresponding defender
	for (var i = 0; i < defenders.length; i++) {
		if (defenders[i].linkedDie === die2) {
			defenders[i].level = die2.level;
			break;
		}
	}
	LK.getSound('merge').play();
}
game.move = handleMove;
game.up = handleUp;
game.update = function () {
	// Update game timer
	gameTimer++;
	// Progressive enemy spawning
	enemySpawnTimer++;
	var currentInterval = enemySpawnInterval;
	// First 20 seconds: very slow spawning (12 seconds)
	if (gameTimer <= 1200) {
		currentInterval = 720; // 12 seconds
	}
	// Next phase: medium spawning (8 seconds)
	else if (gameTimer <= 2400) {
		currentInterval = 480; // 8 seconds
	}
	// After 40 seconds: moderate spawning (5 seconds)
	else {
		currentInterval = 300; // 5 seconds
	}
	if (enemySpawnTimer >= currentInterval) {
		enemySpawnTimer = 0;
		spawnEnemy();
	}
	// Update bullets and check collisions
	for (var i = bullets.length - 1; i >= 0; i--) {
		var bullet = bullets[i];
		// Check if bullet should be destroyed
		if (bullet.shouldDestroy || bullet.y < -50 || bullet.y > 2732 || bullet.x < 0 || bullet.x > 2048) {
			bullet.destroy();
			bullets.splice(i, 1);
			continue;
		}
		// Check collision with target or any enemy
		var hitEnemy = false;
		for (var j = enemies.length - 1; j >= 0; j--) {
			var enemy = enemies[j];
			if (bullet.intersects(enemy)) {
				// Handle area damage for cannon and dark mage
				if (bullet.bulletType === 'cannonBall') {
					// Small area damage for cannon
					var areaDamage = new AreaDamage(enemy.x, enemy.y, 80, bullet.damage, enemy);
					areaDamage.lifetime = 120; // 2 seconds at 60fps
					game.addChild(areaDamage);
				} else if (bullet.bulletType === 'darkMagic') {
					// Large area damage for dark mage
					var areaDamage = new AreaDamage(enemy.x, enemy.y, 150, bullet.damage, enemy);
					areaDamage.lifetime = 120; // 2 seconds at 60fps
					game.addChild(areaDamage);
				}
				enemy.takeDamage(bullet.damage);
				bullet.destroy();
				bullets.splice(i, 1);
				if (enemy.health <= 0) {
					enemy.destroy();
					enemies.splice(j, 1);
				}
				hitEnemy = true;
				break;
			}
		}
	}
	// Update and cleanup area damage objects
	for (var i = game.children.length - 1; i >= 0; i--) {
		var child = game.children[i];
		if (child.shouldDestroy) {
			child.destroy();
		}
	}
	// Check if enemies reached the wall
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		if (enemy.y >= 1770) {
			// Game over condition
			LK.effects.flashScreen(0xFF0000, 1000);
			LK.setTimeout(function () {
				LK.showGameOver();
			}, 1000);
			return;
		}
	}
};
// Start with one free die
buyDie();

===================================================================
--- original.js
+++ change.js
@@ -333,8 +333,9 @@
 var trashArea = null;
 var enemySpawnTimer = 0;
 var enemySpawnInterval = 300; // 5 seconds initially
 var gameTimer = 0; // Track game time in ticks
+var dicesPurchased = 0; // Track number of dice purchased for pricing
 // UI elements
 var goldText = new Text2('Gold: 10', {
 	size: 60,
 	fill: 0xFFFF00
@@ -390,10 +391,20 @@
 	anchorY: 0.5,
 	x: 1600,
 	y: 2200
 }));
+// Price display text
+var priceText = new Text2('Price: 10', {
+	size: 40,
+	fill: 0xFFFFFF
+});
+priceText.anchor.set(0.5, 0);
+priceText.x = 1600;
+priceText.y = 2400;
+game.addChild(priceText);
 buyButton.down = function (x, y, obj) {
-	if (gold >= 10) {
+	var currentPrice = 10 + dicesPurchased * 5;
+	if (gold >= currentPrice) {
 		buyDie();
 	}
 };
 function buyDie() {
@@ -404,10 +415,15 @@
 			break;
 		}
 	}
 	if (emptySlot) {
-		gold -= 10;
+		var currentPrice = 10 + dicesPurchased * 5;
+		gold -= currentPrice;
+		dicesPurchased++;
 		goldText.setText('Gold: ' + gold);
+		// Update price display for next purchase
+		var nextPrice = 10 + dicesPurchased * 5;
+		priceText.setText('Price: ' + nextPrice);
 		var dieTypes = ['green', 'yellow', 'red', 'orange', 'blue', 'black'];
 		var weights = [30, 30, 20, 20, 10, 10]; // Common, Common, Rare, Rare, Legendary, Legendary
 		var randomType = getWeightedRandom(dieTypes, weights);
 		var newDie = new Die(randomType, 1);