C++俄罗斯方块 (BUG游戏)

于 2025-06-28 17:10:00 发布
阅读量851 收藏 10
点赞数 22
CC 4.0 BY-SA版权
文章标签： c++ bug 游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81641926/article/details/148978930

#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) {
    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 gotoXY(HANDLE hOut, int x, int y) {
    COORD pos;
    pos.X = x;
    pos.Y = y;
    SetConsoleCursorPosition(hOut, pos);
}

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 << "俄罗斯方块坑人版";
    gotoXY(hOut, 35, 19);
    cout << "作者：刘瑞宸";
}

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 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 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;
}

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;
}

FHD_WOLF
关注
用C++编绘图控件工具
ahhdsfbff的博客
05-14 971
点开看看吧！！求求
俄罗斯方块（C++）
CatchMoon
08-15 5672
俄罗斯方块简易版（C++）
俄罗斯方块c++源代码
热门推荐
panjoel的博客
08-23 3万+
俄罗斯方块 其实这也挺简单 的 #include<iostream> #include<string> #include<ctime> #include<cstdlib> #include<windows.h> #include<conio.h> using namespace std; int block00[4][4]...
c++（俄罗斯方块）
最新发布
一个不懂编程的编程大佬，当一个人面对疾风，走上前去当一个逆行者，才是卫国黑客（AI终将代替人类）
06-30 462
切记要用Visual Studio c++,要下载easy-X图形库。
C++俄罗斯方块
m0_62783576的博客
04-29 644
【代码】C++俄罗斯方块。
C++俄罗斯方块游戏开发最全源代码
01-05
在C++编程语言中开发俄罗斯方块游戏是一个经典的项目，对于初学者来说，这是一个极好的实践平台，可以深入了解面向对象编程、游戏逻辑设计以及图形用户界面（GUI）的实现。以下将详细介绍在这个项目中涉及的关键知识...
c/c++ 实现俄罗斯方块小游戏（附全部源码）
q841447739的博客
08-11 2万+
使用easyX库，基于c/c++，实现俄罗斯方块小游戏。（附全部源码）
Vs2017 C++ 俄罗斯方块源码
01-31
总结，这个“Vs2017 C++ 俄罗斯方块源码”项目涵盖了C++编程基础、游戏设计、图形界面开发以及软件工程实践等多个方面，对于想要学习C++游戏开发的人来说，是一份非常有价值的参考资料。通过深入研究，不仅可以掌握...
基于C++的俄罗斯方块游戏的开发与设计
06-15
【标题】"基于C++的俄罗斯方块游戏的开发与设计"揭示了这个项目的核心是使用C++编程语言来实现经典游戏俄罗斯方块的开发。在C++这种强大的面向对象编程语言的支持下，开发者可以充分利用其特性来创建高效、可扩展的...
C++实现的高效无bug俄罗斯方块游戏
俄罗斯方块（Tetris）是一款经典...编写俄罗斯方块游戏不仅仅是编码，还需要调试和测试以确保无bug，并且游戏运行流畅。通过编写和改进俄罗斯方块游戏，不仅可以加深对C++语言的理解，还能提高解决复杂编程问题的能力。
C++俄罗斯方块源码
01-22
C++俄罗斯方块源码
俄罗斯方块源代码（c++语言）
05-05
俄罗斯方块源代码，c++语言所写，可用。
俄罗斯方块源代码(C++源代码)
03-03
俄罗斯方块源代码(C++源代码)，俄罗斯方块游戏源代码，有兴趣的朋友可以看一下。
c++ 实现的俄罗斯方块
07-19
用c++ 实现的简单俄罗斯方块代码，适合初学者使用学习的。
俄罗斯方块C++源代码
09-18
功能齐全，可以保存游戏进度，根据得分自动调整难度，一次性消去多行得分有加权，可玩可学习
俄罗斯方块(C++)
少说，多做。
05-31 3028
#include<iostream> #include<stdlib.h> #include<windows.h> #include<time.h> #include<conio.h> using namespace std; #define A1 0//A代表长条型，B为方块，C为L型，D为闪电型（实在无法描述那个形状） #define A2 1 #define B 2 #define C11 3 #define C12 4 #defin.
C++俄罗斯方块源代码
希望记录下自己的一点一滴，慢慢成长。。
01-27 1万+
转自：http://blog.csdn.net/huangminqiang201209/article/details/8294285 /****************************************************************************** **文件:Tetris.c **编写者:huangminqiang **编写日期:2010
俄罗斯方块C++源码
10-17
一个C++写的俄罗斯方块小游戏，使用控制台显示，键盘的wasd按键操控。使用的都是c语言很基本的函数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值