PYMUNK_DEMO_PLATFORM_11.py完整列表#

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