/**** 
* 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;
		// 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);
				}
			}
		}
	};
	// 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 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,
			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 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;
	}
	// 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;
	// 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
@@ -35,11 +35,11 @@
 				'rightDoor': ['jumpscare', 4]
 			};
 		} else if (self.id === 'bon') {
 			self.movementPath = {
-				1: [3, 5],
-				3: [1, 'rightDoor'],
-				5: [1, 'leftDoor'],
+				1: [3, 'leftDoor', 'rightDoor'],
+				3: [1, 'rightDoor', 'leftDoor'],
+				5: [1, 'leftDoor', 'rightDoor'],
 				'leftDoor': ['jumpscare', 5],
 				'rightDoor': ['jumpscare', 3]
 			};
 		} else if (self.id === 'spinny') {
@@ -56,8 +56,12 @@
 	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;
 		// If at a door and door is open, enter and trigger jumpscare
 		if (self.currentLocation === 'leftDoor' || self.currentLocation === 'rightDoor') {
@@ -209,13 +213,8 @@
 		if (camNum === self.currentCam) return;
 		LK.getSound('cameraSound').play();
 		self.currentCam = camNum;
 		self.camLabel.setText("CAM " + camNum);
-		// Clear Bon timer when switching cameras
-		if (self.bonViewTimer) {
-			LK.clearTimeout(self.bonViewTimer);
-			self.bonViewTimer = null;
-		}
 		// Show static effect when switching
 		self["static"].alpha = 0.8;
 		tween(self["static"], {
 			alpha: 0.3
@@ -246,125 +245,21 @@
 	self.updateAnimatronicsView = function () {
 		self.animatronicsInView.removeChildren();
 		for (var i = 0; i < game.animatronics.length; i++) {
 			var animatronic = game.animatronics[i];
-			// Special case for Bon - always show in camera 4
-			if (animatronic.id === 'bon' && self.currentCam === 4 || animatronic.id !== 'bon' && animatronic.currentLocation === self.currentCam) {
+			// 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
 				});
-				// If it's Bon, start tracking view time
-				if (animatronic.id === 'bon') {
-					// Store reference to the animatronic for later use
-					graphic.bonRef = animatronic;
-					// Start or reset the viewing timer
-					if (self.bonViewTimer) {
-						LK.clearTimeout(self.bonViewTimer);
-					}
-					// Set random time between 2.5-4 seconds for jumpscare
-					var jumpscareTime = 2500 + Math.random() * 1500;
-					self.bonViewTimer = LK.setTimeout(function () {
-						self.triggerBonJumpscare(animatronic);
-					}, jumpscareTime);
-				}
 			}
 		}
 	};
-	// Bon jumpscare function - takes power but doesn't kill
-	self.triggerBonJumpscare = function (bon) {
-		// Clear viewing timer
-		if (self.bonViewTimer) {
-			LK.clearTimeout(self.bonViewTimer);
-			self.bonViewTimer = null;
-		}
-		// 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 bonImage = jumpscare.attachAsset('bon', {
-			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(bonImage, {
-			scaleX: 5,
-			scaleY: 5
-		}, {
-			duration: 500,
-			onFinish: function onFinish() {
-				// Remove jumpscare after a short time
-				LK.setTimeout(function () {
-					jumpscare.destroy();
-					// Drain 10 power
-					game.powerRemaining = Math.max(0, game.powerRemaining - 10);
-					game.powerSystem.updateDisplay(game.powerRemaining, game.powerConsumption);
-					// Move Bon to a different camera
-					self.moveBonToRandomCamera(bon);
-					// Close camera if power runs out
-					if (game.powerRemaining <= 0) {
-						game.powerOut();
-					}
-				}, 500);
-			}
-		});
-	};
-	// Move Bon to a random camera after jumpscare
-	self.moveBonToRandomCamera = function (bon) {
-		// Get current location
-		var currentLocation = bon.currentLocation;
-		// Choose a random new camera (1-5)
-		var newLocation;
-		do {
-			newLocation = Math.floor(Math.random() * 5) + 1;
-		} while (newLocation === currentLocation);
-		// Update Bon's location
-		bon.lastLocation = bon.currentLocation;
-		bon.currentLocation = newLocation;
-		bon.viewX = Math.random() * 400 - 200; // New random position
-		bon.viewY = Math.random() * 300 - 150;
-		// Update camera view if still on cameras
-		if (self.isOpen) {
-			self.updateAnimatronicsView();
-		}
-	};
-	// Clear Bon timer when closing camera
-	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 {
-			// Clear Bon timer when closing camera
-			if (self.bonViewTimer) {
-				LK.clearTimeout(self.bonViewTimer);
-				self.bonViewTimer = null;
-			}
-			LK.getSound('static').stop();
-			self.alpha = 0;
-			game.powerConsumption -= 1;
-		}
-	};
 	// Initially hide camera system
 	self.alpha = 0;
 	return self;
 });
@@ -721,25 +616,18 @@
 	// 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));
-	}
+	// 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');
-	// Clear existing Bon timer if present
-	if (game.bonMoveTimer) {
-		LK.clearTimeout(game.bonMoveTimer);
-		game.bonMoveTimer = null;
-	}
 };
 // Start power drainage
 game.startPowerDrain = function () {
 	// Clear existing timer if any
@@ -762,15 +650,10 @@
 	}, 1000);
 };
 // Handle power outage
 game.powerOut = function () {
-	// Clear power drain
+	// Stop power drain
 	LK.clearInterval(game.powerDrainTimer);
-	// Clear Bon movement timer
-	if (game.bonMoveTimer) {
-		LK.clearTimeout(game.bonMoveTimer);
-		game.bonMoveTimer = null;
-	}
 	// Play power down sound
 	LK.getSound('powerDown').play();
 	// Close camera if open
 	if (game.cameraSystem.isOpen) {
@@ -831,58 +714,16 @@
 	}
 	// Move animatronics (time-based probability)
 	if (LK.ticks % 150 === 0) {
 		// Every 2.5 seconds approximately
-		// Move all animatronics except Bon (handled separately)
 		for (var i = 0; i < game.animatronics.length; i++) {
-			if (game.animatronics[i].id !== 'bon') {
-				game.animatronics[i].move();
-			}
+			game.animatronics[i].move();
 		}
 		// Update camera view if open
 		if (game.cameraSystem && game.cameraSystem.isOpen) {
 			game.cameraSystem.updateAnimatronicsView();
 		}
 	}
-	// Set up Bon's automatic camera movement
-	if (!game.bonMoveTimer) {
-		var _loop = function _loop() {
-				if (game.animatronics[i].id === 'bon') {
-					// Function to update Bon in camera 4 only
-					var _moveBonToRandomCamera = function moveBonToRandomCamera() {
-						var bon = game.animatronics[i];
-						// Only proceed if the game is still active
-						if (!game.isPlaying || game.isGameOver) return;
-						// Always stay in camera 4
-						// Update Bon's location with new random position in camera 4
-						bon.lastLocation = bon.currentLocation;
-						bon.currentLocation = 4; // Always camera 4
-						bon.viewX = Math.random() * 400 - 200; // Random position within camera view
-						bon.viewY = Math.random() * 300 - 150;
-						// Update camera view if open and on the relevant camera
-						if (game.cameraSystem && game.cameraSystem.isOpen) {
-							game.cameraSystem.updateAnimatronicsView();
-						}
-						// Set next move timer (5-10 seconds) - only changes position within camera 4
-						var nextMoveTime = 5000 + Math.random() * 5000;
-						game.bonMoveTimer = LK.setTimeout(_moveBonToRandomCamera, nextMoveTime);
-					}; // Start the initial movement timer (5-10 seconds)
-					// Set Bon to camera 4
-					game.animatronics[i].lastLocation = game.animatronics[i].currentLocation;
-					game.animatronics[i].currentLocation = 4; // Always start in camera 4
-					game.animatronics[i].viewX = Math.random() * 400 - 200;
-					game.animatronics[i].viewY = Math.random() * 300 - 150;
-					initialMoveTime = 5000 + Math.random() * 5000;
-					game.bonMoveTimer = LK.setTimeout(_moveBonToRandomCamera, initialMoveTime);
-					return 1; // break
-				}
-			},
-			initialMoveTime;
-		// Initialize Bon to a random camera on game start
-		for (var i = 0; i < game.animatronics.length; i++) {
-			if (_loop()) break;
-		}
-	}
 };
 // Initialize the game
 game.initialize();
 // Import tween for animations