Pygame游戏 —— 飞机大战

沉稳的紫外线

已于 2024-04-24 19:52:33 修改

阅读量339

点赞数

文章标签： pygame 游戏 python

于 2023-07-18 20:25:43 首次发布

本文链接：https://blog.csdn.net/YBBBooo/article/details/131795597

版权

基本功能：

1.创建游戏窗口，效果如上图；

2.新增游戏配置脚本，将游戏的配置参数放置到游戏配置脚本中，如：游戏窗口大小、游戏背景图片路径等；

3.在游戏窗口中绘制背景图；

4.在游戏窗口中绘制主角飞机；

5.实现键盘控制主角飞机左右移动；

6.绘制主角飞机的子弹；

7.实现主角飞机发射子弹效果；

8.在游戏窗口上方生成一架敌机，并且敌机从上往下移动，当敌机移动到游戏窗口下方后（即超出游戏窗口范围），在游戏窗口上方重新生成一架敌机，循环往复；

9.当玩家飞机的子弹击中敌机后，销毁敌机，并且在游戏窗口上方重新生成一架敌机。

附加：

1.实现背景图片无限向下移动效果；

2.实现主角飞机的飞行动画；

3.实现敌机射击；

4.实现主角飞机被击中后，显示游戏结束；

5.实现主角飞机击毁10个敌机后，显示游戏胜利；

6.实现主角飞机的上下移动。

Game

#  游戏脚本，在这里封装游戏类，来编写游戏整体框架
import sys
import pygame

import Config
import DrawManager
from Config import screenSize

class Game(object):

    #开始游戏
    def Open(self):
        #  初始化pygame
        pygame.init()
        #  创建游戏窗口
        self.screen = pygame.display.set_mode(screenSize)
        #  加载背景图片
        '''
        self.bgImg = pygame.image.load('pygame图片素材/background.png')
        #self.bgImgRect = self.bgImg.get_rect()
        '''

        # 初始化游戏元素
        self.GameInit()


        #  进入游戏性主循环
        while True:
            #  (1)处理游戏事件
            self.GameEvent()
            #  (2)更新游戏状态
            self.GameUpdate()

            #  (3)刷新游戏屏幕
            pygame.display.flip()



    #  处理游戏事件
    def GameEvent(self):
        #  遍历游戏事件
        for event in pygame.event.get():
            #  判断是否有点击关闭按钮
            if event.type == pygame.QUIT:
                #  卸载Pygame,结束项目
                pygame.quit()
                sys.exit()
            #  判断是否有按下
            if event.type == pygame.KEYDOWN:
                # 上方向键
                if event.key == pygame.K_UP or event.key == pygame.K_w:
                    self.drawPlayer.up = True
                #  下方向键
                if event.key == pygame.K_DOWN or event.key == pygame.K_s:
                    self.drawPlayer.down = True
                #  左方向键
                if event.key == pygame.K_LEFT or event.key == pygame.K_a:
                    self.drawPlayer.left = True
                #  右方向键
                if event.key == pygame.K_RIGHT or event.key == pygame.K_d:
                    self.drawPlayer.right = True
            #  判断是否松开
            if event.type == pygame.KEYUP:
                # 上方向键
                if event.key == pygame.K_UP or event.key == pygame.K_w:
                    self.drawPlayer.up = False
                #  下方向键
                if event.key == pygame.K_DOWN or event.key == pygame.K_s:
                    self.drawPlayer.down = False
                #  左方向键
                if event.key == pygame.K_LEFT or event.key == pygame.K_a:
                    self.drawPlayer.left = False
                #  右方向键
                if event.key == pygame.K_RIGHT or event.key == pygame.K_d:
                    self.drawPlayer.right = False




    #  初始化游戏元素
    def GameInit(self):
        #  创建存放玩家飞机发射的子弹的容器（该容器是图片组）
        self.playerBullets = pygame.sprite.Group()
        #  创建游戏背景的对象
        self.drawBg = DrawManager.DrawBg(self.screen)
        #  创建玩家飞机
        self.drawPlayer = DrawManager.DrawPlayer(self.screen,self.playerBullets)
        #  创建存放敌机容器（该容器为图片组）
        self.enemys = pygame.sprite.Group()
        #  创建敌机子弹的容器（该容器为图片组）
        self.enemyBullets = pygame.sprite.Group()
        #  创建敌机管理器
        self.drawEnemyManager = DrawManager.DrawEnemyManager(self.screen, self.enemys, self.enemyBullets)
        #  创建游戏失败的游戏元素
        self.drawGameover = DrawManager.DrawGameOver(self.screen)
        #  创建游戏成功的游戏元素
        self.drawGamewin = DrawManager.DrawGameWin(self.screen)
        #  定义击败了多少个敌机
        self.count = 0









    #  更新游戏状态
    def GameUpdate(self):
        #  当达成游戏目标时，则弹出游戏胜利
        if self.count >= Config.gameTarget:
            #  绘制背景图片
            self.drawBg.Draw()
            #  绘制敌机管理器
            self.drawEnemyManager.Draw(True)
            #  绘制玩家飞机
            self.drawPlayer.Draw()
            #  绘制游戏胜利
            self.drawGamewin.Draw()
            return
        #  飞机处于正常状态
        if self.drawPlayer.state == '飞行中':
            #  碰撞检测函数
            self.GameCollision()

            #  绘制背景图片
            self.drawBg.Draw()

            #  绘制敌机管理器
            self.drawEnemyManager.Draw()

            #  绘制玩家飞机
            self.drawPlayer.Draw()
        #  飞机处于摧毁或已摧毁状态
        else:
            #  绘制背景图片（结束状态）
            self.drawBg.Draw(True)
            #  绘制敌机管理器（结束状态）
            self.drawEnemyManager.Draw(True)
            #  如果敌机处于损毁中的话，才绘制敌机
            if self.drawPlayer.state == '损毁中':
                self.drawPlayer.Draw()
            else:
                self.drawGameover.Draw()








    #  碰撞检测函数
    def GameCollision(self):
        #  检测玩家子弹与敌机是否有发生碰撞
        #  {有发生碰撞的子弹1：【跟子弹1有发生碰撞的敌机的列表】， 有发生碰撞的子弹2：【跟子弹2有发生碰撞的敌机的列表】}
        collider = pygame.sprite.groupcollide(self.playerBullets, self.enemys, False, False)
        #  遍历所有有发生碰撞的子弹，移除这些子弹
        for bullet in collider.keys():
            self.playerBullets.remove(bullet)
        #  遍历所有发生碰撞的敌机，移除这些敌机
        for enemys in collider.values():
            for enemy in enemys:
                #  判断敌机是否是第一次被攻击，如果是的话，我们才计数
                if enemy.obj.state == '飞行中':
                    self.count += 1
                    print(self.count, '/', Config.gameTarget)
                #  攻击敌机
                enemy.Damage()




        #  检测玩家飞机 与 敌军子弹是否发生碰撞
        #  [与玩家飞机发生了碰撞的子弹列表]
        collider1 = pygame.sprite.spritecollide(self.drawPlayer.sprite, self.enemyBullets, False)
        #  遍历子弹，来把碰撞到的敌机子弹移除
        for bullet in collider1:
            self.enemyBullets.remove(bullet)
        #  判断下，返回的碰撞列表中是否有子弹
        if len(collider1) > 0:
            #  让玩家飞机被攻击
            self.drawPlayer.Damage()




#  创建游戏对象
game = Game()
#  开始游戏
game.Open()

DrawManager

#  绘制管理脚本，存放 游戏元素的绘制类
import random
import pygame

import Animation
import Config
import time
from Animation import Animation

#  游戏元素

#  背景图片的绘制类
class DrawBg(object):
    #  构造函数
    def __init__(self, screen):
        #  加载背景图片1

        self.bgImg = pygame.image.load(Config.bgImg_filePath)
        self.bgImgRect = self.bgImg.get_rect()

        #  加载背景图片2

        self.bgImg2 = pygame.image.load(Config.bgImg_filePath)
        self.bgImgRect2 = self.bgImg2.get_rect()

        #  定义游戏窗口
        self.screen = screen

        self.screenRect = screen.get_rect()

        #  将背景图片2的初始位置放到背景图片1的上方
        self.bgImgRect2.bottom = self.bgImgRect.top



    #  绘制函数
    def Draw(self, isFinish = False):
        #  绘制背景图片
        self.screen.blit(self.bgImg,self.bgImgRect)
        #  绘制背景图片1
        self.screen.blit(self.bgImg2, self.bgImgRect2)
        if not isFinish:
            #  移动背景图片1、背景图片2
            speed = Config.bgImgSpeed
            self.bgImgRect.centery += speed
            self.bgImgRect2.centery += speed
            #  判断背景图片是否有超出游戏窗口下方
            if self.bgImgRect.top >= self.screenRect.bottom:
                self.bgImgRect.bottom = self.screenRect.top
            elif self.bgImgRect2.top >= self.screenRect.bottom:
                self.bgImgRect2.bottom = self.screenRect.top



#  主角飞机的绘制类
class DrawPlayer(object):
    #  构造函数，来加载主角飞机
    def __init__(self,screen,playerBullets):
        #  创建主角飞机图片对象
        self.sprite = pygame.sprite.Sprite()
        #  加载主角飞机图片，对象位置
        self.sprite.image = pygame.image.load(Config.playerImg_filePath)
        self.sprite.rect = self.sprite.image.get_rect()
        #  定义游戏窗口
        self.screen = screen
        self.screenRect = screen.get_rect()
        #  设置主角飞机初始位置：底部居中
        #  1)先让主角飞机居中
        self.sprite.rect.center = self.screenRect.center
        #  2)再让主角飞机底部对齐
        self.sprite.rect.bottom = self.screenRect.bottom
        #  定义玩家子弹容器
        self.playerBullets = playerBullets
        #  定义变量，记录当前时间
        self.timer = time.time()

        #  定义上下左右变量
        self.up = False
        self.down = False
        self.left = False
        self.right = False
        #  创建主角飞机的飞行动画对象  参数：存放动画的文件夹路径，游戏窗口
        self.moveAni = Animation(Config.playerMoveAni_path, screen, link_rect= self.sprite.rect)
        self.moveAni.playSpeed = Config.playerMoveAni_playSpeed
        self.moveAni.loop = Config.playerMoveAni_loop
        #  定义主角飞机飞行状态
        self.state = '飞行中'
        #  创建主角飞机的损毁动画
        self.damageAni = Animation(Config.playerDamageAni_path, screen, link_rect=self.sprite.rect)
        #  设置损毁动画的参数
        self.damageAni.playSpeed = Config.playerDamageAni_playSpeed
        self.damageAni.loop = Config.playerDamageAni_loop



    #  绘制函数，绘制主角飞机
    def Draw(self):
        if self.state == '飞行中':
            #  绘制主角飞机
            self.screen.blit(self.sprite.image, self.sprite.rect)
            #  发射子弹
            self.Shooting()
            #  移动主角飞机
            self.Move()
            #  播放动画
            self.moveAni.Play()
        #  否则，则执行损毁中的函数
        else:
            self.Damaging()

    #  主角飞机的移动控制函数
    def Move(self):
        speed = Config.playerSpeed
        #  根据上下左右的信号，控制主角飞机的移动
        if self.up:
            self.sprite.rect.centery -= speed
        elif self.down:
            self.sprite.rect.centery += speed
        if self.left:
            self.sprite.rect.centerx -= speed
        elif self.right:
            self.sprite.rect.centerx += speed


    #  发射子弹函数
    def Shooting(self):
        hit = Config.playHit     #  1秒发射子弹十次
        bulletSpeed = Config.playerBulletSpeed
        bulletImg_filePath = Config.playerBulletImg_filePath
        #  判断是否已经达到可以发射的时间
        if time.time() - self.timer >= 1/hit:
            #  如果达到时间要求，则生成一颗子弹
            bullet = DrawUpBullet(self.screen, self.sprite.rect, bulletSpeed, bulletImg_filePath)
            #  把子弹存储到子弹容器中去
            self.playerBullets.add(bullet.sprite)
            #  更新记录时间，方便计算下一颗子弹的时间
            self.timer = time.time()
        #  遍历子弹容器，绘制子弹
        for bullet in self.playerBullets.sprites():
            #  绘制子弹
            bullet.Draw()
        #  遍历子弹，来判断子弹是否超过游戏窗口的上边界
        temp = list(self.playerBullets.sprites()).copy()
        for bullet in temp:
            #  如果有超过，则将子弹容器中移除
            if bullet.rect.bottom <= self.screenRect.top:
                self.playerBullets.remove(bullet)



    #  玩家飞机被攻击方法
    def Damage(self):
        #  将玩家状态设置为损毁中
        if self.state == '飞行中':
            self.state = '损毁中'



    #  玩家飞机损毁中的方法
    def Damaging(self):
        #  播放损毁动画
        self.damageAni.Play()
        #  若播放完毕，则将状态设置为 已损毁
        if self.damageAni.isFinish:
            self.state = '已损毁'



#  向上发射的子弹绘制类
class DrawUpBullet(object):
    #  构造函数，加载子弹  参数：游戏窗口，飞机坐标位置，移动速度，子弹图片路径
    def __init__(self, screen, flyRect, speed, bulletImg_filePath):
        #  加载子弹图片
        #  (1)创建子弹图片对象
        self.sprite = pygame.sprite.Sprite()
        #  (2)给子弹图片对象，赋予图片，坐标位置
        self.sprite.image = pygame.image.load(bulletImg_filePath)
        self.sprite.rect = self.sprite.image.get_rect()
        #  定义游戏窗口
        self.screen = screen
        #  设置子弹初始位置：设置飞机的前进方向
        #  (1)设置子弹与飞机在同一个位置，也就是中心点相同
        self.sprite.rect.center = flyRect.center
        #  (2)将子弹的下边 跟 飞机的上边 同步
        self.sprite.rect.bottom = flyRect.top
        #  定义子弹速度
        self.speed = speed
        #  给图片对象增加一个Draw函数
        self.sprite.Draw = self.Draw



    #  绘制函数，绘制子弹
    def Draw(self):
        #  通过游戏窗口，绘制子弹
        self.screen.blit(self.sprite.image, self.sprite.rect)
        #  发射子弹
        self.sprite.rect.centery -= self.speed



#  向下发射的子弹绘制类
class DrawDownBullet(object):
    #  构造函数，加载子弹  参数：游戏窗口，飞机坐标位置，移动速度，子弹图片路径
    def __init__(self, screen, flyRect, speed, bulletImg_filePath):
        #  加载子弹图片
        #  (1)创建子弹图片对象
        self.sprite = pygame.sprite.Sprite()
        #  (2)给子弹图片对象，赋予图片，坐标位置
        self.sprite.image = pygame.image.load(bulletImg_filePath)
        self.sprite.rect = self.sprite.image.get_rect()
        #  定义游戏窗口
        self.screen = screen
        #  设置子弹初始位置：设置飞机的前进方向
        #  (1)设置子弹与飞机在同一个位置，也就是中心点相同
        self.sprite.rect.center = flyRect.center
        #  (2)将子弹的上边 跟 飞机的下边 同步
        self.sprite.rect.top = flyRect.bottom
        #  定义子弹速度
        self.speed = speed
        #  给图片对象增加一个Draw函数
        self.sprite.Draw = self.Draw



    #  绘制函数，绘制子弹
    def Draw(self):
        #  通过游戏窗口，绘制子弹
        self.screen.blit(self.sprite.image, self.sprite.rect)
        #  发射子弹
        self.sprite.rect.centery += self.speed



#  敌机绘制类
class DrawEnemy(object):
    #  构造函数  参数：游戏窗口，敌机子弹容器
    def __init__(self, screen, enemyBullets):
        #  加载敌机  参数：游戏窗口
        self.sprite = pygame.sprite.Sprite()
        self.sprite.image = pygame.image.load(Config.enemyImy_filePath)
        self.sprite.rect = self.sprite.image.get_rect()
        #  定义游戏窗口变量
        self.screen = screen
        self.screenRect = screen.get_rect()
        #  初始化敌机位置，设置敌机在游戏窗口上方生成
        self.sprite.rect.bottom = self.screenRect.top
        #  定义敌机子弹容器
        self.enemyBullets = enemyBullets
        #  定义变量，记录当前的时间
        self.timer = time.time()
        #  敌机状态：飞行中，损毁中，已损毁
        self.state = '飞行中'
        #  定义敌机损毁动画
        self.damageAni = Animation(Config.enemyDamageAni_path, self.screen, link_rect=self.sprite.rect)
        #  设置敌机损毁动画参数
        self.damageAni.playSpeed = Config.enemyDamageAni_playSpeed
        self.damageAni.loop = Config.enemyDamageAni_loop
        #  给敌机图片对象增加损毁的方法
        self.sprite.Damage = self.Damage
        self.sprite.obj = self



    #  绘制函数
    def Draw(self):
        self.screen.blit(self.sprite.image, self.sprite.rect)

    #  敌机攻击函数
    def Shooting(self):
        #  定义攻击频率变量hit
        hit = Config.enemyHit
        bulletSpeed = Config.enemyBulletSpeed
        bulletImg_filPath = Config.enemyBulletImg_filePath
        #  判断是否要生成下一个子弹
        if time.time() - self.timer > 1/hit:
            #  生成子弹
            bullet = DrawDownBullet(self.screen , self.sprite.rect, bulletSpeed, bulletImg_filPath)
            #  将子弹存放至容器
            self.enemyBullets.add(bullet.sprite)
            #  更新记录的时间，
            self.timer = time.time()



    #  移动参数  参数：uSpeed 向上移动速度，dSpeed 向下移动速度，lSpeed 向左移动速度，rSpeed 向右移动速度
    def Move(self, uSpeed = 0,dSpeed = 0, lSpeed = 0, rSpeed = 0):
        #  上下移动
        self.sprite.rect.centery -= uSpeed
        self.sprite.rect.centery += dSpeed
        #  左右移动
        self.sprite.rect.centerx -= lSpeed
        self.sprite.rect.centerx += rSpeed

    def Damage(self):
        #  将状态设置为损毁中的状态
        if self.state == '飞行中':
            self.state = '损毁中'

    def Damaging(self):
        #  播放损毁动画
        self.damageAni.Play()
        #  判断损毁动画是否播放完毕
        if self.damageAni.isFinish:
            #  将状态设置为已损毁状态
            self.state = '已损毁'



#  敌机管理绘制类
class DrawEnemyManager(object):
    #  构造函数  参数：游戏窗口，存放敌机的容器
    def __init__(self, screen, enemys, enemyBullets):
        #  定义游戏窗口变量
        self.screen = screen
        self.screenRect = screen.get_rect()
        #  定义敌机存放的容器
        self.enemys = enemys

        #  定义敌机子弹容器
        self.enemyBullets = enemyBullets


    #  绘制函数
    def Draw(self, isFinish = False):
        #  当游戏还没有结束时，调用敌机方案一来生成敌机
        if not isFinish:
            self.G1()
        #  绘制敌机
        self.DrawEnemy()
        #  绘制敌机子弹
        self.DrawEnemyBullet()


    #  绘制敌机函数
    def DrawEnemy(self):
        #  遍历敌机容器中的所有敌机
        for enemy in self.enemys:
            #  判断当前该敌机状态，如果是飞行中，则正常绘制
            if enemy.obj.state == '飞行中':
                #  绘制敌机
                enemy.obj.Draw()
                #  移动敌机
                enemy.obj.Move(dSpeed = Config.enemySpeed)
                #  敌机发射子弹
                enemy.obj.Shooting()

            #  若敌机当前处于摧毁中或已摧毁状态
            else:
                enemy.obj.Damaging()
        #  遍历所有敌机，检测敌机是否有超出游戏窗口下方，或者，敌机处于已摧毁的状态
        #  如果有，将该敌机移除
        temp = list(self.enemys.sprites()).copy()
        for enemy in temp:
            #  判断敌机的顶部top是否超出 游戏窗口的底部bottom
            if enemy.rect.top >= self.screenRect.bottom or enemy.obj.state =='已损毁':
                self.enemys.remove(enemy)



    #  绘制敌机子弹函数
    def DrawEnemyBullet(self):
        #  遍历敌机子弹容器绘制子弹
        for bullet in self.enemyBullets:
            # 绘制子弹
            bullet.Draw()
        #  再次遍历敌机子弹容器，来检测子弹是否有超出游戏窗口，如果有，则将他移除
        temp = list(self.enemyBullets.sprites()).copy()
        for bullet in temp:
            #  判断子弹是否有超出窗口下边
            if bullet.rect.top >= self.screenRect.bottom:
                self.enemyBullets.remove(bullet)



    #  随机敌机出生的x坐标
    def RandomX(self, enemyRect):
        #  先获得随机x坐标
        randomx = random.uniform(enemyRect.width/2, self.screenRect.right - enemyRect.width/2)
        #  然后再赋值
        enemyRect.centerx = randomx





    #  敌机方案一
    def G1(self):
        #  判断敌机容器中是否有敌机，若没有，则生成敌机
        if len(self.enemys) == 0:
            # 生成敌机
            self.enemy = DrawEnemy(self.screen, self.enemyBullets)
            #  随机敌机出生的x坐标
            self.RandomX(self.enemy.sprite.rect)
            #  将生成的敌机存到容器中去，方便后面与玩家子弹碰撞检测
            self.enemys.add(self.enemy.sprite)



#  游戏失败绘制类
class DrawGameOver(object):
    #  构造函数  参数：游戏窗口
    def __init__(self, screen):
        #  加载字体，显示游戏失败文本
        self.f = pygame.font.Font(Config.gameoverFont_path, Config.gameoverFont_size)
        self.text = self.f.render(Config.gameoverFont_content, True, Config.gameoverFont_color)
        self.textRect = self.text.get_rect()
        #  定义游戏窗口
        self.screen = screen
        self.screenRect = screen.get_rect()
        #  设置游戏失败文本的初始位置:居中
        self.textRect.center = self.screenRect.center


    #  绘制函数
    def Draw(self):
        self.screen.blit(self.text, self.textRect)





#  游戏胜利绘制类
class DrawGameWin(object):
    #  构造函数  参数：游戏窗口
    def __init__(self, screen):
        #  加载字体，显示游戏成功文本
        self.f = pygame.font.Font(Config.gamewinFont_path, Config.gamewinFont_size)
        self.text = self.f.render(Config.gamewinFont_content, True, Config.gamewinFont_color)
        self.textRect = self.text.get_rect()
        #  定义游戏窗口
        self.screen = screen
        self.screenRect = screen.get_rect()
        #  设置游戏胜利文本的初始位置:居中
        self.textRect.center = self.screenRect.center

    #  绘制函数
    def Draw(self):
        self.screen.blit(self.text, self.textRect)

Config

#  游戏配置脚本，存放游戏参数
screenSize = (480,752)
#  游戏背景图片的文件路径
bgImg_filePath = 'pygame图片素材\\background.png'
#  游戏背景图片下移速度
bgImgSpeed = 5

#  玩家飞机参数
#  玩家飞机图片路径
playerImg_filePath = 'pygame图片素材\\hero1.png'
#  玩家飞机速度
playerSpeed = 4
#  玩家飞机攻击频率
playHit = 1000
#  玩家飞机子弹速度
playerBulletSpeed = 10
#  玩家飞机子弹图片路径
playerBulletImg_filePath = 'pygame图片素材/bullet1.png'
#  玩家飞机动画
playerMoveAni_path = 'pygame图片素材/player_move'
#  玩家飞机动画播放速度
playerMoveAni_playSpeed = 50
#  玩家飞机动画循环播放
playerMoveAni_loop = True
#  玩家飞机摧毁动画的文件夹路径
playerDamageAni_path = 'pygame图片素材/here_blow up'
#  玩家损毁动画的播放速度
playerDamageAni_playSpeed = 10
#  玩家损毁动画循环播放
playerDamageAni_loop = False

#  敌机参数
#  敌机图片路径
enemyImy_filePath = 'pygame图片素材/enemy0.png'
#  敌机攻击频率
enemyHit = 2
#  敌机子弹速度
enemyBulletSpeed = 2
#  敌机子弹图片路径
enemyBulletImg_filePath = 'pygame图片素材/bullet.png'
#  敌机速度
enemySpeed = 1

#  敌机损毁动画的文件夹路径
enemyDamageAni_path = 'pygame图片素材/enemy0_down'
#  敌机损毁动画的播放速度
enemyDamageAni_playSpeed = 5
#  敌机损毁动画的循环播放
enemyDamageAni_loop = False

#  游戏失败字体路径
gameoverFont_path = r'C:\Windows\Fonts\STXINGKA.TTF'
#  游戏失败字体大小
gameoverFont_size = 145
#  游戏失败字体颜色
gameoverFont_color = 'red'
#  游戏失败文本内容
gameoverFont_content = 'GameOver'


#  游戏胜利字体路径
gamewinFont_path = r'C:\Windows\Fonts\STXINGKA.TTF'
#  游戏胜利字体大小
gamewinFont_size = 150
#  游戏胜利字体颜色
gamewinFont_color = 'red'
#  游戏胜利文本内容
gamewinFont_content = 'Victory'


#  游戏目标值
gameTarget = 10

Animation

# 封装动画类，来让我们的动画的播放写的代码更加简单一些
import os
import time
from pygame import sprite
from pygame import image


# 动画类
class Animation(object):

    # 构造函数 参数：动画图片存放路径,播放速度（1秒内播放多少张图片）,绑定外面的区域坐标rect
    def __init__(self, filePath, screen, playSpeed=1, loop=True, link_rect=None):
        # 根据动画图片存放路径，来加载图片
        # 1.创建图片组
        # self.group = sprite.Group()
        self.group = []
        # 2.获取该路径下的图片名称  os.listdir(存放路径) 获取存放路径下的所有文件的名称
        filenames = os.listdir(filePath)
        # 3.遍历这些文件名称，来加载这些文件
        for name in filenames:
            # 试着去加载图片，如果是图片的话，则加载并存放到图片组中，如果不是图片，则加载下一个文件
            try:
                # (1)创建图片对象
                s = sprite.Sprite()
                # (2)给图片对象加载本地图片
                s.image = image.load(filePath + '/' + name)
                # (3)给图片对象加载区域坐标
                s.rect = s.image.get_rect()
                # (4)存放到图片组中
                self.group.append(s)
            except:
                pass
        # 4.变量来记录经过了当前的时间
        self.timer = time.time()
        # 5.创建当前动画播放的图片对象
        if len(self.group) > 0:
            self.currentSprite = sprite.Sprite()
            self.currentSprite.image = self.group[0].image
            if link_rect is None:
                self.currentSprite.rect = self.group[0].rect
            else:
                self.currentSprite.rect = link_rect
        # 6.创建一个变量，记录当前播放的图片索引
        self.currentIndex = 0
        # 7.定义播放速度
        self.playSpeed = playSpeed
        # 8.定义是否循环播放
        self.loop = loop
        # 9.定义游戏窗口
        self.screen = screen
        # 10.动画是否播放完毕
        self.isFinish = False

    # 编写动画播放的函数
    def Play(self):
        # 第一步，判断是否有图片要播放
        if len(self.group) == 0:
            # 如果没有图片的话，则不播放
            return
        # 切换动画图片
        self.__SwitchAniamtionImg()
        # 绘制动画图片
        self.screen.blit(self.currentSprite.image, self.currentSprite.rect)

    # 切换动画图片
    def __SwitchAniamtionImg(self):
        # 第一步，判断是否循环播放，且是否播放完毕
        # 如果不循环播放，且播放完毕了，则不切换下一张动画图片
        if not self.loop and self.isFinish:
            return
        # 第二步，判断经过的时间，是否超过一张图片播放的时间 1/self.playerSpeed=>1张图片播放的时间
        if time.time() - self.timer >= 1 / self.playSpeed:
            # 图片索引号加一
            self.currentIndex += 1
            # 第三步，判断图片索引号是否超过 图片组的索引界限
            if self.currentIndex >= len(self.group):
                # 如果是循环播放的话，则把图片切换到第一张图片的索引号
                if self.loop:
                    self.currentIndex = 0
                    self.isFinish = False
                # 如果它是不循环播放的话，则把图片切换到最后一张图片的索引号
                else:
                    self.currentIndex = len(self.group) - 1
                    self.isFinish = True
            # 把当前播放的图片 切换到下一张图片
            self.currentSprite.image = self.group[self.currentIndex].image
            # 更新记录的时间，方便计算下一张图片的播放时长
            self.timer = time.time()