opengl实现俄罗斯方块

最新推荐文章于 2024-07-17 17:27:32 发布
最新推荐文章于 2024-07-17 17:27:32 发布
阅读量1.5w 收藏 36
点赞数 4
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/blowfire123/article/details/78569617
版权 
#include "Angel.h"

#pragma comment(lib, "glew32.lib")

#include <cstdlib>
#include <iostream>
#include <time.h>

using namespace std;

int starttime;			// 控制方块向下移动时间
int which;				// 那种方块
int score = 0;			// 得分
int gamespeed = 50;		// 速度
int rotation = 0;		// 控制当前窗口中的方块旋转
vec2 tile[4];			// 表示当前窗口中的方块
bool gameover = false;	// 游戏结束控制变量
int xsize = 400;		// 窗口大小（尽量不要变动窗口大小！）
int ysize = 720;

// 一个二维数组表示所有可能出现的方块和方向。
vec2 allRotationsLshape[7][4][4] =
{ { { vec2(0, 0), vec2(-1,0), vec2(1, 0), vec2(-1,-1) },	// "L"
{ vec2(0, 1), vec2(0, 0), vec2(0,-1), vec2(1, -1) },
{ vec2(1, 1), vec2(-1,0), vec2(0, 0), vec2(1,  0) },
{ vec2(-1,1), vec2(0, 1), vec2(0, 0), vec2(0, -1) } },

{ { vec2(0, 0), vec2(-1, -1), vec2(-1, 0), vec2(0, -1) },	//"O"
{ vec2(0, 0), vec2(-1, -1), vec2(-1, 0), vec2(0, -1) },
{ vec2(0, 0), vec2(-1, -1), vec2(-1, 0), vec2(0, -1) },
{ vec2(0, 0), vec2(-1, -1), vec2(-1, 0), vec2(0, -1) } },

{ { vec2(0, 0), vec2(1, 0), vec2(-1, 0), vec2(-2, 0) },	//"I"
{ vec2(0, 0), vec2(0, -2), vec2(0, -1), vec2(0, 1) },
{ vec2(0, 0), vec2(1, 0), vec2(-1, 0), vec2(-2, 0) },
{ vec2(0, 0), vec2(0, -2), vec2(0, -1), vec2(0, 1) } },

{ { vec2(0, 0), vec2(1, 0), vec2(-1, -1), vec2(0, -1) },	//"S"
{ vec2(0, 0), vec2(0, 1), vec2(1,0), vec2(1, -1) },
{ vec2(0, 0), vec2(1, 0), vec2(-1, -1), vec2(0, -1) },
{ vec2(0, 0), vec2(0, 1), vec2(1, 0), vec2(1, -1) } },

{ { vec2(0, 0), vec2(-1, 0), vec2(1, 0), vec2(1, -1) },	//"J"
{ vec2(0, 0), vec2(0, 1), vec2(0, -1), vec2(1, 1) },
{ vec2(0, 0), vec2(1,0), vec2(-1, 0), vec2(-1, 1) },
{ vec2(0, 0), vec2(0, 1), vec2(0, -1), vec2(-1, -1) } },

{ { vec2(0, 0), vec2(-1, 0), vec2(0, -1), vec2(1, -1) },	//"Z"
{ vec2(0, -1), vec2(0, 0), vec2(1, 0), vec2(1, 1) },
{ vec2(0, 0), vec2(-1, 0), vec2(0, -1), vec2(1, -1) },
{ vec2(0, -1), vec2(0, 0), vec2(1, 0), vec2(1, 1) } },

{ { vec2(0, 0), vec2(1, 0), vec2(-1, 0), vec2(0, -1) },	//"T"
{ vec2(0, 0), vec2(0, 1), vec2(0, -1), vec2(1, 0) },
{ vec2(0, 0), vec2(0, 1), vec2(-1, 0), vec2(1, 0) },
{ vec2(-1, 0), vec2(0, 1), vec2(0, -1), vec2(0, 0) } }

};



// 绘制窗口的颜色变量
vec4 tilecolor[7] = {
	vec4(1.0, 0.5, 0.0,0.5),	//orange
	vec4(1.0, 1.0, 0.0,0.5),	// Yellow
	vec4(0.0, 1.0, 0.0,0.5),	// Green
	vec4(0.0, 1.0, 1.0,0.5),	// Cyan
	vec4(1.0, 0.0, 1.0,0.5),	// Magenta
	vec4(1.0, 0.0, 0.0,0.5),	// Red
	vec4(0.5,1.0,0.0,0.5)		//light Green
};

vec4 grey = vec4(0.9, 0.9, 0.9, 0.8);
vec4 white = vec4(1.0, 1.0, 1.0, 1.0);
vec4 black = vec4(0.0, 0.0, 0.0, 1.0);

// 当前方块的位置（以棋盘格的左下角为原点的坐标系）
vec2 tilepos = vec2(5, 19);

// 布尔数组表示棋盘格的某位置是否被方块填充，即board[x][y] = true表示(x,y)处格子被填充。
// （以棋盘格的左下角为原点的坐标系）
bool board[10][20];


// 当棋盘格某些位置被方块填充之后，记录这些位置上被填充的颜色
vec4 boardcolours[1200];

GLuint locxsize;
GLuint locysize;

GLuint vaoIDs[3];
GLuint vboIDs[6];

//
// 修改棋盘格在pos位置的颜色为colour，并且更新对应的VBO

void changecellcolour(vec2 pos, vec4 colour)
{
	// 每个格子是个正方形，包含两个三角形，总共6个定点，并在特定的位置赋上适当的颜色
	for (int i = 0; i < 6; i++)
		boardcolours[(int)(6 * (10 * pos.y + pos.x) + i)] = colour;

	vec4 newcolours[6] = { colour, colour, colour, colour, colour, colour };

	glBindBuffer(GL_ARRAY_BUFFER, vboIDs[3]);

	// 计算偏移量，在适当的位置赋上颜色
	int offset = 6 * sizeof(vec4) * (int)(10 * pos.y + pos.x);
	glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(newcolours), newcolours);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
}

//
// 当前方块移动或者旋转时，更新VBO

void updatetile()
{
	glBindBuffer(GL_ARRAY_BUFFER, vboIDs[4]);

	// 每个方块包含四个格子
	for (int i = 0; i < 4; i++)
	{
		// 计算格子的坐标值
		GLfloat x = tilepos.x + tile[i].x;
		GLfloat y = tilepos.y + tile[i].y;

		vec4 p1 = vec4(33.0 + (x * 33.0), 33.0 + (y * 33.0), .4, 1);
		vec4 p2 = vec4(33.0 + (x * 33.0), 66.0 + (y * 33.0), .4, 1);
		vec4 p3 = vec4(66.0 + (x * 33.0), 33.0 + (y * 33.0), .4, 1);
		vec4 p4 = vec4(66.0 + (x * 33.0), 66.0 + (y * 33.0), .4, 1);

		// 每个格子包含两个三角形，所以有6个顶点坐标
		vec4 newpoints[6] = { p1, p2, p3, p2, p3, p4 };
		glBufferSubData(GL_ARRAY_BUFFER, i * 6 * sizeof(vec4), 6 * sizeof(vec4), newpoints);
	}
	glBindVertexArray(0);
}

//
// 设置当前方块为下一个即将出现的方块。在游戏开始的时候调用来创建一个初始的方块，
// 在游戏结束的时候判断，没有足够的空间来生成新的方块。

void newtile()
{
	// 将新方块放于棋盘格的最上行中间位置并设置默认的旋转方向
	tilepos = vec2(5, 19);

	srand(time(NULL));
	which = 0 + rand() % 7;//随机得到0-6的数字
	rotation = 0 + rand() % 4;//随机得到0-3的数字

	for (int i = 0; i < 4; i++)
	{
		tile[i] = allRotationsLshape[which][rotation][i];
	}

	updatetile();

	// 给新方块赋上颜色
	vec4 newcolours[24];
	for (int i = 0; i < 24; i++)
		newcolours[i] = tilecolor[which];

	glBindBuffer(GL_ARRAY_BUFFER, vboIDs[5]);
	glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(newcolours), newcolours);
	glBindBuffer(GL_ARRAY_BUFFER, 0);


	glBindVertexArray(0);
}

//
// 游戏和OpenGL初始化

void init()
{
	// 初始化棋盘格，包含64个顶点坐标（总共32条线），并且每个顶点一个颜色值
	vec4 gridpoints[64];
	vec4 gridcolours[64];

	// 纵向线
	for (int i = 0; i < 11; i++)
	{
		gridpoints[2 * i] = vec4((33.0 + (33.0 * i)), 33.0, 0, 1);
		gridpoints[2 * i + 1] = vec4((33.0 + (33.0 * i)), 693.0, 0, 1);

	}

	// 水平线
	for (int i = 0; i < 21; i++)
	{
		gridpoints[22 + 2 * i] = vec4(33.0, (33.0 + (33.0 * i)), 0, 1);
		gridpoints[22 + 2 * i + 1] = vec4(363.0, (33.0 + (33.0 * i)), 0, 1);
	}

	// 将所有线赋成白色
	for (int i = 0; i < 64; i++)
		gridcolours[i] = white;

	// 初始化棋盘格，并将没有被填充的格子设置成黑色
	vec4 boardpoints[1200];
	for (int i = 0; i < 1200; i++)
		boardcolours[i] = black;

	// 对每个格子，初始化6个顶点，表示两个三角形，绘制一个正方形格子
	for (int i = 0; i < 20; i++)
		for (int j = 0; j < 10; j++)
		{
			vec4 p1 = vec4(33.0 + (j * 33.0), 33.0 + (i * 33.0), .5, 1);
			vec4 p2 = vec4(33.0 + (j * 33.0), 66.0 + (i * 33.0), .5, 1);
			vec4 p3 = vec4(66.0 + (j * 33.0), 33.0 + (i * 33.0), .5, 1);
			vec4 p4 = vec4(66.0 + (j * 33.0), 66.0 + (i * 33.0), .5, 1);

			boardpoints[6 * (10 * i + j)] = p1;
			boardpoints[6 * (10 * i + j) + 1] = p2;
			boardpoints[6 * (10 * i + j) + 2] = p3;
			boardpoints[6 * (10 * i + j) + 3] = p2;
			boardpoints[6 * (10 * i + j) + 4] = p3;
			boardpoints[6 * (10 * i + j) + 5] = p4;
		}

	// 将棋盘格所有位置的填充与否都设置为false（没有被填充）
	for (int i = 0; i < 10; i++)
		for (int j = 0; j < 20; j++)
			board[i][j] = false;

	// 载入着色器
	GLuint program = InitShader("vshader.glsl", "fshader.glsl");
	glUseProgram(program);

	locxsize = glGetUniformLocation(program, "xsize");
	locysize = glGetUniformLocation(program, "ysize");

	GLuint vPosition = glGetAttribLocation(program, "vPosition");
	GLuint vColor = glGetAttribLocation(program, "vColor");

	glGenVertexArrays(3, &vaoIDs[0]);

	// 棋盘格顶点
	glBindVertexArray(vaoIDs[0]);
	glGenBuffers(2, vboIDs);

	// 棋盘格顶点位置
	glBindBuffer(GL_ARRAY_BUFFER, vboIDs[0]);
	glBufferData(GL_ARRAY_BUFFER, 64 * sizeof(vec4), gridpoints, GL_STATIC_DRAW);
	glVertexAttribPointer(vPosition, 4, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(vPosition);

	// 棋盘格顶点颜色
	glBindBuffer(GL_ARRAY_BUFFER, vboIDs[1]);
	glBufferData(GL_ARRAY_BUFFER, 64 * sizeof(vec4), gridcolours, GL_STATIC_DRAW);
	glVertexAttribPointer(vColor, 4, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(vColor);

	// 棋盘格每个格子	
	glBindVertexArray(vaoIDs[1]);
	glGenBuffers(2, &vboIDs[2]);

	// 棋盘格每个格子顶点位置
	glBindBuffer(GL_ARRAY_BUFFER, vboIDs[2]);
	glBufferData(GL_ARRAY_BUFFER, 1200 * sizeof(vec4), boardpoints, GL_STATIC_DRAW);
	glVertexAttribPointer(vPosition, 4, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(vPosition);

	// 棋盘格每个格子顶点颜色
	glBindBuffer(GL_ARRAY_BUFFER, vboIDs[3]);
	glBufferData(GL_ARRAY_BUFFER, 1200 * sizeof(vec4), boardcolours, GL_DYNAMIC_DRAW);
	glVertexAttribPointer(vColor, 4, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(vColor);

	// 当前方块
	glBindVertexArray(vaoIDs[2]);
	glGenBuffers(2, &vboIDs[4]);

	// 当前方块顶点位置
	glBindBuffer(GL_ARRAY_BUFFER, vboIDs[4]);
	glBufferData(GL_ARRAY_BUFFER, 24 * sizeof(vec4), NULL, GL_DYNAMIC_DRAW);
	glVertexAttribPointer(vPosition, 4, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(vPosition);

	// 当前方块顶点颜色
	glBindBuffer(GL_ARRAY_BUFFER, vboIDs[5]);
	glBufferData(GL_ARRAY_BUFFER, 24 * sizeof(vec4), NULL, GL_DYNAMIC_DRAW);
	glVertexAttribPointer(vColor, 4, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(vColor);

	glBindVertexArray(0);
	glClearColor(0, 0, 0, 0);

	// 游戏初始化

	newtile();
	starttime = glutGet(GLUT_ELAPSED_TIME);
}

//
// 检查在cellpos位置的格子是否被填充或者是否在棋盘格的边界范围内。

bool checkvalid(vec2 cellpos)
{
	//先判断是否出界
	if (cellpos.x < 0 || cellpos.x >= 10 || cellpos.y < 0 || cellpos.y >= 20) return false;
	//判断是否有格子已经填满
	if (board[(int)cellpos.x][(int)cellpos.y]) return false;
	return true;
}

//
// 在棋盘上有足够空间的情况下旋转当前方块

void rotate()
{
	// 计算得到下一个旋转方向
	int nextrotation = (rotation + 1) % 4;

	// 检查当前旋转之后的位置的有效性
	if (checkvalid((allRotationsLshape[which][nextrotation][0]) + tilepos)
		&& checkvalid((allRotationsLshape[which][nextrotation][1]) + tilepos)
		&& checkvalid((allRotationsLshape[which][nextrotation][2]) + tilepos)
		&& checkvalid((allRotationsLshape[which][nextrotation][3]) + tilepos))
	{
		// 更新旋转，将当前方块设置为旋转之后的方块
		rotation = nextrotation;
		for (int i = 0; i < 4; i++)
			tile[i] = allRotationsLshape[which][rotation][i];

		updatetile();
	}
}

//
// 检查棋盘格在row行有没有被填充满

bool checkfullrow(int row)
{
	bool flag = true;
	for (int i = 0; i < 10; i++) {
		if (!board[i][row]) flag = false;
	}
	// 没满就跳出
	if (!flag) return false;
	// 消格子，将上方的格子向下移动
	for (int i = 0; i < 10; i++) {
		for (int j = row + 1; j < 20; j++) {
			board[i][j - 1] = board[i][j];
			changecellcolour(vec2(i, j - 1), boardcolours[6 * (10 * j + i)]);
		}
	}
	score += 1;
	cout << "你的得分为: " << score << endl;
	return true;
}

//
// 放置当前方块，并且更新棋盘格对应位置顶点的颜色VBO

void settile()
{
	// 每个格子
	for (int i = 0; i < 4; i++)
	{
		// 获取格子在棋盘格上的坐标
		int x = (tile[i] + tilepos).x;
		int y = (tile[i] + tilepos).y;

		//判断是否游戏结束
		if (!checkvalid(vec2(x, y))) {
			gameover = true;
			cout << "GAME OVER!你的得分为：" << score << endl;
			for (int i = 0; i < 10; i++) {
				for (int j = 0; j < 20; j++) {
					if (board[i][j]) {
						changecellcolour(vec2(i, j), grey);
					}
				}
			}
			return;
		}

		// 将格子对应在棋盘格上的位置设置为填充
		board[x][y] = true;
		// 并将相应位置的颜色修改
		changecellcolour(vec2(x, y), tilecolor[which]);
	}
	//判断是否需要消格子
	int n = 0;
	for (int i = 0; i < 20 && n < 4; i++) {
		if (checkfullrow(i)) {
			n++;
			i--;
		}
	}
}


//
// 给定位置(x,y)，移动方块。有效的移动值为(-1,0)，(1,0)，(0,-1)，分别对应于向
// 左，向下和向右移动。如果移动成功，返回值为true，反之为false。

bool movetile(vec2 direction)
{
	// 计算移动之后的方块的位置坐标
	vec2 newtilepos[4];
	for (int i = 0; i < 4; i++)
		newtilepos[i] = tile[i] + tilepos + direction;

	// 检查移动之后的有效性
	if (checkvalid(newtilepos[0])
		&& checkvalid(newtilepos[1])
		&& checkvalid(newtilepos[2])
		&& checkvalid(newtilepos[3]))
	{
		// 有效：移动该方块
		tilepos.x = tilepos.x + direction.x;
		tilepos.y = tilepos.y + direction.y;

		updatetile();

		return true;
	}

	return false;
}

//
// 重新启动游戏

void restart()
{
	//全部归为空
	gameover = false;
	score = 0;
	for (int i = 0; i < 10; i++) {
		for (int j = 0; j < 20; j++) {
			board[i][j] = false;
			changecellcolour(vec2(i, j), black);
		}
	}
	newtile();
}

//
// 游戏渲染部分

void display()
{
	glClear(GL_COLOR_BUFFER_BIT);

	glUniform1i(locxsize, xsize);
	glUniform1i(locysize, ysize);

	glBindVertexArray(vaoIDs[1]);
	glDrawArrays(GL_TRIANGLES, 0, 1200); // 绘制棋盘格 (10*20*2 = 400 个三角形)

	glBindVertexArray(vaoIDs[2]);
	glDrawArrays(GL_TRIANGLES, 0, 24);	 // 绘制当前方块 (8 个三角形)

	glBindVertexArray(vaoIDs[0]);
	glDrawArrays(GL_LINES, 0, 64);		 // 绘制棋盘格的线


	glutSwapBuffers();
}

//
// 在窗口被拉伸的时候，控制棋盘格的大小，使之保持固定的比例。

void reshape(GLsizei w, GLsizei h)
{
	xsize = w;
	ysize = h;
	glViewport(0, 0, w, h);
}

//
// 键盘响应事件中的特殊按键响应

void special(int key, int x, int y)
{
	if (!gameover)
	{
		switch (key)
		{
		case GLUT_KEY_UP:	// 向上按键旋转方块
			rotate();
			break;
		case GLUT_KEY_DOWN: // 向下按键移动方块
			if (!movetile(vec2(0, -1)))
			{
				settile();

				newtile();
			}
			break;
		case GLUT_KEY_LEFT:  // 向左按键移动方块
			movetile(vec2(-1, 0));
			break;
		case GLUT_KEY_RIGHT: // 向右按键移动方块
			movetile(vec2(1, 0));
			break;
		}
	}
}

//
// 键盘响应时间中的普通按键响应

void keyboard(unsigned char key, int x, int y)
{
	switch (key)
	{
	case 033: // ESC键 和 'q' 键退出游戏
		exit(EXIT_SUCCESS);
		break;
	case 'q':
		exit(EXIT_SUCCESS);
		break;
	case 'r': // 'r' 键重启游戏
		restart();
		break;
	}
	glutPostRedisplay();
}

//


void idle(void)
{
	//自动下降
	static int time = 0;
	if (time++ == gamespeed) {
		special(GLUT_KEY_DOWN, 0, 0);
		time = 0;
	}
	glutPostRedisplay();
}

//

int main(int argc, char **argv)
{
	glutInit(&argc, argv);
	glutInitContextVersion(3, 3);
	glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
	glutInitWindowSize(xsize, ysize);
	glutInitWindowPosition(680, 178);
	glutCreateWindow("xxx");
	glewExperimental = GL_TRUE;
	glewInit();
	init();

	glutDisplayFunc(display);
	glutReshapeFunc(reshape);
	glutSpecialFunc(special);
	glutKeyboardFunc(keyboard);
	glutIdleFunc(idle);

	glutMainLoop();
	return 0;
}

 

武倔
关注
  • 4
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
200行C++代码实现实现3D俄罗斯方块，这效果太逼真了！
python学习+VX：YYQX2209
11-24 999
最近学习openGL,在网上看了很多的资料OpenGL入门学习等很多资料,但是也只是学了点皮毛,边学边实践,于是就写了一个3D俄罗斯方块的程序。 VC++基于OpenGL技术实现的3D俄罗斯方块游戏，游戏玩法与以往的俄罗斯方块区别不大，这里主要是3D图形的设计部分.游戏界面展示： 项目结构展示： 部分源码展示： 编辑时请OpenGL中的相应类库已打包，程序仅供学习参考。这个...
俄罗斯方块-C语言-完整代码
彩云国物语
01-24 8769
效果图如下 #ifndef _DAY7_H #define _DAY7_H #include<windows.h> #include<time.h> #include<stdbool.h> #include<conio.h>//控制台输入输出函数getch通过键盘进行的操作 //游戏区域位置设计 #define COL_BEGIN 2 #define COL_END 14 #define ROW_BEGIN 4 #define ROW_END 26
用c++语言实现俄罗斯方块
weixin_42611177的博客
02-16 925
俄罗斯方块是一款经典的游戏，使用C语言实现可以考虑以下步骤： 创建游戏框架：可以使用C语言中的窗口库(如SDL或OpenGL)创建一个游戏窗口，以便显示游戏界面。 设计方块：定义俄罗斯方块的形状和颜色，可以使用二维数组表示方块的形状，每一种颜色用一个整数值表示。 控制方块移动：使用键盘输入函数来控制方块的移动、旋转等操作，并对方块进行边界检测，以避免超出游戏界面。 碰撞检测：当方块落到底部...
OpenGl 俄罗斯方块游戏
最新发布
xiaohema12138的博客
07-17 635
OpenGl项目 俄罗斯方块游戏
webgl实现3D俄罗斯方块
AhCola
06-25 741
webgl实现3D俄罗斯方块 文章同时发布于王鹏飞的个人网站。 试玩地址：3d tetris。 源码: https://github.com/pengfeiw/3d-tetris 学习webgl/opengl已经有一段时间了，打算做个小程序练一练，所以就有了这个俄罗斯方块。采用的技术是webgl + typescript + canvas，至于界面使用的是react + material-ui框架。下面我将介绍一些实现的技术点。 一.介绍 界面左侧是可以打开或者关闭的设置面板。可以通过distance和r
C语言实现——俄罗斯方块小游戏
qq_42562989的博客
04-20 481
俄罗斯方块是一种流行的游戏，其基本玩法是通过随机生成的不同形状的方块，将它们放置在游戏区域中，并尽可能地填满一行或多行。当游戏区域的一行或多行被填满时，这些行将被消除，并且上面的方块将向下移动。如果在游戏过程中方块堆到了游戏区域的顶部，则游戏结束。
matlab俄罗斯方块下降,用MATLAB玩俄罗斯方块
weixin_28950403的博客
03-18 455
偶然发现有人编写了用matlab玩俄罗斯方块的程序，测试了一下，果然可以用。但是我们的目的不是玩，而是学习这个编程的过程。其中各种方块的形状和颜色是用patch这个命令来完成的。方块用方向键控制，上方向键可以调整方块的形状。function [STRUCT] = matlabtetris(varargin)%MATLABTETRIS A MATLAB version of the classic ...
C语言写俄罗斯方块，可上机运行
m0_55685698的博客
03-09 6258
C语言编写，可上机运行的俄罗斯方块，内附有注释！！！
游戏俄罗斯方块（c语言）
唯一的博客
09-28 1394
游戏俄罗斯方块（c语言） 一、背景 ​ 俄罗斯方块（Terris， 俄文：Тетрис）是一款电视游戏机和掌上游戏机游戏。俄罗斯方块的基本规则是移动、旋转和摆放游戏自动输出的各种方块，使之排列成完整的一行或多行并且消除得分。 二、设计目的 如何用OpenGL编写画图程序 如何用数组储存信息 如何实现菜单的显示、选择和响应等功能 如何实现图形的移动，变换等功能 三、项目功能需求 1、游戏方块控制 通过各种条件的判断，实现对游戏方块的左移、右移、快速下落、自由下落、旋转功能，以及行满消除的功
基于OpenGL实现俄罗斯方块
05-23
在Linux环境下，基于OpenGL实现俄罗斯方块游戏功能。
OpenGL实现俄罗斯方块源代码.pdf
03-16
"OpenGL实现俄罗斯方块源代码" 本文档主要介绍了使用OpenGL实现俄罗斯方块游戏的源代码，涵盖了游戏的设计思路、详细设计说明、源代码实现等方面。 一、设计思路 俄罗斯方块游戏的设计思路是基于C++语言和OpenGL...
C++与OpenGL实现俄罗斯方块简要设计说明及源代码.docx
03-10
C++与OpenGL实现俄罗斯方块简要设计说明及源代码 本文档主要介绍如何使用C++语言和OpenGL库函数实现俄罗斯方块游戏的设计思路和源代码。该游戏实现了七种形状的俄罗斯方块的变换操作，包括正方形、T形、L形、反L形...
C++与OpenGL实现俄罗斯方块简要设计说明、源代码及可执行文件
01-05
openGL 俄罗斯方块 c++ . C++配合OpenGL写的俄罗斯方块，包含源代码及可执行文件，欢迎下载及提出改进意见.
DES与3DES 加解密实例（c++）
热门推荐
blowfire123的博客
11-18 1万+
DES与3DES 加解密实例（c++）DES原理：DES算法是一种对称密码算法，也是一种分组加密的算法，以64位分组对数 据加密的，其密钥长度为64位，密钥事实上是56位参与DES运算（第8、16、24、 32、40、48、56、64位是校验位，使得每个密钥都有奇数个1），分组后的明文组和 56位的密钥按位替代或交换的方法形成密文组。 DES算法的主要流程如下图所示 。 1、 IP置
算法分析：求最近点对问题（c++）
blowfire123的博客
11-18 1万+
算法分析：求最近点对问题（c++）1、 准备部分： 对于最近点问题，需要将问题代码化，所以要先创建一个点类，来使得计算使用时候更加方面，class Points //点类 { public: float x; float y; };因为会多次计算距离，需要一个计算两点之间距离的函数。float Distance(Points p1,Points p2)//求
N皇后问题可视化实现（java）
blowfire123的博客
11-18 1万+
package queens; import java.awt.Color; import java.awt.GridLayout; import java.awt.Image; import java.io.IOException; import java.util.Scanner; import javax.swing.ImageIcon; import javax.swing.JFrame
二分查找 (二分搜索) 最通俗易懂的图解与实现
blowfire123的博客
11-14 8799
二分查找场景 二分搜索用于在一个单调或者局部单调有序数组中查找一个符合某些条件的值，时间复杂度为O(logN) 二分查找原理图解 拿升序数组为例子进行解释，假设我们需要再数组中找到目标值key的下标。 1、首先可以将数组按key所在下标划分为三个部分，左边是小于key的部分，然后中间是key值，右边为大于key的部分。 用left和right两个指针不断地缩小搜索区域。 2、取mid为left和right的中间值，如果mid在key的下标的左边（即nums[mid] <..
C++与OpenGL实现俄罗斯方块：程序设计与源码解析
“C++与OpenGL实现俄罗斯方块”的程序设计及源代码 本文将详细介绍如何使用C++编程语言和OpenGL图形库来实现经典的俄罗斯方块游戏。程序的设计思路是基于C++的基础，利用OpenGL库来绘制游戏界面和处理图形变换。...
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值