Python外星人入侵游戏

才不会有稗子

已于 2023-11-11 20:20:42 修改

阅读量673

点赞数 3

文章标签： python 游戏 pygame

于 2023-11-06 09:18:05 首次发布

本文链接：https://blog.csdn.net/qq_73994039/article/details/134034936

版权

游戏开始前的准备工作：

安装Pygame--------使用pip

alien_invasion.py

导入模块

import sys    # sys模块中的工具可以用来帮助玩家退出游戏 
import pygame    # pygame模块包含开发游戏所需的功能
from setting import Setting
from ship import Ship

class AlienInvasion:

"""管理游戏资源和行为的类"""

def init(self):

"""初始化游戏并创建游戏资源“”“

def __init__(self):
    pygame.init()
    self.clock = pygame.time.Clock()
    self.setting = Setting()
    # 指定屏幕大小
    # self.screen = pygame.display.set_mode((self.setting.screen_width,
    # self.setting.screen_height))
    # 全屏
    self.screen = pygame.display.set_mode((0,0),pygame.FULLSCREEN)
    self.setting.screen_width = self.screen.get_rect().width
    self.setting.screen_height = self.screen.get_rect().height
    # 创建Ship实例对象
    self.ship = Ship(self)
    # 创建用来存储外星人的编组
    self.ailiens = pygame.sprite.Group()
    # 创建外星人舰队
    self._create_alien()
    # 创建用来存储子弹的编组
    self.bullets = pygame.sprite.Group()
    # 创建一个用于存储游戏统计信息的实例，创建记分牌
    self.stats = GameStats(self)
    self.sb = Scoreboard(self)
    # 设置窗口标题
    pygame.display.set_caption("AlienInvasion--外星人入侵游戏")
    # 插入背景音乐
    pygame.mixer.music.load(""C:/Users/hp/Desktop/Key Sounds Label (キー・サウンズ・レーベル) - Bloom of Youth (风华正茂).ogg"")
    # 这里的-1代表播放次数，-1就是无限循环下去，反之，如果要播放一遍就停止，只需传入1
    pygame.mixer.music.play(-1)

Surface定义

Surface是一块矩形显示区域，用来显示任意图像，具有固定的宽、高、像素格式。粗略可以理解为画布，可以在上面绘制图像。此外还可以将一个Surface作为图像复制到另一个Surface上。pygame.display.set_mode()实际上就是创建了一个display surface对象

创建surface
通过pygame.display.set_mode（）函数创建display surface(该surface是一个特殊的surface对象）
通过pygame.image.load()返回的image surface创建surface对象
通过Surface类的构造函数创建Surface对象

通过pygame.font.Font.render()创建对象-----在显示文字时用到

绘制Surface
fill(color,rect=None,special_flags=0)--------指定填充颜色

color表示带填充颜色的RGB或RGBA值，该值为一个三元组或四元组

第二个参数代表颜色填充的目标区域，不指定则填充整个surface，第三个涉及更多高级特性，书中未做介绍。
blit(sourface,dest,area=None,special_flags=0)------用于将一个Surface对象复制到另一个Surface对象上。

转换surface的像素格式

convert()——把当前surface转换成与屏幕surface一致的像素格式，返回值未转换后的surface对象（不适用于带透明效果的图片）

convert_alpha()——与convert效果相同，但其适用于带透明效果的图片

获取surface的属性
get_width()-----获取surface的宽度，单位为像素（pixel）
get_height()------获取surface的高度，单位为像素（pixel)
get_size()--------获取surface的尺寸，返回的是一个二元组（width,height)，单位为pixel
get_rect(**kwargs）------获取surface所在的矩形区域，返回值为一个与surface宽高相等的Rect对象。

在pygame中，精灵是游戏中的基本元素，可以是角色、道具、障碍物等。而精灵组则是用于管理精灵的容器，可以方便地对多个精灵进行操作。常用的精灵和精灵组操作包括：

创建精灵：使用pygame.sprite.Sprite类创建一个新的精灵对象，可以通过继承该类来创建自定义的精灵。

创建精灵组：使用pygame.sprite.Group()函数创建一个新的精灵组对象。

添加精灵到组中：使用精灵组的add()方法将一个或多个精灵添加到组中。

从组中移除精灵：使用精灵组的remove()方法将一个精灵从组中移除。

更新精灵组：使用精灵组的update()方法更新组中所有精灵的状态。

绘制精灵组：使用精灵组的draw()方法将组中所有精灵绘制到屏幕上。

碰撞检测：使用pygame.sprite.spritecollide()函数检测两个精灵是否发生碰撞。

精灵动画：使用pygame.sprite.Animation类创建一个新的动画对象，可以通过添加多个图像帧来创建动画效果。

def run_game(self):

"""开始游戏的主循环”“”

一个游戏循环就做三件事： 处理事件； 更新游戏状态； 绘制游戏状态到屏幕上

def run_game(self):
    while True:
        # 监听键盘和鼠标事件
        self._check_event()
        if self.game_active:
            # 更新游戏状态
            # 1.更新飞船的游戏状态
            self.ship.update()
            # 2.更新子弹的游戏状态
            self._update_bullets()
            # 3.更新外星人的游戏状态
            self._update_aliens()
        # 绘制游戏状态到屏幕上
        self._update_screen()        
        # 让时钟进行计时
        self.clock.tick(60)

控制帧率

理想情况下，游戏在所有的系统中都应该以相同的速度（帧率）运行。

创建一个时钟（clock），并确保它在主循环每次通过后都进行计时（tick）。当这个循环的通过速度超过我们定义的帧率时，pygame会计算需要暂停多长时间，以便游戏的运行速度保持一致。

tick()方法接受一个参数：游戏的帧率。

例如：这里传入的是60，Pygame将尽可能确保这个循环每秒恰好运行60次

def _check_events(self):

"""响应按键和鼠标事件“”“

def _check_event(self):
    """监听键盘和鼠标事件"""
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_q:
                sys.exit()
            if event.key == pygame.K_RIGHT:
                self.ship.moving_right = True
            if event.key == pygame.K_LEFT:
                self.ship.moving.left = True
            if event.key == pygame.K_SPACE:
                self._fire_bullet()
        
        if event.type == pygame.KEYUP:
            if event.key == pygame.K_RIGHT:
                self.ship.moving_right = False
            if event.key == pygame.K_LEFT:
                self.ship.moving_left = False
        if event.type == pygame.MOUSEBUTTONDOWN
            mouse_ppos = pygame.mouse.get_pos()
            self._check_play_button(moouse_pos)

def _check_play_button(self,mouse_pos):

"""在玩家单击play按钮时开始游戏"""

def _check_play_button(self,mouse_pos):
    """在玩家单击play按钮时开始游戏"""
    if self.play_button.rect.collidepoint(mouse_pos) and 
            not self.game_active:
        # 还原游戏的速度设置
        self.setting.initialize_dynamic_setting()
        # 隐藏光标
        pygame.mouse.set_visible(False)
        # 重置游戏的统计信息
        self.stats.reset_stats()
        self.sb.prep_score()
        self.sb_prep_level()
        self.sb_prep_ships()
        self.game_active = True
        
        # 清空子弹和外星人列表
        self.aliens.empty()
        self.bullets.empty()
        # 创建一个新的舰队，并让飞船位于屏幕底部中央
        self._create_aliens()
        self.ship.center_ship()

隐藏光标

pygame.mouse.set_visible(False)

def _update_screen(self):

"""更新屏幕上的图像，并切换到新屏幕"""

def _update_screen(self):
    """更新屏幕上的图像，并切换到新屏幕"""
    self.screen.fill(self.setting.bg_color)
    # 绘制飞船在屏幕上
    self.ship.ship_paint()
    # 绘制外星人在屏幕上
    self.aliens.draw(self.screen)
    # 绘制子弹在屏幕上
    self.bullets.draw(self.screen)
    # 绘制得分、最高分、闯关等级在屏幕上
    self.sb.show_score()
    # 如果游戏处于非活动状态，就绘制Play按钮
    if not self.game_active:
        self.play_button.draw_button()
    # 让最近绘制的屏幕可见
    pygame.display.flip()

def _create_alien(self,x_position,y_position):

"""创建一个外星人并将其放在当前行中”“”

def _create_alien(self,x_position,y_position):
    """创建一个外星人，并将其放在当前行中"""
    new_alien = Alien(self)
    new_alien.x = x_position
    new_alien.rect.x = x_position
    new_alien.rect.y = y_position
    self.aliens.add(new_alien)

def _create_aliens(self):

"""创建一个外星舰队“”“

def _create_aliens(self)
    """创建外星人舰队"""
    # 创建一个外星人，再不断添加，直到没有空间再添加外星人为止
    # 外星人的间距为外星人的宽度和外星人的高度
    # 外星人的间距为外星人的宽度和外星人的高度
    alien = Alien(self)
    slien_width,alien_height = alien.rect.size
    current_x, current_y = alien_width,alien_height
    
    while current_y < (self.setting.screen_height - 3*alien_height):
        while current_x<(self.setting_sscreen_width - 2*alien_width):
            self._create_alien(current_x,current_y)
            current_x += 2*alien_width
        # 添加一行外星人后，重置x值并递增y值
        current_x = alien_width
        current_y = 2* alien_height

def _fire_bullet(self):

"""创建一颗子弹，并将其加入编组bullets"""

def _fire_bullet(self):
    """创建一颗子弹，并发射出去"""
    if len(self.bullets)<self.setting.bullet_allowed:
        new_bullet = Bullet(self)
        self.bullets.add(new_bullet)

def _update_bullets(self):

"""更新子弹的位置并删除已经消失的子弹”“”

def _update_bullets(self):
    """更新子弹的位置并删除已经消失的子弹"""
    self.bullets.update()
    for bullet in self.bullets.copy():
        if bullet.rect.bottom <= 0:
            self.bullets.remove(bullet)
    # 检测子弹射中外星人时
    self._check_bulley_alien_collision()

self.sprite.Group.copy()

功能：复制组类

属性：copy() -> Group

创建一个与原始组类具有相同精灵的新组类。如果有子类组类，则新对象将具有与原始对象相同的（子）类。仅当派生类的构造函数采用与组类相同的参数时，此操作才有效。

def _update_aliens(self):

"""检查是否有外星人位于屏幕边缘并即使更新整个外星舰队的位置"""

def _update_aliens(self):
    """检查是否有外星人位于屏幕边缘，并及时更新整个外星舰队的位置"""
    for alien in self.aliens.sprites():
        if alien.check_edges(): 
            # 如果有外星人到达屏幕两边，将整个外星战队向下移动，并改变他们的方向
            for alien1 in self.aliens.sprites():
                alien1.rect.y += self.setting.fleet_drop_speed
            self.setting.fleet_direction *= -1
    # 移动外星人战队
    self.aliens.update()
    # 检测外星人和飞船之间的碰撞
    if pygame.sprite.spritecollideany(self.ship,self.aliens):
        self._ship_hit()
    # 检测是否有外星人到达了屏幕的下边缘
    for alien2 in self.aliens.sprites():
        if alien2.rect.bottom >= self.setting.screen_height:
            # 如果有外星人到达了屏幕的下边缘,像飞船被撞到一样处理
            self._ship_hit()
            break

def _check_bullet_alien_collision(self):

"""响应子弹和外星人的碰撞"""

def _check_bullet_alien_collision(self):
    """响应子弹和外星人的碰撞"""
    # 删除发生碰撞的子弹和外星人
    collections = pygame.sprite.groupcollide(self.bullets,
                    self.aliens,True,True)
    if collections:
        for hit_aliens in collections.values():
            self.stats.score += self.setting.alien_points*len(hit_aliens)
        # 创建一副包含最新得分的新图像
        self.sb.prep_score()
        self.sb.check_high_score()

    if not self.aliens:
        # 已消灭整个外星人战队，删除现有的所有子弹，并创建一个新的外星舰队
        self.bullets.empty()
        self._create_aliens()
        self.setting.increase_speed()
        # 提升闯关等级
        self.stats.level +=1
        self.sb.prep_level()

def _ship_hit(self):

"""响应外星人和飞船的碰撞"""

def _ship_hit(self):
    """响应外星人和飞船的碰撞，同时也包括飞船抵达屏幕下边缘的情况处理"""
    if self.stats.ships_HP>0:
        # 将飞船的生命值ships_HP减一
        self.stats.ships_Hp -=1
        self.sb.prep_ship()
        # 清空外星人和子弹的列表
        self.aliens.empty()
        self.bullets.empty()
        # 创建一个新的外星舰队，并置于屏幕最下方中央
        self._create_aliens()
        self.ship.center_ship()
        # 暂停，让玩家可以看到外星人撞到了飞船
        sleep(0.5)
    else:
        # 飞船的生命值为0，游戏结束
        self.game_active = False
        pygame.mouse,set_visible(True)

settings.py

class Settings:

"""对游戏的一些外观上的设置可以直接在这里进行修改，在主要的运行代码的地方直接调用，修改的时候容易"""

def init(self):

"""初始化游戏的设置"""

    def __init__(self):
        """初始化游戏的静态设置"""
        self.screen_width = 1200
        self.screen_height = 800
        # 背景色
        self.bg_color = (224,255,255)

        # 飞船的生命值
        self.ship_speed=1.5
        self.ship_limit = 3
        # 关于子弹的相关设置
        self.bullet_speed =1.5
        self.bullet_allowed = 10

        self.speedup_scale = 1.1
        # 外星人分数的提高速度
        self.fleet_drop_speed = 3

        self.score_scale =1.5
        self.initialize_dynamic_settings()

def initialize_dynamic_settings(self):

"""初始化随游戏进行而变化的设置"""

    def initialize_dynamic_settings(self):
        """初始化随游戏进行而变化的设置"""
        self.ship_speed =1.5
        self.bullet_speed =3.0
        self.alien_speed = 1.0
        # 1表示向右，-1表示向左
        self.fleet_direction = 1
        # 计分设置
        self.alien_points = 50

def increase_speed(self):

"""提高速度的值"""

    def increase_speed(self):
        """提高速度的值"""
        self.ship_speed *= self.speedup_scale
        self.bullet_speed *= self.speedup_scale
        self.alien_speed *= self.speedup_scale
        self.alien_points = int(self.alien_points*self.score_scale)

ship.py

class Ship():

"""管理飞船的类"""

def init(self,ai_game):

"""初始化飞船并设置飞船的初始位置"""

def __init__(self,ai_game):
    """初始化飞船并设置其初始位置"""
    self.screen = ai_game.screen
    self.setting = ai_game.setting
    self.screen_rect = ai_game.screen.get_rect()
    # 插入飞船的图片，并获得外接矩形
    self.image = pygame.image.load()
    self.rect = self.image.get_rect()
    # 设置飞船的初始位置，每艘飞船都在屏幕底部的中央位置
    self.rect.midbottom = self.screen_rect.midbottom
    # 移动标志（飞船一开始不动）
    self.moving_right = False
    self.moving_left = False
    # 在飞船的属性x存储一个浮点数
    self.x = float(self.rect.x)

sprite模块是一个主要用来实现精灵的模块。

在pygame中，精灵可以认为是一张张可以在屏幕中移动的小图片，并且可以和其他图形对象交互。精灵可以是pygame绘制的图像，也可以是其他途径生成的图像。

在pygame中，精灵用Sprite对象来表示，使用时不需要实例化，而是继承这个类，然后按照需要写出自己的类即可。

每个Sprite类都必须有两个属性rect和image

def update(self):

"""根据移动标志调整飞船的位置"""

def update(self)
    """根据移动标志调整飞船的位置"""
    # 飞船可以移动，且在屏幕范围内
    if self.moving_right and self.rect.right < self.screen_rect.right:
        self.x += self.setting.ship_speed
    if self.moving_left and self.rect.left > 0:
        self.x -= self.setting.ship_speed
    
    # 根据self.x更新self.rect对象
    self.rect.x = self.x

def ship_paint(self) :

"""在self.rect指定位置上绘制飞船"""

def ship_paint(self):
    """绘制飞船在特定的位置上"""
    self.screen.blit(self.image,self.rect)

bullet.py

class Bullet(Sprite):

""""管理飞船所发射的子弹类"""

def init(self,ai_game):

"""在飞船的当前位置创建一个子弹对象"""

def __init__(self,ai_game):
    super().init__()
    self.screen = ai_game.screen
    self.setting = ai_game.setting
    
    # 加载子弹图像并设置其rect属性
    self.image = pygame.image.load("")
    self.rect = self.image.get_rect()
    # 设置初始位置
    self.rect.midtop = ai_game.ship.rect.midtop
    # 存储浮点数表示子弹的位置
    self.y =  float(self.rect.y)

def update(self):

"""向上移动子弹"""

def update(self):
    """向上移动子弹"""
    # 更新子弹的准确位置
    self.y -= self.setting.bullet_speed
    # 更新表示子弹rect的位置
    self.rect.y = self.y

alien.py

class Alien(Sprite):

"""表示单个外星人的类""""

def init(self,ai_game):

"""初始化外星人并设置其起始位置"""

def __init__(self,ai_game):
    super().__init__()
    # 设置外星人的初始位置
    self.screen = ai_game.screen
    self.setting = ai_game.setting
    # 加载外星人图像，并获取其rect值
    self.image = pygame.image.load("")
    self.rect = self.image.get_rect()
    # 设置外星人初始位置都在屏幕的左上方
    self.rect.x = self.rect.width
    self.rect.y = self.rect.height
    # 存储外星人精准的水平位置
    self.x = float(self.rect.x)

def update(self):

"""向右或向左移动外星人"""

def update(self)
    """向左或向右移动外星人"""
    self.x += self.setting.alien_speed*self.setting.fleet_direction
    self.rect.x = self.x

def check_edges(self):

"""如果外星人处于屏幕边缘，就返回True"""

def check_edges(self):
    """如果外星人位于屏幕边缘，就返回True"""
    screen_rect = self.screen.get_rect()
    return (self.rect.right >= screen_rect.right) or (self.rect.left<=0)

button.py

class Button:

"""为游戏创建按钮的类”“”

def init(self,ai_game,msg)：

"""初始化按钮的属性“”“

def __init__(self,ai_game,msg):
    """初始化按钮的属性"""
    self.screen = ai_game.screen
    self.screen_rect = self.screen.get_rect()
    # 设置按钮的尺寸和其他属性
    self.width,self.height = 250,80
    self.button_colcor = (0,135,0)
    self.text_color = (255,255,255)
    self.font = pygame.font.SysFont(None,48)
    
    # 创建按钮的rect对象，并使其居中
    self.rect = pygame.Rect(0,0,self.width,self.height)
    self.rect.center = self.screen_rect.center
    
    # 创建按钮的标志
    # 将msg渲染为图像，并使其在按钮上居中
    self.msg_image = self.font.render(msg,True,self.text_color,self.button_color)
    # 让文本图像在按钮上居中   
    self.msg_image_rect = self.msg_image.get_rect()
    self.msg_image_rect.center = self.rect.center

在pygame中，可以使用pygame中的button类来创建按钮。

首先需要定义按钮的位置和大小

然后使用pygame.draw.rect()函数绘制按钮的矩形框架

接着使用pygame.font.SysFont()函数定义按钮上的文字

最后使用blit()函数将文字渲染到按钮上。

为了检测按钮是否被点击，可以使用pygame.mouse.get_pos()函数获取鼠标的位置，然后使用pygame.Rect()函数创建一个矩形对象，检测鼠标是否在矩形范围内点击即可。

pygame.font.SysFont() 从系统字体库中创建一个Font对象

pygame.font.SysFont(name, size, bold=False, italic=False)

从系统字体库中加载并返回一个新的字体对象。该字体将会匹配 bold（加粗）和 italic（斜体）参数的要求。如果找不到一个合适的系统字体，该函数将会回退并加载默认的 pygame 字体。尝试搜索的 name 参数可以是一个用逗号隔开的列表。

pygame.font.Font() 从一个字体文件创建一个 Font 对象

pygame.font.Font(filename, size)

pygame.font.Font(object, size)

调用font.render()将存储在msg中的文本转换为图像，再将该图像存储在self.msg_image中。

font.render()方法还接受一个布尔实参，该实参指定是否开启反锯齿功能（反锯齿让文本的边缘更平滑）。余下的两个实参分别是文本颜色和背景颜色，若不指定背景色，则

pygame在渲染文本时将使用透明的背景。

方法：

pygame.font.Font.render() —— 在一个新 Surface 对象上绘制文本
pygame.font.Font.size() —— 确定多大的空间用于表示文本
pygame.font.Font.set_underline() —— 控制文本是否用下划线渲染
pygame.font.Font.get_underline() —— 检查文本是否绘制下划线
pygame.font.Font.set_bold() —— 启动粗体字渲染
pygame.font.Font.get_bold() —— 检查文本是否使用粗体渲染
pygame.font.Font.set_italic() —— 启动斜体字渲染
pygame.font.Font.metrics() —— 获取字符串参数每个字符的参数
pygame.font.Font.get_italic() —— 检查文本是否使用斜体渲染
pygame.font.Font.get_linesize() —— 获取字体文本的行高
pygame.font.Font.get_height() —— 获取字体的高度
pygame.font.Font.get_ascent() —— 获取字体顶端到基准线的距离
pygame.font.Font.get_descent() —— 获取字体底端到基准线的距离

def draw_button(self):

"""绘制一个用颜色填充的按钮,再绘制文本"""

def draw_button(self):
    """绘制一个用颜色填充的按钮，再绘制文本"""
    self.screen.fill(self.button_color,self.rect)
    self.screen.blit(self.msg_image,self.msg_image_rect)

在pygame中，fill()和blit()是两个常用的函数。fill()函数用于填充窗口的背景颜色，blit()函数用于将图像绘制到窗口上。

surface.fill(color, rect=None, special_flags=0)

其中color参数指定要填充的颜色，rect参数指定要填充的矩形区域，默认为整个窗口，special_flags参数指定特殊的填充标志。

surface.blit(source, dest, area=None, special_flags=0)

其中source参数指定要绘制的图像，dest参数指定要绘制到的位置，area参数指定要绘制的区域，默认为整个图像，special_flags参数指定特殊的绘制标志。

在pygame游戏开发中，fill()函数通常用于在每一帧更新前清空窗口，blit()函数则用于将游戏中的各种元素绘制到窗口上。

game_stats.py

class GameStats:

"""跟踪游戏的统计信息"""

def init(self,ai_game):

"""初始化统计信息"""

def __init__(self,ai_game):
    """跟踪游戏的统计信息"""
    self.setting = ai_game.setting
    self.reset_stats()
    # 任何情况下都不应该重置最高分
    self.high_score = 0

def reset_state(self):

"""初始化在游戏运行期间可能发生的统计信息"""

def reset_stats(self):
    """初始化再游戏运行期间可能改变的统计信息"""
    # 飞船的生命值
    self.ships_HP = self.setting.ship_limit
    # 得分
    self.score = 0
    # 游戏等级
    self.level = 1

scoreboard.py

class Scoreboard:

"""显示得分信息的类"""

import pygame.font
from pygame.sprite import Group
from ship import Ship

def init(self,ai_game):

"""初始化显示得分的属性"""

def __init__(self,ai_game):
    """初始化显示得分的属性"""
    self.ai_game = ai_game
    self.screen = ai_game.screen
    self.screen_rect = self.screen.get_rect()
    self.setting = ai_game.setting
    self.stats = ai_game.stats
    
    # 显示得分信息时使用的字体设置
    self.text_color = (30,30,30)
    # 字体对象
    self.font = pygame.font.SysFont(None,48)
    
    # 准备初始得分图像
    self.prep_score()
    # 准备包含最高分的图像
    self.prep_high_score()
    # 准备包含闯关等级的图像
    self.prep_level()
    # 准备飞船生命值的图像
    self.prep_ships()

def prep_score(self):

"""将得分渲染为图像"""

def prep_score（self):
    """将得分渲染为图像"""
    rounded_score = round(self.stats.score, -1)
    score_str = f"{rounded_score:,}"
    self.score_image = self.font.render(score_str,True,self.text_color,
            self.setting.bg_color)
    
    # 在屏幕右上角显示得分
    self.score_rect = self.score_image.get_rect()
    self.score_rect.right = self.screen_rect.right - 20
    self.score_rect.top = 15

def prep_high_score(self):

"""将最高分渲染为图像”“”

def prep_high_score(self):
    """将最高分渲染为图像"""
    high_score = round(self.stats.high_score,-1)
    high_score_str = f"{high_score:,}"
    self.high_score_image = self.font.render(high_score_str,True,
            self.text_color,self.setting.bg_color)
    # 将最高分置于屏幕顶部中央
    self.high_score_rect = self.high_score_image.get_rect()
    self.high_score_rect.center = self.screen_rect.centerx
    self.high_score_rect.top = self.screen_rect.top + 15

round()函数通常让浮点数（第一个实参）精确到小数点后某一位，其中的小数位数是由第二个实参指定。如果将第二个实参指定为负数，round()会将第一个实参舍入到最近的10的整数倍，如10、100、1000等。这里是让python将数字舍入到最近的10的整数倍

在表示得分的f字符串中使用一个格式说明符，格式说明符是一个特殊的字符序列，用于指定如何显示变量的值。这里使用的字符序列为冒号和逗号（：，），它让Python在数值的合适位置插入逗号，生成的字符串类似于1，000，000（而不是1000000）

def prep_level(self):

"""将等级渲染为图像"""

def prep_level(self):
    """将等级渲染为图像"""
    level_str = str(self.stats.level)
    self.level_image = self.font.render(level_str,True,
            self.text_color,self.setting.bg_color)
    # 将等级置于得分下方
    self.level_rect = self.level_image.get_rect()
    self.level_rect.centerx = self.score_rect.centerx
    self.level_rect.top = self.score_rect.bottom +10

def prep_ships(self):

"""显示飞船的生命值"""

def prep_ships(self):
    """显示飞船的生命值"""
    self.ships = Group()
    for ship_number in range(self.stats.ships_HP):
        ship = Ship(self.ai_game)
        ship.rect.x = 10+ship_numbers*ship.rect.width
        ship.rect.y = 10
        self.ships.add(ship)

def check_high_score(self):

"""检查是否诞生了新的最高分"""

def check_high_score(self):
    """检查是否诞生了新的最高分"""
    if self.stats.score > self.stats.high_score:
        self.stats.high_score = self.stats.score
        self.prep_high_score()

def show_score(self):

"""在屏幕上显示得分"""

def show_score(self):
    """在屏幕上显示得分"""
    self.screen.blit(self.score_image,self.score_rect)
    self.screen.blit(self.high_score_image,self.high_score_rect)
    self.screen.blit(self.level,self.level_rect)
    self.ship.draw(self.screen)

pygame.screen.blit(source, dest, area=None, special_flags=0) 将一个Surface实例绘制到屏幕上。

source是要绘制的Surface实例

dest是绘制的位置，通常是一个元组，表示左上角的坐标。

area是一个矩形，表示要绘制的区域，如果不指定，则绘制整个Surface。

special_flags是一个可选参数，表示特殊的绘制标志。该方法可以用于在游戏中绘制角色、背景等图像

编程中遇到的问题：

1、拼写错误

解决方法：

2、在程序运行时，需切换到英文状态下，输入q才可以结束程序中文状态下输入q程序不会结束，是无效的在全屏模式下运行游戏时，一定要确认是否能够按下q键退出，因为Pygame 不提供在全屏模式下退出游戏的默认方式

3、行缩进问题：在python中，行缩进出现错误会影响代码的运行结果

4、在插入图片的过程中，一定要注意图片的尺码，比如说，插入外星人图片，但外星人图片尺码过大，就可能造成这种现象：视觉上看不到外星人，但实际已经插入了，这时候就需要尝试调整图片到合适大小

5、代码的先后顺序，Ship类中调用了setting

解决方法：

最终界面呈现：

才不会有稗子

关注

3
点赞
踩
6

收藏

觉得还不错? 一键收藏
3
评论
Python外星人入侵游戏

这里使用的字符序列为冒号和逗号（：，），它让Python在数值的合适位置插入逗号，生成的字符串类似于1，000，000（而不是1000000）4、在插入图片的过程中，一定要注意图片的尺码，比如说，插入外星人图片，但外星人图片尺码过大，就可能造成这种现象：视觉上看不到外星人，但实际已经插入了，这时候就需要尝试调整图片到合适大小。其中source参数指定要绘制的图像，dest参数指定要绘制到的位置，area参数指定要绘制的区域，默认为整个图像，special_flags参数指定特殊的绘制标志。
复制链接

扫一扫