Python项目 外星人入侵游戏

最新推荐文章于 2024-04-08 16:10:56 发布
最新推荐文章于 2024-04-08 16:10:56 发布
阅读量2.3k 收藏 81
点赞数 23
分类专栏： Python入门项目（C语言基础） 文章标签： python 游戏开发 pygame
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/while_BLUE_/article/details/107367583
版权

终于开始入门项目了，使用Pygame包，跟着教程的过程敲打游戏来学习，做了自己的笔记
文末有完整项目代码,或者点这 -->链接

目标

在游戏《外星人入侵》中，玩家控制着一艘最初出现在屏幕底部中央的飞船。玩家可以使用箭头键左右移动飞船，还可使用空格键进行射击。游戏开始时，一群外星人出现在天空中，他们在屏幕中向下移动。玩家的任务是射杀这些外星人。玩家将所有外星人都消灭干净后，将出现一群新的外星人，他们移动的速度更快。只要有外星人撞到了玩家的飞船或到达了屏幕底部，玩家就损失一艘飞船。玩家损失三艘飞船后，游戏结束。

环境

  • 安装Pygame
    在Windows系统中用pip安装Pygame：
    在DOS界面输入：
python -m pip install --user pygame-1.9.2a0-cp35-none-win32.whl

即可安装

  • 使用VS Code进行编写

开始

1.设置游戏环境

1.1 创建Pygame 窗口以及响应用户输入

首先，我们要创建一个空的Pygame窗口，在新文件夹中创建了window.py作为窗口文件。
然后使用Pygame编写的游戏的基本结构如下：

window.py

import sys
import pygame

def run_game():
    #初始化游戏并创建一个屏幕对象
    pygame.init()
    screen = pygame.display.set_mode((1200,800))#设置窗口大小
    pygame.display.set_caption("Alien Invasion 1.0")#窗口名称

    #开始游戏的主循环
    while True:
        #监视键盘和鼠标事件
        for event in pygame.event.get():
            if event.type == pygame.QUIT:#检测玩家单击游戏窗口的关闭按钮，调用sys.exit()退出
                sys.exit()

        #让最近绘制的屏幕可见
        pygame.display.flip()

run_game()
  • 对象screen是一个surface。在Pygame中， surface是屏幕的一部分，用于显示游戏元素。在这
    个游戏中，每个元素（如外星人或飞船）都是一个surface。 display.set_mode()返回的surface表
    示整个游戏窗口。我们激活游戏的动画循环后，每经过一次循环都将自动重绘这个surface。
  • pygame.display.flip()，命令Pygame让最近绘制的屏幕可见。在这里，它在每次执行while循环时都绘制一个空屏幕，并擦去旧屏幕，使得只有新屏幕可见。在我们移动游戏元素时， pygame.display.flip()将不断更新屏幕，以显示元素的新位置，并在原来的位置隐藏元素，从而营造平滑移动的效果。

运行后生成空窗口，如下：
在这里插入图片描述

1.2 设置背景色

调用方法screen.fill()，用背景色填充屏幕

import sys
import pygame


def run_game():
    # 初始化游戏并创建一个屏幕对象
    pygame.init()
    screen = pygame.display.set_mode((1200,800))# 设置窗口大小
    pygame.display.set_caption("Alien Invasion 1.0")# 窗口名称

    # 设置背景色
    bg_color = (230,230,230)

    # 开始游戏的主循环
    while True:
        # 监视键盘和鼠标事件
        for event in pygame.event.get():
            if event.type == pygame.QUIT:# 检测玩家单击游戏窗口的关闭按钮，调用sys.exit()退出
                sys.exit()

        # 每次循环时都重绘屏幕
        screen.fill(bg_color)
        #让最近绘制的屏幕可见
        pygame.display.flip()

run_game()

1.3整合成类

每次给游戏添加新功能时，通常也将引入一些新设置。下面来编写一个名为settings的模块，其中包含一个名为Settings的类，用于将所有设置存储在一个地方，以免在代码中到处添加设置。这样，我们就能传递一个设置对象，而不是众多不同的设置。另外，这让函数调用更简单，且在项目增大时修改游戏的外观更容易：要修改游戏，只需修改settings.py中的一些值，而无需查找散布在文件中的不同设置。

首先新建文件命名为：settings.py

setting.py

class Settings():
    """存储所有设置的类"""

    def __init__(self):
        """初始化游戏的设置"""

        # 屏幕设置
        self.screen_width = 1200
        self.screen_height = 800
        self.bg_color = (230,230,230)

再把设置导入window.py中
window.py

import sys
import pygame

from settings import Settings

def run_game():
    # 初始化pygame、设置和屏幕对象
    pygame.init()
    ai_settings=Settings()
    screen = pygame.display.set_mode(
        (ai_settings.screen_width,ai_settings.screen_height))# 设置窗口大小
    pygame.display.set_caption("Alien Invasion 1.0")# 窗口名称

    # 设置背景色
    bg_color = (230,230,230)

    # 开始游戏的主循环
    while True:
        # 监视键盘和鼠标事件
        for event in pygame.event.get():
            if event.type == pygame.QUIT:# 检测玩家单击游戏窗口的关闭按钮，调用sys.exit()退出
                sys.exit()

        # 每次循环时都重绘屏幕
        screen.fill(ai_settings.bg_color)
        #让最近绘制的屏幕可见
        pygame.display.flip()

run_game()

2.添加飞船图像

下面将飞船加入到游戏中。为了在屏幕上绘制玩家的飞船，我们将加载一幅图像，再使用Pygame方法blit( )绘制它。
新建文件夹images，把下图右键复制到images中，命名ship.bmp
在这里插入图片描述

2.1创建ship类

选择用于表示飞船的图像后，需要将其显示到屏幕上。我们将创建一个名为ship的模块，其中包含Ship类，它负责管理飞船的大部分行为。

ship.py

import pygame

class Ship():
    
    def __init__(self,screen):
        """初始化飞船并设置其初始位置"""
        self.screen = screen

        # 加载飞船图像并获取其外接矩形
        self.image = pygame.image.load('images/ship.bmp')
        self.rect = self.image.get_rect()
        self.screen_rect = screen.get_rect()

        # 将每艘新飞船放在屏幕底部中央
        self.rect.centerx = self.screen_rect.centerx
        self.rect.bottom = self.screen_rect.bottom

    def blitme(self):
        """在指定位置绘制飞船"""
        self.screen.blit(self.image,self.rect)
  • Ship的方法__init__()接受两个参数：引用self和screen，其中后者指定了要将飞船绘制到什么地方。为加载图像，我们调用了pygame.image.load()。这个函数返回一个表示飞船的surface，而我们将这个surface存储到了elf.image中。
  • 处理rect对象时，可使用矩形四角和中心的x和y坐标。可通过设置这些值来指定矩形的位置
  • 要将游戏元素居中，可设置相应rect对象的属性center、 centerx或centery。要让游戏元素与屏幕边缘对齐，可使用属性top、 bottom、 left或right；要调整游戏元素的水平或垂直位置，可使用属性x和y，它们分别是相应矩形左上角的x和y坐标。
  • 我们将把飞船放在屏幕底部中央。为此，首先将表示屏幕的矩形存储在self.screen_rect中,再将self.rect.centerx（飞船中心的x坐标）设置为表示屏幕的矩形的属性centerx,并将self.rect.bottom（飞船下边缘的y坐标）设置为表示屏幕的矩形的属性bottom。 Pygame将使用这些rect属性来放置飞船图像，使其与屏幕下边缘对齐并水平居中。

2.2在屏幕上绘制飞船

接下来更新window.py，使其创建一艘飞船

window.py

import sys
import pygame

from settings import Settings
from ship import Ship

def run_game():
    # 初始化pygame、设置和屏幕对象
    pygame.init()
    ai_settings=Settings()
    screen = pygame.display.set_mode(
        (ai_settings.screen_width,ai_settings.screen_height))# 设置窗口大小
    pygame.display.set_caption("Alien Invasion 1.0")# 窗口名称

    # 设置背景色
    bg_color = (230,230,230)

    # 创建飞船
    ship = Ship(screen)
    # 开始游戏的主循环
    while True:
        # 监视键盘和鼠标事件
        for event in pygame.event.get():
            if event.type == pygame.QUIT:# 检测玩家单击游戏窗口的关闭按钮，调用sys.exit()退出
                sys.exit()

        # 每次循环时都重绘屏幕
        screen.fill(ai_settings.bg_color)
        ship.blitme()
        # 让最近绘制的屏幕可见
        pygame.display.flip()

run_game()

运行之后就有一艘小飞船啦
在这里插入图片描述

3.重构：模块game_functions

写到这里，window.py里的代码行越来越多，为方便理解逻辑，给window.py瘦身，创建一个名为game_functions的新模块，它将存储大量让游戏《外星人入侵》运行的函数。
首先把管理事件的代码移到一个名为check_events()的函数中，以简化run_game()并隔离事件管理循环。通过隔离事件循环，可将事件管理与游戏的其他方面（如更新屏幕）分离。

game_functions.py

import sys

import pygame

def check_events():
    """响应按键和鼠标事件"""
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()

def update_screen(ai_settings,screen,ship):
    """更新屏幕上的图像，并切换到新屏幕"""
    # 每次循环时都重绘屏幕
    screen.fill(ai_settings.bg_color)
    ship.blitme()
    # 让最近绘制的屏幕可见
    pygame.display.flip()

在window.py中就可以简化为相应函数：

import sys
import pygame

from settings import Settings
from ship import Ship
import game_functions as gf

def run_game():
    # 初始化pygame、设置和屏幕对象
    pygame.init()
    ai_settings=Settings()
    screen = pygame.display.set_mode(
        (ai_settings.screen_width,ai_settings.screen_height))# 设置窗口大小
    pygame.display.set_caption("Alien Invasion 1.0")# 窗口名称

    # 设置背景色
    bg_color = (ai_settings.bg_color)

    # 创建飞船
    ship = Ship(screen)
    # 开始游戏的主循环
    while True:
        gf.check_events()
        gf.update_screen(ai_settings,screen,ship)
        

run_game()

4.驾驶飞船

下面来让玩家能够左右移动飞船。

4.1响应按键

  • 每当用户按键时，都将在Pygame中注册一个事件。事件都是通过方法pygame.event.get()获取的，因此在函数check_events()中，我们需要指定要检查哪些类型的事件。每次按键都被注册为一个KEYDOWN事件。
  • 检测到KEYDOWN事件时，我们需要检查按下的是否是特定的键。例如，如果按下的是右箭头键，我们就增大飞船的rect.centerx值，将飞船向右移动
  • 添加标志位：属性self.moving_right，并将其初始值设置为False，当按下右键，飞船就一直向右移动，松开就停止
  • 在ship.py中添加方法update()检查标志moving_right的状态，如果这个标志为True，就调整飞船的位置。
  • 如法炮制向左的按键

ship.py

import pygame

class Ship():
    
    def __init__(self,screen):
        """初始化飞船并设置其初始位置"""
        self.screen = screen

        # 加载飞船图像并获取其外接矩形
        self.image = pygame.image.load('images/ship.bmp')
        self.rect = self.image.get_rect()
        self.screen_rect = screen.get_rect()

        # 将每艘新飞船放在屏幕底部中央
        self.rect.centerx = self.screen_rect.centerx
        self.rect.bottom = self.screen_rect.bottom

        # 移动标志
        self.moving_right = False
        self.moving_left = False

    def update(self):
        """根据移动标志调整飞船的位置"""
        if self.moving_right:
            self.rect.centerx +=1
        if self.moving_left:
            self.rect.centerx -=1

    def blitme(self):
        """在指定位置绘制飞船"""
        self.screen.blit(self.image,self.rect)

game_functions.py

import sys

import pygame

def check_events(ship):
    """响应按键和鼠标事件"""
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_RIGHT:
                ship.moving_right = True
            elif event.key == pygame.K_LEFT:
                ship.moving_left = True

        elif event.type == pygame.KEYUP:
            if event.key == pygame.K_RIGHT:
                ship.moving_right = False
            elif event.key == pygame.K_LEFT:
                ship.moving_left = False

def update_screen(ai_settings,screen,ship):
    """更新屏幕上的图像，并切换到新屏幕"""
    # 每次循环时都重绘屏幕
    screen.fill(ai_settings.bg_color)
    ship.blitme()
    # 让最近绘制的屏幕可见
    pygame.display.flip()

window.py

import sys
import pygame

from settings import Settings
from ship import Ship
import game_functions as gf

def run_game():
    # 初始化pygame、设置和屏幕对象
    pygame.init()
    ai_settings=Settings()
    screen = pygame.display.set_mode(
        (ai_settings.screen_width,ai_settings.screen_height))# 设置窗口大小
    pygame.display.set_caption("Alien Invasion 1.0")# 窗口名称

    # 设置背景色
    bg_color = (ai_settings.bg_color)

    # 创建飞船
    ship = Ship(screen)
    # 开始游戏的主循环
    while True:
        gf.check_events(ship)
        ship.update()
        gf.update_screen(ai_settings,screen,ship)
        

run_game()

4.2调整飞船速度

  • 在Settings类中添加属性ship_speed_factor，用于控制飞船的速度。

代码太长，就用snip跳过之前没改动的代码

settings.py

class Settings():
"""存储所有设置的类"""
def __init__(self):
	--snip--
	# 飞船的设置
	self.ship_speed_factor = 1.5

rect的centerx等属性只能存储整数值，因此我们需要对Ship类做些修改：

class Ship():
	def __init__(self, ai_settings, screen):
	"""初始化飞船并设置其初始位置"""
	self.screen = screen
	self.ai_settings = ai_settings
	--snip--
	# 在飞船的属性center中存储小数值
	self.center = float(self.rect.centerx)

def update(self):
	"""根据移动标志调整飞船的位置"""
	# 更新飞船的center值，而不是rect
	if self.moving_right:
		self.center += self.ai_settings.ship_speed_factor
	if self.moving_left:
		self.center -= self.ai_settings.ship_speed_factor

	# 根据self.center更新rect对象
	self.rect.centerx = self.center

window.py

--snip--
def run_game():
	--snip--
	# 创建飞船
	ship = Ship(ai_settings, screen)

现在，只要ship_speed_factor的值大于1，飞船的移动速度就会比以前更快。这有助于让飞船的反应速度足够快，能够将外星人射下来，还让我们能够随着游戏的进行加快游戏的节奏

4.3限制飞船活动范围

当前，如果玩家按住箭头键的时间足够长，飞船将移到屏幕外面。

  • 修改Ship类的方法update（）
def update(self):
        """根据移动标志调整飞船的位置"""
        # 更新飞船的center值，而不是rect
		if self.moving_right and self.rect.right < self.screen_rect.right:
            self.center += self.ai_settings.ship_speed_factor
        if self.moving_left and self.rect.left > 0:
            self.center -= self.ai_settings.ship_speed_factor

4.4重构check_events()

老样子，随着游戏开发的进行，函数check_events()将越来越长，我们将其部分代码放在两个函数中：一个处理KEYDOWN事件，另一个处理KEYUP事件：

game_functions.py

import sys

import pygame

def check_keydown_events(event,ship):
    """响应按键"""
    if event.key == pygame.K_RIGHT:
        ship.moving_right = True
    elif event.key == pygame.K_LEFT:
        ship.moving_left = True

def check_keyup_events(event,ship):
	"""响应松开"""
    if event.key == pygame.K_RIGHT:
        ship.moving_right = False
    elif event.key == pygame.K_LEFT:
        ship.moving_left = False

def check_events(ship):
    """响应按键和鼠标事件"""
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()
        elif event.type == pygame.KEYDOWN:
            check_keydown_events(event,ship)
        elif event.type == pygame.KEYUP:
            check_keyup_events(event,ship)

def update_screen(ai_settings,screen,ship):
    """更新屏幕上的图像，并切换到新屏幕"""
    # 每次循环时都重绘屏幕
    screen.fill(ai_settings.bg_color)
    ship.blitme()
    # 让最近绘制的屏幕可见
    pygame.display.flip()

5.射击

下面来添加射击功能。我们将编写玩家按空格键时发射子弹（小矩形）的代码。子弹将在屏幕中向上穿行，抵达屏幕上边缘后消失。

5.1添加子弹设置

选择填在setting.py中，在__init__()末尾存储新类Bullet所需的值

settings.py

def __init__(self):
	--snip--
	# 子弹设置
	self.bullet_speed_factor = 1
	self.bullet_width = 3
	self.bullet_height = 15
	self.bullet_color = 60, 60, 60

这些设置创建宽3像素、高15像素的深灰色子弹。子弹的速度比飞船稍低.

5.2创建Bullet类

新建bullet.py

bullet.py


import pygame
from pygame.sprite import Sprite

class Bullet(Sprite):
    """一个对飞船发射子弹管理的类"""
    def __init__(self,ai_settings,screen,ship):
        """在飞船说出的位置创建一个子弹对象"""    
        super().__init__()
        self.screen = screen

        # 在（0，0）创建一个表示子弹的矩阵，再设置正确的位置
        self.rect = pygame.Rect(0,0,ai_settings.bullet_width,ai_settings.bullet_height)
        self.rect.centerx = ship.rect.centerx
        self.rext.top = ship.rect.top

        # 存储用小数表示的子弹位置
        self.y = float(self.rect.y)

        self.color = ai_settings.bullet_color
        self.speed_factor = ai_settings.bullet_speed_factor

    def uppdate(self):
        """向上移动子弹"""
        # 更新表示子弹位置的小数值
        self.y -= self.speed_factor
        # 更新表示子弹的rect的位置
        self.rect.y = self.y

    def draw_bullet(self):
        """在屏幕上绘制子弹"""
        pygame.draw.rect(self.screen, self.color, self.rect)
  • Bullet类继承了我们从模块pygame.sprite中导入的Sprite类。通过使用精灵，可将游戏中相关的元素编组，进而同时操作编组中的所有元素。为创建子弹实例，需要向__init__()传递ai_settings、 screen和ship实例，还调用了super()来继承Sprite。
  • 我们创建了子弹的属性rect。子弹并非基于图像的，因此我们必须使用pygame.Rect()类从空白开始创建一个矩形。创建这个类的实例时，必须提供矩形左上角的x坐标和y坐标，还有矩形的宽度和高度。我们在(0, 0)处创建这个矩形，但接下来的两行代码将其移到了正确的位置，因为子弹的初始位置取决于飞船当前的位置。子弹的宽度和高度是从ai_settings中获取的。
  • 子弹的颜色和速度设置分别存储到self.color和self.speed_factor中
  • 方法update()管理子弹的位置。发射出去后，子弹在屏幕中向上移动，这意味着y坐标将不断减小，因此为更新子弹的位置，我们从self.y中减去self.speed_factor的值
  • 属性speed_factor让我们能够随着游戏的进行或根据需要提高子弹的速度，以调整游戏的行为。子弹发射后，其x坐标始终不变，因此子弹将沿直
    线垂直地往上穿行。

5.3 将子弹存储到编组中

  • 首先，在window.py中创建一个编组（ group），用于存储所有有效的子弹，以便能够管理发射出去的所有子弹。这个编组将是pygame.sprite.Group类的一个实例； pygame.sprite.Group类类似于列表，但提供了有助于开发游戏的额外功能。在主循环中，我们将使用这个编组在屏幕上绘制子弹，以及更新每颗子弹的位置：

window.py

import sys
import pygame
from pygame.sprite import Group

from settings import Settings
from ship import Ship
import game_functions as gf

def run_game():
    # 初始化pygame、设置和屏幕对象
    pygame.init()
    ai_settings=Settings()
    screen = pygame.display.set_mode(
        (ai_settings.screen_width,ai_settings.screen_height))# 设置窗口大小
    pygame.display.set_caption("Alien Invasion 1.0")# 窗口名称

    # 设置背景色
    bg_color = (ai_settings.bg_color)

    # 创建飞船
    ship = Ship(ai_settings,screen)
    # 创建一个用于存储子弹的编组
    bullets = Group()
    # 开始游戏的主循环
    while True:
        gf.check_events(ai_settings,screen,ship,bullets)
        ship.update()
        bullets.update()
        gf.update_screen(ai_settings,screen,ship,bullets)
        

run_game()

5.4开火

  • 在game_functions.py中，我们需要修改check_keydown_events()，以便在玩家按空格键时发射一颗子弹。我们无需修改check_keyup_events()，因为玩家松开空格键时什么都不会发生。我们还需修改update_screen()，确保在调用flip()前在屏幕上重绘每颗子弹。下面是对game_functions.py所做的相关修改：

game_functions.py

import sys
import pygame
from pygame.sprite import Group

from settings import Settings
from ship import Ship
import game_functions as gf

def run_game():
    # 初始化pygame、设置和屏幕对象
    pygame.init() 
    ai_settings=Settings()
    screen = pygame.display.set_mode(
        (ai_settings.screen_width,ai_settings.screen_height))# 设置窗口大小
    pygame.display.set_caption("Alien Invasion 1.0")# 窗口名称

    # 设置背景色
    bg_color = (ai_settings.bg_color)

    # 创建飞船
    ship = Ship(ai_settings,screen)
    # 创建一个用于存储子弹的编组
    bullets = Group()
    # 开始游戏的主循环
    while True:
        gf.check_events(ai_settings,screen,ship,bullets)
        ship.update()
        bullets.update()
        gf.update_screen(ai_settings,screen,ship,bullets)
        

run_game()
  • 编组bulltes传递给了check_keydown_events()。玩家按空格键时，创建一颗新子弹（一个名为new_bullet的Bullet实例），并使用方法add()将其加入到编组bullets中、代码bullets.add(new_bullet)将新子弹存储到编组bullets中。
  • 我 们 给 在 屏 幕 上 绘 制 子 弹 的 update_screen() 添 加 了 形 参 bullets 。 方 法bullets.sprites()返回一个列表，其中包含编组bullets中的所有精灵。为在屏幕上绘制发射的所有子弹，我们遍历编组bullets中的精灵，并对每个精灵都调用draw_bullet()。

5.5删除已消失的子弹

当前，子弹抵达屏幕顶端后消失，这仅仅是因为Pygame无法在屏幕外面绘制它们。这些子弹实际上依然存在，它们的y坐标为负数，且越来越小。这是个问题，因为它们将继续消耗内存和处理能力。
我们需要将这些已消失的子弹删除，否则游戏所做的无谓工作将越来越多，进而变得越来越慢。为此，我们需要检测这样的条件，即表示子弹的rect的bottom属性为零，它表明子弹已穿过屏幕顶端：

window.py

--snip--
# 开始游戏的主循环
    while True:
        gf.check_events(ai_settings,screen,ship,bullets)
        ship.update()
        bullets.update()

        #删除已消失的子弹
        for bullet in bullets.copy():
            if bullet.rect.bottom <=0 :
                bullets.remove(bullet)
        print(len(bullets))

        gf.update_screen(ai_settings,screen,ship,bullets)
  • 在for循环中，不应从列表或编组中删除条目，因此必须遍历编组的副本。我们使用了方法copy()来设置for循环
  • 使用了一条print语句，以显示当前还有多少颗子弹，从而核实已消失的子弹确实删除了
  • 如果这些代码没有问题，我们发射子弹后查看终端窗口时，将发现随着子弹一颗颗地在屏幕顶端消失，子弹数将逐渐降为零。运行这个游戏并确认子弹已被删除后，将这条print语句删除
    在这里插入图片描述
    在这里插入图片描述

5.6限制子弹数量

很多射击游戏都对可同时出现在屏幕上的子弹数量进行限制，以鼓励玩家有目标地射击。

  • 首先，在settings.py中存储所允许的最大子弹数：

settings.py

--snip--
# 子弹设置
self.bullet_width = 3
self.bullet_height = 15
self.bullet_color = 60, 60, 60
self.bullets_allowed = 3

这将未消失的子弹数限制为3颗。在game_functions.py的check_keydown_events()中，我们在创建新子弹前检查未消失的子弹数是否小于该设置：

def check_keydown_events(event, ai_settings, screen, ship, bullets):
   --snip--
	# 创建一颗子弹，并将其加入到编组bullets中
	if len(bullets) < ai_settings.bullets_allowed:
		new_bullet = Bullet(ai_settings, screen, ship)
		bullets.add(new_bullet)

5.7重构

再瘦身

  • 把window.py中删除已消失的子弹代码移动到game_functions.py中，命名为update_bullets()
  • 创建函数 fire_bullet()，把发射子弹的代码移到一个fire_bullet函数中，这样，在check_keydown_events()中只需使用一行代码来发射子弹，让elif代码块变得非常简单

game_functions.py

import sys

import pygame
from bullet import Bullet

def check_keydown_events(event, ai_settings, screen, ship, bullets):
    """响应按键"""
    if event.key == pygame.K_RIGHT:
        ship.moving_right = True
    elif event.key == pygame.K_LEFT:
        ship.moving_left = True
    elif event.key == pygame.K_SPACE:
        fire_bullet(ai_settings, screen, ship, bullets)
        

def fire_bullet(ai_settings, screen, ship, bullets):
    """如果还没有到达限制，就发射一颗子弹"""
    # 创建一颗子弹，并将其加入到编组bullets中
    if len(bullets) < ai_settings.bullets_allowed:
        new_bullet = Bullet(ai_settings, screen, ship)
        bullets.add(new_bullet)

def check_keyup_events(event,ship):
    """响应松开"""
    if event.key == pygame.K_RIGHT:
        ship.moving_right = False
    elif event.key == pygame.K_LEFT:
        ship.moving_left = False

def check_events(ai_settings, screen, ship, bullets):
    """响应按键和鼠标事件"""
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()
        elif event.type == pygame.KEYDOWN:
            check_keydown_events(event, ai_settings, screen, ship, bullets)
        elif event.type == pygame.KEYUP:
            check_keyup_events(event,ship)

def update_screen(ai_settings, screen, ship, bullets):
    """更新屏幕上的图像，并切换到新屏幕"""
    # 每次循环时都重绘屏幕
    screen.fill(ai_settings.bg_color)
    # 在飞船和外星人后面重绘所有子弹
    for bullet in bullets.sprites():
        bullet.draw_bullet()
    ship.blitme()
    # 让最近绘制的屏幕可见
    pygame.display.flip()

def update_bullets(bullets):
    """更新子弹的位置，并删除已消失的子弹"""
    # 更新子弹的位置
    bullets.update()

    #删除已消失的子弹
    for bullet in bullets.copy():
        if bullet.rect.bottom <=0 :
            bullets.remove(bullet)

window.py

--snip--
while True:
        gf.check_events(ai_settings,screen,ship,bullets)
        ship.update()
        gf.update_bullets(bullets)
        gf.update_screen(ai_settings,screen,ship,bullets)

6.创建外星人

6.1选一个合适的敌人

在这里插入图片描述
右键另存为alien.bmp到images

6.2创建 Alien 类

  • 新建alien.py

alien.py

import pygame
from pygame.sprite import Sprite

class Alien(Sprite):
    """表示单个外星人的类"""
    def __init__(self, ai_settings, screen):
        """初始化外星人并设置其起始位置"""
        super().__init__()
        self.screen = screen
        self.ai_settings = ai_settings
        # 加载外星人图像，并设置其rect属性
        self.image = pygame.image.load('images/alien.bmp')
        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 blitme(self):
        """在指定位置绘制外星人"""
        self.screen.blit(self.image, self.rect)

除位置不同外，这个类的大部分代码都与Ship类相似。每个外星人最初都位于屏幕左上角附近，将每个外星人的左边距都设置为外星人的宽度，并将上边距设置为外星人的高度
在window.py中创建实例

window.py

--snip--
from ship import Ship
from alien import Alien
import game_functions as gf
def run_game():
	--snip--
	# 创建一个外星人
	alien = Alien(ai_settings, screen)
	# 开始游戏主循环
	while True:
		gf.check_events(ai_settings, screen, ship, bullets)
		ship.update()
		gf.update_bullets(bullets)
		gf.update_screen(ai_settings, screen, ship, alien, bullets)
run_game()

而后在game_functions.py中函数update_screen()调用其方法blitme()：
game_functions.py

def update_screen(ai_settings, screen, ship, alien, bullets):
	--snip--
	ship.blitme()
	alien.blitme()

6.3创建多个敌人

*alien_invasion.py

def run_game():
	--snip--
    # 创建一艘飞船、一个子弹编组和一个外星人编组
    ship = Ship(ai_settings,screen)
    bullets = Group()
    aliens = Group()
    # 创建外星人群
    gf.create_fleet(ai_settings, screen, aliens)
    # 开始游戏主循环
	while True:
		--snip—
		gf.update_screen(ai_settings, screen, ship, aliens, bullets)

在game_functions.py末尾创建函数create_fleet()

game_functions.py

from alien import Alien
--snip--

def create_fleet(ai_settings, screen, aliens):
    """创建外星人群"""
    # 创建一个外星人，并计算一行可容纳多少个外星人
    # 外星人间距为外星人宽度
    alien = Alien(ai_settings, screen)
    alien_width = alien.rect.width
    available_space_x = ai_settings.screen_width - 2 * alien_width
    number_aliens_x = int(available_space_x / (2 * alien_width))

    # 创建第一行外星人
    for alien_number in range(number_aliens_x):
        # 创建一个外星人并将其加入当前行
        alien = Alien(ai_settings, screen)
        alien.x = alien_width + 2 * alien_width * alien_number
        alien.rect.x = alien.x
        aliens.add(alien)

6.4重构create_fleet()

下面是create_fleet()和两个新函数， get_number_aliens_x()和create_alien()：

game_functions.py

--snip--
def get_number_aliens_x(ai_settings, alien_width):
    """计算每行可容纳多少个外星人"""
    available_space_x = ai_settings.screen_width - 2 * alien_width
    number_aliens_x = int(available_space_x / (2 * alien_width))
    return number_aliens_x

def create_alien(ai_settings, screen, aliens, alien_number):
    """创建一个外星人并将其放在当前行"""
    alien = Alien(ai_settings, screen)
    alien_width = alien.rect.width
    alien.x = alien_width + 2 * alien_width * alien_number
    alien.rect.x = alien.x
    aliens.add(alien)

def create_fleet(ai_settings, screen, aliens):
    """创建外星人群"""
    # 创建一个外星人，并计算一行可容纳多少个外星人
    # 外星人间距为外星人宽度
    alien = Alien(ai_settings, screen)
    number_aliens_x = get_number_aliens_x(ai_settings, alien.rect.width)

    # 创建第一行外星人
    for alien_number in range(number_aliens_x):
        create_alien(ai_settings, screen, aliens, alien_number)

6.5添加行

产生多行敌人
需要计算屏幕可容纳多少行，并对创建一行外星人的循环重复相应的次数。
为计算可容纳的行数，我们这样计算可用垂直空间：将屏幕高度减去第一行外星人的上边距（外星人高度）、飞船的高度以及最初外星人群与飞船的距离（外星人高度的两倍）：

available_space_y = ai_settings.screen_height – 3 * alien_height – ship_height

这将在飞船上方留出一定的空白区域，给玩家留出射杀外星人的时间。
每行下方都要留出一定的空白区域，并将其设置为外星人的高度。为计算可容纳的行数，我们将可用垂直空间除以外星人高度的两倍（同样，如果这样的计算不对，我们马上就能发现，继而将间距调整为合理的值）

number_rows = available_height_y / (2 * alien_height)

然后把公式添加到game_functions.py中

game_functions.py

--snip--
def create_alien(ai_settings, screen, aliens, alien_number, row_number):
    """创建一个外星人并将其放在当前行"""
    alien = Alien(ai_settings, screen)
    alien_width = alien.rect.width
    alien.x = alien_width + 2 * alien_width * alien_number
    alien.rect.x = alien.x
    alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number
    aliens.add(alien)

def get_number_rows(ai_settings,ship_height,alien_height):
    """计算屏幕可容纳多少外星人"""
    available_space_y = (ai_settings.screen_height -3 * alien_height ) - ship_height
    number_rows = int(available_space_y / (2*alien_height)) 
    return number_rows

def create_fleet(ai_settings, screen,ship, aliens):
    """创建外星人群"""
    # 创建一个外星人，并计算一行可容纳多少个外星人
    # 外星人间距为外星人宽度
    alien = Alien(ai_settings, screen)
    number_aliens_x = get_number_aliens_x(ai_settings, alien.rect.width)
    number_rows = get_number_rows(ai_settings, ship.rect.height,alien.rect.height)

    # 创建外星人群
    for row_number in range(number_rows):
        for alien_number in range(number_aliens_x):
            create_alien(ai_settings,screen,aliens,alien_number,row_number)

然后再window.py中修改gf.create_fleet()的值：

window.py

	# 创建外星人群
    gf.create_fleet(ai_settings, screen, ship, aliens)

这时候运行就有一群敌人
在这里插入图片描述

7.移动外星人

7.1向右移动

  • 在settings.py末尾添加：
    settings.py
# 外星人设置
self.alien_speed_factor = 1

然后，使用这个设置来实现update()：
alien.py

 def update(self):
	 """向右移动外星人"""
	 self.x += self.ai_settings.alien_speed_factor
	 self.rect.x = self.x

最后在window.py中调用函数：

window.py

	# 开始游戏的主循环
    while True:
        gf.check_events(ai_settings,screen,ship,bullets)
        ship.update()
        gf.update_bullets(bullets)
        gf.update_aliens(aliens)
        gf.update_screen(ai_settings,screen,ship,aliens,bullets)
  • 我们在更新子弹后再更新外星人的位置，因为稍后要检查是否有子弹撞到了外星人。最后，在文件game_functions.py末尾添加新函数update_aliens()：

game_functions.py

def update_aliens(aliens):
	"""更新外星人群中所有外星人的位置"""
	aliens.update()

7.2创建表示外星人移动方向的设置

在settings.py中加入：
settings.py

# 外星人设置
self.alien_speed_factor = 1
self.fleet_drop_speed = 10
# fleet_direction为1表示向右移，为-1表示向左移
self.fleet_direction = 1

设置fleet_drop_speed指定了有外星人撞到屏幕边缘时，外星人群向下移动的速度。将这个速度与水平速度分开是有好处的，这样你就可以分别调整这两种速度了。
要实现fleet_direction设置，可以将其设置为文本值，如’left’或’right’，但这样就必须编写if-elif语句来检查外星人群的移动方向。鉴于只有两个可能的方向，我们使用值1和-1来表示它们，并在外星人群改变方向时在这两个值之间切换。另外，鉴于向右移动时需要增大每个外星人的x坐标，而向左移动时需要减小每个外星人的x坐标，使用数字来表示方向更合理。

7.3检查外星人是否撞到了屏幕边缘

alien.py

import pygame
from pygame.sprite import Sprite

class Alien(Sprite):
    """表示单个外星人的类"""
    def __init__(self, ai_settings, screen):
        """初始化外星人并设置其起始位置"""
        super(Alien, self).__init__()
        self.screen = screen
        self.ai_settings = ai_settings
        # 加载外星人图像，并设置其rect属性
        self.image = pygame.image.load('images/alien.bmp')
        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 blitme(self):
        """在指定位置绘制外星人"""
        self.screen.blit(self.image, self.rect)

    def check_edges(self):
        """如果外星人位于屏幕边缘，就返回True"""
        screen_rect = self.screen.get_rect()
        if self.rect.right >= screen_rect.right:
            return True
        elif self.rect.left <= 0:
            return True
    
    def update(self):
        """向右移动外星人"""
        self.x += (self.ai_settings.alien_speed_factor *self.ai_settings.fleet_direction)
        self.rect.x = self.x

7.4向下移动外星人群并改变移动方向

有外星人到达屏幕边缘时，需要将整群外星人下移，并改变它们的移动方向。我们需要对game_functions.py做重大修改，因为我们要在这里检查是否有外星人到达了左边缘或右边缘。为此，我们编写函数check_fleet_edges()和change_fleet_direction()，并对update_aliens()进行修改：

game_functions.py

def check_fleet_edges(ai_settings, aliens):
    """有外星人到达边缘时采取相应的措施"""
    for alien in aliens.sprites():
        if alien.check_edges():
            change_fleet_direction(ai_settings, aliens)
            break
def change_fleet_direction(ai_settings, aliens):
    """将整群外星人下移，并改变它们的方向"""
    for alien in aliens.sprites():
        alien.rect.y += ai_settings.fleet_drop_speed
    ai_settings.fleet_direction *= -1

def update_aliens(ai_settings, aliens):
    """检查是否有外星人位于屏幕边缘，并更新整群外星人的位置"""
    check_fleet_edges(ai_settings, aliens)
    aliens.update()

同时在window.py中引用函数：
window.py

gf.update_aliens(ai_settings, aliens)
gf.update_screen(ai_settings, screen, ship, aliens, bullets)

8.射杀

8.1检测子弹与外星人的碰撞

方法sprite.groupcollide()将每颗子弹的rect同每个外星人的rect进行比较，并返回一个字典，其中包含发生了碰撞的子弹和外星人。在这个字典中，每个键都是一颗子弹，而相应的值都是被击中的外星人

更新game_functions.py中update_bullets（）：

game_functions.py

def update_bullets(aliens,bullets):
    """更新子弹的位置，并删除已消失的子弹"""
    # 更新子弹的位置
    bullets.update()

    #删除已消失的子弹
    for bullet in bullets.copy():
        if bullet.rect.bottom <=0 :
            bullets.remove(bullet)
    
    # 检查是否有子弹击中了外星人
    # 如果是这样，就删除相应的子弹和外星人
    collisions = pygame.sprite.groupcollide(bullets, aliens, True, True)

同样在window.py中也同步更新gf.update_bullets(aliens,bullets)

此时实现子弹击落的效果：
在这里插入图片描述

8.2刷怪

要在外星人群被消灭后又显示一群外星人，首先需要检查编组aliens是否为空。如果为空，就调用create_fleet()。我们将在update_bullets()中执行这种检查，因为外星人都是在这里被消灭的：

game_functions.py

def update_bullets(ai_settings, screen, ship, aliens, bullets):
    """更新子弹的位置，并删除已消失的子弹"""
    # 更新子弹的位置
    bullets.update()

    #删除已消失的子弹
    for bullet in bullets.copy():
        if bullet.rect.bottom <=0 :
            bullets.remove(bullet)
    
    # 检查是否有子弹击中了外星人
    # 如果是这样，就删除相应的子弹和外星人
    collisions = pygame.sprite.groupcollide(bullets, aliens, True, True)

    if len(aliens) == 0:
        # 删除现有的子弹并新建一群外星人
        bullets.empty()
        create_fleet(ai_settings, screen, ship, aliens)

同步再window.py上更新gf.update_bullets(ai_settings, screen, ship, aliens, bullets)

8.3提高子弹速度

在settings.py中修改self.bullet_speed_factor即可

8.4重构 update_bullets()

game_functions.py

def update_bullets(ai_settings, screen, ship, aliens, bullets):
    """更新子弹的位置，并删除已消失的子弹"""
    # 更新子弹的位置
    bullets.update()

    #删除已消失的子弹
    for bullet in bullets.copy():
        if bullet.rect.bottom <=0 :
            bullets.remove(bullet)
    
    check_bullet_alien_collisions(ai_settings, screen, ship, aliens, bullets)


def check_bullet_alien_collisions(ai_settings, screen, ship, aliens, bullets):
    """响应子弹和外星人的碰撞"""
    # 删除发生碰撞的子弹和外星人
    collisions = pygame.sprite.groupcollide(bullets, aliens, True, True)

    if len(aliens) == 0:
        # 删除现有的子弹并新建一群外星人
        bullets.empty()
        create_fleet(ai_settings, screen, ship, aliens)

9.结束游戏

9.1检测外星人和飞船碰撞

编 写一 个 用 于 跟 踪 游 戏 统 计 信 息 的 新 类 ——GameStats ， 并 将 其 保 存 为 文 件game_stats.py：

game_stats.py

class GameStats():
    """跟踪游戏的统计信息"""
    def __init__(self, ai_settings):
        """初始化统计信息"""
        self.ai_settings = ai_settings
        self.reset_stats()
        
    def reset_stats(self):
        """初始化在游戏运行期间可能变化的统计信息"""
        self.ships_left = self.ai_settings.ship_limit

更新window.py中的gf.update_aliens(ai_settings, ship, aliens)

9.2响应外星人和飞船碰撞

代码过长，以下就略过，所有文件会在最后放出来

  • 在settings.py中添加self.ship_limit = 3，设置为3条命
  • 来 编 写 一 个 用 于 跟 踪 游 戏 统 计 信 息 的 新 类 ——GameStats ， 并 将 其 保 存 为 文 件game_stats.py：
  • 在window.py中创建一个GameStats实例
  • 更新了update_aliens()的定义，使其包含形参stats、 screen和bullets，让它能够在调用ship_hit()时传递这些值

9.3有外星人到达屏幕底端

  • 如果有外星人到达屏幕底端，我们将像有外星人撞到飞船那样作出响应。
  • game_functions.py中添加
def update_aliens(ai_settings, stats, screen, ship, aliens, bullets):
    """检查是否有外星人位于屏幕边缘，并更新整群外星人的位置"""
    check_fleet_edges(ai_settings, aliens)
    aliens.update()
    if pygame.sprite.spritecollideany(ship, aliens):
        ship_hit(ai_settings, stats, screen, ship, aliens, bullets)

    # 检查是否有外星人到达屏幕底端
    check_aliens_bottom(ai_settings, stats, screen, ship, aliens, bullets)

def check_aliens_bottom(ai_settings, stats, screen, ship, aliens, bullets):
    """检查是否有外星人到达了屏幕底端"""
    screen_rect = screen.get_rect()
    for alien in aliens.sprites():
        if alien.rect.bottom >= screen_rect.bottom:
            # 像飞船被撞到一样进行处理
            ship_hit(ai_settings, stats, screen, ship, aliens, bullets)
            break

9.4结束游戏

game_stats.py

class GameStats():
    """跟踪游戏的统计信息"""
    def __init__(self, ai_settings):
        """初始化统计信息"""
        self.ai_settings = ai_settings
        self.reset_stats()

        # 游戏刚启动时处于活动状态
        self.game_active = True

    def reset_stats(self):
        """初始化在游戏运行期间可能变化的统计信息"""
        self.ships_left = self.ai_settings.ship_limit
        ```
最后在window.py和game_functions.py添加条件
*game_functions.py*

```python
def ship_hit(ai_settings, stats, screen, ship, aliens, bullets):
	"""响应飞船被外星人撞到"""
	if stats.ships_left > 0:
		# 将ships_left减1
		stats.ships_left -= 1
		--snip--
		#暂停一会儿
		sleep(0.5)
	else:
		stats.game_active = False

alien_invasion.py

# 开始游戏主循环
while True:
	gf.check_events(ai_settings, screen, ship, bullets)
	if stats.game_active:
		ship.update()
		gf.update_bullets(ai_settings, screen, ship, aliens, bullets)
		gf.update_aliens(ai_settings, stats, screen, ship, aliens, bullets)
	gf.update_screen(ai_settings, screen, ship, aliens, bullets)

10.记分

添加了记分、最高分和等级记录显示

最终效果：
在这里插入图片描述

完整代码下载

  • 运行window.py就能打开窗口了。
wlop98
关注
专栏目录
python外星人入侵小游戏
ITCSDN_的博客
10-24 693
游戏准备： 项目结构如图所示： 项目中具体代码： （1）文件alien.py中的代码： import pygame from pygame.sprite import Group from settings import Settings from ship import Ship from alien import Alien from game_status import GameStats from button import Button from scoreboard import Scor
Python编程 外星人入侵
Simple的博客
06-10 1515
首先安装PIP 在Python3.6及更新的版本中，PIP已经捆绑安装了，不需要再单独安装 可以PIP升级 python -m install pip --upgrade pip 安装Pygame 打开cmd 输入 python -m pip install pygame --user 然后就开始游戏项目了 注意一下 游戏中要用到的飞船和外星人文件在(ituring.cn/book/1861)可以找到 alien_invasion.py import pygame from pygame.sprite
Python外星人入侵游戏
Stay Hungry, Stay Foolish!
05-15 574
源码来源 《Python从入门到实践》 项目描述 在游戏《外星人入侵》中，玩家控制着一艘最初出现在屏幕底部中央的飞船。玩家可以使用箭头键左右移动飞船，还可使用空格键进行射击。游戏开始时，一群外星人出现在天空中，他们在屏幕中向下移动。玩家的任务是射杀这些外星人。玩家将所有外星人都消灭干净后，将出现一群新的外星人，他们移动的速度更快。只要有外星人撞到了玩家的飞船或到达了屏幕底部，玩家就损失一艘飞船。玩家损失三艘飞船后，游戏结束。 最终效果： 项目分析 （1），创建并设置背景窗口 （2），添加飞船图像，设置飞船
python外星人入侵游戏
03-14
使用python3.6所编写的一个游戏。其中用到了pygame第三方库，有兴趣的同学可以下载看看或者玩玩。已用pycharm测试，可以运行。
python外星人入侵游戏代码大全-Python游戏：外星人入侵游戏编程完整版！内附代码...
weixin_37988176的博客
10-29 486
importsysimportpygamefrom bullet importBulletfrom alien importAlienfrom time importsleepdefcheck_events(ai_settings,screen,stats,sb,play_button,ship,aliens,bullets):#监视键盘和鼠标事件for event inpygame.event....
基于python开发的外星人入侵小游戏源码+详细注释+项目说明.zip
08-31
基于python开发的外星人入侵小游戏源码+详细注释+项目说明.zip 已完成功能 - 方向键控制飞船上下左右运动 - 飞船发射子弹 - 开始按钮 - 计分系统 - ~ 切换全屏和恢复 - 可以用子弹消灭外星人 - 外星人初始的方向...
python编程——外星人入侵游戏pygame源代码
04-03
包含外星人、飞船、子弹的控制，空格控制子弹发射，上下键移动飞船，记分模式，速度升级难度，最高分的记录显示，飞船剩余图片显示...搭配小星的《python编程入门到实践学习笔记——外星人入侵游戏pygame》系列加深理解
Python pygame 外星人入侵游戏项目
01-06
在本项目中，我们将探索如何使用Python的pygame库创建一个简单的外星人入侵游戏。《Python编程从入门到实践 第3版》中的“项目一 外星人入侵”旨在引导初学者逐步掌握游戏开发的基本概念和技术。pygame是Python中一...
基于python开发的外星人入侵游戏+源码（毕业设计&课程设计&项目开发）
最新发布
05-02
基于python开发的外星人入侵游戏+源码，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用~ 基于python开发的外星人入侵游戏+源码，适合毕业设计、课程设计、项目开发...
外星人入侵（python）
充满焦虑的大学生
01-31 9459
游戏的一些初始化数据的储存，子弹的速度，大小，屏幕的大小。游戏的一些初始化设置，界面的大小，标题。飞船的初始化信息和移动。外星人的初始信息和移动。
python实现游戏外星人入侵
07-24
初学python语言 python编写的外星人入侵的游戏 可供初学者查看
外星人入侵小游戏（python）
08-06
Python知识的练习，也可以作为一个简单的游戏来玩，在学习之余动动手，可以提高学习兴趣
python外星人入侵
11-22
python从入门到精通课件 外星人入侵 .....
python之外星人入侵
09-13
信你大家在学习编程语言的过程中经常会碰到一个问题，那就是学完了基本的语法以后不知道自己要做什么。其实，先找一些简单的项目进行练手是非常好的一种学习编程的方式。前段时间学习了python的基本语法，这里给大家推荐一本适合新手学习的python教程，叫《python编程：从入门到实践》。这里给大家分享其中的一段外星人入侵的代码（这里贴出13.1到14.1的代码，后面会补充完整给大家）。 ​
用 Python 写个外星人入侵小游戏
Python小二
08-24 1097
作者：weixin_wangyanpihttps://blog.csdn.net/weixin_44412311/article/details/106590762历时七天，终于做出来...
Python实战——外星人入侵游戏
Nicole1548的博客
10-27 8228
经历三天时间完成为python实战小游戏，外星人入侵，主要完成了书目当中的主要功能。同时添加了一些自己定义的功能：每次保留历史最高分，随着等级的不断提升改变飞船子弹的相关设置，加入音效模块在集中外星人的时候击中音效。同时，简单写了几个遇到的bug，希望可以对大家有帮助，下载资源链接附在最后。
【Python】项目实战一：外星人入侵 - 《Python编程：从入门到实践》
THDoO的博客
11-03 2606
项目1：外星人入侵 （1）项目描述： 在游戏《外星人入侵》中，玩家控制着一艘最初出现在屏幕底部中央的飞船。玩家可以使用箭头键左右移动飞船，还可使用空格键进行射击。游戏开始时，一群外星人出 现在天空中，他们在屏幕中向下移动。玩家的任务是射杀这些外星人。玩家将所有外星 人都消灭干净后，将出现一群新的外星人，他们移动的速度更快。只要有外星人撞到了 玩家的飞船或到达了屏幕底部，玩家就损失一艘飞船。玩家损失三艘飞船后，游戏结束。 ...
用Python语言，pygame模块开发一个简单的外星人入侵小游戏（在实战中学习Python类、函数方法、模版的使用，事半功倍）
zhang___jian61的博客
04-08 863
把上面的8个文件按照文件名复制粘贴到本地，用编辑器打开，安装pygame模块，把外星人和飞船的.bmp文件放到images文件夹中，运行alien_invasion.py文件便可以开始游戏啦~最近深入学习了一下Python类与方法的使用，一边看书，一边敲代码，在实战中加深了对Python类与方法的使用，也对pygame有了更多的理解。4、设置（速度、宽度、数量等）settings.py。1、主文件 alien_invasion.py。8、游戏初始化设置game_stats.py。2、飞船ship.py。
Python完整指南：构建外星人入侵游戏
"Python外星人入侵游戏"是一个经典的项目，它基于Pygame库来创建。Pygame是Python的一个模块，专门用于创建2D游戏。在这个教程中，我们将深入探讨如何实现这个游戏。 首先，我们需要准备的是安装Python环境，推荐...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值