Update game.js

game.js

@@ -1,818 +1,390 @@
 import * as THREE from 'three';
-import * as CANNON from 'cannon-es';
-// import CannonDebugger from 'cannon-es-debugger'; // Keep commented for now
+// Optional: Add OrbitControls for debugging/viewing scene
+// import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
 
 // --- DOM Elements ---
 const sceneContainer = document.getElementById('scene-container');
+const storyTitleElement = document.getElementById('story-title');
+const storyContentElement = document.getElementById('story-content');
+const choicesElement = document.getElementById('choices');
 const statsElement = document.getElementById('stats-display');
 const inventoryElement = document.getElementById('inventory-display');
-const logElement = document.getElementById('log-display');
-
-// --- Config ---
-const ROOM_SIZE = 10;
-const WALL_HEIGHT = 3; // Slightly shorter walls
-const WALL_THICKNESS = 0.5;
-const CAMERA_Y_OFFSET = 25; // Higher camera
-const PLAYER_SPEED = 6;
-const PLAYER_RADIUS = 0.5;
-const PLAYER_HEIGHT = 1.8; // Visual height
-const PLAYER_JUMP_IMPULSE = 7; // Impulse force for jump
-const PROJECTILE_SPEED = 15;
-const PROJECTILE_RADIUS = 0.2;
-const PICKUP_RADIUS = 1.5;
-const PICKUP_RADIUS_SQ = PICKUP_RADIUS * PICKUP_RADIUS; // Use squared distance
 
 // --- Three.js Setup ---
-let scene, camera, renderer;
-let playerMesh;
-const meshesToSync = []; // Holds { mesh: THREE.Mesh, body: CANNON.Body }
-const projectiles = []; // Holds { mesh, body, lifetime }
-let axesHelper;
-
-// --- Physics Setup ---
-let world;
-let playerBody;
-const physicsBodies = new Map(); // Use Map<id, CANNON.Body> for easier removal
-let groundMaterial, playerMaterial, wallMaterial, monsterMaterial, itemMaterial; // Physics materials
-let cannonDebugger = null;
-
-// --- Game State ---
-let gameState = {};
-const keysPressed = {};
-let gameLoopActive = false;
-let animationFrameId = null;
-let selectedTool = null; // For building tools later
-
-// --- Game Data (Ensure starting point 0,0 exists!) ---
-const gameData = {
-    // Structure: "x,y": { type, features?, items?, monsters?, name? }
-    "0,0": { type: 'city', features: ['door_north', 'item_Key'], name: "City Square"},
-    "0,1": { type: 'forest', features: ['path_north', 'door_south', 'item_Healing_Potion'], name: "Forest Entrance" },
-    "0,2": { type: 'forest', features: ['path_south', 'monster_goblin'], name: "Deep Forest"},
-    "1,1": { type: 'forest', features: ['river', 'path_west'], name: "River Bend" },
-    "-1,1": { type: 'ruins', features: ['path_east'], name: "Old Ruins"},
-    "1,0": { type: 'plains', features: ['door_west'], name: "East Plains"},
-    "-1,0": { type: 'plains', features: ['door_east'], name: "West Plains"},
-};
-
-const itemsData = { // Add 'name' for consistency
-    "Healing Potion": { name: "Healing Potion", type: "consumable", description: "Restores 10 HP.", hpRestore: 10, model: 'sphere_red' },
-    "Key": { name: "Key", type: "quest", description: "A rusty key.", model: 'box_gold'},
-};
-
-const monstersData = { // Add 'name'
-    "goblin": { name: "Goblin", hp: 15, attack: 4, defense: 1, speed: 2.5, model: 'capsule_green', xp: 5 },
-};
-
-// --- Materials and Geometries (Defined once) ---
-// Using basic wireframe materials for initial debugging
-const debugMaterials = {
-    player: new THREE.MeshBasicMaterial({ color: 0x0077ff, wireframe: true }),
-    wall: new THREE.MeshBasicMaterial({ color: 0xff0000, wireframe: true }),
-    item: new THREE.MeshBasicMaterial({ color: 0x00ff00, wireframe: true }),
-    monster: new THREE.MeshBasicMaterial({ color: 0xff00ff, wireframe: true }),
-    projectile: new THREE.MeshBasicMaterial({ color: 0xffff00 }), // Keep projectiles solid
-    floor_default: new THREE.MeshBasicMaterial({ color: 0x555555, wireframe: true }), // Wireframe floor
-};
-// Normal Materials (Use after debugging)
-// const normalMaterials = {
-//     player: new THREE.MeshLambertMaterial({ color: 0x0077ff }),
-//     wall: new THREE.MeshLambertMaterial({ color: 0x888888 }),
-//     item_consumable: new THREE.MeshStandardMaterial({ color: 0xff0000, roughness: 0.6 }),
-//     item_quest: new THREE.MeshStandardMaterial({ color: 0xffd700, roughness: 0.4 }),
-//     monster_goblin: new THREE.MeshLambertMaterial({ color: 0x00ff00 }),
-//     floor_city: new THREE.MeshLambertMaterial({ color: 0xdeb887 }),
-//     floor_forest: new THREE.MeshLambertMaterial({ color: 0x228B22 }),
-//      // ... add all floor types
-//     floor_default: new THREE.MeshLambertMaterial({ color: 0xaaaaaa })
-// };
-const activeMaterials = debugMaterials; // Switch to normalMaterials when ready
-
-const geometries = { // Keep geometries simple
-    floor: new THREE.PlaneGeometry(ROOM_SIZE, ROOM_SIZE),
-    wallNS: new THREE.BoxGeometry(ROOM_SIZE, WALL_HEIGHT, WALL_THICKNESS),
-    wallEW: new THREE.BoxGeometry(WALL_THICKNESS, WALL_HEIGHT, ROOM_SIZE),
-    playerCylinder: new THREE.CylinderGeometry(PLAYER_RADIUS, PLAYER_RADIUS, PLAYER_HEIGHT - (PLAYER_RADIUS * 2), 8),
-    playerSphere: new THREE.SphereGeometry(PLAYER_RADIUS, 8, 8),
-    playerNose: new THREE.ConeGeometry(PLAYER_RADIUS * 0.3, PLAYER_RADIUS * 0.5, 4),
-    monsterCapsuleBody: new THREE.CylinderGeometry(0.4, 0.4, 1.0, 8),
-    monsterCapsuleHead: new THREE.SphereGeometry(0.4, 8, 8),
-    itemSphere: new THREE.SphereGeometry(0.3, 8, 8),
-    itemBox: new THREE.BoxGeometry(0.4, 0.4, 0.4),
-    projectile: new THREE.SphereGeometry(PROJECTILE_RADIUS, 6, 6),
-};
-
-
-// --- Initialization ---
-
-function init() {
-    console.log("--- Initializing Game ---");
-    // Reset state and clear arrays/maps
-    gameState = { inventory: [], stats: { hp: 30, maxHp: 30, strength: 7, wisdom: 5, courage: 6 }, monsters: [], items: [] };
-    keysPressed = {};
-    meshesToSync.length = 0;
-    projectiles.length = 0;
-    physicsBodies.clear(); // Clear the map
-
-    // Clear previous scene if restarting
-    if (scene) {
-        while (scene.children.length > 0) scene.remove(scene.children[0]);
-    } else {
-        scene = new THREE.Scene(); // Create scene only if it doesn't exist
-    }
-    scene.background = new THREE.Color(0x1a1a1a);
-
-    // Clear previous renderer if restarting
-    if (renderer) {
-        renderer.dispose();
-        if (renderer.domElement.parentNode) {
-            renderer.domElement.parentNode.removeChild(renderer.domElement);
-        }
-    }
-
-    initThreeJS(); // Setup camera, renderer, lights
-    initPhysics(); // Setup world, materials
-    initPlayer();  // Setup player mesh + body
-    generateMap(); // Setup static map meshes + bodies
-    setupInputListeners();
-    updateUI();
-    addLog("Welcome! Move: QWEASDZXC, Jump: X, Attack: Space, Pickup: F", "info");
-    console.log("--- Initialization Complete ---");
-
-    if (animationFrameId) cancelAnimationFrame(animationFrameId);
-    gameLoopActive = true;
-    animate();
-}
+let scene, camera, renderer, cube; // Basic scene object
+// let controls; // Optional OrbitControls
 
 function initThreeJS() {
-    console.log("Initializing Three.js...");
-    const aspect = sceneContainer.clientWidth / sceneContainer.clientHeight;
-    camera = new THREE.PerspectiveCamera(60, aspect, 0.1, 1000);
-    // Set camera directly overhead looking down
-    camera.position.set(0, CAMERA_Y_OFFSET, 0);
-    camera.lookAt(0, 0, 0); // Look straight down at origin initially
-    camera.rotation.x = -Math.PI / 2; // Explicitly set rotation if lookAt isn't enough
+    // Scene
+    scene = new THREE.Scene();
+    scene.background = new THREE.Color(0x222222); // Match body background
+
+    // Camera
+    camera = new THREE.PerspectiveCamera(75, sceneContainer.clientWidth / sceneContainer.clientHeight, 0.1, 1000);
+    camera.position.z = 5;
 
+    // Renderer
     renderer = new THREE.WebGLRenderer({ antialias: true });
     renderer.setSize(sceneContainer.clientWidth, sceneContainer.clientHeight);
-    renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = THREE.PCFSoftShadowMap;
     sceneContainer.appendChild(renderer.domElement);
 
-    // Lighting
-    scene.add(new THREE.AmbientLight(0xffffff, 0.7)); // Brighter ambient for debug
-    const dirLight = new THREE.DirectionalLight(0xffffff, 1.0);
-    dirLight.position.set(10, 30, 20); // Angled light
-    dirLight.castShadow = true;
-    dirLight.shadow.mapSize.width = 1024;
-    dirLight.shadow.mapSize.height = 1024;
-    scene.add(dirLight);
-
-    // Axes Helper
-    axesHelper = new THREE.AxesHelper(ROOM_SIZE * 0.5);
-    axesHelper.position.set(0, 0.01, 0);
-    scene.add(axesHelper);
-    console.log("Three.js Initialized. Camera at:", camera.position);
+    // Basic Lighting
+    const ambientLight = new THREE.AmbientLight(0xffffff, 0.6); // Soft white light
+    scene.add(ambientLight);
+    const directionalLight = new THREE.DirectionalLight(0xffffff, 1.0);
+    directionalLight.position.set(5, 10, 7.5);
+    scene.add(directionalLight);
 
-    window.addEventListener('resize', onWindowResize, false);
-}
+    // Basic Object (Placeholder for scene illustration)
+    const geometry = new THREE.BoxGeometry(1, 1, 1);
+    const material = new THREE.MeshStandardMaterial({ color: 0xcccccc }); // Default color
+    cube = new THREE.Mesh(geometry, material);
+    scene.add(cube);
 
-function initPhysics() {
-    console.log("Initializing Cannon-es...");
-    world = new CANNON.World({ gravity: new CANNON.Vec3(0, -15, 0) });
-    world.broadphase = new CANNON.SAPBroadphase(world);
-    world.allowSleep = true;
-
-    // Define materials
-    groundMaterial = new CANNON.Material("ground");
-    playerMaterial = new CANNON.Material("player");
-    wallMaterial = new CANNON.Material("wall");
-    monsterMaterial = new CANNON.Material("monster");
-    itemMaterial = new CANNON.Material("item"); // Not used for physics bodies anymore
-
-    // Ground physics body
-    const groundShape = new CANNON.Plane();
-    const groundBody = new CANNON.Body({ mass: 0, material: groundMaterial });
-    groundBody.addShape(groundShape);
-    groundBody.quaternion.setFromEuler(-Math.PI / 2, 0, 0);
-    world.addBody(groundBody);
-    physicsBodies.set(groundBody.id, groundBody); // Track it
-
-    // Contact Materials
-    const playerGround = new CANNON.ContactMaterial(playerMaterial, groundMaterial, { friction: 0.1, restitution: 0.1 }); // Low friction
-    const playerWall = new CANNON.ContactMaterial(playerMaterial, wallMaterial, { friction: 0.01, restitution: 0.1 }); // Very low friction vs walls
-    const monsterGround = new CANNON.ContactMaterial(monsterMaterial, groundMaterial, { friction: 0.4, restitution: 0.1 });
-    const monsterWall = new CANNON.ContactMaterial(monsterMaterial, wallMaterial, { friction: 0.1, restitution: 0.2 });
-
-    world.addContactMaterial(playerGround);
-    world.addContactMaterial(playerWall);
-    world.addContactMaterial(monsterGround);
-    world.addContactMaterial(monsterWall);
-    console.log("Physics World Initialized.");
-
-    // Optional: Physics Debugger Init
-    // try { cannonDebugger = new CannonDebugger(scene, world, { color: 0x00ff00 }); console.log("Debugger Init."); }
-    // catch (e) { console.error("Failed CannonDebugger.", e); }
-}
+    // Optional Controls
+    // controls = new OrbitControls(camera, renderer.domElement);
+    // controls.enableDamping = true;
 
-// --- Primitive Assembly Functions ---
-function createPlayerMesh() {
-    const group = new THREE.Group();
-    const bodyMat = activeMaterials.player; // Use active material set
-    const body = new THREE.Mesh(geometries.playerCylinder, bodyMat);
-    body.position.y = PLAYER_RADIUS; body.castShadow = true;
-    const head = new THREE.Mesh(geometries.playerSphere, bodyMat);
-    head.position.y = PLAYER_HEIGHT - PLAYER_RADIUS; head.castShadow = true;
-    group.add(body); group.add(head);
-    const nose = new THREE.Mesh(geometries.playerNose, new THREE.MeshBasicMaterial({ color: 0xffff00 })); // Nose always bright yellow
-    nose.position.set(0, PLAYER_HEIGHT * 0.6, PLAYER_RADIUS); // Point forward +Z
-    // No rotation needed if pointing +Z
-    group.add(nose);
-    // Important: Set group's origin to the intended base/center of the physics body
-    group.position.set(0, 0, 0); // Position will be controlled by sync
-    return group;
- }
-function createSimpleMonsterMesh(modelType = 'capsule_green') {
-    const group = new THREE.Group();
-    const mat = activeMaterials.monster; // Use active debug/normal material
-    if (modelType === 'capsule_green') {
-        const body = new THREE.Mesh(geometries.monsterCapsuleBody, mat);
-        const head = new THREE.Mesh(geometries.monsterCapsuleHead, mat);
-        body.position.y = 0.5; head.position.y = 1.0 + 0.4;
-        group.add(body); group.add(head);
-    } else { /* Add other monster types if needed */ }
-    group.traverse(child => { if (child.isMesh) child.castShadow = true; });
-    group.position.set(0, 0, 0); // Position set by sync
-    return group;
-}
-function createSimpleItemMesh(modelType = 'sphere_red') {
-     let geom;
-     const mat = activeMaterials.item; // Use active debug/normal material
-     if(modelType === 'sphere_red') geom = geometries.itemSphere;
-     else if (modelType === 'box_gold') geom = geometries.itemBox;
-     else geom = geometries.itemSphere; // Default
-     const mesh = new THREE.Mesh(geom, mat);
-     mesh.position.y = PLAYER_RADIUS; // Default height
-     mesh.castShadow = true;
-     return mesh;
-}
-function createProjectileMesh() {
-    const mat = activeMaterials.projectile; // Use active material
-    const mesh = new THREE.Mesh(geometries.projectile, mat);
-    return mesh;
-}
+    // Handle Resize
+    window.addEventListener('resize', onWindowResize, false);
 
-// --- Player Setup ---
-function initPlayer() {
-    console.log("Initializing Player...");
-    // Visual Mesh
-    playerMesh = createPlayerMesh();
-    // Set initial position high to avoid spawning inside floor
-    playerMesh.position.set(0, PLAYER_HEIGHT + 1, 0);
-    scene.add(playerMesh);
-    console.log("Player mesh added to scene at initial pos:", playerMesh.position);
-
-    // Physics Body - Start at center of 0,0 cell, slightly above ground
-    const startX = 0;
-    const startZ = 0;
-    const startY = PLAYER_HEIGHT * 1.5; // Start higher
-    const playerShape = new CANNON.Sphere(PLAYER_RADIUS);
-    playerBody = new CANNON.Body({
-        mass: 70,
-        shape: playerShape,
-        position: new CANNON.Vec3(startX, startY, startZ),
-        linearDamping: 0.95,
-        angularDamping: 1.0, // Completely prevent angular rotation from physics
-        material: playerMaterial // Use defined material
-    });
-    playerBody.allowSleep = false;
-    playerBody.addEventListener("collide", handlePlayerCollision);
-    world.addBody(playerBody);
-    physicsBodies.set(playerBody.id, playerBody); // Track body using Map
-    console.log(`Player physics body added at ${startX}, ${startY}, ${startZ}`);
-
-    // Add to sync list
-    meshesToSync.push({ mesh: playerMesh, body: playerBody });
-    console.log("Player added to sync list.");
+    // Start Animation Loop
+    animate();
 }
 
-// --- Map Generation ---
-function generateMap() {
-    console.log("Generating Map...");
-    const wallPhysicsMaterial = world.materials.find(m => m.name === "wall");
-    const groundPhysicsMaterial = world.materials.find(m => m.name === "ground");
-
-    // DEBUG: Only generate the starting cell "0,0"
-    const startCoord = "0,0";
-    const data = gameData[startCoord];
-    if (!data) {
-        console.error("CRITICAL: No gameData found for starting cell '0,0'!");
-        return;
-    }
-
-    const x = 0;
-    const z = 0;
-    const type = data.type || 'default';
-    console.log(`Generating START cell: ${startCoord} (Type: ${type})`);
-
-    // Create Floor Mesh
-    const floorMat = activeMaterials[`floor_${type}`] || activeMaterials.floor_default; // Use debug mats
-    const floorMesh = new THREE.Mesh(geometries.floor, floorMat);
-    floorMesh.rotation.x = -Math.PI / 2;
-    floorMesh.position.set(x * ROOM_SIZE, 0, z * ROOM_SIZE);
-    floorMesh.receiveShadow = true; // Floors should receive shadows
-    scene.add(floorMesh);
-    console.log(`Added floor at ${x},${z}`);
-
-    // Create Walls (Visual + Physics) for the single cell
-    const features = data.features || [];
-    const wallDefs = [
-        ['north', geometries.wallNS, 0, -0.5], ['south', geometries.wallNS, 0, 0.5],
-        ['east', geometries.wallEW, 0.5, 0], ['west', geometries.wallEW, -0.5, 0],
-    ];
-
-    wallDefs.forEach(([dir, geom, xOff, zOff]) => {
-        const doorFeature = `door_${dir}`; const pathFeature = `path_${dir}`;
-        if (!features.includes(doorFeature) && !features.includes(pathFeature)) {
-            const wallX = x * ROOM_SIZE + xOff * ROOM_SIZE;
-            const wallZ = z * ROOM_SIZE + zOff * ROOM_SIZE;
-            const wallY = WALL_HEIGHT / 2;
-
-            // Visual Wall (DEBUG)
-            const wallMesh = new THREE.Mesh(geom, activeMaterials.wall); // Use debug wall mat
-            wallMesh.position.set(wallX, wallY, wallZ);
-            wallMesh.castShadow = true; wallMesh.receiveShadow = true;
-            scene.add(wallMesh);
-
-            // Physics Wall
-            const wallShape = new CANNON.Box(new CANNON.Vec3(geom.parameters.width / 2, geom.parameters.height / 2, geom.parameters.depth / 2));
-            const wallBody = new CANNON.Body({ mass: 0, shape: wallShape, position: new CANNON.Vec3(wallX, wallY, wallZ), material: wallPhysicsMaterial });
-            world.addBody(wallBody);
-            physicsBodies.set(wallBody.id, wallBody); // Track it
-            // console.log(`Added ${dir} wall for cell ${x},${z}`);
-        } else {
-             console.log(`Skipping ${dir} wall for cell ${x},${z} due to feature.`);
-        }
-    });
-
-    // Spawn Items & Monsters based on features for the single cell
-    features.forEach(feature => {
-         if (feature.startsWith('item_')) {
-             const itemName = feature.substring(5).replace(/_/g, ' ');
-             if (itemsData[itemName]) spawnItem(itemName, x, z);
-             else console.warn(`Item feature found but no data for: ${itemName}`);
-         } else if (feature.startsWith('monster_')) {
-             const monsterType = feature.substring(8);
-             if (monstersData[monsterType]) spawnMonster(monsterType, x, z);
-             else console.warn(`Monster feature found but no data for: ${monsterType}`);
-         }
-     });
-
-    console.log("Map Generation Complete (Debug Mode - Single Cell).");
+function onWindowResize() {
+    if (!renderer || !camera) return;
+    camera.aspect = sceneContainer.clientWidth / sceneContainer.clientHeight;
+    camera.updateProjectionMatrix();
+    renderer.setSize(sceneContainer.clientWidth, sceneContainer.clientHeight);
 }
 
-// --- Item/Monster Spawning (Simplified for Pickup 'F') ---
-function spawnItem(itemName, gridX, gridZ) {
-    const itemData = itemsData[itemName];
-    if (!itemData) return;
-    const x = gridX * ROOM_SIZE + (Math.random() - 0.5) * (ROOM_SIZE * 0.4);
-    const z = gridZ * ROOM_SIZE + (Math.random() - 0.5) * (ROOM_SIZE * 0.4);
-    const y = PLAYER_RADIUS; // Item height
-
-    // Use DEBUG material
-    const mesh = createSimpleItemMesh(itemData.model); // Use debug mat via create func
-    if (!mesh) return; // Safety check
-    mesh.position.set(x, y, z);
-    mesh.userData = { type: 'item', name: itemName }; // Store data on mesh
-    mesh.castShadow = true;
-    scene.add(mesh);
-
-    // Store item in game state WITHOUT physics body
-    gameState.items.push({
-        id: mesh.uuid, // Use mesh UUID as item ID
-        name: itemName,
-        mesh: mesh,
-        position: mesh.position // Store position for proximity check
-    });
-    console.log(`Spawned item ${itemName} at ${x.toFixed(1)}, ${y.toFixed(1)}, ${z.toFixed(1)} (visual only)`);
-}
+function animate() {
+    requestAnimationFrame(animate);
 
-function spawnMonster(monsterType, gridX, gridZ) {
-    const monsterData = monstersData[monsterType];
-    if (!monsterData) return;
-    const x = gridX * ROOM_SIZE + (Math.random() - 0.5) * (ROOM_SIZE * 0.4);
-    const z = gridZ * ROOM_SIZE + (Math.random() - 0.5) * (ROOM_SIZE * 0.4);
-    const y = PLAYER_HEIGHT; // Start higher
-
-    // Use DEBUG material
-    const mesh = createSimpleMonsterMesh(monsterData.model); // Uses debug mat via create func
-    if (!mesh) return; // Safety check
-    mesh.position.set(x, y, z); // Initial visual position
-    mesh.userData = { type: 'monster', monsterType: monsterType };
-    scene.add(mesh);
-
-    // Physics Body
-    const shape = new CANNON.Sphere(PLAYER_RADIUS * 0.8);
-    const body = new CANNON.Body({
-        mass: 10, shape: shape, position: new CANNON.Vec3(x, y, z),
-        linearDamping: 0.8, angularDamping: 0.9,
-        material: world.materials.find(m => m.name === "monster") || new CANNON.Material("monster")
-    });
-    body.allowSleep = true;
-    // Store reference to mesh and HP on body's userData
-    body.userData = { type: 'monster', monsterType: monsterType, mesh: mesh, hp: monsterData.hp };
-    world.addBody(body);
-
-    gameState.monsters.push({ id: body.id, type: monsterType, hp: monsterData.hp, body: body, mesh: mesh });
-    meshesToSync.push({ mesh: mesh, body: body });
-    physicsBodies.set(body.id, body); // Use map for tracking
-    console.log(`Spawned monster ${monsterType} at ${x.toFixed(1)}, ${y.toFixed(1)}, ${z.toFixed(1)}`);
-}
+    // Simple animation
+    if (cube) {
+        cube.rotation.x += 0.005;
+        cube.rotation.y += 0.005;
+    }
 
+    // if (controls) controls.update(); // If using OrbitControls
 
-// --- Input Handling (QWEASDZXC + Jump 'X' + F + Space) ---
-function setupInputListeners() { /* ... same ... */
-    console.log("Setting up input listeners.");
-    window.addEventListener('keydown', (event) => { keysPressed[event.key.toLowerCase()] = true; keysPressed[event.code] = true; if (['space', 'arrowup', 'arrowdown', 'arrowleft', 'arrowright', 'keyx', 'keyf'].includes(event.code.toLowerCase())) { event.preventDefault(); }});
-    window.addEventListener('keyup', (event) => { keysPressed[event.key.toLowerCase()] = false; keysPressed[event.code] = false; });
+    if (renderer && scene && camera) {
+        renderer.render(scene, camera);
+    }
 }
 
-function handleInput(deltaTime) {
-    if (!playerBody) return;
-
-    const moveSpeed = PLAYER_SPEED;
-    // Correct forward/backward/strafe directions relative to world axes
-    // Assume +Z is SOUTH, -Z is NORTH
-    // Assume +X is EAST, -X is WEST
-    let forceX = 0;
-    let forceZ = 0;
-
-    // Forward (-Z) / Backward (+Z)
-    if (keysPressed['w']) forceZ -= 1; // W = North = -Z
-    if (keysPressed['s']) forceZ += 1; // S = South = +Z
-
-    // Strafe Left (-X) / Right (+X)
-    if (keysPressed['a']) forceX -= 1; // A = West = -X
-    if (keysPressed['d']) forceX += 1; // D = East = +X
-
-    // Diagonals - combine basic directions
-    if (keysPressed['q']) { forceZ -= 0.707; forceX -= 0.707; } // Q = NW
-    if (keysPressed['e']) { forceZ -= 0.707; forceX += 0.707; } // E = NE
-    if (keysPressed['z']) { forceZ += 0.707; forceX -= 0.707; } // Z = SW
-    if (keysPressed['c']) { forceZ += 0.707; forceX += 0.707; } // C = SE
-
-    // --- Calculate final velocity vector ---
-    // We set velocity directly for more responsive control than forces
-    const targetVelocity = new CANNON.Vec3(0, playerBody.velocity.y, 0); // Preserve Y velocity
-
-    if (forceX !== 0 || forceZ !== 0) {
-        const moveVec = new THREE.Vector2(forceX, forceZ);
-        if (moveVec.lengthSq() > 1.0) { // Normalize only if combined magnitude > 1
-            moveVec.normalize();
-        }
-        targetVelocity.x = moveVec.x * moveSpeed;
-        targetVelocity.z = moveVec.y * moveSpeed;
-
-        // --- Rotation ---
-        // Rotate player mesh to face movement direction
-        // Calculate angle from positive Z axis (adjust if your model faces differently)
-        const angle = Math.atan2(targetVelocity.x, targetVelocity.z);
-        const targetQuaternion = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), angle);
-        // Slerp for smooth rotation
-        playerMesh.quaternion.slerp(targetQuaternion, 0.15); // Adjust 0.15 for responsiveness
+// --- Game Data (Ported from Python, simplified for now) ---
+const gameData = {
+    "1": {
+        title: "The Beginning",
+        content: `<p>The Evil Power Master has been terrorizing the land... You stand at the entrance to Silverhold, ready to begin your quest.</p><p>How will you prepare?</p>`,
+        options: [
+            { text: "Visit the local weaponsmith", next: 2, /* addItem: "..." */ },
+            { text: "Seek wisdom at the temple", next: 3, /* addItem: "..." */ },
+            { text: "Meet the resistance leader", next: 4, /* addItem: "..." */ }
+        ],
+        illustration: "city-gates" // Key for Three.js scene
+    },
+    "2": {
+        title: "The Weaponsmith",
+        content: `<p>Gorn the weaponsmith welcomes you. "You'll need more than common steel," he says, offering weapons.</p>`,
+        options: [
+            { text: "Take the Flaming Sword", next: 5, addItem: "Flaming Sword" },
+            { text: "Choose the Whispering Bow", next: 5, addItem: "Whispering Bow" },
+            { text: "Select the Guardian Shield", next: 5, addItem: "Guardian Shield" }
+        ],
+        illustration: "weaponsmith"
+    },
+    "3": {
+        title: "The Ancient Temple",
+        content: `<p>High Priestess Alara greets you. "Prepare your mind and spirit." She offers to teach you a secret art.</p>`,
+        options: [
+            { text: "Learn Healing Light", next: 5, addItem: "Healing Light Spell" },
+            { text: "Master Shield of Faith", next: 5, addItem: "Shield of Faith Spell" },
+            { text: "Study Binding Runes", next: 5, addItem: "Binding Runes Scroll" }
+        ],
+        illustration: "temple"
+    },
+    "4": {
+        title: "The Resistance Leader",
+        content: `<p>Lyra, the resistance leader, shows you a map. "His fortress has three possible entry points." She offers an item.</p>`,
+        options: [
+            { text: "Take the Secret Tunnel Map", next: 5, addItem: "Secret Tunnel Map" },
+            { text: "Accept Poison Daggers", next: 5, addItem: "Poison Daggers" },
+            { text: "Choose the Master Key", next: 5, addItem: "Master Key" }
+        ],
+        illustration: "resistance-meeting"
+    },
+    "5": {
+        title: "The Journey Begins",
+        content: `<p>You leave Silverhold and enter the corrupted Shadowwood Forest. Strange sounds echo. Which path will you take?</p>`,
+        options: [
+            { text: "Take the main road", next: 6 }, // Leads to page 6 (Ambush)
+            { text: "Follow the river path", next: 7 }, // Leads to page 7 (River Spirit)
+            { text: "Brave the ruins shortcut", next: 8 } // Leads to page 8 (Ruins)
+        ],
+        illustration: "shadowwood-forest" // Key for Three.js scene
+        // Add more pages here...
+    },
+     // Add placeholder pages 6, 7, 8 etc. to continue the story
+     "6": {
+         title: "Ambush!",
+         content: "<p>Scouts jump out! 'Surrender!'</p>",
+         options: [{ text: "Fight!", next: 9 }, { text: "Try to flee!", next: 10 }], // Example links
+         illustration: "road-ambush"
+     },
+     // ... Add many more pages based on your Python data ...
+     "9": { // Example continuation
+         title: "Victory!",
+         content: "<p>You defeat the scouts and continue.</p>",
+         options: [{ text: "Proceed to the fortress plains", next: 15 }],
+         illustration: "forest-edge"
+     },
+     "10": { // Example continuation
+         title: "Captured!",
+         content: "<p>You failed to escape and are captured!</p>",
+         options: [{ text: "Accept fate (for now)", next: 20 }], // Go to prison wagon page
+         illustration: "prisoner-cell"
+     },
+     // Game Over placeholder
+     "99": {
+        title: "Game Over",
+        content: "<p>Your adventure ends here.</p>",
+        options: [{ text: "Restart", next: 1 }], // Link back to start
+        illustration: "game-over",
+        gameOver: true
+     }
+};
 
-    } else {
-        // No movement keys pressed - rely on linear damping to stop
-        // Or force stop X/Z velocity:
-         targetVelocity.x = 0;
-         targetVelocity.z = 0;
-    }
+const itemsData = { // Simplified item data
+    "Flaming Sword": { type: "weapon", description: "A fiery blade" },
+    "Whispering Bow": { type: "weapon", description: "A silent bow" },
+    "Guardian Shield": { type: "armor", description: "A protective shield" },
+    "Healing Light Spell": { type: "spell", description: "Mends minor wounds" },
+    "Shield of Faith Spell": { type: "spell", description: "Temporary shield" },
+    "Binding Runes Scroll": { type: "spell", description: "Binds an enemy" },
+    "Secret Tunnel Map": { type: "quest", description: "Shows a hidden path" },
+    "Poison Daggers": { type: "weapon", description: "Daggers with poison" },
+    "Master Key": { type: "quest", description: "Unlocks many doors" },
+    // Add other items...
+};
 
-    playerBody.velocity.x = targetVelocity.x;
-    playerBody.velocity.z = targetVelocity.z;
-    // Y velocity is controlled by gravity + jump impulse
-
-    // --- Jump (X) ---
-    if (keysPressed['x'] || keysPressed['keyx']) { // Check code too
-        // !! Basic jump - Needs ground check via raycast or contact materials !!
-        // Add a simple cooldown or only allow if Y velocity is low
-         if (Math.abs(playerBody.velocity.y) < 0.5) { // Crude check if mostly grounded
-             console.log("JUMP!");
-             addLog("Jump!", "info");
-             // Apply impulse upwards
-             playerBody.applyImpulse(new CANNON.Vec3(0, PLAYER_JUMP_IMPULSE, 0), playerBody.position);
-        }
-        keysPressed['x'] = false; keysPressed['keyx'] = false; // Consume jump input
+// --- Game State ---
+let gameState = {
+    currentPageId: 1,
+    inventory: [],
+    stats: {
+        courage: 7,
+        wisdom: 5,
+        strength: 6,
+        hp: 30,
+        maxHp: 30
     }
+};
 
-    // --- Pickup (F) ---
-    if (keysPressed['f'] || keysPressed['keyf']) {
-        pickupNearbyItem();
-        keysPressed['f'] = false; keysPressed['keyf'] = false; // Consume pickup input
-    }
+// --- Game Logic Functions ---
 
-    // --- Fire (Space) ---
-    if (keysPressed['space']) {
-        fireProjectile();
-        keysPressed['space'] = false; // Consume fire input
-    }
+function startGame() {
+    gameState = { // Reset state
+        currentPageId: 1,
+        inventory: [],
+        stats: { courage: 7, wisdom: 5, strength: 6, hp: 30, maxHp: 30 }
+    };
+    renderPage(gameState.currentPageId);
 }
 
-// --- Interaction Logic ---
-function pickupNearbyItem() {
-    if (!playerBody) return;
-    const playerPos = playerBody.position;
-    let pickedUp = false;
-    let closestItemIndex = -1;
-    let minDistanceSq = PICKUP_RADIUS_SQ; // Use squared distance
-
-    // Find the closest item within radius
-    for (let i = 0; i < gameState.items.length; i++) {
-        const item = gameState.items[i];
-        const distanceSq = playerPos.distanceSquared(item.position);
-        if (distanceSq < minDistanceSq) {
-            minDistanceSq = distanceSq;
-            closestItemIndex = i;
-        }
-    }
-
-    // Pick up the closest item if found
-    if (closestItemIndex > -1) {
-        const item = gameState.items[closestItemIndex];
-        if (!gameState.inventory.includes(item.name)) {
-            gameState.inventory.push(item.name);
-            addLog(`Picked up ${item.name}!`, "pickup");
-            updateInventoryDisplay();
-
-            // Remove item visually and from state
-            if(item.mesh.parent) scene.remove(item.mesh);
-            gameState.items.splice(closestItemIndex, 1);
-            pickedUp = true;
-        } else {
-             addLog(`Already have ${item.name}.`, "info");
-        }
+function renderPage(pageId) {
+    const page = gameData[pageId];
+    if (!page) {
+        console.error(`Error: Page data not found for ID: ${pageId}`);
+        storyTitleElement.textContent = "Error";
+        storyContentElement.innerHTML = "<p>Could not load page data. Adventure halted.</p>";
+        choicesElement.innerHTML = '<button class="choice-button" onclick="handleChoice(1)">Restart</button>'; // Provide restart option
+        updateScene('error'); // Show error scene
+        return;
     }
 
-    if (!pickedUp) {
-        addLog("Nothing nearby to pick up.", "info");
+    // Update UI
+    storyTitleElement.textContent = page.title || "Untitled Page";
+    storyContentElement.innerHTML = page.content || "<p>...</p>";
+    updateStatsDisplay();
+    updateInventoryDisplay();
+
+    // Update Choices
+    choicesElement.innerHTML = ''; // Clear old choices
+    if (page.options && page.options.length > 0) {
+        page.options.forEach(option => {
+            const button = document.createElement('button');
+            button.classList.add('choice-button');
+            button.textContent = option.text;
+
+            // Check requirements (basic check for now)
+            let requirementMet = true;
+            if (option.requireItem && !gameState.inventory.includes(option.requireItem)) {
+                requirementMet = false;
+                button.title = `Requires: ${option.requireItem}`; // Tooltip
+                button.disabled = true;
+            }
+            // Add requireAnyItem check here later if needed
+
+            if (requirementMet) {
+                // Store data needed for handling the choice
+                button.dataset.nextPage = option.next;
+                if (option.addItem) {
+                    button.dataset.addItem = option.addItem;
+                }
+                // Add other potential effects as data attributes if needed
+
+                button.onclick = () => handleChoiceClick(button.dataset);
+            }
+
+            choicesElement.appendChild(button);
+        });
+    } else if (page.gameOver) {
+         const button = document.createElement('button');
+         button.classList.add('choice-button');
+         button.textContent = "Restart Adventure";
+         button.dataset.nextPage = 1; // Restart goes to page 1
+         button.onclick = () => handleChoiceClick(button.dataset);
+         choicesElement.appendChild(button);
+    } else {
+        choicesElement.innerHTML = '<p><i>No further options available from here.</i></p>';
+         const button = document.createElement('button');
+         button.classList.add('choice-button');
+         button.textContent = "Restart Adventure";
+         button.dataset.nextPage = 1; // Restart goes to page 1
+         button.onclick = () => handleChoiceClick(button.dataset);
+         choicesElement.appendChild(button);
     }
-}
 
 
-// --- Combat (Projectile logic remains similar) ---
-function fireProjectile() {
-    if (!playerBody || !playerMesh) return;
-    addLog("Pew!", "combat");
-    const projectileMesh = createProjectileMesh();
-    const projectileShape = new CANNON.Sphere(PROJECTILE_RADIUS);
-    const projectileBody = new CANNON.Body({ mass: 0.1, shape: projectileShape, linearDamping: 0.01, angularDamping: 0.01 });
-    projectileBody.addEventListener("collide", handleProjectileCollision);
-
-    // Calculate start position and velocity based on player's *current* rotation
-    const offsetDistance = PLAYER_RADIUS + PROJECTILE_RADIUS + 0.1;
-    const direction = new THREE.Vector3(0, 0, 1); // Base direction +Z
-    direction.applyQuaternion(playerMesh.quaternion); // Rotate based on player mesh
-
-    const startPos = new CANNON.Vec3().copy(playerBody.position).vadd(
-        new CANNON.Vec3(direction.x, 0, direction.z).scale(offsetDistance) // Offset horizontally
-    );
-    // Adjust start Y based on player body center + visual model height
-    startPos.y = playerBody.position.y; // Fire from player center height
-
-    projectileBody.position.copy(startPos);
-    projectileMesh.position.copy(startPos);
-
-    // Velocity in player facing direction
-    projectileBody.velocity = new CANNON.Vec3(direction.x, 0, direction.z).scale(PROJECTILE_SPEED);
-
-    scene.add(projectileMesh);
-    world.addBody(projectileBody);
-    const projectileData = { mesh: projectileMesh, body: projectileBody, lifetime: 2.0 }; // Shorter lifetime
-    meshesToSync.push(projectileData);
-    projectiles.push(projectileData);
-    physicsBodies.set(projectileBody.id, projectileBody); // Track
-    projectileBody.userData = { type: 'projectile', data: projectileData };
-    projectileMesh.userData = { type: 'projectile', data: projectileData }; // No body ref needed on mesh
+    // Update 3D Scene
+    updateScene(page.illustration || 'default');
 }
 
-// --- Collision Handling ---
-function handlePlayerCollision(event) {
-    const otherBody = event.body;
-    if (!otherBody || !otherBody.userData || !playerBody) return;
-
-    // Player <-> Monster (Example: Simple damage, could add knockback)
-    if (otherBody.userData.type === 'monster') {
-        // Check for cooldown before applying damage again?
-        console.log("Player collided with monster", otherBody.id);
-        // gameState.stats.hp -= 1;
-        // addLog(`Hit by ${otherBody.userData.monsterType || 'monster'}! HP: ${gameState.stats.hp}`, "combat");
-        // updateStatsDisplay();
-        // if (gameState.stats.hp <= 0) { gameOver("Defeated by a monster!"); }
-         // Apply small impulse away from monster
-         const impulse = playerBody.position.vsub(otherBody.position).unit().scale(20); // Knockback force
-         playerBody.applyImpulse(impulse, playerBody.position);
-    }
-     // Player <-> Wall (Handled by physics engine)
-     // Player <-> Item (Handled by 'F' key)
-}
+function handleChoiceClick(dataset) {
+    const nextPageId = parseInt(dataset.nextPage); // Ensure it's a number
+    const itemToAdd = dataset.addItem;
 
-function handleProjectileCollision(event) {
-    const projectileBody = event.target;
-    const otherBody = event.body;
-    if (!projectileBody?.userData || !otherBody?.userData) return; // Null checks
-
-    const projectileData = projectileBody.userData.data;
-    let shouldRemoveProjectile = true; // Assume removal unless hitting player
-
-    if (otherBody.userData.type === 'monster') {
-        const monsterId = otherBody.id;
-        const monsterIndex = gameState.monsters.findIndex(m => m.id === monsterId);
-        if (monsterIndex > -1) {
-             const monster = gameState.monsters[monsterIndex];
-             const damage = gameState.stats.strength + Math.floor(Math.random() * 3); // Add randomness
-             monster.hp -= damage;
-             otherBody.userData.hp = monster.hp;
-             addLog(`Hit ${otherBody.userData.monsterType} for ${damage} damage! (HP: ${monster.hp})`, "combat");
-
-             // Apply impulse to monster
-             const impulseDir = projectileBody.velocity.unit();
-             otherBody.applyImpulse(impulseDir.scale(damage * 5), projectileBody.position); // Knockback scales with damage
-
-
-             if (monster.hp <= 0) {
-                 addLog(`Defeated ${otherBody.userData.monsterType}!`, "info");
-                 // Safely remove monster after physics step using setTimeout
-                 setTimeout(() => {
-                    if(monster.mesh.parent) scene.remove(monster.mesh);
-                    if(world.bodies.includes(monster.body)) world.removeBody(monster.body);
-                    meshesToSync = meshesToSync.filter(sync => sync.body.id !== monster.body.id);
-                    physicsBodies.delete(monster.body.id);
-                    gameState.monsters = gameState.monsters.filter(m => m.id !== monsterId);
-                 }, 0);
-             }
-        }
-    } else if (otherBody === playerBody) {
-        shouldRemoveProjectile = false; // Don't destroy projectile if it hits the player who fired it
-         console.log("Projectile hit player - ignored");
-    } else if (otherBody.mass === 0) {
-         // Hit a static object like a wall
-         console.log("Projectile hit wall/static");
-         // Optional: Add impact effect
+    if (isNaN(nextPageId)) {
+        console.error("Invalid nextPageId:", dataset.nextPage);
+        return;
     }
 
-
-    if (shouldRemoveProjectile) {
-        // Schedule removal might be safer than immediate
-         setTimeout(() => removeProjectile(projectileData), 0);
+    // --- Process Effects of Making the Choice ---
+    // Add item if specified and not already present
+    if (itemToAdd && !gameState.inventory.includes(itemToAdd)) {
+        gameState.inventory.push(itemToAdd);
+        console.log("Added item:", itemToAdd);
     }
-}
+    // Add stat changes/hp loss *linked to the choice itself* here if needed
+
+    // --- Move to Next Page and Process Landing Effects ---
+    gameState.currentPageId = nextPageId;
+
+    const nextPageData = gameData[nextPageId];
+    if (nextPageData) {
+        // Apply HP loss defined on the *landing* page
+        if (nextPageData.hpLoss) {
+            gameState.stats.hp -= nextPageData.hpLoss;
+            console.log(`Lost ${nextPageData.hpLoss} HP.`);
+            if (gameState.stats.hp <= 0) {
+                console.log("Player died from HP loss!");
+                gameState.stats.hp = 0;
+                renderPage(99); // Go to a specific game over page ID
+                return; // Stop further processing
+            }
+        }
+        // Apply stat increase defined on the *landing* page
+        if (nextPageData.statIncrease) {
+            const stat = nextPageData.statIncrease.stat;
+            const amount = nextPageData.statIncrease.amount;
+            if (gameState.stats.hasOwnProperty(stat)) {
+                gameState.stats[stat] += amount;
+                console.log(`Stat ${stat} increased by ${amount}.`);
+            }
+        }
+         // Check if landing page is game over
+         if (nextPageData.gameOver) {
+             console.log("Reached Game Over page.");
+             renderPage(nextPageId);
+             return;
+         }
 
-function removeProjectile(projectileData) {
-    if (!projectileData) return;
-    const index = projectiles.indexOf(projectileData);
-    if (index === -1) return;
+    } else {
+        console.error(`Data for page ${nextPageId} not found!`);
+        // Optionally go to an error page or restart
+        renderPage(99); // Go to game over page as fallback
+        return;
+    }
 
-    if (projectileData.mesh?.parent) scene.remove(projectileData.mesh);
-    if (projectileData.body && world.bodies.includes(projectileData.body)) world.removeBody(projectileData.body);
 
-    meshesToSync = meshesToSync.filter(sync => sync.body?.id !== projectileData.body?.id);
-    if (projectileData.body) physicsBodies.delete(projectileData.body.id);
-    projectiles.splice(index, 1);
+    // Render the new page
+    renderPage(nextPageId);
 }
 
 
-// --- Monster AI ---
-function updateMonsters(deltaTime) {
-     const agroRangeSq = (ROOM_SIZE * 2) ** 2; // Increased range
-     if(!playerBody) return;
-
-     gameState.monsters.forEach(monster => {
-          if (!monster || !monster.body || monster.hp <= 0) return; // Skip dead or removed monsters
-
-         const monsterPos = monster.body.position;
-         const playerPos = playerBody.position;
-         const distanceSq = playerPos.distanceSquared(monsterPos);
-
-         if (distanceSq < agroRangeSq) { // If player is close
-             const direction = playerPos.vsub(monsterPos);
-             direction.y = 0; // Ignore height difference for movement plan
-             if (distanceSq > (PLAYER_RADIUS * 2)**2 && direction.lengthSquared() > 0.1) { // If not too close and direction is valid
-                 direction.normalize();
-                 const monsterData = monstersData[monster.type];
-                 const speed = monsterData?.speed || 1;
-
-                  // Apply velocity for chasing
-                  monster.body.velocity.x = direction.x * speed;
-                  monster.body.velocity.z = direction.z * speed;
-
-                  // Rotation
-                  const angle = Math.atan2(direction.x, direction.z);
-                  const targetQuaternion = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), angle);
-                  monster.mesh.quaternion.slerp(targetQuaternion, 0.1);
-             } else { // Too close or direction invalid, stop horizontal movement
-                  monster.body.velocity.x = 0;
-                  monster.body.velocity.z = 0;
-                  // TODO: Add attack logic here if close enough
-             }
-         } else { // Player too far, stop moving
-              monster.body.velocity.x = 0;
-              monster.body.velocity.z = 0;
-         }
-         // Wake up body if needed (should be awake if chasing)
-         if(monster.body.sleepState === CANNON.Body.SLEEPING) monster.body.wakeUp();
-     });
- }
-
-// --- UI Update Functions ---
-function updateUI() { updateStatsDisplay(); updateInventoryDisplay(); }
-function updateStatsDisplay() { /* ... same ... */
-    let statsHTML = ''; statsHTML += `<span>HP: ${gameState.stats.hp}/${gameState.stats.maxHp}</span>`; statsHTML += `<span>Str: ${gameState.stats.strength}</span>`; statsHTML += `<span>Wis: ${gameState.stats.wisdom}</span>`; statsHTML += `<span>Cor: ${gameState.stats.courage}</span>`; statsElement.innerHTML = statsHTML;
-}
-function updateInventoryDisplay() { /* ... same ... */
-    let inventoryHTML = ''; if (gameState.inventory.length === 0) { inventoryHTML += '<em>Empty</em>'; } else { gameState.inventory.forEach(item => { const itemInfo = itemsData[item] || { type: 'unknown', description: '???' }; const itemClass = `item-${itemInfo.type || 'unknown'}`; inventoryHTML += `<span class="${itemClass}" title="${itemInfo.description}">${item}</span>`; }); } inventoryElement.innerHTML = inventoryHTML;
-}
-function addLog(message, type = "info") { /* ... same ... */
-    const p = document.createElement('p'); p.classList.add(type); p.textContent = `[${new Date().toLocaleTimeString([], { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' })}] ${message}`; logElement.appendChild(p); logElement.scrollTop = logElement.scrollHeight;
+function updateStatsDisplay() {
+    let statsHTML = '<strong>Stats:</strong> ';
+    statsHTML += `<span>HP: ${gameState.stats.hp}/${gameState.stats.maxHp}</span>`;
+    statsHTML += `<span>Str: ${gameState.stats.strength}</span>`;
+    statsHTML += `<span>Wis: ${gameState.stats.wisdom}</span>`;
+    statsHTML += `<span>Cor: ${gameState.stats.courage}</span>`;
+    statsElement.innerHTML = statsHTML;
 }
 
-// --- Game Over ---
-function gameOver(reason) { /* ... same ... */
-     addLog(`GAME OVER: ${reason}`, "error"); console.log("Game Over:", reason);
-     gameLoopActive = false; // Stop the game loop
-     const restartButton = document.createElement('button'); restartButton.textContent = "RESTART GAME"; restartButton.style.cssText = `position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%); padding: 20px 40px; font-size: 2em; cursor: pointer; z-index: 1000; background-color: #ffc107; border: none; border-radius: 5px; color: #333; font-family: 'Courier New', monospace;`;
-     restartButton.onclick = () => { if (restartButton.parentNode) restartButton.parentNode.removeChild(restartButton); init(); }; // Re-initialize
-     sceneContainer.appendChild(restartButton);
-}
-
-// --- Main Game Loop ---
-let lastTimestamp = 0;
-function animate(timestamp) {
-    if (!gameLoopActive) return;
-    animationFrameId = requestAnimationFrame(animate);
-
-    const deltaTime = (timestamp - lastTimestamp) * 0.001;
-    lastTimestamp = timestamp;
-    const dtClamped = Math.min(deltaTime, 1 / 20); // Clamp delta time (max 20 FPS step)
-
-    if (!world || !playerBody || !scene || !camera || !renderer) {
-        console.error("Core component missing, stopping loop.");
-        gameLoopActive = false;
-        return;
+function updateInventoryDisplay() {
+    let inventoryHTML = '<strong>Inventory:</strong> ';
+    if (gameState.inventory.length === 0) {
+        inventoryHTML += '<em>Empty</em>';
+    } else {
+        gameState.inventory.forEach(item => {
+            const itemInfo = itemsData[item] || { type: 'unknown', description: '???' };
+            // Add class based on item type for styling
+            const itemClass = `item-${itemInfo.type || 'unknown'}`;
+            inventoryHTML += `<span class="${itemClass}" title="${itemInfo.description}">${item}</span>`;
+        });
     }
+    inventoryElement.innerHTML = inventoryHTML;
+}
 
-    // 1. Input
-    handleInput(dtClamped);
-
-    // 2. AI
-    updateMonsters(dtClamped);
-
-    // 3. Physics Step
-    try { world.step(dtClamped); }
-    catch (e) { console.error("Physics step error:", e); gameLoopActive = false; return; } // Stop loop on error
-
-    // 4. Projectiles Update
-    for (let i = projectiles.length - 1; i >= 0; i--) {
-        const p = projectiles[i];
-        if (p) { p.lifetime -= dtClamped; if (p.lifetime <= 0) removeProjectile(p); }
-    }
 
-    // 5. Sync Visuals
-    meshesToSync.forEach(item => {
-        if (item?.body && item?.mesh && item.mesh.parent) { // Check existence
-            item.mesh.position.copy(item.body.position);
-            item.mesh.quaternion.copy(item.body.quaternion);
-        }
-    });
-
-    // 6. Update Camera
-    if (playerBody && camera) {
-         const targetCameraPos = new THREE.Vector3(
-             playerBody.position.x,
-             CAMERA_Y_OFFSET,
-             playerBody.position.z // Look straight down from above player
-         );
-         camera.position.lerp(targetCameraPos, 0.1); // Smooth follow
-         // Camera already looking down due to initial setup / rotation
-         // camera.lookAt(playerBody.position.x, 0, playerBody.position.z); // Keep looking at player's feet
+function updateScene(illustrationKey) {
+    console.log("Updating scene for:", illustrationKey);
+    if (!cube) return; // Don't do anything if cube isn't initialized
+
+    // Simple scene update: Change cube color based on key
+    let color = 0xcccccc; // Default grey
+    switch (illustrationKey) {
+        case 'city-gates': color = 0xaaaaaa; break;
+        case 'weaponsmith': color = 0x8B4513; break; // Brown
+        case 'temple': color = 0xFFFFE0; break; // Light yellow
+        case 'resistance-meeting': color = 0x696969; break; // Dim grey
+        case 'shadowwood-forest': color = 0x228B22; break; // Forest green
+        case 'road-ambush': color = 0xD2691E; break; // Chocolate (dirt road)
+        case 'river-spirit': color = 0xADD8E6; break; // Light blue
+        case 'ancient-ruins': color = 0x778899; break; // Light slate grey
+        case 'forest-edge': color = 0x90EE90; break; // Light green
+        case 'prisoner-cell': color = 0x444444; break; // Dark grey
+        case 'game-over': color = 0xff0000; break; // Red
+        case 'error': color = 0xffa500; break; // Orange
+        default: color = 0xcccccc; break; // Default grey for unknown
     }
+    cube.material.color.setHex(color);
 
-    // 7. Physics Debugger (Optional)
-    // if (cannonDebugger) cannonDebugger.update();
-
-    // 8. Render
-    renderer.render(scene, camera);
+    // In a more complex setup, you would:
+    // 1. Remove old objects from the scene (scene.remove(object))
+    // 2. Load/create new objects based on illustrationKey
+    // 3. Add new objects to the scene (scene.add(newObject))
 }
 
-// --- Window Resize ---
-function onWindowResize() {
-    if (!renderer || !camera) return;
-    const width = sceneContainer.clientWidth;
-    const height = sceneContainer.clientHeight;
-    camera.aspect = width / height;
-    camera.updateProjectionMatrix();
-    renderer.setSize(width, height);
-    console.log("Resized");
-}
 
-// --- Start Game ---
-init();
+// --- Initialization ---
+initThreeJS();
+startGame(); // Start the game after setting up Three.js
+
+// Make handleChoiceClick globally accessible IF using inline onclick
+// If using addEventListener, this is not needed.
+// window.handleChoiceClick = handleChoiceClick;