C++ 经典小游戏

1.贪吃蛇（无敌版）

 可删除注释解除无敌

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <time.h>
#include <windows.h>
#include <stdlib.h>
#include<iostream>
#include <conio.h>
#define MY_BUFSIZE 1024    //控制台窗口标题的缓冲区大小
#define INITIALTIME 80

//蛇的状态(上,下,左,右)
#define U 1
#define D 2
#define L 3
#define R 4

using namespace std;

typedef struct Snake {
    int x;                  //节点的x坐标
    int y;                  //节点的y坐标
    struct Snake* next;     //蛇身的下一个节点
} snake;

int init_snack_long = 1;
int score = 0, add = 0;          //总得分与每次吃食物的得分
int HighScore = 0;               //最高的得分
int status;                      //蛇的前进状态
int sleeptime = INITIALTIME;     //蛇的时间间隔
int endgamestatus =
    0;           //游戏的结束的情况: 撞到墙,咬到自己,主动退出游戏

HANDLE hOut;                     //控制台句柄
snake* head, * food;             //蛇头指针,食物指针
snake* q;                        //遍历蛇时用到的指针

void gotoxy(int x, int y);       //设置光标位置
void color(int col);             //更改文字颜色
void printsnake();               //字符画,蛇
void welcometogame();            //开始界面
void createMap();                //绘制地图
void scoreandtips();             //游戏右侧的得分和小提示
void initsnake();                //初始化蛇身(画出蛇身)
void createfood();               //创见并随机出击食物
bool biteself();                  //判断是否咬到自己
void cantcrosswall();            //判断是否撞墙
void speedup();                  //加速
void speedown();                 //减速
void snakemove();                //控制蛇的前进方向
void keyboardControl();          //控制键盘按键
void Lostdraw();                 //游戏结束界面
void endgame();                  //游戏结束
void choose();                   //游戏失败之后的选择
void File_out();                 //从文件中读取最高分
void File_in();                  //将最高分存入文件
void explation();                //游戏说明
HWND GetConsoleHwnd();           //获取当前句柄

int main(void) {
    //设置窗口
    system("mode con cols=100 lines=30");
    SetWindowLongPtr(GetConsoleHwnd(), GWL_STYLE,
                     WS_VISIBLE | WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
                     WS_MAXIMIZEBOX);

    printsnake();
    welcometogame();
    File_out();
    keyboardControl();
    endgame();
}

//设置颜色
void color(int col) {
    //调用API改变控制台字体颜色
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), col);
}

void gotoxy2(int x, int y) {
    COORD pos = {x, y};
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleCursorPosition(hOut, pos);
}

//改变字体位置
void gotoxy(int x, int y) {
    COORD Position;
    Position.X = x;
    Position.Y = y;
    //调用API改变字体位置
    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), Position);
}

//字符画,蛇
void printsnake() {
    color(6);                   //字体颜色设置为黄色

    gotoxy(32, 3);
    printf("~~~~=_=~~~~ \\\\   <----------------------说出来你信吗,我是条蛇...");

    gotoxy(44, 4);
    printf(" \\");

    gotoxy(45, 5);
    printf("  \\");

    gotoxy(46, 6);
    printf("   \\");

    gotoxy(47, 7);
    printf("    \\");

    gotoxy(48, 8);
    printf("    =========================>");

    gotoxy(49, 26);
    return;
}

//开始界面
void welcometogame() {
    cout << "请确定游戏时间间隔(1~500)：";
    cin >> sleeptime;
    cout << "                                                 请确定蛇初始长度(1,2,3,4,5,...29,30)：";
    cin >> init_snack_long;
    int choice;
    int x, y;
    int count1 = 0, count2 = 0;
    gotoxy(37, 15);
    color(11);
    printf("---贪---吃---蛇---大---作---战---");

    for (x = 20; x < 80; x++) {
        count2++;
        for (y = 17; y < 26; y++) {
            count1++;
            if (x == 20 || x == 79) {
                if (count1 % 2 == 0)
                    color(9);
                else
                    color(13);

                gotoxy(x, y);
                printf("|");
            }

            if (y == 17 || y == 25) {
                if (count2 % 2 == 0)
                    color(9);
                else
                    color(13);

                gotoxy(x, y);
                printf("-");
            }
        }
    }

    gotoxy(32, 19);
    color(13);
    printf("1:开始游戏");

    gotoxy(58, 19);
    printf("2:游戏说明");

    gotoxy(32, 23);
    printf("3:退出游戏");

    gotoxy(43, 26);
    printf("请选择[1 2 3]:[ ]\b\b");
    scanf("%d", &choice);

    switch (choice) {
        case 1:
            system("cls");
            createMap();
            initsnake();
            createfood();
            keyboardControl();
            break;

        case 2:
            explation();
            break;

        case 3:
            exit(0);
            break;

        default:

            gotoxy(40, 28);
            color(12);
            printf("输入错误,请输入1~3的数!");
            _getch();             //除了vs系列之外的编译器需要把这一行改成: getch();
            system("cls");
            printsnake();
            welcometogame();
            break;

    };
    return;
}

//打印地图中的方块
void createMap() {
    int i, j;
    int count = 0;
    for (i = 0; i < 58; i += 2) {
        color(13);         //
        gotoxy(i, 0);
        printf("■");
        gotoxy(i, 26);
        printf("■");
    }

    for (i = 1; i < 26; i++) {
        color(13);         //
        gotoxy(0, i);
        printf("■");
        gotoxy(56, i);
        printf("■");
    }


    /*之间是动画效果(虽然不太好看)如果不要可以删除*/


    color(13);
    for (j = 1; j < 26; j += 2) {
        for (i = 2; i < 58; i += 4) {
            gotoxy(i, j);
            printf("■");
            Sleep(2);       //增加点延时效果
        }
    }

    color(10);
    for (i = 2; i < 56; i += 4) {
        for (j = 2; j < 26; j += 2) {
            gotoxy(i, j);
            printf("■");
            Sleep(2);       //增加点延时效果
        }
    }


    /*结束*/



    color(3);
    for (i = 2; i < 56; i += 2) {
        for (j = 1; j < 26; j++) {
            gotoxy(i, j);
            printf("■");
        }
        Sleep(10);       //增加点延时效果
    }
    return;
}

//游戏右侧的得分和小提示
void scoreandtips() {
    int i;
    //File_out();         //读取文件中的最高分数
    gotoxy(64, 4);
    color(11);
    printf("☆历史最高分为: %d ☆", HighScore);

    gotoxy(64, 8);
    color(14);
    printf("得分: %d", score);

    gotoxy(73, 11);
    color(13);
    printf("小 提 示");

    gotoxy(60, 13);              //第一条线
    color(9);
    printf("╬ ");
    for (i = 63; i < 92; i++) {
        if (i % 2 == 0)
            color(9);
        else
            color(13);
        printf("-");
        gotoxy(i, 13);
    }
    gotoxy(91, 13);
    color(9);
    printf("╬ ");


    /*以下是两条线中间的内容*/

    color(3);
    gotoxy(64, 14);
    printf("每个食物得分: %d 分", add);
    gotoxy(64, 16);
    printf("不能撞墙和咬到自己哦~");
    gotoxy(64, 18);
    printf("用 ↑ ↓ ← → 分别控制蛇的移动");
    gotoxy(64, 20);
    printf("F1: 加速。F2: 减速");
    gotoxy(64, 22);
    printf("空格：暂停游戏 ");
    gotoxy(64, 24);
    printf("Esc: 结束游戏 ");
    gotoxy(64, 26);
    printf("时间间隔 : %d 毫秒", sleeptime);

    /*线束*/

    gotoxy(60, 25);              //第二条线
    color(13);
    printf("╬ ");
    for (i = 63; i < 92; i++) {
        if (i % 2 == 0)
            color(9);
        else
            color(13);
        printf("-");
        gotoxy(i, 28);
    }
    gotoxy(91, 28);
    color(13);
    printf("╬ ");
    return;
}

//从文件中读取最高分
void File_out() {
    int ans = 0;
    FILE* fp = NULL;
    fp = fopen("snake.data", "r");
    if (fp == NULL) {   //判断文件是否打开成功,失败则提示并退出游戏
        //下面这一行是vs的问题,其它编译器需要用MessageBox把MessageBox给替换掉(其它编译器中 char* 类型是可以直接转换为 LPCWSTR 类型的而vs系列中改为Unicode字符集还是不可以)
        MessageBoxA(NULL, "Data file read / write failure,Please press OK to exit",
                    "Greedy_snake", MB_OK | MB_ICONERROR);
        exit(1);
    }

    fscanf(fp, "%d", &HighScore);    //读取数据
    fclose(fp);                      //关闭文件
}

//初始化蛇身
void initsnake() {
    snake* tail;
    int i;
    tail = (snake*)malloc(sizeof(
                              snake));       //这是蛇尾从蛇尾开始画(链表的最后一代节点),用头插法,以x,y设为开始位置

    tail->x = 24;        //初始化位置为24,5
    tail->y = 5;
    tail->next = NULL;

    for (i = 0; i <= init_snack_long; i++) {      //设置蛇身长度为:6
        head = (snake*)malloc(sizeof(snake));
        head->next = tail;             //蛇头的下一位置为蛇尾

        head->x = 24 + 2 * i;          //设置蛇头的位置
        head->y = 5;

        tail = head;                   //蛇头变成蛇尾,然后重复循环(可能有点绕,画画就理解了)
    }

    while (tail != NULL) {
        color(14);
        gotoxy(tail->x, tail->y);
        printf("■");               //蛇身用 ■ 表示
        tail = tail->next;         //蛇身一点一点输出,一直输出到蛇尾
    }
    return;
}

//随机产生食物
void createfood() {
    snake* food_1 = NULL;

    food_1 = (snake*)malloc(sizeof(snake));

    food_1->x = 1;
    food_1->y = 0;
    food_1->next = NULL;

    srand((unsigned)time(NULL));     //初始化随机数

    //food_1->x = rand() % 52 + 2;

    while ((food_1->x % 2) != 0) {
        food_1->x = rand() % 52 +
                    2;          //食物的x坐标(52是右边倒数第二列的x坐标, +2是因为防止出现在边框上)
    }

    food_1->y = rand() % 24 +
                1;               //食物的y坐标(为什么要 %24 和 +1 的原因和上面一样)

    q = head;

    while (q->next == NULL) {                  //!!!!!!!!!!!!!!!!!!!!!!!!!1
        if (q->x == food_1->x && q->y == food_1->y) {
            free(food_1);    //如果蛇与食物重合则释放食物指针

            createfood();    //重新创建食物
        }
        q = q->next;
    }
    gotoxy(food_1->x, food_1->y);  //设置食物位置

    food = food_1;
    color(12);
    printf(" ·");               //以红色颜色输出食物

    return;
}

//判断是否咬到自己
bool biteself() {
//  snake* self;               //self是蛇身上的一个节点(除了蛇身之外的节点)
//  self = head->next;
//
//  while (self != NULL)       //判断蛇头是否与蛇身相同,相同就是咬到自己了,咬到自己就返回true否则返回fslse
//  {
//      if (self->x == head->x && self->y == head->y)
//          return true;
//      self = self->next;
//  }
    return false;
}

//判断是否撞墙
void cantcrosswall() {
//  if (head->x == 0 || head->x == 58 || head->y == 0 || head->y == 30)  //判断是否撞到墙
//  {
//      endgamestatus = 1;              //结束游戏的一种情况,endgamestatus等于1时为失败界面
//      endgame();
//  }
}

//加速
void speedup() {
    sleeptime -= 1;       //时间间隔减
    add += rand() % 5 + 1;              //每次吃到的食物的分数加随机
}

//减速
void speeddown() {
    sleeptime += 1;       //时间间隔减10

    add -= rand() % 2 + 1;              //每次吃到的食物的分数加随机

    if ( add < 0 ) {
        add = 0;
    }

    if (sleeptime == 350) {
        add = 1;           //保证最低分为 1 分
    }
}

//蛇的移动方向
void snakemove() {
    snake* nexthead;

    cantcrosswall();
    nexthead = (snake*)malloc(sizeof(snake));


    /*
        下面语句中只有下面这两段代码需要更改其它的都不而要复制一下就好
            nexthead->x = head->x;
            nexthead->y = head->y - 1;
    */

    if (status == U) {  //向上移动
        nexthead->x = head->x;
        nexthead->y = head->y - 1;

        nexthead->next = head;
        head = nexthead;
        q = head;          //指向链表头准备遍历链表

        if (nexthead->x == food->x &&
                nexthead->y == food->y) {    //如果遇到了食物
            color(14);
            while (q != NULL) {          //打印蛇身
                gotoxy(q->x, q->y);
                printf("■");
                q = q->next;
            }
            score += add;               //吃了食物后加分
            speedup();                  //并提升速度
            createfood();               //吃了食物后再创建一个
        } else {       //如果没遇到食物
            color(14);
            while (q->next->next !=
                    NULL) {             //蛇往前移动后前面加一,后面减一   画出移动后蛇身前n-1个格子(画一画就理解了)
                gotoxy(q->x, q->y);
                printf("■");
                q = q->next;
            }

            color(3);
            gotoxy(q->x, q->y);
            printf("■");              //画出蛇身倒数第二个蛇身格子
            free(q->next);            //释放掉原来的最后一个蛇身格子
            q->next = NULL;
        }
    }
    if (status == D) {   //向下移动

        nexthead->x = head->x;
        nexthead->y = head->y + 1;

        nexthead->next = head;
        head = nexthead;
        q = head;          //指向链表头准备遍历链表

        if (nexthead->x == food->x &&
                nexthead->y == food->y) {    //如果遇到了食物
            color(14);
            while (q != NULL) {          //打印蛇身
                gotoxy(q->x, q->y);
                printf("■");
                q = q->next;
            }
            score += add;               //吃了食物后加分
            speedup();                  //并提升速度
            createfood();               //吃了食物后再创建一个
        } else {
            color(14);
            while (q->next->next !=
                    NULL) {             //蛇往前移动后前面加一,后面减一   画出移动后蛇身前n-1个格子(画一画就理解了)
                gotoxy(q->x, q->y);
                printf("■");
                q = q->next;
            }

            color(3);
            gotoxy(q->x, q->y);
            printf("■");              //画出蛇身倒数第二个蛇身格子
            free(q->next);            //释放掉原来的最后一个蛇身格子
            q->next = NULL;
        }
    }

    if (status == L) {   //向左移动

        nexthead->x = head->x - 2;
        nexthead->y = head->y;

        nexthead->next = head;
        head = nexthead;
        q = head;          //指向链表头准备遍历链表

        if (nexthead->x == food->x &&
                nexthead->y == food->y) {    //如果遇到了食物
            color(14);
            while (q != NULL) {          //打印蛇身
                gotoxy(q->x, q->y);
                printf("■");
                q = q->next;
            }
            score += add;               //吃了食物后加分
            speedup();                  //并提升速度
            createfood();               //吃了食物后再创建一个
        } else {
            color(14);
            while (q->next->next !=
                    NULL) {             //蛇往前移动后前面加一,后面减一   画出移动后蛇身前n-1个格子(画一画就理解了)
                gotoxy(q->x, q->y);
                printf("■");
                q = q->next;
            }

            color(3);
            gotoxy(q->x, q->y);
            printf("■");              //画出蛇身倒数第二个蛇身格子
            free(q->next);            //释放掉原来的最后一个蛇身格子
            q->next = NULL;
        }
    }

    if (status == R) {   //向右移动

        nexthead->x = head->x + 2;
        nexthead->y = head->y;

        nexthead->next = head;
        head = nexthead;
        q = head;          //指向链表头准备遍历链表

        if (nexthead->x == food->x &&
                nexthead->y == food->y) {    //如果遇到了食物
            color(14);
            while (q != NULL) {          //打印蛇身
                gotoxy(q->x, q->y);
                printf("■");
                q = q->next;
            }
            score += add;               //吃了食物后加分
            speedup();                  //并提升速度
            createfood();               //吃了食物后再创建一个
        } else {
            color(14);
            while (q->next->next !=
                    NULL) {             //蛇往前移动后前面加一,后面减一   画出移动后蛇身前n-1个格子(画一画就理解了)
                gotoxy(q->x, q->y);
                printf("■");
                q = q->next;
            }

            color(3);
            gotoxy(q->x, q->y);
            printf("■");              //画出蛇身倒数第二个蛇身格子
            free(q->next);            //释放掉原来的最后一个蛇身格子
            q->next = NULL;
        }
    }

    if (biteself() == true) {         //判断是否咬到自己
        endgamestatus = 2;
        endgame();
    }
    return;
}

//控制键盘按键
void keyboardControl() {
    status = R;     //初始化向右移动

    while (1) {
        scoreandtips();      //游戏右边的小提示和得分

        //GetAsyncKeyState函数用来判断调用时指定虚假键的状态
        if (GetAsyncKeyState(VK_UP) &&
                status != D)         //如果按的不是 下 键则向 上 移动
            status = U;
        else if (GetAsyncKeyState(VK_DOWN) &&
                 status != U)  //如果按的不是 上 键则向 下 移动
            status = D;
        else if (GetAsyncKeyState(VK_LEFT) &&
                 status != R)  //如果按的不是 右 键则向 左 移动
            status = L;
        else if (GetAsyncKeyState(VK_RIGHT) &&
                 status != L) //如果按的不是 左 键则向 右 移动
            status = R;

        if (GetAsyncKeyState(VK_SPACE)) {        //按空格键暂停
            while (1) {
                Sleep(300);
                if (GetAsyncKeyState(VK_SPACE))          //再按一次空格键继续
                    break;
            }
        } else if (GetAsyncKeyState(VK_ESCAPE)) {        //按Esc键转到结束界面
            endgamestatus = 3;
            break;
        } else if (GetAsyncKeyState(VK_F1))              //F1加速
            speedup();
        else if (GetAsyncKeyState(VK_F2))                //F2减速
            speeddown();

        Sleep(sleeptime);            //移动速度
        snakemove();                 //没有按这几个键时继续移动
    }
    return;
}

//失败界面
void Lostdraw() {
    system("cls");
    int i;
    gotoxy2(0, 0);

    //四个角上的五角星
    color(13);
    gotoxy(4, 6);
    printf("★");
    gotoxy(96, 6);
    printf("★");
    gotoxy(4, 29);
    printf("★");
    gotoxy(96, 29);
    printf("★");

    //打印边框的四条边
    for (i = 6; i < 96; i++) {
        if (i % 2 == 0)
            color(3);
        else
            color(13);

        gotoxy(i, 6);
        printf("-");
        gotoxy(i, 29);
        printf("-");
    }

    for (i = 7; i < 29; i++) {
        if (i % 2 == 0)
            color(3);
        else
            color(13);
        gotoxy(4, i);
        printf("|");
        gotoxy(97, i);
        printf("|");
    }

    //打印边框上的装饰
    color(14);
    gotoxy(30, 6);
    printf("o 0-0 o");
    gotoxy(71, 6);
    printf("o 0-0 o");

    gotoxy(48, 5);
    color(14);
    printf("<  @ @  >");

    gotoxy(50, 6);
    color(3);
    printf("《_》");

    gotoxy(47, 29);
    color(13);
    printf("☆☆☆☆☆☆");
    return;
}

//结束游戏
void endgame() {
    system("cls");
    gotoxy2(0, 0);
    if (endgamestatus == 1) {
        Lostdraw();
        gotoxy(35, 9);
        color(12);
        printf("对不起，您撞到墙了，游戏结束!");
    } else if (endgamestatus == 2) {
        Lostdraw();
        gotoxy(35, 9);
        color(14);
        printf("对不起，您咬到自己了，游戏结束!");
    } else if (endgamestatus == 3) {
        Lostdraw();
        gotoxy(40, 9);
        color(14);
        printf("您已经结束了游戏。");
    }

    gotoxy(43, 12);
    color(13);
    printf("您的得分是: %d", score);
    if (score >= HighScore) {
        color(10);
        gotoxy(33, 16);
        printf("创新纪录！最高分被您刷新啦，真厉害！");
        File_in();
    } else {
        color(10);
        gotoxy(33, 16);
        printf("继续努力哦,您离最高分只差 %d 喽~", HighScore - score);
    }
    choose();
    return;
}

//把最高分写入文件
void File_in() {
    FILE* fp;
    fp = fopen("snake.data", "w+");    //以只写的方式打开文件
    fprintf(fp, "%d",
            score);          //从文件中读出最高分写入到score中
    fclose(fp);                        //关闭文件
}

//边框下面的选项
void choose() {
    int n;
    gotoxy(25, 23);
    color(10);
    printf("我要重新玩一局------1");
    gotoxy(52, 23);
    printf("不玩了，退出吧------2");
label:
    gotoxy(46, 25);
    color(13);
    printf("选择：[   ]\b\b\b");
    scanf("%d", &n);
    switch (n) {
        case 1:
            gotoxy2(0, 0);
            score = 0;                     //分数初始化为 0
            sleeptime = INITIALTIME;       //速度初始化为 0
            add = 10;                      //食物得分为初始化为 10
            printsnake();                  //返回欢迎界面
            welcometogame();

        case 2:
            exit(0);
            break;
        default:
            gotoxy(35, 27);
            color(12);
            printf("※※您输入的有误，请从新输入※※");
            system("pause >nul");
            endgame();
            choose();               //边框下的分支选项
            goto label;
            break;
    }
    return;
}

//游戏说明
void explation() {
    int i, j = 1;
    gotoxy2(0, 0);
    gotoxy(42, 4);
    printf("游   戏   说   明");
    color(2);
    for (i = 6; i <= 25; i++) {
        for (j = 20; j <= 76; j++) {
            gotoxy(j, i);
            if (i == 6 || i == 25) {
                if (i % 2 == 0)
                    color(3);
                else
                    color(13);
                printf("=");
            } else if (j == 20 || j == 76) {
                if (i % 2 == 0)
                    color(3);
                else
                    color(13);
                printf("||");
            }
        }
    }

    color(13);
    gotoxy(76, 6);
    printf("★");
    gotoxy(76, 25);
    printf("★");

    color(3);
    gotoxy(30, 8);
    printf("tipl: 不能撞墙，不能咬到自己");

    color(10);
    gotoxy(30, 11);
    printf("tip2: 用↑，↓，←，→分别控制蛇的移动");

    color(13);
    gotoxy(30, 14);
    printf("tip3: F1是加速，F2是减速");

    color(14);
    gotoxy(30, 17);
    printf("tip4: 按空格键暂停游戏，再按一次继续游戏");

    color(4);
    gotoxy(30, 20);
    printf("tip5: Esc键退出游戏");

    color(1);
    gotoxy(30, 23);
    printf("tip6: 自己的废物自己需要清理");

    _getch();                        //按任任意键返回主界面

    gotoxy2(0, 0);
    printsnake();
    welcometogame();
}

HWND GetConsoleHwnd() {          //获取窗口句柄

    HWND hwndFound;                      //最后获得的句柄
    WCHAR pszNewWindowTitle[MY_BUFSIZE]; //窗口标题

    WCHAR pszOldWindowTitle[MY_BUFSIZE]; //旧的句柄


    //获取当前窗口标题


    //设置唯一窗口名子。

    char szStr[MY_BUFSIZE];

    sprintf(szStr, "%d%d", GetTickCount(),
            GetCurrentProcessId());   //因为为了兼容下面的MessagrBox这里用的

    memset(pszNewWindowTitle, 0, sizeof(pszNewWindowTitle));
    MultiByteToWideChar(CP_ACP, 0, szStr, strlen(szStr) + 1, pszNewWindowTitle,
                        sizeof(pszNewWindowTitle) / sizeof(pszNewWindowTitle[0]));


    //确保窗口标题已更新
    Sleep(10);


    return (hwndFound);       //返回句柄
}

2.坦克大战

原创魔改版

#include <stdio.h>

#include <windows.h>

#include <time.h>

//里规格：长39*2=78 （真坐标）(假坐标宽为39)  高39
//外规格：长41*2=82 （真坐标）(假坐标宽为41)  高41
#define UP    1
#define DOWN  2
#define LEFT  3
#define RIGHT 4
#define MAX_LEVEL 1000
#define BULLET_NUM 500
#define MAX_LIFE 1000000

//程序中未写入函数参数表中且未说明的变量只有map二维数组,level_info数组和level



/*
      此程序中涉及的x,y类的坐标值，分为以下两种：

假坐标：这里的坐标指的是以一个■长度为单位的坐标，而不是真正的coord坐标 (用于map数组的坐标)

真坐标：头文件自带的坐标结构coord中的坐标（也可以说是控制台里的真正坐标值）

  区别：纵坐标y两值一致，假横坐标x值与真正coord横坐标（真坐标）关系是 x * 2 = coord 横坐标


          coord横坐标既指GoTo函数中的x参数,因为本程序游戏界面以一个■长度为基本单位，

          可以说涉及的coord横坐标全是偶数。既假坐标要变真坐标（变真坐标才能发挥真正作用），横坐标须乘以2



*/
typedef struct {           //这里的出现次序指的是一个AI_tank变量中的次序，游戏共有四个AI_tank变量
    //∵设定每个AI_tank每种特殊坦克只出现一次 ∴fast_tank & firm_tank 最多出现次数不超过1
    int fast_tank_order;   //fast_tank出现的次序(在第fast_tank_order次复活出现,从第0次开始)，且每个AI_tank只出现一次
    int firm_tank_order;   //firm_tank出现的次序，同上
} LevInfo;                 //关卡信息(准确说是该关出现的坦克信息)
LevInfo level_info [MAX_LEVEL] = {{-1, -1}, {3, -1}, {-1, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 3}}; //初始化，-1代表没有该类型坦克


typedef struct {    //子弹结构体
    int x, y;       //子弹坐标,假坐标
    int direction;  //子弹方向变量
    bool exist;     //子弹存在与否的变量,1为存在，0不存在
    bool initial;   //子弹是否处于建立初状态的值，1为处于建立初状态，0为处于非建立初状态
    bool my;        //区分AI子弹与玩家子弹的标记,0为AI子弹，1为玩家（我的）子弹
} Bullet;
Bullet bullet [BULLET_NUM];  //考虑到地图上不太可能同时存在20颗子弹，所以数组元素设置20个


typedef struct {    //坦克结构体
    int x, y;       //坦克中心坐标
    int direction;  //坦克方向
    int color;      //颜色参方向数，1到6分别代表不同颜色，具体在PrintTank函数定义有说明
    int model;      //坦克图案模型，值为1,2,3，分别代表不同的坦克图案,0为我的坦克图案，AI不能使用
    int stop;       //只能是AI坦克使用的参数，非0代表坦克停止走动,0为可以走动
    int revive;     //坦克复活次数
    int num;        //AI坦克编号（固定值，为常量，初始化函数中定下）0~3
    int CD;         //发射子弹冷却计时
    bool my;        //是否敌方坦克参数，我的坦克此参数为1,为常量
    bool alive;     //存活为1，不存活为0
}  Tank;
Tank AI_tank[4], my_tank;   //my_tank为我的坦克，Ai_tank 代表AI坦克

//∵所有的函数都有可能对全局变量map进行读写(改变)，
//∴函数中不另说明是否会对全局变量map读写
//基本操作与游戏辅助函数
void GoToxy(int x, int y);   //光标移动
void HideCursor();           //隐藏光标
void keyboard ();            //接受键盘输入
void Initialize();           //初始化(含有对多个数据的读写)
void Stop();                 //暂停
void Getmap();               //地图数据存放与获取
void Frame ();               //打印游戏主体框架
void PrintMap();             //打印地图(地图既地图障碍物)(含对level的读取)
void SideScreen ();          //副屏幕打印
void GameCheak();            //检测游戏输赢
void GameOver( bool home );  //游戏结束
void ClearMainScreen();      //主屏幕清屏函数∵system("cls")后打印框架有一定几率造成框架上移一行的错误∴单独编写清屏函数
void ColorChoose(int color); //颜色选择函数
void NextLevel();            //下一关(含有对level全局变量的读写)

//子弹部分
void BuildAIBullet(Tank*
                   tank);                //AI坦克发射子弹（含有对my_tank的读取,只读取了my_tank坐标）

void BuildBullet  (Tank
                   tank);                 //子弹发射（建立）（人机共用）(含全局变量bullet的修改)我的坦克发射子弹直接调用该函数,AI通过AIshoot间接调用

void BulletFly    (Bullet
                   bullet[BULLET_NUM]); //子弹移动和打击（人机共用）,
void BulletHit    (Bullet*
                   bullet);            //子弹碰撞（人机共用）(含Tank全局变量的修改)，只通过BulletFly调用，子弹间的碰撞不在本函数,子弹间碰撞已在BulletShoot中检测并处理
void PrintBullet  (int x, int y, int T);       //打印子弹（人机共用）
void ClearBullet  (int x, int y, int T);       //清除子弹（人机共用）
int  BulletCheak  (int x,
                   int y);              //判断子弹前方情况（人机共用）

//坦克部分
void BuildAITank (int* position, Tank* AI_tank); //建立AI坦克

void BuildMyTank (Tank* my_tank);                //建立我的坦克
void MoveAITank  (Tank* AI_tank);                //AI坦克移动
void MoveMyTank  (int
                  turn);                     //我的坦克移动，只通过keyboard函数调用，既键盘控制
void ClearTank   (int x,
                  int y);                 //清除坦克（人机共用）
void PrintTank   (Tank
                  tank);                    //打印坦克（人机共用）
bool TankCheak   (Tank tank,
                  int direction);     //检测坦克dirtection方向的障碍物,返值1阻碍,0 畅通
int  AIPositionCheak (int
                      position);           //检测AI坦克建立位置是否有障碍物AIPositionCheak

//DWORD WINAPI InputX(LPVOID lpParameter); //声明线程函数，用于检查X键输入并设置X键的输入冷却时间


//注意map数组应是纵坐标在前，横坐标在后，既map[y][x]，(∵数组行长度在前，列长度在后)
//map里的值: 个位数的值为地图方块部分，百位数的值为坦克,子弹在map上没有值(子弹仅仅是一个假坐标)
//map里的值: 0为可通过陆地，1为红砖，2黄砖，5为水，100~103为敌方坦克，200为我的坦克，

//全局变量
int map[41][41];  //地图二维数组
int key_x;        // X键是否被“读入”的变量，也是子弹是否可以发射的变，

int bul_num;      //子弹编号
int position;     //位置计数,对应AI坦克生成位置,-1为左位置,0为中间,1为右,2为我的坦克位置
int speed = 8;    //游戏速度,调整用
int level = 1;    //游戏关卡数
int score = 0;    //游戏分数
int remain_enemy; //剩余敌人(未出现的敌人)



char* tank_figure[4][3][4] = {
    {
        {"◢┃◣", "◢━◣", "◢┳◣", "◢┳◣"},
        {"┣●┫", "┣●┫", "━●┃", "┃●━"},
        {"◥━◤", "◥┃◤", "◥┻◤", "◥┻◤"}
    },
    {
        {"┏┃┓", "┏┳┓", "┏┳┓", "┏┳┓"},
        {"┣●┫", "┣●┫", "━●┫", "┣●━"},
        {"┗┻┛", "┗┃┛", "┗┻┛", "┗┻┛"}
    },
    {
        {"┏┃┓", "◢━◣", "┏┳◣", "◢┳┓"},
        {"┣●┫", "┣●┫", "━●┃", "┃●━"},
        {"◥━◤", "┗┃┛", "┗┻◤", "◥┻┛"}
    },
    {
        {"╔┃╗", "╔╦╗", "╔╦╗", "╔╦╗"},
        {"╠█╣", "╠█╣", "━█╣", "╠█━"},
        {"╚╩╝", "╚┃╝", "╚╩╝", "╚╩╝"}
    }
};



int main () {                             //主函数
    int i;
    unsigned int interval[12] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1} ; //间隔计数器数组，用于控制速度
    srand(time(
              NULL)); //设置随机数种子(若不设置种子而调用rand会使每次运行的随机数序列一致)随机数序列指:如首次调用rand得到1,第二次得2,第三次3,则此次随机数序列为1,2,3
    HideCursor();                         //隐藏光标
    system("mode con cols=112 lines=42"); //控制窗口大小
    Frame ();                             //打印游戏主体框架
    Initialize();                         //初始化，全局变量level初值便是1
//    HANDLE h1 , h2 ;                      //定义句柄变量
    for (;;) {
        if (interval[0]++ % speed ==
                0) { //速度调整用,假设interval[0]为a, 语句意为 a % 2==0,a=a+1;
            GameCheak();                  //游戏胜负检测
            BulletFly ( bullet );
            for (i = 0 ; i <= 3 ; i++) {  //AI坦克移动循环
                if (AI_tank[i].model == 2 &&
                        interval[i + 1]++ % 2 == 0) //四个坦克中的快速坦克单独使用计数器1,2,3,4
                    MoveAITank( & AI_tank[i]);
                if (AI_tank[i].model != 2 &&
                        interval[i + 5]++ % 3 == 0) //四个坦克中的慢速坦克单独使用计数器5,6,7,8
                    MoveAITank( & AI_tank[i]);
            }
            for (i = 0; i <= 3; i++)                            //建立AI坦克部分
                if (AI_tank[i].alive == 0 && AI_tank[i].revive < 4 &&
                        interval[9]++ % 90 == 0) { //一个敌方坦克每局只有4条命
                    //如果坦克不存活。计时,每次建立有间隔  1750 ms
                    BuildAITank( &position, & AI_tank[i] );     //建立AI坦克（复活）
                    break;                                      //每次循环只建立一个坦克
                }
            for (i = 0; i <= 3; i++)
                if (AI_tank[i].alive)
                    BuildAIBullet(
                        &AI_tank[i]);                 //AIshoot自带int自增计数CD,不使用main中的CD interval
            if (my_tank.alive && interval[10]++ % 2 == 0 )
                keyboard ();
            if (my_tank.alive == 0 && interval[11]++ % 30 == 0 && my_tank.revive < MAX_LIFE)
                BuildMyTank( &my_tank );
        }
        Sleep(5);
    }
    return 0;
}


/*//这里的多线程暂时不用                   //x键用于子弹发射，x键的冷却时间不能和上下左右一同设置，那样就太快了

DWORD WINAPI InputX(LPVOID lpParameter)    //如果不用多线程运行，那么在x键冷却时间内程序会因Sleep将会挂起，暂停运行

{                                          //因为只有一个变量改变，而且变量改变先后顺序是显而易见的，所以不必设置缓冲区

    for(;;)
    {
        if(GetAsyncKeyState( 88 )& 0x8000) //88为x键键值,当摁下x并且x键处于可输入状态
        {
            key_x=1;                       // X键是否允许被“读入”的变量，也是子弹是否可以发射的变量
            Sleep(600);                    // 子线程Sleep中，x就不能被"读入"，主线程每操作完一次子弹发射，key_x会归零
        }
        Sleep(10);
    }
    return 0;
}*/


void keyboard () {
    // kbhit()   getch()  用法可用但是不好用
    /*

       函数功能:该函数判断在此函数被调用时,某个键是处于UP状态还是处于DOWN状态,及前次调用GetAsyncKeyState函数后,

       是否按过此键.如果返回值的最高位被置位,那么该键处于DOWN状态;如果最低位被置位,那么在前一次调用此函数后,此键被按过,

       否则表示该键没被按过.

       这里GetAsyncKeyState比 kbhit() + getch() 好用,操作更顺畅.   GetAsyncKeyState的返回值表示两个内容，

       一个是最高位bit的值，代表这个键是否被按下。一个是最低位bit的值,代表上次调用GetAsyncKeyState后，这个键是否被按下。

       &为与操作，&0x8000就是判断这个返回值的高位字节。如果high-order bit是1,则是按下状态，否则是弹起状态，为0

    */
    int count = 0;
    if (GetAsyncKeyState(VK_UP) & 0x8000)
        MoveMyTank( UP );
    else if (GetAsyncKeyState(VK_DOWN) & 0x8000)
        MoveMyTank( DOWN );
    else if (GetAsyncKeyState(VK_LEFT) & 0x8000)
        MoveMyTank( LEFT );
    else if (GetAsyncKeyState(VK_RIGHT) & 0x8000)
        MoveMyTank( RIGHT );
    else if (GetAsyncKeyState( 0x1B ) & 0x8000) // Esc键
        exit(0);                                //退出程序函数
    else if (GetAsyncKeyState( 0x20 ) & 0x8000) //空格
        Stop();
    else if (count++ % 7 ==
             0) {      //这里添加计数器是为了防止按键粘连不能达到微调效果
        if (speed > 1 && GetAsyncKeyState( 0x6B ) & 0x8000) { // +键
            speed--;
            GoToxy(102, 11);          //在副屏幕打印出当前速度
            SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                    FOREGROUND_INTENSITY | FOREGROUND_BLUE | FOREGROUND_RED);
            printf("%d ", 31 - speed); //副屏幕显示的速度为1~10
        } else if (speed < 30 && GetAsyncKeyState( 0x6D ) & 0x8000) { // - 键
            speed++;
            GoToxy(102, 11);          //在副屏幕打印出当前速度
            SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                    FOREGROUND_INTENSITY | FOREGROUND_BLUE | FOREGROUND_RED);
            printf("%d ", 31 - speed); //副屏幕显示的速度为1~10
        }
    }
    if (my_tank.CD == 7) {
        if (GetAsyncKeyState( 88 ) & 0x8000) {
            BuildBullet(my_tank);
            my_tank.CD = 0;
//            Sleep(1000);
//            BuildBullet(my_tank);
//            my_tank.CD=0;
        }
    } else
        my_tank.CD += 7;
}



void BuildAIBullet(Tank*
                   tank) { //AI子弹发射(建立)含有对my_tank的读取
    if (tank->CD == 15) {
        if (!(rand() %
                11)) { //冷却结束后在随后的每个游戏周期中有10分之一的可能发射子弹
            BuildBullet(*tank);
            tank->CD = 0;
        }
    } else
        tank->CD++;
    if (tank->CD >=
            14) {    //AI强化部分，在冷却到达一定范围即可使用
        if (tank->y == 38 ) { //如果坦克在底部(这个最优先)
            if (tank->x < 20) { //在老家左边
                if (tank->direction == RIGHT) { //坦克方向朝左
                    BuildBullet(*tank);     //发射子弹
                    tank->CD = 0;
                }
            } else           //在老家右边
                if (tank->direction == LEFT) { //坦克方向朝右
                    BuildBullet(*tank);     //发射子弹
                    tank->CD = 0;
                }
        } else if (tank->x == my_tank.x + 1 || tank->x == my_tank.x ||
                   tank->x == my_tank.x - 1) //AI坦克在纵向上"炮口"对准我的坦克

        {
            if (tank->direction == DOWN && my_tank.y > tank->y || tank->direction == UP &&
                    my_tank.y < tank->y) {
                //若是AI朝下并且我的坦克在AI坦克下方(数值大的在下面)或者AI朝上我的坦克在AI上方
                int big = my_tank.y, smal = tank->y, i;
                if (my_tank.y < tank->y) {
                    big = tank->y;
                    smal = my_tank.y;
                }
                for (i = smal + 2; i <= big - 2;
                        i++) //判断AI炮口的直线上两坦克间有无障碍
                    if (map[i][tank->x] != 0 || map[i][tank->x] != 5) //若有障碍
                        break;
                if (i == big - 1) {         //若i走到big-1说明无障碍
                    BuildBullet(*tank);     //则发射子弹
                    tank->CD = 0;
                }
            }
        } else if (tank->y == my_tank.y + 1 || tank->y == my_tank.y ||
                   tank->y == my_tank.y - 1) { //AI坦克在横向上"炮口"对准我的坦克
            if (tank->direction == RIGHT && my_tank.x > tank->x ||
                    tank->direction == LEFT && my_tank.x < tank->x) {
                //若是AI朝右并且我的坦克在AI坦克右方(数值大的在下面)或者AI朝左我的坦克在AI左方
                int big = my_tank.y, smal = tank->y, i;
                if (my_tank.x < tank->x) {
                    big = tank->x;
                    smal = my_tank.x;
                }
                for (i = smal + 2; i <= big - 2;
                        i++) //判断AI炮口的直线上两坦克间有无障碍
                    if (map[tank->y][i] != 0 || map[tank->y][i] != 5) //若有障碍
                        break;
                if (i == big - 1) { //若i走到big-1说明无障碍
                    BuildBullet(*tank);     //则发射子弹
                    tank->CD = 0;
                }
            }
        }
    }
}







void BuildBullet(Tank
                 tank)  //子弹发射（建立）,传入结构体Tank,这里包含改变了全局变量结构体bullet

{
    //∵实现方式为顺序循环建立子弹，每次调用改变的bullet数组元素都不同

    switch (tank.direction) { //∴为了方便,不将bullet放入参数,bullet作为全局变量使用
        case UP    :
            bullet [bul_num].x = tank.x;
            bullet [bul_num].y = tank.y - 2;
            bullet [bul_num].direction = 1;
            break;
        case DOWN  :
            bullet [bul_num].x = tank.x;
            bullet [bul_num].y = tank.y + 2;
            bullet [bul_num].direction = 2;
            break;
        case LEFT  :
            bullet [bul_num].x = tank.x - 2;
            bullet [bul_num].y = tank.y;
            bullet [bul_num].direction = 3;
            break;
        case RIGHT :
            bullet [bul_num].x = tank.x + 2;
            bullet [bul_num].y = tank.y;
            bullet [bul_num].direction = 4;
            break;
    }
    bullet [bul_num].exist = 1;    //子弹被建立,此值为1则此子弹存在
    bullet [bul_num].initial = 1;  //子弹处于初建立状态
    bullet [bul_num].my =
        tank.my; //如果是我的坦克发射的子弹bullet.my=1，否则为0
    bul_num++;
    if (bul_num ==
            BULLET_NUM)     //如果子弹编号增长到20号，那么重头开始编号
        bul_num = 0;               //考虑到地图上不可能同时存在20颗子弹，所以数组元素设置20个
}





void BulletFly(Bullet bullet[BULLET_NUM]) { //子弹移动和打击
    //含有全局变量Bullet的改变
    for (int i = 0; i < BULLET_NUM; i++) {
        if (bullet [i].exist) {           //如果子弹存在
            if (bullet [i].initial == 0) { //如果子弹不是初建立的
                if (map[bullet[i].y] [bullet[i].x] == 0 ||
                        map[bullet[i].y] [bullet[i].x] == 5)   //如果子弹坐标当前位置无障碍
                    ClearBullet( bullet[i].x, bullet[i].y, BulletCheak(bullet[i].x,
                                 bullet[i].y ));     //抹除子弹图形
                switch (bullet [i].direction) {                                   //然后子弹坐标变化（子弹变到下一个坐标）
                    case UP    :
                        (bullet [i].y)--;
                        break;
                    case DOWN  :
                        (bullet [i].y)++;
                        break;
                    case LEFT  :
                        (bullet [i].x)--;
                        break;
                    case RIGHT :
                        (bullet [i].x)++;
                        break;
                }
            }
            int collide = BulletCheak ( bullet [i].x,
                                        bullet [i].y );    //判断子弹当前位置情况,判断子弹是否碰撞,是否位于水面上。
            if ( collide )                                               //如果检测到当前子弹坐标无障碍(无碰撞)（包括在地面上与在水面上）
                PrintBullet( bullet[i].x, bullet[i].y,
                             collide);         //则打印子弹，若有碰撞则不打印
            else
                BulletHit( &
                           bullet [i] );     //若有碰撞则执行子弹碰撞函数
            if (bullet [i].initial)            //若子弹初建立，则把初建立标记去除
                bullet [i].initial = 0;
            for (int j = 0; j < BULLET_NUM ;
                    j++) //子弹间的碰撞判断,若是我方子弹和敌方子弹碰撞则都删除,若为两敌方子弹则无视
                if (bullet [j].exist && j != i && (bullet[i].my || bullet[j].my) &&
                        bullet[i].x == bullet[j].x &&
                        bullet[i].y == bullet[j].y) {
                    //同样的两颗我方子弹不可能产生碰撞
                    bullet [j].exist = 0;
                    bullet [i].exist = 0;
                    ClearBullet( bullet[j].x, bullet[j].y, BulletCheak(bullet[j].x,
                                 bullet[j].y ));  //抹除j子弹图形,子弹i图形已被抹除
                    break;
                }
        }
    }
}


void BulletHit(Bullet*
               bullet) { //含有Tank全局变量的修改,子弹间的碰撞不在本函数,子弹间碰撞已在BulletShoot中检测并处理
    //∵每次打中的坦克都不一样，不可能把所有坦克放在参数表中
    int x = bullet->x;          //∴这里的Tank使用全局变量
    int y = bullet->y;          //这里传入的值是子弹坐标,这两个值不需要改变
    int i;
    if (map[y][x] == 1 || map[y][x] == 2 || map[y][x] == 6 ) { //子弹碰到砖块
        if (bullet->direction == UP ||
                bullet->direction == DOWN) //如果子弹是纵向的
            for (i = -1 ; i <= 1 ; i++)
                if (map[y][x + i] == 1 || map[y][x + i] == 2 ||
                        map[y][x] ==
                        6 ) { //如果子弹打中砖块两旁为砖块,则删除砖,若不是(一旁为坦克或其他地形)则忽略
                    map[y][x + i] = 0; //砖块碎
                    GoToxy(2 * x + 2 * i, y);
                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                            FOREGROUND_RED); //背景黑色

                    printf("  ");
                }
        if (bullet->direction == LEFT ||
                bullet->direction == RIGHT) //若子弹是横向的  (与子弹纵向实现同理)
            for (i = -1 ; i <= 1 ; i++)
                if (map[y + i][x] == 1 || map[y + i][x] == 2 || map[y][x] == 6 ) {
                    map[y + i][x] = 0;
                    GoToxy(2 * x, y + i);
                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                            FOREGROUND_RED); //背景黑色
                    printf("  ");
                }
        bullet->exist = 0;         //这颗子弹已经不存在了
    } else if (map[y][x] == 4 ||
               map[y][x] == 6 ) //子弹碰到边框或者不可摧毁方块
        bullet->exist = 0;
    else if (bullet->my && map[y][x] >= 100 &&
             map[y][x] < 104 ) { //若我的子弹碰到了敌方坦克
        int num = map[y][x] %
                  100; //map[y][x]%100 等同于 tank.num ，可通过map值读取该坦克信息
        if (AI_tank[num].model == 3 &&
                AI_tank[num].color == 2) //若为firm tank,且color==2。该坦克为绿色,表明没有受到伤害
            AI_tank[num].color =
                3;                      //则变成黄色，color=3为黄色
        else if (AI_tank[num].model == 3 && AI_tank[num].color == 3)
            AI_tank[num].color = 4;                      //4为红色
        else {                     //其他类型的坦克或者firm tank为红色的情况
            AI_tank[num].alive = 0;
            ClearTank(AI_tank[num].x, AI_tank[num].y);       //清除该坦克
        }
        bullet->exist = 0;
        score += 100;
        GoToxy(102, 5);            //在副屏幕上打印出分数
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        printf("%d ", score);
    } else if (map[y][x] == 200 &&
               bullet->my == 0 ) { //若敌方子弹击中我的坦克
        //my_tank.alive=0;
        //ClearTank(my_tank.x , my_tank.y);
        //bullet->exist=0;
        my_tank.revive++;      //我的坦克复活次数+1(∵我的坦克复活次数与生命值有关∴放在这里自减)
        // score+=100;            //分数减少
        GoToxy(102, 5);        //在副屏幕上打印出分数
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        printf("%d   ", score);
        GoToxy(102, 7);        //在副屏幕打印出我的剩余生命值
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                FOREGROUND_INTENSITY | FOREGROUND_GREEN);
        printf("%d   ", MAX_LIFE - my_tank.revive);
    }
//    else if(bullet->my==0 && map[y][x]>=100 && map[y][x]<104) //敌方子弹击中敌方坦克,可以设置两种子弹运行方式,这种暂时不用

//        bullet->exist=0;

    else if (map[y][x] == 9) { //子弹碰到家(无论是谁的子弹)
        bullet->exist = 0;
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                FOREGROUND_BLUE | FOREGROUND_RED | FOREGROUND_GREEN);
        GoToxy(38, 37);
        printf("      ");
        GoToxy(38, 38);
        printf("◢◣  ");
        GoToxy(38, 39);
        printf("███");
        GameOver(1);           //游戏结束,传入1代表老家被毁
    }
}





int BulletCheak (int x, int
                 y) //判断子弹当前位置情况,判断子弹是否碰撞,是否位于水面上。

{
    //有障碍返回0,无障碍且子弹在地面返回1，子弹在水面上返回2

    if (map[y][x] == 0)
        return 1;
    else if (map[y][x] == 5)
        return 2;
    else
        return 0;
}





void PrintBullet (int x, int y,
                  int T) //当前坐标BulletCheak 的值做参量 T

{

    if (T == 1)       //  T==1 表示子弹当前坐标在陆地上
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY);
    else if (T == 2)  //  T==2 表示子弹当前坐标在水面上
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY |
                                BACKGROUND_BLUE);
    GoToxy(2 * x, y);
    printf("●");
}





void ClearBullet(int x, int y,
                 int T) //当前坐标BulletCheak 的值做参量 T

{

    GoToxy(2 * x, y);
    if (T == 2) {   //  T==2 表示子弹当前坐标在水面上
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                FOREGROUND_INTENSITY | BACKGROUND_BLUE | FOREGROUND_BLUE | FOREGROUND_GREEN);
        printf("～");
    } else if (T == 1) { //  T==1 表示子弹当前坐标在陆地上
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_BLUE);
        printf("●");
    }
}





//position为坦克生成位置,-1为左位置,0为中间,1为右,2为我的坦克位置

void BuildAITank(int* position,
                 Tank* AI_tank) { //执行一次该函数只建立一个坦克
    //rand函数公式：0<=rand()%(a+1)<=a  0+m<=rand()%(n-m+1)+m<=n
    //rand函数实现1到n：1<=rand()%(n)+1<=n
    if (AIPositionCheak(
                *position)) {     //若此位置无障碍,可生成。position参数详见AIPositionCheak函数定义
        AI_tank->x = 20 + 18 *
                     (*position); //20 + 18 * position 对应三个生成位置的x假坐标
        AI_tank->y = 2;
        if (AI_tank->revive == level_info[level -
                                                1].firm_tank_order) { //坦克出现(复活)次序==关卡信息(level_info)中firm tank的出现次序
            AI_tank->model = 3;           //3为firm tank的模型(外观)
            AI_tank->color =
                2;           //颜色参数2为绿色，具体详见函数ColorChoose
        } else if (AI_tank->revive == level_info[level -
                         1].fast_tank_order) { //同上if，这里是fast_tank的
            AI_tank->model = 2;
            AI_tank->color = rand() % 6 +
                             1; //若不是firm tank则随机颜色，颜色参数为1~6,分别代表不同颜色,详见函数ColorChoose
        } else {  //普通坦克
            AI_tank->model = 1;
            AI_tank->color = rand() % 6 + 1; //若不是firm tank则随机颜色
        }
        AI_tank->alive = 1;       //坦克变为存在
        AI_tank->direction = 2 ;  //方向朝下
        AI_tank->revive++;        //复活次数+1
        PrintTank(*AI_tank);
        (*position)++;
        remain_enemy--;

        GoToxy(102, 9);           //在副屏幕上打印剩余坦克数
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                FOREGROUND_INTENSITY | FOREGROUND_RED);
        printf("%d ", remain_enemy);
        if (*position ==
                2)       //position只能为0,1，-1，这里position循环重置
            *position = -1;
        return ;                  //若生成了一辆坦克，则结束该函数
    }
}





int AIPositionCheak( int
                     position )    //position为坦克生成位置2为我的坦克位置，其余为AI位，-1为左位，0为中间位置，1为右位

{

    int    x, y;
    if (position ==
            2)                 //2为我的坦克位置，现在暂时用不到
        x = 15, y = 38;
    else
        y = 2, x = 20 + 18 * position
                   ; //20 + 18 * position 对应三个生成位置的x假坐标
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            if ( map[y + j - 1][x + i - 1] != 0) //如果遍历的九宫格里有障碍物
                return 0;              //则返回0，表示此生成位置有阻碍
    return 1;                          //否则生成1，表示此生成位置无阻碍
}





void MoveAITank(Tank* AI_tank) { //AI专用函数，该函数主要为AI加强
    if (AI_tank->alive) {      //如果坦克活着
        if (AI_tank->stop !=
                0) { //坦克是否停止运动的判断，若stop参数不为0
            AI_tank->stop--;   //则此坦克本回合停止运动
            return;
        }
        if ( !(rand() % 23) ) { //22分之1的概率执行方向重置
            AI_tank->direction = rand() % 4 + 1;
            if ( rand() %
                    3 ) { //在方向重置后有2分之1的概率停止走动3步的时间
                AI_tank->stop = 2;
                return;
            }
        }
        ClearTank (AI_tank->x, AI_tank->y);
        if (TankCheak ( *AI_tank, AI_tank->direction))   //如果前方无障碍

            switch ( AI_tank->direction ) {
                case UP   :
                    AI_tank->y--;
                    break;  //上前进一格
                case DOWN :
                    AI_tank->y++;
                    break;  //下前进一格
                case LEFT :
                    AI_tank->x--;
                    break;  //左前进一格
                case RIGHT:
                    AI_tank->x++;
                    break;  //右前进一格
            } else {                 //前方有障碍
            if (!(rand() % 4)) { //3分之1的概率乱转
                AI_tank->direction = rand() % 4 + 1;
                AI_tank->stop = 2; //乱转之后停止走动3步的时间
                PrintTank(*AI_tank);
                return;          //∵continue会跳过下面的打印函数,∴这里先打印
            } else {             //另外3分之2的几率选择正确的方向
                int j;
                for (j = 1; j <= 4; j++)
                    if (TankCheak ( *AI_tank,
                                    j ))  //循环判断坦克四周有无障碍,此函数返值1为可通过
                        break;
                if (j == 5) {    //j==5说明此坦克四周都有障碍物，无法通行
                    PrintTank(*AI_tank);
                    return;      //则跳过下面的while循环以防程序卡死
                }
                while (TankCheak ( *AI_tank,
                                   AI_tank->direction) == 0)  //如果前方仍有障碍
                    AI_tank->direction = (rand() % 4 +
                                          1);              //则换个随机方向检测
            }
        }
        PrintTank(*AI_tank);     //打印AI坦克
    }
}





void BuildMyTank (Tank* my_tank) { //建立我的坦克
    my_tank->x = 15;
    my_tank->y = 38;
    my_tank->stop = NULL;
    my_tank->direction = 1;
    my_tank->model = 0;
    my_tank->color = 1;
    my_tank->alive = 1;
    my_tank->my = 1;
    my_tank->CD = 7;
    PrintTank (*my_tank) ;   //打印我的坦克
}


void MoveMyTank(int
                turn ) { //玩家专用函数，turn为keyboard函数里因输入不同方向键而传入的不同的值
    ClearTank(my_tank.x,
              my_tank.y);         //map 数组中“我的坦克”参数清除工作已在此函数中完成
    my_tank.direction =
        turn;                //将键盘输入的方向值传入我的坦克方向值

    if (TankCheak ( my_tank,
                    my_tank.direction ))  //若此时我的坦克当前方向上无障碍
        switch (turn) {
            case UP   :
                my_tank.y--;
                break;  //上前进一格
            case DOWN :
                my_tank.y++;
                break;  //下前进一格
            case LEFT :
                my_tank.x--;
                break;  //左前进一格
            case RIGHT:
                my_tank.x++;
                break;  //右前进一格
        }                                        //若坦克当前方向上有障碍则跳过坐标变化直接打印该转向的坦克
    PrintTank (my_tank);
}





bool TankCheak(Tank tank,
               int direction) //检测坦克前方障碍函数,参量为假坐标。返值1为可通过,返值0为阻挡(人机共用)

{

    switch (direction) {                 //direction变量   1上，2下，3左，4右
        case UP:
            if (map[tank.y - 2][tank.x] == 0 && map[tank.y - 2][tank.x - 1] == 0 &&
                    map[tank.y - 2][tank.x + 1] == 0)
                return 1;
            else
                return 0;
        case DOWN:
            if (map[tank.y + 2][tank.x] == 0 && map[tank.y + 2][tank.x - 1] == 0 &&
                    map[tank.y + 2][tank.x + 1] == 0)
                return 1;
            else
                return 0;
        case LEFT:
            if (map[tank.y][tank.x - 2] == 0 && map[tank.y - 1][tank.x - 2] == 0 &&
                    map[tank.y + 1][tank.x - 2] == 0)
                return 1;
            else
                return 0;
        case RIGHT:
            if (map[tank.y][tank.x + 2] == 0 && map[tank.y - 1][tank.x + 2] == 0 &&
                    map[tank.y + 1][tank.x + 2] == 0)
                return 1;
            else
                return 0;
        default:
            printf("错误！！");
            Sleep(5000);
            return 0;
    }
}





void ClearTank(int x, int y)  //清除坦克函数（人机共用）

{

    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++) {
            //将坦克占用的地图上的九格去掉
            map[y + j - 1][x + i - 1] = 0;
            SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_GREEN);
            GoToxy(2 * x + 2 * j - 2, y + i - 1);
            printf("  ");
        }
}





void PrintTank(Tank
               tank)     //打印坦克（人机共用） 由于读取的Tank参数较多,故就不将参数一一传入了

{
    // tank.color参数对应不同的颜色,范围 1 ~ 6

    ColorChoose(
        tank.color);  //颜色选择函数   定义一个数组里装着字符指针(既装字符串)的数组指针(指向一维数组首地址的指针)
    char* (*tankF)[4] =
        tank_figure[tank.model];  //将二维数组首址赋初值给数组指针 model==0为我的坦克,4为电脑1坦克,8为电脑2,类推
    for (int i = 0; i < 3; i++) {
        GoToxy((tank.x - 1) * 2,
               tank.y - 1 + i); //在坦克中心坐标的左边，上中下三行打印
        printf("%s", tankF[i][tank.direction -
                              1]); //打印的是地址，地址既字符串
        for (int j = 0; j < 3; j++)
            if (tank.my)      //若为我的坦克
                map[tank.y + j - 1][tank.x + i - 1] =
                    200; //在map上把"坦克"九格填满代表敌我坦克的参数。敌方此值为100~103,我方为200
            else
                map[tank.y + j - 1][tank.x + i - 1] = 100 +
                                                      tank.num; //这样可以通过map值读取坦克编号,读取操作在BulletHit 函数
    }
}





void HideCursor()  //隐藏光标

{
    //CONSOLE_CURSOR_INFO结构体包含控制台光标的信息,DWORD dwSize光标百分比厚度（1~100）和BOOL bVisible光标是否可见

    CONSOLE_CURSOR_INFO cursor_info = {1, 0};
    SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE),
                         &cursor_info); //SetConsoleCursorInfo用来设置指定的控制台光标的大小和可见性。
}





void GoToxy(int x, int
            y) { //光标移动函数，X表示横坐标，Y表示纵坐标。

    COORD  coord;         //使用头文件自带的坐标结构
    coord.X = x;          //这里将int类型值传给short,不过程序中涉及的坐标值均不会超过short范围
    coord.Y = y;
    HANDLE a = GetStdHandle(STD_OUTPUT_HANDLE); //获得标准输出句柄
    SetConsoleCursorPosition(a,
                             coord);        //以标准输出的句柄为参数设置控制台光标坐标
}





void ColorChoose(int color)   //颜色选择函数

{

    switch (color) {
        case 1:               //天蓝色(我的坦克颜色)
            SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                    FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_BLUE);
            break;
        case 2:               //绿色
            SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                    FOREGROUND_INTENSITY | FOREGROUND_GREEN);
            break;
        case 3:               //黄色
            SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                    FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN);
            break;
        case 4:               //红色
            SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                    FOREGROUND_INTENSITY | FOREGROUND_RED);
            break;
        case 5:               //紫色
            SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                    FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_BLUE);
            break;
        case 6:               //白色
            SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                    FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN);
            break;
        case 7:               //深蓝色(∵颜色深难与黑色背景辨识度不高 ∴坦克颜色不选用此颜色),只用在字体颜色闪烁中
            SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                    FOREGROUND_INTENSITY | FOREGROUND_BLUE);
            break;
    }
}





void Stop()    //暂停

{

    int color = 1, timing = 0;
    while (1) {
        if (timing++ % 30 == 0) {
            ColorChoose(color);   //颜色选择
            GoToxy(100, 13);      //副屏幕打印
            printf("游戏暂停");
            GoToxy(88, 17);
            printf("按回车键回到游戏");
            GoToxy(88, 18);
            printf("或按 Esc键退出游戏");
            if (++color == 8)
                color = 1;
        }
        if (GetAsyncKeyState( 0xD ) & 0x8000) {   //回车键
            GoToxy(100, 13);      //副屏幕打印
            SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                    FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_BLUE);
            printf("正在进行");   //覆盖掉原来的提示
            GoToxy(88, 17);
            printf("                     ");
            GoToxy(88, 18);
            printf("                     ");
            break;
        } else if (GetAsyncKeyState( 0x1B ) & 0x8000) //Esc键退出
            exit(0);
        Sleep(20);
    }
}





void ClearMainScreen()  //主屏幕清屏函数，因使用system("cls");再打印框架有一定几率造成框架上移一行的错误，所以单独编写清屏函数

{

    for (int i = 1; i < 40; i++) {
        GoToxy(2, i);
        printf("                                                                              ");
    }
}





void Frame ()     //打印游戏主体框架

{
    //SetConsoleTextAttribute为设置文本颜色和文本背景颜色函数

    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY);
    printf("  ▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁  ");
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_INTENSITY | FOREGROUND_BLUE);
    printf("  ▂▂▂▂▂▂▂▂▂▂▂▂▂ \n");
    for (int i = 0; i < 14; i++) {
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                FOREGROUND_GREEN | FOREGROUND_INTENSITY | FOREGROUND_RED |
                                FOREGROUND_INTENSITY);
        printf("▕                                                                              ▏");
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                FOREGROUND_INTENSITY | FOREGROUND_BLUE);
        printf(" |                          |\n");
    }
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_GREEN | FOREGROUND_INTENSITY | FOREGROUND_RED |
                            FOREGROUND_INTENSITY);
    printf("▕                                                                              ▏");
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_INTENSITY | FOREGROUND_BLUE);
    printf(" |═════════════|\n");
    for (int i = 0; i < 24; i++) {
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                FOREGROUND_GREEN | FOREGROUND_INTENSITY | FOREGROUND_RED |
                                FOREGROUND_INTENSITY);
        printf("▕                                                                              ▏");
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                FOREGROUND_INTENSITY | FOREGROUND_BLUE);
        printf(" |                          |\n");
    }
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_GREEN | FOREGROUND_INTENSITY | FOREGROUND_RED |
                            FOREGROUND_INTENSITY);
    printf("  ▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔  ");
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_INTENSITY | FOREGROUND_BLUE);
    printf(" ﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊﹊\n");
    SideScreen ();  //打印副屏幕
}





void PrintMap()     // 打印地图(地图既地图障碍物)

{

    for (int j = 0; j < 41; j++)
        for (int i = 0; i < 41; i++)
            if (map[i][j] == 6) {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                        FOREGROUND_INTENSITY | FOREGROUND_GREEN
                                        | FOREGROUND_RED | FOREGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED |
                                        BACKGROUND_BLUE);
                GoToxy(2 * j, i);
                printf("■");
            } else if (map[i][j] == 2) {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                        FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | BACKGROUND_GREEN |
                                        BACKGROUND_RED);
                GoToxy(2 * j, i);
                printf("▓");
            } else if (map[i][j] == 1) {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                        FOREGROUND_INTENSITY | FOREGROUND_RED | BACKGROUND_GREEN | BACKGROUND_RED);
                GoToxy(2 * j, i);
                printf("▓");
            } else if (map[i][j] == 5) {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                        FOREGROUND_INTENSITY | BACKGROUND_BLUE | FOREGROUND_BLUE | FOREGROUND_GREEN);
                GoToxy(2 * j, i);
                printf("～");
            }
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_BLUE | FOREGROUND_RED | FOREGROUND_GREEN);
    GoToxy(38, 37);
    printf("◣◢");
    GoToxy(38, 38);
    printf("███");    //∵无论地图怎么变,家所在位置不变,且家的字符多种,不方便用上述方式打印
    GoToxy(38, 39);
    printf("◢█◣");    //∴直接打印(且家的map值与符号无关)
}





void GetMap() {    //地图存放函数
    //map里的值: 个位数的值为地图方块部分，百位数的值为坦克
    int i, j;      //map里的值: 0为可通过陆地，1为红砖，2待定，5为水，100为敌方坦克，200为我的坦克，
    int Map[8][41][41] = {
        {
            {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5, 5, 5, 5, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 6, 6, 6, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 9, 9, 9, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 9, 9, 9, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 9, 9, 9, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4}
        },
        {
            {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 0, 0, 0, 2, 2, 2, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 0, 0, 0, 2, 2, 2, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 0, 0, 0, 2, 2, 2, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 6, 6, 6, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 6, 6, 6, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 6, 6, 6, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 6, 6, 6, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 6, 6, 6, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 6, 6, 6, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 6, 6, 6, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 6, 6, 6, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 6, 6, 6, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 4},
            {4, 6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 4},
            {4, 6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 4},
            {4, 6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 4},
            {4, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 6, 4},
            {4, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 6, 4},
            {4, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 0, 0, 0, 0, 6, 6, 6, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 6, 6, 6, 6, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 6, 6, 6, 6, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 6, 6, 6, 6, 4},
            {4, 2, 2, 2, 0, 0, 0, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 4},
            {4, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 4},
            {4, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 9, 9, 9, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 9, 9, 9, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 9, 9, 9, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 4},
            {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4}
        },
        {
            {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 4},
            {4, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 4},
            {4, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 6, 6, 6, 6, 6, 6, 0, 6, 6, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 6, 6, 6, 6, 6, 6, 0, 6, 6, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 4},
            {4, 6, 6, 6, 6, 6, 6, 0, 6, 6, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 5, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 5, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 5, 0, 1, 6, 6, 1, 6, 1, 6, 6, 1, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 5, 5, 0, 0, 1, 1, 1, 6, 1, 1, 1, 0, 0, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 9, 9, 9, 1, 1, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 4},
            {4, 0, 0, 0, 6, 6, 6, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 6, 6, 9, 9, 9, 6, 6, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 4},
            {4, 0, 0, 0, 6, 6, 6, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 6, 6, 9, 9, 9, 6, 6, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 4},
            {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4}
        },
        {
            {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 4},
            {4, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 5, 5, 5, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 6, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 5, 5, 5, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 6, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 5, 5, 5, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 6, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 1, 1, 1, 1, 1, 1, 1, 6, 1, 1, 1, 4},
            {4, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 0, 1, 1, 1, 1, 1, 1, 0, 0, 6, 1, 1, 1, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 0, 1, 1, 1, 1, 1, 6, 6, 6, 6, 1, 1, 1, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 0, 1, 1, 1, 1, 1, 6, 1, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 1, 1, 1, 6, 6, 6, 6, 6, 6, 1, 1, 1, 6, 6, 6, 6, 6, 6, 6, 6, 1, 6, 6, 0, 0, 0, 4},
            {4, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 1, 1, 1, 1, 1, 9, 9, 9, 6, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 4},
            {4, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 1, 1, 1, 1, 1, 9, 9, 9, 6, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 4},
            {4, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 1, 1, 1, 1, 1, 9, 9, 9, 6, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 4},
            {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4}
        },
        {
            {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 9, 9, 9, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 9, 9, 9, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 9, 9, 9, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4}
        },
        {
            {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 4},
            {4, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 4},
            {4, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 4},
            {4, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 4},
            {4, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 4},
            {4, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 4},
            {4, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 4},
            {4, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 4},
            {4, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2, 6, 6, 6, 6, 6, 6, 2, 2, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 4},
            {4, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 6, 6, 6, 6, 6, 6, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 4},
            {4, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 6, 6, 6, 6, 6, 6, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 4},
            {4, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 1, 1, 1, 0, 0, 1, 1, 1, 1, 4},
            {4, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4},
            {4, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 6, 6, 6, 6, 6, 1, 1, 1, 6, 6, 6, 6, 6, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 4},
            {4, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 6, 6, 6, 6, 6, 1, 1, 1, 6, 6, 6, 6, 6, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 4},
            {4, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 6, 6, 6, 6, 6, 6, 1, 1, 1, 6, 6, 6, 6, 6, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 6, 6, 6, 0, 0, 0, 1, 1, 1, 0, 0, 0, 6, 6, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 6, 6, 6, 0, 0, 0, 1, 1, 1, 0, 0, 0, 6, 6, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 6, 6, 6, 0, 0, 0, 1, 1, 1, 0, 0, 0, 6, 6, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 4},
            {4, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 6, 6, 6, 6, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 4},
            {4, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 6, 6, 6, 6, 6, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 4},
            {4, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 4},
            {4, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 4},
            {4, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 4},
            {4, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 9, 9, 9, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 9, 9, 9, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 9, 9, 9, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4}
        },
        {
            {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 6, 6, 6, 4},
            {4, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 6, 6, 6, 4},
            {4, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 6, 6, 6, 4},
            {4, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 6, 6, 6, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 4},
            {4, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 6, 6, 6, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 4},
            {4, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 6, 6, 6, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 4},
            {4, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 1, 1, 1, 0, 0, 0, 4},
            {4, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 1, 1, 1, 0, 0, 0, 4},
            {4, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 1, 1, 1, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 4},
            {4, 0, 0, 0, 6, 6, 6, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 4},
            {4, 0, 0, 0, 6, 6, 6, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 4},
            {4, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 4},
            {4, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 4},
            {4, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 1, 1, 1, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 1, 1, 1, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 1, 1, 1, 4},
            {4, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 6, 6, 6, 0, 0, 0, 0, 0, 0, 4},
            {4, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 9, 9, 9, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 4},
            {4, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 9, 9, 9, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 4},
            {4, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 9, 9, 9, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 4},
            {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4}
        },
        {
            {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 1, 1, 1, 5, 5, 5, 5, 5, 5, 0, 0, 0, 6, 6, 6, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 1, 1, 1, 5, 5, 5, 5, 5, 5, 0, 0, 0, 6, 6, 6, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 1, 1, 1, 5, 5, 5, 5, 5, 5, 0, 0, 0, 6, 6, 6, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 6, 6, 6, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 1, 1, 1, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 1, 1, 1, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 1, 1, 1, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 5, 5, 5, 5, 5, 5, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 5, 5, 5, 5, 5, 5, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 5, 5, 5, 5, 5, 5, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 4},
            {4, 0, 0, 0, 1, 1, 1, 5, 5, 5, 5, 5, 5, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 1, 1, 1, 5, 5, 5, 5, 5, 5, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 1, 1, 1, 5, 5, 5, 5, 5, 5, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 6, 6, 6, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 4},
            {4, 6, 6, 6, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 4},
            {4, 6, 6, 6, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
            {4, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 9, 9, 9, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 6, 6, 6, 0, 0, 0, 4},
            {4, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 9, 9, 9, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 6, 6, 6, 0, 0, 0, 4},
            {4, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 9, 9, 9, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 6, 6, 6, 0, 0, 0, 4},
            {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4}
        },
    };
    int a = rand() % 8;
    for (i = 0; i < 41; i++)
        for (j = 0; j < 41; j++)
            map[i][j] = Map[a][i][j];
    PrintMap();         //打印地图
}





void GameOver(bool home)

{

    int timing = 0, color = 1;
    while (1) {
        if (timing++ % 30 == 0) {  //游戏结束原因为生命值为0
            ColorChoose(color);    //颜色选择
            if (home) {            //游戏结束原因为老家被毁,则多打印一行字以提示玩家
                GoToxy(37, 19);    //主屏幕中心打印
                printf("老家被毁!");
            }
            GoToxy(37, 20);        //主屏幕中心打印
            printf("游戏结束!");
            GoToxy(100, 13);       //副屏幕打印
            printf("游戏结束");
            GoToxy(88, 17);
            printf("请按回车键重新开始!");
            GoToxy(88, 18);
            printf("或按 Esc键退出游戏!");
            if (++color == 8)
                color = 1;
        }
        if (GetAsyncKeyState( 0xD ) & 0x8000) { //回车键
//            system("cls");       //清屏,这里清屏后再次打印框架有一定几率造成框架上移一行的bug，因此选用自建清屏函数

//            Frame ();            //重新打印游戏框架

            score -= 500;        //分数-500
            ClearMainScreen();   //主屏清屏函数，无需再次打印框架
            Initialize();        //从本关重新开始
            break;
        } else if (GetAsyncKeyState( 0x1B ) & 0x8000) //Esc键退出
            exit(0);
        Sleep(20);
    }
}





void NextLevel()

{

    int timing = 0, color = 1;
    level++;
    if (level <= MAX_LEVEL)
        while (1) {
            if (timing++ % 10 == 0) {
                ColorChoose(color);   //颜色选择
                GoToxy(37, 20);       //主屏幕中心打印
                printf("恭喜过关!");
                GoToxy(100, 13);      //副屏幕打印
                printf("等待下关");
                GoToxy(87, 17);
                printf("请按回车键进入下一关!");
                GoToxy(88, 18);
                printf("或按 Esc键退出游戏!");
                if (++color == 8)
                    color = 1;
            }
            if (GetAsyncKeyState( 0xD ) & 0x8000) { //回车键
                GoToxy(88, 17);       //抹除副屏幕中的提示
                printf("                     ");
                GoToxy(88, 18);
                printf("                     ");
                ClearMainScreen();   //主屏清屏函数，无需再次打印框架
                Initialize();        //初始化从下一关开始,level已++
                break;
            } else if (GetAsyncKeyState( 0x1B ) & 0x8000) //Esc键退出
                exit(0);
            Sleep(20);
        } else //level>8 通关
        while (1) {
            if (timing++ % 5 == 0) {
                ColorChoose(color);
                GoToxy(33, 20);       //主屏幕中心打印
                printf("恭喜通过全部关卡!");
                GoToxy(100, 13);      //副屏幕打印
                printf("已通全关");
                GoToxy(88, 17);
                printf("恭喜通过全部关卡!");
                GoToxy(88, 19);
                printf("按 Esc键退出游戏!");
                if (++color == 8)
                    color = 1;
            }
            if (GetAsyncKeyState( 0x1B ) & 0x8000) //Esc键退出
                exit(0);
            Sleep(10);
        }
}





void GameCheak()

{
    //剩余敌人为0且四坦克全部不存活

    if (remain_enemy <= 0 && !AI_tank[0].alive && !AI_tank[1].alive &&
            !AI_tank[2].alive && !AI_tank[3].alive )
        NextLevel();        //进入下一关
    if (my_tank.revive >=
            MAX_LIFE) //我的生命值(复活次数)全部用完 MAX_LIFE
        GameOver(0);        //游戏结束，传入0代表我的复活次数用光(生命值为0)。游戏结束有两种判断，另一种是老家被毁
}





void SideScreen ()  //副屏幕 行(84起,110末,若双字符宽则在108打印最后一个字）列(11上屏末,13下屏初,39下屏末。为美观最好打在38)

{
    // |         第  d  关         |   " |                          |\n"

    GoToxy(93, 2);
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED);
    printf("第     关");
    GoToxy(92, 5);
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE);
    printf("分  数：");
    GoToxy(92, 7);
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_INTENSITY | FOREGROUND_GREEN);
    printf("生  命：");
    GoToxy(86, 9);
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_INTENSITY | FOREGROUND_RED);
    printf("剩余敌方坦克：");
    GoToxy(86, 11);
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_BLUE);
    printf("当前游戏速度：  %d", 31 - speed);
    GoToxy(86, 13);
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_BLUE);
    printf("当前游戏状态：");
    GoToxy(94, 19);
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED);
    GoToxy(94, 25);
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED);
    /*printf("帮  助");
    GoToxy(86,27);
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_GREEN);
    printf("方向键  ←↑→↓  移动");
    GoToxy(93,29);
    printf("x 键 射击");
    GoToxy(89,31);
    printf("+ - 调整游戏速度");
    GoToxy(90,33);
    printf("游戏速度范围1~20");
    GoToxy(90,35);
    printf("回车键 暂停游戏");
    GoToxy(90,37);
    printf("Esc键  退出游戏");*/
    printf("帮  助");     //这是第二种详细说明的样式
    GoToxy(86, 19);
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_INTENSITY | FOREGROUND_GREEN);
    printf("方向键  ←↑→↓  移动");
    GoToxy(93, 21);
    printf("x 键 射击");
    GoToxy(89, 25);
    printf("+ - 调整游戏速度");
    GoToxy(90, 27);
    printf("游戏速度范围1~20");
    GoToxy(90, 29);
    printf("回车键 暂停游戏");
    GoToxy(90, 31);
    printf("Esc键  退出游戏");
    GoToxy(86, 33);
    printf("敌方坦克全部消灭则过关");
    GoToxy(87, 34);
    printf("己方坦克生命值为0 或");
    GoToxy(86, 35);
    printf("正下方的老家被毁则失败");
    GoToxy(86, 36);
    printf("己坦克与敌坦克子弹碰撞");
    GoToxy(87, 37);
    printf("则抵消，敌坦克间子弹碰");
    GoToxy(86, 38);
    printf("撞不抵消且可穿过敌坦克");

}





void Initialize()      //初始化

{

    remain_enemy = 16;
    my_tank.revive = 0; //我的坦克复活次数为0
    position = 0;
    bul_num = 0;
    GetMap();
    BuildMyTank( &my_tank );
    for (int i = 0; i < 12; i++) { //子弹初始化
        bullet [i].exist = 0;
        bullet [i].initial = 0;
    }
    for (int i = 0; i <= 3; i++) { //AI坦克初始化
        AI_tank [i].revive = 0;
        AI_tank [i].alive =
            0; //初始化坦克全是不存活的，BuildAITank()会建立重新建立不存活的坦克
        AI_tank [i].stop = 0;
        AI_tank [i].num = i;
        AI_tank [i].my = 0;
        AI_tank [i].CD = 0;
    }
    GoToxy(97, 2);                       //在副屏幕上关卡数
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN);
    printf("%d", level);
    GoToxy(102, 5);                      //在副屏幕上打印分数
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE);
    printf("%d   ", score);
    GoToxy(102, 7);                      //在副屏幕打印我的剩余生命值
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_INTENSITY | FOREGROUND_GREEN);
    printf("%d", MAX_LIFE - my_tank.revive);
    GoToxy(102, 9);                      //在副屏幕上打印剩余坦克数
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_INTENSITY | FOREGROUND_RED);
    printf("%d ", remain_enemy);
    GoToxy(100, 13);                     //在副屏幕上打印状态
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                            FOREGROUND_INTENSITY | FOREGROUND_BLUE | FOREGROUND_GREEN);
    printf("正在游戏");
}

3.火柴人跑酷

Blo表示血量

#include<bits/stdc++.h>
#include<windows.h>
#include<stdio.h>
#include<conio.h>
#include<time.h>
#define Nor if(B[b].x<5) B[b].x=5;
#define Out1 Bx1-Bvx1<=6||Bx1-Bvx1>=28||By1-Bvy1<=7||By1-Bvy1>=27
#define Out2 Bx2-Bvx2<=6||Bx2-Bvx2>=28||By2-Bvy2<=7||By2-Bvy2>=27
#define Chang1 {Bwhat1=0;Bvx1=Bvy1=0;memset(Bgo1,0,sizeof(Bgo1));}
#define Chang2 {Bwhat2=0;Bvx2=Bvy2=0;memset(Bgo2,0,sizeof(Bgo2));}
#define Chang3 {Bwhat3=0;Bvx3=Bvy3=0;memset(Bgo3,0,sizeof(Bgo3));}
using namespace std;
int ti(float a) {
    return ((int)(a * 10 + 5)) / 10;
}
void Setpos(float x, float y) {
    COORD pos;
    pos.X = ti(y * 4) / 2;
    pos.Y = ti(x);
    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
}
void Color(int a) {
    if (a == 0) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                            FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    if (a == 1) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                            FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_BLUE);
    if (a == 2) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                            FOREGROUND_INTENSITY | FOREGROUND_GREEN);
    if (a == 3) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                            FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_BLUE);
    if (a == 4) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                            FOREGROUND_INTENSITY | FOREGROUND_RED);
    if (a == 5) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                            FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN);
    if (a == 6) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                            FOREGROUND_INTENSITY | FOREGROUND_BLUE);
    if (a == 7) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                            FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    if (a == 8) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                            FOREGROUND_RED);
    if (a == 9) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                            BACKGROUND_INTENSITY | BACKGROUND_GREEN | BACKGROUND_BLUE);
    if (a == 10) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                             BACKGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_BLUE);
    if (a == 11) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                             FOREGROUND_RED | FOREGROUND_BLUE);
    if (a == 12) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                             FOREGROUND_RED | FOREGROUND_GREEN);
    if (a == 13) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                             FOREGROUND_INTENSITY);
    if (a == 14) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                                             FOREGROUND_GREEN | FOREGROUND_BLUE);
}
int Blomax, Ren, Exp, Expmax, Lv, Lvl, Ice, Drug, ar1, ar2, Tar1, Tar2, bl, br,
    Win, T, Tb, Sy, Up, Upt, Down, u1, u2, Kill, Killb, L, Ll[4], Li, D, Gd[10],
    Biao, Fire, Fir, Water, Thun, Wind, Magne, I[20][2], ib, Dis, Disb, Dis1, Disb1,
    Boss, Bblo, Bblomax, Bwhat1, Bwhat2, Bwhat3, Bgo1[10], Bgo2[10], Bgo3[10], Bbr,
    Bbl, Bl[4];
float X, Y, Vx, Vy, Ding, Blo = 1000000, Hui, Bx1, By1, Bx2, By2, Bx3, By3,
                          Bvx1, Bvy1, Bvx2, Bvy2, Bvx3, Bvy3, Bway[1001][2];
struct bullet {
    float x, y, vx, vy;
    int what;
    int a, t, How;
    int life;
    bool kill;
} B[100001];
void Map(int a, int b);
void Pan(int a, float x, float y, int b) {
    float Nox[4], Noy[4];
    Nox[0] = X, Noy[0] = Y;
    if (Down == 1 &&
            X == 22) Nox[1] = X + 1, Noy[1] = Y - 0.5, Nox[2] = X - 1, Noy[2] = Y - 0.5;
    else if (Down == 2) Nox[1] = X + 1, Noy[1] = Y - 0.5, Nox[2] = -10,
                                     Noy[2] = -10;
    else if (Down == 1 ||
             X < 18) Nox[1] = X - 1, Noy[1] = Y - 0.5, Nox[2] = -10, Noy[2] = -10;
    else Nox[1] = X + 1, Noy[1] = Y - 0.5, Nox[2] = X - 1, Noy[2] = Y - 0.5;
    for (int i = 0; i < 3; i++) {
//      Blo=100;
        if (a == -1) {
            if (abs(x - Nox[i]) + abs(y - Noy[i]) < 1.5) {
                if (B[b].what == -10)Exp += 2;
                if (B[b].what == -11)Exp += 1;
                B[b].life = 0;
                if (B[b].life == 0 && b == bl) bl++;
                Map(3, b);
                break;
            }
        }
        if (a == -2) {
            if (abs(x - Nox[i]) + abs(y - Noy[i]) < 2.5) {
                if (B[b].what == -2)Exp += 5, Biao += 5;
                if (B[b].what == -3)Fire = 300, Ice = 0, Fir = 3;
                if (B[b].what == -4)Water = 200;
                if (B[b].what == -5) {
                    Wind = 70;
                    Ding = 28.25;
                    Ice = 0;
                    if (Y < Ding - 1)Vy = 5;
                    else Vy = 0;
                    if (Up >= 1) Vx = -5;
                    if (Down == 2) Vx = 5;
                }
                if (B[b].what == -6) {
                    Thun = 200;
                    system("color 1F");
                    Sleep(20);
                    system("color 6F");
                    Sleep(10);
                    system("color 0F");
                }
                if (B[b].what == -7)Magne = 300;
                if (B[b].what == -8)Ice = 0, Drug = 0, Blo = fmin((float)Blomax, Blo + 20);
                if (B[b].what == -9)Exp = fmin((float)Expmax, Exp + 20);
                B[b].life = 0;
                if (B[b].life == 0 && b == bl) bl++;
                Map(3, b);
                break;
            }
        }
    }
    if (Wind == 0 && Thun == 0 && (B[b].kill != 0 || Killb >= 15 || Ren == 1 &&
                                   Killb > 0)) return;
//    Blo=100;
    for (int i = 0; i < 3; i++) {
//      Blo=100;
        if ((Wind >= 1 || Thun >= 1) && abs(x - Nox[i]) + abs(y - Noy[i]) < 2.5) {
            if (B[b].what < 98)Exp += 2;
            B[b].life = 0;
            Map(3, b);
            break;
        }
        if (a == 1) {
            if (abs(x - Nox[i]) < 0.5 && abs(y - Noy[i]) < 1) {
                if (B[b].what >= 99)Blo -= 0, Blo -= 10;
                if (B[b].what == 14)Blo -= 0, Blo -= 15, Ice = 100, B[b].life = 0;
                else if (B[b].what == 15)Blo -= 0, Ice = 0, B[b].life = 0;
                else if (B[b].what == 17)Blo -= 0, Blo -= 5, Drug = 100, B[b].life = 0;
                else if (B[b].what >= 13 && B[b].what <= 17)Blo -= 0, Blo -= 10, B[b].life = 0;
                else Blo -= 0, Blo -= 15;
                B[b].kill = 1, Killb = 20;
                Kill = 1;
                Map(3, b);
                break;
            }
        }
        if (a == 2 || a == 6 || a == 8 || a == 9 || a == 10 || a == 11 || a == 12) {
            if (abs(x - Nox[i]) + abs(y - Noy[i]) < 1.5) {
                if (a == 2)Blo -= 0, Blo -= 20;
                else if (a == 8)Blo -= 0;
                Blo -= 10;
            } else {
                Blo -= 15;
                B[b].kill = 1, Killb = 20;
                Kill = 1;
                if (a != 2) {
                    B[b].life = 0;
                    if (B[b].life == 0 && b == bl) bl++;
                    Map(3, b);
                    break;
                }
            }
        }
        if (a == 4) {
            if ((Wind >= 1 || Thun >= 1) && abs(x - Nox[i]) < 1.5 && Noy[i] - y <= 0 &&
                    Noy[i] - y >= -8) {
                if (B[b].what < 98)Exp += 2;
                B[b].life = 0;
                Map(3, b);
                break;
            }
            if (abs(x - Nox[i]) < 1 && Noy[i] - y <= 0 && Noy[i] - y >= -8) {
                Blo -= 25, B[b].kill = 1, Killb = 20;
                Kill = 1;
                Vy = -1;
                Y -= 0.5;
                break;
            }
        }
    }
//    Blo=100;
}
void Map(int a, int b) {
    Color(0);
    if (a == -1) {
//          Blo=100;
        if (Boss == 1 || Boss == 6) {
            if (Bwhat1 == 5) {
                if (ti(Bx1) == 20)Setpos(Bx1, By1), cout << "==";
                else Setpos(Bx1, By1), cout << "  ";
            } else {
                Setpos(Bx1 - 1, By1 - 0.5), cout << "    ";
                Setpos(Bx1, By1 - 1), cout << "      ";
                Setpos(Bx1 + 1, By1 - 0.5), cout << "    ";
                if (abs(ti(Bx1) - 20) <= 1)Setpos(20, By1 - 1), cout << "======";
            }
        }
        if (Boss == 2 || Boss == 6) {
            Setpos(Bx2 - 1, By2 - 1);
            cout << "    ";
            Setpos(Bx2, By2 - 1);
            cout << "      ";
            Setpos(Bx2 + 1, By2 - 1), cout << "      ";
            Color(0);
            if (abs(ti(Bx2) - 20) <= 1)Setpos(20, By2 - 1), cout << "======";
        }
        if (Boss == 3 || Boss == 6) {
            Setpos(Bx3 - 1, By3 - 0.5);
            cout << "     ";
            Setpos(Bx3, By3);
            cout << "  ";
            Setpos(Bx3 + 1, By3 - 1), cout << "      ";
            Color(0);
            if (abs(ti(Bx3) - 20) <= 1)Setpos(20, By3 - 1), cout << "=======";
        }
        if (X < 0)return;
        if (X >= 17 && X <= 19) {
            Setpos(X - 1, Y);
            cout << "  ";
            Setpos(X, Y - 1);
            cout << "   ";
            Setpos(X + 1, Y - 1), cout << "   ";
        } else if (X <= 23 && X >= 21) {
            Setpos(X + 1, Y);
            cout << "  ";
            Setpos(X, Y - 1);
            cout << "   ";
            Setpos(X - 1, Y - 1), cout << "    ";
        } else if (X > 23) {
            Setpos(X, Y - 1);
            cout << "    ";
            Setpos(X - 1, Y - 0.5), cout << "   ";
        } else if (X < 17 && Upt != 0) {
            Setpos(X, Y - 1);
            cout << "    ";
            Setpos(X + 1, Y - 1.5), cout << "    ";
        } else if (X < 17) {
            Setpos(X, Y - 1);
            cout << "    ";
            Setpos(X + 1, Y - 0.5), cout << "   ";
        }
        if (Thun > 0) {
            Setpos(X - 2, Y - 1), cout << "    ";
            Setpos(X + 2, Y - 1), cout << "    ";
            Setpos(X, Y + 2), cout << "  ";
            Setpos(X, Y - 2.5), cout << "  ";
            Setpos(X - 1, Y + 1), cout << "  ";
            Setpos(X + 1, Y + 1), cout << "  ";
            Setpos(X - 1, Y - 2), cout << "  ";
            Setpos(X + 1, Y - 2), cout << "  ";
            Setpos(20, Y - 2.5), cout << "============";
        }
        if (Wind != 0) {
            Setpos(X + 1, Y - 5);
            cout << "        ";
            Setpos(X, Y - 5);
            cout << "        ";
            Setpos(X - 1, Y - 5);
            cout << "        ";
            Setpos(20, Y - 5), cout << "========";
        }
        if (Water != 0) {
            Setpos(X, Y - 4);
            cout << "       ";
            Setpos(X + 2, Y - 3.5);
            cout << "     ";
            Setpos(X - 2, Y - 3.5);
            cout << "     ";
            Setpos(X + 1, Y - 3.5);
            cout << "     ";
            Setpos(X - 1, Y - 3.5);
            cout << "     ";
            Setpos(20, Y - 5), cout << "========";
        }
        if (Fire != 0) {
            Setpos(X, Y + 1), cout << "  ";
            Setpos(X + 1, Y), cout << "  ";
            Setpos(X - 1, Y - 1), cout << "  ";
            Setpos(20, Y - 1);
            cout << "======";
        }
    }
    if (a == 0) {
//          Blo=100;
        if (Boss == 1 || Boss == 6) {
            if (Bwhat1 == 5)Color(5), Setpos(Bx1, By1), cout << "█", Color(0);
            else if (Bwhat1 == 4 && Bgo1[1] > 6 &&
                     Bgo1[1] < 11)Color(4), Setpos(Bgo1[5] - 1, Bgo1[6]), cout << "︻",
                                 Setpos(Bgo1[5], Bgo1[6] - 1), cout << "【", Setpos(Bgo1[5], Bgo1[6] + 1),
                                 cout << "】", Setpos(Bgo1[5] + 1, Bgo1[6]), cout << "︼", Color(0);
            else {
                Setpos(Bx1 - 1, By1 - 0.5), Color(0), cout << "●●";
                Setpos(Bx1, By1 - 1);
                if (Bwhat1 == 2 && Bgo1[1] <= 5)Color(1);
                else if (Bwhat1 == 3 && Bgo1[1] <= 5)Color(5);
                else if (Bwhat1 == 6 && Bgo1[1] <= 5)Color(8);
                else Color(4);
                if (Bwhat1 == 4) Setpos(Bx1, By1 - 0.5), cout << "██(";
                else cout << ")██(";
                Setpos(Bx1 + 1, By1 - 0.5), cout << "……";
                Color(0);
            }
        }
        if (Boss == 2 || Boss == 6) {
            Setpos(Bx2 - 1, By2 - 1);
            Color(0), cout << "\\ ";
            Color(0);
            cout << "●";
            Setpos(Bx2, By2 - 1);
            Color(3);
            cout << "◥";
            Color(5), cout << "JJJ";
            Color(0), cout << ">";
            Color(3);
            Setpos(Bx2 + 1, By2 - 1), cout << "◢█◣";
            Color(0);
        }
        if (Boss == 3 || Boss == 6) {
            Setpos(Bx3 - 1, By3 - 0.5);
            if (Bwhat3 == 3 || Bwhat3 == 9) Color(1);
            else if (Bwhat3 == 4 || Bwhat3 == 10) Color(4);
            else if (Bwhat3 == 5 || Bwhat3 == 11) Color(5);
            if (Bwhat3 == 11)cout << ' ';
            else if (Bwhat3 == 6) Color(3);
            else Color(2);
            cout << "●-";
            Setpos(Bx3, By3);
            if (Bwhat3 == 11)cout << "/";
            else cout << "┃";
            Color(0);
            Setpos(Bx3 + 1, By3 - 1), cout << "●●●";
        }
        if (X < 0)return;
        if (Ren == 2) Color(12);
        if (Ren == 3) Color(1);
        if (Ren == 4) Color(3);
        if (Ren == 5) Color(4);
        if (Ren == 6) Color(2);
        if (Drug != 0 && T % 5 != 0) Color(11);
        if (Drug != 0 && T % 5 == 0) Color(11);
        if (Ice != 0) Color(6);
        if (b == 1) Color(8);
        if (Li != 0) Color(5);
        if (Ren == 1 && Killb > 0 && T % 4 < 2) Color(13);
        if (Wind > 0 && T % 4 <= 1) Color(1);
        if (Wind > 0 && T % 4 >= 2) Color(0);
        if (Thun > 0 && T % 4 <= 1) Color(1);
        if (Thun > 0 && T % 4 >= 2) Color(6);
        if (X >= 17 && X <= 19) {
            Setpos(X - 1, Y);
            cout << "●";
            Setpos(X, Y - 1);
            cout << "━/";
            if (T % 10 < 3) Setpos(X + 1, Y - 1), cout << "┛╲";
            else if (T % 10 < 6) Setpos(X + 1, Y - 1), cout << "┦ ";
            else Setpos(X + 1, Y - 1), cout << "╯>";
            if (Wind > 0 && T % 3 == 0) Setpos(X + 1, Y - 1), cout << "┛╲";
            else if (Wind > 0 && T % 3 == 1) Setpos(X + 1, Y - 1), cout << "┦ ";
            else if (Wind > 0 && T % 3 == 2)Setpos(X + 1, Y - 1), cout << "╯>";
        } else if (X <= 23 && X >= 21) {
            Setpos(X + 1, Y);
            cout << "●";
            Setpos(X, Y - 1);
            cout << "━\\";
            if (T % 10 < 3) Setpos(X - 1, Y - 1), cout << "┓╱";
            else if (T % 10 < 6) Setpos(X - 1, Y - 1), cout << "┪ ";
            else Setpos(X - 1, Y - 1), cout << "╮>";
            if (Wind > 0 && T % 3 == 0) Setpos(X - 1, Y - 1), cout << "┓╱";
            else if (Wind > 0 && T % 3 == 1) Setpos(X - 1, Y - 1), cout << "┪ ";
            else if (Wind > 0 && T % 3 == 2)Setpos(X - 1, Y - 1), cout << "╮>";
        } else if (X > 23) {
            Setpos(X, Y - 1);
            cout << "━ ●";
            Setpos(X - 1, Y - 0.5), cout << "│>";
        } else if (X < 17 && Upt != 0) {
            Setpos(X, Y - 1);
            cout << "━ ●";
            Setpos(X + 1, Y - 1.5), cout << "╱ >";
        } else if (X < 17) {
            Setpos(X, Y - 1);
            cout << "━ ●";
            Setpos(X + 1, Y - 0.5), cout << "│>";
        }
        if (Thun > 0) {
            Setpos(X - 2, Y - 1), cout << "▄▄";
            Setpos(X + 2, Y - 1), cout << "▄▄";
            Setpos(X, Y + 2), cout << "▌";
            Setpos(X, Y - 2.5), cout << "▌";
            Setpos(X - 1, Y + 1), cout << "█";
            Setpos(X + 1, Y + 1), cout << "█";
            Setpos(X - 1, Y - 2), cout << "█";
            Setpos(X + 1, Y - 2), cout << "█";
        }
        if (Magne > 0 && T % 7 < 2)Setpos(X, Y), Color(5), cout << "★";
        if (Wind > 1) {
            if (T % 6 < 2)Color(1);
            else Color(0);
            if (T % 8 <= 1) {
                Setpos(X + 1, Y - 5);
                cout << "----  --";
                Setpos(X, Y - 5);
                cout << "-  --- -";
                Setpos(X - 1, Y - 5);
                cout << "--- - --";
            } else if (T % 8 <= 3) {
                Setpos(X + 1, Y - 5);
                cout << "------  ";
                Setpos(X, Y - 5);
                cout << " --  ---";
                Setpos(X - 1, Y - 5);
                cout << "----- - ";
            } else if (T % 8 <= 5) {
                Setpos(X + 1, Y - 5);
                cout << "  ------";
                Setpos(X, Y - 5);
                cout << "-- --  -";
                Setpos(X - 1, Y - 5);
                cout << "- ----- ";
            } else if (T % 8 <= 7) {
                Setpos(X + 1, Y - 5);
                cout << "--  ----";
                Setpos(X, Y - 5);
                cout << " --- -- ";
                Setpos(X - 1, Y - 5);
                cout << "- - ----";
            }
        }
        if (Water != 0) {
            Color(1);
            if (T % 20 < 5) {
                Setpos(X + 2, Y - 3);
                cout << "■";
                Setpos(X + 1, Y - 3.5);
                cout << "■";
                Setpos(X - 1, Y - 2.5);
                cout << "■";
                Setpos(X - 2, Y - 3);
                cout << "■";
            } else if (T % 20 < 10 || T % 20 >= 15) {
                Setpos(X + 2, Y - 3);
                cout << "■";
                Setpos(X, Y - 4);
                cout << "■■";
                Setpos(X - 2, Y - 3);
                cout << "■";
            } else if (T % 20 < 15) {
                Setpos(X + 2, Y - 3.5);
                cout << "■";
                Setpos(X + 1, Y - 3);
                cout << "■";
                Setpos(X - 1, Y - 3.5);
                cout << "■";
                Setpos(X - 2, Y - 3);
                cout << "■";
            }
        }
        if (Fire != 0) {
            if (T % 6 < 3)Color(4);
            else Color(5);
            if (Fir >= 1)Setpos(X, Y + 1), cout << "●";
            if (Fir >= 2)Setpos(X + 1, Y), cout << "●";
            if (Fir >= 3)Setpos(X - 1, Y - 1), cout << "●";
        }
    }
    if (a == 1 || a == 3) {
//          Blo=100;
        if (B[b].what == 1) {
            Nor;
            Setpos(B[b].x, B[b].y - 1);
            if (ti(B[b].x) == 20)cout << "======";
            else cout << "      ";
            if (B[b].life != 0) {
                B[b].y -= B[b].vy;
                Setpos(B[b].x, B[b].y);
                if (B[b].How <= 1) Color(13);
                else Color(4);
                cout << "●";
                if (a == 1) Pan(1, B[b].x, B[b].y, b);
            }
        }
        if (B[b].what == 2) {
            Nor;
            Setpos(B[b].x - 1, B[b].y - 1);
            if (ti(B[b].x - 1) == 20)cout << "======";
            else cout << "      ";
            Setpos(B[b].x, B[b].y - 1);
            if (ti(B[b].x) == 20)cout << "======";
            else cout << "      ";
            Setpos(B[b].x + 1, B[b].y - 1);
            if (ti(B[b].x + 1) == 20)cout << "======";
            else cout << "      ";
            if (B[b].life != 0) {
                B[b].y -= B[b].vy;
                Setpos(B[b].x, B[b].y);
                Color(5);
                if (B[b].How == 0) {
                    Setpos(B[b].x - 1, B[b].y), cout << "↑";
                    Setpos(B[b].x, B[b].y - 1), cout << "←┼ →";
                    Setpos(B[b].x + 1, B[b].y), cout << "↓";
                } else if (B[b].How == 1) {
                    Setpos(B[b].x - 1, B[b].y - 1), cout << "↖  ↗";
                    Setpos(B[b].x, B[b].y), cout << "╳";
                    Setpos(B[b].x + 1, B[b].y - 1), cout << "↙  ↘";
                }
                if (a == 1) Pan(2, B[b].x, B[b].y, b);
            }
        }
        if (B[b].what == 3 || B[b].what == 5) {
            Nor;
            Setpos(B[b].x, B[b].y);
            if (ti(B[b].x) == 20)cout << "==";
            else cout << "  ";
            if (B[b].life != 0) {
                B[b].y -= B[b].vy;
                B[b].x -= B[b].vx;
                Setpos(B[b].x, B[b].y);
                if (B[b].How == 1) Color(5);
                else Color(4);
                cout << "◎";
            }
        }
        if (B[b].what == 4) {
            Nor;
            Setpos(B[b].x, fmax((float)0, B[b].y - 8));
            if (ti(B[b].x) == 20) {
                for (int i = max(0, (int)B[b].y - 8); i <= B[b].y; i++)cout << "==";
            } else {
                for (int i = max(0, (int)B[b].y - 8); i <= B[b].y; i++)cout << "  ";
            }
            if (B[b].life != 0) {
                B[b].y -= B[b].vy;
                Setpos(B[b].x, fmax((float)0, B[b].y - 8));
                Color(6);
                for (int i = max(0, (int)B[b].y - 8); i <= B[b].y; i++)cout << "═";
                if (a == 1) Pan(4, B[b].x, B[b].y, b);
            }
        }
        if (B[b].what == 6 || B[b].what == 8 || B[b].what == 9) {
            Nor;
            Setpos(B[b].x - 1, B[b].y);
            if (ti(B[b].x) - 1 == 20)cout << "==";
            else cout << "  ";
            Setpos(B[b].x + 1, B[b].y);
            if (ti(B[b].x) + 1 == 20)cout << "==";
            else cout << "  ";
            Setpos(B[b].x, B[b].y - 1);
            if (ti(B[b].x) == 20)cout << "======";
            else cout << "      ";
            if (B[b].life != 0) {
                B[b].y -= B[b].vy;
                B[b].x -= B[b].vx;
                Setpos(B[b].x, B[b].y - 1);
                if (B[b].what == 6) {
                    if (B[b].How <= 1) Color(1);
                    else Color(6);
                }
                if (B[b].what == 9) {
                    if (B[b].How <= 1) Color(4);
                    else Color(8);
                }
                if (B[b].what == 8)Color(5);
                Setpos(B[b].x - 1, B[b].y);
                cout << "︹";
                Setpos(B[b].x + 1, B[b].y);
                cout << "︺";
                Setpos(B[b].x, B[b].y - 1);
                if (B[b].How % 2 == 1) cout << "〔●〕";
                else cout << "﹝○﹞";
                if (a == 1) Pan(6, B[b].x, B[b].y, b);
            }
        }
        if (B[b].what == 7) {
            Nor;
            Setpos(B[b].x, B[b].y);
            if (B[b].How < 0) for (int i = 19; i >= 20 + B[b].How; i--) {
                    Setpos(i, B[b].y);
                    cout << "  ";
                }
            if (B[b].How > 0) for (int i = 21; i <= 20 + B[b].How; i++) {
                    Setpos(i, B[b].y);
                    cout << "  ";
                }
            if (B[b].life != 0) {
                B[b].y -= B[b].vy;
                if (B[b].How < 0) for (int i = 19; i >= 20 + B[b].How; i--) {
                        Setpos(i, B[b].y);
                        cout << "║";
                        if (a == 1) Pan(7, i, B[b].y, b);
                    }
                if (B[b].How > 0) for (int i = 21; i <= 20 + B[b].How; i++) {
                        Setpos(i, B[b].y);
                        cout << "║";
                        if (a == 1) Pan(7, i, B[b].y, b);
                    }
            }
        }
        if (B[b].what == 10 || B[b].what == 11 || B[b].what == 12) {
            Nor;
            Setpos(B[b].x, B[b].y);
            if (ti(B[b].x) == 20)cout << "==";
            else cout << "  ";
            if (B[b].life != 0) {
                B[b].x -= B[b].vx;
                B[b].y -= B[b].vy;
                if (B[b].How == 1) {
                    B[b].vy -= 0.2;
                } else B[b].vx -= 0.35;
                if (B[b].x >= 25) B[b].x = 25, B[b].vx *= -0.8;
                if (B[b].what == 11 && B[b].y <= 1) B[b].y = 1, B[b].vy *= -1;
                if (B[b].what == 12 &&
                        B[b].y <= 1) B[b].y = 1, B[b].vx = 0, B[b].vy = -0.5, B[b].How = 1;
                Setpos(B[b].x, B[b].y);
                if (B[b].what == 11)Color(1);
                else if (B[b].what == 12)Color(5);
                else Color(0);
                if (B[b].t % 4 < 2)cout << "▃";
                else cout << "▍";
                if (a == 1) Pan(B[b].what, B[b].x, B[b].y, b);
            }
        }
        if (B[b].what >= 13 && B[b].what <= 17) {
            Nor;
            Setpos(B[b].x, B[b].y);
            if (ti(B[b].x) == 20)cout << "====";
            else cout << "    ";
            if (B[b].life != 0) {
                B[b].x -= B[b].vx;
                B[b].y -= B[b].vy;
                Setpos(B[b].x, B[b].y);
                if (B[b].what == 14) Color(1);
                else if (B[b].what == 15) Color(4);
                else if (B[b].what == 16) Color(5);
                else if (B[b].what == 17) Color(3);
                else Color(2);
                cout << "●";
                if (B[b].what == 14)cout << "*";
                if (B[b].what == 15)cout << "";
                if (B[b].what == 16)cout << "<";
                if (B[b].what == 17)cout << "X";
            }
            if (a == 1) Pan(1, B[b].x, B[b].y, b);
        }
        if (B[b].what == 98 && B[b].life != 0) {
            B[b].y -= B[b].vy;
            Setpos(B[b].x, B[b].y);
            if (ti(B[b].x == 20))cout << "==";
            else cout << "  ";
            if (B[b].y <= 3)B[b].life = 0;
        }
        if (B[b].what >= 99) {
            if (B[b].y <= 3)B[b].life = 0;
            if (B[b].life != 0) {
                B[b].y -= B[b].vy;
                Setpos(B[b].x, B[b].y);
                Color(5);
                if (B[b].what == 99)cout << "█";
                if (B[b].what >= 100 && B[b].what < 200) {
                    if (B[b].what % 5 == 0)cout << "我";
                    if (B[b].what % 5 == 1)cout << "是";
                    if (B[b].what % 5 == 2)cout << "最";
                    if (B[b].what % 5 == 3)cout << "强";
                    if (B[b].what % 5 == 4)cout << "的";
                }
                if (B[b].what >= 200 && B[b].what < 300) {
                    if (B[b].what % 6 == 0)cout << "神";
                    if (B[b].what % 6 == 1)cout << "级";
                    if (B[b].what % 6 == 2)cout << "怪";
                    if (B[b].what % 6 == 3)cout << "物";
                    if (B[b].what % 6 == 4)cout << "之";
                    if (B[b].what % 6 == 5)cout << "光";
                }
                if (B[b].what >= 300 && B[b].what < 400) {
                    if (B[b].what % 8 == 0)cout << "颤";
                    if (B[b].what % 8 == 1)cout << "抖";
                    if (B[b].what % 8 == 2)cout << "吧";
                    if (B[b].what % 8 == 3)cout << "无";
                    if (B[b].what % 8 == 4)cout << "能";
                    if (B[b].what % 8 == 5)cout << "的";
                    if (B[b].what % 8 == 6)cout << "人";
                    if (B[b].what % 8 == 7)cout << "类";
                }
                if (B[b].what >= 400 && B[b].what < 500) {
                    if (B[b].what % 8 == 0)cout << "还";
                    if (B[b].what % 8 == 1)cout << "不";
                    if (B[b].what % 8 == 2)cout << "快";
                    if (B[b].what % 8 == 3)cout << "跪";
                    if (B[b].what % 8 == 4)cout << "倒";
                    if (B[b].what % 8 == 5)cout << "在";
                    if (B[b].what % 8 == 6)cout << "朕";
                    if (B[b].what % 8 == 7)cout << "前";
                }
                if (B[b].what >= 500 && B[b].what < 600) {
                    if (B[b].what % 8 == 0)cout << "看";
                    if (B[b].what % 8 == 1)cout << "懂";
                    if (B[b].what % 8 == 2)cout << "这";
                    if (B[b].what % 8 == 3)cout << "句";
                    if (B[b].what % 8 == 4)cout << "话";
                    if (B[b].what % 8 == 5)cout << "的";
                    if (B[b].what % 8 == 6)cout << "是";
                    if (B[b].what % 8 == 7)cout << "猪";
                }
                if (a == 1) Pan(1, B[b].x, B[b].y, b);
            }
        }
        if (B[b].what == -1) {
            Nor;
            Setpos(B[b].x, B[b].y);
            if (ti(B[b].x) == 20)cout << "==";
            else cout << "  ";
            if (Boss == 0) B[b].life = 0;
            else if (((Boss == 1 && abs(B[b].x - Bx1) + abs(B[b].y - By1) < 1.5) ||
                      (Boss == 2 && abs(B[b].x - Bx2) + abs(B[b].y - By2) < 1.5) || (Boss == 3 &&
                              abs(B[b].x - Bx3) + abs(B[b].y - By3) < 1.5) || (B[b].t == 10)) &&
                     B[b].life == 1) Bblo -= 8 + Lv * 2, B[b].life = 0;
            if (B[b].life != 0) {
                if (Boss == 1)B[b].x = B[b].x + (Bx1 - B[b].x) / (10 - B[b].t) * 1.0,
                                      B[b].y = B[b].y + (By1 - B[b].y) / (10 - B[b].t) * 1.0;
                if (Boss == 2)B[b].x = B[b].x + (Bx2 - B[b].x) / (10 - B[b].t) * 1.0,
                                      B[b].y = B[b].y + (By2 - B[b].y) / (10 - B[b].t) * 1.0;
                if (Boss == 3)B[b].x = B[b].x + (Bx3 - B[b].x) / (10 - B[b].t) * 1.0,
                                      B[b].y = B[b].y + (By3 - B[b].y) / (10 - B[b].t) * 1.0;
                Setpos(B[b].x, B[b].y);
                Color(7);
                if (B[b].t % 2 == 0) cout << "＋";
                else cout << "×";
            }
        }
        if (B[b].what <= -2 && B[b].what >= -9) {
            Nor;
            Setpos(B[b].x - 1, B[b].y);
            if (ti(B[b].x) - 1 == 20)cout << "==";
            else cout << "  ";
            Setpos(B[b].x + 1, B[b].y);
            if (ti(B[b].x) + 1 == 20)cout << "==";
            else cout << "  ";
            Setpos(B[b].x, B[b].y - 1);
            if (ti(B[b].x) == 20)cout << "======";
            else cout << "      ";
            if (B[b].life != 0) {
                B[b].y -= B[b].vy;
                B[b].x -= B[b].vx;
                if (B[b].what <= -3 && B[b].what >= -7) {
                    if (B[b].x <= 7)B[b].x = 7;
                    if (B[b].x >= 28)B[b].x = 28;
                    else if (B[b].x >= B[b].a + 1 && B[b].How == 1)B[b].How = 0;
                    else if (B[b].x <= B[b].a - 1 && B[b].How == 0)B[b].How = 1;
                    if (B[b].How == 1 && B[b].vx >= -1)B[b].vx -= 0.2;
                    if (B[b].How == 0 && B[b].vx <= 1)B[b].vx += 0.2;
                }
                if (B[b].what == -2) Color(3);
                if (B[b].what == -3) Color(4);
                if (B[b].what == -4) Color(1);
                if (B[b].what == -5) Color(0);
                if (B[b].what == -6) Color(6);
                if (B[b].what == -7) Color(5);
                if (B[b].what == -8) Color(2);
                if (B[b].what == -9) Color(14);
                if (T % 7 <= 1 && B[b].what == -5)Color(1);
                else if (T % 7 <= 1)Color(0);
                Setpos(B[b].x - 1, B[b].y);
                cout << "︹";
                Setpos(B[b].x + 1, B[b].y);
                cout << "︺";
                Setpos(B[b].x, B[b].y - 1);
                if (B[b].what == -2) cout << "﹝镖﹞";
                if (B[b].what == -3) cout << "﹝火﹞";
                if (B[b].what == -4) cout << "﹝水﹞";
                if (B[b].what == -5) cout << "﹝风﹞";
                if (B[b].what == -6) cout << "﹝雷﹞";
                if (B[b].what == -7) cout << "﹝磁﹞";
                if (B[b].what == -8) cout << "﹝血﹞";
                if (B[b].what == -9) cout << "﹝忍﹞";
                if (a == 1) Pan(-2, B[b].x, B[b].y, b);
            }
        }
        if (B[b].what == -11 || B[b].what == -12) {
            Nor;
            Setpos(B[b].x, B[b].y);
            if (ti(B[b].x) == 20)cout << "==";
            else cout << "  ";
            if (B[b].life != 0) {
                if (Magne > 0)B[b].How++,
                    B[b].x = B[b].x + (X - B[b].x) / (10 - B[b].How) * 1.0,
                        B[b].y = B[b].y + (Y - B[b].y) / (10 - B[b].How) * 1.0;
                B[b].y -= B[b].vy;
                Setpos(B[b].x, B[b].y);
                if (B[b].what == -10) Color(5);
                if (B[b].what == -11) Color(7);
                if (T % 7 <= 1)Color(0);
                cout << "◆";
                if (a == 1) Pan(-1, B[b].x, B[b].y, b);
            }
        }
        if (B[b].what == -13) {
            Nor;
            Setpos(B[b].x, B[b].y - 0.5);
            if (ti(B[b].x) == 20)cout << "===";
            else cout << "   ";
            if (B[b].life != 0) {
                if (B[b].a == 13880086) {
                    if (Boss == 0) B[b].life = 0;
                    else if (((Boss == 1 && abs(B[b].x - Bx1) + abs(B[b].y - By1) < 1.5) ||
                              (Boss == 2 && abs(B[b].x - Bx2) + abs(B[b].y - By2) < 1.5) || (Boss == 3 &&
                                      abs(B[b].x - Bx3) + abs(B[b].y - By3) < 1.5) || (B[b].t == 5)) &&
                             B[b].life == 1) Bblo -= 8 + Lv * 2, B[b].life = 0;
                    if (B[b].life != 0) {
                        if (Boss == 1)B[b].x = B[b].x + (Bx1 - B[b].x) / (5 - B[b].t) * 1.0,
                                              B[b].y = B[b].y + (By1 - B[b].y) / (5 - B[b].t) * 1.0;
                        if (Boss == 2)B[b].x = B[b].x + (Bx2 - B[b].x) / (5 - B[b].t) * 1.0,
                                              B[b].y = B[b].y + (By2 - B[b].y) / (5 - B[b].t) * 1.0;
                        if (Boss == 3)B[b].x = B[b].x + (Bx3 - B[b].x) / (5 - B[b].t) * 1.0,
                                              B[b].y = B[b].y + (By3 - B[b].y) / (5 - B[b].t) * 1.0;
                    }
                } else {
                    if (B[B[b].a].life == 0) B[b].life = 0;
                    else if ((abs(B[b].x - B[B[b].a].x) + abs(B[b].y - B[B[b].a].y) < 1.5 ||
                              (B[b].t == 5)) && B[b].life == 1) Exp += 2, B[B[b].a].life = B[b].life = 0;
                    if (B[b].life != 0) {
                        B[b].x = B[b].x + (B[B[b].a].x - B[b].x) / (5 - B[b].t) * 1.0,
                            B[b].y = B[b].y + (B[B[b].a].y - B[b].y) / (5 - B[b].t) * 1.0;
                    }
                }
                Setpos(B[b].x, B[b].y - 0.5);
                if (T % 6 < 3)Color(5);
                else Color(4);
                cout << "●";
            }
        }
    }
    if (br < bl) {
        br = -1, bl = 0;
        memset(B, 0, sizeof(B));
    }
    Color(0);
}
void Move() {
//      Blo=100;
    if (X < 3) X = 3;
    if (Y < 1) Y = 1, Vy = 0;
    if (Y > 29) Y = 29, Vy = 0;
    if (Ice != 0) {
        X -= Vx / 2.0;
        Y += Vy / 2.0;
        Vy = fmax(Vy - 0.025, (float)0);
        if (T % 6 == 0 && Up == 0 && Y < Ding) Y += 0.25;
        if (T % 6 == 3 && Up == 0 && Y >= Ding) Y -= 0.25;
        if (Up == 0 && Y <= Ding - 1.25) Vy = 0.25;
        if (Up == 0 && Y >= Ding + 1.25 && Wind == 0) Vy = -0.25;
        if (Up == 0 && Down == 0 && Vx > 0 &&
                X <= 18) Up = 0, Down = 0, Vx = 0, Vy = 0, X = 18, Setpos(20, Y - 2.5),
                             cout << "==========";
        else if (Down == 2 &&
                 X <= 22) Up = 0, Down = 1, Vx = 0, Vy = 0, X = 22, Setpos(20, Y - 2.5),
                              cout << "==========";
        else if (Up == 0 && Down == 1 && Vx < 0 &&
                 X >= 22) Up = 0, Down = 1, Vx = 0, Vy = 0, X = 22, Setpos(20, Y - 2.5),
                              cout << "==========";
        else if (Up > 0 && Down == 0 &&
                 X > 18) Up = 0, Vx = 0, Vy = 0, X = 18, Setpos(20, Y - 2.5),
                             cout << "==========";
        else if (Down == 2) Vx += 0.175;
        else if (Up > 0 && Upt == 0) Vx -= 0.175;
        else if (Up > 0 && Upt > 0) {
            Vx = fmax(Vx - 0.125, (float)0);
            if (Upt == 1 && T % 2 == 0)Map(-1, 0);
            if (T % 2 == 0)Upt--;
        }
    } else {
        X -= Vx;
        Y += Vy;
        Vy = fmax(Vy - 0.05, (float)0);
        if (Wind == 0) {
            if (T % 6 == 0 && Up == 0 && Y < Ding) Y += 0.5;
            if (T % 6 == 3 && Up == 0 && Y >= Ding) Y -= 0.5;
        } else {
            if (T % 2 == 0 && Up == 0 && Y < Ding) Y += 0.5;
            if (T % 2 == 1 && Up == 0 && Y >= Ding) Y -= 0.5;
        }
        if (Up == 0 && Y <= Ding - 1.25) Vy = 0.5;
        if (Up == 0 && Y >= Ding + 1.25 && Wind == 0) Vy = -0.5;
        if (Up == 0 && Down == 0 && Vx > 0 &&
                X <= 18) Up = 0, Down = 0, Vx = 0, Vy = 0, X = 18, Setpos(20, Y - 2.5),
                             cout << "==========";
        else if (Down == 2 &&
                 X <= 22) Up = 0, Down = 1, Vx = 0, Vy = 0, X = 22, Setpos(20, Y - 2.5),
                              cout << "==========";
        else if (Up == 0 && Down == 1 && Vx < 0 &&
                 X >= 22) Up = 0, Down = 1, Vx = 0, Vy = 0, X = 22, Setpos(20, Y - 2.5),
                              cout << "==========";
        else if (Up > 0 && Down == 0 &&
                 X > 18) Up = 0, Vx = 0, Vy = 0, X = 18, Setpos(20, Y - 2.5),
                             cout << "==========";
        else if (Down == 2) Vx += 0.35;
        else if (Up > 0 && Upt == 0) Vx -= 0.35;
        else if (Up > 0 && Upt > 0) {
            Vx = fmax(Vx - 0.25, (float)0);
            if (Upt == 1)Map(-1, 0);
            Upt--;
        }
    }
    for (int i = bl; i <= br; i++) {
//          Blo=100;
        if (B[i].what < 98)if (B[i].x - B[i].vx <= 5 || B[i].x - B[i].vx >= 30 ||
                                   B[i].y - B[i].vy <= 0 || B[i].y - B[i].vy >= 30) {
                B[i].life = 0;
                Map(1, i);
            }
        for (int j = 0; j < 20; j++)if (B[i].what > 0 && B[i].life != 0 &&
                                            abs(B[i].x - I[j][0]) < 2 && B[i].y - I[j][1] <= 2) {
                Setpos(I[j][0], I[j][1]);
                if (I[j][0] == 20) cout << "===";
                else cout << "   ";
                I[j][0] = I[j][1] = -1;
                B[i].life = 0;
                Exp += 2;
            }
        if (B[i].t >= 100)B[i].life = 0;
        if (B[i].life == 0 && i == bl) bl++;
        Map(1, i);
        if (B[i].life == 0) continue;
        else {
            B[i].t++;
            if (B[i].what == 1) {
                if (B[i].y <= 25 && B[i].How == 0) B[i].vy = 0, B[i].How = 1;
                if (B[i].t == 30) B[i].y += 1.5, B[i].How = 2;
                if (B[i].t == 35) B[i].vy = 1.5, B[i].How = 3;
            }
            if (B[i].what == 2) {
                if (B[i].t % 3 == 0) B[i].How = !B[i].How;
            }
            if (B[i].what == 3 || B[i].what == 5) {
                if (B[i].what == 3 && B[i].y <= 20) B[i].vy = 0;
                if (B[i].what == 5 && B[i].y <= 21) B[i].vy = 0;
                if (B[i].t > 30 && B[i].t % 2 == 0) B[i].How = !B[i].How;
                if (B[i].what == 5 && B[i].t <= 30 && B[i].x < X) B[i].vx = -0.2;
                else if (B[i].what == 5 && B[i].t <= 70 && B[i].x > X) B[i].vx = 0.2;
                else B[i].vx = 0;
                if (B[i].t == 45) {
                    B[i].life = 0;
                    br++;
                    B[br].what = 4;
                    B[br].x = B[i].x;
                    B[br].y = 32;
                    B[br].vy = 3;
                    B[br].life = 1;
                }
            }
            if (B[i].what == 6 || B[i].what == 8 || B[i].what == 9) {
                if (B[i].vx < 0.25 && B[i].vy < 0.25 && B[i].t >= 50) {
                    B[i].life = 0;
                    if (B[i].life == 0 && i == bl) bl++;
                    Map(1, i);
                    break;
                }
                if (B[i].t % 5 == 0) B[i].How = rand() % 4;
                if (B[i].what == 9) {
                    if (B[i].t == 7) {
X9:
                        float xx = (rand() % 41) / 40.0, yy = (rand() % 41) / 40.0;
                        if (xx <= 0.5 && yy <= 0.5) goto X9;
                        for (int j = 1; j <= 4; j++) {
                            br++, B[br].what = 9;
                            B[br].t = 11;
                            B[br].x = B[i].x, B[br].y = B[i].y, B[br].vx = xx, B[br].vy = yy;
                            if (j % 2 == 0)swap(B[br].vx, B[br].vy), B[br].vy *= -1;
                            if (j <= 2)B[br].vx *= -1, B[br].vy *= -1;
                            B[br].life = 1;
                        }
                        B[i].life = 0;
                    }
                }
                if (B[i].what == 8) {
                    if (B[i].x > X && B[i].vx < 1.2) B[i].vx += fmax((float)0, 0.2 - B[i].t / 25);
                    if (B[i].x < X && B[i].vx > -1.2) B[i].vx -= fmax((float)0, 0.2 - B[i].t / 25);
                    if (B[i].y > Y && B[i].vy < 1.2) B[i].vy += fmax((float)0, 0.2 - B[i].t / 25);
                    if (B[i].y < Y && B[i].vy > -1.2) B[i].vy -= fmax((float)0, 0.2 - B[i].t / 25);
                }
            }
            if (B[i].what >= 13 && B[i].what <= 15 && B[i].How != 0) {
                if (B[i].x == B[i].How)B[i].vx = 0, B[i].How = 0;
            }
            if (B[i].what == 16) {
                if (B[i].x < X && B[i].vx >= -1) B[i].vx -= 0.2;
                else if (B[i].x > X && B[i].vx <= 1) B[i].vx += 0.2;
            }
        }
        if (B[i].life == 1 && B[i].a == 0 && B[i].what > 0) {
            if (B[i].y > Y && abs(B[i].x - X) <= 3 &&
                    ((B[i].x - X) * (B[i].x - X) + (B[i].y - Y) * (B[i].y - Y)) < Dis) Dis =
                            (B[i].x - X) * (B[i].x - X) + (B[i].y - Y) * (B[i].y - Y), Disb = i;
            else if (((B[i].x - X) * (B[i].x - X) + (B[i].y - Y) * (B[i].y - Y)) < Dis1)
                Dis1 = (B[i].x - X) * (B[i].x - X) + (B[i].y - Y) * (B[i].y - Y), Disb1 = i;
        }
    }
}
void Guai(int R, int r) {
//      Blo=100;
    if (R == -1) {
        br++;
        B[br].what = -1;
        B[br].x = X + rand() % 3 - 1;
        B[br].y = Y + rand() % 3 - 1;
        B[br].life = 1;
    }
    if (R <= -2 && R >= -11) {
        br++;
        B[br].what = R;
        B[br].x = B[br].a = r;
        B[br].y = 29;
        if (R <= -3 && R >= -7)B[br].vx = -1;
        B[br].vy = 1;
        B[br].life = 1;
    }
    if (R == 0) {
        br++;
        B[br].what = 1;
        B[br].x = r;
        B[br].y = 29;
        B[br].vy = 1;
        B[br].life = 1;
    }
    if (R == 1) {
        br++;
        B[br].what = 2;
        B[br].x = r;
        B[br].y = 29;
        B[br].vy = 1;
        B[br].life = 1;
    }
    if (R == 2 || R == 3) {
        br++;
        B[br].what = 2 * R - 1;
        B[br].x = r;
        B[br].y = 29;
        B[br].vy = 1;
        B[br].life = 1;
    }
    if (R == 4) {
        br++;
        B[br].what = 6;
        if (r < 5)r = 5;
        if (r > 30)r = 30;
        B[br].x = r;
        if (r == 11 || r == 25) B[br].y = 29 - (rand() % 20);
        else B[br].y = 29;
X4:
        B[br].vx = (rand() % 21 - 10) / 30.0;
        B[br].vy = (rand() % 25) / 30.0;
        if (B[br].vx <= 0.8 && B[br].vy <= 0.8)goto X4;
        int rx = rand() % 50;
        if (rx == 0) B[br].vx = 0;
        B[br].life = 1;
    }
    if (R == 5) {
        br++;
        B[br].How = r;
        B[br].what = 7;
        if (B[br].How < 0) B[br].x = 19;
        if (B[br].How > 0) B[br].x = 21;
        B[br].y = 29;
        B[br].vy = 1;
        B[br].life = 1;
    }
}
void CpGuai(int R, float x, float y, float xx, float yy) {
//      Blo=100;
    if (R == 4) {
        br++;
        B[br].what = 6;
        B[br].x = x;
        B[br].y = y;
        B[br].vx = xx;
        B[br].vy = yy;
        B[br].life = 1;
    }
    if (R == 6 || R == 7 || R == 8) {
        br++;
        B[br].what = 4 + R;
        B[br].x = x;
        B[br].y = y;
        B[br].vx = xx;
        B[br].vy = yy;
        B[br].life = 1;
    }
}
void MesGuai(int a, int rr) {
//      Blo=100;
    int R = rand() % rr, r = -10086;
    if (R == 0) {
        if (a == 1) r = (5 + rand() % 8) * 2;
        if (a <= 3 && a != 1) r = 10 + rand() % 16;
        if (a == 4) r = rand() % 75 - 20;
        if (a == 5) r = 2 + rand() % 4;
        if (r != -10086) Guai(a, r);
    }
}
void NorGuai(int a, int b) {
//      Blo=100;
    if (a == 1) {
        if (b == 1 || b == 41) Guai(0, 15), Guai(0, 17), Guai(0, 19);
        if (b == 21 || b == 61) Guai(0, 21), Guai(0, 23), Guai(0, 25);
        if (b == 81) Guai(0, 11), Guai(0, 13), Guai(0, 15), Guai(0, 17), Guai(0, 19);
        if (b == 101 ||
                b == 141) Guai(0, 17), Guai(0, 19), Guai(0, 21), Guai(0, 23), Guai(0, 25);
        if (b == 121) Guai(0, 15), Guai(0, 17), Guai(0, 19), Guai(0, 21), Guai(0, 23);
        if (b >= 160 && b <= 260 && b % 10 == 0) Guai(0, b / 10 - 1);
        if (b >= 270 && b <= 370 && b % 10 == 0) Guai(0, 52 - b / 10);
        if (b >= 460 && b <= 560 &&
                b % 10 == 0) Guai(0, b / 10 - 37), Guai(0, b / 10 - 36), Guai(0, b / 10 - 35);
        if (b >= 570 && b <= 670 &&
                b % 10 == 0) Guai(0, 78 - b / 10), Guai(0, 77 - b / 10), Guai(0, 76 - b / 10);
        if (b >= 760 && b <= 960 &&
                b % 10 == 0) Guai(0, b / 10 - 66), Guai(0, b / 10 - 65), Guai(0, 103 - b / 10),
                    Guai(0, 104 - b / 10);
        if (b >= 1000 && b <= 1300) MesGuai(0, 30 - b / 50);
    }
    if (a == 2) {
        if (b <= 200 && b % 30 == 1) {
            int r = rand() % 4;
            if (r == 1) r = 0;
            for (int i = 0; i < 4; i++) if (i != r) Guai(1, i * 4 + 9);
        }
        if (b > 200 && b <= 220 && b % 5 == 1) Guai(1, 18);
        if (b > 220 && b <= 300 && b % 7 == 1) Guai(1, b / 5 - 26);
        if (b > 350 && b <= 370 && b % 5 == 1) Guai(1, 22);
        if (b > 370 && b <= 450 && b % 7 == 1) Guai(1, 96 - b / 5);
        if (b == 461 || b == 501 || b == 541) Guai(1, 13), Guai(1, 17), Guai(1, 21);
        if (b == 481 || b == 521 || b == 561) Guai(1, 17), Guai(1, 21), Guai(1, 25);
        if (b >= 561 && b <= 861 && b % 20 == 1) Guai(1, b / 40 + 5);
        if (b >= 561 && b <= 861 && b % 20 == 11) Guai(1, 35 - b / 40);
        if (b >= 801 && b <= 961 && b % 15 == 1) Guai(1, 20);
        if (b >= 1000 && b <= 1300) MesGuai(1, 30 - b / 50);
    }
    if (a == 3) {
        if (b == 1 || b == 61) Guai(3, 15), Guai(2, 17), Guai(2, 19);
        if (b == 31 || b == 91) Guai(2, 21), Guai(2, 23), Guai(3, 25);
        if (b >= 120 && b <= 220 && b % 10 == 0) Guai(2, b / 10 + 3);
        if (b >= 240 && b <= 340 && b % 10 == 0) Guai(2, 49 - b / 10);
        if (b >= 360 && b <= 460 &&
                b % 20 == 0) Guai(2, b / 10 - 21), Guai(2, 61 - b / 10);
        if (b >= 480 && b <= 580 &&
                b % 20 == 0) Guai(3, b / 10 - 33), Guai(3, 73 - b / 10);
        if (b >= 600 && b < 750 && b % 30 == 0) {
            for (int i = 0; i < 5; i++) Guai(3, i * 3 + 10);
        }
        if (b >= 750 && b < 830 && b % 10 == 0) if (b <= 200 &&
                    b % 40 == 1) Guai(2, X);
        if (b >= 830 && b < 910 && b % 20 == 0) Guai(2, X);
        if (b >= 910 && b < 980 && b % 10 == 0) Guai(2, X);
        if (b >= 1000 && b <= 1300) MesGuai(rand() % 2 + 2, 40 - b / 50);
    }
    if (a == 4) {
        if (b == 1) CpGuai(4, 10, 29, -0.4, 0.7), CpGuai(4, 14, 29, -0.2, 0.7),
            CpGuai(4, 21, 29, 0, 0.65);
        if (b == 41) CpGuai(4, 10, 29, -0.2, 0.7), CpGuai(4, 14, 29, -0.1, 0.7),
            CpGuai(4, 18, 29, 0, 0.65);
        if (b == 81) CpGuai(4, 5, 20, -0.4, 0.35), CpGuai(4, 10, 29, -0.4, 0.7),
            CpGuai(4, 14, 29, -0.2, 0.7), CpGuai(4, 30, 20, 0.25, 0.4), CpGuai(4, 21, 29, 0,
                    0.65);
        if (b == 121) CpGuai(4, 5, 20, -0.2, 0.35), CpGuai(4, 10, 29, -0.2, 0.7),
            CpGuai(4, 14, 29, -0.1, 0.7), CpGuai(4, 30, 20, 0.4, 0.4), CpGuai(4, 18, 29, 0,
                    0.65);
        if (b == 161) CpGuai(4, 10, 29, -0.4, 0.7), CpGuai(4, 14, 29, -0.2, 0.7),
            CpGuai(4, 21, 29, 0, 0.6), CpGuai(4, 10, 29, -0.2, 0.7), CpGuai(4, 14, 29, -0.1,
                    0.7), CpGuai(4, 18, 29, 0, 0.65);
        if (b >= 200 && b <= 500 && b % 40 == 1) {
            float r = 0, rr;
            for (int i = 1; i <= 5; i++) {
X5:
                rr = 0.7 + (rand() % 5) / 10.0;
                if (rr == r)goto X5;
                r = rr;
                CpGuai(4, i * 3 + 7, 29, 0, 0.5 + (rand() % 50) / 80.0);
            }
        }
        if (b > 540 && b <= 565 && b % 5 == 1) CpGuai(4, 5, 8, -2, 0.2);
        if (b > 590 && b <= 615 && b % 5 == 1) CpGuai(4, 30, 8, 1.5, 0.2);
        if (b > 640 && b <= 665 && b % 5 == 1) CpGuai(4, 5, 8, -1.5, 0.3);
        if (b > 690 && b <= 715 && b % 5 == 1) CpGuai(4, 30, 8, 2, 0.3);
        if (b >= 750 && b <= 950 && b % 20 == 1) {
            float r = 0, rr;
            for (int i = 1; i <= 3; i++) {
X6:
                rr = 0.7 + (rand() % 5) / 10.0;
                if (rr == r)goto X6;
                r = rr;
                CpGuai(4, i * 5 + 7 + (rand() % 3), 29, 0, 0.5 + (rand() % 50) / 200.0);
            }
        }
        if (b >= 1000 && b <= 1300) MesGuai(4, 5);
    }
}
void RandGood() {
//      Blo=100;
    if (Biao > 0) {
        Biao--;
        Guai(-1, 0);
    }
    if (Gd[1] == 0) {
        Gd[1] = rand() % 1000 + 1;
        if (Win == 7)Gd[1] = 10086;
        Gd[3] = rand() % 16 + 8;
    } else if (Gd[1] <= 5) {
        Guai(-2 - Gd[1], Gd[3]);
        memset(Gd, 0, sizeof(Gd));
    } else if (Gd[1] >= 20 && Gd[1] < 27) {
        Guai(-8, Gd[3]);
        memset(Gd, 0, sizeof(Gd));
    } else if (Gd[1] >= 30 && Gd[1] < 37) {
        Guai(-9, Gd[3]);
        memset(Gd, 0, sizeof(Gd));
    } else if (Gd[1] >= 40 && Gd[1] < 70) {
        Gd[2]++;
        if (Gd[2] % 2 == 1)Guai(-10, Gd[3]);
        if (Gd[2] >= 9)memset(Gd, 0, sizeof(Gd));
    } else if (Gd[1] >= 70 && Gd[1] < 100) {
        Gd[2]++;
        if (Gd[2] % 2 == 1)Guai(-11, Gd[3]);
        if (Gd[2] >= 9)memset(Gd, 0, sizeof(Gd));
    } else if (Boss != 0 && Gd[1] >= 450 && Gd[1] <= 500) {
        Guai(-2, Gd[3]);
        memset(Gd, 0, sizeof(Gd));
    } else Gd[1] = 0;
    for (int i = 0; i < 20; i++) {
        if (I[i][0] == -1) continue;
        Setpos(I[i][0], I[i][1]);
        Color(0);
        if (I[i][0] == 20) cout << "===";
        else cout << "   ";
        I[i][1]++;
        if (I[i][0] >= 28 || I[i][0] <= 0 || I[i][1] >= 29) I[i][0] = I[i][1] = -1;
        else Color(1), Setpos(I[i][0], I[i][1]), cout << "■";
        Color(0);
    }
}
void Panboss(int bx, int by) {
//      Blo=100;
    float Nox[4], Noy[4];
    Nox[0] = X, Noy[0] = Y;
    if (Down == 1 &&
            X == 22) Nox[1] = X + 1, Noy[1] = Y - 0.5, Nox[2] = X - 1, Noy[2] = Y - 0.5;
    else if (Down == 2) Nox[1] = X + 1, Noy[1] = Y - 0.5, Nox[2] = -10,
                                     Noy[2] = -10;
    else if (Down == 1 ||
             X < 18) Nox[1] = X - 1, Noy[1] = Y - 0.5, Nox[2] = -10, Noy[2] = -10;
    else Nox[1] = X + 1, Noy[1] = Y - 0.5, Nox[2] = X - 1, Noy[2] = Y - 0.5;
    for (int i = 0; i < 3; i++) {
        if ((Boss == 1 || Boss == 6) && Wind == 0 && Thun == 0 &&
                abs(Nox[i] - bx) < 1 && abs(Noy[i] - by) < 1 &&
                Bgo1[4] == 0) Blo -= 20, Bgo1[4] = 1, Killb = 20, Kill = 1;
        if ((Boss == 2 || Boss == 6) && Wind == 0 && Thun == 0 &&
                abs(Nox[i] - bx) < 1 && abs(Noy[i] - by) < 1 &&
                Bgo2[8] == 0) Blo -= 20, Bgo2[8] = 1, Killb = 20, Kill = 1;
    }
}
void Boss1() {
//      Blo=100;
    for (int j = 0; j < 20; j++)if (abs(Bx1 - I[j][0]) < 2 && By1 - I[j][1] <= 2) {
            Setpos(I[j][0], I[j][1]);
            if (I[j][0] == 20) cout << "===";
            else cout << "   ";
            I[j][0] = I[j][1] = -1;
            Bblo -= 8 + Lv * 2;
            Exp += 2;
        }
    if (Bbr == Bbl && Bbr != 0) Bbr = Bbl = 0;
    for (int i = 1; i <= 3 + (Bbl - Bbr) / 5; i++)if (Bbr < Bbl) {
            Setpos(Bway[Bbr][0], Bway[Bbr][1]);
            if (Bway[Bbr][0] == 20) cout << "==";
            else cout << "  ";
            Bbr++;
        }
    if (Bwhat1 == 5) {
        int bx, by;
        Color(5);
        for (int i = 0; i < 10; i++) {
            bx = Bx1 - i * Bvx1 / 10.0;
            by = By1 - i * Bvy1 / 10.0;
            Setpos(bx, by), cout << "█";
            Bbl++;
            Bway[Bbl][0] = bx;
            Bway[Bbl][1] = by;
        }
        Color(0);
    }
    Bx1 -= Bvx1;
    By1 -= Bvy1;
//      Blo=100;
    if (Bwhat1 == 0) {
X2:
        Bwhat1 = rand() % 7;
        if (Bwhat1 == 2 || Bwhat1 == 3) {
            if (By1 <= 10 || By1 > 25) goto X2;
        }
        if (Bwhat1 == 4) {
            if (By1 <= 15 || Bx1 < 20) goto X2;
            Bgo1[2] = Bx1;
            Bgo1[3] = By1 - 1;
        }
        if (Bwhat1 == 5) {
X0:
            Bgo1[3] = rand() % 4 + 1;
            Bvx1 = (rand() % 101) / 20.0;
            Bvy1 = (rand() % 101) / 20.0;
            if (Bgo1[3] <= 2) Bvx1 *= -1;
            if (Bgo1[3] % 2 == 1) Bvy1 *= -1;
            if (abs(Bvx1) + abs(Bvy1) <= 3 || Out1)goto X0;
        }
        if (Bwhat1 == 6) {
            if (By1 <= 17 || By1 > 25) goto X2;
        }
    }
    if (Bwhat1 == 1) {
        Bgo1[1]++, Bgo1[2]++;
        int R = rand() % (5 - Bgo1[1]), r = rand() % (10 - Bgo1[2]);
        if (Out1) R = 0;
        if (R == 0) {
            int vx = Bvx1, vy = Bvy1;
            Bgo1[1] = 0;
            Bvx1 = (rand() % 101 - 20) / 50.0;
            Bvy1 = (rand() % 101 - 20) / 50.0;
            if (Bgo1[3] <= 2) Bvx1 *= -1;
            if (Bgo1[3] % 2 == 1) Bvy1 *= -1;
            if (Out1) r = 0;
        }
        if (r == 0) Chang1
        }
    if (Bwhat1 == 2) {
        Bgo1[1]++;
        if (Bgo1[1] > 6) {
            Bvy1 = -0.3;
            br++;
            B[br].x = Bx1, B[br].y = By1 - 1;
            B[br].what = 6;
X3:
            B[br].vx = (rand() % 21 - 10) / 40.0;
            B[br].vy = (rand() % 25) / 30.0;
            if (B[br].vx <= 0.8 && B[br].vy <= 0.8)goto X3;
            int rx = rand() % 50;
            if (rx == 0) B[br].vx = 0;
            B[br].life = 1;
        }
        if (Bgo1[1] > 8) Chang1
        }
    if (Bwhat1 == 3) {
        Bgo1[1]++;
        if (Bgo1[1] > 6 && Bgo1[1] % 3 == 0) {
            Bvy1 = -0.3;
            br++;
            B[br].x = Bx1, B[br].y = By1 - 1;
            B[br].what = 8;
            B[br].life = 1;
        }
        if (Bgo1[1] > 15) Chang1
        }
    if (Bwhat1 == 4) {
        Bgo1[1]++;
        if (Bgo1[1] <= 8) {
            Setpos(Bgo1[2], Bgo1[3]);
            if (Bgo1[1] == 1)cout << " ";
            else if (Bgo1[1] > 1 && Bgo1[2] == 20) cout << "==";
            else cout << "  ";
            Bgo1[2]--;
            Setpos(Bgo1[2], Bgo1[3]);
            int r = rand() % 4;
            if (r % 2 == 0) Color(6);
            else Color(9);
            if (r < 2) cout << ") ";
            else cout << "】";
            Color(0);
        }
        if (Bgo1[1] == 6) Bgo1[5] = X, Bgo1[6] = Y;
        if (Bgo1[1] == 11) {
            Map(0, (bool)Kill);
            Setpos(Bgo1[5], Bgo1[6] + 1), cout << "  ";
            Setpos(Bgo1[5], Bgo1[6] - 1), cout << "  ";
            Setpos(Bgo1[5] + 1, Bgo1[6]), cout << "  ";
            Setpos(Bgo1[5] - 1, Bgo1[6]), cout << "  ";
            int bx, by, bvx = Bgo1[2] - Bgo1[5], bvy = Bgo1[3] - Bgo1[6];
            Color(6);
            int i = 0;
            while (1) {
                bx = Bgo1[2] - i * bvx / 30.0;
                by = Bgo1[3] - i * bvy / 30.0;
                if (bx <= 5 || bx >= 30 || by < 0 || by >= 29) break;
                Panboss(bx, by);
                Setpos(bx, by), cout << "█";
                Bbl++;
                Bway[Bbl][0] = bx;
                Bway[Bbl][1] = by;
                i++;
            }
            Color(0);
            Map(-1, 0);
            Chang1
        }
    }
    if (Bwhat1 == 5) {
        Bgo1[1]++, Bgo1[2]++;
        int R = rand() % (5 - Bgo1[1]), r = rand() % (10 - Bgo1[2]);
        if (Out1) R = 0;
        if (R == 0) {
            int vx = Bvx1, vy = Bvy1;
            Bgo1[1] = 0;
X1:
            Bvx1 = (rand() % 101 - 20) / 20.0;
            Bvy1 = (rand() % 101 - 20) / 20.0;
            if (Bgo1[3] <= 2) Bvx1 *= -1;
            if (Bgo1[3] % 2 == 1) Bvy1 *= -1;
            if (abs(Bvx1) + abs(Bvy1) <= 3 || abs(Bvx1 - vx) <= 1 ||
                    abs(Bvy1 - vy) <= 1)goto X1;
            if (Out1) r = 0;
        }
        if (r == 0) Chang1
        }
    if (Bwhat1 == 6) {
        Bgo1[1]++;
        if (Bgo1[1] > 6 && Bgo1[1] % 10 == 0) {
            By1 -= 1;
            br++;
            B[br].x = Bx1, B[br].y = By1 - 1;
            B[br].what = 9;
X30:
            B[br].vy = 1;
            B[br].life = 1;
        }
        if (Bgo1[1] > 31) Chang1
        }
}
void Boss2() {
//      Blo=100;
    for (int j = 0; j < 20; j++)if (abs(Bx2 - I[j][0]) < 2 && By2 - I[j][1] <= 2) {
            Setpos(I[j][0], I[j][1]);
            if (I[j][0] == 20) cout << "===";
            else cout << "   ";
            I[j][0] = I[j][1] = -1;
            Bblo -= 8 + Lv * 2;
            Exp += 2;
        }
    if (Bbr == Bbl && Bbr != 0) Bbr = Bbl = 0;
    for (int i = 1; i <= 3 + (Bbl - Bbr) / 5; i++)if (Bbr < Bbl) {
            Setpos(Bway[Bbr][0], Bway[Bbr][1]);
            if (Bway[Bbr][0] == 20) cout << "==";
            else cout << "  ";
            Bbr++;
        }
    Bx2 -= Bvx2;
    By2 -= Bvy2;
    if (Bwhat2 == 0) {
X21:
        Bwhat2 = rand() % 7;
        if (Bwhat2 == 2) {
X31:
            for (int i = 1; i <= 3; i++) {
                Bgo2[i * 2 + 1] = rand() % 28 + 1, Bgo2[i * 2] = rand() % 25 + 5;
                if ((abs(Bgo2[i * 2] - Bx2) <= 2 && abs(Bgo2[i * 2 + 1] - By2) <= 2) ||
                        (abs(Bgo2[i * 2] - X) <= 2 && abs(Bgo2[i * 2 + 1] - Y) <= 2))goto X31;
            }
            if (Bgo2[2] == Bgo2[4] || Bgo2[2] == Bgo2[6] || Bgo2[6] == Bgo2[4] ||
                    Bgo2[5] == Bgo2[3] || Bgo2[3] == Bgo2[7] || Bgo2[5] == Bgo2[7]) goto X31;
        }
        if (Bwhat2 == 3) {
            Bgo2[2] = rand() % 2;
        }
        if (Bwhat2 == 4 || Bwhat2 == 5 || Bwhat2 == 6) {
            Bvy2 = -1.5;
            Bvx2 = -0.5;
        }
    }
    if (Bwhat2 == 1) {
        Bgo2[1]++, Bgo2[2]++;
        int R = rand() % (5 - Bgo2[1]), r = rand() % (30 - Bgo2[2]);
        if (Out2) R = 0;
        if (R == 0) {
            int vx = Bvx2, vy = Bvy2;
            Bgo2[1] = 0;
            Bvx2 = (rand() % 101 - 20) / 50.0;
            Bvy2 = (rand() % 101 - 20) / 50.0;
            if (Bgo2[3] <= 2) Bvx2 *= -1;
            if (Bgo2[3] % 2 == 1) Bvy2 *= -1;
            if (Out2) r = 0;
        }
        if (r == 0) Chang2
        }
    if (Bwhat2 == 2) {
        Bgo2[1]++;
        float bx, by, bvx, bvy;
        if (Bgo2[1] < 21) {
            for (int i = 1; i <= 3; i++) {
                bvx = Bgo2[i * 2] - Bx2, bvy = Bgo2[i * 2 + 1] - By2;
                if (Bgo2[1] <= 10) {
                    Setpos(Bx2 + (Bgo2[1] - 1)*bvx / 10.0, By2 + (Bgo2[1] - 1)*bvy / 10.0);
                    if (abs(Bx2 + (Bgo2[1] - 1)*bvx / 10.0 - 20) < 0.5)cout << "==";
                    else cout << "  ";
                    bx = Bx2 + Bgo2[1] * bvx / 10.0;
                    by = By2 + Bgo2[1] * bvy / 10.0;
                    Setpos(bx, by);
                } else Setpos(Bgo2[i * 2], Bgo2[i * 2 + 1]);
                int r = rand() % 4;
                if (r % 2 == 0) Color(3);
                else Color(10);
                if (r <= 1) cout << "×";
                else cout << "＋";
                Color(0);
            }
        }
        if (Bgo2[1] == 21) {
            Map(0, (bool)Kill);
            Color(3);
            int j = 0;
            for (int j = 0; j <= 30; j++)for (int i = 1; i <= 3; i++)for (int k = 1; k <= 4;
                            k++) {
                        if (k == 1) bvx = j, bvy = 0;
                        if (k == 2) bvx = -j, bvy = 0;
                        if (k == 3) bvx = 0, bvy = j;
                        if (k == 4) bvx = 0, bvy = -j;
                        bx = Bgo2[i * 2] + bvx, by = Bgo2[i * 2 + 1] + bvy;
                        if (bx <= 5 || bx >= 30 || by < 0 || by >= 30) {
                            continue;
                        }
                        Panboss(bx, by);
                        Setpos(bx, by), cout << "█";
                        Bbl++;
                        Bway[Bbl][0] = bx;
                        Bway[Bbl][1] = by;
                    }
            Color(0);
            Map(-1, 0);
            Chang2
        }
    }
    if (Bwhat2 == 3) {
        Bgo2[1]++;
        if (Bgo2[1] <= 18) {
            if (Bgo2[3] == 0) Setpos(Bgo2[4] - 3, Bgo2[5]), cout << "  ",
                        Setpos(Bgo2[4] + 3, Bgo2[5]), cout << "  ", Color(0), Setpos(20, Bgo2[5]),
                        cout << "==";
            if (Bgo2[3] == 1) Setpos(Bgo2[4], Bgo2[5] - 3.5), cout << "    ",
                        Setpos(Bgo2[4], Bgo2[5] + 2.5), cout << "    ", Color(0), Setpos(20,
                                Bgo2[5] + 2.5), cout << "====", Setpos(20, Bgo2[5] - 3.5), cout << "====";
            if (Bgo2[1] % 4 == 0)Bgo2[3] = !Bgo2[3];
            if (Bgo2[1] % 6 < 3)Color(3);
            else Color(5);
            if (Bgo2[3] == 0) Setpos(X - 3, Y), cout << "▼", Setpos(X + 3, Y),
                        cout << "▲", Bgo2[4] = (int)(X + 0.5), Bgo2[5] = (int)(Y + 0.5);
            if (Bgo2[3] == 1) Setpos(X, Y - 3), cout << " ", Setpos(X, Y + 3), cout << " ",
                        Bgo2[4] = (int)(X + 0.5), Bgo2[5] = (int)(Y + 0.5);
            Color(0);
        }
        if (Bgo2[1] == 18) {
            if (Bgo2[3] == 0) Setpos(Bgo2[4] - 3, Bgo2[5]), cout << "  ",
                        Setpos(Bgo2[4] + 3, Bgo2[5]), cout << "  ", Color(0), Setpos(20, Bgo2[5]),
                        cout << "==";
            if (Bgo2[3] == 1) Setpos(Bgo2[4], Bgo2[5] - 3.5), cout << "    ",
                        Setpos(Bgo2[4], Bgo2[5] + 2.5), cout << "    ", Color(0), Setpos(20,
                                Bgo2[5] + 2.5), cout << "====", Setpos(20, Bgo2[5] - 3.5), cout << "====";
        }
        if (Bgo2[1] > 18 && Bgo2[1] <= 25) {
            Bgo2[3] = Bgo2[2];
            if (Bgo2[3] == 0) Setpos(Bgo2[4] - 3, Bgo2[5]), cout << "  ",
                        Setpos(Bgo2[4] + 3, Bgo2[5]), cout << "  ", Color(0), Setpos(20, Bgo2[5]),
                        cout << "==";
            if (Bgo2[3] == 1) Setpos(Bgo2[4], Bgo2[5] - 3.5), cout << "    ",
                        Setpos(Bgo2[4], Bgo2[5] + 2.5), cout << "    ", Color(0), Setpos(20,
                                Bgo2[5] + 2.5), cout << "====", Setpos(20, Bgo2[5] - 3.5), cout << "====";
            if (Bgo2[1] % 4 < 2)Color(3);
            else Color(5);
            if (Bgo2[3] == 0) Setpos(Bgo2[4] - 3, Bgo2[5]), cout << "▼",
                        Setpos(Bgo2[4] + 3, Bgo2[5]), cout << "▲";
            if (Bgo2[3] == 1) Setpos(Bgo2[4], Bgo2[5] - 3), cout << " ", Setpos(Bgo2[4],
                        Bgo2[5] + 3), cout << " ";
            Color(0);
        }
        if (Bgo2[1] == 25) {
            if (Bgo2[2] == 0) {
                Color(3);
                for (int i = 4; i <= 29; i++) {
                    Setpos(i, Bgo2[5]), cout << "█";
                    Bbl++;
                    Panboss(i, Bgo2[5]);
                    Bway[Bbl][0] = i;
                    Bway[Bbl][1] = Bgo2[5];
                }
            }
            if (Bgo2[2] == 1) {
                Color(3);
                for (int i = 0; i <= 28; i++) {
                    Setpos(Bgo2[4], i), cout << "█";
                    Bbl++;
                    Panboss(Bgo2[4], i);
                    Bway[Bbl][0] = Bgo2[4];
                    Bway[Bbl][1] = i;
                }
            }
            Chang2
        }
    }
    if (Bwhat2 == 4 || Bwhat2 == 5 || Bwhat2 == 6) {
        Bgo2[1]++;
        if (By2 > 27)Bvy2 = 0;
        if (Bx2 > 23)Bvx2 = 0;
        if (Bgo2[1] > 13 && Bgo2[1] % 3 == 0) {
            float t = By2 - Y, g = 0.35;
            if (Boss == 6) t /= 2.0;
            CpGuai(Bwhat2 + 2, Bx2, By2, (Bx2 - X) / t * 1.0 + (t - 1)*g / 2.0, 1);
        }
        if (Bgo2[1] > 20) Chang2
        }
}
void Boss3() {
//      Blo=100;
#define Bean br++;B[br].what=13;B[br].x=Bx3-1,B[br].y=By3-1;B[br].vy=1;B[br].life=1;
    for (int j = 0; j < 20; j++)if (abs(Bx3 - I[j][0]) < 2 && By3 - I[j][1] <= 2) {
            Setpos(I[j][0], I[j][1]);
            if (I[j][0] == 20) cout << "===";
            else cout << "   ";
            I[j][0] = I[j][1] = -1;
            Bblo -= 8 + Lv * 2;
            Exp += 2;
        }
    Bx3 -= Bvx3;
    By3 -= Bvy3;
    if (Bwhat3 <= 8) {
        if (Bx3 > X && Bvx3 < 1.5) Bvx3 += 0.3;
        if (Bx3 < X && Bvx3 > -1.5) Bvx3 -= 0.3;
    }
    if (Bwhat3 == 0) {
X22:
        Bwhat3 = rand() % 12;
        if (Bwhat3 == 11 && abs(Bx3 - 20) <= 1)goto X22;
        if (Bwhat3 == 11)Bgo3[2] = rand() % 5;
    }
    if (Bwhat3 == 1) {
        Bgo3[1]++;
        if (Bgo3[1] == 6) {
            br++;
            B[br].what = 13;
            B[br].x = (int)Bx3 - 1, B[br].y = By3 - 1;
            B[br].vy = 1;
            B[br].vx = 1;
            B[br].How = (int)Bx3 - 4;
            B[br].life = 1;
            br++;
            B[br].what = 13;
            B[br].x = (int)Bx3 - 1, B[br].y = By3 - 1;
            B[br].vy = 1;
            B[br].vx = -1;
            B[br].How = (int)Bx3 + 2;
            B[br].life = 1;
            br++;
            B[br].what = 13;
            B[br].x = (int)Bx3 - 1, B[br].y = By3 - 1;
            B[br].vy = 1;
            B[br].life = 1;
            Chang3
        }
    }
    if (Bwhat3 >= 2 && Bwhat3 <= 6) {
        Bgo3[1]++;
        if (Bgo3[1] == 6) {
            br++;
            B[br].x = (int)Bx3 - 1, B[br].y = By3 - 1;
            B[br].what = 11 + Bwhat3;
            B[br].vy = 0.5 + (rand() % 100) / 80.0;
            if (Bwhat3 == 5)B[br].vy = B[br].vy * 3 / 4.0;
            B[br].life = 1;
            Chang3
        }
    }
    if (Bwhat3 == 7) {
        Bgo3[1]++;
        if (Bgo3[1] == 6) {
            br++;
            B[br].what = 14;
            B[br].x = (int)Bx3 - 1, B[br].y = By3 - 1;
            B[br].vy = 1;
            B[br].vx = 1;
            B[br].How = (int)Bx3 - 4;
            B[br].life = 1;
            br++;
            B[br].what = 14;
            B[br].x = (int)Bx3 - 1, B[br].y = By3 - 1;
            B[br].vy = 1;
            B[br].vx = -1;
            B[br].How = (int)Bx3 + 2;
            B[br].life = 1;
            br++;
            B[br].what = 14;
            B[br].x = (int)Bx3 - 1, B[br].y = By3 - 1;
            B[br].vy = 1;
            B[br].life = 1;
            Chang3
        }
    }
    if (Bwhat3 == 8) {
        Bgo3[1]++;
        if (Bgo3[1] == 6) {
            br++;
            B[br].what = 15;
            B[br].x = (int)Bx3 - 1, B[br].y = By3 - 1;
            B[br].vy = 1;
            B[br].vx = 1;
            B[br].How = (int)Bx3 - 4;
            B[br].life = 1;
            br++;
            B[br].what = 15;
            B[br].x = (int)Bx3 - 1, B[br].y = By3 - 1;
            B[br].vy = 1;
            B[br].vx = -1;
            B[br].How = (int)Bx3 + 2;
            B[br].life = 1;
            br++;
            B[br].what = 15;
            B[br].x = (int)Bx3 - 1, B[br].y = By3 - 1;
            B[br].vy = 1;
            B[br].life = 1;
            Chang3
        }
    }
    if (Bwhat3 == 9) {
        Bvx3 = 0;
        Bgo3[1]++;
        if (Bgo3[1] == 6 || Bgo3[1] == 8) {
            Bean
        }
        if (Bgo3[1] >= 8)Chang3
        }
    if (Bwhat3 == 10) {
        Bvx3 = 0;
        Bgo3[1]++;
        if (Bgo3[1] == 6 || Bgo3[1] == 8 || Bgo3[1] == 10 || Bgo3[1] == 12) {
            Bean
        }
        if (Bgo3[1] >= 12)Chang3
        }
    if (Bwhat3 == 11) {
        Bvx3 = 0;
        Bgo3[1]++;
        if (Bgo3[1] >= 8)for (int i = 1; i <= 4; i++) {
                br++;
                B[br].what = 80 + 100 * Bgo3[2] + Bgo3[1] * 4 + i;
                B[br].x = Bx3 - 1, B[br].y = By3 - 1 + i;
                B[br].vy = 4;
                B[br].life = 1;
                br++;
                B[br].what = 99;
                B[br].x = Bx3, B[br].y = By3 - 1 + i;
                B[br].vy = 4;
                B[br].life = 1;
                br++;
                B[br].what = 99;
                B[br].x = Bx3 - 2, B[br].y = By3 - 1 + i;
                B[br].vy = 4;
                B[br].life = 1;
            }
        if (Bgo3[1] >= 20) {
            for (int i = 1; i <= 4; i++) {
                br++;
                B[br].what = 98;
                B[br].x = Bx3 - 1, B[br].y = By3 - 1 + i;
                B[br].vy = 4;
                B[br].life = 1;
                br++;
                B[br].what = 98;
                B[br].x = Bx3, B[br].y = By3 - 1 + i;
                B[br].vy = 4;
                B[br].life = 1;
                br++;
                B[br].what = 98;
                B[br].x = Bx3 - 2, B[br].y = By3 - 1 + i;
                B[br].vy = 4;
                B[br].life = 1;
            }
            Chang3
        }
    }
}
void Ball(int ball) {
//      Blo=100;
    if (ball == 1) {
        if (Fir < 3 && T % 8 == 0) Fir++;
        if (Fir > 0) {
            br++;
            B[br].what = -13;
            B[br].x = X;
            B[br].y = Y + rand() % 3 - 1;
            B[br].life = 1;
            if (Dis <= 30) B[br].a = Disb, B[Disb].a = 1, Fir--;
            else if (Boss != 0) B[br].a = 13880086, Fir--;
            else if (Dis != 13880087) B[br].a = Disb, B[Disb].a = 1, Fir--;
            else if (Dis1 != 13880087) B[br].a = Disb1, B[Disb1].a = 1, Fir--;
            else B[br].life = 0;
            Dis = Dis1 = 13880087;
        }
    }
    if (ball == 2) {
        if (T % 4 == 0)ib = (ib + 1) % 20, I[ib][1] = Y - 2;
        if (T % 16 == 0)I[ib][0] = X;
        if (T % 16 == 4)I[ib][0] = X - 1;
        if (T % 16 == 8)I[ib][0] = X + 1;
        if (T % 16 == 12)I[ib][0] = X - 2;
        if (T % 12 == 9)I[ib][0] = X + 2;
        if (Water == 1) {
            for (int i = X - 6; i <= X + 6;
                    i++)ib = (ib + 1) % 20, I[ib][0] = i, I[ib][1] = Y - 2 - 0.5 * abs(i - X);
        }
    }
    if (ball == 3) {
        if (Wind > 5) {
            if (Y < Ding - 1)Vy = 5;
            else Vy = 0;
            if (Up >= 1) Vx = -5;
            if (Down == 2) Vx = 5;
        }
        if (Wind < 5) {
            if (Y > Ding - 1)Vy = -5;
            else Vy = 0;
            if (Up >= 1) Vx = -5;
            if (Down == 2) Vx = 5;
        }
        if (Wind == 5) {
            if (Boss == 2) Ding = 12.25;
            else Ding = 6.25;
            if (Boss != 0) Bblo -= 16 + Lv * 4;
            if (Boss == 1) Chang1 if (Boss == 2) Chang2 if (Boss == 3) Chang3
                        system("color 3F");
            Sleep(20);
            system("color 6F");
            Sleep(10);
            system("color 0F");
            system("cls");
            for (int i = bl; i <= br; i++)if (B[i].what > 0)B[i].life = 0;
            Setpos(20, 0);
            for (int i = 1; i <= 60; i++) printf("=");
        }
    }
    if (ball == 4) {
        if (Thun == 1) {
            if (Boss != 0) Bblo -= 16 + Lv * 4;
            if (Boss == 1) Chang1 if (Boss == 2) Chang2 if (Boss == 3) Chang3
                        system("color 9F");
            Sleep(20);
            system("color 6F");
            Sleep(10);
            system("color 0F");
            system("cls");
            for (int i = bl; i <= br; i++)if (B[i].what > 0)B[i].life = 0;
            Setpos(20, 0);
            for (int i = 1; i <= 60; i++) printf("=");
        }
    }
    if (ball == 5) {
        system("cls");
        Color(5);
        Setpos(10, 10);
        cout << "新天赋！";
Y:
        int rr = rand() % 4 + 2;
        Setpos(12, 10);
        if (rr == Ren) goto Y;
        if (rr == 2)cout << "瞬跳";
        if (rr == 3)cout << "空之舞";
        if (rr == 4)cout << "三段跳";
        if (rr == 5)cout << "反重力跳跃";
        Setpos(14, 10);
        cout << "当前天赋：";
        if (Ren == 1)cout << "小无敌";
        if (Ren == 2)cout << "瞬跳";
        if (Ren == 3)cout << "空之舞";
        if (Ren == 4)cout << "三段跳";
        if (Ren == 5)cout << "反重力跳跃";
        Setpos(16, 10);
        cout << "换否？（y/n）";
G:
        char g = _getch();
        if (g == 'y')Ren = rr;
        else if (g != 'n')goto G;
        system("cls");
        Setpos(20, 0);
        Color(0);
        for (int i = 1; i <= 60; i++) printf("=");
    }
    if (ball == 6) {
        Color(4);
        for (float i = 1; i <= Bblo; i += Bblomax / 20.0)cout << "▄";
        Color(0);
        cout << ' ' << Bblo << "                              ";
        Color(0);
    }
    if (ball == 7) {
        Color(1);
        if (Win == 7 && T % 6 < 3)Color(3);
        for (float i = 1; i <= Blo; i += Blomax / 20.0)cout << "▄";
        Color(0);
        if (Win == 7 && T % 6 < 3)Color(3);
        printf(" %0.1f                              ", Blo);
    }
}
int main() {
    system("mode con cols=60 lines=37");
    CONSOLE_CURSOR_INFO cursor_info = {1, 0};
    SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info);
    srand((unsigned)time(NULL));
    Win = 0;
    Ren = 1;
    Lv = 1;
    Blo = Blomax = 100;
    Expmax = 300;
    Hui = 15;
    X = 18, Y = 6;
ReStart:
    system("cls");
    memset(B, 0, sizeof(B));
    memset(I, -1, sizeof(I));
    T = 0;
    bl = 0;
    br = -1;
    Upt = 0;
Start:
    Blo = Blomax * 100;
    Ding = 6.25;
START:
    ;
    memset(Bgo1, 0, sizeof(Bgo1));
    memset(Bgo2, 0, sizeof(Bgo2));
    memset(Bgo3, 0, sizeof(Bgo3));
    if (Win % 2 == 0) T = 0;
    if (Win % 2 == 0 && D == 0) {
        if (Win > 0)Ball(5);
        Boss = 0;
lL:
        L = rand() % 4 + 1;
        for (int i = 0; i <= Win / 2 - 1; i++)if (L == Ll[i]) goto lL;
        Ll[Win / 2] = L;
    }
    if (Win % 2 == 1 && D == 0) {
        if (Win == 7)Boss = 6, T = 0, Blomax += 100;
        else {
bl:
            Boss = rand() % 3 + 1;
            for (int i = 0; i <= 3; i++)if (Boss == Bl[i]) goto bl;
        }
        Bl[Win / 2] = Boss;
        Bwhat1 = Bwhat2 = Bwhat3 = 0, Bx1 = 10, By1 = 20, Bx2 = 15, By2 = 20, Bx3 = 21,
        By3 = 20;
        system("color 4C");
        Sleep(20);
        system("color 0F");
        Map(0, 1);
        Sleep(1000);
    }
    if (Win % 2 == 1) {
        Bblomax = 500 + (Win / 2) * 500;
        Bblo = Bblomax;
        if (Boss == 2) Ding = 12.25;
    }
    while (1) {
        Blo = 100;
        T++;
        if (Wind == 0) {
            if (GetAsyncKeyState(VK_LEFT) & 0x8000) Vy = -(10 - abs(Ding - Y) * 1.5) / 20.0;

            if (GetAsyncKeyState(VK_RIGHT) & 0x8000) Vy = (10 - abs(Ding - Y) * 1.5) / 20.0;
        }
        if (GetAsyncKeyState(VK_UP) & 0x8000 && u1 == 0) {
            u1++;
            if (Down == 1) {
                Down = 0;
                Up = 0;
                if (Ren == 2)Map(-1, 0), Vx = 0, X = 18, Li = 5;
                else Vx = 7, Vy = 0.3;
            } else if (Up == 0 && Wind == 0) {
                Down = 0;
                Up = 1;
                if (Ren == 2)Map(-1, 0), Vx = 1, X = 10, Map(0, 3), Li = 5;
                else Vx = 2, Vy = 0.1;
            } else if (Up == 1 && Wind == 0) {
                Down = 0;
                Up = 2;
                if (Ren == 2)Map(-1, 0), Vx = 1, X -= 6, Map(0, 3), Li = 5;
                else Vx = 1.5, Vy = 0.1;
            } else if (Ren == 3 && Up == 2 && Wind == 0) {
                Down = 0;
                Up = 3;
                Vx = 1;
                Vy = 0.5;
                Upt = 30;
            } else if (Ren == 4 && Up == 2 && Wind == 0) {
                Down = 0;
                Up = 3;
                Vx = 1.8;
                Vy = 0.1;
            }
        }
        if (GetAsyncKeyState(VK_DOWN) & 0x8000 && u2 == 0) {
            u2++;
            if (Down == 1 && Ren == 5) {
                Down = 2;
                Up = 0;
                Vx = -1.7;
            } else {
                Down = 1;
                Up = 0;
                if (Ren == 2)Map(-1, 0), Vx = 0, X = 22, Map(0, 3), Li = 5;
                else {
                    if (Upt != 0) Map(-1, 0), Upt = 0;
                    Vx = -7;
                }
            }
        }
        if ((GetAsyncKeyState(VK_UP) & 0x8000) ? 0 : 1) u1 = 0;
        if ((GetAsyncKeyState(VK_DOWN) & 0x8000) ? 0 : 1) u2 = 0;
        if (kbhit()) {
            char g = _getch();
            if (g == ' ') Sleep(100), Setpos(4, 1), Sy++, system("pause");
        }
        if (Sy == 1) Setpos(4, 1), printf("                           "), Sy--;
        if (Drug == 0) Blo = fmin((float)Blomax, Blo + Hui / 100.0);
        else if (T % 10 == 0)Blo--;
        if (T % 20 == 0) {
            if (Kill != 0) Kill = 0;
            if (Lvl != 0) Lvl = 0;
        }
        if (Killb > 0) Killb--;
        if (Li > 0) Li--;
        if (Ice > 0) Ice--;
        if (Drug > 0) Drug--;
        if (Magne > 0) Magne--;
        if (Fire > 0) Ball(1), Fire--;
        if (Water > 0) Ball(2), Water--;
        if (Wind > 0) Ball(3), Wind--;
        if (Thun > 0) Ball(4), Thun--;
        if (Boss == 0) NorGuai(L, T % 1500);
        RandGood();
        if (T % 20 == 1)Exp++;
        if (T % 50 == 1) {
            Exp++;
            system("cls");
            Setpos(20, 0);
            Color(0);
            for (int i = 1; i <= 60; i++) printf("=");
            if (Win == 0 && T < 300) {
                Setpos(4, 6);
                cout << "↑/↓ 跳跃/下翻，←→ 些微移动（松手即返回）";
                Setpos(8, 6);
                cout << "球可以开启特殊效果，经验积满（300）可提升级别。";
                Setpos(8, 6);
                cout << "打败 7 波即胜利，打败 BOSS 有新天赋。";
                Setpos(10, 15);
                cout << "空格可以暂停。";
            }
        }
        Map(-1, 0);
        if (Boss == 1) Boss1();
        if (Boss == 2) Boss2();
        if (Boss == 3) Boss3();
        if (Boss == 6) Boss1(), Boss2(), Boss3();
        Move();
        Map(0, (bool)Kill);
        Color(0);
        Setpos(1, 1);
        Blo = fmin(Blo, (float)Blomax);
        if (Boss == 0)cout << "血量: " << (int)Blo << "  ";
        Color(0);
        Setpos(1, 9), cout << "死亡次数: " << D << "  ";
        Setpos(2, 1);
        Exp = min(Exp, Expmax);
        if (Exp >= Expmax)Exp = 0, Lv++, Lvl++, Hui++, Blomax += 5;
        if (Lvl > 0)Color(5);
        cout << "级别: " << Lv;
        Color(0);
        Setpos(2, 9);
        cout << "经验: " << Exp << "  ";
        if (Boss > 0) Setpos(3, 1), cout << "血量     : ", Ball(7);
        if (Boss > 0 && Boss != 6) Setpos(4, 1), cout << "怪物血量: ", Ball(6);
        if (Boss == 6) Setpos(1, 9), printf("时间: %0.1f s  ", T / 15.0);
        if (Win == 0) Sleep(55);
        if (Win == 1) Sleep(50);
        if (Win == 2) Sleep(35);
        if (Win == 3) Sleep(40);
        if (Win == 4) Sleep(25);
        if (Win == 5) Sleep(30);
        if (Win == 6) Sleep(20);
        if (Win >= 7) Sleep(17);
        if (Boss == 3 && Bblo <= 0) {
            for (int i = 1; i <= 4; i++) {
                br++;
                B[br].what = 98;
                B[br].x = Bx3 - 1, B[br].y = By3 - 1 + i;
                B[br].vy = 4;
                B[br].life = 1;
                br++;
                B[br].what = 98;
                B[br].x = Bx3, B[br].y = By3 - 1 + i;
                B[br].vy = 4;
                B[br].life = 1;
                br++;
                B[br].what = 98;
                B[br].x = Bx3 - 2, B[br].y = By3 - 1 + i;
                B[br].vy = 4;
                B[br].life = 1;
            }
        }
        if ((Win % 2 == 0 && T >= 1400) || (Win % 2 == 1 && Bblo <= 0) || (Win == 7 &&
                T >= 450) || Blo <= 0) {
            Map(-1, 0);
            break;
        }
    }
    if (Blo <= 0) {
//          Blo=100;
        Sleep(1000);
        D++;
        system("color 7F");
        Setpos(15, 11);
        Color(4);
        cout << "GAME OVER...";
        Sleep(2000);
        goto ReStart;
    } else if (Win == 6) {
        system("color 7F");
        Setpos(15, 11);
        Color(4);
        cout << "坚持30秒 !";
        Sleep(2000);
        Setpos(30, 0);
        Win++;
        D = 0;
    } else if (Win == 7) {
        Sleep(1000);
        system("color 6E");
        Setpos(15, 11);
        Color(5);
        cout << "YOU WIN !";
        Sleep(2000);
        Setpos(30, 0);
        goto START;
        return 0;
    } else Sleep(1000), Win++, D = 0;
    goto Start;
}