===================================================================
--- original.js
+++ change.js
@@ -1,203 +1,213 @@
 /**** 
-* Plugins
-****/ 
-var tween = LK.import("@upit/tween.v1");
-
-/**** 
 * Classes
 ****/ 
-var Character = Container.expand(function (initialY, keyVisualTopY) {
+// Gold color for the key
+// No plugins are explicitly required for this game's core mechanics at this stage.
+// Character class representing the player locked in the chair
+var Character = Container.expand(function () {
 	var self = Container.call(this);
-	var characterGraphics = null; // Will be initialized in setupGraphics
-	self.isAscending = false;
-	self.initialY = initialY;
-	self.keyInteractionY = keyVisualTopY; // The Y-coordinate the character's top should aim for
-	// Must define methods before they are called
-	self.setupGraphics = function () {
-		// Attach asset. Anchor point is center-middle.
-		characterGraphics = self.attachAsset('character_asset', {
-			anchorX: 0.5,
-			anchorY: 0.5 // Center anchor for easier y calculation
+	// Properties
+	self.visualAsset = null; // Stores the graphical representation of the character
+	// Methods are defined at the top of the class structure for clarity
+	/** 
+	* Initializes the character with a specific asset.
+	* @param {string} assetId - The ID of the asset to use for the character.
+	* @param {number} anchorX - The horizontal anchor point (0-1).
+	* @param {number} anchorY - The vertical anchor point (0-1).
+	*/ 
+	self.init = function (assetId, anchorX, anchorY) {
+		self.visualAsset = self.attachAsset(assetId, {
+			anchorX: anchorX,
+			anchorY: anchorY
 		});
-		// Ensure graphics are loaded for height calculation, though LK handles this.
-		// If characterGraphics.height is 0 initially, positions might be off until asset loads.
-		// LK usually preloads assets defined with LK.init.
+		// Characters need to be interactive to receive 'down' events
+		self.interactive = true;
 	};
-	self.ascend = function () {
-		if (self.isAscending || !isGameActiveGlobal) {
-			// Check global game state
+	/** 
+	* Moves the character upwards by a specified amount.
+	* @param {number} amount - The number of pixels to move upwards.
+	*/ 
+	self.moveUp = function (amount) {
+		// Ensure visualAsset is available before accessing its properties
+		if (!self.visualAsset) {
+			console.error("Character visual asset not initialized in moveUp.");
 			return;
 		}
-		if (!characterGraphics) return; // Graphics not ready
-		tween.stop(self, {
-			y: true
-		}); // Stop any ongoing y-tween
-		// Calculate targetY: move up by ASCEND_AMOUNT_GLOBAL, but don't go past the key's general area.
-		// The character's center (this.y) should not go much higher than the key's center (this.keyInteractionY)
-		// to keep the visual logic sensible. Intersection handles the actual win.
-		var currentY = self.y;
-		var potentialY = currentY - ASCEND_AMOUNT_GLOBAL;
-		var targetY = Math.max(potentialY, self.keyInteractionY - characterGraphics.height / 3); // Allow slight overshoot for visual
-		self.isAscending = true;
-		tween(self, {
-			y: targetY
-		}, {
-			duration: ASCEND_DURATION_GLOBAL,
-			easing: tween.easeOut,
-			onFinish: function onFinish() {
-				self.isAscending = false;
-			}
-		});
+		var newY = self.y - amount;
+		// Prevent character from moving off the top of the screen.
+		// Assumes anchorY for character is 1.0 (bottom of the asset).
+		// The character's visual top is at self.y - self.visualAsset.height.
+		var assetTopVisualY = newY - self.visualAsset.height;
+		if (assetTopVisualY < 0) {
+			// If the top of the asset goes above screen edge (y=0)
+			newY = self.visualAsset.height; // Position character so its top is exactly at y=0
+		}
+		self.y = newY;
 	};
-	self.down = function (x, y, obj) {
-		// Call ascend when the character is tapped
-		self.ascend();
+	// Event handler for tap/press on the character instance.
+	// This 'down' method is automatically invoked by the LK engine.
+	self.down = function (x, y, eventObject) {
+		if (isGameActive) {
+			// Only allow movement if the game is currently active
+			self.moveUp(CHARACTER_ASCEND_SPEED);
+			// Future: Could add sound effect for jump/struggle here
+		}
 	};
-	self.resetToInitial = function () {
-		self.y = self.initialY;
-		self.isAscending = false;
-		tween.stop(self, {
-			y: true
+	return self; // Must return self for the class to be correctly defined
+});
+// Key class representing the escape key objective
+var Key = Container.expand(function () {
+	var self = Container.call(this);
+	// Properties
+	self.visualAsset = null; // Stores the graphical representation of the key
+	/** 
+	* Initializes the key with a specific asset.
+	* @param {string} assetId - The ID of the asset to use for the key.
+	* @param {number} anchorX - The horizontal anchor point (0-1).
+	* @param {number} anchorY - The vertical anchor point (0-1).
+	*/ 
+	self.init = function (assetId, anchorX, anchorY) {
+		self.visualAsset = self.attachAsset(assetId, {
+			anchorX: anchorX,
+			anchorY: anchorY
 		});
 	};
-	// Initialize graphics
-	self.setupGraphics();
-	return self;
+	// The key is a static object in this design, so no complex methods are needed here.
+	return self; // Must return self
 });
 
 /**** 
 * Initialize Game
 ****/ 
-// Game constants
+// Create the main game object. Background color is a fallback if no background asset is used or covers fully.
 var game = new LK.Game({
-	backgroundColor: 0x222222 // A dark color for the "old room" vibe
+	backgroundColor: 0x100806 // A very dark base color, suggesting a dim room
 });
 
 /**** 
 * Game Code
 ****/ 
-// Game constants
-// Game element dimensions and asset IDs - adjust these to your actual assets
-// Example dimensions
-// Example dimensions
-var GAME_WIDTH = 2048;
-var GAME_HEIGHT = 2732;
-var ASCEND_AMOUNT_GLOBAL = 70; // Pixels character moves up per tap
-var ASCEND_DURATION_GLOBAL = 120; // Milliseconds for ascend animation
-var GAME_DURATION_SECONDS_GLOBAL = 30; // Game time in seconds
-// Global game variables
-var backgroundInstance = null;
-var characterInstance = null;
-var keyInstance = null;
-var timerDisplay = null;
-var gameTimerIntervalId = null;
-var timeLeftSecondsGlobal = GAME_DURATION_SECONDS_GLOBAL;
-var isGameActiveGlobal = false;
-// Function to set up the background
-function setupBackground() {
-	backgroundInstance = LK.getAsset('background_asset', {
-		anchorX: 0.5,
-		anchorY: 0.5,
-		x: GAME_WIDTH / 2,
-		y: GAME_HEIGHT / 2,
-		width: GAME_WIDTH,
-		// Ensure it covers the screen
-		height: GAME_HEIGHT
+// Placeholder for character in chair
+// A dark, moody room color
+// Using shapes as placeholders for development.
+// In a real project, these would typically be image assets (e.g., 'background_room.png').
+// Defining them here with LK.init is for clarity and follows the example structure.
+// The LK engine can automatically initialize assets based on LK.getAsset calls.
+// Global variables for game state and objects, for clarity and accessibility
+var gameCharacter = null; // Instance of the Character class
+var escapeKey = null; // Instance of the Key class
+var timerDisplay = null; // Text2 object for showing the timer
+var gameUpdateTimerId = null; // ID for the LK.setInterval timer
+var secondsRemaining = 0; // Time left in the game
+var isGameActive = false; // Boolean flag to control game state (running, won, lost)
+// Game constants for easy tuning
+var CHARACTER_ASCEND_SPEED = 40; // Pixels the character moves up per tap
+var GAME_DURATION_SECONDS = 40; // Total time in seconds for the player to escape
+var VIRTUAL_GAME_WIDTH = 2048; // Standard LK virtual width
+var VIRTUAL_GAME_HEIGHT = 2732; // Standard LK virtual height
+/** 
+* Sets up all the initial elements and state for the game.
+* This function is called once when the game starts.
+*/ 
+function setupInitialGameScene() {
+	// 1. Background
+	// The background is added first to ensure it's rendered behind all other game elements.
+	var roomBackground = game.addChild(LK.getAsset('asset_background_room', {
+		anchorX: 0,
+		// Anchor at top-left
+		anchorY: 0,
+		x: 0,
+		// Position at screen origin (0,0)
+		y: 0
+	}));
+	// 2. Player Character
+	gameCharacter = new Character();
+	// Initialize with asset ID and anchor points (0.5 for X-center, 1.0 for Y-bottom)
+	gameCharacter.init('asset_character_locked', 0.5, 1.0);
+	game.addChild(gameCharacter);
+	// Position character: horizontally centered, vertically near the bottom of the screen
+	gameCharacter.x = VIRTUAL_GAME_WIDTH / 2;
+	// Character's Y is its bottom edge. Place it 180px from the screen bottom.
+	gameCharacter.y = VIRTUAL_GAME_HEIGHT - 180;
+	// 3. Escape Key
+	escapeKey = new Key();
+	// Initialize with asset ID and anchor points (0.5, 0.5 for center-center)
+	escapeKey.init('asset_key_overhead', 0.5, 0.5);
+	game.addChild(escapeKey);
+	// Position key: horizontally centered, vertically above the character's initial head position
+	escapeKey.x = VIRTUAL_GAME_WIDTH / 2;
+	// Calculate visual top of character (Y-origin minus asset height, due to anchorY=1.0)
+	var characterVisualTopY = gameCharacter.y - gameCharacter.visualAsset.height;
+	escapeKey.y = characterVisualTopY - 300; // Position key 300px above character's head
+	// Ensure key is not off-screen at the top, providing minimum padding
+	var keyMinY = escapeKey.visualAsset.height / 2 + 70; // Min 70px padding from top
+	if (escapeKey.y < keyMinY) {
+		escapeKey.y = keyMinY;
+	}
+	// 4. Timer Display
+	secondsRemaining = GAME_DURATION_SECONDS;
+	timerDisplay = new Text2('Time: ' + secondsRemaining, {
+		size: 75,
+		// Font size for the timer
+		fill: 0xE0E0E0 // Light grey color for visibility against dark background
 	});
-	game.addChildAt(backgroundInstance, 0); // Add background behind other elements
-}
-// Function to set up the timer display
-function setupTimerDisplay() {
-	timerDisplay = new Text2(String(timeLeftSecondsGlobal), {
-		size: 100,
-		fill: 0xFFFFFF
-		// stroke: "#000000", // Optional stroke for better visibility
-		// strokeThickness: 5 // Optional
-	});
-	timerDisplay.anchor.set(0.5, 0); // Anchor top-center
-	// Position it away from the very top edge, avoiding platform menu icon area
-	timerDisplay.y = 120;
+	timerDisplay.anchor.set(0.5, 0); // Anchor text at its top-center point
+	// Add timer to the GUI layer, positioning at top-center
 	LK.gui.top.addChild(timerDisplay);
+	// Offset Y slightly to avoid extreme top edge and platform menu icon area
+	timerDisplay.y = 70; // 70px down from the top edge of the GUI container
+	// 5. Start Game Logic
+	isGameActive = true; // Set game state to active
+	startCountdown(); // Initialize and start the game timer
+	// Initialize 'last state' for intersection detection in game.update
+	gameCharacter.lastWasIntersectingKey = false;
 }
-// Function to set up character and key
-function setupCharacterAndKey() {
-	// Key setup (anchor center)
-	var keyAsset = LK.getAsset('key_asset', {
-		anchorX: 0.5,
-		anchorY: 0.5
-	});
-	keyInstance = game.addChild(keyAsset);
-	keyInstance.x = GAME_WIDTH / 2;
-	keyInstance.y = GAME_HEIGHT * 0.25; // Position key towards the top quarter
-	// Character setup (anchor center)
-	// Ensure characterGraphics.height is available for positioning.
-	// We assume 'character_asset' provides its dimensions.
-	var tempCharGraphics = LK.getAsset('character_asset', {}); // To get height for positioning
-	var charInitialY = GAME_HEIGHT - tempCharGraphics.height / 2 - 200; // 200px from bottom to character's center
-	// Pass the key's y-coordinate (its center) to the Character.
-	// The character will try to ascend its center towards this y-value.
-	characterInstance = new Character(charInitialY, keyInstance.y);
-	game.addChild(characterInstance);
-	characterInstance.x = GAME_WIDTH / 2;
-	characterInstance.y = charInitialY; // Set initial position
-	characterInstance.lastY = characterInstance.y; // Initialize lastY for any future checks
-	characterInstance.lastIntersectingKey = false; // Initialize for intersection checks
-}
-// Function to start the game timer
-function startGameTimer() {
-	isGameActiveGlobal = true;
-	timeLeftSecondsGlobal = GAME_DURATION_SECONDS_GLOBAL;
-	timerDisplay.setText(String(timeLeftSecondsGlobal));
-	if (gameTimerIntervalId) {
-		LK.clearInterval(gameTimerIntervalId);
+/** 
+* Manages the game's countdown timer.
+*/ 
+function startCountdown() {
+	// Clear any previously existing timer to prevent duplicates
+	if (gameUpdateTimerId) {
+		LK.clearInterval(gameUpdateTimerId);
 	}
-	gameTimerIntervalId = LK.setInterval(function () {
-		if (!isGameActiveGlobal) {
+	// Create a new interval timer that fires every second
+	gameUpdateTimerId = LK.setInterval(function () {
+		if (!isGameActive) {
+			// If game is no longer active (win/loss), stop the timer
+			LK.clearInterval(gameUpdateTimerId);
 			return;
 		}
-		timeLeftSecondsGlobal--;
-		timerDisplay.setText(String(timeLeftSecondsGlobal));
-		if (timeLeftSecondsGlobal <= 0) {
-			isGameActiveGlobal = false;
-			LK.clearInterval(gameTimerIntervalId);
-			LK.showGameOver();
+		secondsRemaining--; // Decrement time
+		timerDisplay.setText('Time: ' + secondsRemaining); // Update display
+		if (secondsRemaining <= 0) {
+			// Time's up!
+			isGameActive = false; // Set game state to inactive
+			LK.clearInterval(gameUpdateTimerId); // Stop this timer
+			LK.showGameOver(); // Trigger LK's game over sequence
 		}
-	}, 1000);
+	}, 1000); // Interval of 1000 milliseconds (1 second)
 }
-// Initialize game elements
-setupBackground();
-setupTimerDisplay();
-setupCharacterAndKey();
-startGameTimer(); // Start the game immediately
-// Game update loop
+// Main game loop, automatically called by the LK engine approximately 60 times per second
 game.update = function () {
-	if (!isGameActiveGlobal || !characterInstance || !keyInstance) {
-		return;
+	if (!isGameActive) {
+		return; // If game is not active, skip updates
 	}
-	// Intersection check: Character and Key
-	// We care about the moment of intersection
-	var currentlyIntersectingKey = characterInstance.intersects(keyInstance);
-	if (!characterInstance.lastIntersectingKey && currentlyIntersectingKey) {
-		isGameActiveGlobal = false;
-		LK.clearInterval(gameTimerIntervalId);
-		// Optional: A small visual effect for grabbing the key
-		LK.effects.flashObject(keyInstance, 0xFFFF00, 300); // Flash key yellow
-		LK.setTimeout(function () {
-			// Slight delay before showing win screen
-			LK.showYouWin();
-		}, 300);
+	// Collision/Win Condition Check: Player Character reaching the Key
+	// This requires character and key assets to be initialized and have dimensions.
+	if (gameCharacter && gameCharacter.visualAsset && escapeKey && escapeKey.visualAsset) {
+		var currentlyIntersectsKey = gameCharacter.intersects(escapeKey);
+		// Win condition: if intersection just started (was false last frame, true this frame)
+		if (!gameCharacter.lastWasIntersectingKey && currentlyIntersectsKey) {
+			isGameActive = false; // Set game state to inactive
+			if (gameUpdateTimerId) {
+				// Stop the game timer
+				LK.clearInterval(gameUpdateTimerId);
+			}
+			LK.showYouWin(); // Trigger LK's "You Win" sequence
+		}
+		// Store current intersection state for the next frame's check
+		gameCharacter.lastWasIntersectingKey = currentlyIntersectsKey;
 	}
-	characterInstance.lastIntersectingKey = currentlyIntersectingKey;
-	// Note: Character movement is handled by its own 'down' event and tweening.
 };
-// Clean up when game ends (LK handles reset, but good practice for intervals)
-// This is typically handled by LK's game lifecycle, but if manual cleanup is needed:
-// function cleanupGame() {
-//     if (gameTimerIntervalId) {
-//         LK.clearInterval(gameTimerIntervalId);
-//         gameTimerIntervalId = null;
-//     }
-//     isGameActiveGlobal = false;
-// }
-// LK.on('gameOver', cleanupGame); // Example: if LK had such specific events exposed
-// LK.on('youWin', cleanupGame);
\ No newline at end of file
+// Initialize and set up all game elements and logic when the script loads
+setupInitialGameScene();
\ No newline at end of file