Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-pro-preview-05-06· GoogleHugging Face LMArena Human Preference 140K

сделай симуляцию солнечной системы на js

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Metallama-4-maverick-03-26-experimental’s answer.
  1. User

    сделай симуляцию солнечной системы на js

  2. Gemini Assistant

    Хорошо, давайте создадим упрощенную 2D симуляцию Солнечной системы с использованием HTML5 Canvas и JavaScript. Мы реализуем гравитационное взаимодействие между телами.

    Эта симуляция будет включать:

    1. Солнце в центре.
    2. Несколько планет, вращающихся вокруг Солнца.
    3. Базовый расчет гравитации (упрощенный).
    4. Возможность масштабирования и панорамирования.
    5. Отображение орбит (следов).
    <!DOCTYPE html>
    <html lang="ru">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Симуляция Солнечной Системы</title>
        <style>
            body {
                margin: 0;
                overflow: hidden;
                background-color: #000;
                display: flex;
                flex-direction: column;
                align-items: center;
                justify-content: center;
                height: 100vh;
                font-family: Arial, sans-serif;
                color: #fff;
            }
            canvas {
                border: 1px solid #333;
            }
            #controls {
                position: absolute;
                top: 10px;
                left: 10px;
                background-color: rgba(50, 50, 50, 0.8);
                padding: 10px;
                border-radius: 5px;
                color: #fff;
            }
            #controls label, #controls input, #controls button {
                margin-bottom: 5px;
                display: block;
            }
            #controls input[type="range"] {
                width: 150px;
            }
            #info {
                position: absolute;
                bottom: 10px;
                left: 10px;
                background-color: rgba(50, 50, 50, 0.8);
                padding: 10px;
                border-radius: 5px;
                font-size: 0.9em;
            }
        </style>
    </head>
    <body>
        <div id="controls">
            <label for="timeSpeed">Скорость времени:</label>
            <input type="range" id="timeSpeed" min="0.1" max="5" step="0.1" value="1">
            <label for="trailLength">Длина следа:</label>
            <input type="range" id="trailLength" min="0" max="1000" step="50" value="200">
            <button id="resetView">Сброс вида</button>
        </div>
        <div id="info">
            Используйте колесо мыши для масштабирования. <br>
            Зажмите ЛКМ и двигайте для панорамирования.
        </div>
        <canvas id="solarSystemCanvas"></canvas>
    
        <script>
            const canvas = document.getElementById('solarSystemCanvas');
            const ctx = canvas.getContext('2d');
    
            const timeSpeedSlider = document.getElementById('timeSpeed');
            const trailLengthSlider = document.getElementById('trailLength');
            const resetViewButton = document.getElementById('resetView');
    
            // Устанавливаем размер канваса
            canvas.width = window.innerWidth * 0.95;
            canvas.height = window.innerHeight * 0.9;
    
            // Параметры симуляции
            const G = 2; // Гравитационная постоянная (подобранная для визуализации)
            let timeScale = 1; // Ускорение времени
            let maxTrailLength = 200;
    
            // Камера/вид
            let zoom = 0.5; // Начальный масштаб
            let panX = canvas.width / 2;
            let panY = canvas.height / 2;
            let isPanning = false;
            let lastPanX, lastPanY;
    
            class CelestialBody {
                constructor(name, x, y, vx, vy, mass, radius, color, isStar = false) {
                    this.name = name;
                    this.x = x; // Координаты в симуляции, не на канвасе
                    this.y = y;
                    this.vx = vx; // Скорость
                    this.vy = vy;
                    this.mass = mass;
                    this.radius = radius; // Визуальный радиус
                    this.color = color;
                    this.isStar = isStar;
                    this.trail = [];
                }
    
                applyForce(fx, fy) {
                    if (this.isStar) return; // Звезда не двигается под действием планет (упрощение)
    
                    // a = F/m
                    const ax = fx / this.mass;
                    const ay = fy / this.mass;
    
                    this.vx += ax * timeScale;
                    this.vy += ay * timeScale;
                }
    
                updatePosition() {
                    if (this.isStar) return;
    
                    this.x += this.vx * timeScale;
                    this.y += this.vy * timeScale;
    
                    // Добавляем точку в след
                    this.trail.push({ x: this.x, y: this.y });
                    if (this.trail.length > maxTrailLength) {
                        this.trail.shift();
                    }
                }
    
                draw(ctx) {
                    // Трансформация координат мира в координаты канваса
                    const screenX = this.x * zoom + panX;
                    const screenY = this.y * zoom + panY;
                    const screenRadius = this.radius * zoom;
    
                    // Не рисуем, если слишком далеко или слишком маленькое
                    if (screenX + screenRadius < 0 || screenX - screenRadius > canvas.width ||
                        screenY + screenRadius < 0 || screenY - screenRadius > canvas.height ||
                        screenRadius < 0.5 && !this.isStar) {
                        return;
                    }
                    
                    // Рисуем след
                    if (this.trail.length > 1 && maxTrailLength > 0) {
                        ctx.beginPath();
                        ctx.strokeStyle = this.color;
                        ctx.lineWidth = Math.max(1, 1 * zoom); // Толщина линии следа
                        const firstTrailPointX = this.trail[0].x * zoom + panX;
                        const firstTrailPointY = this.trail[0].y * zoom + panY;
                        ctx.moveTo(firstTrailPointX, firstTrailPointY);
                        for (let i = 1; i < this.trail.length; i++) {
                            const trailPointX = this.trail[i].x * zoom + panX;
                            const trailPointY = this.trail[i].y * zoom + panY;
                            ctx.lineTo(trailPointX, trailPointY);
                        }
                        ctx.stroke();
                    }
    
                    // Рисуем тело
                    ctx.beginPath();
                    ctx.arc(screenX, screenY, Math.max(0.5, screenRadius), 0, Math.PI * 2);
                    ctx.fillStyle = this.color;
                    ctx.fill();
    
                    // Название планеты, если достаточно крупная
                    if (screenRadius > 10) {
                        ctx.fillStyle = 'white';
                        ctx.font = `${Math.max(8, 12 * zoom)}px Arial`;
                        ctx.textAlign = 'center';
                        ctx.fillText(this.name, screenX, screenY - screenRadius - 5 * zoom);
                    }
                }
            }
    
            let bodies = [];
    
            function initSolarSystem() {
                bodies = []; // Очищаем предыдущие тела
    
                // Солнце
                const sun = new CelestialBody('Солнце', 0, 0, 0, 0, 10000, 30, 'yellow', true);
                bodies.push(sun);
    
                // Планеты (примерные параметры для стабильных орбит с нашим G)
                // Меркурий
                bodies.push(new CelestialBody('Меркурий', 100, 0, 0, 7, 1, 4, 'gray'));
                // Венера
                bodies.push(new CelestialBody('Венера', 0, -180, 6, 0, 8, 8, 'lightyellow'));
                // Земля
                bodies.push(new CelestialBody('Земля', -250, 0, 0, -5.5, 10, 10, 'blue'));
                // Марс
                bodies.push(new CelestialBody('Марс', 0, 350, -4.5, 0, 5, 7, 'red'));
                 // Юпитер
                bodies.push(new CelestialBody('Юпитер', 500, 0, 0, 3.5, 1000, 20, 'orange'));
                // Сатурн (с кольцами - упрощенно)
                const saturn = new CelestialBody('Сатурн', 0, -700, 3, 0, 800, 17, 'khaki');
                bodies.push(saturn);
                 // Кольца Сатурна как отдельный элемент для простоты (не взаимодействуют)
                saturn.drawRing = function(ctx_ring) { // Используем другое имя для ctx
                    const screenX = this.x * zoom + panX;
                    const screenY = this.y * zoom + panY;
                    const screenRadius = this.radius * zoom;
                     if (screenX + screenRadius*2.5 < 0 || screenX - screenRadius*2.5 > canvas.width ||
                        screenY + screenRadius*2.5 < 0 || screenY - screenRadius*2.5 > canvas.height ||
                        screenRadius < 0.5) {
                        return;
                    }
                    ctx_ring.strokeStyle = 'rgba(200, 200, 150, 0.7)';
                    ctx_ring.lineWidth = Math.max(1, 4 * zoom);
                    ctx_ring.beginPath();
                    ctx_ring.ellipse(screenX, screenY, screenRadius * 2.2, screenRadius * 1.2, this.vx > 0 ? 0.2 : -0.2, 0, Math.PI * 2);
                    ctx_ring.stroke();
                    ctx_ring.lineWidth = Math.max(1, 2 * zoom);
                    ctx_ring.beginPath();
                    ctx_ring.ellipse(screenX, screenY, screenRadius * 1.7, screenRadius * 0.8, this.vx > 0 ? 0.2 : -0.2, 0, Math.PI * 2);
                    ctx_ring.stroke();
                }
            }
    
    
            function calculateForces() {
                for (let i = 0; i < bodies.length; i++) {
                    let totalFx = 0;
                    let totalFy = 0;
    
                    if (bodies[i].isStar) continue; // Силы на звезду не считаем (она фиксирована)
    
                    for (let j = 0; j < bodies.length; j++) {
                        if (i === j) continue;
    
                        const body1 = bodies[i];
                        const body2 = bodies[j];
    
                        const dx = body2.x - body1.x;
                        const dy = body2.y - body1.y;
                        const distSq = dx * dx + dy * dy;
                        const dist = Math.sqrt(distSq);
    
                        if (dist < body1.radius + body2.radius) { // Простая обработка столкновений (отскок)
                           // Для упрощения, просто не даем им слипнуться, сила отталкивания
                           // Можно было бы реализовать более сложную физику столкновений
                            if(dist < 1) dist = 1; // избегаем деления на ноль
                            const forceMagnitude = -G * body1.mass * body2.mass / (distSq * 10); // Отталкивание
                            totalFx += (forceMagnitude * dx / dist);
                            totalFy += (forceMagnitude * dy / dist);
                            continue; // Не применяем притяжение если слишком близко
                        }
                        
                        if (dist > 0) { // Избегаем деления на ноль
                            const forceMagnitude = G * body1.mass * body2.mass / distSq;
                            totalFx += (forceMagnitude * dx / dist);
                            totalFy += (forceMagnitude * dy / dist);
                        }
                    }
                    bodies[i].applyForce(totalFx, totalFy);
                }
            }
    
            function updatePositions() {
                bodies.forEach(body => body.updatePosition());
            }
    
            function draw() {
                ctx.fillStyle = 'black';
                ctx.fillRect(0, 0, canvas.width, canvas.height);
    
                // Рисуем сетку для ориентации (опционально)
                drawGrid();
    
                bodies.forEach(body => {
                    body.draw(ctx);
                     if (body.name === 'Сатурн' && body.drawRing) { // Рисуем кольца Сатурна
                        body.drawRing(ctx);
                    }
                });
            }
            
            function drawGrid() {
                const gridSize = 100 * zoom; // Размер ячейки сетки зависит от зума
                if (gridSize < 10) return; // Не рисуем слишком мелкую сетку
    
                ctx.strokeStyle = 'rgba(255, 255, 255, 0.05)'; // Очень тусклая сетка
                ctx.lineWidth = 1;
    
                // Вертикальные линии
                const startX = (-panX % gridSize) - gridSize;
                for (let x = startX; x < canvas.width; x += gridSize) {
                    ctx.beginPath();
                    ctx.moveTo(x, 0);
                    ctx.lineTo(x, canvas.height);
                    ctx.stroke();
                }
    
                // Горизонтальные линии
                const startY = (-panY % gridSize) - gridSize;
                for (let y = startY; y < canvas.height; y += gridSize) {
                    ctx.beginPath();
                    ctx.moveTo(0, y);
                    ctx.lineTo(canvas.width, y);
                    ctx.stroke();
                }
            }
    
    
            function gameLoop() {
                timeScale = parseFloat(timeSpeedSlider.value);
                maxTrailLength = parseInt(trailLengthSlider.value);
    
                // Для более плавной симуляции можно разбить шаг на подшаги
                const subSteps = 2; // Количество подшагов
                const dt = 1 / subSteps; 
                for (let i = 0; i < subSteps; i++) {
                    calculateForces();    // Расчет сил применяется сразу ко всем
                    updatePositions();    // Обновление позиций после всех расчетов сил
                }
                
                draw();
                requestAnimationFrame(gameLoop);
            }
    
            // --- Обработчики событий для управления видом ---
            canvas.addEventListener('wheel', (event) => {
                event.preventDefault();
                const zoomFactor = 1.1;
                const mouseX = event.offsetX;
                const mouseY = event.offsetY;
    
                // Координаты мыши в "мире" до зума
                const worldXBeforeZoom = (mouseX - panX) / zoom;
                const worldYBeforeZoom = (mouseY - panY) / zoom;
    
                if (event.deltaY < 0) { // Zoom in
                    zoom *= zoomFactor;
                } else { // Zoom out
                    zoom /= zoomFactor;
                }
                zoom = Math.max(0.01, Math.min(zoom, 10)); // Ограничение зума
    
                // Новые panX, panY, чтобы точка под мышью осталась на месте
                panX = mouseX - worldXBeforeZoom * zoom;
                panY = mouseY - worldYBeforeZoom * zoom;
            });
    
            canvas.addEventListener('mousedown', (event) => {
                if (event.button === 0) { // Левая кнопка мыши
                    isPanning = true;
                    lastPanX = event.offsetX;
                    lastPanY = event.offsetY;
                    canvas.style.cursor = 'grabbing';
                }
            });
    
            canvas.addEventListener('mousemove', (event) => {
                if (isPanning) {
                    const dx = event.offsetX - lastPanX;
                    const dy = event.offsetY - lastPanY;
                    panX += dx;
                    panY += dy;
                    lastPanX = event.offsetX;
                    lastPanY = event.offsetY;
                }
            });
    
            canvas.addEventListener('mouseup', () => {
                if (isPanning) {
                    isPanning = false;
                    canvas.style.cursor = 'grab';
                }
            });
            canvas.addEventListener('mouseleave', () => { // Если мышь ушла за пределы канваса
                if (isPanning) {
                    isPanning = false;
                    canvas.style.cursor = 'default';
                }
            });
            
            resetViewButton.addEventListener('click', () => {
                zoom = 0.5;
                panX = canvas.width / 2;
                panY = canvas.height / 2;
                initSolarSystem(); // Пересоздаем систему, чтобы сбросить следы и позиции
            });
    
            // Адаптация к размеру окна
            window.addEventListener('resize', () => {
                canvas.width = window.innerWidth * 0.95;
                canvas.height = window.innerHeight * 0.9;
                // При изменении размера окна, центр панорамирования может сместиться,
                // но для простоты оставим как есть или можно пересчитать panX, panY
                // чтобы центр оставался тем же в мировых координатах.
            });
    
            // Начальная инициализация и запуск
            canvas.style.cursor = 'grab';
            initSolarSystem();
            gameLoop();
    
        </script>
    </body>
    </html>
    

    Что делает этот код:

    1. HTML и CSS:

      • Создает <canvas> для рисования.
      • Добавляет панель управления (#controls) для скорости времени и длины следа, а также кнопку сброса.
      • Добавляет информационный блок (#info).
      • Базовые стили для темного фона и расположения элементов.
    2. JavaScript:

      • CelestialBody Класс:
        • Представляет каждое небесное тело (Солнце, планеты).
        • Хранит: имя, позицию (x, y), скорость (vx, vy), массу, визуальный радиус, цвет.
        • isStar: флаг, чтобы Солнце не двигалось (упрощение).
        • trail: массив для хранения точек траектории.
        • applyForce(fx, fy): Применяет силу к телу, изменяя его ускорение и затем скорость (пока без учета dt здесь, dt применяется в updatePosition).
        • updatePosition(): Обновляет позицию на основе скорости и timeScale. Добавляет точку в след.
        • draw(ctx): Рисует тело и его след на канвасе, преобразуя мировые координаты в экранные с учетом panX, panY и zoom. Также рисует имя, если тело достаточно крупное на экране.
        • У Сатурна добавлен метод drawRing для отрисовки колец.
      • Глобальные переменные:
        • G: Гравитационная постоянная. Ее значение подобрано для визуализации и стабильности при заданных массах и скоростях.
        • timeScale: Коэффициент скорости времени.
        • maxTrailLength: Максимальная длина следа.
        • zoom, panX, panY: Параметры камеры.
        • bodies: Массив всех небесных тел.
      • initSolarSystem():
        • Создает объекты CelestialBody для Солнца и нескольких планет.
        • Начальные позиции и скорости подобраны так, чтобы получить более-менее стабильные (хотя и не идеально реалистичные) орбиты.
      • calculateForces():
        • Итерирует по всем парам тел.
        • Рассчитывает силу гравитационного притяжения между ними по закону F = G * m1 * m2 / r^2.
        • Раскладывает силу на компоненты Fx и Fy.
        • Суммирует все силы, действующие на каждое тело.
        • Вызывает applyForce для каждого тела (кроме Солнца).
        • Включает простую обработку "столкновений" в виде силы отталкивания, если тела слишком близко.
      • updatePositions():
        • Вызывает updatePosition() для каждого тела.
      • draw():
        • Очищает канвас.
        • Рисует тусклую сетку для ориентации с помощью drawGrid().
        • Вызывает draw() для каждого небесного тела.
      • drawGrid(): Рисует адаптивную сетку, ячейки которой меняют размер в зависимости от зума.
      • gameLoop():
        • Основной цикл анимации.
        • Обновляет timeScale и maxTrailLength из слайдеров.
        • Выполняет несколько подшагов (subSteps) для расчета сил и обновления позиций для большей стабильности.
        • Перерисовывает сцену (draw()).
        • Использует requestAnimationFrame для плавной анимации.
      • Обработчики событий:
        • wheel: Масштабирование (зум) колесом мыши. Центр зума – текущее положение курсора.
        • mousedown, mousemove, mouseup, mouseleave: Панорамирование (перемещение вида) зажатой левой кнопкой мыши.
        • resetViewButton: Сбрасывает зум, панорамирование и пересоздает солнечную систему.
        • resize: Адаптирует размер канваса при изменении размера окна браузера.

    Как использовать:

    1. Сохраните код как HTML-файл (например, solar_system.html).
    2. Откройте этот файл в современном браузере.

    Вы увидите Солнце и планеты, начинающие свое движение. Вы можете:

    • Изменять скорость симуляции.
    • Изменять длину следов орбит.
    • Масштабировать вид колесом мыши.
    • Перемещать вид, зажав левую кнопку мыши.
    • Нажать "Сброс вида" для возврата к начальным настройкам и позициям.

    Улучшения и возможные доработки:

    • Более реалистичная физика: Использовать более точные начальные данные (массы, расстояния, скорости), более точный интегратор (например, Верле или Рунге-Кутты) вместо простого Эйлера, который используется неявно.
    • Энергия системы: Рассчитывать и отображать полную энергию системы (кинетическую + потенциальную) для проверки стабильности.
    • Столкновения: Более сложная обработка столкновений (слияние, упругий/неупругий удар).
    • Луны: Добавить спутники для планет.
    • Информация о телах: Отображать информацию (масса, скорость, расстояние до Солнца) при наведении или клике на тело.
    • Эллиптические орбиты: С текущими параметрами орбиты будут близки к эллиптическим, но можно точнее задавать параметры для получения конкретных эксцентриситетов.
    • 3D: Это значительно усложнит задачу, но возможно с использованием WebGL (например, через Three.js).
    • Оптимизация: Для большого количества тел могут потребоваться оптимизации (например, дерево Барнса-Хата для расчета гравитации).

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