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 Service Charter
-
Excellent Quality / 100% Plagiarism-Free
We employ a number of measures to ensure top quality essays. The papers go through a system of quality control prior to delivery. We run plagiarism checks on each paper to ensure that they will be 100% plagiarism-free. So, only clean copies hit customers’ emails. We also never resell the papers completed by our writers. So, once it is checked using a plagiarism checker, the paper will be unique. Speaking of the academic writing standards, we will stick to the assignment brief given by the customer and assign the perfect writer. By saying “the perfect writer” we mean the one having an academic degree in the customer’s study field and positive feedback from other customers. -
Free Revisions
We keep the quality bar of all papers high. But in case you need some extra brilliance to the paper, here’s what to do. First of all, you can choose a top writer. It means that we will assign an expert with a degree in your subject. And secondly, you can rely on our editing services. Our editors will revise your papers, checking whether or not they comply with high standards of academic writing. In addition, editing entails adjusting content if it’s off the topic, adding more sources, refining the language style, and making sure the referencing style is followed. -
Confidentiality / 100% No Disclosure
We make sure that clients’ personal data remains confidential and is not exploited for any purposes beyond those related to our services. We only ask you to provide us with the information that is required to produce the paper according to your writing needs. Please note that the payment info is protected as well. Feel free to refer to the support team for more information about our payment methods. The fact that you used our service is kept secret due to the advanced security standards. So, you can be sure that no one will find out that you got a paper from our writing service. -
Money Back Guarantee
If the writer doesn’t address all the questions on your assignment brief or the delivered paper appears to be off the topic, you can ask for a refund. Or, if it is applicable, you can opt in for free revision within 14-30 days, depending on your paper’s length. The revision or refund request should be sent within 14 days after delivery. The customer gets 100% money-back in case they haven't downloaded the paper. All approved refunds will be returned to the customer’s credit card or Bonus Balance in a form of store credit. Take a note that we will send an extra compensation if the customers goes with a store credit. -
24/7 Customer Support
We have a support team working 24/7 ready to give your issue concerning the order their immediate attention. If you have any questions about the ordering process, communication with the writer, payment options, feel free to join live chat. Be sure to get a fast response. They can also give you the exact price quote, taking into account the timing, desired academic level of the paper, and the number of pages.