ELEC2645 (2018/19) / Mbed 2 deprecated el17arm

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   mbed

Sprites/Sprites.h@65:d807f9d9d0b3, 2019-05-09 (annotated)

Committer:
el17arm
Date:
Thu May 09 12:08:26 2019 +0000
Revision:
65:d807f9d9d0b3
Parent:
64:b373b6bf8255 
Final submission

Who changed what in which revision?

UserRevisionLine numberNew contents of line
el17arm 33:023f57d52b1c 1 #ifndef SPRITES_H
el17arm 33:023f57d52b1c 2 #define SPRITES_H
el17arm 33:023f57d52b1c 3
el17arm 33:023f57d52b1c 4 #include "mbed.h"
el17arm 33:023f57d52b1c 5 #include "N5110.h"
el17arm 33:023f57d52b1c 6 #include "Gamepad.h"
el17arm 41:0cf320f73424 7
el17arm 58:4a826093d9e9 8 /////////// All sprite bitmaps ////////////////
el17arm 33:023f57d52b1c 9
el17arm 49:9bea7089b657 10 // right facing miner bitmap
el17arm 33:023f57d52b1c 11 const int miner_right[24] = {
el17arm 41:0cf320f73424 12
el17arm 33:023f57d52b1c 13 1,1,1,
el17arm 33:023f57d52b1c 14 1,1,0,
el17arm 33:023f57d52b1c 15 1,1,1,
el17arm 33:023f57d52b1c 16 0,1,0,
el17arm 33:023f57d52b1c 17 1,1,1,
el17arm 33:023f57d52b1c 18 1,1,1,
el17arm 33:023f57d52b1c 19 0,1,0,
el17arm 33:023f57d52b1c 20 0,1,1,
el17arm 33:023f57d52b1c 21
el17arm 33:023f57d52b1c 22 };
el17arm 49:9bea7089b657 23 // left facing miner bitmap
el17arm 49:9bea7089b657 24 const int miner_left[24] = {
el17arm 41:0cf320f73424 25
el17arm 33:023f57d52b1c 26 1,1,1,
el17arm 33:023f57d52b1c 27 0,1,1,
el17arm 33:023f57d52b1c 28 1,1,1,
el17arm 33:023f57d52b1c 29 0,1,0,
el17arm 33:023f57d52b1c 30 1,1,1,
el17arm 33:023f57d52b1c 31 1,1,1,
el17arm 33:023f57d52b1c 32 0,1,0,
el17arm 33:023f57d52b1c 33 1,1,0,
el17arm 33:023f57d52b1c 34 };
el17arm 49:9bea7089b657 35 // enemy bitmap
el17arm 33:023f57d52b1c 36 const int enemy[15] = {
el17arm 33:023f57d52b1c 37
el17arm 33:023f57d52b1c 38 1,1,1,
el17arm 33:023f57d52b1c 39 1,0,1,
el17arm 33:023f57d52b1c 40 1,1,1,
el17arm 33:023f57d52b1c 41 0,1,0,
el17arm 33:023f57d52b1c 42 1,1,1,
el17arm 33:023f57d52b1c 43 };
el17arm 49:9bea7089b657 44 // key bitmap
el17arm 33:023f57d52b1c 45 const int key[12] = {
el17arm 41:0cf320f73424 46
el17arm 33:023f57d52b1c 47 1,1,0,0,
el17arm 33:023f57d52b1c 48 1,0,1,1,
el17arm 33:023f57d52b1c 49 1,1,0,1,
el17arm 33:023f57d52b1c 50 };
el17arm 49:9bea7089b657 51 // blank bitmap to show key collected
el17arm 33:023f57d52b1c 52 const int key_collected[12] = {
el17arm 33:023f57d52b1c 53
el17arm 33:023f57d52b1c 54 0,0,0,0,
el17arm 33:023f57d52b1c 55 0,0,0,0,
el17arm 33:023f57d52b1c 56 0,0,0,0,
el17arm 33:023f57d52b1c 57 };
el17arm 49:9bea7089b657 58 // trap bitmap
el17arm 33:023f57d52b1c 59 const int spike[9] = {
el17arm 33:023f57d52b1c 60
el17arm 34:c5a042973e0c 61 1,0,1,
el17arm 33:023f57d52b1c 62 0,1,0,
el17arm 34:c5a042973e0c 63 1,0,1,
el17arm 33:023f57d52b1c 64 };
el17arm 49:9bea7089b657 65 // solid block bitmap
el17arm 34:c5a042973e0c 66 const int solid_block[18] = {
el17arm 33:023f57d52b1c 67
el17arm 34:c5a042973e0c 68 1,1,1,1,1,1,
el17arm 34:c5a042973e0c 69 1,0,1,1,0,1,
el17arm 34:c5a042973e0c 70 1,1,1,1,1,1,
el17arm 33:023f57d52b1c 71 };
el17arm 49:9bea7089b657 72 // level exit bitmap
el17arm 33:023f57d52b1c 73 const int door[30] = {
el17arm 33:023f57d52b1c 74
el17arm 33:023f57d52b1c 75 1,1,1,1,1,
el17arm 33:023f57d52b1c 76 1,0,1,0,1,
el17arm 33:023f57d52b1c 77 1,1,0,1,1,
el17arm 33:023f57d52b1c 78 1,0,1,0,1,
el17arm 33:023f57d52b1c 79 1,1,0,1,1,
el17arm 33:023f57d52b1c 80 1,0,1,0,1,
el17arm 33:023f57d52b1c 81 };
el17arm 38:55bb9da08a52 82
el17arm 33:023f57d52b1c 83
el17arm 58:4a826093d9e9 84 ///////////////////////////////////////////////////////////////////////////////
el17arm 52:715791fc08a1 85
el17arm 52:715791fc08a1 86 /** Sprites Class
el17arm 56:8c827d1cae3b 87 @details Draws sprites and sets all collision rules
el17arm 52:715791fc08a1 88 @author Andrew Milner University of Leeds
el17arm 52:715791fc08a1 89 @date April 2019
el17arm 52:715791fc08a1 90 */
el17arm 52:715791fc08a1 91
el17arm 33:023f57d52b1c 92 class Sprites
el17arm 33:023f57d52b1c 93 {
el17arm 33:023f57d52b1c 94
el17arm 33:023f57d52b1c 95 public:
el17arm 53:082c22ac2f9a 96 /** Constructor
el17arm 49:9bea7089b657 97 */
el17arm 33:023f57d52b1c 98 Sprites();
el17arm 53:082c22ac2f9a 99 /** Deconstructor
el17arm 53:082c22ac2f9a 100 */
el17arm 33:023f57d52b1c 101 ~Sprites();
el17arm 53:082c22ac2f9a 102 /** Gets x and y position of player.
el17arm 53:082c22ac2f9a 103 */
el17arm 41:0cf320f73424 104 Vector2D get_pos();
el17arm 53:082c22ac2f9a 105 /** States starting position of player.
el17arm 60:3df033345059 106 @param x miner position.
el17arm 60:3df033345059 107 @param y miner position.
el17arm 53:082c22ac2f9a 108 */
el17arm 33:023f57d52b1c 109 void miner_init(int x, int y);
el17arm 53:082c22ac2f9a 110 /** Updates player x position.
el17arm 53:082c22ac2f9a 111 @details Updates x positon depending on direction of joystick. Will only update
el17arm 53:082c22ac2f9a 112 * position if no collision detected. Function also stops player leaving screen
el17arm 53:082c22ac2f9a 113 * at the left and right sides of screen.
el17arm 54:7fa8c07fdea4 114 @param d Direction enum from Gamepad library.
el17arm 53:082c22ac2f9a 115 */
el17arm 45:bad704c546d4 116 void miner_move(Direction d, N5110 &lcd);
el17arm 53:082c22ac2f9a 117 /** Draws sprite facing direction moving.
el17arm 53:082c22ac2f9a 118 @details _direction states if player left or right facing, function draws
el17arm 53:082c22ac2f9a 119 * left or right facing sprite according.
el17arm 53:082c22ac2f9a 120 */
el17arm 33:023f57d52b1c 121 void miner_draw(N5110 &lcd);
el17arm 53:082c22ac2f9a 122 /** States when player is on a platform.
el17arm 53:082c22ac2f9a 123 @details if _jump true then player can jump, this prevents mid-air jumping.
el17arm 53:082c22ac2f9a 124 * Also states conditions for gravity so player will fall unless on top
el17arm 53:082c22ac2f9a 125 * of a platform.
el17arm 53:082c22ac2f9a 126 */
el17arm 53:082c22ac2f9a 127 void miner_land(N5110 &lcd);
el17arm 53:082c22ac2f9a 128 /** Contains jump conditions and updates player position while jumping.
el17arm 53:082c22ac2f9a 129 @details When A button pressed players y position increases until preset value
el17arm 53:082c22ac2f9a 130 * is reached. Jump flag is true while player y is increasing and false all other
el17arm 53:082c22ac2f9a 131 * times, this prevents double jumping.
el17arm 53:082c22ac2f9a 132 */
el17arm 53:082c22ac2f9a 133 void miner_jump(N5110 &lcd, Gamepad &pad);
el17arm 53:082c22ac2f9a 134 /** Player falls if not on platform.
el17arm 53:082c22ac2f9a 135 */
el17arm 33:023f57d52b1c 136 void miner_gravity(N5110 &lcd);
el17arm 53:082c22ac2f9a 137 /** initialises enemies
el17arm 60:3df033345059 138 @param i index these will always be 0, 1, 2 so each enemy is treated individually.
el17arm 54:7fa8c07fdea4 139 @param x position.
el17arm 54:7fa8c07fdea4 140 @param y position.
el17arm 53:082c22ac2f9a 141 @param distance in pixels enemy to travel.
el17arm 53:082c22ac2f9a 142 */
el17arm 33:023f57d52b1c 143 void enemy_init(int i, int x, int y, int d);
el17arm 53:082c22ac2f9a 144 /** Updates enemy movement.
el17arm 60:3df033345059 145 @param i index these will always be 0 - 2 so each enemy is treated individually.
el17arm 54:7fa8c07fdea4 146 @param velocity how many pixels enemies will move each loop.
el17arm 53:082c22ac2f9a 147 */
el17arm 33:023f57d52b1c 148 void enemy_move(int i, double v, N5110 &lcd);
el17arm 53:082c22ac2f9a 149 /** States conditions for collision between enemy and player.
el17arm 53:082c22ac2f9a 150 @details uses get_pos() and detects if any overlap between player and enemies.
el17arm 60:3df033345059 151 @param i index these will always be 0, 1, 2 so each enemy is treated individually.
el17arm 53:082c22ac2f9a 152 @return will return true if collision detected.
el17arm 53:082c22ac2f9a 153 */
el17arm 33:023f57d52b1c 154 bool enemy_collision(int i);
el17arm 53:082c22ac2f9a 155 /** States conditions for drawing and collection of keys.
el17arm 53:082c22ac2f9a 156 @details Each key is displayed while key flag is false, once collected, key is deleted
el17arm 53:082c22ac2f9a 157 * and flag is changed to true.
el17arm 64:b373b6bf8255 158 @param k index so each key is treated independently
el17arm 54:7fa8c07fdea4 159 @param x key position.
el17arm 54:7fa8c07fdea4 160 @param y key position.
el17arm 53:082c22ac2f9a 161 */
el17arm 33:023f57d52b1c 162 void key_collect(int k, int x, int y, N5110 &lcd, Gamepad &pad);
el17arm 53:082c22ac2f9a 163 /** Counts keys collected.
el17arm 53:082c22ac2f9a 164 @return number of keys collected.
el17arm 53:082c22ac2f9a 165 */
el17arm 40:913339e324b8 166 int keys_collected();
el17arm 65:d807f9d9d0b3 167 /** makes _keys zero
el17arm 65:d807f9d9d0b3 168 @details When game over occurs keys need to be reset to zero
el17arm 65:d807f9d9d0b3 169 */
el17arm 65:d807f9d9d0b3 170 void zero_keys();
el17arm 53:082c22ac2f9a 171 /** Draws level exit and detects player collision
el17arm 53:082c22ac2f9a 172 @details takes player position from get_pos() and detects if overlap between
el17arm 53:082c22ac2f9a 173 player and the exit sprite.
el17arm 60:3df033345059 174 @param x exit position.
el17arm 60:3df033345059 175 @param y exit position.
el17arm 53:082c22ac2f9a 176 */
el17arm 53:082c22ac2f9a 177 bool exit_level(int x, int y, N5110 &lcd);
el17arm 53:082c22ac2f9a 178 /** Draws traps and detects player collision
el17arm 53:082c22ac2f9a 179 @details takes player position from get_pos() and detects if overlap between
el17arm 53:082c22ac2f9a 180 player and the trap sprite.
el17arm 54:7fa8c07fdea4 181 @param x trap position.
el17arm 54:7fa8c07fdea4 182 @param y trap position.
el17arm 53:082c22ac2f9a 183 */
el17arm 37:4d525a37d5d2 184 bool trap(int x, int y, N5110 &lcd);
el17arm 53:082c22ac2f9a 185 /** Draws blocks and detects player collision.
el17arm 60:3df033345059 186 @param d direction so player can turn around if collision with block.
el17arm 60:3df033345059 187 @Param i index so collision rules between blocks dont clash, will always be numbered 0 - 4.
el17arm 54:7fa8c07fdea4 188 @param x block position.
el17arm 54:7fa8c07fdea4 189 @param y block position.
el17arm 53:082c22ac2f9a 190 */
el17arm 43:1ec6b6293c6b 191 void blocks(Direction d, int i, int x, int y, N5110 &lcd);
el17arm 53:082c22ac2f9a 192 /** Checks if player has collided with any blocks.
el17arm 54:7fa8c07fdea4 193 @return if player is contact with any block returns true.
el17arm 53:082c22ac2f9a 194 */
el17arm 43:1ec6b6293c6b 195 bool block_collision();
el17arm 53:082c22ac2f9a 196 /** Draws sinking blocks and detects player contact.
el17arm 54:7fa8c07fdea4 197 @param x1 sinking block starting position.
el17arm 54:7fa8c07fdea4 198 @param y sinking block position.
el17arm 54:7fa8c07fdea4 199 @param x2 Sinking block finish position.
el17arm 53:082c22ac2f9a 200 */
el17arm 59:d82d49a7a4d4 201 void soft_blocks(int x1, int y, int x2, N5110 &lcd);
el17arm 33:023f57d52b1c 202
el17arm 60:3df033345059 203 bool _key[5]; /*initialise key flag, will only draw key if false, array identifies keys
el17arm 64:b373b6bf8255 204 individually, made global variable as key_reinit() needs to reset flag at start of each level*/
el17arm 60:3df033345059 205
el17arm 33:023f57d52b1c 206 private:
el17arm 33:023f57d52b1c 207
el17arm 33:023f57d52b1c 208 int _direction;
el17arm 53:082c22ac2f9a 209 bool _gravity;
el17arm 33:023f57d52b1c 210 bool _jump;
el17arm 33:023f57d52b1c 211 int _y;
el17arm 33:023f57d52b1c 212 int _x;
el17arm 33:023f57d52b1c 213 bool _j_flag;
el17arm 33:023f57d52b1c 214 int _j_counter;
el17arm 33:023f57d52b1c 215
el17arm 58:4a826093d9e9 216 double _kx[5]; // key x position
el17arm 58:4a826093d9e9 217 double _ky[5]; // key y position
el17arm 58:4a826093d9e9 218 int _keys; // keeps count of how many keys collected
el17arm 36:203ec93b4cc7 219
el17arm 58:4a826093d9e9 220 bool _eflag[5]; // initialise enemy flag, array identifies each enemy individually
el17arm 58:4a826093d9e9 221 double _ex[5]; // enemy x position
el17arm 58:4a826093d9e9 222 double _ey[5]; // enemy y position
el17arm 58:4a826093d9e9 223 int _counter[5]; // enemy counter, counts pixels moved
el17arm 58:4a826093d9e9 224 int _distance[5];// distance enemy will travel before turning round
el17arm 36:203ec93b4cc7 225
el17arm 58:4a826093d9e9 226 double _bx[5]; // block x position array identifies each block individually
el17arm 58:4a826093d9e9 227 double _by[5]; // block y position array
el17arm 58:4a826093d9e9 228 bool _collision[5]; // collision indicator for each individual block
el17arm 44:e29458976114 229
el17arm 33:023f57d52b1c 230 };
el17arm 33:023f57d52b1c 231 #endif