• 个人简介

    //俄罗斯方块游戏(1131行,来源CSDN🎉️ )
    #include<iostream>
    #include<string>
    #include<ctime>
    #include<cstdlib>
    #include<windows.h>
    #include<conio.h>
    
    using namespace std;
    
    int block00[4][4] = { { 10,0,0,0 },{ 1,1,1,1 },{ 0,0,0,0 },{ 0,0,0,0 } };
    int block01[4][4] = { { 11,0,1,0 },{ 0,0,1,0 },{ 0,0,1,0 },{ 0,0,1,0 } };
    int block02[4][4] = { { 12,0,0,0 },{ 0,0,0,0 },{ 1,1,1,0 },{ 0,1,0,0 } };
    int block03[4][4] = { { 13,0,0,0 },{ 0,1,0,0 },{ 1,1,0,0 },{ 0,1,0,0 } };
    int block04[4][4] = { { 14,0,0,0 },{ 0,0,0,0 },{ 0,1,0,0 },{ 1,1,1,0 } };
    int block05[4][4] = { { 15,0,0,0 },{ 0,1,0,0 },{ 0,1,1,0 },{ 0,1,0,0 } };
    int block06[4][4] = { { 16,0,0,0 },{ 0,0,0,0 },{ 1,1,1,0 },{ 1,0,0,0 } };
    int block07[4][4] = { { 17,0,0,0 },{ 1,1,0,0 },{ 0,1,0,0 },{ 0,1,0,0 } };
    int block08[4][4] = { { 18,0,0,0 },{ 0,0,0,0 },{ 0,0,1,0 },{ 1,1,1,0 } };
    int block09[4][4] = { { 19,0,0,0 },{ 0,1,0,0 },{ 0,1,0,0 },{ 0,1,1,0 } };
    int block10[4][4] = { { 20,0,0,0 },{ 0,0,0,0 },{ 1,1,1,0 },{ 0,0,1,0 } };
    int block11[4][4] = { { 21,0,0,0 },{ 0,1,0,0 },{ 0,1,0,0 },{ 1,1,0,0 } };
    int block12[4][4] = { { 22,0,0,0 },{ 0,0,0,0 },{ 1,0,0,0 },{ 1,1,1,0 } };
    int block13[4][4] = { { 23,0,0,0 },{ 0,1,1,0 },{ 0,1,0,0 },{ 0,1,0,0 } };
    int block14[4][4] = { { 24,0,0,0 },{ 0,0,0,0 },{ 0,1,1,0 },{ 1,1,0,0 } };
    int block15[4][4] = { { 25,0,0,0 },{ 1,0,0,0 },{ 1,1,0,0 },{ 0,1,0,0 } };
    int block16[4][4] = { { 26,0,0,0 },{ 0,0,0,0 },{ 1,1,0,0 },{ 0,1,1,0 } };
    int block17[4][4] = { { 27,0,0,0 },{ 0,0,1,0 },{ 0,1,1,0 },{ 0,1,0,0 } };
    int block18[4][4] = { { 28,0,0,0 },{ 0,0,0,0 },{ 1,1,0,0 },{ 1,1,0,0 } };
    
    void initialWindow(HANDLE hOut);//初始化窗口
    void initialPrint(HANDLE hOut);//初始化界面
    void gotoXY(HANDLE hOut, int x, int y);//移动光标
    void roundBlock(HANDLE hOut, int block[4][4]);//随机生成方块并打印到下一个方块位置
    bool collisionDetection(int block[4][4], int map[21][12], int x, int y);//检测碰撞
    void printBlock(HANDLE hOut, int block[4][4], int x, int y);//打印方块
    void clearBlock(HANDLE hOut, int block[4][4], int x, int y);//消除方块
    void myLeft(HANDLE hOut, int block[4][4], int map[21][12], int x, int &y);//左移
    void myRight(HANDLE hOut, int block[4][4], int map[21][12], int x, int &y);//右移
    void myUp(HANDLE hOut, int block[4][4], int map[21][12], int x, int &y);//顺时针旋转90度
    int myDown(HANDLE hOut, int block[4][4], int map[21][12], int &x, int y);//加速下落
    void myStop(HANDLE hOut, int block[4][4]);//游戏暂停
    void gameOver(HANDLE hOut, int block[4][4], int map[21][12]);//游戏结束
    void eliminateRow(HANDLE hOut, int map[21][12], int &val, int &fraction, int &checkpoint);//判断是否能消行并更新分值
    int main()
    {
        int map[21][12];
        int blockA[4][4];//候选区的方块
        int blockB[4][4];//下落中的方块
        int positionX, positionY;//方块左上角的坐标
        bool check;//检查方块还能不能下落
        char key;//用来存储按键
        int val;//用来控制下落速度
        int fraction;//用来存储得分
        int checkpoint;//用来存储关卡
        int times;
        HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//获取标准输出设备句柄
        initialWindow(hOut);
    initial:
        gotoXY(hOut, 0, 0);
        initialPrint(hOut);
        check = true;
        val = 50;
        fraction = 0;
        checkpoint = 1;
        times = val;
        for (int i = 0; i < 20; ++i)
        {
            for (int j = 1; j < 11; ++j)
            {
                map[i][j] = 0;
            }
        }
        for (int i = 0; i < 20; ++i)
        {
            map[i][0] = map[i][11] = 1;
        }
        for (int i = 0; i < 12; ++i)
        {
            map[20][i] = 1;
        }
    
        srand((unsigned)time(NULL));
        roundBlock(hOut, blockA);
        while (true)
        {
            if (check)
            {
                eliminateRow(hOut, map, val, fraction, checkpoint);
                check = false;
                positionX = -3;
                positionY = 4;
                if (collisionDetection(blockA, map, positionX, positionY))
                {
                    for (int i = 0; i < 4; ++i)
                    {
                        for (int j = 0; j < 4; ++j)
                        {
                            blockB[i][j] = blockA[i][j];
                        }
                    }
                    roundBlock(hOut, blockA);
                }
                else
                {
                    gameOver(hOut, blockA, map);
                    goto initial;
                }
            }
            printBlock(hOut, blockB, positionX, positionY);
            if (_kbhit())
            {
                key = _getch();
                switch (key)
                {
                case 72:
                    myUp(hOut, blockB, map, positionX, positionY);
                    break;
                case 75:
                    myLeft(hOut, blockB, map, positionX, positionY);
                    break;
                case 77:
                    myRight(hOut, blockB, map, positionX, positionY);
                    break;
                case 80:
                    switch (myDown(hOut, blockB, map, positionX, positionY))
                    {
                    case 0:
                        check = false;
                        break;
                    case 1:
                        check = true;
                        break;
                    case 2:
                        gameOver(hOut, blockB, map);
                        goto initial;
                    default:
                        break;
                    }
                    break;
                case 32:
                    myStop(hOut, blockA);
                    break;
                case 27:
                    exit(0);
                default:
                    break;
                }
            }
            Sleep(20);
            if (0 == --times)
            {
                switch (myDown(hOut, blockB, map, positionX, positionY))
                {
                case 0:
                    check = false;
                    break;
                case 1:
                    check = true;
                    break;
                case 2:
                    gameOver(hOut, blockB, map);
                    goto initial;
                default:
                    break;
                }
                times = val;
            }
        }
        cin.get();
        return 0;
    }
    
    void initialWindow(HANDLE hOut)
    {
        SetConsoleTitle("俄罗斯方块");
        COORD size = { 80, 25 };
        SetConsoleScreenBufferSize(hOut, size);
        SMALL_RECT rc = { 0, 0, 79, 24 };
        SetConsoleWindowInfo(hOut, true, &rc);
        CONSOLE_CURSOR_INFO cursor_info = { 1, 0 };
        SetConsoleCursorInfo(hOut, &cursor_info);
    }
    
    void initialPrint(HANDLE hOut)
    {
        SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        for (int i = 0; i < 20; ++i)
        {
            cout << "■                    ■☆                      ☆" << endl;
        }
        gotoXY(hOut, 26, 0);
        cout << "☆☆☆☆☆☆☆☆☆☆☆";
        gotoXY(hOut, 0, 20);
        cout << "■■■■■■■■■■■■☆☆☆☆☆☆☆☆☆☆☆☆☆";
        gotoXY(hOut, 26, 1);
        cout << "分    数:      ";
        gotoXY(hOut, 26, 2);
        cout << "关    卡:      ";
        gotoXY(hOut, 26, 4);
        cout << "下一方块:";
        gotoXY(hOut, 26, 9);
        cout << "操作方法:";
        gotoXY(hOut, 30, 11);
        cout << "↑:旋转 ↓:速降";
        gotoXY(hOut, 30, 12);
        cout << "→:右移 ←:左移";
        gotoXY(hOut, 30, 13);
        cout << "空格键:开始/暂停";
        gotoXY(hOut, 30, 14);
        cout << "Esc 键:退出";
        gotoXY(hOut, 26, 16);
        cout << "关    于:";
        gotoXY(hOut, 30, 18);
        cout << "俄罗斯方块V1.0";
        gotoXY(hOut, 35, 19);
        cout << "作者:潘约尔";
    }
    
    void gotoXY(HANDLE hOut, int x, int y)
    {
        COORD pos;
        pos.X = x;
        pos.Y = y;
        SetConsoleCursorPosition(hOut, pos);
    }
    
    void roundBlock(HANDLE hOut, int block[4][4])
    {
        clearBlock(hOut, block, 5, 15);
        switch (rand() % 19)
        {
        case 0:
            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    block[i][j] = block00[i][j];
                }
            }
            break;
        case 1:
            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    block[i][j] = block01[i][j];
                }
            }
            break;
        case 2:
            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    block[i][j] = block02[i][j];
                }
            }
            break;
        case 3:
            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    block[i][j] = block03[i][j];
                }
            }
            break;
        case 4:
            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    block[i][j] = block04[i][j];
                }
            }
            break;
        case 5:
            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    block[i][j] = block05[i][j];
                }
            }
            break;
        case 6:
            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    block[i][j] = block06[i][j];
                }
            }
            break;
        case 7:
            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    block[i][j] = block07[i][j];
                }
            }
            break;
        case 8:
            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    block[i][j] = block08[i][j];
                }
            }
            break;
        case 9:
            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    block[i][j] = block09[i][j];
                }
            }
            break;
        case 10:
            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    block[i][j] = block10[i][j];
                }
            }
            break;
        case 11:
            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    block[i][j] = block11[i][j];
                }
            }
            break;
        case 12:
            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    block[i][j] = block12[i][j];
                }
            }
            break;
        case 13:
            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    block[i][j] = block13[i][j];
                }
            }
            break;
        case 14:
            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    block[i][j] = block14[i][j];
                }
            }
            break;
        case 15:
            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    block[i][j] = block15[i][j];
                }
            }
            break;
        case 16:
            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    block[i][j] = block16[i][j];
                }
            }
            break;
        case 17:
            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    block[i][j] = block17[i][j];
                }
            }
            break;
        case 18:
            for (int i = 0; i < 4; ++i)
            {
                for (int j = 0; j < 4; ++j)
                {
                    block[i][j] = block18[i][j];
                }
            }
            break;
        default:
            break;
        }
        printBlock(hOut, block, 5, 15);
    }
    
    bool collisionDetection(int block[4][4], int map[21][12], int x, int y)
    {
        for (int i = 0; i < 4; ++i)
        {
            for (int j = 0; j < 4; ++j)
            {
                if (x + i >= 0 && y + j >= 0 && map[x + i][y + j] == 1 && block[i][j] == 1)
                {
                    return false;
                }
            }
        }
        return true;
    }
    
    void printBlock(HANDLE hOut, int block[4][4], int x, int y)
    {
        switch (block[0][0])
        {
        case 10:
        case 11:
            SetConsoleTextAttribute(hOut, FOREGROUND_GREEN);
            break;
        case 12:
        case 13:
        case 14:
        case 15:
            SetConsoleTextAttribute(hOut, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            break;
        case 16:
        case 17:
        case 18:
        case 19:
            SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            break;
        case 20:
        case 21:
        case 22:
        case 23:
            SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY);
            break;
        case 24:
        case 25:
            SetConsoleTextAttribute(hOut, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
            break;
        case 26:
        case 27:
            SetConsoleTextAttribute(hOut, FOREGROUND_BLUE | FOREGROUND_INTENSITY);
            break;
        case 28:
            SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_INTENSITY);
            break;
        default:
            break;
        }
        for (int i = 0; i < 4; ++i)
        {
            if (i + x >= 0)
            {
                for (int j = 0; j < 4; ++j)
                {
                    if (block[i][j] == 1)
                    {
    
                        gotoXY(hOut, 2 * (y + j), x + i);
                        cout << "■";
                    }
                }
            }
        }
    }
    
    void clearBlock(HANDLE hOut, int block[4][4], int x, int y)
    {
        for (int i = 0; i < 4; ++i)
        {
            if (i + x >= 0)
            {
                for (int j = 0; j < 4; ++j)
                {
                    if (block[i][j] == 1)
                    {
                        gotoXY(hOut, 2 * (y + j), x + i);
                        cout << "  ";
                    }
                }
            }
        }
    }
    
    void gameOver(HANDLE hOut, int block[4][4], int map[21][12])
    {
        SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_INTENSITY);
        gotoXY(hOut, 9, 8);
        cout << "GAME OVER";
        gotoXY(hOut, 8, 9);
        cout << "空格键:重来";
        gotoXY(hOut, 8, 10);
        cout << "ESC键:退出";
        char key;
        while (true)
        {
            key = _getch();
            if (key == 32)
            {
                return;
            }
            if (key == 27)
            {
                exit(0);
            }
        }
    }
    
    int myDown(HANDLE hOut, int block[4][4], int map[21][12], int &x, int y)
    {
        if (collisionDetection(block, map, x + 1, y))
        {
            clearBlock(hOut, block, x, y);
            ++x;
            return 0;
        }
        if (x < 0)
        {
            return 2;
        }
        for (int i = 0; i < 4; ++i)
        {
            for (int j = 0; j < 4; ++j)
            {
                if (block[i][j] == 1)
                {
                    map[x + i][y + j] = 1;
                    SetConsoleTextAttribute(hOut, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY);
                    gotoXY(hOut, 2 * (y + j), x + i);
                    cout << "■";
                }
            }
        }
        return 1;
    }
    
    void myLeft(HANDLE hOut, int block[4][4], int map[21][12], int x, int &y)
    {
        if (collisionDetection(block, map, x, y - 1))
        {
            clearBlock(hOut, block, x, y);
            --y;
        }
    }
    
    void myRight(HANDLE hOut, int block[4][4], int map[21][12], int x, int &y)
    {
        if (collisionDetection(block, map, x, y + 1))
        {
            clearBlock(hOut, block, x, y);
            ++y;
        }
    }
    
    void myUp(HANDLE hOut, int block[4][4], int map[21][12], int x, int &y)
    {
        switch (block[0][0])
        {
        case 10:
            if (collisionDetection(block01, map, x, y))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block01[i][j];
                    }
                }
            }
            break;
        case 11:
            if (collisionDetection(block00, map, x, y))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block00[i][j];
                    }
                }
            }
            else if (collisionDetection(block00, map, x, y - 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block00[i][j];
                    }
                }
                --y;
            }
            else if (collisionDetection(block00, map, x, y + 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block00[i][j];
                    }
                }
                ++y;
            }
            else if (collisionDetection(block00, map, x, y - 2))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block00[i][j];
                    }
                }
                y = y - 2;
            }
            else if (collisionDetection(block00, map, x, y + 2))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block00[i][j];
                    }
                }
                y = y + 2;
            }
            break;
        case 12:
            if (collisionDetection(block03, map, x, y))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block03[i][j];
                    }
                }
            }
            else if (collisionDetection(block03, map, x, y - 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block03[i][j];
                    }
                }
                --y;
            }
            else if (collisionDetection(block03, map, x, y + 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block03[i][j];
                    }
                }
                ++y;
            }
            break;
        case 13:
            if (collisionDetection(block04, map, x, y))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block04[i][j];
                    }
                }
            }
            else if (collisionDetection(block04, map, x, y - 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block04[i][j];
                    }
                }
                --y;
            }
            else if (collisionDetection(block04, map, x, y + 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block04[i][j];
                    }
                }
                ++y;
            }
            break;
        case 14:
            if (collisionDetection(block05, map, x, y))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block05[i][j];
                    }
                }
            }
            else if (collisionDetection(block05, map, x, y - 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block05[i][j];
                    }
                }
                --y;
            }
            else if (collisionDetection(block05, map, x, y + 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block05[i][j];
                    }
                }
                ++y;
            }
            break;
        case 15:
            if (collisionDetection(block02, map, x, y))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block02[i][j];
                    }
                }
            }
            else if (collisionDetection(block02, map, x, y - 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block02[i][j];
                    }
                }
                --y;
            }
            else if (collisionDetection(block02, map, x, y + 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block02[i][j];
                    }
                }
                ++y;
            }
            break;
    
        case 16:
            if (collisionDetection(block07, map, x, y))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block07[i][j];
                    }
                }
            }
            else if (collisionDetection(block07, map, x, y - 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block07[i][j];
                    }
                }
                --y;
            }
            else if (collisionDetection(block07, map, x, y + 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block07[i][j];
                    }
                }
                ++y;
            }
            break;
        case 17:
            if (collisionDetection(block08, map, x, y))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block08[i][j];
                    }
                }
            }
            else if (collisionDetection(block08, map, x, y - 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block08[i][j];
                    }
                }
                --y;
            }
            else if (collisionDetection(block08, map, x, y + 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block08[i][j];
                    }
                }
                ++y;
            }
            break;
        case 18:
            if (collisionDetection(block09, map, x, y))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block09[i][j];
                    }
                }
            }
            else if (collisionDetection(block09, map, x, y - 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block09[i][j];
                    }
                }
                --y;
            }
            else if (collisionDetection(block09, map, x, y + 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block09[i][j];
                    }
                }
                ++y;
            }
            break;
        case 19:
            if (collisionDetection(block06, map, x, y))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block06[i][j];
                    }
                }
            }
            else if (collisionDetection(block06, map, x, y - 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block06[i][j];
                    }
                }
                --y;
            }
            else if (collisionDetection(block06, map, x, y + 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block06[i][j];
                    }
                }
                ++y;
            }
            break;
        case 20:
            if (collisionDetection(block11, map, x, y))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block11[i][j];
                    }
                }
            }
            else if (collisionDetection(block11, map, x, y - 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block11[i][j];
                    }
                }
                --y;
            }
            else if (collisionDetection(block11, map, x, y + 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block11[i][j];
                    }
                }
                ++y;
            }
            break;
        case 21:
            if (collisionDetection(block12, map, x, y))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block12[i][j];
                    }
                }
            }
            else if (collisionDetection(block12, map, x, y - 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block12[i][j];
                    }
                }
                --y;
            }
            else if (collisionDetection(block12, map, x, y + 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block12[i][j];
                    }
                }
                ++y;
            }
            break;
        case 22:
            if (collisionDetection(block13, map, x, y))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block13[i][j];
                    }
                }
            }
            else if (collisionDetection(block13, map, x, y - 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block13[i][j];
                    }
                }
                --y;
            }
            else if (collisionDetection(block13, map, x, y + 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block13[i][j];
                    }
                }
                ++y;
            }
            break;
        case 23:
            if (collisionDetection(block10, map, x, y))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block10[i][j];
                    }
                }
            }
            else if (collisionDetection(block10, map, x, y - 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block10[i][j];
                    }
                }
                --y;
            }
            else if (collisionDetection(block10, map, x, y + 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block10[i][j];
                    }
                }
                ++y;
            }
            break;
        case 24:
            if (collisionDetection(block15, map, x, y))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block15[i][j];
                    }
                }
            }
            else if (collisionDetection(block15, map, x, y - 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block15[i][j];
                    }
                }
                --y;
            }
            else if (collisionDetection(block15, map, x, y + 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block15[i][j];
                    }
                }
                ++y;
            }
            break;
        case 25:
            if (collisionDetection(block14, map, x, y))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block14[i][j];
                    }
                }
            }
            else if (collisionDetection(block14, map, x, y - 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block14[i][j];
                    }
                }
                --y;
            }
            else if (collisionDetection(block14, map, x, y + 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block14[i][j];
                    }
                }
                ++y;
            }
            break;
        case 26:
            if (collisionDetection(block17, map, x, y))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block17[i][j];
                    }
                }
            }
            else if (collisionDetection(block17, map, x, y - 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block17[i][j];
                    }
                }
                --y;
            }
            else if (collisionDetection(block17, map, x, y + 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block17[i][j];
                    }
                }
                ++y;
            }
            break;
        case 27:
            if (collisionDetection(block16, map, x, y))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block16[i][j];
                    }
                }
            }
            else if (collisionDetection(block16, map, x, y - 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block16[i][j];
                    }
                }
                --y;
            }
            else if (collisionDetection(block16, map, x, y + 1))
            {
                clearBlock(hOut, block, x, y);
                for (int i = 0; i < 4; ++i)
                {
                    for (int j = 0; j < 4; ++j)
                    {
                        block[i][j] = block16[i][j];
                    }
                }
                ++y;
            }
            break;
        default:
            break;
        }
    }
    
    void myStop(HANDLE hOut, int block[4][4])
    {
        clearBlock(hOut, block, 5, 15);
        SetConsoleTextAttribute(hOut, FOREGROUND_RED | FOREGROUND_INTENSITY);
        gotoXY(hOut, 30, 7);
        cout << "游戏暂停";
        char key;
        while (true)
        {
            key = _getch();
            if (key == 32)
            {
                gotoXY(hOut, 30, 7);
                cout << "        ";
                printBlock(hOut, block, 5, 15);
                return;
            }
            if (key == 27)
            {
                exit(0);
            }
        }
    }
    
    void eliminateRow(HANDLE hOut, int map[21][12], int &val, int &fraction, int &checkpoint)
    {
        SetConsoleTextAttribute(hOut, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY);
        for (int i = 19; i >= 0; --i)
        {
            int x = 0;
            for (int j = 1; j < 11; ++j)
            {
                x += map[i][j];
            }
            if (x == 10)
            {
                fraction += 100;
                if (val > 1 && fraction / 1000 + 1 != checkpoint)
                {
                    checkpoint = fraction / 1000 + 1;
                    val -= 5;
                }
                for (int m = i; m > 0; --m)
                {
                    for (int n = 1; n < 11; ++n)
                    {
                        map[m][n] = map[m - 1][n];
                        gotoXY(hOut, 2 * n, m);
                        if (map[m][n] == 1)
                        {
                            cout << "■";
                        }
                        else
                        {
                            cout << "  ";
                        }
                    }
                }
                ++i;
            }
        }
        gotoXY(hOut, 36, 1);
        cout << fraction;
        gotoXY(hOut, 36, 2);
        cout << checkpoint;
    }
    //完
    
    //吃豆人游戏👀️ (来源CSDN,可以复制)
    #include <cstdio>
    #include <iostream>
    #include <ctime>
    #include <conio.h>
    #include <windows.h>       //停顿:Sleep(); 
    #include <cstdlib>         //清屏:system("cls");
    #include <cstring>
    using namespace std;
    const int n=809;
    struct Point {int x,y;};
    int dali;
    int fx[4]={-1,27,1,-27};
    int fxfx[4][2]={{0,-1},{1,0},{0,1},{-1,0}};
    int dis[1000][1000]; //0:墙 1:有分的路 2:没分的路 3:怪物的家 
    int changdi[30][27]={
    {0,0,0,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,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,0},
    {0,1,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0},
    {0,1,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0},
    {0,1,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,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,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0},
    {0,1,1,1,1,1,1,0,0,1,1,1,1,0,1,1,1,1,0,0,1,1,1,1,1,1,0},
    {0,0,0,0,0,0,1,0,0,0,0,0,2,0,2,0,0,0,0,0,1,0,0,0,0,0,0},
    {0,0,0,0,0,0,1,0,0,0,0,0,2,0,2,0,0,0,0,0,1,0,0,0,0,0,0},
    {0,0,0,0,0,0,1,0,0,2,2,2,2,2,2,2,2,2,0,0,1,0,0,0,0,0,0},
    {0,0,0,0,0,0,1,0,0,2,0,0,0,3,0,0,0,2,0,0,1,0,0,0,0,0,0},
    {0,0,0,0,0,0,1,0,0,2,0,3,3,3,3,3,0,2,0,0,1,0,0,0,0,0,0},
    {2,2,2,2,2,2,1,2,2,2,0,3,3,3,3,3,0,2,2,2,1,2,2,2,2,2,2},
    {0,0,0,0,0,0,1,0,0,2,0,3,3,3,3,3,0,2,0,0,1,0,0,0,0,0,0},
    {0,0,0,0,0,0,1,0,0,2,0,0,0,0,0,0,0,2,0,0,1,0,0,0,0,0,0},
    {0,0,0,0,0,0,1,0,0,2,2,2,2,2,2,2,2,2,0,0,1,0,0,0,0,0,0},
    {0,0,0,0,0,0,1,0,0,2,0,0,0,0,0,0,0,2,0,0,1,0,0,0,0,0,0},
    {0,0,0,0,0,0,1,0,0,2,0,0,0,0,0,0,0,2,0,0,1,0,0,0,0,0,0},
    {0,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,0},
    {0,1,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0},
    {0,1,0,0,0,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,1,0},
    {0,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,0},
    {0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0},
    {0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0},
    {0,1,1,1,1,1,1,0,0,1,1,1,1,0,1,1,1,1,0,0,1,1,1,1,1,1,0},
    {0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0},
    {0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,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,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
    };
    int x,x1,x2,x3,x4,y,y1,y2,y3,y4;
    int now,now1,now2,now3,now4;
    int g1,g2,g3,g4;
    int fangx,nextfx,last1,last2,last3,last4;
    int fenshu,guozi,guaitimer;
    int T1,T2,t1,t2,stopped; //T:计时 t1:玩家速度 t2:怪物速度 
    int f=0; //f:{0:继续 1:被吃 2:赢了 3:输了}
    int beichi;
    void color(int a)//颜色函数
    {
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),a);
    }
    void gotoxy(int x,int y)//位置函数(行为x 列为y)
    {
    COORD pos;
    pos.X=2*y;
    pos.Y=x;
    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),pos);
    }
    void begin(){
    system("cls");
    color(11); printf("       ★"); color(10); printf("吃豆人"); color(11); printf("★\n\n"); color(7);
    printf("     请将窗口开至"); color(11); printf("全屏\n"); color(7);
    printf("  正在初始化,请耐心等待"); 
    for (int i=0; i<=n; i++) for (int j=1; j<=n; j++) dis[i][j]=900;
     for (int i=0; i<=n; i++){
        for (int j=0; j<=3; j++){
            if (i+fx[j]>=0 && i+fx[j]<=n){
                int k=i+fx[j],xx=k/27,yy=k%27,kk;
                if (changdi[i/27][i%27] && changdi[xx][yy]) dis[i][k]=kk=1;
            }
        }
    }
     for (int k=0; k<=n; k++)if(changdi[k]){
        for (int i=0; i<=n; i++)if(changdi[i])
            for (int j=0; j<=n; j++)if(changdi[j])
                if (dis[i][j]>dis[i][k]+dis[k][j]) dis[i][j]=dis[i][k]+dis[k][j];
        if (k%80==0){color (13); gotoxy(3,12); printf("│");}
        if (k%80==20){color(13); gotoxy(3,12); printf("╱");}
        if (k%80==40){color(13); gotoxy(3,12); printf("─");}
        if (k%80==60){color(13); gotoxy(3,12); printf("╲");}
        if (k%60==0){color(11); gotoxy(5,k/60); printf("●");}
    }
    }
    void shuru(){
    char ch=getch();
    if (ch=='1' | ch=='j') if (changdi[x+fxfx[0][0]][y+fxfx[0][1]]==1|changdi[x+fxfx[0][0]][y+fxfx[0][1]]==2) fangx=nextfx=0; else nextfx=0;
    else if (ch=='2' | ch=='k') if (changdi[x+fxfx[1][0]][y+fxfx[1][1]]==1|changdi[x+fxfx[1][0]][y+fxfx[1][1]]==2) fangx=nextfx=1; else nextfx=1;
    else if (ch=='3' | ch=='l') if (changdi[x+fxfx[2][0]][y+fxfx[2][1]]==1|changdi[x+fxfx[2][0]][y+fxfx[2][1]]==2) fangx=nextfx=2; else nextfx=2;
    else if (ch=='5' | ch=='i') if (changdi[x+fxfx[3][0]][y+fxfx[3][1]]==1|changdi[x+fxfx[3][0]][y+fxfx[3][1]]==2) fangx=nextfx=3; else nextfx=3;
    else if (ch=='0' | ch=='s') stopped=(stopped+1)%2;
    else if (ch=='4' | ch=='a') t1++;
    else if (ch=='7' | ch=='q') t2++;
    else if ((ch=='6' | ch=='d') && t1-1>0) t1--; 
    else if ((ch=='9' | ch=='e') && t2-1>0) t2--;
    else if (ch=='g') dali=(dali+1)%2;
    }
    void reset(){
    system("cls"); color(7);
    gotoxy(2,30); printf("控制方向:1/2/3/5");
    gotoxy(4,30); printf("你的速度:4/6");
    gotoxy(6,30); printf("怪物速度:7/9");
    x=22; y=13; 
    x1=x2=x3=x4=14; y1=11; y2=12; y3=14; y4=15;
    now=607; now1=389; now2=390; now3=392; now4=393;
    for (int k=0; k<=n; k++){
        int i=k/27,j=k%27;
        gotoxy(i,j);
        if (changdi[i][j]==1){color(7); printf("?");}
        else if (!changdi[i][j]){color(1); printf("■");}
        if (j=26){gotoxy(i,27); color(7); printf("%d",i);} 
    }
    gotoxy(0,0);
    gotoxy(x,y); color(14); printf("●");
    gotoxy(x1,y1); color(4); printf("◆");
    gotoxy(x2,y2); color(5); printf("◆");
    gotoxy(x3,y3); color(3); printf("◆");
    gotoxy(x4,y4); color(2); printf("◆");
    fangx=0; T1=T2=guaitimer=0; t1=75; t2=100;stopped=0; fenshu=0; guozi=237; g1=g2=g3=g4=0; dali=0;
    gotoxy(14,30); printf("  ");
    }
    void move1(){
    int xx,yy;
    xx=x+fxfx[nextfx][0]; yy=y+fxfx[nextfx][1];
    if (changdi[xx][yy]){
        if (changdi[xx][yy]==1){fenshu+=1; changdi[xx][yy]=2;}
        color(14);
        gotoxy(x,y); printf("  ");
        gotoxy(xx,yy); if (!dali) printf("◎"); else printf("☆");
        now=x*27+y; x=xx; y=yy;
        fangx=nextfx;
    }
    else{
        if (x==13 && y==0 && fangx==0){xx=x; yy=26;}
        else if (x==13 && y==26 && fangx==2){xx=x; yy=0;}
        else{xx=x+fxfx[fangx][0]; yy=y+fxfx[fangx][1];}
        if (changdi[xx][yy]){
            if (changdi[xx][yy]==1){fenshu+=1; changdi[xx][yy]=2;}
            color(14);
            gotoxy(x,y); printf("  ");
            gotoxy(xx,yy); if (!dali) printf("◎"); else printf("☆");
            now=x*27+y; x=xx; y=yy;
         }
     }
    color(7);
    //gotoxy(15,28); printf("(%d,%d)     ",x,y); gotoxy(16,28); printf("now:%d     ",now); gotoxy(17,28); printf("%d (%d,%d) ",fangx,fxfx[fangx][0],fxfx[fangx][1]); gotoxy(18,28); printf("(%d,%d) changdi:%d  ",xx,yy,changdi[xx][yy]);
    }
    void move2(){
    int haha,minhaha,xx,yy,chi=0;
    if (g1){
        minhaha=2147483647;
        if (now1%27==0 | now1%27==26) haha=last1;
        else if (!dali){
            for (int i=0; i<=3; i++)
                if (changdi[(now1+fx[i])/27][(now1+fx[i])%27] && i!=last1 && minhaha>dis[now1+fx[i]][now]) 
                    {minhaha=dis[now1+fx[i]][now]; haha=i;}
        }
        else{
            minhaha=-minhaha;
            for (int i=0; i<=3; i++)
                if (changdi[(now1+fx[i])/27][(now1+fx[i])%27] && i!=last1 && minhaha<dis[now1+fx[i]][now]) 
                    {minhaha=dis[now1+fx[i]][now]; haha=i;}
        }
        xx=now1/27; yy=now1%27; gotoxy(xx,yy); 
        if (changdi[xx][yy]==1) printf("?");else printf("  "); 
        now1+=fx[haha]; last1=(haha+2)%4;
        xx=now1/27; yy=now1%27; gotoxy(xx,yy); color(4); printf("◆"); color(7);
        if (xx==x && yy==y){
            if (!dali) chi+=1;
            else {
                guozi+=50;
                fenshu+=50;
                last1=0;
                gotoxy(now1/27,now1%27); 
                if (changdi[now1/27][now1%27]==1) printf("?"); else printf("  ");
                now1=389;
            }
        }
    }
    if (g2){
        int k;
        minhaha=2147483647;
        if (fangx==0 | fangx==2){
            k=y+(fxfx[fangx][1])*3;
            while (k>25 | !changdi[x][k]) k--;
            while (k<1 | !changdi[x][k]) k++;
        } else{
            k=x+(fxfx[fangx][0])*3;
            while (k>28 | !changdi[k][y]) k--;
            while (k<1 | !changdi[k][y]) k++; 
        } 
        if (fangx==0 | fangx==2) k=x*27+k; else k=k*27+y;
         if (now2%27==0 | now2%27==26) haha=last2;
        else if (!dali)
            for (int i=0; i<=3; i++){
                if (changdi[(now2+fx[i])/27][(now2+fx[i])%27] && i!=last2 && minhaha>dis[now2+fx[i]][k])  
                    {minhaha=dis[now2+fx[i]][k]; haha=i;}
            }       
        else{
            minhaha=-minhaha;
            for (int i=0; i<=3; i++){
                if (changdi[(now2+fx[i])/27][(now2+fx[i])%27] && i!=last2 && minhaha<dis[now2+fx[i]][k])  
                    {minhaha=dis[now2+fx[i]][k]; haha=i;}
            }   
        }
         xx=now2/27; yy=now2%27; gotoxy(xx,yy); 
        if (changdi[xx][yy]==1) printf("?");else printf("  "); 
        now2+=fx[haha]; last2=(haha+2)%4; gotoxy(18,30);
        xx=now2/27; yy=now2%27; gotoxy(xx,yy); color(5); printf("◆"); color(7);
        if (xx==x && yy==y){
            if (!dali) chi+=1;
            else {
                guozi+=50;
                fenshu+=50;
                last2=0;
                gotoxy(now2/27,now2%27); 
                if (changdi[now2/27][now2%27]==1) printf("?"); else printf("  ");
                now2=390;
            }
        }
    }
    if (g3){
        int k;
        minhaha=2147483647;
        if (fangx==0 | fangx==2){
            k=y+(fxfx[(fangx+1)%4][1])*3;
            while (k>25 | !changdi[x][k]) k--;
            while (k<1 | !changdi[x][k]) k++;
        } else{
            k=x+(fxfx[(fangx+1)%4][0])*3;
            while (k>28 | !changdi[k][y]) k--;
            while (k<1 | !changdi[k][y]) k++; 
        } 
        if (fangx==0 | fangx==2) k=x*27+k; else k=k*27+y;
         if (now3%27==0 | now3%27==26) haha=last3;
        else if (!dali)
            for (int i=0; i<=3; i++){
                if (changdi[(now3+fx[i])/27][(now3+fx[i])%27] && i!=last3 && minhaha>dis[now3+fx[i]][k])  
                    {minhaha=dis[now3+fx[i]][k]; haha=i;}
            }   
        else {
            minhaha=-minhaha;
            for (int i=0; i<=3; i++){
                if (changdi[(now3+fx[i])/27][(now3+fx[i])%27] && i!=last3 && minhaha<dis[now3+fx[i]][k])  
                    {minhaha=dis[now3+fx[i]][k]; haha=i;}
            }   
        }   
         xx=now3/27; yy=now3%27; gotoxy(xx,yy); 
        if (changdi[xx][yy]==1) printf("?");else printf("  "); 
        now3+=fx[haha]; last3=(haha+2)%4; gotoxy(18,30);
        xx=now3/27; yy=now3%27;         
        gotoxy(xx,yy); color(3); printf("◆"); color(7);
        if (xx==x && yy==y){
            if (!dali) chi+=1;
            else {
                guozi+=50;
                fenshu+=50;
                last3=0;
                gotoxy(now3/27,now3%27); 
                if (changdi[now3/27][now3%27]==1) printf("?"); else printf("  ");
                now3=341;
            }
        }
    }
    if (chi) beichi++;
    }
    int main(){
    begin();
    int jixu=1;
    reset();
     string bb[4]={"●","①","②","③"}; color(7);
    gotoxy(12,12); printf("倒计时"); color(12);
    for (int i=3; i>=0; i--){if (i==0) color(11);gotoxy(13,13); cout<<bb[i]; Sleep(1000);}
    gotoxy(12,12); printf("      "); gotoxy(13,13); printf(" "); color(7);
    while (!f){
        Sleep(1);
        gotoxy(10,30); printf("得分:%d   ",fenshu);
        gotoxy(8,30); printf("怪物速度:%d   ",300-t2);
        gotoxy(9,30); printf("你的速度:%d   ",300-t1);
        gotoxy(15,30); printf("被吃次数:%d ",beichi);
        if (kbhit()) shuru();
        if (stopped) continue;
        T1=(T1+1)%t1; T2=(T2+1)%t2;
        if (T1%t1==0 && now+fx[fangx]>0 && now+fx[fangx]<n) move1();
        if (T2%t2==0){
            if (guaitimer<=8){
                if (guaitimer==0) g1=1;
                if (guaitimer==8) g2=1;
                guaitimer++;
            }
            if (!g3 && fenshu>=30) g3=1;
            move2();    
        }
        if (fenshu==guozi)f=2;
    }
    if (f=2) {
        Sleep(3000);
        system("cls");
        printf("恭喜你吃完了!\n你一共被怪物吃掉了 %d 次",beichi);
        Sleep(3000);
        char ying;
        scanf("%c",&ying);
    }
    }
    

  • 最近活动

  • Stat

  • Rating