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

/**** 
* Classes
****/ 
var Gem = Container.expand(function (color) {
	var self = Container.call(this);
	self.gemType = color;
	var gemAssetIds = ['redGem', 'blueGem', 'greenGem', 'yellowGem', 'purpleGem', 'orangeGem'];
	var gemGraphics = self.attachAsset(gemAssetIds[color], {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.gridX = 0;
	self.gridY = 0;
	self.isAnimating = false;
	self.setGridPosition = function (gridX, gridY) {
		self.gridX = gridX;
		self.gridY = gridY;
	};
	self.animateToPosition = function (targetX, targetY, onComplete) {
		self.isAnimating = true;
		tween(self, {
			x: targetX,
			y: targetY
		}, {
			duration: 200,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.isAnimating = false;
				if (onComplete) onComplete();
			}
		});
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var GRID_SIZE = 8;
var GEM_SIZE = 200;
var GRID_OFFSET_X = (2048 - GRID_SIZE * GEM_SIZE) / 2;
var GRID_OFFSET_Y = 400;
var MOVE_LIMIT = 30;
var grid = [];
var selectedGem = null;
var movesLeft = MOVE_LIMIT;
var isProcessing = false;
var targetGemTypes = [];
var targetAmounts = [];
var collectedAmounts = [];
var objectivePanel = null;
var objectiveTxt = null;
// Initialize score display
var scoreTxt = new Text2('Score: 0', {
	size: 120,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Initialize moves display
var movesTxt = new Text2('Moves: 30', {
	size: 100,
	fill: 0xFFFF44
});
movesTxt.anchor.set(1, 0);
movesTxt.x = -50;
movesTxt.y = 150;
LK.gui.topRight.addChild(movesTxt);
function getRandomGemType() {
	return Math.floor(Math.random() * 6);
}
function initializeLevelObjectives() {
	// Select 3 random gem types as targets
	var availableTypes = [0, 1, 2, 3, 4, 5];
	targetGemTypes = [];
	targetAmounts = [];
	collectedAmounts = [];
	for (var i = 0; i < 3; i++) {
		var randomIndex = Math.floor(Math.random() * availableTypes.length);
		var selectedType = availableTypes[randomIndex];
		availableTypes.splice(randomIndex, 1);
		targetGemTypes.push(selectedType);
		targetAmounts.push(15 + Math.floor(Math.random() * 10)); // 15-24 gems needed
		collectedAmounts.push(0);
	}
}
function createObjectivePanel() {
	// Create objective panel background
	objectivePanel = new Container();
	objectivePanel.x = 2048 / 2;
	objectivePanel.y = 2732 - 200;
	LK.gui.addChild(objectivePanel);
	// Create objective text
	objectiveTxt = new Text2('Objectives:', {
		size: 80,
		fill: 0xFFFFFF
	});
	objectiveTxt.anchor.set(0.5, 0);
	objectiveTxt.x = 0;
	objectiveTxt.y = -150;
	objectivePanel.addChild(objectiveTxt);
	// Create target gem displays
	for (var i = 0; i < 3; i++) {
		var gemAssetIds = ['redGem', 'blueGem', 'greenGem', 'yellowGem', 'purpleGem', 'orangeGem'];
		var targetGem = LK.getAsset(gemAssetIds[targetGemTypes[i]], {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.3,
			scaleY: 0.3
		});
		targetGem.x = (i - 1) * 200;
		targetGem.y = -50;
		objectivePanel.addChild(targetGem);
		var targetText = new Text2('0/' + targetAmounts[i], {
			size: 60,
			fill: 0xFFFFFF
		});
		targetText.anchor.set(0.5, 0);
		targetText.x = (i - 1) * 200;
		targetText.y = 20;
		objectivePanel.addChild(targetText);
	}
}
function updateObjectiveDisplay() {
	// Update the text for each target
	for (var i = 0; i < 3; i++) {
		var textChildIndex = 1 + i * 2 + 1; // title(0) + gem(1) + text(2), gem(3) + text(4), etc.
		var textChild = objectivePanel.children[textChildIndex];
		if (textChild && textChild.setText) {
			textChild.setText(collectedAmounts[i] + '/' + targetAmounts[i]);
		}
	}
}
function checkLevelComplete() {
	for (var i = 0; i < 3; i++) {
		if (collectedAmounts[i] < targetAmounts[i]) {
			return false;
		}
	}
	return true;
}
function createGem(gridX, gridY) {
	var gemType = getRandomGemType();
	var gem = new Gem(gemType);
	gem.setGridPosition(gridX, gridY);
	gem.x = GRID_OFFSET_X + gridX * GEM_SIZE + GEM_SIZE / 2;
	gem.y = GRID_OFFSET_Y + gridY * GEM_SIZE + GEM_SIZE / 2;
	return gem;
}
function initializeGrid() {
	for (var y = 0; y < GRID_SIZE; y++) {
		grid[y] = [];
		for (var x = 0; x < GRID_SIZE; x++) {
			var gem = createGem(x, y);
			grid[y][x] = gem;
			game.addChild(gem);
		}
	}
}
function getGridPosition(screenX, screenY) {
	var gridX = Math.floor((screenX - GRID_OFFSET_X) / GEM_SIZE);
	var gridY = Math.floor((screenY - GRID_OFFSET_Y) / GEM_SIZE);
	if (gridX >= 0 && gridX < GRID_SIZE && gridY >= 0 && gridY < GRID_SIZE) {
		return {
			x: gridX,
			y: gridY
		};
	}
	return null;
}
function areAdjacent(gem1, gem2) {
	var dx = Math.abs(gem1.gridX - gem2.gridX);
	var dy = Math.abs(gem1.gridY - gem2.gridY);
	// Only horizontal OR vertical adjacency allowed, not diagonal
	return dx === 1 && dy === 0 || dx === 0 && dy === 1;
}
function swapGems(gem1, gem2) {
	if (isProcessing) return;
	var tempGridX = gem1.gridX;
	var tempGridY = gem1.gridY;
	gem1.setGridPosition(gem2.gridX, gem2.gridY);
	gem2.setGridPosition(tempGridX, tempGridY);
	grid[gem1.gridY][gem1.gridX] = gem1;
	grid[gem2.gridY][gem2.gridX] = gem2;
	var targetX1 = GRID_OFFSET_X + gem1.gridX * GEM_SIZE + GEM_SIZE / 2;
	var targetY1 = GRID_OFFSET_Y + gem1.gridY * GEM_SIZE + GEM_SIZE / 2;
	var targetX2 = GRID_OFFSET_X + gem2.gridX * GEM_SIZE + GEM_SIZE / 2;
	var targetY2 = GRID_OFFSET_Y + gem2.gridY * GEM_SIZE + GEM_SIZE / 2;
	isProcessing = true;
	LK.getSound('swap').play();
	gem1.animateToPosition(targetX1, targetY1);
	gem2.animateToPosition(targetX2, targetY2, function () {
		isProcessing = false;
		processMatches();
	});
}
function findMatches() {
	var matches = [];
	// Check horizontal matches
	for (var y = 0; y < GRID_SIZE; y++) {
		var count = 1;
		var currentType = grid[y][0].gemType;
		for (var x = 1; x < GRID_SIZE; x++) {
			if (grid[y][x].gemType === currentType) {
				count++;
			} else {
				if (count >= 3) {
					for (var i = x - count; i < x; i++) {
						matches.push({
							x: i,
							y: y
						});
					}
				}
				count = 1;
				currentType = grid[y][x].gemType;
			}
		}
		if (count >= 3) {
			for (var i = GRID_SIZE - count; i < GRID_SIZE; i++) {
				matches.push({
					x: i,
					y: y
				});
			}
		}
	}
	// Check vertical matches
	for (var x = 0; x < GRID_SIZE; x++) {
		var count = 1;
		var currentType = grid[0][x].gemType;
		for (var y = 1; y < GRID_SIZE; y++) {
			if (grid[y][x].gemType === currentType) {
				count++;
			} else {
				if (count >= 3) {
					for (var i = y - count; i < y; i++) {
						matches.push({
							x: x,
							y: i
						});
					}
				}
				count = 1;
				currentType = grid[y][x].gemType;
			}
		}
		if (count >= 3) {
			for (var i = GRID_SIZE - count; i < GRID_SIZE; i++) {
				matches.push({
					x: x,
					y: i
				});
			}
		}
	}
	return matches;
}
function removeMatches(matches) {
	if (matches.length === 0) return;
	LK.getSound('match').play();
	var points = matches.length * 10;
	LK.setScore(LK.getScore() + points);
	scoreTxt.setText('Score: ' + LK.getScore());
	// Track collected target gems
	for (var i = 0; i < matches.length; i++) {
		var match = matches[i];
		var gem = grid[match.y][match.x];
		if (gem) {
			// Check if this gem type is a target
			for (var t = 0; t < targetGemTypes.length; t++) {
				if (gem.gemType === targetGemTypes[t]) {
					collectedAmounts[t]++;
				}
			}
			gem.destroy();
			grid[match.y][match.x] = null;
		}
	}
	// Update objective display
	updateObjectiveDisplay();
	// Check if level is complete
	if (checkLevelComplete()) {
		LK.showYouWin();
	}
}
function applyGravity() {
	var gemsToAnimate = [];
	for (var x = 0; x < GRID_SIZE; x++) {
		var writeIndex = GRID_SIZE - 1;
		// Move existing gems down
		for (var y = GRID_SIZE - 1; y >= 0; y--) {
			if (grid[y][x] !== null) {
				if (y !== writeIndex) {
					grid[writeIndex][x] = grid[y][x];
					grid[y][x] = null;
					grid[writeIndex][x].setGridPosition(x, writeIndex);
					var targetY = GRID_OFFSET_Y + writeIndex * GEM_SIZE + GEM_SIZE / 2;
					gemsToAnimate.push({
						gem: grid[writeIndex][x],
						targetY: targetY
					});
				}
				writeIndex--;
			}
		}
		// Create new gems for empty spaces at top
		for (var y = writeIndex; y >= 0; y--) {
			var newGem = createGem(x, y);
			newGem.y = GRID_OFFSET_Y - (writeIndex - y + 1) * GEM_SIZE + GEM_SIZE / 2;
			grid[y][x] = newGem;
			game.addChild(newGem);
			var targetY = GRID_OFFSET_Y + y * GEM_SIZE + GEM_SIZE / 2;
			gemsToAnimate.push({
				gem: newGem,
				targetY: targetY
			});
		}
	}
	// Animate all gems
	if (gemsToAnimate.length > 0) {
		isProcessing = true;
		var animationsComplete = 0;
		for (var i = 0; i < gemsToAnimate.length; i++) {
			var animData = gemsToAnimate[i];
			tween(animData.gem, {
				y: animData.targetY
			}, {
				duration: 300,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					animationsComplete++;
					if (animationsComplete === gemsToAnimate.length) {
						isProcessing = false;
						processMatches();
					}
				}
			});
		}
	}
}
function processMatches() {
	var matches = findMatches();
	if (matches.length > 0) {
		removeMatches(matches);
		applyGravity();
	}
}
function decrementMoves() {
	movesLeft--;
	movesTxt.setText('Moves: ' + movesLeft);
	if (movesLeft <= 0) {
		if (checkLevelComplete()) {
			LK.showYouWin();
		} else {
			LK.showGameOver();
		}
	}
}
var dragStartGem = null;
game.down = function (x, y, obj) {
	if (isProcessing) return;
	var gridPos = getGridPosition(x, y);
	if (!gridPos) return;
	var clickedGem = grid[gridPos.y][gridPos.x];
	if (!clickedGem) return;
	// Store the gem being dragged
	dragStartGem = clickedGem;
	if (selectedGem === null) {
		selectedGem = clickedGem;
		tween(selectedGem, {
			scaleX: 1.1,
			scaleY: 1.1
		}, {
			duration: 150
		});
	} else if (selectedGem === clickedGem) {
		tween(selectedGem, {
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 150
		});
		selectedGem = null;
	} else if (areAdjacent(selectedGem, clickedGem)) {
		tween(selectedGem, {
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 150
		});
		swapGems(selectedGem, clickedGem);
		decrementMoves();
		selectedGem = null;
	} else {
		tween(selectedGem, {
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 150
		});
		selectedGem = clickedGem;
		tween(selectedGem, {
			scaleX: 1.1,
			scaleY: 1.1
		}, {
			duration: 150
		});
	}
};
game.up = function (x, y, obj) {
	if (isProcessing || !dragStartGem) return;
	var gridPos = getGridPosition(x, y);
	if (!gridPos) {
		dragStartGem = null;
		return;
	}
	var targetGem = grid[gridPos.y][gridPos.x];
	if (!targetGem || targetGem === dragStartGem) {
		dragStartGem = null;
		return;
	}
	// Only allow swap if gems are adjacent (horizontal or vertical only)
	if (areAdjacent(dragStartGem, targetGem)) {
		// Clear any existing selection
		if (selectedGem) {
			tween(selectedGem, {
				scaleX: 1,
				scaleY: 1
			}, {
				duration: 150
			});
			selectedGem = null;
		}
		swapGems(dragStartGem, targetGem);
		decrementMoves();
	} else {
		// If not adjacent, do nothing - invalid move
	}
	dragStartGem = null;
};
// Initialize the game
initializeLevelObjectives();
initializeGrid();
createObjectivePanel();
scoreTxt.setText('Score: ' + LK.getScore());

===================================================================
--- original.js
+++ change.js
@@ -135,9 +135,10 @@
 }
 function updateObjectiveDisplay() {
 	// Update the text for each target
 	for (var i = 0; i < 3; i++) {
-		var textChild = objectivePanel.children[i * 2 + 2]; // Skip title (1) + gem/text pairs (2 each)
+		var textChildIndex = 1 + i * 2 + 1; // title(0) + gem(1) + text(2), gem(3) + text(4), etc.
+		var textChild = objectivePanel.children[textChildIndex];
 		if (textChild && textChild.setText) {
 			textChild.setText(collectedAmounts[i] + '/' + targetAmounts[i]);
 		}
 	}
@@ -181,8 +182,9 @@
 }
 function areAdjacent(gem1, gem2) {
 	var dx = Math.abs(gem1.gridX - gem2.gridX);
 	var dy = Math.abs(gem1.gridY - gem2.gridY);
+	// Only horizontal OR vertical adjacency allowed, not diagonal
 	return dx === 1 && dy === 0 || dx === 0 && dy === 1;
 }
 function swapGems(gem1, gem2) {
 	if (isProcessing) return;
@@ -429,9 +431,9 @@
 	if (!targetGem || targetGem === dragStartGem) {
 		dragStartGem = null;
 		return;
 	}
-	// Only allow swap if gems are adjacent
+	// Only allow swap if gems are adjacent (horizontal or vertical only)
 	if (areAdjacent(dragStartGem, targetGem)) {
 		// Clear any existing selection
 		if (selectedGem) {
 			tween(selectedGem, {
@@ -443,8 +445,10 @@
 			selectedGem = null;
 		}
 		swapGems(dragStartGem, targetGem);
 		decrementMoves();
+	} else {
+		// If not adjacent, do nothing - invalid move
 	}
 	dragStartGem = null;
 };
 // Initialize the game