/**** 
* 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;
});

/**** 
* 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);
// 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
function handleRandomEvent() {
	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();

===================================================================
--- original.js
+++ change.js
@@ -400,8 +400,28 @@
 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,
@@ -496,11 +516,49 @@
 			}, 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
 function handleRandomEvent() {
-	var eventType = Math.floor(Math.random() * 4);
+	var eventType = Math.floor(Math.random() * 5);
 	if (eventType === 0) {
 		// Zombie attack
 		showEventOverlay(eventOverlay, eventText, 0x00ff00, 'ZOMBIE ATTACK!', 0x00ff00, 900);
 	} else if (eventType === 1) {
@@ -510,8 +568,11 @@
 		});
 	} 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);
 	}