Ransom Conant / Mbed 2 deprecated MbedPacman

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:   4DGL-uLCD-SE mbed wave_player

Fork of PacMan_Skeleton_unlock by ECE 2035 TA

ghost.cpp@1:fbda247b843b, 2018-03-29 (annotated)

Committer:
rconant6
Date:
Thu Mar 29 05:05:51 2018 +0000
Revision:
1:fbda247b843b
Parent:
0:be33a1fad8c0 
Adding files;

Who changed what in which revision?

UserRevisionLine numberNew contents of line
conantina 0:be33a1fad8c0 1 /* Gatech ECE2035 2015 SPRING PAC MAN
conantina 0:be33a1fad8c0 2 * Copyright (c) 2015 Gatech ECE2035
conantina 0:be33a1fad8c0 3 *
conantina 0:be33a1fad8c0 4 * Permission is hereby granted, free of charge, to any person obtaining a copy
conantina 0:be33a1fad8c0 5 * of this software and associated documentation files (the "Software"), to deal
conantina 0:be33a1fad8c0 6 * in the Software without restriction, including without limitation the rights
conantina 0:be33a1fad8c0 7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
conantina 0:be33a1fad8c0 8 * copies of the Software, and to permit persons to whom the Software is
conantina 0:be33a1fad8c0 9 * furnished to do so, subject to the following conditions:
conantina 0:be33a1fad8c0 10 *
conantina 0:be33a1fad8c0 11 * The above copyright notice and this permission notice shall be included in
conantina 0:be33a1fad8c0 12 * all copies or substantial portions of the Software.
conantina 0:be33a1fad8c0 13 *
conantina 0:be33a1fad8c0 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
conantina 0:be33a1fad8c0 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
conantina 0:be33a1fad8c0 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
conantina 0:be33a1fad8c0 17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
conantina 0:be33a1fad8c0 18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
conantina 0:be33a1fad8c0 19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
conantina 0:be33a1fad8c0 20 * SOFTWARE.
conantina 0:be33a1fad8c0 21 */
conantina 0:be33a1fad8c0 22
conantina 0:be33a1fad8c0 23 #include "ghost.h"
conantina 0:be33a1fad8c0 24
conantina 0:be33a1fad8c0 25 //================================================================//
conantina 0:be33a1fad8c0 26 // Private functions
conantina 0:be33a1fad8c0 27 void clean_blk(unsigned int blk_x, unsigned int blk_y)
conantina 0:be33a1fad8c0 28 {
conantina 0:be33a1fad8c0 29 GRID grid_info = map_get_grid_status(blk_x,blk_y);
conantina 0:be33a1fad8c0 30 uLCD.filled_rectangle(grid_info.x, grid_info.y, grid_info.x+GRID_SIZE-1, grid_info.y+GRID_SIZE-1, BACKGROUND_COLOR);
conantina 0:be33a1fad8c0 31 }
conantina 0:be33a1fad8c0 32
conantina 0:be33a1fad8c0 33 bool check_blk_occupied(unsigned int blk_x, unsigned int blk_y)
conantina 0:be33a1fad8c0 34 {
conantina 0:be33a1fad8c0 35 if (map_get_grid_status(blk_x,blk_y).status==GRID_WALL)
conantina 0:be33a1fad8c0 36 return true;
conantina 0:be33a1fad8c0 37 else
conantina 0:be33a1fad8c0 38 return false;
conantina 0:be33a1fad8c0 39 }
conantina 0:be33a1fad8c0 40
conantina 0:be33a1fad8c0 41 void draw_ghost(unsigned int blk_x, unsigned int blk_y, unsigned int ghost_color)
conantina 0:be33a1fad8c0 42 {
conantina 0:be33a1fad8c0 43 GRID grid = map_get_grid_status(blk_x, blk_y);
conantina 0:be33a1fad8c0 44 unsigned pos_x = grid.x + GRID_RADIUS;
conantina 0:be33a1fad8c0 45 unsigned pos_y = grid.y + GRID_RADIUS;
conantina 0:be33a1fad8c0 46 uLCD.filled_circle(pos_x,pos_y,GRID_RADIUS,ghost_color);
conantina 0:be33a1fad8c0 47 uLCD.filled_rectangle(pos_x-GRID_RADIUS,pos_y,pos_x+GRID_RADIUS,pos_y+GRID_RADIUS,ghost_color);
conantina 0:be33a1fad8c0 48 uLCD.filled_circle(pos_x+1,pos_y-1,1,BLACK);
conantina 0:be33a1fad8c0 49 uLCD.filled_circle(pos_x-1,pos_y-1,1,BLACK);
conantina 0:be33a1fad8c0 50 }
conantina 0:be33a1fad8c0 51
conantina 0:be33a1fad8c0 52 void ghost_move(GHOST * g, unsigned int new_blk_x, unsigned int new_blk_y)
conantina 0:be33a1fad8c0 53 {
conantina 0:be33a1fad8c0 54 // clean up ghost at old position
conantina 0:be33a1fad8c0 55 clean_blk(g->x, g->y);
conantina 0:be33a1fad8c0 56 // clean the block at new position
conantina 0:be33a1fad8c0 57 clean_blk(new_blk_x, new_blk_y);
conantina 0:be33a1fad8c0 58 // draw the ghost at new position
conantina 0:be33a1fad8c0 59 draw_ghost(new_blk_x, new_blk_y, g->color);
conantina 0:be33a1fad8c0 60
conantina 0:be33a1fad8c0 61 // recover map component
conantina 0:be33a1fad8c0 62 map_draw_grid(g->x, g->y);
conantina 0:be33a1fad8c0 63
conantina 0:be33a1fad8c0 64 g->x = new_blk_x;
conantina 0:be33a1fad8c0 65 g->y = new_blk_y;
conantina 0:be33a1fad8c0 66 }
conantina 0:be33a1fad8c0 67
conantina 0:be33a1fad8c0 68 // move ghost up/down/left/right
conantina 0:be33a1fad8c0 69 // return false if failed. true if success
conantina 0:be33a1fad8c0 70 bool ghost_up(GHOST * g)
conantina 0:be33a1fad8c0 71 {
conantina 0:be33a1fad8c0 72 if (check_blk_occupied(g->x, g->y-1)) return false;
conantina 0:be33a1fad8c0 73 if (g->y==0)
conantina 0:be33a1fad8c0 74 ghost_move(g, g->x, (NUM_GRID_Y-1));
conantina 0:be33a1fad8c0 75 else
conantina 0:be33a1fad8c0 76 ghost_move(g, g->x, g->y-1);
conantina 0:be33a1fad8c0 77 return true;
conantina 0:be33a1fad8c0 78 }
conantina 0:be33a1fad8c0 79 bool ghost_down(GHOST * g)
conantina 0:be33a1fad8c0 80 {
conantina 0:be33a1fad8c0 81 if (check_blk_occupied(g->x, g->y+1)) return false;
conantina 0:be33a1fad8c0 82
conantina 0:be33a1fad8c0 83 if (g->y==(NUM_GRID_Y-1))
conantina 0:be33a1fad8c0 84 ghost_move(g, g->x, 0);
conantina 0:be33a1fad8c0 85 else
conantina 0:be33a1fad8c0 86 ghost_move(g, g->x, g->y+1);
conantina 0:be33a1fad8c0 87 return true;
conantina 0:be33a1fad8c0 88 }
conantina 0:be33a1fad8c0 89
conantina 0:be33a1fad8c0 90 bool ghost_left(GHOST * g)
conantina 0:be33a1fad8c0 91 {
conantina 0:be33a1fad8c0 92 if (check_blk_occupied(g->x-1, g->y)) return false;
conantina 0:be33a1fad8c0 93 if (g->x==0)
conantina 0:be33a1fad8c0 94 ghost_move(g, (NUM_GRID_X-1), g->y);
conantina 0:be33a1fad8c0 95 else
conantina 0:be33a1fad8c0 96 ghost_move(g, g->x-1, g->y);
conantina 0:be33a1fad8c0 97 return true;
conantina 0:be33a1fad8c0 98 }
conantina 0:be33a1fad8c0 99 bool ghost_right(GHOST * g)
conantina 0:be33a1fad8c0 100 {
conantina 0:be33a1fad8c0 101 if (check_blk_occupied(g->x+1, g->y)) return false;
conantina 0:be33a1fad8c0 102 if (g->x==(NUM_GRID_X-1))
conantina 0:be33a1fad8c0 103 ghost_move(g, 0, g->y);
conantina 0:be33a1fad8c0 104 else
conantina 0:be33a1fad8c0 105 ghost_move(g, g->x+1, g->y);
conantina 0:be33a1fad8c0 106 return true;
conantina 0:be33a1fad8c0 107 }
conantina 0:be33a1fad8c0 108
conantina 0:be33a1fad8c0 109 void gen_random_direction(GHOST * g)
conantina 0:be33a1fad8c0 110 {
conantina 0:be33a1fad8c0 111 bool blocked[4];
conantina 0:be33a1fad8c0 112 blocked[0] = check_blk_occupied(g->x, g->y-1); //up
conantina 0:be33a1fad8c0 113 blocked[1] = check_blk_occupied(g->x, g->y+1); //down
conantina 0:be33a1fad8c0 114 blocked[2] = check_blk_occupied(g->x-1, g->y); //left
conantina 0:be33a1fad8c0 115 blocked[3] = check_blk_occupied(g->x+1, g->y); //right
conantina 0:be33a1fad8c0 116
conantina 0:be33a1fad8c0 117 unsigned int npath=0;
conantina 0:be33a1fad8c0 118 unsigned int outcome=0;
conantina 0:be33a1fad8c0 119 if (blocked[0]==false) npath++;
conantina 0:be33a1fad8c0 120 if (blocked[1]==false) npath++;
conantina 0:be33a1fad8c0 121 if (blocked[2]==false) npath++;
conantina 0:be33a1fad8c0 122 if (blocked[3]==false) npath++;
conantina 0:be33a1fad8c0 123
conantina 0:be33a1fad8c0 124 unsigned curr=(unsigned int) g->ghost_motion;
conantina 0:be33a1fad8c0 125 unsigned reverse;
conantina 0:be33a1fad8c0 126 if ((curr%2)==0)
conantina 0:be33a1fad8c0 127 reverse = curr+1;
conantina 0:be33a1fad8c0 128 else
conantina 0:be33a1fad8c0 129 reverse = curr-1;
conantina 0:be33a1fad8c0 130
conantina 0:be33a1fad8c0 131 unsigned off=rand();
conantina 0:be33a1fad8c0 132 for (int i=0;i<4;i++)
conantina 0:be33a1fad8c0 133 {
conantina 0:be33a1fad8c0 134 outcome=(off+i)%4;
conantina 0:be33a1fad8c0 135 // skip the reverse path if possible
conantina 0:be33a1fad8c0 136 if (npath>1 && reverse==outcome) continue;
conantina 0:be33a1fad8c0 137 if (blocked[outcome]==false) break;
conantina 0:be33a1fad8c0 138 }
conantina 0:be33a1fad8c0 139 g->ghost_motion = (GHOST_MOTION)outcome;
conantina 0:be33a1fad8c0 140
conantina 0:be33a1fad8c0 141 return;
conantina 0:be33a1fad8c0 142 }
conantina 0:be33a1fad8c0 143 //======================================================================================//
conantina 0:be33a1fad8c0 144 //All the function descriptions are in the ghost.h file
conantina 0:be33a1fad8c0 145
conantina 0:be33a1fad8c0 146 //Create a DLL for ghosts
conantina 0:be33a1fad8c0 147 DLinkedList* ghostDLL = NULL;
conantina 0:be33a1fad8c0 148
conantina 0:be33a1fad8c0 149
conantina 0:be33a1fad8c0 150 void ghost_init(void){
rconant6 1:fbda247b843b 151 ghostDLL = create_dlinkedlist();
conantina 0:be33a1fad8c0 152 }
conantina 0:be33a1fad8c0 153
conantina 0:be33a1fad8c0 154 // Public functions
conantina 0:be33a1fad8c0 155 void ghost_create(unsigned int blk_x, unsigned int blk_y, unsigned int color)
conantina 0:be33a1fad8c0 156 {
rconant6 1:fbda247b843b 157 GHOST* newGhost = (GHOST*)malloc(sizeof(GHOST));
rconant6 1:fbda247b843b 158 newGhost->x = blk_x;
rconant6 1:fbda247b843b 159 newGhost->y = blk_y;
rconant6 1:fbda247b843b 160 newGhost->color = color;
rconant6 1:fbda247b843b 161 insertHead(ghostDLL, (void*)newGhost);
conantina 0:be33a1fad8c0 162 }
conantina 0:be33a1fad8c0 163
conantina 0:be33a1fad8c0 164 DLinkedList* get_ghost_list(void) {
conantina 0:be33a1fad8c0 165 //Your code here
rconant6 1:fbda247b843b 166 return ghostDLL;
conantina 0:be33a1fad8c0 167 }
conantina 0:be33a1fad8c0 168
conantina 0:be33a1fad8c0 169 void ghost_show(DLinkedList* list)
conantina 0:be33a1fad8c0 170 {
conantina 0:be33a1fad8c0 171 //Your code here
conantina 0:be33a1fad8c0 172 //Functions like map_draw_grid, clean_blk, draw_ghost may be useful
rconant6 1:fbda247b843b 173 GHOST* newGhost = (GHOST*)getHead(list);
rconant6 1:fbda247b843b 174 while(newGhost){
rconant6 1:fbda247b843b 175 draw_ghost(newGhost->x,newGhost->y,newGhost->color);
rconant6 1:fbda247b843b 176 newGhost = (GHOST*)getNext(list);
rconant6 1:fbda247b843b 177 }
rconant6 1:fbda247b843b 178 }
rconant6 1:fbda247b843b 179
rconant6 1:fbda247b843b 180 int ghost_collision(DLinkedList* list, int pac_x, int pac_y, int invuln){
rconant6 1:fbda247b843b 181 GHOST* newGhost = (GHOST*)getHead(list);
rconant6 1:fbda247b843b 182 while(newGhost){
rconant6 1:fbda247b843b 183 if(newGhost->x == pac_x && newGhost->y == pac_y){
rconant6 1:fbda247b843b 184 if(invuln > 0){
rconant6 1:fbda247b843b 185 newGhost->ghost_motion = GHOST_DIED;
rconant6 1:fbda247b843b 186 return 10;
rconant6 1:fbda247b843b 187 }
rconant6 1:fbda247b843b 188 else{
rconant6 1:fbda247b843b 189 return 1;
rconant6 1:fbda247b843b 190 }
rconant6 1:fbda247b843b 191
rconant6 1:fbda247b843b 192 }
rconant6 1:fbda247b843b 193 newGhost = (GHOST*)getNext(list);
rconant6 1:fbda247b843b 194 }
rconant6 1:fbda247b843b 195 return 0;
conantina 0:be33a1fad8c0 196 }
conantina 0:be33a1fad8c0 197
conantina 0:be33a1fad8c0 198 void ghost_random_walk(void)
conantina 0:be33a1fad8c0 199 {
conantina 0:be33a1fad8c0 200 GHOST* newGhost = (GHOST*)getHead(ghostDLL);
conantina 0:be33a1fad8c0 201 while(newGhost){
conantina 0:be33a1fad8c0 202 if(newGhost->ghost_motion == GHOST_DIED){
conantina 0:be33a1fad8c0 203 //recover map grid
conantina 0:be33a1fad8c0 204 map_draw_grid(newGhost->x, newGhost->y);
conantina 0:be33a1fad8c0 205 //delete from the linked list
conantina 0:be33a1fad8c0 206 newGhost = (GHOST*)deleteForward(ghostDLL);
conantina 0:be33a1fad8c0 207 }else{
conantina 0:be33a1fad8c0 208 gen_random_direction(newGhost);
conantina 0:be33a1fad8c0 209 switch (newGhost->ghost_motion) {
conantina 0:be33a1fad8c0 210 case GHOST_UP:
conantina 0:be33a1fad8c0 211 ghost_up(newGhost);
conantina 0:be33a1fad8c0 212 break;
conantina 0:be33a1fad8c0 213 case GHOST_DOWN:
conantina 0:be33a1fad8c0 214 ghost_down(newGhost);
conantina 0:be33a1fad8c0 215 break;
conantina 0:be33a1fad8c0 216 case GHOST_LEFT:
conantina 0:be33a1fad8c0 217 ghost_left(newGhost);
conantina 0:be33a1fad8c0 218 break;
conantina 0:be33a1fad8c0 219 case GHOST_RIGHT:
conantina 0:be33a1fad8c0 220 ghost_right(newGhost);
conantina 0:be33a1fad8c0 221 break;
conantina 0:be33a1fad8c0 222 default:
conantina 0:be33a1fad8c0 223 break;
conantina 0:be33a1fad8c0 224 }
conantina 0:be33a1fad8c0 225 }
conantina 0:be33a1fad8c0 226 //advance the loop
conantina 0:be33a1fad8c0 227 newGhost = (GHOST*)getNext(ghostDLL);
conantina 0:be33a1fad8c0 228 }
conantina 0:be33a1fad8c0 229 }
conantina 0:be33a1fad8c0 230
conantina 0:be33a1fad8c0 231 //=======================================================================//
conantina 0:be33a1fad8c0 232