C++ 俄罗斯方块编程

于 2024-06-28 19:57:00 发布
阅读量273 收藏
点赞数 4
文章标签： c++ 开发语言 游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liyinuo23/article/details/140051945
版权

 

今天跟一位大佬学习了一下C++俄罗斯方块的编程代码

                废话不多数，直接上代码！！！

/****Author:victory(liyinuo)****/
/*******************************************************************************************
 *
 *   raylib - classic game: tetris
 *
 *   Sample game developed by Marc Palau and Ramon Santamaria
 *
 *   This game has been created using raylib v1.3 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
 *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/

#include "raylib.h"

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

#if defined(PLATFORM_WEB)
#include <emscripten/emscripten.h>
#endif

//----------------------------------------------------------------------------------
// Some Defines
//----------------------------------------------------------------------------------
#define SQUARE_SIZE             20

#define GRID_HORIZONTAL_SIZE    12
#define GRID_VERTICAL_SIZE      20

#define LATERAL_SPEED           10
#define TURNING_SPEED           12
#define FAST_FALL_AWAIT_COUNTER 30

#define FADING_TIME             33

//----------------------------------------------------------------------------------
// Types and Structures Definition
//----------------------------------------------------------------------------------
typedef enum GridSquare { EMPTY, MOVING, FULL, BLOCK, FADING } GridSquare;

//------------------------------------------------------------------------------------
// Global Variables Declaration
//------------------------------------------------------------------------------------
static const int screenWidth = 800;
static const int screenHeight = 450;

static bool gameOver = false;
static bool pause = false;

// Matrices
static GridSquare grid [GRID_HORIZONTAL_SIZE][GRID_VERTICAL_SIZE];
static GridSquare piece [4][4];
static GridSquare incomingPiece [4][4];

// Theese variables keep track of the active piece position
static int piecePositionX = 0;
static int piecePositionY = 0;

// Game parameters
static Color fadingColor;
//static int fallingSpeed;           // In frames

static bool beginPlay = true;      // This var is only true at the begining of the game, used for the first matrix creations
static bool pieceActive = false;
static bool detection = false;
static bool lineToDelete = false;

// Statistics
static int level = 1;
static int lines = 0;

// Counters
static int gravityMovementCounter = 0;
static int lateralMovementCounter = 0;
static int turnMovementCounter = 0;
static int fastFallMovementCounter = 0;

static int fadeLineCounter = 0;

// Based on level
static int gravitySpeed = 30;

//------------------------------------------------------------------------------------
// Module Functions Declaration (local)
//------------------------------------------------------------------------------------
static void InitGame(void);         // Initialize game
static void UpdateGame(void);       // Update game (one frame)
static void DrawGame(void);         // Draw game (one frame)
static void UnloadGame(void);       // Unload game
static void UpdateDrawFrame(void);  // Update and Draw (one frame)

// Additional module functions
static bool Createpiece();
static void GetRandompiece();
static void ResolveFallingMovement(bool *detection, bool *pieceActive);
static bool ResolveLateralMovement();
static bool ResolveTurnMovement();
static void CheckDetection(bool *detection);
static void CheckCompletion(bool *lineToDelete);
static void DeleteCompleteLines();

//------------------------------------------------------------------------------------
// Program main entry point
//------------------------------------------------------------------------------------
int main(void)
{
	// Initialization (Note windowTitle is unused on Android)
	//---------------------------------------------------------
	InitWindow(screenWidth, screenHeight, "classic game: tetris");
	
	InitGame();
	
#if defined(PLATFORM_WEB)
	emscripten_set_main_loop(UpdateDrawFrame, 60, 1);
#else
	SetTargetFPS(60);
	//--------------------------------------------------------------------------------------
	
	// Main game loop
	while (!WindowShouldClose())    // Detect window close button or ESC key
	{
		// Update and Draw
		//----------------------------------------------------------------------------------
		UpdateDrawFrame();
		//----------------------------------------------------------------------------------
	}
#endif
	// De-Initialization
	//--------------------------------------------------------------------------------------
	UnloadGame();         // Unload loaded data (textures, sounds, models...)
	
	CloseWindow();        // Close window and OpenGL context
	//--------------------------------------------------------------------------------------
	
	return 0;
}

//--------------------------------------------------------------------------------------
// Game Module Functions Definition
//--------------------------------------------------------------------------------------

// Initialize game variables
void InitGame(void)
{
	// Initialize game statistics
	level = 1;
	lines = 0;
	
	fadingColor = GRAY;
	
	piecePositionX = 0;
	piecePositionY = 0;
	
	pause = false;
	
	beginPlay = true;
	pieceActive = false;
	detection = false;
	lineToDelete = false;
	
	// Counters
	gravityMovementCounter = 0;
	lateralMovementCounter = 0;
	turnMovementCounter = 0;
	fastFallMovementCounter = 0;
	
	fadeLineCounter = 0;
	gravitySpeed = 30;
	
	// Initialize grid matrices
	for (int i = 0; i < GRID_HORIZONTAL_SIZE; i++)
	{
		for (int j = 0; j < GRID_VERTICAL_SIZE; j++)
		{
			if ((j == GRID_VERTICAL_SIZE - 1) || (i == 0) || (i == GRID_HORIZONTAL_SIZE - 1)) grid[i][j] = BLOCK;
			else grid[i][j] = EMPTY;
		}
	}
	
	// Initialize incoming piece matrices
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j< 4; j++)
		{
			incomingPiece[i][j] = EMPTY;
		}
	}
}

// Update game (one frame)
void UpdateGame(void)
{
	if (!gameOver)
	{
		if (IsKeyPressed('P')) pause = !pause;
		
		if (!pause)
		{
			if (!lineToDelete)
			{
				if (!pieceActive)
				{
					// Get another piece
					pieceActive = Createpiece();
					
					// We leave a little time before starting the fast falling down
					fastFallMovementCounter = 0;
				}
				else    // Piece falling
				{
					// Counters update
					fastFallMovementCounter++;
					gravityMovementCounter++;
					lateralMovementCounter++;
					turnMovementCounter++;
					
					// We make sure to move if we've pressed the key this frame
					if (IsKeyPressed(KEY_LEFT) || IsKeyPressed(KEY_RIGHT)) lateralMovementCounter = LATERAL_SPEED;
					if (IsKeyPressed(KEY_UP)) turnMovementCounter = TURNING_SPEED;
					
					// Fall down
					if (IsKeyDown(KEY_DOWN) && (fastFallMovementCounter >= FAST_FALL_AWAIT_COUNTER))
					{
						// We make sure the piece is going to fall this frame
						gravityMovementCounter += gravitySpeed;
					}
					
					if (gravityMovementCounter >= gravitySpeed)
					{
						// Basic falling movement
						CheckDetection(&detection);
						
						// Check if the piece has collided with another piece or with the boundings
						ResolveFallingMovement(&detection, &pieceActive);
						
						// Check if we fullfilled a line and if so, erase the line and pull down the the lines above
						CheckCompletion(&lineToDelete);
						
						gravityMovementCounter = 0;
					}
					
					// Move laterally at player's will
					if (lateralMovementCounter >= LATERAL_SPEED)
					{
						// Update the lateral movement and if success, reset the lateral counter
						if (!ResolveLateralMovement()) lateralMovementCounter = 0;
					}
					
					// Turn the piece at player's will
					if (turnMovementCounter >= TURNING_SPEED)
					{
						// Update the turning movement and reset the turning counter
						if (ResolveTurnMovement()) turnMovementCounter = 0;
					}
				}
				
				// Game over logic
				for (int j = 0; j < 2; j++)
				{
					for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
					{
						if (grid[i][j] == FULL)
						{
							gameOver = true;
						}
					}
				}
			}
			else
			{
				// Animation when deleting lines
				fadeLineCounter++;
				
				if (fadeLineCounter%8 < 4) fadingColor = MAROON;
				else fadingColor = GRAY;
				
				if (fadeLineCounter >= FADING_TIME)
				{
					DeleteCompleteLines();
					fadeLineCounter = 0;
					lineToDelete = false;
					
					lines++;
				}
			}
		}
	}
	else
	{
		if (IsKeyPressed(KEY_ENTER))
		{
			InitGame();
			gameOver = false;
		}
	}
}

// Draw game (one frame)
void DrawGame(void)
{
	BeginDrawing();
	
	ClearBackground(RAYWHITE);
	
	if (!gameOver)
	{
		// Draw gameplay area
		Vector2 offset;
		offset.x = screenWidth/2 - (GRID_HORIZONTAL_SIZE*SQUARE_SIZE/2) - 50;
		offset.y = screenHeight/2 - ((GRID_VERTICAL_SIZE - 1)*SQUARE_SIZE/2) + SQUARE_SIZE*2;
		
		offset.y -= 50;     // NOTE: Harcoded position!
		
		int controller = offset.x;
		
		for (int j = 0; j < GRID_VERTICAL_SIZE; j++)
		{
			for (int i = 0; i < GRID_HORIZONTAL_SIZE; i++)
			{
				// Draw each square of the grid
				if (grid[i][j] == EMPTY)
				{
					DrawLine(offset.x, offset.y, offset.x + SQUARE_SIZE, offset.y, LIGHTGRAY );
					DrawLine(offset.x, offset.y, offset.x, offset.y + SQUARE_SIZE, LIGHTGRAY );
					DrawLine(offset.x + SQUARE_SIZE, offset.y, offset.x + SQUARE_SIZE, offset.y + SQUARE_SIZE, LIGHTGRAY );
					DrawLine(offset.x, offset.y + SQUARE_SIZE, offset.x + SQUARE_SIZE, offset.y + SQUARE_SIZE, LIGHTGRAY );
					offset.x += SQUARE_SIZE;
				}
				else if (grid[i][j] == FULL)
				{
					DrawRectangle(offset.x, offset.y, SQUARE_SIZE, SQUARE_SIZE, GRAY);
					offset.x += SQUARE_SIZE;
				}
				else if (grid[i][j] == MOVING)
				{
					DrawRectangle(offset.x, offset.y, SQUARE_SIZE, SQUARE_SIZE, DARKGRAY);
					offset.x += SQUARE_SIZE;
				}
				else if (grid[i][j] == BLOCK)
				{
					DrawRectangle(offset.x, offset.y, SQUARE_SIZE, SQUARE_SIZE, LIGHTGRAY);
					offset.x += SQUARE_SIZE;
				}
				else if (grid[i][j] == FADING)
				{
					DrawRectangle(offset.x, offset.y, SQUARE_SIZE, SQUARE_SIZE, fadingColor);
					offset.x += SQUARE_SIZE;
				}
			}
			
			offset.x = controller;
			offset.y += SQUARE_SIZE;
		}
		
		// Draw incoming piece (hardcoded)
		offset.x = 500;
		offset.y = 45;
		
		int controler = offset.x;
		
		for (int j = 0; j < 4; j++)
		{
			for (int i = 0; i < 4; i++)
			{
				if (incomingPiece[i][j] == EMPTY)
				{
					DrawLine(offset.x, offset.y, offset.x + SQUARE_SIZE, offset.y, LIGHTGRAY );
					DrawLine(offset.x, offset.y, offset.x, offset.y + SQUARE_SIZE, LIGHTGRAY );
					DrawLine(offset.x + SQUARE_SIZE, offset.y, offset.x + SQUARE_SIZE, offset.y + SQUARE_SIZE, LIGHTGRAY );
					DrawLine(offset.x, offset.y + SQUARE_SIZE, offset.x + SQUARE_SIZE, offset.y + SQUARE_SIZE, LIGHTGRAY );
					offset.x += SQUARE_SIZE;
				}
				else if (incomingPiece[i][j] == MOVING)
				{
					DrawRectangle(offset.x, offset.y, SQUARE_SIZE, SQUARE_SIZE, GRAY);
					offset.x += SQUARE_SIZE;
				}
			}
			
			offset.x = controler;
			offset.y += SQUARE_SIZE;
		}
		
		DrawText("INCOMING:", offset.x, offset.y - 100, 10, GRAY);
		DrawText(TextFormat("LINES:      %04i", lines), offset.x, offset.y + 20, 10, GRAY);
		
		if (pause) DrawText("GAME PAUSED", screenWidth/2 - MeasureText("GAME PAUSED", 40)/2, screenHeight/2 - 40, 40, GRAY);
	}
	else DrawText("PRESS [ENTER] TO PLAY AGAIN", GetScreenWidth()/2 - MeasureText("PRESS [ENTER] TO PLAY AGAIN", 20)/2, GetScreenHeight()/2 - 50, 20, GRAY);
	
	EndDrawing();
}

// Unload game variables
void UnloadGame(void)
{
	// TODO: Unload all dynamic loaded data (textures, sounds, models...)
}

// Update and Draw (one frame)
void UpdateDrawFrame(void)
{
	UpdateGame();
	DrawGame();
}

//--------------------------------------------------------------------------------------
// Additional module functions
//--------------------------------------------------------------------------------------
static bool Createpiece()
{
	piecePositionX = (int)((GRID_HORIZONTAL_SIZE - 4)/2);
	piecePositionY = 0;
	
	// If the game is starting and you are going to create the first piece, we create an extra one
	if (beginPlay)
	{
		GetRandompiece();
		beginPlay = false;
	}
	
	// We assign the incoming piece to the actual piece
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j< 4; j++)
		{
			piece[i][j] = incomingPiece[i][j];
		}
	}
	
	// We assign a random piece to the incoming one
	GetRandompiece();
	
	// Assign the piece to the grid
	for (int i = piecePositionX; i < piecePositionX + 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			if (piece[i - (int)piecePositionX][j] == MOVING) grid[i][j] = MOVING;
		}
	}
	
	return true;
}

static void GetRandompiece()
{
	int random = GetRandomValue(0, 6);
	
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			incomingPiece[i][j] = EMPTY;
		}
	}
	
	switch (random)
{
	case 0: { incomingPiece[1][1] = MOVING; incomingPiece[2][1] = MOVING; incomingPiece[1][2] = MOVING; incomingPiece[2][2] = MOVING; } break;    //Cube
	case 1: { incomingPiece[1][0] = MOVING; incomingPiece[1][1] = MOVING; incomingPiece[1][2] = MOVING; incomingPiece[2][2] = MOVING; } break;    //L
	case 2: { incomingPiece[1][2] = MOVING; incomingPiece[2][0] = MOVING; incomingPiece[2][1] = MOVING; incomingPiece[2][2] = MOVING; } break;    //L inversa
	case 3: { incomingPiece[0][1] = MOVING; incomingPiece[1][1] = MOVING; incomingPiece[2][1] = MOVING; incomingPiece[3][1] = MOVING; } break;    //Recta
	case 4: { incomingPiece[1][0] = MOVING; incomingPiece[1][1] = MOVING; incomingPiece[1][2] = MOVING; incomingPiece[2][1] = MOVING; } break;    //Creu tallada
	case 5: { incomingPiece[1][1] = MOVING; incomingPiece[2][1] = MOVING; incomingPiece[2][2] = MOVING; incomingPiece[3][2] = MOVING; } break;    //S
	case 6: { incomingPiece[1][2] = MOVING; incomingPiece[2][2] = MOVING; incomingPiece[2][1] = MOVING; incomingPiece[3][1] = MOVING; } break;    //S inversa
}
}

static void ResolveFallingMovement(bool *detection, bool *pieceActive)
{
	// If we finished moving this piece, we stop it
	if (*detection)
	{
		for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
		{
			for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
			{
				if (grid[i][j] == MOVING)
				{
					grid[i][j] = FULL;
					*detection = false;
					*pieceActive = false;
				}
			}
		}
	}
	else    // We move down the piece
	{
		for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
		{
			for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
			{
				if (grid[i][j] == MOVING)
				{
					grid[i][j+1] = MOVING;
					grid[i][j] = EMPTY;
				}
			}
		}
		
		piecePositionY++;
	}
}

static bool ResolveLateralMovement()
{
	bool collision = false;
	
	// Piece movement
	if (IsKeyDown(KEY_LEFT))        // Move left
	{
		// Check if is possible to move to left
		for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
		{
			for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
			{
				if (grid[i][j] == MOVING)
				{
					// Check if we are touching the left wall or we have a full square at the left
					if ((i-1 == 0) || (grid[i-1][j] == FULL)) collision = true;
				}
			}
		}
		
		// If able, move left
		if (!collision)
		{
			for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
			{
				for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)             // We check the matrix from left to right
				{
					// Move everything to the left
					if (grid[i][j] == MOVING)
					{
						grid[i-1][j] = MOVING;
						grid[i][j] = EMPTY;
					}
				}
			}
			
			piecePositionX--;
		}
	}
	else if (IsKeyDown(KEY_RIGHT))  // Move right
	{
		// Check if is possible to move to right
		for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
		{
			for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
			{
				if (grid[i][j] == MOVING)
				{
					// Check if we are touching the right wall or we have a full square at the right
					if ((i+1 == GRID_HORIZONTAL_SIZE - 1) || (grid[i+1][j] == FULL))
					{
						collision = true;
						
					}
				}
			}
		}
		
		// If able move right
		if (!collision)
		{
			for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
			{
				for (int i = GRID_HORIZONTAL_SIZE - 1; i >= 1; i--)             // We check the matrix from right to left
				{
					// Move everything to the right
					if (grid[i][j] == MOVING)
					{
						grid[i+1][j] = MOVING;
						grid[i][j] = EMPTY;
					}
				}
			}
			
			piecePositionX++;
		}
	}
	
	return collision;
}

static bool ResolveTurnMovement()
{
	// Input for turning the piece
	if (IsKeyDown(KEY_UP))
	{
		GridSquare aux;
		bool checker = false;
		
		// Check all turning possibilities
		if ((grid[piecePositionX + 3][piecePositionY] == MOVING) &&
			(grid[piecePositionX][piecePositionY] != EMPTY) &&
			(grid[piecePositionX][piecePositionY] != MOVING)) checker = true;
		
		if ((grid[piecePositionX + 3][piecePositionY + 3] == MOVING) &&
			(grid[piecePositionX + 3][piecePositionY] != EMPTY) &&
			(grid[piecePositionX + 3][piecePositionY] != MOVING)) checker = true;
		
		if ((grid[piecePositionX][piecePositionY + 3] == MOVING) &&
			(grid[piecePositionX + 3][piecePositionY + 3] != EMPTY) &&
			(grid[piecePositionX + 3][piecePositionY + 3] != MOVING)) checker = true;
		
		if ((grid[piecePositionX][piecePositionY] == MOVING) &&
			(grid[piecePositionX][piecePositionY + 3] != EMPTY) &&
			(grid[piecePositionX][piecePositionY + 3] != MOVING)) checker = true;
		
		if ((grid[piecePositionX + 1][piecePositionY] == MOVING) &&
			(grid[piecePositionX][piecePositionY + 2] != EMPTY) &&
			(grid[piecePositionX][piecePositionY + 2] != MOVING)) checker = true;
		
		if ((grid[piecePositionX + 3][piecePositionY + 1] == MOVING) &&
			(grid[piecePositionX + 1][piecePositionY] != EMPTY) &&
			(grid[piecePositionX + 1][piecePositionY] != MOVING)) checker = true;
		
		if ((grid[piecePositionX + 2][piecePositionY + 3] == MOVING) &&
			(grid[piecePositionX + 3][piecePositionY + 1] != EMPTY) &&
			(grid[piecePositionX + 3][piecePositionY + 1] != MOVING)) checker = true;
		
		if ((grid[piecePositionX][piecePositionY + 2] == MOVING) &&
			(grid[piecePositionX + 2][piecePositionY + 3] != EMPTY) &&
			(grid[piecePositionX + 2][piecePositionY + 3] != MOVING)) checker = true;
		
		if ((grid[piecePositionX + 2][piecePositionY] == MOVING) &&
			(grid[piecePositionX][piecePositionY + 1] != EMPTY) &&
			(grid[piecePositionX][piecePositionY + 1] != MOVING)) checker = true;
		
		if ((grid[piecePositionX + 3][piecePositionY + 2] == MOVING) &&
			(grid[piecePositionX + 2][piecePositionY] != EMPTY) &&
			(grid[piecePositionX + 2][piecePositionY] != MOVING)) checker = true;
		
		if ((grid[piecePositionX + 1][piecePositionY + 3] == MOVING) &&
			(grid[piecePositionX + 3][piecePositionY + 2] != EMPTY) &&
			(grid[piecePositionX + 3][piecePositionY + 2] != MOVING)) checker = true;
		
		if ((grid[piecePositionX][piecePositionY + 1] == MOVING) &&
			(grid[piecePositionX + 1][piecePositionY + 3] != EMPTY) &&
			(grid[piecePositionX + 1][piecePositionY + 3] != MOVING)) checker = true;
		
		if ((grid[piecePositionX + 1][piecePositionY + 1] == MOVING) &&
			(grid[piecePositionX + 1][piecePositionY + 2] != EMPTY) &&
			(grid[piecePositionX + 1][piecePositionY + 2] != MOVING)) checker = true;
		
		if ((grid[piecePositionX + 2][piecePositionY + 1] == MOVING) &&
			(grid[piecePositionX + 1][piecePositionY + 1] != EMPTY) &&
			(grid[piecePositionX + 1][piecePositionY + 1] != MOVING)) checker = true;
		
		if ((grid[piecePositionX + 2][piecePositionY + 2] == MOVING) &&
			(grid[piecePositionX + 2][piecePositionY + 1] != EMPTY) &&
			(grid[piecePositionX + 2][piecePositionY + 1] != MOVING)) checker = true;
		
		if ((grid[piecePositionX + 1][piecePositionY + 2] == MOVING) &&
			(grid[piecePositionX + 2][piecePositionY + 2] != EMPTY) &&
			(grid[piecePositionX + 2][piecePositionY + 2] != MOVING)) checker = true;
		
		if (!checker)
		{
			aux = piece[0][0];
			piece[0][0] = piece[3][0];
			piece[3][0] = piece[3][3];
			piece[3][3] = piece[0][3];
			piece[0][3] = aux;
			
			aux = piece[1][0];
			piece[1][0] = piece[3][1];
			piece[3][1] = piece[2][3];
			piece[2][3] = piece[0][2];
			piece[0][2] = aux;
			
			aux = piece[2][0];
			piece[2][0] = piece[3][2];
			piece[3][2] = piece[1][3];
			piece[1][3] = piece[0][1];
			piece[0][1] = aux;
			
			aux = piece[1][1];
			piece[1][1] = piece[2][1];
			piece[2][1] = piece[2][2];
			piece[2][2] = piece[1][2];
			piece[1][2] = aux;
		}
		
		for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
		{
			for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
			{
				if (grid[i][j] == MOVING)
				{
					grid[i][j] = EMPTY;
				}
			}
		}
		
		for (int i = piecePositionX; i < piecePositionX + 4; i++)
		{
			for (int j = piecePositionY; j < piecePositionY + 4; j++)
			{
				if (piece[i - piecePositionX][j - piecePositionY] == MOVING)
				{
					grid[i][j] = MOVING;
				}
			}
		}
		
		return true;
	}
	
	return false;
}

static void CheckDetection(bool *detection)
{
	for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
	{
		for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
		{
			if ((grid[i][j] == MOVING) && ((grid[i][j+1] == FULL) || (grid[i][j+1] == BLOCK))) *detection = true;
		}
	}
}

static void CheckCompletion(bool *lineToDelete)
{
	int calculator = 0;
	
	for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
	{
		calculator = 0;
		for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
		{
			// Count each square of the line
			if (grid[i][j] == FULL)
			{
				calculator++;
			}
			
			// Check if we completed the whole line
			if (calculator == GRID_HORIZONTAL_SIZE - 2)
			{
				*lineToDelete = true;
				calculator = 0;
				// points++;
				
				// Mark the completed line
				for (int z = 1; z < GRID_HORIZONTAL_SIZE - 1; z++)
				{
					grid[z][j] = FADING;
				}
			}
		}
	}
}

static void DeleteCompleteLines()
{
	// Erase the completed line
	for (int j = GRID_VERTICAL_SIZE - 2; j >= 0; j--)
	{
		while (grid[1][j] == FADING)
		{
			for (int i = 1; i < GRID_HORIZONTAL_SIZE - 1; i++)
			{
				grid[i][j] = EMPTY;
			}
			
			for (int j2 = j-1; j2 >= 0; j2--)
			{
				for (int i2 = 1; i2 < GRID_HORIZONTAL_SIZE - 1; i2++)
				{
					if (grid[i2][j2] == FULL)
					{
						grid[i2][j2+1] = FULL;
						grid[i2][j2] = EMPTY;
					}
					else if (grid[i2][j2] == FADING)
					{
						grid[i2][j2+1] = FADING;
						grid[i2][j2] = EMPTY;
					}
				}
			}
		}
	}
}

 

创作不易，帮忙点个赞呗~~ (#^.^#) 

liyinuo23
关注
  • 4
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++：俄罗斯方块游戏(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-08 350
C++：俄罗斯方块游戏(附完整源码)
基于C++的俄罗斯方块小游戏设计源码
最新发布
04-05
本资源提供了一套基于C++的俄罗斯方块小游戏的设计源码，包含25个文件，其中包括10个头文件，7个C++源代码文件，以及2个Markdown文档。此外，还包括1个解决方案文件，1个项目设置文件，1个资源文件，1个Visual C++项目文件，1个图标文件和1个资源脚本文件。这些文件详细展示了如何使用C++构建一个俄罗斯方块小游戏，非常适合用于个人学习和参考C++项目的开发。
C语言俄罗斯方块源代码（学习小熊猫C++）
2301_81147214的博客
03-16 521
endifInitGame();#elsewhile (!#endifreturn 0;level = 1;lines = 0;
俄罗斯方块C++代码
11-05
俄罗斯方块一款经典的小游戏，这里是C++源码，
C俄罗斯方块源代码
希望记录下自己的一点一滴，慢慢成长。。
01-27 2571
转自：http://blog.csdn.net/l04205613/article/details/6972061 #include #include #include #include #include #define MOD 28 #define SIZE_N 19 #define SIZE_M 12 int cur_x,cur_y; int score,mark,
C++写俄罗斯方块
LCY20110310的博客
05-25 293
0) printf("┆开始 ┆");else printf("┆暂停 ┆");if(x==1) printf("┆重置 ┆");if(x==2) printf("┆退出 ┆");if(x==4) printf("┆是┆");else printf("┆否┆");printf("加速!printf("暂停");printf("你想要 ");printf("下一个");printf("最高分");printf("得分");printf("速度");
俄罗斯方块C++源代码
09-18
总的来说，“俄罗斯方块C++源代码”是一个综合性的学习资源，它涵盖了C++的基本语法、面向对象编程、文件I/O、数据结构（矩阵）、事件处理和算法（如方块旋转和碰撞检测）等多个方面。通过阅读和理解这个源代码，...
c++Windows编程俄罗斯方块
12-04
用c++Windows编程写的俄罗斯方块，内有详细注解，
Dev-C++俄罗斯方块源代码
07-14
C++俄罗斯方块源代码
C++ 俄罗斯方块实现 1G视频教程.zip
08-18
在本套"C++ 俄罗斯方块实现 1G视频教程"中，你将深入学习如何使用C++编程语言从零开始构建经典的俄罗斯方块游戏。这个教程覆盖了多个关键的编程概念和技术，对于想要提升C++技能或者对游戏开发感兴趣的初学者来说，...
C++实现俄罗斯方块游戏
09-07
《C++实现俄罗斯方块游戏详解》 俄罗斯方块是一款深受玩家喜爱的经典电子游戏，它的基本玩法是不同形状的方块从屏幕顶部不断落下，玩家需要通过旋转和移动这些方块，使它们在屏幕底部形成完整的水平行，进而消除...
一种用于png图片处理的C/C++库lodepng的使用说明及踩坑记录
qq_30623327的博客
08-02 4706
引言 前文说到，基于Alios系统的门禁只能处理JPG图片，由于历史遗留问题，服务器下发的人脸中有png格式的图片，开发人员需要将png图片进行解码处理成RGBA格式的图片，用于人脸识别，网上用的最多图片处理库为libjpg和libpng这些图片处理库过于复杂且移植后会扩大程序的大小，因此一款轻量级的png图片处理库的需求日益强烈。 lodepng介绍 LodePNG是一个集合了PNG图像解码器和编码器的代码文件，不依赖于诸如zlib和libpng的外部链接/库，提供方便友好的PNG编解码器调用方法。Lod
俄罗斯方块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++ 实现俄罗斯方块（附详细解析）
qq_28634403的博客
11-07 2万+
需要用到的知识点 条件判断 循环 函数 数组 多cpp文件调用 指针 类 windows的cmd操作 整个程序的实现流程 我们先简单看一下整个实现流程的目录，这个也差不多是我实现时候的具体流程。我一般在写一个相对有点工程量的东西之前会先确定我要做的东西是什么，然后进行分析，接着就是大概设计一下整个项目的模块都有哪些，当然基本是不可能完全覆盖和正确的，但是会有一个大致的方向和流程去完成整个项目，...
c++编程——俄罗斯方块（毫无挑战版）
yang21198的博客
11-26 714
case 80:/*向下键盘键 */cout
C++实现俄罗斯方块（源码+详解）
IT OR 考公？
08-11 1万+
18746字，所有代码，直接复制可玩
带你全流程做完c++ 俄罗斯方块小游戏
abeijixingdeye的博客
12-02 645
原版b站链接：【百万好评】国外油管大神C++游戏编程实战教程，新手6小时入门，并快速达到游戏开发能力（中英字幕）_哔哩哔哩_bilibili【百万好评】国外油管大神C++游戏编程实战教程，新手6小时入门，并快速达到游戏开发能力（中英字幕）共计28条视频，包括：1.俄罗斯方块、2.第一人称射击游戏、3.命令提示符的第一人称射击游戏 (C++)等，UP主更多精彩视频，请关注UP账号。
c/c++ 实现俄罗斯方块小游戏（附全部源码）
q841447739的博客
08-11 2万+
使用easyX库，基于c/c++，实现俄罗斯方块小游戏。（附全部源码）
C++俄罗斯方块课程设计与面向对象编程实践
"C++俄罗斯方块课程设计(雷惊风)" 这篇资源主要涉及的是一个基于C++语言的俄罗斯方块游戏的设计与实现，是作为计算机系信息安全专业学生的毕业论文项目。作者强调，C++程序设计涵盖了面向对象编程的理论、C++语言的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值