1. 首页
  2. 文章列表

俄罗斯方块代马

352 阅读 0 评论

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

  1. srand((unsigned)time(NULL));
  2. roundBlock(hOut, blockA);
  3. while (true)
  4. {
  5.     if (check)
  6.     {
  7.         eliminateRow(hOut, map, val, fraction, checkpoint);
  8.         check = false;
  9.         positionX = -3;
  10.         positionY = 4;
  11.         if (collisionDetection(blockA, map, positionX, positionY))
  12.         {
  13.             for (int i = 0; i < 4; ++i)
  14.             {
  15.                 for (int j = 0; j < 4; ++j)
  16.                 {
  17.                     blockB[i][j] = blockA[i][j];
  18.                 }
  19.             }
  20.             roundBlock(hOut, blockA);
  21.         }
  22.         else
  23.         {
  24.             gameOver(hOut, blockA, map);
  25.             goto initial;
  26.         }
  27.     }
  28.     printBlock(hOut, blockB, positionX, positionY);
  29.     if (_kbhit())
  30.     {
  31.         key = _getch();
  32.         switch (key)
  33.         {
  34.         case 72:
  35.             myUp(hOut, blockB, map, positionX, positionY);
  36.             break;
  37.         case 75:
  38.             myLeft(hOut, blockB, map, positionX, positionY);
  39.             break;
  40.         case 77:
  41.             myRight(hOut, blockB, map, positionX, positionY);
  42.             break;
  43.         case 80:
  44.             switch (myDown(hOut, blockB, map, positionX, positionY))
  45.             {
  46.             case 0:
  47.                 check = false;
  48.                 break;
  49.             case 1:
  50.                 check = true;
  51.                 break;
  52.             case 2:
  53.                 gameOver(hOut, blockB, map);
  54.                 goto initial;
  55.             default:
  56.                 break;
  57.             }
  58.             break;
  59.         case 32:
  60.             myStop(hOut, blockA);
  61.             break;
  62.         case 27:
  63.             exit(0);
  64.         default:
  65.             break;
  66.         }
  67.     }
  68.     Sleep(20);
  69.     if (0 == --times)
  70.     {
  71.         switch (myDown(hOut, blockB, map, positionX, positionY))
  72.         {
  73.         case 0:
  74.             check = false;
  75.             break;
  76.         case 1:
  77.             check = true;
  78.             break;
  79.         case 2:
  80.             gameOver(hOut, blockB, map);
  81.             goto initial;
  82.         default:
  83.             break;
  84.         }
  85.         times = val;
  86.     }
  87. }
  88. cin.get();
  89. 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)
{

  1.                 gotoXY(hOut, 2 * (y + j), x + i);
  2.                 cout << "■";
  3.             }
  4.         }
  5.     }
  6. }

}

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;

  1. case 16:
  2.     if (collisionDetection(block07, map, x, y))
  3.     {
  4.         clearBlock(hOut, block, x, y);
  5.         for (int i = 0; i < 4; ++i)
  6.         {
  7.             for (int j = 0; j < 4; ++j)
  8.             {
  9.                 block[i][j] = block07[i][j];
  10.             }
  11.         }
  12.     }
  13.     else if (collisionDetection(block07, map, x, y - 1))
  14.     {
  15.         clearBlock(hOut, block, x, y);
  16.         for (int i = 0; i < 4; ++i)
  17.         {
  18.             for (int j = 0; j < 4; ++j)
  19.             {
  20.                 block[i][j] = block07[i][j];
  21.             }
  22.         }
  23.         --y;
  24.     }
  25.     else if (collisionDetection(block07, map, x, y + 1))
  26.     {
  27.         clearBlock(hOut, block, x, y);
  28.         for (int i = 0; i < 4; ++i)
  29.         {
  30.             for (int j = 0; j < 4; ++j)
  31.             {
  32.                 block[i][j] = block07[i][j];
  33.             }
  34.         }
  35.         ++y;
  36.     }
  37.     break;
  38. case 17:
  39.     if (collisionDetection(block08, map, x, y))
  40.     {
  41.         clearBlock(hOut, block, x, y);
  42.         for (int i = 0; i < 4; ++i)
  43.         {
  44.             for (int j = 0; j < 4; ++j)
  45.             {
  46.                 block[i][j] = block08[i][j];
  47.             }
  48.         }
  49.     }
  50.     else if (collisionDetection(block08, map, x, y - 1))
  51.     {
  52.         clearBlock(hOut, block, x, y);
  53.         for (int i = 0; i < 4; ++i)
  54.         {
  55.             for (int j = 0; j < 4; ++j)
  56.             {
  57.                 block[i][j] = block08[i][j];
  58.             }
  59.         }
  60.         --y;
  61.     }
  62.     else if (collisionDetection(block08, map, x, y + 1))
  63.     {
  64.         clearBlock(hOut, block, x, y);
  65.         for (int i = 0; i < 4; ++i)
  66.         {
  67.             for (int j = 0; j < 4; ++j)
  68.             {
  69.                 block[i][j] = block08[i][j];
  70.             }
  71.         }
  72.         ++y;
  73.     }
  74.     break;
  75. case 18:
  76.     if (collisionDetection(block09, map, x, y))
  77.     {
  78.         clearBlock(hOut, block, x, y);
  79.         for (int i = 0; i < 4; ++i)
  80.         {
  81.             for (int j = 0; j < 4; ++j)
  82.             {
  83.                 block[i][j] = block09[i][j];
  84.             }
  85.         }
  86.     }
  87.     else if (collisionDetection(block09, map, x, y - 1))
  88.     {
  89.         clearBlock(hOut, block, x, y);
  90.         for (int i = 0; i < 4; ++i)
  91.         {
  92.             for (int j = 0; j < 4; ++j)
  93.             {
  94.                 block[i][j] = block09[i][j];
  95.             }
  96.         }
  97.         --y;
  98.     }
  99.     else if (collisionDetection(block09, map, x, y + 1))
  100.     {
  101.         clearBlock(hOut, block, x, y);
  102.         for (int i = 0; i < 4; ++i)
  103.         {
  104.             for (int j = 0; j < 4; ++j)
  105.             {
  106.                 block[i][j] = block09[i][j];
  107.             }
  108.         }
  109.         ++y;
  110.     }
  111.     break;
  112. case 19:
  113.     if (collisionDetection(block06, map, x, y))
  114.     {
  115.         clearBlock(hOut, block, x, y);
  116.         for (int i = 0; i < 4; ++i)
  117.         {
  118.             for (int j = 0; j < 4; ++j)
  119.             {
  120.                 block[i][j] = block06[i][j];
  121.             }
  122.         }
  123.     }
  124.     else if (collisionDetection(block06, map, x, y - 1))
  125.     {
  126.         clearBlock(hOut, block, x, y);
  127.         for (int i = 0; i < 4; ++i)
  128.         {
  129.             for (int j = 0; j < 4; ++j)
  130.             {
  131.                 block[i][j] = block06[i][j];
  132.             }
  133.         }
  134.         --y;
  135.     }
  136.     else if (collisionDetection(block06, map, x, y + 1))
  137.     {
  138.         clearBlock(hOut, block, x, y);
  139.         for (int i = 0; i < 4; ++i)
  140.         {
  141.             for (int j = 0; j < 4; ++j)
  142.             {
  143.                 block[i][j] = block06[i][j];
  144.             }
  145.         }
  146.         ++y;
  147.     }
  148.     break;
  149. case 20:
  150.     if (collisionDetection(block11, map, x, y))
  151.     {
  152.         clearBlock(hOut, block, x, y);
  153.         for (int i = 0; i < 4; ++i)
  154.         {
  155.             for (int j = 0; j < 4; ++j)
  156.             {
  157.                 block[i][j] = block11[i][j];
  158.             }
  159.         }
  160.     }
  161.     else if (collisionDetection(block11, map, x, y - 1))
  162.     {
  163.         clearBlock(hOut, block, x, y);
  164.         for (int i = 0; i < 4; ++i)
  165.         {
  166.             for (int j = 0; j < 4; ++j)
  167.             {
  168.                 block[i][j] = block11[i][j];
  169.             }
  170.         }
  171.         --y;
  172.     }
  173.     else if (collisionDetection(block11, map, x, y + 1))
  174.     {
  175.         clearBlock(hOut, block, x, y);
  176.         for (int i = 0; i < 4; ++i)
  177.         {
  178.             for (int j = 0; j < 4; ++j)
  179.             {
  180.                 block[i][j] = block11[i][j];
  181.             }
  182.         }
  183.         ++y;
  184.     }
  185.     break;
  186. case 21:
  187.     if (collisionDetection(block12, map, x, y))
  188.     {
  189.         clearBlock(hOut, block, x, y);
  190.         for (int i = 0; i < 4; ++i)
  191.         {
  192.             for (int j = 0; j < 4; ++j)
  193.             {
  194.                 block[i][j] = block12[i][j];
  195.             }
  196.         }
  197.     }
  198.     else if (collisionDetection(block12, map, x, y - 1))
  199.     {
  200.         clearBlock(hOut, block, x, y);
  201.         for (int i = 0; i < 4; ++i)
  202.         {
  203.             for (int j = 0; j < 4; ++j)
  204.             {
  205.                 block[i][j] = block12[i][j];
  206.             }
  207.         }
  208.         --y;
  209.     }
  210.     else if (collisionDetection(block12, map, x, y + 1))
  211.     {
  212.         clearBlock(hOut, block, x, y);
  213.         for (int i = 0; i < 4; ++i)
  214.         {
  215.             for (int j = 0; j < 4; ++j)
  216.             {
  217.                 block[i][j] = block12[i][j];
  218.             }
  219.         }
  220.         ++y;
  221.     }
  222.     break;
  223. case 22:
  224.     if (collisionDetection(block13, map, x, y))
  225.     {
  226.         clearBlock(hOut, block, x, y);
  227.         for (int i = 0; i < 4; ++i)
  228.         {
  229.             for (int j = 0; j < 4; ++j)
  230.             {
  231.                 block[i][j] = block13[i][j];
  232.             }
  233.         }
  234.     }
  235.     else if (collisionDetection(block13, map, x, y - 1))
  236.     {
  237.         clearBlock(hOut, block, x, y);
  238.         for (int i = 0; i < 4; ++i)
  239.         {
  240.             for (int j = 0; j < 4; ++j)
  241.             {
  242.                 block[i][j] = block13[i][j];
  243.             }
  244.         }
  245.         --y;
  246.     }
  247.     else if (collisionDetection(block13, map, x, y + 1))
  248.     {
  249.         clearBlock(hOut, block, x, y);
  250.         for (int i = 0; i < 4; ++i)
  251.         {
  252.             for (int j = 0; j < 4; ++j)
  253.             {
  254.                 block[i][j] = block13[i][j];
  255.             }
  256.         }
  257.         ++y;
  258.     }
  259.     break;
  260. case 23:
  261.     if (collisionDetection(block10, map, x, y))
  262.     {
  263.         clearBlock(hOut, block, x, y);
  264.         for (int i = 0; i < 4; ++i)
  265.         {
  266.             for (int j = 0; j < 4; ++j)
  267.             {
  268.                 block[i][j] = block10[i][j];
  269.             }
  270.         }
  271.     }
  272.     else if (collisionDetection(block10, map, x, y - 1))
  273.     {
  274.         clearBlock(hOut, block, x, y);
  275.         for (int i = 0; i < 4; ++i)
  276.         {
  277.             for (int j = 0; j < 4; ++j)
  278.             {
  279.                 block[i][j] = block10[i][j];
  280.             }
  281.         }
  282.         --y;
  283.     }
  284.     else if (collisionDetection(block10, map, x, y + 1))
  285.     {
  286.         clearBlock(hOut, block, x, y);
  287.         for (int i = 0; i < 4; ++i)
  288.         {
  289.             for (int j = 0; j < 4; ++j)
  290.             {
  291.                 block[i][j] = block10[i][j];
  292.             }
  293.         }
  294.         ++y;
  295.     }
  296.     break;
  297. case 24:
  298.     if (collisionDetection(block15, map, x, y))
  299.     {
  300.         clearBlock(hOut, block, x, y);
  301.         for (int i = 0; i < 4; ++i)
  302.         {
  303.             for (int j = 0; j < 4; ++j)
  304.             {
  305.                 block[i][j] = block15[i][j];
  306.             }
  307.         }
  308.     }
  309.     else if (collisionDetection(block15, map, x, y - 1))
  310.     {
  311.         clearBlock(hOut, block, x, y);
  312.         for (int i = 0; i < 4; ++i)
  313.         {
  314.             for (int j = 0; j < 4; ++j)
  315.             {
  316.                 block[i][j] = block15[i][j];
  317.             }
  318.         }
  319.         --y;
  320.     }
  321.     else if (collisionDetection(block15, map, x, y + 1))
  322.     {
  323.         clearBlock(hOut, block, x, y);
  324.         for (int i = 0; i < 4; ++i)
  325.         {
  326.             for (int j = 0; j < 4; ++j)
  327.             {
  328.                 block[i][j] = block15[i][j];
  329.             }
  330.         }
  331.         ++y;
  332.     }
  333.     break;
  334. case 25:
  335.     if (collisionDetection(block14, map, x, y))
  336.     {
  337.         clearBlock(hOut, block, x, y);
  338.         for (int i = 0; i < 4; ++i)
  339.         {
  340.             for (int j = 0; j < 4; ++j)
  341.             {
  342.                 block[i][j] = block14[i][j];
  343.             }
  344.         }
  345.     }
  346.     else if (collisionDetection(block14, map, x, y - 1))
  347.     {
  348.         clearBlock(hOut, block, x, y);
  349.         for (int i = 0; i < 4; ++i)
  350.         {
  351.             for (int j = 0; j < 4; ++j)
  352.             {
  353.                 block[i][j] = block14[i][j];
  354.             }
  355.         }
  356.         --y;
  357.     }
  358.     else if (collisionDetection(block14, map, x, y + 1))
  359.     {
  360.         clearBlock(hOut, block, x, y);
  361.         for (int i = 0; i < 4; ++i)
  362.         {
  363.             for (int j = 0; j < 4; ++j)
  364.             {
  365.                 block[i][j] = block14[i][j];
  366.             }
  367.         }
  368.         ++y;
  369.     }
  370.     break;
  371. case 26:
  372.     if (collisionDetection(block17, map, x, y))
  373.     {
  374.         clearBlock(hOut, block, x, y);
  375.         for (int i = 0; i < 4; ++i)
  376.         {
  377.             for (int j = 0; j < 4; ++j)
  378.             {
  379.                 block[i][j] = block17[i][j];
  380.             }
  381.         }
  382.     }
  383.     else if (collisionDetection(block17, map, x, y - 1))
  384.     {
  385.         clearBlock(hOut, block, x, y);
  386.         for (int i = 0; i < 4; ++i)
  387.         {
  388.             for (int j = 0; j < 4; ++j)
  389.             {
  390.                 block[i][j] = block17[i][j];
  391.             }
  392.         }
  393.         --y;
  394.     }
  395.     else if (collisionDetection(block17, map, x, y + 1))
  396.     {
  397.         clearBlock(hOut, block, x, y);
  398.         for (int i = 0; i < 4; ++i)
  399.         {
  400.             for (int j = 0; j < 4; ++j)
  401.             {
  402.                 block[i][j] = block17[i][j];
  403.             }
  404.         }
  405.         ++y;
  406.     }
  407.     break;
  408. case 27:
  409.     if (collisionDetection(block16, map, x, y))
  410.     {
  411.         clearBlock(hOut, block, x, y);
  412.         for (int i = 0; i < 4; ++i)
  413.         {
  414.             for (int j = 0; j < 4; ++j)
  415.             {
  416.                 block[i][j] = block16[i][j];
  417.             }
  418.         }
  419.     }
  420.     else if (collisionDetection(block16, map, x, y - 1))
  421.     {
  422.         clearBlock(hOut, block, x, y);
  423.         for (int i = 0; i < 4; ++i)
  424.         {
  425.             for (int j = 0; j < 4; ++j)
  426.             {
  427.                 block[i][j] = block16[i][j];
  428.             }
  429.         }
  430.         --y;
  431.     }
  432.     else if (collisionDetection(block16, map, x, y + 1))
  433.     {
  434.         clearBlock(hOut, block, x, y);
  435.         for (int i = 0; i < 4; ++i)
  436.         {
  437.             for (int j = 0; j < 4; ++j)
  438.             {
  439.                 block[i][j] = block16[i][j];
  440.             }
  441.         }
  442.         ++y;
  443.     }
  444.     break;
  445. default:
  446.     break;
  447. }

}

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

点赞(0)
　

0 分

0 人评分

　

C语言网提供由在职研发工程师或ACM蓝桥杯竞赛优秀选手录制的视频教程，并配有习题和答疑，点击了解：

一点编程也不会写的：零基础C语言学练课程

解决困扰你多年的C语言疑难杂症特性的C语言进阶课程

从零到写出一个爬虫的Python编程课程

只会语法写不出代码？手把手带你写100个编程真题的编程百练课程

信息学奥赛或C++选手的 必学C++课程

蓝桥杯ACM、信息学奥赛的必学课程：算法竞赛课入门课程

手把手讲解近五年真题的蓝桥杯辅导课程

一笔画问题（dfs）
一笔画问题（dfs）
C++ ： 类和两种访问权限的练习
C++ ： 类和两种访问权限的练习
C++ ： 类和两种访问权限的练习
C++ ： 类和两种访问权限的练习
幸运儿（约瑟夫环-模拟+ Vector）
幸运儿（约瑟夫环-模拟+ Vector）

评论列表 共有 0 条评论

暂无评论