控制台小游戏之俄罗斯方块

最新推荐文章于 2019-06-13 11:37:00 发布
最新推荐文章于 2019-06-13 11:37:00 发布
阅读量791 收藏 4
点赞数 1
分类专栏： 控制台游戏 文章标签： 俄罗斯方块 线程 控制台 游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hophan/article/details/50414745
版权

因为最近在学多线程，用的C++新标准的thread库，就尝试简单用了一下，写进俄罗斯方块里监听键盘输入。


基本的思路就是用一个类代表一种方块，方块类中用一个坐标pos表示方块位置，然后一个坐标数组offset代表方块的各个小方格相对于pos的偏移量。加上两个生成随即数的可调用对象的类来随机生成方块。

棋子类base_cube是个虚基类，另外有七个类都继承自base_cube ：O_cube,  I_cube, L_cube, R_cube, S_cube, Z_cube 和 T_cube；分别代表七种方块。然后用一个game类封装起来。

make_random.h


#ifndef _MAKE_RANDOM_H
#define _MAKE_RANDOM_H

#include<random>
class Random4{
public:
	unsigned operator() (){
		static std::default_random_engine e;
		static std::uniform_int_distribution<unsigned> u(1, 4);
		return u(e);
	}
};
class Random7{
public:
	unsigned operator() (){
		static std::default_random_engine e;
		static std::uniform_int_distribution<unsigned> u(1, 7);
		return u(e);
	}
};
#endif

base_cube.h


#ifndef _BASE_CUBE_H
#define _BASE_CUBE_H

#include<vector>
#include"make_random.h"

class __pt
{
public:
	__pt(int x = 0, int y = 0) 
		:_x(x), _y(y) { }
	inline void set(int x, int y){
		_y = y, _x = x; 
	}
	inline int x()const{ return _x; }
	inline int y()const{ return _y; }
private:
	int _x, _y;
};

class base_cube
{
public:
	base_cube(int x = 0, int y = 0) :_pos(x, y), _offset(4,__pt()) { }
	virtual ~base_cube(){ }
	inline virtual void turn() = 0;
	inline int x(std::size_t i){ return _pos.x() + _offset[i].x(); }
	inline int y(std::size_t i){ return _pos.y() + _offset[i].y(); }
	inline const void move(int x, int y){ _pos.set(_pos.x() + x, _pos.y() + y); }
protected:
	__pt _pos;
	std::vector<__pt> _offset;
};

#endif


I_cube.h


#ifndef _I_CUBE_H
#define _I_CUBE_H

#include"base_cube.h"


class I_cube : public base_cube
{
public:
	I_cube(int x = 0, int y = 0) :base_cube(x, y)
	{
		auto r = Random4()();
		if (r == 1 || r == 3){
			_stat = vertical;
			turn_vertical();
		}
		else {
			_stat = horizontal;
			turn_horizontal();
		}
	}
	~I_cube(){ base_cube::~base_cube(); }
	inline void turn() override {
		if (_stat == horizontal)
			turn_vertical();
		else turn_horizontal();
	}
private:
	enum stat{ vertical, horizontal };
	inline void turn_horizontal(){
		_offset[0].set(0, -1);
		_offset[1].set(0, 0);
		_offset[2].set(0, 1);
		_offset[3].set(0, 2);
		_stat = horizontal;
	}
	inline void turn_vertical(){
		_offset[0].set(-1, 0);
		_offset[1].set(0, 0);
		_offset[2].set(1, 0);
		_offset[3].set(2, 0);
		_stat = vertical;
	}
	stat _stat;
};
#endif

L_cube.h 


#ifndef _L_CUBE_H
#define _L_CUBE_H

#include"base_cube.h"

class L_cube : public base_cube
{
public:
	L_cube(int x = 0, int y = 0) :base_cube(x, y)
	{
		auto r = Random4()();
		switch (r){
		case 1: turn_top();		break;
		case 2: turn_left();	break;
		case 3: turn_bottom();	break;
		case 4: turn_right();	break;
		default:				break;
		}
	}
	~L_cube(){ base_cube::~base_cube(); }
	inline void turn() override {
		switch (_stat){
		case top:		turn_left();		break;
		case left:		turn_bottom();		break;
		case bottom:	turn_right();		break;
		case right:		turn_top();			break;
		default:							break;
		}
	}
private:
	enum stat{ top, left, bottom, right };
	inline void turn_top(){
		_offset[0].set(-1, 0);
		_offset[1].set(0, 0);
		_offset[2].set(1, 0);
		_offset[3].set(1, 1);
		_stat = top;
	}
	inline void turn_left(){
		_offset[0].set(0, -1);
		_offset[1].set(0, 0);
		_offset[2].set(0, 1);
		_offset[3].set(-1, 1);
		_stat = left;
	}
	inline void turn_bottom(){
		_offset[0].set(-1, -1);
		_offset[1].set(-1, 0);
		_offset[2].set(0, 0);
		_offset[3].set(1, 0);
		_stat = bottom;
	}
	inline void turn_right(){
		_offset[0].set(1, -1);
		_offset[1].set(0, -1);
		_offset[2].set(0, 0);
		_offset[3].set(0, 1);
		_stat = right;
	}
	stat _stat;
};

#endif

O_cube.h 


#ifndef _O_CUBE_H
#define _O_CUBE_H

#include"base_cube.h"


class O_cube : public base_cube
{
public:
	O_cube(int x = 0, int y = 0) :base_cube(x, y)
	{
		_offset[0].set(0, 0);
		_offset[1].set(0, 1);
		_offset[2].set(1, 0);
		_offset[3].set(1, 1);
	}
	~O_cube(){ base_cube::~base_cube(); }
	inline void turn() override { }
};

#endif


R_cube.h 


#ifndef _R_CUBE_H
#define _R_CUBE_H

#include"base_cube.h"

class R_cube : public base_cube
{
public:
	R_cube(int x = 0, int y = 0) :base_cube(x, y)
	{
		auto r = Random4()();
		switch (r){
		case 1: turn_top();		break;
		case 2: turn_left();	break;
		case 3: turn_bottom();	break;
		case 4: turn_right();	break;
		default:				break;
		}
	}
	~R_cube(){ base_cube::~base_cube(); }
	inline void turn() override {
		switch (_stat){
		case top:		turn_left();		break;
		case left:		turn_bottom();		break;
		case bottom:	turn_right();		break;
		case right:		turn_top();			break;
		default:							break;
		}
	}
private:
	enum stat{ top, left, bottom, right };
	inline void turn_top(){
		_offset[0].set(-1, 0);
		_offset[1].set(0, 0);
		_offset[2].set(1, 0);
		_offset[3].set(1, -1);
		_stat = top;
	}
	inline void turn_left(){
		_offset[0].set(0, -1);
		_offset[1].set(0, 0);
		_offset[2].set(0, 1);
		_offset[3].set(1, 1);
		_stat = left;
	}
	inline void turn_bottom(){
		_offset[0].set(-1, 1);
		_offset[1].set(-1, 0);
		_offset[2].set(0, 0);
		_offset[3].set(1, 0);
		_stat = bottom;
	}
	inline void turn_right(){
		_offset[0].set(-1, -1);
		_offset[1].set(0, -1);
		_offset[2].set(0, 0);
		_offset[3].set(0, 1);
		_stat = right;
	}
	stat _stat;
};

#endif

S_cube.h 


#ifndef _S_CUBE_H
#define _S_CUBE_H

#include"base_cube.h"

class S_cube : public base_cube
{
public:
	S_cube(int x = 0, int y = 0) :base_cube(x, y)
	{
		auto r = Random4()();
		if (r == 1 || r == 3){
			_stat = vertical;
			turn_vertical();
		}
		else {
			_stat = horizontal;
			turn_horizontal();
		}
	}
	~S_cube(){ base_cube::~base_cube(); }
	inline void turn() override {
		if (_stat == horizontal)
			turn_vertical();
		else turn_horizontal();
	}
private:
	enum stat{ vertical, horizontal };
	inline void turn_horizontal(){
		_offset[0].set(0, 1);
		_offset[1].set(0, 0);
		_offset[2].set(1, 0);
		_offset[3].set(1, -1);
		_stat = horizontal;
	}
	inline void turn_vertical(){
		_offset[0].set(-1, 0);
		_offset[1].set(0, 0);
		_offset[2].set(0, 1);
		_offset[3].set(1, 1);
		_stat = vertical;
	}
	stat _stat;
};

#endif


T_cube.h 


#ifndef _T_CUBE_H
#define _T_CUBE_H

#include"base_cube.h"

class T_cube : public base_cube
{
public:
	T_cube(int x = 0, int y = 0) :base_cube(x, y)
	{
		auto r = Random4()();
		switch (r){
		case 1: turn_top();		break;
		case 2: turn_left();	break;
		case 3: turn_bottom();	break;
		case 4: turn_right();	break;
		default:				break;
		}
	}
	~T_cube(){ base_cube::~base_cube(); }
	inline void turn() override {
		switch (_stat){
		case    top:	turn_left();		break;
		case   left:	turn_bottom();		break;
		case bottom:	turn_right();		break;
		case  right:	turn_top();			break;
		default	   :						break;
		}
	}
private:
	enum stat{ top, left, bottom, right };
	inline void turn_top(){
		_offset[0].set(0, -1);
		_offset[1].set(0, 0);
		_offset[2].set(0, 1);
		_offset[3].set(-1, 0);
		_stat = top;
	}
	inline void turn_left(){
		_offset[0].set(-1, 0);
		_offset[1].set(0, 0);
		_offset[2].set(1, 0);
		_offset[3].set(0, -1);
		_stat = left;
	}
	inline void turn_bottom(){
		_offset[0].set(0, -1);
		_offset[1].set(0, 0);
		_offset[2].set(0, 1);
		_offset[3].set(1, 0);
		_stat = bottom;
	}
	inline void turn_right(){
		_offset[0].set(-1, 0);
		_offset[1].set(0, 0);
		_offset[2].set(1, 0);
		_offset[3].set(0, 1);
		_stat = right;
	}
	stat _stat;
};

#endif


Z_cube.h 


#ifndef _Z_CUBE_H
#define _Z_CUBE_H

#include"base_cube.h"

class Z_cube : public base_cube
{
public:
	Z_cube(int x = 0, int y = 0) :base_cube(x, y)
	{
		auto r = Random4()();
		if (r == 1 || r == 3){
			_stat = vertical;
			turn_vertical();
		}
		else {
			_stat = horizontal;
			turn_horizontal();
		}
	}
	~Z_cube(){ base_cube::~base_cube(); }
	inline void turn() override {
		if (_stat == horizontal)
			turn_vertical();
		else turn_horizontal();
	}
private:
	enum stat{ vertical, horizontal };
	inline void turn_horizontal(){
		_offset[0].set(0, -1);
		_offset[1].set(0, 0);
		_offset[2].set(1, 0);
		_offset[3].set(1, 1);
		_stat = horizontal;
	}
	inline void turn_vertical(){
		_offset[0].set(1, 0);
		_offset[1].set(0, 0);
		_offset[2].set(0, 1);
		_offset[3].set(-1, 1);
		_stat = vertical;
	}
	stat _stat;
};

#endif


game.h 


#ifndef _GAME_H
#define _GAME_H

#include<string>
#include<mutex>
#include<Windows.h>
#include"I_cube.h"
#include"L_cube.h"
#include"O_cube.h"
#include"R_cube.h"
#include"T_cube.h"
#include"Z_cube.h"
#include"S_cube.h"

class game
{
public:
	game(int w = 16, int h = 24) :sleep_time(800),
		score(0), width(w), height(h), mtx(),cube(nullptr),
		win(std::vector<std::vector<bool>>(height, std::vector<bool>(width, false)))
	{
		makecube();
	}
	void start();
	bool Over();
	void keydown(char);
	void printwin();
private:
	void keylistener();
	bool touched();
	void insertwin();
	int fullline();
	void destroyline(int);
	bool outofboard(int,int);
	bool turn();
	bool move(int, int);
	void makecube();
	void setsleeptime(int i){
		if (sleep_time + i >= 100 &&
			sleep_time + i <=1500)
			sleep_time += i;
	}
private:
	int sleep_time;
	int score;
	int width, height;
	std::mutex mtx;
	base_cube * cube;
	std::vector<std::vector<bool>> win;
};

#endif



game.cpp 


#include"game.h"
#include<conio.h>
#include<thread>
#include<iostream>

void game::keylistener()
{
	char c;
	while (!Over()){
		c = _getch();
		mtx.lock();
			keydown(c);
			printwin();
		mtx.unlock();
	}
}

void game::printwin()
{
	system("cls");
	std::vector<std::string> board(height, std::string(width * 2, ' '));
	std::string s = "■";
	for (int i = 0; i != 4; ++i){
		if (cube->x(i) >= 0){
			board[cube->x(i)][cube->y(i) * 2] = s[0];
			board[cube->x(i)][cube->y(i) * 2 + 1] = s[1];
		}
	}
	std::cout << "\t\t\t ";
	for (int i = 0; i <= width * 2 + 1; ++i)
		std::cout << "=";
	std::cout << std::endl;
	s = "□";
	for (int i = 0; i != height; ++i){
		for (int j = 0; j != width; ++j)
			if (win[i][j]){
				board[i][j * 2] = s[0];
				board[i][j * 2 + 1] = s[1];
			}
		std::cout << "\t\t\t||" << board[i]<< "||" << std::endl;
	}
	std::cout << "\t\t\t ";
	for (int i = 0; i <= width * 2 + 1; ++i)
		std::cout << "=";
	std::cout << std::endl;
	std::cout <<"\t\t\t\t    SCORE:"<< score << std::endl;
}
bool game::Over()
{
	for (int i = 0; i != width; ++i)
		if (win[0][i])
			return true;
	return false;
}

void game::start()
{
	std::thread t(&game::keylistener,this);
	t.detach();
	while (!Over()){
		Sleep(sleep_time);
		move(1, 0);
		mtx.lock();
			printwin();
		mtx.unlock();
		if (touched()){
			insertwin();
			makecube();
			mtx.lock();
				printwin();
			mtx.unlock();
		}
		int i = fullline();
		while (i != -1){
			destroyline(i);
			++score;
			mtx.lock();
				printwin();
			mtx.unlock();
			i = fullline();
		}
	}
	mtx.lock();
		printwin();
	mtx.unlock();
	std::cout << "\t\t\t\t    GAMEOVER!" << std::endl;
}

void game::keydown(char c)
{
	switch (c){
		case'w':turn();		  				break;
		case'a':move(0,-1);					break;
		case's':move(1, 0);					break;
		case'd':move(0, 1);					break;
		case' ':system("pause");			break;
		case']':setsleeptime(100);			break;
		case'[':setsleeptime(-100);			break;
		case'q':++score;			break;<span style="white-space:pre">			</span>//作弊你咬我呀
		default:							break;
	}
}

bool game::touched()
{
	for (int i = 0; i != 4; ++i){
		int x = cube->x(i) + 1;
		int y = cube->y(i);
		if (x == height || win[x][y])
			return true;
	}
	return false;
}

void game::insertwin()
{
	for (int i = 0; i != 4; ++i){
		int x = cube->x(i);
		int y = cube->y(i);
		if (x >= 0)
			win[x][y] = true;
	}
}
int game::fullline()
{
	for (int j,i = 0; i != height; ++i){
		for (j = 0; j != width; ++j)
			if (!win[i][j])break;
		if (j == width){
			return i;
		}	
	}
	return -1;
}
void game::destroyline(int i)
{
	for (int k = i; k != 0;--k)
		for (int j = 0; j != width; ++j)
			win[k][j] = win[k-1][j];
	for (int k = 0; k != width; ++k)
		win[0][k] = false;
}

bool game::outofboard(int x, int y)
{
	if (y < 0 || x >= height || y >= width)
		return true;
	return false;
}
bool game::turn()
{
	cube->turn();
	for (int i = 0; i != 4; ++i)
		if (outofboard(cube->x(i), cube->y(i))){
			cube->turn(), cube->turn(), cube->turn();
			return false;
		}
	return true;
}
bool game::move(int x,int y)
{
	for (int i = 0; i != 4; ++i)
		if (outofboard(cube->x(i) + x, cube->y(i) + y))
			return false;
		else if (cube->x(i) + x>=0 && win[cube->x(i) + x][cube->y(i) + y])
			return false;
	cube->move(x, y);
	return true;
}
void game::makecube()
{
	auto r = Random7()();
	switch (r){
	case 1:delete cube; cube = new O_cube(0, width / 2); break;
	case 2:delete cube; cube = new T_cube(0, width / 2); break;
	case 3:delete cube; cube = new L_cube(0, width / 2); break;
	case 4:delete cube; cube = new R_cube(0, width / 2); break;
	case 5:delete cube; cube = new I_cube(0, width / 2); break;
	case 6:delete cube; cube = new Z_cube(0, width / 2); break;
	case 7:delete cube; cube = new S_cube(0, width / 2); break;
	default:break;
	}
}


食用方法：

main.cpp


#include"game.h"

int main()
{
	game g;
	g.start();
	return 0;
}




Hophan
关注
专栏目录
批处理写的俄罗斯方块
BOTOAI
07-23 1967
@echo off&rem 俄罗斯方块游戏，由netbenton编写，在bathome首发，完成时间：2009年9月25日 ver 2.0 if "%1" equ "para2" goto :para2 set "d-v=for %%a in (!str!) do set/a one=0x%%a,x=one/4+n,y=one%%4+m&(for %%b in ("r!x!.!y!") do
游戏 俄罗斯方块 源码 c c++ 算法 数据结构 键盘编程 控制台
06-12
俄罗斯方块，基于控制台编写的，采用c、c++，里面既有数据结构的知识，又有算法的内容，还有键盘编程知识，唯独遗憾的是当时没有加入鼠标操作。否则这个例子是所有先手入门的经典案例！！！ /*游戏 俄罗斯方块 源码 c c++ 算法 数据结构 键盘编程 控制台*/
基于控制台的俄罗斯方块
weixin_33694620的博客
06-13 454
基于控制台实现的俄罗斯方块 刚开始磕磕绊绊的学C++，做的不是特别好 转载于:https://www.cnblogs.com/Manual-Linux/p/11015251.html
游戏开发（二）——控制台 俄罗斯方块
zilaishuichina的专栏
07-15 3453
俄罗斯方块游戏设计中主要需要注意的几点： 1：依然是坐标的定义：定义为左上角为（0，0），向右为x正方向，向下为y正方向 2：游戏画面是分两个区域的。左边是游戏区域，就是俄罗斯方块下落的区域。右边一个小的显示下一个方块是什么的区域。 但是，方块出现并开始下落时，并不是一个方块直接出现在画面顶部，而是从最上面一行开始，一行一行的逐行落下来。 比如一个竖长条，并不是一出现就直接占了4行
使用Dev c++实现小游戏俄罗斯方块 C++版
03-31
《使用Dev C++实现小游戏俄罗斯方块 C++版》 在编程世界中，开发小游戏是初学者们常常尝试的项目，因为它们可以帮助我们理解和运用基本的编程概念。本资源提供了一个使用C++语言在Dev C++环境下实现的俄罗斯方块小...
控制台俄罗斯方块
07-17
《控制台俄罗斯方块》是一款基于C语言编写的经典小游戏，它是大一学生学习编程时一个极好的实践项目。这个游戏的实现涉及到许多基础的编程概念和技术，包括数据结构、循环、条件判断、函数调用等，对于初学者来说，...
基于C++实现的（控制台）双人俄罗斯方块小游戏【100013225】
最新发布
08-28
使用visual studio 2015在win32控制台应用程序下用多线程实现双人同时进行俄罗斯方块的桌面游戏。最终将要完成的效果如图1.1所示，左右共两片工作区，也是游戏的主题；工作区旁边是记录当前游戏的级别和分数以及下一...
控制台的俄罗斯方块
11-09
《控制台的俄罗斯方块：深入C++游戏编程实践》 在编程世界中，俄罗斯方块是一款经典的入门级游戏，它的实现能帮助开发者理解和掌握基本的游戏逻辑和编程技巧。本项目是在Visual Studio 2013环境下，用C++语言编写的...
控制台界面俄罗斯方块
weixin_37101711的博客
12-03 694
【代码】控制台界面俄罗斯方块。
批处理版--俄罗斯方块
03-16
批处理版俄罗斯方块 a左 d右 w转 s 加速 q退出
多线程俄罗斯方块
06-07
一个完成的基于winfrom的俄罗斯方块游戏，基于多线程和委托和事件和winform的一些基本的东西组合而成，是不不错的练手小项目
俄罗斯方块（改）
08-27
有炸弹，三角形，四角形，定时器等多种特效。
电脑自动下俄罗斯方块
06-23
俄罗斯方块 人工智能 电脑 自动下棋 编程之美
俄罗斯方块算法以及原理
12-29
俄罗斯方块算法以及原理。数学 俄罗斯方块的由来
C++控制台实现俄罗斯方块游戏，程序员：被新人的技术给秒了！
04-22 631
之前学了些C++的课程，一直想着说编点小游戏，可是MFC又不想学，所以就只能变成控制台的小游戏。制作控制台小游戏可以作为学习编程的练习项目，在这个过程中既能激发创意又能加深对程序语言的理解。 俄罗斯方块一定是很多人小时候玩过的游戏。接下来就说说设计想法。 主要实现，选择游戏的等级，加速下降，不同形状不同颜色，暂停和退出功能。 首先是类的设计。 接下来就是一些常量和光标函数，便于保存和调用 ...
C#俄罗斯方块游戏
林老师的专栏
08-23 3827
俄罗斯方块是一款非常经典的老游戏，相比现在的网络游戏和大型游戏而言，俄罗斯方块非常小。不要看似小，要实现俄罗斯方块的全部功能也不容易。先说说涉及的知识点：继承（不同的方块继承于方块类）、多态（每种方块都可以旋转、初始化，但是每种方块的旋转都不一样，采用抽象方法定义）、简单工厂设计模式（由工厂随机创建方块）等。（感谢周勇学员整理了所有资料。）俄罗斯方块分成六个步骤：1.俄罗斯方块
C++ 俄罗斯方块
chuan_zhang_ak的博客
07-31 2995
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;graphics.h&gt; #include&lt;bios.h&gt; /*下面定义了一些控制命令*/ /*重画界面命令*/ #define CMDDRAW       5 /*消去一个满行的命令*/ #define CMDDELLINE    6 /*自...
Windows控制台俄罗斯方块游戏深度功能介绍
资源摘要信息:"一个基于Windows控制台的俄罗斯方块游戏源代碼" 知识点分析: 1. Windows控制台编程基础: - 控制台应用程序是在Windows操作系统中运行的一种应用程序类型，它使用字符界面与用户交互。 - 控制台...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值