python图形界面化编程GUI（八）坦克大战（四）完整代码

坦克大战（四）完整代码

import pygame
import time
import random
from pygame.sprite import Sprite
# 定义全局变量
SCREEN_WIDTH = 900 # 窗口的宽度
SCREEN_HEIGHT = 700 # 窗口的高度
BG_COLOR = pygame.Color(0, 0, 255) # 设置背景颜色
TEXT_COLOR = pygame.Color(255, 0, 0) # 设置字体颜色

class BaseItem(Sprite):
    def __init__(self, color, width, height):
        pygame.sprite.Sprite.__init__(self)


# 主类
class MainGame():
    window = None
    my_tank = None
    # 存储敌方坦克的列表
    enemyTankList = []
    # 定义敌方坦克的数量
    enemyTankCount = 5
    # 存储我方子弹的列表
    myBulletList = []
    # 存储敌方子弹的列表
    enemyBulletList = []
    # 存储爆炸对象的列表
    explodeList = []
    # 存储障碍物的列表
    walllist = []

    def __init__(self):  # 属性
        pass

    # 开始游戏
    def startGame(self): # 方法
        # 加载主窗口、初始化
        pygame.display.init()
        # 设置窗口大小以及显示窗口，用类属性进行接收
        MainGame.window = pygame.display.set_mode([SCREEN_WIDTH, SCREEN_HEIGHT])
        # 初始化我方坦克
        # self.creatMyTank()
        MainGame.my_tank = Tank(450,400)
        # 初始化敌方坦克
        self.creatEnemyTank()
        # 初始化墙壁
        self.createWall()
        # 设置窗口的标题
        pygame.display.set_caption('坦克大战')
        # 此时的窗口一闪而过，可以用死循环的方法进行窗口的显示
        while True:
            # 让移动速度慢一点，调用时间延迟
            time.sleep(0.02)
            # 给窗口添加颜色
            MainGame.window.fill(BG_COLOR)
            # 获取监听事件
            self.getEvent()
            # 获取文本的绘制，显示文本和出现的位置
            # 敌方坦克的数量用 坦克列表的长度表示
            MainGame.window.blit(self.getTextSurface('敌方坦克的数量：%s'% len(MainGame.enemyTankList)),(10,10))
            if MainGame.my_tank and MainGame.my_tank.live:
                MainGame.my_tank.displayTank()  # 显示我方坦克
            else:
                # 删除我方坦克
                del MainGame.my_tank
                MainGame.my_tank = None
            # 调用显示敌方坦克的方法
            self.showEnemyTank()
            # 调用显示子弹的方法
            self.showBullet()
            # 展示爆炸效果的方法
            self.showExplode()
            # 调用显示敌方子弹的方法
            self.showEnemyBullet()
            # 调用展示墙壁的方法
            self.showWall()
            # 根据坦克的状态进行判断，如果当前坦克移动的开关是开启的才能移动
            if MainGame.my_tank and MainGame.my_tank.live:  # 我方坦克存在且存活的状态下
                if not MainGame.my_tank.stop:
                    # 调用坦克移动的方法，实现按下移动，松开停止
                    MainGame.my_tank.move()
                    MainGame.my_tank.hitWall()
                    MainGame.my_tank.myTank_hit_enemyTank()
            # 让页面一直刷新
            pygame.display.update()

    # 创建我方坦克，在固定坐标处生成我方坦克
    def creatMyTank(self):
        MainGame.my_tank = Tank(450, 500)
        music = Music('img/start.wav')
        music.play()
    # 初始化敌方坦克方法
    def creatEnemyTank(self):
        top = 100 # 坦克出现的上方位置
        # 循环生成坦克
        for i in range(MainGame.enemyTankCount):
            left = random.randint(0, 600) # 坦克出现的左侧位置
            speed = random.randint(1, 4)  # 坦克的速度
            enemy = EnemyTank(left, top, speed)
            MainGame.enemyTankList.append(enemy) # 生成的坦克添加到列表里
    # 展示子弹的方法
    def showBullet(self):
        for myBullet in MainGame.myBulletList:
            # 增加对子弹状态的判断，是否应该消失
            if myBullet.live: # 如果子弹存活，就正常显示
                myBullet.displayBullet()
                myBullet.move()
                # 调用我方子弹碰撞敌方坦克的方法
                myBullet.myBullet_hit_enemyTank()
                myBullet.hitWall()  # 我方子弹击中墙壁
            else:
                # 否则，子弹碰到窗口边界，就从列表中删除子弹
                MainGame.myBulletList.remove(myBullet)
    # 展示敌方坦克子弹的方法
    def showEnemyBullet(self):
        for enemyBullet in MainGame.enemyBulletList:
            # 如果子弹的存活状态为真
            if enemyBullet.live:
                enemyBullet.displayBullet()
                enemyBullet.move()
                # 调用敌方子弹和我方坦克碰撞的方法
                enemyBullet.enemyBullet_hit_myTank()
                enemyBullet.hitWall()  # 敌方子弹击中墙壁
            else:
                MainGame.enemyBulletList.remove(enemyBullet)
    # 展示敌方坦克
    def showEnemyTank(self):
        for enemyTank in MainGame.enemyTankList:
            # 直接调用父类的display()
            if enemyTank.live:
                enemyTank.displayTank()
                # 坦克移动
                enemyTank.randMove()
                enemyTank.hitWall()
                # 调用和我方坦克发生碰撞的方法
                if MainGame.my_tank and MainGame.my_tank.live:
                    enemyTank.enemyTank_hit_myTank()
                # 创建并发射子弹
                enemyBullet = enemyTank.shot()
                if enemyBullet:
                    # 当子弹能创建成功的时候，再添加到列表，在shot方法里进行了生成子弹的限制
                    MainGame.enemyBulletList.append(enemyBullet)
            else:
                MainGame.enemyTankList.remove(enemyTank)
    # 显示爆炸的方法
    def showExplode(self):
        for explode in MainGame.explodeList:
            if explode.live:
                explode.displayExplode()
                music = Music('img/fire.wav')
                music.play()
            else:
                MainGame.explodeList.remove(explode)

    # 创建墙壁的方法
    def createWall(self):
        for i in range(7):
            wall = Wall(i*130, 400)
            MainGame.walllist.append(wall)

    # 展示墙壁
    def showWall(self):
        for wall in MainGame.walllist:
            if wall.live:
                wall.displayWall()
            else:  # 如果障碍物存在就显示，否则从列表中移除
                MainGame.walllist.remove(wall)
    # 结束游戏
    def endGame(self):
        print('欢迎下次再来')
        quit()

    # 获取文本
    def getTextSurface(self,text):
        # 文字初始化
        pygame.font.init()
        # 创建文字对象
        # print(pygame.font.get_default_font()) # 获取pygame里支持哪些字体
        # 使用系统字体对象，仿宋，字体大小
        font = pygame.font.SysFont('fangsong', 18)
        # 使用render方法把字体渲染到窗口上
        testSurface = font.render(text, True, TEXT_COLOR) # 有返回值，返回到文本的表面
        return testSurface   # 文字显示在纸上，把纸返回到窗口上
    # 获取事件
    def getEvent(self):
        # 获取所有的事件
        eventList = pygame.event.get() # 获取的是事件列表，并不是唯一的事件，比如上下左右
        # 遍历出每一个事件
        for event in eventList:
            # 判断按下的是关闭键还是键盘
            if event.type == pygame.QUIT:
                self.endGame()  # 执行退出操作
            # 判断方向键，如果按下的类型是键盘
            elif event.type == pygame.KEYDOWN:
                # 如果没有坦克，如果按下的是ESC键，就调用创建坦克的命令
                if not MainGame.my_tank:
                    if event.key == pygame.K_ESCAPE:
                        self.creatMyTank()
                if MainGame.my_tank and MainGame.my_tank.live:
                    # 左
                    if event.key == pygame.K_LEFT:
                        # 切换方向
                        MainGame.my_tank.direction = 'L'
                        # 更改移动开关
                        MainGame.my_tank.stop = False # 按下按键的时候，解除停止的状态
                        # MainGame.my_tank.move()  # 实现坦克按下移动，松开停止，要把单个方向的移动禁用掉
                        print('按下左键，向左移动')
                    # 右
                    elif event.key == pygame.K_RIGHT:
                        MainGame.my_tank.direction = 'R'
                        # 更改移动开关
                        MainGame.my_tank.stop = False  # 按下按键的时候，解除停止的状态
                        # MainGame.my_tank.move()
                        print('按下右键，向右移动')
                    # 上
                    elif event.key == pygame.K_UP:
                        MainGame.my_tank.direction = 'U'
                        # 更改移动开关
                        MainGame.my_tank.stop = False  # 按下按键的时候，解除停止的状态
                        # MainGame.my_tank.move()
                        print('按下上键，向上移动')
                    # 下
                    elif event.key == pygame.K_DOWN:
                        MainGame.my_tank.direction = 'D'
                        # 更改移动开关
                        MainGame.my_tank.stop = False  # 按下按键的时候，解除停止的状态
                        # MainGame.my_tank.move()
                        print('按下下键，向下移动')
                    # 用空格发射子弹，此时发射子弹和坦克移动是冲突的，松开空格相当于松开键盘，坦克就停止了，不能实现边走边发射子弹
                    # 如果实现边移动边发射子弹的逻辑，就要把松开方向键进行判断
                    elif event.key == pygame.K_SPACE:
                        print('发射子弹')
                        # 如果当前子弹列表长度不大于3，才进行子弹的创建
                        if len(MainGame.myBulletList) < 3:
                            # 我方坦克发射子弹
                            myBullet = Bullet(MainGame.my_tank)
                            MainGame.myBulletList.append(myBullet)
                            music = Music('img/hit.wav')
                            music.play()
            # 松开按键，坦克停止移动，修改坦克的移动开关状态
            elif event.type == pygame.KEYUP:  # 此时不能实现边移动边发射子弹，需要再进行判断
                # 判断如果松开的是上下左右键，才停止移动，这是跟发射子弹就不冲突了
                if event.key == pygame.K_UP or event.key == pygame.K_DOWN or event.key == pygame.K_LEFT or event.key == pygame.K_RIGHT:
                    if MainGame.my_tank and MainGame.my_tank.live:
                        MainGame.my_tank.stop = True

# 坦克类
class Tank(BaseItem):
    def __init__(self, left, top):
        # 保存加载的图片,返回值是surface，也相当于一张纸，要放到创建窗口上，需要变量接收
        self.images = {
            'U': pygame.image.load('img/p1tankU.gif'),
            'D': pygame.image.load('img/p1tankD.gif'),
            'R': pygame.image.load('img/p1tankR.gif'),
            'L': pygame.image.load('img/p1tankL.gif'),
        }
        # 默认坦克的方向
        self.direction = 'U'
        # 根据当前图片的方向来获取图片
        self.image = self.images[self.direction]  # 坦克方向向上
        # 根据图像获取区域
        self.rect = self.image.get_rect()

        # 设置图像区域距窗口左边(left)和上边(top)的的距离,矩形框
        self.rect.left = left
        self.rect.top = top
        # 设置坦克的移动速度
        self.speed = 10  # 值越小移动的越慢

        # 坦克移动的开关，按下移动，松开停止
        self.stop = True  # 默认坦克是不动的状态
        # 添加坦克是否存在的属性
        self.live = True  # 默认坦克是存在的
        # 添加两个之前的额位置坐标的属性
        self.oldleft = self.rect.left
        self.oldtop = self.rect.top

    # 移动
    def move(self):
        # 移动后记录原始的坐标
        self.oldleft = self.rect.left
        self.oldtop = self.rect.top
        # 判断坦克方向进行移动
        if self.direction == 'L':
            if self.rect.left > 0: # 不能超出左边界
                self.rect.left -= self.speed
        elif self.direction == 'R':
            # 向右移动的时候，坦克转向右，此时的右边距应是用坦克移动的距离加上坦克的高度
            if self.rect.left + self.rect.height < SCREEN_WIDTH:
                self.rect.left += self.speed
        elif self.direction == 'U':
            if self.rect.top > 0:
                self.rect.top -= self.speed
        elif self.direction == 'D':
            # 同样向下移动的时候，坦克方向向下，下边距应是坦克移动的距离加上坦克的高度
            if self.rect.top + self.rect.height < SCREEN_HEIGHT:
                self.rect.top += self.speed

    # 射击
    def shot(self):# 需要对射击的方法进行限制，不然坦克会一直发射子弹
        # 用随机数控制敌方坦克偶尔发射子弹
        num = random.randint(1,100)
        if num < 10:
            return Bullet(self)

    def stay(self):
        self.rect.left = self.oldleft
        self.rect.top = self.oldtop

    def hitWall(self):
        for wall in MainGame.walllist:
            if pygame.sprite.collide_rect(self, wall):
                # 将坐标设置为移动之前的坐标,即为坦克出现的地方
                self.stay()

    # 显示坦克
    def displayTank(self):
        # 重新获取坦克的方向信息，切换了图片
        self.image = self.images[self.direction]
        # 调用blit方法显示图像
        MainGame.window.blit(self.image, self.rect)
    def myTank_hit_enemyTank(self):
        for enemyTank in MainGame.enemyTankList:
            if pygame.sprite.collide_rect(self, enemyTank):
                self.stay()
# 我方坦克
class MyTank(Tank):  # 继承自坦克类
    def __init__(self, left, top):
        super().__init__(left, top)



# 敌方坦克
class EnemyTank(Tank):
    def __init__(self, left, top, speed):
        # 调用父类的方法
        super().__init__(left, top)
        # 保存加载的图片,返回值是surface，也相当于一张纸，要放到创建窗口上，需要变量接收
        self.images = {
            'U': pygame.image.load('img/enemy1U.gif'),
            'D': pygame.image.load('img/enemy1D.gif'),
            'R': pygame.image.load('img/enemy1R.gif'),
            'L': pygame.image.load('img/enemy1L.gif'),
        }
        # 坦克的方向为随机生成
        self.direction = self.randDirection()
        # 根据当前图片的方向来获取图片
        self.image = self.images[self.direction]  # 坦克方向向上
        # 根据图像获取区域
        self.rect = self.image.get_rect()

        # 设置图像区域距窗口左边(left)和上边(top)的的距离,矩形框
        self.rect.left = left
        self.rect.top = top
        # 设置坦克的移动速度
        self.speed = speed  # 每种类型的坦克速度不一样

        # 坦克移动的开关，按下移动，松开停止
        self.stop = True  # 默认坦克是不动的状态
        # 步数变量
        self.step = 20

    # 坦克的随机移动
    def randMove(self):
        if self.step <= 0:
            # 修改方向
            self.direction = self.randDirection()
            # 恢复步数
            self.step = 20
        else:
            self.move()
            # 移动一次，步数减少1
            self.step -= 1
    # 生成敌方坦克出现时的随机方向
    def randDirection(self):
        num = random.randint(1,4)
        if num == 1:
            return 'U'
        elif num == 2:
            return 'D'
        elif num == 3:
            return 'L'
        elif num == 4:
            return 'R'

    def enemyTank_hit_myTank(self):
        if pygame.sprite.collide_rect(self, MainGame.my_tank):
            self.stay()
# 子弹类
class Bullet(BaseItem):
    def __init__(self, tank):
        self.image = pygame.image.load('img/enemymissile.gif')
        # 子弹的方向，要跟随坦克的炮嘴方向，跟坦克的方向是一致的
        self.direction = tank.direction
        # 获取子弹区域，也就是子弹图片的大小
        self.rect = self.image.get_rect()
        if self.direction == 'U':
            self.rect.left = tank.rect.left + tank.rect.width / 2 - self.rect.width / 2
            self.rect.top = tank.rect.top - self.rect.height
        elif self.direction == 'D':
            self.rect.left = tank.rect.left + tank.rect.width / 2 - self.rect.width / 2
            self.rect.top = tank.rect.top + tank.rect.height
        elif self.direction == 'L':
            self.rect.left = tank.rect.left - self.rect.height
            self.rect.top = tank.rect.top + tank.rect.width / 2 - self.rect.width / 2
        elif self.direction == 'R':
            self.rect.left = tank.rect.left + tank.rect.height
            self.rect.top = tank.rect.top + tank.rect.width / 2 - self.rect.width / 2

        # 子弹的速度
        self.speed = 6
        # 子弹的状态，是否碰到窗口边界，碰到了就修改状态
        self.live = True

    # 移动
    def move(self):
        if self.direction == 'U':
            if self.rect.top > 0:
                self.rect.top -= self.speed
            else:
                # 修改子弹的状态值
                self.live = False
        elif self.direction == 'D':
            if self.rect.top < SCREEN_HEIGHT - self.rect.height:
                self.rect.top += self.speed
            else:
                # 修改子弹的状态值
                self.live = False
        elif self.direction == 'L':
            if self.rect.left > 0:
                self.rect.left -= self.speed
            else:
                # 修改子弹的状态值
                self.live = False
        elif self.direction == 'R':
            if self.rect.left < SCREEN_WIDTH - self.rect.width:
                self.rect.left += self.speed
            else:
                # 修改子弹的状态值
                self.live = False

    # 显示子弹
    def displayBullet(self):
        MainGame.window.blit(self.image, self.rect)

    # 我方子弹碰撞敌方坦克
    def myBullet_hit_enemyTank(self):
        for enemyTank in MainGame.enemyTankList:
            # 两个精灵之间的距离检测，返回布尔值
            if pygame.sprite.collide_rect(self, enemyTank):
                enemyTank.live = False
                self.live = False
                explode = Explode(enemyTank)
                # 将爆炸对象添加到爆炸列表中
                MainGame.explodeList.append(explode)

    # 敌方子弹碰撞我方坦克
    def enemyBullet_hit_myTank(self):
        if MainGame.my_tank and MainGame.my_tank.live:
            if pygame.sprite.collide_rect(MainGame.my_tank,self):
                explode = Explode(MainGame.my_tank)
                MainGame.explodeList.append(explode)
                # 修改我方坦克和敌方子弹的状态
                self.live = False
                MainGame.my_tank.live = False
    # 障碍物被射击三次，则消失
    def hitWall(self):
        for wall in MainGame.walllist:
            if pygame.sprite.collide_rect(self, wall):
                self.live = False
                wall.hp -= 1
                if wall.hp <= 0:
                    wall.live = False
# 障碍物类
class Wall():
    def __init__(self, left, top):
        # 获取图片
        self.image = pygame.image.load('img/steels.gif')
        # 墙的尺寸从图片中获取
        self.rect = self.image.get_rect()
        self.rect.left = left
        self.rect.top = top
        # 墙壁存在的属性
        self.live = True
        # 墙壁的韧性，可以打几下才消失
        self.hp = 3

    # 显示障碍物
    def displayWall(self):
        MainGame.window.blit(self.image, self.rect)

# 爆炸类
class Explode():
    def __init__(self, tank):
        # 爆炸位置由当前子弹打中的坦克决定
        self.rect = tank.rect
        # 获取爆炸效果的图片
        self.images = [
            pygame.image.load('img/blast0.gif'),
            pygame.image.load('img/blast1.gif'),
            pygame.image.load('img/blast2.gif'),
            pygame.image.load('img/blast3.gif'),
            pygame.image.load('img/blast4.gif'),
        ]
        self.step = 0
        self.image = self.images[self.step]
        self.live = True

    # 显示爆炸效果
    def displayExplode(self):
        if self.step < len(self.images):
            # 根据索引获取爆炸的图片
            self.image = self.images[self.step]
            self.step += 1
            # 爆炸效果添加到主窗口上
            MainGame.window.blit(self.image, self.rect)
        else:
            self.live = False
            self.step = 0

# 音效类
class Music():
    def __init__(self, filename):
        self.filename = filename
        pygame.mixer.init()
        # 加载音乐
        pygame.mixer.music.load(filename)
    # 播放音乐
    def play(self):
        pygame.mixer.music.play()

if __name__ == '__main__':
    MainGame().startGame()
    # MainGame().getTextSurface()