A small and simple PyGame wrapper, for getting started quick and easy.
If you want do do something in your game but can't find a suitable function, you may want use pygame directly. All documentation for pygame can be found at https://www.pygame.org/docs/
Also note that not everything is documented, if it's not documented you probably don't have to care about it.
Some of the functions in ribs use a Python feature you may not have come
across: default arguments. These allow you to only specify a few of the
arguments to a function, and leave the rest. For example, the definition of
draw_transformed looks like this:
draw_transformed( img, position, scale=(1., 1.), degrees=0 )
The =x part of the scale and degrees mean that you can call the function as one of
draw_transformed( img, (100, 100)) # Default scale and degrees
draw_transformed( img, (100, 100), (2, 2)) # Scale up by 2, leave degrees unchanged
draw_transformed( img, (100, 100), (2, 2), 90) # Scale up by 2, rotate by 90 degrees
draw_transformed( img, (100, 100), , degrees = 90) # Rotate 90 degrees, default scale
Takes a key, that's either a keycode or a character, and returns true if that key is held.
key | A string with the character or keycode on the form (pg.K_****) of the button to check. |
For a list of keycodes, see the table in the pygame documentation
if key_down("a"):
print("COWABUNGA")
if key_down(pg.K_LEFT):
print("Move left")
Takes a key, that's either a keycode or a character and returns true if the key was released this frame.
key | A string with the character or keycode on the form (pg.K_****) of the button to check. |
For a list of keycodes, see the table in the pygame documentation
if key_released("a"):
print("hold longer maybe?")
Takes a key, that's either a keycode or a character, and returns true if that key was pressed this frame.
key | A string with the character or keycode on the form (pg.K_****) of the button to check. |
For a list of keycodes, see the table in the pygame documentation
if key_pressed(pg.K_SPACE):
print("JUMP")
Draws a sprite centered around position scaled by scale and rotated
clockwise degrees. The position to draw the sprite is given in pixels
relative to the top left corner of the screen.
The img argument is an image object loaded by
pg.image.load. Note that if you want to draw lots of images, it is
not a good idea to re-load the images every frame. Instead, load images into a
variable in the init function and do the drawing in
update
img | The image to be used as a sprite. |
position | The center position of the sprite. |
scale | A scale factor to apply. (Optional) |
degrees | Rotate the sprite. (Optional) |
assets["teapot"] = pg.image.load("teapot.png")
draw_transformed(assets["teapot"], (100, 100))
assets["teapot"] = pg.image.load("teapot.png")
draw_transformed(assets["teapot"], (100, 100),
(1, 0.5), time)
time was the "time since the program started", this
would draw a sprite at (100, 100) shrunk to half size along the y axis, rotating
around it's center.
Draw text at position, which is given in pixels from the top left corner.
Optional arguments include size given in points, color which is
a standard pygame color and font which is a string. To get a list of
available fonts, use pg.font.get_fonts().
text | The text to be drawn. |
position | The top left corner of the text, in pixel coordinates. |
size | The font size in points. (Optional) |
color | The color of the text. (Optional) |
font | Name of the font to use. (Optional) |
draw_text("Level: 1", (0, 0))
draw_text("Level: 2", (0, 0), size=100)
draw_text("Level: 3", (0, 0), color=pg.Color(255, 0, 0))
draw_text("Level: 4", (0, 0), font="Times New Roman")
pg.font.get_fonts() to get a list of fonts installed on your system.
draw_text("Level: 5", (1000, 1000), 50, pg.Color(0, 255, 0), "Comic Sans MS")
Returns the axis that points from a to b, and the depth of the collision. If the depth is negative it means they are far away from overlapping.
Note that this function is not super important, you probably want
to use solve_rect_overlap(a, b)
a | A pg.Rect(minx, miny, width, height). |
b | A pg.Rect(minx, miny, width, height). |
rect_a = pg.Rect(200, 200, 100, 100)
rect_b = pg.Rect(250, 250, 50, 100)
normal, depth = overlap_data(rect_a, rect_b)
overlap = depth > 0
print(overlap)
This function checks if a and b overlap, if they do the collision
is solved and two new rectangles moved out of eachother along the shortest
collision vector are returned along with their velocities.
Note that a and b are modified inplace, and might be changed after
calling this function.
a | A pg.Rect(minx, miny, width, height). |
b | A pg.Rect(minx, miny, width, height). |
vel_a | The velocity of a, given as a tuple. |
vel_b | The velocity of b, given as a tuple. |
mass_a | The mass of a. 0 mass means it's static and immovable. |
mass_b | The mass of b. 0 mass means it's static and immovable. |
bounce | How bouncy the collision should be. Values higher than 1 will introduce more energy into the system and might cause glitches. Values lower than 0 don't make sense. |
rect_a = pg.Rect(200, 200, 100, 100)
vel_a = (0, 1000)
rect_b = pg.Rect(250, 250, 50, 100)
vel_b = (0, 0)
vel_a, vel_b, hit = solve_rect_overlap(rect_a,\
rect_b,\
vel_a,\
vel_b,\
bounce=1.0)
rect_a and rect_b. The collision will send
rect_b flying since all the energy from rect _a is transferred to rect_b.
Sets new dimensions for the screen that renders the game.
width | The new width of the screen in pixels. |
height | The new height of the screen in pixels. |
set_screen_size(1337, 420)
Updates the frame rate limit to the supplied FPS, if set to 0 there will be no limit.
fps | The frame rate to limit to, 0 means no limit. |
set_frame_rate(0)
set_frame_rate(60)
Return the number of seconds passed since the start of the game, or the latest restart.
Return the number of seconds passed between this frame and the previous. The number is usually quite small (~0.16).
Restart the game and reset all state from the engine's side of things. Note that it might not clear your stored state, which might cause the game to behave strangely when restarting.
Note that calling restart() won't terminate the "run".
The code that calls into the ribs.py and sets up everything that needs to be
set up. You just give in your function.
If you're using the supplied template, you don't need to worry about this.
init | The initalization function, this one is only called once. Takes no arguments. |
update | The update function, expected to be an iterator that returns when the game is finished. Takes no arguments. |
def init():
print("Initialized, only called once!")
</p><p>def update():
print("Called for every start and restart!")
while True:
print("Update!")
yield
</p><p>start_game(init, update)
Initialized, only called once! I'm called for every start and restart! Update! Update! Update! . . .