日本综合一区二区|亚洲中文天堂综合|日韩欧美自拍一区|男女精品天堂一区|欧美自拍第6页亚洲成人精品一区|亚洲黄色天堂一区二区成人|超碰91偷拍第一页|日韩av夜夜嗨中文字幕|久久蜜综合视频官网|精美人妻一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產(chǎn)品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
在你的Python游戲中添加投擲機制

四處奔跑躲避敵人是一回事，反擊敵人是另一回事。學習如何在這系列的第十二篇文章中在 Pygame 中創(chuàng)建平臺游戲。

這是仍在進行中的關于使用 Pygame 模塊在 Python 3 中創(chuàng)建電腦游戲的第十二部分。先前的文章是：

  1. 通過構(gòu)建一個簡單的擲骰子游戲去學習怎么用 Python 編程
  2. 使用 Python 和 Pygame 模塊構(gòu)建一個游戲框架
  3. 如何在你的 Python 游戲中添加一個玩家
  4. 用 Pygame 使你的游戲角色移動起來
  5. 如何向你的 Python 游戲中添加一個敵人
  6. 在 Pygame 游戲中放置平臺
  7. 在你的 Python 游戲中模擬引力
  8. 為你的 Python 平臺類游戲添加跳躍功能
  9. 使你的 Python 游戲玩家能夠向前和向后跑
  10. 在你的 Python 平臺類游戲中放一些獎勵
  11. 添加計分到你的 Python 游戲

我的上一篇文章本來是這一系列文章的最后一篇，它鼓勵你為這個游戲編寫自己的附加程序。你們很多人都這么做了！我收到了一些電子郵件，要求幫助我還沒有涵蓋的常用機制：戰(zhàn)斗。畢竟，跳起來躲避壞人是一回事，但是有時候讓他們走開是一件非常令人滿意的事。在電腦游戲中向你的敵人投擲一些物品是很常見的，不管是一個火球、一支箭、一道閃電，還是其它適合游戲的東西。

與迄今為止你在這個系列中為你的平臺游戲編程的任何東西不同，可投擲物品有一個生存時間。在你投擲一個物品后，它會如期在移動一段距離后消失。如果它是一支箭或其它類似的東西，它可能會在通過屏幕的邊緣時而消失。如果它是一個火球或一道閃電，它可能會在一段時間后熄滅。

這意味著每次生成一個可投擲的物品時，也必須生成一個獨特的衡量其生存時間的標準。為了介紹這個概念，這篇文章演示如何一次只投擲一個物品。（換句話說，每次僅存在一個投擲物品）。 一方面，這是一個游戲的限制條件，但另一方面，它卻是游戲本身的運行機制。你的玩家不能每次同時投擲 50 個火球，因為每次僅允許一個投擲物品，所以當你的玩家釋放一個火球來嘗試擊中一名敵人就成為了一項挑戰(zhàn)。而在幕后，這也使你的代碼保持簡單。

如果你想啟用每次投擲多個項目，在完成這篇教程后，通過學習這篇教程所獲取的知識來挑戰(zhàn)你自己。

創(chuàng)建 Throwable 類

如果你跟隨學習這系列的其它文章，那么你應該熟悉在屏幕上生成一個新的對象基礎的 __init__ 函數(shù)。這和你用來生成你的 玩家 和 敵人 的函數(shù)是一樣的。這里是生成一個 throwable 對象的 __init__ 函數(shù)來：

 
 
 
 
    
  
  
  
  
  1. class Throwable(pygame.sprite.Sprite):
    2. 
  
  
  
  
  2.  """
    3. 
  
  
  
  
  3.  生成一個 throwable 對象
    4. 
  
  
  
  
  4.  """
    5. 
  
  
  
  
  5.  def __init__(self, x, y, img, throw):
    6. 
  
  
  
  
  6.  pygame.sprite.Sprite.__init__(self)
    7. 
  
  
  
  
  7.  self.image = pygame.image.load(os.path.join('images',img))
    8. 
  
  
  
  
  8.  self.image.convert_alpha()
    9. 
  
  
  
  
  9.  self.image.set_colorkey(ALPHA)
    10. 
  
  
  
  
  10.  self.rect = self.image.get_rect()
    11. 
  
  
  
  
  11.  self.rect.x = x
    12. 
  
  
  
  
  12.  self.rect.y = y
    13. 
  
  
  
  
  13.  self.firing = throw
    14.

同你的 Player 類或 Enemy 類的 __init__ 函數(shù)相比，這個函數(shù)的主要區(qū)別是，它有一個 self.firing 變量。這個變量保持跟蹤一個投擲的物品是否在當前屏幕上活動，因此當一個 throwable 對象創(chuàng)建時，將變量設置為 1 的合乎情理的。

判斷存活時間

接下來，就像使用 Player 和 Enemy 一樣，你需要一個 update 函數(shù)，以便投擲的物品在瞄準敵人拋向空中時，它會自己移動。

測定一個投擲的物品存活時間的最簡單方法是偵測它何時離開屏幕。你需要監(jiān)視的屏幕邊緣取決于你投擲的物品的物理特性。

  • 如果你的玩家正在投擲的物品是沿著水平軸快速移動的，像一只弩箭或箭或一股非?？斓哪Хα?，而你想監(jiān)視你游戲屏幕的水平軸極限。這可以通過 worldx 定義。
  • 如果你的玩家正在投擲的物品是沿著垂直方向或同時沿著水平方向和垂直方向移動的，那么你必須監(jiān)視你游戲屏幕的垂直軸極限。這可以通過 worldy 定義。

這個示例假設你投擲的物品向前移動一點并最終落到地面上。不過，投擲的物品不會從地面上反彈起來，而是繼續(xù)掉落出屏幕。你可以嘗試不同的設置來看看什么最適合你的游戲：

 
 
 
 
    
  
  
  
  
  1.  def update(self,worldy):
    2. 
  
  
  
  
  2.  '''
    3. 
  
  
  
  
  3.  投擲物理學
    4. 
  
  
  
  
  4.  '''
    5. 
  
  
  
  
  5.  if self.rect.y < worldy: #垂直軸 
    6. 
  
  
  
  
  6.  self.rect.x += 15 #它向前移動的速度有多快
    7. 
  
  
  
  
  7.  self.rect.y += 5 #它掉落的速度有多快
    8. 
  
  
  
  
  8.  else:
    9. 
  
  
  
  
  9.  self.kill() #移除投擲對象
    10. 
  
  
  
  
  10.  self.firing = 0 #解除火力發(fā)射
    11.

為使你的投擲物品移動地更快，增加 self.rect 的動量值。

如果投擲物品不在屏幕上，那么該物品將被銷毀，以及釋放其所占用的寄存器。另外，self.firing 將被設置回 0 以允許你的玩家來進行另一次射擊。

設置你的投擲對象

就像使用你的玩家和敵人一樣，你必須在你的設置部分中創(chuàng)建一個精靈組來保持投擲對象。

此外，你必須創(chuàng)建一個非活動的投擲對象來供開始的游戲使用。如果在游戲開始時卻沒有一個投擲對象，那么玩家在第一次嘗試投擲一柄武器時，投擲將失敗。

這個示例假設你的玩家使用一個火球作為開始的武器，因此，每一個投擲實例都是由 fire 變量指派的。在后面的關卡中，當玩家獲取新的技能時，你可以使用相同的 Throwable 類來引入一個新的變量以使用一張不同的圖像。

在這代碼塊中，前兩行已經(jīng)在你的代碼中，因此不要重新鍵入它們:

 
 
 
 
    
  
  
  
  
  1. player_list = pygame.sprite.Group() #上下文
    2. 
  
  
  
  
  2. player_list.add(player) #上下文
    3. 
  
  
  
  
  3. fire = Throwable(player.rect.x,player.rect.y,'fire.png',0)
    4. 
  
  
  
  
  4. firepower = pygame.sprite.Group()
    5.

注意，每一個投擲對象的起始位置都是和玩家所在的位置相同。這使得它看起來像是投擲對象來自玩家。在第一個火球生成時，使用 0 來顯示 self.firing 是可用的。

在主循環(huán)中獲取投擲行為

沒有在主循環(huán)中出現(xiàn)的代碼不會在游戲中使用，因此你需要在你的主循環(huán)中添加一些東西，以便能在你的游戲世界中獲取投擲對象。

首先，添加玩家控制。當前，你沒有火力觸發(fā)器。在鍵盤上的按鍵是有兩種狀態(tài)的：釋放的按鍵，按下的按鍵。為了移動，你要使用這兩種狀態(tài)：按下按鍵來啟動玩家移動，釋放按鍵來停止玩家移動。開火僅需要一個信號。你使用哪個按鍵事件（按鍵按下或按鍵釋放）來觸發(fā)你的投擲對象取決于你的品味。

在這個代碼語句塊中，前兩行是用于上下文的：

 
 
 
 
    
  
  
  
  
  1.  if event.key == pygame.K_UP or event.key == ord('w'):
    2. 
  
  
  
  
  2.  player.jump(platform_list)
    3. 
  
  
  
  
  3.  if event.key == pygame.K_SPACE:
    4. 
  
  
  
  
  4.  if not fire.firing:
    5. 
  
  
  
  
  5.  fire = Throwable(player.rect.x,player.rect.y,'fire.png',1)
    6. 
  
  
  
  
  6.  firepower.add(fire)
    7.

與你在設置部分創(chuàng)建的火球不同，你使用一個 1 來設置 self.firing 為不可用。

最后，你必須更新和繪制你的投擲物品。這個順序很重要，因此把這段代碼放置到你現(xiàn)有的 enemy.move 和 player_list.draw 的代碼行之間：

 
 
 
 
    
  
  
  
  
  1.  enemy.move() # 上下文
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3.  if fire.firing:
    4. 
  
  
  
  
  4.  fire.update(worldy)
    5. 
  
  
  
  
  5.  firepower.draw(world)
    6. 
  
  
  
  
  6.  player_list.draw(screen) # 上下文
    7. 
  
  
  
  
  7.  enemy_list.draw(screen) # 上下文
    8.

注意，這些更新僅在 self.firing 變量被設置為 1 時執(zhí)行。如果它被設置為 0 ，那么 fire.firing 就不為 true，接下來就跳過更新。如果你嘗試做上述這些更新，不管怎樣，你的游戲都會崩潰，因為在游戲中將不會更新或繪制一個 fire 對象。

啟動你的游戲，嘗試挑戰(zhàn)你的武器。

檢測碰撞

如果你玩使用了新投擲技巧的游戲，你可能會注意到，你可以投擲對象，但是它卻不會對你的敵人有任何影響。

原因是你的敵人沒有被查到碰撞事故。一名敵人可能會被你的投擲物品所擊中，但是敵人卻從來不知道被擊中了。

你已經(jīng)在你的 Player 類中完成了碰撞檢測，這非常類似。在你的 Enemy 類中，添加一個新的 update 函數(shù)：

 
 
 
 
    
  
  
  
  
  1.  def update(self,firepower, enemy_list):
    2. 
  
  
  
  
  2.  """
    3. 
  
  
  
  
  3.  檢測火力碰撞
    4. 
  
  
  
  
  4.  """
    5. 
  
  
  
  
  5.  fire_hit_list = pygame.sprite.spritecollide(self,firepower,False)
    6. 
  
  
  
  
  6.  for fire in fire_hit_list:
    7. 
  
  
  
  
  7.  enemy_list.remove(self)
    8.

代碼很簡單。每個敵人對象都檢查并看看它自己是否被 firepower 精靈組的成員所擊中。如果它被擊中，那么敵人就會從敵人組中移除和消失。

為集成這些功能到你的游戲之中，在主循環(huán)中調(diào)用位于新觸發(fā)語句塊中的函數(shù)：

 
 
 
 
    
  
  
  
  
  1.  if fire.firing: # 上下文
    2. 
  
  
  
  
  2.  fire.update(worldy) # 上下文
    3. 
  
  
  
  
  3.  firepower.draw(screen) # 上下文
    4. 
  
  
  
  
  4.  enemy_list.update(firepower,enemy_list) # 更新敵人
    5.

你現(xiàn)在可以嘗試一下你的游戲了，大多數(shù)的事情都如預期般的那樣工作。不過，這里仍然有一個問題，那就是投擲的方向。

更改投擲機制的方向

當前，你英雄的火球只會向右移動。這是因為 Throwable 類的 update 函數(shù)將像素添加到火球的位置，在 Pygame 中，在 X 軸上一個較大的數(shù)字意味著向屏幕的右側(cè)移動。當你的英雄轉(zhuǎn)向另一個方向時，你可能希望它投擲的火球也拋向左側(cè)。

到目前為止，你已經(jīng)知道如何實現(xiàn)這一點，至少在技術上是這樣的。然而，最簡單的解決方案卻是使用一個變量，在一定程度上對你來說可能是一種新的方法。一般來說，你可以“設置一個標記”（有時也被稱為“翻轉(zhuǎn)一個位”）來標明你的英雄所面向的方向。在你做完后，你就可以檢查這個變量來得知火球是向左移動還是向右移動。

首先，在你的 Player 類中創(chuàng)建一個新的變量來代表你的游戲所面向的方向。因為我的游戲天然地面向右側(cè)，由此我把面向右側(cè)作為默認值：

 
 
 
 
    
  
  
  
  
  1.  self.score = 0
    2. 
  
  
  
  
  2.  self.facing_right = True # 添加這行
    3. 
  
  
  
  
  3.  self.is_jumping = True
    4.

當這個變量是 True 時，你的英雄精靈是面向右側(cè)的。當玩家每次更改英雄的方向時，變量也必須重新設置，因此，在你的主循環(huán)中相關的 keyup 事件中這樣做：

 
 
 
 
    
  
  
  
  
  1.  if event.type == pygame.KEYUP:
    2. 
  
  
  
  
  2.  if event.key == pygame.K_LEFT or event.key == ord('a'):
    3. 
  
  
  
  
  3.  player.control(steps, 0)
    4. 
  
  
  
  
  4.  player.facing_right = False # 添加這行
    5. 
  
  
  
  
  5.  if event.key == pygame.K_RIGHT or event.key == ord('d'):
    6. 
  
  
  
  
  6.  player.control(-steps, 0)
    7. 
  
  
  
  
  7.  player.facing_right = True # 添加這行
    8.

最后，更改你的 Throwable 類的 update 函數(shù)，以檢測英雄是否面向右側(cè)，并恰當?shù)靥砑踊驕p去來自火球位置的像素：

 
 
 
 
    
  
  
  
  
  1.  if self.rect.y < worldy:
    2. 
  
  
  
  
  2.  if player.facing_right:
    3. 
  
  
  
  
  3.  self.rect.x += 15
    4. 
  
  
  
  
  4.  else:
    5. 
  
  
  
  
  5.  self.rect.x -= 15
    6. 
  
  
  
  
  6.  self.rect.y += 5
    7.

再次嘗試你的游戲，清除掉你游戲世界中的一些壞人。

Python 平臺類使用投擲能力

作為一項額外的挑戰(zhàn)，當徹底打敗敵人時，嘗試增加你玩家的得分。

完整的代碼

 
 
 
 
    
  
  
  
  
  1. #!/usr/bin/env python3
    2. 
  
  
  
  
  2. # 作者: Seth Kenlon
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4. # GPLv3
    5. 
  
  
  
  
  5. # This program is free software: you can redistribute it and/or
    6. 
  
  
  
  
  6. # modify it under the terms of the GNU General Public License as
    7. 
  
  
  
  
  7. # published by the Free Software Foundation, either version 3 of the
    8. 
  
  
  
  
  8. # License, or (at your option) any later version.
    9. 
  
  
  
  
  9. #
    10. 
  
  
  
  
  10. # This program is distributed in the hope that it will be useful, but
    11. 
  
  
  
  
  11. # WITHOUT ANY WARRANTY; without even the implied warranty of
    12. 
  
  
  
  
  12. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    13. 
  
  
  
  
  13. # General Public License for more details.
    14. 
  
  
  
  
  14. #
    15. 
  
  
  
  
  15. # You should have received a copy of the GNU General Public License
    16. 
  
  
  
  
  16. # along with this program. If not, see <[http://www.gnu.org/licenses/>][17].
    17. 
  
  
  
  
  17.  
    18. 
  
  
  
  
  18. import pygame
    19. 
  
  
  
  
  19. import pygame.freetype
    20. 
  
  
  
  
  20. import sys
    21. 
  
  
  
  
  21. import os
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23. '''
    24. 
  
  
  
  
  24. 變量
    25. 
  
  
  
  
  25. '''
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27. worldx = 960
    28. 
  
  
  
  
  28. worldy = 720
    29. 
  
  
  
  
  29. fps = 40
    30. 
  
  
  
  
  30. ani = 4
    31. 
  
  
  
  
  31. world = pygame.display.set_mode([worldx, worldy])
    32. 
  
  
  
  
  32. forwardx = 600
    33. 
  
  
  
  
  33. backwardx = 120
    34. 
  
  
  
  
  34.  
    35. 
  
  
  
  
  35. BLUE = (80, 80, 155)
    36. 
  
  
  
  
  36. BLACK = (23, 23, 23)
    37. 
  
  
  
  
  37. WHITE = (254, 254, 254)
    38. 
  
  
  
  
  38. ALPHA = (0, 255, 0)
    39. 
  
  
  
  
  39.  
    40. 
  
  
  
  
  40. tx = 64
    41. 
  
  
  
  
  41. ty = 64
    42. 
  
  
  
  
  42.  
    43. 
  
  
  
  
  43. font_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "fonts", "amazdoom.ttf")
    44. 
  
  
  
  
  44. font_size = tx
    45. 
  
  
  
  
  45. pygame.freetype.init()
    46. 
  
  
  
  
  46. myfont = pygame.freetype.Font(font_path, font_size)
    47. 
  
  
  
  
  47.  
    48. 
  
  
  
  
  48. '''
    49. 
  
  
  
  
  49. 對象
    50. 
  
  
  
  
  50. '''
    51. 
  
  
  
  
  51.  
    52. 
  
  
  
  
  52. def stats(score, health):
    53. 
  
  
  
  
  53.  myfont.render_to(world, (4, 4), "Score:"+str(score), BLUE, None, size=64)
    54. 
  
  
  
  
  54.  myfont.render_to(world, (4, 72), "Health:"+str(health), BLUE, None, size=64)
    55. 
  
  
  
  
  55.  
    56. 
  
  
  
  
  56. class Throwable(pygame.sprite.Sprite):
    57. 
  
  
  
  
  57.  """
    58. 
  
  
  
  
  58.  生成一個投擲的對象
    59. 
  
  
  
  
  59.  """
    60. 
  
  
  
  
  60.  def __init__(self, x, y, img, throw):
    61. 
  
  
  
  
  61.  pygame.sprite.Sprite.__init__(self)
    62. 
  
  
  
  
  62.  self.image = pygame.image.load(os.path.join('images', img))
    63. 
  
  
  
  
  63.  self.image.convert_alpha()
    64. 
  
  
  
  
  64.  self.image.set_colorkey(ALPHA)
    65. 
  
  
  
  
  65.  self.rect = self.image.get_rect()
    66. 
  
  
  
  
  66.  self.rect.x = x
    67. 
  
  
  
  
  67.  self.rect.y = y
    68. 
  
  
  
  
  68.  self.firing = throw
    69. 
  
  
  
  
  69.  
    70. 
  
  
  
  
  70.  def update(self, worldy):
    71. 
  
  
  
  
  71.  '''
    72. 
  
  
  
  
  72.  投擲物理學
    73. 
  
  
  
  
  73.  '''
    74. 
  
  
  
  
  74.  if self.rect.y < worldy:
    75. 
  
  
  
  
  75.  if player.facing_right:
    76. 
  
  
  
  
  76.  self.rect.x += 15
    77. 
  
  
  
  
  77.  else:
    78. 
  
  
  
  
  78.  self.rect.x -= 15
    79. 
  
  
  
  
  79.  self.rect.y += 5
    80. 
  
  
  
  
  80.  else:
    81. 
  
  
  
  
  81.  self.kill()
    82. 
  
  
  
  
  82.  self.firing = 0
    83. 
  
  
  
  
  83.  
    84. 
  
  
  
  
  84. # x 位置, y 位置, img 寬度, img 高度, img 文件
    85. 
  
  
  
  
  85. class Platform(pygame.sprite.Sprite):
    86. 
  
  
  
  
  86.  def __init__(self, xloc, yloc, imgw, imgh, img):
    87. 
  
  
  
  
  87.  pygame.sprite.Sprite.__init__(self)
    88. 
  
  
  
  
  88.  self.image = pygame.image.load(os.path.join('images', img)).convert()
    89. 
  
  
  
  
  89.  self.image.convert_alpha()
    90. 
  
  
  
  
  90.  self.image.set_colorkey(ALPHA)
    91. 
  
  
  
  
  91.  self.rect = self.image.get_rect()
    92. 
  
  
  
  
  92.  self.rect.y = yloc
    93. 
  
  
  
  
  93.  self.rect.x = xloc
    94. 
  
  
  
  
  94.  
    95. 
  
  
  
  
  95. class Player(pygame.sprite.Sprite):
    96. 
  
  
  
  
  96.  """
    97. 
  
  
  
  
  97.  生成一名玩家
    98. 
  
  
  
  
  98.  """
    99. 
  
  
  
  
  99.  
    100. 
  
  
  
  
  100.  def __init__(self):
    101. 
  
  
  
  
  101.  pygame.sprite.Sprite.__init__(self)
    102. 
  
  
  
  
  102.  self.movex = 0
    103. 
  
  
  
  
  103.  self.movey = 0
    104. 
  
  
  
  
  104.  self.frame = 0
    105. 
  
  
  
  
  105.  self.health = 10
    106. 
  
  
  
  
  106.  self.damage = 0
    107. 
  
  
  
  
  107.  self.score = 0
    108. 
  
  
  
  
  108.  self.facing_right = True
    109. 
  
  
  
  
  109.  self.is_jumping = True
    110. 
  
  
  
  
  110.  self.is_falling = True
    111. 
  
  
  
  
  111.  self.images = []
    112. 
  
  
  
  
  112.  for i in range(1, 5):
    113. 
  
  
  
  
  113.  img = pygame.image.load(os.path.join('images', 'walk' + str(i) + '.png')).convert()
    114. 
  
  
  
  
  114.  img.convert_alpha()
    115. 
  
  
  
  
  115.  img.set_colorkey(ALPHA)
    116. 
  
  
  
  
  116.  self.images.append(img)
    117. 
  
  
  
  
  117.  self.image = self.images[0]
    118. 
  
  
  
  
  118.  self.rect = self.image.get_rect()
    119. 
  
  
  
  
  119.  
    120. 
  
  
  
  
  120.  def gravity(self):
    121. 
  
  
  
  
  121.  if self.is_jumping:
    122. 
  
  
  
  
  122.  self.movey += 3.2
    123. 
  
  
  
  
  123.  
    124. 
  
  
  
  
  124.  def control(self, x, y):
    125. 
  
  
  
  
  125.  """
    126. 
  
  
  
  
  126.  控制玩家移動
    127. 
  
  
  
  
  127.  """
    128. 
  
  
  
  
  128.  self.movex += x
    129. 
  
  
  
  
  129.  
    130. 
  
  
  
  
  130.  def jump(self):
    131. 
  
  
  
  
  131.  if self.is_jumping is False:
    132. 
  
  
  
  
  132.  self.is_falling = False
    133. 
  
  
  
  
  133.  self.is_jumping = True
    134. 
  
  
  
  
  134.  
    135. 
  
  
  
  
  135.  def update(self):
    136. 
  
  
  
  
  136.  """
    137. 
  
  
  
  
  137.  更新精靈位置
    138. 
  
  
  
  
  138.  """
    139. 
  
  
  
  
  139.  
    140. 
  
  
  
  
  140.  # 向左移動
    141. 
  
  
  
  
  141.  if self.movex < 0:
    142. 
  
  
  
  
  142.  self.is_jumping = True
    143. 
  
  
  
  
  143.  self.frame += 1
    144. 
  
  
  
  
  144.  if self.frame > 3 * ani:
    145. 
  
  
  
  
  145.  self.frame = 0
    146. 
  
  
  
  
  146.  self.image = pygame.transform.flip(self.images[self.frame // ani], True, False)
    147. 
  
  
  
  
  147.  
    148. 
  
  
  
  
  148.  # 向右移動
    149. 
  
  
  
  
  149.  if self.movex > 0:
    150. 
  
  
  
  
  150.  self.is_jumping = True
    151. 
  
  
  
  
  151.  self.frame += 1
    152. 
  
  
  
  
  152.  if self.frame > 3 * ani:
    153. 
  
  
  
  
  153.  self.frame = 0
    154. 
  
  
  
  
  154.  self.image = self.images[self.frame // ani]
    155. 
  
  
  
  
  155.  
    156. 
  
  
  
  
  156.  # 碰撞
    157. 
  
  
  
  
  157.  enemy_hit_list = pygame.sprite.spritecollide(self, enemy_list, False)
    158. 
  
  
  
  
  158.  if self.damage == 0:
    159. 
  
  
  
  
  159.  for enemy in enemy_hit_list:
    160. 
  
  
  
  
  160.  if not self.rect.contains(enemy):
    161. 
  
  
  
  
  161.  self.damage = self.rect.colliderect(enemy)
    162. 
  
  
  
  
  162.  if self.damage == 1:
    163. 
  
  
  
  
  163.  idx = self.rect.collidelist(enemy_hit_list)
    164. 
  
  
  
  
  164.  if idx == -1:
    165. 
  
  
  
  
  165.  self.damage = 0 # 設置傷害回 0
    166. 
  
  
  
  
  166.  self.health -= 1 # 減去 1 單位健康度
    167. 
  
  
  
  
  167.  
    168. 
  
  
  
  
  168.  ground_hit_list = pygame.sprite.spritecollide(self, ground_list, False)
    169. 
  
  
  
  
  169.  for g in ground_hit_list:
    170. 
  
  
  
  
  170.  self.movey = 0
    171. 
  
  
  
  
  171.  self.rect.bottom = g.rect.top
    172. 
  
  
  
  
  172.  self.is_jumping = False # 停止跳躍
    173. 
  
  
  
  
  173.  
    174. 
  
  
  
  
  174.  # 掉落世界
    175. 
  
  
  
  
  175.  if self.rect.y > worldy:
    176. 
  
  
  
  
  176.  self.health -=1
    177. 
  
  
  
  
  177.  print(self.health)
    178. 
  
  
  
  
  178.  self.rect.x = tx
    179. 
  
  
  
  
  179.  self.rect.y = ty
    180. 
  
  
  
  
  180.  
    181. 
  
  
  
  
  181.  plat_hit_list = pygame.sprite.spritecollide(self, plat_list, False)
    182. 
  
  
  
  
  182.  for p in plat_hit_list:
    183. 
  
  
  
  
  183.  self.is_jumping = False # 停止跳躍
    184. 
  
  
  
  
  184.  self.movey = 0
    185. 
  
  
  
  
  185.  if self.rect.bottom <= p.rect.bottom:
    186. 
  
  
  
  
  186.  self.rect.bottom = p.rect.top
    187. 
  
  
  
  
  187.  else:
    188. 
  
  
  
  
  188.  self.movey += 3.2
    189. 
  
  
  
  
  189.  
    190. 
  
  
  
  
  190.  if self.is_jumping and self.is_falling is False:
    191. 
  
  
  
  
  191.  self.is_falling = True
    192. 
  
  
  
  
  192.  self.movey -= 33 # 跳躍多高
    193. 
  
  
  
  
  193.  
    194. 
  
  
  
  
  194.  loot_hit_list = pygame.sprite.spritecollide(self, loot_list, False)
    195. 
  
  
  
  
  195.  for loot in loot_hit_list:
    196. 
  
  
  
  
  196.  loot_list.remove(loot)
    197. 
  
  
  
  
  197.  self.score += 1
    198. 
  
  
  
  
  198.  print(self.score)
    199. 
  
  
  
  
  199.  
    200. 
  
  
  
  
  200.  plat_hit_list = pygame.sprite.spritecollide(self, plat_list, False)
    201. 
  
  
  
  
  201.  
    202. 
  
  
  
  
  202.  self.rect.x += self.movex
    203. 
  
  
  
  
  203.  self.rect.y += self.movey
    204. 
  
  
  
  
  204.  
    205. 
  
  
  
  
  205. class Enemy(pygame.sprite.Sprite):
    206. 
  
  
  
  
  206.  """
    207. 
  
  
  
  
  207.  生成一名敵人
    208. 
  
  
  
  
  208.  """
    209. 
  
  
  
  
  209.  
    210. 
  
  
  
  
  210.  def __init__(self, x, y, img):
    211. 
  
  
  
  
  211.  pygame.sprite.Sprite.__init__(self)
    212. 
  
  
  
  
  212.  self.image = pygame.image.load(os.path.join('images', img))
    213. 
  
  
  
  
  213.  self.image.convert_alpha()
    214. 
  
  
  
  
  214.  self.image.set_colorkey(ALPHA)
    215. 
  
  
  
  
  215.  self.rect = self.image.get_rect()
    216. 
  
  
  
  
  216.  self.rect.x = x
    217. 
  
  
  
  
  217.  self.rect.y = y
    218. 
  
  
  
  
  218.  self.counter = 0
    219. 
  
  
  
  
  219.  
    220. 
  
  
  
  
  220.  def move(self):
    221. 
  
  
  
  
  221.  """
    222. 
  
  
  
  
  222.  敵人移動
    223. 
  
  
  
  
  223.  """
    224. 
  
  
  
  
  224.  distance = 80
    225. 
  
  
  
  
  225.  speed = 8
    226. 
  
  
  
  
  226.  
    227. 
  
  
  
  
  227.  if self.counter >= 0 and self.counter <= distance:
    228. 
  
  
  
  
  228.  self.rect.x += speed
    229. 
  
  
  
  
  229.  elif self.counter >= distance and self.counter <= distance * 2:
    230. 
  
  
  
  
  230.  self.rect.x -= speed
    231. 
  
  
  
  
  231.  else:
    232. 
  
  
  
  
  232.  self.counter = 0
    233. 
  
  
  
  
  233.  
    234. 
  
  
  
  
  234.  self.counter += 1
    235. 
  
  
  
  
  235.  
    236. 
  
  
  
  
  236.  def update(self, firepower, enemy_list):
    237. 
  
  
  
  
  237.  """
    238. 
  
  
  
  
  238.  檢測火力碰撞
    239. 
  
  
  
  
  239.  """
    240. 
  
  
  
  
  240.  fire_hit_list = pygame.sprite.spritecollide(self, firepower, False)
    241. 
  
  
  
  
  241.  for fire in fire_hit_list:
    242. 
  
  
  
  
  242.  enemy_list.remove(self)
    243. 
  
  
  
  
  243.  
    244. 
  
  
  
  
  244. class Level:
    245. 
  
  
  
  
  245.  def ground(lvl, gloc, tx, ty):
    246. 
  
  
  
  
  246.  ground_list = pygame.sprite.Group()
    247. 
  
  
  
  
  247.  i = 0
    248. 
  
  
  
  
  248.  if lvl == 1:
    249. 
  
  
  
  
  249.  while i < len(gloc):
    250. 
  
  
  
  
  250.  ground = Platform(gloc[i], worldy - ty, tx, ty, 'tile-ground.png')
    251. 
  
  
  
  
  251.  ground_list.add(ground)
    252. 
  
  
  
  
  252.  i = i + 1
    253. 
  
  
  
  
  253.  
    254. 
  
  
  
  
  254.  if lvl == 2:
    255. 
  
  
  
  
  255.  print("Level " + str(lvl))
    256. 
  
  
  
  
  256.  
    257. 
  
  
  
  
  257.  return ground_list
    258. 
  
  
  
  
  258.  
    259. 
  
  
  
  
  259.  def bad(lvl, eloc):
    260. 
  
  
  
  
  260.  if lvl == 1:
    261. 
  
  
  
  
  261.  enemy = Enemy(eloc[0], eloc[1], 'enemy.png')
    262. 
  
  
  
  
  262.  enemy_list = pygame.sprite.Group()
    263. 
  
  
  
  
  263.  enemy_list.add(enemy)
    264. 
  
  
  
  
  264.  if lvl == 2:
    265. 
  
  
  
  
  265.  print("Level " + str(lvl))
    266. 
  
  
  
  
  266.  
    267. 
  
  
  
  
  267.  return enemy_list
    268. 
  
  
  
  
  268.  
    269. 
  
  
  
  
  269.  # x 位置, y 位置, img 寬度, img 高度, img 文件
    270. 
  
  
  
  
  270.  def platform(lvl, tx, ty):
    271. 
  
  
  
  
  271.  plat_list = pygame.sprite.Group()
    272. 
  
  
  
  
  272.  ploc = []
    273. 
  
  
  
  
  273.  i = 0
    274. 
  
  
  
  
  274.  if lvl == 1:
    275. 
  
  
  
  
  275.  ploc.append((200, worldy - ty - 128, 3))
    276. 
  
  
  
  
  276.  ploc.append((300, worldy - ty - 256, 3))
    277. 
  
  
  
  
  277.  ploc.append((550, worldy - ty - 128, 4))
    278. 
  
  
  
  
  278.  while i < len(ploc):
    279. 
  
  
  
  
  279.  j = 0
    280. 
  
  
  
  
  280.  while j <= ploc[i][2]:
    281. 
  
  
  
  
  281.  plat = Platform((ploc[i][0] + (j * tx)), ploc[i][1], tx, ty, 'tile.png')
    282. 
  
  
  
  
  282.  plat_list.add(plat)
    283. 
  
  
  
  
  283.  j = j + 1
    284. 
  
  
  
  
  284.  print('run' + str(i) + str(ploc[i]))
    285. 
  
  
  
  
  285.  i = i + 1
    286. 
  
  
  
  
  286.  
    287. 
  
  
  
  
  287.  if lvl == 2:
    288. 
  
  
  
  
  288.  print("Level " + str(lvl))
    289. 
  
  
  
  
  289.  
    290. 
  
  
  
  
  290.  return plat_list
    291. 
  
  
  
  
  291.  
    292. 
  
  
  
  
  292.  def loot(lvl):
    293. 
  
  
  
  
  293.  if
                                                當前名稱：在你的Python游戲中添加投擲機制                                                
    
                                                網(wǎng)站網(wǎng)址：http://www.dlmjj.cn/article/coogosp.html