08 Jul Your Input Flovodoh
i need an input of this program. anything good or bad. what could be changed, what you may like or dislike about it. only one paragraph.
// newTetris.cpp : Defines the entry point for the console application.
//
#include “stdafx.h”
#include <stdlib.h>
#include <iostream>
#include <time.h>
#include <windows.h>
#define GAME_INTERVAL 20
#define DIR_DOWN 2
#define DIR_LEFT 4
#define DIR_RIGHT 6
#define DIR_ROTATE 5
using namespace std;
class TetrisShape {
public:
char shapeArray[4][4];
int shapeTopLeftX = 6;
int shapeTopLeftY = 0;
void populateShapeArray(int shape);
void rotate();
template <size_t rows, size_t cols>
void setShape(char(&shape)[rows][cols]);
TetrisShape(int shape) { populateShapeArray(shape); };
TetrisShape() {};
};
void TetrisShape::rotate() {
char _shapeArray[4][4];
_shapeArray[0][0] = shapeArray[0][3]; _shapeArray[1][0] = shapeArray[0][2]; _shapeArray[2][0] = shapeArray[0][1]; _shapeArray[3][0] = shapeArray[0][0];
_shapeArray[0][1] = shapeArray[1][3]; _shapeArray[1][1] = shapeArray[1][2]; _shapeArray[2][1] = shapeArray[1][1]; _shapeArray[3][1] = shapeArray[1][0];
_shapeArray[0][2] = shapeArray[2][3]; _shapeArray[1][2] = shapeArray[2][2]; _shapeArray[2][2] = shapeArray[2][1]; _shapeArray[3][2] = shapeArray[2][0];
_shapeArray[0][3] = shapeArray[3][3]; _shapeArray[1][3] = shapeArray[3][2]; _shapeArray[2][3] = shapeArray[3][1]; _shapeArray[3][3] = shapeArray[3][0];
for (int _x = 0; _x < 4; _x++) {
for (int _y = 0; _y < 4; _y++) {
shapeArray[_x][_y] = _shapeArray[_x][_y];
}
}
}
void TetrisShape::populateShapeArray(int shape) {
switch (shape) {
case 1:
shapeArray[0][0] = ‘ ‘; shapeArray[1][0] = ‘ ‘; shapeArray[2][0] = ‘ ‘; shapeArray[3][0] = ‘ ‘;
shapeArray[0][1] = ‘ ‘; shapeArray[1][1] = ‘X’; shapeArray[2][1] = ‘ ‘; shapeArray[3][1] = ‘ ‘;
shapeArray[0][2] = ‘ ‘; shapeArray[1][2] = ‘X’; shapeArray[2][2] = ‘ ‘; shapeArray[3][2] = ‘ ‘;
shapeArray[0][3] = ‘ ‘; shapeArray[1][3] = ‘X’; shapeArray[2][3] = ‘X’; shapeArray[3][3] = ‘ ‘;
break;
case 2:
shapeArray[0][0] = ‘ ‘; shapeArray[1][0] = ‘X’; shapeArray[2][0] = ‘ ‘; shapeArray[3][0] = ‘ ‘;
shapeArray[0][1] = ‘ ‘; shapeArray[1][1] = ‘X’; shapeArray[2][1] = ‘ ‘; shapeArray[3][1] = ‘ ‘;
shapeArray[0][2] = ‘ ‘; shapeArray[1][2] = ‘X’; shapeArray[2][2] = ‘ ‘; shapeArray[3][2] = ‘ ‘;
shapeArray[0][3] = ‘ ‘; shapeArray[1][3] = ‘X’; shapeArray[2][3] = ‘ ‘; shapeArray[3][3] = ‘ ‘;
break;
case 3:
shapeArray[0][0] = ‘ ‘; shapeArray[1][0] = ‘ ‘; shapeArray[2][0] = ‘ ‘; shapeArray[3][0] = ‘ ‘;
shapeArray[0][1] = ‘ ‘; shapeArray[1][1] = ‘X’; shapeArray[2][1] = ‘ ‘; shapeArray[3][1] = ‘ ‘;
shapeArray[0][2] = ‘ ‘; shapeArray[1][2] = ‘X’; shapeArray[2][2] = ‘X’; shapeArray[3][2] = ‘ ‘;
shapeArray[0][3] = ‘ ‘; shapeArray[1][3] = ‘ ‘; shapeArray[2][3] = ‘X’; shapeArray[3][3] = ‘ ‘;
break;
case 4:
shapeArray[0][0] = ‘ ‘; shapeArray[1][0] = ‘ ‘; shapeArray[2][0] = ‘ ‘; shapeArray[3][0] = ‘ ‘;
shapeArray[0][1] = ‘ ‘; shapeArray[1][1] = ‘ ‘; shapeArray[2][1] = ‘X’; shapeArray[3][1] = ‘ ‘;
shapeArray[0][2] = ‘ ‘; shapeArray[1][2] = ‘X’; shapeArray[2][2] = ‘X’; shapeArray[3][2] = ‘ ‘;
shapeArray[0][3] = ‘ ‘; shapeArray[1][3] = ‘X’; shapeArray[2][3] = ‘ ‘; shapeArray[3][3] = ‘ ‘;
break;
case 5:
shapeArray[0][0] = ‘ ‘; shapeArray[1][0] = ‘ ‘; shapeArray[2][0] = ‘ ‘; shapeArray[3][0] = ‘ ‘;
shapeArray[0][1] = ‘ ‘; shapeArray[1][1] = ‘ ‘; shapeArray[2][1] = ‘X’; shapeArray[3][1] = ‘ ‘;
shapeArray[0][2] = ‘ ‘; shapeArray[1][2] = ‘ ‘; shapeArray[2][2] = ‘X’; shapeArray[3][2] = ‘ ‘;
shapeArray[0][3] = ‘ ‘; shapeArray[1][3] = ‘X’; shapeArray[2][3] = ‘X’; shapeArray[3][3] = ‘ ‘;
break;
case 6:
shapeArray[0][0] = ‘ ‘; shapeArray[1][0] = ‘ ‘; shapeArray[2][0] = ‘ ‘; shapeArray[3][0] = ‘ ‘;
shapeArray[0][1] = ‘ ‘; shapeArray[1][1] = ‘ ‘; shapeArray[2][1] = ‘ ‘; shapeArray[3][1] = ‘ ‘;
shapeArray[0][2] = ‘ ‘; shapeArray[1][2] = ‘X’; shapeArray[2][2] = ‘X’; shapeArray[3][2] = ‘ ‘;
shapeArray[0][3] = ‘ ‘; shapeArray[1][3] = ‘X’; shapeArray[2][3] = ‘X’; shapeArray[3][3] = ‘ ‘;
break;
}
}
int score = 0;
int currentShape = -1; // this is going to represent the shape that is currently in play.
bool isDropping = false; // global that defines if a piece is currently falling – mainly for gameTick function.
int currentTick = 0;
template <size_t rows, size_t cols>
void generateBucket(char(&bucket)[rows][cols]); // Creates a slightly pre-filled bucket.
void generateShapeStream(); // Generate a stream of shapes.
void dropShape(); // Draw the shape top/center.
bool moveShape(int direction); // Move the shape in the spec. dir.
template <size_t rows, size_t cols>
bool gameTick(char(&bucket)[rows][cols], char(&perm_bucket)[rows][cols]); // Handles what is going on in the game every second.
template <size_t rows, size_t cols>
void landShape(char(&bucket)[rows][cols]); // What to do when the shape hits the bottom.
template <size_t rows, size_t cols>
int checkScore(char(&bucket)[rows][cols], char(&perm_bucket)[rows][cols], int tempvar, int score);
template <size_t rows, size_t cols>
void drawBucket(char(&bucket)[rows][cols]); // Draws the current contents of the bucket.
template <size_t rows, size_t cols>
bool canEnter(int direction, char(&bucket)[rows][cols]); // Checks if the shape can enter the space it is trying to drop into.
int getUserInput(); // gets the key pressed from the user.
void setCursorTo(int x, int y);// Move the cursor to the appropriate position
int previousX = 6, previousY = 0;
int shapes[256];
template <size_t rows, size_t cols>
int check_bucket(char(&bucket)[rows][cols]);
template <size_t rows, size_t cols>
void set_bucket(char(&bucket)[rows][cols], char(&perm_bucket)[rows][cols]);
TetrisShape activeShape;
int main() {
// Two bucket arrays, one shown on the screen, the other with the permanent contents of the buckets (walls and any non-moving shapes)
char bucket[12][25];
int score = 0;
int tempvar = 0;
char _bucket[12][25];
int shapes[256] = {};
int shapeIndex = 0;
bool gameOver = false;
generateBucket(bucket);
generateBucket(_bucket);
generateShapeStream();
drawBucket(bucket);
while (!gameOver) {
gameOver = gameTick(bucket, _bucket);
Sleep(50);
checkScore(bucket, _bucket, tempvar, score);
cout << “Your Score is: ” << score << endl;
currentTick++;
}
setCursorTo(25, 6);
cout << “GAME OVER”;
system(“pause”);
}
void setCursorTo(int x, int y)
{
HANDLE handle;
COORD position;
handle = GetStdHandle(STD_OUTPUT_HANDLE);
position.X = x;
position.Y = y;
SetConsoleCursorPosition(handle, position);
}
/* generateBucket – takes a bucket array of any size and
* creates a semi-empty bucket, with a
* few random shapes in the bottom few lines. */
template <size_t rows, size_t cols>
void generateBucket(char(&bucket)[rows][cols]) {
for (int w = 0; w < 12; w++) {
for (int z = 0; z < 25; z++) {
if (((w == 0) || (w == 11)) && (z == 0)) { bucket[w][z] = ‘.’; }
else if (((w % 12 == 0) || (w % 12 == 11)) && ((z > 0) && (z < 24))) { bucket[w][z] = ‘|’; }
else if (((w == 0) || (w == 11)) && (z == 24)) { bucket[w][z] = ‘+’; }
else if (z == 24) { bucket[w][z] = ‘-‘; }
else { bucket[w][z] = ‘ ‘; }
}
}
}
/* generateShapeStream – generates a pre-determined list of
* shapes that will fall from the sky. */
void generateShapeStream() {
// Initialize the random number generator
srand(time(NULL));
for (int i = 0; i < 256; i++) {
shapes[i] = rand() % 6 + 1;
}
//cout << “In generate shape…” << endl;
}
/* drawBucket – draws the actual bucket on the screen
* including the currently dropping shape. */
template <size_t rows, size_t cols>
void drawBucket(char(&bucket)[rows][cols]) {
setCursorTo(0, 0);
for (int w = 0; w < 25; w++) {
for (int z = 0; z < 12; z++) {
cout << bucket[z][w];
}
cout << endl;
}
}
/* gameTick – this function does all of the different
* processessing that happens throughout
* the game.This also returns false to
* stop the main loop once gameover has
* been reached*/
template <size_t rows, size_t cols>
bool gameTick(char(&bucket)[rows][cols], char(&perm_bucket)[rows][cols]) {
drawBucket(bucket);
if (!isDropping) {
currentShape++;
activeShape = TetrisShape(shapes[currentShape]);
if (!canEnter(DIR_DOWN, perm_bucket)) {
return true;
}
else {
isDropping = true;
updateBucket(bucket, false);
}
}
else {
if (currentTick % GAME_INTERVAL == 1) {
// we are on a drop interval.
if (canEnter(DIR_DOWN, perm_bucket)) {
updateBucket(bucket, moveShape(DIR_DOWN));
}
else {
landShape(perm_bucket);
}
}
}
int direction = getUserInput();
if (canEnter(direction, perm_bucket)) {
updateBucket(bucket, moveShape(direction));
}
if (!canEnter(DIR_DOWN, perm_bucket)) {
landShape(perm_bucket);
set_bucket(bucket, perm_bucket);
}
return false;
}
/* moveShape – Handles moving the shape in the bucket. */
bool moveShape(int direction) {
previousX = activeShape.shapeTopLeftX;
previousY = activeShape.shapeTopLeftY;
switch (direction) {
case DIR_DOWN:
activeShape.shapeTopLeftY++;
return false;
break;
case DIR_RIGHT:
activeShape.shapeTopLeftX++;
return false;
break;
case DIR_LEFT:
activeShape.shapeTopLeftX–;
return false;
break;
case DIR_ROTATE:
activeShape.rotate();
return true;
break;
}
}
/* updateBucket – place the cureret shape in the bucket, remove the old shape*/
template <size_t rows, size_t cols>
void updateBucket(char(&bucket)[rows][cols], bool isRotation) {
for (int _x = 0; _x < 4; _x++) {
for (int _y = 0; _y < 4; _y++) {
if (!isRotation) {
if ((activeShape.shapeArray[_x][_y] != ‘ ‘) && (bucket[_x + previousX][_y + previousY] != ‘|’) && (bucket[_x + previousX][_y + previousY] != ‘-‘)) {
bucket[_x + previousX][_y + previousY] = ‘ ‘;
}
}
else {
if ((bucket[_x + previousX][_y + previousY] != ‘|’) && (bucket[_x + previousX][_y + previousY] != ‘-‘)) {
bucket[_x + previousX][_y + previousY] = ‘ ‘;
}
}
}
}
for (int _x = 0; _x < 4; _x++) {
for (int _y = 0; _y < 4; _y++) {
if (activeShape.shapeArray[_x][_y] != ‘ ‘) {
bucket[_x + activeShape.shapeTopLeftX][_y + activeShape.shapeTopLeftY] = activeShape.shapeArray[_x][_y];
}
}
}
}
/* landShape – Sets the shape in place once it hits the
bottom of the bucket. Moves the shape to the permanent bucket (_bucket)*/
template <size_t rows, size_t cols>
void landShape(char(&bucket)[rows][cols]) {
updateBucket(bucket, false);
previousX = 6; previousY = 0;
check_bucket(bucket);
isDropping = false;
}
template<size_t rows, size_t cols>
int checkScore(char(&bucket)[rows][cols], char(&perm_bucket)[rows][cols], int tempvar, int score)
{
for (int y = 0; y < 25; y++) {
int tmp_count = 0;
for (int x = 0; x < 13; x++) {
if (bucket[x][y] == ‘X’) {
tmp_count++;
}
}
if (tmp_count == 10) {
tempvar = 1;
if (tempvar == 1) {
score = score + 100;
return score;
}
}
}
}
/* getUserInput – Reads the user input from the player*/
int getUserInput() {
setCursorTo(35, 9);
if ((GetKeyState(VK_DOWN) != 0) && (GetKeyState(VK_DOWN) != 1)) { return DIR_DOWN; }
if ((GetKeyState(VK_RIGHT) != 0) && (GetKeyState(VK_RIGHT) != 1)) { return DIR_RIGHT; }
if ((GetKeyState(VK_LEFT) != 0) && (GetKeyState(VK_LEFT) != 1)) { return DIR_LEFT; }
if ((GetKeyState(VK_UP) != 0) && (GetKeyState(VK_UP) != 1)) { return DIR_ROTATE; }
return 0;
}
/* canRotate – if we are adjacent to another shape, then we CANNOT rotate */
template <size_t rows, size_t cols>
bool canRotate(char(&bucket)[rows][cols]) {
// The only real way to do this is to create a copy of the shape, rotate it, then try to determine where it will be in the bucket.
TetrisShape _tmp = TetrisShape(activeShape);
_tmp.rotate();
for (int _x = 0; _x < 4; _x++) {
for (int _y = 0; _y < 4; _y++) {
if (_tmp.shapeArray[_x][_y] != ‘ ‘) {
if (bucket[_tmp.shapeTopLeftX + _x][_tmp.shapeTopLeftY + _y] != ‘ ‘) {
return false;
}
}
}
}
return true;
}
/* canEnter – Tests to see if the falling blocks can
enter in any direction.*/
template <size_t rows, size_t cols>
bool canEnter(int dir, char(&bucket)[rows][cols]) {
// Check for collision with any elements of the shape array, and any elements of the bucket.
// Determine which direction we are moving.
int delta_x = 0, delta_y = 0;
switch (dir) {
case DIR_DOWN:
delta_y++;
break;
case DIR_LEFT:
delta_x–;
break;
case DIR_RIGHT:
delta_x++;
break;
case DIR_ROTATE:
return canRotate(bucket);
break;
}
// Create the starting {x, y} position to test for collsion
int test_x = activeShape.shapeTopLeftX + delta_x;
int test_y = activeShape.shapeTopLeftY + delta_y;
for (int _x = 0; _x < 4; _x++) {
for (int _y = 0; _y < 4; _y++) {
if (activeShape.shapeArray[_x][_y] != ‘ ‘) {
if (bucket[test_x + _x][test_y + _y] != ‘ ‘) {
return false;
}
}
}
}
return true;
}
template <size_t rows, size_t cols>
int checkScore(char(&bucket)[rows][cols], int tempvar, int score) {
for (int y = 0; y < 25; y++) {
int tmp_count = 0;
for (int x = 0; x < 13; x++) {
if (bucket[x][y] == ‘X’) {
tmp_count++;
}
}
if (tmp_count == 10) {
tempvar = 1;
if (tempvar == 1) {
score = score + 100;
return score;
}
for (int x = 1; x < 11; x++) {
for (int _y = y; _y > 0; _y–) {
bucket[x][_y] = bucket[x][_y – 1];
}
}
}
}
}
template <size_t rows, size_t cols>
void check_bucket(char(&bucket)[rows][cols]) {
for (int y = 0; y < 25; y++) {
int tmp_count = 0;
for (int x = 0; x < 13; x++) {
if (bucket[x][y] == ‘X’) {
tmp_count++;
}
}
if (tmp_count == 10) {
for (int x = 1; x < 11; x++) {
for (int _y = y; _y > 0; _y–) {
bucket[x][_y] = bucket[x][_y – 1];
}
}
}
}
}
template <size_t rows, size_t cols>
void set_bucket(char(&bucket)[rows][cols], char(&perm_bucket)[rows][cols]) {
for (int x = 0; x < 12; x++) {
for (int y = 0; y < 25; y++) {
bucket[x][y] = perm_bucket[x][y];
}
}
}
Our website has a team of professional writers who can help you write any of your homework. They will write your papers from scratch. We also have a team of editors just to make sure all papers are of HIGH QUALITY & PLAGIARISM FREE. To make an Order you only need to click Ask A Question and we will direct you to our Order Page at WriteDemy. Then fill Our Order Form with all your assignment instructions. Select your deadline and pay for your paper. You will get it few hours before your set deadline.
Fill in all the assignment paper details that are required in the order form with the standard information being the page count, deadline, academic level and type of paper. It is advisable to have this information at hand so that you can quickly fill in the necessary information needed in the form for the essay writer to be immediately assigned to your writing project. Make payment for the custom essay order to enable us to assign a suitable writer to your order. Payments are made through Paypal on a secured billing page. Finally, sit back and relax.
About Writedemy
We are a professional paper writing website. If you have searched a question and bumped into our website just know you are in the right place to get help in your coursework. We offer HIGH QUALITY & PLAGIARISM FREE Papers.
How It Works
To make an Order you only need to click on “Order Now” and we will direct you to our Order Page. Fill Our Order Form with all your assignment instructions. Select your deadline and pay for your paper. You will get it few hours before your set deadline.
Are there Discounts?
All new clients are eligible for 20% off in their first Order. Our payment method is safe and secure.