home *** CD-ROM | disk | FTP | other *** search
/ World of Shareware - Software Farm 2 / wosw_2.zip / wosw_2 / CPROG / CHASE.ZIP / CHASE.C
Text File  |  1989-03-19  |  17KB  |  665 lines
  1. /***************************************************************************
  2. *
  3. *
  4. *        chase appeared in Creative Computing
  5. *        magazine way back in 1976.  According
  6. *        to the book "More BASIC Computer Games"
  7. *        it was written by Mac Oglesby, with
  8. *        improvements by Bill Cotter and Arnold
  9. *        Loveridge.
  10. *        This version, in C, was written by
  11. *        Ken Brown.        7/25/84
  12. *        Code specific to the Microsoft C compiler
  13. *        is noted.
  14. *        The cursor movement routines assume that
  15. *        the DOS 2.x ANSI.SYS driver has been
  16. *        loaded.
  17. *
  18. ***************************************************************************/
  19.  
  20.  
  21. #include <stdio.h>
  22. #include <ctype.h>
  23. #include <conio.h>        /*  Microsoft direct console I/O routines */
  24.  
  25.  
  26.                 /* constant definitions */
  27. #define TRUE 1
  28. #define FALSE 0
  29. #define XDIM 60
  30. #define YDIM 20
  31. #define MAX_ROBOTS 120
  32. #define MAX_FENCES 120
  33. #define MIN_FENCES 5
  34. #define MIN_ROBOTS 5
  35. #define MY_CHAR '\002'
  36. #define ROB_CHAR '\004'
  37. #define JUNK_CHAR '@'
  38. #define FENCE_CHAR 'X' 
  39.  
  40.  
  41.                 /* global variable definitions */
  42. char        field[YDIM][XDIM], 
  43.             field_save[YDIM][XDIM]; 
  44.  
  45. int         robot_y[MAX_ROBOTS], 
  46.             robot_x[MAX_ROBOTS], 
  47.             robot_y_save[MAX_ROBOTS], 
  48.             robot_x_save[MAX_ROBOTS],
  49.         my_x, 
  50.             my_y, 
  51.         last_stand,
  52.         my_x_save,
  53.         my_y_save,
  54.         no_robots,
  55.         no_fences;
  56.  
  57. unsigned int    seed;
  58.  
  59. main() 
  60. { 
  61.         int     i_won,
  62.         game_over,
  63.         set_up,
  64.         c;
  65.          
  66.         initial();
  67.         instruct();
  68.  
  69.         set_up=TRUE;
  70.         while(TRUE) {
  71.                 if(set_up)
  72.                         new_board();
  73.                 else 
  74.                         old_board();
  75.  
  76.                 last_stand=FALSE; 
  77.         game_over=FALSE;
  78.         i_won=FALSE;
  79.  
  80.                 while(!game_over) {
  81.                         if(!last_stand)
  82.                                 game_over=move_me();
  83.  
  84.                         if(!game_over)
  85.                                 game_over=move_robots();
  86.             else
  87.                 break;
  88.  
  89.                         if(!game_over) {
  90.                 if(more_robots()==TRUE)
  91.                     continue;
  92.                 else {
  93.                     i_won=TRUE;
  94.                     break;
  95.                                 } 
  96.             }
  97.                 }
  98.                  
  99.                 if (i_won) {
  100.             move(21,0);
  101.                         printf("You have destroyed all your opponents  --  the game is yours"); 
  102.                 }
  103.                 move(22,0);
  104.                 printf("another game? (y/n)");
  105.                 c=getchar();
  106.         c=tolower(c);
  107.                 if(c=='n')
  108.             break;
  109.  
  110.                 move(23,0);
  111.                 printf("same set-up? (y/n)");
  112.                 c=getchar();
  113.                 c=tolower(c);
  114.         if(c=='y')
  115.                         set_up=FALSE;
  116.                 else
  117.                         set_up=TRUE;
  118.         }
  119.         clear();
  120.         move(22,0);
  121.  
  122. } 
  123.  
  124.  
  125. initial()
  126. /*
  127. *        get a seed for the random number generator
  128. */
  129. {
  130.  
  131.     clear();
  132.         do {
  133.                 clrtoeol(10,0);
  134.                 printf("Enter a seed for the random number generator? ");
  135.                 getnum(&seed);
  136.         } while(seed<=0);
  137.  
  138.     move(18,0);
  139.     printf("Be sure to lock the NUM LOCK KEY to use the numeric keypad");
  140.  
  141. }
  142.  
  143. instruct()
  144. /*
  145. *        print instructions
  146. */
  147. {
  148.         int c;
  149.  
  150.         move(20,0);
  151.         printf("do you want instructions? (y/n)");
  152.         c=getchar();
  153.         c=tolower(c);
  154.     if (c=='y') {
  155.                 clear();
  156.                 move(2,0);
  157.                 printf("you are within the walls of a high voltage maze\r\n"); 
  158.                 printf("the areas marked '%c' are high voltage fences\r\n",FENCE_CHAR); 
  159.         printf("being chased by robots\r\n");
  160.                 printf("your only chance for survival is to maneuver each\r\n"); 
  161.                 printf("robot into a fence\r\n"); 
  162.                 printf("you are the '%c'  the robots are the '%c'\r\n",MY_CHAR,ROB_CHAR); 
  163.                 printf("moves are:    7.8.9\r\n"); 
  164.                 printf("              4.*.6\r\n"); 
  165.                 printf("              1.2.3\r\n"); 
  166.                 printf("\r\nj = a tremendous (but unfortunately random leap)\r\n"); 
  167.                 printf("s = no move for rest of the game\r\n"); 
  168.                 printf("q = gave up, situation hopeless.\r\n"); 
  169.                 printf("\r\n\r\ngood luck!!");
  170.                 move(22,0);
  171.                 printf("press any key to begin");
  172.                 c=getchar();
  173.         }
  174. }
  175.  
  176. new_board()
  177. /*
  178. *        create and display a new playing board
  179. */
  180. {
  181.         int     y_coor,
  182.         x_coor,
  183.         fen_count,
  184.         rob_count;
  185.  
  186.         clear();
  187.         do {
  188.                 clrtoeol(10,0);
  189.                 printf("how many robots? (5 to 120) ");
  190.                 getnum(&no_robots);
  191.         } while(no_robots<MIN_ROBOTS||no_robots>MAX_ROBOTS);
  192.  
  193.         do {
  194.                 clrtoeol(12,0);
  195.                 printf("how many fences? (5 to 120) ");
  196.                 getnum(&no_fences);
  197.         } while(no_fences<MIN_FENCES||no_fences>MAX_FENCES);
  198.  
  199.         clear();
  200.         move(10,34);
  201.         printf("working.....");
  202.  
  203.         for(y_coor=0; y_coor<YDIM; y_coor++) {
  204.                 for(x_coor=0; x_coor<XDIM; x_coor++)
  205.                         field[y_coor][x_coor]=' ';
  206.         }
  207.  
  208.         for (y_coor=0; y_coor<YDIM; y_coor++) { 
  209.                 field[y_coor][0]=FENCE_CHAR; 
  210.                 field[y_coor][XDIM-1]=FENCE_CHAR; 
  211.         } 
  212.         for(x_coor=0; x_coor<XDIM; x_coor++) { 
  213.                 field[0][x_coor]=FENCE_CHAR; 
  214.                 field[YDIM-1][x_coor]=FENCE_CHAR; 
  215.         } 
  216.  
  217.         for(fen_count=0; fen_count<no_fences; fen_count++) {
  218.                 findspot(&y_coor, &x_coor);
  219.                 field[y_coor][x_coor]=FENCE_CHAR;
  220.         }
  221.  
  222.         findspot(&my_y, &my_x); 
  223.         field[my_y][my_x]=MY_CHAR; 
  224.  
  225.         for (rob_count=0; rob_count<no_robots; rob_count++) { 
  226.                 findspot(&robot_y[rob_count], &robot_x[rob_count]); 
  227.                 field[robot_y[rob_count]][robot_x[rob_count]]=ROB_CHAR; 
  228.         } 
  229.  
  230.         for (y_coor=0; y_coor<YDIM; y_coor++) { 
  231.                 for (x_coor=0; x_coor<XDIM; x_coor++) { 
  232.                         field_save[y_coor][x_coor]=field[y_coor][x_coor]; 
  233.                 } 
  234.         } 
  235.  
  236.         for (rob_count=0; rob_count<no_robots; rob_count++) { 
  237.                 robot_y_save[rob_count]=robot_y[rob_count]; 
  238.                 robot_x_save[rob_count]=robot_x[rob_count]; 
  239.         } 
  240.         my_y_save=my_y;
  241.         my_x_save=my_x;
  242.         draw_board();
  243. }
  244.  
  245. old_board()
  246. /*
  247. *        reload and display the previous board
  248. */
  249. {
  250.         int     y_coor,
  251.         x_coor,
  252.         rob_count;
  253.  
  254.         for(y_coor=0; y_coor<YDIM; y_coor++) {
  255.                 for(x_coor=0; x_coor<XDIM; x_coor++) {
  256.                         field[y_coor][x_coor]=field_save[y_coor][x_coor];
  257.                 }
  258.         }
  259.         for(rob_count=0; rob_count<no_robots; rob_count++) {
  260.                 robot_y[rob_count]=robot_y_save[rob_count];
  261.                 robot_x[rob_count]=robot_x_save[rob_count];
  262.         }
  263.         my_y=my_y_save;
  264.         my_x=my_x_save;
  265.         draw_board();
  266. }
  267.  
  268. move_me()
  269. /*
  270. *        player's movement routine
  271. */
  272. {
  273.         int     c,
  274.         my_x_old,
  275.         my_y_old;
  276.  
  277.     my_x_old=my_x;
  278.     my_y_old=my_y;
  279.         move(22,69);
  280.     putchar('*');
  281.     putchar('\b');
  282.     while(TRUE) {
  283.         c=getchar();
  284.         c=tolower(c);
  285.         if(isdigit(c)||c=='j'||c=='s'||c=='q')
  286.             break;
  287.         if(c==0)    /* trap for funtion keys */
  288.             c=getchar();
  289.         putchar('\007');
  290.     }
  291.     putchar(c);
  292.         switch(c) { 
  293.  
  294.                 case '1': 
  295.                         my_y++; 
  296.                         my_x--; 
  297.                         break; 
  298.                 case '2': 
  299.                         my_y++; 
  300.                         break; 
  301.                 case '3': 
  302.                         my_y++; 
  303.                         my_x++; 
  304.                         break; 
  305.                 case '4': 
  306.                         my_x--; 
  307.                         break; 
  308.                 case '6': 
  309.                         my_x++; 
  310.                         break; 
  311.                 case '7': 
  312.                         my_y--; 
  313.                         my_x--; 
  314.                         break; 
  315.                 case '8': 
  316.                         my_y--; 
  317.                         break; 
  318.                 case '9': 
  319.                         my_y--; 
  320.                         my_x++; 
  321.                         break; 
  322.                 case 'q': 
  323.                         clear();
  324.                         move(10,36);
  325.                         printf("chicken\n\n\n"); 
  326.                         move(22,0);
  327.                         exit(0); 
  328.                 case 'j': 
  329.                         my_y=1+rnd(YDIM-2); 
  330.                         my_x=1+rnd(XDIM-2); 
  331.                         break; 
  332.                 case 's': 
  333.                         last_stand=TRUE; 
  334.                         break; 
  335.                 default: 
  336.                         break; 
  337.         }        
  338.         field[my_y_old][my_x_old]=' '; 
  339.         move(my_y_old,my_x_old);
  340.         putchar(' ');
  341.         c=field[my_y][my_x]; 
  342.         switch(c) {
  343.                 case ROB_CHAR:
  344.                         flash(my_y,my_x);
  345.                         flash(my_y,my_x);
  346.                         move(my_y,my_x);
  347.                         printf("**MUNCH**");
  348.             move(21,0);
  349.                         printf("You have been eaten by robots");
  350.             return(TRUE);
  351.                         break;
  352.  
  353.                 case FENCE_CHAR:
  354.                 case JUNK_CHAR:
  355.                         flash(my_y,my_x);
  356.                         flash(my_y,my_x);
  357.                         move(my_y,my_x);
  358.                         printf("**ZAP**");
  359.             move(21,0);
  360.                         printf("High Voltage!!!  Zap, you're dead!"); 
  361.             return(TRUE);
  362.                         break;
  363.  
  364.                 default:
  365.                         field[my_y][my_x]=MY_CHAR; 
  366.                         move(my_y,my_x);
  367.             print_me();
  368.                         break;
  369.         }
  370. } 
  371.  
  372. move_robots()
  373. /*
  374. *        movement routine for robots
  375. */
  376. {
  377.         int     rob_count,
  378.         c;
  379.  
  380.         for(rob_count=0; rob_count<no_robots; rob_count++) { 
  381.                 if((c=field[robot_y[rob_count]][robot_x[rob_count]])!=ROB_CHAR)
  382.                         continue;
  383.                 move(robot_y[rob_count],robot_x[rob_count]);
  384.                 putchar(' ');
  385.                 field[robot_y[rob_count]][robot_x[rob_count]]=' ';
  386.                 robot_y[rob_count]=robot_y[rob_count]+sgn(my_y-robot_y[rob_count]); 
  387.                 robot_x[rob_count]=robot_x[rob_count]+sgn(my_x-robot_x[rob_count]); 
  388.                 c=field[robot_y[rob_count]][robot_x[rob_count]]; 
  389.         switch(c) {
  390.             case MY_CHAR:
  391.                             move(robot_y[rob_count],robot_x[rob_count]);
  392.                 print_robot();
  393.                             field[robot_y[rob_count]][robot_x[rob_count]]=ROB_CHAR;
  394.                             flash(robot_y[rob_count],robot_x[rob_count]);
  395.                             flash(robot_y[rob_count],robot_x[rob_count]);
  396.                             move(robot_y[rob_count],robot_x[rob_count]);
  397.                             printf("**MUNCH**");
  398.                 move(21,0);
  399.                             printf("you have been eaten by robots");
  400.                             return(TRUE);
  401.                 break;
  402.  
  403.             case ROB_CHAR:
  404.                             move(robot_y[rob_count],robot_x[rob_count]);
  405.                             putchar(JUNK_CHAR);
  406.                             field[robot_y[rob_count]][robot_x[rob_count]]=JUNK_CHAR;
  407.                             flash(robot_y[rob_count],robot_x[rob_count]);
  408.                 break;
  409.  
  410.             case JUNK_CHAR:
  411.                             flash(robot_y[rob_count],robot_x[rob_count]);
  412.                 break;
  413.  
  414.             case FENCE_CHAR:
  415.                             flash(robot_y[rob_count],robot_x[rob_count]);
  416.                 break;
  417.  
  418.             default:
  419.                         move(robot_y[rob_count],robot_x[rob_count]);
  420.                 print_robot();
  421.                         field[robot_y[rob_count]][robot_x[rob_count]]=ROB_CHAR; 
  422.                 break;
  423.             }
  424.     }
  425.     return(FALSE);
  426. }
  427.  
  428. more_robots()
  429. /*
  430. *        check whether more robots are still alive
  431. */
  432. {
  433.     int    rob_count;
  434.  
  435.     for(rob_count=0; rob_count<no_robots; rob_count++) { 
  436.         if(field[robot_y[rob_count]][robot_x[rob_count]]==ROB_CHAR)
  437.             return(TRUE);
  438.     }
  439.     return(FALSE);
  440. } 
  441.  
  442. draw_board()
  443. /*
  444. *        draw the board from the array board[][]
  445. */
  446. {
  447.         int     y_coor,
  448.         x_coor,
  449.         rob_count;
  450.  
  451.         clear();
  452.         move(0,0);
  453.         for(y_coor=0; y_coor<YDIM; y_coor++) { 
  454.                 for(x_coor=0; x_coor<XDIM; x_coor++) { 
  455.                         putchar(field[y_coor][x_coor]); 
  456.                 } 
  457.                 move(y_coor+1,0);
  458.         } 
  459.  
  460.     move(my_y,my_x);
  461.     print_me();
  462.  
  463.     for(rob_count=0; rob_count<no_robots; rob_count++) {
  464.         move(robot_y[rob_count],robot_x[rob_count]);
  465.         print_robot();
  466.     }
  467.  
  468.         move(1,63);
  469.         printf("Move Control:");
  470.         move(2,67);
  471.         printf("7 8 9");
  472.         move(3,68);
  473.         printf("\\|/");
  474.         move(4,67);
  475.         printf("4-5-6");
  476.         move(5,68);
  477.         printf("/|\\");
  478.         move(6,67);
  479.         printf("1 2 3");
  480.         move(9,66);
  481.         printf("Commands:");
  482.         move(10,63);
  483.         printf("j - a giant jump");
  484.         move(11,63);
  485.         printf("s - last stand");
  486.         move(12,63);
  487.         printf("q - quit");
  488.         move(15,66);
  489.         printf("Key:");
  490.         move(16,63);
  491.         printf("* - you");
  492.         move(17,63);
  493.         printf("+ - robot");
  494.         move(18,63);
  495.         printf("@ - junked robot");
  496.         move(19,63);
  497.         printf("X - electic fence");
  498.         move(22,63);
  499.         printf("Move [*]");
  500.  
  501. }
  502.  
  503. getnum(number)
  504. int *number;
  505. /*
  506. *        get a numeric input from the player
  507. *        non-numberic characters are locked out
  508. *        and the maximum length is arbitrarily set
  509. *        at 5 digits
  510. */
  511. {
  512.  
  513.         int     c,
  514.         count;
  515.         char     string[6];
  516.  
  517.         count=0;
  518.         while((c=getchar())!='\n'&&c!='\r') {
  519.                 switch(c) {
  520.                         case '1':
  521.                         case '2':
  522.                         case '3':
  523.                         case '4':
  524.                         case '5':
  525.                         case '6':
  526.                         case '7':
  527.                         case '8':
  528.                         case '9':
  529.                         case '0':
  530.                                 if(count<5) {
  531.                     string[count++]=c;
  532.                     putchar(c);
  533.                 }
  534.                                 break;
  535.                         case '\b':
  536.                                 if(count>0) {
  537.                                         count--;
  538.                     putchar('\b');
  539.                     putchar(' ');
  540.                     putchar('\b');
  541.                                 }
  542.                                 else {
  543.                                         putchar('\007');
  544.                                 }
  545.                                 break;
  546.                         default:
  547.                                 putchar('\007');
  548.                                 break;
  549.                 }
  550.         }
  551.         string[count]='\0';
  552.     stcd_i(string,number);    /* Microsoft string to numeric conversion
  553.                     (equiv. to atoi) */
  554. }
  555.  
  556.  
  557.  
  558. findspot(new_y,new_x) 
  559. /*
  560. *        locate a empty board position
  561. */
  562. int *new_y, *new_x; 
  563. { 
  564.  
  565.         do { 
  566.                 *new_y=1+rnd(YDIM-2); 
  567.                 *new_x=1+rnd(XDIM-2); 
  568.         } while(field[*new_y][*new_x] != ' '); 
  569.  
  570. } 
  571.  
  572. rnd(range) 
  573. /*
  574. *        generate a random number in the
  575. *        range 0<= number < range
  576. */
  577. int range; 
  578. { 
  579.         float  x; 
  580.  
  581.         seed  *= 15625;                  /* Multiplication mod 65536     */
  582.         x=(seed/65536.0)*(float)range; 
  583.         return((int)x); 
  584. } 
  585.  
  586.  
  587. sgn(number) 
  588. int(number); 
  589. /*
  590. *        return the sign of a number
  591. */
  592.  
  593. { 
  594.         if (number<0) 
  595.                 return(-1); 
  596.         if(number>0) 
  597.                 return(1); 
  598.         return(0); 
  599. } 
  600.  
  601. /*****************************************************************************
  602. *
  603. *        these routines assume that the ANSI.SYS driver
  604. *        has been loaded
  605. *
  606. *****************************************************************************/
  607.  
  608. move(y,x)
  609. int y,x;
  610. {
  611.     printf("\033[%d;%dH",y+1,x+1);     /* cursor postions are incremented
  612.                        by one because playing board
  613.                        starts at (0,0) and screen
  614.                        starts at (1,1) */    
  615. }
  616.  
  617. clrtoeol(y,x)
  618. int y,x;
  619. {
  620.     move(y,x);
  621.     printf("\033[K");
  622. }
  623.  
  624. clear()
  625. {
  626.     printf("\033[2J");
  627. }
  628.  
  629. print_me()
  630. {
  631.     printf("\033[1m");
  632.     putchar(MY_CHAR);
  633.     printf("\033[0m");
  634. }
  635.  
  636. print_robot()
  637. {
  638.     printf("\033[1m");
  639.     putchar(ROB_CHAR);
  640.     printf("\033[0m");
  641. }
  642.  
  643. flash(y,x)
  644. int x,y;
  645. {
  646.     int    count,
  647.         c;
  648.  
  649.         c=field[y][x];
  650.     move(y,x);
  651.         for(count=0; count<20; count++) {
  652.         printf("\033[1m");
  653.         putchar('\080');
  654.         putchar('\b');
  655.         printf("\033[0m");
  656.         putchar(c);
  657.         putchar('\b');
  658.         }
  659. }
  660. printf("\033[1m");
  661.         putchar('\080');
  662.         putchar('\b');
  663.         printf("\033[0m");
  664.         putchar(c);
  665.