Ahmed Adamjee / Mbed 2 deprecated SnakeVSBlock

Snake vs Block Game to be run upon K64F.

Dependencies:   mbed

GameEngine/SnakevsBlock/SnakevsBlock.cpp@83:329da564799a, 2019-05-06 (annotated)

Committer:
AhmedPlaymaker
Date:
Mon May 06 14:28:35 2019 +0000
Revision:
83:329da564799a
Parent:
82:c51ae8a501d1
Child:
84:9950d561fdf8
Now, I have put gamepad and lcd objects from the main() in a pointer, so that i can declare them in init() in every class i use them in and use them as global objects for each class, without having to send their addresses to all of the functions.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
AhmedPlaymaker 7:48ba87cd79b5 1 #include "SnakevsBlock.h"
AhmedPlaymaker 7:48ba87cd79b5 2
AhmedPlaymaker 7:48ba87cd79b5 3 SnakevsBlock::SnakevsBlock()
AhmedPlaymaker 7:48ba87cd79b5 4 {
AhmedPlaymaker 7:48ba87cd79b5 5
AhmedPlaymaker 7:48ba87cd79b5 6 }
AhmedPlaymaker 7:48ba87cd79b5 7
AhmedPlaymaker 7:48ba87cd79b5 8 SnakevsBlock::~SnakevsBlock()
AhmedPlaymaker 7:48ba87cd79b5 9 {
AhmedPlaymaker 7:48ba87cd79b5 10
AhmedPlaymaker 7:48ba87cd79b5 11 }
AhmedPlaymaker 7:48ba87cd79b5 12
AhmedPlaymaker 83:329da564799a 13 void SnakevsBlock::init(N5110 *lcd, Gamepad *pad)
AhmedPlaymaker 7:48ba87cd79b5 14 {
AhmedPlaymaker 83:329da564799a 15 _lcd = lcd;
AhmedPlaymaker 83:329da564799a 16 _pad = pad;
AhmedPlaymaker 67:39b9ba6019b0 17 SnakevsBlock::object_initialisations();
AhmedPlaymaker 83:329da564799a 18 _length = _l._getLength(); //saves the snake length into a private variable.
AhmedPlaymaker 83:329da564799a 19 _s._setLength(_length);
AhmedPlaymaker 41:4edac50f010d 20 //The level initialisation and all the other initial information passing will be done here
AhmedPlaymaker 19:05cc9f801468 21 level = 1;
AhmedPlaymaker 59:c65a2e933c47 22 _maxLength = 10; // this makes us go to the next level if if maxLength is achieved;
AhmedPlaymaker 41:4edac50f010d 23 garbage = 0; //this is to allow the user to change the position of reference for motion control by saving the absolute angle.
AhmedPlaymaker 64:540aa1602372 24 _dropbuff = 0; //this makes the food fall at diffrent times when a particular level starts.
AhmedPlaymaker 56:142e9fdb77a8 25 send_block_number = 0; //this is 0 when there is no collision, thus block number isn't remembered for next set (which would lead to empty blocks).
AhmedPlaymaker 59:c65a2e933c47 26 blockgap = 300; //this is the number of itterations the block will reccur after in the first level.
AhmedPlaymaker 70:7caab8069b9b 27
AhmedPlaymaker 74:7b6568bc16d5 28 //To make default motion of the snake free.
AhmedPlaymaker 71:4bd2b27693f3 29 for(int i=0; i<=9; i++) {
AhmedPlaymaker 70:7caab8069b9b 30 b[i] = 1;
AhmedPlaymaker 62:ebf6ecf8a6d5 31 }
AhmedPlaymaker 7:48ba87cd79b5 32 }
AhmedPlaymaker 7:48ba87cd79b5 33
AhmedPlaymaker 41:4edac50f010d 34 void SnakevsBlock::reset()
AhmedPlaymaker 41:4edac50f010d 35 {
AhmedPlaymaker 67:39b9ba6019b0 36 SnakevsBlock::object_initialisations();
AhmedPlaymaker 41:4edac50f010d 37 //This prepares the game for the next level by reseting certain variables.
AhmedPlaymaker 64:540aa1602372 38 _dropbuff = 0;
AhmedPlaymaker 67:39b9ba6019b0 39 if(blockgap >= 60) {
AhmedPlaymaker 62:ebf6ecf8a6d5 40 blockgap -= 10; //to make progressive levels harder by making the blocks drop more frequently.
AhmedPlaymaker 62:ebf6ecf8a6d5 41 }
AhmedPlaymaker 74:7b6568bc16d5 42 //To make default motion of the snake free.
AhmedPlaymaker 74:7b6568bc16d5 43 for(int i=0; i<=9; i++) {
AhmedPlaymaker 74:7b6568bc16d5 44 b[i] = 1;
AhmedPlaymaker 74:7b6568bc16d5 45 }
AhmedPlaymaker 49:441c32f6603e 46 }
AhmedPlaymaker 49:441c32f6603e 47
AhmedPlaymaker 49:441c32f6603e 48 void SnakevsBlock::object_initialisations()
AhmedPlaymaker 49:441c32f6603e 49 {
AhmedPlaymaker 83:329da564799a 50 _wl.init(_lcd, _pad); //Win Loose Object initialisation.
AhmedPlaymaker 83:329da564799a 51 _l.init(_lcd); //length calc object initialisation.
AhmedPlaymaker 83:329da564799a 52 _s.init(_lcd); //snake object initialisation.
AhmedPlaymaker 83:329da564799a 53 _f.init(_lcd); //food 1 object initialisation.
AhmedPlaymaker 83:329da564799a 54 _ff.init(_lcd); //food 2 object initialisation.
AhmedPlaymaker 83:329da564799a 55 _fff.init(_lcd); //food 3 object initialisation.
AhmedPlaymaker 83:329da564799a 56 _b.init(_lcd); //block object initialisation.
AhmedPlaymaker 83:329da564799a 57 _barA.init(_lcd); //barrier A object initialisation.
AhmedPlaymaker 83:329da564799a 58 _barB.init(_lcd); //barrier B object initialisation.
AhmedPlaymaker 41:4edac50f010d 59 }
AhmedPlaymaker 7:48ba87cd79b5 60
AhmedPlaymaker 83:329da564799a 61 void SnakevsBlock::read_input(FXOS8700CQ &device, int g_mode)
AhmedPlaymaker 7:48ba87cd79b5 62 {
AhmedPlaymaker 83:329da564799a 63 SnakevsBlock::calculateTilt(device);
AhmedPlaymaker 63:205f0ca48473 64
AhmedPlaymaker 56:142e9fdb77a8 65 switch (g_mode) {
AhmedPlaymaker 62:ebf6ecf8a6d5 66 case 1:
AhmedPlaymaker 83:329da564799a 67 _d = _pad->get_direction(); //Obtains Direction pushed towards on Joystick.
AhmedPlaymaker 62:ebf6ecf8a6d5 68 break;
AhmedPlaymaker 62:ebf6ecf8a6d5 69 case 2:
AhmedPlaymaker 80:51ca38c5dcdf 70 if (_tiltAngle >= 5) {
AhmedPlaymaker 62:ebf6ecf8a6d5 71 _d = E;
AhmedPlaymaker 80:51ca38c5dcdf 72 } else if (_tiltAngle <= -5) {
AhmedPlaymaker 62:ebf6ecf8a6d5 73 _d = W;
AhmedPlaymaker 62:ebf6ecf8a6d5 74 } else {
AhmedPlaymaker 62:ebf6ecf8a6d5 75 _d = CENTRE;
AhmedPlaymaker 62:ebf6ecf8a6d5 76 }
AhmedPlaymaker 62:ebf6ecf8a6d5 77 break;
AhmedPlaymaker 38:30e4e6191762 78 }
AhmedPlaymaker 83:329da564799a 79 SnakevsBlock::lightTheLEDS(); //This function ligths the LEDS dependent on the direction of travel.
AhmedPlaymaker 38:30e4e6191762 80 //printf("%d",gm);
AhmedPlaymaker 63:205f0ca48473 81 //printf("%f",_tiltAngle);
AhmedPlaymaker 63:205f0ca48473 82 //printf("%f",device.get_roll_angle());
AhmedPlaymaker 63:205f0ca48473 83 }
AhmedPlaymaker 63:205f0ca48473 84
AhmedPlaymaker 83:329da564799a 85 void SnakevsBlock::calculateTilt(FXOS8700CQ &device) //this just reads the angle of tilt required for motion contol and also resets it if A is pressed.
AhmedPlaymaker 63:205f0ca48473 86 {
AhmedPlaymaker 63:205f0ca48473 87 device.get_values();
AhmedPlaymaker 63:205f0ca48473 88 _tiltAngle = -device.get_roll_angle();
AhmedPlaymaker 63:205f0ca48473 89 //if button A is pressed then reset that particular position to center
AhmedPlaymaker 83:329da564799a 90 if (_pad->check_event(Gamepad::A_PRESSED) == true) {
AhmedPlaymaker 63:205f0ca48473 91 garbage = _tiltAngle;
AhmedPlaymaker 63:205f0ca48473 92 }
AhmedPlaymaker 63:205f0ca48473 93 _tiltAngle = -device.get_roll_angle() - garbage;
AhmedPlaymaker 63:205f0ca48473 94
AhmedPlaymaker 63:205f0ca48473 95 //device.get_values();
AhmedPlaymaker 63:205f0ca48473 96 //printf("%f",_tiltAngle);
AhmedPlaymaker 38:30e4e6191762 97 //printf("%f",device.get_roll_angle());
AhmedPlaymaker 7:48ba87cd79b5 98 }
AhmedPlaymaker 7:48ba87cd79b5 99
AhmedPlaymaker 83:329da564799a 100 void SnakevsBlock::lightTheLEDS() //This function ligths the LEDS dependent on the direction of travel.
AhmedPlaymaker 63:205f0ca48473 101 {
AhmedPlaymaker 63:205f0ca48473 102 if (_d == E) {
AhmedPlaymaker 63:205f0ca48473 103 for(int led = 4; led <= 6; led++) {
AhmedPlaymaker 83:329da564799a 104 _pad->led(led,1);
AhmedPlaymaker 63:205f0ca48473 105 }
AhmedPlaymaker 63:205f0ca48473 106 } else if (_d == W) {
AhmedPlaymaker 63:205f0ca48473 107 for(int led = 1; led <= 3; led++) {
AhmedPlaymaker 83:329da564799a 108 _pad->led(led,1);
AhmedPlaymaker 63:205f0ca48473 109 }
AhmedPlaymaker 63:205f0ca48473 110 } else {
AhmedPlaymaker 63:205f0ca48473 111 for(int led = 1; led <= 6; led++) {
AhmedPlaymaker 83:329da564799a 112 _pad->led(led,0);
AhmedPlaymaker 63:205f0ca48473 113 }
AhmedPlaymaker 63:205f0ca48473 114 }
AhmedPlaymaker 63:205f0ca48473 115 }
AhmedPlaymaker 63:205f0ca48473 116
AhmedPlaymaker 83:329da564799a 117 void SnakevsBlock::draw()
AhmedPlaymaker 62:ebf6ecf8a6d5 118 {
AhmedPlaymaker 83:329da564799a 119 _s.draw(); //Draws the Snake and sends the value of length to the snake class, which is capped at 10.
AhmedPlaymaker 64:540aa1602372 120 if(_dropbuff >= 0) {
AhmedPlaymaker 83:329da564799a 121 _f.draw(); //Draws the first food after a loop delay of 0.
AhmedPlaymaker 39:210ac915e0a0 122 }
AhmedPlaymaker 64:540aa1602372 123 if(_dropbuff >= 50) {
AhmedPlaymaker 83:329da564799a 124 _ff.draw(); //Draws the first food after a loop delay of 50.
AhmedPlaymaker 9:d1d79d4ee673 125 }
AhmedPlaymaker 64:540aa1602372 126 if(_dropbuff >= 80) {
AhmedPlaymaker 83:329da564799a 127 _fff.draw(); //Draws the first food after a loop delay of 80.
AhmedPlaymaker 39:210ac915e0a0 128 }
AhmedPlaymaker 81:4c1641e10dcd 129 if(_dropbuff >= 22) {
AhmedPlaymaker 83:329da564799a 130 _barA.draw(b_pos.y); //Draws the first set of blocks after a loop delay of 8.
AhmedPlaymaker 81:4c1641e10dcd 131 }
AhmedPlaymaker 81:4c1641e10dcd 132 if(_dropbuff >= 40) {
AhmedPlaymaker 83:329da564799a 133 _barB.draw(b_pos.y); //Draws the first set of blocks after a loop delay of 8.
AhmedPlaymaker 81:4c1641e10dcd 134 }
AhmedPlaymaker 79:35cb65c52d25 135 if(_dropbuff >= 8) {
AhmedPlaymaker 83:329da564799a 136 _b.draw(_length); //Draws the first set of blocks after a loop delay of 8.
AhmedPlaymaker 79:35cb65c52d25 137 }
AhmedPlaymaker 64:540aa1602372 138 _dropbuff +=1;
AhmedPlaymaker 79:35cb65c52d25 139 //Code to print length of snake on nokia screen.
AhmedPlaymaker 83:329da564799a 140 _l.print_length_on_screen();
AhmedPlaymaker 62:ebf6ecf8a6d5 141 }
AhmedPlaymaker 39:210ac915e0a0 142
AhmedPlaymaker 83:329da564799a 143 void SnakevsBlock::update() //Updates objects on screen.
AhmedPlaymaker 39:210ac915e0a0 144 {
AhmedPlaymaker 83:329da564799a 145 _length = _l._getLength(); //saves the snake length into a private variable.
AhmedPlaymaker 83:329da564799a 146 _s._setLength(_length);
AhmedPlaymaker 77:5c6bd659c32d 147 SnakevsBlock::MakeDefaultMotionFree(); //this makes the default motion of the snake freemoving before a collision is checked for, to forget the previous collision.
AhmedPlaymaker 76:7fa91122907f 148 send_block_number = 0; //this is for the game to decide wether to send the number on the block for the current itteration to the blaocks class.
AhmedPlaymaker 76:7fa91122907f 149 //we dont need to remember if it has already gone past the screen. The saved number in this changes if the snake collides with the block in CheckSnakeBlockCollision.
AhmedPlaymaker 83:329da564799a 150
AhmedPlaymaker 83:329da564799a 151 SnakevsBlock::makeVirtualLengthMaxTen(); //stops the length at 10 for collision and drawing purposes.
AhmedPlaymaker 83:329da564799a 152
AhmedPlaymaker 83:329da564799a 153 SnakevsBlock::CheckSnakeFoodCollision(); //Function checks for when the snake collides with it's food.
AhmedPlaymaker 83:329da564799a 154 SnakevsBlock::CheckSnakeBlockCollision(); //Function checks for when the snake collides with any of the blocks.
AhmedPlaymaker 83:329da564799a 155 SnakevsBlock::CheckSnakeBlockSidesCollision(); //Function checks for when the snake collides with any of the blocks' sides.
AhmedPlaymaker 83:329da564799a 156 SnakevsBlock::CheckSnakeBarrierCollision(0); //Function checks for when the snake collides with barrier A.
AhmedPlaymaker 83:329da564799a 157 SnakevsBlock::CheckSnakeBarrierCollision(1); //Function checks for when the snake collides with barrier B.
AhmedPlaymaker 83:329da564799a 158
AhmedPlaymaker 41:4edac50f010d 159 _s.update(_d, b); //_d is the direction of joystick and b controls the motion of a section of the snake relative to obstruction
AhmedPlaymaker 9:d1d79d4ee673 160 _f.update();
AhmedPlaymaker 9:d1d79d4ee673 161 _ff.update();
AhmedPlaymaker 62:ebf6ecf8a6d5 162 _fff.update();
AhmedPlaymaker 48:d774bb162c61 163 _b.update(blocknum, blockgap, srn, send_block_number);
AhmedPlaymaker 81:4c1641e10dcd 164 _barA.update(blockgap);
AhmedPlaymaker 81:4c1641e10dcd 165 _barB.update(blockgap);
AhmedPlaymaker 63:205f0ca48473 166
AhmedPlaymaker 63:205f0ca48473 167 }
AhmedPlaymaker 63:205f0ca48473 168
AhmedPlaymaker 83:329da564799a 169 int SnakevsBlock::CheckGameProgression(SDFileSystem &sd)
AhmedPlaymaker 63:205f0ca48473 170 {
AhmedPlaymaker 63:205f0ca48473 171 //Function handles level progression and level failure operations by using the class WinLoose.
AhmedPlaymaker 49:441c32f6603e 172 if(_length == 0) {
AhmedPlaymaker 83:329da564799a 173 _wl.GameOver();
AhmedPlaymaker 49:441c32f6603e 174 }
AhmedPlaymaker 83:329da564799a 175 if((_pad->check_event(Gamepad::BACK_PRESSED))||(_length == 0)) { //Waits for Back button to be pressed or the length to reach 0.
AhmedPlaymaker 25:e827f1a8fadc 176 back = 1;
AhmedPlaymaker 83:329da564799a 177 SnakevsBlock::init(_lcd, _pad);
AhmedPlaymaker 62:ebf6ecf8a6d5 178 } else {
AhmedPlaymaker 25:e827f1a8fadc 179 back = 0;
AhmedPlaymaker 25:e827f1a8fadc 180 }
AhmedPlaymaker 52:c2faa96cf293 181 //printf("%d\n",_length);
AhmedPlaymaker 59:c65a2e933c47 182 if(_length >= _maxLength) {
AhmedPlaymaker 59:c65a2e933c47 183 _maxLength++;
AhmedPlaymaker 83:329da564799a 184 level = _wl.LevelComplete(level);
AhmedPlaymaker 50:3cf9a94a264e 185 _Setstats.write(level, sd);
AhmedPlaymaker 63:205f0ca48473 186 //_statset.read(sd); //to read the currently stored value.
AhmedPlaymaker 63:205f0ca48473 187 SnakevsBlock::reset(); //reset prepares the game for the next level.
AhmedPlaymaker 50:3cf9a94a264e 188 }
AhmedPlaymaker 63:205f0ca48473 189 //_statset.read(sd); //to read the currently stored value.
AhmedPlaymaker 25:e827f1a8fadc 190 return back;
AhmedPlaymaker 7:48ba87cd79b5 191 }
AhmedPlaymaker 7:48ba87cd79b5 192
AhmedPlaymaker 7:48ba87cd79b5 193 void SnakevsBlock::get_pos()
AhmedPlaymaker 7:48ba87cd79b5 194 {
AhmedPlaymaker 7:48ba87cd79b5 195 //printf("player pos = %f %f \n", player_pos.x, player_pos.y); //top left of player sprite
AhmedPlaymaker 7:48ba87cd79b5 196 // 81.000000 0.000000 top right
AhmedPlaymaker 7:48ba87cd79b5 197 // 0.000000 0.000000 is top left
AhmedPlaymaker 7:48ba87cd79b5 198 // 81.000000 45.000000 bottom right
AhmedPlaymaker 70:7caab8069b9b 199 snakex = _s.get_pos(0).x; //this could be snake_pos[0].x or simply snake_pos[0] to represent both x&y but as it is used the most, it improves readability.
AhmedPlaymaker 70:7caab8069b9b 200 snakey = _s.get_pos(0).y; //this could be snake_pos[0].y or simply snake_pos[0] to represent both x&y but as it is used the most, it improves readability.
AhmedPlaymaker 7:48ba87cd79b5 201 //printf("snakexy in GAME = %d %d \n", snakex, snakey);
AhmedPlaymaker 41:4edac50f010d 202 //Obtains all required coordinates.
AhmedPlaymaker 41:4edac50f010d 203 food_pos[0] = _f.get_pos();
AhmedPlaymaker 41:4edac50f010d 204 food_pos[1] = _ff.get_pos();
AhmedPlaymaker 41:4edac50f010d 205 food_pos[2] = _fff.get_pos();
AhmedPlaymaker 41:4edac50f010d 206 //obtains origin cordinates of block.
AhmedPlaymaker 41:4edac50f010d 207 b_pos = _b.get_pos();
AhmedPlaymaker 41:4edac50f010d 208 //this saves the positions of each snake beed (the first to the last) in a single array. Element[0] is the top beed and soo on.
AhmedPlaymaker 71:4bd2b27693f3 209 for(int i = 0; i <= 9; i++) {
AhmedPlaymaker 71:4bd2b27693f3 210 snake_pos[i] = _s.get_pos(i); //gets the position of the each beed from the snake class and saves in array.
AhmedPlaymaker 71:4bd2b27693f3 211 }
AhmedPlaymaker 82:c51ae8a501d1 212 bar_pos[0] = _barA.get_pos(); //gets the position of the barrier A's origin from barriers class and saves in array.
AhmedPlaymaker 82:c51ae8a501d1 213 bar_pos[1] = _barB.get_pos(); //gets the position of the barrier B's origin from barriers class and saves in array.
AhmedPlaymaker 62:ebf6ecf8a6d5 214 }
AhmedPlaymaker 62:ebf6ecf8a6d5 215
AhmedPlaymaker 9:d1d79d4ee673 216
AhmedPlaymaker 83:329da564799a 217 void SnakevsBlock::CheckSnakeFoodCollision()
AhmedPlaymaker 62:ebf6ecf8a6d5 218 {
AhmedPlaymaker 32:3a3bdeffdf62 219 //If statements check if the snake sprite has collided with any
AhmedPlaymaker 32:3a3bdeffdf62 220 //of the three food sprites, if so then the food location is reset and
AhmedPlaymaker 32:3a3bdeffdf62 221 //length of the snake is increased using the length variable.
AhmedPlaymaker 65:2872ca289b49 222
AhmedPlaymaker 79:35cb65c52d25 223 for(int food_sr=0; food_sr<=2; food_sr++) { //this loop runs 3 times to detect collision with all the three food objects.
AhmedPlaymaker 83:329da564799a 224 SnakevsBlock::CheckSnakeFoodYCollision(food_sr);
AhmedPlaymaker 79:35cb65c52d25 225 }
AhmedPlaymaker 65:2872ca289b49 226
AhmedPlaymaker 29:c6358c39a70e 227 _f.set_pos(food_pos[0]);
AhmedPlaymaker 29:c6358c39a70e 228 _ff.set_pos(food_pos[1]);
AhmedPlaymaker 29:c6358c39a70e 229 _fff.set_pos(food_pos[2]);
AhmedPlaymaker 29:c6358c39a70e 230 }
AhmedPlaymaker 62:ebf6ecf8a6d5 231
AhmedPlaymaker 83:329da564799a 232 void SnakevsBlock::CheckSnakeFoodYCollision(int food_sr)
AhmedPlaymaker 65:2872ca289b49 233 {
AhmedPlaymaker 79:35cb65c52d25 234 for(int y=0; y<=2; y++) { //this loop automatically detects for each collision of food and snake in the y axis.
AhmedPlaymaker 65:2872ca289b49 235
AhmedPlaymaker 79:35cb65c52d25 236 if(
AhmedPlaymaker 79:35cb65c52d25 237 ((snakey + y == food_pos[food_sr].y) ||
AhmedPlaymaker 79:35cb65c52d25 238 (snakey + y == food_pos[food_sr].y + 1) ||
AhmedPlaymaker 79:35cb65c52d25 239 (snakey + y == food_pos[food_sr].y + 2))
AhmedPlaymaker 79:35cb65c52d25 240 ) {
AhmedPlaymaker 83:329da564799a 241 SnakevsBlock::CheckSnakeFoodXCollision(food_sr); //checks X collision only if Y collisison satisfies.
AhmedPlaymaker 79:35cb65c52d25 242 }
AhmedPlaymaker 65:2872ca289b49 243 }
AhmedPlaymaker 65:2872ca289b49 244
AhmedPlaymaker 65:2872ca289b49 245 }
AhmedPlaymaker 65:2872ca289b49 246
AhmedPlaymaker 83:329da564799a 247 void SnakevsBlock::CheckSnakeFoodXCollision(int food_sr)
AhmedPlaymaker 65:2872ca289b49 248 {
AhmedPlaymaker 79:35cb65c52d25 249
AhmedPlaymaker 79:35cb65c52d25 250 for(int x=0; x<=2; x++) { //this loop automatically detects for each collision of food and snake in the x axis.
AhmedPlaymaker 79:35cb65c52d25 251 if(
AhmedPlaymaker 65:2872ca289b49 252 ((snakex + x == food_pos[food_sr].x) ||
AhmedPlaymaker 65:2872ca289b49 253 (snakex + x == food_pos[food_sr].x + 1) ||
AhmedPlaymaker 65:2872ca289b49 254 (snakex + x == food_pos[food_sr].x + 2))
AhmedPlaymaker 65:2872ca289b49 255 ) {
AhmedPlaymaker 83:329da564799a 256 SnakevsBlock::ImplementSnakeFoodCollision(food_sr);
AhmedPlaymaker 65:2872ca289b49 257 }
AhmedPlaymaker 79:35cb65c52d25 258
AhmedPlaymaker 65:2872ca289b49 259 }
AhmedPlaymaker 65:2872ca289b49 260
AhmedPlaymaker 65:2872ca289b49 261 }
AhmedPlaymaker 65:2872ca289b49 262
AhmedPlaymaker 83:329da564799a 263 void SnakevsBlock::ImplementSnakeFoodCollision(int food_sr)
AhmedPlaymaker 79:35cb65c52d25 264 {
AhmedPlaymaker 79:35cb65c52d25 265 //printf("snake feast working \n");
AhmedPlaymaker 79:35cb65c52d25 266 //audio feedback
AhmedPlaymaker 83:329da564799a 267 _pad->tone(786.0,0.1);
AhmedPlaymaker 79:35cb65c52d25 268 _l.PlusLength();
AhmedPlaymaker 79:35cb65c52d25 269
AhmedPlaymaker 79:35cb65c52d25 270 ////////////RESET FOOD POSITION////////////
AhmedPlaymaker 79:35cb65c52d25 271 food_pos[food_sr].x = (rand() % 82); //this makes the food pop up at a random, unspecified location in the x axis.
AhmedPlaymaker 79:35cb65c52d25 272 food_pos[food_sr].y = -3;
AhmedPlaymaker 79:35cb65c52d25 273
AhmedPlaymaker 79:35cb65c52d25 274 }
AhmedPlaymaker 79:35cb65c52d25 275
AhmedPlaymaker 83:329da564799a 276 void SnakevsBlock::CheckSnakeBlockCollision()
AhmedPlaymaker 62:ebf6ecf8a6d5 277 {
AhmedPlaymaker 41:4edac50f010d 278 //Obtains the numbers inside the block.
AhmedPlaymaker 39:210ac915e0a0 279 b_number = _b.get_number();
AhmedPlaymaker 39:210ac915e0a0 280 //If statements check if the snake sprite has collided with any
AhmedPlaymaker 39:210ac915e0a0 281 //of the blocks which are a maximum of 5, if so then the snake length reduces and the block number reduces
AhmedPlaymaker 39:210ac915e0a0 282 //the block has to move slower and come down after every 2/3 iterations(dependent on the snake size.(think about this)
AhmedPlaymaker 39:210ac915e0a0 283 for(int block=0; block<=83; block+=1) { //this loop automatically detects for each section of block and each combination of collision
AhmedPlaymaker 54:20abd16c7d74 284 if (((snakey == b_pos.y + 11)||
AhmedPlaymaker 62:ebf6ecf8a6d5 285 (snakey == b_pos.y + 10)||
AhmedPlaymaker 62:ebf6ecf8a6d5 286 (snakey == b_pos.y + 9)||
AhmedPlaymaker 62:ebf6ecf8a6d5 287 (snakey == b_pos.y + 8))&&
AhmedPlaymaker 62:ebf6ecf8a6d5 288 (snakex + 1 == b_pos.x + block)) {
AhmedPlaymaker 43:233f93860d08 289 //the or for the block's y position is due to the fact the exact y co-ordinate might not be collided if the snake's length has increased in the same itteration.
AhmedPlaymaker 39:210ac915e0a0 290 //printf("snake collision working \n");
AhmedPlaymaker 39:210ac915e0a0 291 //audio feedback
AhmedPlaymaker 39:210ac915e0a0 292 srn = CheckBlock(block); //this tells us which of the 5 blocks we are colliding with
AhmedPlaymaker 63:205f0ca48473 293 blocknum = b_number[srn]; //this saves the number inside the colliding block into blocknum.
AhmedPlaymaker 83:329da564799a 294 ImplementSnakeBlockCollision(); //this implements the collision once the conditions are met.
AhmedPlaymaker 65:2872ca289b49 295 SnakevsBlock::_setVelocity(srn); //sets the block and foods free or frezes them depending on snake length.
AhmedPlaymaker 12:1e601b176437 296 }
AhmedPlaymaker 39:210ac915e0a0 297 }
AhmedPlaymaker 39:210ac915e0a0 298 }
AhmedPlaymaker 62:ebf6ecf8a6d5 299
AhmedPlaymaker 65:2872ca289b49 300 void SnakevsBlock::_setVelocity(int srn)
AhmedPlaymaker 62:ebf6ecf8a6d5 301 {
AhmedPlaymaker 65:2872ca289b49 302 if((_length>=10)&&(b_number[srn]>0)) { //this makes the block stop moving down if it's length is more than 10 and still collides.
AhmedPlaymaker 65:2872ca289b49 303 velocity = 0; //the block and food have to stop as if length of snake is 15 and it reaches 10 one by one, it stays at the same place, as max virtual length
AhmedPlaymaker 65:2872ca289b49 304 } else { //is 10.
AhmedPlaymaker 65:2872ca289b49 305 velocity = 1;
AhmedPlaymaker 65:2872ca289b49 306 }
AhmedPlaymaker 39:210ac915e0a0 307 _b.velocity.y = velocity;
AhmedPlaymaker 39:210ac915e0a0 308 _f.velocity.y = velocity;
AhmedPlaymaker 39:210ac915e0a0 309 _ff.velocity.y = velocity;
AhmedPlaymaker 39:210ac915e0a0 310 _fff.velocity.y = velocity;
AhmedPlaymaker 27:3b4775a0d0bb 311 }
AhmedPlaymaker 62:ebf6ecf8a6d5 312
AhmedPlaymaker 62:ebf6ecf8a6d5 313 int SnakevsBlock::CheckBlock(int block)
AhmedPlaymaker 62:ebf6ecf8a6d5 314 {
AhmedPlaymaker 29:c6358c39a70e 315 int srn;
AhmedPlaymaker 62:ebf6ecf8a6d5 316 if((block>=0)&&(block<=18)) {
AhmedPlaymaker 62:ebf6ecf8a6d5 317 srn = 0;
AhmedPlaymaker 62:ebf6ecf8a6d5 318 }
AhmedPlaymaker 62:ebf6ecf8a6d5 319 if((block>=19)&&(block<=34)) {
AhmedPlaymaker 62:ebf6ecf8a6d5 320 srn = 1;
AhmedPlaymaker 62:ebf6ecf8a6d5 321 }
AhmedPlaymaker 62:ebf6ecf8a6d5 322 if((block>=35)&&(block<=50)) {
AhmedPlaymaker 62:ebf6ecf8a6d5 323 srn = 2;
AhmedPlaymaker 62:ebf6ecf8a6d5 324 }
AhmedPlaymaker 62:ebf6ecf8a6d5 325 if((block>=51)&&(block<=66)) {
AhmedPlaymaker 62:ebf6ecf8a6d5 326 srn = 3;
AhmedPlaymaker 62:ebf6ecf8a6d5 327 }
AhmedPlaymaker 62:ebf6ecf8a6d5 328 if((block>=67)&&(block<=83)) {
AhmedPlaymaker 62:ebf6ecf8a6d5 329 srn = 4;
AhmedPlaymaker 62:ebf6ecf8a6d5 330 }
AhmedPlaymaker 29:c6358c39a70e 331 return srn;
AhmedPlaymaker 29:c6358c39a70e 332 }
AhmedPlaymaker 62:ebf6ecf8a6d5 333
AhmedPlaymaker 83:329da564799a 334 void SnakevsBlock::ImplementSnakeBlockCollision()
AhmedPlaymaker 62:ebf6ecf8a6d5 335 {
AhmedPlaymaker 42:973bb6036f81 336 send_block_number = 1;
AhmedPlaymaker 44:cd10d07ea1e5 337 if(blocknum > 0) { // to make sure that snake doesn't decrease in _length if number on the block is less than 1;
AhmedPlaymaker 41:4edac50f010d 338 _l.MinusLength();
AhmedPlaymaker 83:329da564799a 339 _pad->tone(432.0,0.1);
AhmedPlaymaker 29:c6358c39a70e 340 wait(0.04);
AhmedPlaymaker 12:1e601b176437 341 }
AhmedPlaymaker 44:cd10d07ea1e5 342 blocknum-=1;
AhmedPlaymaker 13:9785f2404045 343 }
AhmedPlaymaker 13:9785f2404045 344
AhmedPlaymaker 83:329da564799a 345 void SnakevsBlock::CheckSnakeBlockSidesCollision()
AhmedPlaymaker 42:973bb6036f81 346 {
AhmedPlaymaker 42:973bb6036f81 347 //If statements check if the snake sprite has collided with any
AhmedPlaymaker 42:973bb6036f81 348 //of the blocks' sides and then stop the snake moving in x axis
AhmedPlaymaker 63:205f0ca48473 349
AhmedPlaymaker 63:205f0ca48473 350 for(int i=0; i<=9; i++) { //i checks for all possible collisions with the snake respective to it's length.
AhmedPlaymaker 65:2872ca289b49 351 SnakevsBlock::CheckSnakeBlockSidesYCollision(i); //checks if the snake and the block are at the same position in y axis.
AhmedPlaymaker 63:205f0ca48473 352 }
AhmedPlaymaker 63:205f0ca48473 353
AhmedPlaymaker 63:205f0ca48473 354 }
AhmedPlaymaker 63:205f0ca48473 355
AhmedPlaymaker 63:205f0ca48473 356 void SnakevsBlock::MakeDefaultMotionFree() //this makes the default motion of the snake freemoving before a collision is checked for, to forget the previous collision.
AhmedPlaymaker 63:205f0ca48473 357 {
AhmedPlaymaker 42:973bb6036f81 358 for(int i=0; i<=9; i++) {
AhmedPlaymaker 42:973bb6036f81 359 b[i] = 1;
AhmedPlaymaker 42:973bb6036f81 360 }
AhmedPlaymaker 62:ebf6ecf8a6d5 361 }
AhmedPlaymaker 62:ebf6ecf8a6d5 362
AhmedPlaymaker 65:2872ca289b49 363 void SnakevsBlock::CheckSnakeBlockSidesYCollision(int i) //i is the index of the snake beed and checks for all possible collisions with the snake respective to it's length.
AhmedPlaymaker 62:ebf6ecf8a6d5 364 {
AhmedPlaymaker 62:ebf6ecf8a6d5 365 //This code checks if the snake and the block overlap in the Y axis.
AhmedPlaymaker 79:35cb65c52d25 366 for(int Y=0; Y<=10; Y++) { //this carries out the next stage if the Y axis collision criterion is met.
AhmedPlaymaker 62:ebf6ecf8a6d5 367 if (
AhmedPlaymaker 79:35cb65c52d25 368 (snake_pos[i].y == b_pos.y + Y) ||
AhmedPlaymaker 79:35cb65c52d25 369 (snake_pos[i].y + 1 == b_pos.y + Y) ||
AhmedPlaymaker 79:35cb65c52d25 370 (snake_pos[i].y + 2 == b_pos.y + Y)) {
AhmedPlaymaker 62:ebf6ecf8a6d5 371
AhmedPlaymaker 65:2872ca289b49 372 SnakevsBlock::CheckSnakeBlockSidesXCollision(i); //checks if the snake and the block are at the same position in x axis.
AhmedPlaymaker 62:ebf6ecf8a6d5 373
AhmedPlaymaker 62:ebf6ecf8a6d5 374 }
AhmedPlaymaker 62:ebf6ecf8a6d5 375 }
AhmedPlaymaker 62:ebf6ecf8a6d5 376 }
AhmedPlaymaker 62:ebf6ecf8a6d5 377
AhmedPlaymaker 65:2872ca289b49 378 void SnakevsBlock::CheckSnakeBlockSidesXCollision(int i) //i is the index of the snake beed and checks for all possible collisions with the snake respective to it's length.
AhmedPlaymaker 62:ebf6ecf8a6d5 379 {
AhmedPlaymaker 79:35cb65c52d25 380 for(int X=3; X<=83; X+=16) { //this creates a loop in which each barrier is checked for in each loop using the following functions, by running loops
AhmedPlaymaker 79:35cb65c52d25 381 //in relation to where the sides of the blocks are situated in the X axis.
AhmedPlaymaker 62:ebf6ecf8a6d5 382
AhmedPlaymaker 79:35cb65c52d25 383 SnakevsBlock::CheckSnakeBlockSidesEastWestCollision(X, i); //checks if the colliding wall is on east side or west side.
AhmedPlaymaker 79:35cb65c52d25 384 //X is sent because every barrier is in a diffrent position and W/E collision happen at either side of these and therefore cannot have a common X collision.
AhmedPlaymaker 62:ebf6ecf8a6d5 385 }
AhmedPlaymaker 62:ebf6ecf8a6d5 386 }
AhmedPlaymaker 62:ebf6ecf8a6d5 387
AhmedPlaymaker 79:35cb65c52d25 388 void SnakevsBlock::CheckSnakeBlockSidesEastWestCollision(int X, int i) //i checks for all possible collisions with the snake respective to it's length.
AhmedPlaymaker 62:ebf6ecf8a6d5 389 {
AhmedPlaymaker 70:7caab8069b9b 390 //For West side of walls
AhmedPlaymaker 62:ebf6ecf8a6d5 391 if(
AhmedPlaymaker 79:35cb65c52d25 392 ((snake_pos[i].x == X + 1) || //W
AhmedPlaymaker 79:35cb65c52d25 393 (snake_pos[i].x + 1 == X + 1))&&(_d != E)&&(_virtualLength > i) //W
AhmedPlaymaker 62:ebf6ecf8a6d5 394 ) {
AhmedPlaymaker 82:c51ae8a501d1 395 SnakevsBlock::ImplementBarrierCollision(i);
AhmedPlaymaker 62:ebf6ecf8a6d5 396 }
AhmedPlaymaker 62:ebf6ecf8a6d5 397 //for East side of walls
AhmedPlaymaker 62:ebf6ecf8a6d5 398 else if (
AhmedPlaymaker 79:35cb65c52d25 399 ((snake_pos[i].x + 1 == X - 1) || //E
AhmedPlaymaker 79:35cb65c52d25 400 (snake_pos[i].x + 2 == X - 1))&&(_d != W)&&(_virtualLength > i) //E
AhmedPlaymaker 62:ebf6ecf8a6d5 401 ) {
AhmedPlaymaker 82:c51ae8a501d1 402 SnakevsBlock::ImplementBarrierCollision(i);
AhmedPlaymaker 62:ebf6ecf8a6d5 403 }
AhmedPlaymaker 62:ebf6ecf8a6d5 404 }
AhmedPlaymaker 62:ebf6ecf8a6d5 405
AhmedPlaymaker 82:c51ae8a501d1 406
AhmedPlaymaker 83:329da564799a 407 void SnakevsBlock::CheckSnakeBarrierCollision(int bar_sr_no)
AhmedPlaymaker 82:c51ae8a501d1 408 {
AhmedPlaymaker 82:c51ae8a501d1 409 //If statements check if the snake sprite has collided with any
AhmedPlaymaker 82:c51ae8a501d1 410 //of the barrier's sides and then stop the snake moving in x axis
AhmedPlaymaker 82:c51ae8a501d1 411
AhmedPlaymaker 82:c51ae8a501d1 412 for(int i=0; i<=9; i++) { //i checks for all possible collisions with the snake respective to it's length.
AhmedPlaymaker 82:c51ae8a501d1 413 SnakevsBlock::CheckSnakeBarrierYCollision(i, bar_sr_no); //checks if the snake and the block are at the same position in y axis.
AhmedPlaymaker 82:c51ae8a501d1 414 }
AhmedPlaymaker 82:c51ae8a501d1 415
AhmedPlaymaker 82:c51ae8a501d1 416 }
AhmedPlaymaker 82:c51ae8a501d1 417
AhmedPlaymaker 82:c51ae8a501d1 418 void SnakevsBlock::CheckSnakeBarrierYCollision(int i, int bar_sr_no) //i is the index of the snake beed and checks for all possible collisions with the snake respective to it's length.
AhmedPlaymaker 82:c51ae8a501d1 419 {
AhmedPlaymaker 82:c51ae8a501d1 420 //This code checks if the snake and the block overlap in the Y axis.
AhmedPlaymaker 82:c51ae8a501d1 421 for(int Y=0; Y<=21; Y++) { //this carries out the next stage if the Y axis collision criterion is met.
AhmedPlaymaker 82:c51ae8a501d1 422 if (
AhmedPlaymaker 82:c51ae8a501d1 423 (snake_pos[i].y == bar_pos[bar_sr_no].y + Y) ||
AhmedPlaymaker 82:c51ae8a501d1 424 (snake_pos[i].y + 1 == bar_pos[bar_sr_no].y + Y) ||
AhmedPlaymaker 82:c51ae8a501d1 425 (snake_pos[i].y + 2 == bar_pos[bar_sr_no].y + Y)
AhmedPlaymaker 82:c51ae8a501d1 426 ) {
AhmedPlaymaker 82:c51ae8a501d1 427 SnakevsBlock::CheckSnakeBarrierEastWestCollision(i, bar_sr_no); //checks if the colliding barrier is on east side or west side.
AhmedPlaymaker 82:c51ae8a501d1 428
AhmedPlaymaker 82:c51ae8a501d1 429 }
AhmedPlaymaker 82:c51ae8a501d1 430 }
AhmedPlaymaker 82:c51ae8a501d1 431 }
AhmedPlaymaker 82:c51ae8a501d1 432
AhmedPlaymaker 82:c51ae8a501d1 433 void SnakevsBlock::CheckSnakeBarrierEastWestCollision(int i, int bar_sr_no) //i checks for all possible collisions with the snake respective to it's length.
AhmedPlaymaker 82:c51ae8a501d1 434 {
AhmedPlaymaker 82:c51ae8a501d1 435 //bar_pos[0].x and bar_pos[1].x are used to confirm collision of snake with the barriers in the X axis.
AhmedPlaymaker 82:c51ae8a501d1 436 //For West side of walls
AhmedPlaymaker 82:c51ae8a501d1 437 if(
AhmedPlaymaker 82:c51ae8a501d1 438 ((snake_pos[i].x == bar_pos[bar_sr_no].x + 1) || //W
AhmedPlaymaker 82:c51ae8a501d1 439 (snake_pos[i].x + 1 == bar_pos[bar_sr_no].x + 1))&&(_d != E)&&(_virtualLength > i) //W
AhmedPlaymaker 82:c51ae8a501d1 440 ) {
AhmedPlaymaker 82:c51ae8a501d1 441 SnakevsBlock::ImplementBarrierCollision(i);
AhmedPlaymaker 82:c51ae8a501d1 442 }
AhmedPlaymaker 82:c51ae8a501d1 443 //for East side of walls
AhmedPlaymaker 82:c51ae8a501d1 444 else if (
AhmedPlaymaker 82:c51ae8a501d1 445 ((snake_pos[i].x + 1 == bar_pos[bar_sr_no].x - 1) || //E
AhmedPlaymaker 82:c51ae8a501d1 446 (snake_pos[i].x + 2 == bar_pos[bar_sr_no].x - 1))&&(_d != W)&&(_virtualLength > i) //E
AhmedPlaymaker 82:c51ae8a501d1 447 ) {
AhmedPlaymaker 82:c51ae8a501d1 448 SnakevsBlock::ImplementBarrierCollision(i);
AhmedPlaymaker 82:c51ae8a501d1 449 }
AhmedPlaymaker 82:c51ae8a501d1 450 }
AhmedPlaymaker 82:c51ae8a501d1 451
AhmedPlaymaker 82:c51ae8a501d1 452
AhmedPlaymaker 82:c51ae8a501d1 453 ////////////////////////////USED IN BOTH BLOCK SIDES COLLISION AND BARRIER COLLISION////////////////////////////
AhmedPlaymaker 82:c51ae8a501d1 454
AhmedPlaymaker 82:c51ae8a501d1 455 //Also used to send length to snake class as the max length drawn must also be 10
AhmedPlaymaker 64:540aa1602372 456 void SnakevsBlock::makeVirtualLengthMaxTen()
AhmedPlaymaker 64:540aa1602372 457 {
AhmedPlaymaker 64:540aa1602372 458 //this makes the virtual length -> 10 for the side collision implementation because if the length is fifteen and the last beed collides, it still is the 10th beed
AhmedPlaymaker 64:540aa1602372 459 //on screen.
AhmedPlaymaker 64:540aa1602372 460 _virtualLength = _length;
AhmedPlaymaker 71:4bd2b27693f3 461 if(_length >= 10) {
AhmedPlaymaker 64:540aa1602372 462 _virtualLength = 10; //to stop the snake length virtually at 10 when it goes past it.
AhmedPlaymaker 64:540aa1602372 463 }
AhmedPlaymaker 64:540aa1602372 464 }
AhmedPlaymaker 82:c51ae8a501d1 465 //Implements both SnakeBlockSides and SnakeBarrier Collisions.
AhmedPlaymaker 82:c51ae8a501d1 466 void SnakevsBlock::ImplementBarrierCollision(int i) //i is the index of the snake beed and checks for all possible collisions with the snake respective to it's length.
AhmedPlaymaker 62:ebf6ecf8a6d5 467 {
AhmedPlaymaker 62:ebf6ecf8a6d5 468 //code makes sure that the colliding part doesn't move in x axis.
AhmedPlaymaker 62:ebf6ecf8a6d5 469 for(int snake_beed_num=0; snake_beed_num<=10; snake_beed_num++) {
AhmedPlaymaker 64:540aa1602372 470 if(_virtualLength == snake_beed_num + i) {
AhmedPlaymaker 62:ebf6ecf8a6d5 471 b[snake_beed_num - 1] = 0;
AhmedPlaymaker 24:1c118b071430 472 }
AhmedPlaymaker 15:f4d069da093d 473 }
AhmedPlaymaker 22:ee698f66146f 474 }