/**** 
* 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
****/ 
// Global variables for game objects, drag state, and interaction states
// The LK engine can automatically initialize assets based on LK.getAsset calls.
// Defining them here with LK.init is for clarity and follows the example structure.
// In a real project, these would typically be image assets (e.g., 'background_room.png').
// Using shapes as placeholders for development.
// A dark, moody room color
var key = null;
var lockclosed1 = null,
	lockclosed2 = null;
var lockopen1 = null,
	lockopen2 = null;
var draggedObject = null; // Renamed from draggedKey to handle any draggable object
var isLock1Open = false,
	isLock2Open = false;
var bloodAsset = null; // Variable to hold the blood asset
var person = null; // Will hold the person asset
var personFreed = false; // Flag to track if the person has been changed to 'personfree'
var keyImage = null; // Asset for the key image
var signClickHere = null; // Asset for the "Click Here" sign
var body = null; // Will hold the body asset, needs to be global for knife interaction
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
var roomBackground = null; // Will hold the main game background asset
var knifeAsset = null; // Will hold the knife asset
// 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)
// Helper function to create blood effects
function createBloodEffectsAt(effectX, effectY) {
	var mainBloodSplat = LK.getAsset('blood', {
		anchorX: 4,
		// Using original anchor from body.down for visual consistency
		anchorY: -6,
		// Using original anchor
		x: effectX,
		y: effectY
	});
	game.addChild(mainBloodSplat);
	var bloodSplatterArray = [];
	for (var i = 0; i < 4 + Math.floor(Math.random() * 3); i++) {
		// 4-6 splats
		var angle = Math.random() * Math.PI * 2;
		var dist = 40 + Math.random() * 30; // 40-70 px away
		var size = 30 + Math.random() * 40; // 30-70 px size
		var blood1 = LK.getAsset('blood1', {
			anchorX: 6,
			// Original anchor
			anchorY: -10,
			// Original anchor
			x: effectX + Math.cos(angle) * dist,
			y: effectY + Math.sin(angle) * dist,
			width: size,
			height: size
		});
		game.addChild(blood1);
		bloodSplatterArray.push(blood1);
	}
	LK.setTimeout(function () {
		if (mainBloodSplat && mainBloodSplat.parent) {
			// Check if asset still exists before destroying
			mainBloodSplat.destroy();
		}
		for (var j = 0; j < bloodSplatterArray.length; j++) {
			if (bloodSplatterArray[j] && bloodSplatterArray[j].parent) {
				bloodSplatterArray[j].destroy();
			}
		}
	}, 500); // Blood effects last for 500ms
}
var canInteract = false; // Flag to control if elements can be clicked after game starts
var canInteract = false; // Flag to control if elements can be clicked after game starts
// 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
if (introActive) {
	// Start intro music only if the intro phase is active
	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() {
	LK.stopMusic(); // Ensure Intromusic1 is stopped when game scene initializes
	// Gamemusic1 will now be played after the sawface sequence.
	// 1. Background
	// The background is added first to ensure it's rendered behind all other game elements.
	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);
	// Add pic1 asset at the middle left of the screen, avoiding 500px area from left side
	var pic1 = LK.getAsset('pic1', {
		anchorX: 0.5,
		//{m} // Anchor at its left edge
		anchorY: 1,
		//{n} // Anchor at its vertical center
		x: 500,
		// Position its left edge 500px from the screen's left
		y: VIRTUAL_GAME_HEIGHT / 2 // Position its vertical center at the screen's middle
	});
	game.addChild(pic1);
	// 2. Body (player) - centered horizontally, near the bottom of the room
	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
	person = LK.getAsset('Person', {
		// Assign to global '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 knife asset to the game scene, beside the person (bottom left)
	knifeAsset = LK.getAsset('knife', {
		anchorX: -1.5,
		// Anchor at its right edge for easier positioning to the left of person
		anchorY: 1.2 // Anchor at its top edge for easier positioning below person
	});
	// Position the knife to the bottom-left of the person
	// Person's origin is its center due to anchorX: 1, anchorY: -0.5 in its creation
	// So, person's visual left edge is person.x - person.width * (1 - person.anchor.x)
	// and person's visual bottom edge is person.y + person.height * (1 - person.anchor.y)
	// Let's adjust based on person's anchor (1, -0.5 makes x center, y as if anchored at -0.5*height above actual center)
	// Visual left of person: person.x (since anchorX is 1, it's effectively centered on its right edge, so person.x is its right edge. person.x - person.width is left edge)
	// Visual bottom of person: person.y + person.height * 1.5 (since anchorY is -0.5, the visual bottom is tricky, let's use person.y + person.height/2 as a simpler reference if person was 0.5,0.5 anchored)
	// Corrected positioning relative to person's visual center and size
	// Person's visual center X: person.x - person.width * (person.anchor.x - 0.5)
	// Person's visual center Y: person.y + person.height * (person.anchor.y - 0.5) (Note: this is tricky with negative anchorY)
	// Let's use the person's x, y (which are set to VIRTUAL_GAME_WIDTH / 2, VIRTUAL_GAME_HEIGHT / 2)
	// And assume person asset is roughly centered around this point for visual placement
	knifeAsset.x = person.x - person.width / 2 + knifeAsset.width * 0.5; // Place it left of person's center, then adjust by knife's width
	knifeAsset.y = person.y + person.height / 2 - knifeAsset.height * 0.5; // Place it bottom of person's center, then adjust
	// Fine-tuning to be "close" and "bottom left"
	// If person's anchor is (1, -0.5), person.x is its right edge, person.y is above its visual center.
	// Let's target person's visual bottom left.
	// Person visual left edge approx person.x - person.width
	// Person visual bottom edge approx person.y + person.height (given -0.5 anchor)
	knifeAsset.x = person.x - person.width + knifeAsset.width * 0.2; // A bit to the right of person's absolute left
	knifeAsset.y = person.y + person.height * 0.5 - knifeAsset.height * 0.2; // A bit above person's absolute bottom (considering anchor)
	game.addChild(knifeAsset);
	// Make knifeAsset interactive and set up its drag listener
	knifeAsset.interactive = true;
	knifeAsset.down = function (x, y, obj) {
		if (!canInteract) {
			return;
		} // Do nothing if interaction is not yet allowed
		// Start dragging the knife
		draggedObject = knifeAsset;
		// Store the offset of the click relative to the knife's anchor point.
		dragOffsetX = x;
		dragOffsetY = y;
		// The knife's position will be updated in game.move.
	};
	// 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: 3,
		// Center horizontally on the body
		anchorY: 2.8 // 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
	// Disable interactions initially and enable after 36 seconds
	canInteract = false;
	LK.setTimeout(function () {
		if (isGameActive) {
			// Check if game is still running
			canInteract = true;
			// You could add a subtle visual cue here if desired, like a quick flash
		}
	}, 36000); // 36000 milliseconds = 36 seconds
	// Disable interactions initially and enable after 36 seconds
	canInteract = false;
	LK.setTimeout(function () {
		if (isGameActive) {
			// Check if game is still running
			canInteract = true;
			// You could add a subtle visual cue here if desired, like a quick flash
		}
	}, 36000); // 36000 milliseconds = 36 seconds
	// 5. Sawface
	var sawface = LK.getAsset('Sawface', {
		anchorX: -3.1,
		anchorY: 3,
		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;
					}
					// Start Gamemusic1 now that the sawface sequence is complete
					if (isGameActive) {
						// Only play if the game is still supposed to be running
						LK.playMusic('Gamemusic1');
					}
				}, 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
	// Add a tap listener to the body. Direct taps no longer reveal key or create blood.
	body.down = function (x, y, obj) {
		if (!canInteract) {
			return;
		} // Do nothing if interaction is not yet allowed
		// Key reveal and blood effects are now handled when the knife is used on the body (in game.up).
	};
	// 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 (!canInteract) {
			return;
		} // Do nothing if interaction is not yet allowed
		if (!canInteract) {
			return;
		} // Do nothing if interaction is not yet allowed
		if (key.visible) {
			// Start dragging the key
			draggedObject = key; // Use generalized draggedObject
			// 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.
		}
	};
	// Add a tap listener to the key to create blood asset
	// Event listener on the main game stage to handle movement while dragging
	game.move = function (x, y, eventObj) {
		if (draggedObject) {
			//{2b} // Use generalized draggedObject
			// Position the dragged object's anchor so that the point originally clicked on it follows the cursor.
			// 'x' and 'y' are global cursor coordinates from the game.move event.
			draggedObject.x = x - dragOffsetX;
			draggedObject.y = y - dragOffsetY;
			// If the dragged object is the key, check for lock interactions
			if (draggedObject === key) {
				// Check for intersection with the first lock
				if (!isLock1Open && lockclosed1.visible && key.intersects(lockclosed1)) {
					//{2e} // Ensure using 'key' for intersection
					lockclosed1.visible = false; // Hide the closed lock
					if (lockopen1) {
						lockopen1.visible = true;
					} // Show the open lock
					isLock1Open = true; // Mark this lock as opened
					checkAndFreePerson(); // Check if person should be freed
				}
				// Check for intersection with the second lock
				if (!isLock2Open && lockclosed2.visible && key.intersects(lockclosed2)) {
					//{2k} // Ensure using 'key' for intersection
					lockclosed2.visible = false; // Hide the closed lock
					if (lockopen2) {
						lockopen2.visible = true;
					} // Show the open lock
					isLock2Open = true; // Mark this lock as opened
					checkAndFreePerson(); // Check if person should be freed
				}
			}
			// Future: if (draggedObject === knifeAsset) { /* knife-specific move logic */ }
		}
	};
	// Event listener on the main game stage to handle release of the drag
	game.up = function (x, y, eventObj) {
		if (draggedObject) {
			//{2s} // Use generalized draggedObject
			// If an object was being dragged
			// Set the object's final position maintaining the drag offset.
			// 'x' and 'y' are global cursor coordinates from the game.up event.
			draggedObject.x = x - dragOffsetX;
			draggedObject.y = y - dragOffsetY;
			// If the dragged object was the key, perform a final intersection check
			if (draggedObject === key) {
				if (!isLock1Open && lockclosed1.visible && key.intersects(lockclosed1)) {
					//{2v} // Ensure using 'key' for intersection
					lockclosed1.visible = false;
					if (lockopen1) {
						lockopen1.visible = true;
					}
					isLock1Open = true;
					checkAndFreePerson(); // Check if person should be freed
				}
				if (!isLock2Open && lockclosed2.visible && key.intersects(lockclosed2)) {
					//{2B} // Ensure using 'key' for intersection
					lockclosed2.visible = false;
					if (lockopen2) {
						lockopen2.visible = true;
					}
					isLock2Open = true;
					checkAndFreePerson(); // Check if person should be freed
				}
			}
			// Else, if the dragged object was the knife, check for interaction with the body
			else if (draggedObject === knifeAsset) {
				// Ensure body and knifeAsset are not null before checking intersection
				if (body && knifeAsset && knifeAsset.intersects(body)) {
					// Create blood effects centered on the body's current position.
					// The createBloodEffectsAt function is defined globally.
					createBloodEffectsAt(body.x, body.y);
					// Increment touch count for knife interaction
					bodyTouchCount++;
					// Check if key should be revealed
					if (bodyTouchCount >= 7) {
						if (key) {
							key.visible = true; // Show the key after 7 successful knife uses
						}
						if (signClickHere) {
							signClickHere.visible = false; // Hide the "Click Here" sign
						}
						if (keyImage) {
							keyImage.visible = false; // Hide the key image
						}
					}
				}
				// Other knife-specific logic on release could go here if needed in the future.
			}
			draggedObject = null; // Release the object, 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.
	/** 
	* Checks if both locks are open and changes the person asset to 'personfree'.
	*/ 
	function checkAndFreePerson() {
		if (isLock1Open && isLock2Open && !personFreed) {
			if (person) {
				var oldX = person.x;
				var oldY = person.y;
				var oldAnchorX = person.anchor.x;
				var oldAnchorY = person.anchor.y;
				// To maintain drawing order, ideally we'd get the index.
				// For simplicity, we'll re-add; adjust if z-order becomes an issue.
				// var personIndex = game.getChildIndex(person); 
				person.destroy(); // Remove the old person asset
				person = LK.getAsset('personfree', {
					anchorX: oldAnchorX,
					anchorY: oldAnchorY,
					x: oldX,
					y: oldY
				});
				game.addChild(person); // Add the new 'personfree' asset
				// if (personIndex !== -1) game.addChildAt(person, personIndex);
				// else game.addChildAt(person, personIndex);
				// else game.addChild(person);
				personFreed = true; // Set flag to prevent this from running again
				// Hide the open locks
				if (lockopen1) {
					lockopen1.visible = false;
				}
				if (lockopen2) {
					lockopen2.visible = false;
				}
				// Change the background to Background2
				if (roomBackground) {
					roomBackground.destroy(); // Destroy the old background asset
				}
				roomBackground = LK.getAsset('Background2', {
					anchorX: 0,
					// Match original background's anchor
					anchorY: 0,
					// Match original background's anchor
					x: 0,
					// Match original background's position
					y: 0 // Match original background's position
					// Width and height will be taken from the 'Background2' asset definition
				});
				game.addChildAt(roomBackground, 0); // Add new background at the bottom layer (index 0)
				// Optional: Play a success sound or trigger other 'win' related events here
				// LK.getSound('someSuccessSound').play();
			}
		}
	}
}
/** 
* 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
		} else if (personFreed) {
			// Check if the person is freed
			isGameActive = false; // Set game state to inactive
			LK.clearInterval(gameUpdateTimerId); // Stop this timer
			LK.showYouWin(); // Trigger LK's game win 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
@@ -11,14 +11,14 @@
 
 /**** 
 * 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
+// The LK engine can automatically initialize assets based on LK.getAsset calls.
+// Defining them here with LK.init is for clarity and follows the example structure.
+// In a real project, these would typically be image assets (e.g., 'background_room.png').
+// Using shapes as placeholders for development.
+// A dark, moody room color
 var key = null;
 var lockclosed1 = null,
 	lockclosed2 = null;
 var lockopen1 = null,
@@ -612,8 +612,13 @@
 			// Time's up!
 			isGameActive = false; // Set game state to inactive
 			LK.clearInterval(gameUpdateTimerId); // Stop this timer
 			LK.showGameOver(); // Trigger LK's game over sequence
+		} else if (personFreed) {
+			// Check if the person is freed
+			isGameActive = false; // Set game state to inactive
+			LK.clearInterval(gameUpdateTimerId); // Stop this timer
+			LK.showYouWin(); // Trigger LK's game win sequence
 		}
 	}, 1000); // Interval of 1000 milliseconds (1 second)
 }
 // Main game loop, automatically called by the LK engine approximately 60 times per second
@@ -623,5 +628,5 @@
 	}
 	// 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
\ No newline at end of file
+// setupInitialGameScene(); // Game start is now deferred to user tap on the intro screen;
\ No newline at end of file