ELEC2645 (2019/20) / Mbed 2 deprecated ELEC2645_Project_el18rs

All there but errors need fixing

Dependencies:   mbed

Overview:

Rookie Tetris is a jigsaw style game based on the classic Tetris.

A block will appear at the top of the screen, you must move it (your options for movement are left, right and down - you cannot move up the board). The block will stop when it if placed either on the floor of the board or on-top of another block.

Your goal is to fill a complete row of the board with the blocks; when you do so the row will delete and the pattern above it will drop down. The game is over when your pattern is tall enough to reach to the top of the board!

Controls:

Use the joystick to move your block! Your block cannot move out of the parameters of the board.

Pot 2 controls the contrast of the screen.

TetrisGame/TetrisGame.cpp@23:cbfa9d1ee3db, 2020-06-03 (annotated)

Committer:
el18rs
Date:
Wed Jun 03 19:52:59 2020 +0000
Revision:
23:cbfa9d1ee3db
Parent:
22:403759d2f093
Child:
24:8868a01f4a8c
line clears and screen drops down but jumps up and down alternate blocks

Who changed what in which revision?

UserRevisionLine numberNew contents of line
el18rs 3:522c6f850e91 1 #include "TetrisGame.h"
el18rs 3:522c6f850e91 2
el18rs 15:68114eae4053 3 volatile int iH;
el18rs 22:403759d2f093 4 volatile int iB;
el18rs 15:68114eae4053 5
el18rs 3:522c6f850e91 6 TetrisGame::TetrisGame()
el18rs 3:522c6f850e91 7 {
el18rs 15:68114eae4053 8
el18rs 3:522c6f850e91 9 }
el18rs 3:522c6f850e91 10
el18rs 3:522c6f850e91 11 TetrisGame::~TetrisGame()
el18rs 3:522c6f850e91 12 {
el18rs 15:68114eae4053 13
el18rs 3:522c6f850e91 14 }
el18rs 3:522c6f850e91 15
el18rs 11:0183a52c1077 16 void TetrisGame::init(int speed)
el18rs 3:522c6f850e91 17 {
el18rs 4:7ddd287a5d28 18 // initialise game parameters
el18rs 11:0183a52c1077 19 _px = 40;
el18rs 11:0183a52c1077 20 _py = 4;
el18rs 9:58103274b2ab 21 _speed = speed;
el18rs 15:68114eae4053 22
el18rs 19:2ad31dbd5d11 23 _tetromino.init(_px, _py); // puts tetromino in middle
el18rs 15:68114eae4053 24
el18rs 21:6d4dd906edde 25 // printf("initiate(%i)\n",_speed);
el18rs 15:68114eae4053 26
el18rs 3:522c6f850e91 27 }
el18rs 3:522c6f850e91 28
el18rs 4:7ddd287a5d28 29
el18rs 22:403759d2f093 30 void TetrisGame::read_input(Gamepad &pad) // read inputs
el18rs 3:522c6f850e91 31 {
el18rs 3:522c6f850e91 32 _d = pad.get_direction();
el18rs 4:7ddd287a5d28 33 _mag = pad.get_mag();
el18rs 3:522c6f850e91 34 }
el18rs 3:522c6f850e91 35
el18rs 21:6d4dd906edde 36 void TetrisGame::draw(N5110 &lcd) // draw elements in lcd buffer
el18rs 3:522c6f850e91 37 {
el18rs 15:68114eae4053 38
el18rs 19:2ad31dbd5d11 39
el18rs 19:2ad31dbd5d11 40 lcd.drawRect(19, 4, 42, HEIGHT - 4, FILL_TRANSPARENT);
el18rs 19:2ad31dbd5d11 41
el18rs 6:39cbec524483 42 _tetromino.draw(lcd);
el18rs 15:68114eae4053 43
el18rs 23:cbfa9d1ee3db 44 print_scores(lcd);
el18rs 23:cbfa9d1ee3db 45
el18rs 19:2ad31dbd5d11 46 // printf("draw (%i,%i)\n",_px,_py);
el18rs 15:68114eae4053 47
el18rs 3:522c6f850e91 48 }
el18rs 3:522c6f850e91 49
el18rs 22:403759d2f093 50 void TetrisGame::update(Gamepad &pad, N5110 &lcd) // update values
el18rs 3:522c6f850e91 51 {
el18rs 15:68114eae4053 52
el18rs 4:7ddd287a5d28 53 _tetromino.update(_d,_mag);
el18rs 15:68114eae4053 54
el18rs 21:6d4dd906edde 55 check_wall_collision(pad, lcd); // check if block has collided with the floor
el18rs 21:6d4dd906edde 56 check_tetromino_collisions(pad, lcd); // check if block has collided with an old block
el18rs 15:68114eae4053 57
el18rs 19:2ad31dbd5d11 58 // printf("update (%i,%i,%i)\n",_px,_py,_d);
el18rs 3:522c6f850e91 59 }
el18rs 4:7ddd287a5d28 60
el18rs 4:7ddd287a5d28 61
el18rs 21:6d4dd906edde 62 void TetrisGame::check_wall_collision(Gamepad &pad, N5110 &lcd) // check if block has hit floor
el18rs 3:522c6f850e91 63 {
el18rs 21:6d4dd906edde 64 Vector2D tetromino_pos = _tetromino.get_pos(); // get current positioning of block
el18rs 15:68114eae4053 65
el18rs 22:403759d2f093 66 if (tetromino_pos.y + 4 >= (HEIGHT-1) ) { // if bottom of block is on bottom boundary
el18rs 15:68114eae4053 67
el18rs 21:6d4dd906edde 68 tetromino_pos.y = (HEIGHT-1) - 4; // stop block
el18rs 15:68114eae4053 69
el18rs 22:403759d2f093 70 pad.tone(750.0,0.1); // play tone
el18rs 15:68114eae4053 71
el18rs 22:403759d2f093 72 cancel_line(lcd); // check if row is full
el18rs 15:68114eae4053 73
el18rs 15:68114eae4053 74 _tetromino.init(_px, _py); // drop new shame
el18rs 19:2ad31dbd5d11 75
el18rs 21:6d4dd906edde 76 a = tetromino_pos.x; // save positions to be drawn on next screen
el18rs 13:600a34a047ca 77 b = tetromino_pos.y;
el18rs 15:68114eae4053 78
el18rs 21:6d4dd906edde 79 floor_hit_flag = 1; // set flag so program knows to draw block on next screen
el18rs 22:403759d2f093 80
el18rs 22:403759d2f093 81 if (b <= 4) { // if pattern reaches top of screen
el18rs 22:403759d2f093 82 exit_game(lcd); // game over
el18rs 20:ad685b35a1a4 83 }
el18rs 15:68114eae4053 84
el18rs 23:cbfa9d1ee3db 85 // printf("floor hit!\n");
el18rs 15:68114eae4053 86
el18rs 4:7ddd287a5d28 87 }
el18rs 19:2ad31dbd5d11 88 // printf("wall collision\n");
el18rs 4:7ddd287a5d28 89 }
el18rs 4:7ddd287a5d28 90
el18rs 22:403759d2f093 91 void TetrisGame::check_tetromino_collisions(Gamepad &pad, N5110 &lcd) // check if block has old block beneath it
el18rs 5:53e021832adc 92 {
el18rs 21:6d4dd906edde 93 Vector2D tetromino_pos = _tetromino.get_pos(); // get current position of block
el18rs 5:53e021832adc 94
el18rs 5:53e021832adc 95 if (
el18rs 22:403759d2f093 96 (lcd.getPixel(tetromino_pos.x, tetromino_pos.y + 4) == 1) ||
el18rs 17:70d45e9e44a8 97 (lcd.getPixel(tetromino_pos.x + 1, tetromino_pos.y + 4) == 1) ||
el18rs 17:70d45e9e44a8 98 (lcd.getPixel(tetromino_pos.x + 2, tetromino_pos.y + 4) == 1) ||
el18rs 22:403759d2f093 99 (lcd.getPixel(tetromino_pos.x + 3, tetromino_pos.y + 4) == 1) // if any of the 4 pixels directly below the block are black
el18rs 5:53e021832adc 100 ) {
el18rs 15:68114eae4053 101
el18rs 22:403759d2f093 102 pad.tone(1000.0,0.1); // play tone
el18rs 21:6d4dd906edde 103 cancel_line(lcd); // check if row is full
el18rs 15:68114eae4053 104
el18rs 21:6d4dd906edde 105 _tetromino.init(_px, _py); // drop new block
el18rs 15:68114eae4053 106
el18rs 21:6d4dd906edde 107 a = tetromino_pos.x; // save positioning of old block
el18rs 16:fca1bbb06c44 108 b = tetromino_pos.y;
el18rs 16:fca1bbb06c44 109
el18rs 21:6d4dd906edde 110 floor_hit_flag = 1; // set flag so program knows to draw block on next screen
el18rs 22:403759d2f093 111
el18rs 22:403759d2f093 112 if (b <= 4) { // if pattern reaches top of screen
el18rs 22:403759d2f093 113 exit_game(lcd); // game over
el18rs 20:ad685b35a1a4 114 }
el18rs 15:68114eae4053 115
el18rs 23:cbfa9d1ee3db 116 // printf("blocks stacked!\n");
el18rs 19:2ad31dbd5d11 117 }
el18rs 19:2ad31dbd5d11 118 // printf("tetromino collision\n");
el18rs 5:53e021832adc 119 }
el18rs 6:39cbec524483 120
el18rs 22:403759d2f093 121 void TetrisGame::cancel_line(N5110 &lcd) // check if row is full, if it is then delete line and drop pattern down
el18rs 6:39cbec524483 122 {
el18rs 22:403759d2f093 123 for(int j=4; j<=46; j++) {
el18rs 20:ad685b35a1a4 124 for(int i=20; i<=60; i++) {
el18rs 21:6d4dd906edde 125 if (lcd.getPixel(i,j)==0) { // if the pixel is empty the counting stops and exits loop (row is not full)
el18rs 15:68114eae4053 126 count=0;
el18rs 23:cbfa9d1ee3db 127 // printf("line not full\n");
el18rs 15:68114eae4053 128 break;
el18rs 22:403759d2f093 129 } else if (lcd.getPixel(i,j)==1) { // if the pixel is full carries on counting
el18rs 15:68114eae4053 130 count ++;
el18rs 23:cbfa9d1ee3db 131 // printf("counting... count=%i\n",count);
el18rs 6:39cbec524483 132 }
el18rs 22:403759d2f093 133 if (count==48) { // if gets to end of line
el18rs 22:403759d2f093 134 count = 0;
el18rs 22:403759d2f093 135 printf("line full\n");
el18rs 22:403759d2f093 136 // lcd.drawRect(20,j,40,4,FILL_WHITE); // clear line
el18rs 22:403759d2f093 137 c = j;
el18rs 23:cbfa9d1ee3db 138 d = i;
el18rs 22:403759d2f093 139 clear_line_flag = 1;
el18rs 22:403759d2f093 140 floor_hit_flag = 0;
el18rs 23:cbfa9d1ee3db 141 // printf("line canceled!\n");
el18rs 22:403759d2f093 142 }
el18rs 15:68114eae4053 143 // score++;
el18rs 22:403759d2f093 144 // for(int x=20; x<=60; x++) {
el18rs 22:403759d2f093 145 // for(int y=j; y>=4; y--) {
el18rs 22:403759d2f093 146 // lcd.setPixel(x,y,false);
el18rs 22:403759d2f093 147 // lcd.setPixel(x,y+1); // sets pixel to the one above
el18rs 22:403759d2f093 148 // printf("line dropped!\n");
el18rs 22:403759d2f093 149 // }
el18rs 22:403759d2f093 150 // }
el18rs 6:39cbec524483 151 }
el18rs 15:68114eae4053 152 }
el18rs 23:cbfa9d1ee3db 153 // printf("cancel line\n");
el18rs 15:68114eae4053 154 }
el18rs 6:39cbec524483 155
el18rs 15:68114eae4053 156 void TetrisGame::exit_game(N5110 &lcd)
el18rs 15:68114eae4053 157 {
el18rs 15:68114eae4053 158 lcd.clear();
el18rs 23:cbfa9d1ee3db 159 lcd.printString(" GAME OVER \n",0, 3);
el18rs 15:68114eae4053 160 lcd.refresh();
el18rs 15:68114eae4053 161 wait(10);
el18rs 23:cbfa9d1ee3db 162 // printf("game over!\n");
el18rs 15:68114eae4053 163 lcd.clear();
el18rs 15:68114eae4053 164 lcd.printString(" press RESET ",0,6);
el18rs 15:68114eae4053 165 lcd.refresh();
el18rs 23:cbfa9d1ee3db 166 // printf("press reset!\n");
el18rs 15:68114eae4053 167 exit(1.0);
el18rs 15:68114eae4053 168 }
el18rs 15:68114eae4053 169
el18rs 15:68114eae4053 170 void TetrisGame::fallenblocks(N5110 &lcd, int iH)
el18rs 15:68114eae4053 171 {
el18rs 15:68114eae4053 172 for (int i=0; i<=iH; i++) {
el18rs 15:68114eae4053 173 x0 = X[i];
el18rs 15:68114eae4053 174 y0 = Y[i];
el18rs 16:fca1bbb06c44 175 lcd.drawRect(x0, y0, 4, 4, FILL_BLACK);
el18rs 19:2ad31dbd5d11 176 // printf("block drawn\n");
el18rs 15:68114eae4053 177 }
el18rs 22:403759d2f093 178 }
el18rs 22:403759d2f093 179
el18rs 23:cbfa9d1ee3db 180 void TetrisGame::currentscreen(N5110 &lcd)
el18rs 23:cbfa9d1ee3db 181 {
el18rs 23:cbfa9d1ee3db 182 for (int i=0; i<=83; i++) {
el18rs 23:cbfa9d1ee3db 183 for (int j=0; j<=47; j++) {
el18rs 23:cbfa9d1ee3db 184 if(lcd.getPixel(i,j)) { //if pixel is set
el18rs 23:cbfa9d1ee3db 185 buffer[i][j] = 1;
el18rs 23:cbfa9d1ee3db 186 } else { // pixel is clear
el18rs 23:cbfa9d1ee3db 187 buffer[i][j] = 0;
el18rs 23:cbfa9d1ee3db 188 }
el18rs 23:cbfa9d1ee3db 189 }
el18rs 23:cbfa9d1ee3db 190 }
el18rs 23:cbfa9d1ee3db 191 }
el18rs 23:cbfa9d1ee3db 192
el18rs 23:cbfa9d1ee3db 193 void TetrisGame::clearline(N5110 &lcd, int iB)
el18rs 22:403759d2f093 194 {
el18rs 22:403759d2f093 195 for (int i=0; i<=iB; i++) {
el18rs 22:403759d2f093 196 z0 = Z[i];
el18rs 23:cbfa9d1ee3db 197 q0 = Q[i];
el18rs 22:403759d2f093 198 lcd.drawRect(20, z0, 40, 4, FILL_WHITE);
el18rs 22:403759d2f093 199 }
el18rs 23:cbfa9d1ee3db 200 currentscreen(lcd);
el18rs 23:cbfa9d1ee3db 201 for (int x=20; x<=60; x++) {
el18rs 23:cbfa9d1ee3db 202 for (int y=c; y>=0; y--) {
el18rs 23:cbfa9d1ee3db 203 if (buffer[x][y]) {
el18rs 23:cbfa9d1ee3db 204 lcd.setPixel(x,y, false);
el18rs 23:cbfa9d1ee3db 205 lcd.setPixel(x,y+4);
el18rs 23:cbfa9d1ee3db 206 }
el18rs 23:cbfa9d1ee3db 207 }
el18rs 23:cbfa9d1ee3db 208 }
el18rs 23:cbfa9d1ee3db 209 }
el18rs 23:cbfa9d1ee3db 210
el18rs 23:cbfa9d1ee3db 211 void TetrisGame::print_scores(N5110 &lcd)
el18rs 23:cbfa9d1ee3db 212 {
el18rs 23:cbfa9d1ee3db 213 char buffer[15];
el18rs 23:cbfa9d1ee3db 214 sprintf(buffer,"%d",_score);
el18rs 23:cbfa9d1ee3db 215 lcd.printString(buffer, WIDTH - 20, 10);
el18rs 23:cbfa9d1ee3db 216 }
el18rs 23:cbfa9d1ee3db 217
el18rs 23:cbfa9d1ee3db 218 void TetrisGame::check_score(Gamepad &pad)
el18rs 23:cbfa9d1ee3db 219 {
el18rs 23:cbfa9d1ee3db 220 if ( clear_line_flag == 1) {
el18rs 23:cbfa9d1ee3db 221 _score+=10;
el18rs 23:cbfa9d1ee3db 222 }
el18rs 15:68114eae4053 223 }