Skip to content
TheChatArchiveThe Chat Archive
Qwenqwen3-30b-a3b· Alibaba (Qwen)Hugging Face LMArena Human Preference 140K

Crée un jeux Minecraft. Avec comme systèmes : Contrôle du joueur il faut que sa…

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

    Crée un jeux Minecraft.

    Avec comme systèmes :

    Contrôle du joueur il faut que sa fonctionne sous android.

    Crée un plateforme 3D à la quelle c'est composé de plusieurs cube gris attaché les une par les autres. Pour les distinguer a l'extrémité du cube gris il est gris foncé.

    un système qui permet de charger des chunck lorsque le joueur se déplace

    le joueur incarnera un rectangle vert mes il sera plus petit horizontal par rapport au cube gris

    il faut que tu crée un bouton qui permet de mettre à la 1er personne et à la 3eme personne.

    un système de hitbox de collision pour éviter que le joueur traverse le cube gris

    le ciel est bleu pour l'arrière plan

    pour la génération de plateforme il faut qu'il y a des montagnes et des creux (il faut également qu'il y a des cube gris dans le creux)

    Utiliser le bibliothèque three

    Écrire en une seul fichier de code.

  2. Qwen Assistant

    Voici un fichier HTML complet contenant un jeu Minecraft-like, écrit en JavaScript avec la bibliothèque Three.js. Ce code est conçu pour fonctionner sur un appareil Android (via un navigateur web compatible WebGL) et inclut tous les systèmes demandés :


    🌟 Caractéristiques principales :

    • Contrôles tactiles adaptés pour Android (boutons pour se déplacer, tourner, sauter, basculer la vue).
    • Plateforme 3D composée de cubes gris, avec une différenciation visuelle des extrémités (cubes gris foncé à l'extrémité).
    • Chargement dynamique de chunks selon la position du joueur.
    • Joueur représenté par un rectangle vert plus petit horizontalement que les cubes.
    • Système de collision pour éviter que le joueur traverse les cubes.
    • Ciel bleu en arrière-plan.
    • Génération de terrain avec des montagnes et des creux (cubes dans les creux).

    📄 Code complet (un seul fichier HTML) :

    <!DOCTYPE html>
    <html lang="fr">
    <head>
        <meta charset="UTF-8" />
        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
        <title>Jeu Minecraft-Like</title>
        <style>
            body {
                margin: 0;
                overflow: hidden;
            }
            #controls {
                position: absolute;
                bottom: 10px;
                left: 10px;
                display: flex;
                flex-direction: column;
            }
            .row {
                display: flex;
                justify-content: space-between;
            }
            button {
                width: 50px;
                height: 50px;
                margin: 5px;
                font-size: 20px;
            }
        </style>
    </head>
    <body>
        <div id="controls">
            <div class="row">
                <button id="turnLeft">↺</button>
                <button id="forward">↑</button>
                <button id="turnRight">↻</button>
            </div>
            <div class="row">
                <button id="left">←</button>
                <button id="backward">↓</button>
                <button id="right">→</button>
            </div>
            <div class="row">
                <button id="jump">Saut</button>
                <button id="toggleView">Vue</button>
            </div>
        </div>
    
        <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
        <script>
            // Configuration
            const chunkSize = 16;
            const renderDistance = 2;
            const moveSpeed = 5;
            const turnSpeed = Math.PI;
            const jumpStrength = 5;
            const gravity = 20;
    
            let isFirstPerson = false;
            let playerYaw = 0;
            let velocity = new THREE.Vector3();
            let isOnGround = false;
            let isMovingForward = false, isMovingBackward = false, isMovingLeft = false, isMovingRight = false;
            let isTurningLeft = false, isTurningRight = false;
    
            const scene = new THREE.Scene();
            scene.background = new THREE.Color(0x87ceeb); // Ciel bleu
    
            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);
    
            // Lumière
            const ambientLight = new THREE.AmbientLight(0xffffff, 0.5);
            scene.add(ambientLight);
            const directionalLight = new THREE.DirectionalLight(0xffffff, 0.5);
            directionalLight.position.set(1, 1, 1);
            scene.add(directionalLight);
    
            // Joueur (rectangle vert)
            const playerGeometry = new THREE.BoxGeometry(0.6, 1.8, 0.6);
            const playerMaterial = new THREE.MeshBasicMaterial({ color: 0x00ff00 });
            const player = new THREE.Mesh(playerGeometry, playerMaterial);
            player.position.set(0, 11, 0);
            scene.add(player);
    
            // Génération de terrain
            function getHeight(x, z) {
                return Math.floor(10 + 5 * Math.sin(x / 5) * Math.cos(z / 5));
            }
    
            function isSolid(x, y, z) {
                if (y < 0) return false;
                const height = getHeight(x, z);
                return y <= height;
            }
    
            function checkCollision(position) {
                const playerMin = new THREE.Vector3().subVectors(position, new THREE.Vector3(0.3, 0.9, 0.3));
                const playerMax = new THREE.Vector3().addVectors(position, new THREE.Vector3(0.3, 0.9, 0.3));
                const minX = Math.floor(playerMin.x), maxX = Math.floor(playerMax.x);
                const minY = Math.floor(playerMin.y), maxY = Math.floor(playerMax.y);
                const minZ = Math.floor(playerMin.z), maxZ = Math.floor(playerMax.z);
    
                for (let x = minX; x <= maxX; x++) {
                    for (let y = minY; y <= maxY; y++) {
                        for (let z = minZ; z <= maxZ; z++) {
                            if (isSolid(x, y, z)) return true;
                        }
                    }
                }
                return false;
            }
    
            function generateChunk(cx, cz) {
                const chunkGroup = new THREE.Group();
                for (let dx = 0; dx < chunkSize; dx++) {
                    for (let dz = 0; dz < chunkSize; dz++) {
                        const wx = cx * chunkSize + dx;
                        const wz = cz * chunkSize + dz;
                        const height = getHeight(wx, wz);
                        for (let wy = 0; wy <= height; wy++) {
                            const cube = new THREE.Mesh(
                                new THREE.BoxGeometry(1, 1, 1),
                                new THREE.MeshLambertMaterial({
                                    color: wy === height ? 0x444444 : 0x808080 // Cube gris foncé à l'extrémité
                                })
                            );
                            cube.position.set(wx + 0.5, wy + 0.5, wz + 0.5);
                            chunkGroup.add(cube);
                        }
                    }
                }
                scene.add(chunkGroup);
                return chunkGroup;
            }
    
            function loadChunks() {
                const playerChunkX = Math.floor(player.position.x / chunkSize);
                const playerChunkZ = Math.floor(player.position.z / chunkSize);
                for (let cz = playerChunkZ - renderDistance; cz <= playerChunkZ + renderDistance; cz++) {
                    for (let cx = playerChunkX - renderDistance; cx <= playerChunkX + renderDistance; cx++) {
                        const key = `${cx}_${cz}`;
                        if (!chunks[key]) chunks[key] = generateChunk(cx, cz);
                    }
                }
            }
    
            function jump() {
                if (isOnGround) {
                    velocity.y = jumpStrength;
                    isOnGround = false;
                }
            }
    
            function toggleView() {
                isFirstPerson = !isFirstPerson;
            }
    
            // Contrôles tactiles
            document.getElementById('forward').addEventListener('touchstart', () => isMovingForward = true);
            document.getElementById('forward').addEventListener('touchend', () => isMovingForward = false);
            document.getElementById('backward').addEventListener('touchstart', () => isMovingBackward = true);
            document.getElementById('backward').addEventListener('touchend', () => isMovingBackward = false);
            document.getElementById('left').addEventListener('touchstart', () => isMovingLeft = true);
            document.getElementById('left').addEventListener('touchend', () => isMovingLeft = false);
            document.getElementById('right').addEventListener('touchstart', () => isMovingRight = true);
            document.getElementById('right').addEventListener('touchend', () => isMovingRight = false);
            document.getElementById('turnLeft').addEventListener('touchstart', () => isTurningLeft = true);
            document.getElementById('turnLeft').addEventListener('touchend', () => isTurningLeft = false);
            document.getElementById('turnRight').addEventListener('touchstart', () => isTurningRight = true);
            document.getElementById('turnRight').addEventListener('touchend', () => isTurningRight = false);
            document.getElementById('jump').addEventListener('touchstart', jump);
            document.getElementById('toggleView').addEventListener('click', toggleView);
    
            // Animation
            const clock = new THREE.Clock();
            const chunks = {};
            loadChunks();
    
            function animate() {
                requestAnimationFrame(animate);
                const delta = clock.getDelta();
    
                if (isTurningLeft) playerYaw -= turnSpeed * delta;
                if (isTurningRight) playerYaw += turnSpeed * delta;
    
                const forward = new THREE.Vector3(0, 0, -1).applyAxisAngle(new THREE.Vector3(0, 1, 0), playerYaw);
                const right = new THREE.Vector3(1, 0, 0).applyAxisAngle(new THREE.Vector3(0, 1, 0), playerYaw);
                let displacement = new THREE.Vector3();
                if (isMovingForward) displacement.add(forward.clone().multiplyScalar(moveSpeed * delta));
                if (isMovingBackward) displacement.add(forward.clone().multiplyScalar(-moveSpeed * delta));
                if (isMovingLeft) displacement.add(right.clone().multiplyScalar(-moveSpeed * delta));
                if (isMovingRight) displacement.add(right.clone().multiplyScalar(moveSpeed * delta));
    
                velocity.y -= gravity * delta;
                let displacementY = velocity.y * delta;
    
                player.position.x += displacement.x;
                if (checkCollision(player.position)) player.position.x -= displacement.x;
    
                player.position.z += displacement.z;
                if (checkCollision(player.position)) player.position.z -= displacement.z;
    
                const originalY = player.position.y;
                player.position.y += displacementY;
                if (checkCollision(player.position)) {
                    if (displacementY < 0) {
                        const pminX = Math.floor(player.position.x - 0.3);
                        const pmaxX = Math.floor(player.position.x + 0.3);
                        const pminZ = Math.floor(player.position.z - 0.3);
                        const pmaxZ = Math.floor(player.position.z + 0.3);
                        let maxHeight = -Infinity;
                        for (let x = pminX; x <= pmaxX; x++) {
                            for (let z = pminZ; z <= pmaxZ; z++) {
                                const height = getHeight(x, z);
                                if (height > maxHeight) maxHeight = height;
                            }
                        }
                        player.position.y = maxHeight + 1.0;
                        velocity.y = 0;
                        isOnGround = true;
                    } else {
                        player.position.y = originalY;
                        velocity.y = 0;
                    }
                } else {
                    isOnGround = false;
                }
    
                loadChunks();
    
                if (isFirstPerson) {
                    camera.position.copy(player.position).add(new THREE.Vector3(0, 1.6, 0));
                    camera.rotation.y = playerYaw;
                } else {
                    const cameraOffset = new THREE.Vector3(0, 1.6, 5).applyAxisAngle(new THREE.Vector3(0, 1, 0), playerYaw);
                    camera.position.copy(player.position).add(cameraOffset);
                    camera.lookAt(player.position.x, player.position.y + 1.6, player.position.z);
                }
    
                player.visible = !isFirstPerson;
    
                renderer.render(scene, camera);
            }
    
            animate();
        </script>
    </body>
    </html>
    

    🧠 Comment fonctionne le code :

    • Contrôles tactiles : Les boutons sont gérés via touchstart et touchend. Le joueur se déplace en utilisant des directions (haut, bas, gauche, droite) et peut sauter.
    • Cube gris avec extrémité noire : Les cubes sont générés avec une couleur grise par défaut, mais le dernier cube de chaque colonne (la surface) est en gris foncé pour simuler les extrémités.
    • Chunks dynamiques : Les chunks sont chargés autour du joueur en fonction de sa position, avec une distance de rendu fixe.
    • Collision : Une vérification AABB (Axis-Aligned Bounding Box) est utilisée pour éviter que le joueur traverse les cubes.
    • Vue à la première ou troisième personne : Un bouton permet de basculer entre les deux modes.

    📱 Pour tester :

    1. Copiez le code dans un fichier .html.
    2. Ouvrez-le dans un navigateur web sur un appareil Android.
    3. Utilisez les boutons tactiles pour contrôler le joueur.
    4. Explorez le monde 3D avec des montagnes et des creux.

    Ce code est un prototype complet et peut être étendu pour ajouter des textures, des blocs interactifs ou des mécaniques avancées.

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