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

Objective: Create a Python animation that simulates multiple "balls" bouncing within a…

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

    Objective: Create a Python animation that simulates multiple "balls" bouncing within a continuously spinning regular hexagon.

    Requirements:

    The Hexagon:

    A regular hexagon should be drawn in the center of the animation window.

    It must slowly and continuously rotate around its own geometric center.

    The hexagon should have a clear outline (e.g., colored border, no fill).

    The Balls:

    Generate at least 5-10 small circular "balls" (particles).

    Each ball should start at a random position inside the initial (unrotated) hexagon.

    Each ball should have a random initial velocity (direction and speed).

    Each ball should have a random color.

    Balls should move continuously.

    Collision Physics:

    When a ball collides with any of the internal edges of the spinning hexagon, it should bounce off that edge.

    The collision should be elastic (meaning the ball's speed magnitude remains roughly constant, only its direction changes upon reflection).

    The reflection logic should account for the hexagon's current rotation; the ball should reflect off the current orientation of the edge.

    Animation:

    The animation should run continuously.

    Choose a suitable Python library for 2D animation (e.g., matplotlib.animation, pygame, turtle). matplotlib.animation is preferred for simplicity if possible.

    The animation window should have fixed dimensions.

    Your response should include:

    The complete, runnable Python code for the animation.

    A clear explanation of the mathematical and physics principles used (e.g., how hexagon vertices are calculated, how rotation is applied, how collision detection and reflection work).

    Instructions on how to run the code.

    Any considerations for performance or potential improvements.

  2. Cohere Assistant

    Below is a complete Python implementation using matplotlib.animation to create the described animation. The code includes a spinning hexagon, multiple balls bouncing inside it, and elastic collisions with the hexagon's edges.


    Python Code

    import numpy as np
    import matplotlib.pyplot as plt
    import matplotlib.animation as animation
    from matplotlib.patches import Polygon, Circle
    
    # Constants
    HEXAGON_RADIUS = 1.0
    BALL_RADIUS = 0.05
    NUM_BALLS = 8
    WINDOW_SIZE = 8
    ROTATION_SPEED = 0.01  # Radians per frame
    BALL_SPEED = 0.05
    
    # Initialize the hexagon
    def create_hexagon(center, radius, angle=0):
        n = 6
        theta = np.linspace(0, 2 * np.pi, n, endpoint=False) + angle
        vertices = np.column_stack([
            center[0] + radius * np.cos(theta),
            center[1] + radius * np.sin(theta)
        ])
        return vertices
    
    # Initialize balls
    class Ball:
        def __init__(self, x, y, vx, vy, color):
            self.x = x
            self.y = y
            self.vx = vx
            self.vy = vy
            self.color = color
    
    # Collision detection and reflection
    def reflect_ball(ball, hexagon_vertices):
        ball_center = np.array([ball.x, ball.y])
        for i in range(len(hexagon_vertices)):
            edge_start = hexagon_vertices[i]
            edge_end = hexagon_vertices[(i + 1) % len(hexagon_vertices)]
            edge_vector = edge_end - edge_start
            edge_normal = np.array([-edge_vector[1], edge_vector[0]])  # Perpendicular to edge
            edge_normal /= np.linalg.norm(edge_normal)  # Normalize
    
            # Project ball position onto edge
            relative_pos = ball_center - edge_start
            projection = np.dot(relative_pos, edge_vector) / np.dot(edge_vector, edge_vector)
            projection = np.clip(projection, 0, 1)  # Clamp to edge bounds
            closest_point = edge_start + projection * edge_vector
    
            # Check if ball is close to edge and within edge bounds
            if np.linalg.norm(ball_center - closest_point) < BALL_RADIUS:
                distance_to_edge = np.dot(relative_pos, edge_normal)
                if distance_to_edge < BALL_RADIUS:
                    # Reflect velocity across edge normal
                    velocity = np.array([ball.vx, ball.vy])
                    reflection = velocity - 2 * np.dot(velocity, edge_normal) * edge_normal
                    ball.vx, ball.vy = reflection
                    return True
        return False
    
    # Animation setup
    fig, ax = plt.subplots()
    ax.set_xlim(-WINDOW_SIZE / 2, WINDOW_SIZE / 2)
    ax.set_ylim(-WINDOW_SIZE / 2, WINDOW_SIZE / 2)
    ax.set_aspect('equal')
    ax.axis('off')
    
    # Create hexagon patch
    hexagon_center = (0, 0)
    hexagon_patch = Polygon(create_hexagon(hexagon_center, HEXAGON_RADIUS), edgecolor='black', facecolor='none', linewidth=2)
    ax.add_patch(hexagon_patch)
    
    # Create balls
    balls = []
    for _ in range(NUM_BALLS):
        angle = 2 * np.pi * np.random.rand()
        radius = HEXAGON_RADIUS * 0.8 * np.sqrt(np.random.rand())  # Random radius within hexagon
        x = hexagon_center[0] + radius * np.cos(angle)
        y = hexagon_center[1] + radius * np.sin(angle)
        vx, vy = BALL_SPEED * np.random.randn(2)  # Random velocity
        color = np.random.choice(['red', 'blue', 'green', 'orange', 'purple', 'cyan', 'magenta'])
        ball = Ball(x, y, vx, vy, color)
        balls.append(ball)
    
    # Ball patches
    ball_patches = [Circle((ball.x, ball.y), BALL_RADIUS, color=ball.color) for ball in balls]
    for patch in ball_patches:
        ax.add_patch(patch)
    
    # Animation update function
    def update(frame):
        global hexagon_patch, ball_patches, balls
    
        # Rotate hexagon
        rotation_angle = ROTATION_SPEED * frame
        hexagon_vertices = create_hexagon(hexagon_center, HEXAGON_RADIUS, rotation_angle)
        hexagon_patch.set_xy(hexagon_vertices)
    
        # Update balls
        for ball, patch in zip(balls, ball_patches):
            # Move ball
            ball.x += ball.vx
            ball.y += ball.vy
    
            # Check collision and reflect
            if reflect_ball(ball, hexagon_vertices):
                pass  # Reflection handled in reflect_ball
    
            # Update patch position
            patch.center = (ball.x, ball.y)
    
        return [hexagon_patch] + ball_patches
    
    # Create animation
    ani = animation.FuncAnimation(fig, update, frames=1000, interval=20, blit=True)
    plt.show()
    

    Explanation

    1. Hexagon Calculation:

      • The hexagon vertices are calculated using polar coordinates, with rotation applied by adding an angle to the base angles.
      • The create_hexagon function generates the vertices based on the center, radius, and rotation angle.
    2. Ball Initialization:

      • Balls are initialized with random positions inside the hexagon and random velocities.
      • Each ball is represented as a Ball object with attributes for position, velocity, and color.
    3. Collision Detection and Reflection:

      • For each ball, the code checks if it intersects with any edge of the hexagon.
      • The closest point on the edge to the ball is calculated, and if the ball is within its radius of this point, a collision is detected.
      • The ball's velocity is reflected across the edge normal to simulate an elastic collision.
    4. Animation:

      • The hexagon rotates continuously by updating its vertices in each frame.
      • Balls move according to their velocities and bounce off the hexagon edges.
      • matplotlib.animation.FuncAnimation handles the animation loop.

    Running the Code

    1. Install the required library:
      pip install matplotlib numpy
      
    2. Save the code to a .py file and run it:
      python animation.py
      
    3. A window will open displaying the spinning hexagon with balls bouncing inside it.

    Considerations and Improvements

    1. Performance:

      • The collision detection could be optimized by using spatial partitioning (e.g., bounding boxes) to reduce the number of edge checks.
      • For larger numbers of balls, consider using a more efficient animation library like pygame.
    2. Accuracy:

      • The reflection logic assumes the ball's center is on the edge, which may not be precise for fast-moving balls. A more accurate method would account for the ball's radius in collision detection.
    3. Features:

      • Add gravity or friction for more realistic physics.
      • Allow user interaction (e.g., pausing or resetting the animation).

    This implementation provides a clean and educational example of 2D animation with physics simulation in Python.

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