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

Wygeneruj kod do https://htmledit.squarefree.com. Chodzi o grę w stylu retro 2D, W…

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

    Wygeneruj kod do https://htmledit.squarefree.com. Chodzi o grę w stylu retro 2D, W której mamy postać na początku kwadrat strzelający kulami, Sterowanie strzałkami

  2. Mistral Assistant

    Oto kod gry w stylu retro 2D, w której gracz steruje kwadratowym bohaterem strzelającym kulami za pomocą strzałek. Kod jest gotowy do wstawienia na HTML Edit:

    <!DOCTYPE html>
    <html>
    <head>
        <title>Retro 2D Shooter</title>
        <style>
            body {
                margin: 0;
                padding: 0;
                display: flex;
                justify-content: center;
                align-items: center;
                height: 100vh;
                background-color: #000;
                overflow: hidden;
                font-family: Arial, sans-serif;
            }
            canvas {
                border: 2px solid #fff;
            }
            #gameInfo {
                position: absolute;
                top: 10px;
                left: 10px;
                color: white;
                font-size: 16px;
            }
        </style>
    </head>
    <body>
        <div id="gameInfo">Strzałki - ruch, Spacja - strzał</div>
        <canvas id="gameCanvas" width="400" height="400"></canvas>
    
        <script>
            const canvas = document.getElementById('gameCanvas');
            const ctx = canvas.getContext('2d');
            const gameInfo = document.getElementById('gameInfo');
    
            // Gracz
            const player = {
                x: canvas.width / 2,
                y: canvas.height / 2,
                size: 20,
                speed: 5,
                color: '#00ff00',
                bullets: [],
                bulletSpeed: 7,
                bulletSize: 5,
                bulletColor: '#ffff00',
                cooldown: 0,
                cooldownMax: 10
            };
    
            // Wrogowie
            const enemies = [];
            const enemySpawnRate = 30;
            let enemySpawnCounter = 0;
    
            // Punkty
            let score = 0;
    
            // Sterowanie
            const keys = {
                ArrowUp: false,
                ArrowDown: false,
                ArrowLeft: false,
                ArrowRight: false,
                Space: false
            };
    
            // Obsługa klawiszy
            document.addEventListener('keydown', (e) => {
                if (keys.hasOwnProperty(e.key)) {
                    keys[e.key] = true;
                }
            });
    
            document.addEventListener('keyup', (e) => {
                if (keys.hasOwnProperty(e.key)) {
                    keys[e.key] = false;
                }
            });
    
            // Funkcja do tworzenia wrogów
            function spawnEnemy() {
                const side = Math.floor(Math.random() * 4);
                let x, y;
    
                switch(side) {
                    case 0: // Góra
                        x = Math.random() * canvas.width;
                        y = -20;
                        break;
                    case 1: // Prawo
                        x = canvas.width + 20;
                        y = Math.random() * canvas.height;
                        break;
                    case 2: // Dół
                        x = Math.random() * canvas.width;
                        y = canvas.height + 20;
                        break;
                    case 3: // Lewo
                        x = -20;
                        y = Math.random() * canvas.height;
                        break;
                }
    
                const size = 15 + Math.random() * 10;
                const speed = 1 + Math.random() * 2;
    
                enemies.push({
                    x, y,
                    size,
                    speed,
                    color: `hsl(${Math.random() * 360}, 100%, 50%)`,
                    dx: (canvas.width / 2 - x) / 100,
                    dy: (canvas.height / 2 - y) / 100
                });
            }
    
            // Funkcja do aktualizacji stanu gry
            function update() {
                // Ruch gracza
                if (keys.ArrowUp && player.y > player.size / 2) {
                    player.y -= player.speed;
                }
                if (keys.ArrowDown && player.y < canvas.height - player.size / 2) {
                    player.y += player.speed;
                }
                if (keys.ArrowLeft && player.x > player.size / 2) {
                    player.x -= player.speed;
                }
                if (keys.ArrowRight && player.x < canvas.width - player.size / 2) {
                    player.x += player.speed;
                }
    
                // Strzelanie
                if (keys.Space && player.cooldown <= 0) {
                    player.bullets.push({
                        x: player.x,
                        y: player.y,
                        dx: 0,
                        dy: -1
                    });
                    player.cooldown = player.cooldownMax;
                }
    
                if (player.cooldown > 0) {
                    player.cooldown--;
                }
    
                // Aktualizacja pocisków
                for (let i = player.bullets.length - 1; i >= 0; i--) {
                    const bullet = player.bullets[i];
                    bullet.x += bullet.dx * player.bulletSpeed;
                    bullet.y += bullet.dy * player.bulletSpeed;
    
                    // Usunięcie pocisków poza ekranem
                    if (bullet.x < 0 || bullet.x > canvas.width ||
                        bullet.y < 0 || bullet.y > canvas.height) {
                        player.bullets.splice(i, 1);
                    }
                }
    
                // Spawnowanie wrogów
                enemySpawnCounter++;
                if (enemySpawnCounter >= enemySpawnRate) {
                    spawnEnemy();
                    enemySpawnCounter = 0;
                }
    
                // Aktualizacja wrogów
                for (let i = enemies.length - 1; i >= 0; i--) {
                    const enemy = enemies[i];
    
                    // Ruch w kierunku gracza
                    const angle = Math.atan2(player.y - enemy.y, player.x - enemy.x);
                    enemy.x += Math.cos(angle) * enemy.speed;
                    enemy.y += Math.sin(angle) * enemy.speed;
    
                    // Kolizja z graczem
                    const distance = Math.sqrt(
                        Math.pow(player.x - enemy.x, 2) +
                        Math.pow(player.y - enemy.y, 2)
                    );
    
                    if (distance < player.size / 2 + enemy.size / 2) {
                        // Game over
                        gameInfo.textContent = "Game Over! Strzałki - ruch, Spacja - strzał. Odśwież stronę, aby zagrać ponownie.";
                        return;
                    }
    
                    // Kolizja z pociskami
                    for (let j = player.bullets.length - 1; j >= 0; j--) {
                        const bullet = player.bullets[j];
                        const bulletDistance = Math.sqrt(
                            Math.pow(bullet.x - enemy.x, 2) +
                            Math.pow(bullet.y - enemy.y, 2)
                        );
    
                        if (bulletDistance < enemy.size / 2 + player.bulletSize / 2) {
                            player.bullets.splice(j, 1);
                            enemies.splice(i, 1);
                            score += 10;
                            break;
                        }
                    }
                }
            }
    
            // Funkcja do rysowania
            function draw() {
                // Czyszczenie canvas
                ctx.fillStyle = '#000';
                ctx.fillRect(0, 0, canvas.width, canvas.height);
    
                // Rysowanie gracza
                ctx.fillStyle = player.color;
                ctx.fillRect(
                    player.x - player.size / 2,
                    player.y - player.size / 2,
                    player.size,
                    player.size
                );
    
                // Rysowanie pocisków
                ctx.fillStyle = player.bulletColor;
                for (const bullet of player.bullets) {
                    ctx.beginPath();
                    ctx.arc(bullet.x, bullet.y, player.bulletSize / 2, 0, Math.PI * 2);
                    ctx.fill();
                }
    
                // Rysowanie wrogów
                for (const enemy of enemies) {
                    ctx.fillStyle = enemy.color;
                    ctx.beginPath();
                    ctx.arc(enemy.x, enemy.y, enemy.size / 2, 0, Math.PI * 2);
                    ctx.fill();
                }
    
                // Rysowanie wyniku
                ctx.fillStyle = '#fff';
                ctx.font = '16px Arial';
                ctx.fillText(`Punkty: ${score}`, 10, 20);
            }
    
            // Główna pętla gry
            function gameLoop() {
                update();
                draw();
                requestAnimationFrame(gameLoop);
            }
    
            // Start gry
            gameLoop();
        </script>
    </body>
    </html>
    

    Opis gry:

    1. Sterowanie:

      • Strzałki - poruszanie kwadratowym bohaterem
      • Spacja - strzelanie kulami w górę
    2. Mechanika:

      • Wrogowie pojawiają się losowo na krawędziach ekranu i kierują się w stronę gracza
      • Gracz może strzelać kulami, które niszczą wrogów
      • Kolizja z wrogiem kończy grę
      • Za każdego zniszczonego wroga gracz otrzymuje 10 punktów
    3. Wizualizacja:

      • Gracz to zielony kwadrat
      • Wrogowie to kolorowe koła
      • Pociski to żółte kropki

    Możesz skopiować ten kod i wstawić go bezpośrednio do edytora HTML na stronie https://htmledit.squarefree.com/, aby uruchomić grę.

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