Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.0-flash-001· GoogleHugging Face LMArena Human Preference 140K

cool, can we improve that a little bit? please ensure that there: 1. the spaceship is…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with o3-mini’s answer.
  1. User

    cool, can we improve that a little bit?

    please ensure that there:

    1. the spaceship is visible witho toggle to first perrson
    2. there are other space objects
    3. perhaps infinite expansion of space?
  2. Gemini Assistant

    Okay, let's enhance the space flight simulator with the following improvements:

    1. Third-Person View with Toggle: Retain the visible spaceship with a simple key toggle (e.g., 'T') to switch between a first-person view (camera inside the ship) and a third-person view (camera behind the ship).
    2. Space Objects: Add some static planets/asteroids to populate the scene.
    3. Infinite Space Expansion: Implement a basic "infinite" scrolling effect for the starfield and space objects so that the player feels like they are always moving forward even though they are within a limited area.

    Here's the modified code:

    <!DOCTYPE html>
    <html lang="en">
    <head>
      <meta charset="UTF-8">
      <title>Three.js Space Flight Simulator</title>
      <style>
        body { margin: 0; overflow: hidden; background: black; }
        #info { position: absolute; top: 10px; left: 10px; color: white; z-index: 1; }
      </style>
    </head>
    <body>
      <div id="info">
        <b>Space Flight Simulator</b><br>
        WASD: Move<br>
        Mouse: Look<br>
        Space/Shift: Up/Down<br>
        T: Toggle View<br>
        Click to lock pointer
      </div>
      <script type="module">
        import * as THREE from 'https://cdn.jsdelivr.net/npm/three@0.153.0/build/three.module.js';
    
        // Scene, Camera, Renderer
        const scene = new THREE.Scene();
        scene.background = new THREE.Color(0x000010);
    
        const camera = new THREE.PerspectiveCamera(75, window.innerWidth/window.innerHeight, 0.1, 10000);
        camera.position.set(0, 5, 15);
    
        const renderer = new THREE.WebGLRenderer({antialias: true});
        renderer.setSize(window.innerWidth, window.innerHeight);
        document.body.appendChild(renderer.domElement);
    
        // Starfield
        const starGeometry = new THREE.BufferGeometry();
        const starCount = 2000;
        const starVertices = [];
        for (let i = 0; i < starCount; i++) {
          const x = (Math.random() - 0.5) * 2000;
          const y = (Math.random() - 0.5) * 2000;
          const z = (Math.random() - 0.5) * 2000;
          starVertices.push(x, y, z);
        }
        starGeometry.setAttribute('position', new THREE.Float32BufferAttribute(starVertices, 3));
        const starMaterial = new THREE.PointsMaterial({ color: 0xffffff, size: 1 });
        const stars = new THREE.Points(starGeometry, starMaterial);
        scene.add(stars);
    
        // Spaceship (simple cone)
        const shipGeometry = new THREE.ConeGeometry(1, 3, 16);
        const shipMaterial = new THREE.MeshPhongMaterial({ color: 0x00ffcc });
        const ship = new THREE.Mesh(shipGeometry, shipMaterial);
        ship.rotation.x = Math.PI / 2;
        scene.add(ship);
    
        // Space Objects
        const objects = [];
        const objectCount = 10;
        for (let i = 0; i < objectCount; i++) {
          const geometry = new THREE.SphereGeometry(Math.random() * 5 + 1, 16, 16);
          const material = new THREE.MeshPhongMaterial({ color: Math.random() * 0xffffff });
          const object = new THREE.Mesh(geometry, material);
          object.position.set(
            (Math.random() - 0.5) * 100,
            (Math.random() - 0.5) * 100,
            (Math.random() - 0.5) * 100
          );
          scene.add(object);
          objects.push(object);
        }
    
        // Light
        const light = new THREE.PointLight(0xffffff, 1, 100);
        light.position.set(0, 10, 10);
        scene.add(light);
    
        // Controls
        let velocity = new THREE.Vector3();
        let direction = new THREE.Vector3();
        let moveForward = false, moveBackward = false, moveLeft = false, moveRight = false, moveUp = false, moveDown = false;
        let canMove = false;
        let thirdPerson = true; // Start in third-person mode
        let cameraOffset = new THREE.Vector3(0, 5, 15); // Default third-person camera offset
    
        // Pointer Lock
        renderer.domElement.addEventListener('click', () => {
          renderer.domElement.requestPointerLock();
        });
    
        let pitch = 0, yaw = 0;
        document.addEventListener('pointerlockchange', () => {
          canMove = document.pointerLockElement === renderer.domElement;
        });
    
        document.addEventListener('mousemove', (event) => {
          if (!canMove) return;
          yaw -= event.movementX * 0.002;
          pitch -= event.movementY * 0.002;
          pitch = Math.max(-Math.PI/2, Math.min(Math.PI/2, pitch));
        });
    
        // Keyboard
        document.addEventListener('keydown', (event) => {
          switch(event.code) {
            case 'KeyW': moveForward = true; break;
            case 'KeyS': moveBackward = true; break;
            case 'KeyA': moveLeft = true; break;
            case 'KeyD': moveRight = true; break;
            case 'Space': moveUp = true; break;
            case 'ShiftLeft': moveDown = true; break;
            case 'KeyT': // Toggle View
              thirdPerson = !thirdPerson;
              cameraOffset = thirdPerson ? new THREE.Vector3(0, 5, 15) : new THREE.Vector3(0, 0, 0);
              break;
          }
        });
        document.addEventListener('keyup', (event) => {
          switch(event.code) {
            case 'KeyW': moveForward = false; break;
            case 'KeyS': moveBackward = false; break;
            case 'KeyA': moveLeft = false; break;
            case 'KeyD': moveRight = false; break;
            case 'Space': moveUp = false; break;
            case 'ShiftLeft': moveDown = false; break;
          }
        });
    
        // Animation Loop
        function animate() {
          requestAnimationFrame(animate);
    
          // Update direction
          direction.set(0, 0, 0);
          if (moveForward) direction.z -= 1;
          if (moveBackward) direction.z += 1;
          if (moveLeft) direction.x -= 1;
          if (moveRight) direction.x += 1;
          if (moveUp) direction.y += 1;
          if (moveDown) direction.y -= 1;
          direction.normalize();
    
          // Rotate camera and ship
          camera.rotation.order = 'YXZ';
          camera.rotation.y = yaw;
          camera.rotation.x = pitch;
    
          // Move ship
          const speed = 0.5;
          const move = new THREE.Vector3(direction.x, direction.y, direction.z);
          move.applyEuler(camera.rotation);
          ship.position.add(move.multiplyScalar(speed));
    
          // Camera follow ship
          const cameraPosition = ship.position.clone().add(cameraOffset.clone().applyEuler(ship.rotation));
          camera.position.copy(cameraPosition);
          camera.rotation.copy(ship.rotation);
    
          // "Infinite" Scrolling
          const scrollSpeed = 0.1;
          stars.position.z += scrollSpeed;
          if (stars.position.z > 1000) {
              stars.position.z -= 2000; // Reset starfield
          }
    
          objects.forEach(object => {
              object.position.z += scrollSpeed;
              if (object.position.z > 100) {
                  object.position.z = -100; // Reset objects
                  object.position.x = (Math.random() - 0.5) * 100;
                  object.position.y = (Math.random() - 0.5) * 100;
              }
          });
    
          renderer.render(scene, camera);
        }
        animate();
    
        // Responsive
        window.addEventListener('resize', () => {
          camera.aspect = window.innerWidth / window.innerHeight;
          camera.updateProjectionMatrix();
          renderer.setSize(window.innerWidth, window.innerHeight);
        });
      </script>
    </body>
    </html>
    

    Key changes from the previous version:

    • thirdPerson Variable: Tracks the current camera mode.
    • cameraOffset Vector: Determines the camera's position relative to the ship in third-person mode. It's set to (0, 5, 15) initially.
    • KeyT Event: Added a keydown event for the 'T' key that toggles the thirdPerson variable and updates the cameraOffset.
    • Camera Positioning: Instead of moving the camera independently, the camera now follows the ship's position and rotation, with the specified offset in third-person mode, or right inside the ship in first-person mode.
    • Infinite Scrolling: The stars and objects positions are updated on each frame. When they move past a certain threshold (1000 for stars, 100 for objects), they're repositioned to create the illusion of endless space.

    How to Use:

    1. Save: Save the code as index.html.
    2. Open: Open index.html in your browser.
    3. Click: Click on the screen to lock the pointer and enable movement.
    4. Controls:
      • WASD: Move the ship
      • Mouse: Look around
      • Space/Shift: Move up/down
      • 'T': Toggle between third-person and first-person view

    This expanded version provides a more engaging space flight experience with a visible spaceship, space objects, and a simple "infinite" scrolling effect.

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

Identical first prompt