计算机图形学 期中大作业 俄罗斯方块

已于 2022-08-18 12:02:29 修改
阅读量8.1k 收藏 159
点赞数 24
分类专栏： 计算机图形学 文章标签： 算法 3d html
于 2021-02-25 11:22:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43757333/article/details/114064639
版权

期中大作业 俄罗斯方块

一、 作业内容

设计一个简化版的俄罗斯方块游戏 。游戏窗口大小是20×10的方形棋盘格阵列（下图左），游戏中出现的方块共有7种（下图右），每种方块的旋转中心由黑点标出 。留空代码“tetris.cpp”文件中针对L形状记录方块布局的数组vec2 allRotationsLshape[4][4]的设定请参看（下图右）中的第五行图示（老师上课的时候也会简单说明一下）。
在这里插入图片描述
具体实现内容和步骤包括：

  1. 方块/棋盘格的渲染和方块向下移动
    创建OpenGL绘制窗口，然后绘制网格线来完成对棋盘格的渲染。随机选择方块并赋上颜色，从窗口最上方中间开始往下自动移动，每次移动一个格子。初始的方块类型和方向也必须随机选择，另外可以通过键盘控制方块向下移动的速度，在方块移动到窗口底部的时候，新的方块出现并重复上述移动过程。
  2. 方块叠加
    不断下落的方块需要能够相互叠加在一起，即不同的方块之间不能相互碰撞和叠加。另外，所有方块移动不能超出窗口的边界。
  3. 键盘控制方块的移动
    通过方向键（上/下/左/右）来控制方块的移动。按“上”键使方块以旋转中心顺（逆）时针旋转，每次旋转90°，按“左”和“右”键分别将方块向左/右方向移动一格，按“下”键加速方块移动。
  4. 游戏逻辑
    当游戏窗口中的任意一行被方块占满，该行即被消除，所有上面的方块向下移动一格子。当整个窗口被占满而不能再出现新的方块时，游戏结束。通过按下“q”键结束游戏，和按下“r”键重新开始游戏。

代码解析

为了实现方块形状和颜色的随机生成，方块的自动下落，以及额外添加的积分和暂停功能所增加的变量：
在这里插入图片描述
根据教程图写出来的方块的形状以及旋转后的位置（）
在这里插入图片描述
根据教程图写出来的方块的形状以及旋转后的位置（）
在这里插入图片描述
在这里插入图片描述
新增加的颜色：

在这里插入图片描述
我们需要新增一个全局变量二维数组记录每个格子的颜色：
在这里插入图片描述
当改变颜色的时候，同时修改这个格子的颜色

在这里插入图片描述
生成方块时需要做的事：
在这里插入图片描述
初始化游戏界面时，在另一个窗口增添游戏指引：
在这里插入图片描述
初始化时，增添了一步：将所有方块的颜色初始化为黑色
在这里插入图片描述
方块的碰撞检测：
在这里插入图片描述
判断某行是否被填满，如果被填满需要进行一系列的操作：
在这里插入图片描述
当物体运行到窗口底部或者是碰到物体则需要执行以下函数：
在这里插入图片描述
重新启动游戏
在这里插入图片描述
注意键盘响应时，如果处于暂停状态则不触发功能
在这里插入图片描述
在键盘响应部分添加P键的操作：暂停功能
在这里插入图片描述
在这里插入图片描述
在idle函数内增加物块下落的操作
在这里插入图片描述

实验效果

(具体实际效果可以看视频
随机生成方块的形状及颜色，每隔一段时间，都会自然往下掉落，当有一行被填满时，则会自动消除，上面一行的方块将会往下掉一行
在这里插入图片描述

在这里插入图片描述
暂停或者恢复时也会有提示，暂停时按下暂停键则会恢复
在这里插入图片描述
重启游戏后，界面也会全部清空，下落速度恢复到初始状态

完整代码

/*
 * - 本代码仅仅是参考代码，具体要求请参考作业说明，按照顺序逐步完成。
 * - 关于配置OpenGL开发环境、编译运行，请参考第一周实验课程相关文档。
 *
 * - 已实现功能如下：
 * - 1) 绘制棋盘格和‘L’型方块
 * - 2) 键盘左/右/下键控制方块的移动，上键旋转方块
 *
 * - 未实现功能如下：
 * - 1) 随机生成方块并赋上不同的颜色
 * - 2) 方块的自动向下移动
 * - 3) 方块之间的碰撞检测
 * - 4) 棋盘格中每一行填充满之后自动消除
 * - 5) 其他
 *

 * 致谢：参考代码来自于西蒙弗雷泽大学CMPT361-Assignment
 */

#include "include/Angel.h"

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

#include <cstdlib>
#include <iostream>

using namespace std;

int starttime;			// 控制方块向下移动时间
int rotation = 0;		// 控制当前窗口中的方块旋转
vec2 tile[4];			// 表示当前窗口中的方块
bool gameover = false;	// 游戏结束控制变量
int xsize = 400;		// 窗口大小（尽量不要变动窗口大小！）
int ysize = 720;
int ColorNum;//颜色数量
int ShapeNum;//形状的数量
int DownTime = 1000;//下落的时间间隔
int nowTime;
int DownNum = 1;//下落了多少个方块
int Point = 0;//积分数量 每消除一行积分加10
bool pause = false;//用来表示游戏是否暂停的变量
int Rank = 1;//游戏难度

// 一个二维数组表示所有可能出现的方块和方向。
//这个数组的设置比较难理解，是根据word文档里面的（下图右）里面的图示而来，老师上课会解释一下，请注意听
vec2 allRotationsLshape[7][4][4] =
{
	//以下按照实验指导的图形顺序
	//1：O型方块
{	{vec2(0, 0), vec2(-1,0), vec2(0, -1), vec2(-1,-1)},	
   {vec2(0, 0), vec2(-1,0), vec2(0, -1), vec2(-1,-1)},   
   {vec2(0, 0), vec2(-1,0), vec2(0, -1), vec2(-1,-1)},    
   {vec2(0, 0), vec2(-1,0), vec2(0, -1), vec2(-1,-1)}  },

   //2:I型方块
{	{vec2(-2, 0), vec2(-1,0), vec2(1, 0), vec2(0,0)},	
	{vec2(0, 1), vec2(0, 0), vec2(0,-1), vec2(0, -2)},   
	{vec2(-2, 0), vec2(-1,0), vec2(1, 0), vec2(0,0)},     
	{vec2(0, 1), vec2(0, 0), vec2(0,-1), vec2(0, -2)}  },

   //3:S型方块
{	{vec2(0, 0), vec2(0,-1), vec2(-1, -1), vec2(1,0)},	
	{vec2(0, 1), vec2(0, 0), vec2(1,0), vec2(1, -1)},    
	{vec2(0, 0), vec2(0,-1), vec2(-1, -1), vec2(1,0)},    
	{vec2(0, 1), vec2(0, 0), vec2(1,0), vec2(1, -1)}  },

   //4:Z型方块
{	{vec2(-1, 0), vec2(0,0), vec2(0, -1), vec2(1,-1)},	
	{vec2(0, 0), vec2(0, -1), vec2(1,0), vec2(1, 1)},    
	{vec2(-1, 0), vec2(0,0), vec2(0, -1), vec2(1,-1)},  
	{vec2(0, 0), vec2(0, -1), vec2(1,0), vec2(1, 1)}  },

   //5:L型方块
{	{vec2(0, 0), vec2(-1,0), vec2(1, 0), vec2(-1,-1)},	
	{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)}  },

   //6:J型方块
{	{vec2(-1, 0), vec2(0,0), vec2(1, 0), vec2(1,-1)},	
	{vec2(0, 1), vec2(0, 0), vec2(0,-1), vec2(1, 1)},  
	{vec2(-1, 0), vec2(0,0), vec2(1, 0), vec2(-1,  1)},     
	{vec2(-1,-1), vec2(0, -1), vec2(0, 0), vec2(0, 1)} },

   //7:T型方块
{	{vec2(-1, 0), vec2(0,0), vec2(1, 0), vec2(0,-1)},	
	{vec2(0, -1), vec2(0, 0), vec2(0,1), vec2(1, 0)},    
	{vec2(-1, 0), vec2(0,0), vec2(1, 0), vec2(0,  1)},      
	{vec2(-1,0), vec2(0, -1), vec2(0, 0), vec2(0, 1)}  },

};

// 绘制窗口的颜色变量

vec4 white  = vec4(1.0, 1.0, 1.0, 1.0);
vec4 black  = vec4(0.0, 0.0, 0.0, 1.0); 
vec4 red = vec4(1.0, 0.0, 0.0, 1.0);
vec4 green = vec4(0.0, 1.0, 0.0, 1.0);
vec4 blue = vec4(0.0, 0.0, 1.0, 1.0);
vec4 orange = vec4(1.0, 0.5, 0.0, 1.0);
vec4 pink = vec4(1.0, 0.75, 0.8, 1.0);
vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);
vec4 purple = vec4(0.8, 0.0, 0.8, 1.0);
vec4 bluegreen = vec4(0.0, 1.0, 1.0, 1.0);
vec4 CubeColor[] = { red,green,blue,orange,pink,yellow,purple,bluegreen };
// 当前方块的位置（以棋盘格的左下角为原点的坐标系）
vec2 tilepos = vec2(5, 19);

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

//用来记录每个格子的颜色
vec4 BoardColor[10][20];

// 当棋盘格某些位置被方块填充之后，记录这些位置上被填充的颜色
vec4 boardcolours[1200];  //棋盘格 10*20*2 = 400 个三角形，每个三角形3个点，3*400=1200个点的颜色值需要记录

GLuint locxsize;
GLuint locysize;

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


//
// 修改棋盘格在pos位置的颜色为colour，并且更新对应的VBO
void changecellcolour(vec2 pos, vec4 colour)
{
	BoardColor[int(pos.x)][int(pos.y)] = 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()
{
	//判断最上面两行的中间是否被填满，如果被填满说明无法再生成方块，游戏结束
	int flag = 0;
	for (int i = 18; i < 20; i++) {
		for (int j = 4; j < 7; j++) {
			if (board[j][i] == true)flag = 1;
		}
	}
	if (flag == 1) {
		cout << "游戏结束，请按下R键重新开始游戏，或者按下Q或Esc键退出游戏。"<<endl;
		gameover = true;
		return;
	}
	// 将新方块放于棋盘格的最上行中间位置并设置默认的旋转方向
	tilepos = vec2(5 , 19);
	rotation = 0;
	ShapeNum = (starttime+rand()) % 7;
	for (int i = 0; i < 4; i++)
	{
		tile[i] = allRotationsLshape[ShapeNum][0][i];
	}

	updatetile();

	// 给新方块赋上颜色
	vec4 newcolours[24];
	ColorNum = (starttime+rand()) % 8;
	for (int i = 0; i < 24; i++)
		newcolours[i] = CubeColor[ColorNum];

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


	glBindVertexArray(0);
}

//
// 游戏和OpenGL初始化
void init()
{
	std::cout << "欢迎来到俄罗斯方块游戏，接下来我来给您介绍游戏规则：" << endl;
	std::cout << "由小方块组成的不同形状的板块陆续从屏幕上方落下来，它们会自动下落，玩家通过调整板块的位置和方向，使它们在屏幕底部拼出完整的一条或几条。这些完整的横条会随即消失，给新落下来的板块腾出空间，与此同时，玩家得到分数奖励。没有被消除掉的方块不断堆积起来，一旦堆到屏幕顶端，玩家便告输，游戏结束。" << endl;
	std::cout << "按键操作：↑键旋转，↓键往下落，←键往左移，→键往右移，P键暂停或恢复游戏，R键重启游戏，Q或ESC键退出游戏。" << endl;
	std::cout << "接下来请操控小方块来获取更多的分数吧！" << endl;
	std::cout << "当前难度：" << Rank << endl;
	std::cout << "积分：" << Point << endl;
	// 初始化棋盘格，包含64个顶点坐标（总共32条线），并且每个顶点一个颜色值
	vec4 gridpoints[64];
	vec4 gridcolours[64];

	// 纵向线（10个格子所以11条线）
	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;
			BoardColor[i][j] = black;
			//将所有方块的颜色初始化为黑色
		}



	// 载入着色器
	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)&& (board[(int)cellpos.x][(int)cellpos.y]==false))//判断该位置是否已被填充
		return true;
	else
		return false;
}

//
// 判断在棋盘上有足够空间的情况下旋转当前方块
void rotate()
{      
	// 计算得到下一个旋转方向
	int nextrotation = (rotation + 1) % 4;

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

		updatetile();
	}
}

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

//传入某一行，判断这一行是否被填满，如果被填满需要：消除这行，上一行往下掉，增加积分
void checkfullrow(int row)
{
	int flag = 1;
	int i = row;
	for (int j = 0; j < 10; j++) {
		if (board[j][i] == false) {
			flag = 0;//这一行有格子没被填满则说明不能消行
		}
	}
	if (flag == 1) {
		Point += 10;
		std::cout << "积分：" << Point << endl;
		//积分数量每增加50，则难度自动增加，使得方块下落时间变长
		if (Point >= Rank * 20) {
			Rank++;
			DownTime /= 2;//调整下落时间间隔
			DownNum*= 2;//这里让DoneNum*=2是和判断是否下落的方式有关，
			//为了让下落时间间隔和下落数量的乘积与之前相同
			cout << "当前难度：" << Rank<<endl;
		}
		for (int j = 0; j < 10; j++) {
			changecellcolour(vec2(j, i), black);//颜色全部变黑
			board[j][i] = false;//这一行全部变成未填满状态
		}
		for (int k = row + 1; k < 20; k++) {
			for (int j = 0; j < 10; j++) {
				if (board[j][k] == true) {//如果上一行有方块，则需要往下掉一行
					board[j][k] = false;//将上一行置为未填满状态
					changecellcolour(vec2(j, k - 1), BoardColor[j][k]);
					//下一行对应位置的颜色变成上一行对应位置的颜色
					changecellcolour(vec2(j, k), black);//上一行清空为黑色
					board[j][k-1] = true;//下一行对应位置设置为填满状态
				}
			}

		}
	}


}

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

void settile()
{
	// 每个格子
	for (int i = 0; i < 4; i++)
	{
		// 获取格子在棋盘格上的坐标
		int x = (tile[i] + tilepos).x;
		int y = (tile[i] + tilepos).y;
		// 将格子对应在棋盘格上的位置设置为填充
		board[x][y] = true;
		// 并将相应位置的颜色修改
		changecellcolour(vec2(x,y), CubeColor[ColorNum]);
	}
	for (int i = 0; i < 4; i++) {
		int y = (tile[i] + tilepos).y;
		checkfullrow(y);
		//这个物体的四个方块所处的y轴都需要判断是否被填满
	}

}

//
// 给定位置(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()
{
	//先将所有格子清空
	for (int i = 0; i < 10; i++) {
		for (int j = 0; j < 20; j++) {
			board[i][j] = false;
			BoardColor[i][j] = black;
			changecellcolour(vec2(i, j), black);
		}	
	}
	starttime= glutGet(GLUT_ELAPSED_TIME);
	std::cout << "您已重启游戏，游戏还原成初始模样，积分已清零。"<<endl;
	Point = 0;
	std::cout << "积分：" << Point << endl;
	Rank = 1;
	DownTime = 1000;//难度和下落时间重新设立
	DownNum = 0;
	pause = false;//设置游戏为运行状态
	gameover = false;//结束游戏的标志置为false
	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&&pause==false)
	{
		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 'p'://  'p' 键暂停游戏
			if (pause == false) {
				pause = true;
				std::cout << "您已暂停游戏" << endl;
			}
			else if (pause == true) {
				pause = false;
				std::cout << "您已恢复游戏" << endl;
			}
			break;
		case 033: // ESC键 和 'q' 键退出游戏
			std::cout << "您已退出游戏，欢迎下次再来玩。" << endl;
			exit(EXIT_SUCCESS);
			break;
		case 'q':
			std::cout << "您已退出游戏，欢迎下次再来玩。" << endl;
			exit (EXIT_SUCCESS);
			break;
		case 'r': // 'r' 键重启游戏
			restart();
			break;

	}
	glutPostRedisplay();
}

//

void idle(void)
{
	//idle函数会不断地执行，时间也会不断地增加，
	//因此在这里加入物块下落的操作
	nowTime = glutGet(GLUT_ELAPSED_TIME);

	//由于时间不断的增加，我们用时间是否大于下落数量乘以
	//下落间隔来判断是否要进行下落操作
	if (nowTime-starttime> DownNum * DownTime) {
		DownNum++;
		if (gameover == false&&pause==false) {
			if (!movetile(vec2(0, -1)))
			{
				settile();
				newtile();
			}
		}
	}
	glutPostRedisplay();
}

//

int main(int argc, char **argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
	glutInitWindowSize(xsize, ysize);
	glutInitWindowPosition(680, 178);
	glutCreateWindow("Mid-Term-Skeleton-Code");
	glewInit();
	init();
	glutDisplayFunc(display);
	glutReshapeFunc(reshape);
	glutSpecialFunc(special);
	glutKeyboardFunc(keyboard);
	glutIdleFunc(idle);

	glutMainLoop();
	return 0;
}
TIT 计算机图形学 期中课设-坛子的线框模型
张时贰的博客
01-02 623
文章目录TIT 计算机图形学 期中课设-坛子的线框模型前言一、课设要求二、项目描述三、项目设计四、主要代码五、运行截图六、项目总结 TIT 计算机图形学 期中课设-坛子的线框模型 前言 参考视频计算机图形学全套算法讲解和C++编码实现（共23讲配套源码)，计算机图形学案例视频讲解以及主页相关算法。孔老师是我的代课老师，孔教授有十多年教学经验，视频课很不错，所有的源程序都基于他写的函数，并非小张写的。所有源程序都基于C+编译 参考教材《计算机图形学-理论与实践项目化教程》 孔令德著，大家多多支持哇 《计算机
计算机图形学大作业
06-01
计算机图形学的opengl大作业，源码，有部分注释
【深圳大学计算机图形学】期中大作业 俄罗斯方块
归忆_AC的博客
02-05 2819
仔细分析movetile函数后发现，它是到底部才会返回false，所以这个if就成了相判断其是否到了底部，只有到了底部才会更新时间，而不是我所设想的下移一格更新一次时间。既然如此，将更新时间的语句移到if语句外即可。17.接下来完善checkfullrow函数，检查棋盘格在row行有没有被填充满，如果没有填满row行则返回函数，否则消去那一行，并将其上的格子下移一格。19.其实到这里游戏的基础功能就已经基本做好了，加下来需要考虑的是优化人机交互界面即UI设计，以及游戏难易度调整，记分以及按键功能提示等等。
Python俄罗斯方块游戏开发实战合集
最新发布
weixin_42453228的博客
11-25 591
本文还有配套的精品资源，点击获取 简介：本合集包含18种不同的俄罗斯方块游戏实现，使用Python编程语言结合图形库如pygame进行开发。它涉及游戏开发的核心概念，如游戏循环、对象与类设计、碰撞检测、动画与定时器、用户输入处理、得分系统、文件I/O以及性能优化，旨在帮助学习者深入理解Python在游戏开发中的应用。 1. Python游戏开发概述 游戏开发是一...
俄罗斯方块计算机图形学C++
12-16
设计一个简化版的俄罗斯方块游戏 。游戏窗口大小是20×10的方形棋盘格阵列（下图左），游戏中出现的方块共有7种（下图右），每种方块的旋转中心由黑点标出 。 1. 绘制棋盘格和‘L’型方块。 2. 键盘左/右/下键控制方块的移动，上键旋转方块。 （1和2参考代码中已实现，不赘述） 这里详细说明“上键旋转方块”的实现 实现思路：为了方便对不同型的方块进行周期变化，将不足4种状态的方块按照变化周期重复补足4种，这样所有方块的变化周期都统一成4。共28种状态，用三维数组储存allRotationsLshape[7][4][4]，前两个下标分别表示方块的种类和方向。 每次按上键rotation加1，变换到下一状态。通过rotation对4取余实现同一类型方块的周期变化。
Computer-Graphics:计算机图形学和3D模型渲染-3D俄罗斯方块
05-01
计算机图形学 计算机图形和3D模型渲染 3-D Tetris项目于2015年秋季投入使用。初始代码框架由美国空军学院的布朗博士提供。 所有3D模型，html和游戏逻辑都是从头开始开发的。 希望你喜欢！
牛客网 俄罗斯方块
weixin_30547797的博客
08-11 148
链接：https://www.nowcoder.com/questionTerminal/9407e24a70b04fedba4ab3bd3ae29704?source=relative来源：牛客网 小易有一个古老的游戏机，上面有着经典的游戏俄罗斯方块。因为它比较古老，所以规则和一般的俄罗斯方块不同。 荧幕上一共有 n 列，每次都会有一个 1 x 1 的方块随机落下，在同一列中，后落下...
俄罗斯方块
02-25
俄罗斯方块小游戏，根据网上教程逐一编写，特此上传赚取积分，感谢CSDN
俄罗斯方块--大作业.zip
03-13
用winapi和c++开发的俄罗斯方块，只做了很简单的界面，但是功能是完整的，也很流程。是学校做的大作业
计算机图形学实验作业.zip
10-04
【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目...
计算机图形学画图及代码实现——山农
05-30
从提供的信息来看，这份资源可能是一个学生在学习过程中完成的期中和期末作业，包含了绘制各种图形的算法说明以及相应的代码实现。 首先，让我们讨论一下计算机图形学的基本概念。它主要包括两个主要领域：几何建模...
OpenGL 俄罗斯方块(Tetris)
06-19
Tetris opengl 俄罗斯方块 Tetris opengl 俄罗斯方块 Tetris opengl 俄罗斯方块 Tetris opengl 俄罗斯方块
OpenGL版俄罗斯方块
03-22
用OpenGL编写的俄罗斯方块，运行良好，界面也很不错。
OpenGL 俄罗斯方块
01-03
用Dev-C++和OpenGL 开发的2D小游戏 俄罗斯方块 运行环行： window98/ME/XP
基于OpenGL的俄罗斯方块
05-29
这个俄罗斯方块是我在别人基础上改写的，看作者的代码比较都，而且比较繁杂，不利于新手学习，所以在此将其简化，贴图的图片资源没有重做，沿用了作者的图片，故此说明。对新手学习OpenGL很有帮助。
UML期中大作业的所有图-类图/用例图/活动图/状态图/顺序图（协作图）
01-21
根据提供的文件信息，我们可以推断出这是一份关于UML（Unified Modeling Language，统一建模语言）期中作业的相关描述。这份作业包含了多种类型的UML图：类图、用例图、活动图、状态图以及顺序图（协作图）。下面将...
java大作业 俄罗斯方块_俄罗斯方块Java程序设计
weixin_35562134的博客
02-25 695
2021年2月9日发(作者：pending)俄罗斯方块游戏一、课题内容和要求课题内容：俄罗斯方块游戏(Tetris)是一款经典单机游戏，早期常见于各个平台。设计一个俄罗斯方块，玩家根据下落的不同方块形状，通过上、下、</p>左、右四个键实现对方块的左右移动、旋转、下落等控制。游戏中，一共有7种不同的方块形状、每种方块以1/7的概率随机出现，一旦方块到达顶部，游戏结束。</p&gt...
python编的俄罗斯方块游戏_Python编写俄罗斯方块小游戏
weixin_39966130的博客
11-21 308
俄罗斯方块是俄罗斯人发明的一款休闲类的小游戏，这款小游戏可以说是很多人童年的主打电子游戏了，本文我们使用 Python 来实现这款小游戏。游戏的基本规则是：移动、旋转和摆放游戏自动输出的各种方块，使之排列成完整的一行或多行并且消除得分。实现我们实现俄罗斯方块，主要用到的是 PyQt5 库，安装使用 pip install PyQt5 即可，游戏的组成比较简单，主要包括：主界面、各种方块和计分板，下...
计算机专业项目二 俄罗斯方块
量子小白的博客
03-27 1017
俄罗斯方块比上一个项目贪吃蛇的难度大， 需要考虑到初始化方块的形状，以及对方块变形的存储 随机产生方块图形可以类比贪吃蛇食物的随机产生 srand（）实现 初始化边界 方块的自动下落 用sleep（）控制下落速度 控制范围，当靠近边界空间不够时，不能进行形状的变换 当某一行被方块铺满时，消除 ........................... 不多说了 直接上代码吧 //...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值