===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,384 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+
+/**** 
+* Classes
+****/ 
+var Tile = Container.expand(function (value, gridX, gridY) {
+	var self = Container.call(this);
+	self.value = value;
+	self.gridX = gridX;
+	self.gridY = gridY;
+	self.hasMerged = false;
+	// Get the appropriate asset based on value
+	var assetName = 'tile' + value;
+	var tileGraphics = self.attachAsset(assetName, {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	// Add text for the number
+	self.numberText = new Text2(value.toString(), {
+		size: value >= 1000 ? 36 : value >= 100 ? 42 : 48,
+		fill: value <= 4 ? "#776e65" : "#f9f6f2"
+	});
+	self.numberText.anchor.set(0.5, 0.5);
+	self.addChild(self.numberText);
+	self.updatePosition = function () {
+		var targetX = gridStartX + self.gridX * (tileSize + tileGap);
+		var targetY = gridStartY + self.gridY * (tileSize + tileGap);
+		tween(self, {
+			x: targetX,
+			y: targetY
+		}, {
+			duration: 150,
+			easing: tween.easeOut
+		});
+	};
+	self.setValue = function (newValue) {
+		self.value = newValue;
+		self.numberText.setText(newValue.toString());
+		self.numberText.style.size = newValue >= 1000 ? 36 : newValue >= 100 ? 42 : 48;
+		// Update graphics
+		self.removeChild(tileGraphics);
+		assetName = 'tile' + newValue;
+		tileGraphics = self.attachAsset(assetName, {
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+		self.addChildAt(tileGraphics, 0);
+	};
+	return self;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000000
-});
\ No newline at end of file
+	backgroundColor: 0xfaf8ef
+});
+
+/**** 
+* Game Code
+****/ 
+// Game constants
+var gridSize = 4;
+var tileSize = 120;
+var tileGap = 10;
+var gridStartX = (2048 - (gridSize * tileSize + (gridSize - 1) * tileGap)) / 2;
+var gridStartY = (2732 - (gridSize * tileSize + (gridSize - 1) * tileGap)) / 2;
+// Game state
+var grid = [];
+var tiles = [];
+var isMoving = false;
+var gameWon = false;
+var gameOver = false;
+// Initialize grid
+for (var i = 0; i < gridSize; i++) {
+	grid[i] = [];
+	for (var j = 0; j < gridSize; j++) {
+		grid[i][j] = null;
+	}
+}
+// Create grid background
+var gridContainer = game.addChild(new Container());
+for (var i = 0; i < gridSize; i++) {
+	for (var j = 0; j < gridSize; j++) {
+		var cell = gridContainer.attachAsset('gridCell', {
+			anchorX: 0.5,
+			anchorY: 0.5,
+			x: gridStartX + j * (tileSize + tileGap),
+			y: gridStartY + i * (tileSize + tileGap)
+		});
+	}
+}
+// Score display
+var scoreTxt = new Text2('0', {
+	size: 80,
+	fill: 0x776E65
+});
+scoreTxt.anchor.set(0.5, 0);
+LK.gui.top.addChild(scoreTxt);
+scoreTxt.y = 100;
+// Add initial tiles
+function addRandomTile() {
+	var emptyCells = [];
+	for (var i = 0; i < gridSize; i++) {
+		for (var j = 0; j < gridSize; j++) {
+			if (grid[i][j] === null) {
+				emptyCells.push({
+					x: j,
+					y: i
+				});
+			}
+		}
+	}
+	if (emptyCells.length > 0) {
+		var randomCell = emptyCells[Math.floor(Math.random() * emptyCells.length)];
+		var value = Math.random() < 0.9 ? 2 : 4;
+		var tile = new Tile(value, randomCell.x, randomCell.y);
+		tile.x = gridStartX + randomCell.x * (tileSize + tileGap);
+		tile.y = gridStartY + randomCell.y * (tileSize + tileGap);
+		grid[randomCell.y][randomCell.x] = tile;
+		tiles.push(tile);
+		game.addChild(tile);
+		// Scale animation for new tile
+		tile.scaleX = 0.1;
+		tile.scaleY = 0.1;
+		tween(tile, {
+			scaleX: 1,
+			scaleY: 1
+		}, {
+			duration: 200,
+			easing: tween.bounceOut
+		});
+	}
+}
+function checkGameWon() {
+	for (var i = 0; i < tiles.length; i++) {
+		if (tiles[i].value >= 2048 && !gameWon) {
+			gameWon = true;
+			LK.showYouWin();
+			return true;
+		}
+	}
+	return false;
+}
+function checkGameOver() {
+	// Check if grid is full
+	var fullGrid = true;
+	for (var i = 0; i < gridSize; i++) {
+		for (var j = 0; j < gridSize; j++) {
+			if (grid[i][j] === null) {
+				fullGrid = false;
+				break;
+			}
+		}
+		if (!fullGrid) break;
+	}
+	if (!fullGrid) return false;
+	// Check for possible moves
+	for (var i = 0; i < gridSize; i++) {
+		for (var j = 0; j < gridSize; j++) {
+			var currentValue = grid[i][j].value;
+			// Check right
+			if (j < gridSize - 1 && grid[i][j + 1].value === currentValue) {
+				return false;
+			}
+			// Check down
+			if (i < gridSize - 1 && grid[i + 1][j].value === currentValue) {
+				return false;
+			}
+		}
+	}
+	gameOver = true;
+	LK.showGameOver();
+	return true;
+}
+function moveTiles(direction) {
+	if (isMoving || gameOver || gameWon) return false;
+	var moved = false;
+	var score = 0;
+	// Reset merge flags
+	for (var i = 0; i < tiles.length; i++) {
+		tiles[i].hasMerged = false;
+	}
+	// Create new grid state
+	var newGrid = [];
+	for (var i = 0; i < gridSize; i++) {
+		newGrid[i] = [];
+		for (var j = 0; j < gridSize; j++) {
+			newGrid[i][j] = null;
+		}
+	}
+	if (direction === 'left') {
+		for (var i = 0; i < gridSize; i++) {
+			var row = [];
+			// Collect non-null tiles
+			for (var j = 0; j < gridSize; j++) {
+				if (grid[i][j] !== null) {
+					row.push(grid[i][j]);
+				}
+			}
+			// Merge tiles
+			for (var k = 0; k < row.length - 1; k++) {
+				if (row[k].value === row[k + 1].value && !row[k].hasMerged && !row[k + 1].hasMerged) {
+					row[k].setValue(row[k].value * 2);
+					row[k].hasMerged = true;
+					score += row[k].value;
+					// Remove merged tile
+					game.removeChild(row[k + 1]);
+					tiles.splice(tiles.indexOf(row[k + 1]), 1);
+					row.splice(k + 1, 1);
+					LK.getSound('merge').play();
+				}
+			}
+			// Place tiles in new positions
+			for (var k = 0; k < row.length; k++) {
+				if (row[k].gridX !== k || row[k].gridY !== i) {
+					moved = true;
+				}
+				row[k].gridX = k;
+				row[k].gridY = i;
+				newGrid[i][k] = row[k];
+				row[k].updatePosition();
+			}
+		}
+	} else if (direction === 'right') {
+		for (var i = 0; i < gridSize; i++) {
+			var row = [];
+			// Collect non-null tiles
+			for (var j = gridSize - 1; j >= 0; j--) {
+				if (grid[i][j] !== null) {
+					row.push(grid[i][j]);
+				}
+			}
+			// Merge tiles
+			for (var k = 0; k < row.length - 1; k++) {
+				if (row[k].value === row[k + 1].value && !row[k].hasMerged && !row[k + 1].hasMerged) {
+					row[k].setValue(row[k].value * 2);
+					row[k].hasMerged = true;
+					score += row[k].value;
+					// Remove merged tile
+					game.removeChild(row[k + 1]);
+					tiles.splice(tiles.indexOf(row[k + 1]), 1);
+					row.splice(k + 1, 1);
+					LK.getSound('merge').play();
+				}
+			}
+			// Place tiles in new positions
+			for (var k = 0; k < row.length; k++) {
+				var newX = gridSize - 1 - k;
+				if (row[k].gridX !== newX || row[k].gridY !== i) {
+					moved = true;
+				}
+				row[k].gridX = newX;
+				row[k].gridY = i;
+				newGrid[i][newX] = row[k];
+				row[k].updatePosition();
+			}
+		}
+	} else if (direction === 'up') {
+		for (var j = 0; j < gridSize; j++) {
+			var column = [];
+			// Collect non-null tiles
+			for (var i = 0; i < gridSize; i++) {
+				if (grid[i][j] !== null) {
+					column.push(grid[i][j]);
+				}
+			}
+			// Merge tiles
+			for (var k = 0; k < column.length - 1; k++) {
+				if (column[k].value === column[k + 1].value && !column[k].hasMerged && !column[k + 1].hasMerged) {
+					column[k].setValue(column[k].value * 2);
+					column[k].hasMerged = true;
+					score += column[k].value;
+					// Remove merged tile
+					game.removeChild(column[k + 1]);
+					tiles.splice(tiles.indexOf(column[k + 1]), 1);
+					column.splice(k + 1, 1);
+					LK.getSound('merge').play();
+				}
+			}
+			// Place tiles in new positions
+			for (var k = 0; k < column.length; k++) {
+				if (column[k].gridX !== j || column[k].gridY !== k) {
+					moved = true;
+				}
+				column[k].gridX = j;
+				column[k].gridY = k;
+				newGrid[k][j] = column[k];
+				column[k].updatePosition();
+			}
+		}
+	} else if (direction === 'down') {
+		for (var j = 0; j < gridSize; j++) {
+			var column = [];
+			// Collect non-null tiles
+			for (var i = gridSize - 1; i >= 0; i--) {
+				if (grid[i][j] !== null) {
+					column.push(grid[i][j]);
+				}
+			}
+			// Merge tiles
+			for (var k = 0; k < column.length - 1; k++) {
+				if (column[k].value === column[k + 1].value && !column[k].hasMerged && !column[k + 1].hasMerged) {
+					column[k].setValue(column[k].value * 2);
+					column[k].hasMerged = true;
+					score += column[k].value;
+					// Remove merged tile
+					game.removeChild(column[k + 1]);
+					tiles.splice(tiles.indexOf(column[k + 1]), 1);
+					column.splice(k + 1, 1);
+					LK.getSound('merge').play();
+				}
+			}
+			// Place tiles in new positions
+			for (var k = 0; k < column.length; k++) {
+				var newY = gridSize - 1 - k;
+				if (column[k].gridX !== j || column[k].gridY !== newY) {
+					moved = true;
+				}
+				column[k].gridX = j;
+				column[k].gridY = newY;
+				newGrid[newY][j] = column[k];
+				column[k].updatePosition();
+			}
+		}
+	}
+	grid = newGrid;
+	if (moved) {
+		LK.setScore(LK.getScore() + score);
+		scoreTxt.setText(LK.getScore());
+		LK.getSound('move').play();
+		isMoving = true;
+		LK.setTimeout(function () {
+			addRandomTile();
+			isMoving = false;
+			if (!checkGameWon()) {
+				checkGameOver();
+			}
+		}, 200);
+	}
+	return moved;
+}
+// Touch controls
+var startX = 0;
+var startY = 0;
+var isDragging = false;
+game.down = function (x, y, obj) {
+	startX = x;
+	startY = y;
+	isDragging = true;
+};
+game.up = function (x, y, obj) {
+	if (!isDragging) return;
+	var deltaX = x - startX;
+	var deltaY = y - startY;
+	var minSwipeDistance = 50;
+	if (Math.abs(deltaX) > minSwipeDistance || Math.abs(deltaY) > minSwipeDistance) {
+		if (Math.abs(deltaX) > Math.abs(deltaY)) {
+			// Horizontal swipe
+			if (deltaX > 0) {
+				moveTiles('right');
+			} else {
+				moveTiles('left');
+			}
+		} else {
+			// Vertical swipe
+			if (deltaY > 0) {
+				moveTiles('down');
+			} else {
+				moveTiles('up');
+			}
+		}
+	}
+	isDragging = false;
+};
+// Add initial tiles
+addRandomTile();
+addRandomTile();
+game.update = function () {
+	scoreTxt.setText(LK.getScore());
+};
\ No newline at end of file