?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
console: Format tabs semi-intelligently
[attac-man.git] / game.c
blob03c21803d0f0e361485b7c8789f39fd67e4ea7c4
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: game.c,v 1.71 2003/11/30 17:43:55 nsubtil Exp $";
22
23 #ifdef _WIN32
24 #include <windows.h>
25 #endif
26
27 #include <GL/gl.h>
28 #include <GL/glu.h>
29 #include <SDL.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <math.h>
33
34 #include "object.h"
35 #include "audio.h"
36 #include "m_math.h"
37 #include "gfx.h"
38 #include "game.h"
39 #include "map.h"
40 #include "screen.h"
41 #include "render.h"
42 #include "shot.h"
43 #include "bomb.h"
44 #include "particle.h"
45 #include "input.h"
46 #include "score.h"
47
48 #include "player.h"
49 #include "ghost.h"
50
51 #include "render_map.h"
52 #include "render_ghost.h"
53 #include "render_player.h"
54 #include "render_shot.h"
55 #include "render_bomb.h"
56 #include "oglconsole.h"
57
58 #include "level-0.h"
59 //#include "level-classic.h"
60 //#include "level-demo.h"
61 //#include "level-1.h"
62
63 struct game *game_new(int game_type)
64 {
65 struct game *ret;
66
67 ret = (struct game *)malloc(sizeof(struct game));
68 ret->game_type = game_type;
69 ret->current_level = -1;
70 ret->n_players = 0;
71 ret->players = NULL;
72 ret->n_ghosts = 0;
73 ret->ghosts = NULL;
74 ret->n_shots = 0;
75 ret->bombs = NULL;
76 ret->n_bombs = 0;
77 ret->shots = NULL;
78 ret->map = NULL;
79 ret->demo_camera = NULL;
80
81 return ret;
82 }
83
84 void game_free(struct game *game)
85 {
86 if(game->players)
87 free(game->players);
88 if(game->ghosts)
89 free(game->ghosts);
90 if(game->map)
91 map_free(game->map);
92
93 free(game);
94 }
95
96 void game_run(struct game *game)
97 {
98 struct viewport *vp = screen_get_viewport(0);
99 int last_update, ticks;
100 int frames;
101 int c;
102 score_lock_t lock;
103
104 input_reset();
105
106 last_update = ticks = SDL_GetTicks();
107
108 game_start(game);
109
110 for(c = 0; c < game->n_players; c++)
111 {
112 render_reset_camera(game->players[c].camera);
113 game_reset_camera(game, c);
114 }
115
116 frames = 0;
117
118 audio_play_music("sfx/tranzy.ogg");
119
120 for(;;)
121 {
122 int diff;
123
124 input_update();
125
126 if(input_kstate(SDLK_ESCAPE))
127 {
128 audio_fade_music(500);
129 SDL_Delay(500);
130 return;
131 }
132
133 diff = SDL_GetTicks() - last_update;
134 game_update(game, (float)diff / 1000);
135 last_update = SDL_GetTicks();
136
137 render_start_frame();
138
139 for(c = 0; c < game->n_players; c++)
140 {
141 render_setup(game, c);
142
143 map_render_opaque_objects(game);
144 game_draw_opaque_objects(game, c);
145 map_render_translucent_objects(game, c);
146 game_draw_translucent_objects(game, c);
147 game_draw_player_lives(game, c, (float)diff / 1000);
148 }
149
150 /*
151 if(game->n_players == 1)
152 render_draw_logo();
153 */
154
155 render_setup_2d(vp);
156 render_finish_frame();
157 frames++;
158
159 if(SDL_GetTicks() - ticks >= 1000)
160 {
161 printf("%d FPS\n", frames);
162 ticks = SDL_GetTicks();
163 frames = 0;
164 }
165
166 if (game_count_dots(game) == 0 || game->players[0].lives == 0) {
167
168 con_printf("Final Score: %d\n", game->players[0].score);
169 lock = lock_scores();
170 if (lock >= 0) {
171 if (high_score(game->players[0].score)) {
172 add_high_score("xxx",
173 game->players[0].score);
174 rewrite_score_file();
175 }
176 unlock_scores(lock);
177 }
178 if (game_count_dots(game) == 0)
179 game_do_victory_loop(game);
180 else
181 game_do_defeat_loop(game);
182 return;
183 }
184
185 SDL_Delay(0);
186 }
187 }
188
189 void game_draw_player_lives(struct game *game, int player_no, float delta)
190 {
191 GLfloat light0_position[] = { 0.0, 1.0, 0.0, 1.0 };
192 GLfloat light0_direction[] = { 0.0, 0.5, 1.5 };
193 GLfloat inactive_color[] = { 0.5, 0.5, 0.5, 1.0 };
194
195 int c;
196 struct player *p;
197 static float frame = 0.0;
198
199 struct viewport *vp;
200
201 vp = screen_get_viewport(player_no);
202 p = &game->players[player_no];
203 frame += delta * ANIM_FPS;
204
205 for(c = 0; c < p->lives; c++)
206 {
207 glMatrixMode(GL_MODELVIEW);
208 glLoadIdentity();
209 glMatrixMode(GL_PROJECTION);
210 glLoadIdentity();
211 /*
212 glViewport(0 + 70 * vp->width / 800 * c, 0,
213 150 * vp->width / 800, 150 * vp->width / 800);
214 */
215 glViewport(0 + 70 * vp->width / 800 * c, vp->ll_y,
216 150 * vp->width / 800, 150 * vp->width / 800);
217
218 glFrustum(-1.0, 1.0,
219 -1.0, 1.0, 1.5, 3.0);
220 gluLookAt(0.0, 0.0, 0.0,
221 0.0, 0.0, 1.0,
222 0.0, 1.0, 0.0);
223
224 glShadeModel(GL_SMOOTH);
225 glEnable(GL_COLOR_MATERIAL);
226 glDisable(GL_BLEND);
227 glDisable(GL_TEXTURE_2D);
228 glEnable(GL_DEPTH_TEST);
229 glDepthMask(GL_TRUE);
230
231 glEnable(GL_LIGHTING);
232 glEnable(GL_LIGHT0);
233 glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
234 glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, light0_direction);
235
236 glClear(GL_DEPTH_BUFFER_BIT);
237 glMatrixMode(GL_MODELVIEW);
238 glTranslatef(0.0, 0.0, 2.1);
239
240 glRotatef(180.0, 0.0, 1.0, 0.0);
241 glRotatef(180.0, 0.0, 0.0, 1.0);
242 glRotatef(-75.0, 0.0, 1.0, 0.0);
243
244 if(c == p->lives - 1)
245 switch(p->state)
246 {
247 case PLAYER_STATE_MOVING:
248 case PLAYER_STATE_STOPPED:
249 render_dlist(&p->model_moving[(int)frame % p->frames_moving], p->color);
250 break;
251
252 case PLAYER_STATE_DEAD:
253 render_dlist(&p->model_dying[(int)p->current_frame % p->frames_dying], p->color);
254 break;
255 }
256 else
257 render_dlist(&p->model_stopped[0], inactive_color);
258 }
259 }
260
261 #if 1
262 /* XXX - this is for player 0 only */
263 void game_do_victory_loop(struct game *game)
264 {
265 int last_update;
266 struct image_rgba32 *level_complete;
267 int tx_level_complete;
268 struct viewport *vp;
269
270 audio_fade_music(500);
271 SDL_Delay(500);
272
273 level_complete = gfx_get("gfx/level-complete.tga");
274 gfx_alpha_from_key("gfx/level-complete.tga", 0, 0, 0);
275 tx_level_complete = gfx_upload_texture("gfx/level-complete.tga");
276
277 audio_play_music("sfx/hiscore.ogg");
278
279 game->players[0].camera->type = CAMERA_TYPE_DEMO;
280
281 last_update = SDL_GetTicks();
282
283 game->players[0].state = PLAYER_STATE_WON;
284 game->players[0].current_frame = 0.0;
285 vp = screen_get_viewport(0);
286
287 for(;;)
288 {
289 SDL_Event ev;
290 int diff, c;
291 float delta;
292
293 while(SDL_PollEvent(&ev))
294 {
295 if (OGLCONSOLE_SDLEvent(&ev) != 0)
296 continue;
297
298 if(ev.type == SDL_QUIT)
299 {
300 SDL_Quit();
301 exit(0);
302 }
303
304 if((ev.type == SDL_KEYDOWN && ev.key.keysym.sym == SDLK_ESCAPE) ||
305 (ev.type == SDL_KEYDOWN && ev.key.keysym.sym == SDLK_SPACE))
306 {
307 audio_fade_music(500);
308 SDL_Delay(500);
309 return;
310 }
311 }
312
313 diff = SDL_GetTicks() - last_update;
314 last_update = SDL_GetTicks();
315 delta = (float)diff / 1000.0;
316
317 for(c = 0; c < game->n_players; c++)
318 game->players[c].current_frame += delta * ANIM_FPS;
319
320 for(c = 0; c < game->n_ghosts; c++)
321 game->ghosts[c].current_frame += delta * ANIM_FPS;
322
323 game_update_camera(game, 0, delta);
324 render_point_camera(game->players[0].camera,
325 game->players[0].position[X],
326 game->players[0].position[Y],
327 game->players[0].position[Z]);
328
329 render_start_frame();
330
331 render_setup(game, 0);
332 map_render_opaque_objects(game);
333 game_draw_opaque_objects(game, 0);
334 map_render_translucent_objects(game, 0);
335 game_draw_translucent_objects(game, 0);
336
337 /* render_draw_logo();*/
338
339 render_setup_2d(vp);
340
341 if(level_complete->width > vp->width)
342 render_draw_scaled_image("gfx/level-complete.tga",
343 0, 0,
344 vp->width,
345 level_complete->height * vp->height / vp->width);
346 else
347 render_draw_scaled_image("gfx/level-complete.tga",
348 (vp->width - level_complete->width) / 2, 0,
349 (vp->width + level_complete->width) / 2,
350 level_complete->height);
351
352 render_finish_frame();
353 }
354 }
355
356 /* XXX - player 0 only */
357 void game_do_defeat_loop(struct game *game)
358 {
359 int last_update;
360 struct image_rgba32 *game_over;
361 int tx_game_over;
362 struct viewport *vp;
363
364 audio_fade_music(500);
365 SDL_Delay(500);
366
367 game_over = gfx_get("gfx/game-over.tga");
368 gfx_alpha_from_key("gfx/game-over.tga", 0, 0, 0);
369 tx_game_over = gfx_upload_texture("gfx/game-over.tga");
370
371 audio_play_music("sfx/gameover.ogg");
372
373 game->players[0].camera->type = CAMERA_TYPE_DEMO;
374
375 last_update = SDL_GetTicks();
376 vp = screen_get_viewport(0);
377
378 for(;;)
379 {
380 int diff, c;
381 float delta;
382
383 input_update();
384
385 if(input_kstate(SDLK_ESCAPE))
386 {
387 input_kclear(SDLK_ESCAPE);
388 audio_fade_music(500);
389 SDL_Delay(500);
390 return;
391 }
392
393 diff = SDL_GetTicks() - last_update;
394 last_update = SDL_GetTicks();
395 delta = (float)diff / 1000.0;
396 /*
397 for(c = 0; c < n_players; c++)
398 players[c].current_frame += delta * ANIM_FPS;
399 */
400 for(c = 0; c < game->n_ghosts; c++)
401 game->ghosts[c].current_frame += delta * ANIM_FPS;
402
403 game_update_camera(game, 0, delta);
404 render_point_camera(game->players[0].camera,
405 game->players[0].position[X],
406 game->players[0].position[Y],
407 game->players[0].position[Z]);
408
409 render_start_frame();
410
411 render_setup(game, 0);
412 map_render_opaque_objects(game);
413 game_draw_opaque_objects(game, 0);
414 map_render_translucent_objects(game, 0);
415 game_draw_translucent_objects(game, 0);
416
417 /* render_draw_logo();*/
418
419 render_setup_2d(vp);
420
421 if(game_over->width > vp->width)
422 render_draw_scaled_image("gfx/game-over.tga",
423 0, 0,
424 vp->width,
425 game_over->height * vp->height / vp->width);
426 else
427 render_draw_scaled_image("gfx/game-over.tga",
428 (vp->width - game_over->width) / 2, 0,
429 (vp->width + game_over->width) / 2,
430 game_over->height);
431 render_finish_frame();
432 }
433 }
434 #else
435 void game_do_victory_loop(struct game *game)
436 {
437 }
438
439 void game_do_defeat_loop(struct game *game)
440 {
441 }
442 #endif
443
444 void game_reset(struct game *game)
445 {
446 player_reset(game);
447 glDisable(GL_LIGHT1);
448 }
449
450 int game_count_dots(struct game *game)
451 {
452 struct map *map;
453 int x, y, ret;
454
455 map = game->map;
456 ret = 0;
457
458 for(x = 0; x < map->width; x++)
459 for(y = 0; y < map->height; y++)
460 if(MAP(map, x, y).content == MAP_CONTENT_FOOD &&
461 MAP(map, x, y).c_data.food.status == FOOD_STATUS_ACTIVE)
462 ret++;
463
464 return ret;
465 }
466
467 void game_teleport_player(struct game *game, int player)
468 {
469 struct player *p;
470 struct map *map;
471 int x, y;
472 int dx, dy;
473
474 p = &game->players[player];
475 map = game->map;
476
477 x = (int)p->position[X];
478 y = (int)p->position[Z];
479
480 if(MAP(map, x, y).content != MAP_CONTENT_TELEPORT)
481 return;
482
483 if(MAP_TELEPORT(map, x, y).direction != p->direction)
484 return;
485
486 dx = MAP_TELEPORT(map, x, y).dest_x;
487 dy = MAP_TELEPORT(map, x, y).dest_y;
488
489 p->position[X] = (float)dx + 0.5;
490 p->position[Z] = (float)dy + 0.5;
491 }
492
493 void game_start(struct game *game)
494 {
495 struct map *map;
496 int c, cx, cy;
497
498 /* distribuir os jogadores pelos spawn points */
499 c = 0;
500 map = game->map;
501
502 for(cx = 0; cx < map->width; cx++)
503 for(cy = 0; cy < map->height; cy++)
504 if(c < game->n_players &&
505 MAP(map, cx, cy).flags & MAP_FLAG_PACMAN_START_POSITION)
506 {
507 /* spawn */
508 game->players[c].position[X] = (float)cx + 0.5;
509 game->players[c].position[Z] = (float)cy + 0.5;
510
511 game->players[c].start_position[X] = (float)cx + 0.5;
512 game->players[c].start_position[Y] = game->players[c].position[Y];
513 game->players[c].start_position[Z] = (float)cy + 0.5;
514
515 c++;
516
517 if(c == game->n_players)
518 break;
519
520
521 }
522
523 if(c != game->n_players)
524 {
525 printf("game_start: tanta gente (%d)!\n", game->n_players);
526 SDL_Quit();
527 exit(1);
528 }
529
530 ghost_reset_all(game);
531 }
532
533 void game_reset_camera(struct game *game, int player_no)
534 {
535 struct camera *cam;
536 struct player *player;
537
538 if(player_no == -1)
539 {
540 player = NULL;
541 cam = game->demo_camera;
542 } else {
543 player = &game->players[player_no];
544 cam = player->camera;
545 }
546
547 switch(cam->type)
548 {
549 case CAMERA_TYPE_FIXED_CHASE:
550 break;
551
552 case CAMERA_TYPE_LOOSE_CHASE:
553 render_reset_camera(cam);
554 render_move_camera(cam,
555 player->position[X],
556 -3.5,
557 player->position[Z] - 3.5);
558 break;
559
560 case CAMERA_TYPE_LOOSE_TRAIL:
561 render_reset_camera(cam);
562 render_move_camera(cam,
563 0.0, CAMERA_LOOSE_TRAIL_Y_OFFSET, CAMERA_LOOSE_TRAIL_Z_OFFSET);
564 render_point_camera(cam,
565 player->position[X],
566 player->position[Y],
567 player->position[Z]);
568
569 break;
570
571 case CAMERA_TYPE_DEMO:
572 render_reset_camera(cam);
573 render_move_camera(cam, game->map->width / 2 + 0.5, CAMERA_DEMO_HEIGHT, 0.0);
574 render_point_camera(cam, game->map->width / 2 + 0.5, 0.0, game->map->height / 2 + 0.5);
575 break;
576
577 case CAMERA_TYPE_TOMB_RAIDER:
578 render_reset_camera(cam);
579 render_move_camera(cam,
580 0.0, CAMERA_TOMB_RAIDER_Y_OFFSET, -CAMERA_TOMB_RAIDER_OFFSET);
581 render_point_camera(cam,
582 player->position[X],
583 player->position[Y],
584 player->position[Z]);
585
586 break;
587
588 case CAMERA_TYPE_FREE:
589 break;
590 }
591 }
592
593 void game_update_camera(struct game *game, int player_no, float delta)
594 {
595 static int state = 0;
596 struct camera *cam;
597 struct player *player;
598
599 if(player_no == -1)
600 {
601 /* magic value: demo camera */
602 player = NULL;
603 cam = game->demo_camera;
604 } else {
605 player = &game->players[player_no];
606 cam = player->camera;
607 }
608
609 if(input_kstate(SDLK_c))
610 {
611 cam->type = (cam->type + 1) % CAMERA_NUM_TYPES;
612 input_kclear(SDLK_c);
613 // game_reset_camera(game, player_no);
614 }
615
616 switch(cam->type)
617 {
618 float v1[3], v2[3], vr[3], dist, d2;
619
620 case CAMERA_TYPE_FIXED_CHASE:
621 render_reset_camera(cam);
622 render_move_camera(cam,
623 player->position[X],
624 -3.5,
625 player->position[Z] - 2.5);
626 render_point_camera(cam,
627 player->position[X],
628 player->position[Y],
629 player->position[Z]);
630
631 break;
632
633 case CAMERA_TYPE_LOOSE_CHASE:
634 render_point_camera(cam,
635 player->position[X],
636 player->position[Y],
637 player->position[Z]);
638
639 v1[X] = player->position[X];
640 v1[Y] = cam->pos[Y];
641 v1[Z] = player->position[Z];
642
643 math_sub_vec3(v1, v1, cam->pos);
644
645 if(state)
646 {
647 if(math_norm_vec3(v1) > CAMERA_LOOSE_CHASE_LOW_THRESHOLD)
648 {
649 math_len_vec3(v1, v1, delta * CAMERA_LOOSE_CHASE_SPEED);
650 math_add_vec3(v1, cam->pos, v1);
651 render_move_camera(cam, v1[X], v1[Y], v1[Z]);
652 } else
653 state = 0;
654 } else
655 if(math_norm_vec3(v1) > CAMERA_LOOSE_CHASE_HIGH_THRESHOLD)
656 state = 1;
657
658 break;
659
660 case CAMERA_TYPE_LOOSE_TRAIL:
661 v1[X] = cam->dir[X];
662 v1[Y] = cam->dir[Y];
663 v1[Z] = cam->dir[Z];
664
665 render_point_camera(cam,
666 player->position[X],
667 player->position[Y],
668 player->position[Z]);
669
670
671 v2[X] = cam->dir[X];
672 v2[Y] = cam->dir[Y];
673 v2[Z] = cam->dir[Z];
674
675 math_sub_vec3(vr, v2, v1);
676 dist = math_norm_vec3(vr);
677 if(dist > CAMERA_LOOSE_TRAIL_ROTATE_SPEED * delta || state)
678 {
679 state = 1;
680
681 math_len_vec3(vr, vr,
682 CAMERA_LOOSE_TRAIL_ROTATE_SPEED * delta * sin(dist));
683 math_add_vec3(v1, v1, vr);
684 render_point_camera(cam, v1[X], v1[Y], v1[Z]);
685
686 math_sub_vec3(vr, player->position, cam->pos);
687 if(dist * math_norm_vec3(vr) < 0.06)
688 state = 0;
689 }
690
691 /* xx */
692 v1[X] = player->position[X];
693 v1[Y] = 0.0;
694 v1[Z] = 0.0;
695
696 v2[X] = cam->pos[X];
697 v2[Y] = 0.0;
698 v2[Z] = 0.0;
699
700 math_sub_vec3(vr, v2, v1);
701
702 dist = math_norm_vec3(vr);
703 math_len_vec3(vr, vr,
704 MAX(-delta * player->speed * dist * 0.7,
705 -CAMERA_LOOSE_TRAIL_SPEED * delta));
706
707 d2 = math_norm_vec3(vr);
708 math_len_vec3(vr, vr, MAX(d2, d2 * (dist * 0.07) * (dist * 0.07)));
709
710 render_translate_camera(cam, vr[X], vr[Y], vr[Z]);
711
712 /* yy */
713 v1[X] = 0.0;
714 v1[Y] = CAMERA_LOOSE_TRAIL_Y_OFFSET;
715 v1[Z] = 0.0;
716
717 v2[X] = 0.0;
718 v2[Y] = cam->pos[Y];
719 v2[Z] = 0.0;
720
721 math_sub_vec3(vr, v2, v1);
722
723 dist = math_norm_vec3(vr);
724 math_len_vec3(vr, vr,
725 MAX(-delta * player->speed * dist * 0.7,
726 -CAMERA_LOOSE_TRAIL_SPEED * delta));
727
728 d2 = math_norm_vec3(vr);
729 math_len_vec3(vr, vr, MAX(d2, d2 * (dist * 0.07) * (dist * 0.07)));
730
731 render_translate_camera(cam, vr[X], vr[Y], vr[Z]);
732
733
734 /* zz */
735 v1[X] = 0.0;
736 v1[Y] = 0.0;
737 v1[Z] = player->position[Z] + CAMERA_LOOSE_TRAIL_Z_OFFSET;
738
739 v2[X] = 0.0;
740 v2[Y] = 0.0;
741 v2[Z] = cam->pos[Z];
742
743 math_sub_vec3(vr, v2, v1);
744
745 dist = math_norm_vec3(vr);
746 math_len_vec3(vr, vr,
747 MAX(-delta * player->speed * dist * 0.9,
748 -CAMERA_LOOSE_TRAIL_SPEED * delta));
749
750 d2 = math_norm_vec3(vr);
751 math_len_vec3(vr, vr, MAX(d2, d2 * (dist * 0.07) * (dist * 0.07)));
752
753 render_translate_camera(cam, vr[X], vr[Y], vr[Z]);
754
755 break;
756
757 case CAMERA_TYPE_DEMO:
758 v1[X] = game->map->width / 2 + 0.5;
759 v1[Y] = 0.0;
760 v1[Z] = game->map->height / 2 + 0.5;
761
762 v2[X] = 0.0;
763 v2[Y] = 1.0;
764 v2[Z] = 0.0;
765
766 math_sub_vec3(vr, cam->pos, v1);
767 math_rotate_vec3(vr, vr, v2, CAMERA_DEMO_ROTATE_SPEED * delta);
768 math_add_vec3(cam->pos, v1, vr);
769
770 render_point_camera(cam,
771 game->map->width / 2 + 0.5, 0.0,
772 game->map->height / 2 + 0.5);
773 break;
774
775 case CAMERA_TYPE_TOMB_RAIDER:
776 v1[X] = cam->dir[X];
777 v1[Y] = cam->dir[Y];
778 v1[Z] = cam->dir[Z];
779
780 render_point_camera(cam,
781 player->position[X],
782 player->position[Y],
783 player->position[Z]);
784
785
786 v2[X] = cam->dir[X];
787 v2[Y] = cam->dir[Y];
788 v2[Z] = cam->dir[Z];
789
790 math_sub_vec3(vr, v2, v1);
791 dist = math_norm_vec3(vr);
792 if(dist > CAMERA_TOMB_RAIDER_ROTATE_SPEED * delta || state)
793 {
794 state = 1;
795
796 math_len_vec3(vr, vr,
797 CAMERA_TOMB_RAIDER_ROTATE_SPEED * delta * sin(dist));
798 math_add_vec3(v1, v1, vr);
799 render_point_camera(cam, v1[X], v1[Y], v1[Z]);
800
801 math_sub_vec3(vr, player->position, cam->pos);
802 if(dist * math_norm_vec3(vr) < 0.6)
803 state = 0;
804 }
805
806 /* xx */
807 switch(player->direction)
808 {
809 case DIRECTION_UP:
810 case DIRECTION_DOWN:
811 v1[X] = player->position[X];
812 break;
813
814 case DIRECTION_LEFT:
815 v1[X] = player->position[X] + CAMERA_TOMB_RAIDER_OFFSET;
816 break;
817
818 case DIRECTION_RIGHT:
819 v1[X] = player->position[X] - CAMERA_TOMB_RAIDER_OFFSET;
820 break;
821 }
822 v1[Y] = 0.0;
823 v1[Z] = 0.0;
824
825 v2[X] = cam->pos[X];
826 v2[Y] = 0.0;
827 v2[Z] = 0.0;
828
829 math_sub_vec3(vr, v2, v1);
830
831 dist = math_norm_vec3(vr);
832 math_len_vec3(vr, vr,
833 MAX(-delta * player->speed * dist * 0.7,
834 -CAMERA_TOMB_RAIDER_SPEED * delta));
835
836 d2 = math_norm_vec3(vr);
837 math_len_vec3(vr, vr, MAX(d2, d2 * (dist * 0.07) * (dist * 0.07)));
838
839 render_translate_camera(cam, vr[X], vr[Y], vr[Z]);
840
841 /* yy */
842 v1[X] = 0.0;
843 v1[Y] = CAMERA_TOMB_RAIDER_Y_OFFSET;
844 v1[Z] = 0.0;
845
846 v2[X] = 0.0;
847 v2[Y] = cam->pos[Y];
848 v2[Z] = 0.0;
849
850 math_sub_vec3(vr, v2, v1);
851
852 dist = math_norm_vec3(vr);
853 math_len_vec3(vr, vr,
854 MAX(-delta * player->speed * dist * 0.7,
855 -CAMERA_TOMB_RAIDER_SPEED * delta));
856
857 d2 = math_norm_vec3(vr);
858 math_len_vec3(vr, vr, MAX(d2, d2 * (dist * 0.07) * (dist * 0.07)));
859
860 render_translate_camera(cam, vr[X], vr[Y], vr[Z]);
861
862 /* zz */
863 v1[X] = 0.0;
864 v1[Y] = 0.0;
865 switch(player->direction)
866 {
867 case DIRECTION_UP:
868 v1[Z] = player->position[Z] - CAMERA_TOMB_RAIDER_OFFSET;
869 break;
870
871 case DIRECTION_DOWN:
872 v1[Z] = player->position[Z] + CAMERA_TOMB_RAIDER_OFFSET;
873 break;
874
875 case DIRECTION_LEFT:
876 case DIRECTION_RIGHT:
877 v1[Z] = player->position[Z];
878 break;
879 }
880
881 v2[X] = 0.0;
882 v2[Y] = 0.0;
883 v2[Z] = cam->pos[Z];
884
885 math_sub_vec3(vr, v2, v1);
886
887 dist = math_norm_vec3(vr);
888 math_len_vec3(vr, vr,
889 MAX(-delta * player->speed * dist * 0.9,
890 -CAMERA_TOMB_RAIDER_SPEED * delta));
891
892 d2 = math_norm_vec3(vr);
893 math_len_vec3(vr, vr, MAX(d2, d2 * (dist * 0.07) * (dist * 0.07)));
894
895 render_translate_camera(cam, vr[X], vr[Y], vr[Z]);
896
897 break;
898
899 case CAMERA_TYPE_FREE:
900 if(input_kstate(SDLK_w))
901 /* move forward */
902 render_advance_camera(cam, 0.0, 0.0, 0.1);
903
904 if(input_kstate(SDLK_s))
905 /* move backward */
906 render_advance_camera(cam, 0.0, 0.0, -0.1);
907
908 if(input_kstate(SDLK_a))
909 /* move left */
910 render_advance_camera(cam, -0.1, 0.0, 0.0);
911
912 if(input_kstate(SDLK_d))
913 /* move right */
914 render_advance_camera(cam, 0.1, 0.0, 0.0);
915
916 if(input_kstate(SDLK_r))
917 /* move up */
918 render_advance_camera(cam, 0.0, -0.1, 0.0);
919
920 if(input_kstate(SDLK_f))
921 /* move down */
922 render_advance_camera(cam, 0.0, 0.1, 0.0);
923
924 if(input_kstate(SDLK_q))
925 /* roll Cwise */
926 render_camera_roll(cam, 1.0);
927
928 if(input_kstate(SDLK_e))
929 /* roll CCwise */
930 render_camera_roll(cam, -1.0);
931
932 if(input_kstate(SDLK_z))
933 /* rotate Cwise */
934 render_camera_yaw(cam, 1.0);
935
936 if(input_kstate(SDLK_x))
937 /* rotate CCwise */
938 render_camera_yaw(cam, -1.0);
939
940 if(input_kstate(SDLK_t))
941 /* pitch up */
942 render_camera_pitch(cam, -1.0);
943
944 if(input_kstate(SDLK_g))
945 /* pitch down */
946 render_camera_pitch(cam, 1.0);
947
948 break;
949 }
950 }
951
952 /*
953 actualiza o estado do jogo
954 */
955 void game_update(struct game *game, float delta)
956 {
957 int c;
958
959 map_update(game->map, delta);
960
961 for(c = 0; c < game->n_players; c++)
962 {
963 player_update(game, c, delta);
964 game_update_camera(game, c, delta);
965 }
966
967 for(c = 0; c < game->n_ghosts; c++)
968 ghost_update(game, c, delta);
969
970 for(c = 0; c < game->n_shots; c++)
971 shot_update(game, c, delta);
972
973 for(c = 0; c < game->n_bombs; c++)
974 bomb_update(game, c, delta);
975
976 if(game->demo_camera)
977 game_update_camera(game, -1, delta);
978 }
979
980 void game_draw_opaque_objects(struct game *game, int player_no)
981 {
982 int c;
983
984 for(c = 0; c < game->n_ghosts; c++)
985 ghost_render(game, &game->ghosts[c]);
986
987 for(c = 0; c < game->n_players; c++)
988 player_render(&game->players[c]);
989
990 for(c = 0; c < game->n_shots; c++)
991 shot_render_opaque(game, c);
992
993 for(c = 0; c < game->n_bombs; c++)
994 bomb_render_opaque(game, c);
995 }
996
997 void game_draw_translucent_objects(struct game *game, int player_no)
998 {
999 int c;
1000
1001 for(c = 0; c < game->n_shots; c++)
1002 shot_render_translucent(game, player_no, c);
1003
1004 for(c = 0; c < game->n_bombs; c++)
1005 bomb_render_translucent(game, player_no, c);
1006 }
multi-player pac-man clone