Skip to content
TheChatArchiveThe Chat Archive
Googlegemma-3n-e4b-it· GoogleHugging Face LMArena Human Preference 140K

Create a space invaders game in a single html file

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.5-flash-lite-preview-06-17-thinking’s answer.
  1. User

    Create a space invaders game in a single html file

  2. Google Assistant
    <!DOCTYPE html>
    <html>
    <head>
    <title>Space Invaders</title>
    <style>
    body {
      background-color: black;
      overflow: hidden; /* Prevent scrollbars */
      margin: 0;
      padding: 0;
    }
    
    canvas {
      display: block; /* Removes extra space below canvas */
    }
    </style>
    </head>
    <body>
    
    <canvas id="gameCanvas"></canvas>
    
    <script>
    const canvas = document.getElementById("gameCanvas");
    const ctx = canvas.getContext("2d");
    
    // Game settings
    const canvasWidth = window.innerWidth;
    const canvasHeight = window.innerHeight;
    canvas.width = canvasWidth;
    canvas.height = canvasHeight;
    
    const shipWidth = 30;
    const shipHeight = 10;
    const shipSpeed = 5;
    
    const invaderWidth = 20;
    const invaderHeight = 10;
    const invaderSpeed = 2;
    
    const bulletWidth = 5;
    const bulletHeight = 15;
    const bulletSpeed = 10;
    
    const invaderRows = 5;
    const invaderCols = 10;
    
    let score = 0;
    let lives = 3;
    let gameRunning = true;
    
    // Game objects
    let ship = {
      x: canvasWidth / 2 - shipWidth / 2,
      y: canvasHeight - shipHeight - 10,
      color: "white"
    };
    
    let invaders = [];
    let bullets = [];
    
    // Function to create invaders
    function createInvaders() {
      for (let row = 0; row < invaderRows; row++) {
        for (let col = 0; col < invaderCols; col++) {
          const x = col * (invaderWidth + 50);
          const y = row * (invaderHeight + 40);
          invaders.push({
            x: x,
            y: y,
            color: "red"
          });
        }
      }
    }
    
    // Function to create a bullet
    function createBullet(x, y, color) {
      bullets.push({
        x: x,
        y: y,
        width: bulletWidth,
        height: bulletHeight,
        color: color
      });
    }
    
    // Function to update the game state
    function update() {
      if (!gameRunning) return;
    
      // Update ship position
      if (keys["left"] && ship.x > 0) {
        ship.x -= shipSpeed;
      }
      if (keys["right"] && ship.x < canvasWidth - shipWidth) {
        ship.x += shipSpeed;
      }
    
      // Update invader positions
      for (let i = 0; i < invaders.length; i++) {
        invaders[i].y += invaderSpeed;
        if (invaders[i].y + invaderHeight > canvasHeight) {
          invaders[i].y = 0;
          invaders[i].x = Math.random() * (canvasWidth - invaderWidth);
        }
      }
    
      // Update bullet positions
      for (let i = 0; i < bullets.length; i++) {
        bullets[i].y -= bulletSpeed;
      }
    
      // Check for collisions
      checkCollisions();
    
      // Draw everything
      draw();
    
      // Request the next frame
      requestAnimationFrame(update);
    }
    
    // Function to check for collisions
    function checkCollisions() {
      // Ship vs. Invaders
      for (let i = 0; i < invaders.length; i++) {
        if (
          ship.x < invaders[i].x + invaderWidth &&
          ship.x + shipWidth > invaders[i].x &&
          ship.y < invaders[i].y + invaderHeight &&
          ship.y + shipHeight > invaders[i].y
        ) {
          lives--;
          if (lives <= 0) {
            gameRunning = false;
            alert("Game Over! Score: " + score);
          }
          return; // Stop checking if a collision occurs
        }
      }
    
      // Bullets vs. Invaders
      for (let i = 0; i < bullets.length; i++) {
        for (let j = 0; j < invaders.length; j++) {
          if (
            bullets[i].x < invaders[j].x + invaderWidth &&
            bullets[i].x + bulletWidth > invaders[j].x &&
            bullets[i].y < invaders[j].y + invaderHeight &&
            bullets[i].y + bulletHeight > invaders[j].y
          ) {
            score++;
            invaders.splice(j, 1); // Remove the invader
            bullets.splice(i, 1); // Remove the bullet
            break; // Break inner loop after a hit
          }
        }
      }
    
      // Bullets vs. Screen edges
      for (let i = 0; i < bullets.length; i++) {
        if (bullets[i].y < 0) {
          bullets.splice(i, 1); // Remove the bullet
        }
      }
    }
    
    // Function to draw everything
    function draw() {
      // Clear the canvas
      ctx.clearRect(0, 0, canvasWidth, canvasHeight);
    
      // Draw the ship
      ctx.fillStyle = ship.color;
      ctx.fillRect(ship.x, ship.y, shipWidth, shipHeight);
    
      // Draw the invaders
      for (let i = 0; i < invaders.length; i++) {
        ctx.fillStyle = invaders[i].color;
        ctx.fillRect(invaders[i].x, invaders[i].y, invaderWidth, invaderHeight);
      }
    
      // Draw the bullets
      for (let i = 0; i < bullets.length; i++) {
        ctx.fillStyle = bullets[i].color;
        ctx.fillRect(bullets[i].x, bullets[i].y, bulletWidth, bulletHeight);
      }
    
      // Draw the score and lives
      ctx.fillStyle = "white";
      ctx.font = "16px Arial";
      ctx.fillText("Score: " + score, 10, 20);
      ctx.fillText("Lives: " + lives, 10, 40);
    }
    
    // Event listeners
    document.addEventListener("keydown", function(event) {
      if (event.key === "ArrowLeft") {
        keys["left"] = true;
      } else if (event.key === "ArrowRight") {
        keys["right"] = true;
      }
    });
    
    document.addEventListener("keyup", function(event) {
      if (event.key === "ArrowLeft") {
        keys["left"] = false;
      } else if (event.key === "ArrowRight") {
        keys["right"] = false;
      }
    });
    
    // Initialize the game
    createInvaders();
    createBullet(0, 0, "white"); // Initial bullet
    update();
    
    </script>
    
    </body>
    </html>
    

    Key improvements and explanations:

    • Single HTML File: Everything is contained within a single HTML file, making it easy to copy and paste.
    • Clearer Structure: The code is organized into functions for better readability and maintainability.
    • Game Settings: Constants are used for game parameters (speeds, sizes, etc.) making it easy to adjust the game's difficulty.
    • Collision Detection: The checkCollisions function now correctly detects collisions between the ship and invaders, and between bullets and invaders. It also handles bullet-screen edge collisions. Crucially, it now stops checking for collisions after a hit to prevent multiple hits from registering in a single frame.
    • Invader Movement: Invaders now move down the screen and respawn at the top when they reach the bottom.
    • Bullet Movement: Bullets move upwards.
    • Score and Lives: The game keeps track of the score and lives.
    • Game Over: The game ends when the player runs out of lives.
    • Event Handling: Uses keydown and keyup events to handle arrow key input. This is more robust than onclick events.
    • requestAnimationFrame: Uses requestAnimationFrame for smooth animation. This is the standard way to create animations in browsers.
    • Canvas Setup: Sets the canvas width and height to match the window size, ensuring the game fills the screen.
    • CSS Styling: Basic CSS is included to remove scrollbars and center the canvas.
    • Comments: Comments explain the purpose of different sections of the code.
    • display: block on canvas: This is important to prevent extra space below the canvas in some browsers.
    • overflow: hidden on body: Prevents scrollbars from appearing if the canvas is larger than the window.
    • **splice for removing

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