===================================================================
--- original.js
+++ change.js
@@ -6,53 +6,100 @@
 /**** 
 * Classes
 ****/ 
 /** 
-* Drone Class – with a slight random deviation in movement.
+* Cluster spawns multiple Ore objects of a given type.
 */ 
+var Cluster = Container.expand(function (type) {
+	var self = Container.call(this);
+	self.type = type;
+	self.oreList = [];
+	// Random center
+	var centerX = 100 + Math.random() * (2048 - 200);
+	var centerY = 100 + Math.random() * (2732 - 200);
+	self.x = centerX;
+	self.y = centerY;
+	// Decide how many ore in this cluster
+	var cc = gameState.clusterConfig;
+	var count = randomInt(cc.min, cc.max);
+	// Create ore
+	for (var i = 0; i < count; i++) {
+		var ore = new Ore(type, self);
+		ore.x = (Math.random() - 0.5) * 120;
+		ore.y = (Math.random() - 0.5) * 120;
+		self.oreList.push(ore);
+		self.addChild(ore);
+	}
+	self.notifyOreDestroyed = function (ore) {
+		var idx = self.oreList.indexOf(ore);
+		if (idx >= 0) {
+			self.oreList.splice(idx, 1);
+		}
+		ore.destroy();
+		// If all gone => remove cluster
+		if (self.oreList.length === 0) {
+			if (self.parent) {
+				self.parent.removeChild(self);
+			}
+			var cidx = clusters.indexOf(self);
+			if (cidx >= 0) {
+				clusters.splice(cidx, 1);
+			}
+			gameState.clusterCount[type]--;
+			// Wait respawnTime, then spawn new cluster
+			var finalDelay = gameState.respawnTime;
+			if (type === 'coal') {
+				finalDelay *= 2; // slow for coal
+			}
+			LK.setTimeout(function () {
+				maybeSpawnCluster(type);
+			}, finalDelay);
+		}
+	};
+	return self;
+});
 var Drone = Container.expand(function () {
 	var self = Container.call(this);
+	// Drone sprite
 	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;
+	// Movement constants
+	var SPEED = 8; // Moves faster diagonally
+	var MIN_X = 50; // Left boundary
+	var MAX_X = 2000; // Right boundary (adjust for your stage width)
+	var MIN_Y = 50; // Top boundary
+	var MAX_Y = 2682; // Bottom boundary (adjust for your stage height)
+	// Initial random direction
 	self.vx = Math.random() < 0.5 ? SPEED : -SPEED;
 	self.vy = Math.random() < 0.5 ? SPEED : -SPEED;
+	// AoE stats
 	self.AOE_RANGE = 100;
-	self.droneDamage = 2;
-	self.COOLDOWN_MAX = 60;
+	self.droneDamage = 2; // Per zap
+	self.COOLDOWN_MAX = 60; // ~1 second at 60fps
 	self.cooldown = 0;
+	// Each frame, move & bounce
 	self.updateDrone = function () {
+		// Move
 		self.x += self.vx;
 		self.y += self.vy;
+		// Bounce off boundaries
 		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;
-			}
-		}
+		// AoE zap if off cooldown
 		if (self.cooldown > 0) {
 			self.cooldown--;
 		} else {
 			self.tryZap();
 		}
 	};
+	// AoE attack: damage ores within AOE_RANGE
 	self.tryZap = function () {
 		var hitSomething = false;
 		clusters.forEach(function (cluster) {
 			cluster.oreList.forEach(function (ore) {
@@ -62,10 +109,12 @@
 					var dx = self.x - oreGlobalX;
 					var dy = self.y - oreGlobalY;
 					var dist = Math.sqrt(dx * dx + dy * dy);
 					if (dist < self.AOE_RANGE) {
+						// Deal damage
 						ore.health -= self.droneDamage;
 						hitSomething = true;
+						// If killed the ore
 						if (ore.health <= 0) {
 							var baseValue = ore.getValue();
 							gameState.money += baseValue;
 							updateUI();
@@ -75,16 +124,17 @@
 					}
 				}
 			});
 		});
+		// If we zapped anything, trigger cooldown
 		if (hitSomething) {
 			self.cooldown = self.COOLDOWN_MAX;
 		}
 	};
 	return self;
 });
 /** 
-* Miner Class – now with Hyper Mining Mode.
+* Miner moves to the closest valid ore and mines it.
 */ 
 var Miner = Container.expand(function () {
 	var self = Container.call(this);
 	self.attachAsset('miner', {
@@ -94,36 +144,30 @@
 	self.speed = 5;
 	self.currentTarget = null;
 	self.miningRange = 25;
 	self.miningCooldown = 0;
-	self.miningRate = 30;
+	self.miningRate = 30; // frames per "hit"
 	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;
+	// For the Chronostone speed boost
+	self.speedBoostMultiplier = 1; // accumulative if multiple boosts occur
+	self.speedBoostTimer = 0; // frames left
+	// For the Soul Ember 500% value boost (for next 10 ores)
+	self.soulEmberStacks = 0; // how many empowered hits remain
+	// For the Quantum Shard pathing system
 	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.quantumShardValueBonus = false; // 50% bonus if path completed
 	self.findNewTarget = function () {
 		if (self.quantumPathActive && self.quantumPath.length > 0) {
+			// If quantum path is active and we have a queued path, pick the next ore
 			self.currentTarget = self.quantumPath[0];
+			// If that ore is destroyed or invalid, remove it and find again
 			if (!self.currentTarget || self.currentTarget.health <= 0) {
 				self.quantumPath.shift();
 				if (self.quantumPath.length === 0) {
+					// finished the path
 					if (self.quantumShardValueBonus) {
+						// maybe notify user or something
 						self.quantumShardValueBonus = false;
 					}
 					self.quantumPathActive = false;
 					self.currentTarget = null;
@@ -131,8 +175,9 @@
 				return;
 			}
 			return;
 		}
+		// Normal search
 		var validOre = [];
 		clusters.forEach(function (c) {
 			c.oreList.forEach(function (ore) {
 				if (ore.health > 0 && ore.tier <= gameState.currentTier) {
@@ -143,8 +188,9 @@
 		if (validOre.length === 0) {
 			self.currentTarget = null;
 			return;
 		}
+		// Sort by distance
 		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;
@@ -154,21 +200,13 @@
 			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:
+		// Decay speed boost if active
 		if (self.speedBoostTimer > 0) {
 			self.speedBoostTimer--;
 			if (self.speedBoostTimer <= 0) {
+				// reset
 				self.speedBoostMultiplier = 1;
 			}
 		}
 		self.findNewTarget();
@@ -185,8 +223,9 @@
 			} else {
 				self.mineOre(self.currentTarget);
 			}
 		} else {
+			// idle float
 			if (typeof LK.time !== 'undefined') {
 				self.y += Math.sin(LK.time.elapsed / 250) * 0.5;
 			}
 		}
@@ -195,99 +234,97 @@
 		if (self.miningCooldown > 0) {
 			self.miningCooldown--;
 			return;
 		}
+		// If quantum path is in effect, once we mine this target, remove it from path
 		if (self.quantumPathActive && self.quantumPath.length > 0 && self.quantumPath[0] === ore) {
 			self.quantumPath.shift();
 			if (self.quantumPath.length === 0) {
-				if (self.quantumShardValueBonus) {}
+				// done
+				if (self.quantumShardValueBonus) {
+					// 50% extra money for the chain.
+					// We'll just handle that by applying the multiplier below
+				}
 				self.quantumPathActive = false;
 			}
 		}
 		var damageDealt = self.miningDamage * gameState.pickaxeLevel * (gameState.pickaxeBaseMultiplier || 1);
 		ore.health -= damageDealt;
-		self.miningCooldown = self.miningRate;
+		self.miningCooldown = self.miningRate; // reset cooldown
 		if (ore.health <= 0) {
 			var baseValue = ore.getValue();
 			var finalValue = baseValue;
+			// If soul ember effect is active, 500% value
 			if (self.soulEmberStacks > 0) {
-				finalValue *= 5;
+				finalValue *= 5; // 500%
 				self.soulEmberStacks--;
 			}
+			// If quantum shard chain is active and we want a 50% bonus
 			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)
+	// Chronostone speed boost
 	self.applyChronostoneBoost = function () {
-		self.speedBoostMultiplier *= 3;
-		self.speedBoostTimer = 30 * 60;
+		self.speedBoostMultiplier *= 3; // +200% on top of current (300% total speed)
+		self.speedBoostTimer = 30 * 60; // 30 seconds at 60fps
 	};
+	// Soul Ember effect
 	self.applySoulEmberBoost = function () {
+		// Drains 10% money, then next 10 ores are 500% value
+		// only if money >= 1e6
 		if (gameState.money >= 1e6) {
 			var drain = gameState.money * 0.10;
 			gameState.money -= drain;
 			self.soulEmberStacks = 10;
 			updateUI();
-		}
+		} // else do nothing (auto-decline)
 	};
+	// Quantum Shard effect
 	self.triggerQuantumShardMode = function () {
-		self.quantumShardValueBonus = true;
+		// Pause game? We can temporarily set a global var to freeze updates except for UI.
+		// But we'll do a simpler approach: set quantumPathActive = true, then let player choose 5 ores.
+		// Darken screen, highlight ores, let user pick up to 5.
+		// We'll store them in self.quantumPath.
+		// Implementation detail: We'll just simulate.
+		self.quantumShardValueBonus = true; // 50% bonus if completed chain
 		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.
+* A single ore object (7 possible types + new prestige ores).
 */ 
 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)
+	// Determine tier based on order. We'll handle special prestige ores differently.
 	var typeList = ['coal', 'iron', 'gold', 'diamond', 'sapphire', 'emerald', 'ruby'];
 	if (typeList.indexOf(type) >= 0) {
 		self.tier = typeList.indexOf(type) + 1;
 	} else {
+		// For new special ores, we'll set tier super high so they appear only if we specifically spawn them.
 		self.tier = 999;
 	}
 	self.baseValue = oreData[type].baseValue;
 	self.maxHealth = oreData[type].baseHealth;
 	self.health = self.maxHealth;
-	// Attach sprite for the ore:
+	// Attach sprite
 	self.attachAsset(oreData[type].assetId, {
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
-	// Add a health bar:
+	// Health bar
 	self.healthBar = LK.getAsset('rectangle', {
 		width: 120,
 		height: 20,
 		fill: 0x00FF00,
@@ -296,64 +333,8 @@
 	});
 	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;
@@ -361,58 +342,90 @@
 
 /**** 
 * Initialize Game
 ****/ 
+/**** 
+* HELPER FUNCTIONS
+****/ 
+/**** 
+* The Game
+****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000000
+	backgroundColor: 0x1a1a1a
 });
 
 /**** 
 * Game Code
 ****/ 
-// Define the clusters array to store ore clusters
-var clusters = [];
-// Define the upgradeMenu object to fix the ReferenceError
-var upgradeMenu = {
-	parent: null // Placeholder for the parent property
-};
-// Define quantumSelectionActive to fix the ReferenceError
-var quantumSelectionActive = false;
-// Define the droneObjects array to store drone instances
-var droneObjects = [];
 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.");
+	var allTypes = ['coal', 'iron', 'gold', 'diamond', 'sapphire', 'emerald', 'ruby'];
+	allTypes.forEach(function (type, idx) {
+		var t = idx + 1;
+		if (t <= gameState.currentTier) {
+			for (var i = 0; i < gameState.maxClustersPerType; i++) {
+				maybeSpawnCluster(type);
+			}
+		}
+	});
+	// also attempt special ore spawns
+	maybeSpawnSpecialOres();
 }
+var droneObjects = [];
+// A function to create new drones up to gameState.droneLevel
+function updateDroneObjects() {
+	// If we want exactly gameState.droneLevel drones:
+	while (droneObjects.length < gameState.droneLevel) {
+		var d = new Drone();
+		// position them randomly
+		d.x = 200 + Math.random() * (2048 - 400);
+		d.y = 200 + Math.random() * (2732 - 400);
+		droneObjects.push(d);
+		game.addChild(d);
+	}
+}
+// We'll track two backgrounds at a time for transitions
+// Below is the updated code for your Idle Mining game with the requested Prestige system, new ore mechanics, background transitions,
+// upgraded pickaxes, a prestige shop, and a separate drone system tab in the buy menu.
+// Original assets
+// New images for upgraded pickaxes
+// Image for the Prestige Shop
+// New backgrounds for deeper layers
+// Additional new special ores
 /**** 
-* Helper Functions
+* HELPER FUNCTIONS
 ****/ 
-// New asset for explosive ore:
-// (Existing assets …)
+var droneSprites = [];
+// After each drone upgrade purchase:
+function updateDroneSprites() {
+	// If we want exactly gameState.droneLevel drones on screen:
+	while (droneSprites.length < gameState.droneLevel) {
+		var drone = LK.getAsset('drone_asset', {
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+		// Position them in a fun way. For example, stack them near top-left:
+		drone.x = 100 + droneSprites.length * 90;
+		drone.y = 200;
+		droneSprites.push(drone);
+		game.addChild(drone);
+	}
+}
 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, {
@@ -426,9 +439,8 @@
 		});
 		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;
@@ -439,49 +451,83 @@
 	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;
+function maybeSpawnCluster(type) {
+	var typeList = ['coal', 'iron', 'gold', 'diamond', 'sapphire', 'emerald', 'ruby'];
+	// If these special ores are requested, handle separately.
+	// We'll do normal cluster spawns for standard ore, with a chance to spawn special ores if conditions are met.
+	if (typeList.indexOf(type) >= 0) {
+		var tIndex = typeList.indexOf(type) + 1;
+		if (tIndex > gameState.currentTier) {
+			return;
 		}
-	}, shakeInterval);
+	}
+	if (gameState.clusterCount[type] >= gameState.maxClustersPerType) {
+		return;
+	}
+	var cluster = new Cluster(type);
+	game.addChild(cluster);
+	clusters.push(cluster);
+	gameState.clusterCount[type]++;
 }
-/**** 
-* 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;
+// Attempt to spawn special ores if prestige level is high enough
+function maybeSpawnSpecialOres() {
+	// Chronostone => Prestige >= 3 => 3-5% chance per cluster
+	// Soul Ember => Prestige >= 5 => 1.5-2.5% chance
+	// Quantum Shard => Prestige >= 8 => 0.8-1.2%
+	var spawnChances = [];
+	if (gameState.prestigeCount >= 3) {
+		spawnChances.push({
+			type: 'chronostone',
+			min: 3,
+			max: 5
+		});
 	}
-}, {
-	id: 'rich_miner',
-	name: 'Rich Miner',
-	description: 'Earn 1 Billion money',
-	achieved: false,
-	condition: function condition() {
-		return gameState.money >= 1e9;
+	if (gameState.prestigeCount >= 5) {
+		spawnChances.push({
+			type: 'soulember',
+			min: 1.5,
+			max: 2.5
+		});
 	}
+	if (gameState.prestigeCount >= 8) {
+		spawnChances.push({
+			type: 'quantumshard',
+			min: 0.8,
+			max: 1.2
+		});
+	}
+	if (spawnChances.length === 0) {
+		return;
+	}
+	// For each standard spawn, we have a chance to replace it with a special ore cluster
+	var standardTypes = ['coal', 'iron', 'gold', 'diamond', 'sapphire', 'emerald', 'ruby'];
+	standardTypes.forEach(function (type) {
+		if (gameState.clusterCount[type] < gameState.maxClustersPerType) {
+			// roll chance for each special ore type
+			for (var i = 0; i < spawnChances.length; i++) {
+				var chanceObj = spawnChances[i];
+				var chance = randomInt(chanceObj.min * 10, chanceObj.max * 10) / 10; // e.g. 3.1%
+				var roll = Math.random() * 100;
+				if (roll < chance) {
+					// spawn that special ore cluster
+					if (gameState.clusterCount[chanceObj.type] < gameState.maxClustersPerType) {
+						maybeSpawnCluster(chanceObj.type);
+					}
+				}
+			}
+		}
+	});
 }
-// More achievements can be added here.
-];
+var currentBackground = null;
+var nextBackground = null;
+// miner instance
+var miner = null;
+// Keep references to each cluster container
+var clusters = [];
 /**** 
-* Ore Data
+* ORE DATA
 ****/ 
 var oreData = {
 	coal: {
 		baseValue: 5,
@@ -520,37 +566,30 @@
 	},
 	chronostone: {
 		baseValue: 2000000,
 		baseHealth: 2000,
-		assetId: 'chronostone_ore',
-		color: 0xc997d8
+		assetId: 'chronostone_ore'
 	},
 	soulember: {
 		baseValue: 5000000,
 		baseHealth: 5000,
-		assetId: 'soulember_ore',
-		color: 0xdef3e5
+		assetId: 'soulember_ore'
 	},
 	quantumshard: {
 		baseValue: 10000000,
 		baseHealth: 10000,
-		assetId: 'quantumshard_ore',
-		color: 0xa1bb12
-	},
-	// New explosive ore type:
-	explosive: {
-		baseValue: 50000,
-		baseHealth: 800,
-		assetId: 'explosive_ore'
+		assetId: 'quantumshard_ore'
 	}
 };
 /**** 
 * GAME STATE
 ****/ 
 var gameState = {
 	money: 0,
 	pickaxeLevel: 1,
+	// A new multiplier we can boost by a percentage
 	pickaxeBaseMultiplier: 1,
+	// For drones
 	droneLevel: 0,
 	currentTier: 1,
 	oreMultipliers: {
 		coal: 1,
@@ -561,10 +600,9 @@
 		emerald: 1,
 		ruby: 1,
 		chronostone: 1,
 		soulember: 1,
-		quantumshard: 1,
-		explosive: 1
+		quantumshard: 1
 	},
 	respawnTime: 3000,
 	maxClustersPerType: 3,
 	clusterCount: {
@@ -576,10 +614,9 @@
 		emerald: 0,
 		ruby: 0,
 		chronostone: 0,
 		soulember: 0,
-		quantumshard: 0,
-		explosive: 0
+		quantumshard: 0
 	},
 	clusterConfigLevels: [{
 		min: 2,
 		max: 3
@@ -599,25 +636,368 @@
 			min: 2,
 			max: 3
 		};
 	},
+	// Prestige
 	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:
-*/ 
+* HELPER FUNCTIONS FOR PRESTIGE
+****/ 
+function getPrestigeRequirement() {
+	// Example: Next prestige requires 1e12 * (10^(2*prestigeCount)) etc.
+	// We'll just do a simpler approach for demonstration.
+	var base = 1e12; // 1 trillion
+	var multiplier = Math.pow(1000, gameState.prestigeCount); // scale by 1000 each time
+	return base * multiplier;
+}
+function canPrestige() {
+	return gameState.money >= getPrestigeRequirement();
+}
+function calculatePrestigeShards() {
+	// example: 1 shard per 10x over threshold
+	var threshold = getPrestigeRequirement();
+	if (gameState.money < threshold) {
+		return 0;
+	}
+	var ratio = gameState.money / threshold;
+	var shards = Math.floor(Math.log10(ratio) * 2); // scale
+	return Math.max(shards, 1);
+}
+function doPrestige() {
+	// Clear all clusters from screen
+	for (var i = clusters.length - 1; i >= 0; i--) {
+		var c = clusters[i];
+		c.removeChildren();
+		if (c.parent) {
+			c.parent.removeChild(c);
+		}
+		clusters.splice(i, 1);
+	}
+	// Calculate shards, increment prestige count
+	var shards = calculatePrestigeShards();
+	gameState.prestigeCurrency += shards;
+	gameState.prestigeCount++;
+	// Reset progression but keep prestige shop items (pickaxe upgrades can remain partial or we can reset them if you want)
+	gameState.money = 0;
+	gameState.currentTier = 1;
+	// reset cluster counts
+	for (var key in gameState.clusterCount) {
+		gameState.clusterCount[key] = 0;
+	}
+	// background transition
+	handleBackgroundTransition();
+	// Re-initialize spawns
+	initialSpawn();
+	updateUI();
+}
+/**** 
+* BACKGROUND TRANSITION
+****/ 
+function handleBackgroundTransition() {
+	// If we have a next background that was in transition, remove it.
+	if (nextBackground && nextBackground.parent) {
+		nextBackground.parent.removeChild(nextBackground);
+	}
+	// We'll pick a background based on prestige tiers: 3,5,8
+	var newBg = null;
+	if (gameState.prestigeCount >= 8) {
+		newBg = LK.getAsset('background_tier8', {
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+	} else if (gameState.prestigeCount >= 5) {
+		newBg = LK.getAsset('background_tier5', {
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+	} else if (gameState.prestigeCount >= 3) {
+		newBg = LK.getAsset('background_tier3', {
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+	} else {
+		newBg = LK.getAsset('background', {
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+	}
+	newBg.x = 2048 / 2;
+	newBg.y = 2732 + 2732 / 2; // start off-screen bottom
+	game.addChild(newBg);
+	nextBackground = newBg;
+	var oldBg = currentBackground;
+	if (!oldBg) {
+		// If none, the old background is just the normal background.
+		oldBg = LK.getAsset('background', {
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+		oldBg.x = 2048 / 2;
+		oldBg.y = 2732 / 2;
+		game.addChildAt(oldBg, 0);
+	}
+	// If oldBg is the same as newBg, skip.
+	if (oldBg === newBg) {
+		currentBackground = newBg;
+		return;
+	}
+	// Move them upwards for 3 seconds to simulate descending
+	var dur = 3000;
+	tween(oldBg, {
+		y: oldBg.y - 2732
+	}, {
+		duration: dur,
+		onFinish: function onFinish() {
+			if (oldBg && oldBg.parent) {
+				oldBg.parent.removeChild(oldBg);
+			}
+		}
+	});
+	tween(newBg, {
+		y: 2732 / 2
+	}, {
+		duration: dur,
+		onFinish: function onFinish() {
+			currentBackground = newBg;
+		}
+	});
+}
+/**** 
+* DRONES
+****/ 
+// We'll add a new tab in the main buy menu for drones.
+// For simplicity, let's store a droneLevel in gameState and each level adds some base DPS.
+var droneDPS = 0; // We'll accumulate from drone upgrades.
 function getDroneDPS() {
-	return 10 * gameState.droneLevel * (gameState.droneEfficiencyMultiplier || 1);
+	// formula: each level adds some base DPS.
+	// e.g. 10 * droneLevel.
+	return 10 * gameState.droneLevel;
 }
-/*
-* 2. Add new general upgrades for Hyper Mining Mode and Drone Efficiency.
-*/ 
+function droneDamageTick() {
+	// Let the drones deal damage over time.
+	// We'll do a simplified approach: find random valid ores and deal damage.
+	var dps = getDroneDPS();
+	if (dps <= 0) {
+		return;
+	}
+	// pick random ore or distribute among them.
+	var totalOreCount = 0;
+	var allValidOres = [];
+	clusters.forEach(function (c) {
+		c.oreList.forEach(function (ore) {
+			if (ore.health > 0 && ore.tier <= gameState.currentTier) {
+				allValidOres.push(ore);
+			}
+		});
+	});
+	if (allValidOres.length === 0) {
+		return;
+	}
+	// We'll just do total dps as damage distributed among some random ore.
+	var damageRemaining = dps;
+	while (damageRemaining > 0 && allValidOres.length > 0) {
+		var randomIndex = Math.floor(Math.random() * allValidOres.length);
+		var ore = allValidOres[randomIndex];
+		var chunk = Math.min(damageRemaining, 10); // deal in chunks
+		ore.health -= chunk;
+		damageRemaining -= chunk;
+		if (ore.health <= 0) {
+			// kill ore
+			var baseValue = ore.getValue();
+			gameState.money += baseValue;
+			updateUI();
+			ore.cluster.notifyOreDestroyed(ore);
+			spawnMiningParticles(ore, 5);
+			allValidOres.splice(randomIndex, 1);
+		}
+	}
+}
+/**** 
+* UPGRADE DATA
+****/ 
+// We'll add a tab for drones in main menu, with upgrades.
+// We'll also add a new prestige shop with artifacts.
+var oreUpgrades = {
+	coal: [{
+		id: 'double_coal',
+		name: 'Double Coal Value',
+		cost: 100,
+		multi: true,
+		level: 0,
+		effect: 'Doubles Coal Value each purchase',
+		action: function action() {
+			this.level++;
+			gameState.oreMultipliers.coal *= 2;
+			this.cost *= 2;
+		}
+	}],
+	iron: [{
+		id: 'unlock_iron',
+		name: 'Unlock Iron Mining',
+		cost: 500,
+		effect: 'Allows iron ore clusters to spawn',
+		purchased: false,
+		action: function action() {
+			// Increase currentTier if needed
+			if (gameState.currentTier < 2) {
+				gameState.currentTier = 2;
+			}
+			// Immediately spawn some iron
+			for (var i = 0; i < gameState.maxClustersPerType; i++) {
+				maybeSpawnCluster('iron');
+			}
+		}
+	}, {
+		id: 'double_iron',
+		name: 'Double Iron Value',
+		cost: 1000,
+		multi: true,
+		level: 0,
+		effect: 'Doubles Iron Value each purchase',
+		action: function action() {
+			this.level++;
+			gameState.oreMultipliers.iron *= 2;
+			this.cost *= 2;
+		}
+	}],
+	gold: [{
+		id: 'unlock_gold',
+		name: 'Unlock Gold Mining',
+		cost: 5000,
+		effect: 'Allows gold ore clusters to spawn',
+		purchased: false,
+		action: function action() {
+			if (gameState.currentTier < 3) {
+				gameState.currentTier = 3;
+			}
+			for (var i = 0; i < gameState.maxClustersPerType; i++) {
+				maybeSpawnCluster('gold');
+			}
+		}
+	}, {
+		id: 'double_gold',
+		name: 'Double Gold Value',
+		cost: 20000,
+		multi: true,
+		level: 0,
+		effect: 'Doubles Gold Value each purchase',
+		action: function action() {
+			this.level++;
+			gameState.oreMultipliers.gold *= 2;
+			this.cost *= 2;
+		}
+	}],
+	diamond: [{
+		id: 'unlock_diamond',
+		name: 'Unlock Diamond Mining',
+		cost: 20000,
+		effect: 'Allows diamond ore clusters to spawn',
+		purchased: false,
+		action: function action() {
+			if (gameState.currentTier < 4) {
+				gameState.currentTier = 4;
+			}
+			for (var i = 0; i < gameState.maxClustersPerType; i++) {
+				maybeSpawnCluster('diamond');
+			}
+		}
+	}, {
+		id: 'double_diamond',
+		name: 'Double Diamond Value',
+		cost: 50000,
+		multi: true,
+		level: 0,
+		effect: 'Doubles Diamond Value each purchase',
+		action: function action() {
+			this.level++;
+			gameState.oreMultipliers.diamond *= 2;
+			this.cost *= 2;
+		}
+	}],
+	sapphire: [{
+		id: 'unlock_sapphire',
+		name: 'Unlock Sapphire Mining',
+		cost: 100000,
+		effect: 'Allows sapphire ore clusters to spawn',
+		purchased: false,
+		action: function action() {
+			if (gameState.currentTier < 5) {
+				gameState.currentTier = 5;
+			}
+			for (var i = 0; i < gameState.maxClustersPerType; i++) {
+				maybeSpawnCluster('sapphire');
+			}
+		}
+	}, {
+		id: 'double_sapphire',
+		name: 'Double Sapphire Value',
+		cost: 200000,
+		multi: true,
+		level: 0,
+		effect: 'Doubles Sapphire Value each purchase',
+		action: function action() {
+			this.level++;
+			gameState.oreMultipliers.sapphire *= 2;
+			this.cost *= 2;
+		}
+	}],
+	emerald: [{
+		id: 'unlock_emerald',
+		name: 'Unlock Emerald Mining',
+		cost: 500000,
+		effect: 'Allows emerald ore clusters to spawn',
+		purchased: false,
+		action: function action() {
+			if (gameState.currentTier < 6) {
+				gameState.currentTier = 6;
+			}
+			for (var i = 0; i < gameState.maxClustersPerType; i++) {
+				maybeSpawnCluster('emerald');
+			}
+		}
+	}, {
+		id: 'double_emerald',
+		name: 'Double Emerald Value',
+		cost: 1000000,
+		multi: true,
+		level: 0,
+		effect: 'Doubles Emerald Value each purchase',
+		action: function action() {
+			this.level++;
+			gameState.oreMultipliers.emerald *= 2;
+			this.cost *= 2;
+		}
+	}],
+	ruby: [{
+		id: 'unlock_ruby',
+		name: 'Unlock Ruby Mining',
+		cost: 1000000,
+		effect: 'Allows ruby ore clusters to spawn',
+		purchased: false,
+		action: function action() {
+			if (gameState.currentTier < 7) {
+				gameState.currentTier = 7;
+			}
+			for (var i = 0; i < gameState.maxClustersPerType; i++) {
+				maybeSpawnCluster('ruby');
+			}
+		}
+	}, {
+		id: 'double_ruby',
+		name: 'Double Ruby Value',
+		cost: 2000000,
+		multi: true,
+		level: 0,
+		effect: 'Doubles Ruby Value each purchase',
+		action: function action() {
+			this.level++;
+			gameState.oreMultipliers.ruby *= 2;
+			this.cost *= 2;
+		}
+	}]
+};
 var generalUpgrades = [{
 	id: 'faster_respawn',
 	name: 'Quicker Respawn',
 	cost: 8000,
@@ -647,55 +1027,427 @@
 	multi: true,
 	level: 0,
 	action: function action() {
 		this.level++;
+		// Multiply base damage by 1.2 each time
 		gameState.pickaxeBaseMultiplier *= 1.2;
+		// Increase cost for next purchase
 		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',
+}];
+// new pickaxe upgrades (artifact axes) in the Prestige shop
+var prestigeUpgrades = [{
+	id: 'pickaxe_plus_1',
+	name: 'Pickaxe Level +1',
+	cost: 5,
+	effect: 'Increases pickaxe damage by 1',
 	purchased: false,
 	action: function action() {
-		miner.activateHyperMining();
+		gameState.pickaxeLevel++;
 	}
-},
-// New Drone Efficiency upgrade:
-{
-	id: 'drone_efficiency',
-	name: 'Drone Efficiency',
-	cost: 30000,
-	effect: 'Increases Drone DPS by 20%',
+}, {
+	id: 'pickaxe_plus_2',
+	name: 'Pickaxe Speed +10%',
+	cost: 8,
+	effect: 'Reduces mining cooldown by 10%',
 	purchased: false,
+	action: function action() {
+		miner.miningRate = Math.floor(miner.miningRate * 0.90);
+		if (miner.miningRate < 1) {
+			miner.miningRate = 1;
+		}
+	}
+}, {
+	id: 'pickaxe_plus_3',
+	name: 'Pickaxe Bonus DMG +2',
+	cost: 10,
+	effect: 'Increases pickaxe damage by an additional 2',
+	purchased: false,
+	action: function action() {
+		gameState.pickaxeLevel += 2;
+	}
+}
+// you can add more
+];
+// a separate list for artifact drones in prestige shop
+var prestigeDrones = [{
+	id: 'drone_speedup',
+	name: 'Drone Technology +1',
+	cost: 10,
+	effect: 'Increases Drone DPS by 50',
+	purchased: false,
+	action: function action() {
+		if (!gameState.droneLevel) {
+			gameState.droneLevel = 0;
+		}
+		// each purchase +5 levels?
+		gameState.droneLevel += 5;
+	}
+}];
+// standard drone upgrades in the normal buy menu
+var droneUpgrades = [{
+	id: 'drone_level_1',
+	name: 'Buy Drones (Lv +1)',
+	cost: 5000,
+	effect: 'Each level adds +10 DPS',
+	purchased: false,
 	multi: true,
 	level: 0,
 	action: function action() {
-		this.level++;
-		if (!gameState.droneEfficiencyMultiplier) {
-			gameState.droneEfficiencyMultiplier = 1;
+		if (!gameState.droneLevel) {
+			gameState.droneLevel = 0;
 		}
-		gameState.droneEfficiencyMultiplier *= 1.2;
-		this.cost = Math.floor(this.cost * 2);
+		gameState.droneLevel++;
+		this.level++;
+		this.cost = Math.floor(this.cost * 1.5);
+		updateDroneObjects();
 	}
 }];
-// (Other upgrade arrays remain as in your original code)
 /**** 
-* ACHIEVEMENT CHECK (in your game update loop)
+* UI
 ****/ 
+var upgradeMenu = new Container();
+var tooltip = new Text2('', {
+	size: 40,
+	fill: 0xFFFFFF
+});
+game.addChild(tooltip);
+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;
+game.addChild(moneyDisplay);
+// Add a text display for Prestige info
+var prestigeDisplay = new Text2('Prestige: 0', {
+	size: 50,
+	fill: 0xFFFFFF,
+	fontWeight: 'bold',
+	stroke: 0x000000,
+	strokeThickness: 4
+});
+prestigeDisplay.x = 50;
+prestigeDisplay.y = 50;
+game.addChild(prestigeDisplay);
+// Shop icon
+var shopOpenButton = LK.getAsset('shop_icon', {
+	anchorX: 0.5,
+	anchorY: 0.5
+});
+shopOpenButton.x = 2048 - 150;
+shopOpenButton.y = 2732 - 150;
+shopOpenButton.down = function () {
+	createMainUpgradeMenu();
+	game.addChild(upgradeMenu);
+};
+game.addChild(shopOpenButton);
+// Prestige shop icon
+var prestigeShopButton = LK.getAsset('prestige_shop_icon', {
+	anchorX: 0.5,
+	anchorY: 0.5
+});
+prestigeShopButton.x = 150;
+prestigeShopButton.y = 2732 - 150;
+prestigeShopButton.down = function () {
+	if (canPrestige()) {
+		doPrestige();
+	} else {
+		createPrestigeShopMenu();
+		game.addChild(upgradeMenu);
+	}
+};
+game.addChild(prestigeShopButton);
+// Debug: Add money button
+var addMoneyButton = LK.getAsset('buy_button', {
+	anchorX: 0.5,
+	anchorY: 0.5
+});
+addMoneyButton.x = 200;
+addMoneyButton.y = 2732 - 300;
+addMoneyButton.down = function () {
+	gameState.money += 5000000000; // 5B
+	updateUI();
+};
+game.addChild(addMoneyButton);
+// create main upgrade menu with an additional tab for drones
+function createMainUpgradeMenu() {
+	upgradeMenu.removeChildren();
+	subUpgradeItemRefs = [];
+	var menuBg = LK.getAsset('rectangle', {
+		width: 1800,
+		height: 2200,
+		color: 0x2a2a2a,
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	menuBg.x = 2048 / 2;
+	menuBg.y = 2732 / 2 + 50;
+	upgradeMenu.addChild(menuBg);
+	// 8 categories + 1 drones
+	var categories = [{
+		name: 'Coal Upgrades',
+		yOff: -800,
+		type: 'coal'
+	}, {
+		name: 'Iron Upgrades',
+		yOff: -600,
+		type: 'iron'
+	}, {
+		name: 'Gold Upgrades',
+		yOff: -400,
+		type: 'gold'
+	}, {
+		name: 'Diamond Upgrades',
+		yOff: -200,
+		type: 'diamond'
+	}, {
+		name: 'Sapphire Upgrades',
+		yOff: 0,
+		type: 'sapphire'
+	}, {
+		name: 'Emerald Upgrades',
+		yOff: 200,
+		type: 'emerald'
+	}, {
+		name: 'Ruby Upgrades',
+		yOff: 400,
+		type: 'ruby'
+	}, {
+		name: 'General Upgrades',
+		yOff: 600,
+		type: 'general'
+	}, {
+		name: 'Drones',
+		yOff: 800,
+		type: 'drones'
+	}];
+	categories.forEach(function (cat) {
+		var btn = LK.getAsset('buy_button', {
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+		btn.x = menuBg.x;
+		btn.y = menuBg.y + cat.yOff;
+		upgradeMenu.addChild(btn);
+		var txt = new Text2(cat.name, {
+			size: 50,
+			fill: 0x000000,
+			align: 'center'
+		});
+		txt.anchor.set(0.5);
+		txt.x = btn.x;
+		txt.y = btn.y;
+		upgradeMenu.addChild(txt);
+		btn.down = function () {
+			if (cat.type === 'general') {
+				createSubUpgradeMenu('General Upgrades', generalUpgrades);
+			} else if (cat.type === 'drones') {
+				createSubUpgradeMenu('Drone Upgrades', droneUpgrades);
+			} else {
+				createSubUpgradeMenu(cat.name, oreUpgrades[cat.type]);
+			}
+		};
+	});
+	// Close button
+	var closeBtn = LK.getAsset('cancelButton', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	closeBtn.x = menuBg.x + 700;
+	closeBtn.y = menuBg.y - 900;
+	closeBtn.down = function () {
+		game.removeChild(upgradeMenu);
+	};
+	upgradeMenu.addChild(closeBtn);
+}
+var subUpgradeItemRefs = [];
+function createSubUpgradeMenu(title, upgList) {
+	upgradeMenu.removeChildren();
+	subUpgradeItemRefs = [];
+	var menuBg = LK.getAsset('rectangle', {
+		width: 1800,
+		height: 2200,
+		color: 0x2a2a2a,
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	menuBg.x = 2048 / 2;
+	menuBg.y = 2732 / 2 + 50;
+	upgradeMenu.addChild(menuBg);
+	var titleText = new Text2(title, {
+		size: 60,
+		fill: 0xFFFFFF,
+		align: 'center'
+	});
+	titleText.anchor.set(0.5);
+	titleText.x = menuBg.x;
+	titleText.y = menuBg.y - 1000;
+	upgradeMenu.addChild(titleText);
+	var startY = menuBg.y - 800;
+	upgList.forEach(function (upg, i) {
+		var itemContainer = new Container();
+		upgradeMenu.addChild(itemContainer);
+		var btn = LK.getAsset('buy_button', {
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+		btn.x = menuBg.x;
+		btn.y = startY + i * 250;
+		itemContainer.addChild(btn);
+		var displayName = upg.name;
+		if (typeof upg.level === 'number' && upg.level > 0) {
+			displayName += " (Lv " + upg.level + ")";
+		}
+		var costStr = upg.multi ? "$" + upg.cost : "$" + upg.cost;
+		var txtStr = displayName + "\n" + upg.effect + "\n" + costStr;
+		var txt = new Text2(txtStr, {
+			size: 40,
+			fill: 0x666666,
+			align: 'center'
+		});
+		txt.anchor.set(0.5);
+		txt.x = btn.x;
+		txt.y = btn.y;
+		itemContainer.addChild(txt);
+		btn.down = function () {
+			if (canPurchaseUpgrade(upgList, upg)) {
+				gameState.money -= upg.cost;
+				upg.purchased = true;
+				upg.action();
+				updateUI();
+				createSubUpgradeMenu(title, upgList);
+			}
+		};
+		subUpgradeItemRefs.push({
+			upgList: upgList,
+			upgrade: upg,
+			textObj: txt
+		});
+	});
+	var backBtn = LK.getAsset('cancelButton', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	backBtn.x = menuBg.x + 700;
+	backBtn.y = menuBg.y - 1000;
+	backBtn.down = function () {
+		createMainUpgradeMenu();
+	};
+	upgradeMenu.addChild(backBtn);
+}
+function canPurchaseUpgrade(upgList, upg) {
+	if (upg.requires) {
+		var needed = upgList.find(function (u) {
+			return u.id === upg.requires;
+		});
+		if (!needed || !needed.purchased) {
+			return false;
+		}
+	}
+	if (!upg.multi && upg.purchased) {
+		return false;
+	}
+	if (gameState.money < upg.cost) {
+		return false;
+	}
+	return true;
+}
+// Prestige Shop Menu
+function createPrestigeShopMenu() {
+	upgradeMenu.removeChildren();
+	var menuBg = LK.getAsset('rectangle', {
+		width: 1800,
+		height: 2200,
+		color: 0x2a2a2a,
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	menuBg.x = 2048 / 2;
+	menuBg.y = 2732 / 2 + 50;
+	upgradeMenu.addChild(menuBg);
+	var titleText = new Text2('Prestige Shop', {
+		size: 60,
+		fill: 0xFFFFFF,
+		align: 'center'
+	});
+	titleText.anchor.set(0.5);
+	titleText.x = menuBg.x;
+	titleText.y = menuBg.y - 1000;
+	upgradeMenu.addChild(titleText);
+	var shardText = new Text2('Prestige Shards: ' + gameState.prestigeCurrency, {
+		size: 50,
+		fill: 0xFFFF00,
+		align: 'center'
+	});
+	shardText.anchor.set(0.5);
+	shardText.x = menuBg.x;
+	shardText.y = menuBg.y - 900;
+	upgradeMenu.addChild(shardText);
+	// We'll list pickaxe artifact upgrades and drone artifact upgrades
+	var combinedUpgrades = prestigeUpgrades.concat(prestigeDrones);
+	var startY = menuBg.y - 700;
+	combinedUpgrades.forEach(function (upg, i) {
+		var itemContainer = new Container();
+		upgradeMenu.addChild(itemContainer);
+		var btn = LK.getAsset('buy_button', {
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+		btn.x = menuBg.x;
+		btn.y = startY + i * 250;
+		itemContainer.addChild(btn);
+		var txtStr = upg.name + "\n" + upg.effect + "\nCost: " + upg.cost + " Shards";
+		var txt = new Text2(txtStr, {
+			size: 40,
+			fill: 0x666666,
+			align: 'center'
+		});
+		txt.anchor.set(0.5);
+		txt.x = btn.x;
+		txt.y = btn.y;
+		itemContainer.addChild(txt);
+		btn.down = function () {
+			if (gameState.prestigeCurrency >= upg.cost) {
+				gameState.prestigeCurrency -= upg.cost;
+				upg.action();
+				updateUI();
+				createPrestigeShopMenu();
+			}
+		};
+	});
+	var backBtn = LK.getAsset('cancelButton', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	backBtn.x = menuBg.x + 700;
+	backBtn.y = menuBg.y - 1000;
+	backBtn.down = function () {
+		game.removeChild(upgradeMenu);
+	};
+	upgradeMenu.addChild(backBtn);
+}
+/**** 
+* GAME LOOP
+****/ 
+var quantumSelectTimer = 0;
+var quantumSelectionActive = false;
 game.update = function () {
 	if (miner) {
 		miner.update();
 	}
+	// update each drone
 	for (var i = 0; i < droneObjects.length; i++) {
 		droneObjects[i].updateDrone();
 	}
+	// Drone DPS tick (maybe once per second)
 	if (typeof LK.time !== 'undefined' && LK.time.elapsed % 60 === 0) {
 		droneDamageTick();
 	}
+	// Update ore visuals
 	clusters.forEach(function (cluster) {
 		cluster.oreList.forEach(function (ore) {
 			if (ore.health > 0) {
 				var fraction = ore.health / ore.maxHealth;
@@ -704,8 +1456,9 @@
 				ore.alpha = fraction;
 			}
 		});
 	});
+	// Update sub-menu color if open
 	if (upgradeMenu.parent) {
 		subUpgradeItemRefs.forEach(function (ref) {
 			var upg = ref.upgrade;
 			var canBuy = canPurchaseUpgrade(ref.upgList, upg);
@@ -713,61 +1466,63 @@
 				ref.textObj.style.fill = canBuy ? 0xFFFFFF : 0x666666;
 			}
 		});
 	}
+	// If quantum selection is active, track timer
 	if (quantumSelectionActive) {
 		quantumSelectTimer++;
 		if (quantumSelectTimer > 15 * 60) {
+			// 15s passed, unpause
 			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)
+* UI REFRESH
 ****/ 
+function updateUI() {
+	moneyDisplay.setText("$" + Math.floor(gameState.money).toLocaleString());
+	moneyDisplay.x = 2048 / 2 - moneyDisplay.width / 2;
+	prestigeDisplay.setText("Prestige: " + gameState.prestigeCount);
+}
+/**** 
+* SAVE & LOAD
+****/ 
+LK.saveGame = function () {
+	return gameState;
+};
+LK.loadGame = function (data) {
+	gameState = data;
+	updateUI();
+};
+/**** 
+* INITIAL SPAWN
+****/ 
+/**** 
+* START
+****/ 
 function startGame() {
+	// spawn backgrounds
 	currentBackground = LK.getAsset('background', {
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
 	currentBackground.x = 2048 / 2;
 	currentBackground.y = 2732 / 2;
 	game.addChildAt(currentBackground, 0);
+	// create miner
 	miner = new Miner();
 	miner.x = 2048 / 2;
 	miner.y = 2732 / 2;
 	game.addChild(miner);
 	initialSpawn();
 	updateUI();
 }
 startGame();
-// quantum selection stub remains unchanged.
+// quantum selection function
+// This is a stub for the advanced effect. We won't fully implement the UI.
 game.pauseForQuantumSelection = function () {
 	quantumSelectionActive = true;
 	quantumSelectTimer = 0;
-};
-function updateUI() {
-	// Placeholder for UI update logic
-	console.log("UI updated.");
-}
\ No newline at end of file
+	// darken screen, highlight ores, etc.
+};
\ No newline at end of file