❏ 站外平台：

为你的 Python 平台类游戏添加跳跃功能

作者： Seth Kenlon 译者： LCTT cycoe

| 2020-01-16 21:49      

在本期使用 Python Pygame 模块编写视频游戏中，学会如何使用跳跃来对抗重力。

在本系列的 前一篇文章 中，你已经模拟了重力。但现在，你需要赋予你的角色跳跃的能力来对抗重力。

跳跃是对重力作用的暂时延缓。在这一小段时间里，你是向上跳，而不是被重力拉着向下落。但你一旦到达了跳跃的最高点，重力就会重新发挥作用，将你拉回地面。

在代码中，这种变化被表示为变量。首先，你需要为玩家精灵建立一个变量，使得 Python 能够跟踪该精灵是否正在跳跃中。一旦玩家精灵开始跳跃，他就会再次受到重力的作用，并被拉回最近的物体。

设置跳跃状态变量

你需要为你的 Player 类添加两个新变量：

  • 一个是为了跟踪你的角色是否正在跳跃中，可通过你的玩家精灵是否站在坚实的地面来确定
  • 一个是为了将玩家带回地面

将如下两个变量添加到你的 Player 类中。在下方的代码中，注释前的部分用于提示上下文，因此只需要添加最后两行：

  1.                 self.movex = 0
  2.                 self.movey = 0
  3.                 self.frame = 0
  4.                 self.health = 10
  5.                 # 此处是重力相关变量
  6.                 self.collide_delta = 0
  7.                 self.jump_delta = 6

第一个变量 collide_delta 被设为 0 是因为在正常状态下，玩家精灵没有处在跳跃中的状态。另一个变量 jump_delta 被设为 6，是为了防止精灵在第一次进入游戏世界时就发生反弹（实际上就是跳跃）。当你完成了本篇文章的示例，尝试把该变量设为 0 看看会发生什么。

跳跃中的碰撞

如果你是跳到一个蹦床上，那你的跳跃一定非常优美。但是如果你是跳向一面墙会发生什么呢？（千万不要去尝试！）不管你的起跳多么令人印象深刻，当你撞到比你更大更硬的物体时，你都会立马停下。（LCTT 译注：原理参考动量守恒定律）

为了在你的视频游戏中模拟这一点，你需要在你的玩家精灵与地面等东西发生碰撞时，将 self.collide_delta 变量设为 0。如果你的 self.collide_delta 不是 0 而是其它的什么值，那么你的玩家就会发生跳跃，并且当你的玩家与墙或者地面发生碰撞时无法跳跃。

在你的 Player 类的 update 方法中，将地面碰撞相关代码块修改为如下所示：

  1.         ground_hit_list = pygame.sprite.spritecollide(self, ground_list, False)
  2.         for g in ground_hit_list:
  3.             self.movey = 0
  4.             self.rect.y = worldy-ty-ty
  5.             self.collide_delta = 0 # 停止跳跃
  6.             if self.rect.y > g.rect.y:
  7.                 self.health -=1
  8.                 print(self.health)

这段代码块检查了地面精灵和玩家精灵之间发生的碰撞。当发生碰撞时，它会将玩家 Y 方向的坐标值设置为游戏窗口的高度减去一个瓷砖的高度再减去另一个瓷砖的高度。以此保证了玩家精灵是站在地面上，而不是嵌在地面里。同时它也将 self.collide_delta 设为 0，使得程序能够知道玩家未处在跳跃中。除此之外，它将 self.movey 设为 0，使得程序能够知道玩家当前未受到重力的牵引作用（这是游戏物理引擎的奇怪之处，一旦玩家落地，也就没有必要继续将玩家拉向地面）。

此处 if 语句用来检测玩家是否已经落到地面之下，如果是，那就扣除一点生命值作为惩罚。此处假定了你希望当你的玩家落到地图之外时失去生命值。这个设定不是必需的，它只是平台类游戏的一种惯例。更有可能的是，你希望这个事件能够触发另一些事件，或者说是一种能够让你的现实世界玩家沉迷于让精灵掉到屏幕之外的东西。一种简单的恢复方式是在玩家精灵掉落到地图之外时，将 self.rect.y 重新设置为 0，这样它就会在地图上方重新生成，并落到坚实的地面上。

撞向地面

模拟的重力使你玩家的 Y 坐标不断增大（LCTT 译注：此处原文中为 0，但在 Pygame 中越靠下方 Y 坐标应越大）。要实现跳跃，完成如下代码使你的玩家精灵离开地面，飞向空中。

在你的 Player 类的 update 方法中，添加如下代码来暂时延缓重力的作用：

  1.         if self.collide_delta < 6 and self.jump_delta < 6:
  2.             self.jump_delta = 6*2
  3.             self.movey -= 33  # 跳跃的高度
  4.             self.collide_delta += 6
  5.             self.jump_delta    += 6

根据此代码所示，跳跃使玩家精灵向空中移动了 33 个像素。此处是负 33 是因为在 Pygame 中，越小的数代表距离屏幕顶端越近。

不过此事件视条件而定，只有当 self.collide_delta 小于 6（缺省值定义在你 Player 类的 init 方法中）并且 self.jump_delta 也于 6 的时候才会发生。此条件能够保证直到玩家碰到一个平台，才能触发另一次跳跃。换言之，它能够阻止空中二段跳。

在某些特殊条件下，你可能不想阻止空中二段跳，或者说你允许玩家进行空中二段跳。举个栗子，如果玩家获得了某个战利品，那么在他被敌人攻击到之前，都能够拥有空中二段跳的能力。

当你完成本篇文章中的示例，尝试将 self.collide_delta 和 self.jump_delta 设置为 0，从而获得百分之百的几率触发空中二段跳。

在平台上着陆

目前你已经定义了在玩家精灵摔落地面时的抵抗重力条件，但此时你的游戏代码仍保持平台与地面置于不同的列表中（就像本文中做的很多其他选择一样，这个设定并不是必需的，你可以尝试将地面作为另一种平台）。为了允许玩家精灵站在平台之上，你必须像检测地面碰撞一样，检测玩家精灵与平台精灵之间的碰撞。将如下代码放于你的 update 方法中：

  1.         plat_hit_list = pygame.sprite.spritecollide(self, plat_list, False)
  2.         for p in plat_hit_list:
  3.             self.collide_delta = 0 # 跳跃结束
  4.             self.movey = 0

但此处还有一点需要考虑：平台悬在空中，也就意味着玩家可以通过从上面或者从下面接触平台来与之互动。

确定平台如何与玩家互动取决于你，阻止玩家从下方到达平台也并不稀奇。将如下代码加到上方的代码块中，使得平台表现得像天花板或者说是藤架。只有在玩家精灵跳得比平台上沿更高时才能跳到平台上，但会阻止玩家从平台下方跳上来：

  1.             if self.rect.y > p.rect.y:
  2.                 self.rect.y = p.rect.y+ty
  3.             else:
  4.                 self.rect.y = p.rect.y-ty

此处 if 语句代码块的第一个子句阻止玩家精灵从平台正下方跳到平台上。如果它检测到玩家精灵的坐标比平台更大（在 Pygame 中，坐标更大意味着在屏幕的更下方），那么将玩家精灵新的 Y 坐标设置为当前平台的 Y 坐标加上一个瓷砖的高度。实际效果就是保证玩家精灵距离平台一个瓷砖的高度，防止其从下方穿过平台。

else 子句做了相反的事情。当程序运行到此处时，如果玩家精灵的 Y 坐标不比平台的更大，意味着玩家精灵是从空中落下（不论是由于玩家刚刚从此处生成，或者是玩家执行了跳跃）。在这种情况下，玩家精灵的 Y 坐标被设为平台的 Y 坐标减去一个瓷砖的高度（切记，在 Pygame 中更小的 Y 坐标代表在屏幕上的更高处）。这样就能保证玩家在平台上，除非他从平台上跳下来或者走下来。

你也可以尝试其他的方式来处理玩家与平台之间的互动。举个栗子，也许玩家精灵被设定为处在平台的“前面”，他能够无障碍地跳跃穿过平台并站在上面。或者你可以设计一种平台会减缓而又不完全阻止玩家的跳跃过程。甚至你可以通过将不同平台分到不同列表中来混合搭配使用。

触发一次跳跃

目前为此，你的代码已经模拟了所有必需的跳跃条件，但仍缺少一个跳跃触发器。你的玩家精灵的 self.jump_delta 初始值被设置为 6，只有当它比 6 小的时候才会触发更新跳跃的代码。

为跳跃变量设置一个新的设置方法，在你的 Player 类中创建一个 jump 方法，并将 self.jump_delta 设为小于 6 的值。通过使玩家精灵向空中移动 33 个像素，来暂时减缓重力的作用。

  1.     def jump(self,platform_list):
  2.         self.jump_delta = 0

不管你相信与否，这就是 jump 方法的全部。剩余的部分在 update 方法中，你已经在前面实现了相关代码。

要使你游戏中的跳跃功能生效，还有最后一件事情要做。如果你想不起来是什么，运行游戏并观察跳跃是如何生效的。

问题就在于你的主循环中没有调用 jump 方法。先前你已经为该方法创建了一个按键占位符，现在，跳跃键所做的就是将 jump 打印到终端。

调用 jump 方法

在你的主循环中，将上方向键的效果从打印一条调试语句，改为调用 jump 方法。

注意此处，与 update 方法类似，jump 方法也需要检测碰撞，因此你需要告诉它使用哪个 plat_list。

  1.             if event.key == pygame.K_UP or event.key == ord('w'):
  2.                 player.jump(plat_list)

如果你倾向于使用空格键作为跳跃键，使用 pygame.K_SPACE 替代 pygame.K_UP 作为按键。另一种选择，你可以同时使用两种方式（使用单独的 if 语句），给玩家多一种选择。

现在来尝试你的游戏吧！在下一篇文章中，你将让你的游戏卷动起来。

Pygame 平台类游戏

Pygame 平台类游戏

以下是目前为止的所有代码：

  1. #!/usr/bin/env python3
  2. # draw a world
  3. # add a player and player control
  4. # add player movement
  5. # add enemy and basic collision
  6. # add platform
  7. # add gravity
  8. # add jumping
  10. # GNU All-Permissive License
  11. # Copying and distribution of this file, with or without modification,
  12. # are permitted in any medium without royalty provided the copyright
  13. # notice and this notice are preserved.  This file is offered as-is,
  14. # without any warranty.
  16. import pygame
  17. import sys
  18. import os
  20. '''
  21. Objects
  22. '''
  24. class Platform(pygame.sprite.Sprite):
  25.     # x 坐标，y 坐标，图像宽度，图像高度，图像文件
  26.     def __init__(self,xloc,yloc,imgw,imgh,img):
  27.         pygame.sprite.Sprite.__init__(self)
  28.         self.image = pygame.image.load(os.path.join('images',img)).convert()
  29.         self.image.convert_alpha()
  30.         self.rect = self.image.get_rect()
  31.         self.rect.y = yloc
  32.         self.rect.x = xloc
  34. class Player(pygame.sprite.Sprite):
  35.     '''
  36.     生成一个玩家
  37.     '''
  38.     def __init__(self):
  39.         pygame.sprite.Sprite.__init__(self)
  40.         self.movex = 0
  41.         self.movey = 0
  42.         self.frame = 0
  43.         self.health = 10
  44.         self.collide_delta = 0
  45.         self.jump_delta = 6
  46.         self.score = 1
  47.         self.images = []
  48.         for i in range(1,9):
  49.             img = pygame.image.load(os.path.join('images','hero' + str(i) + '.png')).convert()
  50.             img.convert_alpha()
  51.             img.set_colorkey(ALPHA)
  52.             self.images.append(img)
  53.             self.image = self.images[0]
  54.             self.rect  = self.image.get_rect()
  56.     def jump(self,platform_list):
  57.         self.jump_delta = 0
  59.     def gravity(self):
  60.         self.movey += 3.2 # how fast player falls
  61.        
  62.         if self.rect.y > worldy and self.movey >= 0:
  63.             self.movey = 0
  64.             self.rect.y = worldy-ty
  65.        
  66.     def control(self,x,y):
  67.         '''
  68.         控制玩家移动
  69.         '''
  70.         self.movex += x
  71.         self.movey += y
  72.        
  73.     def update(self):
  74.         '''
  75.         更新精灵位置
  76.         '''
  77.        
  78.         self.rect.x = self.rect.x + self.movex
  79.         self.rect.y = self.rect.y + self.movey
  81.         # 向左移动
  82.         if self.movex < 0:
  83.             self.frame += 1
  84.             if self.frame > ani*3:
  85.                 self.frame = 0
  86.             self.image = self.images[self.frame//ani]
  88.         # 向右移动
  89.         if self.movex > 0:
  90.             self.frame += 1
  91.             if self.frame > ani*3:
  92.                 self.frame = 0
  93.             self.image = self.images[(self.frame//ani)+4]
  95.         # 碰撞
  96.         enemy_hit_list = pygame.sprite.spritecollide(self, enemy_list, False)
  97.         for enemy in enemy_hit_list:
  98.             self.health -= 1
  99.             #print(self.health)
  101.         plat_hit_list = pygame.sprite.spritecollide(self, plat_list, False)
  102.         for p in plat_hit_list:
  103.             self.collide_delta = 0 # stop jumping
  104.             self.movey = 0
  105.             if self.rect.y > p.rect.y:
  106.                 self.rect.y = p.rect.y+ty
  107.             else:
  108.                 self.rect.y = p.rect.y-ty
  109.            
  110.         ground_hit_list = pygame.sprite.spritecollide(self, ground_list, False)
  111.         for g in ground_hit_list:
  112.             self.movey = 0
  113.             self.rect.y = worldy-ty-ty
  114.             self.collide_delta = 0 # stop jumping
  115.             if self.rect.y > g.rect.y:
  116.                 self.health -=1
  117.                 print(self.health)
  118.                
  119.         if self.collide_delta < 6 and self.jump_delta < 6:
  120.             self.jump_delta = 6*2
  121.             self.movey -= 33  # how high to jump
  122.             self.collide_delta += 6
  123.             self.jump_delta    += 6
  124.            
  125. class Enemy(pygame.sprite.Sprite):
  126.     '''
  127.     生成一个敌人
  128.     '''
  129.     def __init__(self,x,y,img):
  130.         pygame.sprite.Sprite.__init__(self)
  131.         self.image = pygame.image.load(os.path.join('images',img))
  132.         self.movey = 0
  133.         #self.image.convert_alpha()
  134.         #self.image.set_colorkey(ALPHA)
  135.         self.rect = self.image.get_rect()
  136.         self.rect.x = x
  137.         self.rect.y = y
  138.         self.counter = 0
  140.                
  141.     def move(self):
  142.         '''
  143.         敌人移动
  144.         '''
  145.         distance = 80
  146.         speed = 8
  148.         self.movey += 3.2
  149.        
  150.         if self.counter >= 0 and self.counter <= distance:
  151.             self.rect.x += speed
  152.         elif self.counter >= distance and self.counter <= distance*2:
  153.             self.rect.x -= speed
  154.         else:
  155.             self.counter = 0
  156.        
  157.         self.counter += 1
  159.         if not self.rect.y >= worldy-ty-ty:
  160.             self.rect.y += self.movey
  162.         plat_hit_list = pygame.sprite.spritecollide(self, plat_list, False)
  163.         for p in plat_hit_list:
  164.             self.movey = 0
  165.             if self.rect.y > p.rect.y:
  166.                 self.rect.y = p.rect.y+ty
  167.             else:
  168.                 self.rect.y = p.rect.y-ty
  170.         ground_hit_list = pygame.sprite.spritecollide(self, ground_list, False)
  171.         for g in ground_hit_list:
  172.             self.rect.y = worldy-ty-ty
  174.        
  175. class Level():
  176.     def bad(lvl,eloc):
  177.         if lvl == 1:
  178.             enemy = Enemy(eloc[0],eloc[1],'yeti.png') # 生成敌人
  179.             enemy_list = pygame.sprite.Group() # 创建敌人组
  180.             enemy_list.add(enemy)              # 将敌人添加到敌人组
  181.            
  182.         if lvl == 2:
  183.             print("Level " + str(lvl) )
  185.         return enemy_list
  187.     def loot(lvl,lloc):
  188.         print(lvl)
  190.     def ground(lvl,gloc,tx,ty):
  191.         ground_list = pygame.sprite.Group()
  192.         i=0
  193.         if lvl == 1:
  194.             while i < len(gloc):
  195.                 ground = Platform(gloc[i],worldy-ty,tx,ty,'ground.png')
  196.                 ground_list.add(ground)
  197.                 i=i+1
  199.         if lvl == 2:
  200.             print("Level " + str(lvl) )
  202.         return ground_list
  204.     def platform(lvl,tx,ty):
  205.         plat_list = pygame.sprite.Group()
  206.         ploc = []
  207.         i=0
  208.         if lvl == 1:
  209.             ploc.append((0,worldy-ty-128,3))
  210.             ploc.append((300,worldy-ty-256,3))
  211.             ploc.append((500,worldy-ty-128,4))
  213.             while i < len(ploc):
  214.                 j=0
  215.                 while j <= ploc[i][2]:
  216.                     plat = Platform((ploc[i][0]+(j*tx)),ploc[i][1],tx,ty,'ground.png')
  217.                     plat_list.add(plat)
  218.                     j=j+1
  219.                 print('run' + str(i) + str(ploc[i]))
  220.                 i=i+1
  222.         if lvl == 2:
  223.             print("Level " + str(lvl) )
  225.         return plat_list
  227. '''
  228. Setup
  229. '''
  230. worldx = 960
  231. worldy = 720
  233. fps = 40 # 帧率
  234. ani = 4  # 动画循环
  235. clock = pygame.time.Clock()
  236. pygame.init()
  237. main = True
  239. BLUE  = (25,25,200)
  240. BLACK = (23,23,23 )
  241. WHITE = (254,254,254)
  242. ALPHA = (0,255,0)
  244. world = pygame.display.set_mode([worldx,worldy])
  245. backdrop = pygame.image.load(os.path.join('images','stage.png')).convert()
  246. backdropbox = world.get_rect()
  247. player = Player() # 生成玩家
  248. player.rect.x = 0
  249. player.rect.y = 0
  250. player_list = pygame.sprite.Group()
  251. player_list.add(player)
  252. steps = 10 # how fast to move
  253. jump = -24
  255. eloc = []
  256. eloc = [200,20]
  257. gloc = []
  258. #gloc = [0,630,64,630,128,630,192,630,256,630,320,630,384,630]
  259. tx = 64 # 瓷砖尺寸
  260. ty = 64 # 瓷砖尺寸
  262. i=0
  263. while i <= (worldx/tx)+tx:
  264.     gloc.append(i*tx)
  265.     i=i+1
  267. enemy_list = Level.bad( 1, eloc )
  268. ground_list = Level.ground( 1,gloc,tx,ty )
  269. plat_list = Level.platform( 1,tx,ty )
  271. '''
  272. 主循环
  273. '''
  274. while main == True:
  275.     for event in pygame.event.get():
  276.         if event.type == pygame.QUIT:
  277.             pygame.quit(); sys.exit()
  278.             main = False
  280.         if event.type == pygame.KEYDOWN:
  281.             if event.key == pygame.K_LEFT or event.key == ord('a'):
  282.                 print("LEFT")
  283.                 player.control(-steps,0)
  284.             if event.key == pygame.K_RIGHT or event.key == ord('d'):
  285.                 print("RIGHT")
  286.                 player.control(steps,0)
  287.             if event.key == pygame.K_UP or event.key == ord('w'):
  288.                 print('jump')
  290.         if event.type == pygame.KEYUP:
  291.             if event.key == pygame.K_LEFT or event.key == ord('a'):
  292.                 player.control(steps,0)
  293.             if event.key == pygame.K_RIGHT or event.key == ord('d'):
  294.                 player.control(-steps,0)
  295.             if event.key == pygame.K_UP or event.key == ord('w'):
  296.                 player.jump(plat_list)
  298.             if event.key == ord('q'):
  299.                 pygame.quit()
  300.                 sys.exit()
  301.                 main = False
  303. #    world.fill(BLACK)
  304.     world.blit(backdrop, backdropbox)
  305.     player.gravity() # 检查重力
  306.     player.update()
  307.     player_list.draw(world) # 刷新玩家位置
  308.     enemy_list.draw(world)  # 刷新敌人
  309.     ground_list.draw(world)  # 刷新地面
  310.     plat_list.draw(world)   # 刷新平台
  311.     for e in enemy_list:
  312.         e.move()
  313.     pygame.display.flip()
  314.     clock.tick(fps)

本期是使用 Pygame 模块在 Python 3 中创建视频游戏连载系列的第 7 期。往期文章为：

via: https://opensource.com/article/19/12/jumping-python-platformer-game

作者：Seth Kenlon 选题：lujun9972 译者：cycoe 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出



最新评论

从 2025.1.15 起，不再提供评论功能
LCTT 译者
cycoe 🌟🌟🌟
共计翻译： 16.0 篇 | 共计贡献： 1136 天
贡献时间：2017-03-08 -> 2020-04-16
访问我的 LCTT 主页 | 在 GitHub 上关注我


返回顶部

分享到微信

打开微信，点击顶部的“╋”，
使用“扫一扫”将网页分享至微信。