pymunk_demo_platformer_12.py Full Listing#
pymunk_demo_platformer_12.py#
1"""
2Example of Pymunk Physics Engine Platformer
3"""
4import math
5from typing import Optional
6import arcade
7
8SCREEN_TITLE = "PyMunk Platformer"
9
10# How big are our image tiles?
11SPRITE_IMAGE_SIZE = 128
12
13# Scale sprites up or down
14SPRITE_SCALING_PLAYER = 0.5
15SPRITE_SCALING_TILES = 0.5
16
17# Scaled sprite size for tiles
18SPRITE_SIZE = int(SPRITE_IMAGE_SIZE * SPRITE_SCALING_PLAYER)
19
20# Size of grid to show on screen, in number of tiles
21SCREEN_GRID_WIDTH = 25
22SCREEN_GRID_HEIGHT = 15
23
24# Size of screen to show, in pixels
25SCREEN_WIDTH = SPRITE_SIZE * SCREEN_GRID_WIDTH
26SCREEN_HEIGHT = SPRITE_SIZE * SCREEN_GRID_HEIGHT
27
28# --- Physics forces. Higher number, faster accelerating.
29
30# Gravity
31GRAVITY = 1500
32
33# Damping - Amount of speed lost per second
34DEFAULT_DAMPING = 1.0
35PLAYER_DAMPING = 0.4
36
37# Friction between objects
38PLAYER_FRICTION = 1.0
39WALL_FRICTION = 0.7
40DYNAMIC_ITEM_FRICTION = 0.6
41
42# Mass (defaults to 1)
43PLAYER_MASS = 2.0
44
45# Keep player from going too fast
46PLAYER_MAX_HORIZONTAL_SPEED = 450
47PLAYER_MAX_VERTICAL_SPEED = 1600
48
49# Force applied while on the ground
50PLAYER_MOVE_FORCE_ON_GROUND = 8000
51
52# Force applied when moving left/right in the air
53PLAYER_MOVE_FORCE_IN_AIR = 900
54
55# Strength of a jump
56PLAYER_JUMP_IMPULSE = 1800
57
58# Close enough to not-moving to have the animation go to idle.
59DEAD_ZONE = 0.1
60
61# Constants used to track if the player is facing left or right
62RIGHT_FACING = 0
63LEFT_FACING = 1
64
65# How many pixels to move before we change the texture in the walking animation
66DISTANCE_TO_CHANGE_TEXTURE = 20
67
68# How much force to put on the bullet
69BULLET_MOVE_FORCE = 4500
70
71# Mass of the bullet
72BULLET_MASS = 0.1
73
74# Make bullet less affected by gravity
75BULLET_GRAVITY = 300
76
77
78class PlayerSprite(arcade.Sprite):
79 """ Player Sprite """
80 def __init__(self,
81 ladder_list: arcade.SpriteList,
82 hit_box_algorithm: arcade.hitbox.HitBoxAlgorithm):
83 """ Init """
84 # Let parent initialize
85 super().__init__()
86
87 # Set our scale
88 self.scale = SPRITE_SCALING_PLAYER
89
90 # Images from Kenney.nl's Character pack
91 # main_path = ":resources:images/animated_characters/female_adventurer/femaleAdventurer"
92 main_path = ":resources:images/animated_characters/female_person/femalePerson"
93 # main_path = ":resources:images/animated_characters/male_person/malePerson"
94 # main_path = ":resources:images/animated_characters/male_adventurer/maleAdventurer"
95 # main_path = ":resources:images/animated_characters/zombie/zombie"
96 # main_path = ":resources:images/animated_characters/robot/robot"
97
98 # Load textures for idle standing
99 self.idle_texture_pair = arcade.load_texture_pair(f"{main_path}_idle.png",
100 hit_box_algorithm=hit_box_algorithm)
101 self.jump_texture_pair = arcade.load_texture_pair(f"{main_path}_jump.png")
102 self.fall_texture_pair = arcade.load_texture_pair(f"{main_path}_fall.png")
103
104 # Load textures for walking
105 self.walk_textures = []
106 for i in range(8):
107 texture = arcade.load_texture_pair(f"{main_path}_walk{i}.png")
108 self.walk_textures.append(texture)
109
110 # Load textures for climbing
111 self.climbing_textures = []
112 texture = arcade.load_texture(f"{main_path}_climb0.png")
113 self.climbing_textures.append(texture)
114 texture = arcade.load_texture(f"{main_path}_climb1.png")
115 self.climbing_textures.append(texture)
116
117 # Set the initial texture
118 self.texture = self.idle_texture_pair[0]
119
120 # Default to face-right
121 self.character_face_direction = RIGHT_FACING
122
123 # Index of our current texture
124 self.cur_texture = 0
125
126 # How far have we traveled horizontally since changing the texture
127 self.x_odometer = 0
128 self.y_odometer = 0
129
130 self.ladder_list = ladder_list
131 self.is_on_ladder = False
132
133 def pymunk_moved(self, physics_engine, dx, dy, d_angle):
134 """ Handle being moved by the pymunk engine """
135 # Figure out if we need to face left or right
136 if dx < -DEAD_ZONE and self.character_face_direction == RIGHT_FACING:
137 self.character_face_direction = LEFT_FACING
138 elif dx > DEAD_ZONE and self.character_face_direction == LEFT_FACING:
139 self.character_face_direction = RIGHT_FACING
140
141 # Are we on the ground?
142 is_on_ground = physics_engine.is_on_ground(self)
143
144 # Are we on a ladder?
145 if len(arcade.check_for_collision_with_list(self, self.ladder_list)) > 0:
146 if not self.is_on_ladder:
147 self.is_on_ladder = True
148 self.pymunk.gravity = (0, 0)
149 self.pymunk.damping = 0.0001
150 self.pymunk.max_vertical_velocity = PLAYER_MAX_HORIZONTAL_SPEED
151 else:
152 if self.is_on_ladder:
153 self.pymunk.damping = 1.0
154 self.pymunk.max_vertical_velocity = PLAYER_MAX_VERTICAL_SPEED
155 self.is_on_ladder = False
156 self.pymunk.gravity = None
157
158 # Add to the odometer how far we've moved
159 self.x_odometer += dx
160 self.y_odometer += dy
161
162 if self.is_on_ladder and not is_on_ground:
163 # Have we moved far enough to change the texture?
164 if abs(self.y_odometer) > DISTANCE_TO_CHANGE_TEXTURE:
165
166 # Reset the odometer
167 self.y_odometer = 0
168
169 # Advance the walking animation
170 self.cur_texture += 1
171
172 if self.cur_texture > 1:
173 self.cur_texture = 0
174 self.texture = self.climbing_textures[self.cur_texture]
175 return
176
177 # Jumping animation
178 if not is_on_ground:
179 if dy > DEAD_ZONE:
180 self.texture = self.jump_texture_pair[self.character_face_direction]
181 return
182 elif dy < -DEAD_ZONE:
183 self.texture = self.fall_texture_pair[self.character_face_direction]
184 return
185
186 # Idle animation
187 if abs(dx) <= DEAD_ZONE:
188 self.texture = self.idle_texture_pair[self.character_face_direction]
189 return
190
191 # Have we moved far enough to change the texture?
192 if abs(self.x_odometer) > DISTANCE_TO_CHANGE_TEXTURE:
193
194 # Reset the odometer
195 self.x_odometer = 0
196
197 # Advance the walking animation
198 self.cur_texture += 1
199 if self.cur_texture > 7:
200 self.cur_texture = 0
201 self.texture = self.walk_textures[self.cur_texture][self.character_face_direction]
202
203class BulletSprite(arcade.SpriteSolidColor):
204 """ Bullet Sprite """
205 def pymunk_moved(self, physics_engine, dx, dy, d_angle):
206 """ Handle when the sprite is moved by the physics engine. """
207 # If the bullet falls below the screen, remove it
208 if self.center_y < -100:
209 self.remove_from_sprite_lists()
210
211class GameWindow(arcade.Window):
212 """ Main Window """
213
214 def __init__(self, width, height, title):
215 """ Create the variables """
216
217 # Init the parent class
218 super().__init__(width, height, title)
219
220 # Player sprite
221 self.player_sprite: Optional[PlayerSprite] = None
222
223 # Sprite lists we need
224 self.player_list: Optional[arcade.SpriteList] = None
225 self.wall_list: Optional[arcade.SpriteList] = None
226 self.bullet_list: Optional[arcade.SpriteList] = None
227 self.item_list: Optional[arcade.SpriteList] = None
228 self.moving_sprites_list: Optional[arcade.SpriteList] = None
229 self.ladder_list: Optional[arcade.SpriteList] = None
230
231 # Track the current state of what key is pressed
232 self.left_pressed: bool = False
233 self.right_pressed: bool = False
234 self.up_pressed: bool = False
235 self.down_pressed: bool = False
236
237 # Physics engine
238 self.physics_engine: Optional[arcade.PymunkPhysicsEngine] = None
239
240 # Set background color
241 self.background_color = arcade.color.AMAZON
242
243 def setup(self):
244 """ Set up everything with the game """
245
246 # Create the sprite lists
247 self.player_list = arcade.SpriteList()
248 self.bullet_list = arcade.SpriteList()
249
250 # Map name
251 map_name = ":resources:/tiled_maps/pymunk_test_map.json"
252
253 # Load in TileMap
254 tile_map = arcade.load_tilemap(map_name, SPRITE_SCALING_TILES)
255
256 # Pull the sprite layers out of the tile map
257 self.wall_list = tile_map.sprite_lists["Platforms"]
258 self.item_list = tile_map.sprite_lists["Dynamic Items"]
259 self.ladder_list = tile_map.sprite_lists["Ladders"]
260 self.moving_sprites_list = tile_map.sprite_lists['Moving Platforms']
261
262 # Create player sprite
263 self.player_sprite = PlayerSprite(self.ladder_list, hit_box_algorithm=arcade.hitbox.algo_detailed)
264
265 # Set player location
266 grid_x = 1
267 grid_y = 1
268 self.player_sprite.center_x = SPRITE_SIZE * grid_x + SPRITE_SIZE / 2
269 self.player_sprite.center_y = SPRITE_SIZE * grid_y + SPRITE_SIZE / 2
270 # Add to player sprite list
271 self.player_list.append(self.player_sprite)
272
273 # --- Pymunk Physics Engine Setup ---
274
275 # The default damping for every object controls the percent of velocity
276 # the object will keep each second. A value of 1.0 is no speed loss,
277 # 0.9 is 10% per second, 0.1 is 90% per second.
278 # For top-down games, this is basically the friction for moving objects.
279 # For platformers with gravity, this should probably be set to 1.0.
280 # Default value is 1.0 if not specified.
281 damping = DEFAULT_DAMPING
282
283 # Set the gravity. (0, 0) is good for outer space and top-down.
284 gravity = (0, -GRAVITY)
285
286 # Create the physics engine
287 self.physics_engine = arcade.PymunkPhysicsEngine(damping=damping,
288 gravity=gravity)
289
290 def wall_hit_handler(bullet_sprite, _wall_sprite, _arbiter, _space, _data):
291 """ Called for bullet/wall collision """
292 bullet_sprite.remove_from_sprite_lists()
293
294 self.physics_engine.add_collision_handler("bullet", "wall", post_handler=wall_hit_handler)
295
296 def item_hit_handler(bullet_sprite, item_sprite, _arbiter, _space, _data):
297 """ Called for bullet/wall collision """
298 bullet_sprite.remove_from_sprite_lists()
299 item_sprite.remove_from_sprite_lists()
300
301 self.physics_engine.add_collision_handler("bullet", "item", post_handler=item_hit_handler)
302
303 # Add the player.
304 # For the player, we set the damping to a lower value, which increases
305 # the damping rate. This prevents the character from traveling too far
306 # after the player lets off the movement keys.
307 # Setting the moment of intertia to PymunkPhysicsEngine.MOMENT_INF prevents it from
308 # rotating.
309 # Friction normally goes between 0 (no friction) and 1.0 (high friction)
310 # Friction is between two objects in contact. It is important to remember
311 # in top-down games that friction moving along the 'floor' is controlled
312 # by damping.
313 self.physics_engine.add_sprite(self.player_sprite,
314 friction=PLAYER_FRICTION,
315 mass=PLAYER_MASS,
316 moment_of_inertia=arcade.PymunkPhysicsEngine.MOMENT_INF,
317 collision_type="player",
318 max_horizontal_velocity=PLAYER_MAX_HORIZONTAL_SPEED,
319 max_vertical_velocity=PLAYER_MAX_VERTICAL_SPEED)
320
321 # Create the walls.
322 # By setting the body type to PymunkPhysicsEngine.STATIC the walls can't
323 # move.
324 # Movable objects that respond to forces are PymunkPhysicsEngine.DYNAMIC
325 # PymunkPhysicsEngine.KINEMATIC objects will move, but are assumed to be
326 # repositioned by code and don't respond to physics forces.
327 # Dynamic is default.
328 self.physics_engine.add_sprite_list(self.wall_list,
329 friction=WALL_FRICTION,
330 collision_type="wall",
331 body_type=arcade.PymunkPhysicsEngine.STATIC)
332
333 # Create the items
334 self.physics_engine.add_sprite_list(self.item_list,
335 friction=DYNAMIC_ITEM_FRICTION,
336 collision_type="item")
337
338 # Add kinematic sprites
339 self.physics_engine.add_sprite_list(self.moving_sprites_list,
340 body_type=arcade.PymunkPhysicsEngine.KINEMATIC)
341
342 def on_key_press(self, key, modifiers):
343 """Called whenever a key is pressed. """
344
345 if key == arcade.key.LEFT:
346 self.left_pressed = True
347 elif key == arcade.key.RIGHT:
348 self.right_pressed = True
349 elif key == arcade.key.UP:
350 self.up_pressed = True
351 # find out if player is standing on ground, and not on a ladder
352 if self.physics_engine.is_on_ground(self.player_sprite) \
353 and not self.player_sprite.is_on_ladder:
354 # She is! Go ahead and jump
355 impulse = (0, PLAYER_JUMP_IMPULSE)
356 self.physics_engine.apply_impulse(self.player_sprite, impulse)
357 elif key == arcade.key.DOWN:
358 self.down_pressed = True
359
360 def on_key_release(self, key, modifiers):
361 """Called when the user releases a key. """
362
363 if key == arcade.key.LEFT:
364 self.left_pressed = False
365 elif key == arcade.key.RIGHT:
366 self.right_pressed = False
367 elif key == arcade.key.UP:
368 self.up_pressed = False
369 elif key == arcade.key.DOWN:
370 self.down_pressed = False
371
372 def on_mouse_press(self, x, y, button, modifiers):
373 """ Called whenever the mouse button is clicked. """
374
375 bullet = BulletSprite(width=20, height=5, color=arcade.color.DARK_YELLOW)
376 self.bullet_list.append(bullet)
377
378 # Position the bullet at the player's current location
379 start_x = self.player_sprite.center_x
380 start_y = self.player_sprite.center_y
381 bullet.position = self.player_sprite.position
382
383 # Get from the mouse the destination location for the bullet
384 # IMPORTANT! If you have a scrolling screen, you will also need
385 # to add in self.view_bottom and self.view_left.
386 dest_x = x
387 dest_y = y
388
389 # Do math to calculate how to get the bullet to the destination.
390 # Calculation the angle in radians between the start points
391 # and end points. This is the angle the bullet will travel.
392 x_diff = dest_x - start_x
393 y_diff = dest_y - start_y
394 angle = math.atan2(y_diff, x_diff)
395
396 # What is the 1/2 size of this sprite, so we can figure out how far
397 # away to spawn the bullet
398 size = max(self.player_sprite.width, self.player_sprite.height) / 2
399
400 # Use angle to to spawn bullet away from player in proper direction
401 bullet.center_x += size * math.cos(angle)
402 bullet.center_y += size * math.sin(angle)
403
404 # Set angle of bullet
405 bullet.angle = math.degrees(angle)
406
407 # Gravity to use for the bullet
408 # If we don't use custom gravity, bullet drops too fast, or we have
409 # to make it go too fast.
410 # Force is in relation to bullet's angle.
411 bullet_gravity = (0, -BULLET_GRAVITY)
412
413 # Add the sprite. This needs to be done AFTER setting the fields above.
414 self.physics_engine.add_sprite(bullet,
415 mass=BULLET_MASS,
416 damping=1.0,
417 friction=0.6,
418 collision_type="bullet",
419 gravity=bullet_gravity,
420 elasticity=0.9)
421
422 # Add force to bullet
423 force = (BULLET_MOVE_FORCE, 0)
424 self.physics_engine.apply_force(bullet, force)
425
426 def on_update(self, delta_time):
427 """ Movement and game logic """
428
429 is_on_ground = self.physics_engine.is_on_ground(self.player_sprite)
430 # Update player forces based on keys pressed
431 if self.left_pressed and not self.right_pressed:
432 # Create a force to the left. Apply it.
433 if is_on_ground or self.player_sprite.is_on_ladder:
434 force = (-PLAYER_MOVE_FORCE_ON_GROUND, 0)
435 else:
436 force = (-PLAYER_MOVE_FORCE_IN_AIR, 0)
437 self.physics_engine.apply_force(self.player_sprite, force)
438 # Set friction to zero for the player while moving
439 self.physics_engine.set_friction(self.player_sprite, 0)
440 elif self.right_pressed and not self.left_pressed:
441 # Create a force to the right. Apply it.
442 if is_on_ground or self.player_sprite.is_on_ladder:
443 force = (PLAYER_MOVE_FORCE_ON_GROUND, 0)
444 else:
445 force = (PLAYER_MOVE_FORCE_IN_AIR, 0)
446 self.physics_engine.apply_force(self.player_sprite, force)
447 # Set friction to zero for the player while moving
448 self.physics_engine.set_friction(self.player_sprite, 0)
449 elif self.up_pressed and not self.down_pressed:
450 # Create a force to the right. Apply it.
451 if self.player_sprite.is_on_ladder:
452 force = (0, PLAYER_MOVE_FORCE_ON_GROUND)
453 self.physics_engine.apply_force(self.player_sprite, force)
454 # Set friction to zero for the player while moving
455 self.physics_engine.set_friction(self.player_sprite, 0)
456 elif self.down_pressed and not self.up_pressed:
457 # Create a force to the right. Apply it.
458 if self.player_sprite.is_on_ladder:
459 force = (0, -PLAYER_MOVE_FORCE_ON_GROUND)
460 self.physics_engine.apply_force(self.player_sprite, force)
461 # Set friction to zero for the player while moving
462 self.physics_engine.set_friction(self.player_sprite, 0)
463
464 else:
465 # Player's feet are not moving. Therefore up the friction so we stop.
466 self.physics_engine.set_friction(self.player_sprite, 1.0)
467
468 # Move items in the physics engine
469 self.physics_engine.step()
470
471 # For each moving sprite, see if we've reached a boundary and need to
472 # reverse course.
473 for moving_sprite in self.moving_sprites_list:
474 if moving_sprite.boundary_right and \
475 moving_sprite.change_x > 0 and \
476 moving_sprite.right > moving_sprite.boundary_right:
477 moving_sprite.change_x *= -1
478 elif moving_sprite.boundary_left and \
479 moving_sprite.change_x < 0 and \
480 moving_sprite.left > moving_sprite.boundary_left:
481 moving_sprite.change_x *= -1
482 if moving_sprite.boundary_top and \
483 moving_sprite.change_y > 0 and \
484 moving_sprite.top > moving_sprite.boundary_top:
485 moving_sprite.change_y *= -1
486 elif moving_sprite.boundary_bottom and \
487 moving_sprite.change_y < 0 and \
488 moving_sprite.bottom < moving_sprite.boundary_bottom:
489 moving_sprite.change_y *= -1
490
491 # Figure out and set our moving platform velocity.
492 # Pymunk uses velocity is in pixels per second. If we instead have
493 # pixels per frame, we need to convert.
494 velocity = (moving_sprite.change_x * 1 / delta_time, moving_sprite.change_y * 1 / delta_time)
495 self.physics_engine.set_velocity(moving_sprite, velocity)
496
497 def on_draw(self):
498 """ Draw everything """
499 self.clear()
500 self.wall_list.draw()
501 self.ladder_list.draw()
502 self.moving_sprites_list.draw()
503 self.bullet_list.draw()
504 self.item_list.draw()
505 self.player_list.draw()
506
507 # for item in self.player_list:
508 # item.draw_hit_box(arcade.color.RED)
509 # for item in self.item_list:
510 # item.draw_hit_box(arcade.color.RED)
511
512def main():
513 """ Main function """
514 window = GameWindow(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE)
515 window.setup()
516 arcade.run()
517
518
519if __name__ == "__main__":
520 main()