your input flovodoh

profilevazquez1012

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];

}

}

}

 

  • Posted: 3 years ago
  • Due: 
  • Budget: $5
Answers 2

Purchase the answer to view it

blurred-text

    Purchase the answer to view it

    blurred-text