Python坦克大战

# Python 坦克大战

> 还有C语言版坦克大战, 感兴趣的可以关注: [坦克大战-C语言-详注版](http://www.demodashi.com/demo/14259.html)

## 准备工作

### pygame安装

```bash
pip install pygame -i https://mirrors.ustc.edu.cn/pypi/web/simple
```

> 需要管理员权限, 利用 ***-i*** 为pip指令镜像源, 这里使用电子科技大学的源, 速度比官方源更快.

### numpy安装

```bash
pip install numpy -i https://mirrors.ustc.edu.cn/pypi/web/simple
```

> 需要管理员权限

## 视频欣赏

[Python Tank 坦克大战](https://v.youku.com/v_show/id_XNDg4NTAyMDEwMA==.html)
![tank_move_ok.gif](https://raw.githubusercontent.com/WHJWNAVY/myImage/master/py_tank.assets/tank_move_ok.gif)

## 操作说明

| 按键  |       功能        |
| :---: | :---------------: |
|  UP   |     向上移动      |
| DOWN  |     向下移动      |
| LEFT  |     向左移动      |
| RIGHT |     向右移动      |
| 回车  |       开火        |
| 空格  |     暂停/继续     |
|  F1   |       加速        |
|  F2   |       减速        |
|  F3   | 开启/关闭无敌模式 |
|  F5   |     增援我军      |
|  ESC  |     退出游戏      |

## 游戏说明

本教程使用python实现了一个简易的坦克大战游戏,为了让更多人能体会到python给我们带来的方便和乐趣,本教程源代码包含了详细的注释,同时也采用了更简单和易于理解的方式来实现坦克大战游戏.

* 游戏开始时,会生成 五个 ***位置随机的敌军坦克*** (蓝色),一个 ***位置随机的我军坦克*** (红色).
* 游戏运行过程中,可以通过 ***方向键*** 控制我军坦克移动,通过***回车键***开火击毁敌军坦克,通过***F5键***增援我军坦克

* 敌军坦克被击毁后会自动增援,我军每击毁10辆敌军坦克,敌军就会多增援一辆坦克.
* 游戏过程中会在地图上随机出现装备,包括生命(***绿色菱形***)和武器(***紫色三角形***),吃掉生命可以增加生命值,吃掉武器可以发射超级炮(每次发射三枚炮弹).

## 源码详解

本游戏的源码共分为三个模块: ***game模块*** , ***window模块*** , ***tank模块***.

### game模块

game模块是游戏的入口,在本模块中,`game_init`用于系统初始化, `game_run`负责坦克大战运行, `game_event`负责游戏过程中的按键和事件处理.

```python
import window
import tank
import time
import sys
import os

game_stop = False

GAME_SOUND_START = "start.wav"
GAME_SOUND_BG = "base.wav"

'''
游戏初始化
'''

def game_init():
    (width, height) = (60, 40)
    _window = window.GameWindow(
        gw_tittle="Tank", gw_width=width, gw_height=height, pnt_border=True, bg_line=True)
    _tank = tank.Tank(width=width, height=height, debug=False)
    return _tank, _window

'''
坦克大战运行线程
'''

def game_run(_tank, _window):

_tank.run(_window)
    _tank.show(_window)

'''
坦克大战事件线程
'''

def game_event(_tank, _window):
    global game_stop

event = _window.event()
    if event != _window.EVENT_NONE:
        if event == _window.EVENT_QUIT:  # ESC退出
            _window.quit()
        elif event == _window.EVENT_KUP:   # 方向键控坦克移动
            _tank.t_dir = tank.DIR_UP
        elif event == _window.EVENT_KDOWN:
            _tank.t_dir = tank.DIR_DOWN
        elif event == _window.EVENT_KLEFT:
            _tank.t_dir = tank.DIR_LEFT
        elif event == _window.EVENT_KRIGHT:
            _tank.t_dir = tank.DIR_RIGHT
        elif event == _window.EVENT_OK:  # 回车开火
            _tank.t_fire = True
        elif event == _window.EVENT_STOP:  # 空格键暂停和继续
            if game_stop == False:
                game_stop = True
            else:
                game_stop = False
        elif event == _window.EVENT_ADD:  # F1速度加
            _tank.t_speed += 1
        elif event == _window.EVENT_SUB:  # F2速度减
            _tank.t_speed -= 1
        elif event == _window.EVENT_KING:  # F3无敌模式
            if _tank.t_king == True:
                _tank.t_king = False
            else:
                _tank.t_king = True
        elif event == _window.EVENT_HELP:  # F5增援我军
            _tank.tank_reinforce()

if __name__ == "__main__":
    _tank, _window = game_init()

_window.sound_play(GAME_SOUND_START)

while True:
        _window.sound_bg_play(GAME_SOUND_BG)
        game_event(_tank, _window)
        if game_stop != True:
            game_run(_tank, _window)

```

### window模块

本模块用于实现游戏界面的绘制和窗口事件的检测.
本模块提供了 ***clear(清屏)*** , ***update(刷新)*** , ***rect(画矩形)*** , ***circle(画圆)*** , ***event(事件检测)*** 等接口.
本模块的功能主要使用***pygame***模块实现,是对pygame的进一步封装.

#### **clear**

用指定颜色填充背景,并且绘制游戏地图方格,游戏地图是一个由横向40个方格,纵向20个方格组成的方阵
```python
'''
用背景色填充屏幕(清屏)
'''
def clear(self):
    color = self._color_sub(self.COLOR_WHITE, self.gw_bgcol)
    self._game_window.fill(self.gw_bgcol)
    for x in range(self.maxx()+1):
        pygame.draw.line(self._game_window, color, (x*self.pnt_size, 0), (x*self.pnt_size, self.gw_height), 1)
    for y in range(self.maxy()+1):
        pygame.draw.line(self._game_window, color, (0, y * self.pnt_size), (self.gw_width, y*self.pnt_size), 1)
```
#### **update**
pygame的update,刷新屏幕
```python
'''
刷新屏幕
'''
def update(self):
    pygame.display.update()
```

#### **rect**
往地图上的指定位置的小方格中画一个矩形,这里使用的坐标不是屏幕坐标,而是小方格在地图中的坐标( *_rect是对pygame的draw.rect的封装,使用的是屏幕坐标* )
```python
'''
在屏幕指定位置画一个正方形(相对坐标)

Parameters
:param x: 正方形左上角的x坐标
:param y: 正方形左上角的y坐标
:param color: 圆形填充颜色
'''
def rect(self, x, y, *color):
    pntcol = self.pnt_col
    if len(color) != 0:
        pntcol = color[0]
    if x < 0 or x > self.maxx() or y < 0 or y > self.maxy():
        return
    self._rect(x*self.pnt_size, y*self.pnt_size, pntcol)
```

#### **circle**
往地图上的指定位置的小方格中画一个圆形,这里使用的坐标不是屏幕坐标,而是小方格在地图中的坐标( *_circle是对pygame的draw.circle的封装,使用的是屏幕坐标* )
```python
'''
在屏幕指定位置画一个圆形(相对坐标)

Parameters
:param x: 圆形外接正方形左上角的x坐标
:param y: 圆形外接正方形左上角的y坐标
:param color: 圆形填充颜色
'''
def circle(self, x, y, *color):
    pntcol = self.pnt_col
    if len(color) != 0:
        pntcol = color[0]
    if x < 0 or x > self.maxx() or y < 0 or y > self.maxy():
        return
    x = x*self.pnt_size
    y = y*self.pnt_size
    self._circle(x, y, x+self.pnt_size, y+self.pnt_size, pntcol)
```
#### **event**
检按键按下的事件,是对pygame的event的封装,把按键按下的状态封装成事件
```python
'''
屏幕事件
'''
def event(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            return self.EVENT_QUIT
        elif event.type == pygame.KEYDOWN:  # KEYUP:
            if event.key == pygame.K_LEFT or event.key == pygame.K_a:
                return self.EVENT_KLEFT
            elif event.key == pygame.K_RIGHT or event.key == pygame.K_d:
                return self.EVENT_KRIGHT
            elif event.key == pygame.K_UP or event.key == pygame.K_w:
                return self.EVENT_KUP
            elif event.key == pygame.K_DOWN or event.key == pygame.K_s:
                return self.EVENT_KDOWN
            elif event.key == pygame.K_SPACE:
                return self.EVENT_STOP
            elif event.key == pygame.K_F1:
                return self.EVENT_ADD
            elif event.key == pygame.K_F2:
                return self.EVENT_SUB
            elif event.key == pygame.K_ESCAPE:
                return self.EVENT_QUIT
            elif event.key == pygame.K_F3:
                return self.EVENT_KING
    return self.EVENT_NONE
```

### tank模块

tanke模块是整个坦克大战游戏的核心模块,该模块中实现了坦克大战的所有逻辑.

tanke模块的实现分三步走, 循序渐进, 从易到难, 首先***把坦克画出来***,然后***让坦克动起来***, 接着***让坦克开战*** ,最后就是完善逻辑, 添加音乐, 等细节上的处理.

##### 坦克地图

首先我们需要一张地图, 所有的场景, 坦克, 武器装备都表现在这张地图上.我们可以把地图看成一个40x20的格子, 通过window模块中的API可以在地图上画出各种小方块, 每种小方块可以代表不同的物体,如下图:

![image-20200924093916253](http://www.demodashi.com/contentImages/image/20201015/bB1fOLymQ7FMyn8Esnn.png)

这里我们用一个二维数组***self.tank_map***表示地图, 即形状为***[40,20]***的list, ***self.tank_map***中的每一个元素代表地图上的一个小格子:

```python
self.tank_map = np.zeros((self.t_height, self.t_width), dtype=int)  # pr list
```

对于地图来说,它不关心地图上显示的到底是什么, 它只需要按照要求显示不同颜色和形状的小格子就可以了, ***show***函数就负责把地图绘制到屏幕上

```python
'''
把地图绘制到屏幕上
'''

def show(self, pen):
    pen.clear()
    self.map_clear()
    self.tank_update()
    self.bomb_update()
    self.equip_update()
    (yy, xx) = self.tank_map.shape
    # self.tank_debug("self.tank_map={0}".format(self.tank_map))
    for y in range(yy):
        for x in range(xx):
            pr = self.tank_map[y][x]
            # self.tank_debug("pr[{0}][{1}] = {2}".format(y, x, pr))
            self.point_draw(pen, x, y, pr)
    pen.update()

def point_draw(self, pen, x, y, pr):
    if pr == PR_BOMB:  # 炮弹，黄色圆形
        pen.circle(x, y, pen.COLOR_YELLOW)
    if pr == PR_WEAPON:  # 武器，紫色三角形
        pen.triangle(x, y, pen.COLOR_PURPLE)
    if pr == PR_LIFE:  # 装备，绿色菱形
        pen.rhombus(x, y, pen.COLOR_GREEN)
    if pr == PR_SELF:  # 我军，红色矩形
        pen.rect(x, y, pen.COLOR_RED)
    if pr == PR_ENMY:  # 敌军，蓝色矩形
        pen.rect(x, y, pen.COLOR_BLUE)
    if pr == PR_TBOMB:  # 被击毁的坦克，黄色矩形
        pen.rect(x, y, pen.COLOR_YELLOW)
    if pr == PR_WALL:  # 墙，深灰色矩形
        pen.rect(x, y, pen.COLOR_DARKGRAY)
    else:
        pass
        # pen.rect(x, y, pen.COLOR_NULL)
```

对于坦克,一辆坦克由6个小格子组成(见下图), 这里我们用6个红色的正方形小格子组成一辆坦克, 绘制坦克的时候, 只需要改变地图上对应的位置的6个小格子的颜色和形状就可以了.炮弹和装备也是同样的道理.

##### 坦克类

对于坦克, 炸弹,装备等不同的物体, 他们都有自己的各种属性,这里我们为他们创建三个类, 用来表示一个真实的坦克, 炸弹, 装备.

```python
class TankBody(object):
    def __init__(self, dir=0, x=0, y=0, pr=PR_ENMY, fires=TANK_FIRE_TIMER, steps=TANK_STEPS_TIMER):
        self.name = _random_uuid()  # ID
        self.x = x  # 坐标
        self.y = y  # 坐标
        self.dir = dir  # 方向, 随机
        self.pr = pr  # 属性
        self.life = LF_LIVE  # 生命
        self.wep = WP_NORMAL  # 武器
        self.kills = 0  # 击杀敌军数量
        self.bombs = 0  # 弹药消耗
        self.steps = 0  # 剩余移动步数
        self.fires = 0  # 开火倒计时

if pr == PR_SELF:
            self.steps = 0
            self.fires = 0
        elif pr == PR_ENMY:
            self.steps = random.randint(0, steps)
            self.fires = random.randint(0, fires)

class BombBody(object):
    def __init__(self, dir=0, x=0, y=0, pr=PR_ENMY, name=None):
        self.id = _random_uuid()
        self.name = name  # ID
        self.x = x  # 坐标
        self.y = y  # 坐标
        self.dir = dir  # 方向
        self.pr = pr  # 属性

class EquipBody(object):
    def __init__(self, x=0, y=0, pr=PR_WEAPON, timer=TANK_EQUIP_TIMER_MAX):
        self.id = _random_uuid()
        self.x = x  # 坐标
        self.y = y  # 坐标
        self.timer = timer  # 存活时间
        self.pr = pr  # 装备类型
```

另外, 我们还需要三个list, ***self.tank_list = []***, ***self.bomb_list = []***和***self.equip_list = []***, 用来保存所有的坦克和炮弹.

#### 把坦克画出来

##### 坦克模板

![坦克模板](http://www.demodashi.com/contentImages/image/20201015/iVJQyRNigDoicZ4Xqh4.png)

如上图所示,每个坦克由***6个小方块***组成,把这6个小方块按顺序标号.每个坦克有上下左右四个方向.

为了简化程序操作,把这四个方向的坦克放在一个(二维)数组 ***TANK_SHAPE_BOX*** 中,表示共有4种形状的坦克(4个方向),每种坦克由6个小方块. 数组的每个元素保存的是这6个小方块的相对坐标.坦克的每个方块的实际坐标可以通过坦克左上角的坐标与这6个相对坐标计算得到.如下图

```python
POINT_T = np.dtype([('x', np.int), ('y', np.int), ('pr', np.int)])

TANK_SHAPE_BOX = np.array([
    [(1, 0, 0), (0, 1, 0), (2, 1, 0), (1, 1, 0), (0, 2, 0), (2, 2, 0)],  # 上
    [(2, 1, 0), (1, 0, 0), (1, 2, 0), (1, 1, 0), (0, 0, 0), (0, 2, 0)],  # 右
    [(1, 2, 0), (2, 1, 0), (0, 1, 0), (1, 1, 0), (2, 0, 0), (0, 0, 0)],  # 下
    [(0, 1, 0), (1, 2, 0), (1, 0, 0), (1, 1, 0), (2, 2, 0), (2, 0, 0)]  # 左
], dtype=POINT_T)
```

***TANK_SHAPE_BOX***就是制造坦克的模板, 只需要知道坦克的坐标和方向, 套上***TANK_SHAPE_BOX***模板, 就可以在地图上画出一辆真正的坦克.如下:

> gen_tank_box

```python
'''
根据坦克坐标和坦克模板计算坦克的6个小个子的坐标
'''

def gen_tank_box(self, dir, x, y, pr):
    if dir < 0 or dir >= len(DIR_BOX):
        return None
    if self.is_over_border(x, y):
        return None

# 复制坦克模板
    tbox = self.TANK_SHAPE_BOX[dir].copy()  # 复制, 而不是引用!!!

# 根据坦克坐标计算坦克6个小格子的坐标
    for b in tbox:
        b['x'] += x
        b['y'] += y
        b['pr'] = pr
        if self.is_over_border(b['x'], b['y']):
            return None
        return tbox
```

##### tank create, draw, update

通过***tank_create***, ***tank_draw***, ***tank_update***函数可以生成一辆真正的坦克, 并把这辆坦克显示到地图上.

> tank_create

```python
'''
生成一个方向和坐标都随机的并且在地图上不被遮挡的坦克
'''

def tank_create(self, pr):
    x_arr = list(range(self.t_width))
    y_arr = list(range(self.t_height))
    dir_box = list(range(len(DIR_BOX)))

while len(dir_box) > 0:
        dir = random.choice(dir_box)  # 随机选择一个方向
        dir_box.remove(dir)  # 移除已经使用过的方向
        while len(y_arr) > 0:
            yy = random.choice(y_arr)  # 随机选择一个y坐标
            y_arr.remove(yy)  # 移除已经使用过的y坐标
            while len(x_arr) > 0:
                xx = random.choice(x_arr)  # 随机选择一个x坐标
                x_arr.remove(xx)  # 移除已经使用过的x坐标
                tbox = self.gen_tank_box(dir, xx, yy, pr)
                if tbox != None:
                    is_blank, _ = self.tank_box_check(tbox)
                    if is_blank == True:
                        # 如果该坐标可用, 就新建一个坦克对象
                        tank = TankBody(
                            dir, xx, yy, pr, self.t_fire_timer, self.t_steps_timer)
                        self.tank_list.append(tank)
                        self.tank_draw(tank)
                        return tank
            x_arr = list(range(self.t_width))
        y_arr = list(range(self.t_height))

return None
```

> tank_draw, tank_update

```python
'''
把(一辆)坦克贴[投影]到地图上
'''

def tank_draw(self, tank):
    dir = tank.dir
    x = tank.x
    y = tank.y
    pr = tank.pr

if dir < 0 or dir >= len(DIR_BOX):
        return False
    if self.is_over_border(x, y):
        return False

# self.tank_debug("tank name[{0}], dir[{1}], x[{2}], y[{3}], pr[{4}]".format(
    #     tank.name, dir, x, y, pr))

# 根据坦克坐标和坦克模板计算坦克的6个小个子的坐标
    tbox = self.gen_tank_box(dir, x, y, pr)
    if tbox == None:
        return False

# 把这6个小格子绘制到地图上
    for b in tbox:
        x = b['x']
        y = b['y']
        pr = b['pr']
        # self.tank_debug(
        #     "tank box x[{0}], y[{1}], pr[{2}]".format(x, y, pr))
        self.tank_map[y][x] = pr

'''
把所有坦克贴[投影]到地图上
'''

def tank_update(self):
    for t in self.tank_list:
        self.tank_draw(t)
```

如下:

![image-20200924094048212](http://www.demodashi.com/contentImages/image/20201015/AgTEHfPvMPOW1uBEyGB.png)

![image-20200924093817781](http://www.demodashi.com/contentImages/image/20201015/51dKmBh1m2HqsNeT5iH.png)

##### bomb create, draw, update

通过***bomb_create***, ***bomb_draw***, ***bomb_update***函数可以生成一辆真正的坦克, 并把这辆坦克显示到地图上.

> bomb_create

```python
'''
坦克发射炮弹
'''

def bomb_create(self, tank):
    dir = tank.dir
    x = tank.x
    y = tank.y
    pr = tank.pr
    name = tank.name
    wep_type = tank.wep
    if wep_type <= WP_NONE:
        return False
    if dir < 0 or dir >= len(DIR_BOX):
        return False
    if self.is_over_border(x, y):
        return False

# 根据坦克坐标和坦克模板计算坦克的6个小个子的坐标
    tbox = self.gen_tank_box(dir, x, y, pr)
    if tbox == None:
        return False

bomb_n = 0
    (dx, dy) = DIR_BOX[dir]
    # self.tank_debug("dir={0}, {1}".format(dir, (dx, dy)))
    for b in tbox:
        x = b['x'] + dx
        y = b['y'] + dy
        pr = b['pr']
        bomb = BombBody(dir, x, y, pr, name)
        self.tank_debug("bomb name[{0}], dir[{1}], x[{2}], y[{3}], pr[{4}]".format(
            bomb.name, bomb.dir, bomb.x, bomb.y, bomb.pr))
        self.bomb_list.append(bomb)
        self.bomb_draw(bomb)
        tank.bombs += 1 # 统计坦克的弹药消耗量
        bomb_n += 1
        if bomb_n >= wep_type:
            break

return True
```

> bomb_draw, bomb_update

```python
'''
把(一颗)炮弹贴[投影]到地图上
'''

def bomb_draw(self, bomb):
    x = bomb.x
    y = bomb.y
    pr = PR_BOMB

if self.is_over_border(x, y):
        return False

# self.tank_debug("bomb name[{0}], dir[{1}], x[{2}], y[{3}], pr[{4}]".format(
    #     bomb.name, dir, x, y, pr))
    self.tank_map[y][x] = pr

'''
把所有炸弹贴[投影]到地图上
'''

def bomb_update(self):
    for b in self.bomb_list:
        self.bomb_draw(b)
```

如下:

> 普通炮弹

![image-20200924164131573](http://www.demodashi.com/contentImages/image/20201015/2HfMOfmniJS56UT0naC.png)

![image-20200924163913360](http://www.demodashi.com/contentImages/image/20201015/pE4Ik5ClzafSEkFtquY.png)

> 超级炮弹

![image-20200924185736032](http://www.demodashi.com/contentImages/image/20201015/RkIsqLzk9oPbgXyiyqK.png)

![image-20200924185613502](http://www.demodashi.com/contentImages/image/20201015/3MPSSTaE0zML52WBdkU.png)

#### 让坦克动起来

要想让坦克移动, 只需要不断的跟新坦克的坐标就可以了.如果是敌军, 需要自动随机移动, 这个也很简单, 每次生成坦克时, 都给这辆坦克一个随机的移动步数, 当移动步数用完, 就随机旋转一个方向.

##### tank_move_step

```python
'''
把坦克向前移动一步
'''

def tank_move_step(self, tank):
    self.tank_clear(tank)
    (dx, dy) = DIR_BOX[tank.dir]
    tank.x += dx
    tank.y += dy
    self.tank_draw(tank)
```

另外, 坦克移动过程中有很多特殊情况需要处理:

* 坦克移动到地图边界外
* 坦克撞上了其他坦克
* 坦克是否"撞"上了武器和装备

对于以上情况,坦克都不能再继续移动,需要随机改变一个方向继续移动.

##### tank_move_auto

```python
'''
自动控制坦克
'''

def tank_move_auto(self, tank):
    tank_eat_pr = PR_NULL
    # 敌军坦克自动控制
    is_move, next_pr = self.tank_move_check(tank)
    # 如果坦克的移动步数用完，需要改变方向
    if tank.steps <= 0:
        is_move = False
        next_pr = PR_NULL
        tank.steps = random.randint(0, self.t_steps_timer)
    else:
        tank.steps -= 1

if is_move == True:  # 可以继续移动
        self.tank_debug(
            "tank [{0}] move check ok".format(tank.name))
        self.tank_move_step(tank)
    else:  # 不能继续移动
        if next_pr == PR_LIFE:
            # tank.life += 1  # 生命值增加
            tank_eat_pr = next_pr
            self.tank_move_step(tank)  # 吃到生命,继续移动
        elif next_pr == PR_WEAPON:
            # tank.wep = WP_SUPER  # 武器加强
            tank_eat_pr = next_pr
            self.tank_move_step(tank)  # 吃到武器,继续移动
        else:
            # 如果坦克不能移动, 则给坦克选择一个随机的(和原来不一样的)方向
            self.tank_debug(
                "tank [{0}] move check fail".format(tank.name))
            self.tank_dir_step(tank)
    return tank_eat_pr
```

##### tank_move_manual

```python
'''
手动控制坦克
'''

def tank_move_manual(self, tank, dir):
    tank_eat_pr = PR_NULL
    # 我军坦克手动控制
    if tank.dir != dir:  # 改变方向
        if self.tank_dir_check(tank, dir):
            tank.dir = dir
    else:
        # 向前移动
        is_move, next_pr = self.tank_move_check(tank)
        if is_move == True:  # 可以继续移动
            self.tank_debug(
                "tank [{0}] move check ok".format(tank.name))
            self.tank_move_step(tank)
        else:  # 不能继续移动
            if next_pr == PR_LIFE:
                # t.life += 1  # 生命增加
                tank_eat_pr = next_pr
                self.tank_move_step(tank)  # 吃到生命,继续移动
            elif next_pr == PR_WEAPON:
                tank_eat_pr = next_pr
                # t.wep = WP_SUPER  # 武器加强
                self.tank_move_step(tank)  # 吃到武器,继续移动
    return tank_eat_pr
```

##### tank_move_check

因此我们在每一步移动的时候, 都需要检测坦克能否继续移动.

> tank_move_check

```python
'''
检测坦克是否能向前移动
'''

def tank_move_check(self, tank):
    dir = tank.dir
    (dx, dy) = DIR_BOX[dir]
    pr = tank.pr
    x = tank.x
    y = tank.y
    self.tank_debug(
        "tank_move_check x[{0}], y[{1}], pr[{2}], dir[{3}]".format(x, y, pr, (dx, dy)))
    tbox = self.gen_tank_box(dir, x, y, pr)
    if tbox == None:
        is_blank = False
        next_pr = PR_NULL
        return is_blank, next_pr

# 检测坦克的每个小格子前方是否有阻挡
    for t in range(tbox.size):
        if t == 0:
            tbox[t]['x'] += dx
            tbox[t]['y'] += dy
            else:
                # 把坦克压缩成一个3*2的格子(因为4,5,6号格子的正前方时坦克自身)
                tbox[t]['x'] += (dx * 2)
                tbox[t]['y'] += (dy * 2)
                self.tank_debug("tank_move_check tbox[{0}]".format(tbox))

# 为了避免检测自身,先在地图上清除改坦克
                self.tank_clear(tank)
                is_blank, next_pr = self.tank_box_check(tbox)
                # 检测完之后重画该坦克
                self.tank_draw(tank)
                return is_blank, next_pr
```

##### tank_dir_check

> tank_dir_check, tank_dir_step

```python
'''
检测坦克是否能向指定方向旋转
'''

def tank_dir_check(self, tank, dir):
    is_blank = False
    # 检测坦克能否旋转到新的方向(即旋转过后不能有阻挡)
    tbox = self.gen_tank_box(dir, tank.x, tank.y, tank.pr)
    if tbox != None:
        is_blank = self.tank_box_check(tbox)
        return is_blank
'''
把坦克旋转一个随机的(与原来不同的)方向
'''

def tank_dir_step(self, tank):
    self.tank_clear(tank)
    # 如果坦克不能移动, 则给坦克选择一个随机的(和原来不一样的)方向
    dir_box = list(range(len(DIR_BOX)))
    dir_box.remove(tank.dir)
    while len(dir_box) > 0:
        dir = random.choice(dir_box)
        dir_box.remove(dir)
        # 检测坦克能否旋转到新的方向(即旋转过后不能有阻挡)
        if self.tank_dir_check(tank, dir):
            tank.dir = dir
            self.tank_debug("set tank [{0}] dir to {1}".format(
                tank.name, DIR_BOX[tank.dir]))
            break
            # 如果所有方向上都有遮挡, 坦克无法旋转, 则保持不动
            self.tank_draw(tank)
```

如下:

![tank_move](http://www.demodashi.com/contentImages/image/20201015/0qeb8XQXKF5ZAoosqSj.gif)

对于炮弹的移动, 相对来说简单一点,炮弹可以穿过一切物体,穿过坦克时,坦克被击毁,越界后就失效.

##### bomb_move_step

```python

'''
把炮弹向前移动一步
'''

def bomb_move_step(self, bomb):
    self.bomb_clear(bomb)
    (dx, dy) = DIR_BOX[bomb.dir]
    bomb.x += dx
    bomb.y += dy
    self.bomb_draw(bomb)
```

##### bomb_move_check

```python
'''
检测炮弹是否能向前移动
'''

def bomb_move_check(self, bomb):
    (dx, dy) = DIR_BOX[bomb.dir]
    x = bomb.x
    y = bomb.y
    self.tank_debug(
        "bomb_move_check name [{0}], pos[{1},{2}], dir[{3}]".format(bomb.name, x, y, (dx, dy)))
    x += dx
    y += dy

is_move = True
    next_pr = PR_NULL
    if self.is_over_border(x, y):
        is_move = False
    else:
        next_pr = self.tank_map[y][x]
    self.tank_debug(
        "bomb_move_check name[{0}] pos[{1},{2}], is_move[{3}], next_pr[{4}]".format(bomb.name, x, y, is_move, next_pr))
    return is_move, next_pr
```

##### bobm_move_auto

```python
'''
自动移动炮弹
'''

def bobm_move_auto(self, bomb):
    is_bobm_hit = False
    is_move, next_pr = self.bomb_move_check(bomb)
    if is_move == True:
        self.bomb_move_step(bomb)
        # 检测炮弹是否击中目标
        if next_pr != bomb.pr:  # 炮弹不能击中友军
            if next_pr == PR_ENMY or next_pr == PR_SELF:
                is_bobm_hit = True
                tank_fire = self.get_tank_by_name(bomb.name)
                if tank_fire != None:
                    # 发射该炮弹的坦克击杀数增加
                    tank_fire.kills += 1
                tank_kill = self.get_tank_by_pos(bomb.x, bomb.y)
                if tank_kill != None:
                    # 被击中的坦克烧毁
                    tank_kill.life -= 1
                    tank_kill.wep = WP_NORMAL  # 被击中后武器恢复为普通
                    self.tank_debug("bomb x[{0}], y[{1}], name[{2}], dir[{3}] fire a tank[{4}]".format(
                        bomb.x, bomb.y, bomb.name, bomb.dir, tank_kill.name))
                bomb.pr = PR_TBOMB  # 炮弹烧毁
    else:
        self.tank_debug("remove bomb x[{0}], y[{1}], name[{2}], dir[{3}]".format(
            bomb.x, bomb.y, bomb.name, bomb.dir))
        self.bomb_list.remove(bomb)
    return is_bobm_hit
```

#### 开战吧!英雄们!

##### 打扫战场

> 用于清理战场上被击毁的坦克,失效的炮弹,超时的装备等

```python
'''
打扫战场
'''

def tank_clean(self):
    # 列表遍历删除时需要先把原列表复制到新列表中(a[:]表示复制列表),
    # 然后遍历新列表, 在原列表中remove, 如果不这么做会存在有些元素
    # 无法删除的情况, 详见
    # [python list删除元素时的遗漏问题](https://blog.csdn.net/lanyang123456/article/details/71055163)
    for b in self.bomb_list[:]:
        # 移除已经爆炸或越界的炮弹
        if b.pr == PR_TBOMB:
            self.bomb_list.remove(b)
        elif self.is_over_border(b.x, b.y):
            self.bomb_list.remove(b)

# 移除已经被击毁或越界的坦克
    for t in self.tank_list[:]:
        if t.pr == PR_TBOMB:
            t.life = LF_DIE

if self.is_over_border(t.x, t.y):
            t.life = LF_DIE

if t.life <= LF_DIE:
            self.tank_list.remove(t)
        elif t.life <= LF_BURN:
            t.pr = PR_TBOMB
            t.wep = WP_NONE
```

##### 火炮系统

> 火炮系统用于控制敌军(自动)和我军(手动)开火

```python
'''
火炮系统
'''

def tank_fire(self, game):
    for t in self.tank_list:
        if t == self.tank_self:
            # 我军手动开火
            if self.t_fire == True:
                self.t_fire = False
                t.fires = 0
            else:
                t.fires = 1
        else:
            # 敌军自动开火(根据开火倒计时)
            if t.fires > 0:
                t.fires -= 1
            else:
                t.fires = random.randint(0, self.t_fire_timer)

if t.fires == 0:
            game.sound_play(TANK_SOUND_FIRE)
            self.bomb_create(t)
```

##### 对战系统

> 对战系统用于控制敌军和我军的移动,开火等, 并判断坦克是否被击中,炮弹开火和爆炸的音效, 以及被击毁坦克的处理

```python
'''
对战系统
'''

def tank_war(self, game):

# 移动所有炮弹
    for b in self.bomb_list[:]:
        # 检测炮弹能否移动
        if self.bobm_move_auto(b):
            game.sound_play(TANK_SOUND_BOOM)

if self.bomb_speed >= TANK_BOMB_SPEED:
        self.bomb_speed = 0
        # 移动所有坦克
        for t in self.tank_list:
            self.tank_debug("tank [{0}] move check start".format(t.name))

tank_eat_pr = PR_NULL
            # 检查坦克是否能够移动
            if t == self.tank_self:
                if self.t_dir != None:
                    self_dir = self.dir_to_idx(self.t_dir)
                    self.t_dir = None
                    # 我军坦克手动控制
                    tank_eat_pr = self.tank_move_manual(t, self_dir)
            else:
                # 敌军坦克自动控制
                tank_eat_pr = self.tank_move_auto(t)
            if tank_eat_pr == PR_LIFE:
                game.sound_play(TANK_SOUND_LIFE)
            elif tank_eat_pr == PR_WEAPON:
                game.sound_play(TANK_SOUND_WEP)
            self.tank_debug("tank [{0}] move check end".format(t.name))
    else:
        self.bomb_speed += 1
```

##### 坦克裁判系统

> 裁判系统负责统计坦克数量,分数, 自动增援等

```python
'''
坦克裁判系统
'''

def tank_judge(self, game):
    if self.t_king:
        self.tank_self.life = LF_LIVE
        self.tank_self.wep = WP_SUPER

# 我军自动增援
    self_num = self.get_tank_self_num()
    if self_num <= 0:
        self.tank_reinforce()

# 如果自己被击败, 把控制权转移到友军身上
    if self.tank_self.life <= LF_DIE:
        for t in self.tank_list:
            if t.pr == PR_SELF:
                self.tank_self = t

# 统计分数
    tank_life = 0
    tank_score = 0
    for t in self.tank_list:
        if t.pr == PR_SELF:
            tank_life += t.life
            tank_score += t.kills

if tank_life <= self.t_life:
        self.t_life = tank_life

# 根据得分加快速度
    if tank_score > self.t_score:
        self.t_score = tank_score
        if((self.t_score > 0) and (self.t_score % 10 == 0)):
            self.t_speed += 1
            self.t_emey_num += 1
            self.t_score += 1  # 系统奖励1分, 为了解决杀敌10个之后敌军暴增的问题

# 敌军自动增援
    emey_num = self.get_tank_emey_num()
    emey_num = self.t_emey_num - emey_num
    if emey_num > 0:
        for _ in range(emey_num):
            self.tank_reinforce(PR_ENMY)

if self.t_life <= LF_DIE:  # 如果坦克死亡则退出游戏
        print("You killed {0} enemies!".format(self.t_score))
        game.quit()
```

##### 坦克装备系统

> 装备系统用于装备的生成和老化(自动消失)

```python
'''
坦克装备系统
'''

def tank_equip(self, game):
    # 倒计时时间到, 生成一个装备
    if self.t_equip_timer <= 0:
        if len(self.equip_list) < TANK_EQUIP_NUM_MAX:
            self.equip_create()  # 总的装备不能超过限制
        # 重置生成装备的定时器为随机值
        self.t_equip_timer = random.randint(
            TANK_EQUIP_TIMER_MIN, TANK_EQUIP_TIMER_MAX)
    else:
        self.t_equip_timer -= 1

# 遍历所有装备, 如果装备已经被坦克吃掉, 使该装备失效
    for t in self.tank_list:
        tbox = self.gen_tank_box(t.dir, t.x, t.y, t.pr)
        if tbox == None:
            continue
        for b in tbox:
            x = b['x']
            y = b['y']
            equip = self.get_equip_by_pos(x, y)
            if equip == None:
                continue
            equip.timer = 0  # 使该装备失效
            if equip.pr == PR_WEAPON:
                t.wep = WP_SUPER  # 武器加强
                game.sound_play(TANK_SOUND_WEP)
            if equip.pr == PR_LIFE:
                t.life += 1  # 生命值增加
                game.sound_play(TANK_SOUND_LIFE)

for e in self.equip_list[:]:
        if e.timer <= 0:
            # 移除已经失效时的装备
            self.equip_list.remove(e)
        else:
            # 更新装备的倒计时
            e.timer -= 1

if self.is_over_border(e.x, e.y):
            self.equip_list.remove(e)
```

##### 坦克大战运行

> 坦克大战运行入口

```python
'''
坦克大战运行
'''

def run(self, game):
    self.tank_clean()
    self.tank_fire(game)
    self.tank_war(game)
    self.tank_equip(game)

self.tank_judge(game)

game_delay = TANK_DELAY_MAX - self.t_speed * TANK_DELAY_STEP
    if game_delay <= TANK_DELAY_MIN:
        game_delay = TANK_DELAY_MIN

time.sleep(game_delay)
```

## 程序运行截图

![image-20201015154417843](http://www.demodashi.com/contentImages/image/20201015/7rlt8kOuY5V3Q9pADEf.png)

## 项目文件截图

![image-20201015154449766](http://www.demodashi.com/contentImages/image/20201015/wyjvpopmNyB4c1y8bAN.png)

Python坦克大战

概述

详细

相似例子推荐

评论

作者

评分详细

作者例子