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@0:be33a1fad8c0, 2017-02-24 (annotated)

Committer:
conantina
Date:
Fri Feb 24 17:33:27 2017 +0000
Revision:
0:be33a1fad8c0
Child:
1:fbda247b843b
PacMan_Skeleton for student

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){
conantina 0:be33a1fad8c0 151 //Your code here
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 {
conantina 0:be33a1fad8c0 157 //Your code here
conantina 0:be33a1fad8c0 158 }
conantina 0:be33a1fad8c0 159
conantina 0:be33a1fad8c0 160 DLinkedList* get_ghost_list(void) {
conantina 0:be33a1fad8c0 161 //Your code here
conantina 0:be33a1fad8c0 162 return NULL;
conantina 0:be33a1fad8c0 163 }
conantina 0:be33a1fad8c0 164
conantina 0:be33a1fad8c0 165 void ghost_show(DLinkedList* list)
conantina 0:be33a1fad8c0 166 {
conantina 0:be33a1fad8c0 167 //Your code here
conantina 0:be33a1fad8c0 168 //Functions like map_draw_grid, clean_blk, draw_ghost may be useful
conantina 0:be33a1fad8c0 169 }
conantina 0:be33a1fad8c0 170
conantina 0:be33a1fad8c0 171 void ghost_random_walk(void)
conantina 0:be33a1fad8c0 172 {
conantina 0:be33a1fad8c0 173 GHOST* newGhost = (GHOST*)getHead(ghostDLL);
conantina 0:be33a1fad8c0 174 while(newGhost){
conantina 0:be33a1fad8c0 175 if(newGhost->ghost_motion == GHOST_DIED){
conantina 0:be33a1fad8c0 176 //recover map grid
conantina 0:be33a1fad8c0 177 map_draw_grid(newGhost->x, newGhost->y);
conantina 0:be33a1fad8c0 178 //delete from the linked list
conantina 0:be33a1fad8c0 179 newGhost = (GHOST*)deleteForward(ghostDLL);
conantina 0:be33a1fad8c0 180 }else{
conantina 0:be33a1fad8c0 181 gen_random_direction(newGhost);
conantina 0:be33a1fad8c0 182 switch (newGhost->ghost_motion) {
conantina 0:be33a1fad8c0 183 case GHOST_UP:
conantina 0:be33a1fad8c0 184 ghost_up(newGhost);
conantina 0:be33a1fad8c0 185 break;
conantina 0:be33a1fad8c0 186 case GHOST_DOWN:
conantina 0:be33a1fad8c0 187 ghost_down(newGhost);
conantina 0:be33a1fad8c0 188 break;
conantina 0:be33a1fad8c0 189 case GHOST_LEFT:
conantina 0:be33a1fad8c0 190 ghost_left(newGhost);
conantina 0:be33a1fad8c0 191 break;
conantina 0:be33a1fad8c0 192 case GHOST_RIGHT:
conantina 0:be33a1fad8c0 193 ghost_right(newGhost);
conantina 0:be33a1fad8c0 194 break;
conantina 0:be33a1fad8c0 195 default:
conantina 0:be33a1fad8c0 196 break;
conantina 0:be33a1fad8c0 197 }
conantina 0:be33a1fad8c0 198 }
conantina 0:be33a1fad8c0 199 //advance the loop
conantina 0:be33a1fad8c0 200 newGhost = (GHOST*)getNext(ghostDLL);
conantina 0:be33a1fad8c0 201 }
conantina 0:be33a1fad8c0 202 }
conantina 0:be33a1fad8c0 203
conantina 0:be33a1fad8c0 204 //=======================================================================//
conantina 0:be33a1fad8c0 205