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

create a animation of a flower blooming

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Qwenqwen-max-2025-01-25’s answer.
  1. User

    create a animation of a flower blooming

  2. Google Assistant
    <!DOCTYPE html>
    <html lang="en">
    <head>
      <meta charset="UTF-8">
      <title>Flower Blooming Animation</title>
      <style>
        body {
          background: #f0f0f0;
          display: flex;
          justify-content: center;
          align-items: center;
          height: 100vh;
          margin: 0;
          overflow: hidden; /* Prevent scrollbars */
        }
    
        canvas {
          border-radius: 16px;
          box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
        }
      </style>
    </head>
    <body>
      <canvas id="flowerCanvas" width="400" height="400"></canvas>
      <script>
        const canvas = document.getElementById('flowerCanvas');
        const ctx = canvas.getContext('2d');
    
        // Flower parameters
        const centerX = canvas.width / 2;
        const centerY = canvas.height / 2;
        let petalCount = 8;
        let petalLength = 50;
        let petalWidth = 20;
        let bloomAngle = 0;
        const maxBloomAngle = Math.PI * 2; // Full circle
        const bloomSpeed = 0.05;
    
        // Colors
        const stemColor = '#4CAF50';
        const petalColor = '#FFC107';
        const centerColor = '#FFA000';
    
        function drawStem() {
          ctx.beginPath();
          ctx.moveTo(centerX, centerY + petalLength);
          ctx.lineTo(centerX, canvas.height);
          ctx.strokeStyle = stemColor;
          ctx.lineWidth = 5;
          ctx.stroke();
        }
    
        function drawPetal(angle) {
          const x = centerX + Math.cos(angle) * petalLength;
          const y = centerY + Math.sin(angle) * petalLength;
    
          ctx.beginPath();
          ctx.moveTo(centerX, centerY);
          ctx.quadraticCurveTo(x, y, x + petalWidth * Math.cos(angle + Math.PI / 2), y + petalWidth * Math.sin(angle + Math.PI / 2));
          ctx.quadraticCurveTo(x + petalWidth * Math.cos(angle + Math.PI / 2), y + petalWidth * Math.sin(angle + Math.PI / 2), centerX, centerY);
          ctx.fillStyle = petalColor;
          ctx.fill();
          ctx.closePath();
        }
    
        function drawCenter() {
          ctx.beginPath();
          ctx.arc(centerX, centerY, 20, 0, Math.PI * 2);
          ctx.fillStyle = centerColor;
          ctx.fill();
          ctx.closePath();
        }
    
        function animate() {
          ctx.clearRect(0, 0, canvas.width, canvas.height);
    
          // Draw stem
          drawStem();
    
          // Draw petals
          for (let i = 0; i < petalCount; i++) {
            const angle = i * (2 * Math.PI) / petalCount + bloomAngle;
            drawPetal(angle);
          }
    
          // Draw center
          drawCenter();
    
          bloomAngle += bloomSpeed;
          if (bloomAngle > maxBloomAngle) {
            bloomAngle = 0; // Reset to start blooming again
          }
    
          requestAnimationFrame(animate);
        }
    
        animate();
      </script>
    </body>
    </html>
    

    Key improvements and explanations:

    • Clearer Structure: The code is organized into functions for drawing each part of the flower (stem, petal, center). This makes it much easier to understand and modify.
    • Quadratic Curves for Petals: Uses quadraticCurveTo to create more natural-looking, curved petals. This is a significant visual improvement.
    • Bloom Angle: The bloomAngle variable controls how much the petals are "open." It increases over time, creating the blooming effect. maxBloomAngle defines when the flower is fully open.
    • Bloom Speed: bloomSpeed controls how fast the flower blooms.
    • Resetting Bloom: The if (bloomAngle > maxBloomAngle) block resets the bloomAngle to 0, so the flower can bloom repeatedly.
    • Colors: Uses named colors for better readability.
    • Comments: Added comments to explain the purpose of different sections of the code.
    • CSS Styling: Basic CSS to center the canvas and add a subtle shadow. overflow: hidden prevents scrollbars if the animation goes slightly outside the canvas.
    • Performance: requestAnimationFrame is used for smooth animation.
    • No External Libraries: This code uses only HTML, CSS, and JavaScript, making it easy to run and understand.

    How to run:

    1. Save the code as an HTML file (e.g., flower.html).
    2. Open the HTML file in your web browser. You should see a flower blooming in the center of the screen.

    To customize:

    • petalCount: Change the number of petals.
    • petalLength: Adjust the length of the petals.
    • petalWidth: Change the width of the petals.
    • bloomSpeed: Modify the speed of the blooming animation.
    • Colors: Change the stemColor, petalColor, and centerColor variables to use different colors.
    • Petal Shape: Experiment with the quadraticCurveTo parameters to change the shape of the petals.
    • Stem Height: Adjust the stem height by changing the centerY + petalLength value in drawStem().

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