/**** 
* 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.inOffice = false;
	self.previousLocation = null;
	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, 5],
				3: [1, 'rightDoor'],
				5: [1, 'leftDoor'],
				'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;
		var willMove = Math.random() * 20 < activityLevel;
		if (!willMove) return;
		// Special behavior for Bon to appear directly in office
		if (self.id === 'bon' && !self.inOffice && Math.random() < 0.15) {
			// 15% chance for Bon to appear in office
			self.appearInOffice();
			return;
		}
		// 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];
			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);
				}
			}
		}
	};
	// Track if the animatronic is currently in the office special position
	self.inOffice = false;
	self.officeImage = null;
	self.stealPowerTimer = null;
	// Update Bon's visibility in office based on camera status
	self.updateOfficeVisibility = function () {
		if (self.id !== 'bon' || !self.inOffice || !self.officeImage) return;
		// Show Bon in office only when cameras are closed
		if (game.cameraSystem && game.cameraSystem.isOpen) {
			self.officeImage.alpha = 0; // Hide when on camera
		} else {
			self.officeImage.alpha = 1; // Show when not on camera
		}
		// Show Bon in office only when cameras are closed
		if (game.cameraSystem && game.cameraSystem.isOpen) {
			self.officeImage.alpha = 0; // Hide when on camera
		} else {
			self.officeImage.alpha = 1; // Show when not on camera
		}
	};
	// Function for Bon to appear in office
	self.appearInOffice = function () {
		// Only Bon can appear in office directly
		if (self.id !== 'bon') return;
		// Store previous location for return
		self.previousLocation = self.currentLocation;
		self.inOffice = true;
		// Create office image for Bon
		self.officeImage = new Container();
		var bonGraphic = self.officeImage.attachAsset('bon', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.5,
			scaleY: 1.5
		});
		// Position at random location in office
		self.officeImage.x = Math.random() * 1200 + 400; // Between 400 and 1600
		self.officeImage.y = Math.random() * 600 + 600; // Between 600 and 1200
		// Make clickable
		self.officeImage.down = function () {
			if (game.cameraSystem.isOpen) return; // Can't click if cameras are open
			self.leaveOffice();
		};
		// Add to office container
		if (game.office) {
			game.office.addChild(self.officeImage);
			// Initially hide/show based on camera status
			self.updateOfficeVisibility();
			// Set timer to steal power if not clicked
			self.stealPowerTimer = LK.setTimeout(function () {
				if (self.inOffice) {
					self.stealPower();
				}
			}, 5000); // 5 seconds to click
		}
	};
	// Function for Bon to steal power
	self.stealPower = function () {
		if (!self.inOffice) return;
		// Mini jumpscare animation
		var tempJumpscare = new Container();
		var jumpscareGraphic = tempJumpscare.attachAsset('jumpscare', {
			anchorX: 0.5,
			anchorY: 0.5,
			alpha: 0.7
		});
		var animatronicImage = tempJumpscare.attachAsset(self.id, {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 3,
			scaleY: 3
		});
		// Position at center of screen
		tempJumpscare.x = 2048 / 2;
		tempJumpscare.y = 2732 / 2;
		// Add to game
		game.addChild(tempJumpscare);
		// Play jumpscare sound
		LK.getSound('jumpscare').play();
		// Animate jumpscare
		tween(animatronicImage, {
			scaleX: 4,
			scaleY: 4
		}, {
			duration: 300,
			onFinish: function onFinish() {
				// Remove jumpscare
				LK.setTimeout(function () {
					game.removeChild(tempJumpscare);
					// Steal power
					game.powerRemaining = Math.max(0, game.powerRemaining - 10);
					game.powerSystem.updateDisplay(game.powerRemaining, game.powerConsumption);
					// Leave office
					self.leaveOffice();
					// Handle power out if needed
					if (game.powerRemaining <= 0) {
						game.powerOut();
					}
				}, 300);
			}
		});
	};
	// Function for Bon to leave the office
	self.leaveOffice = function () {
		if (!self.inOffice) return;
		// Clear steal power timer
		if (self.stealPowerTimer) {
			LK.clearTimeout(self.stealPowerTimer);
			self.stealPowerTimer = null;
		}
		// Remove office image
		if (self.officeImage && game.office) {
			game.office.removeChild(self.officeImage);
			self.officeImage = null;
		}
		// Return to previous location
		self.currentLocation = self.previousLocation || 1;
		self.inOffice = false;
	};
	// Trigger jumpscare sequence
	self.triggerJumpscare = function () {
		// 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 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 Bon's visibility in office
		for (var i = 0; i < game.animatronics.length; i++) {
			if (game.animatronics[i].id === 'bon') {
				game.animatronics[i].updateOfficeVisibility();
				break;
			}
		}
		// Update Bon's visibility in office
		for (var i = 0; i < game.animatronics.length; i++) {
			if (game.animatronics[i].id === 'bon') {
				game.animatronics[i].updateOfficeVisibility();
				break;
			}
		}
	};
	// 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 in camera if he's in the office
			if (animatronic.id === 'bon' && animatronic.inOffice) {
				continue;
			}
			// Don't show Bon in camera if he's in the office
			if (animatronic.id === 'bon' && animatronic.inOffice) {
				continue;
			}
			if (animatronic.currentLocation === self.currentCam) {
				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,
			scaleY: 1
		});
		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;
	// 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 2
	if (game.currentNight >= 2) {
		game.animatronics.push(new Animatronic('bon', 'Bon', 1 + game.currentNight, 1));
		// Set a timer for Bon to randomly appear in office every 20-30 seconds
		game.bonOfficeTimer = LK.setInterval(function () {
			if (!game.isPlaying || game.isGameOver) return;
			// Find Bon in the animatronics array
			for (var i = 0; i < game.animatronics.length; i++) {
				if (game.animatronics[i].id === 'bon' && !game.animatronics[i].inOffice) {
					game.animatronics[i].appearInOffice();
					break;
				}
			}
		}, Math.floor(Math.random() * 10000) + 20000); // Random between 20-30 seconds
		// Set a timer for Bon to randomly appear in office every 6.7-10 seconds (3X faster)
		game.bonOfficeTimer = LK.setInterval(function () {
			if (!game.isPlaying || game.isGameOver) return;
			// Find Bon in the animatronics array
			for (var i = 0; i < game.animatronics.length; i++) {
				if (game.animatronics[i].id === 'bon' && !game.animatronics[i].inOffice) {
					game.animatronics[i].appearInOffice();
					break;
				}
			}
		}, Math.floor(Math.random() * 3333) + 6667); // Random between 6.7-10 seconds (3X faster)
	}
	// 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;
	}
	// Wait a bit, then let Dobby jumpscare
	LK.setTimeout(function () {
		for (var i = 0; i < game.animatronics.length; i++) {
			if (game.animatronics[i].id === 'dobby') {
				game.animatronics[i].triggerJumpscare();
				break;
			}
		}
	}, 5000);
};
// Win the night
game.winNight = function () {
	// Stop gameplay
	game.isPlaying = false;
	// Clear Bon's office timer if it exists
	if (game.bonOfficeTimer) {
		LK.clearInterval(game.bonOfficeTimer);
	}
	// Clear Bon's office timer if it exists
	if (game.bonOfficeTimer) {
		LK.clearInterval(game.bonOfficeTimer);
	}
	// 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

===================================================================
--- original.js
+++ change.js
@@ -774,9 +774,9 @@
 					break;
 				}
 			}
 		}, Math.floor(Math.random() * 10000) + 20000); // Random between 20-30 seconds
-		// Set a timer for Bon to randomly appear in office every 20-30 seconds
+		// Set a timer for Bon to randomly appear in office every 6.7-10 seconds (3X faster)
 		game.bonOfficeTimer = LK.setInterval(function () {
 			if (!game.isPlaying || game.isGameOver) return;
 			// Find Bon in the animatronics array
 			for (var i = 0; i < game.animatronics.length; i++) {
@@ -784,9 +784,9 @@
 					game.animatronics[i].appearInOffice();
 					break;
 				}
 			}
-		}, Math.floor(Math.random() * 10000) + 20000); // Random between 20-30 seconds
+		}, Math.floor(Math.random() * 3333) + 6667); // Random between 6.7-10 seconds (3X faster)
 	}
 	// Spinny - active from night 3
 	if (game.currentNight >= 3) {
 		game.animatronics.push(new Animatronic('spinny', 'Spinny', game.currentNight, 2));