home *** CD-ROM | disk | FTP | other *** search
/ Game Programming - All in One (3rd Edition) / game_prog_all_in_one_3rd_ed.iso / sources / TankWar-Final / main.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2006-09-17  |  7.6 KB  |  314 lines
  1. /////////////////////////////////////////////////////////////////////////
  2. // Game Programming All In One, Third Edition
  3. // Tank War Final - main.c
  4. /////////////////////////////////////////////////////////////////////////
  5.  
  6. #include "tankwar.h"
  7.  
  8.  
  9. //sprites used in the game
  10. sprite *tanks[2];
  11. sprite *bullets[2];
  12. sprite *explosions[2][2];
  13. sprite *sideviews[2];
  14.  
  15. //declare some variables
  16. int gamestate = STATE_TITLE;
  17. double scrollx[2], scrolly[2];
  18. int startx[2], starty[2];
  19. int tilex, tiley, n;
  20. int radarx, radary;
  21. int health[2];
  22.  
  23. //double buffer
  24. BITMAP *buffer;
  25.  
  26. //screen background
  27. sprite *back;
  28. sprite *title;
  29. sprite *victory1;
  30. sprite *victory2;
  31.  
  32. //define the datafile object
  33. DATAFILE *datafile;
  34.  
  35. //sounds and music
  36. SAMPLE *sounds[NUM_SOUNDS];
  37. MIDI *music_title;
  38. MIDI *music_battle;
  39. MIDI *music_victory;
  40.  
  41. //some variables used to slow down keyboard input
  42. int key_count[2];
  43. int key_delay[2];
  44.  
  45. //timer variables
  46. volatile int ticks;
  47. volatile int framerate;
  48.  
  49.  
  50. //calculate X movement value based on direction angle
  51. double calcAngleMoveX(int angle) {
  52.     return (double) cos(angle * PI / 180);
  53. }
  54.  
  55. //calculate Y movement value based on direction angle
  56. double calcAngleMoveY(int angle) {
  57.     return (double) sin(angle * PI / 180);
  58. }
  59.  
  60. //perform basic collision detection
  61. int inside(int x,int y,int left,int top,int right,int bottom)
  62. {
  63.     if (x > left && x < right && y > top && y < bottom)
  64.         return 1;
  65.     else
  66.         return 0;
  67. }
  68.  
  69. void updateradar()
  70. {
  71. /*        rectfill(buffer,radarx+1,radary+1,radarx+99,radary+88,BLACK);
  72.     rect(buffer,radarx,radary,radarx+100,radary+89,WHITE);
  73.  
  74.     //draw mini tanks on radar
  75.     for (n=0; n<2; n++)
  76.         stretch_sprite(buffer, tank_bmp[n][tanks[n]->curframe][tanks[n]->dir], 
  77.             radarx + scrollx[n]/10 + (SCROLLW/10)/2-4,
  78.             radary + scrolly[n]/12 + (SCROLLH/12)/2-4,
  79.             8, 8);
  80.  
  81.     //draw player viewport on radar
  82.     for (n=0; n<2; n++)
  83.         rect(buffer,radarx+scrollx[n]/10, radary+scrolly[n]/12,
  84.             radarx+scrollx[n]/10+SCROLLW/10, 
  85.             radary+scrolly[n]/12+SCROLLH/12, GRAY);
  86. */
  87.  
  88. }
  89.  
  90.  
  91. void updateplayerstats() 
  92. {
  93.     int n;
  94.  
  95.     //create bar for health
  96.     BITMAP *bar = create_bitmap(2,80);
  97.     rectfill(bar, 0,0,1,79, makecol(0,200,0));
  98.  
  99.     //draw bars for player 1's health
  100.     for (n=0; n < health[1]; n++)
  101.         draw_sprite(buffer, bar, 10+n*2, 5);
  102.  
  103.     //draw player 1's tank sideview
  104.     sideviews[0]->draw(buffer);
  105.  
  106.     //draw bars for player 2's health
  107.     for (n=0; n < health[0]; n++)
  108.         draw_sprite(buffer, bar, 629-n*2, 5);
  109.  
  110.  
  111.     //draw player 2's tank sideview
  112.     sideviews[1]->draw(buffer);
  113.  
  114. }
  115.  
  116.  
  117. void shutdown() 
  118. {
  119.     //free tank sprites
  120.     delete tanks[0];
  121.     delete tanks[1];
  122.  
  123.     //remove the sound driver
  124.     stop_midi();
  125.     destroy_midi(music_title);
  126.     destroy_midi(music_battle);
  127.     destroy_midi(music_victory);
  128.     remove_sound();
  129.  
  130.     //remove the joystick driver
  131.     remove_joystick();
  132.  
  133.     //free the MappyAL memory
  134.     MapFreeMem();
  135.  
  136.     //destroy bitmaps
  137.     destroy_bitmap(buffer);
  138.     
  139.     //unload datafile
  140.     unload_datafile(datafile);
  141.  
  142.     allegro_exit();
  143.  
  144.     exit(0);
  145. }
  146.  
  147. void fatalerror(char *msg)
  148. {
  149. //    set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
  150.     allegro_message(msg);
  151.     shutdown();
  152.     exit(1);
  153. }
  154.  
  155.  
  156. //calculate framerate every second
  157. void timer1(void)
  158. {
  159.     framerate = ticks;
  160.     ticks=0;
  161. }
  162. END_OF_FUNCTION(timer1)
  163.  
  164. //do something while resting
  165. void rest1(void)
  166. {
  167.     //don't do anything time intensive here!
  168. }
  169.  
  170. //main function
  171. int main(void)
  172. {
  173.     //initialize the game
  174.     allegro_init(); 
  175.     install_keyboard(); 
  176.     install_timer();
  177.     srand(time(NULL));
  178.     loaddatafile();
  179.     setupscreen();
  180.     loadgraphics();
  181.     loadsounds();
  182.  
  183.     //install the joystick handler
  184.     install_joystick(JOY_TYPE_AUTODETECT);
  185.     poll_joystick();
  186.  
  187.     //setup input delays
  188.     key_count[0] = 0;
  189.     key_delay[0] = 2;
  190.     key_count[1] = 0;
  191.     key_delay[1] = 2;
  192.  
  193.     //lock interrupt variables
  194.     LOCK_VARIABLE(framerate);
  195.     LOCK_VARIABLE(ticks);
  196.     LOCK_FUNCTION(timer1);
  197.     LOCK_FUNCTION(rest1);
  198.     install_int(timer1, 999);
  199.     
  200.     //game loop
  201.     while(1)
  202.     {
  203.         switch(gamestate) {
  204.             case STATE_TITLE:
  205.                 //display game title screen
  206.                 blit(title->image,buffer,0,0,0,0,639,479);
  207.  
  208.                 //wait for keypress
  209.                 if (keypressed()) {
  210.                     if (key[KEY_ESC])
  211.                         shutdown();
  212.                     else {
  213.                         gamestate = STATE_NORMAL;
  214.                         health[0] = 95;
  215.                         health[1] = 95;
  216.  
  217.                         //reset tanks
  218.                         scrollx[0] = 300;
  219.                         scrolly[0] = 100;
  220.                         scrollx[1] = 300; // mapwidth*mapblockwidth - 400;
  221.                         scrolly[1] = 200; // mapheight*mapblockheight - 500;
  222.                         tanks[0]->velx = 0.0f;
  223.                         tanks[0]->vely = 0.0f;
  224.                         tanks[1]->velx = 0.0f;
  225.                         tanks[1]->vely = 0.0f;
  226.  
  227.                         play_midi(music_battle, 1);
  228.                         rest(200);
  229.                         clear_keybuf();
  230.                     }
  231.                 }
  232.                 break;
  233.  
  234.             case STATE_VICTORY:
  235.                 //display victory screen for the winner
  236.                 if (health[0] > health[1])
  237.                     blit(victory1->image,buffer,0,0,0,0,639,479);
  238.                 else
  239.                     blit(victory2->image,buffer,0,0,0,0,639,479);
  240.  
  241.                 //pause before restarting
  242.                 if (keypressed()) {
  243.                     if (key[KEY_ESC]) 
  244.                         shutdown();
  245.                     else {
  246.                         gamestate = STATE_TITLE;
  247.                         play_midi(music_title, 1);
  248.                         rest(200);
  249.                         clear_keybuf();
  250.                     }
  251.                 }
  252.  
  253.                 break;
  254.         
  255.             case STATE_NORMAL:
  256.                 //draw background bitmap
  257.                 blit(back->image, buffer, 0, 0, 0, 0, back->width, back->height);
  258.  
  259.                 //draw scrolling windows (now using Mappy)
  260.                 for (n=0; n<2; n++)
  261.                     MapDrawBG(buffer, scrollx[n], scrolly[n], 
  262.                         startx[n], starty[n], SCROLLW, SCROLLH);
  263.  
  264.                 //move the tanks and bullets
  265.                 movetanks();
  266.                 animatetanks();
  267.                 movebullets();
  268.  
  269.                 //draw the sprites
  270.                 drawbullets();
  271.                 drawtanks();
  272.  
  273.                 //draw explosions over tanks
  274.                 for (int window=0; window<2; window++)
  275.                     for (n=0; n<2; n++)
  276.                         updateexplosion(window,n);
  277.  
  278.                 //update the radar
  279.                 updateradar();
  280.  
  281.                 //draw player health bars
  282.                 updateplayerstats();
  283.  
  284.                 //check for keypresses
  285.                 if (keypressed())
  286.                     getinput();
  287.  
  288.                 readjoysticks();
  289.  
  290.                 break;
  291.  
  292.         }
  293.  
  294.         //update ticks
  295.         ticks++;
  296.  
  297.         //slow the game down
  298.         rest_callback(15, rest1);
  299.  
  300.         textprintf_ex(buffer,font,0,470,makecol(255,189,73),-1,"FPS %d", framerate);
  301.  
  302.         //refresh the screen
  303.         acquire_screen();
  304.         blit(buffer, screen, 0, 0, 0, 0, WIDTH-1, HEIGHT-1);
  305.         release_screen();
  306.     }
  307.  
  308.     shutdown();
  309.     return 0;
  310. }
  311. END_OF_MAIN()
  312.  
  313.  
  314.