add bouncing ball simulation in a spinning hexagon with collision detection

examples/bouncing_ball_hexagon/flavioAd_R1.py

@@ -0,0 +1,133 @@
+"""
+https://x.com/flavioAd/status/1885449107436679394
+https://codeishot.com/6yxHiwZ2
+changed colors for visualization
+tried to match params to o3 results
+"""
+
+import pygame
+import numpy as np
+import math
+
+# Initialize Pygame
+pygame.init()
+WIDTH, HEIGHT = 800, 600
+screen = pygame.display.set_mode((WIDTH, HEIGHT))
+clock = pygame.time.Clock()
+FPS = 100  # Match with physics time step
+
+# Simulation parameters
+SCALE = 40  # pixels per simulation unit
+radius_hexagon = 5.0
+ball_radius = 0.2
+angular_velocity = np.pi / 6  # rad/s
+gravity = 9.81  # m/s²
+coefficient_of_restitution = 0.9
+friction_coefficient = 0.2
+dt = 1.0 / FPS  # Time step matches frame rate
+
+# Initialize ball state
+ball_pos = np.array([0.0, 3.0])
+ball_vel = np.array([3.0, 0.0])
+
+# Create hexagon vertices (unrotated)
+angles = np.linspace(0, 2*np.pi, 7)[:-1]
+original_vertices = radius_hexagon * np.column_stack([np.cos(angles), np.sin(angles)])
+current_angle = 0.0
+
+def get_rotated_vertices(angle):
+    """Return vertices rotated by given angle"""
+    rot_mat = np.array([[np.cos(angle), -np.sin(angle)],
+                        [np.sin(angle), np.cos(angle)]])
+    return original_vertices @ rot_mat
+
+def screen_pos(pos):
+    """Convert simulation coordinates to Pygame screen coordinates"""
+    return (WIDTH//2 + int(pos[0] * SCALE), 
+            HEIGHT//2 - int(pos[1] * SCALE))
+
+# Colors
+BG_COLOR = (0, 0, 0)
+HEX_COLOR = (255, 255, 255)
+BALL_COLOR = (255, 0, 0)
+
+running = True
+while running:
+    # Handle events
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+
+    # Update hexagon rotation
+    current_angle += angular_velocity * dt
+    if current_angle > 2*np.pi:
+        current_angle -= 2*np.pi
+    r_vertices = get_rotated_vertices(current_angle)
+
+    # Apply gravity
+    ball_vel[1] -= gravity * dt  # Gravity acts downward in simulation
+
+    # Save previous position and update ball
+    prev_pos = np.copy(ball_pos)
+    ball_pos += ball_vel * dt
+
+    # Collision detection and response
+    collision_occurred = False
+    for i in range(len(r_vertices)):
+        A = r_vertices[i]
+        B = r_vertices[(i+1)%len(r_vertices)]
+        
+        edge_vec = B - A
+        normal = np.array([-edge_vec[1], edge_vec[0]])
+        normal /= np.linalg.norm(normal)
+        
+        # Find closest point on edge
+        AB = B - A
+        AP = prev_pos - A
+        t = np.dot(AP, AB) / np.dot(AB, AB)
+        t = np.clip(t, 0.0, 1.0)
+        closest_point = A + t * AB
+        
+        # Check collision
+        dist_vec = prev_pos - closest_point
+        distance = np.linalg.norm(dist_vec)
+        
+        if distance < ball_radius:
+            # Calculate wall velocity at collision point
+            wall_vel = angular_velocity * np.array([-closest_point[1], closest_point[0]])
+            
+            # Calculate relative velocity
+            rel_vel = ball_vel - wall_vel
+            normal_vel = np.dot(rel_vel, normal) * normal
+            tangent_vel = rel_vel - normal_vel
+            
+            # Apply collision response
+            new_normal_vel = -coefficient_of_restitution * normal_vel
+            new_tangent_vel = (1 - friction_coefficient) * tangent_vel
+            new_rel_vel = new_normal_vel + new_tangent_vel
+            
+            # Update ball velocity
+            ball_vel = wall_vel + new_rel_vel
+            
+            # Position correction
+            penetration = ball_radius - distance
+            ball_pos = prev_pos + penetration * normal
+            
+            collision_occurred = True
+            break
+
+    # Draw everything
+    screen.fill(BG_COLOR)
+    
+    # Draw hexagon
+    hex_points = [screen_pos(v) for v in r_vertices]
+    pygame.draw.polygon(screen, HEX_COLOR, hex_points, 3)
+    
+    # Draw ball
+    ball_scr_pos = screen_pos(ball_pos)
+    pygame.draw.circle(screen, BALL_COLOR, ball_scr_pos, int(ball_radius * SCALE))
+    
+    pygame.display.flip()
+    clock.tick(FPS)
+
+pygame.quit()

examples/bouncing_ball_hexagon/flavioAd_o3mini.py

@@ -0,0 +1,185 @@
+"""
+https://x.com/flavioAd/status/1885449107436679394
+https://codeishot.com/6yxHiwZ2
+https://codeishot.com/1SlxNjbP
+"""
+
+import math
+import numpy as np
+import pygame
+
+# -----------------------------
+# Helper functions
+# -----------------------------
+def rotate_point(point, angle, center):
+    """
+    Rotate a 2D point around a given center by 'angle' radians.
+    """
+    s, c = math.sin(angle), math.cos(angle)
+    translated = point - center
+    rotated = np.array([translated[0]*c - translated[1]*s,
+                        translated[0]*s + translated[1]*c])
+    return rotated + center
+
+def closest_point_on_segment(A, B, P):
+    """
+    Returns the closest point on the line segment AB to point P.
+    """
+    AB = B - A
+    if np.allclose(AB, 0):
+        return A
+    t = np.dot(P - A, AB) / np.dot(AB, AB)
+    t = np.clip(t, 0, 1)
+    return A + t * AB
+
+def compute_inward_normal(A, B, poly_center):
+    """
+    Compute the inward normal (unit vector) for edge AB of a polygon,
+    ensuring that the normal points from the edge toward the polygon’s center.
+    """
+    # Compute candidate normal: rotate edge vector by 90 degrees
+    edge = B - A
+    candidate = np.array([edge[1], -edge[0]])
+    candidate_norm = candidate / np.linalg.norm(candidate)
+    # Ensure it points toward the polygon center.
+    mid = (A + B) / 2.0
+    if np.dot(poly_center - mid, candidate_norm) < 0:
+        candidate_norm = -candidate_norm
+    return candidate_norm
+
+# -----------------------------
+# Main simulation
+# -----------------------------
+def main():
+    # Initialize Pygame
+    pygame.init()
+    WIDTH, HEIGHT = 800, 600
+    screen = pygame.display.set_mode((WIDTH, HEIGHT))
+    pygame.display.set_caption("Ball in a Rotating Hexagon")
+    clock = pygame.time.Clock()
+    running = True
+
+    # -----------------------------
+    # Simulation parameters
+    # -----------------------------
+    # Physics constants
+    gravity = np.array([0, 500.0])  # pixels/s^2 (downward)
+    restitution = 0.9               # bounce factor (0 < restitution <= 1)
+    friction_coef = 0.2             # friction coefficient for tangential velocity
+
+    # Ball properties
+    ball_radius = 15
+    ball_position = np.array([WIDTH/2, HEIGHT/2])
+    ball_velocity = np.array([200.0, -150.0])  # initial velocity in pixels/s
+
+    # Hexagon properties
+    hex_center = np.array([WIDTH/2, HEIGHT/2])
+    hex_radius = 200              # distance from center to vertex
+    hexagon_local = []            # vertices in local (non-rotated) coordinates
+    num_sides = 6
+    for i in range(num_sides):
+        angle = 2 * math.pi * i / num_sides
+        vertex = np.array([hex_radius * math.cos(angle),
+                           hex_radius * math.sin(angle)])
+        hexagon_local.append(vertex)
+    hexagon_local = np.array(hexagon_local)
+
+    hex_angle = 0.0                           # initial rotation angle in radians
+    hex_angular_velocity = math.radians(30)   # constant angular velocity (30°/s)
+
+    # -----------------------------
+    # Main loop
+    # -----------------------------
+    while running:
+        dt = clock.tick(60) / 1000.0  # seconds elapsed since last frame (aim for 60 FPS)
+
+        # --- Event Handling ---
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                running = False
+
+        # --- Update Hexagon ---
+        hex_angle += hex_angular_velocity * dt
+
+        # Compute the global (rotated) positions of the hexagon vertices.
+        hexagon_global = []
+        for vertex in hexagon_local:
+            # Since the local vertices are relative to hex_center, we can
+            # rotate them directly and then add hex_center.
+            s, c = math.sin(hex_angle), math.cos(hex_angle)
+            rotated = np.array([vertex[0]*c - vertex[1]*s,
+                                vertex[0]*s + vertex[1]*c])
+            hexagon_global.append(rotated + hex_center)
+        hexagon_global = np.array(hexagon_global)
+
+        # --- Update Ball Physics ---
+        # Apply gravity
+        ball_velocity += gravity * dt
+        # Update position
+        ball_position += ball_velocity * dt
+
+        # --- Collision Detection & Response with Hexagon Edges ---
+        for i in range(len(hexagon_global)):
+            A = hexagon_global[i]
+            B = hexagon_global[(i + 1) % len(hexagon_global)]
+            # Compute the inward normal for this edge.
+            n = compute_inward_normal(A, B, hex_center)
+
+            # Find the closest point on the edge AB to the ball’s center.
+            closest = closest_point_on_segment(A, B, ball_position)
+            diff = ball_position - closest
+            dist = np.linalg.norm(diff)
+
+            if dist < ball_radius:
+                # --- Position Correction ---
+                penetration = ball_radius - dist
+                # Use the diff direction if available; otherwise fall back on edge normal.
+                if dist != 0:
+                    correction_dir = diff / dist
+                else:
+                    correction_dir = n
+                ball_position += correction_dir * penetration
+
+                # --- Collision Response ---
+                # Compute the velocity of the wall at the collision point due to rotation.
+                r = closest - hex_center
+                # In 2D, the tangential velocity due to rotation: v = ω x r,
+                # which can be computed as: v = ω * [-r_y, r_x]
+                v_wall = hex_angular_velocity * np.array([-r[1], r[0]])
+
+                # Compute the ball’s velocity relative to the wall.
+                v_rel = ball_velocity - v_wall
+                # Determine the component along the collision normal.
+                v_rel_normal = np.dot(v_rel, n)
+
+                # Only respond if the ball is moving into the wall.
+                if v_rel_normal < 0:
+                    # Decompose the relative velocity into normal and tangential components.
+                    v_n = v_rel_normal * n
+                    v_t = v_rel - v_n
+
+                    # Reflect the normal component (with restitution) and reduce the tangential
+                    # component according to friction.
+                    v_n_new = -restitution * v_n
+                    v_t_new = (1 - friction_coef) * v_t
+
+                    # Update ball velocity by adding back the wall’s velocity.
+                    ball_velocity = v_wall + v_n_new + v_t_new
+
+        # --- Rendering ---
+        screen.fill((0, 0, 0))  # Dark background
+
+        # Draw the rotating hexagon.
+        hex_points = [(int(x), int(y)) for x, y in hexagon_global]
+        pygame.draw.polygon(screen, (255, 255, 255), hex_points, 3)
+
+        # Draw the ball.
+        pygame.draw.circle(screen, (255, 0, 0),
+                           (int(ball_position[0]), int(ball_position[1])), ball_radius)
+
+        pygame.display.flip()
+
+    pygame.quit()
+
+if __name__ == '__main__':
+    main()

examples/bouncing_ball_hexagon/mistral.py

@@ -0,0 +1,116 @@
+"""
+system_prompt:
+You are a helpful assistant. You write high quality code following best practises and employing the relevant packages for the task. 
+When dealing with code ensure it is coherent and that the implementation logic fully tackles the request you received.
+
+temperature: 0
+max_tokens: 3072
+
+reasoner_system_prompt:
+You are a helpfull assistant with reasoning capabilites that breaks down problems into at least 10 detailed steps with usefull thoughts on how to solve them.
+
+temperature: 0.5
+max_tokens: 2048
+
+prompt:
+write a python program that shows a ball bouncing inside a spninning hexagon. The ball should be affected by gravity and friction, and it must bounce off the rotating walls realistically.
+"""
+
+import pygame
+import math
+
+# Initialize Pygame
+pygame.init()
+
+# Screen dimensions
+WIDTH, HEIGHT = 800, 600
+screen = pygame.display.set_mode((WIDTH, HEIGHT))
+pygame.display.set_caption("Bouncing Ball in Spinning Hexagon")
+
+# Colors
+WHITE = (255, 255, 255)
+RED = (255, 0, 0)
+BLACK = (0, 0, 0)
+
+# Hexagon properties
+hexagon_radius = 200
+hexagon_angle = 0
+hexagon_rotation_speed = 0.01  # radians per frame
+
+# Ball properties
+ball_radius = 20
+ball_position = pygame.Vector2(WIDTH // 2, HEIGHT // 2)
+ball_velocity = pygame.Vector2(-3, 15)
+ball_acceleration = pygame.Vector2(0, 0.5)  # Gravity
+ball_friction = 0.99
+ball_elasticity = 0.9
+
+# Clock to control the frame rate
+clock = pygame.time.Clock()
+
+def calculate_hexagon_vertices(angle):
+    vertices = []
+    for i in range(6):
+        x = WIDTH // 2 + hexagon_radius * math.cos(angle + i * math.pi / 3)
+        y = HEIGHT // 2 + hexagon_radius * math.sin(angle + i * math.pi / 3)
+        vertices.append((x, y))
+    return vertices
+
+def draw_hexagon(vertices):
+    pygame.draw.polygon(screen, WHITE, vertices, 2)
+
+def draw_ball(position):
+    pygame.draw.circle(screen, RED, (int(position.x), int(position.y)), ball_radius)
+
+def check_collision(ball_position, ball_velocity, vertices):
+    for i in range(6):
+        x1, y1 = vertices[i]
+        x2, y2 = vertices[(i + 1) % 6]
+
+        # Calculate the normal vector of the side
+        dx = x2 - x1
+        dy = y2 - y1
+        normal = pygame.Vector2(-dy, dx).normalize()
+
+        # Calculate the distance from the ball to the line
+        distance = abs((x2 - x1) * (y1 - ball_position.y) - (x1 - ball_position.x) * (y2 - y1)) / math.sqrt(dx**2 + dy**2)
+
+        if distance <= ball_radius:
+            # Collision detected, reflect the velocity
+            relative_velocity = ball_velocity.dot(normal)
+            if relative_velocity < 0:
+                ball_velocity.reflect_ip(normal)
+                ball_velocity *= ball_elasticity
+                ball_position += normal * (ball_radius - distance)
+
+# Main loop
+running = True
+while running:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+
+    # Update hexagon angle
+    hexagon_angle += hexagon_rotation_speed
+
+    # Calculate hexagon vertices
+    vertices = calculate_hexagon_vertices(hexagon_angle)
+
+    # Apply gravity and friction to the ball
+    ball_velocity += ball_acceleration
+    ball_velocity *= ball_friction
+    ball_position += ball_velocity
+
+    # Check for collisions with hexagon sides
+    check_collision(ball_position, ball_velocity, vertices)
+
+    # Draw everything
+    screen.fill(BLACK)
+    draw_hexagon(vertices)
+    draw_ball(ball_position)
+    pygame.display.flip()
+
+    # Cap the frame rate
+    clock.tick(60)
+
+pygame.quit()

examples/bouncing_ball_hexagon/mistral_no_reasoner.py

@@ -0,0 +1,109 @@
+import pygame
+import math
+import random
+
+# Initialize Pygame
+pygame.init()
+
+# Screen dimensions
+WIDTH, HEIGHT = 800, 600
+screen = pygame.display.set_mode((WIDTH, HEIGHT))
+pygame.display.set_caption("Bouncing Ball in Spinning Hexagon")
+
+# Colors
+WHITE = (255, 255, 255)
+BLACK = (0, 0, 0)
+RED = (255, 0, 0)
+
+# Ball properties
+ball_radius = 10
+ball_pos = [WIDTH // 2, HEIGHT // 2]
+ball_vel = [random.uniform(-2, 2), random.uniform(-2, 2)]
+gravity = 0.3
+friction = 1.2
+
+# Hexagon properties
+hexagon_radius = 150
+hexagon_angle = 0
+hexagon_rotation_speed = 0.005  # radians per frame
+
+def draw_hexagon(surface, color, radius, angle, center):
+    points = []
+    for i in range(6):
+        x = center[0] + radius * math.cos(angle + i * math.pi / 3)
+        y = center[1] + radius * math.sin(angle + i * math.pi / 3)
+        points.append((x, y))
+    pygame.draw.polygon(surface, color, points, 2)
+
+def is_point_inside_hexagon(point, radius, angle, center):
+    for i in range(6):
+        x1 = center[0] + radius * math.cos(angle + i * math.pi / 3)
+        y1 = center[1] + radius * math.sin(angle + i * math.pi / 3)
+        x2 = center[0] + radius * math.cos(angle + (i + 1) * math.pi / 3)
+        y2 = center[1] + radius * math.sin(angle + (i + 1) * math.pi / 3)
+        if intersects(point, ball_radius, (x1, y1), (x2, y2)):
+            return True
+    return False
+
+def intersects(point, radius, p1, p2):
+    # Check if the circle intersects the line segment
+    dx = p2[0] - p1[0]
+    dy = p2[1] - p1[1]
+    t = ((point[0] - p1[0]) * dx + (point[1] - p1[1]) * dy) / (dx * dx + dy * dy)
+    if t < 0:
+        closest = p1
+    elif t > 1:
+        closest = p2
+    else:
+        closest = (p1[0] + t * dx, p1[1] + t * dy)
+    distance = math.hypot(point[0] - closest[0], point[1] - closest[1])
+    return distance <= radius
+
+def reflect_velocity(vel, normal):
+    dot_product = vel[0] * normal[0] + vel[1] * normal[1]
+    vel[0] = vel[0] - 2 * dot_product * normal[0]
+    vel[1] = vel[1] - 2 * dot_product * normal[1]
+
+# Main loop
+running = True
+clock = pygame.time.Clock()
+
+while running:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+
+    # Update ball position
+    ball_vel[1] += gravity
+    ball_pos[0] += ball_vel[0]
+    ball_pos[1] += ball_vel[1]
+
+    # Check for collision with hexagon walls
+    if is_point_inside_hexagon(ball_pos, hexagon_radius, hexagon_angle, (WIDTH // 2, HEIGHT // 2)):
+        for i in range(6):
+            x1 = WIDTH // 2 + hexagon_radius * math.cos(hexagon_angle + i * math.pi / 3)
+            y1 = HEIGHT // 2 + hexagon_radius * math.sin(hexagon_angle + i * math.pi / 3)
+            x2 = WIDTH // 2 + hexagon_radius * math.cos(hexagon_angle + (i + 1) * math.pi / 3)
+            y2 = HEIGHT // 2 + hexagon_radius * math.sin(hexagon_angle + (i + 1) * math.pi / 3)
+            if intersects(ball_pos, ball_radius, (x1, y1), (x2, y2)):
+                normal = (y2 - y1, x1 - x2)
+                normal_length = math.hypot(normal[0], normal[1])
+                normal = (normal[0] / normal_length, normal[1] / normal_length)
+                reflect_velocity(ball_vel, normal)
+                ball_vel[0] *= friction
+                ball_vel[1] *= friction
+                break
+
+    # Update hexagon angle
+    hexagon_angle += hexagon_rotation_speed
+
+    # Draw everything
+    screen.fill(BLACK)
+    draw_hexagon(screen, WHITE, hexagon_radius, hexagon_angle, (WIDTH // 2, HEIGHT // 2))
+    pygame.draw.circle(screen, RED, (int(ball_pos[0]), int(ball_pos[1])), ball_radius)
+    pygame.display.flip()
+
+    # Cap the frame rate
+    clock.tick(60)
+
+pygame.quit()