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

/**** 
* Classes
****/ 
// Food Class
var Food = Container.expand(function () {
	var self = Container.call(this);
	// Food is a yellow ellipse
	var foodAsset = self.attachAsset('food', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
// Snake Head Class
var SnakeHead = Container.expand(function () {
	var self = Container.call(this);
	// Head is a unique asset
	var headAsset = self.attachAsset('snakeHead', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
// Snake Segment Class
var SnakeSegment = Container.expand(function () {
	var self = Container.call(this);
	// Each segment is a green box
	var segmentAsset = self.attachAsset('snakeSegment', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
// Wall Class
var Wall = Container.expand(function () {
	var self = Container.call(this);
	// Wall is a red box
	var wallAsset = self.attachAsset('wall', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});

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

/**** 
* Game Code
****/ 
// --- Game Constants ---
// --- Asset Initialization ---
// Snake Head Class
// --- 16:9 Board Setup ---
// We'll use the full width (2048px) and calculate height for 16:9
var GRID_SIZE = 180; // Each cell is 180x180 px
var GRID_COLS = Math.floor(2048 / GRID_SIZE); // 11
var BOARD_WIDTH = GRID_COLS * GRID_SIZE;
var BOARD_HEIGHT = Math.floor(BOARD_WIDTH * 9 / 16); // 16:9 aspect ratio
var GRID_ROWS = Math.floor(BOARD_HEIGHT / GRID_SIZE); // 5
BOARD_HEIGHT = GRID_ROWS * GRID_SIZE; // snap to grid
var BOARD_OFFSET_X = Math.floor((2048 - BOARD_WIDTH) / 2);
var BOARD_OFFSET_Y = Math.floor((2732 - BOARD_HEIGHT) / 2);
var SNAKE_START_LENGTH = 2;
var SNAKE_MAX_LENGTH = 30; // Win condition, slightly reduced for new board size
// --- Game State ---
var snake = [];
var snakeDir = {
	x: 1,
	y: 0
}; // Start moving right
var nextDir = {
	x: 1,
	y: 0
};
var moveTimer = 0;
var MOVE_INTERVAL = 180; // ms
var food = null;
var walls = [];
var isDead = false;
var isWin = false;
var pendingGrowth = 0;
var lastTouch = null;
// --- Score UI ---
var scoreTxt = new Text2('1', {
	size: 240,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// --- Helper Functions ---
function gridToPos(col, row) {
	return {
		x: BOARD_OFFSET_X + col * GRID_SIZE + GRID_SIZE / 2,
		y: BOARD_OFFSET_Y + row * GRID_SIZE + GRID_SIZE / 2
	};
}
function posToGrid(x, y) {
	var col = Math.floor((x - BOARD_OFFSET_X) / GRID_SIZE);
	var row = Math.floor((y - BOARD_OFFSET_Y) / GRID_SIZE);
	return {
		col: col,
		row: row
	};
}
function randomFreeCell() {
	// Returns a random cell not occupied by snake or wall
	var free = [];
	for (var r = 1; r < GRID_ROWS - 1; r++) {
		for (var c = 1; c < GRID_COLS - 1; c++) {
			var occupied = false;
			for (var i = 0; i < snake.length; i++) {
				if (snake[i].col === c && snake[i].row === r) {
					occupied = true;
					break;
				}
			}
			if (food && food.col === c && food.row === r) occupied = true;
			if (!occupied) free.push({
				col: c,
				row: r
			});
		}
	}
	if (free.length === 0) return null;
	return free[Math.floor(Math.random() * free.length)];
}
function setScore(val) {
	LK.setScore(val);
	scoreTxt.setText(val);
}
// --- Wall Setup ---
function createWalls() {
	// Top and bottom
	for (var c = 0; c < GRID_COLS; c++) {
		var wallTop = new Wall();
		var wallBottom = new Wall();
		var posTop = gridToPos(c, 0);
		var posBottom = gridToPos(c, GRID_ROWS - 1);
		wallTop.x = posTop.x;
		wallTop.y = posTop.y;
		wallTop.col = c;
		wallTop.row = 0;
		wallBottom.x = posBottom.x;
		wallBottom.y = posBottom.y;
		wallBottom.col = c;
		wallBottom.row = GRID_ROWS - 1;
		game.addChild(wallTop);
		game.addChild(wallBottom);
		walls.push(wallTop, wallBottom);
	}
	// Left and right
	for (var r = 1; r < GRID_ROWS - 1; r++) {
		var wallLeft = new Wall();
		var wallRight = new Wall();
		var posLeft = gridToPos(0, r);
		var posRight = gridToPos(GRID_COLS - 1, r);
		wallLeft.x = posLeft.x;
		wallLeft.y = posLeft.y;
		wallLeft.col = 0;
		wallLeft.row = r;
		wallRight.x = posRight.x;
		wallRight.y = posRight.y;
		wallRight.col = GRID_COLS - 1;
		wallRight.row = r;
		game.addChild(wallLeft);
		game.addChild(wallRight);
		walls.push(wallLeft, wallRight);
	}
}
// --- Snake Setup ---
function createSnake() {
	var startCol = Math.floor(GRID_COLS / 2);
	var startRow = Math.floor(GRID_ROWS / 2);
	// First segment is the head
	var head = new SnakeHead();
	head.col = startCol;
	head.row = startRow;
	var pos = gridToPos(head.col, head.row);
	head.x = pos.x;
	head.y = pos.y;
	game.addChild(head);
	snake.push(head);
	// The rest are segments
	for (var i = 1; i < SNAKE_START_LENGTH; i++) {
		var seg = new SnakeSegment();
		seg.col = startCol - i;
		seg.row = startRow;
		var pos2 = gridToPos(seg.col, seg.row);
		seg.x = pos2.x;
		seg.y = pos2.y;
		game.addChild(seg);
		snake.push(seg);
	}
}
// --- Food Setup ---
function spawnFood() {
	if (food) {
		food.destroy();
		food = null;
	}
	var cell = randomFreeCell();
	if (!cell) return;
	food = new Food();
	food.col = cell.col;
	food.row = cell.row;
	var pos = gridToPos(cell.col, cell.row);
	food.x = pos.x;
	food.y = pos.y;
	game.addChild(food);
}
// --- Collision Checks ---
function isWall(col, row) {
	return col === 0 || row === 0 || col === GRID_COLS - 1 || row === GRID_ROWS - 1;
}
function isSnake(col, row, skipHead) {
	for (var i = skipHead ? 1 : 0; i < snake.length; i++) {
		if (snake[i].col === col && snake[i].row === row) return true;
	}
	return false;
}
// --- Game Over / Win ---
function triggerGameOver() {
	if (isDead) return;
	isDead = true;
	LK.effects.flashScreen(0xff0000, 1000);
	// Create a container for the game over display
	var goCont = new Container();
	// Create large snake head asset (350x350)
	var snakeHeadAsset = LK.getAsset('snakeHead', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 350,
		height: 350
	});
	snakeHeadAsset.x = 350 / 2;
	snakeHeadAsset.y = 350 / 2;
	// Create large food asset (350x350)
	var foodAsset = LK.getAsset('food', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 350,
		height: 350
	});
	foodAsset.x = 350 + 350 / 2 + 40; // 40px gap between
	foodAsset.y = 350 / 2;
	// Set container size and center on screen
	var totalWidth = 350 * 2 + 40;
	var totalHeight = 350;
	goCont.x = 0;
	goCont.y = 0;
	goCont.width = totalWidth;
	goCont.height = totalHeight;
	goCont.addChild(snakeHeadAsset);
	goCont.addChild(foodAsset);
	// Show the container as a popup overlay (LK will remove it on reset)
	LK.showGameOver({
		customContent: goCont,
		customContentWidth: totalWidth,
		customContentHeight: totalHeight,
		customContentY: 120 // Place below the menu (menu is top 100px, so 120px for margin)
	});
}
function triggerWin() {
	if (isWin) return;
	isWin = true;
	LK.effects.flashScreen(0x00ff00, 1000);
	LK.showYouWin();
}
// --- Input Handling (Touch/Drag) ---
var dragStart = null;
var dragDir = null;
function getDirectionFromDrag(dx, dy) {
	if (Math.abs(dx) > Math.abs(dy)) {
		return dx > 0 ? {
			x: 1,
			y: 0
		} : {
			x: -1,
			y: 0
		};
	} else {
		return dy > 0 ? {
			x: 0,
			y: 1
		} : {
			x: 0,
			y: -1
		};
	}
}
game.down = function (x, y, obj) {
	dragStart = {
		x: x,
		y: y
	};
	dragDir = null;
};
game.move = function (x, y, obj) {
	if (!dragStart) return;
	var dx = x - dragStart.x;
	var dy = y - dragStart.y;
	if (Math.abs(dx) > 40 || Math.abs(dy) > 40) {
		var dir = getDirectionFromDrag(dx, dy);
		// Prevent reversing
		if ((dir.x !== -snakeDir.x || dir.y !== -snakeDir.y) && (dir.x !== snakeDir.x || dir.y !== snakeDir.y)) {
			nextDir = dir;
			dragDir = dir;
			dragStart = null;
		}
	}
};
game.up = function (x, y, obj) {
	dragStart = null;
	dragDir = null;
};
// --- Main Game Loop ---
game.update = function () {
	if (isDead || isWin) return;
	moveTimer += 1000 / 60;
	if (moveTimer < MOVE_INTERVAL) return;
	moveTimer = 0;
	// Update direction
	if (nextDir.x !== -snakeDir.x || nextDir.y !== -snakeDir.y) {
		snakeDir = {
			x: nextDir.x,
			y: nextDir.y
		};
	}
	// Calculate new head position
	var head = snake[0];
	var newCol = head.col + snakeDir.x;
	var newRow = head.row + snakeDir.y;
	// Check collisions
	if (isWall(newCol, newRow) || isSnake(newCol, newRow, false)) {
		triggerGameOver();
		return;
	}
	// Move snake
	// Remove old head and replace with segment
	var oldHead = snake[0];
	var newSegment = new SnakeSegment();
	newSegment.col = oldHead.col;
	newSegment.row = oldHead.row;
	newSegment.x = oldHead.x;
	newSegment.y = oldHead.y;
	game.addChild(newSegment);
	snake[0].destroy();
	snake[0] = newSegment;
	// Add new head at the front
	var newHead = new SnakeHead();
	newHead.col = newCol;
	newHead.row = newRow;
	var pos = gridToPos(newCol, newRow);
	newHead.x = pos.x;
	newHead.y = pos.y;
	// Set rotation based on direction (asset is upright, so rotate by +90deg for right)
	if (snakeDir.x === 1 && snakeDir.y === 0) {
		newHead.rotation = Math.PI / 2; // Right
	} else if (snakeDir.x === -1 && snakeDir.y === 0) {
		newHead.rotation = -Math.PI / 2; // Left
	} else if (snakeDir.x === 0 && snakeDir.y === -1) {
		newHead.rotation = 0; // Up
	} else if (snakeDir.x === 0 && snakeDir.y === 1) {
		newHead.rotation = Math.PI; // Down
	}
	game.addChild(newHead);
	snake.unshift(newHead);
	// Check food
	var ateFood = food && food.col === newCol && food.row === newRow;
	if (ateFood) {
		setScore(LK.getScore() + 1);
		pendingGrowth += 1;
		// Play feeding sound
		LK.getSound('feeding').play();
		// 25% chance to play feeding2 sound in background
		if (Math.random() < 0.25) {
			LK.getSound('feeding2').play();
		}
		food.destroy();
		food = null;
		spawnFood();
		// Win condition
		if (snake.length >= SNAKE_MAX_LENGTH) {
			triggerWin();
			return;
		}
	}
	// Remove tail if not growing
	if (pendingGrowth > 0) {
		pendingGrowth--;
	} else {
		var tail = snake.pop();
		tail.destroy();
	}
};
// --- Draw Board Grid Background ---
var gridBg = new Container();
for (var r = 0; r < GRID_ROWS; r++) {
	for (var c = 0; c < GRID_COLS; c++) {
		// Use a light color for grid lines, and a slightly darker fill for the cell
		var cell = LK.getAsset('snakeSegment', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: BOARD_OFFSET_X + c * GRID_SIZE + GRID_SIZE / 2,
			y: BOARD_OFFSET_Y + r * GRID_SIZE + GRID_SIZE / 2,
			width: GRID_SIZE,
			height: GRID_SIZE,
			tint: (r + c) % 2 === 0 ? 0x232323 : 0x1a1a1a // subtle checkerboard for clarity
		});
		// Add a border by overlaying a slightly smaller cell of the same color as background
		var border = LK.getAsset('snakeSegment', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: BOARD_OFFSET_X + c * GRID_SIZE + GRID_SIZE / 2,
			y: BOARD_OFFSET_Y + r * GRID_SIZE + GRID_SIZE / 2,
			width: GRID_SIZE - 8,
			height: GRID_SIZE - 8,
			tint: (r + c) % 2 === 0 ? 0x181818 : 0x181818 // match background
		});
		gridBg.addChild(cell);
		gridBg.addChild(border);
	}
}
game.addChild(gridBg);
// --- Game Initialization ---
createWalls();
createSnake();
spawnFood();
setScore(1);
;

===================================================================
--- original.js
+++ change.js
@@ -56,16 +56,19 @@
 
 /**** 
 * Game Code
 ****/ 
-// Snake Head Class
-// --- Asset Initialization ---
 // --- Game Constants ---
-var GRID_SIZE = 180; // Each cell is 180x180 px (increased)
+// --- Asset Initialization ---
+// Snake Head Class
+// --- 16:9 Board Setup ---
+// We'll use the full width (2048px) and calculate height for 16:9
+var GRID_SIZE = 180; // Each cell is 180x180 px
 var GRID_COLS = Math.floor(2048 / GRID_SIZE); // 11
-var GRID_ROWS = Math.floor(2732 / GRID_SIZE); // 15
 var BOARD_WIDTH = GRID_COLS * GRID_SIZE;
-var BOARD_HEIGHT = GRID_ROWS * GRID_SIZE;
+var BOARD_HEIGHT = Math.floor(BOARD_WIDTH * 9 / 16); // 16:9 aspect ratio
+var GRID_ROWS = Math.floor(BOARD_HEIGHT / GRID_SIZE); // 5
+BOARD_HEIGHT = GRID_ROWS * GRID_SIZE; // snap to grid
 var BOARD_OFFSET_X = Math.floor((2048 - BOARD_WIDTH) / 2);
 var BOARD_OFFSET_Y = Math.floor((2732 - BOARD_HEIGHT) / 2);
 var SNAKE_START_LENGTH = 2;
 var SNAKE_MAX_LENGTH = 30; // Win condition, slightly reduced for new board size