/**** 
* 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
});

/**** 
* Game Code
****/ 
// 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 keyImage = null; // Asset for the key image
var signClickHere = null; // Asset for the "Click Here" sign
var bodyTouchCount = 0; // Moved from setupInitialGameScene for clarity and proper scope
var dragOffsetX = 0,
	dragOffsetY = 0; // Store offset of click within the key during drag
// 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
	// Add Sign_clickhere asset to guide tapping on the body
	signClickHere = LK.getAsset('Sign_clickhere', {
		anchorX: 2.4,
		// Center anchor
		anchorY: 3 // Center anchor
	});
	// Calculate the visual center of the body asset to position the sign accurately
	// body.anchor.x and body.anchor.y are set by LK.getAsset
	var bodyVisualCenterX = body.x + body.width * (0.5 - body.anchor.x);
	var bodyVisualCenterY = body.y + body.height * (0.5 - body.anchor.y);
	signClickHere.x = bodyVisualCenterX;
	// Position the sign so its bottom edge is roughly at the body's visual center, making it appear on top
	signClickHere.y = bodyVisualCenterY - signClickHere.height * 0.5;
	game.addChild(signClickHere);
	signClickHere.visible = true; // Make sure the sign is visible initially
	// Add KeyImage asset below the sign
	keyImage = LK.getAsset('Keyimage', {
		anchorX: 2.4,
		// Center horizontally on the body
		anchorY: 3 // Position the top edge below the sign
	});
	keyImage.x = signClickHere.x; // Center horizontally on the sign's new position
	// Position the key image below the sign with some spacing
	keyImage.y = signClickHere.y + signClickHere.height * 0.5 + keyImage.height * 0.1;
	game.addChild(keyImage);
	keyImage.visible = true; // Make sure the key image is visible initially
	// 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
			if (signClickHere) {
				// Check if the sign asset exists
				signClickHere.visible = false; // Hide the "Click Here" sign
			}
			if (keyImage) {
				// Check if the key image asset exists
				keyImage.visible = false; // Hide the key image
			}
		}
	};
	// 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 (x, y, obj) {
		if (key.visible) {
			// Start dragging the key
			draggedKey = key;
			// Store the offset of the click relative to the key's anchor point.
			// 'x' and 'y' are the pointer coordinates in the local space of the key (relative to its anchor).
			dragOffsetX = x;
			dragOffsetY = y;
			// The key's position will be updated in game.move, so it doesn't jump on click.
		}
	};
	// Event listener on the main game stage to handle movement while dragging
	game.move = function (x, y, eventObj) {
		if (draggedKey) {
			// Position the key's anchor so that the point originally clicked on the key follows the cursor.
			// 'x' and 'y' are global cursor coordinates from the game.move event.
			draggedKey.x = x - dragOffsetX;
			draggedKey.y = y - dragOffsetY;
			// 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
			// Set the key's final position maintaining the drag offset.
			// 'x' and 'y' are global cursor coordinates from the game.up event.
			draggedKey.x = x - dragOffsetX;
			draggedKey.y = y - dragOffsetY;
			// 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
@@ -143,13 +143,13 @@
 	game.addChild(signClickHere);
 	signClickHere.visible = true; // Make sure the sign is visible initially
 	// Add KeyImage asset below the sign
 	keyImage = LK.getAsset('Keyimage', {
-		anchorX: 0.5,
+		anchorX: 2.4,
 		// Center horizontally on the body
-		anchorY: 0 // Position the top edge below the sign
+		anchorY: 3 // Position the top edge below the sign
 	});
-	keyImage.x = bodyVisualCenterX;
+	keyImage.x = signClickHere.x; // Center horizontally on the sign's new position
 	// Position the key image below the sign with some spacing
 	keyImage.y = signClickHere.y + signClickHere.height * 0.5 + keyImage.height * 0.1;
 	game.addChild(keyImage);
 	keyImage.visible = true; // Make sure the key image is visible initially