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

/**** 
* Classes
****/ 
var Fruit = Container.expand(function (type) {
	var self = Container.call(this);
	var assetName = 'apple';
	if (type === 'pear') assetName = 'pear';else if (type === 'banana') assetName = 'banana';else if (type === 'multicolor') assetName = 'multicolor';else if (type === 'coconut') assetName = 'coconut';
	var graphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.fruitType = type || 'apple';
	// Add gentle pulsing animation to all fruits
	self.animationCounter = 0;
	self.baseScale = 1.0;
	// Add color animation for multicolor fruit
	if (type === 'multicolor') {
		self.colorIndex = 0;
		self.colors = [0xff3333, 0x44dd44, 0x3366ff, 0xffdd44, 0xff44dd, 0x44ddff];
		self.update = function () {
			// Color cycling for multicolor fruit
			if (LK.ticks % 15 === 0) {
				self.colorIndex = (self.colorIndex + 1) % self.colors.length;
				graphics.tint = self.colors[self.colorIndex];
			}
			// Gentle pulsing animation
			self.animationCounter += 0.08;
			var pulseScale = self.baseScale + Math.sin(self.animationCounter) * 0.15;
			graphics.scaleX = pulseScale;
			graphics.scaleY = pulseScale;
		};
	} else {
		self.update = function () {
			// Gentle pulsing animation for regular fruits
			self.animationCounter += 0.06;
			var pulseScale = self.baseScale + Math.sin(self.animationCounter) * 0.1;
			graphics.scaleX = pulseScale;
			graphics.scaleY = pulseScale;
		};
	}
	return self;
});
var GrowthPoint = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('growthPoint', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add gentle pulsing animation
	self.animationCounter = 0;
	self.baseScale = 1.0;
	self.update = function () {
		// Gentle pulsing animation
		self.animationCounter += 0.1;
		var pulseScale = self.baseScale + Math.sin(self.animationCounter) * 0.2;
		graphics.scaleX = pulseScale;
		graphics.scaleY = pulseScale;
	};
	return self;
});
var LavaArea = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('lavaArea', {
		anchorX: 0,
		anchorY: 0
	});
	self.isWarning = true;
	self.warningTime = 5000; // 5 seconds warning
	self.startTime = Date.now();
	// Set initial warning appearance
	graphics.alpha = 0.3;
	graphics.tint = 0xffff00; // Yellow warning
	self.update = function () {
		var elapsed = Date.now() - self.startTime;
		if (self.isWarning && elapsed < self.warningTime) {
			// Slower, more intermittent blinking warning effect
			var blinkSpeed = 2; // Much slower blinking
			var blinkCycle = Math.sin(LK.ticks * blinkSpeed * 0.1);
			// More intermittent pattern - only blink when sine wave is positive
			if (blinkCycle > 0) {
				graphics.alpha = 0.3 + 0.4 * blinkCycle;
			} else {
				graphics.alpha = 0.1; // Very dim when not blinking
			}
		} else if (self.isWarning && elapsed >= self.warningTime) {
			// Convert to lava
			self.isWarning = false;
			graphics.alpha = 1.0;
			graphics.tint = 0xff4400; // Red lava
		}
	};
	return self;
});
var SnakeHead = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('snakeHead', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.thickness = 1;
	self.animationCounter = 0;
	self.baseThickness = 1;
	self.setThickness = function (newThickness) {
		self.thickness = newThickness;
		self.baseThickness = newThickness;
		graphics.scaleX = newThickness;
		graphics.scaleY = newThickness;
	};
	self.update = function () {
		// Subtle breathing animation for snake head
		self.animationCounter += 0.05;
		var breatheScale = self.baseThickness + Math.sin(self.animationCounter) * 0.05;
		graphics.scaleX = breatheScale;
		graphics.scaleY = breatheScale;
	};
	return self;
});
var SnakeSegment = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('snakeBody', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.thickness = 1;
	self.setThickness = function (newThickness) {
		self.thickness = newThickness;
		graphics.scaleX = newThickness;
		graphics.scaleY = newThickness;
	};
	return self;
});
var Spike = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('spike', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.speed = 3;
	// Set random direction
	var angle = Math.random() * Math.PI * 2;
	self.velocityX = Math.cos(angle) * self.speed;
	self.velocityY = Math.sin(angle) * self.speed;
	self.update = function () {
		// Move spike
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Bounce off walls
		if (self.x <= 30 || self.x >= GAME_WIDTH - 30) {
			self.velocityX = -self.velocityX;
			self.x = Math.max(30, Math.min(GAME_WIDTH - 30, self.x));
			LK.getSound('spike_bounce').play();
		}
		if (self.y <= 30 || self.y >= GAME_HEIGHT - 30) {
			self.velocityY = -self.velocityY;
			self.y = Math.max(30, Math.min(GAME_HEIGHT - 30, self.y));
			LK.getSound('spike_bounce').play();
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var GRID_SIZE = 40;
var GAME_WIDTH = 2048;
var GAME_HEIGHT = 2732;
var COLS = Math.floor(GAME_WIDTH / GRID_SIZE);
var ROWS = Math.floor(GAME_HEIGHT / GRID_SIZE);
// Snake variables
var snake = [];
var snakeDirection = {
	x: 1,
	y: 0
};
var nextDirection = {
	x: 1,
	y: 0
};
var snakeSpeed = 8;
var moveCounter = 0;
var snakeThickness = 1;
// Fruit variables
var currentFruit = null;
var fruits = [];
// Growth points variables
var growthPoints = [];
var coconutPowerActive = false;
var coconutPowerEndTime = 0;
var lastGrowthPointSpawn = 0;
// Game state
var gameRunning = true;
var touchStartX = 0;
var touchStartY = 0;
// Autopilot variables
var autoPilotActive = false;
var autoPilotEndTime = 0;
var countdownText = null;
// Event system variables
var lastEventTime = 0;
var eventInterval = 30000; // 30 seconds
var activeSpikes = [];
var activeLavaAreas = [];
// Score display
var scoreTxt = new Text2('Score: 0', {
	size: 60,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0, 0);
scoreTxt.x = 120;
scoreTxt.y = 20;
LK.gui.topLeft.addChild(scoreTxt);
// Power-up display
var powerTxt = new Text2('Speed: 1x | Thickness: 1x', {
	size: 40,
	fill: 0xFFFF00
});
powerTxt.anchor.set(1, 0);
powerTxt.x = -20;
powerTxt.y = 20;
LK.gui.topRight.addChild(powerTxt);
// Create walls
var topWall = game.addChild(LK.getAsset('wall', {
	x: 0,
	y: 0,
	width: GAME_WIDTH,
	height: 20
}));
var bottomWall = game.addChild(LK.getAsset('wall', {
	x: 0,
	y: GAME_HEIGHT - 20,
	width: GAME_WIDTH,
	height: 20
}));
var leftWall = game.addChild(LK.getAsset('wall', {
	x: 0,
	y: 0,
	width: 20,
	height: GAME_HEIGHT
}));
var rightWall = game.addChild(LK.getAsset('wall', {
	x: GAME_WIDTH - 20,
	y: 0,
	width: 20,
	height: GAME_HEIGHT
}));
// Initialize snake
function initSnake() {
	// Create initial snake with 3 segments
	var startX = Math.floor(COLS / 4);
	var startY = Math.floor(ROWS / 2);
	for (var i = 0; i < 3; i++) {
		var segment;
		if (i === 0) {
			segment = new SnakeHead();
		} else {
			segment = new SnakeSegment();
		}
		segment.gridX = startX - i;
		segment.gridY = startY;
		segment.x = segment.gridX * GRID_SIZE + GRID_SIZE / 2;
		segment.y = segment.gridY * GRID_SIZE + GRID_SIZE / 2;
		snake.push(segment);
		game.addChild(segment);
	}
}
// Spawn growth point
function spawnGrowthPoint() {
	// Only spawn if no growth points exist OR coconut power is active
	if (growthPoints.length > 0 && !coconutPowerActive) {
		return;
	}
	var validPosition = false;
	var gridX, gridY;
	while (!validPosition) {
		gridX = Math.floor(Math.random() * (COLS - 4)) + 2;
		gridY = Math.floor(Math.random() * (ROWS - 4)) + 2;
		validPosition = true;
		// Check snake collision
		for (var i = 0; i < snake.length; i++) {
			if (snake[i].gridX === gridX && snake[i].gridY === gridY) {
				validPosition = false;
				break;
			}
		}
		// Check fruit collision
		if (currentFruit && currentFruit.gridX === gridX && currentFruit.gridY === gridY) {
			validPosition = false;
		}
		// Check other growth points collision
		for (var i = 0; i < growthPoints.length; i++) {
			if (growthPoints[i].gridX === gridX && growthPoints[i].gridY === gridY) {
				validPosition = false;
				break;
			}
		}
		// Avoid lava areas
		var worldX = gridX * GRID_SIZE + GRID_SIZE / 2;
		var worldY = gridY * GRID_SIZE + GRID_SIZE / 2;
		for (var l = 0; l < activeLavaAreas.length; l++) {
			var lavaArea = activeLavaAreas[l];
			if (worldX >= lavaArea.x && worldX <= lavaArea.x + 1024 && worldY >= lavaArea.y && worldY <= lavaArea.y + 1366) {
				validPosition = false;
				break;
			}
		}
	}
	var growthPoint = new GrowthPoint();
	growthPoint.gridX = gridX;
	growthPoint.gridY = gridY;
	growthPoint.x = gridX * GRID_SIZE + GRID_SIZE / 2;
	growthPoint.y = gridY * GRID_SIZE + GRID_SIZE / 2;
	growthPoints.push(growthPoint);
	game.addChild(growthPoint);
}
// Spawn fruit
function spawnFruit() {
	if (currentFruit) {
		currentFruit.destroy();
		currentFruit = null;
	}
	var fruitTypes = ['apple', 'pear', 'banana', 'multicolor', 'coconut'];
	var randomType = fruitTypes[Math.floor(Math.random() * fruitTypes.length)];
	var validPosition = false;
	var gridX, gridY;
	while (!validPosition) {
		gridX = Math.floor(Math.random() * (COLS - 4)) + 2;
		gridY = Math.floor(Math.random() * (ROWS - 4)) + 2;
		validPosition = true;
		for (var i = 0; i < snake.length; i++) {
			if (snake[i].gridX === gridX && snake[i].gridY === gridY) {
				validPosition = false;
				break;
			}
		}
		// Avoid lava areas
		var worldX = gridX * GRID_SIZE + GRID_SIZE / 2;
		var worldY = gridY * GRID_SIZE + GRID_SIZE / 2;
		for (var l = 0; l < activeLavaAreas.length; l++) {
			var lavaArea = activeLavaAreas[l];
			if (worldX >= lavaArea.x && worldX <= lavaArea.x + 1024 && worldY >= lavaArea.y && worldY <= lavaArea.y + 1366) {
				validPosition = false;
				break;
			}
		}
	}
	currentFruit = new Fruit(randomType);
	currentFruit.gridX = gridX;
	currentFruit.gridY = gridY;
	currentFruit.x = gridX * GRID_SIZE + GRID_SIZE / 2;
	currentFruit.y = gridY * GRID_SIZE + GRID_SIZE / 2;
	game.addChild(currentFruit);
}
// Move snake
function moveSnake() {
	if (!gameRunning) return;
	var head = snake[0];
	// Autopilot logic
	if (autoPilotActive && currentFruit) {
		// Function to check if a position is safe
		var isSafePosition = function isSafePosition(gridX, gridY) {
			// Check walls
			if (gridX <= 0 || gridX >= COLS - 1 || gridY <= 0 || gridY >= ROWS - 1) {
				return false;
			}
			// Check snake body collision
			for (var i = 1; i < snake.length; i++) {
				if (snake[i].gridX === gridX && snake[i].gridY === gridY) {
					return false;
				}
			}
			// In autopilot mode, avoid spikes and lava areas
			if (autoPilotActive) {
				var worldX = gridX * GRID_SIZE + GRID_SIZE / 2;
				var worldY = gridY * GRID_SIZE + GRID_SIZE / 2;
				// Check spike collisions
				for (var s = 0; s < activeSpikes.length; s++) {
					var spike = activeSpikes[s];
					var spikeDistance = Math.sqrt(Math.pow(spike.x - worldX, 2) + Math.pow(spike.y - worldY, 2));
					if (spikeDistance < 100) {
						// Give extra buffer for autopilot
						return false;
					}
				}
				// Check lava area collisions
				for (var l = 0; l < activeLavaAreas.length; l++) {
					var lavaArea = activeLavaAreas[l];
					if (!lavaArea.isWarning) {
						// Only avoid active lava
						if (worldX >= lavaArea.x - 40 && worldX <= lavaArea.x + 1024 + 40 && worldY >= lavaArea.y - 40 && worldY <= lavaArea.y + 1366 + 40) {
							return false;
						}
					}
				}
			}
			return true;
		};
		var deltaX = currentFruit.gridX - head.gridX;
		var deltaY = currentFruit.gridY - head.gridY;
		var possibleDirections = [];
		var currentDirection = snakeDirection;
		// Calculate potential moves towards fruit
		if (Math.abs(deltaX) > Math.abs(deltaY)) {
			// Prioritize horizontal movement
			if (deltaX > 0) {
				possibleDirections.push({
					x: 1,
					y: 0
				}); // Right
			} else if (deltaX < 0) {
				possibleDirections.push({
					x: -1,
					y: 0
				}); // Left
			}
			// Add vertical as backup
			if (deltaY > 0) {
				possibleDirections.push({
					x: 0,
					y: 1
				}); // Down
			} else if (deltaY < 0) {
				possibleDirections.push({
					x: 0,
					y: -1
				}); // Up
			}
		} else {
			// Prioritize vertical movement
			if (deltaY > 0) {
				possibleDirections.push({
					x: 0,
					y: 1
				}); // Down
			} else if (deltaY < 0) {
				possibleDirections.push({
					x: 0,
					y: -1
				}); // Up
			}
			// Add horizontal as backup
			if (deltaX > 0) {
				possibleDirections.push({
					x: 1,
					y: 0
				}); // Right
			} else if (deltaX < 0) {
				possibleDirections.push({
					x: -1,
					y: 0
				}); // Left
			}
		}
		// Add remaining directions as last resort
		var allDirections = [{
			x: 1,
			y: 0
		}, {
			x: -1,
			y: 0
		}, {
			x: 0,
			y: 1
		}, {
			x: 0,
			y: -1
		}];
		for (var i = 0; i < allDirections.length; i++) {
			var dir = allDirections[i];
			var found = false;
			for (var j = 0; j < possibleDirections.length; j++) {
				if (possibleDirections[j].x === dir.x && possibleDirections[j].y === dir.y) {
					found = true;
					break;
				}
			}
			if (!found) {
				possibleDirections.push(dir);
			}
		}
		// Find first safe direction
		var newDirection = currentDirection;
		for (var i = 0; i < possibleDirections.length; i++) {
			var testDir = possibleDirections[i];
			// Don't reverse direction
			if (testDir.x === -currentDirection.x && testDir.y === -currentDirection.y) {
				continue;
			}
			var testX = head.gridX + testDir.x;
			var testY = head.gridY + testDir.y;
			if (isSafePosition(testX, testY)) {
				newDirection = testDir;
				break;
			}
		}
		snakeDirection = newDirection;
		nextDirection = snakeDirection;
	}
	var newGridX = head.gridX + snakeDirection.x;
	var newGridY = head.gridY + snakeDirection.y;
	// Check wall collision
	if (newGridX <= 0 || newGridX >= COLS - 1 || newGridY <= 0 || newGridY >= ROWS - 1) {
		gameOver();
		return;
	}
	// Check self collision
	for (var i = 0; i < snake.length; i++) {
		if (snake[i].gridX === newGridX && snake[i].gridY === newGridY) {
			gameOver();
			return;
		}
	}
	// Check fruit collision
	var ateFood = false;
	if (currentFruit && currentFruit.gridX === newGridX && currentFruit.gridY === newGridY) {
		ateFood = true;
		handleFruitEaten(currentFruit.fruitType);
	}
	// Check growth point collision
	for (var i = growthPoints.length - 1; i >= 0; i--) {
		var growthPoint = growthPoints[i];
		if (growthPoint.gridX === newGridX && growthPoint.gridY === newGridY) {
			ateFood = true;
			LK.getSound('eat').play();
			LK.setScore(LK.getScore() + 1);
			scoreTxt.setText('Score: ' + LK.getScore());
			growthPoint.destroy();
			growthPoints.splice(i, 1);
			break;
		}
	}
	// Move snake
	var newHead = new SnakeHead();
	newHead.gridX = newGridX;
	newHead.gridY = newGridY;
	newHead.x = newGridX * GRID_SIZE + GRID_SIZE / 2;
	newHead.y = newGridY * GRID_SIZE + GRID_SIZE / 2;
	newHead.setThickness(snakeThickness);
	// Convert old head to body
	var oldHead = snake[0];
	oldHead.destroy();
	var newBody = new SnakeSegment();
	newBody.gridX = oldHead.gridX;
	newBody.gridY = oldHead.gridY;
	newBody.x = oldHead.x;
	newBody.y = oldHead.y;
	newBody.setThickness(snakeThickness);
	game.addChild(newBody);
	snake[0] = newBody;
	// Add new head
	snake.unshift(newHead);
	game.addChild(newHead);
	if (!ateFood) {
		// Remove tail
		var tail = snake.pop();
		tail.destroy();
	}
	// Update thickness for all segments
	for (var i = 0; i < snake.length; i++) {
		snake[i].setThickness(snakeThickness);
	}
}
// Handle fruit eaten
function handleFruitEaten(fruitType) {
	LK.getSound('eat').play();
	if (fruitType === 'apple') {
		LK.setScore(LK.getScore() + 3);
		LK.getSound('powerup').play();
	} else if (fruitType === 'pear') {
		snakeThickness += 0.2;
		LK.setScore(LK.getScore() + 1);
		LK.getSound('powerup').play();
	} else if (fruitType === 'banana') {
		snakeSpeed += 1;
		LK.setScore(LK.getScore() + 1);
		LK.getSound('powerup').play();
	} else if (fruitType === 'multicolor') {
		// Activate autopilot for 10 seconds
		autoPilotActive = true;
		autoPilotEndTime = Date.now() + 10000;
		LK.setScore(LK.getScore() + 5);
		LK.getSound('powerup').play();
		// Clean up any existing countdown
		if (countdownText) {
			countdownText.destroy();
			countdownText = null;
		}
		// Show autopilot activation feedback
		LK.effects.flashScreen(0x00ff00, 500);
	} else if (fruitType === 'coconut') {
		// Activate coconut power for 10 seconds - allows multiple growth points
		coconutPowerActive = true;
		coconutPowerEndTime = Date.now() + 10000;
		lastGrowthPointSpawn = Date.now();
		LK.setScore(LK.getScore() + 2);
		LK.getSound('powerup').play();
		// Show coconut power activation feedback
		LK.effects.flashScreen(0xffffff, 500);
	}
	scoreTxt.setText('Score: ' + LK.getScore());
	powerTxt.setText('Speed: ' + snakeSpeed + 'x | Thickness: ' + Math.round(snakeThickness * 10) / 10 + 'x');
	currentFruit.destroy();
	currentFruit = null;
	spawnFruit();
}
// Spawn random event
function spawnEvent() {
	var eventType = Math.random() < 0.5 ? 'spike' : 'lava';
	if (eventType === 'spike') {
		// Spawn bouncing spike
		var spike = new Spike();
		spike.x = Math.random() * (GAME_WIDTH - 100) + 50;
		spike.y = Math.random() * (GAME_HEIGHT - 100) + 50;
		activeSpikes.push(spike);
		game.addChild(spike);
	} else {
		// Spawn lava area in one quarter of the screen
		var lavaArea = new LavaArea();
		var quarter = Math.floor(Math.random() * 4);
		switch (quarter) {
			case 0:
				// Top-left
				lavaArea.x = 20;
				lavaArea.y = 20;
				break;
			case 1:
				// Top-right
				lavaArea.x = GAME_WIDTH / 2;
				lavaArea.y = 20;
				break;
			case 2:
				// Bottom-left
				lavaArea.x = 20;
				lavaArea.y = GAME_HEIGHT / 2;
				break;
			case 3:
				// Bottom-right
				lavaArea.x = GAME_WIDTH / 2;
				lavaArea.y = GAME_HEIGHT / 2;
				break;
		}
		activeLavaAreas.push(lavaArea);
		game.addChild(lavaArea);
		LK.getSound('lava_warning').play();
	}
}
// Game over
function gameOver() {
	gameRunning = false;
	LK.showGameOver();
}
// Touch controls
game.down = function (x, y, obj) {
	touchStartX = x;
	touchStartY = y;
};
game.up = function (x, y, obj) {
	if (!gameRunning) return;
	var deltaX = x - touchStartX;
	var deltaY = y - touchStartY;
	var minSwipeDistance = 50;
	if (Math.abs(deltaX) > minSwipeDistance || Math.abs(deltaY) > minSwipeDistance) {
		if (Math.abs(deltaX) > Math.abs(deltaY)) {
			// Horizontal swipe
			if (deltaX > 0 && snakeDirection.x !== -1) {
				nextDirection = {
					x: 1,
					y: 0
				}; // Right
			} else if (deltaX < 0 && snakeDirection.x !== 1) {
				nextDirection = {
					x: -1,
					y: 0
				}; // Left
			}
		} else {
			// Vertical swipe
			if (deltaY > 0 && snakeDirection.y !== -1) {
				nextDirection = {
					x: 0,
					y: 1
				}; // Down
			} else if (deltaY < 0 && snakeDirection.y !== 1) {
				nextDirection = {
					x: 0,
					y: -1
				}; // Up
			}
		}
	}
};
// Initialize game
initSnake();
spawnFruit();
// Spawn initial growth points
for (var i = 0; i < 3; i++) {
	spawnGrowthPoint();
}
// Main game loop
game.update = function () {
	if (!gameRunning) return;
	moveCounter++;
	// Handle autopilot countdown
	if (autoPilotActive) {
		var timeLeft = autoPilotEndTime - Date.now();
		if (timeLeft <= 0) {
			autoPilotActive = false;
			if (countdownText) {
				countdownText.destroy();
				countdownText = null;
			}
		} else if (timeLeft <= 3000 && !countdownText) {
			// Show countdown when 3 seconds left
			countdownText = new Text2('3', {
				size: 120,
				fill: 0xFF0000
			});
			countdownText.anchor.set(0.5, 0.5);
			LK.gui.center.addChild(countdownText);
		}
		// Update countdown text
		if (countdownText) {
			var secondsLeft = Math.ceil(timeLeft / 1000);
			if (secondsLeft > 0) {
				countdownText.setText(secondsLeft.toString());
				// Animate countdown
				tween(countdownText, {
					scaleX: 1.2,
					scaleY: 1.2
				}, {
					duration: 200,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						if (countdownText) {
							tween(countdownText, {
								scaleX: 1,
								scaleY: 1
							}, {
								duration: 200,
								easing: tween.easeIn
							});
						}
					}
				});
			} else {
				countdownText.destroy();
				countdownText = null;
			}
		}
	}
	// Update direction (only if not in autopilot)
	if (!autoPilotActive) {
		snakeDirection = nextDirection;
	}
	// Event spawning timer
	var currentTime = Date.now();
	if (currentTime - lastEventTime >= eventInterval) {
		lastEventTime = currentTime;
		spawnEvent();
	}
	// Check spike collisions with snake (skip during autopilot)
	if (!autoPilotActive) {
		for (var i = activeSpikes.length - 1; i >= 0; i--) {
			var spike = activeSpikes[i];
			var head = snake[0];
			// Check collision with snake head
			var distance = Math.sqrt(Math.pow(spike.x - head.x, 2) + Math.pow(spike.y - head.y, 2));
			if (distance < 60) {
				// Increased collision area for larger spike
				gameOver();
				return;
			}
		}
	}
	// Check lava area collisions with snake (skip during autopilot)
	if (!autoPilotActive) {
		for (var i = activeLavaAreas.length - 1; i >= 0; i--) {
			var lavaArea = activeLavaAreas[i];
			// Only check collision if lava is active (not warning)
			if (!lavaArea.isWarning) {
				var head = snake[0];
				// Check if snake head is inside lava area (larger quarter-screen area)
				if (head.x >= lavaArea.x && head.x <= lavaArea.x + 1024 && head.y >= lavaArea.y && head.y <= lavaArea.y + 1366) {
					gameOver();
					return;
				}
			}
		}
	}
	// Clean up old events (remove them after next event spawns)
	if (activeSpikes.length > 1) {
		var oldSpike = activeSpikes.shift();
		oldSpike.destroy();
	}
	if (activeLavaAreas.length > 1) {
		var oldLava = activeLavaAreas.shift();
		oldLava.destroy();
	}
	// Handle coconut power and growth point spawning
	var currentTime = Date.now();
	if (coconutPowerActive) {
		// Check if coconut power has expired
		if (currentTime >= coconutPowerEndTime) {
			coconutPowerActive = false;
		}
		// Spawn growth points every 2.5 seconds during coconut power
		if (currentTime - lastGrowthPointSpawn >= 2500) {
			spawnGrowthPoint();
			lastGrowthPointSpawn = currentTime;
		}
	} else {
		// Normal mode: spawn growth point only if none exist
		if (growthPoints.length === 0) {
			spawnGrowthPoint();
		}
	}
	// Move snake based on speed
	var moveInterval = Math.max(3, 15 - snakeSpeed);
	if (moveCounter >= moveInterval) {
		moveCounter = 0;
		moveSnake();
	}
};

===================================================================
--- original.js
+++ change.js
@@ -8,9 +8,9 @@
 ****/ 
 var Fruit = Container.expand(function (type) {
 	var self = Container.call(this);
 	var assetName = 'apple';
-	if (type === 'pear') assetName = 'pear';else if (type === 'banana') assetName = 'banana';else if (type === 'multicolor') assetName = 'multicolor';
+	if (type === 'pear') assetName = 'pear';else if (type === 'banana') assetName = 'banana';else if (type === 'multicolor') assetName = 'multicolor';else if (type === 'coconut') assetName = 'coconut';
 	var graphics = self.attachAsset(assetName, {
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
@@ -198,8 +198,11 @@
 var currentFruit = null;
 var fruits = [];
 // Growth points variables
 var growthPoints = [];
+var coconutPowerActive = false;
+var coconutPowerEndTime = 0;
+var lastGrowthPointSpawn = 0;
 // Game state
 var gameRunning = true;
 var touchStartX = 0;
 var touchStartY = 0;
@@ -276,8 +279,12 @@
 	}
 }
 // Spawn growth point
 function spawnGrowthPoint() {
+	// Only spawn if no growth points exist OR coconut power is active
+	if (growthPoints.length > 0 && !coconutPowerActive) {
+		return;
+	}
 	var validPosition = false;
 	var gridX, gridY;
 	while (!validPosition) {
 		gridX = Math.floor(Math.random() * (COLS - 4)) + 2;
@@ -325,9 +332,9 @@
 	if (currentFruit) {
 		currentFruit.destroy();
 		currentFruit = null;
 	}
-	var fruitTypes = ['apple', 'pear', 'banana', 'multicolor'];
+	var fruitTypes = ['apple', 'pear', 'banana', 'multicolor', 'coconut'];
 	var randomType = fruitTypes[Math.floor(Math.random() * fruitTypes.length)];
 	var validPosition = false;
 	var gridX, gridY;
 	while (!validPosition) {
@@ -593,8 +600,17 @@
 			countdownText = null;
 		}
 		// Show autopilot activation feedback
 		LK.effects.flashScreen(0x00ff00, 500);
+	} else if (fruitType === 'coconut') {
+		// Activate coconut power for 10 seconds - allows multiple growth points
+		coconutPowerActive = true;
+		coconutPowerEndTime = Date.now() + 10000;
+		lastGrowthPointSpawn = Date.now();
+		LK.setScore(LK.getScore() + 2);
+		LK.getSound('powerup').play();
+		// Show coconut power activation feedback
+		LK.effects.flashScreen(0xffffff, 500);
 	}
 	scoreTxt.setText('Score: ' + LK.getScore());
 	powerTxt.setText('Speed: ' + snakeSpeed + 'x | Thickness: ' + Math.round(snakeThickness * 10) / 10 + 'x');
 	currentFruit.destroy();
@@ -793,11 +809,25 @@
 	if (activeLavaAreas.length > 1) {
 		var oldLava = activeLavaAreas.shift();
 		oldLava.destroy();
 	}
-	// Spawn growth points periodically (every 5 seconds)
-	if (LK.ticks % 300 === 0 && growthPoints.length < 5) {
-		spawnGrowthPoint();
+	// Handle coconut power and growth point spawning
+	var currentTime = Date.now();
+	if (coconutPowerActive) {
+		// Check if coconut power has expired
+		if (currentTime >= coconutPowerEndTime) {
+			coconutPowerActive = false;
+		}
+		// Spawn growth points every 2.5 seconds during coconut power
+		if (currentTime - lastGrowthPointSpawn >= 2500) {
+			spawnGrowthPoint();
+			lastGrowthPointSpawn = currentTime;
+		}
+	} else {
+		// Normal mode: spawn growth point only if none exist
+		if (growthPoints.length === 0) {
+			spawnGrowthPoint();
+		}
 	}
 	// Move snake based on speed
 	var moveInterval = Math.max(3, 15 - snakeSpeed);
 	if (moveCounter >= moveInterval) {