❏ 站外平台：

添加计分到你的 Python 游戏

作者： Seth Kenlon 译者： LCTT 郑

| 2020-02-01 15:48      

在本系列的第十一篇有关使用 Python Pygame 模块进行编程的文章中，显示玩家获得战利品或受到伤害时的得分。

这是仍在进行中的关于使用 Pygame 模块来在 Python 3 在创建电脑游戏的第十一部分。先前的文章是：

如果你已经跟随这一系列很久，那么已经学习了使用 Python 创建一个视频游戏所需的所有基本语法和模式。然而，它仍然缺少一个至关重要的组成部分。这一组成部分不仅仅对用 Python 编程游戏重要；不管你探究哪个计算机分支，你都必需精通：作为一个程序员，通过阅读一种语言的或库的文档来学习新的技巧。

幸运的是，你正在阅读本文的事实表明你熟悉文档。为了使你的平台类游戏更加美观，在这篇文章中，你将在游戏屏幕上添加得分和生命值显示。不过，教你如何找到一个库的功能以及如何使用这些新的功能的这节课程并没有多神秘。

在 Pygame 中显示得分

现在，既然你有了可以被玩家收集的奖励，那就有充分的理由来记录分数，以便你的玩家看到他们收集了多少奖励。你也可以跟踪玩家的生命值，以便当他们被敌人击中时会有相应结果。

你已经有了跟踪分数和生命值的变量，但是这一切都发生在后台。这篇文章教你在游戏期间在游戏屏幕上以你选择的一种字体来显示这些统计数字。

阅读文档

大多数 Python 模块都有文档，即使那些没有文档的模块，也能通过 Python 的帮助功能来进行最小的文档化。Pygame 的主页面 链接了它的文档。不过，Pygame 是一个带有很多文档的大模块，并且它的文档不像在 Opensource.com 上的文章一样，以同样易理解的（和友好的、易解释的、有用的）叙述风格来撰写的。它们是技术文档，并且列出在模块中可用的每个类和函数，各自要求的输入类型等等。如果你不适应参考代码组件描述，这可能会令人不知所措。

在烦恼于库的文档前，第一件要做的事，就是来想想你正在尝试达到的目标。在这种情况下，你想在屏幕上显示玩家的得分和生命值。

在你确定你需要的结果后，想想它需要什么的组件。你可以从变量和函数的方面考虑这一点，或者，如果你还没有自然地想到这一点，你可以进行一般性思考。你可能意识到需要一些文本来显示一个分数，你希望 Pygame 在屏幕上绘制这些文本。如果你仔细思考，你可能会意识到它与在屏幕上渲染一个玩家、奖励或一个平台并多么大的不同。

从技术上讲，你可以使用数字图形，并让 Pygame 显示这些数字图形。它不是达到你目标的最容易的方法，但是如果它是你唯一知道的方法，那么它是一个有效的方法。不过，如果你参考 Pygame 的文档，你看到列出的模块之一是 font，这是 Pygame 使得在屏幕上来使打印文本像输入文字一样容易的方法。

解密技术文档

font 文档页面以 pygame.font.init() 开始，它列出了用于初始化字体模块的函数。它由 pygame.init() 自动地调用，你已经在代码中调用了它。再强调一次，从技术上讲，你已经到达一个足够好的点。虽然你尚不知道如何做，你知道你能够使用 pygame.font 函数来在屏幕上打印文本。

然而，如果你阅读更多一些，你会找到这里还有一种更好的方法来打印字体。pygame.freetype 模块在文档中的描述方式如下：

pygame.freetype 模块是 pygame.fontpygame 模块的一个替代品，用于加载和渲染字体。它有原函数的所有功能，外加很多新的功能。

在 pygame.freetype 文档页面的下方，有一些示例代码：

  1. import pygame
  2. import pygame.freetype

你的代码应该已经导入了 Pygame，不过，请修改你的 import 语句以包含 Freetype 模块：

  1. import pygame
  2. import sys
  3. import os
  4. import pygame.freetype

在 Pygame 中使用字体

从 font 模块的描述中可以看出，显然 Pygame 使用一种字体（不管它的你提供的或内置到 Pygame 的默认字体）在屏幕上渲染字体。滚动浏览 pygame.freetype 文档来找到 pygame.freetype.Font 函数：

  1. pygame.freetype.Font
  2. 从支持的字体文件中创建一个新的字体实例。
  4. Font(file, size=0, font_index=0, resolution=0, ucs4=False) -> Font
  6. pygame.freetype.Font.name
  7.   符合规则的字体名称。
  9. pygame.freetype.Font.path
  10.   字体文件路径。
  12. pygame.freetype.Font.size
  13.   在渲染中使用的默认点大小

这描述了如何在 Pygame 中构建一个字体“对象”。把屏幕上的一个简单对象视为一些代码属性的组合对你来说可能不太自然，但是这与你构建英雄和敌人精灵的方式非常类似。你需要一个字体文件，而不是一个图像文件。在你有一个字体文件后，你可以在你的代码中使用 pygame.freetype.Font 函数来创建一个字体对象，然后使用该对象来在屏幕上渲染文本。

因为并不是世界上的每个人的电脑上都有完全一样的字体，因此将你选择的字体与你的游戏捆绑在一起是很重要的。要捆绑字体，首先在你的游戏文件夹中创建一个新的目录，放在你为图像而创建的文件目录旁边。称其为 fonts 。

即使你的计算机操作系统随附了几种字体，但是将这些字体给予其他人是非法的。这看起来很奇怪，但法律就是这样运作的。如果想与你的游戏一起随附一种字体，你必需找到一种开源或知识共享的字体，以允许你随游戏一起提供该字体。

专门提供自由和合法字体的网站包括：

当你找到你喜欢的字体后，下载下来。解压缩 ZIP 或 TAR 文件，并移动 .ttf 或 .otf 文件到你的项目目录下的 fonts 文件夹中。

你没有安装字体到你的计算机上。你只是放置字体到你游戏的 fonts 文件夹中，以便 Pygame 可以使用它。如果你想，你可以在你的计算机上安装该字体，但是没有必要。重要的是将字体放在你的游戏目录中，这样 Pygame 可以“描绘”字体到屏幕上。

如果字体文件的名称复杂且带有空格或特殊字符，只需要重新命名它即可。文件名称是完全任意的，并且对你来说，文件名称越简单，越容易将其键入你的代码中。

现在告诉 Pygame 你的字体。从文档中你知道，当你至少提供了字体文件路径给 pygame.freetype.Font 时（文档明确指出所有其余属性都是可选的），你将在返回中获得一个字体对象：

  1. Font(file, size=0, font_index=0, resolution=0, ucs4=False) -> Font

创建一个称为 myfont 的新变量来充当你在游戏中字体，并放置 Font 函数的结果到这个变量中。这个示例中使用 amazdoom.ttf 字体，但是你可以使用任何你想使用的字体。在你的设置部分放置这些代码：

  1. font_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),"fonts","amazdoom.ttf")
  2. font_size = tx
  3. myfont = pygame.freetype.Font(font_path, font_size)

在 Pygame 中显示文本

现在你已经创建一个字体对象，你需要一个函数来绘制你想绘制到屏幕上的文本。这和你在你的游戏中绘制背景和平台是相同的原理。

首先，创建一个函数，并使用 myfont 对象来创建一些文本，设置颜色为某些 RGB 值。这必须是一个全局函数；它不属于任何具体的类：

  1. def stats(score,health):
  2.     myfont.render_to(world, (4, 4), "Score:"+str(score), WHITE, None, size=64)
  3.     myfont.render_to(world, (4, 72), "Health:"+str(health), WHITE, None, size=64)

当然，你此刻已经知道，如果它不在主循环中，你的游戏将不会发生任何事，所以在文件的底部添加一个对你的 stats 函数的调用：

  1.     for e in enemy_list:
  2.         e.move()
  3.     stats(player.score,player.health) # draw text
  4.     pygame.display.flip()

尝试你的游戏。

当玩家收集奖励品时，得分会上升。当玩家被敌人击中时，生命值下降。成功！

Keeping score in Pygame

Keeping score in Pygame

不过，这里有一个问题。当一个玩家被敌人击中时，健康度会一路下降，这是不公平的。你刚刚发现一个非致命的错误。非致命的错误是这些在应用程序中小问题，（通常）不会阻止应用程序启动或甚至导致停止工作，但是它们要么没有意义，要么会惹恼用户。这里是如何解决这个问题的方法。

修复生命值计数

当前生命值系统的问题是，敌人接触玩家时，Pygame 时钟的每一次滴答，健康度都会减少。这意味着一个缓慢移动的敌人可能在一次遭遇中将一个玩家降低健康度至 -200 ，这不公平。当然，你可以给你的玩家一个 10000 的起始健康度得分，而不用担心它；这可以工作，并且可能没有人会注意。但是这里有一个更好的方法。

当前，你的代码侦查出一个玩家和一个敌人发生碰撞的时候。生命值问题的修复是检测两个独立的事件：什么时候玩家和敌人碰撞，并且，在它们碰撞后，什么时候它们停止碰撞。

首先，在你的玩家类中，创建一个变量来代表玩家和敌人碰撞在一起：

  1.         self.frame = 0
  2.         self.health = 10
  3.         self.damage = 0

在你的 Player 类的 update 函数中，移除这块代码块：

  1.         for enemy in enemy_hit_list:
  2.             self.health -= 1
  3.             #print(self.health)

并且在它的位置，只要玩家当前没有被击中，检查碰撞：

  1.         if self.damage == 0:
  2.             for enemy in enemy_hit_list:
  3.                 if not self.rect.contains(enemy):
  4.                     self.damage = self.rect.colliderect(enemy)

你可能会在你删除的语句块和你刚刚添加的语句块之间看到相似之处。它们都在做相同的工作，但是新的代码更复杂。最重要的是，只有当玩家当前没有被击中时，新的代码才运行。这意味着，当一个玩家和敌人碰撞时，这些代码运行一次，而不是像以前那样一直发生碰撞。

新的代码使用两个新的 Pygame 函数。self.rect.contains 函数检查一个敌人当前是否在玩家的边界框内，并且当它是 true 时， self.rect.colliderect 设置你的新的 self.damage 变量为 1，而不管它多少次是 true 。

现在，即使被一个敌人击中 3 秒，对 Pygame 来说仍然看作一次击中。

我通过通读 Pygame 的文档而发现了这些函数。你没有必要一次阅读完全部的文档，并且你也没有必要阅读每个函数的每个单词。不过，花费时间在你正在使用的新的库或模块的文档上是很重要的；否则，你极有可能在重新发明轮子。不要花费一个下午的时间来尝试修改拼接一个解决方案到一些东西，而这些东西已经被你正在使用的框架的所解决。阅读文档，知悉函数，并从别人的工作中获益！

最后，添加另一个代码语句块来侦查出什么时候玩家和敌人不再接触。然后直到那时，才从玩家减少一个生命值。

  1.         if self.damage == 1:
  2.             idx = self.rect.collidelist(enemy_hit_list)
  3.             if idx == -1:
  4.                 self.damage = 0   # set damage back to 0
  5.                 self.health -= 1  # subtract 1 hp

注意，只有当玩家被击中时，这个新的代码才会被触发。这意味着，在你的玩家在你的游戏世界正在探索或收集奖励时，这个代码不会运行。它仅当 self.damage 变量被激活时运行。

当代码运行时，它使用 self.rect.collidelist 来查看玩家是否仍然接触在你敌人列表中的敌人（当其未侦查到碰撞时，collidelist 返回 -1）。在它没有接触敌人时，是该处理 self.damage 的时机：通过设置 self.damage 变量回到 0 来使其无效，并减少一点生命值。

现在尝试你的游戏。

得分反应

现在，你有一个来让你的玩家知道它们分数和生命值的方法，当你的玩家达到某些里程碑时，你可以确保某些事件发生。例如，也许这里有一个特殊的恢复一些生命值的奖励项目。也许一个到达 0 生命值的玩家不得不从一个关卡的起始位置重新开始。

你可以在你的代码中检查这些事件，并且相应地操纵你的游戏世界。你已经知道该怎么做，所以请浏览文档来寻找新的技巧，并且独立地尝试这些技巧。

这里是到目前为止所有的代码：

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

via: https://opensource.com/article/20/1/add-scorekeeping-your-python-game

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

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



最新评论

从 2025.1.15 起，不再提供评论功能
LCTT 译者
郑 🌟🌟🌟🌟🌟
共计翻译： 122.0 篇 | 共计贡献： 1773 天
贡献时间：2018-12-03 -> 2023-10-10
访问我的 LCTT 主页 | 在 GitHub 上关注我


返回顶部

分享到微信

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