?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Reinitialize console text / font on resolution change
[attac-man.git] / ghost.c
blob54cee9bd670c7b329837b8ac51671f373224ba00
1 /*
2 Pacman Arena
3 Copyright (C) 2003 Nuno Subtil
4
5 This program is free software; you can redistribute it and/or
6 modify it under the terms of the GNU General Public License
7 as published by the Free Software Foundation; either version 2
8 of the License, or (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 */
19
20 static const char cvsid[] =
21 "$Id: ghost.c,v 1.21 2003/11/22 17:07:42 nsubtil Exp $";
22
23 #ifdef _WIN32
24 #include <windows.h>
25 #endif
26
27 #include <GL/gl.h>
28 #include <SDL.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32
33 #include "m_math.h"
34 #include "object.h"
35 #include "game.h"
36 #include "map.h"
37 #include "ghost.h"
38 #include "player.h"
39 #include "render.h"
40 #include "audio.h"
41
42 GLfloat ghost_colors[4][4] = {
43 {GHOST_GREEN}, {GHOST_RED}, {GHOST_MAGENTA}, {GHOST_ORANGE}
44 };
45 int num_ghost_colors = 4;
46
47 void ghost_taint_all(struct game *game)
48 {
49 int c;
50
51 for(c = 0; c < game->n_ghosts; c++)
52 if(!game->ghosts[c].tainted && game->ghosts[c].state == GHOST_STATE_ACTIVE)
53 {
54 game->ghosts[c].tainted = 1;
55 game->ghosts[c].speed /= 2.0;
56 }
57 }
58
59 void ghost_untaint_all(struct game *game)
60 {
61 int c;
62
63 for(c = 0; c < game->n_ghosts; c++)
64 if(game->ghosts[c].tainted)
65 {
66 game->ghosts[c].tainted = 0;
67 game->ghosts[c].speed *= 2.0;
68 }
69 }
70
71 void ghost_reset_all(struct game *game)
72 {
73 int cx, cy;
74 struct map *map;
75
76 map = game->map;
77
78 if(game->ghosts)
79 free(game->ghosts);
80
81 game->ghosts = NULL;
82 game->n_ghosts = 0;
83
84 for(cx = 0; cx < map->width; cx++)
85 for(cy = 0; cy < map->height; cy++)
86 if(MAP(map, cx, cy).flags & MAP_FLAG_GHOST_START_POSITION)
87 {
88 struct ghost *new;
89
90 game->n_ghosts++;
91 game->ghosts = realloc(game->ghosts,
92 sizeof(struct ghost) * game->n_ghosts);
93
94 new = &game->ghosts[game->n_ghosts - 1];
95 new->state = GHOST_STATE_ACTIVE;
96
97 new->position[X] = (float)cx + 0.5;
98 new->position[Y] = -0.5;
99 new->position[Z] = (float)cy + 0.5;
100
101 new->direction = DIRECTION_UP;
102 new->speed = GHOST_SPEED;
103
104 new->model_active =
105 object_read_file("gfx/ghost-green-moving.3d",
106 &new->frames_active);
107
108 new->model_dying =
109 object_read_file("gfx/ghost-green-dying.3d",
110 &new->frames_dying);
111
112 new->model_dead = &new->model_dying[new->frames_dying - 1];
113 new->frames_dead = 1;
114
115 new->model_returning =
116 object_read_file("gfx/ghost-green-returning.3d",
117 &new->frames_returning);
118
119 new->current_frame = (float)(rand() % new->frames_active);
120 new->time = 0.0;
121 new->view_distance = 10;
122
123 new->color = ghost_colors[(game->n_ghosts - 1) % num_ghost_colors];
124 new->tainted = 0;
125 }
126 }
127
128 void ghost_kill(struct game *game, struct ghost *g)
129 {
130 g->state = GHOST_STATE_DYING;
131 g->current_frame = 0.0;
132 audio_play_sample("sfx/eat-ghost.wav");
133 }
134
135 void ghost_update(struct game *game, int ghost_no, float delta)
136 {
137 float new_position[3], vec[2];
138 float frac_x, frac_z, dest_x, dest_z;
139 struct ghost *g;
140 struct map *map;
141 int keep_moving = 1, verify = 0;
142
143 g = &game->ghosts[ghost_no];
144 map = game->map;
145
146 switch(g->state)
147 {
148 case GHOST_STATE_DYING:
149 g->current_frame += delta * ANIM_FPS;
150
151 if(g->current_frame >= (float)g->frames_dying)
152 {
153 g->state = GHOST_STATE_DEAD;
154 g->current_frame = 0.0;
155 if(g->tainted)
156 {
157 g->tainted = 0;
158 g->speed *= 2.0;
159 }
160
161 }
162
163 return;
164
165 case GHOST_STATE_RETURNING:
166 g->current_frame += delta * ANIM_FPS;
167
168 if(g->current_frame >= (float)g->frames_returning)
169 {
170 g->state = GHOST_STATE_ACTIVE;
171 g->current_frame = 0.0;
172 }
173
174 return;
175 }
176
177 g->time -= delta;
178 if(g->time <= 0.0)
179 keep_moving = 0;
180
181 new_position[X] = g->position[X];
182 new_position[Y] = g->position[Y];
183 new_position[Z] = g->position[Z];
184
185 frac_x = g->position[X] - (float)((int)g->position[X]);
186 frac_z = g->position[Z] - (float)((int)g->position[Z]);
187
188 dest_x = (int)g->position[X] + 0.5;
189 dest_z = (int)g->position[Z] + 0.5;
190
191 switch(g->direction)
192 {
193 case DIRECTION_UP:
194 new_position[Z] += MIN(delta * g->speed, 0.5);
195
196 if(frac_z > 0.5)
197 dest_z += 1.0;
198
199 if(new_position[Z] > dest_z)
200 {
201 verify = 1;
202
203 if(keep_moving)
204 {
205 g->position[X] = new_position[X];
206 g->position[Z] = new_position[Z];
207 } else {
208 g->position[X] = dest_x;
209 g->position[Z] = dest_z;
210 ghost_new_direction(game, g);
211 }
212 } else {
213 if(MAP_CAN_ENTER_GHOST(map, (int)dest_x, (int)dest_z))
214 {
215 g->position[X] = new_position[X];
216 g->position[Z] = new_position[Z];
217 } else {
218
219 g->position[X] = dest_x;
220 g->position[Z] = dest_z - 1.0;
221 do {
222 ghost_new_direction(game, g);
223 } while(g->direction == DIRECTION_UP &&
224 g->state != GHOST_STATE_DEAD);
225 }
226 }
227
228 break;
229
230 case DIRECTION_DOWN:
231 new_position[Z] -= MIN(delta * g->speed, 0.5);
232
233 if(frac_z < 0.5)
234 dest_z -= 1.0;
235
236 if(new_position[Z] < dest_z)
237 {
238 verify = 1;
239
240 if(keep_moving)
241 {
242 g->position[X] = new_position[X];
243 g->position[Z] = new_position[Z];
244 } else {
245 g->position[X] = dest_x;
246 g->position[Z] = dest_z;
247 ghost_new_direction(game, g);
248 }
249 } else {
250 if(MAP_CAN_ENTER_GHOST(map, (int)dest_x, (int)dest_z))
251 {
252 g->position[X] = new_position[X];
253 g->position[Z] = new_position[Z];
254 } else {
255
256 g->position[X] = dest_x;
257 g->position[Z] = dest_z + 1.0;
258 do {
259 ghost_new_direction(game, g);
260 } while(g->direction == DIRECTION_DOWN &&
261 g->state != GHOST_STATE_DEAD);
262 }
263 }
264
265 break;
266
267 case DIRECTION_LEFT:
268 new_position[X] -= MIN(delta * g->speed, 0.5);
269
270 if(frac_x < 0.5)
271 dest_x -= 1.0;
272
273 if(new_position[X] < dest_x)
274 {
275 verify = 1;
276
277 if(keep_moving)
278 {
279 g->position[X] = new_position[X];
280 g->position[Z] = new_position[Z];
281 } else {
282 g->position[X] = dest_x;
283 g->position[Z] = dest_z;
284 ghost_new_direction(game, g);
285 }
286 } else {
287 if(MAP_CAN_ENTER_GHOST(map, (int)dest_x, (int)dest_z))
288 {
289 g->position[X] = new_position[X];
290 g->position[Z] = new_position[Z];
291 } else {
292
293 g->position[X] = dest_x + 1.0;
294 g->position[Z] = dest_z;
295 do {
296 ghost_new_direction(game, g);
297 } while(g->direction == DIRECTION_LEFT &&
298 g->state != GHOST_STATE_DEAD);
299 }
300 }
301
302 break;
303
304 case DIRECTION_RIGHT:
305 new_position[X] += MIN(delta * g->speed, 0.5);
306
307 if(frac_x > 0.5)
308 dest_x += 1.0;
309
310 if(new_position[X] > dest_x)
311 {
312 verify = 1;
313
314 if(keep_moving)
315 {
316 g->position[X] = new_position[X];
317 g->position[Z] = new_position[Z];
318 } else {
319 g->position[X] = dest_x;
320 g->position[Z] = dest_z;
321 ghost_new_direction(game, g);
322 }
323 } else {
324 if(MAP_CAN_ENTER_GHOST(map, (int)dest_x, (int)dest_z))
325 {
326 g->position[X] = new_position[X];
327 g->position[Z] = new_position[Z];
328 } else {
329
330 g->position[X] = dest_x - 1.0;
331 g->position[Z] = dest_z;
332 do {
333 ghost_new_direction(game, g);
334 } while(g->direction == DIRECTION_RIGHT &&
335 g->state != GHOST_STATE_DEAD);
336 }
337 }
338
339 break;
340 }
341
342 if(g->time <= 0.0)
343 ghost_new_direction(game, g);
344
345 vec[X] = g->position[X] - (float)((int)g->position[X]);
346 vec[Y] = g->position[Z] - (float)((int)g->position[Z]);
347 if(verify || math_norm_vec2(vec) <= 0.1)
348 {
349 if(MAP(map, (int)g->position[X], (int)g->position[Z]).flags & MAP_FLAG_GHOST_START_POSITION)
350 if(g->state == GHOST_STATE_DEAD)
351 {
352 g->state = GHOST_STATE_RETURNING;
353 g->current_frame = 0.0;
354 audio_play_sample("sfx/ghost-return.wav");
355 return;
356 }
357
358 switch(MAP(map, (int)g->position[X], (int)g->position[Z]).ghost_dir_alive)
359 {
360 case DIRECTION_UP:
361 if(g->state == GHOST_STATE_ACTIVE)
362 {
363 g->direction = DIRECTION_UP;
364 g->time = 1.0 / g->speed;
365 }
366
367 break;
368
369 default:
370 {
371 int dir, dist;
372
373 dir = ghost_check_visibility(game, g, &dist);
374 if(dir != -1)
375 {
376 /* jogador por perto */
377 g->direction = dir;
378 g->time = dist / g->speed;
379 }
380 }
381 }
382 }
383
384 /* animação */
385 g->current_frame = g->current_frame + delta * ANIM_FPS;
386
387 ghost_detect_player_collisions(game, g);
388 ghost_detect_ghost_collisions(game, g);
389 }
390
391 void ghost_detect_ghost_collisions(struct game *game, struct ghost *g)
392 {
393 int c;
394 float vec[3];
395 struct map *map;
396
397 map = game->map;
398
399 for(c = 0; c < game->n_ghosts; c++)
400 {
401 math_sub_vec3(vec, g->position, game->ghosts[c].position);
402
403 if(math_norm_vec3(vec) < 0.7)
404 {
405 int gx, gy, ox, oy;
406
407 if(math_norm_vec3(vec) == 0.0)
408 /* sou eu */
409 continue;
410
411 if(g->direction == DIRECTION_STOPPED)
412 /* já colidiu */
413 continue;
414
415 gx = (int)g->position[X];
416 gy = (int)g->position[Z];
417
418 ox = (int)game->ghosts[c].position[X];
419 oy = (int)game->ghosts[c].position[Z];
420
421 if(rand() % 2)
422 {
423 /* escapatória para g */
424 if(MAP_CAN_ENTER_GHOST(map, gx, gy + 1) &&
425 !ghost_in_position(game, gx, gy + 1))
426 {
427 g->direction = DIRECTION_UP;
428 g->time = 1.0;
429
430 // ghosts[c].direction = DIRECTION_STOPPED;
431 // ghosts[c].time = 0.25;
432 continue;
433 }
434
435 if(MAP_CAN_ENTER_GHOST(map, gx, gy - 1) &&
436 !ghost_in_position(game, gx, gy - 1))
437 {
438 g->direction = DIRECTION_DOWN;
439 g->time = 1.0;
440
441 // ghosts[c].direction = DIRECTION_STOPPED;
442 // ghosts[c].time = 0.25;
443 continue;
444 }
445
446 if(MAP_CAN_ENTER_GHOST(map, gx - 1, gy) &&
447 !ghost_in_position(game, gx - 1, gy))
448 {
449 g->direction = DIRECTION_LEFT;
450 g->time = 1.0;
451
452 // ghosts[c].direction = DIRECTION_STOPPED;
453 // ghosts[c].time = 0.25;
454 continue;
455 }
456
457 if(MAP_CAN_ENTER_GHOST(map, gx + 1, gy) &&
458 !ghost_in_position(game, gx + 1, gy))
459 {
460 g->direction = DIRECTION_RIGHT;
461 g->time = 1.0;
462
463 // ghosts[c].direction = DIRECTION_STOPPED;
464 // ghosts[c].time = 0.25;
465 continue;
466 }
467
468 /* escapatória para ghosts[c] */
469 g->direction = DIRECTION_STOPPED;
470 g->time = 0.0;
471
472 if(MAP_CAN_ENTER_GHOST(map, ox, oy + 1) &&
473 !ghost_in_position(game, ox, oy + 1))
474 {
475 game->ghosts[c].direction = DIRECTION_UP;
476 game->ghosts[c].time = 1.0;
477 continue;
478 }
479
480 if(MAP_CAN_ENTER_GHOST(map, ox, oy - 1) &&
481 !ghost_in_position(game, ox, oy - 1))
482 {
483 game->ghosts[c].direction = DIRECTION_DOWN;
484 game->ghosts[c].time = 1.0;
485 continue;
486 }
487
488 if(MAP_CAN_ENTER_GHOST(map, ox - 1, oy) &&
489 !ghost_in_position(game, ox - 1, oy))
490 {
491 game->ghosts[c].direction = DIRECTION_LEFT;
492 game->ghosts[c].time = 1.0;
493 continue;
494 }
495
496 if(MAP_CAN_ENTER_GHOST(map, ox + 1, oy) &&
497 !ghost_in_position(game, ox + 1, oy))
498 {
499 game->ghosts[c].direction = DIRECTION_RIGHT;
500 game->ghosts[c].time = 1.0;
501 continue;
502 }
503
504 game->ghosts[c].direction = DIRECTION_STOPPED;
505 game->ghosts[c].time = 0.25;
506 } else {
507 /* escapatória para ghosts[c] */
508 if(MAP_CAN_ENTER_GHOST(map, ox, oy + 1) &&
509 !ghost_in_position(game, ox, oy + 1))
510 {
511 game->ghosts[c].direction = DIRECTION_UP;
512 game->ghosts[c].time = 1.0;
513
514 // g->direction = DIRECTION_STOPPED;
515 // g->time = 0.25;
516 continue;
517 }
518
519 if(MAP_CAN_ENTER_GHOST(map, ox, oy - 1) &&
520 !ghost_in_position(game, ox, oy - 1))
521 {
522 game->ghosts[c].direction = DIRECTION_DOWN;
523 game->ghosts[c].time = 1.0;
524
525 // g->direction = DIRECTION_STOPPED;
526 // g->time = 0.25;
527 continue;
528 }
529
530 if(MAP_CAN_ENTER_GHOST(map, ox - 1, oy) &&
531 !ghost_in_position(game, ox - 1, oy))
532 {
533 game->ghosts[c].direction = DIRECTION_LEFT;
534 game->ghosts[c].time = 1.0;
535
536 // g->direction = DIRECTION_STOPPED;
537 // g->time = 0.25;
538 continue;
539 }
540
541 if(MAP_CAN_ENTER_GHOST(map, ox + 1, oy) &&
542 !ghost_in_position(game, ox + 1, oy))
543 {
544 game->ghosts[c].direction = DIRECTION_RIGHT;
545 game->ghosts[c].time = 1.0;
546
547 // g->direction = DIRECTION_STOPPED;
548 // g->time = 0.25;
549 continue;
550 }
551
552 game->ghosts[c].direction = DIRECTION_STOPPED;
553 game->ghosts[c].time = 0.0;
554
555 /* escapatória para g */
556 if(MAP_CAN_ENTER_GHOST(map, gx, gy + 1) &&
557 !ghost_in_position(game, gx, gy + 1))
558 {
559 g->direction = DIRECTION_UP;
560 g->time = 1.0;
561 continue;
562 }
563
564 if(MAP_CAN_ENTER_GHOST(map, gx, gy - 1) &&
565 !ghost_in_position(game, gx, gy - 1))
566 {
567 g->direction = DIRECTION_DOWN;
568 g->time = 1.0;
569 continue;
570 }
571
572 if(MAP_CAN_ENTER_GHOST(map, gx - 1, gy) &&
573 !ghost_in_position(game, gx - 1, gy))
574 {
575 g->direction = DIRECTION_LEFT;
576 g->time = 1.0;
577 continue;
578 }
579
580 if(MAP_CAN_ENTER_GHOST(map, gx + 1, gy) &&
581 !ghost_in_position(game, gx + 1, gy))
582 {
583 g->direction = DIRECTION_RIGHT;
584 g->time = 1.0;
585 continue;
586 }
587
588 g->direction = DIRECTION_STOPPED;
589 g->time = 0.25;
590 }
591 }
592 }
593 }
594
595 int ghost_in_position(struct game *game, int x, int y)
596 {
597 int c;
598
599 for(c = 0; c < game->n_ghosts; c++)
600 if((int)game->ghosts[c].position[X] == x &&
601 (int)game->ghosts[c].position[Z] == y)
602 return 1;
603
604 return 0;
605 }
606
607 void ghost_detect_player_collisions(struct game *game, struct ghost *g)
608 {
609 int c;
610 float vec[3];
611
612 if(g->state != GHOST_STATE_ACTIVE)
613 return;
614
615 for(c = 0; c < game->n_players; c++)
616 {
617 if(game->players[c].state == PLAYER_STATE_DEAD)
618 continue;
619
620 math_sub_vec3(vec, g->position, game->players[c].position);
621 if(math_norm_vec3(vec) < 0.7)
622 {
623 /* fantasma bateu num jogador */
624 if(game->players[c].pill_time > 0.0)
625 {
626 /* uh oh, fantasma comido */
627 game->players[c].score += (100 * game->players[c].multiplier);
628 game->players[c].multiplier <<= 1;
629 ghost_kill(game, g);
630 return;
631 }
632
633 switch(g->direction)
634 {
635 case DIRECTION_UP:
636 g->direction = DIRECTION_DOWN;
637 break;
638
639 case DIRECTION_DOWN:
640 g->direction = DIRECTION_UP;
641 break;
642
643 case DIRECTION_LEFT:
644 g->direction = DIRECTION_RIGHT;
645 break;
646
647 case DIRECTION_RIGHT:
648 g->direction = DIRECTION_LEFT;
649 break;
650 }
651
652 g->time = 1.0 / g->speed;
653
654 player_kill(game, c);
655 return;
656 }
657 }
658 }
659
660 /*
661 devolve a direcção de um jogador próximo (distância em dist)
662 ou -1 se não houver
663 */
664 int ghost_check_visibility(struct game *game, struct ghost *g, int *r_dist)
665 {
666 int c, px, py, gx, gy, dist, player_no;
667 struct map *map;
668
669 map = game->map;
670 gx = (int)g->position[X];
671 gy = (int)g->position[Z];
672
673 if(g->state == GHOST_STATE_DEAD)
674 return -1;
675
676 /* determinar visibilidade de jogadores próximos */
677 for(player_no = 0; player_no < game->n_players; player_no++)
678 {
679 if(game->players[player_no].state == PLAYER_STATE_DEAD)
680 continue;
681
682 px = (int)game->players[player_no].position[X];
683 py = (int)game->players[player_no].position[Z];
684
685 if(py == gy)
686 {
687 dist = gx - px;
688 if(dist < 0)
689 dist = -dist;
690
691 if(dist > g->view_distance)
692 /* muito longe */
693 continue;
694
695 if(px < gx)
696 {
697 for(c = gx - 1; c > px; c--)
698 if(!MAP_CAN_ENTER_GHOST(map, c, py))
699 /* não chega lá */
700 break;
701
702 if(c == px)
703 {
704 /* jogador à esquerda */
705 *r_dist = dist;
706
707 if(game->players[player_no].pill_time > 0.0)
708 {
709 /* fugir! */
710 *r_dist = 1;
711
712 if(MAP_CAN_ENTER_GHOST(map,
713 (int)g->position[X] + 1,
714 (int)g->position[Z]))
715 return DIRECTION_RIGHT;
716
717 if(MAP_CAN_ENTER_GHOST(map,
718 (int)g->position[X],
719 (int)g->position[Z] + 1))
720 return DIRECTION_UP;
721
722 if(MAP_CAN_ENTER_GHOST(map,
723 (int)g->position[X],
724 (int)g->position[Z] - 1))
725 return DIRECTION_DOWN;
726
727 /* sem hipótese de fugir */
728 }
729
730 return DIRECTION_LEFT;
731 }
732 } else {
733 for(c = gx + 1; c < px; c++)
734 if(!MAP_CAN_ENTER_GHOST(map, c, py))
735 break;
736
737 if(c == px)
738 {
739 /* jogador à direita */
740 *r_dist = dist;
741
742 if(game->players[player_no].pill_time > 0.0)
743 {
744 /* fugir! */
745 *r_dist = 1;
746
747 if(MAP_CAN_ENTER_GHOST(map,
748 (int)g->position[X] - 1,
749 (int)g->position[Z]))
750 return DIRECTION_LEFT;
751
752 if(MAP_CAN_ENTER_GHOST(map,
753 (int)g->position[X],
754 (int)g->position[Z] + 1))
755 return DIRECTION_UP;
756
757 if(MAP_CAN_ENTER_GHOST(map,
758 (int)g->position[X],
759 (int)g->position[Z] - 1))
760 return DIRECTION_DOWN;
761 }
762
763 return DIRECTION_RIGHT;
764 }
765 }
766 }
767
768 if(px == gx)
769 {
770 dist = gy - py;
771 if(dist < 0)
772 dist = -dist;
773
774 if(dist > g->view_distance)
775 continue;
776
777 if(py < gy)
778 {
779 for(c = gy - 1; c > py; c--)
780 if(!MAP_CAN_ENTER_GHOST(map, px, c))
781 break;
782
783 if(c == py)
784 {
785 /* jogador abaixo */
786 *r_dist = dist;
787
788 if(game->players[player_no].pill_time > 0.0)
789 {
790 *r_dist = 1;
791
792 if(MAP_CAN_ENTER_GHOST(map,
793 (int)g->position[X],
794 (int)g->position[Z] + 1))
795 return DIRECTION_UP;
796
797 if(MAP_CAN_ENTER_GHOST(map,
798 (int)g->position[X] - 1,
799 (int)g->position[Z]))
800 return DIRECTION_LEFT;
801
802 if(MAP_CAN_ENTER_GHOST(map,
803 (int)g->position[X] + 1,
804 (int)g->position[Z]))
805 return DIRECTION_RIGHT;
806 }
807
808 return DIRECTION_DOWN;
809 }
810 } else {
811 for(c = gy + 1; c < py; c++)
812 if(!MAP_CAN_ENTER_GHOST(map, px, c))
813 break;
814
815 if(c == py)
816 {
817 /* jogador acima */
818 *r_dist = dist;
819
820 if(game->players[player_no].pill_time > 0.0)
821 {
822 *r_dist = 1;
823
824 if(MAP_CAN_ENTER_GHOST(map,
825 (int)g->position[X],
826 (int)g->position[Z] - 1))
827 return DIRECTION_DOWN;
828
829 if(MAP_CAN_ENTER_GHOST(map,
830 (int)g->position[X] - 1,
831 (int)g->position[Z]))
832 return DIRECTION_LEFT;
833
834 if(MAP_CAN_ENTER_GHOST(map,
835 (int)g->position[X] + 1,
836 (int)g->position[Z]))
837 return DIRECTION_RIGHT;
838 }
839
840 return DIRECTION_UP;
841 }
842 }
843 }
844 }
845
846 return -1;
847 }
848
849 void ghost_new_direction(struct game *game, struct ghost *g)
850 {
851 int dir, dist;
852 struct map *map;
853
854 map = game->map;
855
856 /* XXX - eek! */
857 g->position[X] = (float)((int)g->position[X]) + 0.5;
858 g->position[Z] = (float)((int)g->position[Z]) + 0.5;
859
860 if(g->state == GHOST_STATE_DEAD)
861 {
862 g->time = 1.0 / g->speed;
863
864 switch(MAP(map, (int)g->position[X], (int)g->position[Z]).ghost_dir)
865 {
866 case DIRECTION_UP:
867 g->direction = DIRECTION_UP;
868 break;
869
870 case DIRECTION_DOWN:
871 g->direction = DIRECTION_DOWN;
872 break;
873
874 case DIRECTION_LEFT:
875 g->direction = DIRECTION_LEFT;
876 break;
877
878 case DIRECTION_RIGHT:
879 g->direction = DIRECTION_RIGHT;
880 break;
881
882 default:
883 if(MAP(map, (int)g->position[X], (int)g->position[Z]).flags & MAP_FLAG_GHOST_START_POSITION)
884 {
885 g->time = 0.0;
886 break;
887 }
888
889 printf("ghost_new_direction: que raio está um (hmm...) a fazer no mapa ? (%d %d)\n", (int)g->position[X], (int)g->position[Z]);
890 fflush(stdout);
891 SDL_Quit();
892 exit(1);
893
894 break;
895 }
896
897 return;
898 }
899
900 dir = ghost_check_visibility(game, g, &dist);
901 if(dir == -1)
902 {
903 /* não há jogadores visíveis, direcção aleatória */
904 g->direction = rand() % DIRECTION_COUNT;
905 g->time = (float)(rand() % 5) + 1.0;
906 } else {
907 g->direction = dir;
908 g->time = dist / g->speed;
909 }
910 }
multi-player pac-man clone