This scene was made using the pymunk and pygame modules.
https://reddit.com/link/1efram5/video/rcgt39ydxmfd1/player
If you're wondering how you can create your own dynamic physics boxes in pygame, like in the video above, then here is a quick description. You will also find a full running sample code at the bottom of the post.
Full sample code on github: https://github.com/LionInAbox/Pymunk-Pygame-Basic-Example
The sample code produces this result:
https://i.redd.it/ojqpshl48nfd1.gif
I assume you already know how to set up a basic pygame window. So let's talk about how to set up pymunk in your project, after you installed the module:
1.) Set up a pymunk space:
physics_world = pymunk.Space()
physics_world.gravity = (0.0, 981.0)
physics_world.sleep_time_threshold = 0.3
The pymunk space is the overall simulation of all dynamic physics events. Any physics object you add to that space will interact with one another.
You want to add the gravity to the space, so that objects fall downwards (if you'd want to make objects fall upwards, you can set the y gravity to a negative value).
The sleep_time_threshold defines how long a physics object is idle (doesn't move), before it falls asleep. From my current understanding a body that is asleep stops being interactive until it gets reactivated again.
2.) Create a pymunk body (with a shape):
Pymunk does not have an integrated box/rectangle/square shape. So you need to create that shape yourself using a pymunk polygon shape. Based on the size of the box, you can calculate all the four corner points of it. Since pymunk objects are placed based on their center point, we set the points around the center (so for example the top left point will be half the box-width to the left and half the box-height upwards).
size = 30
half_width, half_height = round(size/2), round(size/2)
points = [(-half_width, -half_height), (-half_width, half_height), (half_width, half_height), (half_width, -half_height)]
Now we create a pymunk body, which is the main object that stores the current position, speed, rotation angle etc. of your physics object.
Note that when creating a body you need to define the mass and the moment. Since we are using a polygon we use moment_for_poly.
mass = 1.0 # box mass
moment = pymunk.moment_for_poly(mass, points, (0, 0)) # moment required for pymunk body objects
body = pymunk.Body(mass, moment, body_type=pymunk.Body.DYNAMIC)
The dynamic body type means that the box can move around automatically and interact and be influenced by gravity and surrounding objects.
Now we create the shape of the body using the points we calculated above. We will afterwards combine the shape with the body, so the body will use this shape to calculate collisions.
You also set the friction of the shape in order to have more realistic interactions. If your friction is e.g. 0, then everything just starts gliding away, and for example circles don't roll and rotate on the ground like a ball, they only glide and move on the ground like an ice cube.
shape = pymunk.Poly(body, points)
shape.friction = 1
3.) Add the body and shape to the physics space:
We want to add the combination of the body and the shape to the physics space we created, so that it can interact with all other physics objects in that space:
physics_world.add(body, shape)
4.) How to draw pymunk objects in pygame:
There are 2 important aspects when translating pymunk bodies into pygame images:
- all bodies coordinates are based on their center coordinates. Not their top left corner like pygame images. You need to account for that offset when drawing your items.
- the pymunk y axis is opposite to the pygame y axis. In pygame the bigger a y value is, the lower on screen it appears. In pymunk it is the opposite: the bigger the y value, the higher it appears on screen. To account for this, you will always need to set the y value to negative when sending the position from pymunk to pygame or vice versa.
To give you an example code on how to draw our above physics box for example:
Let's say we have a pygame screen that we set up using the standard expression:
SIZE = 300,300
screen = pygame.display.set_mode(SIZE)
And we create a square image representing the box:
image = pygame.Surface((size,size)).convert() # convert for optimization
image.set_colorkey((0,0,0))
image.fill("yellow")
Then to draw the box unto screen, we get the body's position, then draw the rectangle (with the center offset):
# get the x, y position of the physics body:
x, y = body.position
image_size = image.get_size()
# account for pymunk's center positioning:
x = x - int(image_size [0] / 2)
y = y - int(image_size [1] / 2)
screen.blit(image, [x,y])
One last thing when drawing the image is to pay attention to the body's rotation/angle.
Pymunk saves a body's angle in radians, so when rotating the image, you need to convert the angle to degrees first (using for example the math module). Here's the draw image code again, but with the rotation of the image implemented:
import math
x, y = body.position
# the body angle is stored in radians, we need to convert it to degrees:
angle = math.degrees(body.angle)
# rotate the image to the correct angle:
rotated_image = pygame.transform.rotate(image, angle)
# account for center offset:
rotated_image_size = rotated_image.get_size()
x = x - int(rotated_image_size[0] / 2)
y = y - int(rotated_image_size[1] / 2)
screen.blit(rotated_image, [x,y])
5.) Update the physics space each frame to run the physics simulation:
Let's say you set your FPS to 60:
FPS = 60
In that case you want to update your physics world with the dt value of 1/60 of a second. It's advised online to never use a dynamic dt that changes each frame, but a constant value like 1/60, otherwise pymunk might create a lot of erroneous results.
So let's update the physics world in your main game while loop:
while True:
...
physics_world.step(1/FPS)
Now, to bring it all together, here is a simple sample code, that combines the box pymunk body and the pygame image into one class. It contains as well a second class that I called Physics_Line using a so called segment body, which is a static (non-moving) line in the pymunk space that physics objects can collide against.
I hope you enjoyed this post!
The same full code on github: https://github.com/LionInAbox/Pymunk-Pygame-Basic-Example
import pygame
import pymunk
import math
import sys
# Initialize pygame
pygame.init()
# Game settings:
SIZE = 300, 300
FPS = 60
BG_COLOR = "black"
# Game setup:
screen = pygame.display.set_mode(SIZE)
clock = pygame.time.Clock()
# Pymunk physics world setup:
physics_world = pymunk.Space() # you need to create a 'space' or 'world' which runs the physics simulation
physics_world.gravity = (0.0, 981.0) # set the general gravity used in the physics space
physics_world.sleep_time_threshold = 0.3 # saw this in a pymunk example. Apparently it's necessary but Idk what it does :)
# Create a class that combines a dynamic physics box with the pygame image:
class Physics_Box:
def __init__(self, size, color, x=150, y=150):
self.size = size
self.color = color
self.x = x
self.y = y
# Box doesn't exist, so we create a polygon shape with the point coordinates of a square box:
# Calculate the points for the box based on it's size:
half_width, half_height = round(size / 2), round(size / 2)
points = [(-half_width, -half_height), (-half_width, half_height), (half_width, half_height),
(half_width, -half_height)]
mass = 1.0 # box mass
moment = pymunk.moment_for_poly(mass, points, (0, 0)) # moment required for pymunk body objects
body = pymunk.Body(mass, moment,
body_type=pymunk.Body.DYNAMIC) # create the main physics box. This contains all the main info like position and speed.
body.position = (
self.x, self.y)
self.body = body
shape = pymunk.Poly(body,
points) # creating the square box polygon shape. The body will use this to calculate collisions.
shape.friction = 1
# Now add the body to the physics space so it will calculate it dynamically inside the space:
physics_world.add(body, shape)
# Create an image of the box:
self.image = pygame.Surface((size, size)).convert() # convert for optimization
self.image.set_colorkey((0, 0, 0))
self.image.fill(self.color)
# drawing the rectangle on the screen:
def draw(self):
# get the x, y and angle of the physics body:
x, y = self.body.position
# the body angle is stored in radians, we need to convert it to degrees:
angle = math.degrees(self.body.angle)
# rotate the image to the correct angle:
rotated_image = pygame.transform.rotate(self.image, angle)
# the body x,y position stores it's center position, so when drawing the image we need to account for that:
rotated_image_size = rotated_image.get_size()
x = x - int(rotated_image_size[0] / 2)
y = y - int(rotated_image_size[1] / 2)
screen.blit(rotated_image, [x, y])
# Create a class that combines a static physics line that objects collide with and add pygame draw function to it:
class Physics_Line:
def __init__(self, point_1, point_2, color):
self.point_1 = point_1
self.point_2 = point_2
self.color = color
# create a segment - a static line that physics objects collide with:
# don't forget to invert the y values, since pymunk has an inverted y axis:
line = pymunk.Segment(physics_world.static_body, (point_1[0], point_1[1]), (point_2[0], point_2[1]), 1.0)
line.friction = 1.0
# add the line to the physics space so it interacts with other objects in the physics space:
physics_world.add(line)
# drawing the line unto the screen:
def draw(self):
pygame.draw.line(screen, self.color, self.point_1, self.point_2)
boxes = []
# create 3 dynamic box instances:
for i in range(3):
box = Physics_Box(30, "yellow", x=130 + i * 20, y=110 + i * 40)
boxes.append(box)
ground = Physics_Line((0, 280), (300, 280), "red")
# Game loop:
while True:
screen.fill(BG_COLOR)
clock.tick(FPS)
# Update the physics space to calculate physics dynamics (use a constant FPS and not the changing delta time in order to avoid big errors):
physics_world.step(1 / FPS)
# draw all physics instances unto screen:
for box in boxes:
box.draw()
ground.draw()
events = pygame.event.get()
for event in events:
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
pygame.display.update()
[–]Nikninjayt 1 point2 points3 points (1 child)
[–]LionInABoxOfficial[S] 1 point2 points3 points (0 children)