Skip to content
The Chat Archive
gemma-3-27b-it· Google LMArena Human Preference 140K

Make a 3d FPS using Three.js, css, and html in one file. Make it to where i can move…

  1. User

    Make a 3d FPS using Three.js, css, and html in one file. Make it to where i can move using WASD, theres a gun that i can shoot. A simple crosshair with a HUD system. Very nice UI.

  2. Assistant

    Okay, this is a substantial project, and providing a fully functional, polished FPS in a single HTML file is quite extensive. I'll give you a solid, well-commented starting point that incorporates the core elements you requested: WASD movement, a basic gun with shooting, a crosshair, and a simple HUD. I'll focus on clarity and structure. Be prepared to expand upon this significantly to create a truly "nice" UI and more complex gameplay.

    Important Considerations:

    • Performance: A single HTML file can become unwieldy for complex 3D scenes. For a more advanced game, you'd typically separate your code into multiple JavaScript files.
    • Collision Detection: This example uses very basic collision. For a real game, you'd need a more robust collision detection system (e.g., using a library like cannon-es or ammo.js).
    • Assets: I'm using placeholder geometry. You'll want to replace these with actual 3D models and textures.
    • UI Frameworks: For a truly "nice" UI, consider using a UI library like lil-gui or a more comprehensive framework like React or Vue.js. This example uses basic HTML/CSS for simplicity.
    • Game Logic: This is a bare-bones example. You'll need to add more game logic (enemies, scoring, levels, etc.).

    Here's the code (index.html):

    <!DOCTYPE html>
    <html>
    <head>
        <title>Simple FPS</title>
        <style>
            body { margin: 0; overflow: hidden; }
            #hud {
                position: absolute;
                top: 10px;
                left: 10px;
                color: white;
                font-family: sans-serif;
                z-index: 100;
            }
            #crosshair {
                position: absolute;
                top: 50%;
                left: 50%;
                transform: translate(-50%, -50%);
                width: 20px;
                height: 20px;
                border: 1px solid white;
                border-radius: 50%;
                pointer-events: none; /* Prevent blocking mouse clicks */
                z-index: 100;
            }
        </style>
    </head>
    <body>
        <div id="hud">
            Health: <span id="health">100</span><br>
            Ammo: <span id="ammo">10</span>
        </div>
        <div id="crosshair"></div>
    
        <script src="https://threejs.org/build/three.js"></script>
        <script>
            // Scene, Camera, and Renderer
            const scene = new THREE.Scene();
            const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
            const renderer = new THREE.WebGLRenderer();
            renderer.setSize(window.innerWidth, window.innerHeight);
            document.body.appendChild(renderer.domElement);
    
            // Player
            const playerGeometry = new THREE.BoxGeometry(1, 2, 1);
            const playerMaterial = new THREE.MeshBasicMaterial({ color: 0x00ff00 });
            const player = new THREE.Mesh(playerGeometry, playerMaterial);
            player.position.set(0, 1, 0);
            scene.add(player);
    
            // Gun
            const gunGeometry = new THREE.BoxGeometry(0.2, 0.5, 1);
            const gunMaterial = new THREE.MeshBasicMaterial({ color: 0x808080 });
            const gun = new THREE.Mesh(gunGeometry, gunMaterial);
            gun.position.set(0.5, 1.2, 0);
            gun.lookAt(camera.position); // Initially point towards the camera
            player.add(gun);
    
            // Ground
            const groundGeometry = new THREE.PlaneGeometry(100, 100);
            const groundMaterial = new THREE.MeshBasicMaterial({ color: 0x808080 });
            const ground = new THREE.Mesh(groundGeometry, groundMaterial);
            ground.rotation.x = -Math.PI / 2;
            scene.add(ground);
    
            // Basic Collision (very simple)
            const groundBounds = {
                x: -50,
                y: 0,
                z: -50,
                width: 100,
                height: 0,
                depth: 100
            };
    
            // Variables
            let moveSpeed = 0.1;
            let health = 100;
            let ammo = 10;
            const hudHealth = document.getElementById('health');
            const hudAmmo = document.getElementById('ammo');
    
            // Shooting
            const bulletGeometry = new THREE.SphereGeometry(0.1);
            const bulletMaterial = new THREE.MeshBasicMaterial({ color: 0xff0000 });
            let bullets = [];
    
            // Raycaster for shooting
            const raycaster = new THREE.Raycaster();
    
            // Input Handling
            const keys = {};
            document.addEventListener('keydown', (e) => {
                keys[e.key] = true;
            });
            document.addEventListener('keyup', (e) => {
                keys[e.key] = false;
            });
    
            // Mouse Control (for looking - basic)
            let mouseX = 0;
            let mouseY = 0;
    
            document.addEventListener('mousemove', (e) => {
                mouseX = e.clientX;
                mouseY = e.clientY;
            });
    
            // Function to update the camera's look direction
            function updateCameraLook() {
                camera.lookAt(player.position);
                gun.lookAt(camera.position);
            }
    
            // Game Loop
            function animate() {
                requestAnimationFrame(animate);
    
                // Movement
                if (keys['w']) {
                    player.translateZ(moveSpeed);
                }
                if (keys['s']) {
                    player.translateZ(-moveSpeed);
                }
                if (keys['a']) {
                    player.translateX(-moveSpeed);
                }
                if (keys['d']) {
                    player.translateX(moveSpeed);
                }
    
                // Basic Collision Detection
                if (player.position.y < groundBounds.height + player.geometry.parameters.height / 2) {
                    player.position.y = groundBounds.height + player.geometry.parameters.height / 2;
                }
    
                // Shooting
                if (keys[' '] && ammo > 0) {
                    const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
                    bullet.position.copy(gun.position);
                    bullet.lookAt(camera.position);
                    scene.add(bullet);
                    bullets.push(bullet);
    
                    ammo--;
                    hudAmmo.textContent = ammo;
    
                    // Raycast to determine bullet direction
                    raycaster.setFromCamera(new THREE.Vector3(0, 0, -1), camera);
                    const intersection = raycaster.intersectObjects(scene.children);
    
                    if (intersection.length > 0) {
                        // You can add damage logic here based on the intersected object
                        console.log("Hit:", intersection[0].object);
                    }
    
                    // Move the bullet forward
                    bullet.velocityX = 0.5; // Adjust speed as needed
                }
    
                // Update bullet positions
                bullets.forEach(bullet => {
                    bullet.translateX(bullet.velocityX);
                    if (bullet.position.distanceTo(player.position) > 50) {
                        scene.remove(bullet);
                        bullets = bullets.filter(b => b !== bullet);
                    }
                });
    
                // Update HUD
                hudHealth.textContent = health;
                hudAmmo.textContent = ammo;
    
                // Update camera look
                updateCameraLook();
    
                renderer.render(scene, camera);
            }
    
            animate();
    
            // Window Resize
            window.addEventListener('resize', () => {
                camera.aspect = window.innerWidth / window.innerHeight;
                camera.updateProjectionMatrix();
                renderer.setSize(window.innerWidth, window.innerHeight);
            });
        </script>
    </body>
    </html>
    

    Explanation:

    1. HTML Structure: Sets up the basic HTML with a div for the HUD and another for the crosshair.
    2. Three.js Setup: Initializes the scene, camera, and renderer.
    3. Player and Gun: Creates simple box geometries for the player and gun. The gun is added as a child of the player so it moves with the player.
    4. Ground: Creates a ground plane.
    5. Input Handling: Uses keydown and keyup events to track WASD keys and spacebar for shooting.
    6. Movement: Translates the player based on the pressed keys.
    7. Shooting:
      • Creates a bullet (sphere geometry).
      • Positions the bullet at the gun's position.
      • Sets the bullet's direction using lookAt.
      • Adds the bullet to the scene.
      • Decrements ammo.
      • Uses a raycaster to determine the direction of the bullet.
    8. Game Loop (animate):
      • Updates player position based on input.
      • Renders the scene.
    9. Window Resize: Handles window resizing to maintain the correct aspect ratio.
    10. HUD: Updates the health and ammo display.
    11. Crosshair: A simple CSS-styled crosshair.

    How to Run:

    1. Save the code as index.html.
    2. Open index.html in a web browser.

    Next Steps (to make it "nice"):

    • Models and Textures: Replace the placeholder boxes with actual 3D models (e.g., from Blender, Sketchfab, or other sources). Add textures to make them look more realistic.
    • UI Library: Use a UI library like lil-gui or a framework like React/Vue.js to create a more sophisticated and responsive HUD.
    • Collision Detection: Implement a proper collision detection system using a library like cannon-es or ammo.js.
    • Sound Effects: Add sound effects for shooting, movement, and impacts.
    • Enemies: Add enemies with AI.
    • Levels: Create multiple levels.
    • Lighting: Add lighting to the scene to improve the visual quality.
    • Animations: Add animations to the player and gun.
    • More Realistic Movement: Implement more realistic movement physics (e.g., gravity, friction).
    • Refactor: Break the code into separate JavaScript files for better organization.

    This is a starting point. Building a full-fledged FPS is a significant undertaking, but this example provides a foundation to build upon. Good luck!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.