pymunk_demo_platformer_11.py Full Listing
pymunk_demo_platformer_11.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 """ Init """
82 # Let parent initialize
83 super().__init__(scale=SPRITE_SCALING_PLAYER)
84
85 # Images from Kenney.nl's Character pack
86 # main_path = ":resources:images/animated_characters/female_adventurer/femaleAdventurer"
87 main_path = ":resources:images/animated_characters/female_person/femalePerson"
88 # main_path = ":resources:images/animated_characters/male_person/malePerson"
89 # main_path = ":resources:images/animated_characters/male_adventurer/maleAdventurer"
90 # main_path = ":resources:images/animated_characters/zombie/zombie"
91 # main_path = ":resources:images/animated_characters/robot/robot"
92
93 # Load textures for idle, jump, and fall states
94 idle_texture = arcade.load_texture(f"{main_path}_idle.png")
95 jump_texture = arcade.load_texture(f"{main_path}_jump.png")
96 fall_texture = arcade.load_texture(f"{main_path}_fall.png")
97 # Make pairs of textures facing left and right
98 self.idle_texture_pair = idle_texture, idle_texture.flip_left_right()
99 self.jump_texture_pair = jump_texture, jump_texture.flip_left_right()
100 self.fall_texture_pair = fall_texture, fall_texture.flip_left_right()
101
102 # Load textures for walking and make pairs of textures facing left and right
103 self.walk_textures = []
104 for i in range(8):
105 texture = arcade.load_texture(f"{main_path}_walk{i}.png")
106 self.walk_textures.append((texture, texture.flip_left_right()))
107
108 # Set the initial texture
109 self.texture = self.idle_texture_pair[0]
110
111 # Default to face-right
112 self.character_face_direction = RIGHT_FACING
113
114 # Index of our current texture
115 self.cur_texture = 0
116
117 # How far have we traveled horizontally since changing the texture
118 self.x_odometer = 0
119
120 def pymunk_moved(self, physics_engine, dx, dy, d_angle):
121 """ Handle being moved by the pymunk engine """
122 # Figure out if we need to face left or right
123 if dx < -DEAD_ZONE and self.character_face_direction == RIGHT_FACING:
124 self.character_face_direction = LEFT_FACING
125 elif dx > DEAD_ZONE and self.character_face_direction == LEFT_FACING:
126 self.character_face_direction = RIGHT_FACING
127
128 # Are we on the ground?
129 is_on_ground = physics_engine.is_on_ground(self)
130
131 # Add to the odometer how far we've moved
132 self.x_odometer += dx
133
134 # Jumping animation
135 if not is_on_ground:
136 if dy > DEAD_ZONE:
137 self.texture = self.jump_texture_pair[self.character_face_direction]
138 return
139 elif dy < -DEAD_ZONE:
140 self.texture = self.fall_texture_pair[self.character_face_direction]
141 return
142
143 # Idle animation
144 if abs(dx) <= DEAD_ZONE:
145 self.texture = self.idle_texture_pair[self.character_face_direction]
146 return
147
148 # Have we moved far enough to change the texture?
149 if abs(self.x_odometer) > DISTANCE_TO_CHANGE_TEXTURE:
150
151 # Reset the odometer
152 self.x_odometer = 0
153
154 # Advance the walking animation
155 self.cur_texture += 1
156 if self.cur_texture > 7:
157 self.cur_texture = 0
158 self.texture = self.walk_textures[self.cur_texture][self.character_face_direction]
159
160
161class BulletSprite(arcade.SpriteSolidColor):
162 """ Bullet Sprite """
163 def pymunk_moved(self, physics_engine, dx, dy, d_angle):
164 """ Handle when the sprite is moved by the physics engine. """
165 # If the bullet falls below the screen, remove it
166 if self.center_y < -100:
167 self.remove_from_sprite_lists()
168
169
170class GameWindow(arcade.Window):
171 """ Main Window """
172
173 def __init__(self, width, height, title):
174 """ Create the variables """
175
176 # Init the parent class
177 super().__init__(width, height, title)
178
179 # Player sprite
180 self.player_sprite: Optional[PlayerSprite] = None
181
182 # Sprite lists we need
183 self.player_list: Optional[arcade.SpriteList] = None
184 self.wall_list: Optional[arcade.SpriteList] = None
185 self.bullet_list: Optional[arcade.SpriteList] = None
186 self.item_list: Optional[arcade.SpriteList] = None
187 self.moving_sprites_list: Optional[arcade.SpriteList] = None
188
189 # Track the current state of what key is pressed
190 self.left_pressed: bool = False
191 self.right_pressed: bool = False
192
193 # Physics engine
194 self.physics_engine = Optional[arcade.PymunkPhysicsEngine]
195
196 # Set background color
197 self.background_color = arcade.color.AMAZON
198
199 def setup(self):
200 """ Set up everything with the game """
201
202 # Create the sprite lists
203 self.player_list = arcade.SpriteList()
204 self.bullet_list = arcade.SpriteList()
205
206 # Map name
207 map_name = ":resources:/tiled_maps/pymunk_test_map.json"
208
209 # Load in TileMap
210 tile_map = arcade.load_tilemap(map_name, SPRITE_SCALING_TILES)
211
212 # Pull the sprite layers out of the tile map
213 self.wall_list = tile_map.sprite_lists["Platforms"]
214 self.item_list = tile_map.sprite_lists["Dynamic Items"]
215
216 # Create player sprite
217 self.player_sprite = PlayerSprite()
218
219 # Set player location
220 grid_x = 1
221 grid_y = 1
222 self.player_sprite.center_x = SPRITE_SIZE * grid_x + SPRITE_SIZE / 2
223 self.player_sprite.center_y = SPRITE_SIZE * grid_y + SPRITE_SIZE / 2
224 # Add to player sprite list
225 self.player_list.append(self.player_sprite)
226
227 # Moving Sprite
228 self.moving_sprites_list = tile_map.sprite_lists['Moving Platforms']
229
230 # --- Pymunk Physics Engine Setup ---
231
232 # The default damping for every object controls the percent of velocity
233 # the object will keep each second. A value of 1.0 is no speed loss,
234 # 0.9 is 10% per second, 0.1 is 90% per second.
235 # For top-down games, this is basically the friction for moving objects.
236 # For platformers with gravity, this should probably be set to 1.0.
237 # Default value is 1.0 if not specified.
238 damping = DEFAULT_DAMPING
239
240 # Set the gravity. (0, 0) is good for outer space and top-down.
241 gravity = (0, -GRAVITY)
242
243 # Create the physics engine
244 self.physics_engine = arcade.PymunkPhysicsEngine(damping=damping,
245 gravity=gravity)
246
247 def wall_hit_handler(bullet_sprite, _wall_sprite, _arbiter, _space, _data):
248 """ Called for bullet/wall collision """
249 bullet_sprite.remove_from_sprite_lists()
250
251 self.physics_engine.add_collision_handler("bullet", "wall", post_handler=wall_hit_handler)
252
253 def item_hit_handler(bullet_sprite, item_sprite, _arbiter, _space, _data):
254 """ Called for bullet/wall collision """
255 bullet_sprite.remove_from_sprite_lists()
256 item_sprite.remove_from_sprite_lists()
257
258 self.physics_engine.add_collision_handler("bullet", "item", post_handler=item_hit_handler)
259
260 # Add the player.
261 # For the player, we set the damping to a lower value, which increases
262 # the damping rate. This prevents the character from traveling too far
263 # after the player lets off the movement keys.
264 # Setting the moment of inertia to PymunkPhysicsEngine.MOMENT_INF prevents it from
265 # rotating.
266 # Friction normally goes between 0 (no friction) and 1.0 (high friction)
267 # Friction is between two objects in contact. It is important to remember
268 # in top-down games that friction moving along the 'floor' is controlled
269 # by damping.
270 self.physics_engine.add_sprite(self.player_sprite,
271 friction=PLAYER_FRICTION,
272 mass=PLAYER_MASS,
273 moment_of_inertia=arcade.PymunkPhysicsEngine.MOMENT_INF,
274 collision_type="player",
275 max_horizontal_velocity=PLAYER_MAX_HORIZONTAL_SPEED,
276 max_vertical_velocity=PLAYER_MAX_VERTICAL_SPEED)
277
278 # Create the walls.
279 # By setting the body type to PymunkPhysicsEngine.STATIC the walls can't
280 # move.
281 # Movable objects that respond to forces are PymunkPhysicsEngine.DYNAMIC
282 # PymunkPhysicsEngine.KINEMATIC objects will move, but are assumed to be
283 # repositioned by code and don't respond to physics forces.
284 # Dynamic is default.
285 self.physics_engine.add_sprite_list(self.wall_list,
286 friction=WALL_FRICTION,
287 collision_type="wall",
288 body_type=arcade.PymunkPhysicsEngine.STATIC)
289
290 # Create the items
291 self.physics_engine.add_sprite_list(self.item_list,
292 friction=DYNAMIC_ITEM_FRICTION,
293 collision_type="item")
294
295 # Add kinematic sprites
296 self.physics_engine.add_sprite_list(self.moving_sprites_list,
297 body_type=arcade.PymunkPhysicsEngine.KINEMATIC)
298
299 def on_key_press(self, key, modifiers):
300 """Called whenever a key is pressed. """
301
302 if key == arcade.key.LEFT:
303 self.left_pressed = True
304 elif key == arcade.key.RIGHT:
305 self.right_pressed = True
306 elif key == arcade.key.UP:
307 # find out if player is standing on ground
308 if self.physics_engine.is_on_ground(self.player_sprite):
309 # She is! Go ahead and jump
310 impulse = (0, PLAYER_JUMP_IMPULSE)
311 self.physics_engine.apply_impulse(self.player_sprite, impulse)
312
313 def on_key_release(self, key, modifiers):
314 """Called when the user releases a key. """
315
316 if key == arcade.key.LEFT:
317 self.left_pressed = False
318 elif key == arcade.key.RIGHT:
319 self.right_pressed = False
320
321 def on_mouse_press(self, x, y, button, modifiers):
322 """ Called whenever the mouse button is clicked. """
323
324 bullet = BulletSprite(width=20, height=5, color=arcade.color.DARK_YELLOW)
325 self.bullet_list.append(bullet)
326
327 # Position the bullet at the player's current location
328 start_x = self.player_sprite.center_x
329 start_y = self.player_sprite.center_y
330 bullet.position = self.player_sprite.position
331
332 # Get from the mouse the destination location for the bullet
333 # IMPORTANT! If you have a scrolling screen, you will also need
334 # to add in self.view_bottom and self.view_left.
335 dest_x = x
336 dest_y = y
337
338 # Do math to calculate how to get the bullet to the destination.
339 # Calculation the angle in radians between the start points
340 # and end points. This is the angle the bullet will travel.
341 x_diff = dest_x - start_x
342 y_diff = dest_y - start_y
343 angle = math.atan2(y_diff, x_diff)
344
345 # What is the 1/2 size of this sprite, so we can figure out how far
346 # away to spawn the bullet
347 size = max(self.player_sprite.width, self.player_sprite.height) / 2
348
349 # Use angle to to spawn bullet away from player in proper direction
350 bullet.center_x += size * math.cos(angle)
351 bullet.center_y += size * math.sin(angle)
352
353 # Set angle of bullet
354 bullet.angle = math.degrees(angle)
355
356 # Gravity to use for the bullet
357 # If we don't use custom gravity, bullet drops too fast, or we have
358 # to make it go too fast.
359 # Force is in relation to bullet's angle.
360 bullet_gravity = (0, -BULLET_GRAVITY)
361
362 # Add the sprite. This needs to be done AFTER setting the fields above.
363 self.physics_engine.add_sprite(bullet,
364 mass=BULLET_MASS,
365 damping=1.0,
366 friction=0.6,
367 collision_type="bullet",
368 gravity=bullet_gravity,
369 elasticity=0.9)
370
371 # Add force to bullet
372 force = (BULLET_MOVE_FORCE, 0)
373 self.physics_engine.apply_force(bullet, force)
374
375 def on_update(self, delta_time):
376 """ Movement and game logic """
377
378 is_on_ground = self.physics_engine.is_on_ground(self.player_sprite)
379 # Update player forces based on keys pressed
380 if self.left_pressed and not self.right_pressed:
381 # Create a force to the left. Apply it.
382 if is_on_ground:
383 force = (-PLAYER_MOVE_FORCE_ON_GROUND, 0)
384 else:
385 force = (-PLAYER_MOVE_FORCE_IN_AIR, 0)
386 self.physics_engine.apply_force(self.player_sprite, force)
387 # Set friction to zero for the player while moving
388 self.physics_engine.set_friction(self.player_sprite, 0)
389 elif self.right_pressed and not self.left_pressed:
390 # Create a force to the right. Apply it.
391 if is_on_ground:
392 force = (PLAYER_MOVE_FORCE_ON_GROUND, 0)
393 else:
394 force = (PLAYER_MOVE_FORCE_IN_AIR, 0)
395 self.physics_engine.apply_force(self.player_sprite, force)
396 # Set friction to zero for the player while moving
397 self.physics_engine.set_friction(self.player_sprite, 0)
398 else:
399 # Player's feet are not moving. Therefore up the friction so we stop.
400 self.physics_engine.set_friction(self.player_sprite, 1.0)
401
402 # Move items in the physics engine
403 self.physics_engine.step()
404
405 # For each moving sprite, see if we've reached a boundary and need to
406 # reverse course.
407 for moving_sprite in self.moving_sprites_list:
408 if moving_sprite.boundary_right and \
409 moving_sprite.change_x > 0 and \
410 moving_sprite.right > moving_sprite.boundary_right:
411 moving_sprite.change_x *= -1
412 elif moving_sprite.boundary_left and \
413 moving_sprite.change_x < 0 and \
414 moving_sprite.left > moving_sprite.boundary_left:
415 moving_sprite.change_x *= -1
416 if moving_sprite.boundary_top and \
417 moving_sprite.change_y > 0 and \
418 moving_sprite.top > moving_sprite.boundary_top:
419 moving_sprite.change_y *= -1
420 elif moving_sprite.boundary_bottom and \
421 moving_sprite.change_y < 0 and \
422 moving_sprite.bottom < moving_sprite.boundary_bottom:
423 moving_sprite.change_y *= -1
424
425 # Figure out and set our moving platform velocity.
426 # Pymunk uses velocity is in pixels per second. If we instead have
427 # pixels per frame, we need to convert.
428 velocity = (moving_sprite.change_x * 1 / delta_time, moving_sprite.change_y * 1 / delta_time)
429 self.physics_engine.set_velocity(moving_sprite, velocity)
430
431 def on_draw(self):
432 """ Draw everything """
433 self.clear()
434 self.wall_list.draw()
435 self.moving_sprites_list.draw()
436 self.bullet_list.draw()
437 self.item_list.draw()
438 self.player_list.draw()
439
440def main():
441 """ Main function """
442 window = GameWindow(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE)
443 window.setup()
444 arcade.run()
445
446
447if __name__ == "__main__":
448 main()