Create game.js

game.js

@@ -0,0 +1,818 @@
+import * as THREE from 'three';
+import * as CANNON from 'cannon-es';
+// import CannonDebugger from 'cannon-es-debugger'; // Keep commented for now
+
+// --- DOM Elements ---
+const sceneContainer = document.getElementById('scene-container');
+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();
+}
+
+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
+
+    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);
+
+    window.addEventListener('resize', onWindowResize, false);
+}
+
+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); }
+}
+
+// --- 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;
+}
+
+// --- 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.");
+}
+
+// --- 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).");
+}
+
+// --- 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 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)}`);
+}
+
+
+// --- 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; });
+}
+
+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
+
+    } else {
+        // No movement keys pressed - rely on linear damping to stop
+        // Or force stop X/Z velocity:
+         targetVelocity.x = 0;
+         targetVelocity.z = 0;
+    }
+
+    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
+    }
+
+    // --- Pickup (F) ---
+    if (keysPressed['f'] || keysPressed['keyf']) {
+        pickupNearbyItem();
+        keysPressed['f'] = false; keysPressed['keyf'] = false; // Consume pickup input
+    }
+
+    // --- Fire (Space) ---
+    if (keysPressed['space']) {
+        fireProjectile();
+        keysPressed['space'] = false; // Consume fire input
+    }
+}
+
+// --- 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");
+        }
+    }
+
+    if (!pickedUp) {
+        addLog("Nothing nearby to pick up.", "info");
+    }
+}
+
+
+// --- 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
+}
+
+// --- 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 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 (shouldRemoveProjectile) {
+        // Schedule removal might be safer than immediate
+         setTimeout(() => removeProjectile(projectileData), 0);
+    }
+}
+
+function removeProjectile(projectileData) {
+    if (!projectileData) return;
+    const index = projectiles.indexOf(projectileData);
+    if (index === -1) 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);
+}
+
+
+// --- 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;
+}
+
+// --- 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;
+    }
+
+    // 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
+    }
+
+    // 7. Physics Debugger (Optional)
+    // if (cannonDebugger) cannonDebugger.update();
+
+    // 8. Render
+    renderer.render(scene, camera);
+}
+
+// --- 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();