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

/**** 
* Classes
****/ 
// CountryMarker: Player, AI, or Country 3 marker for claiming territory
var CountryMarker = Container.expand(function () {
	var self = Container.call(this);
	// 1 = player, 2 = AI, 3 = Country 3 (green)
	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 if (self.owner === 2) {
			markerAsset = self.attachAsset('aiMarker', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (self.owner === 3) {
			markerAsset = self.attachAsset('markerCountry3', {
				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
			});
		} else if (self.state === 3) {
			cellAsset = self.attachAsset('cellCountry3', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (self.state === 4) {
			cellAsset = self.attachAsset('cellCountry4', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Additional colors for more countries
// Grid cell states
// Country markers (player and AI)
// Grid settings
var GRID_ROWS = 9;
var GRID_COLS = 7;
var CELL_SIZE = 180;
var GRID_OFFSET_X = (2048 - GRID_COLS * CELL_SIZE) / 2;
var GRID_OFFSET_Y = 200;
// Game state
var grid = [];
var playerMarker = null;
var aiMarker = null;
var playerCells = 0;
var aiCells = 0;
var neutralCells = 0;
var country3Cells = 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 - 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];
	// Green (country 3) AI move
	if (!gameEnded && LK.ticks - lastCountry3UpdateTick > country3MoveInterval) {
		lastCountry3UpdateTick = LK.ticks;
		var greenTarget = country3ChooseTarget();
		if (greenTarget) {
			// Animate green marker to target
			tween(country3Marker, {
				x: greenTarget.x,
				y: greenTarget.y
			}, {
				duration: 200,
				easing: tween.easeInOut,
				onFinish: function onFinish() {
					// Claim cell
					if (greenTarget.state === 1 || greenTarget.state === 2) {
						// Player or AI loses cell
						greenTarget.setState(3);
						// If player marker is here, snap it back to last owned cell
						var dx = playerMarker.x - greenTarget.x;
						var dy = playerMarker.y - greenTarget.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 {
						greenTarget.setState(3);
					}
					lastCountry3Cell = greenTarget;
					countCells();
					updateScore();
					checkEndGame();
				}
			});
		}
	}
}
;
// 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;
	country3Cells = 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++;
			} else if (cell.state === 3) {
				country3Cells++;
			}
		}
	}
}
// Helper: Update score display
function updateScore() {
	scoreTxt.setText(playerCells + " - " + aiCells + " - " + country3Cells);
}
// 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, AI, and Country 3 (green) 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);
var country3Start = getCell(Math.floor(GRID_ROWS / 2), Math.floor(GRID_COLS / 2));
country3Start.setState(3);
// 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);
// Place Country 3 (green) marker (now with AI movement/attack)
country3Marker = new CountryMarker();
country3Marker.setOwner(3);
country3Marker.x = country3Start.x;
country3Marker.y = country3Start.y;
game.addChild(country3Marker);
lastCountry3Cell = country3Start;
// Country 3 (green) AI variables
var lastCountry3UpdateTick = 0;
var country3MoveInterval = 60; // green AI moves every 60 ticks (~1s)
// 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 || cell.state === 3)) {
			// 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++) {
			// Only target neutral, player, or green (country 3) cells
			if (adj[j].state === 0 || adj[j].state === 1 || adj[j].state === 3) {
				candidates.push(adj[j]);
			}
		}
	}
	// Pick random candidate
	if (candidates.length > 0) {
		var idx = Math.floor(Math.random() * candidates.length);
		return candidates[idx];
	}
	return null;
}
// Green (country 3) AI logic: move towards nearest neutral, player, or AI cell adjacent to its territory
function country3ChooseTarget() {
	// Find all green cells
	var greenCellsArr = [];
	for (var r = 0; r < GRID_ROWS; r++) {
		for (var c = 0; c < GRID_COLS; c++) {
			if (grid[r][c].state === 3) greenCellsArr.push(grid[r][c]);
		}
	}
	// For each green cell, check adjacent for neutral, player, or AI cells (never yellow)
	var candidates = [];
	for (var i = 0; i < greenCellsArr.length; i++) {
		var adj = getAdjacentCells(greenCellsArr[i]);
		for (var j = 0; j < adj.length; j++) {
			// Only target neutral, player, or AI cells, never yellow (country 4) or itself
			if (adj[j].state === 0 || adj[j].state === 1 || adj[j].state === 2) {
				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();
				}
			});
		}
	}
	// Green (country 3) AI move
	if (!gameEnded && LK.ticks - lastCountry3UpdateTick > country3MoveInterval) {
		lastCountry3UpdateTick = LK.ticks;
		var greenTarget = country3ChooseTarget();
		if (greenTarget) {
			// Animate green marker to target
			tween(country3Marker, {
				x: greenTarget.x,
				y: greenTarget.y
			}, {
				duration: 200,
				easing: tween.easeInOut,
				onFinish: function onFinish() {
					// Claim cell
					if (greenTarget.state === 1 || greenTarget.state === 2) {
						// Player or AI loses cell
						greenTarget.setState(3);
						// If player marker is here, snap it back to last owned cell
						var dx = playerMarker.x - greenTarget.x;
						var dy = playerMarker.y - greenTarget.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 {
						greenTarget.setState(3);
					}
					lastCountry3Cell = greenTarget;
					countCells();
					updateScore();
					checkEndGame();
				}
			});
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -307,9 +307,9 @@
 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)) {
+		if (cell && (cell.state === 0 || cell.state === 2 || cell.state === 3)) {
 			// Only allow move to adjacent cell
 			var adj = getAdjacentCells(lastPlayerCell);
 			var isAdj = false;
 			for (var i = 0; i < adj.length; i++) {