import * as THREE from 'three'; import { OrbitControls } from 'three/addons/controls/OrbitControls.js'; import { EffectComposer } from 'three/addons/postprocessing/EffectComposer.js'; import { RenderPass } from 'three/addons/postprocessing/RenderPass.js'; import { UnrealBloomPass } from 'three/addons/postprocessing/UnrealBloomPass.js'; import { SMAAPass } from 'three/addons/postprocessing/SMAAPass.js'; // Initialize loading manager and game state const loadingManager = new THREE.LoadingManager(); const textureLoader = new THREE.TextureLoader(loadingManager); let gasCansCollected = 0; const TOTAL_GAS_CANS = 7; // Cheat code variables let cheatsEnabled = false; let nightVisionEnabled = false; let superSpeedEnabled = false; let noClipEnabled = false; let flyModeEnabled = false; let cheatCode = ''; const CHEAT_CODE = 'rosebud'; // The cheat code to enter let carryingGasCan = false; let currentGasCan = null; let generator = null; let generatorIndicator = null; let gasCans = []; // Load game textures const generatorTexture = textureLoader.load('https://play.rosebud.ai/assets/CLOWNING AROUND.png?LITz'); const gasCanTexture = textureLoader.load('https://play.rosebud.ai/assets/output-removebg-preview (17).png?4FFL'); let assetsLoaded = false; const parentDiv = document.getElementById('renderDiv'); let canvas = document.getElementById('threeRenderCanvas'); if (!canvas) { canvas = document.createElement('canvas'); canvas.id = 'threeRenderCanvas'; parentDiv.appendChild(canvas); } // Create loading screen const loadingScreen = document.createElement('div'); loadingScreen.style.position = 'absolute'; loadingScreen.style.top = '0'; loadingScreen.style.left = '0'; loadingScreen.style.width = '100%'; loadingScreen.style.height = '100%'; loadingScreen.style.backgroundColor = 'rgba(0, 0, 0, 0.8)'; loadingScreen.style.color = 'white'; loadingScreen.style.display = 'flex'; loadingScreen.style.justifyContent = 'center'; loadingScreen.style.alignItems = 'center'; loadingScreen.style.fontSize = '24px'; loadingScreen.innerHTML = 'Loading... 0%'; parentDiv.appendChild(loadingScreen); // Initialize background music variable let backgroundMusic; // Loading manager events loadingManager.onProgress = function(url, itemsLoaded, itemsTotal) { const progress = (itemsLoaded / itemsTotal * 100).toFixed(0); loadingScreen.innerHTML = `Loading... ${progress}%`; }; loadingManager.onLoad = function() { assetsLoaded = true; loadingScreen.style.display = 'none'; // Initialize and play background music backgroundMusic = new Audio('https://play.rosebud.ai/assets/rosebud_official_theme_02.mp3?a1V7'); backgroundMusic.loop = true; backgroundMusic.volume = 0.04; // Adjust volume as needed (0.0 to 1.0) // Attempt to play the music. Note: Some browsers may require user interaction to play audio. backgroundMusic.play().catch((error) => { console.warn('Autoplay was prevented. User interaction is required to play the background music.'); }); }; loadingManager.onError = function(url) { console.error('Error loading:', url); }; // Initialize the scene const scene = new THREE.Scene(); const world = new CANNON.World(); world.gravity.set(0, -30, 0); // Increased gravity for better control // Player movement state const moveState = { forward: false, backward: false, left: false, right: false }; world.defaultContactMaterial.friction = 0.01; world.defaultContactMaterial.restitution = 0; world.solver.iterations = 10; world.solver.tolerance = 0.001; // Define physics materials const groundPhysMaterial = new CANNON.Material('ground'); const clock = new THREE.Clock(); // Initialize the camera const camera = new THREE.PerspectiveCamera( 75, canvas.offsetWidth / canvas.offsetHeight, 0.1, 1000 ); // Initial camera setup (will be updated to follow player) camera.position.set(0, 1, 0); camera.lookAt(0, 1, -1); camera.rotation.order = 'YXZ'; // This ensures proper first-person rotation // Initialize the renderer with HDR const renderer = new THREE.WebGLRenderer({ antialias: true, canvas: canvas, powerPreference: "high-performance" }); renderer.setPixelRatio(window.devicePixelRatio); renderer.setSize(canvas.offsetWidth, canvas.offsetHeight); renderer.shadowMap.enabled = true; renderer.shadowMap.type = THREE.PCFSoftShadowMap; renderer.outputEncoding = THREE.sRGBEncoding; renderer.toneMapping = THREE.ACESFilmicToneMapping; renderer.toneMappingExposure = 1.2; // Initialize post-processing const composer = new EffectComposer(renderer); // Regular scene render pass const renderPass = new RenderPass(scene, camera); composer.addPass(renderPass); // Add subtle bloom effect const bloomPass = new UnrealBloomPass( new THREE.Vector2(window.innerWidth, window.innerHeight), 0.2, // bloom strength 0.4, // radius 0.9 // threshold ); composer.addPass(bloomPass); // Add anti-aliasing const smaaPass = new SMAAPass( window.innerWidth * renderer.getPixelRatio(), window.innerHeight * renderer.getPixelRatio() ); composer.addPass(smaaPass); // Initialize composer size composer.setSize(parentDiv.clientWidth, parentDiv.clientHeight); // Define sky colors for environmental lighting const skyColor = new THREE.Color(0x87CEEB); // Bright sky blue const groundColor = new THREE.Color(0xFFFFFF); // White ground reflection // Create sky dome with improved colors const vertexShader = ` varying vec3 vWorldPosition; void main() { vec4 worldPosition = modelMatrix * vec4( position, 1.0 ); vWorldPosition = worldPosition.xyz; gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 ); }`; const fragmentShader = ` uniform vec3 topColor; uniform vec3 bottomColor; uniform float offset; uniform float exponent; varying vec3 vWorldPosition; void main() { float h = normalize( vWorldPosition + offset ).y; gl_FragColor = vec4( mix( bottomColor, topColor, max( pow( max( h, 0.0 ), exponent ), 0.0 ) ), 1.0 ); }`; const uniforms = { topColor: { value: skyColor }, bottomColor: { value: groundColor }, offset: { value: 33 }, exponent: { value: 0.6 } }; const skyGeo = new THREE.SphereGeometry(500, 32, 15); const skyMat = new THREE.ShaderMaterial({ uniforms: uniforms, vertexShader: vertexShader, fragmentShader: fragmentShader, side: THREE.BackSide }); const sky = new THREE.Mesh(skyGeo, skyMat); scene.add(sky); // Remove OrbitControls as we'll use first-person controls // Create flat terrain function createTerrain() { const size = 200; // Create simple flat plane for visuals const geometry = new THREE.PlaneGeometry(size, size); const texture = textureLoader.load('https://play.rosebud.ai/assets/output.jpg?gWeQ'); texture.wrapS = texture.wrapT = THREE.RepeatWrapping; texture.repeat.set(8, 8); texture.encoding = THREE.sRGBEncoding; const material = new THREE.MeshStandardMaterial({ map: texture, roughness: 0.8, metalness: 0.1, envMapIntensity: 1.0 }); const terrain = new THREE.Mesh(geometry, material); terrain.rotation.x = -Math.PI / 2; terrain.receiveShadow = true; scene.add(terrain); const groundShape = new CANNON.Box(new CANNON.Vec3(size / 2, 0.1, size / 2)); const groundBody = new CANNON.Body({ mass: 0, material: groundPhysMaterial }); groundBody.addShape(groundShape); groundBody.position.set(0, -0.1, 0); world.addBody(groundBody); return terrain; } // Setup indoor lighting system const ambientLight = new THREE.AmbientLight(0x404040, 0.4); // Brighter ambient light scene.add(ambientLight); // Create player flashlight const flashlight = new THREE.SpotLight(0xffffff, 2.0); flashlight.angle = Math.PI / 6; // 30 degrees flashlight.penumbra = 0.3; flashlight.decay = 2; flashlight.distance = 30; flashlight.castShadow = true; flashlight.shadow.mapSize.width = 1024; flashlight.shadow.mapSize.height = 1024; flashlight.shadow.camera.near = 0.5; flashlight.shadow.camera.far = 30; camera.add(flashlight); flashlight.position.set(0, 0, 1); scene.add(camera); // Create maze walls // Maze generation configuration const ROWS = 25; const COLS = 35; const CELL_SIZE = 4; // Size in Three.js units const WALL_HEIGHT = 8; const WALL_THICKNESS = 1; const ROOM_ATTEMPTS = 8; // how many rooms to try placing const MIN_ROOM_SIZE = 4; const MAX_ROOM_SIZE = 10; // Spawn room configuration const spawnRoomW = MAX_ROOM_SIZE; const spawnRoomH = MAX_ROOM_SIZE; const spawnRoomX = Math.floor(COLS / 2 - spawnRoomW / 2); const spawnRoomY = Math.floor(ROWS / 2 - spawnRoomH / 2); function createMazeWalls() { const texture = textureLoader.load('https://play.rosebud.ai/assets/output.jpg?gWeQ'); texture.encoding = THREE.sRGBEncoding; const wallMaterial = new THREE.MeshStandardMaterial({ map: texture, roughness: 0.8, metalness: 0.2 }); // Utility function for random integers function randInt(min, max) { return Math.floor(Math.random() * (max - min + 1)) + min; } // Generate maze layout using the provided algorithm function makeGrid(r, c) { const grid = []; for (let y = 0; y < r; y++) { const row = []; for (let x = 0; x < c; x++) { row.push({ walls: { N: true, S: true, W: true, E: true }, visited: false }); } grid.push(row); } return grid; } // Place random rectangular rooms function generateRooms(grid) { const rooms = []; // First, create a guaranteed large room near the center for spawning const spawnRoom = { x: spawnRoomX, y: spawnRoomY, w: spawnRoomW, h: spawnRoomH }; rooms.push(spawnRoom); // Carve out spawn room for (let ry = spawnRoomY; ry < spawnRoomY + spawnRoomH; ry++) { for (let rx = spawnRoomX; rx < spawnRoomX + spawnRoomW; rx++) { grid[ry][rx].walls = { N: false, S: false, W: false, E: false }; } } // Continue with random room generation for (let i = 0; i < ROOM_ATTEMPTS - 1; i++) { const w = randInt(MIN_ROOM_SIZE, MAX_ROOM_SIZE); const h = randInt(MIN_ROOM_SIZE, MAX_ROOM_SIZE); const x = randInt(1, COLS - w - 2); const y = randInt(1, ROWS - h - 2); const newRoom = { x, y, w, h }; // Check for room overlap let ok = true; for (const r of rooms) { if (x < r.x + r.w + 1 && x + w + 1 > r.x && y < r.y + r.h + 1 && y + h + 1 > r.y) { ok = false; break; } } if (!ok) continue; rooms.push(newRoom); // Carve out room interior for (let ry = y; ry < y + h; ry++) { for (let rx = x; rx < x + w; rx++) { grid[ry][rx].walls = { N: false, S: false, W: false, E: false }; } } } return rooms; } function carveMaze(grid, r = 0, c = 0) { grid[r][c].visited = true; const dirs = Object.keys(DIRS).sort(() => Math.random() - 0.5); for (const d of dirs) { const nx = c + DIRS[d].dx; const ny = r + DIRS[d].dy; if (ny >= 0 && ny < ROWS && nx >= 0 && nx < COLS && !grid[ny][nx].visited) { grid[r][c].walls[d] = false; grid[ny][nx].walls[DIRS[d].opposite] = false; carveMaze(grid, ny, nx); } } } const DIRS = { N: { dx: 0, dy: -1, opposite: 'S' }, S: { dx: 0, dy: 1, opposite: 'N' }, W: { dx: -1, dy: 0, opposite: 'E' }, E: { dx: 1, dy: 0, opposite: 'W' }, }; const grid = makeGrid(ROWS, COLS); const rooms = generateRooms(grid); carveMaze(grid); const wallBodies = []; const wallPhysMaterial = new CANNON.Material('wall'); // Create walls based on the generated maze for (let y = 0; y < ROWS; y++) { for (let x = 0; x < COLS; x++) { const cell = grid[y][x]; const x1 = (x - COLS / 2) * CELL_SIZE; const y1 = (y - ROWS / 2) * CELL_SIZE; // Create walls for each direction if present if (cell.walls.N) { const wallGeometry = new THREE.BoxGeometry(CELL_SIZE + WALL_THICKNESS, WALL_HEIGHT, WALL_THICKNESS); const wall = new THREE.Mesh(wallGeometry, wallMaterial); wall.position.set(x1 + CELL_SIZE / 2, WALL_HEIGHT / 2, y1); wall.castShadow = true; wall.receiveShadow = true; scene.add(wall); const wallShape = new CANNON.Box(new CANNON.Vec3((CELL_SIZE + WALL_THICKNESS) / 2, WALL_HEIGHT / 2, WALL_THICKNESS / 2)); const wallBody = new CANNON.Body({ mass: 0, material: wallPhysMaterial }); wallBody.addShape(wallShape); wallBody.position.copy(wall.position); world.addBody(wallBody); wallBodies.push(wallBody); } if (cell.walls.W) { const wallGeometry = new THREE.BoxGeometry(WALL_THICKNESS, WALL_HEIGHT, CELL_SIZE + WALL_THICKNESS); const wall = new THREE.Mesh(wallGeometry, wallMaterial); wall.position.set(x1, WALL_HEIGHT / 2, y1 + CELL_SIZE / 2); wall.castShadow = true; wall.receiveShadow = true; scene.add(wall); const wallShape = new CANNON.Box(new CANNON.Vec3(WALL_THICKNESS / 2, WALL_HEIGHT / 2, (CELL_SIZE + WALL_THICKNESS) / 2)); const wallBody = new CANNON.Body({ mass: 0, material: wallPhysMaterial }); wallBody.addShape(wallShape); wallBody.position.copy(wall.position); world.addBody(wallBody); wallBodies.push(wallBody); } // Add East and South walls only for the last row/column if (x === COLS - 1 && cell.walls.E) { const wallGeometry = new THREE.BoxGeometry(WALL_THICKNESS, WALL_HEIGHT, CELL_SIZE + WALL_THICKNESS); const wall = new THREE.Mesh(wallGeometry, wallMaterial); wall.position.set(x1 + CELL_SIZE, WALL_HEIGHT / 2, y1 + CELL_SIZE / 2); wall.castShadow = true; wall.receiveShadow = true; scene.add(wall); const wallShape = new CANNON.Box(new CANNON.Vec3(WALL_THICKNESS / 2, WALL_HEIGHT / 2, (CELL_SIZE + WALL_THICKNESS) / 2)); const wallBody = new CANNON.Body({ mass: 0, material: wallPhysMaterial }); wallBody.addShape(wallShape); wallBody.position.copy(wall.position); world.addBody(wallBody); wallBodies.push(wallBody); } if (y === ROWS - 1 && cell.walls.S) { const wallGeometry = new THREE.BoxGeometry(CELL_SIZE + WALL_THICKNESS, WALL_HEIGHT, WALL_THICKNESS); const wall = new THREE.Mesh(wallGeometry, wallMaterial); wall.position.set(x1 + CELL_SIZE / 2, WALL_HEIGHT / 2, y1 + CELL_SIZE); wall.castShadow = true; wall.receiveShadow = true; scene.add(wall); const wallShape = new CANNON.Box(new CANNON.Vec3((CELL_SIZE + WALL_THICKNESS) / 2, WALL_HEIGHT / 2, WALL_THICKNESS / 2)); const wallBody = new CANNON.Body({ mass: 0, material: wallPhysMaterial }); wallBody.addShape(wallShape); wallBody.position.copy(wall.position); world.addBody(wallBody); wallBodies.push(wallBody); } } } // Add roof const roofGeometry = new THREE.PlaneGeometry(COLS * CELL_SIZE, ROWS * CELL_SIZE); const roofMaterial = new THREE.MeshStandardMaterial({ map: texture, side: THREE.DoubleSide, roughness: 0.8, metalness: 0.2 }); const roof = new THREE.Mesh(roofGeometry, roofMaterial); roof.rotation.x = Math.PI / 2; roof.position.y = WALL_HEIGHT; scene.add(roof); // Add light fixtures in rooms rooms.forEach(room => { const centerX = (room.x - COLS / 2 + room.w / 2) * CELL_SIZE; const centerZ = (room.y - ROWS / 2 + room.h / 2) * CELL_SIZE; // Create light bulb geometry const bulbGeometry = new THREE.SphereGeometry(0.2, 8, 8); const bulbMaterial = new THREE.MeshStandardMaterial({ emissive: 0xffffee, emissiveIntensity: 1, color: 0x000000 }); const bulb = new THREE.Mesh(bulbGeometry, bulbMaterial); bulb.position.set(centerX, WALL_HEIGHT - 0.5, centerZ); scene.add(bulb); // Add point light const light = new THREE.SpotLight(0xffffee, 3, CELL_SIZE * 8, Math.PI / 2, 0.3, 1); light.position.copy(bulb.position); light.target.position.set(centerX, 0, centerZ); scene.add(light.target); light.castShadow = true; light.shadow.mapSize.width = 512; light.shadow.mapSize.height = 512; light.shadow.camera.near = 0.1; light.shadow.camera.far = CELL_SIZE * 6; scene.add(light); }); return { wallBodies, rooms }; } // Create player function createPlayer() { // Player physical properties const playerRadius = 0.5; const playerHeight = 2; const playerShape = new CANNON.Cylinder(playerRadius, playerRadius, playerHeight, 8); const playerBody = new CANNON.Body({ mass: 5, material: new CANNON.Material('player') }); playerBody.addShape(playerShape); const spawnX = (spawnRoomX - COLS / 2 + spawnRoomW / 2) * CELL_SIZE; const spawnZ = (spawnRoomY - ROWS / 2 + spawnRoomH / 2) * CELL_SIZE; playerBody.position.set(spawnX, playerHeight / 2 + 0.5, spawnZ); playerBody.linearDamping = 0.9; // Add damping to prevent sliding world.addBody(playerBody); // Optional: Create a visual representation of the player (if needed) const playerGeometry = new THREE.CylinderGeometry(playerRadius, playerRadius, playerHeight, 8); const playerMaterial = new THREE.MeshPhongMaterial({ color: 0x00ff00, opacity: 0.5, transparent: true }); const playerMesh = new THREE.Mesh(playerGeometry, playerMaterial); playerMesh.visible = false; // Hide the player mesh since we're in first person scene.add(playerMesh); return { body: playerBody, mesh: playerMesh }; } // Create generator near player spawn point function createGenerator(playerPosition) { const generatorGeometry = new THREE.BoxGeometry(2, 3, 2); const generatorMaterial = new THREE.MeshStandardMaterial({ map: generatorTexture, metalness: 0.5, roughness: 0.5 }); const generatorMesh = new THREE.Mesh(generatorGeometry, generatorMaterial); const offset = new THREE.Vector3(CELL_SIZE / 2, 1.5, CELL_SIZE / 2); generatorMesh.position.copy(playerPosition).add(offset); generatorMesh.castShadow = true; generatorMesh.receiveShadow = true; scene.add(generatorMesh); // Create generator indicator const indicatorGeometry = new THREE.RingGeometry(1.5, 2, 32); const indicatorMaterial = new THREE.MeshBasicMaterial({ color: 0x00ff00, side: THREE.DoubleSide, transparent: true, opacity: 0.5 }); generatorIndicator = new THREE.Mesh(indicatorGeometry, indicatorMaterial); generatorIndicator.rotation.x = -Math.PI / 2; generatorIndicator.position.copy(generatorMesh.position); generatorIndicator.position.y = 0.1; scene.add(generatorIndicator); return generatorMesh; } // Function to check if a position is valid (not inside walls) function isValidPosition(position, wallBodies) { const testBody = new CANNON.Body({ mass: 0, shape: new CANNON.Sphere(0.5), position: new CANNON.Vec3(position.x, position.y, position.z) }); for (const wall of wallBodies) { const distance = testBody.position.vsub(wall.position); if (distance.length() < 2) { // Minimum distance from walls return false; } } return true; } // Create gas cans at random valid positions function createGasCans(wallBodies, rooms) { const gasCanGeometry = new THREE.BoxGeometry(0.8, 1, 0.4); const gasCanMaterial = new THREE.MeshStandardMaterial({ map: gasCanTexture, metalness: 0.5, roughness: 0.5 }); for (let i = 0; i < TOTAL_GAS_CANS; i++) { // Select a random room (excluding spawn room) const room = rooms[Math.floor(Math.random() * (rooms.length - 1)) + 1]; let position; let isValid = false; // Keep trying until we find a valid position while (!isValid) { const x = (room.x - COLS / 2 + Math.random() * room.w) * CELL_SIZE; const z = (room.y - ROWS / 2 + Math.random() * room.h) * CELL_SIZE; position = new THREE.Vector3(x, 0.5, z); isValid = isValidPosition(position, wallBodies); } const gasCan = new THREE.Mesh(gasCanGeometry, gasCanMaterial); gasCan.position.copy(position); gasCan.castShadow = true; gasCan.receiveShadow = true; gasCan.userData.isGasCan = true; gasCan.userData.isCollected = false; scene.add(gasCan); gasCans.push(gasCan); } } // Create initial scene const terrain = createTerrain(); const { wallBodies: mazeWalls, rooms } = createMazeWalls(); const player = createPlayer(); // Initialize game objects generator = createGenerator(player.body.position); createGasCans(mazeWalls, rooms); // Movement speed configuration const MOVE_SPEED = 15; const mouseSensitivity = 0.002; let mouseEnabled = false; // Lock and hide mouse pointer canvas.addEventListener('click', () => { canvas.requestPointerLock(); }); document.addEventListener('pointerlockchange', () => { mouseEnabled = document.pointerLockElement === canvas; }); // Mouse movement handler document.addEventListener('mousemove', (event) => { if (mouseEnabled) { camera.rotation.y -= event.movementX * mouseSensitivity; // Add vertical rotation with limits const newRotationX = camera.rotation.x - event.movementY * mouseSensitivity; // Limit vertical rotation to prevent over-rotation camera.rotation.x = Math.max(-Math.PI / 2, Math.min(Math.PI / 2, newRotationX)); } }); // Function to check distance between player and object function isNearObject(playerPos, objectPos, maxDistance = 3) { return playerPos.distanceTo(new THREE.Vector3(objectPos.x, objectPos.y, objectPos.z)) < maxDistance; } // Handle keyboard controls document.addEventListener('keydown', (event) => { const playerPos = new THREE.Vector3(player.body.position.x, player.body.position.y, player.body.position.z); if (event.code === 'KeyE') { if (!carryingGasCan) { // Try to pick up a gas can for (const gasCan of gasCans) { if (!gasCan.userData.isCollected && isNearObject(playerPos, gasCan.position)) { carryingGasCan = true; currentGasCan = gasCan; gasCan.visible = false; break; } } } else if (isNearObject(playerPos, generator.position)) { // Deposit gas can at generator carryingGasCan = false; currentGasCan.userData.isCollected = true; gasCansCollected++; currentGasCan = null; // Update indicator color based on progress const progress = gasCansCollected / TOTAL_GAS_CANS; generatorIndicator.material.color.setHSL(progress / 3, 1, 0.5); if (gasCansCollected >= TOTAL_GAS_CANS) { alert("Congratulations! You've powered up the generator!"); } } } switch (event.code) { case 'KeyW': moveState.forward = true; break; case 'KeyS': moveState.backward = true; break; case 'KeyA': moveState.right = true; break; case 'KeyD': moveState.left = true; break; } }); document.addEventListener('keyup', (event) => { switch (event.code) { case 'KeyW': moveState.forward = false; break; case 'KeyS': moveState.backward = false; break; case 'KeyA': moveState.right = false; break; case 'KeyD': moveState.left = false; break; } }); // Cheat code handler document.addEventListener('keydown', (event) => { // Only process alphabetical keys if (event.key.length === 1 && event.key.match(/[a-z]/i)) { cheatCode += event.key.toLowerCase(); // Check if the entered sequence matches our cheat code if (cheatCode.includes(CHEAT_CODE)) { cheatsEnabled = !cheatsEnabled; nightVisionEnabled = cheatsEnabled; superSpeedEnabled = cheatsEnabled; noClipEnabled = cheatsEnabled; flyModeEnabled = cheatsEnabled; // Reset cheat code buffer cheatCode = ''; // Visual feedback if (cheatsEnabled) { scene.fog = null; // Remove fog for night vision MOVE_SPEED = 45; // Triple speed // Disable collision response for no-clip player.body.collisionResponse = false; // Make ambient light brighter for night vision ambientLight.intensity = 1.5; alert('Cheats Enabled: Night Vision, Super Speed, No-Clip, and Flight!'); } else { scene.fog = new THREE.Fog(0x000000, 1, 30); MOVE_SPEED = 15; player.body.collisionResponse = true; ambientLight.intensity = 0.4; alert('Cheats Disabled'); } } // Keep the buffer from growing too large if (cheatCode.length > 20) { cheatCode = cheatCode.slice(-20); } } }); function animate() { requestAnimationFrame(animate); const deltaTime = Math.min(clock.getDelta(), 0.1); if (assetsLoaded) { // Handle player movement const playerBody = player.body; const playerMesh = player.mesh; // Calculate movement direction // Get the camera's forward direction const forward = new THREE.Vector3(0, 0, -1); forward.applyQuaternion(camera.quaternion); forward.y = 0; // Keep movement horizontal forward.normalize(); // Calculate right direction from forward const right = new THREE.Vector3(); right.crossVectors(new THREE.Vector3(0, 1, 0), forward).normalize(); // Reset velocity let moveX = 0; let moveZ = 0; let moveY = 0; // Handle vertical movement when flight mode is enabled if (flyModeEnabled) { if (moveState.forward) moveY += MOVE_SPEED; if (moveState.backward) moveY -= MOVE_SPEED; } // Apply movement based on key states relative to camera direction if (moveState.forward) { moveX += forward.x * MOVE_SPEED; moveZ += forward.z * MOVE_SPEED; } if (moveState.backward) { moveX -= forward.x * MOVE_SPEED; moveZ -= forward.z * MOVE_SPEED; } if (moveState.right) { moveX += right.x * MOVE_SPEED; moveZ += right.z * MOVE_SPEED; } if (moveState.left) { moveX -= right.x * MOVE_SPEED; moveZ -= right.z * MOVE_SPEED; } // Update player velocity playerBody.velocity.x = moveX; playerBody.velocity.z = moveZ; if (flyModeEnabled) { playerBody.velocity.y = moveY; playerBody.gravity = 0; // Disable gravity in flight mode } else { playerBody.gravity = -30; // Normal gravity when flight is disabled } // Update physics world.step(deltaTime); // Update player mesh position playerMesh.position.copy(playerBody.position); // Update carried gas can position if (carryingGasCan && currentGasCan) { const offset = new THREE.Vector3( forward.x * 1.5, -0.5, forward.z * 1.5 ); currentGasCan.position.copy(playerBody.position).add(offset); currentGasCan.rotation.y = camera.rotation.y; } playerMesh.quaternion.copy(playerBody.quaternion); // Update camera position and rotation // Update camera position to follow player camera.position.set( playerBody.position.x, playerBody.position.y + 1.6, // Slightly lower eye level for better perspective playerBody.position.z ); // Update flashlight target based on camera direction const target = new THREE.Vector3(); target.copy(forward).multiplyScalar(10).add(camera.position); flashlight.target.position.copy(target); flashlight.target.updateMatrixWorld(); } composer.render(); } // Handle window resize function onWindowResize() { const width = parentDiv.clientWidth; const height = parentDiv.clientHeight; // Update camera camera.aspect = width / height; camera.updateProjectionMatrix(); // Update renderer and composer renderer.setSize(width, height); composer.setSize(width, height); // Update post-processing passes bloomPass.resolution.set(width, height); smaaPass.setSize(width, height); } // Add event listeners window.addEventListener('resize', onWindowResize); const resizeObserver = new ResizeObserver(onWindowResize); resizeObserver.observe(parentDiv); // Start animation animate();