python学习-飞机大战_python飞机大战详细教程

一、pygame正确安装
1.安装：pip install pygame
2.验证安装：python -m pygame.examples.aliens；安装ok即会出现如下图所示动画

二、使用pygame创建图像窗口
1.游戏的初始化和退出；要使用pygame提供的所有功能之前，必须先调用init方法；在游戏结束，需要调用quit方法

pygame.init()→游戏代码→pygame.quit()
1

2.在游戏中，所有可见的元素都是以矩形区域来描述位置的；要描述一个矩形区域有4个要素（x,y（width,height））；pygame.Rect用于专门描述矩形区域的
（pygame.Rect是一个比较特殊的类，内部只是封装了一些数字计算，不需要执行pygame.init()方法就能直接使用）

举个例子：

三.创建游戏主窗口；

模块：pygame.display；用于创建、管理游戏窗口
方法：pygame.display.set_mode()：初始化游戏显示窗口
     pygame.display.update()：刷新屏幕内容显示，稍后使用
	set_moed(resolution=(0,0)，flags=0，depth=0) →Surface

1
2
3
4
5

resolution：指定屏幕的宽和高；默认创建的窗口大小和屏幕大小一致
flags：指定屏幕的附加选项，例如是否全屏等等，默认不需要传递
depth：表示颜色的位置，默认自动匹配
Suface返回值；暂时可以理解为游戏的屏幕，游戏的元素都需要被绘制到游戏的屏幕上
注意：必须使用变量记录set_mode方法的返回结果！（因为后续所有的图像绘制都基于这个返回结果）
举个例子：

import pygame
pygame.init()

#游戏代码：
screen = pygame.display.set_mode((480, 700))    #宽480，高700

#游戏循环；为了做到游戏程序启动后，不会立即退出，
while True:
    pass

pygame.quit()
1
2
3
4
5
6
7
8
9
10
11

四.理解图像并实现图像绘制；
图像文件初始是保存在磁盘上，如需使用，第一步就需要被加载到内存；要在屏幕上看到某一个图像的内容，需要按照三个步骤：
①.使用pygame.image.load()；加载图像的数据 【load(file_path)】
②.使用游戏屏幕对象，调用blit方法将图像绘制到指定位置怕【blit(图像，位置)】
③.调用pygame.display.update()方法更新整个屏幕的显示

举个例子：

import pygame
pygame.init()

#游戏代码：
screen = pygame.display.set_mode((480, 700))    #宽480，高700

#绘制背景图像
"""
①.使用pygame.image.load()；加载图像的数据
②.使用游戏屏幕对象，调用blit方法将图像绘制到指定位置
③.调用pygame.display.update()方法更新整个屏幕的显示
"""

bg = pygame.image.load("./images/background.png") #load方法需要有返回值；将背景图片的地址写入
screen.blit(bg, (0, 0))  #blit方法里传入俩个参数：图像，位置
pygame.display.update() #必须要使用这个方法，才能更新到屏幕上
#游戏循环；为了做到游戏程序启动后，不会立即退出，
while True:
    pass

pygame.quit()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

在游戏中，能够看到的游戏元素大多是图像；
图像文件初始是保存在磁盘上的，如果需要使用，第一步就需要被加载到内存
要在屏幕上看到某一个图像的内容，需要按照三个步骤：
①.使用pygame.image.load()加载图像的数据
②.使用游戏屏幕对象，调用blit方法，将图像绘制到指定位置
③.调用pygame.display.update()方法更新整个屏幕的显示

五.绘制英雄图像，并在屏幕上显示

"""
需求：
1.加载me1.png图像，创建英雄费飞机
2.将英雄飞机绘制在屏幕的（200,500）位置
3.调用屏幕更新显示飞机图像
"""


import pygame
pygame.init()

#游戏代码：
screen = pygame.display.set_mode((480, 700))    #宽480，高700

#绘制背景图像
"""
①.使用pygame.image.load()；加载图像的数据
②.使用游戏屏幕对象，调用blit方法将图像绘制到指定位置
③.调用pygame.display.update()方法更新整个屏幕的显示
"""

bg = pygame.image.load("./images/background.png") #load方法需要有返回值；将背景图片的地址写入
screen.blit(bg, (0, 0))  #blit方法里传入俩个参数：图像，位置
pygame.display.update() #必须要使用这个方法，才能更新到屏幕上
#游戏循环；为了做到游戏程序启动后，不会立即退出

# 绘制英雄的飞机并更新在屏幕上
hero = pygame.image.load("./images/me1.png")
screen.blit(hero, (200, 500))
pygame.display.update()
while True:
    pass

pygame.quit()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

透明图像：
png格式的图像是支持透明的，在绘制图像时，透明区域不会显示任何内容，但是如果下方已经有内容，会透过透明区域显示出来

六.update方法的作用
可以在所有绘制工作完成后，统一调用update方法

7.游戏循环

游戏循环的作用：
①.保证游戏不会直接退出
②.变化图像位置-动画效果 （每隔1/60s移动一下所有图像的位置，调用pygame.display.update()更新屏幕显示）
③.检测用户交互 ——按键，鼠标等

游戏由2个部分组成：游戏初始化 + 游戏循环
而游戏循环的开始，才意味着游戏的正式开始
游戏初始化：
①.设置游戏窗口
②.绘制图像初始位置
③.设置游戏时钟

游戏循环：
①.设置刷新帧率
②.检测用户交互
③.更新所有图像位置
④.更新屏幕显示

游戏时钟（利用时钟设置游戏循环的刷新帧率）：
pygame专门提供了一个类：pygame.time.Clock()可以非常方便的设置屏幕绘制速度）刷新帧率；要使用时钟对象，需要俩步
1）在游戏初始化创建一个时钟对象
2）在游戏循环中让时钟对象调用tick（帧率）方法
tick方法会根据上次被调用的时间，自动设置游戏循环中的延时

英雄动画效果实现：

"""
需求：
1.在游戏初始化定时一个pygame.Rect的变量记录英雄的初始位置
2.在游戏循环中每次让英雄的y-1（向上移动）
3.y<=0将英雄移动到屏幕的底部
"""


import pygame
pygame.init()

#游戏代码：
screen = pygame.display.set_mode((480, 700))    #宽480，高700

#绘制背景图像
"""
①.使用pygame.image.load()；加载图像的数据
②.使用游戏屏幕对象，调用blit方法将图像绘制到指定位置
③.调用pygame.display.update()方法更新整个屏幕的显示
"""

bg = pygame.image.load("./images/background.png") #load方法需要有返回值；将背景图片的地址写入
screen.blit(bg, (0, 0))  #blit方法里传入俩个参数：图像，位置
#游戏循环；为了做到游戏程序启动后，不会立即退出

# 绘制英雄的飞机并更新在屏幕上
hero = pygame.image.load("./images/me1.png")
screen.blit(hero, (200, 500))
pygame.display.update()

#创建游戏时钟对象
clock = pygame.time.Clock()

#定义rect记录飞机的初始位置
hero_rect = pygame.Rect(200, 500, 102, 126)

#游戏循环：意味着游戏的正式开始
while True:
    clock.tick(60)

    #2.修改飞机的位置
    hero_rect.y -=50

    #判断飞机的位置
    if hero_rect.y <=0:
        hero_rect.y = 700


    #3.调用blit方法绘制图像
    screen.blit(bg, (0, 0))#绘制游戏背景； 为了飞机回到原点，没有残影
    screen.blit(hero, hero_rect)
    #4.调用update方法更新显示
    pygame.display.update()


pygame.quit()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

在游戏中监听事件：

………………………………省略，没有详细的说明了~附带代码
plane_main.py

import pygame
from plane_sprites import *

"""
该文件为游戏的主程序；封装主游戏类；创建游戏对象；启动游戏
"""

class PlaneGame(object):
    """飞机大战主游戏"""

    def __init__(self):
        #1.创建游戏的窗口
        #self.screen = pygame.display.set_mode((480, 700))      #这个屏幕的大小值不固定，可以使用常量，在plane_sprites.py中设置常量，这边引用即可
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)
        #2.创建游戏的时钟
        self.clock = pygame.time.Clock()
        #3.调用私有方法，精灵和精灵组的创建
        self.__creat_sprites()

        #设置定时器，创建敌机1~秒
        pygame.time.set_timer(CREATE_ENEMY_EVENT, 1000)
        pygame.time.set_timer(HERO_FIRE_EVENT, 500)

    #创建私有方法（精灵和精灵组的创建）
    def __creat_sprites(self):
        #创建背景精灵和精灵组
        bg1 = BackGround()
        bg2 = BackGround(True)
        self.back_group = pygame.sprite.Group(bg1, bg2)     #背景精灵组
        self.enemy_group = pygame.sprite.Group()    #敌机精灵组

        self.hero = Hero()
        self.hero_group = pygame.sprite.Group(self.hero)     #英雄精灵组

    #开始游戏，且循环游戏
    def start_time(self):
        while True:
        #print("开始游戏了……")
            #1.设置刷新帧率
            self.clock.tick(FRAME_PER_SEC)
            #2.事件监听
            self.__event_handler()
            #3.碰撞检测
            self.__check_collide()
            #4.更新精灵组
            self.__update_sprites()
            #5.更新屏幕显示
            pygame.display.update()

    #事件监听
    def __event_handler(self):
        for event in pygame.event.get():
            #判断是否退出游戏
            if event.type == pygame.QUIT:
                PlaneGame.__game_over()
            elif event.type == CREATE_ENEMY_EVENT:
                print("敌机出场……")
                enemy = Enemy()
                self.enemy_group.add(enemy)
            elif event.type == HERO_FIRE_EVENT:
                self.hero.fire()
        #使用键盘提供的方法获取键盘按键（按键元组）
        keys_pressed = pygame.key.get_pressed()
        #判断元组中对应的按键索引值 1
        if keys_pressed[pygame.K_RIGHT]:
            self.hero.speed = 2

        elif keys_pressed[pygame.K_LEFT]:
            self.hero.speed = -2

        else:
            self.hero.speed = 0

    #碰撞检测
    def __check_collide(self):
        #1.子弹摧毁敌机
        pygame.sprite.groupcollide(self.hero.bullets, self.enemy_group, True, True)

        #2.敌机撞毁英雄
        enemies = pygame.sprite.spritecollide(self.hero, self.enemy_group, True)

        #3.判断列表有内容
        if len(enemies) > 0:
            #让英雄牺牲
            self.hero.kill()
            #游戏结束
            PlaneGame.__game_over()


    #更新精灵组
    def __update_sprites(self):
        self.back_group.update()
        self.back_group.draw(self.screen)

        self.enemy_group.update()
        self.enemy_group.draw(self.screen)

        self.hero_group.update()
        self.hero_group.draw(self.screen)

        self.hero.bullets.update()
        self.hero.bullets.draw(self.screen)

    @staticmethod
    def __game_over():
        pygame.quit()
        exit()

if __name__ == '__main__':
    """创建游戏对象"""
    game = PlaneGame()

    """开始游戏"""
    game.start_time()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

plane_sprites.py

import random
import pygame
# 屏幕大小的常量
SCREEN_RECT = pygame.Rect(0, 0, 480, 700)

#刷新的帧率
FRAME_PER_SEC =60

#定义敌机定时器的事件常量
CREATE_ENEMY_EVENT = pygame.USEREVENT

#英雄发射子弹事件
HERO_FIRE_EVENT = pygame.USEREVENT + 1

"""
该文件是封装游戏中所有需要使用的精灵子类；提供游戏的相关工具；（比如屏幕尺寸大小，游戏精灵子类）
"""

#创建游戏精灵基类；并继承pygame.sprite.Sprite
class GameSprite(pygame.sprite.Sprite):

    def __init__(self, image_name, speed=1):
        #调用父类的初始化方法
        super().__init__()
        #加载图像
        self.image = pygame.image.load(image_name)
        #设置尺寸
        self.rect = self.image.get_rect()
        #记录速度
        self.speed = speed


    def update(self):
        #默认在垂直方向移动
        self.rect.y += self.speed

#创建游戏背景精灵
class BackGround(GameSprite):
    def __init__(self, is_alt=False):
        # 1. 调用父类方法实现精灵的创建(image/rect/speed)
        super().__init__("./images/background.png")

        # 2. 判断是否是交替图像，如果是，需要设置初始位置
        if is_alt:
            self.rect.y = -self.rect.height

    def update(self):
        # 1. 调用父类的方法实现
        super().update()

        # 2. 判断是否移出屏幕，如果移出屏幕，将图像设置到屏幕的上方
        if self.rect.y >= SCREEN_RECT.height:
            self.rect.y = -self.rect.height

#创建敌机精灵
class Enemy(GameSprite):
    def __init__(self):
        #1.调用父类的方法，创建敌机精灵，并且指定敌机的图像
        super().__init__("./images/enemy1.png")
        #2.设置敌机的随机初始速度
        self.speed = random.randint(1, 3)
        #3.设置敌机的随机初始位置
        self.rect.bottom = 0

        max_x = SCREEN_RECT.width - self.rect.width
        self.rect.x = random.randint(0, max_x)


    def update(self, *args):
        #1.调用父类的方法，让敌机在垂直方向运动
        super().update()
        #2.判断是否飞出屏幕，如果是，需要将敌机从精灵组删除
        if self.rect.y >= SCREEN_RECT.height:
            # print("敌机飞出屏幕")
            # kill方法可以将精灵从所有精灵组中移出，精灵就会被自动销毁
            self.kill()

    def __del__(self):
        pass

#创建英雄精灵
class Hero(GameSprite):
    def __init__(self):
        #1.调用父类方法，设置图像和速度
        super().__init__("./images/me1.png", 0)

        #2.设置英雄的初始位置
        self.rect.centerx =SCREEN_RECT.centerx
        self.rect.bottom =SCREEN_RECT.bottom - 120

        #3.创建子弹的精灵组
        self.bullets = pygame.sprite.Group()

    def update(self):
        #1.英雄在水平方向移动
        self.rect.x += self.speed

        #控制英雄不能离开屏幕
        if self.rect.x < 0:
            self.rect.x = 0
        elif self.rect.right > SCREEN_RECT.right:
            self.rect.right = SCREEN_RECT.right

    def fire(self):
        print("发射子弹……")
        for i in (0, 1, 2):
            #1.创建子弹精灵
            bullet = Bullet()

            #2.设置精灵的位置
            bullet.rect.bottom = self.rect.y - i * 20
            bullet.rect.centerx = self.rect.centerx

            #3.将精灵添加到精灵组
            self.bullets.add(bullet)

#创建子弹精灵类
class Bullet(GameSprite):
    def __init__(self):
        #调用父类方法，设置子弹图片和设置初始速度
        super().__init__("./images/bullet1.png", -2)

    def update(self):
        #调用父类方法，让子弹沿垂直方向飞行
        super().update()

        #判断子弹是否飞出屏幕
        if self.rect.bottom < 0:
            self.kill()

    def __del__(self):
        print("子弹被销毁……")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132