===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,730 @@
-/****
+/**** 
+* 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, 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;
+		// 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];
+			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
-});
\ No newline at end of file
+});
+
+/**** 
+* 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));
+	}
+	// 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
\ No newline at end of file