Skip to content
TheChatArchiveThe Chat Archive
Mistralmagistral-medium-2506· Mistral AIHugging Face LMArena Human Preference 140K

ahora escribe el código para una simulación del sistema solar. Que sea lo más manejable…

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

    ahora escribe el código para una simulación del sistema solar. Que sea lo más manejable posible, es decir, que pueda moverme dentro del entorno 3D y pueda ver los planetas de cerca y aumentar o disminuir la velocidad de movimiento de estos planetas

  2. Mistral Assistant

    Aquí tienes el código completo para una simulación del sistema solar interactiva y manejable:

    <!DOCTYPE html>
    <html lang="es">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Simulación del Sistema Solar</title>
        <style>
            body {
                margin: 0;
                overflow: hidden;
                font-family: Arial, sans-serif;
            }
            canvas {
                display: block;
            }
            #info {
                position: absolute;
                top: 10px;
                left: 10px;
                color: white;
                background-color: rgba(0, 0, 0, 0.5);
                padding: 10px;
                border-radius: 5px;
                font-size: 14px;
            }
            #controls {
                position: absolute;
                bottom: 20px;
                left: 50%;
                transform: translateX(-50%);
                background-color: rgba(0, 0, 0, 0.5);
                padding: 10px;
                border-radius: 5px;
                color: white;
                display: flex;
                gap: 10px;
            }
            button {
                padding: 5px 10px;
                border: none;
                border-radius: 5px;
                background-color: rgba(255, 255, 255, 0.2);
                color: white;
                cursor: pointer;
            }
            button:hover {
                background-color: rgba(255, 255, 255, 0.3);
            }
        </style>
    </head>
    <body>
        <div id="info">
            <p>Simulación del Sistema Solar</p>
            <p>Usa el ratón para mover la cámara</p>
            <p>Rueda del ratón para acercar/alejar</p>
        </div>
        <div id="controls">
            <button id="speedUp">Aumentar velocidad</button>
            <button id="speedDown">Disminuir velocidad</button>
            <button id="resetSpeed">Velocidad normal</button>
        </div>
        <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
        <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/controls/OrbitControls.min.js"></script>
        <script>
            // Variables globales
            let scene, camera, renderer, controls;
            let planets = [];
            let speedFactor = 1;
    
            // Datos de los planetas (distancia relativa al sol, tamaño relativo, velocidad orbital relativa)
            const planetData = [
                { name: 'Mercurio', distance: 0.39, size: 0.038, speed: 4.15, color: 0xAAAAAA },
                { name: 'Venus', distance: 0.72, size: 0.095, speed: 1.62, color: 0xE6C229 },
                { name: 'Tierra', distance: 1.0, size: 0.1, speed: 1.0, color: 0x1DA1F2 },
                { name: 'Marte', distance: 1.52, size: 0.053, speed: 0.53, color: 0xC1440E },
                { name: 'Júpiter', distance: 5.20, size: 0.3, speed: 0.084, color: 0xDEA584 },
                { name: 'Saturno', distance: 9.58, size: 0.25, speed: 0.034, color: 0xF7E7CE },
                { name: 'Urano', distance: 19.22, size: 0.15, speed: 0.012, color: 0xB5E6E6 },
                { name: 'Neptuno', distance: 30.05, size: 0.15, speed: 0.006, color: 0x4B70DD }
            ];
    
            // Inicializar la escena
            function init() {
                // Crear la escena
                scene = new THREE.Scene();
                scene.background = new THREE.Color(0x000000);
    
                // Crear la cámara
                camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
                camera.position.set(0, 50, 100);
                camera.lookAt(0, 0, 0);
    
                // Crear el renderer
                renderer = new THREE.WebGLRenderer({ antialias: true });
                renderer.setSize(window.innerWidth, window.innerHeight);
                document.body.appendChild(renderer.domElement);
    
                // Añadir controles de órbita
                controls = new THREE.OrbitControls(camera, renderer.domElement);
                controls.enableDamping = true;
                controls.dampingFactor = 0.05;
    
                // Añadir luz ambiental
                const ambientLight = new THREE.AmbientLight(0x404040);
                scene.add(ambientLight);
    
                // Añadir luz direccional
                const directionalLight = new THREE.DirectionalLight(0xffffff, 1);
                directionalLight.position.set(1, 1, 1);
                scene.add(directionalLight);
    
                // Crear el sol
                const sunGeometry = new THREE.SphereGeometry(1, 32, 32);
                const sunMaterial = new THREE.MeshBasicMaterial({ color: 0xFFFF00 });
                const sun = new THREE.Mesh(sunGeometry, sunMaterial);
                scene.add(sun);
    
                // Crear los planetas
                planetData.forEach((data, index) => {
                    const planetGeometry = new THREE.SphereGeometry(data.size, 32, 32);
                    const planetMaterial = new THREE.MeshStandardMaterial({
                        color: data.color,
                        emissive: data.color,
                        emissiveIntensity: 0.2
                    });
                    const planet = new THREE.Mesh(planetGeometry, planetMaterial);
                    planet.position.x = data.distance * 10; // Escalar la distancia para mejor visualización
                    scene.add(planet);
    
                    // Crear la órbita (anillo)
                    const orbitGeometry = new THREE.RingGeometry(data.distance * 10 - 0.05, data.distance * 10 + 0.05, 64);
                    const orbitMaterial = new THREE.MeshBasicMaterial({
                        color: 0x888888,
                        side: THREE.DoubleSide,
                        transparent: true,
                        opacity: 0.5
                    });
                    const orbit = new THREE.Mesh(orbitGeometry, orbitMaterial);
                    orbit.rotation.x = Math.PI / 2; // Rotar para que esté en el plano XY
                    scene.add(orbit);
    
                    // Guardar información del planeta para la animación
                    planets.push({
                        mesh: planet,
                        distance: data.distance * 10,
                        speed: data.speed * 0.01 * speedFactor, // Ajustar la velocidad para la simulación
                        angle: Math.random() * Math.PI * 2, // Posición inicial aleatoria
                        orbit: orbit
                    });
                });
    
                // Añadir estrellas de fondo
                addStars();
    
                // Manejar el cambio de tamaño de la ventana
                window.addEventListener('resize', onWindowResize);
    
                // Añadir controles de velocidad
                document.getElementById('speedUp').addEventListener('click', () => {
                    speedFactor *= 1.5;
                    updatePlanetSpeeds();
                });
    
                document.getElementById('speedDown').addEventListener('click', () => {
                    speedFactor /= 1.5;
                    updatePlanetSpeeds();
                });
    
                document.getElementById('resetSpeed').addEventListener('click', () => {
                    speedFactor = 1;
                    updatePlanetSpeeds();
                });
    
                // Iniciar la animación
                animate();
            }
    
            function addStars() {
                const starGeometry = new THREE.BufferGeometry();
                const starMaterial = new THREE.PointsMaterial({
                    color: 0xFFFFFF,
                    size: 0.1,
                    transparent: true,
                    opacity: 0.8
                });
    
                const starVertices = [];
                for (let i = 0; i < 10000; 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 stars = new THREE.Points(starGeometry, starMaterial);
                scene.add(stars);
            }
    
            function updatePlanetSpeeds() {
                planetData.forEach((data, index) => {
                    planets[index].speed = data.speed * 0.01 * speedFactor;
                });
            }
    
            function onWindowResize() {
                camera.aspect = window.innerWidth / window.innerHeight;
                camera.updateProjectionMatrix();
                renderer.setSize(window.innerWidth, window.innerHeight);
            }
    
            function animate() {
                requestAnimationFrame(animate);
    
                // Actualizar la posición de los planetas
                planets.forEach(planet => {
                    planet.angle += planet.speed;
                    planet.mesh.position.x = Math.cos(planet.angle) * planet.distance;
                    planet.mesh.position.z = Math.sin(planet.angle) * planet.distance;
                });
    
                controls.update();
                renderer.render(scene, camera);
            }
    
            // Iniciar la aplicación
            init();
        </script>
    </body>
    </html>
    

    Esta simulación del sistema solar incluye:

    • Representación del Sol y los ocho planetas principales.
    • Órbitas visuales para cada planeta.
    • Controles de cámara para explorar la escena en 3D.
    • Botones para ajustar la velocidad de la simulación.
    • Estrellas de fondo para un efecto de espacio.
    • Iluminación adecuada para una mejor visualización.

    La simulación es interactiva y permite al usuario moverse libremente por el espacio para observar los planetas desde diferentes ángulos y distancias. Los controles de velocidad permiten ajustar la velocidad de la simulación para observar mejor los movimientos orbitales.

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