/**** 
* 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);
// Player money
var playerMoney = 5;
var moneyTxt = new Text2('💰 ' + playerMoney, {
	size: 90,
	fill: 0x2ECC40
});
moneyTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(moneyTxt);
moneyTxt.y = 120;
// 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)) {
			// Allow move to any cell adjacent to ANY player cell
			var isAdj = false;
			for (var r = 0; r < GRID_ROWS; r++) {
				for (var c = 0; c < GRID_COLS; c++) {
					if (grid[r][c].state === 1) {
						var adj = getAdjacentCells(grid[r][c]);
						for (var i = 0; i < adj.length; i++) {
							if (adj[i] === cell) {
								isAdj = true;
								break;
							}
						}
						if (isAdj) break;
					}
				}
				if (isAdj) break;
			}
			if (isAdj) {
				// Only allow attack if player has money
				if (playerMoney > 0) {
					playerMoney--;
					moneyTxt.setText('💰 ' + playerMoney);
					// 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 enough money, snap back
					tween(playerMarker, {
						x: lastPlayerCell.x,
						y: lastPlayerCell.y
					}, {
						duration: 120,
						easing: tween.easeIn
					});
				}
			} 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;
	// Give player money for each cell owned at the start of their turn (max 10)
	if (LK.ticks % 60 === 0 && !gameEnded) {
		var newMoney = 0;
		for (var r = 0; r < GRID_ROWS; r++) {
			for (var c = 0; c < GRID_COLS; c++) {
				if (grid[r][c].state === 1) newMoney++;
			}
		}
		playerMoney += newMoney;
		if (playerMoney > 10) playerMoney = 10;
		moneyTxt.setText('💰 ' + playerMoney);
	}
	// 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
@@ -121,8 +121,17 @@
 	fill: "#222"
 });
 scoreTxt.anchor.set(0.5, 0);
 LK.gui.top.addChild(scoreTxt);
+// Player money
+var playerMoney = 5;
+var moneyTxt = new Text2('💰 ' + playerMoney, {
+	size: 90,
+	fill: 0x2ECC40
+});
+moneyTxt.anchor.set(0.5, 0);
+LK.gui.top.addChild(moneyTxt);
+moneyTxt.y = 120;
 // 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];
@@ -326,22 +335,36 @@
 				}
 				if (isAdj) 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();
+				// Only allow attack if player has money
+				if (playerMoney > 0) {
+					playerMoney--;
+					moneyTxt.setText('💰 ' + playerMoney);
+					// 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 enough money, snap back
+					tween(playerMarker, {
+						x: lastPlayerCell.x,
+						y: lastPlayerCell.y
+					}, {
+						duration: 120,
+						easing: tween.easeIn
+					});
+				}
 			} else {
 				// Not adjacent, snap back
 				tween(playerMarker, {
 					x: lastPlayerCell.x,
@@ -429,8 +452,20 @@
 }
 // Main game update loop
 game.update = function () {
 	if (gameEnded) return;
+	// Give player money for each cell owned at the start of their turn (max 10)
+	if (LK.ticks % 60 === 0 && !gameEnded) {
+		var newMoney = 0;
+		for (var r = 0; r < GRID_ROWS; r++) {
+			for (var c = 0; c < GRID_COLS; c++) {
+				if (grid[r][c].state === 1) newMoney++;
+			}
+		}
+		playerMoney += newMoney;
+		if (playerMoney > 10) playerMoney = 10;
+		moneyTxt.setText('💰 ' + playerMoney);
+	}
 	// AI move
 	if (LK.ticks - lastAIUpdateTick > aiMoveInterval) {
 		lastAIUpdateTick = LK.ticks;
 		var target = aiChooseTarget();