Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
#include <iomanip>
#include <iostream>
#include <vector>
#include <random>
#ifdef __linux__
/*****************************************************************************
kbhit() and getch() for Linux/UNIX
Chris Giese <geezer@execpc.com> http://my.execpc.com/~geezer
Release date: ?
This code is public domain (no copyright).
You can do whatever you want with it.
****************************************************************************/
#include <sys/time.h> /* struct timeval, select() */
/* ICANON, ECHO, TCSANOW, struct termios */
#include <termios.h> /* tcgetattr(), tcsetattr() */
#include <stdlib.h> /* atexit(), exit() */
#include <unistd.h> /* read() */
#include <stdio.h> /* printf() */
static struct termios g_old_kbd_mode;
/*****************************************************************************
*****************************************************************************/
static void cooked(void)
{
tcsetattr(0, TCSANOW, &g_old_kbd_mode);
}
/*****************************************************************************
*****************************************************************************/
static void raw(void)
{
static char init;
/**/
struct termios new_kbd_mode;
if (init)
return;
/* put keyboard (stdin, actually) in raw, unbuffered mode */
tcgetattr(0, &g_old_kbd_mode);
memcpy(&new_kbd_mode, &g_old_kbd_mode, sizeof(struct termios));
new_kbd_mode.c_lflag &= ~(ICANON | ECHO);
new_kbd_mode.c_cc[VTIME] = 0;
new_kbd_mode.c_cc[VMIN] = 1;
tcsetattr(0, TCSANOW, &new_kbd_mode);
/* when we exit, go back to normal, "cooked" mode */
atexit(cooked);
init = 1;
}
/*****************************************************************************
*****************************************************************************/
static int _kbhit(void)
{
struct timeval timeout;
fd_set read_handles;
int status;
raw();
/* check stdin (fd 0) for activity */
FD_ZERO(&read_handles);
FD_SET(0, &read_handles);
timeout.tv_sec = timeout.tv_usec = 0;
status = select(0 + 1, &read_handles, NULL, NULL, &timeout);
if (status < 0)
{
printf("select() failed in kbhit()\n");
exit(1);
}
return status;
}
/*****************************************************************************
*****************************************************************************/
static int _getch(void)
{
unsigned char temp;
raw();
/* stdin = fd 0 */
if (read(0, &temp, 1) != 1)
return 0;
return temp;
}
struct COORD { short X; short Y; };
bool gotoxy(unsigned short x = 1, unsigned short y = 1) {
if ((x == 0) || (y == 0))
return false;
std::cout << "\x1B[" << y << ";" << x << "H";
}
void clearScreen(bool moveToStart = true) {
std::cout << "\x1B[2J";
if (moveToStart)
gotoxy(1, 1);
}
inline
void print(const std::string& str, COORD& coord)
{
gotoxy(coord.X, coord.Y);
std::cout << str << std::flush;
}
inline
void print(const char* str, COORD& coord){
gotoxy(coord.X, coord.Y);
std::cout << str << std::flush;
}
inline
void print(char c, COORD& coord){
gotoxy(coord.X, coord.Y);
std::cout << c << std::flush;
}
#elif _WIN32
#include <conio.h> /* kbhit(), getch() */
#include <Windows.h>
#include <tchar.h>
static HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
static CONSOLE_SCREEN_BUFFER_INFO csbi;
void clearScreen()
{
DWORD count;
DWORD cellCount;
COORD homeCoords = { 0, 0 };
if (!GetConsoleScreenBufferInfo(hStdOut, &csbi))
std::cerr << "ERROR GetConsoleScreenBufferInfo - clearScreen : "
<< GetLastError() << std::endl;
cellCount = csbi.dwSize.X *csbi.dwSize.Y;
FillConsoleOutputCharacter( hStdOut, (TCHAR) ' ',cellCount, homeCoords, &count);
FillConsoleOutputAttribute( hStdOut, csbi.wAttributes, cellCount, homeCoords, &count);
SetConsoleCursorPosition(hStdOut, homeCoords);
}
void gotoxy(int x, int y)
{
COORD coord;
coord.X = x;
coord.Y = y;
SetConsoleCursorPosition(hStdOut, coord);
}
COORD getXY()
{
if (!GetConsoleScreenBufferInfo(hStdOut, &csbi))
std::cerr << "ERROR GetConsoleScreenBufferInfo - getXY : "
<< GetLastError() << std::endl;
COORD position;
position.X = csbi.dwCursorPosition.X;
position.Y = csbi.dwCursorPosition.Y;
return position;
}
SHORT getPosX()
{
if (!GetConsoleScreenBufferInfo(hStdOut, &csbi))
std::cerr << "ERROR GetConsoleScreenBufferInfo - getX : "
<< GetLastError() << std::endl;
return csbi.dwCursorPosition.X;
}
SHORT getPosY()
{
if (!GetConsoleScreenBufferInfo(hStdOut, &csbi))
std::cerr << "ERROR GetConsoleScreenBufferInfo - getY : "
<< GetLastError() << std::endl;
return csbi.dwCursorPosition.Y;
}
static DWORD cCharsWritten = 0;
inline
void print(const std::string& str, COORD& coord)
{
WriteConsoleOutputCharacter(hStdOut, str.c_str(), str.length(), coord, &cCharsWritten);
}
inline
void print(const TCHAR* str, COORD& coord)
{
WriteConsoleOutputCharacter(hStdOut, str, _tcslen(str), coord, &cCharsWritten);
}
inline
void print(TCHAR c, COORD& coord, bool dummy = true)
{
FillConsoleOutputCharacter(hStdOut, c, 1, coord, &cCharsWritten);
}
#else
#error "OS not supported!"
#endif
using Matrix = std::vector<std::vector<int>>;
constexpr std::initializer_list<size_t> il =
{
0, 1, 2, 3
};
constexpr std::initializer_list<size_t> ilBoard =
{
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20
};
constexpr std::initializer_list<size_t> ilBoardRow =
{
0,1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
};
const size_t mSize = 22;
static std::vector<Matrix> blockList =
{
{
{ 0, 1, 0, 0 },
{ 0, 1, 0, 0 },
{ 0, 1, 0, 0 },
{ 0, 1, 0, 0 }
},
{
{ 0, 0, 0, 0 },
{ 0, 1, 1, 0 },
{ 0, 1, 0, 0 },
{ 0, 1, 0, 0 }
},
{
{ 0, 0, 1, 0 },
{ 0, 1, 1, 0 },
{ 0, 1, 0, 0 },
{ 0, 0, 0, 0 }
},
{
{ 0, 1, 0, 0 },
{ 0, 1, 1, 0 },
{ 0, 0, 1, 0 },
{ 0, 0, 0, 0 }
},
{
{ 0, 0, 0, 0 },
{ 0, 1, 0, 0 },
{ 1, 1, 1, 0 },
{ 0, 0, 0, 0 }
},
{
{ 0, 0, 0, 0 },
{ 0, 1, 1, 0 },
{ 0, 1, 1, 0 },
{ 0, 0, 0, 0 }
},
{
{ 0, 0, 0, 0 },
{ 0, 1, 1, 0 },
{ 0, 0, 1, 0 },
{ 0, 0, 1, 0 }
}
};
class NonCopyable
{
public:
NonCopyable() = default;
private:
NonCopyable(const NonCopyable &) = delete;
NonCopyable(const NonCopyable &&) = delete;
NonCopyable& operator = (const NonCopyable&) = delete;
};
class Random : private NonCopyable
{
public:
Random(int min, int max)
: mUniformDistribution(min, max)
{}
int operator()()
{
return mUniformDistribution(mEngine);
}
private:
std::default_random_engine mEngine{ std::random_device()() };
std::uniform_int_distribution<int> mUniformDistribution;
};
class Block : private NonCopyable
{
public:
Block()
{
mBlock.resize(size(), std::vector<int>(size(), 0));
mCoord.X = 0;
mCoord.Y = 0;
}
void rotate()
{
++mRotationCount;
while (mRotationCount > ROTATIONS_IN_CIRCLE)
{
mRotationCount -= ROTATIONS_IN_CIRCLE;
}
}
int& getDim(int row, int column)
{
switch (mRotationCount % ROTATIONS_IN_CIRCLE)
{
default:
return mBlock[row][column];
case 1:
return mBlock[size() - column - 1][row];
case 2:
return mBlock[size() - row - 1][size() - column - 1];
case 3:
return mBlock[column][size() - row - 1];
}
}
size_t size() const
{
return il.size();
}
private:
static const int ROTATIONS_IN_CIRCLE = 4;
int mRotationCount = 0;
COORD mCoord;
Matrix mBlock;
};
class Board : private NonCopyable
{
public:
Board()
{
mField.resize(size(), std::vector<int>(rowSize(), 0));
mCoord.X = 0;
mCoord.Y = 0;
}
int& getDim(int row, int column)
{
return mField[row][column];
}
size_t size() const
{
return ilBoard.size();
}
size_t rowSize() const
{
return ilBoardRow.size();
}
private:
COORD mCoord;
Matrix mField;
};
class Collidable : private NonCopyable
{
public:
Collidable()
{
mStage.resize(size(), std::vector<int>(rowSize(), 0));
mCoord.X = 0;
mCoord.Y = 0;
}
int& getDim(int row, int column)
{
return mStage[row][column];
}
size_t size() const
{
return ilBoard.size();
}
size_t rowSize() const
{
return ilBoardRow.size();
}
private:
COORD mCoord;
Matrix mStage;
};
class Tetris : private NonCopyable
{
public:
Tetris()
: board(), block(), stage()
{};
private:
bool makeBlocks();
void moveBlock(int, int);
void collidable();
bool isCollide(int, int);
bool rotateBlock();
virtual void display(){};
virtual void GameOverScreen() {};
Random getRandom{ 0, (il.size() - 1) };
Collidable stage;
Block block;
int y = 0;
int x = block.size();
protected:
void initField();
void spawnBlock();
void userInput();
bool gameOver = false;
Board board;
};
void Tetris::initField()
{
for (auto i = ilBoard.begin(); i != ilBoard.end() - 1; ++i)
{
for (auto j = ilBoardRow.begin(); j != ilBoardRow.end() - 1; ++j)
{
if ((*j == 0) || (*j == ilBoardRow.size() - 2) || (*i == ilBoard.size() - 2))
{
board.getDim(*i, *j) = stage.getDim(*i, *j) = 9;
}
else
{
board.getDim(*i, *j) = stage.getDim(*i, *j) = 0;
}
}
}
makeBlocks();
display();
}
bool Tetris::makeBlocks()
{
x = block.size();
y = 0;
int blockType = getRandom();
for (auto i : il)
{
for (auto j : il)
{
block.getDim(i, j) = 0;
block.getDim(i, j) = blockList[blockType][i][j];
}
}
for (auto i : il)
{
for (auto j : il)
{
board.getDim(i, j + il.size()) = stage.getDim(i, j + il.size()) + block.getDim(i, j);
if ( board.getDim(i, j + il.size() ) > 1)
{
return gameOver = true;
}
}
}
return false;
}
void Tetris::moveBlock(int x2, int y2)
{
//Remove block
for (auto i : il)
{
for (auto j : il)
{
board.getDim(y + i, x + j) -= block.getDim(i, j);
}
}
//Update coordinates
x = x2;
y = y2;
// assign a block with the updated value
for (auto i : il)
{
for (auto j : il)
{
board.getDim(y + i, x + j) += block.getDim(i, j);
}
}
display();
}
void Tetris::collidable()
{
for (auto i : ilBoard)
{
for (auto j : ilBoardRow)
{
stage.getDim(i, j) = board.getDim(i, j);
}
}
}
bool Tetris::isCollide(int x2, int y2)
{
for (auto i : il)
{
for (auto j : il)
{
if (block.getDim(i, j) && stage.getDim(y2 + i, x2 + j) != 0)
{
return true;
}
}
}
return false;
}
void Tetris::userInput()
{
char key;
key = _getch();
switch (key)
{
case 'd':
if (!isCollide(x + 1, y))
{
moveBlock(x + 1, y);
}
break;
case 'a':
if (!isCollide(x - 1, y))
{
moveBlock(x - 1, y);
}
break;
case 's':
if (!isCollide(x, y + 1))
{
moveBlock(x, y + 1);
}
break;
case ' ':
rotateBlock();
}
}
bool Tetris::rotateBlock()
{
Matrix temp(il.size(), std::vector<int>(il.size(), 0));
for (auto i : il)
{
for (auto j : il)
{
temp[i][j] = block.getDim(i, j);
}
}
for (auto i : il)
{
for (auto j : il)
{
block.getDim(i, j) = temp[il.size() - 1 - j][i];
}
}
if (isCollide(x, y))
{ // And stop if it overlaps not be rotated
for (auto i : il)
{
for (auto j : il)
{
block.getDim(i, j) = temp[i][j];
}
}
return true;
}
for (auto i : il)
{
for (auto j : il)
{
board.getDim(y + i, x + j) -= temp[i][j];
board.getDim(y + i, x + j) += block.getDim(i, j);
}
}
display();
return false;
}
void Tetris::spawnBlock()
{
if (!isCollide(x, y + 1))
{
moveBlock(x, y + 1);
}
else
{
collidable();
makeBlocks();
display();
}
}
class Game : public Tetris
{
public:
Game() = default;
int menu();
void gameLoop();
private:
void introScreen();
virtual void display();
virtual void gameOverScreen();
size_t GAMESPEED = 20000;
};
void Game::gameOverScreen()
{
COORD coord = { 0, 0 };
coord.Y += 2;
print(" ##### # # # ####### ####### # # ####### ######", coord); coord.Y++;
print("# # # # ## ## # # # # # # # #", coord);coord.Y++;
print("# # # # # # # # # # # # # # #", coord);coord.Y++;
print("# #### # # # # # ##### # # # # ##### ######", coord); coord.Y++;
print("# # ####### # # # # # # # # # #", coord); coord.Y++;
print("# # # # # # # # # # # # # #", coord); coord.Y++;
print(" ##### # # # # ####### ####### # ####### # #", coord);coord.Y += 2;
print("Press any key and enter", coord);
gotoxy((coord.X = strlen("Press any key and enter") + 1), coord.Y++);
char a;
std::cin >> a;
}
void Game::gameLoop()
{
size_t time = 0;
initField();
while (!gameOver)
{
if (_kbhit())
{
userInput();
}
if (time < GAMESPEED)
{
time++;
}
else
{
spawnBlock();
time = 0;
}
}
}
int Game::menu()
{
introScreen();
int select_num = 0;
std::cin >> select_num;
switch (select_num)
{
case 1:
case 2:
case 3:
break;
default:
select_num = 0;
break;
}
return select_num;
}
void Game::introScreen()
{
clearScreen();
COORD coord = { 0, 0 };
print("#==============================================================================#", coord); coord.Y += 2;
print("####### ####### ####### ###### ### #####", coord); coord.Y++;
print(" # # # # # # # #", coord); coord.Y++;
print(" # # # # # # #", coord); coord.Y++;
print(" # ##### # ###### # #####", coord); coord.Y++;
print(" # # # # # # #", coord); coord.Y++;
print(" # # # # # # # #", coord); coord.Y++;
print(" # ####### # # # ### ##### made for fun ", coord); coord.Y += 4;
coord.Y++;
print(" <Menu>", coord); coord.Y++;
print(" 1: Start Game", coord); coord.Y++;
print(" 2: Quit", coord); coord.Y += 2;
print("#==============================================================================#", coord); coord.Y++;
print("Choose >> ", coord);
coord.X = strlen("Choose >> ");
gotoxy(coord.X, coord.Y);
}
void Game::display()
{
clearScreen();
for (auto i : ilBoard)
{
for (auto j : ilBoardRow)
{
switch (board.getDim(i, j))
{
case 0:
std::cout << ' ';
break;
case 9:
std::cout << '@';
break;
default:
std::cout << '#';
break;
}
}
std::cout << std::endl;
}
COORD coord = { 0, ilBoard.size() };
print(" A: left S: down D: right Rotation[Space]", coord);
if (gameOver)
{
clearScreen();
gameOverScreen();
}
}
int main()
{
Game game;
switch (game.menu())
{
case 1:
game.gameLoop();
break;
case 2:
return 0;
default:
COORD coord = { 0, 0 };
print("Choose 1~2", coord);
return -1;
}
return 0;
}
@MORTAL2000
Copy link
Author

MORTAL2000 commented Dec 21, 2014

first draft

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment