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

/**** 
* Classes
****/ 
/** 
* Drone Class – with a slight random deviation in movement.
*/ 
var Drone = Container.expand(function () {
	var self = Container.call(this);
	self.droneSprite = LK.getAsset('drone_asset', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.addChild(self.droneSprite);
	var SPEED = 8;
	var MIN_X = 50,
		MAX_X = 2000,
		MIN_Y = 50,
		MAX_Y = 2682;
	self.vx = Math.random() < 0.5 ? SPEED : -SPEED;
	self.vy = Math.random() < 0.5 ? SPEED : -SPEED;
	self.AOE_RANGE = 100;
	self.droneDamage = 2;
	self.COOLDOWN_MAX = 60;
	self.cooldown = 0;
	self.updateDrone = function () {
		self.x += self.vx;
		self.y += self.vy;
		if (self.x < MIN_X || self.x > MAX_X) {
			self.vx = -self.vx;
		}
		if (self.y < MIN_Y || self.y > MAX_Y) {
			self.vy = -self.vy;
		}
		// Add slight random deviation:
		if (Math.random() < 0.01) {
			self.vx += (Math.random() - 0.5) * 2;
			self.vy += (Math.random() - 0.5) * 2;
			var speed = Math.sqrt(self.vx * self.vx + self.vy * self.vy);
			if (speed > SPEED) {
				self.vx = self.vx / speed * SPEED;
				self.vy = self.vy / speed * SPEED;
			}
		}
		if (self.cooldown > 0) {
			self.cooldown--;
		} else {
			self.tryZap();
		}
	};
	self.tryZap = function () {
		var hitSomething = false;
		clusters.forEach(function (cluster) {
			cluster.oreList.forEach(function (ore) {
				if (ore.health > 0) {
					var oreGlobalX = cluster.x + ore.x;
					var oreGlobalY = cluster.y + ore.y;
					var dx = self.x - oreGlobalX;
					var dy = self.y - oreGlobalY;
					var dist = Math.sqrt(dx * dx + dy * dy);
					if (dist < self.AOE_RANGE) {
						ore.health -= self.droneDamage;
						hitSomething = true;
						if (ore.health <= 0) {
							var baseValue = ore.getValue();
							gameState.money += baseValue;
							updateUI();
							ore.cluster.notifyOreDestroyed(ore);
							spawnMiningParticles(ore, 5);
						}
					}
				}
			});
		});
		if (hitSomething) {
			self.cooldown = self.COOLDOWN_MAX;
		}
	};
	return self;
});
/** 
* Miner Class – now with Hyper Mining Mode.
*/ 
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;
	// Save original values for resetting after boosts:
	self.originalMiningRate = self.miningRate;
	self.originalMiningDamage = self.miningDamage;
	// Chronostone boost, Soul Ember, and Quantum Shard properties (existing)
	self.speedBoostMultiplier = 1;
	self.speedBoostTimer = 0;
	self.soulEmberStacks = 0;
	self.quantumPathActive = false;
	self.quantumPath = [];
	self.quantumShardValueBonus = false;
	// New Hyper Mining Mode variables:
	self.hyperMiningActive = false;
	self.hyperMiningTimer = 0;
	self.activateHyperMining = function () {
		self.hyperMiningActive = true;
		self.hyperMiningTimer = 10 * 60; // 10 seconds at 60fps
		self.miningDamage *= 2;
		self.miningRate = Math.max(1, Math.floor(self.miningRate / 2));
	};
	self.findNewTarget = function () {
		if (self.quantumPathActive && self.quantumPath.length > 0) {
			self.currentTarget = self.quantumPath[0];
			if (!self.currentTarget || self.currentTarget.health <= 0) {
				self.quantumPath.shift();
				if (self.quantumPath.length === 0) {
					if (self.quantumShardValueBonus) {
						self.quantumShardValueBonus = false;
					}
					self.quantumPathActive = false;
					self.currentTarget = null;
				}
				return;
			}
			return;
		}
		var validOre = [];
		clusters.forEach(function (c) {
			c.oreList.forEach(function (ore) {
				if (ore.health > 0 && ore.tier <= gameState.currentTier) {
					validOre.push(ore);
				}
			});
		});
		if (validOre.length === 0) {
			self.currentTarget = null;
			return;
		}
		self.currentTarget = validOre.sort(function (a, b) {
			var aX = a.parent.x + a.x;
			var aY = a.parent.y + a.y;
			var bX = b.parent.x + b.x;
			var bY = b.parent.y + b.y;
			var distA = Math.hypot(aX - self.x, aY - self.y);
			var distB = Math.hypot(bX - self.x, bY - self.y);
			return distA - distB;
		})[0];
	};
	self.update = function () {
		// Update Hyper Mining Mode timer if active:
		if (self.hyperMiningActive) {
			self.hyperMiningTimer--;
			if (self.hyperMiningTimer <= 0) {
				self.miningDamage = self.originalMiningDamage;
				self.miningRate = self.originalMiningRate;
				self.hyperMiningActive = false;
			}
		}
		// Decay Chronostone speed boost:
		if (self.speedBoostTimer > 0) {
			self.speedBoostTimer--;
			if (self.speedBoostTimer <= 0) {
				self.speedBoostMultiplier = 1;
			}
		}
		self.findNewTarget();
		if (self.currentTarget) {
			var tx = self.currentTarget.parent.x + self.currentTarget.x;
			var ty = self.currentTarget.parent.y + self.currentTarget.y;
			var dx = tx - self.x;
			var dy = ty - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			var finalSpeed = self.speed * self.speedBoostMultiplier;
			if (dist > self.miningRange) {
				self.x += dx / dist * finalSpeed;
				self.y += dy / dist * finalSpeed;
			} else {
				self.mineOre(self.currentTarget);
			}
		} else {
			if (typeof LK.time !== 'undefined') {
				self.y += Math.sin(LK.time.elapsed / 250) * 0.5;
			}
		}
	};
	self.mineOre = function (ore) {
		if (self.miningCooldown > 0) {
			self.miningCooldown--;
			return;
		}
		if (self.quantumPathActive && self.quantumPath.length > 0 && self.quantumPath[0] === ore) {
			self.quantumPath.shift();
			if (self.quantumPath.length === 0) {
				if (self.quantumShardValueBonus) {}
				self.quantumPathActive = false;
			}
		}
		var damageDealt = self.miningDamage * gameState.pickaxeLevel * (gameState.pickaxeBaseMultiplier || 1);
		ore.health -= damageDealt;
		self.miningCooldown = self.miningRate;
		if (ore.health <= 0) {
			var baseValue = ore.getValue();
			var finalValue = baseValue;
			if (self.soulEmberStacks > 0) {
				finalValue *= 5;
				self.soulEmberStacks--;
			}
			if (self.quantumShardValueBonus) {
				finalValue *= 1.5;
			}
			gameState.money += finalValue;
			updateUI();
			ore.cluster.notifyOreDestroyed(ore);
			spawnMiningParticles(ore, 5);
			// If the ore is explosive, trigger its chain reaction:
			if (ore.type === "explosive" && ore.explode) {
				ore.explode();
			}
		} else {
			spawnMiningParticles(ore, 2);
		}
	};
	// Existing boost functions (Chronostone, Soul Ember, Quantum Shard)
	self.applyChronostoneBoost = function () {
		self.speedBoostMultiplier *= 3;
		self.speedBoostTimer = 30 * 60;
	};
	self.applySoulEmberBoost = function () {
		if (gameState.money >= 1e6) {
			var drain = gameState.money * 0.10;
			gameState.money -= drain;
			self.soulEmberStacks = 10;
			updateUI();
		}
	};
	self.triggerQuantumShardMode = function () {
		self.quantumShardValueBonus = true;
		self.quantumPathActive = true;
		self.quantumPath = [];
		game.pauseForQuantumSelection();
	};
	return self;
});
/**** 
* DRONES, CLUSTERS, UI, SAVE/LOAD, SPAWNING etc.
* (The rest of your original code – including cluster spawning, UI menus, upgrade menus, prestige logic, etc. – remains unchanged.)
* 
* Just make sure to update the following:
* 
* 1. In getDroneDPS(), include the efficiency multiplier:
*/ 
/**** 
* HELPER FUNCTIONS FOR PRESTIGE & BACKGROUNDS (unchanged)
****/ 
// ... (Your existing prestige and background transition functions remain here)
/**** 
* CLASSES
****/ 
/** 
* Ore Class – now includes special glow and explosion behavior.
*/ 
var Ore = Container.expand(function (type, cluster) {
	var self = Container.call(this);
	self.type = type;
	self.cluster = cluster;
	// Determine tier (standard types or special ores)
	var typeList = ['coal', 'iron', 'gold', 'diamond', 'sapphire', 'emerald', 'ruby'];
	if (typeList.indexOf(type) >= 0) {
		self.tier = typeList.indexOf(type) + 1;
	} else {
		self.tier = 999;
	}
	self.baseValue = oreData[type].baseValue;
	self.maxHealth = oreData[type].baseHealth;
	self.health = self.maxHealth;
	// Attach sprite for the ore:
	self.attachAsset(oreData[type].assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add a health bar:
	self.healthBar = LK.getAsset('rectangle', {
		width: 120,
		height: 20,
		fill: 0x00FF00,
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.healthBar.x = 0;
	self.healthBar.y = -70;
	self.addChild(self.healthBar);
	// For special ores, add a pulsing glow effect:
	if (["chronostone", "soulember", "quantumshard"].indexOf(type) >= 0) {
		var _pulseGlow = function pulseGlow() {
			tween(glow, {
				alpha: 1
			}, {
				duration: 1000,
				onFinish: function onFinish() {
					tween(glow, {
						alpha: 0.5
					}, {
						duration: 1000,
						onFinish: _pulseGlow
					});
				}
			});
		};
		var glow = LK.getAsset('glowing_line_asset', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		glow.alpha = 0.5;
		self.addChildAt(glow, 0); // place behind the ore sprite
		_pulseGlow();
	}
	// If this is an explosive ore, add explosion behavior:
	if (type === "explosive") {
		self.explode = function () {
			var explosionRadius = 100;
			clusters.forEach(function (cluster) {
				cluster.oreList.forEach(function (otherOre) {
					if (otherOre !== self && otherOre.health > 0) {
						var oreGlobalX = cluster.x + otherOre.x;
						var oreGlobalY = cluster.y + otherOre.y;
						var dx = self.parent.x + self.x - oreGlobalX;
						var dy = self.parent.y + self.y - oreGlobalY;
						var dist = Math.sqrt(dx * dx + dy * dy);
						if (dist < explosionRadius) {
							otherOre.health -= 50; // chain-damage value
							if (otherOre.health <= 0) {
								var baseValue = otherOre.getValue();
								gameState.money += baseValue;
								updateUI();
								otherOre.cluster.notifyOreDestroyed(otherOre);
								spawnMiningParticles(otherOre, 5);
							} else {
								spawnMiningParticles(otherOre, 2);
							}
						}
					}
				});
			});
			// Trigger a screen shake on explosion:
			screenShake(500, 10);
		};
	}
	self.getValue = function () {
		return self.baseValue * gameState.oreMultipliers[self.type];
	};
	return self;
});

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

/**** 
* Game Code
****/ 
function initialSpawn() {
	// Logic for initial spawning of game elements, such as clusters or ores
	// This is a placeholder function and should be filled with the appropriate logic
	console.log("Initial spawn logic executed.");
}
/**** 
* Helper Functions
****/ 
// New asset for explosive ore:
// (Existing assets …)
function randomInt(min, max) {
	return Math.floor(Math.random() * (max - min + 1)) + min;
}
// Enhanced mining particles (different color for special ores)
function spawnMiningParticles(ore, num) {
	for (var i = 0; i < num; i++) {
		var p = LK.getAsset('mining_particle', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Position the particle at ore's global position:
		if (ore.parent) {
			p.x = ore.parent.x + ore.x;
			p.y = ore.parent.y + ore.y;
		} else {
			p.x = ore.x;
			p.y = ore.y;
		}
		// Specialize color for special ores:
		if (["chronostone", "soulember", "quantumshard"].indexOf(ore.type) >= 0) {
			// If the engine supports a tint/fill property, set it here:
			p.tint = oreData[ore.type].color || 0xffffff;
		}
		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);
	}
}
// Simple color interpolation function (used in health bars)
function interpolateColor(c1, c2, f) {
	var r1 = c1 >> 16 & 0xFF,
		g1 = c1 >> 8 & 0xFF,
		b1 = c1 & 0xFF;
	var r2 = c2 >> 16 & 0xFF,
		g2 = c2 >> 8 & 0xFF,
		b2 = c2 & 0xFF;
	var r = Math.round(r1 + f * (r2 - r1));
	var g = Math.round(g1 + f * (g2 - g1));
	var b = Math.round(b1 + f * (b2 - b1));
	return r << 16 | g << 8 | b;
}
// A screen shake effect (for explosions)
function screenShake(duration, magnitude) {
	var originalX = game.x;
	var originalY = game.y;
	var shakeInterval = 50; // in milliseconds
	var elapsed = 0;
	var shake = setInterval(function () {
		elapsed += shakeInterval;
		game.x = originalX + (Math.random() - 0.5) * magnitude;
		game.y = originalY + (Math.random() - 0.5) * magnitude;
		if (elapsed >= duration) {
			clearInterval(shake);
			game.x = originalX;
			game.y = originalY;
		}
	}, shakeInterval);
}
/**** 
* Achievements (simple system)
****/ 
var achievements = [{
	id: 'first_mine',
	name: 'First Mine',
	description: 'Mine your first ore',
	achieved: false,
	condition: function condition() {
		return gameState.money > 0;
	}
}, {
	id: 'rich_miner',
	name: 'Rich Miner',
	description: 'Earn 1 Billion money',
	achieved: false,
	condition: function condition() {
		return gameState.money >= 1e9;
	}
}
// More achievements can be added here.
];
/**** 
* Ore Data
****/ 
var oreData = {
	coal: {
		baseValue: 5,
		baseHealth: 10,
		assetId: 'coal_ore'
	},
	iron: {
		baseValue: 500,
		baseHealth: 100,
		assetId: 'iron_ore'
	},
	gold: {
		baseValue: 10000,
		baseHealth: 500,
		assetId: 'gold_ore'
	},
	diamond: {
		baseValue: 25000,
		baseHealth: 1000,
		assetId: 'diamond_ore'
	},
	sapphire: {
		baseValue: 100000,
		baseHealth: 2000,
		assetId: 'sapphire_ore'
	},
	emerald: {
		baseValue: 500000,
		baseHealth: 5000,
		assetId: 'emerald_ore'
	},
	ruby: {
		baseValue: 1000000,
		baseHealth: 10000,
		assetId: 'ruby_ore'
	},
	chronostone: {
		baseValue: 2000000,
		baseHealth: 2000,
		assetId: 'chronostone_ore',
		color: 0xc997d8
	},
	soulember: {
		baseValue: 5000000,
		baseHealth: 5000,
		assetId: 'soulember_ore',
		color: 0xdef3e5
	},
	quantumshard: {
		baseValue: 10000000,
		baseHealth: 10000,
		assetId: 'quantumshard_ore',
		color: 0xa1bb12
	},
	// New explosive ore type:
	explosive: {
		baseValue: 50000,
		baseHealth: 800,
		assetId: 'explosive_ore'
	}
};
/**** 
* GAME STATE
****/ 
var gameState = {
	money: 0,
	pickaxeLevel: 1,
	pickaxeBaseMultiplier: 1,
	droneLevel: 0,
	currentTier: 1,
	oreMultipliers: {
		coal: 1,
		iron: 1,
		gold: 1,
		diamond: 1,
		sapphire: 1,
		emerald: 1,
		ruby: 1,
		chronostone: 1,
		soulember: 1,
		quantumshard: 1,
		explosive: 1
	},
	respawnTime: 3000,
	maxClustersPerType: 3,
	clusterCount: {
		coal: 0,
		iron: 0,
		gold: 0,
		diamond: 0,
		sapphire: 0,
		emerald: 0,
		ruby: 0,
		chronostone: 0,
		soulember: 0,
		quantumshard: 0,
		explosive: 0
	},
	clusterConfigLevels: [{
		min: 2,
		max: 3
	}, {
		min: 2,
		max: 4
	}, {
		min: 3,
		max: 5
	}, {
		min: 5,
		max: 10
	}],
	clusterUpgradeTier: 0,
	get clusterConfig() {
		return this.clusterConfigLevels[this.clusterUpgradeTier] || {
			min: 2,
			max: 3
		};
	},
	prestigeCount: 0,
	prestigeCurrency: 0
};
/**** 
* DRONES, CLUSTERS, UI, SAVE/LOAD, SPAWNING etc.
* (The rest of your original code – including cluster spawning, UI menus, upgrade menus, prestige logic, etc. – remains unchanged.)
* 
* Just make sure to update the following:
* 
* 1. In getDroneDPS(), include the efficiency multiplier:
*/ 
function getDroneDPS() {
	return 10 * gameState.droneLevel * (gameState.droneEfficiencyMultiplier || 1);
}
/*
* 2. Add new general upgrades for Hyper Mining Mode and Drone Efficiency.
*/ 
var generalUpgrades = [{
	id: 'faster_respawn',
	name: 'Quicker Respawn',
	cost: 8000,
	effect: 'Halves respawn time (min 500 ms)',
	purchased: false,
	action: function action() {
		gameState.respawnTime = Math.max(500, gameState.respawnTime / 2);
	}
}, {
	id: 'cluster_up',
	name: 'Cluster Growth',
	cost: 1000,
	effect: 'Increases cluster size range',
	purchased: false,
	action: function action() {
		if (gameState.clusterUpgradeTier < gameState.clusterConfigLevels.length - 1) {
			gameState.clusterUpgradeTier++;
		}
		this.cost += 2000;
	}
}, {
	id: 'pickaxe_buff',
	name: 'Pickaxe DMG +20%',
	cost: 20000,
	effect: 'Increases your total pickaxe damage by 20%',
	purchased: false,
	multi: true,
	level: 0,
	action: function action() {
		this.level++;
		gameState.pickaxeBaseMultiplier *= 1.2;
		this.cost = Math.floor(this.cost * 2);
	}
},
// New Hyper Mining Mode upgrade:
{
	id: 'hyper_mining',
	name: 'Hyper Mining Mode',
	cost: 50000,
	effect: 'Temporarily doubles pickaxe damage and halves mining cooldown for 10 seconds',
	purchased: false,
	action: function action() {
		miner.activateHyperMining();
	}
},
// New Drone Efficiency upgrade:
{
	id: 'drone_efficiency',
	name: 'Drone Efficiency',
	cost: 30000,
	effect: 'Increases Drone DPS by 20%',
	purchased: false,
	multi: true,
	level: 0,
	action: function action() {
		this.level++;
		if (!gameState.droneEfficiencyMultiplier) {
			gameState.droneEfficiencyMultiplier = 1;
		}
		gameState.droneEfficiencyMultiplier *= 1.2;
		this.cost = Math.floor(this.cost * 2);
	}
}];
// (Other upgrade arrays remain as in your original code)
/**** 
* ACHIEVEMENT CHECK (in your game update loop)
****/ 
game.update = function () {
	if (miner) {
		miner.update();
	}
	for (var i = 0; i < droneObjects.length; i++) {
		droneObjects[i].updateDrone();
	}
	if (typeof LK.time !== 'undefined' && LK.time.elapsed % 60 === 0) {
		droneDamageTick();
	}
	clusters.forEach(function (cluster) {
		cluster.oreList.forEach(function (ore) {
			if (ore.health > 0) {
				var fraction = ore.health / ore.maxHealth;
				ore.healthBar.width = 120 * fraction;
				ore.healthBar.fill = interpolateColor(0xFF0000, 0x00FF00, fraction);
				ore.alpha = fraction;
			}
		});
	});
	if (upgradeMenu.parent) {
		subUpgradeItemRefs.forEach(function (ref) {
			var upg = ref.upgrade;
			var canBuy = canPurchaseUpgrade(ref.upgList, upg);
			if (ref.textObj && ref.textObj.style) {
				ref.textObj.style.fill = canBuy ? 0xFFFFFF : 0x666666;
			}
		});
	}
	if (quantumSelectionActive) {
		quantumSelectTimer++;
		if (quantumSelectTimer > 15 * 60) {
			quantumSelectionActive = false;
			miner.quantumPathActive = false;
		}
	}
	// Check achievements:
	achievements.forEach(function (ach) {
		if (!ach.achieved && ach.condition()) {
			ach.achieved = true;
			var achText = new Text2("Achievement Unlocked: " + ach.name, {
				size: 40,
				fill: 0xFFFF00
			});
			achText.x = 2048 / 2;
			achText.y = 100;
			game.addChild(achText);
			tween(achText, {
				alpha: 0
			}, {
				duration: 2000,
				onFinish: function onFinish() {
					achText.destroy();
				}
			});
		}
	});
};
/**** 
* INITIALIZATION & START (unchanged)
****/ 
function startGame() {
	currentBackground = LK.getAsset('background', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	currentBackground.x = 2048 / 2;
	currentBackground.y = 2732 / 2;
	game.addChildAt(currentBackground, 0);
	miner = new Miner();
	miner.x = 2048 / 2;
	miner.y = 2732 / 2;
	game.addChild(miner);
	initialSpawn();
	updateUI();
}
startGame();
// quantum selection stub remains unchanged.
game.pauseForQuantumSelection = function () {
	quantumSelectionActive = true;
	quantumSelectTimer = 0;
};
function updateUI() {
	// Placeholder for UI update logic
	console.log("UI updated.");
}

===================================================================
--- original.js
+++ change.js
@@ -755,5 +755,9 @@
 // quantum selection stub remains unchanged.
 game.pauseForQuantumSelection = function () {
 	quantumSelectionActive = true;
 	quantumSelectTimer = 0;
-};
\ No newline at end of file
+};
+function updateUI() {
+	// Placeholder for UI update logic
+	console.log("UI updated.");
+}
\ No newline at end of file