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

/**** 
* Classes
****/ 
// AI Robot: Simple animated character that moves left and right
var AIRobot = Container.expand(function () {
	var self = Container.call(this);
	// Attach a robot body (use aiIndicator image as the robot's head/body)
	var robotBody = self.attachAsset('aiIndicator', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add two "eyes" using small ellipses
	var leftEye = self.attachAsset('freeSpace', {
		width: 24,
		height: 24,
		color: 0xffffff,
		anchorX: 0.5,
		anchorY: 0.5
	});
	var rightEye = self.attachAsset('freeSpace', {
		width: 24,
		height: 24,
		color: 0xffffff,
		anchorX: 0.5,
		anchorY: 0.5
	});
	leftEye.x = -36;
	leftEye.y = -20;
	rightEye.x = 36;
	rightEye.y = -20;
	// Animation state
	self.direction = 1; // 1: right, -1: left
	self.speed = 6 + Math.random() * 4; // px per frame
	self.minX = 200;
	self.maxX = 2048 - 200;
	// For eye animation
	self.eyeTick = 0;
	// Initial position
	self.x = 2048 * 3 / 4;
	self.y = 2732 - 180;
	// Update method for movement and eye animation
	self.update = function () {
		// Move left/right
		self.x += self.direction * self.speed;
		if (self.x > self.maxX) {
			self.x = self.maxX;
			self.direction = -1;
		}
		if (self.x < self.minX) {
			self.x = self.minX;
			self.direction = 1;
		}
		// Animate eyes (look in direction of movement)
		self.eyeTick++;
		var eyeOffset = 4 * self.direction + Math.sin(self.eyeTick / 10) * 2;
		leftEye.x = -36 + eyeOffset;
		rightEye.x = 36 + eyeOffset;
	};
	return self;
});
// BingoCell: Represents a single cell on the bingo card
var BingoCell = Container.expand(function () {
	var self = Container.call(this);
	// Properties
	self.number = 0;
	self.marked = false;
	// Create cell background
	var cellBg = self.attachAsset('bingoCellBg', {
		width: cellSize,
		height: cellSize,
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Number text
	var numberText = new Text2('', {
		size: Math.floor(cellSize * 0.45),
		fill: 0xffffff
	});
	numberText.anchor.set(0.5, 0.5);
	self.addChild(numberText);
	// Mark overlay (hidden by default)
	var markOverlay = self.attachAsset('bingoMark', {
		width: cellSize * 0.7,
		height: cellSize * 0.7,
		anchorX: 0.5,
		anchorY: 0.5
	});
	markOverlay.alpha = 0;
	self.markOverlay = markOverlay;
	// Set number and update text
	self.setNumber = function (num) {
		self.number = num;
		numberText.setText(num > 0 ? num : '');
	};
	// Mark/unmark cell
	self.setMarked = function (val) {
		self.marked = val;
		if (val) {
			tween(markOverlay, {
				alpha: 0.8
			}, {
				duration: 200,
				easing: tween.easeOut
			});
			numberText.setText(self.number);
			numberText.setStyle({
				fill: 0x000000
			});
		} else {
			tween(markOverlay, {
				alpha: 0
			}, {
				duration: 200,
				easing: tween.easeOut
			});
			numberText.setStyle({
				fill: 0xffffff
			});
		}
	};
	// Touch event
	self.down = function (x, y, obj) {
		// Play click sound on any cell tap
		LK.getSound('Click').play();
		if (self.marked) return;
		if (game.state !== 'playing') return;
		var p = self.playerIndex !== undefined ? self.playerIndex : 0;
		if (self.number === game.currentNumber && p === currentPlayer) {
			self.setMarked(true);
			LK.effects.flashObject(self, 0xff6600, 200);
			// Streak logic
			if (typeof streak !== "undefined") {
				streak[p]++;
				streakText[p].setText("Streak: " + streak[p]);
				if (streak[p] > 1) {
					// Bonus: add 1s per streak above 1
					timeLeft[p] += 1000;
					tween(streakText[p], {
						scaleX: 1.3,
						scaleY: 1.3
					}, {
						duration: 100,
						yoyo: true,
						repeat: 1,
						easing: tween.easeOut
					});
				}
			}
			game.checkWin();
		} else {
			if (typeof streak !== "undefined") {
				streak[p] = 0;
				streakText[p].setText("");
			}
			LK.effects.flashObject(self, 0x8b0000, 200);
		}
	};
	// Example: Trigger action when cell crosses X = 1000 from left to right
	if (self.lastX !== undefined && self.lastX <= 1000 && self.x > 1000) {
		// Place your action here, e.g. console.log("Cell crossed X=1000!");
	}
	// Always update lastX at the end
	self.lastX = self.x;
	// Example: Trigger action when cell crosses Y = 800 from above to below
	if (self.lastY !== undefined && self.lastY <= 800 && self.y > 800) {
		// Place your action here, e.g. console.log("Cell crossed Y=800!");
	}
	// Always update lastY at the end
	self.lastY = self.y;
	// Example: Trigger action when cell crosses X=1000 and Y=800 at the same frame
	if (self.lastY !== undefined && self.lastY <= 800 && self.y > 800 && self.lastX !== undefined && self.lastX <= 1000 && self.x > 1000) {
		// Place your action here, e.g. console.log("Cell arrived at (1000,800)!");
	}
	// Always update lastX and lastY at the end
	self.lastX = self.x;
	self.lastY = self.y;
	return self;
});
// CalledNumberBall: Shows a called number as a round ball
var CalledNumberBall = Container.expand(function () {
	var self = Container.call(this);
	// Ball background
	var ball = self.attachAsset('bingoBall', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Number text
	var numberText = new Text2('', {
		size: 60,
		fill: 0x000000
	});
	numberText.anchor.set(0.5, 0.5);
	numberText.x = 0;
	numberText.y = 0;
	self.addChild(numberText);
	self.setNumber = function (num) {
		numberText.setText(num);
	};
	return self;
});
// MazeMode: Simple maze mini-game overlay
var MazeMode = Container.expand(function () {
	var self = Container.call(this);
	// Maze config
	var mazeCols = 7;
	var mazeRows = 9;
	var cellW = Math.floor(2048 / mazeCols);
	var cellH = Math.floor(1800 / mazeRows);
	var offsetX = Math.floor((2048 - mazeCols * cellW) / 2);
	var offsetY = 400;
	// Maze grid: 0 = open, 1 = wall
	self.grid = [];
	// Generate a simple random maze (DFS backtracker)
	function generateMaze(cols, rows) {
		var grid = [];
		for (var y = 0; y < rows; y++) {
			var row = [];
			for (var x = 0; x < cols; x++) row.push(1);
			grid.push(row);
		}
		function carve(x, y) {
			grid[y][x] = 0;
			var dirs = [[0, 1], [1, 0], [0, -1], [-1, 0]];
			for (var i = 0; i < 4; i++) {
				var j = Math.floor(Math.random() * 4);
				var tmp = dirs[i];
				dirs[i] = dirs[j];
				dirs[j] = tmp;
			}
			for (var d = 0; d < 4; d++) {
				var nx = x + dirs[d][0] * 2,
					ny = y + dirs[d][1] * 2;
				if (nx >= 0 && nx < cols && ny >= 0 && ny < rows && grid[ny][nx] === 1) {
					grid[y + dirs[d][1]][x + dirs[d][0]] = 0;
					carve(nx, ny);
				}
			}
		}
		carve(1, 1);
		grid[1][1] = 0; // Start
		grid[rows - 2][cols - 2] = 0; // End
		return grid;
	}
	self.grid = generateMaze(mazeCols, mazeRows);
	// Draw maze
	self.cells = [];
	for (var y = 0; y < mazeRows; y++) {
		for (var x = 0; x < mazeCols; x++) {
			if (self.grid[y][x] === 1) {
				var wall = LK.getAsset('calledNumbersBg', {
					width: cellW - 8,
					height: cellH - 8,
					anchorX: 0,
					anchorY: 0,
					x: offsetX + x * cellW + 4,
					y: offsetY + y * cellH + 4
				});
				self.addChild(wall);
				self.cells.push(wall);
			}
		}
	}
	// Start and end
	var startX = 1,
		startY = 1;
	var endX = mazeCols - 2,
		endY = mazeRows - 2;
	var startCell = LK.getAsset('freeSpace', {
		width: cellW - 12,
		height: cellH - 12,
		anchorX: 0,
		anchorY: 0,
		x: offsetX + startX * cellW + 6,
		y: offsetY + startY * cellH + 6
	});
	startCell.alpha = 0.7;
	self.addChild(startCell);
	var endCell = LK.getAsset('winHighlight', {
		width: cellW - 12,
		height: cellH - 12,
		anchorX: 0,
		anchorY: 0,
		x: offsetX + endX * cellW + 6,
		y: offsetY + endY * cellH + 6
	});
	endCell.alpha = 0.7;
	self.addChild(endCell);
	// Player
	self.playerX = startX;
	self.playerY = startY;
	self.player = LK.getAsset('aiIndicator', {
		width: cellW - 24,
		height: cellH - 24,
		anchorX: 0,
		anchorY: 0,
		x: offsetX + self.playerX * cellW + 12,
		y: offsetY + self.playerY * cellH + 12
	});
	self.addChild(self.player);
	// Touch controls: swipe or tap to move
	self.touchStartX = null;
	self.touchStartY = null;
	self.touching = false;
	// Helper: move player if possible
	self.tryMove = function (dx, dy) {
		var nx = self.playerX + dx,
			ny = self.playerY + dy;
		if (nx >= 0 && nx < mazeCols && ny >= 0 && ny < mazeRows) {
			if (self.grid[ny][nx] === 0) {
				self.playerX = nx;
				self.playerY = ny;
				self.player.x = offsetX + self.playerX * cellW + 12;
				self.player.y = offsetY + self.playerY * cellH + 12;
				// Win check
				if (self.playerX === endX && self.playerY === endY) {
					if (typeof self.onWin === "function") self.onWin();
				}
			} else {
				// Bump event: every time you try to move into a wall
				LK.effects.flashObject(self.player, 0xff0000, 150);
			}
		}
	};
	// Touch events
	self.down = function (x, y, obj) {
		self.touchStartX = x;
		self.touchStartY = y;
		self.touching = true;
	};
	self.up = function (x, y, obj) {
		if (!self.touching) return;
		var dx = x - self.touchStartX;
		var dy = y - self.touchStartY;
		if (Math.abs(dx) > Math.abs(dy)) {
			if (dx > 40) self.tryMove(1, 0);else if (dx < -40) self.tryMove(-1, 0);
		} else {
			if (dy > 40) self.tryMove(0, 1);else if (dy < -40) self.tryMove(0, -1);
		}
		self.touching = false;
	};
	// Also allow tap on adjacent cell
	self.move = function (x, y, obj) {};
	// Overlay text
	var mazeText = new Text2('Maze! Reach the yellow cell!', {
		size: 90,
		fill: 0xffd700
	});
	mazeText.anchor.set(0.5, 1);
	mazeText.x = 2048 / 2;
	mazeText.y = offsetY - 30;
	self.addChild(mazeText);
	// Win callback (set externally)
	self.onWin = null;
	return self;
});

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

/**** 
* Game Code
****/ 
// --- Added ses41 to ses75 sound assets (IDs to be filled by asset loader) ---
// Save the current game state (called numbers, card numbers, marked cells, time left, streaks)
// All bingo card and bingo cell logic removed as requested.
// Bingo ball (yellow ellipse)
// Bingo cell background (cyan box)
// Mark overlay (beige box, used for marking cells)
// Hint button background (green box, used for hint power-up)
// Free space overlay (distinct color for center cell)
// Win highlight overlay (gold ellipse for winning line)
// Reveal Row button removed
// Freeze Timer button and logic removed
// Ses assets for ses1 to ses40
var gridSize = 5; // 5x5 bingo
// Adjust cellSize and card positions for two-player mode to fit both cards on screen
var cellSize = 180; // px, reduced to fit two cards side by side
var cardPadding = 30;
var cardWidth = gridSize * cellSize;
var cardHeight = gridSize * cellSize;
var cardStartX = 2048 / 4 - cardWidth / 2; // Player 1 card center at 1/4 width, Player 2 at 3/4 width
var cardStartY = 500; // Lowered to fit both cards and UI
var callIntervalStart = 4000; // ms (4 seconds initial call speed)
var callIntervalMin = 1200; // ms (slower minimum speed)
var callIntervalStep = 60; // ms, decrease per call (slower speedup)
var gameDuration = 225000; // ms (3 min 45 sec)
var numbersRange = 75; // 1-75
// Remove all bingo logic and display random numbers on screen repeatedly
// Create a big number text in the center
var numberCallText = new Text2('', {
	size: 400,
	fill: 0xff073a
});
numberCallText.anchor.set(0.5, 0.5);
numberCallText.x = 2048 / 2;
numberCallText.y = 2732 / 2;
game.addChild(numberCallText);
// Add a warning text in the center, above the number
var warningText = new Text2('click, something will happen.', {
	size: 120,
	fill: 0xff0000
});
warningText.anchor.set(0.5, 1);
warningText.x = 2048 / 2;
warningText.y = 2732 / 2 - 260;
game.addChild(warningText);
// Function to show a random number and play its sound
function showRandomNumber() {
	var num = 1 + Math.floor(Math.random() * 75);
	numberCallText.setText(num);
	// Play ses1-ses75 sound if available
	var soundId = 'ses' + num;
	var sound = LK.getSound(soundId);
	if (sound) sound.play();
	// Animate the number
	numberCallText.scale.x = 0.7;
	numberCallText.scale.y = 0.7;
	tween(numberCallText.scale, {
		x: 1,
		y: 1
	}, {
		duration: 200,
		easing: tween.easeOut
	});
}
// Call a new number every 2 seconds
LK.setInterval(showRandomNumber, 2000);
// Show the first number immediately
showRandomNumber();
// --- Jump Scare Overlay and Logic --- 
var jumpScareOverlay = LK.getAsset('flashOverlay', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2,
	y: 2732 / 2,
	alpha: 0
});
game.addChild(jumpScareOverlay);
// Optionally, you can add a scary text
var jumpScareText = new Text2('!', {
	size: 600,
	fill: 0xff0000
});
jumpScareText.anchor.set(0.5, 0.5);
jumpScareText.x = 2048 / 2;
jumpScareText.y = 2732 / 2;
jumpScareText.alpha = 0;
game.addChild(jumpScareText);
function triggerJumpScare() {
	// Flash overlay and text in
	jumpScareOverlay.alpha = 0.92;
	jumpScareText.alpha = 1;
	// Animate out after 600ms
	LK.setTimeout(function () {
		tween(jumpScareOverlay, {
			alpha: 0
		}, {
			duration: 400,
			easing: tween.easeOut
		});
		tween(jumpScareText, {
			alpha: 0
		}, {
			duration: 400,
			easing: tween.easeOut
		});
	}, 600);
}
// --- Second Jump Scare Overlay (Question Mark) and Logic ---
var jumpScareOverlay2 = LK.getAsset('flashOverlay', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2,
	y: 2732 / 2,
	alpha: 0
});
game.addChild(jumpScareOverlay2);
var jumpScareText2 = new Text2('?', {
	size: 600,
	fill: 0x00aaff
});
jumpScareText2.anchor.set(0.5, 0.5);
jumpScareText2.x = 2048 / 2;
jumpScareText2.y = 2732 / 2;
jumpScareText2.alpha = 0;
game.addChild(jumpScareText2);
function triggerJumpScare2() {
	// Flash overlay and text in
	jumpScareOverlay2.alpha = 0.92;
	jumpScareText2.alpha = 1;
	// Animate out after 600ms
	LK.setTimeout(function () {
		tween(jumpScareOverlay2, {
			alpha: 0
		}, {
			duration: 400,
			easing: tween.easeOut
		});
		tween(jumpScareText2, {
			alpha: 0
		}, {
			duration: 400,
			easing: tween.easeOut
		});
	}, 600);
}
// Schedule the question mark jump scare every 3 seconds
LK.setInterval(triggerJumpScare2, 3000);
// Schedule both click sound and jump scare every 9 seconds, in sync
function triggerClickAndJumpScare() {
	// Play click sound
	var clickSound = LK.getSound('Click');
	if (clickSound) clickSound.play();
	// Trigger jump scare
	triggerJumpScare();
}
// Call every 9 seconds (9000 ms)
LK.setInterval(triggerClickAndJumpScare, 9000);
// Optionally, trigger immediately at start
triggerClickAndJumpScare();
// --- Random Event on Click: Zombie Attack, Door Close, Golden Zombie, Zombie ---
// Helper overlays and logic for events
var eventOverlay = LK.getAsset('flashOverlay', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2,
	y: 2732 / 2,
	alpha: 0
});
game.addChild(eventOverlay);
var eventText = new Text2('', {
	size: 400,
	fill: 0x00ff00
});
eventText.anchor.set(0.5, 0.5);
eventText.x = 2048 / 2;
eventText.y = 2732 / 2;
eventText.alpha = 0;
game.addChild(eventText);
// Golden zombie overlay
var goldenZombieOverlay = LK.getAsset('flashOverlay', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2,
	y: 2732 / 2,
	alpha: 0
});
game.addChild(goldenZombieOverlay);
var goldenZombieText = new Text2('GOLDEN ZOMBIE!', {
	size: 180,
	fill: 0xffd700
});
goldenZombieText.anchor.set(0.5, 0.5);
goldenZombieText.x = 2048 / 2;
goldenZombieText.y = 2732 / 2;
goldenZombieText.alpha = 0;
game.addChild(goldenZombieText);
// Golden zombie picture overlay
var goldenZombiePicOverlay = LK.getAsset('flashOverlay', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2,
	y: 2732 / 2,
	alpha: 0
});
game.addChild(goldenZombiePicOverlay);
// Use a placeholder image for golden zombie picture (replace with real asset id if available)
var goldenZombiePic = LK.getAsset('aiIndicator', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2,
	y: 2732 / 2,
	scaleX: 2.2,
	scaleY: 2.2,
	alpha: 0
});
game.addChild(goldenZombiePic);
// Zombie overlay
var zombieOverlay = LK.getAsset('flashOverlay', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2,
	y: 2732 / 2,
	alpha: 0
});
game.addChild(zombieOverlay);
var zombieText = new Text2('ZOMBIE!', {
	size: 220,
	fill: 0x00ff00
});
zombieText.anchor.set(0.5, 0.5);
zombieText.x = 2048 / 2;
zombieText.y = 2732 / 2;
zombieText.alpha = 0;
game.addChild(zombieText);
// Door close overlay
var doorOverlay = LK.getAsset('flashOverlay', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2,
	y: 2732 / 2,
	alpha: 0
});
game.addChild(doorOverlay);
var doorText = new Text2('DOOR CLOSES!', {
	size: 220,
	fill: 0x888888
});
doorText.anchor.set(0.5, 0.5);
doorText.x = 2048 / 2;
doorText.y = 2732 / 2;
doorText.alpha = 0;
game.addChild(doorText);
// Helper: show overlay + text, fade out after ms, then optional callback
function showEventOverlay(overlay, textObj, color, text, textColor, duration, cb) {
	overlay.alpha = 0.92;
	textObj.setText(text);
	textObj.fill = textColor;
	textObj.alpha = 1;
	LK.setTimeout(function () {
		tween(overlay, {
			alpha: 0
		}, {
			duration: 400,
			easing: tween.easeOut
		});
		tween(textObj, {
			alpha: 0
		}, {
			duration: 400,
			easing: tween.easeOut
		});
		if (cb) LK.setTimeout(cb, 400);
	}, duration);
}
// Helper: show golden zombie, then zombie
function showGoldenZombieThenZombie() {
	goldenZombieOverlay.alpha = 0.92;
	goldenZombieText.alpha = 1;
	LK.setTimeout(function () {
		tween(goldenZombieOverlay, {
			alpha: 0
		}, {
			duration: 400,
			easing: tween.easeOut
		});
		tween(goldenZombieText, {
			alpha: 0
		}, {
			duration: 400,
			easing: tween.easeOut
		});
		// After golden zombie, show zombie
		LK.setTimeout(function () {
			zombieOverlay.alpha = 0.92;
			zombieText.alpha = 1;
			LK.setTimeout(function () {
				tween(zombieOverlay, {
					alpha: 0
				}, {
					duration: 400,
					easing: tween.easeOut
				});
				tween(zombieText, {
					alpha: 0
				}, {
					duration: 400,
					easing: tween.easeOut
				});
			}, 700);
		}, 400);
	}, 900);
}
// Helper: show golden zombie picture, then zombie
function showGoldenZombiePicThenZombie() {
	goldenZombiePicOverlay.alpha = 0.92;
	goldenZombiePic.alpha = 1;
	LK.setTimeout(function () {
		tween(goldenZombiePicOverlay, {
			alpha: 0
		}, {
			duration: 400,
			easing: tween.easeOut
		});
		tween(goldenZombiePic, {
			alpha: 0
		}, {
			duration: 400,
			easing: tween.easeOut
		});
		// After golden zombie picture, show zombie
		LK.setTimeout(function () {
			zombieOverlay.alpha = 0.92;
			zombieText.alpha = 1;
			LK.setTimeout(function () {
				tween(zombieOverlay, {
					alpha: 0
				}, {
					duration: 400,
					easing: tween.easeOut
				});
				tween(zombieText, {
					alpha: 0
				}, {
					duration: 400,
					easing: tween.easeOut
				});
			}, 700);
		}, 400);
	}, 900);
}
// Main random event handler
var mazeActive = false;
var mazeInstance = null;
var pausedIntervals = [];
function pauseAllIntervals() {
	// Pause all intervals by clearing them and storing their ids
	if (typeof window !== "undefined") return; // Defensive: not in browser
	// Not needed in LK, as intervals are not global, but we can set a flag if needed
}
function resumeAllIntervals() {
	// No-op for now, as LK intervals are not globally tracked
}
function handleRandomEvent() {
	// 1 in 6 chance to trigger maze mode
	if (!mazeActive && Math.random() < 0.17) {
		mazeActive = true;
		// Hide main UI
		numberCallText.alpha = 0.1;
		warningText.alpha = 0.1;
		jumpScareOverlay.alpha = 0;
		jumpScareText.alpha = 0;
		jumpScareOverlay2.alpha = 0;
		jumpScareText2.alpha = 0;
		eventOverlay.alpha = 0;
		eventText.alpha = 0;
		goldenZombieOverlay.alpha = 0;
		goldenZombieText.alpha = 0;
		goldenZombiePicOverlay.alpha = 0;
		goldenZombiePic.alpha = 0;
		zombieOverlay.alpha = 0;
		zombieText.alpha = 0;
		doorOverlay.alpha = 0;
		doorText.alpha = 0;
		// Create maze instance
		mazeInstance = new MazeMode();
		mazeInstance.x = 0;
		mazeInstance.y = 0;
		mazeInstance.alpha = 1;
		game.addChild(mazeInstance);
		// Block main game input
		game.down = null;
		// Maze win callback
		mazeInstance.onWin = function () {
			// Remove maze, restore UI, resume game
			if (mazeInstance) {
				mazeInstance.destroy();
				mazeInstance = null;
			}
			numberCallText.alpha = 1;
			warningText.alpha = 1;
			mazeActive = false;
			// Restore click handler
			game.down = function (x, y, obj) {
				handleRandomEvent();
			};
		};
		// Forward touch events to maze
		game.down = function (x, y, obj) {
			if (mazeInstance && mazeInstance.down) mazeInstance.down(x, y, obj);
		};
		game.up = function (x, y, obj) {
			if (mazeInstance && mazeInstance.up) mazeInstance.up(x, y, obj);
		};
		game.move = function (x, y, obj) {
			if (mazeInstance && mazeInstance.move) mazeInstance.move(x, y, obj);
		};
		return;
	}
	var eventType = Math.floor(Math.random() * 5);
	if (eventType === 0) {
		// Zombie attack
		showEventOverlay(eventOverlay, eventText, 0x00ff00, 'ZOMBIE ATTACK!', 0x00ff00, 900);
	} else if (eventType === 1) {
		// Door closes, then game over
		showEventOverlay(doorOverlay, doorText, 0x888888, 'DOOR CLOSES!', 0x888888, 900, function () {
			LK.showGameOver();
		});
	} else if (eventType === 2) {
		// Golden zombie, then zombie
		showGoldenZombieThenZombie();
	} else if (eventType === 3) {
		// Golden zombie picture, then zombie
		showGoldenZombiePicThenZombie();
	} else {
		// Zombie
		showEventOverlay(zombieOverlay, zombieText, 0x00ff00, 'ZOMBIE!', 0x00ff00, 900);
	}
}
// Listen for click/tap on the game area
game.down = function (x, y, obj) {
	handleRandomEvent();
};
// --- Animated background color pulse for visual appeal ---
var bgPulseColors = [0x181a1b,
// near-black
0x23272a,
// dark gray
0x222326,
// blackish blue
0x181a1b,
// repeat for smooth loop
0x23272a]; // Blackish/dark palette
var bgPulseIndex = 0;
var bgPulseDuration = 3000;
function pulseBackground() {
	var fromColor = bgPulseColors[bgPulseIndex];
	var toColor = bgPulseColors[(bgPulseIndex + 1) % bgPulseColors.length];
	var t = {
		v: 0
	};
	tween(t, {
		v: 1
	}, {
		duration: bgPulseDuration,
		easing: tween.easeInOut,
		onUpdate: function onUpdate() {
			// Interpolate color
			var r1 = fromColor >> 16 & 0xff,
				g1 = fromColor >> 8 & 0xff,
				b1 = fromColor & 0xff;
			var r2 = toColor >> 16 & 0xff,
				g2 = toColor >> 8 & 0xff,
				b2 = toColor & 0xff;
			var r = Math.round(r1 + (r2 - r1) * t.v);
			var g = Math.round(g1 + (g2 - g1) * t.v);
			var b = Math.round(b1 + (b2 - b1) * t.v);
			var color = r << 16 | g << 8 | b;
			game.setBackgroundColor(color);
		},
		onComplete: function onComplete() {
			bgPulseIndex = (bgPulseIndex + 1) % bgPulseColors.length;
			pulseBackground();
		}
	});
}
pulseBackground();
// --- Golden Sign Event: Every 9-100 years, show golden sign with age message ---
// Helper: returns ms for N years (365.25 days per year)
function yearsToMs(years) {
	return Math.floor(years * 365.25 * 24 * 60 * 60 * 1000);
}
// Track game start time (ms)
var gameStartTime = Date.now();
// Golden sign overlay and text
var goldenSignOverlay = LK.getAsset('flashOverlay', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2,
	y: 2732 / 2,
	alpha: 0
});
game.addChild(goldenSignOverlay);
var goldenSignText = new Text2('', {
	size: 180,
	fill: 0xffd700
});
goldenSignText.anchor.set(0.5, 0.5);
goldenSignText.x = 2048 / 2;
goldenSignText.y = 2732 / 2;
goldenSignText.alpha = 0;
game.addChild(goldenSignText);
// Helper: show golden sign with message
function showGoldenSign(message) {
	goldenSignOverlay.alpha = 0.95;
	goldenSignText.setText(message);
	goldenSignText.fill = 0xffd700;
	goldenSignText.alpha = 1;
	LK.setTimeout(function () {
		tween(goldenSignOverlay, {
			alpha: 0
		}, {
			duration: 1200,
			easing: tween.easeOut
		});
		tween(goldenSignText, {
			alpha: 0
		}, {
			duration: 1200,
			easing: tween.easeOut
		});
	}, 2200);
}
// Helper: pick a random integer in [a, b]
function randInt(a, b) {
	return a + Math.floor(Math.random() * (b - a + 1));
}
// Schedule the first golden sign event
var nextGoldenSignYears = randInt(9, 10 + Math.floor(Math.random() * 91)); // 9-100 or 10-100 years
var nextGoldenSignTime = gameStartTime + yearsToMs(nextGoldenSignYears);
// Track how many golden sign events have occurred
var goldenSignEventCount = 0;
// Periodically check if it's time to show the golden sign
LK.setInterval(function () {
	var now = Date.now();
	if (now >= nextGoldenSignTime) {
		// Compute "age" for fun message
		var yearsElapsed = Math.floor((now - gameStartTime) / yearsToMs(1));
		var fakeAge = 600 + goldenSignEventCount * randInt(1, 100);
		showGoldenSign("How old are you now? You're probably " + fakeAge + "!");
		goldenSignEventCount++;
		// Schedule next event in 9-100 or 10-100 years
		var nextYears = randInt(9, 10 + Math.floor(Math.random() * 91));
		nextGoldenSignTime = now + yearsToMs(nextYears);
	}
}, 10000); // Check every 10 seconds (safe, since event is ultra-rare);
// --- World Clock Calendar in Top-Right Corner ---
// List of major cities and their IANA time zones
var worldClocks = [{
	city: "London",
	tz: "Europe/London"
}, {
	city: "New York",
	tz: "America/New_York"
}, {
	city: "Tokyo",
	tz: "Asia/Tokyo"
}, {
	city: "Sydney",
	tz: "Australia/Sydney"
}, {
	city: "Moscow",
	tz: "Europe/Moscow"
}, {
	city: "Dubai",
	tz: "Asia/Dubai"
}, {
	city: "Beijing",
	tz: "Asia/Shanghai"
}, {
	city: "Los Angeles",
	tz: "America/Los_Angeles"
}];
// Helper: format time as HH:MM:SS
function formatTime(date) {
	var h = date.getHours();
	var m = date.getMinutes();
	var s = date.getSeconds();
	return (h < 10 ? "0" : "") + h + ":" + (m < 10 ? "0" : "") + m + ":" + (s < 10 ? "0" : "") + s;
}
// Helper: get time in a specific timezone
function getTimeInZone(tz) {
	// Defensive: fallback to UTC if toLocaleString fails
	try {
		var d = new Date();
		var parts = d.toLocaleString('en-US', {
			timeZone: tz,
			hour12: false
		}).split(/[\s,\/:]+/);
		// parts: [MM, DD, YYYY, HH, MM, SS]
		var year = parseInt(parts[2], 10);
		var month = parseInt(parts[0], 10) - 1;
		var day = parseInt(parts[1], 10);
		var hour = parseInt(parts[3], 10);
		var min = parseInt(parts[4], 10);
		var sec = parseInt(parts[5], 10);
		return new Date(year, month, day, hour, min, sec);
	} catch (e) {
		return new Date();
	}
}
// Create a container for the world clock calendar
var worldClockContainer = new Container();
worldClockContainer.x = 2048 - 20; // Right edge, with margin
worldClockContainer.y = 120; // Below top bar, avoid top-left menu
worldClockContainer.pivot = {
	x: 0,
	y: 0
};
// Create Text2 objects for each city
var worldClockTexts = [];
for (var i = 0; i < worldClocks.length; i++) {
	var txt = new Text2("", {
		size: 44,
		fill: 0xffd700
	});
	txt.anchor.set(1, 0); // Right align, top
	txt.x = 0;
	txt.y = i * 54;
	worldClockContainer.addChild(txt);
	worldClockTexts.push(txt);
}
// Add the container to the GUI overlay (topRight)
LK.gui.topRight.addChild(worldClockContainer);
// Update the clocks every second
LK.setInterval(function () {
	for (var i = 0; i < worldClocks.length; i++) {
		var city = worldClocks[i].city;
		var tz = worldClocks[i].tz;
		var d = getTimeInZone(tz);
		var timeStr = formatTime(d);
		worldClockTexts[i].setText(city + ": " + timeStr);
	}
}, 1000);

===================================================================
--- original.js
+++ change.js
@@ -922,5 +922,93 @@
 		// Schedule next event in 9-100 or 10-100 years
 		var nextYears = randInt(9, 10 + Math.floor(Math.random() * 91));
 		nextGoldenSignTime = now + yearsToMs(nextYears);
 	}
-}, 10000); // Check every 10 seconds (safe, since event is ultra-rare)
\ No newline at end of file
+}, 10000); // Check every 10 seconds (safe, since event is ultra-rare);
+// --- World Clock Calendar in Top-Right Corner ---
+// List of major cities and their IANA time zones
+var worldClocks = [{
+	city: "London",
+	tz: "Europe/London"
+}, {
+	city: "New York",
+	tz: "America/New_York"
+}, {
+	city: "Tokyo",
+	tz: "Asia/Tokyo"
+}, {
+	city: "Sydney",
+	tz: "Australia/Sydney"
+}, {
+	city: "Moscow",
+	tz: "Europe/Moscow"
+}, {
+	city: "Dubai",
+	tz: "Asia/Dubai"
+}, {
+	city: "Beijing",
+	tz: "Asia/Shanghai"
+}, {
+	city: "Los Angeles",
+	tz: "America/Los_Angeles"
+}];
+// Helper: format time as HH:MM:SS
+function formatTime(date) {
+	var h = date.getHours();
+	var m = date.getMinutes();
+	var s = date.getSeconds();
+	return (h < 10 ? "0" : "") + h + ":" + (m < 10 ? "0" : "") + m + ":" + (s < 10 ? "0" : "") + s;
+}
+// Helper: get time in a specific timezone
+function getTimeInZone(tz) {
+	// Defensive: fallback to UTC if toLocaleString fails
+	try {
+		var d = new Date();
+		var parts = d.toLocaleString('en-US', {
+			timeZone: tz,
+			hour12: false
+		}).split(/[\s,\/:]+/);
+		// parts: [MM, DD, YYYY, HH, MM, SS]
+		var year = parseInt(parts[2], 10);
+		var month = parseInt(parts[0], 10) - 1;
+		var day = parseInt(parts[1], 10);
+		var hour = parseInt(parts[3], 10);
+		var min = parseInt(parts[4], 10);
+		var sec = parseInt(parts[5], 10);
+		return new Date(year, month, day, hour, min, sec);
+	} catch (e) {
+		return new Date();
+	}
+}
+// Create a container for the world clock calendar
+var worldClockContainer = new Container();
+worldClockContainer.x = 2048 - 20; // Right edge, with margin
+worldClockContainer.y = 120; // Below top bar, avoid top-left menu
+worldClockContainer.pivot = {
+	x: 0,
+	y: 0
+};
+// Create Text2 objects for each city
+var worldClockTexts = [];
+for (var i = 0; i < worldClocks.length; i++) {
+	var txt = new Text2("", {
+		size: 44,
+		fill: 0xffd700
+	});
+	txt.anchor.set(1, 0); // Right align, top
+	txt.x = 0;
+	txt.y = i * 54;
+	worldClockContainer.addChild(txt);
+	worldClockTexts.push(txt);
+}
+// Add the container to the GUI overlay (topRight)
+LK.gui.topRight.addChild(worldClockContainer);
+// Update the clocks every second
+LK.setInterval(function () {
+	for (var i = 0; i < worldClocks.length; i++) {
+		var city = worldClocks[i].city;
+		var tz = worldClocks[i].tz;
+		var d = getTimeInZone(tz);
+		var timeStr = formatTime(d);
+		worldClockTexts[i].setText(city + ": " + timeStr);
+	}
+}, 1000);
\ No newline at end of file