Trois | Webleb

HTML

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>3D Space Shooter</title>
    <style>
        body { margin: 0; overflow: hidden; background-color: #000; font-family: sans-serif; }
        canvas { display: block; }
        #instructions {
            position: absolute;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            color: white;
            text-align: center;
            background: rgba(0, 0, 0, 0.8);
            padding: 20px;
            border: 2px solid #00ff00;
            cursor: pointer;
            z-index: 10;
        }
        #ui {
            position: absolute;
            top: 20px;
            left: 20px;
            color: #00ff00;
            font-size: 24px;
            pointer-events: none;
        }
        #crosshair {
            position: absolute;
            top: 50%;
            left: 50%;
            width: 20px;
            height: 20px;
            border: 2px solid #00ff00;
            border-radius: 50%;
            transform: translate(-50%, -50%);
            pointer-events: none;
        }
    </style>
</head>
<body>

<div id="instructions">
        <h1>3D SHOOTER</h1>
        <p>CLICK TO START</p>
        <p>(W,A,S,D to Move | MOUSE to Aim | CLICK to Shoot)</p>
    </div>

<div id="ui">Score: <span id="score">0</span></div>
    <div id="crosshair"></div>

init();
        animate();

function init() {
            // Scene & Camera
            scene = new THREE.Scene();
            scene.background = new THREE.Color(0x050505);
            scene.fog = new THREE.Fog(0x050505, 0, 50);

camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
            camera.position.y = 1.6; // Human height

// Lighting
            const light = new THREE.HemisphereLight(0xeeeeff, 0x777788, 0.75);
            light.position.set(0.5, 1, 0.75);
            scene.add(light);

// Floor
            const floorGeometry = new THREE.PlaneGeometry(2000, 2000, 100, 100);
            floorGeometry.rotateX(-Math.PI / 2);
            const floorMaterial = new THREE.MeshBasicMaterial({ color: 0x111111, wireframe: true });
            const floor = new THREE.Mesh(floorGeometry, floorMaterial);
            scene.add(floor);

// Raycaster for shooting
            raycaster = new THREE.Raycaster();

// Renderer
            renderer = new THREE.WebGLRenderer({ antialias: true });
            renderer.setPixelRatio(window.devicePixelRatio);
            renderer.setSize(window.innerWidth, window.innerHeight);
            document.body.appendChild(renderer.domElement);

// Controls logic
            instructions.addEventListener('click', () => {
                document.body.requestPointerLock();
            });

document.addEventListener('pointerlockchange', () => {
                instructions.style.display = document.pointerLockElement === document.body ? 'none' : 'block';
            });

document.addEventListener('mousemove', (e) => {
                if (document.pointerLockElement === document.body) {
                    camera.rotation.y -= e.movementX * 0.002;
                    camera.rotation.x -= e.movementY * 0.002;
                    camera.rotation.x = Math.max(-Math.PI/2, Math.min(Math.PI/2, camera.rotation.x));
                }
            });

document.addEventListener('keydown', (e) => {
                switch (e.code) {
                    case 'KeyW': moveForward = true; break;
                    case 'KeyA': moveLeft = true; break;
                    case 'KeyS': moveBackward = true; break;
                    case 'KeyD': moveRight = true; break;
                }
            });

document.addEventListener('keyup', (e) => {
                switch (e.code) {
                    case 'KeyW': moveForward = false; break;
                    case 'KeyA': moveLeft = false; break;
                    case 'KeyS': moveBackward = false; break;
                    case 'KeyD': moveRight = false; break;
                }
            });

document.addEventListener('mousedown', shoot);

// Spawn initial targets
            for (let i = 0; i < 20; i++) spawnTarget();

window.addEventListener('resize', onWindowResize);
        }

function spawnTarget() {
            const geometry = new THREE.BoxGeometry(1, 1, 1);
            const material = new THREE.MeshPhongMaterial({ color: Math.random() * 0xffffff });
            const cube = new THREE.Mesh(geometry, material);
            
            cube.position.x = (Math.random() - 0.5) * 40;
            cube.position.y = Math.random() * 5 + 0.5;
            cube.position.z = (Math.random() - 0.5) * 40;
            
            scene.add(cube);
            targets.push(cube);
        }

function shoot() {
            if (document.pointerLockElement !== document.body) return;

// Visual feedback (flash)
            scene.background = new THREE.Color(0x330000);
            setTimeout(() => scene.background = new THREE.Color(0x050505), 50);

raycaster.setFromCamera(new THREE.Vector2(0, 0), camera);
            const intersects = raycaster.intersectObjects(targets);

if (intersects.length > 0) {
                const hit = intersects[0].object;
                scene.remove(hit);
                targets = targets.filter(t => t !== hit);
                score += 10;
                scoreElement.innerText = score;
                spawnTarget(); // Replace target
            }
        }

function onWindowResize() {
            camera.aspect = window.innerWidth / window.innerHeight;
            camera.updateProjectionMatrix();
            renderer.setSize(window.innerWidth, window.innerHeight);
        }

function animate() {
            requestAnimationFrame(animate);

if (document.pointerLockElement === document.body) {
                const time = performance.now();
                const delta = 0.15;

velocity.x -= velocity.x * 10.0 * delta;
                velocity.z -= velocity.z * 10.0 * delta;

direction.z = Number(moveForward) - Number(moveBackward);
                direction.x = Number(moveRight) - Number(moveLeft);
                direction.normalize();

if (moveForward || moveBackward) velocity.z -= direction.z * 400.0 * delta;
                if (moveLeft || moveRight) velocity.x -= direction.x * 400.0 * delta;

camera.translateX(-velocity.x * delta);
                camera.translateZ(velocity.z * delta);
                camera.position.y = 1.6; // Keep height fixed
            }

// Animate targets slightly
            targets.forEach(t => {
                t.rotation.y += 0.01;
                t.position.y += Math.sin(Date.now() * 0.002) * 0.005;
            });

renderer.render(scene, camera);
        }
    </script>
</body>
</html>

CSS

JS