===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,357 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+
+/**** 
+* Classes
+****/ 
+// CountryMarker: Player or AI marker for claiming territory
+var CountryMarker = Container.expand(function () {
+	var self = Container.call(this);
+	// 1 = player, 2 = AI
+	self.owner = 1;
+	var markerAsset = null;
+	self.setOwner = function (owner) {
+		self.owner = owner;
+		self.removeChildren();
+		if (self.owner === 1) {
+			markerAsset = self.attachAsset('playerMarker', {
+				anchorX: 0.5,
+				anchorY: 0.5
+			});
+		} else {
+			markerAsset = self.attachAsset('aiMarker', {
+				anchorX: 0.5,
+				anchorY: 0.5
+			});
+		}
+	};
+	// For AI, target cell to move towards
+	self.targetCell = null;
+	return self;
+});
+// GridCell: Represents a single region on the map
+var GridCell = Container.expand(function () {
+	var self = Container.call(this);
+	// State: 0 = neutral, 1 = player, 2 = AI
+	self.state = 0;
+	self.row = 0;
+	self.col = 0;
+	// Attach neutral asset by default
+	var cellAsset = self.attachAsset('cellNeutral', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	// Update cell appearance based on state
+	self.setState = function (newState) {
+		self.state = newState;
+		// Remove previous asset
+		self.removeChildren();
+		if (self.state === 0) {
+			cellAsset = self.attachAsset('cellNeutral', {
+				anchorX: 0.5,
+				anchorY: 0.5
+			});
+		} else if (self.state === 1) {
+			cellAsset = self.attachAsset('cellPlayer', {
+				anchorX: 0.5,
+				anchorY: 0.5
+			});
+		} else if (self.state === 2) {
+			cellAsset = self.attachAsset('cellAI', {
+				anchorX: 0.5,
+				anchorY: 0.5
+			});
+		}
+	};
+	return self;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000000
-});
\ No newline at end of file
+	backgroundColor: 0xfafafa
+});
+
+/**** 
+* Game Code
+****/ 
+// Grid cell states
+// Country markers (player and AI)
+// Grid settings
+var GRID_ROWS = 7;
+var GRID_COLS = 5;
+var CELL_SIZE = 220;
+var GRID_OFFSET_X = (2048 - GRID_COLS * CELL_SIZE) / 2;
+var GRID_OFFSET_Y = 300;
+// Game state
+var grid = [];
+var playerMarker = null;
+var aiMarker = null;
+var playerCells = 0;
+var aiCells = 0;
+var neutralCells = 0;
+var dragMarker = null;
+var lastPlayerCell = null;
+var lastAIUpdateTick = 0;
+var aiMoveInterval = 60; // AI moves every 60 ticks (~1s)
+var gameEnded = false;
+// Score display
+var scoreTxt = new Text2('0 - 0', {
+	size: 110,
+	fill: "#222"
+});
+scoreTxt.anchor.set(0.5, 0);
+LK.gui.top.addChild(scoreTxt);
+// Helper: Get cell at grid position
+function getCell(row, col) {
+	if (row < 0 || row >= GRID_ROWS || col < 0 || col >= GRID_COLS) return null;
+	return grid[row][col];
+}
+// Helper: Get cell at (x, y) game coordinates
+function getCellAtPosition(x, y) {
+	var col = Math.floor((x - GRID_OFFSET_X) / CELL_SIZE);
+	var row = Math.floor((y - GRID_OFFSET_Y) / CELL_SIZE);
+	return getCell(row, col);
+}
+// Helper: Get adjacent cells (up, down, left, right)
+function getAdjacentCells(cell) {
+	var adj = [];
+	var dirs = [{
+		dr: -1,
+		dc: 0
+	}, {
+		dr: 1,
+		dc: 0
+	}, {
+		dr: 0,
+		dc: -1
+	}, {
+		dr: 0,
+		dc: 1
+	}];
+	for (var i = 0; i < dirs.length; i++) {
+		var ncell = getCell(cell.row + dirs[i].dr, cell.col + dirs[i].dc);
+		if (ncell) adj.push(ncell);
+	}
+	return adj;
+}
+// Helper: Count cells by state
+function countCells() {
+	playerCells = 0;
+	aiCells = 0;
+	neutralCells = 0;
+	for (var r = 0; r < GRID_ROWS; r++) {
+		for (var c = 0; c < GRID_COLS; c++) {
+			var cell = grid[r][c];
+			if (cell.state === 0) neutralCells++;else if (cell.state === 1) playerCells++;else if (cell.state === 2) aiCells++;
+		}
+	}
+}
+// Helper: Update score display
+function updateScore() {
+	scoreTxt.setText(playerCells + " - " + aiCells);
+}
+// Helper: Check win/lose
+function checkEndGame() {
+	if (gameEnded) return;
+	var total = GRID_ROWS * GRID_COLS;
+	if (playerCells > total / 2) {
+		gameEnded = true;
+		LK.showYouWin();
+	} else if (aiCells > total / 2 || playerCells === 0) {
+		gameEnded = true;
+		LK.showGameOver();
+	}
+}
+// Initialize grid
+grid = [];
+for (var r = 0; r < GRID_ROWS; r++) {
+	var rowArr = [];
+	for (var c = 0; c < GRID_COLS; c++) {
+		var cell = new GridCell();
+		cell.row = r;
+		cell.col = c;
+		cell.x = GRID_OFFSET_X + c * CELL_SIZE + CELL_SIZE / 2;
+		cell.y = GRID_OFFSET_Y + r * CELL_SIZE + CELL_SIZE / 2;
+		cell.setState(0);
+		game.addChild(cell);
+		rowArr.push(cell);
+	}
+	grid.push(rowArr);
+}
+// Set initial player and AI territory (center cells)
+var playerStart = getCell(Math.floor(GRID_ROWS / 2), 1);
+playerStart.setState(1);
+var aiStart = getCell(Math.floor(GRID_ROWS / 2), GRID_COLS - 2);
+aiStart.setState(2);
+// Place player marker
+playerMarker = new CountryMarker();
+playerMarker.setOwner(1);
+playerMarker.x = playerStart.x;
+playerMarker.y = playerStart.y;
+game.addChild(playerMarker);
+lastPlayerCell = playerStart;
+// Place AI marker
+aiMarker = new CountryMarker();
+aiMarker.setOwner(2);
+aiMarker.x = aiStart.x;
+aiMarker.y = aiStart.y;
+game.addChild(aiMarker);
+// Initial cell counts
+countCells();
+updateScore();
+// Dragging logic for player marker
+game.down = function (x, y, obj) {
+	// Only allow drag if touch/click is on player marker
+	var dx = x - playerMarker.x;
+	var dy = y - playerMarker.y;
+	var dist = Math.sqrt(dx * dx + dy * dy);
+	if (dist < 80) {
+		dragMarker = playerMarker;
+	}
+};
+game.up = function (x, y, obj) {
+	if (dragMarker === playerMarker) {
+		// Snap to nearest cell
+		var cell = getCellAtPosition(playerMarker.x, playerMarker.y);
+		if (cell && (cell.state === 0 || cell.state === 2)) {
+			// Only allow move to adjacent cell
+			var adj = getAdjacentCells(lastPlayerCell);
+			var isAdj = false;
+			for (var i = 0; i < adj.length; i++) {
+				if (adj[i] === cell) {
+					isAdj = true;
+					break;
+				}
+			}
+			if (isAdj) {
+				// Claim cell
+				cell.setState(1);
+				lastPlayerCell = cell;
+				// Animate marker to cell center
+				tween(playerMarker, {
+					x: cell.x,
+					y: cell.y
+				}, {
+					duration: 180,
+					easing: tween.easeOut
+				});
+				countCells();
+				updateScore();
+				checkEndGame();
+			} else {
+				// Not adjacent, snap back
+				tween(playerMarker, {
+					x: lastPlayerCell.x,
+					y: lastPlayerCell.y
+				}, {
+					duration: 120,
+					easing: tween.easeIn
+				});
+			}
+		} else {
+			// Not a valid cell, snap back
+			tween(playerMarker, {
+				x: lastPlayerCell.x,
+				y: lastPlayerCell.y
+			}, {
+				duration: 120,
+				easing: tween.easeIn
+			});
+		}
+	}
+	dragMarker = null;
+};
+game.move = function (x, y, obj) {
+	if (dragMarker === playerMarker) {
+		// Restrict movement to grid area
+		var px = Math.max(GRID_OFFSET_X + 60, Math.min(x, GRID_OFFSET_X + GRID_COLS * CELL_SIZE - 60));
+		var py = Math.max(GRID_OFFSET_Y + 60, Math.min(y, GRID_OFFSET_Y + GRID_ROWS * CELL_SIZE - 60));
+		playerMarker.x = px;
+		playerMarker.y = py;
+	}
+};
+// AI logic: move towards nearest neutral or player cell adjacent to its territory
+function aiChooseTarget() {
+	// Find all AI cells
+	var aiCellsArr = [];
+	for (var r = 0; r < GRID_ROWS; r++) {
+		for (var c = 0; c < GRID_COLS; c++) {
+			if (grid[r][c].state === 2) aiCellsArr.push(grid[r][c]);
+		}
+	}
+	// For each AI cell, check adjacent for neutral or player cells
+	var candidates = [];
+	for (var i = 0; i < aiCellsArr.length; i++) {
+		var adj = getAdjacentCells(aiCellsArr[i]);
+		for (var j = 0; j < adj.length; j++) {
+			if (adj[j].state === 0 || adj[j].state === 1) {
+				candidates.push(adj[j]);
+			}
+		}
+	}
+	// Pick random candidate
+	if (candidates.length > 0) {
+		var idx = Math.floor(Math.random() * candidates.length);
+		return candidates[idx];
+	}
+	return null;
+}
+// Main game update loop
+game.update = function () {
+	if (gameEnded) return;
+	// AI move
+	if (LK.ticks - lastAIUpdateTick > aiMoveInterval) {
+		lastAIUpdateTick = LK.ticks;
+		var target = aiChooseTarget();
+		if (target) {
+			// Animate AI marker to target
+			tween(aiMarker, {
+				x: target.x,
+				y: target.y
+			}, {
+				duration: 200,
+				easing: tween.easeInOut,
+				onFinish: function onFinish() {
+					// Claim cell
+					if (target.state === 1) {
+						// Player loses cell
+						target.setState(2);
+						// If player marker is here, snap it back to last owned cell
+						var dx = playerMarker.x - target.x;
+						var dy = playerMarker.y - target.y;
+						if (Math.sqrt(dx * dx + dy * dy) < 10) {
+							// Find any player cell to snap to
+							var found = false;
+							for (var r = 0; r < GRID_ROWS; r++) {
+								for (var c = 0; c < GRID_COLS; c++) {
+									if (grid[r][c].state === 1) {
+										lastPlayerCell = grid[r][c];
+										tween(playerMarker, {
+											x: lastPlayerCell.x,
+											y: lastPlayerCell.y
+										}, {
+											duration: 120,
+											easing: tween.easeIn
+										});
+										found = true;
+										break;
+									}
+								}
+								if (found) break;
+							}
+						}
+					} else {
+						target.setState(2);
+					}
+					countCells();
+					updateScore();
+					checkEndGame();
+				}
+			});
+		}
+	}
+};
\ No newline at end of file