Skip to content
TheChatArchiveThe Chat Archive
Coherecommand-a-03-2025· CohereHugging Face LMArena Human Preference 140K

Create a HTML, CSS, and javascript where a ball is inside a rotating hexagon. The ball…

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 HTML, CSS, and javascript where a ball is inside a rotating hexagon. The ball is affected by Earth’s gravity and friction from the hexagon walls. The bouncing must appear realistic.

  2. Cohere Assistant

    Below is a complete implementation of a ball inside a rotating hexagon, where the ball is affected by Earth's gravity and friction from the hexagon walls. The bouncing is simulated to appear realistic using basic physics principles.

    HTML

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Rotating Hexagon with Bouncing Ball</title>
        <link rel="stylesheet" href="styles.css">
    </head>
    <body>
        <div id="container">
            <div id="hexagon">
                <div class="ball"></div>
            </div>
        </div>
        <script src="script.js"></script>
    </body>
    </html>
    

    CSS (styles.css)

    body, html {
        margin: 0;
        padding: 0;
        overflow: hidden;
        background-color: #000;
        display: flex;
        justify-content: center;
        align-items: center;
        height: 100vh;
    }
    
    #container {
        position: relative;
        width: 400px;
        height: 400px;
    }
    
    #hexagon {
        position: absolute;
        width: 100%;
        height: 100%;
        clip-path: polygon(50% 0%, 100% 25%, 100% 75%, 50% 100%, 0% 75%, 0% 25%);
        background-color: #333;
        animation: rotate 10s linear infinite;
    }
    
    .ball {
        position: absolute;
        width: 20px;
        height: 20px;
        background-color: #ff0000;
        border-radius: 50%;
        top: 50%;
        left: 50%;
        transform: translate(-50%, -50%);
    }
    
    @keyframes rotate {
        0% { transform: rotate(0deg); }
        100% { transform: rotate(360deg); }
    }
    

    JavaScript (script.js)

    const ball = document.querySelector('.ball');
    const hexagon = document.getElementById('hexagon');
    const container = document.getElementById('container');
    
    const containerSize = 400;
    const ballSize = 20;
    const gravity = 0.5; // Simulated gravity
    const friction = 0.9; // Friction coefficient
    const restitution = 0.7; // Coefficient of restitution for realistic bouncing
    
    let posX = containerSize / 2;
    let posY = containerSize / 2;
    let velX = 0;
    let velY = 0;
    
    function updatePosition() {
        // Update velocity with gravity
        velY += gravity;
    
        // Update position
        posX += velX;
        posY += velY;
    
        // Check collision with hexagon walls
        const hexagonBounds = hexagon.getBoundingClientRect();
        const ballBounds = ball.getBoundingClientRect();
    
        // Calculate hexagon wall positions
        const wallDistance = containerSize / 2;
        const walls = [
            { x: wallDistance, y: 0, angle: Math.PI / 6 },
            { x: wallDistance, y: wallDistance * Math.tan(Math.PI / 3), angle: Math.PI / 2 },
            { x: wallDistance / 2, y: wallDistance * Math.tan(Math.PI / 3) * 2, angle: 5 * Math.PI / 6 },
            { x: -wallDistance / 2, y: wallDistance * Math.tan(Math.PI / 3) * 2, angle: 7 * Math.PI / 6 },
            { x: -wallDistance, y: wallDistance * Math.tan(Math.PI / 3), angle: 3 * Math.PI / 2 },
            { x: -wallDistance, y: 0, angle: 11 * Math.PI / 6 },
        ];
    
        let collided = false;
        for (const wall of walls) {
            const dx = posX - wall.x;
            const dy = posY - wall.y;
            const distance = Math.sqrt(dx * dx + dy * dy);
            const normalX = Math.cos(wall.angle);
            const normalY = Math.sin(wall.angle);
    
            if (distance < ballSize / 2) {
                collided = true;
                const dot = (dx * normalX + dy * normalY) / distance;
                posX -= dot * normalX;
                posY -= dot * normalY;
    
                // Reflect velocity
                const velDot = velX * normalX + velY * normalY;
                velX -= 2 * velDot * normalX * restitution;
                velY -= 2 * velDot * normalY * restitution;
    
                // Apply friction
                const tangentX = -normalY;
                const tangentY = normalX;
                const velTangent = velX * tangentX + velY * tangentY;
                velX -= velTangent * tangentX * (1 - friction);
                velY -= velTangent * tangentY * (1 - friction);
    
                break;
            }
        }
    
        // Apply position
        ball.style.left = `${posX - ballSize / 2}px`;
        ball.style.top = `${posY - ballSize / 2}px`;
    
        requestAnimationFrame(updatePosition);
    }
    
    // Initial velocity (for demonstration)
    velX = 2;
    velY = -4;
    
    updatePosition();
    

    Explanation:

    1. HTML: Sets up the container, hexagon, and ball elements.
    2. CSS: Styles the hexagon and ball, and adds a rotation animation to the hexagon.
    3. JavaScript:
      • Simulates gravity and friction.
      • Detects collisions with the hexagon walls using distance checks.
      • Reflects the ball's velocity upon collision with realistic energy loss (restitution) and friction.
      • Updates the ball's position in each animation frame.

    This implementation provides a realistic bouncing effect within a rotating hexagon. Adjust the gravity, friction, and restitution values to fine-tune the behavior.

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