基于vs2022，使用easyX库制作俄罗斯方块

于 2024-07-05 17:38:39 发布
阅读量149 收藏 1
点赞数 4
文章标签： java javascript 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzh192837/article/details/140214944
版权 
//三个文件，这个是main.cpp
#include"game.h"


int main() {
    srand(time(NULL));
		clock_t starttime, endtime = 0;

		initgraph(600, 540, 1);
		while (1) {
			Game tmp;
			tmp.Paint_BackGround_Window();
			tmp.Request_Window();
			tmp.Paint_Pre_Game_Area();
			starttime = clock();
			while (1) {
				BeginBatchDraw();
				/* 绘制函数*/
				tmp.Paint();
				endtime = clock();
				if (endtime - starttime > 1000) {
					starttime = clock();
					BeginBatchDraw();
					/* 绘制函数*/
					tmp.Block_Move_DOWN();
					//绘制的内容：物块每秒钟下降一次
					FlushBatchDraw();
				}
				FlushBatchDraw();
				tmp.Key_Press();
				tmp.Check_game_area_And_Clear_All_Line_And_Change_Score();
				if (tmp.IsOver()) {
					if (!tmp.Over_Service()) {
						closegraph();
						return 0;
					}
					break;
				}
				cleardevice();
			}
			cleardevice();
		}
		
}

//这个是game.h
#pragma once

#define _CRT_SECURE_NO_WARNINGS

#include<graphics.h>//图形库头文件
#include<iostream>
#include<easyx.h>//鼠标
#include<conio.h>//使用getch()
#include<stdio.h>
#include<time.h> 
#include <stdlib.h>  
const int game_area_x = 10;//横着能放的方块数
const int game_area_y = 15;//竖着能放的方块数
const int Block_Area_x = 4;//方块组对象横着能放的方块个数
const int Block_Area_y = 4;//方块组对象竖着着能放的方块个数
//方块的定义
const int Occupied_Part_Length = 36;//占据部分
const int Inner_Margin = 2;//内边距
const int Border_Fillet = 6;//边框圆角
const int Really_length = 32;//实体边长
using namespace std;
static int tmp1[4][4] = { 
	{0,0,0,0}, 
	{0,1,1,0} ,
	{0,1,1,0} ,
	{0,0,0,0} };
static int tmp2[4][4] = {
	{0,1,0,0},
	{0,1,0,0} ,
	{0,1,0,0} ,
	{0,1,0,0} };
static int tmp3[4][4] = {
	{0,0,1,0},
	{0,0,1,0} ,
	{0,1,1,0} ,
	{0,0,0,0} };
static int tmp4[4][4] = {
	{0,1,0,0},
	{0,1,0,0} ,
	{0,1,1,0} ,
	{0,0,0,0} };
static int tmp5[4][4] = {
	{0,1,0,0},
	{0,1,1,0} ,
	{0,0,1,0} ,
	{0,0,0,0} };
static int tmp6[4][4] = {
	{0,0,1,0},
	{0,1,1,0} ,
	{0,1,0,0} ,
	{0,0,0,0} };
static int tmp7[4][4] = {
	{0,1,0,0},
	{1,1,1,0} ,
	{0,0,0,0} ,
	{0,0,0,0} };

int Get_Random_Number();


class Block_Group {
	friend class Game;
private:
	int Block_Position_x = 0;
	int Block_Position_y = 0;
	int Block_Area[Block_Area_y][Block_Area_x] = { 0 };
public:
	void Block_Copy(int x[4][4]);//复制数组
	void Block_Array_Refresh(int x);//只刷新数组，传入id
	void Block_Group_Refresh(int x);//刷新x,y,二维数组
};
class Game  {
	private:
	Block_Group C_Board_Group;//当前
	Block_Group N_Board_Group;//下一个
	int score = 0;
	int game_area[game_area_y][game_area_x] = { 0 };//0,1（不稳定，红色）,2(稳定，绿色)
public:
	Game() {
		C_Board_Group.Block_Group_Refresh(Get_Random_Number());
		N_Board_Group.Block_Group_Refresh(Get_Random_Number());
	}
	void Paint_Warn_Line();
	void Paint();//全部绘制
	void Paint_BackGround_Window();//背景绘制
	void Request_Window();//询问是否要玩游戏
	void Paint_Game_Area();//绘制游戏区域上个各种状态的方块
	void Paint_Pre_Game_Area();//根据id画出下一个预告方块组
	void Next_Trans_Current_And_Next_Refresh();//N-》C
	void Key_Press();//检测键盘信息
	bool IsCollide_Up();
	bool IsCollide_Down();//能够下降吗
	int IsCollide_Left();//能够左移吗
	int IsCollide_Right();//能够右移吗
	void To_Stable();//直接让C_Board_Group中的1按照位置以2的内容传给game_area
	bool Block_Move_DOWN();//接受了下降指令后，C_Board_Group要进行下降，Block_Position_y会发生改变,并且直接绘制
	void Block_Move_LEFT();//接受了左移指令后，C_Board_Group要进行左移，Block_Position_x会发生改变,并且直接绘制
	void Block_Move_RIGHT();//接受了右移指令后，C_Board_Group要进行右移，Block_Position_x会发生改变,并且直接绘制
	void Block_Move_UP();
	void Block_Move_SPACE();
	void Check_game_area_And_Clear_All_Line_And_Change_Score();//遍历棋盘，所有整行2删除，并且记录删除次数，进行分数计算
	bool IsOver();//游戏结束了吗：结束了返回true
	bool Over_Service();//不想重玩，返回false
};
int Get_N_ID();












//这个是game.cpp
#include"game.h"
int N_ID;
int Get_Random_Number()
{
	return rand() % 7 + 1;
}//返回1~7的随机数
void Game::Paint_BackGround_Window() {

	//色彩
	for (int i = 0; i < 541; ++i)
	{
		setlinecolor(RGB(135, 206, 250 - i / 5));
		line(0, 540 - i, 360, 540 - i);
	}
	for (int i = 0; i < 541; ++i)
	{
		setlinecolor(RGB(224, 178, 220 - i / 15));
		line(361, i, 600, i);
	}
	//文字
	//得分
	char str[50];
	settextstyle(30, 0, "楷体");//字体大小
	settextcolor(BLUE);//字体颜色
	setbkmode(TRANSPARENT);//不叠加，透过
	sprintf(str, "score:%d", score);
	outtextxy(360 + 48, 200, str);
	//按键提示
	outtextxy(360 + 48, 300 + 30 * 0, "左移 ←");
	outtextxy(360 + 48, 300 + 30 * 1, "右移 →");
	outtextxy(360 + 48, 300 + 30 * 2, "旋转 ↑");
	outtextxy(360 + 48, 300 + 30 * 3, "下落 ↓");
	//侧边预览框
	setlinecolor(RED);//边线颜色
	setlinestyle(0, 5);
	rectangle(360 + 36, 36, 600 - 48 - 12, 36 + 144);
}
bool Game::Over_Service() {
	//设置窗口标题
	HWND hnd = GetHWnd();
	SetWindowText(hnd, "俄罗斯方块");
	//弹出窗口
	int isok = MessageBox(NULL,
		"\t  LOSE！\n       DO YOU WANGT TO PALY AGAIN?",
		"俄罗斯方块",
		MB_OKCANCEL);
	if (isok != IDOK) {
		return false;
	}
}
void Game::Request_Window() {
	//设置窗口标题
	HWND hnd = GetHWnd();
	SetWindowText(hnd, "俄罗斯方块");
	//弹出窗口
	int isok = MessageBox(NULL,
		"\t  WELCOME！\n        DO YOU WANT TO PLAY?",
		"俄罗斯方块",
		MB_OKCANCEL);
	if (isok != IDOK) {
		exit(0);
	}
}
//方块x为36，y为36
void  Draw_Block_RED(int x, int y) {
	setlinecolor(BLACK);
	setfillcolor(RED);
	fillroundrect(x * Occupied_Part_Length, y * Occupied_Part_Length,
		x * Occupied_Part_Length + Occupied_Part_Length,
		y * Occupied_Part_Length + Occupied_Part_Length, Border_Fillet, Border_Fillet);
}
void  Draw_Block_GREEN(int x, int y) {
	setlinecolor(BLACK);
	setfillcolor(GREEN);
	fillroundrect(x * Occupied_Part_Length, y * Occupied_Part_Length,
		x * Occupied_Part_Length + Occupied_Part_Length,
		y * Occupied_Part_Length + Occupied_Part_Length, Border_Fillet, Border_Fillet);
}
void Game::Paint_Game_Area() {

	for (int i = 0; i < game_area_x; i++) {
		for (int j = 0; j < game_area_y; j++) {
			if (game_area[j][i] == 1) {
				Draw_Block_RED(i, j);
			}
			else if (game_area[j][i] == 2) {
				Draw_Block_GREEN(i, j);
			}

		}
	}
}
void Block_Group::Block_Copy(int tmp[4][4]) {
	for (int i = 0;i < 4;i++) {
		for (int j = 0;j < 4;j++) {
			Block_Area[i][j] = tmp[i][j];
		}
	}
}


void Block_Group::Block_Array_Refresh(int x) {
	switch (x) {
	case 1: {
		Block_Copy(tmp1);
		break;
	}
	case 2: {
		Block_Copy(tmp2);
		break;
	}
	case 3: {
		Block_Copy(tmp3);
		break;
	}
	case 4: {
		Block_Copy(tmp4);
		break;
	}
	case 5: {
		Block_Copy(tmp5);
		break;
	}
	case 6: {
		Block_Copy(tmp6);
		break;
	}
	case 7: {
		Block_Copy(tmp7);
		break;
	}
	default:
		break;
	}
}
void Block_Group::Block_Group_Refresh(int x)//刷新
{
	N_ID = x;
	Block_Array_Refresh(x);
	Block_Position_x = 3;
	Block_Position_y = 0;

}



void block_copy_Two(int Ablock[4][4], int Bblock[4][4]) {
	for (int i = 0;i < 4;i++) {
		for (int j = 0;j < 4;j++) {
			Ablock[i][j] = Bblock[i][j];
		}
	}

}
void Game::Paint_Pre_Game_Area()//已经获取了id
{
	int t[4][4];
	switch (N_ID) {
	case 1: {
		block_copy_Two(t, tmp1);
		break;
	}
	case 2: {
		block_copy_Two(t, tmp2);
		break;
	}
	case 3: {
		block_copy_Two(t, tmp3);
		break;
	}
	case 4: {
		block_copy_Two(t, tmp4);
		break;
	}
	case 5: {
		block_copy_Two(t, tmp5);
		break;
	}
	case 6: {
		block_copy_Two(t, tmp6);
		break;
	}
	case 7: {
		block_copy_Two(t, tmp7);
		break;
	}
	default:
		break;
	}

	for (int i = 0;i < 4;i++) {
		for (int j = 0;j < 4;j++) {
			if (t[j][i] == 1) {
				Draw_Block_RED(i + 11, j + 1);
			}
		}
	}
}

int Get_N_ID() {
	return N_ID;
}
void Game::Paint_Warn_Line() {
	setlinecolor(BROWN);
	setlinestyle(PS_SOLID,2);
	line(0,36*4,360,36*4);
}

void Game::Next_Trans_Current_And_Next_Refresh()
{
	block_copy_Two(C_Board_Group.Block_Area, N_Board_Group.Block_Area);
	N_Board_Group.Block_Group_Refresh(Get_Random_Number());
}


void Game::To_Stable() {
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			if (C_Board_Group.Block_Area[j][i] == 1) {
				game_area[j + C_Board_Group.Block_Position_y][i + C_Board_Group.Block_Position_x] = 2;
			}
		}
	}
}

bool Game::IsCollide_Down() {
	int dbound;
	for (int i = 0; i < 4; i++)
		for (int j = 0; j < 4; j++)
			if (C_Board_Group.Block_Area[i][j] == 1)
			{
				dbound = i;
				break;
			}
	int y = C_Board_Group.Block_Position_y;
	y++;

	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			if (dbound + y > game_area_y - 1 || (C_Board_Group.Block_Area[i][j] == 1 && game_area[i + y][j + C_Board_Group.Block_Position_x] == 2)) {
				return true;
			}
		}
	}
	return false;
}
bool Game::Block_Move_DOWN() {

	if (IsCollide_Down()) {
		To_Stable();
		Next_Trans_Current_And_Next_Refresh();
		C_Board_Group.Block_Position_x = 3;
		C_Board_Group.Block_Position_y = 0;
		return false;
	}
	else {
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				if (C_Board_Group.Block_Area[j][i] == 1)
					game_area[j + C_Board_Group.Block_Position_y][i + C_Board_Group.Block_Position_x] = 0;
			}
		}
		C_Board_Group.Block_Position_y++;

		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				if (game_area[j + C_Board_Group.Block_Position_y][i + C_Board_Group.Block_Position_x] != 2 && (j + C_Board_Group.Block_Position_y) <= game_area_y - 1)
					game_area[j + C_Board_Group.Block_Position_y][i + C_Board_Group.Block_Position_x] = C_Board_Group.Block_Area[j][i];
			}
		}
	}
	return true;
}

void Game::Paint() {
	Paint_BackGround_Window();
	Paint_Game_Area();
	Paint_Pre_Game_Area();
	Paint_Warn_Line();
}
bool Game::IsCollide_Up() {
	int temp_block[4][4];int nums = 0;
	for (int i = 0;i < 4;i++)
		for (int j = 0;j < 4;j++)
		{
			temp_block[3 - j][i] = C_Board_Group.Block_Area[i][j];
			if (temp_block[3 - j][i] == 1) {
				nums++;
			}
		}
	int lbound = 10, rbound=-1;
	int ubound = 10, dbound = -1;
	for (int j = 0;j < 4;j++) {
		for (int i = 0;i < 4;i++) {
			if(temp_block[i][j] == 1)
			lbound = min(lbound, j);
			rbound = max(rbound, j);
			ubound = min(ubound, i);
			dbound = max(dbound, i);
		}
	}
	if (C_Board_Group.Block_Position_x + lbound >= 0&&
		C_Board_Group.Block_Position_x + rbound < 10&&
		C_Board_Group.Block_Position_y+dbound<=14)
	{
		for (int i = C_Board_Group.Block_Position_y + ubound;i <= C_Board_Group.Block_Position_y + dbound;i++) {
			for (int j = C_Board_Group.Block_Position_x + lbound;j <= C_Board_Group.Block_Position_x + rbound;j++) {
				if (temp_block[i- C_Board_Group.Block_Position_y][j- C_Board_Group.Block_Position_x] == 1) {
					if (game_area[i ][j] == 2) {
						return true;
					}
				}
			}
		}
		return false;
	}
	return true;
}

void Game::Block_Move_UP() {
	if (IsCollide_Up()) {
	}
	else {
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				if (C_Board_Group.Block_Area[j][i] == 1)
					game_area[j + C_Board_Group.Block_Position_y][i + C_Board_Group.Block_Position_x] = 0;
			}
		}//擦除
		int temp_block[4][4];
		for (int i = 0;i < 4;i++)
			for (int j = 0;j < 4;j++)
					temp_block[3 - j][i] = C_Board_Group.Block_Area[i][j];
		for (int i = 0;i < 4;i++)
			for (int j = 0;j < 4;j++)
				C_Board_Group.Block_Area[i][j] = temp_block[i][j];
		//方块组变形
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				if (game_area[j + C_Board_Group.Block_Position_y][i + C_Board_Group.Block_Position_x] != 2 && (j + C_Board_Group.Block_Position_y) <= game_area_y - 1)
					game_area[j + C_Board_Group.Block_Position_y][i + C_Board_Group.Block_Position_x] = C_Board_Group.Block_Area[j][i];
			}
		}
		//游戏区域数组更新
	}
}


void Game::Key_Press() {
	if (GetAsyncKeyState(VK_UP)) {
		Sleep(100);
		Block_Move_UP();
	}
	else if (GetAsyncKeyState(VK_RIGHT)) {
		Sleep(100);
		Block_Move_RIGHT();
	}
	else if (GetAsyncKeyState(VK_LEFT)) {
		Sleep(100);
		Block_Move_LEFT();
	}
	else if (GetAsyncKeyState(VK_DOWN)) {
		Sleep(100);
		Block_Move_DOWN();
	}
	else if (GetAsyncKeyState(VK_SPACE)) {
		Sleep(100);
		Block_Move_SPACE();
	}
}




int Game::IsCollide_Left() {
	int lbound, rbound, ubound, dbound;
	for (int i = 3; i >= 0; i--)
		for (int j = 0; j < 4; j++)
			if (C_Board_Group.Block_Area[i][j] == 1)
			{
				ubound = i;
				break;
			}
	for (int j = 3; j >= 0; j--)
		for (int i = 0; i < 4; i++)
			if (C_Board_Group.Block_Area[i][j] == 1)
			{
				lbound = j;
				break;
			}
	for (int i = 0; i < 4; i++)
		for (int j = 0; j < 4; j++)
			if (C_Board_Group.Block_Area[i][j] == 1)
			{
				dbound = i;
				break;
			}
	for (int j = 0; j < 4; j++)
		for (int i = 0; i < 4; i++)
			if (C_Board_Group.Block_Area[i][j] == 1)
			{
				rbound = j;
				break;
			}
	int x = C_Board_Group.Block_Position_x;
	x--;
	if (lbound + x < 0) {
		return 1;
	}
	for (int i = lbound; i <= rbound; i++) {
		for (int j = ubound; j <= dbound; j++) {
			if (x + lbound == i + x && game_area[j + C_Board_Group.Block_Position_y][i + x] == 2) {
				return 1;
			}
		}
	}
	for (int i = lbound; i <= rbound; i++) {
		for (int j = ubound; j <= dbound; j++) {
			if (x + lbound<0 || x + rbound>game_area_x - 1 || (C_Board_Group.Block_Area[j][i] == 1 && game_area[j + C_Board_Group.Block_Position_y][i + x] == 2)) {
				return 2;
			}
		}
	}
	return 3;

}//能够左移吗
int Game::IsCollide_Right() {
	int lbound, rbound, ubound, dbound;
	for (int i = 3; i >= 0; i--)
		for (int j = 0; j < 4; j++)
			if (C_Board_Group.Block_Area[i][j] == 1)
			{
				ubound = i;
				break;
			}
	for (int j = 3; j >= 0; j--)
		for (int i = 0; i < 4; i++)
			if (C_Board_Group.Block_Area[i][j] == 1)
			{
				lbound = j;
				break;
			}
	for (int i = 0; i < 4; i++)
		for (int j = 0; j < 4; j++)
			if (C_Board_Group.Block_Area[i][j] == 1)
			{
				dbound = i;
				break;
			}
	for (int j = 0; j < 4; j++)
		for (int i = 0; i < 4; i++)
			if (C_Board_Group.Block_Area[i][j] == 1)
			{
				rbound = j;
				break;
			}
	int x = C_Board_Group.Block_Position_x;
	x++;
	if (rbound + x > game_area_x - 1) {
		return 1;
	}
	for (int i = lbound; i <= rbound; i++) {
		for (int j = ubound; j <= dbound; j++) {
			if (x + rbound == x + i && game_area[j + C_Board_Group.Block_Position_y][i + x] == 2) {
				return 1;
			}
		}
	}
	for (int i = lbound; i <= rbound; i++) {
		for (int j = ubound; j <= dbound; j++) {
			if (x + lbound<0 || x + rbound>game_area_x - 1 || (C_Board_Group.Block_Area[j][i] == 1 && game_area[j + C_Board_Group.Block_Position_y][i + x] == 2)) {
				return 2;
			}
		}
	}
	return 3;


}//能够右移吗

void Game::Block_Move_LEFT() {


	if (IsCollide_Left() == 2) {
		To_Stable();
		Next_Trans_Current_And_Next_Refresh();
		C_Board_Group.Block_Position_x = 3;
		C_Board_Group.Block_Position_y = 0;
	}
	else if (IsCollide_Left() == 1) {
	}
	else {
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				if (C_Board_Group.Block_Area[j][i] == 1)
					game_area[j + C_Board_Group.Block_Position_y][i + C_Board_Group.Block_Position_x] = 0;
			}
		}
		C_Board_Group.Block_Position_x--;

		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				if (game_area[j + C_Board_Group.Block_Position_y][i + C_Board_Group.Block_Position_x] != 2 && (j + C_Board_Group.Block_Position_y) <= game_area_y - 1
					&& (i + C_Board_Group.Block_Position_x) >= 0)
					game_area[j + C_Board_Group.Block_Position_y][i + C_Board_Group.Block_Position_x] = C_Board_Group.Block_Area[j][i];
			}
		}
	}

}
void Game::Block_Move_RIGHT() {

	if (IsCollide_Right() == 2) {
		To_Stable();
		Next_Trans_Current_And_Next_Refresh();
		C_Board_Group.Block_Position_x = 3;
		C_Board_Group.Block_Position_y = 0;
	}
	else if (IsCollide_Right() == 1) {
	}
	else {
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				if (C_Board_Group.Block_Area[j][i] == 1)
					game_area[j + C_Board_Group.Block_Position_y][i + C_Board_Group.Block_Position_x] = 0;
			}
		}
		C_Board_Group.Block_Position_x++;

		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				if (game_area[j + C_Board_Group.Block_Position_y][i + C_Board_Group.Block_Position_x] != 2 && (j + C_Board_Group.Block_Position_y) <= game_area_y - 1
					&& (i + C_Board_Group.Block_Position_x) <= game_area_x - 1)
					game_area[j + C_Board_Group.Block_Position_y][i + C_Board_Group.Block_Position_x] = C_Board_Group.Block_Area[j][i];
			}
		}
	}


}

void Game::Check_game_area_And_Clear_All_Line_And_Change_Score(){
	int line = 0;
	for (int i = 14;i >= 0;i--) {
		int flag = 1;
		
		for (int j = 0;j < 10;j++) {
			if (game_area[i][j] != 2) {

				flag = 0;
				break;
			}
		}
		if (flag == 1) {
			for(int k = i;k>0;k--)
			for (int j = 0;j < 10;j++) {
				game_area[k][j] = 0;
				swap(game_area[k][j], game_area[k-1][j]);
			}
			line++;
		}

	}
	while (line--) {
		score += (10 * (line+1));
	}


}


void Game::Block_Move_SPACE() {
	for (int i = 0;i < 15;i++) {
		if (!Block_Move_DOWN()) {
			return;
		}
	}
}

bool Game::IsOver() {
	for (int i = 0;i < 10;i++) {
		if (game_area[1][i] == 2) {
			cout << 1;
			return true;
		}
	}
	return false;

}

zzh192837
关注
Visual Studio下安装C/C++图形库（easyx）2022版
m0_57037805的博客
09-29 3万+
这里演示的是在Visual Studio 2022下安装C/C++图形库（easyx），简单易懂，从此告别黑乎乎的窗口。
利用easyX图像处理库构建俄罗斯方块
qq_50399762的博客
03-18 891
前言 《俄罗斯方块》是一款由俄罗斯人阿列克谢·帕基特诺夫于1984年6月发明的休闲游戏。 《俄罗斯方块》的基本规则是移动、旋转和摆放游戏自动输出的各种方块，使之排列成完整的一行或多行并且消除得分。 一、设计思路 1.1、利用二维数组构造出各种方块样式如下： 注意：这里还需构造各式方块的不同状态 L型方块： int shape[5][5]={ 0,0,0,0,0 0,0,1,0,0 0,0,1,0,0 0,0,1,1,1 } 1.2、利用easyX对窗口中游戏区和得分区的版块进行设计。 确定窗口大小，以
EasyX实现俄罗斯方块游戏
木子皿--啥都不会的菜鸟
11-21 5055
文章目录1 启动页面1.1 启动页面分析 1 启动页面 1.1 启动页面分析 启动页面： 启动页面分析： 启动界面的大小为：550 X 660（像素）。
EasyX项目-俄罗斯方块
m0_59061536的博客
01-04 4085
EasyX项目-俄罗斯方块
基于easyX实现俄罗斯方块
ftzchina的博客
03-11 4393
一：效果展示 二：环境准备 1，安装VS，目前最新版本是VS2022，安装方法可以参考我的博客 手把手教你安装VS2022_ftzchina的博客-CSDN博客一：官网下载地址Visual Studio: 面向软件开发人员和 Teams 的 IDE 和代码编辑器Visual Studio 开发工具和服务让任何开发人员在任何平台和语言的应用开发都更加轻松。 随时随地免费使用代码编辑器或 IDE 进行开发。https://visualstudio.microsoft.com/zh-hans/?r.
C++ EasyX 俄罗斯方块代码
01-07
简单的俄罗斯方块代码
大一计算机期末作业，c语言结合easyx编写的俄罗斯方块代码
07-26
本资源提供了一个使用 EasyX 库结合 C 语言开发的俄罗斯方块游戏代码。该代码实现了游戏的基本功能，包括游戏初始化、方块生成、游戏地图绘制和游戏逻辑实现等。 EasyX 库简介 EasyX 库是一个基于 C 语言的图形...
大二数据结构作业，基于vs2022以及easyx开发的有图形界面的通讯录项目
04-18
内容：基于vs2022以及easyx开发的有图形界面的通讯录项目。 概述：内部有自己手写的组件，通过这个项目可以更好的让你了解easyx的绝大部分内容。以便自己使用easyx快速开发自己喜欢的小项目，节省学习成本。这个项目...
基于C++和EasyX 写的俄罗斯方块小游戏源码+项目说明文件.zip
最新发布
07-19
这是一个使用 C++ 和 EasyX 写的俄罗斯方块小游戏，里面用到的 C++ 特性并不多。游戏主要分成了两个类来实现：Game 和 Block 类，分别用来实现游戏逻辑和单独的俄罗斯方块，里面顶多就用到了静态成员函数和变量的...
基于C语言实现俄罗斯方块使用EasyX插件
12-14
《基于C语言实现俄罗斯方块使用EasyX插件》 对于C语言初学者而言，学习并实践一个实际的游戏项目是提升编程技能和兴趣的良好途径。本项目“基于C语言实现俄罗斯方块使用EasyX插件”就是这样一个实例，旨在帮助初学...
C语言版俄罗斯方块（基于EASYX库）
10-23
这是用C语言写出来的俄罗斯方块，基于EASYX图形库，编译器VC++6.0，有兴趣的可以下来看看。
C 语言 + easyx 课程设计俄罗斯方块 （星空表白彩蛋 ，游戏是假，爱你是真）
05-11
C 语言课程设计作业 在下载 前需要 再到easyx官网下载 easyx 库 直接搜即可 ，下载好 程序，再选择再vscode 安装即可、下载好了压缩包，解压后 ，运行即可正常游戏。中途有任何问题欢迎私聊博主询问哦！ 适合给自己女朋友一个惊喜嘿嘿，表面看完成C 语言课程设计作业，实际逗女朋友开心为主
用C/C++加Easyx实现俄罗斯方块游戏（爆肝4万字，完全免费）
2301_79964905的博客
04-06 2122
想要完游戏么？自己动手吧！
用俄罗斯方块入门EasyX库
ZHangFFYY的博客
06-06 3094
从知乎的童老师那里看到这个库，感觉很好玩的样子，但对于一个入门小白来说，踩了很多的坑，所以我写下这篇文章，希望可以帮到你。首先你需要完成以下事: ①基础c/c++语法知识 ②了解Visual Studio基本使用方法（安装好easyx库，网上有教程，会建项目，会编译程序，把常用的功能都装上） ③会查EasyX官方手册（把官网上简易教程照着写一遍，很关键，知道如何使用库函数） ④一点windo
c + easyx 实现放怀旧掌机界面风格俄罗斯方块
weixin_48758682的博客
11-05 1466
c + easyx 实现放怀旧掌机界面风格俄罗斯方块 文章目录c + easyx 实现放怀旧掌机界面风格俄罗斯方块前言一、俄罗斯方块的构型二、游戏主界面的实现逻辑1.引入库2.读入数据总结 前言 好久没写东西了，用一个星期的下班休息时间写了一个俄罗斯方块小游戏，算是圆了儿时的一个梦。界面写成了怀旧的掌机风格，之所以写成这样是因为当初在查找资料的时候谷歌出来的第一个条目是github上的一个俄罗斯方块项目（项目地址），一下子就喜欢上这个风格，于是就打算模仿这个写了基本一样效果的。不同于github上的这个项
c/c++ 实现俄罗斯方块小游戏（附全部源码）
热门推荐
q841447739的博客
08-11 2万+
使用easyX库，基于c/c++，实现俄罗斯方块小游戏。（附全部源码）
easyx在vs里的简单使用
weixin_65716190的博客
04-19 372
初次使用easyx遇到的一个问题
vscode配置EasyX图形库（图文）（全网最全）
djc3501558870的博客
03-09 7444
引用原文链接：https://codebus.cn/bestans/easyx-for-mingw。
EasyX的安装与使用（VisualStudio C++免费绘图库）
2301_77482405的博客
01-24 1155
是针对Visual C++的免费绘图库安装教程安装示例程序easyxdemo.cpp的右击属性后找到，在中的。
基于easyx的俄罗斯方块
05-04
好的，我可以为您提供一些关于基于EasyX的俄罗斯方块的代码示例。 首先，您需要安装EasyX图形库并配置好开发环境。然后，您可以创建一个新的EasyX项目，编写以下代码来实现俄罗斯方块的基本功能： ```C++ #include <graphics.h> #include <conio.h> #include <time.h> #include <stdlib.h> const int BLOCK_SIZE = 20; // 方块大小 const int BOARD_WIDTH = 10; // 棋盘宽度 const int BOARD_HEIGHT = 20; // 棋盘高度 const int BOARD_LEFT = 100; // 棋盘左侧位置 const int BOARD_TOP = 50; // 棋盘顶部位置 const int WINDOW_WIDTH = 500; // 窗口宽度 const int WINDOW_HEIGHT = 600; // 窗口高度 const int FPS = 60; // 帧率 int board[BOARD_HEIGHT][BOARD_WIDTH] = {0}; // 棋盘数组 int currentBlock[4][4] = {0}; // 当前方块数组 int currentBlockType = 0; // 当前方块类型 int currentBlockX = 0; // 当前方块x坐标 int currentBlockY = 0; // 当前方块y坐标 int score = 0; // 得分 bool gameOver = false; // 游戏是否结束 // 方块类型及其形状 int blockTypes[7][4][4] = { { { 0, 0, 0, 0 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } }, { { 0, 2, 2, 0 }, { 0, 2, 2, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } }, { { 0, 3, 0, 0 }, { 3, 3, 3, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } }, { { 4, 4, 0, 0 }, { 0, 4, 4, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } }, { { 0, 5, 5, 0 }, { 5, 5, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } }, { { 6, 6, 6, 0 }, { 0, 0, 6, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } }, { { 7, 7, 7, 0 }, { 7, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } } }; // 绘制方块 void drawBlock(int x, int y, int type) { setfillcolor(type + 1); for (int i = 0; i < 4; i++) { for (int j = 0; j < 4; j++) { if (blockTypes[type][i][j]) { solidrectangle(BOARD_LEFT + (x + j) * BLOCK_SIZE, BOARD_TOP + (y + i) * BLOCK_SIZE, BOARD_LEFT + (x + j + 1) * BLOCK_SIZE, BOARD_TOP + (y + i + 1) * BLOCK_SIZE); } } } } // 绘制棋盘 void drawBoard() { setfillcolor(WHITE); solidrectangle(BOARD_LEFT, BOARD_TOP, BOARD_LEFT + BOARD_WIDTH * BLOCK_SIZE, BOARD_TOP + BOARD_HEIGHT * BLOCK_SIZE); for (int i = 0; i < BOARD_HEIGHT; i++) { for (int j = 0; j < BOARD_WIDTH; j++) { if (board[i][j]) { drawBlock(j, i, board[i][j] - 1); } } } } // 检查方块是否出界或与已有方块重叠 bool checkBlock(int x, int y, int type) { for (int i = 0; i < 4; i++) { for (int j = 0; j < 4; j++) { if (blockTypes[type][i][j]) { int newX = x + j; int newY = y + i; if (newX < 0 || newX >= BOARD_WIDTH || newY < 0 || newY >= BOARD_HEIGHT || board[newY][newX]) { return false; } } } } return true; } // 将当前方块放入棋盘中 void placeBlock() { for (int i = 0; i < 4; i++) { for (int j = 0; j < 4; j++) { if (blockTypes[currentBlockType][i][j]) { board[currentBlockY + i][currentBlockX + j] = currentBlockType + 1; } } } } // 移除已满行并计分 void removeFullRows() { for (int i = BOARD_HEIGHT - 1; i >= 0; i--) { bool rowFull = true; for (int j = 0; j < BOARD_WIDTH; j++) { if (!board[i][j]) { rowFull = false; break; } } if (rowFull) { for (int k = i; k > 0; k--) { for (int j = 0; j < BOARD_WIDTH; j++) { board[k][j] = board[k - 1][j]; } } i++; score += 100; } } } // 生成新的方块 void generateNewBlock() { currentBlockType = rand() % 7; for (int i = 0; i < 4; i++) { for (int j = 0; j < 4; j++) { currentBlock[i][j] = blockTypes[currentBlockType][i][j]; } } currentBlockX = BOARD_WIDTH / 2 - 2; currentBlockY = 0; if (!checkBlock(currentBlockX, currentBlockY, currentBlockType)) { gameOver = true; } } // 消息循环 void gameLoop() { while (!gameOver) { cleardevice(); drawBoard(); drawBlock(currentBlockX, currentBlockY, currentBlockType); char scoreStr[20]; sprintf_s(scoreStr, "Score: %d", score); outtextxy(10, 10, scoreStr); Sleep(1000 / FPS); if (kbhit()) { int key = getch(); switch (key) { case 'a': if (checkBlock(currentBlockX - 1, currentBlockY, currentBlockType)) { currentBlockX--; } break; case 'd': if (checkBlock(currentBlockX + 1, currentBlockY, currentBlockType)) { currentBlockX++; } break; case 's': if (checkBlock(currentBlockX, currentBlockY + 1, currentBlockType)) { currentBlockY++; } break; case 'w': int newType = (currentBlockType + 1) % 7; if (checkBlock(currentBlockX, currentBlockY, newType)) { currentBlockType = newType; } break; case ' ': while (checkBlock(currentBlockX, currentBlockY + 1, currentBlockType)) { currentBlockY++; } break; } } if (!checkBlock(currentBlockX, currentBlockY + 1, currentBlockType)) { placeBlock(); removeFullRows(); generateNewBlock(); } else { currentBlockY++; } } outtextxy(WINDOW_WIDTH / 2 - 50, WINDOW_HEIGHT / 2 - 10, "Game Over"); } // 主函数 int main() { initgraph(WINDOW_WIDTH, WINDOW_HEIGHT); srand((unsigned)time(NULL)); generateNewBlock(); gameLoop(); getch(); closegraph(); return 0; } ``` 以上代码实现了基本的俄罗斯方块游戏功能，包括绘制棋盘和方块、检查方块是否出界或与已有方块重叠、将当前方块放入棋盘中、移除已满行并计分、生成新的方块等。您可以根据需要进行修改和扩展。 希望这个示例对您有所帮助！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值