在你的Python平台类游戏中放一些奖励

这部分是关于在使用 Python 的 Pygame 模块开发的视频游戏总给你的玩家提供收集的宝物和经验值的内容。

从网站建设到定制行业解决方案，为提供做网站、成都网站设计服务体系，各种行业企业客户提供网站建设解决方案，助力业务快速发展。创新互联将不断加快创新步伐，提供优质的建站服务。

这是正在进行的关于使用 Python 3 的 Pygame 模块创建视频游戏的系列文章的第十部分。以前的文章有:

  • 通过构建一个简单的掷骰子游戏去学习怎么用 Python 编程
  • 使用 Python 和 Pygame 模块构建一个游戏框架
  • 如何在你的 Python 游戏中添加一个玩家
  • 用 Pygame 使你的游戏角色移动起来
  • 如何向你的 Python 游戏中添加一个敌人
  • 在 Pygame 游戏中放置平台
  • 在你的 Python 游戏中模拟引力
  • 为你的 Python 平台类游戏添加跳跃功能
  • 使你的 Python 游戏玩家能够向前和向后跑

如果你已经阅读了本系列的前几篇文章，那么你已经了解了编写游戏的所有基础知识。现在你可以在这些基础上，创造一个全功能的游戏。当你第一次学习时，遵循本系列代码示例，这样的“用例”是有帮助的，但是，用例也会约束你。现在是时候运用你学到的知识，以新的方式应用它们了。

如果说，说起来容易做起来难，这篇文章展示了一个如何将你已经了解的内容用于新目的的例子中。具体来说，就是它涵盖了如何使用你以前的课程中已经了解到的来实现奖励系统。

在大多数电子游戏中，你有机会在游戏世界中获得“奖励”或收集到宝物和其他物品。奖励通常会增加你的分数或者你的生命值，或者为你的下一次任务提供信息。

游戏中包含的奖励类似于编程平台。像平台一样，奖励没有用户控制，随着游戏世界的滚动进行，并且必须检查与玩家的碰撞。

创建奖励函数

奖励和平台非常相似，你甚至不需要一个奖励的类。你可以重用 Platform 类，并将结果称为“奖励”。

由于奖励类型和位置可能因关卡不同而不同，如果你还没有，请在你的 Level 中创建一个名为 loot 的新函数。因为奖励物品不是平台，你也必须创建一个新的 loot_list 组，然后添加奖励物品。与平台、地面和敌人一样，该组用于检查玩家碰撞:

 
 
 
 
    
  
  
  
  
  1.  def loot(lvl,lloc):
    2. 
  
  
  
  
  2.  if lvl == 1:
    3. 
  
  
  
  
  3.  loot_list = pygame.sprite.Group()
    4. 
  
  
  
  
  4.  loot = Platform(300,ty*7,tx,ty, 'loot_1.png')
    5. 
  
  
  
  
  5.  loot_list.add(loot)
    6. 
  
  
  
  
  6. 
  
  
  
  
  7.  if lvl == 2:
    8. 
  
  
  
  
  8.  print(lvl)
    9. 
  
  
  
  
  9. 
  
  
  
  
  10.  return loot_list
    11.

你可以随意添加任意数量的奖励对象；记住把每一个都加到你的奖励清单上。Platform 类的参数是奖励图标的 X 位置、Y 位置、宽度和高度（通常让你的奖励精灵保持和所有其他方块一样的大小最为简单），以及你想要用作的奖励的图片。奖励的放置可以和贴图平台一样复杂，所以使用创建关卡时需要的关卡设计文档。

在脚本的设置部分调用新的奖励函数。在下面的代码中，前三行是上下文，所以只需添加第四行:

 
 
 
 
    
  
  
  
  
  1. enemy_list = Level.bad( 1, eloc )
    2. 
  
  
  
  
  2. ground_list = Level.ground( 1,gloc,tx,ty )
    3. 
  
  
  
  
  3. plat_list = Level.platform( 1,tx,ty )
    4. 
  
  
  
  
  4. loot_list = Level.loot(1,tx,ty)
    5.

正如你现在所知道的，除非你把它包含在你的主循环中，否则奖励不会被显示到屏幕上。将下面代码示例的最后一行添加到循环中:

 
 
 
 
    
  
  
  
  
  1.     enemy_list.draw(world)
    2. 
  
  
  
  
  2.     ground_list.draw(world)
    3. 
  
  
  
  
  3.     plat_list.draw(world)
    4. 
  
  
  
  
  4.     loot_list.draw(world)
    5.

启动你的游戏看看会发生什么。

Loot in Python platformer

你的奖励将会显示出来，但是当你的玩家碰到它们时，它们不会做任何事情，当你的玩家经过它们时，它们也不会滚动。接下来解决这些问题。

滚动奖励

像平台一样，当玩家在游戏世界中移动时，奖励必须滚动。逻辑与平台滚动相同。要向前滚动奖励物品，添加最后两行:

 
 
 
 
    
  
  
  
  
  1.         for e in enemy_list:
    2. 
  
  
  
  
  2.             e.rect.x -= scroll
    3. 
  
  
  
  
  3.         for l in loot_list:
    4. 
  
  
  
  
  4.             l.rect.x -= scroll
    5.

要向后滚动，请添加最后两行：

 
 
 
 
    
  
  
  
  
  1.         for e in enemy_list:
    2. 
  
  
  
  
  2.             e.rect.x += scroll
    3. 
  
  
  
  
  3.         for l in loot_list:
    4. 
  
  
  
  
  4.             l.rect.x += scroll
    5.

再次启动你的游戏，看看你的奖励物品现在表现得像在游戏世界里一样了，而不是仅仅画在上面。

检测碰撞

就像平台和敌人一样，你可以检查奖励物品和玩家之间的碰撞。逻辑与其他碰撞相同，除了撞击不会（必然）影响重力或生命值。取而代之的是，命中会导致奖励物品会消失并增加玩家的分数。

当你的玩家触摸到一个奖励对象时，你可以从 loot_list 中移除该对象。这意味着当你的主循环在 loot_list 中重绘所有奖励物品时，它不会重绘那个特定的对象，所以看起来玩家已经获得了奖励物品。

在 Player 类的 update 函数中的平台碰撞检测之上添加以下代码（最后一行仅用于上下文）：

 
 
 
 
    
  
  
  
  
  1.                 loot_hit_list = pygame.sprite.spritecollide(self, loot_list, False)
    2. 
  
  
  
  
  2.                 for loot in loot_hit_list:
    3. 
  
  
  
  
  3.                         loot_list.remove(loot)
    4. 
  
  
  
  
  4.                         self.score += 1
    5. 
  
  
  
  
  5.                 print(self.score)
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7.         plat_hit_list = pygame.sprite.spritecollide(self, plat_list, False)
    8.

当碰撞发生时，你不仅要把奖励从它的组中移除，还要给你的玩家一个分数提升。你还没有创建分数变量，所以请将它添加到你的玩家属性中，该属性是在 Player 类的 __init__ 函数中创建的。在下面的代码中，前两行是上下文，所以只需添加分数变量:

 
 
 
 
    
  
  
  
  
  1.         self.frame = 0
    2. 
  
  
  
  
  2.         self.health = 10
    3. 
  
  
  
  
  3.         self.score = 0
    4.

当在主循环中调用 update 函数时，需要包括 loot_list：

 
 
 
 
    
  
  
  
  
  1.         player.gravity()
    2. 
  
  
  
  
  2.         player.update()
    3.

如你所见，你已经掌握了所有的基本知识。你现在要做的就是用新的方式使用你所知道的。

在下一篇文章中还有一些提示，但是与此同时，用你学到的知识来制作一些简单的单关卡游戏。限制你试图创造的东西的范围是很重要的，这样你就不会埋没自己。这也使得最终的成品看起来和感觉上更容易完成。

以下是迄今为止你为这个 Python 平台编写的所有代码:

 
 
 
 
    
  
  
  
  
  1. #!/usr/bin/env python3
    2. 
  
  
  
  
  2. # draw a world
    3. 
  
  
  
  
  3. # add a player and player control
    4. 
  
  
  
  
  4. # add player movement
    5. 
  
  
  
  
  5. # add enemy and basic collision
    6. 
  
  
  
  
  6. # add platform
    7. 
  
  
  
  
  7. # add gravity
    8. 
  
  
  
  
  8. # add jumping
    9. 
  
  
  
  
  9. # add scrolling
    10. 
  
  
  
  
  10. 
  
  
  
  
  11. # GNU All-Permissive License
    12. 
  
  
  
  
  12. # Copying and distribution of this file, with or without modification,
    13. 
  
  
  
  
  13. # are permitted in any medium without royalty provided the copyright
    14. 
  
  
  
  
  14. # notice and this notice are preserved. This file is offered as-is,
    15. 
  
  
  
  
  15. # without any warranty.
    16. 
  
  
  
  
  16. 
  
  
  
  
  17. import pygame
    18. 
  
  
  
  
  18. import sys
    19. 
  
  
  
  
  19. import os
    20. 
  
  
  
  
  20. 
  
  
  
  
  21. '''
    22. 
  
  
  
  
  22. Objects
    23. 
  
  
  
  
  23. '''
    24. 
  
  
  
  
  24. 
  
  
  
  
  25. class Platform(pygame.sprite.Sprite):
    26. 
  
  
  
  
  26.  # x location, y location, img width, img height, img file 
    27. 
  
  
  
  
  27.  def __init__(self,xloc,yloc,imgw,imgh,img):
    28. 
  
  
  
  
  28.  pygame.sprite.Sprite.__init__(self)
    29. 
  
  
  
  
  29.  self.image = pygame.image.load(os.path.join('images',img)).convert()
    30. 
  
  
  
  
  30.  self.image.convert_alpha()
    31. 
  
  
  
  
  31.  self.rect = self.image.get_rect()
    32. 
  
  
  
  
  32.  self.rect.y = yloc
    33. 
  
  
  
  
  33.  self.rect.x = xloc
    34. 
  
  
  
  
  34. 
  
  
  
  
  35. class Player(pygame.sprite.Sprite):
    36. 
  
  
  
  
  36.  '''
    37. 
  
  
  
  
  37.  Spawn a player
    38. 
  
  
  
  
  38.  '''
    39. 
  
  
  
  
  39.  def __init__(self):
    40. 
  
  
  
  
  40.  pygame.sprite.Sprite.__init__(self)
    41. 
  
  
  
  
  41.  self.movex = 0
    42. 
  
  
  
  
  42.  self.movey = 0
    43. 
  
  
  
  
  43.  self.frame = 0
    44. 
  
  
  
  
  44.  self.health = 10
    45. 
  
  
  
  
  45.  self.collide_delta = 0
    46. 
  
  
  
  
  46.  self.jump_delta = 6
    47. 
  
  
  
  
  47.  self.score = 1
    48. 
  
  
  
  
  48.  self.images = []
    49. 
  
  
  
  
  49.  for i in range(1,9):
    50. 
  
  
  
  
  50.  img = pygame.image.load(os.path.join('images','hero' + str(i) + '.png')).convert()
    51. 
  
  
  
  
  51.  img.convert_alpha()
    52. 
  
  
  
  
  52.  img.set_colorkey(ALPHA)
    53. 
  
  
  
  
  53.  self.images.append(img)
    54. 
  
  
  
  
  54.  self.image = self.images[0]
    55. 
  
  
  
  
  55.  self.rect = self.image.get_rect()
    56. 
  
  
  
  
  56. 
  
  
  
  
  57.  def jump(self,platform_list):
    58. 
  
  
  
  
  58.  self.jump_delta = 0
    59. 
  
  
  
  
  59. 
  
  
  
  
  60.  def gravity(self):
    61. 
  
  
  
  
  61.  self.movey += 3.2 # how fast player falls
    62. 
  
  
  
  
  62.  
    63. 
  
  
  
  
  63.  if self.rect.y > worldy and self.movey >= 0:
    64. 
  
  
  
  
  64.  self.movey = 0
    65. 
  
  
  
  
  65.  self.rect.y = worldy-ty
    66. 
  
  
  
  
  66.  
    67. 
  
  
  
  
  67.  def control(self,x,y):
    68. 
  
  
  
  
  68.  '''
    69. 
  
  
  
  
  69.  control player movement
    70. 
  
  
  
  
  70.  '''
    71. 
  
  
  
  
  71.  self.movex += x
    72. 
  
  
  
  
  72.  self.movey += y
    73. 
  
  
  
  
  73.  
    74. 
  
  
  
  
  74.  def update(self):
    75. 
  
  
  
  
  75.  '''
    76. 
  
  
  
  
  76.  Update sprite position
    77. 
  
  
  
  
  77.  '''
    78. 
  
  
  
  
  78.  
    79. 
  
  
  
  
  79.  self.rect.x = self.rect.x + self.movex
    80. 
  
  
  
  
  80.  self.rect.y = self.rect.y + self.movey
    81. 
  
  
  
  
  81. 
  
  
  
  
  82.  # moving left
    83. 
  
  
  
  
  83.  if self.movex < 0:
    84. 
  
  
  
  
  84.  self.frame += 1
    85. 
  
  
  
  
  85.  if self.frame > ani*3:
    86. 
  
  
  
  
  86.  self.frame = 0
    87. 
  
  
  
  
  87.  self.image = self.images[self.frame//ani]
    88. 
  
  
  
  
  88. 
  
  
  
  
  89.  # moving right
    90. 
  
  
  
  
  90.  if self.movex > 0:
    91. 
  
  
  
  
  91.  self.frame += 1
    92. 
  
  
  
  
  92.  if self.frame > ani*3:
    93. 
  
  
  
  
  93.  self.frame = 0
    94. 
  
  
  
  
  94.  self.image = self.images[(self.frame//ani)+4]
    95. 
  
  
  
  
  95. 
  
  
  
  
  96.  # collisions
    97. 
  
  
  
  
  97.  enemy_hit_list = pygame.sprite.spritecollide(self, enemy_list, False)
    98. 
  
  
  
  
  98.  for enemy in enemy_hit_list:
    99. 
  
  
  
  
  99.  self.health -= 1
    100. 
  
  
  
  
  100.  #print(self.health)
    101. 
  
  
  
  
  101. 
  
  
  
  
  102.  loot_hit_list = pygame.sprite.spritecollide(self, loot_list, False)
    103. 
  
  
  
  
  103.  for loot in loot_hit_list:
    104. 
  
  
  
  
  104.  loot_list.remove(loot)
    105. 
  
  
  
  
  105.  self.score += 1
    106. 
  
  
  
  
  106.  print(self.score)
    107. 
  
  
  
  
  107. 
  
  
  
  
  108.  plat_hit_list = pygame.sprite.spritecollide(self, plat_list, False)
    109. 
  
  
  
  
  109.  for p in plat_hit_list:
    110. 
  
  
  
  
  110.  self.collide_delta = 0 # stop jumping
    111. 
  
  
  
  
  111.  self.movey = 0
    112. 
  
  
  
  
  112.  if self.rect.y > p.rect.y:
    113. 
  
  
  
  
  113.  self.rect.y = p.rect.y+ty
    114. 
  
  
  
  
  114.  else:
    115. 
  
  
  
  
  115.  self.rect.y = p.rect.y-ty
    116. 
  
  
  
  
  116.  
    117. 
  
  
  
  
  117.  ground_hit_list = pygame.sprite.spritecollide(self, ground_list, False)
    118. 
  
  
  
  
  118.  for g in ground_hit_list:
    119. 
  
  
  
  
  119.  self.movey = 0
    120. 
  
  
  
  
  120.  self.rect.y = worldy-ty-ty
    121. 
  
  
  
  
  121.  self.collide_delta = 0 # stop jumping
    122. 
  
  
  
  
  122.  if self.rect.y > g.rect.y:
    123. 
  
  
  
  
  123.  self.health -=1
    124. 
  
  
  
  
  124.  print(self.health)
    125. 
  
  
  
  
  125.  
    126. 
  
  
  
  
  126.  if self.collide_delta < 6 and self.jump_delta < 6:
    127. 
  
  
  
  
  127.  self.jump_delta = 6*2
    128. 
  
  
  
  
  128.  self.movey -= 33 # how high to jump
    129. 
  
  
  
  
  129.  self.collide_delta += 6
    130. 
  
  
  
  
  130.  self.jump_delta += 6
    131. 
  
  
  
  
  131.  
    132. 
  
  
  
  
  132. class Enemy(pygame.sprite.Sprite):
    133. 
  
  
  
  
  133.  '''
    134. 
  
  
  
  
  134.  Spawn an enemy
    135. 
  
  
  
  
  135.  '''
    136. 
  
  
  
  
  136.  def __init__(self,x,y,img):
    137. 
  
  
  
  
  137.  pygame.sprite.Sprite.__init__(self)
    138. 
  
  
  
  
  138.  self.image = pygame.image.load(os.path.join('images',img))
    139. 
  
  
  
  
  139.  self.movey = 0
    140. 
  
  
  
  
  140.  #self.image.convert_alpha()
    141. 
  
  
  
  
  141.  #self.image.set_colorkey(ALPHA)
    142. 
  
  
  
  
  142.  self.rect = self.image.get_rect()
    143. 
  
  
  
  
  143.  self.rect.x = x
    144. 
  
  
  
  
  144.  self.rect.y = y
    145. 
  
  
  
  
  145.  self.counter = 0
    146. 
  
  
  
  
  146. 
  
  
  
  
  147.  
    148. 
  
  
  
  
  148.  def move(self):
    149. 
  
  
  
  
  149.  '''
    150. 
  
  
  
  
  150.  enemy movement
    151. 
  
  
  
  
  151.  '''
    152. 
  
  
  
  
  152.  distance = 80
    153. 
  
  
  
  
  153.  speed = 8
    154. 
  
  
  
  
  154. 
  
  
  
  
  155.  self.movey += 3.2
    156. 
  
  
  
  
  156.  
    157. 
  
  
  
  
  157.  if self.counter >= 0 and self.counter <= distance:
    158. 
  
  
  
  
  158.  self.rect.x += speed
    159. 
  
  
  
  
  159.  elif self.counter >= distance and self.counter <= distance*2:
    160. 
  
  
  
  
  160.  self.rect.x -= speed
    161. 
  
  
  
  
  161.  else:
    162. 
  
  
  
  
  162.  self.counter = 0
    163. 
  
  
  
  
  163.  
    164. 
  
  
  
  
  164.  self.counter += 1
    165. 
  
  
  
  
  165. 
  
  
  
  
  166.  if not self.rect.y >= worldy-ty-ty:
    167. 
  
  
  
  
  167.  self.rect.y += self.movey
    168. 
  
  
  
  
  168. 
  
  
  
  
  169.  plat_hit_list = pygame.sprite.spritecollide(self, plat_list, False)
    170. 
  
  
  
  
  170.  for p in plat_hit_list:
    171. 
  
  
  
  
  171.  self.movey = 0
    172. 
  
  
  
  
  172.  if self.rect.y > p.rect.y:
    173. 
  
  
  
  
  173.  self.rect.y = p.rect.y+ty
    174. 
  
  
  
  
  174.  else:
    175. 
  
  
  
  
  175.  self.rect.y = p.rect.y-ty
    176. 
  
  
  
  
  176. 
  
  
  
  
  177.  ground_hit_list = pygame.sprite.spritecollide(self, ground_list, False)
    178. 
  
  
  
  
  178.  for g in ground_hit_list:
    179. 
  
  
  
  
  179.  self.rect.y = worldy-ty-ty
    180. 
  
  
  
  
  180. 
  
  
  
  
  181.  
    182. 
  
  
  
  
  182. class Level():
    183. 
  
  
  
  
  183.  def bad(lvl,eloc):
    184. 
  
  
  
  
  184.  if lvl == 1:
    185. 
  
  
  
  
  185.  enemy = Enemy(eloc[0],eloc[1],'yeti.png') # spawn enemy
    186. 
  
  
  
  
  186.  enemy_list = pygame.sprite.Group() # create enemy group
    187. 
  
  
  
  
  187.  enemy_list.add(enemy) # add enemy to group
    188. 
  
  
  
  
  188.  
    189. 
  
  
  
  
  189.  if lvl == 2:
    190. 
  
  
  
  
  190.  print("Level " + str(lvl) )
    191. 
  
  
  
  
  191. 
  
  
  
  
  192.  return enemy_list
    193. 
  
  
  
  
  193. 
  
  
  
  
  194.  def loot(lvl,tx,ty):
    195. 
  
  
  
  
  195.  if lvl == 1:
    196. 
  
  
  
  
  196.  loot_list = pygame.sprite.Group()
    197. 
  
  
  
  
  197.  loot = Platform(200,ty*7,tx,ty, 'loot_1.png')
    198. 
  
  
  
  
  198.  loot_list.add(loot)
    199. 
  
  
  
  
  199. 
  
  
  
  
  200.  if lvl == 2:
    201. 
  
  
  
  
  201.  print(lvl)
    202. 
  
  
  
  
  202. 
  
  
  
  
  203.  return loot_list
    204. 
  
  
  
  
  204. 
  
  
  
  
  205.  def ground(lvl,gloc,tx,ty):
    206. 
  
  
  
  
  206.  ground_list = pygame.sprite.Group()
    207. 
  
  
  
  
  207.  i=0
    208. 
  
  
  
  
  208.  if lvl == 1:
    209. 
  
  
  
  
  209.  while i < len(gloc):
    210. 
  
  
  
  
  210.  ground = Platform(gloc[i],worldy-ty,tx,ty,'ground.png')
    211. 
  
  
  
  
  211.  ground_list.add(ground)
    212. 
  
  
  
  
  212.  i=i+1
    213. 
  
  
  
  
  213. 
  
  
  
  
  214.  if lvl == 2:
    215. 
  
  
  
  
  215.  print("Level " + str(lvl) )
    216. 
  
  
  
  
  216. 
  
  
  
  
  217.  return ground_list
    218. 
  
  
  
  
  218. 
  
  
  
  
  219.  def platform(lvl,tx,ty):
    220. 
  
  
  
  
  220.  plat_list = pygame.sprite.Group()
    221. 
  
  
  
  
  221.  ploc = []
    222. 
  
  
  
  
  222.  i=0
    223. 
  
  
  
  
  223.  if lvl == 1:
    224. 
  
  
  
  
  224.  ploc.append((20,worldy-ty-128,3))
    225. 
  
  
  
  
  225.  ploc.append((300,worldy-ty-256,3))
    226. 
  
  
  
  
  226.  ploc.append((500,worldy-ty-128,4))
    227. 
  
  
  
  
  227. 
  
  
  
  
  228.  while i < len(ploc):
    229. 
  
  
  
  
  229.  j=0
    230. 
  
  
  
  
  230.  while j <= ploc[i][2]:
    231. 
  
  
  
  
  231.  plat = Platform((ploc[i][0]+(j*tx)),ploc[i][1],tx,ty,'ground.png')
    232. 
  
  
  
  
  232.  plat_list.add(plat)
    233. 
  
  
  
  
  233.  j=j+1
    234. 
  
  
  
  
  234.  print('run' + str(i) + str(ploc[i]))
    235. 
  
  
  
  
  235.  i=i+1
    236. 
  
  
  
  
  236. 
  
  
  
  
  237.  if lvl == 2:
    238. 
  
  
  
  
  238.  print("Level " + str(lvl) )
    239. 
  
  
  
  
  239. 
  
  
  
  
  240.  return plat_list
    241. 
  
  
  
  
  241. 
  
  
  
  
  242. '''
    243. 
  
  
  
  
  243. Setup
    244. 
  
  
  
  
  244. '''
    245. 
  
  
  
  
  245. worldx = 960
    246. 
  
  
  
  
  246. worldy = 720
    247. 
  
  
  
  
  247. 
  
  
  
  
  248. fps = 40 # frame rate
    249. 
  
  
  
  
  249. ani = 4 # animation cycles
    250. 
  
  
  
  
  250. clock = pygame.time.Clock()
    251. 
  
  
  
  
  251. pygame.init()
    252. 
  
  
  
  
  252. main = True
    253. 
  
  
  
  
  253. 
  
  
  
  
  254. BLUE = (25,25,200)
    255. 
  
  
  
  
  255. BLACK = (23,23,23 )
    256. 
  
  
  
  
  256. WHITE = (254,254,254)
    257. 
  
  
  
  
  257. ALPHA = (0,255,0)
    258. 
  
  
  
  
  258. 
  
  
  
  
  259. world = pygame.display.set_mode([worldx,worldy])
    260. 
  
  
  
  
  260. backdrop = pygame.image.load(os.path.join('images','stage.png')).convert()
    261. 
  
  
  
  
  261. backdropbox = world.get_rect()
    262. 
  
  
  
  
  262. player = Player() # spawn player
    263. 
  
  
  
  
  263. player.rect.x = 0
    264. 
  
  
  
  
  264. player.rect.y = 0
    265. 
  
  
  
  
  265. player_list = pygame.sprite.Group()
    266. 
  
  
  
  
  266. player_list.add(player)
    267. 
  
  
  
  
  267. steps = 10
    268. 
  
  
  
  
  268. forwardx = 600
    269. 
  
  
  
  
  269. backwardx = 230
    270. 
  
  
  
  
  270. 
  
  
  
  
  271. eloc = []
    272. 
  
  
  
  
  272. eloc = [200,20]
    273. 
  
  
  
  
  273. gloc = []
    274. 
  
  
  
  
  274. #gloc = [0,630,64,630,128,630,192,630,256,630,320,630,384,630]
    275. 
  
  
  
  
  275. tx = 64 #tile size
    276. 
  
  
  
  
  276. ty = 64 #tile size
    277. 
  
  
  
  
  277. 
  
  
  
  
  278. i=0
    279. 
  
  
  
  
  279. while i <= (worldx/tx)+tx:
    280. 
  
  
  
  
  280.  gloc.append(i*tx)
    281. 
  
  
  
  
  281.  i=i+1
    282. 
  
  
  
  
  282. 
  
  
  
  
  283. enemy_list = Level.bad( 1, eloc )
    284. 
  
  
  
  
  284. ground_list = Level.ground( 1,gloc,tx,ty )
    285. 
  
  
  
  
  285. plat_list = Level.platform( 1,tx,ty )
    286. 
  
  
  
  
  286. loot_list = Level.loot(1,tx,ty)
    287. 
  
  
  
  
  287. 
  
  
  
  
  288. '''
    289. 
  
  
  
  
  289. Main loop
    290. 
  
  
  
  
  290. '''
    291. 
  
  
  
  
  291. while main == True:
    292. 
  
  
  
  
  292.  for event in pygame.event.get():
    293. 
  
  
  
  
  293.  if event.type == pygame.QUIT:
    294. 
  
  
  
  
  294.  pygame.quit(); sys.exit()
    295. 
  
  
  
  
  295.  main = False
    296. 
  
  
  
  
  296. 
  
  
  
  
  297.  if event.type == pygame.KEYDOWN:
    298. 
  
  
  
  
  298.  if event.key == pygame.K_LEFT or event.key == ord('a'):
    299. 
  
  
  
  
  299.  print("LEFT")
    300. 
  
  
  
  
  300.  player.control(-steps,0)
    301. 
  
  
  
  
  301.  if event.key == pygame.K_RIGHT or event.key == ord('d'):
    302. 
  
  
  
  
  302.  print("RIGHT")
    303. 
  
  
  
  
  303.  player.control(steps,0)
    304. 
  
  
  
  
  304.  if event.key == pygame.K_UP or event.key == ord('w'):
    305. 
  
  
  
  
  305.  print('jump')
    306. 
  
  
  
  
  306. 
  
  
  
  
  307.  if event.type == pygame.KEYUP:
    308. 
  
  
  
  
  308.  if event.key == pygame.K_LEFT or event.key == ord('a'):
    309. 
  
  
  
  
  309.  player.control(steps,0)
    310. 
  
  
  
  
  310.  if event.key == pygame.K_RIGHT or event.key == ord('d'):
    311. 
  
  
  
  
  311.  player.control(-steps,0)
    312. 
  
  
  
  
  312.  if event.key == pygame.K_UP or event.key == ord('w'):
    313. 
  
  
  
  
  313.  player.jump(plat_list)
    314. 
  
  
  
  
  314. 
  
  
  
  
  315.  if event.key == ord('q'):
    316. 
  
  
  
  
  316.  pygame.quit()
    317. 
  
  
  
  
  317.  sys.exit()
    318. 
  
  
  
  
  318.  main = False
    319. 
  
  
  
  
  319. 
  
  
  
  
  320.  # scroll the world forward
    321. 
  
  
  
  
  321.  if player.rect.x >= forwardx:
    322. 
  
  
  
  
  322.  scroll = player.rect.x - forwardx
    323. 
  
  
  
  
  323.  player.rect.x = forwardx
    324. 
  
  
  
  
  324.  for p in plat_list:
    325. 
  
  
  
  
  325.  p.rect.x -= scroll
    326. 
  
  
  
  
  326.  for e in enemy_list:
    327. 
  
  
  
  
  327.  e.rect.x -= scroll
    328. 
  
  
  
  
  328.  for l in loot_list:
    329. 
  
  
  
  
  329.  l.rect.x -= scroll
    330. 
  
  
  
  
  330.  
    331. 
  
  
  
  
  331.  # scroll the world backward
    332. 
  
  
  
  
  332.  if player.rect.x <= backwardx:
    333. 
  
  
  
  
  333.  scroll = backwardx - player.rect.x
    334. 
  
  
  
  
  334.  player.rect.x = backwardx
    335. 
  
  
  
  
  335.  for p in plat_list:
    336. 
  
  
  
  
  336.  p.rect.x += scroll
    337. 
  
  
  
  
  337.  for e in enemy_list:
    338. 
  
  
  
  
  338.  e.rect.x += scroll
    339. 
  
  
  
  
  339.  for l in loot_list:
    340. 
  
  
  
  
  340.  l.rect.x += scroll
    341. 
  
  
  
  
  341. 
  
  
  
  
  342.  world.blit(backdrop, backdropbox) 
    343. 
  
  
  
  
  343.  player.gravity() # check gravity
    344. 
  
  
  
  
  344.  player.update()
    345. 
  
  
  
  
  345.  player_list.draw(world) #refresh player position
    346. 
  
  
  
  
  346.  enemy_list.draw(world) # refresh enemies
    347. 
  
  
  
  
  347.  ground_list.draw(world) # refresh enemies
    348. 
  
  
  
  
  348.  plat_list.draw(world) # refresh platforms
    349. 
  
  
  
  
  349.  loot_list.draw(world) # refresh loot
    350. 
  
  
  
  
  350. 
  
  
  
  
  351.  for e in enemy_list:
    352. 
  
  
  
  
  352.  e.move()
    353. 
  
  
  
  
  353.  pygame.display.flip()
    354. 
  
  
  
  
  354.  clock.tick(fps)
    355.

当前标题：在你的Python平台类游戏中放一些奖励
分享网址：http://www.shufengxianlan.com/qtweb/news45/309995.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

定制网站知识

分类信息网站

成都网站改版　　 　成都品牌网站建设　　 　成都免费建站　　 　大足网站建设　　 　成都做网站　　 　做网站　　 　网创优客　　 　成都包装设计公司　　 　成都网站制作　　 　成都电商解决方案　　 　服务器托管　　 　高端网站设计　　 　成都移动托管　　 　高端网站定制　　 　一带一路　　 　香港云主机　　 　定制级高端网站建设　　 　丹棱网站建设　　 　品牌网站建设　　 　成都机柜租用