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@53:082c22ac2f9a, 2019-04-24 (annotated)

Committer:
el17arm
Date:
Wed Apr 24 19:33:39 2019 +0000
Revision:
53:082c22ac2f9a
Parent:
52:715791fc08a1
Child:
54:7fa8c07fdea4
Documentation for Sprites class complete

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 45:bad704c546d4 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 45:bad704c546d4 83 /////////structs for sprite parameters and collision detection//////////////
el17arm 38:55bb9da08a52 84
el17arm 49:9bea7089b657 85 /** Keys position struct */
el17arm 49:9bea7089b657 86
el17arm 51:a4b5ded0b727 87 struct Key_init {
el17arm 49:9bea7089b657 88 bool key[5]; /**< initialise key flag array identifies each key individually */
el17arm 49:9bea7089b657 89 double kx[5]; /**< key x position*/
el17arm 49:9bea7089b657 90 double ky[5]; /**< key y position*/
el17arm 38:55bb9da08a52 91 };
el17arm 50:65ba437510f8 92
el17arm 49:9bea7089b657 93 /** Enemy position and movement struct */
el17arm 51:a4b5ded0b727 94 struct Enemies_init {
el17arm 49:9bea7089b657 95 bool eflag[5]; /**< initialise enemy flag array identifies each key individually */
el17arm 49:9bea7089b657 96 double ex[5]; /**< enemy x position */
el17arm 49:9bea7089b657 97 double ey[5]; /**< enemy y position */
el17arm 49:9bea7089b657 98 int counter[5]; /**< enemy counter, counts pixels moved */
el17arm 49:9bea7089b657 99 int distance[5];/**< distance enemy will travel before turning round */
el17arm 40:913339e324b8 100 };
el17arm 50:65ba437510f8 101
el17arm 49:9bea7089b657 102 /** Solid blocks struct */
el17arm 43:1ec6b6293c6b 103 struct Solid_blocks_init {
el17arm 49:9bea7089b657 104 double bx[5]; /**< block x position array identifies each block individually */
el17arm 49:9bea7089b657 105 double by[5]; /**< block y position array */
el17arm 49:9bea7089b657 106 bool collision[5]; /**< collision indicator for each individual block */
el17arm 40:913339e324b8 107
el17arm 43:1ec6b6293c6b 108 };
el17arm 49:9bea7089b657 109 /////////////structs for populating up to 6 levels//////////////////
el17arm 50:65ba437510f8 110
el17arm 50:65ba437510f8 111 /** Enemy locations for each level struct */
el17arm 38:55bb9da08a52 112 struct Enemies {
el17arm 49:9bea7089b657 113 double ex[5]; /**< enemy x positions for each level */
el17arm 49:9bea7089b657 114 double ey[5]; /**< enemy y positions for each level */
el17arm 49:9bea7089b657 115 int c[5]; /**< enemy counters for each level */
el17arm 49:9bea7089b657 116 int d[5]; /**< enemy travel distances for each level */
el17arm 49:9bea7089b657 117 double v[5]; /**< varies enemies velocity */
el17arm 38:55bb9da08a52 118 };
el17arm 50:65ba437510f8 119 /** Trap locations for each level struct */
el17arm 38:55bb9da08a52 120 struct Traps {
el17arm 49:9bea7089b657 121 double tx[5]; /**< traps x positions for each level */
el17arm 49:9bea7089b657 122 double ty[5]; /**< traps y positions for each level */
el17arm 38:55bb9da08a52 123 };
el17arm 50:65ba437510f8 124 /** Key locations for each level struct*/
el17arm 38:55bb9da08a52 125 struct Keys {
el17arm 49:9bea7089b657 126 double kx[5]; /**< keys x positions for each level */
el17arm 49:9bea7089b657 127 double ky[5]; /**< keys y positions for each level */
el17arm 38:55bb9da08a52 128 };
el17arm 50:65ba437510f8 129 /** block locations for each level struct*/
el17arm 38:55bb9da08a52 130 struct Solid_blocks {
el17arm 49:9bea7089b657 131 double bx[5]; /**< blocks x positions for each level */
el17arm 49:9bea7089b657 132 double by[5]; /**< blocks y positions for each level */
el17arm 38:55bb9da08a52 133 };
el17arm 50:65ba437510f8 134 /** sinking block locations for each level struct*/
el17arm 38:55bb9da08a52 135 struct Soft_blocks {
el17arm 49:9bea7089b657 136 double sx1[5]; /**< sinking blocks x1 positions for each level */
el17arm 49:9bea7089b657 137 double sy[5]; /**< sinking blocks y positions for each level */
el17arm 49:9bea7089b657 138 int sx2[5]; /**< sinking blocks x2 (length) positions for each level */
el17arm 40:913339e324b8 139 };
el17arm 50:65ba437510f8 140 /** Exit location for each level struct */
el17arm 40:913339e324b8 141 struct Level_exit {
el17arm 49:9bea7089b657 142 double lx[5]; /**< Exit x position for each level */
el17arm 49:9bea7089b657 143 double ly[5]; /**< Exit y position for each level */
el17arm 33:023f57d52b1c 144 };
el17arm 33:023f57d52b1c 145
el17arm 52:715791fc08a1 146
el17arm 52:715791fc08a1 147 /** Sprites Class
el17arm 52:715791fc08a1 148 @author Andrew Milner University of Leeds
el17arm 52:715791fc08a1 149 @brief Draws sprites and sets all collision rules
el17arm 52:715791fc08a1 150 @date April 2019
el17arm 52:715791fc08a1 151 */
el17arm 52:715791fc08a1 152
el17arm 33:023f57d52b1c 153 class Sprites
el17arm 33:023f57d52b1c 154 {
el17arm 33:023f57d52b1c 155
el17arm 33:023f57d52b1c 156 public:
el17arm 53:082c22ac2f9a 157 /** Constructor
el17arm 49:9bea7089b657 158 */
el17arm 33:023f57d52b1c 159 Sprites();
el17arm 53:082c22ac2f9a 160 /** Deconstructor
el17arm 53:082c22ac2f9a 161 */
el17arm 33:023f57d52b1c 162 ~Sprites();
el17arm 53:082c22ac2f9a 163 /** Gets x and y position of player.
el17arm 53:082c22ac2f9a 164 */
el17arm 41:0cf320f73424 165 Vector2D get_pos();
el17arm 53:082c22ac2f9a 166 /** States starting position of player.
el17arm 53:082c22ac2f9a 167 @param miner x position.
el17arm 53:082c22ac2f9a 168 @param miner y position.
el17arm 53:082c22ac2f9a 169 */
el17arm 33:023f57d52b1c 170 void miner_init(int x, int y);
el17arm 53:082c22ac2f9a 171 /** Updates player x position.
el17arm 53:082c22ac2f9a 172 @details Updates x positon depending on direction of joystick. Will only update
el17arm 53:082c22ac2f9a 173 * position if no collision detected. Function also stops player leaving screen
el17arm 53:082c22ac2f9a 174 * at the left and right sides of screen.
el17arm 53:082c22ac2f9a 175 @param Direction enum from Gamepad library.
el17arm 53:082c22ac2f9a 176 */
el17arm 45:bad704c546d4 177 void miner_move(Direction d, N5110 &lcd);
el17arm 53:082c22ac2f9a 178 /** Draws sprite facing direction moving.
el17arm 53:082c22ac2f9a 179 @details _direction states if player left or right facing, function draws
el17arm 53:082c22ac2f9a 180 * left or right facing sprite according.
el17arm 53:082c22ac2f9a 181 */
el17arm 33:023f57d52b1c 182 void miner_draw(N5110 &lcd);
el17arm 53:082c22ac2f9a 183 /** States when player is on a platform.
el17arm 53:082c22ac2f9a 184 @details if _jump true then player can jump, this prevents mid-air jumping.
el17arm 53:082c22ac2f9a 185 * Also states conditions for gravity so player will fall unless on top
el17arm 53:082c22ac2f9a 186 * of a platform.
el17arm 53:082c22ac2f9a 187 */
el17arm 53:082c22ac2f9a 188 void miner_land(N5110 &lcd);
el17arm 53:082c22ac2f9a 189 /** Contains jump conditions and updates player position while jumping.
el17arm 53:082c22ac2f9a 190 @details When A button pressed players y position increases until preset value
el17arm 53:082c22ac2f9a 191 * is reached. Jump flag is true while player y is increasing and false all other
el17arm 53:082c22ac2f9a 192 * times, this prevents double jumping.
el17arm 53:082c22ac2f9a 193 */
el17arm 53:082c22ac2f9a 194 void miner_jump(N5110 &lcd, Gamepad &pad);
el17arm 53:082c22ac2f9a 195 /** Player falls if not on platform.
el17arm 53:082c22ac2f9a 196 */
el17arm 33:023f57d52b1c 197 void miner_gravity(N5110 &lcd);
el17arm 53:082c22ac2f9a 198 /** initialises enemies
el17arm 53:082c22ac2f9a 199 @param enemy index, these will always be 0, 1, 2 so each enemy is treated individually.
el17arm 53:082c22ac2f9a 200 @param enemy x position.
el17arm 53:082c22ac2f9a 201 @param enemy y position.
el17arm 53:082c22ac2f9a 202 @param distance in pixels enemy to travel.
el17arm 53:082c22ac2f9a 203 */
el17arm 33:023f57d52b1c 204 void enemy_init(int i, int x, int y, int d);
el17arm 53:082c22ac2f9a 205 /** Updates enemy movement.
el17arm 53:082c22ac2f9a 206 @param enemy index, these will always be 0, 1, 2 so each enemy is treated individually.
el17arm 53:082c22ac2f9a 207 @param stets how many pixels enemies will move each loop.
el17arm 53:082c22ac2f9a 208 */
el17arm 33:023f57d52b1c 209 void enemy_move(int i, double v, N5110 &lcd);
el17arm 53:082c22ac2f9a 210 /** States conditions for collision between enemy and player.
el17arm 53:082c22ac2f9a 211 @details uses get_pos() and detects if any overlap between player and enemies.
el17arm 53:082c22ac2f9a 212 @param enemy index, these will always be 0, 1, 2 so each enemy is treated individually.
el17arm 53:082c22ac2f9a 213 @return will return true if collision detected.
el17arm 53:082c22ac2f9a 214 */
el17arm 33:023f57d52b1c 215 bool enemy_collision(int i);
el17arm 53:082c22ac2f9a 216 /** States conditions for drawing and collection of keys.
el17arm 53:082c22ac2f9a 217 @details Each key is displayed while key flag is false, once collected, key is deleted
el17arm 53:082c22ac2f9a 218 * and flag is changed to true.
el17arm 53:082c22ac2f9a 219 @param each key indexed so they are treated independently.
el17arm 53:082c22ac2f9a 220 @param keys x position.
el17arm 53:082c22ac2f9a 221 @param keys y position.
el17arm 53:082c22ac2f9a 222 */
el17arm 33:023f57d52b1c 223 void key_collect(int k, int x, int y, N5110 &lcd, Gamepad &pad);
el17arm 53:082c22ac2f9a 224 /** Counts keys collected.
el17arm 53:082c22ac2f9a 225 @return number of keys collected.
el17arm 53:082c22ac2f9a 226 */
el17arm 40:913339e324b8 227 int keys_collected();
el17arm 53:082c22ac2f9a 228 /** Draws level exit and detects player collision
el17arm 53:082c22ac2f9a 229 @details takes player position from get_pos() and detects if overlap between
el17arm 53:082c22ac2f9a 230 player and the exit sprite.
el17arm 53:082c22ac2f9a 231 @param Exit x position.
el17arm 53:082c22ac2f9a 232 @param Exit y position.
el17arm 53:082c22ac2f9a 233 */
el17arm 53:082c22ac2f9a 234 bool exit_level(int x, int y, N5110 &lcd);
el17arm 53:082c22ac2f9a 235 /** Draws traps and detects player collision
el17arm 53:082c22ac2f9a 236 @details takes player position from get_pos() and detects if overlap between
el17arm 53:082c22ac2f9a 237 player and the trap sprite.
el17arm 53:082c22ac2f9a 238 @param Trap x position.
el17arm 53:082c22ac2f9a 239 @param Trap y position.
el17arm 53:082c22ac2f9a 240 */
el17arm 37:4d525a37d5d2 241 bool trap(int x, int y, N5110 &lcd);
el17arm 53:082c22ac2f9a 242 /** Draws blocks and detects player collision.
el17arm 53:082c22ac2f9a 243 @param Direction needed so player can turn around if collision with block.
el17arm 53:082c22ac2f9a 244 @Param each block indexed so collision rules between blocks dont clash.
el17arm 53:082c22ac2f9a 245 @param Block x position.
el17arm 53:082c22ac2f9a 246 @param Block y position.
el17arm 53:082c22ac2f9a 247 */
el17arm 43:1ec6b6293c6b 248 void blocks(Direction d, int i, int x, int y, N5110 &lcd);
el17arm 53:082c22ac2f9a 249 /** Checks if player has collided with any blocks.
el17arm 53:082c22ac2f9a 250 @return If player is contact with any block returns true.
el17arm 53:082c22ac2f9a 251 */
el17arm 43:1ec6b6293c6b 252 bool block_collision();
el17arm 53:082c22ac2f9a 253 /** Draws sinking blocks and detects player contact.
el17arm 53:082c22ac2f9a 254 @param Sinking block x starting position.
el17arm 53:082c22ac2f9a 255 @param Block y position.
el17arm 53:082c22ac2f9a 256 @param Sinking block x finish position.
el17arm 53:082c22ac2f9a 257 */
el17arm 38:55bb9da08a52 258 void soft_blocks(int x, int y, int z, N5110 &lcd);
el17arm 33:023f57d52b1c 259
el17arm 51:a4b5ded0b727 260 Key_init _k;
el17arm 38:55bb9da08a52 261
el17arm 33:023f57d52b1c 262 private:
el17arm 33:023f57d52b1c 263
el17arm 33:023f57d52b1c 264 int _direction;
el17arm 53:082c22ac2f9a 265 bool _gravity;
el17arm 33:023f57d52b1c 266 bool _jump;
el17arm 33:023f57d52b1c 267 int _y;
el17arm 33:023f57d52b1c 268 int _x;
el17arm 33:023f57d52b1c 269 bool _j_flag;
el17arm 33:023f57d52b1c 270 int _j_counter;
el17arm 33:023f57d52b1c 271
el17arm 34:c5a042973e0c 272 bool block[5];
el17arm 36:203ec93b4cc7 273 bool right_collision;
el17arm 36:203ec93b4cc7 274 bool left_collision;
el17arm 36:203ec93b4cc7 275
el17arm 36:203ec93b4cc7 276 bool _collision;
el17arm 36:203ec93b4cc7 277 int _keys;
el17arm 36:203ec93b4cc7 278
el17arm 53:082c22ac2f9a 279 Enemies_init _enem;
el17arm 43:1ec6b6293c6b 280 Solid_blocks_init _b;
el17arm 44:e29458976114 281
el17arm 33:023f57d52b1c 282 };
el17arm 33:023f57d52b1c 283 #endif