Mercurial > MadButterfly

comparison examples/tank/tank_main.c @ 1027:c693cd8c6e23 refine_backend_if

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Migrate examples/tank to new definition of backend
author Thinker K.F. Li <thinker@codemud.net>
date Mon, 22 Nov 2010 17:02:49 +0800
parents 5235aded379c
children e415c55b4a0d
comparison
equal deleted inserted replaced
1026:407932b8a160 1027:c693cd8c6e23
57 int start_map_x, start_map_y; 57 int start_map_x, start_map_y;
58 int direction; 58 int direction;
59 mb_progm_t *progm; 59 mb_progm_t *progm;
60 mb_timeval_t start_time; 60 mb_timeval_t start_time;
61 observer_t *ob_redraw; 61 observer_t *ob_redraw;
62 mb_timer_t *hit_tmr; 62 int hit_tmr;
63 mb_tman_t *tman; 63 mb_timer_man_t *timer_man;
64 }; 64 };
65 typedef struct _tank_bullet tank_bullet_t; 65 typedef struct _tank_bullet tank_bullet_t;
66 /*! \brief The direction a bullet is going. 66 /*! \brief The direction a bullet is going.
67 */ 67 */
68 enum { BU_UP = 0, BU_RIGHT, BU_DOWN, BU_LEFT }; 68 enum { BU_UP = 0, BU_RIGHT, BU_DOWN, BU_LEFT };
104 tank_t *tank_enemies[10]; 104 tank_t *tank_enemies[10];
105 tank_en_t *tank_enemies_o[10]; 105 tank_en_t *tank_enemies_o[10];
106 tank_t *tanks[12]; 106 tank_t *tanks[12];
107 int n_tanks; 107 int n_tanks;
108 void *map[12][16]; 108 void *map[12][16];
109 X_MB_runtime_t *mb_rt; 109 mb_rt_t *mb_rt;
110 observer_t *kb_observer; 110 observer_t *kb_observer;
111 }; 111 };
112 112
113 /*! \ingroup tank_elf 113 /*! \ingroup tank_elf
114 * @{ 114 * @{
122 122
123 tank = O_ALLOC(tank_t); 123 tank = O_ALLOC(tank_t);
124 if(tank == NULL) 124 if(tank == NULL)
125 return NULL; 125 return NULL;
126 126
127 rdman = X_MB_rdman(tank_rt->mb_rt); 127 rdman = mb_runtime_rdman(tank_rt->mb_rt);
128 128
129 tank->coord_pos = coord_pos; 129 tank->coord_pos = coord_pos;
130 tank->coord_rot = coord_rot; 130 tank->coord_rot = coord_rot;
131 tank->map_x = map_x; 131 tank->map_x = map_x;
132 tank->map_y = map_y; 132 tank->map_y = map_y;
143 rdman_coord_changed(rdman, coord_pos); 143 rdman_coord_changed(rdman, coord_pos);
144 144
145 return tank; 145 return tank;
146 } 146 }
147 147
148 static void tank_free(tank_t *tank, X_MB_runtime_t *xmb_rt) { 148 static void tank_free(tank_t *tank, mb_rt_t *mb_rt) {
149 mb_tman_t *tman;
150
151 if(tank->progm) { 149 if(tank->progm) {
152 tman = X_MB_tman(xmb_rt);
153 mb_progm_abort(tank->progm); 150 mb_progm_abort(tank->progm);
154 } 151 }
155 free(tank); 152 free(tank);
156 } 153 }
157 154
168 165
169 #define PI 3.1415926 166 #define PI 3.1415926
170 167
171 static void tank_move(tank_t *tank, int direction, 168 static void tank_move(tank_t *tank, int direction,
172 tank_rt_t *tank_rt) { 169 tank_rt_t *tank_rt) {
173 X_MB_runtime_t *xmb_rt = tank_rt->mb_rt; 170 mb_rt_t *mb_rt = tank_rt->mb_rt;
174 redraw_man_t *rdman; 171 redraw_man_t *rdman;
175 mb_tman_t *tman; 172 mb_timer_man_t *timer_man;
176 ob_factory_t *factory; 173 ob_factory_t *factory;
177 /* for the program */ 174 /* for the program */
178 mb_progm_t *progm; 175 mb_progm_t *progm;
179 subject_t *comp_sub; 176 subject_t *comp_sub;
180 mb_word_t *word; 177 mb_word_t *word;
237 return; 234 return;
238 } 235 }
239 } 236 }
240 } 237 }
241 238
242 rdman = X_MB_rdman(xmb_rt); 239 rdman = mb_runtime_rdman(mb_rt);
243 tman = X_MB_tman(xmb_rt); 240 timer_man = mb_runtime_timer_man(mb_rt);
244 factory = X_MB_ob_factory(xmb_rt); 241 factory = mb_runtime_ob_factory(mb_rt);
245 242
246 progm = mb_progm_new(1, rdman); 243 progm = mb_progm_new(1, rdman);
247 tank->progm = progm; 244 tank->progm = progm;
248 245
249 MB_TIMEVAL_SET(&start, 0, 0); 246 MB_TIMEVAL_SET(&start, 0, 0);
267 /* Clean program when it is completed. */ 264 /* Clean program when it is completed. */
268 comp_sub = mb_progm_get_complete(progm); 265 comp_sub = mb_progm_get_complete(progm);
269 subject_add_observer(comp_sub, clean_tank_progm_handler, tank); 266 subject_add_observer(comp_sub, clean_tank_progm_handler, tank);
270 267
271 get_now(&now); 268 get_now(&now);
272 mb_progm_start(progm, tman, &now); 269 mb_progm_start(progm, timer_man, &now);
273 } 270 }
274 271
275 /* @} */ 272 /* @} */
276 273
277 /*! \ingroup bullet_elf 274 /*! \ingroup bullet_elf
308 static float _coss[] = { 1, 0, -1, 0}; 305 static float _coss[] = { 1, 0, -1, 0};
309 float _sin, _cos; 306 float _sin, _cos;
310 307
311 bullet = O_ALLOC(tank_bullet_t); 308 bullet = O_ALLOC(tank_bullet_t);
312 bullet->rdman = rdman; 309 bullet->rdman = rdman;
310 bullet->hit_tmr = -1;
313 311
314 make_bullet_elf_coords(rdman, &bullet->coord_pos, 312 make_bullet_elf_coords(rdman, &bullet->coord_pos,
315 &bullet->coord_rot, 313 &bullet->coord_rot,
316 &coord_center); 314 &coord_center);
317 bullet->bullet_obj = bullet_new(rdman, coord_center); 315 bullet->bullet_obj = bullet_new(rdman, coord_center);
336 334
337 return bullet; 335 return bullet;
338 } 336 }
339 337
340 static void tank_bullet_free(tank_bullet_t *bullet) { 338 static void tank_bullet_free(tank_bullet_t *bullet) {
339 if(bullet->hit_tmr != -1)
340 mb_timer_man_remove(bullet->timer_man, bullet->hit_tmr);
341 bullet_free(bullet->bullet_obj); 341 bullet_free(bullet->bullet_obj);
342 rdman_coord_subtree_free(bullet->rdman, bullet->coord_pos); 342 rdman_coord_subtree_free(bullet->rdman, bullet->coord_pos);
343 } 343 }
344 344
345 static void bullet_go_out_map(event_t *event, void *arg) { 345 static void bullet_go_out_map(event_t *event, void *arg) {
348 redraw_man_t *rdman; 348 redraw_man_t *rdman;
349 349
350 bullet = tank->bullet; 350 bullet = tank->bullet;
351 rdman = bullet->rdman; 351 rdman = bullet->rdman;
352 352
353 if(bullet->hit_tmr != NULL) 353 if(bullet->hit_tmr != -1) {
354 mb_tman_remove(bullet->tman, bullet->hit_tmr); 354 mb_timer_man_remove(bullet->timer_man, bullet->hit_tmr);
355 bullet->hit_tmr = -1;
356 }
355 357
356 coord_hide(bullet->coord_pos); 358 coord_hide(bullet->coord_pos);
357 rdman_coord_changed(rdman, bullet->coord_pos); 359 rdman_coord_changed(rdman, bullet->coord_pos);
358 360
359 bullet = tank->bullet; 361 bullet = tank->bullet;
362 tank->bullet = NULL; 364 tank->bullet = NULL;
363 } 365 }
364 366
365 static void bullet_bang(tank_bullet_t *bullet, int map_x, int map_y) { 367 static void bullet_bang(tank_bullet_t *bullet, int map_x, int map_y) {
366 redraw_man_t *rdman; 368 redraw_man_t *rdman;
367 mb_tman_t *tman; 369 mb_timer_man_t *timer_man;
368 mb_progm_t *progm; 370 mb_progm_t *progm;
369 mb_word_t *word; 371 mb_word_t *word;
370 mb_timeval_t start, playing; 372 mb_timeval_t start, playing;
371 mb_timeval_t now; 373 mb_timeval_t now;
372 bang_t *bang; 374 bang_t *bang;
373 co_aix *matrix; 375 co_aix *matrix;
374 376
375 rdman = bullet->rdman; 377 rdman = bullet->rdman;
376 tman = bullet->tman; 378 timer_man = bullet->timer_man;
377 379
378 bang = bang_new(rdman, rdman->root_coord); 380 bang = bang_new(rdman, rdman->root_coord);
379 matrix = bang->root_coord->matrix; 381 matrix = bang->root_coord->matrix;
380 matrix[2] = map_x * 50; 382 matrix[2] = map_x * 50;
381 matrix[5] = map_y * 50; 383 matrix[5] = map_y * 50;
399 mb_subtree_free_new(bang->root_coord, word); 401 mb_subtree_free_new(bang->root_coord, word);
400 402
401 mb_progm_free_completed(progm); 403 mb_progm_free_completed(progm);
402 404
403 get_now(&now); 405 get_now(&now);
404 mb_progm_start(progm, tman, &now); 406 mb_progm_start(progm, timer_man, &now);
405 } 407 }
406 408
407 /*! \brief To check if a bullet hits walls or tanks. */ 409 /*! \brief To check if a bullet hits walls or tanks. */
408 static void bullet_hit_chk(const mb_timeval_t *tmo, 410 static void bullet_hit_chk(int hdl,
411 const mb_timeval_t *tmo,
409 const mb_timeval_t *now, 412 const mb_timeval_t *now,
410 void *arg) { 413 void *arg) {
411 tank_t *tank = (tank_t *)arg; 414 tank_t *tank = (tank_t *)arg;
412 tank_rt_t *tank_rt = tank->tank_rt; 415 tank_rt_t *tank_rt = tank->tank_rt;
413 tank_t *tank_hitted; 416 tank_t *tank_hitted;
420 int dir; 423 int dir;
421 int i; 424 int i;
422 static int move_adj[][2] = {{0, -1}, {1, 0}, {0, 1}, {-1, 0}}; 425 static int move_adj[][2] = {{0, -1}, {1, 0}, {0, 1}, {-1, 0}};
423 426
424 bullet = tank->bullet; 427 bullet = tank->bullet;
425 bullet->hit_tmr = NULL; /* clear hit timer that bullet_go_out_map() 428 bullet->hit_tmr = -1; /* clear hit timer that bullet_go_out_map()
426 * can not remove it & currupt memory. 429 * can not remove it & currupt memory.
427 */ 430 */
428 431
429 MB_TIMEVAL_CP(&diff, now); 432 MB_TIMEVAL_CP(&diff, now);
430 MB_TIMEVAL_DIFF(&diff, &bullet->start_time); 433 MB_TIMEVAL_DIFF(&diff, &bullet->start_time);
431 MB_TIMEVAL_SET(&unit_tm, 0, 250000); 434 MB_TIMEVAL_SET(&unit_tm, 0, 250000);
432 move_units_f = MB_TIMEVAL_DIV(&diff, &unit_tm); 435 move_units_f = MB_TIMEVAL_DIV(&diff, &unit_tm);
478 } 481 }
479 } 482 }
480 483
481 MB_TIMEVAL_SET(&next, 0, 100000); 484 MB_TIMEVAL_SET(&next, 0, 100000);
482 MB_TIMEVAL_ADD(&next, now); 485 MB_TIMEVAL_ADD(&next, now);
483 bullet->hit_tmr = mb_tman_timeout(bullet->tman, &next, 486 bullet->hit_tmr = mb_timer_man_timeout(bullet->timer_man, &next,
484 bullet_hit_chk, arg); 487 bullet_hit_chk, arg);
485 } 488 }
486 489
487 /*! \brief To fire a bullet for a tank. */ 490 /*! \brief To fire a bullet for a tank. */
488 static void tank_fire_bullet(tank_rt_t *tank_rt, tank_t *tank) { 491 static void tank_fire_bullet(tank_rt_t *tank_rt, tank_t *tank) {
489 X_MB_runtime_t *xmb_rt; 492 mb_rt_t *mb_rt;
490 redraw_man_t *rdman; 493 redraw_man_t *rdman;
491 int map_x, map_y; 494 int map_x, map_y;
492 int shift_x, shift_y; 495 int shift_x, shift_y;
493 int shift_len; 496 int shift_len;
494 int dir; 497 int dir;
496 mb_progm_t *progm; 499 mb_progm_t *progm;
497 mb_word_t *word; 500 mb_word_t *word;
498 mb_action_t *act; 501 mb_action_t *act;
499 mb_timeval_t start, playing; 502 mb_timeval_t start, playing;
500 mb_timeval_t now, next; 503 mb_timeval_t now, next;
501 mb_tman_t *tman; 504 mb_timer_man_t *timer_man;
502 subject_t *subject; 505 subject_t *subject;
503 static int map_xy_adj[][2] = {{0, -1}, {1, 0}, {0, 1}, {-1, 0}}; 506 static int map_xy_adj[][2] = {{0, -1}, {1, 0}, {0, 1}, {-1, 0}};
504 507
505 if(tank->bullet != NULL) 508 if(tank->bullet != NULL)
506 return; 509 return;
507 510
508 xmb_rt = tank_rt->mb_rt; 511 mb_rt = tank_rt->mb_rt;
509 rdman = X_MB_rdman(xmb_rt); 512 rdman = mb_runtime_rdman(mb_rt);
510 tman = X_MB_tman(xmb_rt); 513 timer_man = mb_runtime_timer_man(mb_rt);
511 514
512 dir = tank->direction; 515 dir = tank->direction;
513 map_x = tank->map_x + map_xy_adj[dir][0]; 516 map_x = tank->map_x + map_xy_adj[dir][0];
514 map_y = tank->map_y + map_xy_adj[dir][1]; 517 map_y = tank->map_y + map_xy_adj[dir][1];
515 switch(dir) { 518 switch(dir) {
538 if(shift_len <= 0) 541 if(shift_len <= 0)
539 return; 542 return;
540 543
541 tank->bullet = tank_bullet_new(rdman, map_x, map_y, dir); 544 tank->bullet = tank_bullet_new(rdman, map_x, map_y, dir);
542 bullet = tank->bullet; 545 bullet = tank->bullet;
543 bullet->tman = tman; 546 bullet->timer_man = timer_man;
544 547
545 progm = mb_progm_new(2, rdman); 548 progm = mb_progm_new(2, rdman);
546 MB_TIMEVAL_SET(&start, 0, 0); 549 MB_TIMEVAL_SET(&start, 0, 0);
547 MB_TIMEVAL_SET(&playing, shift_len / 4, (shift_len % 4) * 250000); 550 MB_TIMEVAL_SET(&playing, shift_len / 4, (shift_len % 4) * 250000);
548 word = mb_progm_next_word(progm, &start, &playing); 551 word = mb_progm_next_word(progm, &start, &playing);
553 subject = mb_progm_get_complete(progm); 556 subject = mb_progm_get_complete(progm);
554 subject_add_observer(subject, bullet_go_out_map, tank); 557 subject_add_observer(subject, bullet_go_out_map, tank);
555 558
556 get_now(&now); 559 get_now(&now);
557 MB_TIMEVAL_CP(&bullet->start_time, &now); 560 MB_TIMEVAL_CP(&bullet->start_time, &now);
558 mb_progm_start(progm, tman, &now); 561 mb_progm_start(progm, timer_man, &now);
559 562
560 MB_TIMEVAL_SET(&next, 0, 100000); 563 MB_TIMEVAL_SET(&next, 0, 100000);
561 MB_TIMEVAL_ADD(&next, &now); 564 MB_TIMEVAL_ADD(&next, &now);
562 bullet->hit_tmr = mb_tman_timeout(tman, &next, bullet_hit_chk, tank); 565 bullet->hit_tmr = mb_timer_man_timeout(timer_man, &next,
566 bullet_hit_chk, tank);
563 } 567 }
564 568
565 /* @} */ 569 /* @} */
566 570
567 /*! \ingroup tank 571 /*! \ingroup tank
613 } 617 }
614 618
615 } 619 }
616 620
617 static void init_keyboard(tank_rt_t *tank_rt) { 621 static void init_keyboard(tank_rt_t *tank_rt) {
618 X_MB_runtime_t *mb_rt; 622 mb_rt_t *mb_rt;
619 subject_t *kbevents; 623 subject_t *kbevents;
620 redraw_man_t *rdman; 624 redraw_man_t *rdman;
621 625
622 mb_rt = tank_rt->mb_rt; 626 mb_rt = tank_rt->mb_rt;
623 kbevents = X_MB_kbevents(mb_rt); 627 kbevents = mb_runtime_kbevents(mb_rt);
624 628
625 rdman = X_MB_rdman(mb_rt); 629 rdman = mb_runtime_rdman(mb_rt);
626 630
627 tank_rt->kb_observer = 631 tank_rt->kb_observer =
628 subject_add_observer(kbevents, keyboard_handler, tank_rt); 632 subject_add_observer(kbevents, keyboard_handler, tank_rt);
629 } 633 }
630 634
652 (*coord_center)->matrix[5] = -25; 656 (*coord_center)->matrix[5] = -25;
653 rdman_coord_changed(rdman, *coord_center); 657 rdman_coord_changed(rdman, *coord_center);
654 } 658 }
655 659
656 void 660 void
657 initial_tank(tank_rt_t *tank_rt, X_MB_runtime_t *mb_rt) { 661 initial_tank(tank_rt_t *tank_rt, mb_rt_t *mb_rt) {
658 redraw_man_t *rdman; 662 redraw_man_t *rdman;
659 /* for map areas */ 663 /* for map areas */
660 mud_t *mud; 664 mud_t *mud;
661 brick_t *brick; 665 brick_t *brick;
662 rock_t *rock; 666 rock_t *rock;
666 tank1_t *tank1_o; 670 tank1_t *tank1_o;
667 tank2_t *tank2_o; 671 tank2_t *tank2_o;
668 tank_en_t *tank_en_o; 672 tank_en_t *tank_en_o;
669 int i, j; 673 int i, j;
670 674
671 rdman = X_MB_rdman(mb_rt); 675 rdman = mb_runtime_rdman(mb_rt);
672 676
673 tank_rt->mb_rt = mb_rt; 677 tank_rt->mb_rt = mb_rt;
674 for(i = 0; i < 12; i++) { 678 for(i = 0; i < 12; i++) {
675 for(j = 0; j < 16; j++) { 679 for(j = 0; j < 16; j++) {
676 switch(map[i][j]) { 680 switch(map[i][j]) {
725 init_keyboard(tank_rt); 729 init_keyboard(tank_rt);
726 } 730 }
727 731
728 int 732 int
729 main(int argc, char *const argv[]) { 733 main(int argc, char *const argv[]) {
730 X_MB_runtime_t *rt; 734 mb_rt_t *rt;
731 tank_rt_t tank_rt; 735 tank_rt_t tank_rt;
732 736
733 rt = X_MB_new(":0.0", 800, 600); 737 rt = mb_runtime_new(":0.0", 800, 600);
734 738
735 initial_tank(&tank_rt, rt); 739 initial_tank(&tank_rt, rt);
736 740
737 X_MB_handle_connection(rt); 741 mb_runtime_event_loop(rt);
738 742
739 X_MB_free(rt); 743 mb_runtime_free(rt);
740 } 744 }
741 745
742 /* @} */ 746 /* @} */