/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1", {
	currentNight: 1,
	highestNight: 1
});

/**** 
* Classes
****/ 
var Animatronic = Container.expand(function (id, name, difficulty, startLocation) {
	var self = Container.call(this);
	self.id = id;
	self.name = name;
	self.difficulty = difficulty;
	self.currentLocation = startLocation;
	self.lastLocation = startLocation;
	self.atDoor = false;
	self.doorSide = null;
	self.moveTimer = null;
	self.viewX = Math.random() * 400 - 200; // Random position in camera view
	self.viewY = Math.random() * 300 - 150;
	// Set movement pattern (different for each animatronic)
	self.setMovementPattern = function () {
		// Movement paths from cameras to door
		if (self.id === 'dobby') {
			self.movementPath = {
				1: [2, 3],
				2: [1, 3],
				3: [2, 4, 'leftDoor'],
				4: [3, 'rightDoor'],
				'leftDoor': ['jumpscare', 3],
				'rightDoor': ['jumpscare', 4]
			};
		} else if (self.id === 'bon') {
			self.movementPath = {
				1: [3, 'leftDoor', 'rightDoor'],
				3: [1, 'rightDoor', 'leftDoor'],
				5: [1, 'leftDoor', 'rightDoor'],
				'leftDoor': ['jumpscare', 5],
				'rightDoor': ['jumpscare', 3]
			};
		} else if (self.id === 'spinny') {
			self.movementPath = {
				2: [1, 4],
				1: [2, 'leftDoor'],
				4: [2, 'rightDoor'],
				'leftDoor': ['jumpscare', 1],
				'rightDoor': ['jumpscare', 4]
			};
		}
	};
	// Make movement decisions
	self.move = function () {
		self.lastLocation = self.currentLocation;
		// Check activity level (based on difficulty and night)
		var activityLevel = self.difficulty + (game.currentNight - 1) * 2;
		// Make Bon move much faster
		if (self.id === 'bon') {
			activityLevel = activityLevel * 2.5; // Significantly increase Bon's activity
		}
		var willMove = Math.random() * 20 < activityLevel;
		if (!willMove) return;
		// Special behavior for Spinny - when he moves, play radar sound and start countdown
		if (self.id === 'spinny' && game.bugSpray && !game.bugSpray.spinnyActive) {
			// Random chance to trigger radar sound when Spinny moves (50%)
			if (Math.random() < 0.5) {
				game.bugSpray.startThreat();
			}
		}
		// If at a door and door is open, enter and trigger jumpscare
		if (self.currentLocation === 'leftDoor' || self.currentLocation === 'rightDoor') {
			// Check if door is open (accessible from animatronic's door side)
			var door = self.currentLocation === 'leftDoor' ? game.office.leftDoor : game.office.rightDoor;
			if (door.isOpen) {
				self.triggerJumpscare();
				return;
			} else {
				// Door is closed, retreat
				var possibleMoves = self.movementPath[self.currentLocation];
				for (var i = 1; i < possibleMoves.length; i++) {
					self.currentLocation = possibleMoves[i];
					break;
				}
				self.atDoor = false;
				door.setAnimatronic(null);
			}
		} else {
			// Choose a random valid location to move to
			var possibleMoves = self.movementPath[self.currentLocation];
			// Check if possibleMoves exists before accessing it
			if (!possibleMoves || possibleMoves.length === 0) {
				// If no valid moves exist, stay in current location
				return;
			}
			var nextLocation = possibleMoves[Math.floor(Math.random() * possibleMoves.length)];
			self.currentLocation = nextLocation;
			// If moved to a door, update door status
			if (nextLocation === 'leftDoor') {
				self.atDoor = true;
				self.doorSide = 'left';
				game.office.leftDoor.setAnimatronic(self);
			} else if (nextLocation === 'rightDoor') {
				self.atDoor = true;
				self.doorSide = 'right';
				game.office.rightDoor.setAnimatronic(self);
			} else {
				self.atDoor = false;
				// Clear from doors if moved away
				if (self.lastLocation === 'leftDoor') {
					game.office.leftDoor.setAnimatronic(null);
				} else if (self.lastLocation === 'rightDoor') {
					game.office.rightDoor.setAnimatronic(null);
				}
			}
		}
	};
	// Trigger jumpscare sequence
	self.triggerJumpscare = function () {
		// Special handling for Bon - he takes power instead of game over
		if (self.id === 'bon' && game.powerRemaining > 0) {
			// Play jumpscare sound
			LK.getSound('jumpscare').play();
			// Create jumpscare animation
			var jumpscare = new Container();
			var jumpscareGraphic = jumpscare.attachAsset('jumpscare', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			var animatronicImage = jumpscare.attachAsset(self.id, {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: 3,
				scaleY: 3
			});
			// Position at center of screen
			jumpscare.x = 2048 / 2;
			jumpscare.y = 2732 / 2;
			// Add to game
			game.addChild(jumpscare);
			// Animate jumpscare
			tween(animatronicImage, {
				scaleX: 5,
				scaleY: 5
			}, {
				duration: 500,
				onFinish: function onFinish() {
					// Remove Bon from game for this night
					self.currentLocation = 0; // Set to invalid location
					// Remove from doors if present
					if (self.doorSide === 'left') {
						game.office.leftDoor.setAnimatronic(null);
					} else if (self.doorSide === 'right') {
						game.office.rightDoor.setAnimatronic(null);
					}
					self.atDoor = false;
					// Take power instead of game over
					game.powerRemaining -= 10;
					if (game.powerRemaining < 0) game.powerRemaining = 0;
					game.powerSystem.updateDisplay(game.powerRemaining, game.powerConsumption);
					// Remove jumpscare after a moment
					LK.setTimeout(function () {
						jumpscare.destroy();
					}, 500);
				}
			});
		} else {
			// Regular jumpscare behavior for other animatronics
			// Set game state
			game.isGameOver = true;
			// Play jumpscare sound
			LK.getSound('jumpscare').play();
			// Create jumpscare animation
			var jumpscare = new Container();
			var jumpscareGraphic = jumpscare.attachAsset('jumpscare', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			var animatronicImage = jumpscare.attachAsset(self.id, {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: 3,
				scaleY: 3
			});
			// Position at center of screen
			jumpscare.x = 2048 / 2;
			jumpscare.y = 2732 / 2;
			// Add to game
			game.addChild(jumpscare);
			// Animate jumpscare
			tween(animatronicImage, {
				scaleX: 5,
				scaleY: 5
			}, {
				duration: 500,
				onFinish: function onFinish() {
					// Game over
					LK.setTimeout(function () {
						LK.showGameOver();
					}, 500);
				}
			});
		}
	};
	// Initialize movement pattern
	self.setMovementPattern();
	return self;
});
var BugSpray = Container.expand(function () {
	var self = Container.call(this);
	// Create button with bug spray label
	self.button = self.addChild(new Button("BUG SPRAY", function () {
		self.spray();
	}));
	// Is bug spray available
	self.available = true;
	// Current timer for spinny threat
	self.threatTimer = null;
	// Whether Spinny is currently active with radar
	self.spinnyActive = false;
	// Spray bugs (specifically Spinny)
	self.spray = function () {
		// Only allow if available and Spinny is active
		if (!self.available || !self.spinnyActive) return;
		// Use the spray
		self.available = false;
		self.button.alpha = 0.5;
		// Stop radar sound immediately
		LK.getSound('radarSound').stop();
		// Stop Spinny's threat
		self.stopThreat();
		// Find Spinny and force him back to his starting position
		for (var i = 0; i < game.animatronics.length; i++) {
			if (game.animatronics[i].id === 'spinny') {
				var spinny = game.animatronics[i];
				spinny.currentLocation = 2; // Reset to starting position
				// If at door, remove from door
				if (spinny.doorSide === 'left') {
					game.office.leftDoor.setAnimatronic(null);
				} else if (spinny.doorSide === 'right') {
					game.office.rightDoor.setAnimatronic(null);
				}
				spinny.atDoor = false;
				break;
			}
		}
		// Make bug spray available again after 30 seconds
		LK.setTimeout(function () {
			self.available = true;
			self.button.alpha = 1;
		}, 30000);
	};
	// Start the spinny threat countdown
	self.startThreat = function () {
		// Clear any existing timer
		self.stopThreat();
		// Set spinny as active
		self.spinnyActive = true;
		// Play radar sound on loop
		LK.getSound('radarSound').play();
		// Start 10 second countdown
		self.threatTimer = LK.setTimeout(function () {
			// Time's up - trigger jumpscare for Spinny
			for (var i = 0; i < game.animatronics.length; i++) {
				if (game.animatronics[i].id === 'spinny') {
					game.animatronics[i].triggerJumpscare();
					break;
				}
			}
			self.stopThreat();
		}, 10000);
	};
	// Stop the spinny threat
	self.stopThreat = function () {
		if (self.threatTimer) {
			LK.clearTimeout(self.threatTimer);
			self.threatTimer = null;
		}
		// Stop radar sound
		LK.getSound('radarSound').stop();
		// Set spinny as inactive
		self.spinnyActive = false;
	};
	return self;
});
var Button = Container.expand(function (label, callback) {
	var self = Container.call(this);
	var buttonGraphic = self.attachAsset('button', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var labelText = new Text2(label, {
		size: 40,
		fill: 0xFFFFFF
	});
	labelText.anchor.set(0.5, 0.5);
	self.addChild(labelText);
	self.down = function (x, y, obj) {
		buttonGraphic.alpha = 0.7;
		if (callback) callback();
	};
	self.up = function (x, y, obj) {
		buttonGraphic.alpha = 1;
	};
	return self;
});
var CameraSystem = Container.expand(function () {
	var self = Container.call(this);
	self.isOpen = false;
	self.currentCam = 1;
	// Camera view background
	var cameraBackground = self.attachAsset('camera', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 2,
		scaleY: 2
	});
	// Camera label
	self.camLabel = new Text2("CAM 1", {
		size: 60,
		fill: 0xFFFFFF
	});
	self.camLabel.anchor.set(0.5, 0);
	self.camLabel.y = -600;
	self.addChild(self.camLabel);
	// Static overlay
	self["static"] = self.attachAsset('background', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1,
		scaleY: 1
	});
	self["static"].alpha = 0.3;
	// Camera buttons
	self.camButtons = [];
	for (var i = 1; i <= 5; i++) {
		var btn = self.addChild(new Button("CAM " + i, function (camNum) {
			return function () {
				self.switchCam(camNum);
			};
		}(i)));
		btn.x = -800 + (i - 1) * 400;
		btn.y = 600;
		self.camButtons.push(btn);
	}
	// Animatronics in view
	self.animatronicsInView = self.addChild(new Container());
	// Switch to a different camera
	self.switchCam = function (camNum) {
		if (camNum === self.currentCam) return;
		LK.getSound('cameraSound').play();
		self.currentCam = camNum;
		self.camLabel.setText("CAM " + camNum);
		// Show static effect when switching
		self["static"].alpha = 0.8;
		tween(self["static"], {
			alpha: 0.3
		}, {
			duration: 300
		});
		// Update which animatronics are visible
		self.updateAnimatronicsView();
	};
	// Toggle camera system
	self.toggle = function () {
		// Only allow toggling if power is on
		if (game.powerRemaining <= 0) return;
		self.isOpen = !self.isOpen;
		if (self.isOpen) {
			LK.getSound('cameraSound').play();
			LK.getSound('static').play();
			self.alpha = 1;
			game.powerConsumption += 1;
			self.updateAnimatronicsView();
		} else {
			LK.getSound('static').stop();
			self.alpha = 0;
			game.powerConsumption -= 1;
		}
	};
	// Update which animatronics are shown based on current camera
	self.updateAnimatronicsView = function () {
		self.animatronicsInView.removeChildren();
		for (var i = 0; i < game.animatronics.length; i++) {
			var animatronic = game.animatronics[i];
			// Don't show Bon on cameras - he's too fast to be seen
			if (animatronic.currentLocation === self.currentCam && animatronic.id !== 'bon') {
				var graphic = self.animatronicsInView.attachAsset(animatronic.id, {
					anchorX: 0.5,
					anchorY: 0.5,
					x: animatronic.viewX,
					y: animatronic.viewY,
					scaleX: 1.5,
					scaleY: 1.5
				});
			}
		}
	};
	// Initially hide camera system
	self.alpha = 0;
	return self;
});
var ClockDisplay = Container.expand(function () {
	var self = Container.call(this);
	// Current in-game time (12 AM to 6 AM)
	self.hour = 12;
	self.am = true;
	// Time text
	self.timeText = new Text2("12 AM", {
		size: 60,
		fill: 0xFFFFFF
	});
	self.timeText.anchor.set(0.5, 0.5);
	self.addChild(self.timeText);
	// Night text
	self.nightText = new Text2("Night 1", {
		size: 40,
		fill: 0xFFFFFF
	});
	self.nightText.anchor.set(0.5, 0.5);
	self.nightText.y = 50;
	self.addChild(self.nightText);
	// Update the clock display
	self.updateTime = function (night, gameTime) {
		// Calculate hour based on game time (7 hours for 420 seconds - 12AM to 6AM)
		var hourValue = Math.floor(gameTime / 60) + 12;
		if (hourValue > 12) hourValue -= 12;
		self.hour = hourValue;
		self.am = true;
		// Update display
		self.timeText.setText(self.hour + " AM");
		self.nightText.setText("Night " + night);
	};
	return self;
});
var Door = Container.expand(function (side) {
	var self = Container.call(this);
	self.side = side;
	self.isOpen = true;
	self.lightOn = false;
	self.animatronicPresent = false;
	// Door visuals
	self.doorGraphic = self.attachAsset('door', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.doorGraphic.alpha = 0; // Hidden when open
	// Light area
	self.lightGraphic = self.attachAsset('doorLight', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.lightGraphic.alpha = 0; // Light is off by default
	// Door button
	self.doorBtn = self.addChild(new Button('DOOR', function () {
		self.toggleDoor();
	}));
	self.doorBtn.y = -400;
	self.doorBtn.x = self.side === 'left' ? 150 : -150;
	// Light button
	self.lightBtn = self.addChild(new Button('LIGHT', function () {
		self.toggleLight();
	}));
	self.lightBtn.y = -300;
	self.lightBtn.x = self.side === 'left' ? 150 : -150;
	// Animatronic that might be at the door
	self.animatronic = self.addChild(new Container());
	if (self.side === 'left') {
		self.animatronic.x = -200;
	} else {
		self.animatronic.x = 200;
	}
	self.animatronic.y = 0;
	self.animatronic.alpha = 0;
	// Toggle door open/closed
	self.toggleDoor = function () {
		// Only allow toggling if power is on
		if (game.powerRemaining <= 0) return;
		LK.getSound('doorSound').play();
		self.isOpen = !self.isOpen;
		// Update visuals and power consumption
		if (self.isOpen) {
			self.doorGraphic.alpha = 0;
			game.powerConsumption -= 1;
		} else {
			self.doorGraphic.alpha = 1;
			game.powerConsumption += 1;
		}
	};
	// Toggle light on/off
	self.toggleLight = function () {
		// Only allow toggling if power is on
		if (game.powerRemaining <= 0) return;
		// Toggle the light
		self.lightOn = !self.lightOn;
		if (self.lightOn) {
			LK.getSound('lightSound').play();
			self.lightGraphic.alpha = 0.5;
			// Show animatronic if present
			if (self.animatronicPresent) {
				self.showAnimatronic();
			}
			// Light uses power while on
			game.powerConsumption += 1;
			// Auto turn off light after 2 seconds
			LK.setTimeout(function () {
				if (self.lightOn) {
					self.toggleLight();
				}
			}, 2000);
		} else {
			self.lightGraphic.alpha = 0;
			self.animatronic.alpha = 0;
			game.powerConsumption -= 1;
		}
	};
	// Show the animatronic at the door
	self.showAnimatronic = function () {
		if (!self.animatronicData) return;
		// Clear existing animatronic
		self.animatronic.removeChildren();
		// Create new animatronic based on which one is at the door
		var animatronicGraphic = self.animatronic.attachAsset(self.animatronicData.id, {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.5,
			scaleY: 1.5
		});
		self.animatronic.alpha = 1;
	};
	// Set which animatronic is at the door
	self.setAnimatronic = function (animatronicData) {
		self.animatronicData = animatronicData;
		self.animatronicPresent = !!animatronicData;
		// Show animatronic if light is on
		if (self.lightOn && self.animatronicPresent) {
			self.showAnimatronic();
		} else {
			self.animatronic.alpha = 0;
		}
	};
	return self;
});
var Office = Container.expand(function () {
	var self = Container.call(this);
	var officeBackground = self.attachAsset('office', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add left door and light
	self.leftDoor = self.addChild(new Door('left'));
	self.leftDoor.x = 400;
	self.leftDoor.y = 1366 / 2;
	// Add right door and light
	self.rightDoor = self.addChild(new Door('right'));
	self.rightDoor.x = 2048 - 400;
	self.rightDoor.y = 1366 / 2;
	return self;
});
var PowerSystem = Container.expand(function () {
	var self = Container.call(this);
	// Power background
	var powerBg = self.attachAsset('powerBg', {
		anchorX: 0,
		anchorY: 0.5
	});
	// Power meter
	self.powerMeter = self.attachAsset('powerMeter', {
		anchorX: 0,
		anchorY: 0.5,
		x: 10,
		y: 0
	});
	// Power text
	self.powerText = new Text2("Power: 100%", {
		size: 40,
		fill: 0xFFFFFF
	});
	self.powerText.anchor.set(0, 0.5);
	self.powerText.x = 430;
	self.addChild(self.powerText);
	// Power usage indicator
	self.usageText = new Text2("Usage: •", {
		size: 40,
		fill: 0xFFFFFF
	});
	self.usageText.anchor.set(0, 0.5);
	self.usageText.x = 430;
	self.usageText.y = 50;
	self.addChild(self.usageText);
	// Update power display
	self.updateDisplay = function (power, usage) {
		// Update power percentage text
		var percent = Math.floor(power / game.maxPower * 100);
		self.powerText.setText("Power: " + percent + "%");
		// Update power meter width
		var meterWidth = 400 * (power / game.maxPower);
		self.powerMeter.width = Math.max(meterWidth, 0);
		// Update power usage indicators
		var usageIndicator = "";
		for (var i = 0; i < usage; i++) {
			usageIndicator += "•";
		}
		self.usageText.setText("Usage: " + usageIndicator);
		// Change power meter color based on remaining power
		if (percent <= 10) {
			self.powerMeter.tint = 0xff0000; // Red when low
		} else if (percent <= 30) {
			self.powerMeter.tint = 0xffff00; // Yellow when medium
		} else {
			self.powerMeter.tint = 0x00ff00; // Green when high
		}
	};
	return self;
});
var TitleScreen = Container.expand(function () {
	var self = Container.call(this);
	// Title background
	var titleBg = self.attachAsset('background', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1,
		scaleY: 1
	});
	// Main character display
	var dobbyDisplay = self.attachAsset('dobby', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: -300,
		scaleX: 2,
		scaleY: 2
	});
	// Title text
	var titleText = new Text2("FIVE SCARY NIGHTS", {
		size: 100,
		fill: 0xFF0000
	});
	titleText.anchor.set(0.5, 0.5);
	titleText.y = -600;
	self.addChild(titleText);
	var subtitleText = new Text2("with Dobby", {
		size: 80,
		fill: 0xFFFFFF
	});
	subtitleText.anchor.set(0.5, 0.5);
	subtitleText.y = -500;
	self.addChild(subtitleText);
	// Night display
	var nightText = new Text2("Night " + storage.currentNight, {
		size: 60,
		fill: 0xFFFFFF
	});
	nightText.anchor.set(0.5, 0.5);
	nightText.y = 100;
	self.addChild(nightText);
	// Start button
	var startBtn = self.addChild(new Button("START NIGHT", function () {
		game.startNight();
	}));
	startBtn.y = 300;
	// Animate Dobby
	function animateDobby() {
		tween(dobbyDisplay, {
			rotation: 0.1
		}, {
			duration: 2000,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(dobbyDisplay, {
					rotation: -0.1
				}, {
					duration: 2000,
					easing: tween.easeInOut,
					onFinish: animateDobby
				});
			}
		});
	}
	// Start animation
	animateDobby();
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state variables
game.isPlaying = false;
game.isGameOver = false;
game.titleScreen = null;
game.office = null;
game.cameraSystem = null;
game.powerSystem = null;
game.clockDisplay = null;
game.animatronics = [];
game.currentNight = storage.currentNight || 1;
game.gameTime = 0;
game.maxGameTime = 420; // 7 minutes (420 seconds) per night
game.maxPower = 100;
game.powerRemaining = 100;
game.powerConsumption = 1; // Basic power consumption
game.powerDrainTimer = null;
// Initialize the game
game.initialize = function () {
	// Create title screen
	game.titleScreen = game.addChild(new TitleScreen());
	game.titleScreen.x = 2048 / 2;
	game.titleScreen.y = 2732 / 2;
	// Set current night
	game.currentNight = storage.currentNight || 1;
	// Play ambient sound
	LK.getSound('ambience').play();
};
// Start a night
game.startNight = function () {
	// Hide title screen
	game.titleScreen.alpha = 0;
	// Reset game state
	game.isPlaying = true;
	game.isGameOver = false;
	game.gameTime = 0;
	game.powerRemaining = game.maxPower;
	game.powerConsumption = 1;
	// Create office
	game.office = game.addChild(new Office());
	game.office.x = 2048 / 2;
	game.office.y = 2732 / 2;
	// Create camera system
	game.cameraSystem = game.addChild(new CameraSystem());
	game.cameraSystem.x = 2048 / 2;
	game.cameraSystem.y = 2732 / 2;
	// Create power system
	game.powerSystem = game.addChild(new PowerSystem());
	game.powerSystem.x = 150;
	game.powerSystem.y = 100;
	// Create clock display
	game.clockDisplay = game.addChild(new ClockDisplay());
	game.clockDisplay.x = 2048 - 150;
	game.clockDisplay.y = 100;
	// Camera button
	game.cameraBtn = game.addChild(new Button("CAMERA", function () {
		game.cameraSystem.toggle();
	}));
	game.cameraBtn.x = 2048 / 2;
	game.cameraBtn.y = 2732 - 150;
	// Bug spray button
	game.bugSpray = game.addChild(new BugSpray());
	game.bugSpray.x = 2048 - 150;
	game.bugSpray.y = 200;
	// Create animatronics - starting positions and difficulties vary by night
	game.animatronics = [];
	// Dobby - main animatronic, active from night 1
	game.animatronics.push(new Animatronic('dobby', 'Dobby', 2 + game.currentNight, 1));
	// Bon - active from night 1 (modified to always be active)
	game.animatronics.push(new Animatronic('bon', 'Bon', 3 + game.currentNight, 1));
	// Spinny - active from night 3
	if (game.currentNight >= 3) {
		game.animatronics.push(new Animatronic('spinny', 'Spinny', game.currentNight, 2));
	}
	// Start power drain
	game.startPowerDrain();
	// Play night music
	LK.playMusic('nightMusic');
};
// Start power drainage
game.startPowerDrain = function () {
	// Clear existing timer if any
	if (game.powerDrainTimer) {
		LK.clearInterval(game.powerDrainTimer);
	}
	// Start draining power based on consumption
	game.powerDrainTimer = LK.setInterval(function () {
		if (!game.isPlaying || game.isGameOver) return;
		// Drain power based on current consumption
		var drainAmount = 0.1 * game.powerConsumption;
		game.powerRemaining -= drainAmount;
		// Handle power out
		if (game.powerRemaining <= 0) {
			game.powerRemaining = 0;
			game.powerOut();
		}
		// Update power display
		game.powerSystem.updateDisplay(game.powerRemaining, game.powerConsumption);
	}, 1000);
};
// Handle power outage
game.powerOut = function () {
	// Stop power drain
	LK.clearInterval(game.powerDrainTimer);
	// Play power down sound
	LK.getSound('powerDown').play();
	// Close camera if open
	if (game.cameraSystem.isOpen) {
		game.cameraSystem.toggle();
	}
	// Turn off all lights
	if (game.office.leftDoor.lightOn) {
		game.office.leftDoor.toggleLight();
	}
	if (game.office.rightDoor.lightOn) {
		game.office.rightDoor.toggleLight();
	}
	// Open all doors
	if (!game.office.leftDoor.isOpen) {
		game.office.leftDoor.doorGraphic.alpha = 0;
		game.office.leftDoor.isOpen = true;
	}
	if (!game.office.rightDoor.isOpen) {
		game.office.rightDoor.doorGraphic.alpha = 0;
		game.office.rightDoor.isOpen = true;
	}
	// Stop any active spinny threat
	if (game.bugSpray && game.bugSpray.spinnyActive) {
		game.bugSpray.stopThreat();
	}
	// Wait 10 seconds, then let Bon jumpscare (rather than Dobby)
	LK.setTimeout(function () {
		for (var i = 0; i < game.animatronics.length; i++) {
			if (game.animatronics[i].id === 'bon') {
				// Override Bon's normal behavior for power outage - he will cause game over
				var bonAnimatronic = game.animatronics[i];
				// Create jumpscare animation with game over
				game.isGameOver = true;
				LK.getSound('jumpscare').play();
				var jumpscare = new Container();
				var jumpscareGraphic = jumpscare.attachAsset('jumpscare', {
					anchorX: 0.5,
					anchorY: 0.5
				});
				var animatronicImage = jumpscare.attachAsset('bon', {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleX: 3,
					scaleY: 3
				});
				jumpscare.x = 2048 / 2;
				jumpscare.y = 2732 / 2;
				game.addChild(jumpscare);
				tween(animatronicImage, {
					scaleX: 5,
					scaleY: 5
				}, {
					duration: 500,
					onFinish: function onFinish() {
						LK.setTimeout(function () {
							LK.showGameOver();
						}, 500);
					}
				});
				break;
			}
		}
	}, 10000); // 10 seconds instead of 5
};
// Win the night
game.winNight = function () {
	// Stop gameplay
	game.isPlaying = false;
	// Stop any active spinny threat
	if (game.bugSpray && game.bugSpray.spinnyActive) {
		game.bugSpray.stopThreat();
	}
	// Update night progress
	storage.currentNight = Math.min(game.currentNight + 1, 5);
	// Update highest night if needed
	if (storage.currentNight > storage.highestNight) {
		storage.highestNight = storage.currentNight;
	}
	// Show win screen
	LK.showYouWin();
};
// Update game state
game.update = function () {
	if (!game.isPlaying || game.isGameOver) return;
	// Update game time
	game.gameTime += 1 / 60; // Add 1/60th of a second (assuming 60 FPS)
	// Update clock
	if (game.clockDisplay) {
		game.clockDisplay.updateTime(game.currentNight, game.gameTime);
	}
	// Check for win condition
	if (game.gameTime >= game.maxGameTime) {
		game.winNight();
		return;
	}
	// Move animatronics (time-based probability)
	if (LK.ticks % 150 === 0) {
		// Every 2.5 seconds approximately
		for (var i = 0; i < game.animatronics.length; i++) {
			game.animatronics[i].move();
		}
		// Update camera view if open
		if (game.cameraSystem && game.cameraSystem.isOpen) {
			game.cameraSystem.updateAnimatronicsView();
		}
	}
};
// Initialize the game
game.initialize();
// Import tween for animations
// Import storage for saving game progress
// Initialize assets
// Sound effects
// Background music