شبیه سازی توپ های تندرست با برخورد در پایتون با استفاده از پیگام

pip install pygame

pygame.init()

# Set up the display
width = 800
height = 600
ball_radius = 20
screen = pygame.display.set_mode((width, height))
clock = pygame.time.Clock()

white = (255, 255, 255)
black = (0, 0, 0)
red = (255, 0, 0)
green = (0, 255, 0)
blue = (0, 0, 255)

class Ball:
    def __init__(self, color):
        self.x = random.randint(ball_radius, width - ball_radius)
        self.y = random.randint(ball_radius, height - ball_radius)
        self.velocity_x = random.randint(1, 3) * 2
        self.velocity_y = random.randint(1, 3) * -2
        self.color = color

def move(self):
    self.x += self.velocity_x
    self.y += self.velocity_y

    # Bounce off walls, considering the radius of the ball
    if self.x <= ball_radius or self.x >= width - ball_radius:
        self.velocity_x *= -1
        if self.x <= ball_radius:
            self.x = ball_radius
        elif self.x >= width - ball_radius:
            self.x = width - ball_radius

    if self.y <= ball_radius:
        self.velocity_y *= -1
        self.y = ball_radius
    elif self.y >= height - ball_radius:
        self.velocity_y *= -1
        self.y = height - ball_radius

def draw(self):
    pygame.draw.circle(screen, self.color, (self.x, self.y), ball_radius)

def check_collision(self, other_ball):
    dx = self.x - other_ball.x
    dy = self.y - other_ball.y
    distance = math.sqrt(dx**2 + dy**2)

    # If the distance between centers is less than twice the radius, a collision occurred
    if distance < 2 * ball_radius:
        # Normalize the vector between the two balls
        normal_vector = pygame.math.Vector2(dx, dy).normalize()

        # Calculate relative velocity
        relative_velocity = pygame.math.Vector2(self.velocity_x, self.velocity_y) - pygame.math.Vector2(other_ball.velocity_x, other_ball.velocity_y)

        # Calculate the velocity along the normal vector (dot product)
        velocity_along_normal = relative_velocity.dot(normal_vector)

        if velocity_along_normal > 0:
            return

        # Calculate the impulse scalar
        impulse = 2 * velocity_along_normal / (2 * ball_radius)

        # Apply the impulse to the velocities of both balls
        self.velocity_x -= impulse * normal_vector.x
        self.velocity_y -= impulse * normal_vector.y
        other_ball.velocity_x += impulse * normal_vector.x
        other_ball.velocity_y += impulse * normal_vector.y

        # Reposition the balls to avoid overlap
        overlap = 2 * ball_radius - distance
        self.x += normal_vector.x * overlap / 2
        self.y += normal_vector.y * overlap / 2
        other_ball.x -= normal_vector.x * overlap / 2
        other_ball.y -= normal_vector.y * overlap / 2

balls = [Ball(red), Ball(green), Ball(blue)]
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Move and check collisions for each ball
    for ball in balls:
        ball.move()

    # Check for collisions between the balls
    for i in range(len(balls)):
        for j in range(i + 1, len(balls)):
            balls[i].check_collision(balls[j])

    # Draw the window
    screen.fill(white)

    # Draw all balls
    for ball in balls:
        ball.draw()

    # Update and render
    pygame.display.flip()
    clock.tick(60)

pygame.quit()

import pygame
import random
import math

# Initialize Pygame
pygame.init()

# Set up the display
width = 800
height = 600
ball_radius = 20

# Define colors
white = (255, 255, 255)
black = (0, 0, 0)
red = (255, 0, 0)
green = (0, 255, 0)
blue = (0, 0, 255)

# Create a Pygame display surface
screen = pygame.display.set_mode((width, height))
clock = pygame.time.Clock()

# Ball class to manage multiple balls
class Ball:
    def __init__(self, color):
        self.x = random.randint(ball_radius, width - ball_radius)
        self.y = random.randint(ball_radius, height - ball_radius)
        self.velocity_x = random.randint(1, 3) * 2
        self.velocity_y = random.randint(1, 3) * -2
        self.color = color

    def move(self):
        self.x += self.velocity_x
        self.y += self.velocity_y

        # Bounce off walls, considering the radius of the ball
        if self.x <= ball_radius or self.x >= width - ball_radius:
            self.velocity_x *= -1
            if self.x <= ball_radius:
                self.x = ball_radius
            elif self.x >= width - ball_radius:
                self.x = width - ball_radius

        if self.y <= ball_radius:
            self.velocity_y *= -1
            self.y = ball_radius
        elif self.y >= height - ball_radius:
            self.velocity_y *= -1
            self.y = height - ball_radius

    def draw(self):
        pygame.draw.circle(screen, self.color, (self.x, self.y), ball_radius)

    def check_collision(self, other_ball):
        dx = self.x - other_ball.x
        dy = self.y - other_ball.y
        distance = math.sqrt(dx**2 + dy**2)

        # If the distance between centers is less than twice the radius, a collision occurred
        if distance < 2 * ball_radius:
            # Normalize the vector between the two balls
            normal_vector = pygame.math.Vector2(dx, dy).normalize()

            # Calculate relative velocity
            relative_velocity = pygame.math.Vector2(self.velocity_x, self.velocity_y) - pygame.math.Vector2(other_ball.velocity_x, other_ball.velocity_y)

            # Calculate the velocity along the normal vector (dot product)
            velocity_along_normal = relative_velocity.dot(normal_vector)

            if velocity_along_normal > 0:
                return

            # Calculate the impulse scalar
            impulse = 2 * velocity_along_normal / (2 * ball_radius)

            # Apply the impulse to the velocities of both balls
            self.velocity_x -= impulse * normal_vector.x
            self.velocity_y -= impulse * normal_vector.y
            other_ball.velocity_x += impulse * normal_vector.x
            other_ball.velocity_y += impulse * normal_vector.y

            # Reposition the balls to avoid overlap
            overlap = 2 * ball_radius - distance
            self.x += normal_vector.x * overlap / 2
            self.y += normal_vector.y * overlap / 2
            other_ball.x -= normal_vector.x * overlap / 2
            other_ball.y -= normal_vector.y * overlap / 2

# Create 3 balls of different colors
balls = [Ball(red), Ball(green), Ball(blue)]

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Move and check collisions for each ball
    for ball in balls:
        ball.move()

    # Check for collisions between the balls
    for i in range(len(balls)):
        for j in range(i + 1, len(balls)):
            balls[i].check_collision(balls[j])

    # Draw the window
    screen.fill(white)

    # Draw all balls
    for ball in balls:
        ball.draw()

    # Update and render
    pygame.display.flip()
    clock.tick(60)

pygame.quit()