Game Physics with Python - Rishan Solutions

Game physics is essential for creating realistic interactions in games, such as movement, collisions, gravity, and forces. Python provides various libraries to simulate physics in games, with Pygame and Pymunk being the most commonly used.

1. Understanding Game Physics

Game physics helps simulate real-world physics in games. Common physics concepts include:

Gravity: Objects fall due to gravitational acceleration.
Collision Detection: Detecting when two objects collide.
Forces: Applying push or pull forces (e.g., wind, explosions).
Friction: Slowing objects down due to resistance.
Rigid Body Dynamics: Simulating how objects move and interact.

Physics Libraries in Python

Pygame: Basic physics (movement, collisions).
Pymunk: Advanced physics (realistic forces, rigid body simulation).
Box2D: Used in physics-based games (e.g., Angry Birds).
PyBullet: For realistic 3D physics simulations.

2. Setting Up Pygame for Game Physics

Install Pygame

bashCopyEditpip install pygame

Basic Game Loop with Gravity

import pygame

pygame.init()

# Screen settings
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Basic Game Physics")

# Colors
WHITE = (255, 255, 255)
BLUE = (0, 0, 255)

# Object properties
player_size = 40
player_pos = [WIDTH // 2, HEIGHT // 2]
velocity = [0, 0]
gravity = 0.5
ground_level = HEIGHT - player_size

clock = pygame.time.Clock()
running = True

3. Adding Gravity and Jump Mechanics

Step 1: Simulate Gravity

def apply_gravity():
    if player_pos[1] < ground_level:
        velocity[1] += gravity
    else:
        velocity[1] = 0  # Stop falling when on the ground
        player_pos[1] = ground_level

Step 2: Jumping Mechanism

def jump():
    if player_pos[1] == ground_level:
        velocity[1] = -12  # Jump force

Step 3: Player Movement

def move_player(keys):
    speed = 5
    if keys[pygame.K_LEFT]:  player_pos[0] -= speed
    if keys[pygame.K_RIGHT]: player_pos[0] += speed
    if keys[pygame.K_SPACE]: jump()

4. Running the Game Loop

Step 4: Integrating Physics in Game Loop

while running:
    screen.fill(WHITE)

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

    keys = pygame.key.get_pressed()
    move_player(keys)
    apply_gravity()
    
    # Apply velocity
    player_pos[1] += velocity[1]

    pygame.draw.rect(screen, BLUE, (*player_pos, player_size, player_size))

    pygame.display.update()
    clock.tick(30)

pygame.quit()

This basic implementation simulates gravity and jumping.

5. Collision Detection

Collision detection ensures that objects do not pass through walls or floors.

Step 1: Basic Collision with Ground

if player_pos[1] + player_size >= HEIGHT:
    player_pos[1] = HEIGHT - player_size

Step 2: Collision with a Wall

wall_pos = [300, 400, 50, 100]  # (x, y, width, height)

def check_wall_collision():
    if (player_pos[0] < wall_pos[0] + wall_pos[2] and
        player_pos[0] + player_size > wall_pos[0] and
        player_pos[1] < wall_pos[1] + wall_pos[3] and
        player_pos[1] + player_size > wall_pos[1]):
        return True
    return False

Step 3: Adding Walls in the Game Loop

pygame.draw.rect(screen, (255, 0, 0), wall_pos)  # Draw wall

if check_wall_collision():
    velocity[1] = 0  # Stop movement on collision

6. Using Pymunk for Advanced Physics

Pymunk is a powerful physics engine for handling forces, rigid body dynamics, and realistic simulations.

Install Pymunk

pip install pymunk

Step 1: Initialize Pymunk Physics Space

import pymunk
import pymunk.pygame_util

space = pymunk.Space()
space.gravity = (0, 900)  # Gravity downward

Step 2: Create a Ball Object

def create_ball(x, y):
    mass = 1
    radius = 20
    body = pymunk.Body(mass, pymunk.moment_for_circle(mass, 0, radius))
    body.position = x, y
    shape = pymunk.Circle(body, radius)
    shape.elasticity = 0.8  # Bounciness
    space.add(body, shape)
    return shape

Step 3: Add Ground

def create_ground():
    body = pymunk.Body(body_type=pymunk.Body.STATIC)
    shape = pymunk.Segment(body, (50, HEIGHT - 50), (WIDTH - 50, HEIGHT - 50), 5)
    shape.elasticity = 0.8
    space.add(body, shape)

Step 4: Run the Physics Simulation

balls = []
create_ground()

while running:
    screen.fill(WHITE)
    
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == pygame.MOUSEBUTTONDOWN:
            x, y = event.pos
            balls.append(create_ball(x, y))

    space.step(1/60)  # Update physics

    for ball in balls:
        pygame.draw.circle(screen, BLUE, (int(ball.body.position.x), int(ball.body.position.y)), 20)

    pygame.display.update()
    clock.tick(60)

7. Enhancing Game Physics

Friction

shape.friction = 0.5  # Higher friction slows down objects

Explosion Force

def apply_explosion(x, y):
    for ball in balls:
        direction = pymunk.Vec2d(ball.body.position - (x, y))
        force = 500 / (1 + direction.length)  # Decay force with distance
        ball.body.apply_impulse_at_local_point(direction.normalized() * force)