python实现坦克大战游戏

import pygame
import time
import random
from pygame.sprite import Sprite

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 500
BG_COLOR = pygame.Color(255, 255, 255)

#BG_COLOR=pygame.Color(0,0,0)

TEXT_COLOR = pygame.Color(255, 0, 0)

#基类，继承Sprite类 让坦克类和子弹类都继承基类

class BaseItem(Sprite):
def init(self, color, width, height):
# Call the parent class (Sprite) constructor
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()   # 初始化窗口
    # 设置窗口的大小及显示 set_mode返回一个Surface对象
    MainGame.window = pygame.display.set_mode([SCREEN_WIDTH, SCREEN_HEIGHT])
    # 初始化我方坦克
    self.createMytank()
    # 初始化敌方坦克，并将敌方坦克添加到列表中
    self.createEnemyTank()
    # 初始化墙壁
    self.createWall()
    # 设置窗口标题
    pygame.display.set_caption('坦克大战1.03')
    while True:
        # 使坦克的移动速度慢一点
        time.sleep(0.02)
        # 给窗口设置填充色 MainGame.window为一个Surface对象
        MainGame.window.fill(BG_COLOR)
        # 获取事件
        self.getEvent()
        # 绘制文字:在主窗口绘制Surface：blit    (10, 10):位置
        MainGame.window.blit(self.getTextSurface('敌方坦克剩余数量:%d'%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.blitEnemyTank()
        # 循环遍历显示我方坦克的子弹
        self.blitBullet()
        # 循环遍历敌方子弹列表，展示敌方子弹
        self.blitEnemyBullet()
        # 循环遍历爆炸列表，展示爆炸效果
        self.blitExplode()
        # 循环遍历墙壁列表，展示墙壁
        self.blitWall()
        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 blitWall(self):
    for wall in MainGame.wallList:
        # 判断墙壁是否存活
        if wall.live:
            # 调用墙壁的显示方法
            wall.displayWall()
        else:
            # 从墙壁列表移除
            MainGame.wallList.remove(wall)

# 创建初始化墙壁的方法
def createWall(self):
    for i in range(6):  # 添加6个墙壁
        # 初始化墙壁
        wall = Wall(i*130, 220)   # (left, top)
        # 将墙壁添加到列表中
        MainGame.wallList.append(wall)

# 创建我方坦克的方法
def createMytank(self):
    MainGame.my_tank = MyTank(350, 300)  # 位置
    # 创建Music对象
    music = Music('img/start.wav')
    #摆放音乐
    music.play()

# 初始化敌方坦克，并将敌方坦克添加到列表中
def createEnemyTank(self):
    top = 100  # 同一高度
    # 循环生成敌方坦克
    for i in range(MainGame.enemyTankCount):
        left = random.randint(0, SCREEN_WIDTH - 100)
        speed = random.randint(1, 4)
        enemy = EnemyTank(left, top, speed)
        MainGame.enemyTankList.append(enemy)

# 循环展示爆炸效果
def blitExplode(self):
    for explode in MainGame.explodeList:
        # 判断爆炸效果是否活着
        if explode.live:
            explode.displayExplode()
        else:
            # 将爆炸效果从列表中移除
            MainGame.explodeList.remove(explode)

# 循环遍历敌方坦克列表，展示敌方坦克
def blitEnemyTank(self):
    for enemyTank in MainGame.enemyTankList:
        # 判断当前敌方坦克是否活着
        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()   # 调用子类的shot()方法
            # 因为敌方子弹enemyBullet的num<10时才让它返回，所以存在为None的情况
            # 判断敌方子弹是否为None，如果不为None则添加到敌方子弹列表中
            if enemyBullet:
                # 将敌方子弹存储到敌方子弹列表中
                MainGame.enemyBulletList.append(enemyBullet)
        else:  # 敌方坦克不活着，从敌方坦克列表中移除
            MainGame.enemyTankList.remove(enemyTank)

# 循环遍历我方子弹存储列表
def blitBullet(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 blitEnemyBullet(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 endGame(self):
    print('谢谢使用，欢迎再次使用')
    exit()

# 左上角文字的绘制
def getTextSurface(self, text):
    # 初始化字体模块
    pygame.font.init()
    # 查看所有的字体名称
    # print(pygame.font.get_fonts())
    # 获取字体Font对象(字体， 大小)
    font = pygame.font.SysFont('kaiti', 18)
    # 绘制文字信息(渲染)  render（文本，抗锯齿，颜色，背景=无）
    textSurface = font.render(text, True, TEXT_COLOR)
    return textSurface


# 获取事件
def getEvent(self):
    # 获取所有事件
    eventList = pygame.event.get()
    # 遍历事件
    for event in eventList:
        # 判断按下的键是关闭还是键盘按下
        if event.type == pygame.QUIT:  # 如果按下的是退出，关闭窗口
            self.endGame()
        # 如果是键盘的按下
        if event.type == pygame.KEYDOWN:
            # 当我方坦克不存在或死亡
            if not MainGame.my_tank:
                # 判断按下的是Esc键，让坦克重生
                if event.key == pygame.K_ESCAPE:
                    # 让我方坦克重生即调用创建坦克的方法
                    self.createMytank()
            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()

        # 松开方向键，坦克停止移动，修改坦克的开关状态
        if 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):
# 添加距离左边left，距离上边top
def init(self, left, top):
# 保存加载的图片
self.images = {‘U’: pygame.image.load(‘img/p1tankU.gif’),
‘R’: pygame.image.load(‘img/p1tankR.gif’),
‘L’: pygame.image.load(‘img/p1tankL.gif’),
‘D’: pygame.image.load(‘img/p1tankD.gif’)
}
# 方向默认向上
self.direction = ‘U’
# 根据当前图片的方向获取图片surface
self.image = self.images[self.direction]
# 根据图片获取矩形区域
self.rect = self.image.get_rect()
# 默认位于左上角，设置区域的left和top
self.rect.left = left
self.rect.top = top
# 速度：决定坦克移动的快慢
self.speed = 5

    # 坦克移动的开关,默认关闭
    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):
    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)

class MyTank(Tank):
def init(self, left, top):
super(MyTank, self).init(left, top) # 调用父类的初始化方法

# 检测我方坦克与敌方坦克发生碰撞
def myTank_hit_enemyTank(self):
    # 循环遍历敌方坦克列表
    for enemyTank in MainGame.enemyTankList:
        if pygame.sprite.collide_rect(self, enemyTank):  # (我方坦克，敌方坦克)
            self.stay()       # 让我方坦克不能移动

class EnemyTank(Tank):
def init(self, left, top, speed):
# 调用父类的初始化方法
super(EnemyTank, self).init(left, top)
# 加载图片集
self.images = {
‘U’: pygame.image.load(‘img/enemy1U.gif’),
‘D’: pygame.image.load(‘img/enemy1D.gif’),
‘L’: pygame.image.load(‘img/enemy1L.gif’),
‘R’: pygame.image.load(‘img/enemy1R.gif’)
}
# 方向，随机生成敌方坦克的方向
self.direction = self.randDirection()
# 根据方向获取图片 方向为字典的Key
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.flag = True

    # 新增一个步数变量step
    self.step = 60

# 敌方坦克与我方坦克是否发生碰撞
def enemyTank_hit_myTank(self):
    if pygame.sprite.collide_rect(self, MainGame.my_tank):  # (敌方坦克，我方坦克)
        self.stay()     # 让敌方坦克不能移动

# 随机生成敌方坦克的方向
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 randMove(self):
    if self.step <= 0:
        # 修改方向
        self.direction = self.randDirection()
        # 修改方向后，让步数复位，才能移动
        self.step = 60
    else:
        self.move()
        # 步数递减
        self.step -= 1

# 重写父类的shot()方法
def shot(self):
    # 随机生成100以内的数
    num = random.randint(1, 100)
    if num < 10:
        return Bullet(self)     # 创建子弹

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()
# 子弹的left和top与方向有关
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.width / 2 - self.rect.width / 2
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.width
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 == 'R':
        if self.rect.left + self.rect.width < SCREEN_WIDTH:
            self.rect.left += self.speed
        else:
            # 修改子弹的状态
            self.live = False
    elif self.direction == 'D':
        if self.rect.top + self.rect.height < SCREEN_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

# 子弹是否碰撞墙壁
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

def displayBullet(self):
    # 将图片surface加载到窗口:blit(目标，区域)
    MainGame.window.blit(self.image, self.rect)

# 我方子弹与敌方坦克的碰撞
def myBullet_hit_enemyTank(self):
    # 循环遍历敌方坦克列表，判断是否发生碰撞
    for enemyTank in MainGame.enemyTankList:
        # 检测两个精灵之间的碰撞collide_rect（左，右）->布尔
        if pygame.sprite.collide_rect(enemyTank, self):   # (敌方坦克，我方子弹)
            # 发生碰撞，修改我方子弹和敌方坦克的状态
            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)
            # 修改我方坦克和敌方子弹的状态
            MainGame.my_tank.live = False
            self.live = False

class Wall():
def init(self, left, top):
# 加载墙壁图片
self.image = pygame.image.load(‘img/steels.gif’)
# 获取墙壁的区域
self.rect = self.image.get_rect()
# 设置位置left、top
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): # filename:音乐的名字
# 音乐的名字
self.filename = filename
# 初始化音乐混合器
pygame.mixer.init()
# 加载音乐
pygame.mixer.music.load(self.filename)

def play(self):
    pygame.mixer.music.play()

if name == ‘main’:
MainGame().startGame()