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

/**** 
* Classes
****/ 
/**** 
* CLASSES
****/ 
// Miner class
var Miner = Container.expand(function () {
	var self = Container.call(this);
	self.attachAsset('miner', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 5;
	self.currentTarget = null;
	self.miningRange = 25;
	self.miningCooldown = 0;
	self.miningRate = 30;
	self.miningDamage = 1;
	// Finds the closest ore that is unlocked & still alive
	self.findNewTarget = function () {
		var validOres = ores.filter(function (ore) {
			return ore.health > 0 && ore.tier <= gameState.currentTier;
		});
		if (validOres.length === 0) {
			self.currentTarget = null;
			return;
		}
		// Sort by distance ascending
		self.currentTarget = validOres.sort(function (a, b) {
			var distA = Math.hypot(a.x - self.x, a.y - self.y);
			var distB = Math.hypot(b.x - self.x, b.y - self.y);
			return distA - distB;
		})[0];
	};
	self.update = function () {
		self.findNewTarget();
		if (self.currentTarget) {
			var dx = self.currentTarget.x - self.x;
			var dy = self.currentTarget.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance > self.miningRange) {
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			} else {
				self.mineOre(self.currentTarget);
			}
		} else {
			// Idle float
			self.y += Math.sin(LK.ticks / 250) * 0.5;
		}
	};
	self.mineOre = function (ore) {
		if (self.miningCooldown > 0) {
			self.miningCooldown--;
			return;
		}
		// Deal damage
		ore.health -= self.miningDamage * gameState.pickaxeLevel;
		self.miningCooldown = self.miningRate;
		// If ore is destroyed, add money & spawn new cluster after delay
		if (ore.health <= 0) {
			gameState.money += ore.getValue();
			updateUI();
			ore.respawn();
			// Immediately look for a new target
			self.findNewTarget();
		}
		// Mining particle effect
		for (var i = 0; i < 5; i++) {
			var p = LK.getAsset('mining_particle', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			p.x = ore.x;
			p.y = ore.y;
			p.vx = (Math.random() - 0.5) * 10;
			p.vy = (Math.random() - 0.5) * 10;
			p.alpha = 1;
			tween(p, {
				alpha: 0,
				y: p.y - 50
			}, {
				duration: 1000,
				onFinish: function onFinish() {
					p.destroy();
				}
			});
			game.addChild(p);
		}
	};
	return self;
});
// Ore class
var Ore = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type;
	self.tier = ['coal', 'iron', 'gold', 'diamond'].indexOf(type) + 1;
	// For fade-out effect
	self.maxHealth = 10;
	self.health = self.maxHealth;
	// Base value depends on tier. Then multiplied by oreMultipliers in gameState.
	self.baseValue = 5 * self.tier;
	self.attachAsset(type + '_ore', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Health bar (bigger, and above the ore)
	self.healthBar = LK.getAsset('rectangle', {
		width: 100,
		// bigger than default
		height: 10,
		fill: 0x00FF00
	});
	self.healthBar.y = -70;
	self.addChild(self.healthBar);
	// The final money from this ore
	self.getValue = function () {
		return self.baseValue * gameState.oreMultipliers[self.type];
	};
	// Respawn = remove this ore, then spawn a new cluster after some delay
	self.respawn = function () {
		// Remove this ore from the game & from 'ores'
		self.destroy();
		var idx = ores.indexOf(self);
		if (idx !== -1) {
			ores.splice(idx, 1);
		}
		// Wait for respawnTime, then spawn a new cluster
		// of the same type with min–max from clusterConfig
		LK.setTimeout(function () {
			spawnCluster(self.type);
		}, gameState.respawnTime);
	};
	return self;
});

/**** 
* Initialize Game
****/ 
/**** 
* SPAWNING in CLUSTERS
****/ 
// Spawn a cluster of {min–max} ore objects near a random center
/**** 
* Initialize the Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x1a1a1a
});

/**** 
* Game Code
****/ 
// Where all current ore objects go
/**** 
* GLOBAL ARRAYS & STATE
****/ 
/**** 
* GAME CODE
****/ 
var ores = [];
// Predefined cluster ranges for upgrades
var clusterConfigLevels = [{
	min: 2,
	max: 3
},
// default
{
	min: 2,
	max: 4
}, {
	min: 3,
	max: 5
}, {
	min: 5,
	max: 10
}];
/**** 
* SPAWNING in CLUSTERS
****/ 
// Spawn a cluster of {min–max} ore objects near a random center
function spawnCluster(type) {
	// If type not unlocked (tier > currentTier), no spawn
	var tierIndex = ['coal', 'iron', 'gold', 'diamond'].indexOf(type) + 1;
	if (tierIndex > gameState.currentTier) {
		return;
	}
	var cfg = gameState.clusterConfig;
	var count = randomBetween(cfg.min, cfg.max);
	// Random center
	var centerX = 100 + Math.random() * (2048 - 200);
	var centerY = 100 + Math.random() * (2732 - 200);
	for (var i = 0; i < count; i++) {
		var ore = new Ore(type);
		// Random offset
		var offsetX = (Math.random() - 0.5) * 120;
		var offsetY = (Math.random() - 0.5) * 120;
		ore.x = centerX + offsetX;
		ore.y = centerY + offsetY;
		game.addChild(ore);
		ores.push(ore);
	}
}
// Utility to pick an integer between min and max inclusive
function randomBetween(min, max) {
	return Math.floor(Math.random() * (max - min + 1)) + min;
}
var upgradeMenu = new Container();
var tooltip = new Text2('', {
	size: 40,
	fill: 0xFFFFFF
});
// NEW cluster upgrade cost logic
// Each time we buy it, the cost goes up, and we move to next cluster tier.
var clusterUpgradeBaseCost = 1000;
/**** 
* Upgrades
****/ 
var upgrades = [{
	id: 'coal_expert',
	name: "Coal Expertise",
	cost: 100,
	effect: "Double coal value",
	tier: 1,
	action: function action() {
		gameState.oreMultipliers.coal *= 2;
	}
}, {
	id: 'unlock_iron',
	name: "Iron Mining",
	cost: 500,
	effect: "Unlock iron mining",
	tier: 2,
	action: function action() {
		gameState.currentTier = 2;
	}
}, {
	id: 'iron_expert',
	name: "Iron Expertise",
	cost: 2000,
	effect: "Triple iron value",
	tier: 2,
	requires: 'unlock_iron',
	action: function action() {
		gameState.oreMultipliers.iron *= 3;
	}
}, {
	id: 'unlock_gold',
	name: "Gold Mining",
	cost: 5000,
	effect: "Unlock gold mining",
	tier: 3,
	action: function action() {
		gameState.currentTier = 3;
	}
}, {
	id: 'gold_expert',
	name: "Gold Expertise",
	cost: 10000,
	effect: "Quadruple gold value",
	tier: 3,
	requires: 'unlock_gold',
	action: function action() {
		gameState.oreMultipliers.gold *= 4;
	}
}, {
	id: 'unlock_diamond',
	name: "Diamond Mining",
	cost: 20000,
	effect: "Unlock diamond mining",
	tier: 4,
	action: function action() {
		gameState.currentTier = 4;
	}
}, {
	id: 'faster_respawn',
	name: "Quicker Respawn",
	cost: 8000,
	effect: "Halves ore respawn time",
	tier: 2,
	action: function action() {
		// Halve the respawn time, min of 500 ms
		gameState.respawnTime = Math.max(500, gameState.respawnTime / 2);
	}
},
// The cluster upgrade
{
	id: 'cluster_up',
	name: "Cluster Growth [Tier 1]",
	cost: clusterUpgradeBaseCost,
	effect: "Increases cluster spawn range",
	tier: 1,
	action: function action() {
		// Increase clusterUpgradeTier if possible
		if (gameState.clusterUpgradeTier < clusterConfigLevels.length - 1) {
			gameState.clusterUpgradeTier++;
		}
		// Update cost each purchase (optional: double or add a fixed amount)
		// Example: next cost is +2000
		this.cost += 2000;
		// Update the cluster config in gameState
		gameState.clusterConfig = clusterConfigLevels[gameState.clusterUpgradeTier];
	}
}];
// Game state, including cluster setup
var gameState = {
	money: 0,
	pickaxeLevel: 1,
	currentTier: 1,
	oreMultipliers: {
		coal: 1,
		iron: 1,
		gold: 1,
		diamond: 1
	},
	respawnTime: 3000,
	// in ms
	clusterUpgradeTier: 0,
	// index into clusterConfigLevels
	// Default cluster range is 2-3
	clusterConfig: {
		min: 2,
		max: 3
	}
};
// Create the Miner
var miner = game.addChild(new Miner());
miner.x = 2048 / 2;
miner.y = 2732 / 2;
// Background
var background = LK.getAsset('background', {
	anchorX: 0.5,
	anchorY: 0.5
});
background.x = 2048 / 2;
background.y = 2732 / 2;
game.addChildAt(background, 0);
// UI
var moneyDisplay = new Text2('$0', {
	size: 80,
	fill: 0xFFFFFF,
	fontWeight: 'bold',
	stroke: 0x000000,
	strokeThickness: 5
});
moneyDisplay.x = 2048 / 2 - moneyDisplay.width / 2;
moneyDisplay.y = 50;
var shopButton = LK.getAsset('buy_button', {
	anchorX: 0.5,
	anchorY: 0.5
});
shopButton.x = 2048 - 150;
shopButton.y = 2732 - 150;
shopButton.down = function () {
	createUpgradeMenu();
	game.addChild(upgradeMenu);
};
game.addChild(moneyDisplay);
game.addChild(shopButton);
game.addChild(tooltip);
/**** 
* CREATE UPGRADE MENU
****/ 
function createUpgradeMenu() {
	upgradeMenu.removeChildren();
	var menuBg = LK.getAsset('rectangle', {
		width: 1600,
		height: 1800,
		color: 0x2a2a2a,
		anchorX: 0.5,
		anchorY: 0.5
	});
	menuBg.x = 2048 / 2;
	menuBg.y = 2732 / 2;
	upgradeMenu.addChild(menuBg);
	// Dynamically update the cluster upgrade’s display
	var clusterUpObj = upgrades.find(function (u) {
		return u.id === 'cluster_up';
	});
	if (clusterUpObj) {
		clusterUpObj.name = "Cluster Growth [Tier " + (gameState.clusterUpgradeTier + 1) + "]";
		var cfg = clusterConfigLevels[gameState.clusterUpgradeTier];
		clusterUpObj.effect = "Spawns " + cfg.min + "-" + cfg.max + " per cluster";
	}
	upgrades.forEach(function (upgrade, i) {
		// Check requirements
		var requirement = null;
		if (upgrade.requires) {
			requirement = upgrades.find(function (u) {
				return u.id === upgrade.requires;
			});
		}
		var y = 2732 / 2 - 500 + i * 200;
		// The buy button
		var btn = LK.getAsset('buy_button', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		btn.x = 2048 / 2;
		btn.y = y;
		upgradeMenu.addChild(btn);
		var canBuy = !upgrade.purchased && gameState.money >= upgrade.cost && (!requirement || requirement.purchased);
		// Text on top of button
		var text = new Text2(upgrade.name + "\n" + upgrade.effect + "\n$" + upgrade.cost, {
			size: 40,
			fill: canBuy ? 0xFFFFFF : 0x666666,
			align: 'center'
		});
		text.anchor.set(0.5, 0.5);
		text.x = btn.x;
		text.y = btn.y;
		upgradeMenu.addChild(text);
		// Button action
		btn.down = function () {
			if (canBuy) {
				gameState.money -= upgrade.cost;
				upgrade.purchased = true;
				upgrade.action();
				createUpgradeMenu();
				updateUI();
			}
		};
	});
	// Close button
	var closeBtn = LK.getAsset('cancelButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	closeBtn.x = 2048 / 2 + 600;
	closeBtn.y = 2732 / 2 - 700;
	closeBtn.down = function () {
		game.removeChild(upgradeMenu);
	};
	upgradeMenu.addChild(closeBtn);
}
/**** 
* UPDATE UI
****/ 
function updateUI() {
	moneyDisplay.setText("$" + gameState.money.toLocaleString() + "\n" + "Multipliers: " + "C" + gameState.oreMultipliers.coal + "x " + "I" + gameState.oreMultipliers.iron + "x " + "G" + gameState.oreMultipliers.gold + "x " + "D" + gameState.oreMultipliers.diamond + "x");
	moneyDisplay.x = 2048 / 2 - moneyDisplay.width / 2;
}
/**** 
* MAIN GAME UPDATE
****/ 
game.update = function () {
	miner.update();
	// Update ore health bars & alpha fade
	ores.forEach(function (ore) {
		if (ore.health > 0) {
			var fraction = ore.health / ore.maxHealth;
			// Health bar width & color
			ore.healthBar.width = 100 * fraction;
			ore.healthBar.fill = interpolateColor(0xFF0000, 0x00FF00, fraction);
			// Fade out
			ore.alpha = fraction;
		}
	});
};
/**** 
* COLOR HELPER
****/ 
function interpolateColor(color1, color2, factor) {
	var r1 = color1 >> 16 & 0xff;
	var g1 = color1 >> 8 & 0xff;
	var b1 = color1 & 0xff;
	var r2 = color2 >> 16 & 0xff;
	var g2 = color2 >> 8 & 0xff;
	var b2 = color2 & 0xff;
	var r = Math.round(r1 + factor * (r2 - r1));
	var g = Math.round(g1 + factor * (g2 - g1));
	var b = Math.round(b1 + factor * (b2 - b1));
	return r << 16 | g << 8 | b;
}
/**** 
* SAVE & LOAD
****/ 
LK.saveGame = function () {
	return gameState;
};
LK.loadGame = function (data) {
	gameState = data;
	updateUI();
};
/**** 
* INITIAL SPAWN
****/ 
// Spawn clusters of each type up to your currentTier
function initialSpawn() {
	var types = ['coal', 'iron', 'gold', 'diamond'];
	types.forEach(function (type, index) {
		// If type's tier <= currentTier, spawn a cluster of it
		var tier = index + 1;
		if (tier <= gameState.currentTier) {
			spawnCluster(type);
		}
	});
}
initialSpawn();
updateUI();

===================================================================
--- original.js
+++ change.js
@@ -51,9 +51,9 @@
 				self.mineOre(self.currentTarget);
 			}
 		} else {
 			// Idle float
-			self.y += Math.sin(LK.time.elapsed / 250) * 0.5;
+			self.y += Math.sin(LK.ticks / 250) * 0.5;
 		}
 	};
 	self.mineOre = function (ore) {
 		if (self.miningCooldown > 0) {