home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_100 / 136_01 / dumpstar.c < prev    next >
Text File  |  1979-12-31  |  12KB  |  644 lines
  1. /*    HEADER:  CUG136.08;
  2.     TITLE:        DUMPSTAR;
  3.     VERSION:    1.00;
  4.     DATE:        9/10/1984;
  5.     DESCRIPTION:    "DumpStar Video Game";
  6.     KEYWORDS:    game,video;
  7.     SYSTEM:        CP/M;
  8.     FILENAME:    DUMPSTAR.C;
  9.     AUTHORS:    R. Rodman;
  10.     COMPILERS:    C/80;
  11. */
  12.  
  13. /*    DUMPSTAR
  14.  
  15.     830721 remove WS references
  16.     830730 both x and y for enemies
  17.     830908 convert to c
  18.     830912 try to get working
  19.     830913 correct bug in movea, make 40 cols
  20.     830913 make 64 cols per sector
  21.     830916 add blast routine
  22.     830917 various fixes
  23.     830926 acceleration, other misc changes
  24.     830929 ground by calculation
  25.     831013 some refinements
  26.     831014 more refinements
  27.     840306 changes for adm5
  28.     840811 22 aliens, strategy aliens, became DUMPSTAR
  29.     840910 read terminal file
  30. */
  31.  
  32. #include "printf.c"
  33. #include "random.c"
  34.  
  35. /* value of ships includes the one you're playing with */
  36.  
  37.     int ax[ 22 ], ay[ 22 ], dx[ 22 ], dy[ 22 ];
  38.     char as[ 22 ][ 3 ];
  39.     int aliens, ships, other, gnd1ind, gnd2ind;
  40.     int ux, uy, uface, uspeed, uaccel, score, oldsco;
  41.  
  42.     char hi_name[ 10 ][ 16 ];
  43.     int hi_cnt, hi_scor[ 10 ];
  44.  
  45.     char trmbuf[ 128 ];
  46.     char *p;
  47.     int i;
  48.  
  49.     int width, height, defint, uselst, yfirst, method, addx, addy;
  50.     char *inistr, *clrscn, *clreos, *clreol, *curoff, *curon,
  51.         *curbeg, *curmid, *curend, *hiint, *loint, *revvid, *norvid,
  52.         *inslin, *dellin;
  53.  
  54. /* main program */
  55.  
  56. main()
  57. {
  58.     char wplayer(), inkey();
  59.  
  60.     terminit();            /* init terminal file */
  61.  
  62.     while( wplayer() != 'Q' ) {    /* wait for a player */
  63.  
  64.         init();
  65.         take();            /* take a ship */
  66.  
  67.         while( ships && aliens ) {
  68.             ckkey();    /* check user input */
  69.  
  70.             update();    /* update screen */
  71.  
  72.             movea();    /* move aliens */
  73.  
  74.             if( ux == 999 ) take();
  75.         }
  76.  
  77.         if( ships ) {
  78.             goxy( 0, 20 );
  79.             puts( "YOU GOT THEM ALL! PRESS A KEY: " );
  80.             puts( curon );
  81.             while( ! inkey() );
  82.         }
  83.     }
  84.  
  85.     puts( clrscn );        /* exit if player typed 'Q' */
  86.     puts( curon );
  87.  
  88.     if( defint != 'H' ) puts( loint );
  89. }
  90.  
  91. terminit()
  92. {
  93.     int t, u;
  94.     char *p;
  95.     t = fopen( "TERMINAL.SYS", "r" );
  96.  
  97.     if( t == 0 ) {
  98.         puts( "Run TERMINAL first, please." );
  99.         exit();
  100.     }
  101.  
  102.     p = &trmbuf[ 0 ];
  103.  
  104.     read( t, p, 128 );
  105.  
  106.     fclose( t );
  107.  
  108.     width = *p++;
  109.     height = *p++;
  110.     defint = *p++;
  111.     uselst = *p++;
  112.     yfirst = *p++;
  113.     method = *p++;
  114.     addx = *p++;
  115.     addy = *p++;
  116.  
  117.     for( u = 1; u <= 15; u++ ) {
  118.         switch( u ) {
  119.             case 1 : inistr = p; break;
  120.             case 2 : clrscn = p; break;
  121.             case 3 : clreos = p; break;
  122.             case 4 : clreol = p; break;
  123.             case 5 : curoff = p; break;
  124.             case 6 : curon = p; break;
  125.             case 7 : curbeg = p; break;
  126.             case 8 : curmid = p; break;
  127.             case 9 : curend = p; break;
  128.             case 10 : hiint = p; break;
  129.             case 11 : loint = p; break;
  130.             case 12 : revvid = p; break;
  131.             case 13 : norvid = p; break;
  132.             case 14 : inslin = p; break;
  133.             case 15 : dellin = p; break;
  134.         }
  135.  
  136.         p++; p++; p++; p++;
  137.         p++; p++; p++; p++;
  138.     }
  139. }
  140.  
  141. /* output a coordinate */
  142.  
  143. coord( c )
  144. int c;
  145. {
  146.     switch( method ) {
  147.         case '0' : putchar( c ); break;
  148.         case '1' : {
  149.             if( c >= 100 ) {
  150.                 putchar( '0' + c / 100 );
  151.                 c %= 100;
  152.             }
  153.             if( c >= 10 ) {
  154.                 putchar( '0' + c / 10 );
  155.                 c %= 10;
  156.             }
  157.             putchar( '0' + c );
  158.         }
  159.     }
  160. }
  161.  
  162. /* position cursor */
  163.  
  164. goxy( x, y )
  165. int x, y;
  166. {
  167.     puts( curbeg );
  168.     if( yfirst == 'Y' ) coord( y + addy );
  169.         else coord( x + addx );
  170.     puts( curmid );
  171.     if( yfirst == 'Y' ) coord( x + addx );
  172.         else coord( y + addy );
  173.     puts( curend );
  174. }
  175.  
  176. /* get a random number between 0 and range */
  177.  
  178. rnd( range )
  179. int range;
  180. {
  181.     unsigned q, rand();
  182.  
  183.     q = rand();
  184.     return( q % range );
  185. }
  186.  
  187. /* initialize game */
  188.  
  189. init()
  190. {
  191.     int j;
  192.  
  193.     srand( 0 );
  194.  
  195.     score = 0;
  196.     oldsco = 0;
  197.     aliens = 22;
  198.  
  199.     for( j = 0; j < 22; j++ ) {
  200.         ax[ j ] = rnd( 512 );
  201.         dx[ j ] = 2 * rnd( 2 ) - 1;
  202.         dy[ j ] = 2 * rnd( 2 ) - 1;
  203.         ay[ j ] = rnd( 22 );
  204.     }
  205.  
  206.     for( j = 0; j < 8; ++j ) {
  207.         dx[ j ] = 0;        /* mines */
  208.         dy[ j ] = 0;
  209.         strcpy( as[ j ], "::" );
  210.     }
  211.  
  212.     for( j = 8; j < 16; ++j )
  213.         if( dx[ j ] > 0 ) strcpy( as[ j ], ">o" );
  214.             else strcpy( as[ j ], "o<" );    /* fighters */
  215.  
  216.     for( j = 16; j < 22; ++j )
  217.         if( dx[ j ] > 0 ) strcpy( as[ j ], ")O" );
  218.             else strcpy( as[ j ], "O(" );    /* flagships */
  219.  
  220.     ships = 4;    /* initial count of ships, extra for init take() */
  221.  
  222.     gnd1ind = 0;
  223.     gnd2ind = 0;
  224.     other = 0;
  225. }
  226.  
  227. /* check keyboard for a char */
  228.  
  229. char inkey()
  230. {
  231.     return toupper( bdos( 6, 0xFF ) & 0x7F );
  232. }
  233.  
  234. /* send out string */
  235.  
  236. puts( c )
  237. char *c;
  238. {
  239.     while( *c ) putchar( *c++ );
  240. }
  241.  
  242. /* wait for someone to play */
  243.  
  244. char wplayer()
  245. {
  246.     char c;
  247.  
  248.     puts( clrscn );
  249.  
  250.     puts( "\n\n\n" );
  251.  
  252.     puts( "[[[[[[                                 \n" );
  253.     puts( "[[[ [[[                                \n" );
  254.     puts( "[[[  [[[ [[[  [[[ [[[[   [[[[ [[[[[[[  \n" );
  255.     puts( "[[[  [[[ [[[  [[[ [[[[[ [[[[[ [[[  [[[ \n" );
  256.     puts( "[[[  [[[ [[[  [[[ [[[[[[[[[[[ [[[ [[[  \n" );
  257.     puts( "[[[  [[[ [[[  [[[ [[[ [[[ [[[ [[[[[[   \n" );
  258.     puts( "[[[  [[[ [[[  [[[ [[[     [[[ [[[      \n" );
  259.     puts( "[[[[[[[   [[[[[[  [[[     [[[ [[[      \n" );
  260.     puts( "                                       \n" );
  261.     puts( "  [[[[[[[[[[[[[[[[[  [[[      [[[[[[[  \n" );
  262.     puts( " [[[[       [[[     [[[[[     [[[  [[[ \n" );
  263.     puts( "  [[[[      [[[    [[[ [[[    [[[ [[[  \n" );
  264.     puts( "   [[[[     [[[   [[[   [[[   [[[[[[   \n" );
  265.     puts( "    [[[[    [[[  [[[[[[[[[[[  [[[[[[[  \n" );
  266.     puts( "     [[[[   [[[ [[[       [[[ [[[  [[[ \n" );
  267.     puts( "      [[[[                             \n" );
  268.     puts( "]]]]]][[[                              \n" );
  269.  
  270.     puts( "\n\n" );
  271.  
  272.     puts( curon );
  273.     puts( "PRESS ANY KEY TO PLAY (Q TO QUIT): " );
  274.  
  275.     while( c = inkey() );    /* clear up any keypresses pending */
  276.     while( ! ( c = inkey() ));    /* wait for a new keypress */
  277.  
  278.     puts( curoff );
  279.  
  280.     return( c );
  281. }
  282.  
  283. /* set up screen */
  284.  
  285. setup()
  286. {
  287.     int j;
  288.  
  289.     puts( clrscn );
  290.     puts( curoff );
  291.  
  292.     for( j = 0; j <= 23; j++ ) {
  293.         goxy( 64, j );
  294.         puts( loint );
  295.         putchar( '|' );
  296.         puts( hiint );
  297.     }
  298.  
  299.     /* show ships in storage, ships - 1 */
  300.  
  301.     for( j = 13; j < ships + 12; j++ ) ship( 67, j, 1 );
  302.  
  303.     ux = 30;
  304.     uy = 14;
  305.     uface = 1;
  306.     uspeed = 1;
  307.     uaccel = 0;
  308.  
  309.     ship( ux, uy, uface );
  310. }
  311.  
  312. /* take a ship away */
  313.  
  314. take()
  315. {
  316.     int k;
  317.  
  318.     --ships;
  319.     if( ! ships ) return;
  320.  
  321.     for( k = 1; k < 30000; k++ );    /* delay */
  322.  
  323.     setup();        /* repaint screen */
  324. }
  325.  
  326. /* add another ship */
  327.  
  328. give()
  329. {
  330.     ships++;
  331.     ship( 65, ships + 13, 1 );
  332. }
  333.  
  334. /* draw ship */
  335.  
  336. ship( x, y, p )
  337. int x, y, p;
  338. {
  339.     goxy( x, y );
  340.     switch( p ) {
  341.         case -1 : puts( "<>==<" ); break;
  342.         case 0 : puts( "     " ); break;
  343.         case 1 : puts( ">==<>" ); break;
  344.     }
  345. }
  346.  
  347. /* evaluate keyboard command */
  348.  
  349. ckkey()
  350. {
  351.     int k;
  352.  
  353.     k = inkey();
  354.  
  355.     switch( k ) {
  356.         case 'Q' : ships = 0; break;
  357.  
  358.         case 'C' : if( uy < 21 ) {
  359.                 ship( ux, uy, 0 );
  360.                 ship( ux, ++uy, uface );
  361.             }; break;
  362.  
  363.         case 'E' : if( uy > 0 ) {
  364.                 ship( ux, uy, 0 );
  365.                 ship( ux, --uy, uface );
  366.             }; break;
  367.  
  368.         case 'S' :    uface = -1;
  369.                 uspeed = 1;
  370.                 uaccel = 0;
  371.                 ship( ux, uy, uface );
  372.                 break;
  373.  
  374.         case 'F' :    uface = 1;
  375.                 uspeed = 1;
  376.                 uaccel = 0;
  377.                 ship( ux, uy, uface );
  378.                 break;
  379.  
  380.         case ' ' :    fire();
  381.                 break;
  382.     }
  383.     uaccel++;
  384.     if( uaccel >= 10 && uspeed < 3 ) {
  385.         ++uspeed;    /* accelerate up to 3 */
  386.         uaccel = 0;
  387.     }
  388. }
  389.  
  390. /* fire a shot */
  391.  
  392. fire()
  393. {
  394.     int ll, ul, j, k;
  395.  
  396.     ll = ux + 5;    /* lower limit */
  397.     ul = 63;
  398.  
  399.     if( uface < 0 ) {
  400.         ll = ux - 2;
  401.         ul = -1;
  402.     }
  403.  
  404.     for( j = ll; j != ul; j += uface ) blast( j, uy, '-' );
  405. }
  406.  
  407. /* move aliens */
  408.  
  409. movea()
  410. {
  411.     int j, k, xx;
  412.     int q_cnt[ 8 ];
  413.  
  414.     for( j = 0; j < 8; j++ ) q_cnt[ j ] = 0;
  415.  
  416.     for( j = 0; j < 22; j++ ) {
  417.         if( ax[ j ] == 999 ) {
  418.             /* alien destroyed */
  419.         } else {
  420.             /* clear old pic of alien */
  421.  
  422.             for( k = 0; as[ j ][ k ]; k++ ) {
  423.                 xx = ax[ j ] + k;
  424.                 if( xx > 511 ) xx -= 512;
  425.  
  426.                 if( ( xx >= 0 ) && ( xx <= 63 ) ) {
  427.                     goxy( xx, ay[ j ] );
  428.                     putchar( ' ' );
  429.                 }
  430.             }
  431.  
  432.             ax[ j ] += dx[ j ];    /* movement of alien */
  433.             ax[ j ] -= uface * uspeed;    /* movement of ship */
  434.             if( ax[ j ] < 0 ) ax[ j ] += 512;
  435.             if( ax[ j ] > 511 ) ax[ j ] -= 512;
  436.  
  437.             ay[ j ] += dy[ j ];
  438.  
  439.             if( ay[ j ] < 0 || ay[ j ] > 21 ) {
  440.                 dy[ j ] = -dy[ j ];    /* reverse */
  441.                 ay[ j ] += dy[ j ];    /* direction */
  442.             }
  443.  
  444. /* now check strategy.  first mines */
  445.  
  446.             if( j < 8
  447.                 && absdif( ax[ j ], ux ) < 6
  448.                 && absdif( ay[ j ], uy ) < 6 ) {
  449.                 xx = ax[ j ];
  450.                 ax[ j ] = 999;    /* get rid of alien */
  451.                 --aliens;
  452.                 explode( xx, ay[ j ] );
  453.             }
  454.  
  455.             if( j >= 8 && j < 16
  456.                 && absdif( ax[ j ], ux ) > 8 ) {
  457.                     dx[ j ] = sign( ux - ax[ j ] );
  458.                     if( dx[ j ] > 0 )
  459.                         strcpy( as[ j ], ">o" );
  460.                         else strcpy( as[ j ], "o<" );
  461.             }
  462.  
  463.             if( j >= 16
  464.                 && absdif( ax[ j ], ux ) > 16 ) {
  465.                     dx[ j ] = sign( ux - ax[ j ] );
  466.                     if( dx[ j ] > 0 )
  467.                         strcpy( as[ j ], ")O" );
  468.                         else strcpy( as[ j ], "O(" );
  469.             }
  470.  
  471. /* draw new pic of alien */
  472.  
  473.             for( k = 0; as[ j ][ k ]; k++ ) {
  474.                 xx = ax[ j ] + k;
  475.                 if( xx > 511 ) xx -= 512;
  476.  
  477.                 if( ( xx >= 0 ) && ( xx <= 63 ) ) {
  478.                     goxy( xx, ay[ j ] );
  479.                     putchar( as[ j ][ k ] );
  480.                 }
  481.  
  482. /* check for collision */
  483.  
  484.                 if( ( xx >= ux && xx <= ux + 4 )
  485.                     && ( ay[ j ] == uy ) ) {
  486.                     ax[ j ] = 999;
  487.                     --aliens;
  488.                     explode( xx, ay[ j ] );
  489.                 }
  490.             }
  491.  
  492.             q_cnt[ ax[ j ] / 64 ]++;
  493.         }
  494.     }
  495.  
  496.     for( j = 0; j < 8; j++ ) {
  497.         switch( j ) {
  498.             case 0 : goxy( 69, 6 ); break;
  499.             case 1 : goxy( 72, 6 ); break;
  500.             case 2 : goxy( 72, 8 ); break;
  501.             case 3 : goxy( 72, 10 ); break;
  502.             case 4 : goxy( 69, 10 ); break;
  503.             case 5 : goxy( 66, 10 ); break;
  504.             case 6 : goxy( 66, 8 ); break;
  505.             case 7 : goxy( 66, 6 ); break;
  506.         }
  507.         printf( "%2d", q_cnt[ j ] );
  508.     }
  509. }
  510.  
  511. /* update score, etc. */
  512.  
  513. update()
  514. {
  515.     char t;
  516.     int i;
  517.  
  518.     if( score != oldsco ) {
  519.         oldsco = score;
  520.         goxy( 66, 0 );
  521.         puts( loint );
  522.         printf( "Score: %d", score );
  523.         puts( hiint );
  524.     }
  525.  
  526.     other = ! other;    /* only repaint gnd1 every other time */
  527.  
  528. /*    ground should look like this, roughly:
  529.  
  530.     _/_______/_______/______|_____\_______\________\_
  531.     /    /    /    |    \    \    \    */
  532.  
  533.     goxy( 0, 23 );
  534.     puts( loint );
  535.     for( i = gnd2ind; i < ( gnd2ind + 63 ); i++ ) {
  536.         if( i % 16 ) putchar( ' ' );
  537.             else if( i - gnd2ind < 30 )
  538.                 putchar( '/' );
  539.                 else if( i - gnd2ind > 34 )
  540.                     putchar( '\\' );
  541.                     else putchar( '|' );
  542.     }
  543.     puts( hiint );
  544.  
  545.     if( ! other ) {
  546.         goxy( 0, 22 );
  547.         puts( loint );
  548.         for( i = gnd1ind; i < ( gnd1ind + 63 ); i++ ) {
  549.             if( i % 12 ) putchar( '_' );
  550.                 else if( i - gnd1ind < 30 )
  551.                     putchar( '/' );
  552.                     else if( i - gnd1ind > 34 )
  553.                         putchar( '\\' );
  554.                         else putchar( '|' );
  555.         }
  556.         puts( hiint );
  557.  
  558.         gnd1ind += uface * uspeed;
  559.     }
  560.  
  561.     puts( hiint );
  562.  
  563.     gnd2ind += uface * uspeed;
  564. }
  565.  
  566. /* blast a location */
  567.  
  568. blast( x, y, p )
  569. int x, y;
  570. char p;
  571. {
  572.     int k, tx;
  573.  
  574.     if(( x > 63 ) || ( x < 0 )) return;
  575.  
  576.     goxy( x, y );
  577.     putchar( p );
  578.  
  579.     if(( x >= ux && x <= ux + 4 ) && y == uy ) {
  580.         tx = ux;
  581.         ux = 999;
  582.         explode( tx, uy );        /* explode you */
  583.     }
  584.  
  585.     for( k = 0; k < 22; k++ ) {
  586.         if( ( ay[ k ] == y ) && ( ax[ k ] == x ) ) {
  587.             tx = ax[ k ];        /* save x */
  588.             ax[ k ] = 999;        /* remove alien */
  589.             --aliens;        /* count down aliens left */
  590.             score += 10;        /* add 10 points */
  591.             explode( tx, ay[ k ] );
  592.         }
  593.     }
  594.  
  595.     for( k = 1; k < 150; k++ );        /* delay */
  596.  
  597.     goxy( x, y );
  598.     putchar( ' ' );
  599. }
  600.  
  601. /* explosion subroutine */
  602.  
  603. explode( x, y ) 
  604. int x, y;
  605. {
  606.     blast( x, y - 1, '|' );
  607.     blast( x - 2, y, '-' );
  608.     blast( x, y + 1, '|' );
  609.     blast( x + 2, y, '-' );
  610.     blast( x - 2, y - 1, '\\' );    /* explode in a ring around it */
  611.     blast( x - 2, y + 1, '/' );
  612.     blast( x + 2, y + 1, '\\' );
  613.     blast( x + 2, y - 1, '/' );
  614.  
  615.     blast( x, y - 2, ':' );        /* outer ring */
  616.     blast( x - 4, y, ':' );
  617.     blast( x, y + 2, ':' );
  618.     blast( x + 4, y, ':' );
  619.  
  620.     blast( x - 4, y - 2, '.' );
  621.     blast( x + 4, y + 2, '.' );
  622.     blast( x - 4, y + 2, '.' );
  623.     blast( x + 4, y - 2, '.' );
  624. }
  625.  
  626. absdif( x, y )
  627. int x, y;
  628. {
  629.     if( x > y ) return x - y;
  630.         else return y - x;
  631. }
  632.  
  633. sign( x )
  634. int x;
  635. {
  636.     if( x > 0 ) return 1;
  637.     if( x < 0 ) return -1;
  638.     return 0;
  639. }
  640.  
  641. #include "stdlib.c"
  642.  
  643.  
  644.