Skip to content
TheChatArchiveThe Chat Archive
Metallama-4-maverick-03-26-experimental· MetaHugging Face LMArena Human Preference 140K

Generate a live turning hexagon where a ball is placed inside as the hexagon rotates…

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

    Generate a live turning hexagon where a ball is placed inside as the hexagon rotates clockwise the ball inside it should be affected by gravity

  2. Meta Assistant

    A delightful physics-based animation! Here's a solution using Python with the Pygame library. We'll create a rotating hexagon with a ball inside, affected by gravity. Buckle up!

    Code:

    import pygame
    import math
    
    # Window dimensions
    WIDTH, HEIGHT = 640, 480
    
    # Colors
    WHITE = (255, 255, 255)
    RED = (255, 0, 0)
    BLUE = (0, 0, 255)
    
    # Hexagon properties
    HEX_SIZE = 200
    HEX_CENTER = (WIDTH // 2, HEIGHT // 2)
    HEX_COLOR = BLUE
    
    # Ball properties
    BALL_RADIUS = 10
    BALL_COLOR = RED
    GRAVITY = 0.1  # pixels per frame squared
    
    class Ball:
        def __init__(self):
            self.x = HEX_CENTER[0]
            self.y = HEX_CENTER[1]
            self.vx = 0
            self.vy = 0
    
        def update(self):
            self.vy += GRAVITY
            self.y += self.vy
            self.x += self.vx
    
            # Boundary check: keep the ball inside the hexagon
            dx = self.x - HEX_CENTER[0]
            dy = self.y - HEX_CENTER[1]
            dist = math.hypot(dx, dy)
            if dist > HEX_SIZE - BALL_RADIUS:
                # Reflect the ball off the hexagon edge
                normal_x = dx / dist
                normal_y = dy / dist
                tangent_x = -normal_y
                tangent_y = normal_x
                v_normal = self.vx * normal_x + self.vy * normal_y
                v_tangent = self.vx * tangent_x + self.vy * tangent_y
                v_normal = -v_normal * 0.9  # dampen the reflection
                self.vx = v_normal * normal_x + v_tangent * tangent_x
                self.vy = v_normal * normal_y + v_tangent * tangent_y
                # Move the ball back to the edge
                self.x = HEX_CENTER[0] + (HEX_SIZE - BALL_RADIUS) * dx / dist
                self.y = HEX_CENTER[1] + (HEX_SIZE - BALL_RADIUS) * dy / dist
    
    def draw_hexagon(surface, color, center, size, angle):
        points = []
        for i in range(6):
            a = angle + i * math.pi / 3
            px = center[0] + size * math.cos(a)
            py = center[1] + size * math.sin(a)
            points.append((px, py))
        pygame.draw.polygon(surface, color, points)
    
    def main():
        pygame.init()
        screen = pygame.display.set_mode((WIDTH, HEIGHT))
        clock = pygame.time.Clock()
        running = True
    
        angle = 0
        ball = Ball()
    
        while running:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False
    
            screen.fill(WHITE)
    
            # Draw the rotating hexagon
            draw_hexagon(screen, HEX_COLOR, HEX_CENTER, HEX_SIZE, angle)
            angle += 0.01  # rotation speed
    
            # Update and draw the ball
            ball.update()
            pygame.draw.circle(screen, BALL_COLOR, (int(ball.x), int(ball.y)), BALL_RADIUS)
    
            pygame.display.flip()
            clock.tick(60)
    
        pygame.quit()
    
    if __name__ == "__main__":
        main()
    

    How it works:

    1. We define the window dimensions, colors, and properties for the hexagon and the ball.
    2. The Ball class represents the ball inside the hexagon. It has attributes for position (x, y), velocity (vx, vy), and methods to update its position based on gravity and boundary checks.
    3. In the update method:
      • We apply gravity to the ball's vertical velocity (vy += GRAVITY).
      • We update the ball's position using its velocity (y += self.vy, etc.).
      • We check if the ball has hit the hexagon edge. If so, we reflect the ball's velocity around the normal of the edge, dampening the reflection to simulate energy loss.
      • We move the ball back to the edge of the hexagon to prevent it from escaping.
    4. The draw_hexagon function calculates the points of the hexagon based on the center, size, and rotation angle, and draws it using pygame.draw.polygon.
    5. In the main loop:
      • We handle events and clear the screen.
      • We draw the rotating hexagon by incrementing the angle variable and calling draw_hexagon.
      • We update the ball's position using its update method and draw it at its new position.
      • We cap the frame rate at 60 FPS using clock.tick(60).

    Run the code:

    Save this code to a file (e.g., rotating_hexagon.py) and run it using Python (e.g., python rotating_hexagon.py). You'll need to have Pygame installed (pip install pygame).

    Enjoy watching the ball bounce around the rotating hexagon, affected by gravity!

    Tips and Variations:

    • Adjust the GRAVITY value to change the strength of the gravitational force.
    • Experiment with different HEX_SIZE, BALL_RADIUS, and BALL_COLOR values to alter the appearance.
    • Add more complexity to the ball's behavior by introducing friction, air resistance, or even a second ball!
    • Try changing the hexagon's rotation speed or direction (e.g., counterclockwise).
    • For a challenge, implement a more realistic physics engine using libraries like Pymunk or Panda3D.

    Happy coding!

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