===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,467 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+var storage = LK.import("@upit/storage.v1", {
+	highScore: 0
+});
+
+/**** 
+* Classes
+****/ 
+var Miner = Container.expand(function () {
+	var self = Container.call(this);
+	self.sprite = self.attachAsset('miner', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.gridX = 0;
+	self.gridY = 0;
+	self.moving = false;
+	self.moveTo = function (x, y) {
+		if (self.moving) {
+			return false;
+		}
+		var oldX = self.gridX;
+		var oldY = self.gridY;
+		self.gridX = x;
+		self.gridY = y;
+		self.moving = true;
+		tween(self, {
+			x: x * TILE_SIZE,
+			y: y * TILE_SIZE
+		}, {
+			duration: 200,
+			easing: tween.easeOut,
+			onFinish: function onFinish() {
+				self.moving = false;
+			}
+		});
+		return true;
+	};
+	return self;
+});
+var Monster = Container.expand(function (startX, startY, patrolRange) {
+	var self = Container.call(this);
+	self.sprite = self.attachAsset('monster', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.gridX = startX;
+	self.gridY = startY;
+	self.patrolRange = patrolRange || 3;
+	self.startX = startX;
+	self.moving = false;
+	self.direction = 1; // 1 right, -1 left
+	self.update = function () {
+		if (self.moving) {
+			return;
+		}
+		if (Math.abs(self.gridX - self.startX) >= self.patrolRange) {
+			self.direction *= -1;
+		}
+		var nextX = self.gridX + self.direction;
+		if (isValidMove(nextX, self.gridY)) {
+			self.moveTo(nextX, self.gridY);
+		} else {
+			self.direction *= -1;
+		}
+	};
+	self.moveTo = function (x, y) {
+		self.moving = true;
+		self.gridX = x;
+		self.gridY = y;
+		tween(self, {
+			x: x * TILE_SIZE,
+			y: y * TILE_SIZE
+		}, {
+			duration: 300,
+			easing: tween.linear,
+			onFinish: function onFinish() {
+				self.moving = false;
+			}
+		});
+	};
+	return self;
+});
+var StatusBar = Container.expand(function (type, width, height) {
+	var self = Container.call(this);
+	self.maxValue = 100;
+	self.currentValue = 100;
+	var borderAsset = type + 'Border';
+	var fillerAsset = type;
+	self.border = self.attachAsset(borderAsset, {
+		anchorX: 0,
+		anchorY: 0
+	});
+	self.filler = self.attachAsset(fillerAsset, {
+		anchorX: 0,
+		anchorY: 0,
+		x: 2,
+		y: 2
+	});
+	self.setValue = function (value) {
+		self.currentValue = Math.max(0, Math.min(self.maxValue, value));
+		var percentage = self.currentValue / self.maxValue;
+		self.filler.scale.x = percentage;
+	};
+	return self;
+});
+var Tile = Container.expand(function (type, x, y) {
+	var self = Container.call(this);
+	self.type = type;
+	self.gridX = x;
+	self.gridY = y;
+	self.revealed = false;
+	var assetId;
+	switch (type) {
+		case 'wall':
+			assetId = 'wall';
+			break;
+		case 'dirt':
+			assetId = 'dirt';
+			break;
+		case 'gemCommon':
+			assetId = 'gemCommon';
+			break;
+		case 'gemRare':
+			assetId = 'gemRare';
+			break;
+		case 'gemEpic':
+			assetId = 'gemEpic';
+			break;
+		case 'lava':
+			assetId = 'lava';
+			break;
+		default:
+			assetId = 'dirt';
+			break;
+	}
+	self.sprite = self.attachAsset(assetId, {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.reveal = function () {
+		if (self.revealed) {
+			return;
+		}
+		self.revealed = true;
+		if (self.type === 'dirt') {
+			tween(self.sprite, {
+				alpha: 0
+			}, {
+				duration: 300,
+				onFinish: function onFinish() {
+					self.sprite.visible = false;
+				}
+			});
+		}
+	};
+	return self;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
 	backgroundColor: 0x000000
-});
\ No newline at end of file
+});
+
+/**** 
+* Game Code
+****/ 
+// Constants
+var GRID_WIDTH = 15;
+var GRID_HEIGHT = 100;
+var TILE_SIZE = 50;
+var VIEWPORT_HEIGHT = 15; // Number of rows visible at once
+var OXYGEN_DECREASE_RATE = 0.1;
+var DRILL_DECREASE_AMOUNT = 5;
+var MAX_DEPTH = 95; // Maximum depth to consider for win condition
+// Game variables
+var grid = [];
+var miner;
+var score = 0;
+var depth = 0;
+var monsters = [];
+var viewportOffset = 0;
+var oxygenBar;
+var durabilityBar;
+var scoreText;
+var depthText;
+var gameActive = true;
+// Initialize game elements
+game.setBackgroundColor(0x222222);
+function initGame() {
+	// Reset game variables
+	grid = [];
+	monsters = [];
+	score = 0;
+	depth = 0;
+	viewportOffset = 0;
+	gameActive = true;
+	// Generate the grid
+	generateGrid();
+	// Create miner
+	miner = new Miner();
+	miner.x = Math.floor(GRID_WIDTH / 2) * TILE_SIZE;
+	miner.y = 0;
+	miner.gridX = Math.floor(GRID_WIDTH / 2);
+	miner.gridY = 0;
+	game.addChild(miner);
+	// Spawn monsters
+	spawnMonsters();
+	// Create UI
+	createUI();
+	// Start background music
+	LK.playMusic('bgMusic');
+}
+function createUI() {
+	// Oxygen bar
+	oxygenBar = new StatusBar('oxygen');
+	oxygenBar.x = 20;
+	oxygenBar.y = 20;
+	LK.gui.topLeft.addChild(oxygenBar);
+	// Durability bar
+	durabilityBar = new StatusBar('durability');
+	durabilityBar.x = 20;
+	durabilityBar.y = 50;
+	LK.gui.topLeft.addChild(durabilityBar);
+	// Score text
+	scoreText = new Text2("Score: 0", {
+		size: 40,
+		fill: 0xFFFFFF
+	});
+	scoreText.anchor.set(1, 0);
+	LK.gui.topRight.addChild(scoreText);
+	// Depth text
+	depthText = new Text2("Depth: 0m", {
+		size: 40,
+		fill: 0xFFFFFF
+	});
+	depthText.anchor.set(0.5, 0);
+	LK.gui.top.addChild(depthText);
+}
+function generateGrid() {
+	// Clear existing grid
+	for (var i = 0; i < grid.length; i++) {
+		for (var j = 0; j < grid[i].length; j++) {
+			if (grid[i][j] && grid[i][j].parent) {
+				grid[i][j].parent.removeChild(grid[i][j]);
+			}
+		}
+	}
+	// Generate new grid
+	for (var y = 0; y < GRID_HEIGHT; y++) {
+		grid[y] = [];
+		for (var x = 0; x < GRID_WIDTH; x++) {
+			var type = 'dirt';
+			// Edge walls
+			if (x === 0 || x === GRID_WIDTH - 1) {
+				type = 'wall';
+			}
+			// Random walls
+			else if (y > 0 && Math.random() < 0.1) {
+				type = 'wall';
+			}
+			// Gems (more valuable as you go deeper)
+			else if (Math.random() < 0.05) {
+				if (y > 60) {
+					type = 'gemEpic';
+				} else if (y > 30) {
+					type = 'gemRare';
+				} else {
+					type = 'gemCommon';
+				}
+			}
+			// Lava (more common as you go deeper)
+			else if (y > 10 && Math.random() < 0.02 + y / 1000) {
+				type = 'lava';
+			}
+			var tile = new Tile(type, x, y);
+			tile.x = x * TILE_SIZE;
+			tile.y = y * TILE_SIZE;
+			grid[y][x] = tile;
+			game.addChild(tile);
+			// Initial tiles should be visible
+			if (y < 2) {
+				tile.reveal();
+			}
+		}
+	}
+}
+function spawnMonsters() {
+	// Add monsters at various depths
+	for (var i = 0; i < 10; i++) {
+		var depth = 10 + i * 8;
+		var x = 1 + Math.floor(Math.random() * (GRID_WIDTH - 2));
+		var monster = new Monster(x, depth, 3 + Math.floor(i / 3));
+		monster.x = x * TILE_SIZE;
+		monster.y = depth * TILE_SIZE;
+		monsters.push(monster);
+		game.addChild(monster);
+	}
+}
+function updateViewport() {
+	var targetOffset = Math.max(0, miner.gridY - Math.floor(VIEWPORT_HEIGHT / 2));
+	if (targetOffset !== viewportOffset) {
+		viewportOffset = targetOffset;
+		// Adjust all elements based on new viewport
+		for (var y = 0; y < GRID_HEIGHT; y++) {
+			for (var x = 0; x < GRID_WIDTH; x++) {
+				if (grid[y] && grid[y][x]) {
+					grid[y][x].y = (y - viewportOffset) * TILE_SIZE;
+				}
+			}
+		}
+		// Adjust monsters
+		for (var i = 0; i < monsters.length; i++) {
+			monsters[i].y = (monsters[i].gridY - viewportOffset) * TILE_SIZE;
+		}
+		// Adjust miner
+		miner.y = (miner.gridY - viewportOffset) * TILE_SIZE;
+	}
+}
+function isValidMove(x, y) {
+	// Check bounds
+	if (x < 0 || x >= GRID_WIDTH || y < 0 || y >= GRID_HEIGHT) {
+		return false;
+	}
+	// Check if position is valid
+	if (!grid[y] || !grid[y][x]) {
+		return false;
+	}
+	// Can't move through walls
+	if (grid[y][x].type === 'wall') {
+		return false;
+	}
+	return true;
+}
+function handleTileInteraction(x, y) {
+	if (!grid[y] || !grid[y][x]) {
+		return;
+	}
+	var tile = grid[y][x];
+	// Reveal the tile
+	tile.reveal();
+	// Collect gems
+	if (tile.type.includes('gem')) {
+		var gemValue = 0;
+		if (tile.type === 'gemCommon') {
+			gemValue = 10;
+		} else if (tile.type === 'gemRare') {
+			gemValue = 25;
+		} else if (tile.type === 'gemEpic') {
+			gemValue = 50;
+		}
+		score += gemValue;
+		scoreText.setText("Score: " + score);
+		// Play gem collection sound
+		LK.getSound('gemCollect').play();
+		// Change tile to dirt after collection
+		tile.type = 'dirt';
+	}
+	// Check for lava
+	if (tile.type === 'lava') {
+		LK.getSound('danger').play();
+		LK.effects.flashScreen(0xFF0000, 1000);
+		endGame(false);
+	}
+	// Decrease drill durability for dirt and wall
+	if (tile.type === 'dirt' || tile.type === 'wall') {
+		durabilityBar.setValue(durabilityBar.currentValue - DRILL_DECREASE_AMOUNT);
+		LK.getSound('dig').play();
+		// Check if drill is broken
+		if (durabilityBar.currentValue <= 0) {
+			endGame(false);
+		}
+	}
+	// Update depth if this is a new deepest point
+	if (y > depth) {
+		depth = y;
+		depthText.setText("Depth: " + depth + "m");
+		// Check win condition
+		if (depth >= MAX_DEPTH) {
+			endGame(true);
+		}
+	}
+}
+function checkMonsterCollision() {
+	for (var i = 0; i < monsters.length; i++) {
+		if (monsters[i].gridX === miner.gridX && monsters[i].gridY === miner.gridY) {
+			LK.getSound('danger').play();
+			LK.effects.flashScreen(0xFF0000, 1000);
+			endGame(false);
+			break;
+		}
+	}
+}
+function endGame(win) {
+	gameActive = false;
+	// Update high score if needed
+	if (score > storage.highScore) {
+		storage.highScore = score;
+	}
+	if (win) {
+		LK.showYouWin();
+	} else {
+		LK.showGameOver();
+	}
+}
+function handleMovement(dx, dy) {
+	if (!gameActive || miner.moving) {
+		return;
+	}
+	var newX = miner.gridX + dx;
+	var newY = miner.gridY + dy;
+	if (isValidMove(newX, newY)) {
+		if (miner.moveTo(newX, newY)) {
+			handleTileInteraction(newX, newY);
+		}
+	}
+}
+game.down = function (x, y) {
+	if (!gameActive) {
+		return;
+	}
+	// Convert screen coordinates to grid coordinates
+	var gridX = Math.floor(x / TILE_SIZE);
+	var gridY = Math.floor(y / TILE_SIZE) + viewportOffset;
+	// Check if it's a valid move (only adjacent tiles)
+	var dx = gridX - miner.gridX;
+	var dy = gridY - miner.gridY;
+	// Only allow moving to adjacent tiles (manhattan distance of 1)
+	if (Math.abs(dx) + Math.abs(dy) === 1) {
+		handleMovement(dx, dy);
+	}
+};
+game.update = function () {
+	if (!gameActive) {
+		return;
+	}
+	// Update viewport position
+	updateViewport();
+	// Update oxygen level
+	oxygenBar.setValue(oxygenBar.currentValue - OXYGEN_DECREASE_RATE);
+	if (oxygenBar.currentValue <= 0) {
+		endGame(false);
+	}
+	// Update monsters
+	for (var i = 0; i < monsters.length; i++) {
+		monsters[i].update();
+	}
+	// Check for monster collisions
+	checkMonsterCollision();
+	// Reveal nearby tiles
+	for (var dy = -1; dy <= 1; dy++) {
+		for (var dx = -1; dx <= 1; dx++) {
+			var nx = miner.gridX + dx;
+			var ny = miner.gridY + dy;
+			if (nx >= 0 && nx < GRID_WIDTH && ny >= 0 && ny < GRID_HEIGHT && grid[ny] && grid[ny][nx]) {
+				grid[ny][nx].reveal();
+			}
+		}
+	}
+};
+// Initialize the game
+initGame();
\ No newline at end of file