Python基础-Pygame游戏框架之飞机大战

淡淡的烟草味﹌ 2023-07-10 08:41 51阅读 0赞

#                                       Pygame游戏框架 #

## **Pygame** ##

Pygame是一套跨平台的Python模块，专为编写游戏而设计。

它包括计算机图形和声音库，旨在与Python编程语言一起使用。

## 展示窗体 ##

**引入pygame模块**

import pygame

**初始化游戏**

pygame.init()

**设置窗体大小**

pygame.display.set\_mode((400, 400))

## 展示窗体-程序执行流程 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1MjA0MTc5_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1MjA0MTc5_size_16_color_FFFFFF_t_70 1][]

**展示窗体**

图形化界面程序都是阻塞式的

通常阻塞的实现策略就是死循环

**事件捕获之窗体关闭**

窗体关闭

pygame.event.get()提供事件的清单

event.type指明了事件的类型

pygame.locals模块提供了常量

QUIT就是窗体关闭事件

01.pygame窗口创建.py

# 导入游戏引擎
    import pygame
    
    # 初始化pygame
    pygame.init()
    
    # 创建窗口
    # size 窗口大小 宽度和高度
    pygame.display.set_mode(size=(800,800))

02.pygame窗口一直展示.py

# 导入游戏引擎
    import pygame
    
    # 初始化pygame
    pygame.init()
    
    # 创建窗口
    # size 窗口大小 宽度和高度
    pygame.display.set_mode(size=(800,800))
    # 避免程序结束
    while True:
        pass

03.游戏停止.py

# 导入游戏引擎
    import pygame
    from pygame.locals import *
    import sys
    
    # 初始化pygame
    pygame.init()
    
    # 创建窗口
    # size 窗口大小 宽度和高度
    window = pygame.display.set_mode(size=(800,800))
    # 避免程序结束
    while True:
        # 处理事件
        eventList = pygame.event.get()
        # if len(eventList)>0:
        # 有事件发生
        # 判断是否是退出事件
        # if len(eventList)>0:
        #     print(eventList)
        for event in eventList:
            # 退出事件类型
            if event.type==QUIT:
                # 退出界面
                pygame.display.quit()
                # sys退出
                sys.exit()

04.窗口标题和图标.py

05.展示图片到窗口.py

06.键盘事件处理.py

06.1 键盘按压一次触发一次

# 导入游戏引擎
    import pygame
    from pygame.locals import *
    import sys
    
    # 初始化pygame
    pygame.init()
    
    # 创建窗口
    # size 窗口大小 宽度和高度
    window = pygame.display.set_mode(size=(800,800))
    
    
    # 避免程序结束
    while True:
        # 处理事件
        eventList = pygame.event.get()
        for event in eventList:
            # 退出事件类型
            if event.type==QUIT:# 退出事件类型
                # 退出界面
                pygame.display.quit()
                # sys退出
                sys.exit()
            elif event.type==KEYDOWN:# 键盘按下的事件
                # 判断按下的是哪个键
                if event.key==K_a:
                    print('向左')
                elif event.key==K_d:
                    print('向右')
                elif event.key==K_w:
                    print('向前')
                elif event.key==K_s:
                    print('向后')
                elif event.key==K_RETURN:
                    print('点击了enter键')

06.2 键盘一直按压,就一直触发

# 导入游戏引擎
    import pygame
    from pygame.locals import *
    import sys
    
    # 初始化pygame
    pygame.init()
    
    # 创建窗口
    # size 窗口大小 宽度和高度
    window = pygame.display.set_mode(size=(800,800))
    
    
    # 避免程序结束
    while True:
        # 处理事件
        eventList = pygame.event.get()
        for event in eventList:
            # 退出事件类型
            if event.type==QUIT:# 退出事件类型
                # 退出界面
                pygame.display.quit()
                # sys退出
                sys.exit()
    
    
          # 返回所有键对应的状态 0:没有按压  1:有按压
            states = pygame.key.get_pressed() # 键盘一直按压,就一直触发
            # 有按压事件
            if 1 in states:
                # 是否是关心的a d s w键
                if states[K_a]:  # 0 1
                    plane.moveLeft()
                elif states[K_d]:
                    plane.moveRight()
                elif states[K_w]:
                    plane.moveUp()
                elif states[K_s]:
                    plane.moveDown()

07.展示图片到窗口.py

# 导入游戏引擎
    import pygame
    from pygame.locals import *
    import sys
    
    # 初始化pygame
    pygame.init()
    
    # 创建窗口
    # size 窗口大小 宽度和高度
    window = pygame.display.set_mode(size=(800,800))
    # 设置窗口标题
    pygame.display.set_caption('飞机大战')
    
    # 加载图标
    icon = pygame.image.load('img/app.ico')
    # 设置图标
    pygame.display.set_icon(icon)
    
    # 加载飞机图片
    heroImg = pygame.image.load('img/hero2.png')
    
    heroX = 200
    heroY = 200
    
    # 避免程序结束
    while True:
        # 清空窗口,通过背景颜色覆盖
        # R G B
        window.fill((0,0,0))
    
        # 展示飞机图片
        window.blit(heroImg,(heroX,heroY))
        # 刷新
        pygame.display.flip()
    
        # 处理事件
        eventList = pygame.event.get()
        for event in eventList:
            # 退出事件类型
            if event.type==QUIT:
                # 退出界面
                pygame.display.quit()
                # sys退出
                sys.exit()
            elif event.type==KEYDOWN:# 键盘按下的事件
                # 判断按下的是哪个键
                if event.key==K_a:
                    heroX-=10
                elif event.key==K_d:
                    heroX+=10
                elif event.key==K_w:
                    heroY-=10
                elif event.key==K_s:
                    heroY+=10

08.文字展示.py

# 导入游戏引擎
    import pygame
    from pygame.locals import *
    import sys
    
    # 初始化pygame
    pygame.init()
    
    # 创建窗口
    # size 窗口大小 宽度和高度
    window = pygame.display.set_mode(size=(800,800))
    # 加载字体
    font = pygame.font.Font('font/happy.ttf',50)
    # 渲染字体
    fontSurface = font.render('游戏开始',True,(255,255,255))
    
    # 避免程序结束
    while True:
        # 显示字体控件
        window.blit(fontSurface,(200,200))
        # 刷新(只需要执行一次)
        pygame.display.flip()
    
        # 处理事件
        eventList = pygame.event.get()
        for event in eventList:
            # 退出事件类型
            if event.type==QUIT:
                # 退出界面
                pygame.display.quit()
                # sys退出
                sys.exit()

09.背景音效播放.py

# 导入游戏引擎
    import pygame
    from pygame.locals import *
    import sys
    
    # 初始化pygame
    pygame.init()
    
    # 创建窗口
    # size 窗口大小 宽度和高度
    window = pygame.display.set_mode(size=(800,800))
    # 加载背景音效
    pygame.mixer.music.load('snd/bomb.wav')
    
    # 避免程序结束
    while True:
        # 处理事件
        eventList = pygame.event.get()
        for event in eventList:
            # 退出事件类型
            if event.type==QUIT:# 退出事件类型
                # 退出界面
                pygame.display.quit()
                # sys退出
                sys.exit()
            elif event.type==KEYDOWN:# 键盘按下的事件
                # 判断按下的是哪个键
                if event.key==K_a:
                    # 播放背景音效
                    pygame.mixer.music.play(loops=-1)

10.特殊音效处理.py

# 导入游戏引擎
    import pygame
    from pygame.locals import *
    import sys
    
    # 初始化pygame
    pygame.init()
    
    # 创建窗口
    # size 窗口大小 宽度和高度
    window = pygame.display.set_mode(size=(800,800))
    
    # 加载特殊音效
    sn = pygame.mixer.Sound('snd/bomb.wav')
    
    # 避免程序结束
    while True:
        # 处理事件
        eventList = pygame.event.get()
        for event in eventList:
            # 退出事件类型
            if event.type==QUIT:# 退出事件类型
                # 退出界面
                pygame.display.quit()
                # sys退出
                sys.exit()
            elif event.type==KEYDOWN:# 键盘按下的事件
                # 判断按下的是哪个键
                if event.key==K_a:
                    sn.stop()
                elif event.key==K_s:
                    sn.play(loops=0)

11.FPS计算.py

# 导入游戏引擎
    import pygame
    from pygame.locals import *
    import sys
    import time
    
    # 初始化pygame
    pygame.init()
    
    # 创建窗口
    # size 窗口大小 宽度和高度
    window = pygame.display.set_mode(size=(800,800))
    # 设置窗口标题
    pygame.display.set_caption('飞机大战')
    
    # 加载图标
    icon = pygame.image.load('img/app.ico')
    # 设置图标
    pygame.display.set_icon(icon)
    
    # 加载飞机图片
    heroImg = pygame.image.load('img/hero2.png')
    
    heroX = 200
    heroY = 200
    
    # 避免程序结束
    while True:
        # 开始时间
        startTime = time.time()
    
        # 清空窗口,通过背景颜色覆盖
        # R G B
        window.fill((0,0,0))
    
        # 展示飞机图片
        window.blit(heroImg,(heroX,heroY))
        # 刷新
        pygame.display.flip()
    
        # 处理事件
        eventList = pygame.event.get()
        for event in eventList:
            # 退出事件类型
            if event.type==QUIT:
                # 退出界面
                pygame.display.quit()
                # sys退出
                sys.exit()
            elif event.type==KEYDOWN:# 键盘按下的事件
                # 判断按下的是哪个键
                if event.key==K_a:
                    heroX-=10
                elif event.key==K_d:
                    heroX+=10
                elif event.key==K_w:
                    heroY-=10
                elif event.key==K_s:
                    heroY+=10
        # 降低fps
        time.sleep(0.008)
        # 结束时间
        endTime = time.time()
        # 这一次渲染时间
        renderTime = endTime-startTime
        try:
            # 求FPS
            fps = int(1/renderTime)
            print(fps)
        except:
            pass

12.Surface.py

# 导入游戏引擎
    import pygame
    from pygame.locals import *
    import sys
    
    # 初始化pygame
    pygame.init()
    
    # 创建窗口
    # size 窗口大小 宽度和高度
    window = pygame.display.set_mode(size=(800,800))
    
    print(window.get_width(),window.get_height())
    # 设置窗口标题
    pygame.display.set_caption('飞机大战')
    
    # 加载图标
    icon = pygame.image.load('img/app.ico')
    # 设置图标
    pygame.display.set_icon(icon)
    
    # 加载飞机图片
    heroImg = pygame.image.load('img/hero2.png')
    
    # 获取图片大小
    # print(heroImg.get_width(),heroImg.get_height())
    print(heroImg.get_rect())
    
    heroX = 200
    heroY = 200
    
    # 避免程序结束
    while True:
        # 清空窗口,通过背景颜色覆盖
        # R G B
        window.fill((0,0,0))
    
        # 展示飞机图片
        window.blit(heroImg,(heroX,heroY))
        # 刷新
        pygame.display.flip()
    
        # 处理事件
        eventList = pygame.event.get()
        for event in eventList:
            # 退出事件类型
            if event.type==QUIT:
                # 退出界面
                pygame.display.quit()
                # sys退出
                sys.exit()
            elif event.type==KEYDOWN:# 键盘按下的事件
                # 判断按下的是哪个键
                if event.key==K_a:
                    heroX-=10
                elif event.key==K_d:
                    heroX+=10
                elif event.key==K_w:
                    heroY-=10
                elif event.key==K_s:
                    heroY+=10

## 飞机大战 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1MjA0MTc5_size_16_color_FFFFFF_t_70 2][]

01.创建飞机大战窗口

import pygame
    
    # 初始化
    pygame.init()
    
    # 创建游戏窗口
    window = pygame.display.set_mode(size=(600,800))
    
    # 保证窗口不关闭
    while True:
        pass

02.窗口处理:

import pygame
    from pygame.locals import *
    import sys
    """
    1.标题和图标
    2.退出事件
    """
    
    # 初始化
    pygame.init()
    
    # 创建游戏窗口
    window = pygame.display.set_mode(size=(600,800))
    # 窗口标题
    pygame.display.set_caption('飞机大战')
    
    # 加载图标图片
    iconSurface = pygame.image.load('img/app.ico')
    # 设置图标
    pygame.display.set_icon(iconSurface)
    
    
    # 保证窗口不关闭
    while True:
        # 处理窗口关闭
        eventList = pygame.event.get()
        for event in eventList:
            # 判断是否是退出类型
            if event.type==QUIT:
                # 退出游戏
                pygame.quit()
                # 退出程序
                sys.exit()

03.展示背景

import pygame
    from pygame.locals import *
    import sys
    """
    1.标题和图标
    2.退出事件
    """
    
    # 初始化
    pygame.init()
    
    # 加载背景图片
    bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
    # 获取背景图片的大小
    bgWidth = bgSurface.get_width()
    bgHeight = bgSurface.get_height()
    
    # 创建游戏窗口
    window = pygame.display.set_mode(size=(bgWidth,bgHeight))
    # 窗口标题
    pygame.display.set_caption('飞机大战')
    
    # 加载图标图片
    iconSurface = pygame.image.load('img/app.ico')
    # 设置图标
    pygame.display.set_icon(iconSurface)
    
    
    # 保证窗口不关闭
    while True:
        # 展示背景
        window.blit(bgSurface,(0,0))
        # 刷新
        pygame.display.flip()
    
        # 处理窗口关闭
        eventList = pygame.event.get()
        for event in eventList:
            # 判断是否是退出类型
            if event.type==QUIT:
                # 退出游戏
                pygame.quit()
                # 退出程序
                sys.exit()

04.入口函数处理

import pygame
    from pygame.locals import *
    import sys
    """
    1.标题和图标
    2.退出事件
    """
    
    def start():
        # 初始化
        pygame.init()
    
        # 加载背景图片
        bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
        # 获取背景图片的大小
        bgWidth = bgSurface.get_width()
        bgHeight = bgSurface.get_height()
    
        # 创建游戏窗口
        window = pygame.display.set_mode(size=(bgWidth,bgHeight))
        # 窗口标题
        pygame.display.set_caption('飞机大战')
    
        # 加载图标图片
        iconSurface = pygame.image.load('img/app.ico')
        # 设置图标
        pygame.display.set_icon(iconSurface)
    
    
        # 保证窗口不关闭
        while True:
            # 展示背景
            window.blit(bgSurface,(0,0))
            # 刷新
            pygame.display.flip()
    
            # 处理窗口关闭
            eventList = pygame.event.get()
            for event in eventList:
                # 判断是否是退出类型
                if event.type==QUIT:
                    # 退出游戏
                    pygame.quit()
                    # 退出程序
                    sys.exit()
    
    if __name__ == '__main__':
        start()

05.添加我方飞机

import pygame
    from pygame.locals import *
    import sys
    """
    1.标题和图标
    2.退出事件
    """
    
    def start():
        # 初始化
        pygame.init()
    
        # 加载背景图片
        bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
        # 获取背景图片的大小
        bgWidth = bgSurface.get_width()
        bgHeight = bgSurface.get_height()
    
        # 创建游戏窗口
        window = pygame.display.set_mode(size=(bgWidth,bgHeight))
        # 窗口标题
        pygame.display.set_caption('飞机大战')
    
        # 加载图标图片
        iconSurface = pygame.image.load('img/app.ico')
        # 设置图标
        pygame.display.set_icon(iconSurface)
    
        # 加载我方飞机图片
        heroSurface = pygame.image.load('img/hero2.png')
    
        # 保证窗口不关闭
        while True:
            # 展示背景
            window.blit(bgSurface,(0,0))
            # 展示我方飞机
            window.blit(heroSurface,(200,600))
            # 刷新
            pygame.display.flip()
    
            # 处理窗口关闭
            eventList = pygame.event.get()
            for event in eventList:
                # 判断是否是退出类型
                if event.type==QUIT:
                    # 退出游戏
                    pygame.quit()
                    # 退出程序
                    sys.exit()
    
    if __name__ == '__main__':
        start()

06.飞机类抽取

07.飞机的移动

import pygame
    from pygame.locals import *
    import sys
    
    """
    1.标题和图标
    2.退出事件
    """
    """
    飞机属性: x,y window
    飞机行为:被展示行为display
    """
    
    """------------------ 我方飞机类 ------------------"""
    
    
    class Plane:
        def __init__(self, x, y, window):
            # 坐标
            self.__x = x
            self.__y = y
            # 被展示到的窗口
            self.__window = window
            # 飞机展示的Surface
            self.__surface = pygame.image.load('img/hero2.png')
    
        def display(self):
            '''
            被展示
            :return:
            '''
            # 展示我方飞机
            self.__window.blit(self.__surface, (self.__x, self.__y))
    
        def moveLeft(self):
            '''
            向左移动
            :return:
            '''
            self.__x -= 1
    
        def moveRight(self):
            '''
            向右移动
            :return:
            '''
            self.__x += 1
    
        def moveUp(self):
            '''
            向上移动
            :return:
            '''
            self.__y -= 1
    
        def moveDown(self):
            '''
            向下移动
            :return:
            '''
            self.__y += 1
    
    
    def start():
        # 初始化
        pygame.init()
    
        # 加载背景图片
        bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
        # 获取背景图片的大小
        bgWidth = bgSurface.get_width()
        bgHeight = bgSurface.get_height()
    
        # 创建游戏窗口
        window = pygame.display.set_mode(size=(bgWidth, bgHeight))
        # 窗口标题
        pygame.display.set_caption('飞机大战')
    
        # 加载图标图片
        iconSurface = pygame.image.load('img/app.ico')
        # 设置图标
        pygame.display.set_icon(iconSurface)
    
        # 创建飞机类
        plane = Plane(200, 600, window)
    
        # 保证窗口不关闭
        while True:
            # 展示背景
            window.blit(bgSurface, (0, 0))
            # 展示飞机
            plane.display()
            # 刷新
            pygame.display.flip()
    
            # 处理窗口关闭
            eventList = pygame.event.get()
            for event in eventList:
                # 判断是否是退出类型
                if event.type == QUIT:
                    # 退出游戏
                    pygame.quit()
                    # 退出程序
                    sys.exit()
                elif event.type == KEYDOWN:  # 按下事件
                    if event.key == K_a:
                        plane.moveLeft()
                    elif event.key == K_d:
                        plane.moveRight()
                    elif event.key == K_w:
                        plane.moveUp()
                    elif event.key == K_s:
                        plane.moveDown()
    
    
    if __name__ == '__main__':
        start()

08.飞机的移动细节处理

import pygame
    from pygame.locals import *
    import sys
    
    """
    1.标题和图标
    2.退出事件
    """
    """
    飞机属性: x,y window
    飞机行为:被展示行为display
    """
    
    """------------------ 我方飞机类 ------------------"""
    
    
    class Plane:
        def __init__(self, x, y, window):
            # 坐标
            self.__x = x
            self.__y = y
            # 被展示到的窗口
            self.__window = window
            # 飞机展示的Surface
            self.__surface = pygame.image.load('img/hero2.png')
            # 运动速度
            self.speed = 1
    
        def display(self):
            '''
            被展示
            :return:
            '''
            # 展示我方飞机
            self.__window.blit(self.__surface, (self.__x, self.__y))
    
        def moveLeft(self):
            '''
            向左移动
            :return:
            '''
            self.__x -= self.speed
    
        def moveRight(self):
            '''
            向右移动
            :return:
            '''
            self.__x += self.speed
    
        def moveUp(self):
            '''
            向上移动
            :return:
            '''
            self.__y -= self.speed
    
        def moveDown(self):
            '''
            向下移动
            :return:
            '''
            self.__y += self.speed
    
    
    def start():
        # 初始化
        pygame.init()
    
        # 加载背景图片
        bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
        # 获取背景图片的大小
        bgWidth = bgSurface.get_width()
        bgHeight = bgSurface.get_height()
    
        # 创建游戏窗口
        window = pygame.display.set_mode(size=(bgWidth, bgHeight))
        # 窗口标题
        pygame.display.set_caption('飞机大战')
    
        # 加载图标图片
        iconSurface = pygame.image.load('img/app.ico')
        # 设置图标
        pygame.display.set_icon(iconSurface)
    
        # 创建飞机类
        plane = Plane(200, 600, window)
    
        # 保证窗口不关闭
        while True:
            # 展示背景
            window.blit(bgSurface, (0, 0))
            # 展示飞机
            plane.display()
            # 刷新
            pygame.display.flip()
    
            # 处理窗口关闭
            eventList = pygame.event.get()
            for event in eventList:
                # 判断是否是退出类型
                if event.type == QUIT:
                    # 退出游戏
                    pygame.quit()
                    # 退出程序
                    sys.exit()
            # 处理按压事件
            # 返回所有键对应的状态 0:没有按压  1:有按压
            states = pygame.key.get_pressed()
            # 有按压事件
            if 1 in states:
                # 是否是关心的a d s w键
                if states[K_a]:# 0 1
                    plane.moveLeft()
                elif states[K_d]:
                    plane.moveRight()
                elif states[K_w]:
                    plane.moveUp()
                elif states[K_s]:
                    plane.moveDown()
                # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
                #     if event.key == K_a:
                #         plane.moveLeft()
                #     elif event.key == K_d:
                #         plane.moveRight()
                #     elif event.key == K_w:
                #         plane.moveUp()
                #     elif event.key == K_s:
                #         plane.moveDown()
    
    
    if __name__ == '__main__':
        start()

09.子弹类的创建

10.发射子弹

11.子弹位置确定

import pygame
    from pygame.locals import *
    import sys
    
    """
    1.标题和图标
    2.退出事件
    """
    """
    飞机属性: x,y window
    飞机行为:被展示行为display
    """
    """------------------ 子弹类 ------------------"""
    class Bullet:
        def __init__(self,px,py,pw,window):
            # 需要展示的窗口
            self.__window = window
            # 展示的控件
            self.__surface = pygame.image.load('img/bullet_10.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
    
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            self.__x = px+(pw-self.width)/2
            self.__y = py-self.height/2
    
    
        def display(self):
            '''
            展示控件
            :return:
            '''
            self.__window.blit(self.__surface,(self.__x,self.__y))
    
    
    """------------------ 我方飞机类 ------------------"""
    class Plane:
        def __init__(self, x, y, window):
            # 坐标
            self.__x = x
            self.__y = y
            # 被展示到的窗口
            self.__window = window
            # 飞机展示的Surface
            self.__surface = pygame.image.load('img/hero2.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
            # 运动速度
            self.speed = 1
            # 发射的子弹容器
            self.__bullets = []
    
        def display(self):
            '''
            被展示
            :return:
            '''
            # 展示我方飞机
            self.__window.blit(self.__surface, (self.__x, self.__y))
            # 把所有发射的子弹渲染出来
            for bullet in self.__bullets:
                # 把子弹展示出来
                bullet.display()
    
        def fire(self):
            '''
            发射子弹
            :return:
            '''
            # 子弹的x和y
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            # 创建子弹对象
            bullet = Bullet(self.__x,self.__y,self.width,self.__window)
            # 子弹对象添加到子弹列表中
            self.__bullets.append(bullet)
    
        def moveLeft(self):
            '''
            向左移动
            :return:
            '''
            self.__x -= self.speed
    
        def moveRight(self):
            '''
            向右移动
            :return:
            '''
            self.__x += self.speed
    
        def moveUp(self):
            '''
            向上移动
            :return:
            '''
            self.__y -= self.speed
    
        def moveDown(self):
            '''
            向下移动
            :return:
            '''
            self.__y += self.speed
    
    
    def start():
        # 初始化
        pygame.init()
    
        # 加载背景图片
        bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
        # 获取背景图片的大小
        bgWidth = bgSurface.get_width()
        bgHeight = bgSurface.get_height()
    
        # 创建游戏窗口
        window = pygame.display.set_mode(size=(bgWidth, bgHeight))
        # 窗口标题
        pygame.display.set_caption('飞机大战')
    
        # 加载图标图片
        iconSurface = pygame.image.load('img/app.ico')
        # 设置图标
        pygame.display.set_icon(iconSurface)
    
        # 创建飞机类
        plane = Plane(200, 600, window)
    
        # 保证窗口不关闭
        while True:
            # 展示背景
            window.blit(bgSurface, (0, 0))
            # 展示飞机
            plane.display()
            # 刷新
            pygame.display.flip()
    
            # 处理窗口关闭
            eventList = pygame.event.get()
            for event in eventList:
                # 判断是否是退出类型
                if event.type == QUIT:
                    # 退出游戏
                    pygame.quit()
                    # 退出程序
                    sys.exit()
                elif event.type==KEYDOWN:
                    if event.key==K_RETURN:
                        # 发射子弹
                        plane.fire()
    
            # 处理按压事件
            # 返回所有键对应的状态 0:没有按压  1:有按压
            states = pygame.key.get_pressed()
            # 有按压事件
            if 1 in states:
                # 是否是关心的a d s w键
                if states[K_a]:# 0 1
                    plane.moveLeft()
                elif states[K_d]:
                    plane.moveRight()
                elif states[K_w]:
                    plane.moveUp()
                elif states[K_s]:
                    plane.moveDown()
                # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
                #     if event.key == K_a:
                #         plane.moveLeft()
                #     elif event.key == K_d:
                #         plane.moveRight()
                #     elif event.key == K_w:
                #         plane.moveUp()
                #     elif event.key == K_s:
                #         plane.moveDown()
    
    
    if __name__ == '__main__':
        start()

12.子弹的移动

import pygame
    from pygame.locals import *
    import sys
    
    """
    1.标题和图标
    2.退出事件
    """
    """
    飞机属性: x,y window
    飞机行为:被展示行为display
    """
    """------------------ 子弹类 ------------------"""
    class Bullet:
        def __init__(self,px,py,pw,window):
            # 需要展示的窗口
            self.__window = window
            # 展示的控件
            self.__surface = pygame.image.load('img/bullet_10.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
    
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            self.__x = px+(pw-self.width)/2
            self.__y = py-self.height/2
            # 自动运行速度
            self.__speed = 2
    
    
        def display(self):
            '''
            展示控件
            :return:
            '''
            self.__window.blit(self.__surface,(self.__x,self.__y))
            # 自动移动
            self.autoMove()
    
        def autoMove(self):
            '''
            自动移动
            :return:
            '''
            self.__y-=self.__speed
    
    
    """------------------ 我方飞机类 ------------------"""
    class Plane:
        def __init__(self, x, y, window):
            # 坐标
            self.__x = x
            self.__y = y
            # 被展示到的窗口
            self.__window = window
            # 飞机展示的Surface
            self.__surface = pygame.image.load('img/hero2.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
            # 运动速度
            self.speed = 1
            # 发射的子弹容器
            self.__bullets = []
    
        def display(self):
            '''
            被展示
            :return:
            '''
            # 展示我方飞机
            self.__window.blit(self.__surface, (self.__x, self.__y))
            # 把所有发射的子弹渲染出来
            for bullet in self.__bullets:
                # 把子弹展示出来
                bullet.display()
    
        def fire(self):
            '''
            发射子弹
            :return:
            '''
            # 子弹的x和y
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            # 创建子弹对象
            bullet = Bullet(self.__x,self.__y,self.width,self.__window)
            # 子弹对象添加到子弹列表中
            self.__bullets.append(bullet)
    
        def moveLeft(self):
            '''
            向左移动
            :return:
            '''
            self.__x -= self.speed
    
        def moveRight(self):
            '''
            向右移动
            :return:
            '''
            self.__x += self.speed
    
        def moveUp(self):
            '''
            向上移动
            :return:
            '''
            self.__y -= self.speed
    
        def moveDown(self):
            '''
            向下移动
            :return:
            '''
            self.__y += self.speed
    
    
    def start():
        # 初始化
        pygame.init()
    
        # 加载背景图片
        bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
        # 获取背景图片的大小
        bgWidth = bgSurface.get_width()
        bgHeight = bgSurface.get_height()
    
        # 创建游戏窗口
        window = pygame.display.set_mode(size=(bgWidth, bgHeight))
        # 窗口标题
        pygame.display.set_caption('飞机大战')
    
        # 加载图标图片
        iconSurface = pygame.image.load('img/app.ico')
        # 设置图标
        pygame.display.set_icon(iconSurface)
    
        # 创建飞机类
        plane = Plane(200, 600, window)
    
        # 保证窗口不关闭
        while True:
            # 展示背景
            window.blit(bgSurface, (0, 0))
            # 展示飞机
            plane.display()
            # 刷新
            pygame.display.flip()
    
            # 处理窗口关闭
            eventList = pygame.event.get()
            for event in eventList:
                # 判断是否是退出类型
                if event.type == QUIT:
                    # 退出游戏
                    pygame.quit()
                    # 退出程序
                    sys.exit()
                elif event.type==KEYDOWN:
                    if event.key==K_RETURN:
                        # 发射子弹
                        plane.fire()
    
            # 处理按压事件
            # 返回所有键对应的状态 0:没有按压  1:有按压
            states = pygame.key.get_pressed()
            # 有按压事件
            if 1 in states:
                # 是否是关心的a d s w键
                if states[K_a]:# 0 1
                    plane.moveLeft()
                elif states[K_d]:
                    plane.moveRight()
                elif states[K_w]:
                    plane.moveUp()
                elif states[K_s]:
                    plane.moveDown()
                # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
                #     if event.key == K_a:
                #         plane.moveLeft()
                #     elif event.key == K_d:
                #         plane.moveRight()
                #     elif event.key == K_w:
                #         plane.moveUp()
                #     elif event.key == K_s:
                #         plane.moveDown()
    
    
    if __name__ == '__main__':
        start()

13.子弹的越界处理

import pygame
    from pygame.locals import *
    import sys
    
    """
    1.标题和图标
    2.退出事件
    """
    """
    飞机属性: x,y window
    飞机行为:被展示行为display
    """
    """------------------ 子弹类 ------------------"""
    class Bullet:
        def __init__(self,px,py,pw,window):
            # 需要展示的窗口
            self.__window = window
            # 展示的控件
            self.__surface = pygame.image.load('img/bullet_10.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
    
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            self.__x = px+(pw-self.width)/2
            self.__y = py-self.height/2
            # 自动运行速度
            self.__speed = 2
    
    
        def display(self):
            '''
            展示控件
            :return:
            '''
            self.__window.blit(self.__surface,(self.__x,self.__y))
            # 自动移动
            self.autoMove()
    
        def autoMove(self):
            '''
            自动移动
            :return:
            '''
            self.__y-=self.__speed
    
        def needDestroy(self):
            '''
            是否需要被销毁
            :return:
            '''
            return self.__y<=-self.height
    
    
    """------------------ 我方飞机类 ------------------"""
    class Plane:
        def __init__(self, x, y, window):
            # 坐标
            self.__x = x
            self.__y = y
            # 被展示到的窗口
            self.__window = window
            # 飞机展示的Surface
            self.__surface = pygame.image.load('img/hero2.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
            # 运动速度
            self.speed = 1
            # 发射的子弹容器
            self.__bullets = []
    
        def display(self):
            '''
            被展示
            :return:
            '''
            print(len(self.__bullets))
            # 展示我方飞机
            self.__window.blit(self.__surface, (self.__x, self.__y))
            # 先销毁越界子弹
            for bullet in self.__bullets:
                # 如果子弹需要销毁
                if bullet.needDestroy():
                    # 移除子弹对象
                    self.__bullets.remove(bullet)
                    # 内存销毁对象
                    del bullet
    
            # 把所有发射的子弹渲染出来
            for bullet in self.__bullets:
                # 把子弹展示出来
                bullet.display()
    
        def fire(self):
            '''
            发射子弹
            :return:
            '''
            # 子弹的x和y
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            # 创建子弹对象
            bullet = Bullet(self.__x,self.__y,self.width,self.__window)
            # 子弹对象添加到子弹列表中
            self.__bullets.append(bullet)
    
        def moveLeft(self):
            '''
            向左移动
            :return:
            '''
            self.__x -= self.speed
    
        def moveRight(self):
            '''
            向右移动
            :return:
            '''
            self.__x += self.speed
    
        def moveUp(self):
            '''
            向上移动
            :return:
            '''
            self.__y -= self.speed
    
        def moveDown(self):
            '''
            向下移动
            :return:
            '''
            self.__y += self.speed
    
    
    def start():
        # 初始化
        pygame.init()
    
        # 加载背景图片
        bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
        # 获取背景图片的大小
        bgWidth = bgSurface.get_width()
        bgHeight = bgSurface.get_height()
    
        # 创建游戏窗口
        window = pygame.display.set_mode(size=(bgWidth, bgHeight))
        # 窗口标题
        pygame.display.set_caption('飞机大战')
    
        # 加载图标图片
        iconSurface = pygame.image.load('img/app.ico')
        # 设置图标
        pygame.display.set_icon(iconSurface)
    
        # 创建飞机类
        plane = Plane(200, 600, window)
    
        # 保证窗口不关闭
        while True:
            # 展示背景
            window.blit(bgSurface, (0, 0))
            # 展示飞机
            plane.display()
            # 刷新
            pygame.display.flip()
    
            # 处理窗口关闭
            eventList = pygame.event.get()
            for event in eventList:
                # 判断是否是退出类型
                if event.type == QUIT:
                    # 退出游戏
                    pygame.quit()
                    # 退出程序
                    sys.exit()
                elif event.type==KEYDOWN:
                    if event.key==K_RETURN:
                        # 发射子弹
                        plane.fire()
    
            # 处理按压事件
            # 返回所有键对应的状态 0:没有按压  1:有按压
            states = pygame.key.get_pressed()
            # 有按压事件
            if 1 in states:
                # 是否是关心的a d s w键
                if states[K_a]:# 0 1
                    plane.moveLeft()
                elif states[K_d]:
                    plane.moveRight()
                elif states[K_w]:
                    plane.moveUp()
                elif states[K_s]:
                    plane.moveDown()
                # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
                #     if event.key == K_a:
                #         plane.moveLeft()
                #     elif event.key == K_d:
                #         plane.moveRight()
                #     elif event.key == K_w:
                #         plane.moveUp()
                #     elif event.key == K_s:
                #         plane.moveDown()
    
    
    if __name__ == '__main__':
        start()

14.子弹的越界处理错误解决

import pygame
    from pygame.locals import *
    import sys
    
    """
    1.标题和图标
    2.退出事件
    """
    """
    飞机属性: x,y window
    飞机行为:被展示行为display
    """
    """------------------ 子弹类 ------------------"""
    
    
    class Bullet:
        def __init__(self, px, py, pw, window):
            # 需要展示的窗口
            self.__window = window
            # 展示的控件
            self.__surface = pygame.image.load('img/bullet_10.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
    
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            self.__x = px + (pw - self.width) / 2
            self.__y = py - self.height / 2
            # 自动运行速度
            self.__speed = 2
    
        def display(self):
            '''
            展示控件
            :return:
            '''
            self.__window.blit(self.__surface, (self.__x, self.__y))
            # 自动移动
            self.autoMove()
    
        def autoMove(self):
            '''
            自动移动
            :return:
            '''
            self.__y -= self.__speed
    
        def needDestroy(self):
            '''
            是否需要被销毁
            :return:
            '''
            return self.__y <= -self.height
    
    
    """------------------ 我方飞机类 ------------------"""
    
    
    class Plane:
        def __init__(self, x, y, window):
            # 坐标
            self.__x = x
            self.__y = y
            # 被展示到的窗口
            self.__window = window
            # 飞机展示的Surface
            self.__surface = pygame.image.load('img/hero2.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
            # 运动速度
            self.speed = 1
            # 发射的子弹容器
            self.__bullets = []
    
        def display(self):
            '''
            被展示
            :return:
            '''
            print(len(self.__bullets))
            # 展示我方飞机
            self.__window.blit(self.__surface, (self.__x, self.__y))
    
            # 在循环遍历的时候做了移除元素的操作
            # 先销毁越界子弹
            # for bullet in self.__bullets:
            #     # 如果子弹需要销毁
            #     if bullet.needDestroy():
            #         # 移除子弹对象
            #         self.__bullets.remove(bullet)
            #         # 内存销毁对象
            #         del bullet
    
            for index in range(len(self.__bullets) - 1, -1, -1):
                bullet = self.__bullets[index]
                if bullet.needDestroy():
                    # 移除子弹对象
                    self.__bullets.remove(bullet)
                    # 内存销毁对象
                    del bullet
                else:
                    # 把子弹展示出来
                    bullet.display()
    
            # # 把所有发射的子弹渲染出来
            # for bullet in self.__bullets:
            #     # 把子弹展示出来
            #     bullet.display()
    
        def fire(self):
            '''
            发射子弹
            :return:
            '''
            # 子弹的x和y
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            # 创建子弹对象
            bullet = Bullet(self.__x, self.__y, self.width, self.__window)
            # 子弹对象添加到子弹列表中
            self.__bullets.append(bullet)
    
        def moveLeft(self):
            '''
            向左移动
            :return:
            '''
            self.__x -= self.speed
            # 越界处理
            if self.__x < 0:
                self.__x = 0
    
        def moveRight(self):
            '''
            向右移动
            :return:
            '''
            self.__x += self.speed
            # 越界处理
            if self.__x > bgWidth - self.width:
                self.__x = bgWidth - self.width
    
        def moveUp(self):
            '''
            向上移动
            :return:
            '''
            self.__y -= self.speed
            # 越界处理
            if self.__y < 0:
                self.__y = 0
    
        def moveDown(self):
            '''
            向下移动
            :return:
            '''
            self.__y += self.speed
            # 越界处理
            if self.__y > bgHeight - self.height:
                self.__y = bgHeight - self.height
    
    
    # 全局变量
    bgWidth = 0
    bgHeight = 0
    
    
    def start():
        global bgWidth, bgHeight
        # 初始化
        pygame.init()
    
        # 加载背景图片
        bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
        # 获取背景图片的大小
        bgWidth = bgSurface.get_width()
        bgHeight = bgSurface.get_height()
    
        # 创建游戏窗口
        window = pygame.display.set_mode(size=(bgWidth, bgHeight))
        # 窗口标题
        pygame.display.set_caption('飞机大战')
    
        # 加载图标图片
        iconSurface = pygame.image.load('img/app.ico')
        # 设置图标
        pygame.display.set_icon(iconSurface)
    
        # 创建飞机类
        plane = Plane(200, 600, window)
    
        # 保证窗口不关闭
        while True:
            # 展示背景
            window.blit(bgSurface, (0, 0))
            # 展示飞机
            plane.display()
            # 刷新
            pygame.display.flip()
    
            # 处理窗口关闭
            eventList = pygame.event.get()
            for event in eventList:
                # 判断是否是退出类型
                if event.type == QUIT:
                    # 退出游戏
                    pygame.quit()
                    # 退出程序
                    sys.exit()
                elif event.type == KEYDOWN:
                    if event.key == K_RETURN:
                        # 发射子弹
                        plane.fire()
    
            # 处理按压事件
            # 返回所有键对应的状态 0:没有按压  1:有按压
            states = pygame.key.get_pressed()
            # 有按压事件
            if 1 in states:
                # 是否是关心的a d s w键
                if states[K_a]:  # 0 1
                    plane.moveLeft()
                elif states[K_d]:
                    plane.moveRight()
                elif states[K_w]:
                    plane.moveUp()
                elif states[K_s]:
                    plane.moveDown()
                # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
                #     if event.key == K_a:
                #         plane.moveLeft()
                #     elif event.key == K_d:
                #         plane.moveRight()
                #     elif event.key == K_w:
                #         plane.moveUp()
                #     elif event.key == K_s:
                #         plane.moveDown()
    
    
    if __name__ == '__main__':
        start()

15.提取敌方飞机类

import pygame
    from pygame.locals import *
    import sys
    
    """
    1.标题和图标
    2.退出事件
    """
    """
    飞机属性: x,y window
    飞机行为:被展示行为display
    """
    """------------------ 敌方飞机类 ------------------"""
    class EnemyPlane:
        def __init__(self, x, y, window):
            # 坐标
            self.__x = x
            self.__y = y
            # 被展示到的窗口
            self.__window = window
            # 飞机展示的Surface
            self.__surface = pygame.image.load('img/img-plane_1.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
    
    
        def display(self):
            '''
            被展示
            :return:
            '''
            # 展示我方飞机
            self.__window.blit(self.__surface, (self.__x, self.__y))
    
    
    """------------------ 子弹类 ------------------"""
    class Bullet:
        def __init__(self, px, py, pw, window):
            # 需要展示的窗口
            self.__window = window
            # 展示的控件
            self.__surface = pygame.image.load('img/bullet_10.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
    
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            self.__x = px + (pw - self.width) / 2
            self.__y = py - self.height / 2
            # 自动运行速度
            self.__speed = 2
    
        def display(self):
            '''
            展示控件
            :return:
            '''
            self.__window.blit(self.__surface, (self.__x, self.__y))
            # 自动移动
            self.autoMove()
    
        def autoMove(self):
            '''
            自动移动
            :return:
            '''
            self.__y -= self.__speed
    
        def needDestroy(self):
            '''
            是否需要被销毁
            :return:
            '''
            return self.__y <= -self.height
    
    
    """------------------ 我方飞机类 ------------------"""
    
    
    class Plane:
        def __init__(self, x, y, window):
            # 坐标
            self.__x = x
            self.__y = y
            # 被展示到的窗口
            self.__window = window
            # 飞机展示的Surface
            self.__surface = pygame.image.load('img/hero2.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
            # 运动速度
            self.speed = 1
            # 发射的子弹容器
            self.__bullets = []
    
        def display(self):
            '''
            被展示
            :return:
            '''
            print(len(self.__bullets))
            # 展示我方飞机
            self.__window.blit(self.__surface, (self.__x, self.__y))
    
            # 在循环遍历的时候做了移除元素的操作
            # 先销毁越界子弹
            # for bullet in self.__bullets:
            #     # 如果子弹需要销毁
            #     if bullet.needDestroy():
            #         # 移除子弹对象
            #         self.__bullets.remove(bullet)
            #         # 内存销毁对象
            #         del bullet
    
            for index in range(len(self.__bullets) - 1, -1, -1):
                bullet = self.__bullets[index]
                if bullet.needDestroy():
                    # 移除子弹对象
                    self.__bullets.remove(bullet)
                    # 内存销毁对象
                    del bullet
                else:
                    # 把子弹展示出来
                    bullet.display()
    
            # # 把所有发射的子弹渲染出来
            # for bullet in self.__bullets:
            #     # 把子弹展示出来
            #     bullet.display()
    
        def fire(self):
            '''
            发射子弹
            :return:
            '''
            # 子弹的x和y
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            # 创建子弹对象
            bullet = Bullet(self.__x, self.__y, self.width, self.__window)
            # 子弹对象添加到子弹列表中
            self.__bullets.append(bullet)
    
        def moveLeft(self):
            '''
            向左移动
            :return:
            '''
            self.__x -= self.speed
            # 越界处理
            if self.__x < 0:
                self.__x = 0
    
        def moveRight(self):
            '''
            向右移动
            :return:
            '''
            self.__x += self.speed
            # 越界处理
            if self.__x > bgWidth - self.width:
                self.__x = bgWidth - self.width
    
        def moveUp(self):
            '''
            向上移动
            :return:
            '''
            self.__y -= self.speed
            # 越界处理
            if self.__y < 0:
                self.__y = 0
    
        def moveDown(self):
            '''
            向下移动
            :return:
            '''
            self.__y += self.speed
            # 越界处理
            if self.__y > bgHeight - self.height:
                self.__y = bgHeight - self.height
    
    
    # 全局变量
    bgWidth = 0
    bgHeight = 0
    
    
    def start():
        global bgWidth, bgHeight
        # 初始化
        pygame.init()
    
        # 加载背景图片
        bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
        # 获取背景图片的大小
        bgWidth = bgSurface.get_width()
        bgHeight = bgSurface.get_height()
    
        # 创建游戏窗口
        window = pygame.display.set_mode(size=(bgWidth, bgHeight))
        # 窗口标题
        pygame.display.set_caption('飞机大战')
    
        # 加载图标图片
        iconSurface = pygame.image.load('img/app.ico')
        # 设置图标
        pygame.display.set_icon(iconSurface)
    
        # 创建飞机类
        plane = Plane(200, 600, window)
    
        # 保证窗口不关闭
        while True:
            # 展示背景
            window.blit(bgSurface, (0, 0))
            # 展示飞机
            plane.display()
            # 刷新
            pygame.display.flip()
    
            # 处理窗口关闭
            eventList = pygame.event.get()
            for event in eventList:
                # 判断是否是退出类型
                if event.type == QUIT:
                    # 退出游戏
                    pygame.quit()
                    # 退出程序
                    sys.exit()
                elif event.type == KEYDOWN:
                    if event.key == K_RETURN:
                        # 发射子弹
                        plane.fire()
    
            # 处理按压事件
            # 返回所有键对应的状态 0:没有按压  1:有按压
            states = pygame.key.get_pressed()
            # 有按压事件
            if 1 in states:
                # 是否是关心的a d s w键
                if states[K_a]:  # 0 1
                    plane.moveLeft()
                elif states[K_d]:
                    plane.moveRight()
                elif states[K_w]:
                    plane.moveUp()
                elif states[K_s]:
                    plane.moveDown()
                # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
                #     if event.key == K_a:
                #         plane.moveLeft()
                #     elif event.key == K_d:
                #         plane.moveRight()
                #     elif event.key == K_w:
                #         plane.moveUp()
                #     elif event.key == K_s:
                #         plane.moveDown()
    
    
    if __name__ == '__main__':
        start()

16.展示敌方飞机以及敌方飞机自动移动

import pygame
    from pygame.locals import *
    import sys
    
    """
    1.标题和图标
    2.退出事件
    """
    """
    飞机属性: x,y window
    飞机行为:被展示行为display
    """
    """------------------ 敌方飞机类 ------------------"""
    class EnemyPlane:
        def __init__(self, x, y, window):
            # 坐标
            self.__x = x
            self.__y = y
            # 被展示到的窗口
            self.__window = window
            # 飞机展示的Surface
            self.__surface = pygame.image.load('img/img-plane_1.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
            # 自动移动
            self.__speed = 1
    
    
        def display(self):
            '''
            被展示
            :return:
            '''
            # 展示我方飞机
            self.__window.blit(self.__surface, (self.__x, self.__y))
            # 自动移动
            self.autoMove()
    
        def autoMove(self):
            '''
            自动移动
            :return:
            '''
            self.__y += self.__speed
    
    
    """------------------ 子弹类 ------------------"""
    class Bullet:
        def __init__(self, px, py, pw, window):
            # 需要展示的窗口
            self.__window = window
            # 展示的控件
            self.__surface = pygame.image.load('img/bullet_10.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
    
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            self.__x = px + (pw - self.width) / 2
            self.__y = py - self.height / 2
            # 自动运行速度
            self.__speed = 2
    
        def display(self):
            '''
            展示控件
            :return:
            '''
            self.__window.blit(self.__surface, (self.__x, self.__y))
            # 自动移动
            self.autoMove()
    
        def autoMove(self):
            '''
            自动移动
            :return:
            '''
            self.__y -= self.__speed
    
        def needDestroy(self):
            '''
            是否需要被销毁
            :return:
            '''
            return self.__y <= -self.height
    
    
    """------------------ 我方飞机类 ------------------"""
    
    
    class Plane:
        def __init__(self, x, y, window):
            # 坐标
            self.__x = x
            self.__y = y
            # 被展示到的窗口
            self.__window = window
            # 飞机展示的Surface
            self.__surface = pygame.image.load('img/hero2.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
            # 运动速度
            self.speed = 1
            # 发射的子弹容器
            self.__bullets = []
    
        def display(self):
            '''
            被展示
            :return:
            '''
            print(len(self.__bullets))
            # 展示我方飞机
            self.__window.blit(self.__surface, (self.__x, self.__y))
    
            # 在循环遍历的时候做了移除元素的操作
            # 先销毁越界子弹
            # for bullet in self.__bullets:
            #     # 如果子弹需要销毁
            #     if bullet.needDestroy():
            #         # 移除子弹对象
            #         self.__bullets.remove(bullet)
            #         # 内存销毁对象
            #         del bullet
            # 是否和敌方飞机发生了碰撞
            # TODO 是否发生碰撞
    
            # 展示
            for index in range(len(self.__bullets) - 1, -1, -1):
                bullet = self.__bullets[index]
                if bullet.needDestroy():
                    # 移除子弹对象
                    self.__bullets.remove(bullet)
                    # 内存销毁对象
                    del bullet
                else:
                    # 把子弹展示出来
                    bullet.display()
    
            # # 把所有发射的子弹渲染出来
            # for bullet in self.__bullets:
            #     # 把子弹展示出来
            #     bullet.display()
    
        def fire(self):
            '''
            发射子弹
            :return:
            '''
            # 子弹的x和y
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            # 创建子弹对象
            bullet = Bullet(self.__x, self.__y, self.width, self.__window)
            # 子弹对象添加到子弹列表中
            self.__bullets.append(bullet)
    
        def moveLeft(self):
            '''
            向左移动
            :return:
            '''
            self.__x -= self.speed
            # 越界处理
            if self.__x < 0:
                self.__x = 0
    
        def moveRight(self):
            '''
            向右移动
            :return:
            '''
            self.__x += self.speed
            # 越界处理
            if self.__x > bgWidth - self.width:
                self.__x = bgWidth - self.width
    
        def moveUp(self):
            '''
            向上移动
            :return:
            '''
            self.__y -= self.speed
            # 越界处理
            if self.__y < 0:
                self.__y = 0
    
        def moveDown(self):
            '''
            向下移动
            :return:
            '''
            self.__y += self.speed
            # 越界处理
            if self.__y > bgHeight - self.height:
                self.__y = bgHeight - self.height
    
    
    # 全局变量
    bgWidth = 0
    bgHeight = 0
    
    
    def start():
        global bgWidth, bgHeight
        # 初始化
        pygame.init()
    
        # 加载背景图片
        bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
        # 获取背景图片的大小
        bgWidth = bgSurface.get_width()
        bgHeight = bgSurface.get_height()
    
        # 创建游戏窗口
        window = pygame.display.set_mode(size=(bgWidth, bgHeight))
        # 窗口标题
        pygame.display.set_caption('飞机大战')
    
        # 加载图标图片
        iconSurface = pygame.image.load('img/app.ico')
        # 设置图标
        pygame.display.set_icon(iconSurface)
    
        # 创建飞机类
        plane = Plane(200, 600, window)
    
        # 创建敌方飞机类
        enemyPlane = EnemyPlane(100,0,window)
    
        # 保证窗口不关闭
        while True:
            # 展示背景
            window.blit(bgSurface, (0, 0))
            # 展示我方飞机
            plane.display()
            # 展示敌方飞机
            enemyPlane.display()
            # 刷新
            pygame.display.flip()
    
            # 处理窗口关闭
            eventList = pygame.event.get()
            for event in eventList:
                # 判断是否是退出类型
                if event.type == QUIT:
                    # 退出游戏
                    pygame.quit()
                    # 退出程序
                    sys.exit()
                elif event.type == KEYDOWN:
                    if event.key == K_RETURN:
                        # 发射子弹
                        plane.fire()
    
            # 处理按压事件
            # 返回所有键对应的状态 0:没有按压  1:有按压
            states = pygame.key.get_pressed()
            # 有按压事件
            if 1 in states:
                # 是否是关心的a d s w键
                if states[K_a]:  # 0 1
                    plane.moveLeft()
                elif states[K_d]:
                    plane.moveRight()
                elif states[K_w]:
                    plane.moveUp()
                elif states[K_s]:
                    plane.moveDown()
                # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
                #     if event.key == K_a:
                #         plane.moveLeft()
                #     elif event.key == K_d:
                #         plane.moveRight()
                #     elif event.key == K_w:
                #         plane.moveUp()
                #     elif event.key == K_s:
                #         plane.moveDown()
    
    
    if __name__ == '__main__':
        start()

17.子弹和敌方飞机碰撞检测

import pygame
    from pygame.locals import *
    import sys
    
    """
    1.标题和图标
    2.退出事件
    """
    """
    飞机属性: x,y window
    飞机行为:被展示行为display
    """
    """------------------ 敌方飞机类 ------------------"""
    class EnemyPlane:
        def __init__(self, x, y, window):
            # 坐标
            self.__x = x
            self.__y = y
            # 被展示到的窗口
            self.__window = window
            # 飞机展示的Surface
            self.__surface = pygame.image.load('img/img-plane_1.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
            # 自动移动
            self.__speed = 1
    
        def getX(self):
            return self.__x
    
        def getY(self):
            return self.__y
    
        def display(self):
            '''
            被展示
            :return:
            '''
            # 展示我方飞机
            self.__window.blit(self.__surface, (self.__x, self.__y))
            # 自动移动
            self.autoMove()
    
        def autoMove(self):
            '''
            自动移动
            :return:
            '''
            self.__y += self.__speed
    
    
    """------------------ 子弹类 ------------------"""
    class Bullet:
        def __init__(self, px, py, pw, window):
            # 需要展示的窗口
            self.__window = window
            # 展示的控件
            self.__surface = pygame.image.load('img/bullet_10.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
    
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            self.__x = px + (pw - self.width) / 2
            self.__y = py - self.height / 2
            # 自动运行速度
            self.__speed = 2
    
        def display(self):
            '''
            展示控件
            :return:
            '''
            self.__window.blit(self.__surface, (self.__x, self.__y))
            # 自动移动
            self.autoMove()
    
        def autoMove(self):
            '''
            自动移动
            :return:
            '''
            self.__y -= self.__speed
    
        def needDestroy(self):
            '''
            是否需要被销毁
            :return:
            '''
            return self.__y <= -self.height
    
        def hasShootEnemey(self,enemy):
            '''
            是否已经射击到敌方飞机
            :param enemy: EnemyPlane
            :return:
            '''
            # 子弹矩形
            bulletRect = pygame.Rect(self.__x,self.__y,self.width,self.height)
            # 敌方飞机矩形
            enemyRect = pygame.Rect(enemy.getX(),enemy.getY(),enemy.width,enemy.height)
    
            return bulletRect.colliderect(enemyRect)
    
    
    
    """------------------ 我方飞机类 ------------------"""
    
    
    class Plane:
        def __init__(self, x, y, window):
            # 坐标
            self.__x = x
            self.__y = y
            # 被展示到的窗口
            self.__window = window
            # 飞机展示的Surface
            self.__surface = pygame.image.load('img/hero2.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
            # 运动速度
            self.speed = 1
            # 发射的子弹容器
            self.__bullets = []
    
        def display(self):
            '''
            被展示
            :return:
            '''
            print(len(self.__bullets))
            # 展示我方飞机
            self.__window.blit(self.__surface, (self.__x, self.__y))
    
            # 在循环遍历的时候做了移除元素的操作
            # 先销毁越界子弹
            # for bullet in self.__bullets:
            #     # 如果子弹需要销毁
            #     if bullet.needDestroy():
            #         # 移除子弹对象
            #         self.__bullets.remove(bullet)
            #         # 内存销毁对象
            #         del bullet
            # 是否和敌方飞机发生了碰撞
            for index in range(len(self.__bullets) - 1, -1, -1):
                bullet = self.__bullets[index]
                # bullet和enemy是否发生了碰撞
                if bullet.hasShootEnemey(enemyPlane):
                    # 子弹销毁
                    self.__bullets.remove(bullet)
                    del bullet
                    # 敌方飞机打掉
                    # 敌方飞机复用
    
    
            # 展示
            for index in range(len(self.__bullets) - 1, -1, -1):
                bullet = self.__bullets[index]
                if bullet.needDestroy():
                    # 移除子弹对象
                    self.__bullets.remove(bullet)
                    # 内存销毁对象
                    del bullet
                else:
                    # 把子弹展示出来
                    bullet.display()
    
            # # 把所有发射的子弹渲染出来
            # for bullet in self.__bullets:
            #     # 把子弹展示出来
            #     bullet.display()
    
        def fire(self):
            '''
            发射子弹
            :return:
            '''
            # 子弹的x和y
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            # 创建子弹对象
            bullet = Bullet(self.__x, self.__y, self.width, self.__window)
            # 子弹对象添加到子弹列表中
            self.__bullets.append(bullet)
    
        def moveLeft(self):
            '''
            向左移动
            :return:
            '''
            self.__x -= self.speed
            # 越界处理
            if self.__x < 0:
                self.__x = 0
    
        def moveRight(self):
            '''
            向右移动
            :return:
            '''
            self.__x += self.speed
            # 越界处理
            if self.__x > bgWidth - self.width:
                self.__x = bgWidth - self.width
    
        def moveUp(self):
            '''
            向上移动
            :return:
            '''
            self.__y -= self.speed
            # 越界处理
            if self.__y < 0:
                self.__y = 0
    
        def moveDown(self):
            '''
            向下移动
            :return:
            '''
            self.__y += self.speed
            # 越界处理
            if self.__y > bgHeight - self.height:
                self.__y = bgHeight - self.height
    
    
    # 全局变量
    bgWidth = 0
    bgHeight = 0
    
    # 敌方飞机
    enemyPlane = None
    
    def start():
        global bgWidth, bgHeight,enemyPlane
        # 初始化
        pygame.init()
    
        # 加载背景图片
        bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
        # 获取背景图片的大小
        bgWidth = bgSurface.get_width()
        bgHeight = bgSurface.get_height()
    
        # 创建游戏窗口
        window = pygame.display.set_mode(size=(bgWidth, bgHeight))
        # 窗口标题
        pygame.display.set_caption('飞机大战')
    
        # 加载图标图片
        iconSurface = pygame.image.load('img/app.ico')
        # 设置图标
        pygame.display.set_icon(iconSurface)
    
        # 创建飞机类
        plane = Plane(200, 600, window)
    
        # 创建敌方飞机类
        enemyPlane = EnemyPlane(100,0,window)
    
        # 保证窗口不关闭
        while True:
            # 展示背景
            window.blit(bgSurface, (0, 0))
            # 展示我方飞机
            plane.display()
            # 展示敌方飞机
            enemyPlane.display()
            # 刷新
            pygame.display.flip()
    
            # 处理窗口关闭
            eventList = pygame.event.get()
            for event in eventList:
                # 判断是否是退出类型
                if event.type == QUIT:
                    # 退出游戏
                    pygame.quit()
                    # 退出程序
                    sys.exit()
                elif event.type == KEYDOWN:
                    if event.key == K_RETURN:
                        # 发射子弹
                        plane.fire()
    
            # 处理按压事件
            # 返回所有键对应的状态 0:没有按压  1:有按压
            states = pygame.key.get_pressed()
            # 有按压事件
            if 1 in states:
                # 是否是关心的a d s w键
                if states[K_a]:  # 0 1
                    plane.moveLeft()
                elif states[K_d]:
                    plane.moveRight()
                elif states[K_w]:
                    plane.moveUp()
                elif states[K_s]:
                    plane.moveDown()
                # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
                #     if event.key == K_a:
                #         plane.moveLeft()
                #     elif event.key == K_d:
                #         plane.moveRight()
                #     elif event.key == K_w:
                #         plane.moveUp()
                #     elif event.key == K_s:
                #         plane.moveDown()
    
    
    if __name__ == '__main__':
        start()

18.敌方飞机复用

import pygame
    from pygame.locals import *
    import sys
    
    """
    1.标题和图标
    2.退出事件
    """
    """
    飞机属性: x,y window
    飞机行为:被展示行为display
    """
    import random
    """------------------ 敌方飞机类 ------------------"""
    class EnemyPlane:
        def __init__(self, window):
            # 被展示到的窗口
            self.__window = window
            # 自动移动
            self.__speed = 1
            # 重置
            self.__reset()
    
        def getX(self):
            return self.__x
    
        def getY(self):
            return self.__y
    
        def display(self):
            '''
            被展示
            :return:
            '''
            # 展示我方飞机
            self.__window.blit(self.__surface, (self.__x, self.__y))
            # 自动移动
            self.autoMove()
    
        def autoMove(self):
            '''
            自动移动
            :return:
            '''
            self.__y += self.__speed
            # 如果越界 需要重置
            if self.__y>bgHeight-self.height:
                self.__reset()
    
        def reUse(self):
            '''
            飞机被打死后者飞机越界 需要重新复用飞机
            :return:
            '''
            self.__reset()
    
        def __reset(self):
            '''
            重置
            :return:
            '''
            # 飞机展示的Surface
            self.__surface = pygame.image.load('img/img-plane_{}.png'.format(random.randint(1,7)))
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
            # 坐标
            self.__x = random.randint(0,bgWidth-self.width)
            self.__y = -self.height
    
    
    """------------------ 子弹类 ------------------"""
    class Bullet:
        def __init__(self, px, py, pw, window):
            # 需要展示的窗口
            self.__window = window
            # 展示的控件
            self.__surface = pygame.image.load('img/bullet_10.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
    
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            self.__x = px + (pw - self.width) / 2
            self.__y = py - self.height / 2
            # 自动运行速度
            self.__speed = 2
    
        def display(self):
            '''
            展示控件
            :return:
            '''
            self.__window.blit(self.__surface, (self.__x, self.__y))
            # 自动移动
            self.autoMove()
    
        def autoMove(self):
            '''
            自动移动
            :return:
            '''
            self.__y -= self.__speed
    
        def needDestroy(self):
            '''
            是否需要被销毁
            :return:
            '''
            return self.__y <= -self.height
    
        def hasShootEnemey(self,enemy):
            '''
            是否已经射击到敌方飞机
            :param enemy: EnemyPlane
            :return:
            '''
            # 子弹矩形
            bulletRect = pygame.Rect(self.__x,self.__y,self.width,self.height)
            # 敌方飞机矩形
            enemyRect = pygame.Rect(enemy.getX(),enemy.getY(),enemy.width,enemy.height)
    
            return bulletRect.colliderect(enemyRect)
    
    
    
    """------------------ 我方飞机类 ------------------"""
    
    
    class Plane:
        def __init__(self, x, y, window):
            # 坐标
            self.__x = x
            self.__y = y
            # 被展示到的窗口
            self.__window = window
            # 飞机展示的Surface
            self.__surface = pygame.image.load('img/hero2.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
            # 运动速度
            self.speed = 1
            # 发射的子弹容器
            self.__bullets = []
    
        def display(self):
            '''
            被展示
            :return:
            '''
            print(len(self.__bullets))
            # 展示我方飞机
            self.__window.blit(self.__surface, (self.__x, self.__y))
    
            # 在循环遍历的时候做了移除元素的操作
            # 先销毁越界子弹
            # for bullet in self.__bullets:
            #     # 如果子弹需要销毁
            #     if bullet.needDestroy():
            #         # 移除子弹对象
            #         self.__bullets.remove(bullet)
            #         # 内存销毁对象
            #         del bullet
            # 是否和敌方飞机发生了碰撞
            for index in range(len(self.__bullets) - 1, -1, -1):
                bullet = self.__bullets[index]
                # bullet和enemy是否发生了碰撞
                if bullet.hasShootEnemey(enemyPlane):
                    # 子弹销毁
                    self.__bullets.remove(bullet)
                    del bullet
                    # 敌方飞机打掉
                    # 敌方飞机复用
                    enemyPlane.reUse()
    
    
            # 展示
            for index in range(len(self.__bullets) - 1, -1, -1):
                bullet = self.__bullets[index]
                if bullet.needDestroy():
                    # 移除子弹对象
                    self.__bullets.remove(bullet)
                    # 内存销毁对象
                    del bullet
                else:
                    # 把子弹展示出来
                    bullet.display()
    
            # # 把所有发射的子弹渲染出来
            # for bullet in self.__bullets:
            #     # 把子弹展示出来
            #     bullet.display()
    
        def fire(self):
            '''
            发射子弹
            :return:
            '''
            # 子弹的x和y
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            # 创建子弹对象
            bullet = Bullet(self.__x, self.__y, self.width, self.__window)
            # 子弹对象添加到子弹列表中
            self.__bullets.append(bullet)
    
        def moveLeft(self):
            '''
            向左移动
            :return:
            '''
            self.__x -= self.speed
            # 越界处理
            if self.__x < 0:
                self.__x = 0
    
        def moveRight(self):
            '''
            向右移动
            :return:
            '''
            self.__x += self.speed
            # 越界处理
            if self.__x > bgWidth - self.width:
                self.__x = bgWidth - self.width
    
        def moveUp(self):
            '''
            向上移动
            :return:
            '''
            self.__y -= self.speed
            # 越界处理
            if self.__y < 0:
                self.__y = 0
    
        def moveDown(self):
            '''
            向下移动
            :return:
            '''
            self.__y += self.speed
            # 越界处理
            if self.__y > bgHeight - self.height:
                self.__y = bgHeight - self.height
    
    
    # 全局变量
    bgWidth = 0
    bgHeight = 0
    
    # 敌方飞机
    enemyPlane = None
    
    def start():
        global bgWidth, bgHeight,enemyPlane
        # 初始化
        pygame.init()
    
        # 加载背景图片
        bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
        # 获取背景图片的大小
        bgWidth = bgSurface.get_width()
        bgHeight = bgSurface.get_height()
    
        # 创建游戏窗口
        window = pygame.display.set_mode(size=(bgWidth, bgHeight))
        # 窗口标题
        pygame.display.set_caption('飞机大战')
    
        # 加载图标图片
        iconSurface = pygame.image.load('img/app.ico')
        # 设置图标
        pygame.display.set_icon(iconSurface)
    
        # 创建飞机类
        plane = Plane(200, 600, window)
    
        # 创建敌方飞机类
        enemyPlane = EnemyPlane(window)
    
        # 保证窗口不关闭
        while True:
            # 展示背景
            window.blit(bgSurface, (0, 0))
            # 展示我方飞机
            plane.display()
            # 展示敌方飞机
            enemyPlane.display()
            # 刷新
            pygame.display.flip()
    
            # 处理窗口关闭
            eventList = pygame.event.get()
            for event in eventList:
                # 判断是否是退出类型
                if event.type == QUIT:
                    # 退出游戏
                    pygame.quit()
                    # 退出程序
                    sys.exit()
                elif event.type == KEYDOWN:
                    if event.key == K_RETURN:
                        # 发射子弹
                        plane.fire()
    
            # 处理按压事件
            # 返回所有键对应的状态 0:没有按压  1:有按压
            states = pygame.key.get_pressed()
            # 有按压事件
            if 1 in states:
                # 是否是关心的a d s w键
                if states[K_a]:  # 0 1
                    plane.moveLeft()
                elif states[K_d]:
                    plane.moveRight()
                elif states[K_w]:
                    plane.moveUp()
                elif states[K_s]:
                    plane.moveDown()
                # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
                #     if event.key == K_a:
                #         plane.moveLeft()
                #     elif event.key == K_d:
                #         plane.moveRight()
                #     elif event.key == K_w:
                #         plane.moveUp()
                #     elif event.key == K_s:
                #         plane.moveDown()
    
    
    if __name__ == '__main__':
        start()

批量产生敌方飞机:

import pygame
    from pygame.locals import *
    import sys
    
    """
    1.标题和图标
    2.退出事件
    """
    """
    飞机属性: x,y window
    飞机行为:被展示行为display
    """
    import random
    """------------------ 敌方飞机类 ------------------"""
    class EnemyPlane:
        def __init__(self, window):
            # 被展示到的窗口
            self.__window = window
            # 自动移动
            self.__speed = 1
            # 重置
            self.__reset()
    
        def getX(self):
            return self.__x
    
        def getY(self):
            return self.__y
    
        def display(self):
            '''
            被展示
            :return:
            '''
            # 展示我方飞机
            self.__window.blit(self.__surface, (self.__x, self.__y))
            # 自动移动
            self.autoMove()
    
        def autoMove(self):
            '''
            自动移动
            :return:
            '''
            self.__y += self.__speed
            # 如果越界 需要重置
            if self.__y>bgHeight-self.height:
                self.__reset()
    
        def reUse(self):
            '''
            飞机被打死后者飞机越界 需要重新复用飞机
            :return:
            '''
            self.__reset()
    
        def __reset(self):
            '''
            重置
            :return:
            '''
            # 飞机展示的Surface
            self.__surface = pygame.image.load('img/img-plane_{}.png'.format(random.randint(1,7)))
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
            # 坐标
            self.__x = random.randint(0,bgWidth-self.width)
            self.__y = -random.randint(3*self.height,10*self.height)
    
    
    """------------------ 子弹类 ------------------"""
    class Bullet:
        def __init__(self, px, py, pw, window):
            # 需要展示的窗口
            self.__window = window
            # 展示的控件
            self.__surface = pygame.image.load('img/bullet_10.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
    
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            self.__x = px + (pw - self.width) / 2
            self.__y = py - self.height / 2
            # 自动运行速度
            self.__speed = 2
    
        def display(self):
            '''
            展示控件
            :return:
            '''
            self.__window.blit(self.__surface, (self.__x, self.__y))
            # 自动移动
            self.autoMove()
    
        def autoMove(self):
            '''
            自动移动
            :return:
            '''
            self.__y -= self.__speed
    
        def needDestroy(self):
            '''
            是否需要被销毁
            :return:
            '''
            return self.__y <= -self.height
    
        def hasShootEnemey(self,enemy):
            '''
            是否已经射击到敌方飞机
            :param enemy: EnemyPlane
            :return:
            '''
            # 子弹矩形
            bulletRect = pygame.Rect(self.__x,self.__y,self.width,self.height)
            # 敌方飞机矩形
            enemyRect = pygame.Rect(enemy.getX(),enemy.getY(),enemy.width,enemy.height)
    
            return bulletRect.colliderect(enemyRect)
    
    
    
    """------------------ 我方飞机类 ------------------"""
    
    
    class Plane:
        def __init__(self, x, y, window):
            # 坐标
            self.__x = x
            self.__y = y
            # 被展示到的窗口
            self.__window = window
            # 飞机展示的Surface
            self.__surface = pygame.image.load('img/hero2.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
            # 运动速度
            self.speed = 1
            # 发射的子弹容器
            self.__bullets = []
            # 血量值
            self.blood = 5
    
        def hasCollision(self,enemy):
            '''
            是否和敌方飞机发生了碰撞
            :param enemy:
            :return:
            '''
            # 我方飞机矩形
            myRect = pygame.Rect(self.__x,self.__y,self.width,self.height)
            # 敌方飞机矩形
            enemyRect = pygame.Rect(enemy.getX(),enemy.getY(),enemy.width,enemy.height)
            return myRect.colliderect(enemyRect)
    
        def display(self):
            '''
            被展示
            :return:
            '''
            # 展示我方飞机
            self.__window.blit(self.__surface, (self.__x, self.__y))
    
            # 在循环遍历的时候做了移除元素的操作
            # 先销毁越界子弹
            # for bullet in self.__bullets:
            #     # 如果子弹需要销毁
            #     if bullet.needDestroy():
            #         # 移除子弹对象
            #         self.__bullets.remove(bullet)
            #         # 内存销毁对象
            #         del bullet
    
            # 检测我方飞机和敌方飞机是否发生了碰撞
            for enemy in enemyList:
                # 判断是否发生了碰撞
                if self.hasCollision(enemy):
                    # 我方飞机掉血
                    self.blood -= 1
                    print('血量',self.blood)
                    # 敌方飞机重复使用
                    enemy.reUse()
    
            # 子弹是否和敌方飞机发生了碰撞
            for index in range(len(self.__bullets) - 1, -1, -1):
                bullet = self.__bullets[index]
                for enemy in enemyList:
                    # bullet和enemy是否发生了碰撞
                    if bullet.hasShootEnemey(enemy):
                        # 子弹销毁
                        self.__bullets.remove(bullet)
                        del bullet
                        # 敌方飞机打掉
                        # 敌方飞机复用
                        enemy.reUse()
                        # 退出里层循环
                        break
    
    
    
    
            # 展示
            for index in range(len(self.__bullets) - 1, -1, -1):
                bullet = self.__bullets[index]
                if bullet.needDestroy():
                    # 移除子弹对象
                    self.__bullets.remove(bullet)
                    # 内存销毁对象
                    del bullet
                else:
                    # 把子弹展示出来
                    bullet.display()
    
            # # 把所有发射的子弹渲染出来
            # for bullet in self.__bullets:
            #     # 把子弹展示出来
            #     bullet.display()
    
        def fire(self):
            '''
            发射子弹
            :return:
            '''
            # 子弹的x和y
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            # 创建子弹对象
            bullet = Bullet(self.__x, self.__y, self.width, self.__window)
            # 子弹对象添加到子弹列表中
            self.__bullets.append(bullet)
    
        def moveLeft(self):
            '''
            向左移动
            :return:
            '''
            self.__x -= self.speed
            # 越界处理
            if self.__x < 0:
                self.__x = 0
    
        def moveRight(self):
            '''
            向右移动
            :return:
            '''
            self.__x += self.speed
            # 越界处理
            if self.__x > bgWidth - self.width:
                self.__x = bgWidth - self.width
    
        def moveUp(self):
            '''
            向上移动
            :return:
            '''
            self.__y -= self.speed
            # 越界处理
            if self.__y < 0:
                self.__y = 0
    
        def moveDown(self):
            '''
            向下移动
            :return:
            '''
            self.__y += self.speed
            # 越界处理
            if self.__y > bgHeight - self.height:
                self.__y = bgHeight - self.height
    
    
    # 全局变量
    bgWidth = 0
    bgHeight = 0
    
    # 敌方飞机
    enemyList = []
    
    def start():
        global bgWidth, bgHeight,enemyPlane
        # 初始化
        pygame.init()
    
        # 加载背景图片
        bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
        # 获取背景图片的大小
        bgWidth = bgSurface.get_width()
        bgHeight = bgSurface.get_height()
    
        # 创建游戏窗口
        window = pygame.display.set_mode(size=(bgWidth, bgHeight))
        # 窗口标题
        pygame.display.set_caption('飞机大战')
    
        # 加载图标图片
        iconSurface = pygame.image.load('img/app.ico')
        # 设置图标
        pygame.display.set_icon(iconSurface)
    
        # 创建飞机类
        plane = Plane(200, 600, window)
    
        # 创建5个敌方飞机对象
        for index in range(0,5):
            enemyList.append(EnemyPlane(window))
    
        # 保证窗口不关闭
        while True:
            # 展示背景
            window.blit(bgSurface, (0, 0))
            # 展示我方飞机
            plane.display()
            # 展示敌方飞机
            for enemy in enemyList:
                enemy.display()
    
            # 刷新
            pygame.display.flip()
    
            # 处理窗口关闭
            eventList = pygame.event.get()
            for event in eventList:
                # 判断是否是退出类型
                if event.type == QUIT:
                    # 退出游戏
                    pygame.quit()
                    # 退出程序
                    sys.exit()
                elif event.type == KEYDOWN:
                    if event.key == K_RETURN:
                        # 发射子弹
                        plane.fire()
    
            # 处理按压事件
            # 返回所有键对应的状态 0:没有按压  1:有按压
            states = pygame.key.get_pressed()
            # 有按压事件
            if 1 in states:
                # 是否是关心的a d s w键
                if states[K_a]:  # 0 1
                    plane.moveLeft()
                elif states[K_d]:
                    plane.moveRight()
                elif states[K_w]:
                    plane.moveUp()
                elif states[K_s]:
                    plane.moveDown()
                # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
                #     if event.key == K_a:
                #         plane.moveLeft()
                #     elif event.key == K_d:
                #         plane.moveRight()
                #     elif event.key == K_w:
                #         plane.moveUp()
                #     elif event.key == K_s:
                #         plane.moveDown()
    
    
    if __name__ == '__main__':
        start()

20.游戏结束

import pygame
    from pygame.locals import *
    import sys
    
    """
    1.标题和图标
    2.退出事件
    """
    """
    飞机属性: x,y window
    飞机行为:被展示行为display
    """
    import random
    """------------------ 敌方飞机类 ------------------"""
    class EnemyPlane:
        def __init__(self, window):
            # 被展示到的窗口
            self.__window = window
            # 自动移动
            self.__speed = 1
            # 重置
            self.__reset()
    
        def getX(self):
            return self.__x
    
        def getY(self):
            return self.__y
    
        def display(self):
            '''
            被展示
            :return:
            '''
            # 展示我方飞机
            self.__window.blit(self.__surface, (self.__x, self.__y))
    
    
        def autoMove(self):
            '''
            自动移动
            :return:
            '''
            self.__y += self.__speed
            # 如果越界 需要重置
            if self.__y>bgHeight-self.height:
                self.__reset()
    
        def reUse(self):
            '''
            飞机被打死后者飞机越界 需要重新复用飞机
            :return:
            '''
            self.__reset()
    
        def __reset(self):
            '''
            重置
            :return:
            '''
            # 飞机展示的Surface
            self.__surface = pygame.image.load('img/img-plane_{}.png'.format(random.randint(1,7)))
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
            # 坐标
            self.__x = random.randint(0,bgWidth-self.width)
            self.__y = -random.randint(3*self.height,10*self.height)
    
    
    """------------------ 子弹类 ------------------"""
    class Bullet:
        def __init__(self, px, py, pw, window):
            # 需要展示的窗口
            self.__window = window
            # 展示的控件
            self.__surface = pygame.image.load('img/bullet_10.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
    
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            self.__x = px + (pw - self.width) / 2
            self.__y = py - self.height / 2
            # 自动运行速度
            self.__speed = 2
    
        def display(self):
            '''
            展示控件
            :return:
            '''
            self.__window.blit(self.__surface, (self.__x, self.__y))
            # 自动移动
            self.autoMove()
    
        def autoMove(self):
            '''
            自动移动
            :return:
            '''
            self.__y -= self.__speed
    
        def needDestroy(self):
            '''
            是否需要被销毁
            :return:
            '''
            return self.__y <= -self.height
    
        def hasShootEnemey(self,enemy):
            '''
            是否已经射击到敌方飞机
            :param enemy: EnemyPlane
            :return:
            '''
            # 子弹矩形
            bulletRect = pygame.Rect(self.__x,self.__y,self.width,self.height)
            # 敌方飞机矩形
            enemyRect = pygame.Rect(enemy.getX(),enemy.getY(),enemy.width,enemy.height)
    
            return bulletRect.colliderect(enemyRect)
    
    
    
    """------------------ 我方飞机类 ------------------"""
    
    
    class Plane:
        def __init__(self, x, y, window):
            # 坐标
            self.__x = x
            self.__y = y
            # 被展示到的窗口
            self.__window = window
            # 飞机展示的Surface
            self.__surface = pygame.image.load('img/hero2.png')
            # 控件宽度和高度
            self.width = self.__surface.get_width()
            self.height = self.__surface.get_height()
            # 运动速度
            self.speed = 1
            # 发射的子弹容器
            self.__bullets = []
            # 血量值
            self.blood = 5
    
        def hasCollision(self,enemy):
            '''
            是否和敌方飞机发生了碰撞
            :param enemy:
            :return:
            '''
            # 我方飞机矩形
            myRect = pygame.Rect(self.__x,self.__y,self.width,self.height)
            # 敌方飞机矩形
            enemyRect = pygame.Rect(enemy.getX(),enemy.getY(),enemy.width,enemy.height)
            return myRect.colliderect(enemyRect)
    
        def display(self):
            '''
            被展示
            :return:
            '''
            # 展示我方飞机
            self.__window.blit(self.__surface, (self.__x, self.__y))
    
            # 在循环遍历的时候做了移除元素的操作
            # 先销毁越界子弹
            # for bullet in self.__bullets:
            #     # 如果子弹需要销毁
            #     if bullet.needDestroy():
            #         # 移除子弹对象
            #         self.__bullets.remove(bullet)
            #         # 内存销毁对象
            #         del bullet
    
            # 检测我方飞机和敌方飞机是否发生了碰撞
            for enemy in enemyList:
                # 判断是否发生了碰撞
                if self.hasCollision(enemy):
                    # 我方飞机掉血
                    self.blood -= 1
                    print('血量',self.blood)
                    # 敌方飞机重复使用
                    enemy.reUse()
    
            # 子弹是否和敌方飞机发生了碰撞
            for index in range(len(self.__bullets) - 1, -1, -1):
                bullet = self.__bullets[index]
                for enemy in enemyList:
                    # bullet和enemy是否发生了碰撞
                    if bullet.hasShootEnemey(enemy):
                        # 子弹销毁
                        self.__bullets.remove(bullet)
                        del bullet
                        # 敌方飞机打掉
                        # 敌方飞机复用
                        enemy.reUse()
                        # 退出里层循环
                        break
    
    
    
    
            # 展示
            for index in range(len(self.__bullets) - 1, -1, -1):
                bullet = self.__bullets[index]
                if bullet.needDestroy():
                    # 移除子弹对象
                    self.__bullets.remove(bullet)
                    # 内存销毁对象
                    del bullet
                else:
                    # 把子弹展示出来
                    bullet.display()
    
            # # 把所有发射的子弹渲染出来
            # for bullet in self.__bullets:
            #     # 把子弹展示出来
            #     bullet.display()
    
        def fire(self):
            '''
            发射子弹
            :return:
            '''
            # 子弹的x和y
            # bx = px + (pw - bw) / 2
            # by = py - bh / 2
            # 创建子弹对象
            bullet = Bullet(self.__x, self.__y, self.width, self.__window)
            # 子弹对象添加到子弹列表中
            self.__bullets.append(bullet)
    
        def moveLeft(self):
            '''
            向左移动
            :return:
            '''
            self.__x -= self.speed
            # 越界处理
            if self.__x < 0:
                self.__x = 0
    
        def moveRight(self):
            '''
            向右移动
            :return:
            '''
            self.__x += self.speed
            # 越界处理
            if self.__x > bgWidth - self.width:
                self.__x = bgWidth - self.width
    
        def moveUp(self):
            '''
            向上移动
            :return:
            '''
            self.__y -= self.speed
            # 越界处理
            if self.__y < 0:
                self.__y = 0
    
        def moveDown(self):
            '''
            向下移动
            :return:
            '''
            self.__y += self.speed
            # 越界处理
            if self.__y > bgHeight - self.height:
                self.__y = bgHeight - self.height
    
    
    # 全局变量
    bgWidth = 0
    bgHeight = 0
    
    # 敌方飞机
    enemyList = []
    
    def start():
        global bgWidth, bgHeight,enemyPlane
        # 初始化
        pygame.init()
    
        # 加载背景图片
        bgSurface = pygame.image.load('img/img_bg_level_1.jpg')
        # 获取背景图片的大小
        bgWidth = bgSurface.get_width()
        bgHeight = bgSurface.get_height()
    
        # 创建游戏窗口
        window = pygame.display.set_mode(size=(bgWidth, bgHeight))
        # 窗口标题
        pygame.display.set_caption('飞机大战')
    
        # 加载图标图片
        iconSurface = pygame.image.load('img/app.ico')
        # 设置图标
        pygame.display.set_icon(iconSurface)
    
        # 创建飞机类
        plane = Plane(200, 600, window)
    
        # 创建5个敌方飞机对象
        for index in range(0,5):
            enemyList.append(EnemyPlane(window))
    
        # 游戏结束文字
        font = pygame.font.Font('font/happy.ttf',50)
        gameOverSurface = font.render('游戏结束',True,(255,255,255))
    
        # 保证窗口不关闭
        while True:
            # 展示背景
            window.blit(bgSurface, (0, 0))
            # 展示我方飞机
            plane.display()
    
            # 展示敌方飞机
            for enemy in enemyList:
                enemy.display()
    
            # 处理窗口关闭
            eventList = pygame.event.get()
            for event in eventList:
                # 判断是否是退出类型
                if event.type == QUIT:
                    # 退出游戏
                    pygame.quit()
                    # 退出程序
                    sys.exit()
                elif event.type == KEYDOWN:
                    if event.key == K_RETURN:
                        # 发射子弹
                        plane.fire()
            # 检测是否停止
            if plane.blood<=0:
                # 游戏停止
                window.blit(gameOverSurface,((bgWidth-gameOverSurface.get_width())/2,(bgHeight-gameOverSurface.get_height())/2))
                # 刷新
                pygame.display.flip()
                continue
    
    
            # 敌方飞机自动移动
            for enemy in enemyList:
                enemy.autoMove()
    
            # 刷新
            pygame.display.flip()
    
            # 处理窗口关闭
            eventList = pygame.event.get()
            for event in eventList:
                # 判断是否是退出类型
                if event.type == QUIT:
                    # 退出游戏
                    pygame.quit()
                    # 退出程序
                    sys.exit()
                elif event.type == KEYDOWN:
                    if event.key == K_RETURN:
                        # 发射子弹
                        plane.fire()
    
            # 处理按压事件
            # 返回所有键对应的状态 0:没有按压  1:有按压
            states = pygame.key.get_pressed()
            # 有按压事件
            if 1 in states:
                # 是否是关心的a d s w键
                if states[K_a]:  # 0 1
                    plane.moveLeft()
                elif states[K_d]:
                    plane.moveRight()
                elif states[K_w]:
                    plane.moveUp()
                elif states[K_s]:
                    plane.moveDown()
                # elif event.type == KEYDOWN:  # 按下事件 一次按下只能执行一次
                #     if event.key == K_a:
                #         plane.moveLeft()
                #     elif event.key == K_d:
                #         plane.moveRight()
                #     elif event.key == K_w:
                #         plane.moveUp()
                #     elif event.key == K_s:
                #         plane.moveDown()
    
    
    if __name__ == '__main__':
        start()

**代码下载:**

链接: https://pan.baidu.com/s/1yScaUX3Aumos\_iMrI4ZKjw 提取码: xwct

注意:

打包时把所有的图片和文字路径改成绝对路径:

![20200301205022396.png][]

# #

## 程序打包 ##

**PyInstaller**

将Python应用打包成可执行文件

**安装和使用**

**安装:**

pip install pyinstaller

**打包命令:**

pyinstaller-F xx.py -w

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1MjA0MTc5_size_16_color_FFFFFF_t_70 3][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1MjA0MTc5_size_16_color_FFFFFF_t_70 4][]

最后说下-p这个参数

-p：添加搜索路径

这个参数是告诉打包工具到哪去搜索依耐性文件，此次我们没有使用-p参数是因为工具默认为到python安装路径下的Lib 以及 Lib文件夹下的site-packages。

Lib文件夹下是python自带的一些库，site-packages为pip安装的库。此次的第三方库我都是通过pip安装的，所以不用加-p参数。如果使用了第三方库并且不再这两个路径下的需要加上：-p 库地址，告诉打包工具你使用的库在哪

**3.更改exe文件的图标**

自定义打包出来的exe文件图标，需要使用-i参数，同时需要准备一个ico格式的图片，贴上一个在线ico制作网站：

[ico图片转换][ico]

pyinstaller -F --icon=1234.ico run.py

**打包好的下载:**

链接: https://pan.baidu.com/s/1EFsyTRQ6C6S82c0Tw33OYA 提取码: qkc6

![20200301205316876.png][]

**注意:** 如果打包后打不开文件,就把代码中用到的资源路径改成绝对路径后在打包

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1MjA0MTc5_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200301165432340.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1MjA0MTc5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1MjA0MTc5_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020030116543885.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1MjA0MTc5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1MjA0MTc5_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200301204856498.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1MjA0MTc5,size_16,color_FFFFFF,t_70
[20200301205022396.png]: https://img-blog.csdnimg.cn/20200301205022396.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1MjA0MTc5_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200301195155553.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1MjA0MTc5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1MjA0MTc5_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200301195319310.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE1MjA0MTc5,size_16,color_FFFFFF,t_70
[ico]: https://tool.lu/favicon/
[20200301205316876.png]: https://img-blog.csdnimg.cn/20200301205316876.png