===================================================================
--- original.js
+++ change.js
@@ -1,213 +1,203 @@
 /**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+
+/**** 
 * Classes
 ****/ 
-// 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 Character = Container.expand(function (initialY, keyVisualTopY) {
 	var self = Container.call(this);
-	// 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
+	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
 		});
-		// Characters need to be interactive to receive 'down' events
-		self.interactive = true;
+		// 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.
 	};
-	/** 
-	* 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.");
+	self.ascend = function () {
+		if (self.isAscending || !isGameActiveGlobal) {
+			// Check global game state
 			return;
 		}
-		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;
+		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;
+			}
+		});
 	};
-	// 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 (global.isGameActive) {
-			// Only allow movement if the game is currently active
-			self.moveUp(global.CHARACTER_ASCEND_SPEED);
-			// Future: Could add sound effect for jump/struggle here
-		}
+	self.down = function (x, y, obj) {
+		// Call ascend when the character is tapped
+		self.ascend();
 	};
-	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
+	self.resetToInitial = function () {
+		self.y = self.initialY;
+		self.isAscending = false;
+		tween.stop(self, {
+			y: true
 		});
 	};
-	// The key is a static object in this design, so no complex methods are needed here.
-	return self; // Must return self
+	// Initialize graphics
+	self.setupGraphics();
+	return self;
 });
 
 /**** 
 * Initialize Game
 ****/ 
-// Create the main game object. Background color is a fallback if no background asset is used or covers fully.
+// Game constants
 var game = new LK.Game({
-	backgroundColor: 0x100806 // A very dark base color, suggesting a dim room
+	backgroundColor: 0x222222 // A dark color for the "old room" vibe
 });
 
 /**** 
 * Game Code
 ****/ 
-// 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, prefixed with 'global' for clarity and accessibility
-global.gameCharacter = null; // Instance of the Character class
-global.escapeKey = null; // Instance of the Key class
-global.timerDisplay = null; // Text2 object for showing the timer
-global.gameUpdateTimerId = null; // ID for the LK.setInterval timer
-global.secondsRemaining = 0; // Time left in the game
-global.isGameActive = false; // Boolean flag to control game state (running, won, lost)
-// Game constants for easy tuning
-global.CHARACTER_ASCEND_SPEED = 40; // Pixels the character moves up per tap
-global.GAME_DURATION_SECONDS = 40; // Total time in seconds for the player to escape
-global.VIRTUAL_GAME_WIDTH = 2048; // Standard LK virtual width
-global.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
-	global.gameCharacter = new Character();
-	// Initialize with asset ID and anchor points (0.5 for X-center, 1.0 for Y-bottom)
-	global.gameCharacter.init('asset_character_locked', 0.5, 1.0);
-	game.addChild(global.gameCharacter);
-	// Position character: horizontally centered, vertically near the bottom of the screen
-	global.gameCharacter.x = global.VIRTUAL_GAME_WIDTH / 2;
-	// Character's Y is its bottom edge. Place it 180px from the screen bottom.
-	global.gameCharacter.y = global.VIRTUAL_GAME_HEIGHT - 180;
-	// 3. Escape Key
-	global.escapeKey = new Key();
-	// Initialize with asset ID and anchor points (0.5, 0.5 for center-center)
-	global.escapeKey.init('asset_key_overhead', 0.5, 0.5);
-	game.addChild(global.escapeKey);
-	// Position key: horizontally centered, vertically above the character's initial head position
-	global.escapeKey.x = global.VIRTUAL_GAME_WIDTH / 2;
-	// Calculate visual top of character (Y-origin minus asset height, due to anchorY=1.0)
-	var characterVisualTopY = global.gameCharacter.y - global.gameCharacter.visualAsset.height;
-	global.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 = global.escapeKey.visualAsset.height / 2 + 70; // Min 70px padding from top
-	if (global.escapeKey.y < keyMinY) {
-		global.escapeKey.y = keyMinY;
-	}
-	// 4. Timer Display
-	global.secondsRemaining = global.GAME_DURATION_SECONDS;
-	global.timerDisplay = new Text2('Time: ' + global.secondsRemaining, {
-		size: 75,
-		// Font size for the timer
-		fill: 0xE0E0E0 // Light grey color for visibility against dark background
+// 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
 	});
-	global.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(global.timerDisplay);
-	// Offset Y slightly to avoid extreme top edge and platform menu icon area
-	global.timerDisplay.y = 70; // 70px down from the top edge of the GUI container
-	// 5. Start Game Logic
-	global.isGameActive = true; // Set game state to active
-	startCountdown(); // Initialize and start the game timer
-	// Initialize 'last state' for intersection detection in game.update
-	global.gameCharacter.lastWasIntersectingKey = false;
+	game.addChildAt(backgroundInstance, 0); // Add background behind other elements
 }
-/** 
-* Manages the game's countdown timer.
-*/ 
-function startCountdown() {
-	// Clear any previously existing timer to prevent duplicates
-	if (global.gameUpdateTimerId) {
-		LK.clearInterval(global.gameUpdateTimerId);
+// 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;
+	LK.gui.top.addChild(timerDisplay);
+}
+// 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);
 	}
-	// Create a new interval timer that fires every second
-	global.gameUpdateTimerId = LK.setInterval(function () {
-		if (!global.isGameActive) {
-			// If game is no longer active (win/loss), stop the timer
-			LK.clearInterval(global.gameUpdateTimerId);
+	gameTimerIntervalId = LK.setInterval(function () {
+		if (!isGameActiveGlobal) {
 			return;
 		}
-		global.secondsRemaining--; // Decrement time
-		global.timerDisplay.setText('Time: ' + global.secondsRemaining); // Update display
-		if (global.secondsRemaining <= 0) {
-			// Time's up!
-			global.isGameActive = false; // Set game state to inactive
-			LK.clearInterval(global.gameUpdateTimerId); // Stop this timer
-			LK.showGameOver(); // Trigger LK's game over sequence
+		timeLeftSecondsGlobal--;
+		timerDisplay.setText(String(timeLeftSecondsGlobal));
+		if (timeLeftSecondsGlobal <= 0) {
+			isGameActiveGlobal = false;
+			LK.clearInterval(gameTimerIntervalId);
+			LK.showGameOver();
 		}
-	}, 1000); // Interval of 1000 milliseconds (1 second)
+	}, 1000);
 }
-// Main game loop, automatically called by the LK engine approximately 60 times per second
+// Initialize game elements
+setupBackground();
+setupTimerDisplay();
+setupCharacterAndKey();
+startGameTimer(); // Start the game immediately
+// Game update loop
 game.update = function () {
-	if (!global.isGameActive) {
-		return; // If game is not active, skip updates
+	if (!isGameActiveGlobal || !characterInstance || !keyInstance) {
+		return;
 	}
-	// Collision/Win Condition Check: Player Character reaching the Key
-	// This requires character and key assets to be initialized and have dimensions.
-	if (global.gameCharacter && global.gameCharacter.visualAsset && global.escapeKey && global.escapeKey.visualAsset) {
-		var currentlyIntersectsKey = global.gameCharacter.intersects(global.escapeKey);
-		// Win condition: if intersection just started (was false last frame, true this frame)
-		if (!global.gameCharacter.lastWasIntersectingKey && currentlyIntersectsKey) {
-			global.isGameActive = false; // Set game state to inactive
-			if (global.gameUpdateTimerId) {
-				// Stop the game timer
-				LK.clearInterval(global.gameUpdateTimerId);
-			}
-			LK.showYouWin(); // Trigger LK's "You Win" sequence
-		}
-		// Store current intersection state for the next frame's check
-		global.gameCharacter.lastWasIntersectingKey = currentlyIntersectsKey;
+	// 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);
 	}
+	characterInstance.lastIntersectingKey = currentlyIntersectingKey;
+	// Note: Character movement is handled by its own 'down' event and tweening.
 };
-// Initialize and set up all game elements and logic when the script loads
-setupInitialGameScene();
\ No newline at end of file
+// 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