Skip to content
TheChatArchiveThe Chat Archive
gpt-4.1-2025-04-14· OpenAIHugging Face LMArena Human Preference 140K

Generate a fully working minecraft clone in an html file

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-3-7-sonnet-20250219-thinking-32k’s answer.
  1. User

    Generate a fully working minecraft clone in an html file

  2. Assistant

    Creating a fully working Minecraft clone in a single HTML file is a huge challenge—Minecraft is a complex 3D game with many features. However, I can provide you with a simple voxel engine (block world) in a single HTML file using JavaScript and Three.js. This will let you move around, place, and remove blocks—a basic Minecraft-like experience.

    You can copy and save the following code as minecraft-clone.html and open it in your browser.
    Controls:

    • WASD: Move
    • Space: Jump
    • Left Click: Remove block
    • Right Click: Place block
    • Mouse: Look around (click to lock pointer)

    <!DOCTYPE html>
    <html lang="en">
    <head>
      <meta charset="UTF-8">
      <title>Mini Minecraft Clone</title>
      <style>
        body { margin: 0; overflow: hidden; }
        #info {
          position: absolute; top: 10px; left: 10px; color: #fff;
          background: rgba(0,0,0,0.5); padding: 8px; font-family: sans-serif;
          z-index: 10;
        }
        canvas { display: block; }
      </style>
    </head>
    <body>
    <div id="info">
      <b>Mini Minecraft Clone</b><br>
      WASD: Move | Space: Jump<br>
      Mouse: Look | Left Click: Remove | Right Click: Place<br>
      Click to lock pointer
    </div>
    <script src="https://cdn.jsdelivr.net/npm/three@0.153.0/build/three.min.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/three@0.153.0/examples/js/controls/PointerLockControls.js"></script>
    <script>
    const WORLD_SIZE = 16;
    const WORLD_HEIGHT = 8;
    const BLOCK_SIZE = 1;
    const blocks = {};
    
    function key(x, y, z) { return `${x},${y},${z}`; }
    
    function addBlock(x, y, z, mesh) {
      blocks[key(x, y, z)] = mesh;
    }
    
    function removeBlock(x, y, z) {
      const k = key(x, y, z);
      if (blocks[k]) {
        scene.remove(blocks[k]);
        delete blocks[k];
      }
    }
    
    function blockExists(x, y, z) {
      return !!blocks[key(x, y, z)];
    }
    
    // THREE.js setup
    const scene = new THREE.Scene();
    scene.background = new THREE.Color(0x87ceeb);
    
    const camera = new THREE.PerspectiveCamera(75, window.innerWidth/window.innerHeight, 0.1, 1000);
    
    const renderer = new THREE.WebGLRenderer({antialias:true});
    renderer.setSize(window.innerWidth, window.innerHeight);
    document.body.appendChild(renderer.domElement);
    
    // Lighting
    const light = new THREE.DirectionalLight(0xffffff, 1);
    light.position.set(10, 20, 10);
    scene.add(light);
    scene.add(new THREE.AmbientLight(0xffffff, 0.5));
    
    // Controls
    const controls = new THREE.PointerLockControls(camera, document.body);
    document.body.addEventListener('click', () => controls.lock());
    scene.add(controls.getObject());
    
    // Block material
    const materials = [
      new THREE.MeshLambertMaterial({color: 0x8B4513}), // dirt
      new THREE.MeshLambertMaterial({color: 0x228B22}), // grass
      new THREE.MeshLambertMaterial({color: 0xaaaaaa}), // stone
    ];
    
    function getBlockMaterial(y) {
      if (y === 1) return materials[1]; // grass
      if (y === 0) return materials[0]; // dirt
      return materials[2]; // stone
    }
    
    // Generate flat world
    for (let x = -WORLD_SIZE/2; x < WORLD_SIZE/2; x++) {
      for (let z = -WORLD_SIZE/2; z < WORLD_SIZE/2; z++) {
        for (let y = 0; y < 2; y++) {
          const geometry = new THREE.BoxGeometry(BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE);
          const mesh = new THREE.Mesh(geometry, getBlockMaterial(y));
          mesh.position.set(x, y, z);
          scene.add(mesh);
          addBlock(x, y, z, mesh);
        }
      }
    }
    
    // Player
    camera.position.set(0, 3, 5);
    
    // Movement
    const velocity = new THREE.Vector3();
    const direction = new THREE.Vector3();
    let canJump = false;
    const move = { forward: false, backward: false, left: false, right: false };
    
    document.addEventListener('keydown', function(event) {
      switch(event.code) {
        case 'ArrowUp':
        case 'KeyW': move.forward = true; break;
        case 'ArrowLeft':
        case 'KeyA': move.left = true; break;
        case 'ArrowDown':
        case 'KeyS': move.backward = true; break;
        case 'ArrowRight':
        case 'KeyD': move.right = true; break;
        case 'Space':
          if (canJump) { velocity.y += 5; canJump = false; }
          break;
      }
    });
    document.addEventListener('keyup', function(event) {
      switch(event.code) {
        case 'ArrowUp':
        case 'KeyW': move.forward = false; break;
        case 'ArrowLeft':
        case 'KeyA': move.left = false; break;
        case 'ArrowDown':
        case 'KeyS': move.backward = false; break;
        case 'ArrowRight':
        case 'KeyD': move.right = false; break;
      }
    });
    
    // Raycaster for block interaction
    const raycaster = new THREE.Raycaster();
    let INTERSECTED;
    
    // Place/Remove blocks
    renderer.domElement.addEventListener('mousedown', function(event) {
      if (!controls.isLocked) return;
      raycaster.setFromCamera(new THREE.Vector2(0, 0), camera);
      const intersects = raycaster.intersectObjects(Object.values(blocks));
      if (intersects.length > 0) {
        const intersect = intersects[0];
        const pos = intersect.object.position;
        if (event.button === 0) { // Left click: remove
          if (pos.y > 0) removeBlock(pos.x, pos.y, pos.z);
        } else if (event.button === 2) { // Right click: place
          const normal = intersect.face.normal;
          const nx = pos.x + normal.x;
          const ny = pos.y + normal.y;
          const nz = pos.z + normal.z;
          if (!blockExists(nx, ny, nz)) {
            const geometry = new THREE.BoxGeometry(BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE);
            const mesh = new THREE.Mesh(geometry, materials[0]);
            mesh.position.set(nx, ny, nz);
            scene.add(mesh);
            addBlock(nx, ny, nz, mesh);
          }
        }
      }
    });
    renderer.domElement.addEventListener('contextmenu', e => e.preventDefault());
    
    // Simple collision detection
    function playerCollides(x, y, z) {
      return blockExists(Math.floor(x), Math.floor(y), Math.floor(z));
    }
    
    // Animation loop
    let prevTime = performance.now();
    function animate() {
      requestAnimationFrame(animate);
    
      if (controls.isLocked) {
        const time = performance.now();
        const delta = (time - prevTime) / 1000;
    
        velocity.x -= velocity.x * 10.0 * delta;
        velocity.z -= velocity.z * 10.0 * delta;
        velocity.y -= 9.8 * 5.0 * delta; // gravity
    
        direction.z = Number(move.forward) - Number(move.backward);
        direction.x = Number(move.right) - Number(move.left);
        direction.normalize();
    
        if (move.forward || move.backward) velocity.z -= direction.z * 40.0 * delta;
        if (move.left || move.right) velocity.x -= direction.x * 40.0 * delta;
    
        // Move player
        controls.moveRight(-velocity.x * delta);
        controls.moveForward(-velocity.z * delta);
        camera.position.y += velocity.y * delta;
    
        // Simple ground collision
        if (camera.position.y < 2) {
          velocity.y = 0;
          camera.position.y = 2;
          canJump = true;
        }
    
        // Prevent falling through blocks
        const px = Math.floor(camera.position.x);
        const py = Math.floor(camera.position.y - 1.5);
        const pz = Math.floor(camera.position.z);
        if (blockExists(px, py, pz)) {
          velocity.y = Math.max(0, velocity.y);
          camera.position.y = py + 2.5;
          canJump = true;
        }
    
        prevTime = time;
      }
    
      renderer.render(scene, camera);
    }
    animate();
    
    window.addEventListener('resize', () => {
      camera.aspect = window.innerWidth / window.innerHeight;
      camera.updateProjectionMatrix();
      renderer.setSize(window.innerWidth, window.innerHeight);
    });
    </script>
    </body>
    </html>
    

    Features:

    • 3D block world (flat terrain)
    • Place and remove blocks
    • WASD + mouse movement
    • Jumping and gravity
    • Simple collision

    Limitations:
    This is a very basic clone for demonstration. It does not have advanced features like chunk loading, inventory, crafting, mobs, or multiplayer. For a more advanced project, you'd need a full JavaScript game engine and much more code.

    Let me know if you want to add more features!

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