/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");

/**** 
* Initialize Game
****/ 
// Character and Key classes have been removed as they're no longer needed for the game
// 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: 0x100806 // A very dark base color, suggesting a dim room
});

/**** 
* Game Code
****/ 
// Gold color for the key
// 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 objects, drag state, and interaction states
var key = null;
var lockclosed1 = null,
	lockclosed2 = null;
var lockopen1 = null,
	lockopen2 = null;
var draggedKey = null;
var isLock1Open = false,
	isLock2Open = false;
var bodyTouchCount = 0; // Moved from setupInitialGameScene for clarity and proper scope
// Global variables for game state and objects, for clarity and accessibility
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 GAME_DURATION_SECONDS = 180; // Total time in seconds (3 minutes)
var VIRTUAL_GAME_WIDTH = 2048; // Standard LK virtual width
var VIRTUAL_GAME_HEIGHT = 2732; // Standard LK virtual height
var SAWRECORD1_ESTIMATED_DURATION_MS = 4000; // Estimated duration of Sawrecord1 sound in milliseconds (e.g., 4 seconds)
// Global variables for intro screen
var introBackground = null;
var introActive = true; // To ensure intro logic runs only once
// Display intro background as soon as game code runs
// It's assumed VIRTUAL_GAME_WIDTH and VIRTUAL_GAME_HEIGHT are available here.
introBackground = LK.getAsset('Background0', {
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 0,
	width: VIRTUAL_GAME_WIDTH,
	// Make it full screen
	height: VIRTUAL_GAME_HEIGHT
});
game.addChild(introBackground); // Add to the main game stage
// Play intro music
LK.playMusic('Intromusic1');
// Add start button to intro
var startButton = LK.getAsset('Startbutton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: VIRTUAL_GAME_WIDTH / 2,
	y: VIRTUAL_GAME_HEIGHT * 0.85 // Place button closer to the bottom, at 85% of screen height
});
game.addChild(startButton);
// Set up a global tap listener to start the game only if start button is pressed
game.down = function (x, y, obj) {
	if (introActive) {
		// Only start if tap is inside startButton bounds
		if (startButton && x >= startButton.x - startButton.width / 2 && x <= startButton.x + startButton.width / 2 && y >= startButton.y - startButton.height / 2 && y <= startButton.y + startButton.height / 2) {
			// Remove intro assets
			if (introBackground) {
				introBackground.destroy();
				introBackground = null;
			}
			if (startButton) {
				startButton.destroy();
				startButton = null;
			}
			// Stop intro music when starting the game
			LK.stopMusic();
			introActive = false;
			setupInitialGameScene();
			// Note: If setupInitialGameScene or subsequent game logic defines its own game.down handler,
			// it will automatically replace this one. This is typically the desired behavior,
			// as the intro tap is a one-time action.
		}
	}
};
/** 
* 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 = LK.getAsset('asset_background_room', {
		anchorX: 0,
		// Anchor at top-left
		anchorY: 0,
		x: 0,
		// Position at screen origin (0,0)
		y: 0
	});
	// Make the background asset visible
	roomBackground.visible = true;
	game.addChildAt(roomBackground, 0);
	// 2. Body (player) - centered horizontally, near the bottom of the room
	var body = LK.getAsset('Body', {
		anchorX: 0.7,
		anchorY: -0.5
	});
	body.x = VIRTUAL_GAME_WIDTH / 2;
	// Place the person so their feet are 150px above the bottom edge (to avoid being flush with the edge)
	game.addChild(body);
	// 3. Person - Add the person asset to the game scene
	var person = LK.getAsset('Person', {
		anchorX: 1,
		anchorY: -0.5
	});
	person.x = VIRTUAL_GAME_WIDTH / 2;
	person.y = VIRTUAL_GAME_HEIGHT / 2; // Center the person
	game.addChild(person);
	// Add the body asset beside the person from the right
	body.x = person.x + body.width / 2 + person.width / 2; // Position body to the right of person
	body.y = person.y; // Align body vertically with person
	// 4. Timer Display
	secondsRemaining = GAME_DURATION_SECONDS;
	// Format initial time as minutes:seconds (3:00 format)
	var minutes = Math.floor(secondsRemaining / 60);
	var seconds = secondsRemaining % 60;
	// Add leading zero for seconds less than 10
	var formattedTime = minutes + ':' + (seconds < 10 ? '0' : '') + seconds;
	timerDisplay = new Text2('Time: ' + formattedTime, {
		size: 75,
		// Font size for the timer
		fill: 0xE0E0E0 // Light grey color for visibility against dark background
	});
	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
	// 5. Sawface
	var sawface = LK.getAsset('Sawface', {
		anchorX: -2.9,
		anchorY: 2.5,
		visible: false // Initially hidden
	});
	sawface.x = VIRTUAL_GAME_WIDTH / 2 - 200; // Position it to the left of the center
	sawface.y = VIRTUAL_GAME_HEIGHT / 2; // Vertically centered
	game.addChild(sawface);
	// 6. Start Game Logic
	isGameActive = true; // Set game state to active
	startCountdown(); // Initialize and start the game timer
	// Play Sawrecord1 sound, show Sawface 3 seconds after game start, then hide Sawface after sound finishes.
	LK.setTimeout(function () {
		if (isGameActive) {
			// Check if game is still active, e.g. not game over immediately
			var sawSound = LK.getSound('Sawrecord1');
			if (sawSound) {
				sawSound.play();
			}
			if (sawface) {
				// Ensure sawface asset exists
				sawface.visible = true; // Show the sawface
				// Hide sawface 33 seconds after Sawrecord1 sound starts
				LK.setTimeout(function () {
					if (sawface) {
						sawface.visible = false;
					}
				}, 33000); // 33000 milliseconds = 33 seconds
			}
		}
	}, 3000); // 3000 milliseconds = 3 seconds
	// Character and key interaction removed
	// Add a tap listener to the body
	body.down = function () {
		bodyTouchCount++;
		if (bodyTouchCount >= 7) {
			key.visible = true; // Show the key after 7 touches
		}
	};
	// 7. Key - Add the key to the game scene, attached to the body
	key = LK.getAsset('key', {
		// Assign to global 'key'
		anchorX: 1.5,
		// Anchor key at its center
		anchorY: -4.5 // Anchor key at its center
	});
	// Position the key on the body.
	// (Positioning comments from original code retained for context)
	key.x = body.x - body.width * (body.anchor.x - 0.5) - key.width * 0.1; // Slightly to the left on the body
	key.y = body.y + body.height * (0.5 + body.anchor.y); // Centered vertically on the body graphic
	game.addChild(key);
	key.visible = false; // Initially hide the key
	key.interactive = true; // Make key interactive for dragging
	// 8. Locks - Add lock assets to the game scene
	// Lock 1
	lockclosed1 = LK.getAsset('Lockclosed', {
		// Assign to global 'lockclosed1'
		anchorX: 13.5,
		anchorY: -11.5
	});
	lockclosed1.x = body.x - body.width * 0.15; // Position on the body
	lockclosed1.y = body.y + body.height * (0.1 + body.anchor.y);
	game.addChild(lockclosed1);
	lockopen1 = LK.getAsset('Lockopen', {
		// Corresponding open state for lock1
		anchorX: 13.5,
		// Same anchor as lockclosed1 for proper alignment
		anchorY: -11.5
	});
	lockopen1.x = lockclosed1.x; // Position identically to lockclosed1
	lockopen1.y = lockclosed1.y;
	lockopen1.visible = false; // Initially hidden
	game.addChild(lockopen1);
	// Lock 2
	lockclosed2 = LK.getAsset('Lockclosed', {
		// Assign to global 'lockclosed2'
		anchorX: 11.5,
		anchorY: -11
	});
	lockclosed2.x = body.x + body.width * 0.15; // Position on the body
	lockclosed2.y = body.y + body.height * (0.1 + body.anchor.y);
	game.addChild(lockclosed2);
	lockopen2 = LK.getAsset('Lockopen', {
		// Corresponding open state for lock2
		anchorX: 11.5,
		// Same anchor as lockclosed2
		anchorY: -11
	});
	lockopen2.x = lockclosed2.x; // Position identically to lockclosed2
	lockopen2.y = lockclosed2.y;
	lockopen2.visible = false; // Initially hidden
	game.addChild(lockopen2);
	// Initialize lock states (flags to ensure they open only once)
	isLock1Open = false;
	isLock2Open = false;
	// Original comment about key as child of body:
	// Make key a child of body so it moves with the body, if body were a Container.
	// Since body is an LK.getAsset(), it's a DisplayObject, not a Container by default.
	// If we need the key to move with the body and body itself moves, we'd need to update key's position in game.update relative to body.
	// For now, assuming body is static after initial placement. If body moves, this needs adjustment or body needs to be a Container.
	// 9. Key dragging and lock interaction logic
	// Event listener on the key itself to initiate dragging
	key.down = function (event) {
		// The 'event' object might contain more details if needed
		if (key.visible) {
			// Only allow dragging if the key is currently visible
			draggedKey = key; // Set the 'draggedKey' to this key object
			// If z-ordering becomes an issue (e.g., key dragging behind other objects),
			// you might need to bring the key to the front of the display list.
			// Example: if (key.parent) { key.parent.setChildIndex(key, key.parent.children.length - 1); }
			// This depends on LK supporting such operations easily on 'game' or generic parents.
		}
	};
	// Event listener on the main game stage to handle movement while dragging
	game.move = function (x, y, eventObj) {
		if (draggedKey) {
			// If a key is being dragged
			// Stop any previous position tween on the key to ensure responsiveness
			tween.stop(draggedKey, {
				x: true,
				y: true
			});
			tween(draggedKey, {
				x: x,
				y: y
			}, {
				duration: 100,
				easing: tween.linear
			}); // Smoothly move the key
			// Check for intersection with the first lock
			if (!isLock1Open && lockclosed1.visible && draggedKey.intersects(lockclosed1)) {
				lockclosed1.visible = false; // Hide the closed lock
				if (lockopen1) {
					lockopen1.visible = true;
				} // Show the open lock
				isLock1Open = true; // Mark this lock as opened
			}
			// Check for intersection with the second lock
			if (!isLock2Open && lockclosed2.visible && draggedKey.intersects(lockclosed2)) {
				lockclosed2.visible = false; // Hide the closed lock
				if (lockopen2) {
					lockopen2.visible = true;
				} // Show the open lock
				isLock2Open = true; // Mark this lock as opened
			}
		}
	};
	// Event listener on the main game stage to handle release of the drag
	game.up = function (x, y, eventObj) {
		if (draggedKey) {
			// If a key was being dragged
			// Stop any active tween on the key to ensure its position is set definitively
			tween.stop(draggedKey); // Stop all tweens on draggedKey
			// It's good practice to ensure the dragged object's final position is set based on release coordinates
			draggedKey.x = x;
			draggedKey.y = y;
			// Perform a final intersection check on release, in case the last 'move' event didn't catch it
			if (!isLock1Open && lockclosed1.visible && draggedKey.intersects(lockclosed1)) {
				lockclosed1.visible = false;
				if (lockopen1) {
					lockopen1.visible = true;
				}
				isLock1Open = true;
			}
			if (!isLock2Open && lockclosed2.visible && draggedKey.intersects(lockclosed2)) {
				lockclosed2.visible = false;
				if (lockopen2) {
					lockopen2.visible = true;
				}
				isLock2Open = true;
			}
			draggedKey = null; // Release the key, stop dragging
		}
	};
	// Note: The 'bodyTouchCount' variable is now global and initialized to 0.
	// The 'body.down' listener (defined earlier in setupInitialGameScene) will use this global variable.
}
/** 
* Manages the game's countdown timer.
*/ 
function startCountdown() {
	// Clear any previously existing timer to prevent duplicates
	if (gameUpdateTimerId) {
		LK.clearInterval(gameUpdateTimerId);
	}
	// 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;
		}
		secondsRemaining--; // Decrement time
		// Format time as minutes:seconds (3:00 format)
		var minutes = Math.floor(secondsRemaining / 60);
		var seconds = secondsRemaining % 60;
		// Add leading zero for seconds less than 10
		var formattedTime = minutes + ':' + (seconds < 10 ? '0' : '') + seconds;
		timerDisplay.setText('Time: ' + formattedTime); // Update display with formatted time
		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); // Interval of 1000 milliseconds (1 second)
}
// Main game loop, automatically called by the LK engine approximately 60 times per second
game.update = function () {
	if (!isGameActive) {
		return; // If game is not active, skip updates
	}
	// Character and key collision detection removed - no game win condition
};
// Initialize and set up all game elements and logic when the script loads
// setupInitialGameScene(); // Game start is now deferred to user tap on the intro screen

===================================================================
--- original.js
+++ change.js
@@ -1,9 +1,12 @@
 /**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+
+/**** 
 * Initialize Game
 ****/ 
-// Gold color for the key
-// No plugins are explicitly required for this game's core mechanics at this stage.
 // Character and Key classes have been removed as they're no longer needed for the game
 // 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: 0x100806 // A very dark base color, suggesting a dim room
@@ -11,8 +14,9 @@
 
 /**** 
 * Game Code
 ****/ 
+// Gold color for the key
 // 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.
@@ -260,10 +264,20 @@
 	// Event listener on the main game stage to handle movement while dragging
 	game.move = function (x, y, eventObj) {
 		if (draggedKey) {
 			// If a key is being dragged
-			draggedKey.x = x; // Update the key's x position to the pointer's x
-			draggedKey.y = y; // Update the key's y position to the pointer's y
+			// Stop any previous position tween on the key to ensure responsiveness
+			tween.stop(draggedKey, {
+				x: true,
+				y: true
+			});
+			tween(draggedKey, {
+				x: x,
+				y: y
+			}, {
+				duration: 100,
+				easing: tween.linear
+			}); // Smoothly move the key
 			// Check for intersection with the first lock
 			if (!isLock1Open && lockclosed1.visible && draggedKey.intersects(lockclosed1)) {
 				lockclosed1.visible = false; // Hide the closed lock
 				if (lockopen1) {
@@ -284,8 +298,10 @@
 	// Event listener on the main game stage to handle release of the drag
 	game.up = function (x, y, eventObj) {
 		if (draggedKey) {
 			// If a key was being dragged
+			// Stop any active tween on the key to ensure its position is set definitively
+			tween.stop(draggedKey); // Stop all tweens on draggedKey
 			// It's good practice to ensure the dragged object's final position is set based on release coordinates
 			draggedKey.x = x;
 			draggedKey.y = y;
 			// Perform a final intersection check on release, in case the last 'move' event didn't catch it