home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume19 / xtmines / part01 / play.c < prev   
Encoding:
C/C++ Source or Header  |  1993-04-28  |  28.8 KB  |  1,149 lines
  1. /* xtmines: game where you try to cross a minefield */
  2. /* play.c: */
  3. /* Written by Timothy Tsai  April 13, 1992 */
  4.  
  5. #include "xtmines.h"
  6.  
  7. /* This is a kludge for systems without usleep() */
  8. #ifdef NOUSLEEP
  9. #define USLEEP_LOOPS    15000
  10. void usleep(usecs)
  11. unsigned usecs;
  12. {
  13.     int    i;
  14.     for (i=0;i<USLEEP_LOOPS;i++);
  15. }
  16. #endif
  17.  
  18. void PrintStr(window,str)
  19. windtype window;
  20. char *str;
  21. {
  22.     unsigned int    ww,wh;    /* get width and height of window */
  23.     unsigned int    wbw;    /*     border width               */
  24.     Font        font;
  25.     XFontStruct    *fs;
  26.     Window        a;
  27.     int        b,c;    /* dummy vars */
  28.     unsigned int    e;    /* dummy vars */
  29.     GC        gc;
  30.  
  31.     gc = (window==status) ? gcs : (window==time_left) ? gct : gcm;
  32.     XSetForeground(disp,gc,color[font_color].pixel);
  33.     XSetBackground(disp,gc,color[background_color].pixel);
  34.     XGetGeometry(disp,wind[window],&a,&b,&c,&ww,&wh,&wbw,&e);
  35.     fs = (window==status) ? fontsstruct : 
  36.          (window==time_left) ? fonttstruct : fontmstruct;
  37.     XDrawImageString(disp,wind[window],gc,
  38.         ((ww-2*wbw)-XTextWidth(fs,str,strlen(str)))/2,
  39.         (wh - fs->ascent - fs->descent)/2 +
  40.             fs->ascent,str,strlen(str));
  41.     XFlush(disp);
  42. }
  43.  
  44. void InvPrintStr(window,str)
  45. windtype window;
  46. char *str;
  47. {
  48.     unsigned int    ww,wh;    /* get width and height of window */
  49.     unsigned int    wbw;    /*     border width               */
  50.     Font        font;
  51.     XFontStruct    *fs;
  52.     Window        a;
  53.     int        b,c;    /* dummy vars */
  54.     unsigned int    e;    /* dummy vars */
  55.     GC        gc;
  56.  
  57.     gc = (window==status) ? gcs : (window==time_left) ? gct : gcm;
  58.     XSetForeground(disp,gc,color[background_color].pixel);
  59.     XSetBackground(disp,gc,color[font_color].pixel);
  60.     XGetGeometry(disp,wind[window],&a,&b,&c,&ww,&wh,&wbw,&e);
  61.     fs = (window==status) ? fontsstruct : 
  62.          (window==time_left) ? fonttstruct : fontmstruct;
  63.     XDrawImageString(disp,wind[window],gc,
  64.         ((ww-2*wbw)-XTextWidth(fs,str,strlen(str)))/2,
  65.         (wh - fs->ascent - fs->descent)/2 +
  66.             fs->ascent,str,strlen(str));
  67.     XFlush(disp);
  68. }
  69.  
  70. void WindPrint(window,str)
  71. windtype window;
  72. char *str;
  73. {
  74.     XClearWindow(disp,wind[window]);
  75.     PrintStr(window,str);
  76. }
  77.  
  78. char *num_rank_to_words(num_rank)
  79. ranktype num_rank;
  80. {
  81.     switch (num_rank) {
  82.         case grunt    : return ("grunt"); break;
  83.         case corporal    : return ("corporal"); break;
  84.         case lieutenant    : return ("lieutenant"); break;
  85.         case captain    : return ("captain"); break;
  86.         case mmajor    : return ("major"); break;
  87.         case general    : return ("general"); break;
  88.         case president    : return ("president"); break;
  89.         case king    : return ("king"); break;
  90.         case emperor    : return ("emperor"); break;
  91.         case angel    : return ("angel"); break;
  92.         case god    : return ("god"); break;
  93.         default        : fprintf(stderr,"Error: Illegal rank\n");
  94.                   exit(2);
  95.     }
  96. }
  97.  
  98. char    last_status_str[MAXSTRLEN];
  99. void print_status(str)
  100. char *str;
  101. {
  102.  
  103.     strcpy(last_status_str,str);
  104.     WindPrint(status,str);
  105. }
  106.  
  107. char    *clock_time_str(time)
  108. int time;
  109. {
  110.     int        h,m,s;
  111.     static char    str[MAXSTRLEN];
  112.  
  113.     h = time/3600;
  114.     m = (time-(h*3600))/60;
  115.     s = (time-(h*3600)-(m*60));
  116.     if (h != 0)
  117.         sprintf(str,"%d:%02d:%02d",h,m,s);
  118.     else if (m != 0)
  119.         sprintf(str,"%d:%02d",m,s);
  120.     else
  121.         sprintf(str,"%d",s);
  122.     return (str);
  123. }
  124.  
  125. void print_display()
  126. {
  127.     char        str[MAXSTRLEN];
  128.  
  129.     sprintf(str,"Bombs: %d",num_bombs_left);
  130.     WindPrint(bombs_left,str);
  131.  
  132.     sprintf(str,"Bonus: %d",num_bonus);
  133.     WindPrint(bonus_wind,str);
  134.  
  135.     sprintf(str,"Time: %s",clock_time_str(num_time_left));
  136.     WindPrint(time_left,str);
  137.  
  138.     sprintf(str,"Score: %d",num_score);
  139.     WindPrint(score,str);
  140.  
  141.     sprintf(str,"Grenades: %d",num_grenades_left);
  142.     WindPrint(grenades_left,str);
  143.  
  144.     sprintf(str,"Rank: %s",num_rank_to_words(level));
  145.     WindPrint(rank,str);
  146.  
  147.     WindPrint(quit_wind,"Quit");
  148.  
  149.     if (used_showfig)
  150.         sprintf(str,"Show = *%s", (show==sh_man) ? "man" : "fig");
  151.     else
  152.         sprintf(str,"Show = %s", (show==sh_man) ? "man" : "fig");
  153.     WindPrint(show_wind,str);
  154.  
  155.     WindPrint(tgrenade_wind,"Throw Grenade");
  156.  
  157.     WindPrint(giveup_wind,"Surrender");
  158.  
  159.     sprintf(str,"Automark = %s",automark ? "on" : "off");
  160.     WindPrint(automark_wind,str);
  161.  
  162.     sprintf(str,"Lives: %d",num_lives);
  163.     WindPrint(lives_left,str);
  164.  
  165.     WindPrint(pause_wind,"Pause");
  166.  
  167.     if (used_sanity)
  168.         sprintf(str,"Sanity = *%s",sanity ? "on" : "off");
  169.     else
  170.         sprintf(str,"Sanity = %s",sanity ? "on" : "off");
  171.     WindPrint(sanitycheck_wind,str);
  172.  
  173.     if (used_eautomark)
  174.         sprintf(str,"ExtAmark = *%s",extended_automark ? "on" : "off");
  175.     else
  176.         sprintf(str,"ExtAmark = %s",extended_automark ? "on" : "off");
  177.     WindPrint(eautomark_wind,str);
  178.  
  179.     WindPrint(refresh_wind,"Refresh");
  180.  
  181.     WindPrint(status,last_status_str);
  182.  
  183.     XFlush(disp);
  184. }
  185.  
  186. Pixmap bitmap[NUMBITMAPS];
  187. int bmwidth[NUMBITMAPS];
  188. int bmheight[NUMBITMAPS];
  189. /* This function will draw the bitmap indicated by bm in the field at the */
  190. /*   position (vx,vy).  If show==sh_fig, then a figure will be drawn      */
  191. /*   instead of the man bitmap.  The figure is the number of surrounding  */
  192. /*   bombs.  The font for figures is the same as the font for the status. */
  193. void draw(bm,vx,vy)
  194. bmtype bm;
  195. int vx,vy;
  196. {
  197.     int    x,y;
  198.     int    numbombs;
  199.     char    str[2];
  200.  
  201.     setxy(vx,vy,&x,&y);
  202.     if ((bm==bm_man) && (show==sh_fig)) {
  203.        clear(vx,vy);
  204.        numbombs = bomb_status(vx,vy);
  205.        str[0] = '0' + numbombs; str[1]=NULL;
  206.        XDrawString(disp,field,gcs,
  207.         1+vx*(man_width+1)+(man_width-fontshoww)/2,
  208.         1+vy*(man_height+1)+(man_height-fontshowa)/2+fontshowa,
  209.         str,strlen(str));
  210.     }
  211.     else
  212.        XCopyPlane(disp,bitmap[bm],field,gcm,0,0,bmwidth[bm],bmheight[bm],
  213.         x+1,y+1,1);
  214.     XFlush(disp);
  215. }
  216.  
  217. void clear(vx,vy)
  218. int vx,vy;
  219. {
  220.     int    x,y;
  221.  
  222.     setxy(vx,vy,&x,&y);
  223.     XClearArea(disp,field,x+1,y+1,bmwidth[bm_man],bmwidth[bm_safe],FALSE);
  224. }
  225.  
  226. fieldstruct FIELD[NUMCOLS][NUMROWS];
  227. void draw_field()
  228. {
  229.     int    r,c;
  230.     double    rowsep,colsep;
  231.  
  232.     /* draw vertical lines */
  233.     colsep = ((double)(w-2*bw)/(double)NUMCOLS);
  234.     for (c=0; c<NUMCOLS; c++) {
  235.         XSetForeground(disp,gcm,color[field_color].pixel);
  236.         XSetBackground(disp,gcm,color[background_color].pixel);
  237.         XDrawLine(disp,field,gcm,(int)(c*colsep),0,(int)(c*colsep),fh);
  238.     }
  239.  
  240.     /* draw horizontal lines */
  241.     rowsep = ((double)fh/(double)NUMROWS);
  242.     for (r=0; r<NUMROWS; r++) {
  243.         XSetForeground(disp,gcm,color[field_color].pixel);
  244.         XSetBackground(disp,gcm,color[background_color].pixel);
  245.         XDrawLine(disp,field,gcm,0,(int)(r*rowsep),w,(int)(r*rowsep));
  246.     }
  247.  
  248.     /* draw contents */
  249.     for (c=0;c<NUMCOLS;c++)
  250.         for (r=0;r<NUMROWS;r++)
  251.             if (FIELD[c][r].m==fm_safe)
  252.                 draw(bm_safe,c,r);
  253.             else if (FIELD[c][r].m==fm_bomb)
  254.                 draw(bm_bombmark,c,r);
  255.             else switch (FIELD[c][r].c) {
  256.                 case fc_empty    : break;
  257.                 case fc_man    : draw(bm_man,c,r); break;
  258.                 case fc_bomb    : if (dead)
  259.                             draw(bm_bomb,c,r);
  260.                           break;
  261.                 case fc_tombstone
  262.                         : draw(bm_tombstone,c,r); break;
  263.                 case fc_goal    : draw(bm_goal,c,r); break;
  264.                 case fc_trail    : draw(bm_trail,c,r); break;
  265.                 default        : fprintf(stderr,
  266.                     "Error: Illegal FIELD content\n");
  267.                     exit(1);
  268.             }
  269.     XFlush(disp);
  270. }
  271.  
  272. /* remove all Exposure events from the events queue; return the number
  273.    of actual events removed */
  274. int remove_expose_events()
  275. {
  276.     int    r=0;        /* number of events removed so far */
  277.     XEvent    event;        /* not used */
  278.  
  279.     while (XCheckMaskEvent(disp,ExposureMask,&event))
  280.         r++;
  281.     return (r);
  282. }
  283.  
  284. void refresh()
  285. {
  286.     XEvent        event;
  287.     int        done=FALSE;    /* finished dequeuing all exposes? */
  288.  
  289.     print_display();
  290.     draw_field();
  291.     draw(bm_man,manvx,manvy);
  292.     XFlush(disp);
  293.  
  294.     /* now dequeue all immediately succeeding exposure events */
  295.     /*    to prevent multiple, useless refreshes              */
  296.     remove_expose_events();
  297. }
  298.  
  299. /* set up windows for pausing;  the field should be blanked to prevent
  300.    cheating;  the time should be adjusted so there is no penalty for pausing;
  301. */
  302. int do_pause()
  303. {
  304.     int        time_at_start_of_pause;
  305.  
  306.     char        str[MAXSTRLEN];
  307.     unsigned int    ww,wh;    /* get width and height of window */
  308.     unsigned int    wbw;    /*     border width               */
  309.     XFontStruct    *fs;
  310.     Window        a;
  311.     int        b,c;    /* dummy vars */
  312.     unsigned int    e;    /* dummy vars */
  313.  
  314.     int            wait=TRUE;
  315.     XEvent            event;
  316.     XButtonPressedEvent    *eventbp;
  317.     XKeyPressedEvent    *eventkp;
  318.     KeySym            ksym;
  319.     char            s;
  320.     int            done;
  321.  
  322.     WindPrint(pause_wind,"Continue");
  323.     time_at_start_of_pause = time(0);
  324.  
  325.     /* blank out field and write "P-A-U-S-E" message on field */
  326.     XClearWindow(disp,field);
  327.     strcpy(str,"P-A-U-S-E");
  328.     XSetForeground(disp,gcs,color[font_color].pixel);
  329.     XSetBackground(disp,gcs,color[background_color].pixel);
  330.     XGetGeometry(disp,field,&a,&b,&c,&ww,&wh,&wbw,&e);
  331.     fs = fontsstruct;
  332.     XDrawImageString(disp,field,gcs,
  333.         ((ww-2*wbw)-XTextWidth(fs,str,strlen(str)))/2,
  334.         (wh - fs->ascent - fs->descent)/2 +
  335.             fs->ascent,str,strlen(str));
  336.     XFlush(disp);
  337.  
  338.     /* Wait for keypress or button click to signal done with pause */
  339.     while (wait == TRUE) {
  340.        while (!XPending(disp))
  341.         usleep(XPENDING_UDELAY);
  342.        XNextEvent(disp,&event);
  343.        if (event.type==ButtonPress) {
  344.         eventbp = (XButtonPressedEvent *) &event;
  345.         if (eventbp->window == wind[pause_wind])
  346.                     wait = FALSE;
  347.        }
  348.        else if (event.type == KeyPress) {
  349.         eventkp = (XKeyPressedEvent *) &event;
  350.         XLookupString(&event,&s,1,&ksym,NULL);
  351.         if ((s == 'c') || (s == 'C'))
  352.             wait = FALSE;
  353.        }
  354.        else if (event.type == Expose) {
  355.        /* do refresh in pause mode; pause_wind and field are different */
  356.         print_display();
  357.         WindPrint(pause_wind,"Continue");
  358.         sprintf(str,"Time: %s",clock_time_str(
  359.             num_time_left_at_start-
  360.             (time_at_start_of_pause-time_at_start_of_level
  361.                            -pause_time)));
  362.         WindPrint(time_left,str);
  363.  
  364.         /* blank out field and write "P-A-U-S-E" message on field */
  365.         WindPrint(pause_wind,"Continue");
  366.         XClearWindow(disp,field);
  367.         strcpy(str,"P-A-U-S-E");
  368.         XSetForeground(disp,gcs,color[font_color].pixel);
  369.         XSetBackground(disp,gcs,color[background_color].pixel);
  370.         XGetGeometry(disp,field,&a,&b,&c,&ww,&wh,&wbw,&e);
  371.         fs = fontsstruct;
  372.         XDrawImageString(disp,field,gcs,
  373.             ((ww-2*wbw)-XTextWidth(fs,str,strlen(str)))/2,
  374.             (wh - fs->ascent - fs->descent)/2 +
  375.                 fs->ascent,str,strlen(str));
  376.         XFlush(disp);
  377.     
  378.         /* now dequeue all immediately succeeding exposure events */
  379.         /*    to prevent multiple, useless refreshes              */
  380.         remove_expose_events();
  381.        }
  382.     }
  383.  
  384.     pause_time += time(0) - time_at_start_of_pause;
  385.  
  386.     /* Restore windows to continue game */
  387.     XClearWindow(disp,field);
  388.     refresh();
  389.  
  390.     WindPrint(pause_wind,"Pause");
  391. }
  392.  
  393. int setxy(vx,vy,x,y)
  394. int vx,vy,*x,*y;
  395. {
  396. /* convert virtual coordinates to actual field pixel coordinates */
  397.     double    rowsep,colsep;
  398.  
  399.     if (((vx>=0) && (vx<NUMCOLS)) &&
  400.         ((vy>=0) && (vy<NUMROWS))) {
  401.         colsep = ((double)(w-2*bw)/(double)NUMCOLS);
  402.         rowsep = ((double)fh/(double)NUMROWS);
  403.         *x = vx*colsep;
  404.         *y = vy*rowsep;
  405.         return (SUCCESS);
  406.     }
  407.     else
  408.         return (OUT_OF_RANGE);
  409. }
  410.  
  411. int setvxvy(x,y,vx,vy)
  412. int x,y,*vx,*vy;
  413. {
  414. /* convert actual field pixel coordinates to virtual coordinates */
  415.     double    rowsep,colsep;
  416.  
  417.     if (((x>=0) && (x<w-2*bw)) &&
  418.         ((y>=0) && (y<fh))) {
  419.         colsep = ((double)(w-2*bw)/(double)NUMCOLS);
  420.         rowsep = ((double)fh/(double)NUMROWS);
  421.         *vx = x/colsep;
  422.         *vy = y/rowsep;
  423.         return (SUCCESS);
  424.     }
  425.     else
  426.         return (OUT_OF_RANGE);
  427. }
  428.  
  429. int bomb_status(vx,vy)
  430. int vx,vy;
  431. {
  432.     int    numbombs=0;
  433.  
  434.     if (vy>0) {
  435.         if ((vx>0) && (FIELD[vx-1][vy-1].c==fc_bomb))
  436.             numbombs++;
  437.         if (FIELD[vx][vy-1].c==fc_bomb)
  438.             numbombs++;
  439.         if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy-1].c==fc_bomb))
  440.             numbombs++;
  441.     }
  442.     if (vy<NUMROWS-1) {
  443.         if ((vx>0) && (FIELD[vx-1][vy+1].c==fc_bomb))
  444.             numbombs++;
  445.         if (FIELD[vx][vy+1].c==fc_bomb)
  446.             numbombs++;
  447.         if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy+1].c==fc_bomb))
  448.             numbombs++;
  449.     }
  450.     if ((vx>0) && (FIELD[vx-1][vy].c==fc_bomb))
  451.         numbombs++;
  452.     if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy].c==fc_bomb))
  453.         numbombs++;
  454.  
  455.     return (numbombs);
  456. }
  457.  
  458. void show_bomb_status(vx,vy)
  459. int vx,vy;
  460. {
  461.     int    numbombs;
  462.     char    str[MAXSTRLEN];
  463.  
  464.     numbombs = bomb_status(vx,vy);
  465.  
  466.     sprintf(str,"%d surrounding bomb%c",numbombs,numbombs==1 ? ' ' : 's');
  467.     print_status(str);
  468.  
  469.     if ((automark) && (numbombs==0))
  470.         mark_allaround_ok(manvx,manvy,0);
  471. } 
  472.  
  473. /* show_all_bombs:  shows all bombs on field   */
  474. /*                  if any marks are incorrect */
  475. /*                     highlight those squares */
  476. void show_all_bombs()
  477. {
  478.     int    c,r;    /* column and row under consideration */
  479.  
  480.     for (c=0;c<NUMCOLS;c++)
  481.        for (r=0;r<NUMROWS;r++)
  482.         if (FIELD[c][r].c == fc_bomb)
  483.            if (FIELD[c][r].m == fm_safe)
  484.             draw(bm_safewrong,c,r);    /* bomb, marked safe */
  485.            else
  486.             draw(bm_bomb,c,r);    /* bomb, unmarked or correct */
  487.         else if (FIELD[c][r].m == fm_bomb)
  488.            draw(bm_bombmarkwrong,c,r);    /* no bomb, marked unsafe */
  489. }
  490.  
  491. void do_promotion()
  492. {
  493.         char                    str[MAXSTRLEN];
  494.     XEvent            event;
  495.         XButtonPressedEvent     *eventbp;
  496.         XKeyPressedEvent        *eventkp;
  497.         int                     wait = TRUE;
  498.  
  499.     finished = TRUE;
  500.     num_score += current_bonus();
  501.     printf("Your bonus for reaching the goal at rank %s is\n",
  502.         num_rank_to_words(level));
  503.     printf("     %5d = %d*%d \t (level*Time left)\n",
  504.         current_bonus(),level+1,num_time_left);
  505.     if (num_bombs_left>0)
  506.         printf("           + %d    \t (Num bombs left)\n",
  507.         num_bombs_left);
  508.     if (num_grenades_left>0)
  509.         printf("           + %d*%d \t (Num grenades left*ppg)\n",
  510.         num_grenades_left,POINTS_PER_GRENADE);
  511.     if (num_tombstones>0)
  512.         printf("           - %d*%d \t (Num tombstones*ppts)\n",
  513.         num_tombstones,POINTS_PER_TOMBSTONE);
  514. /* This used to be used for ver 1.0
  515.     if (used_showfig)
  516.         printf("           - %d \t (Used showfig?)\n",
  517.         POINTS_FOR_USED_SHOWFIG);
  518. */
  519.     if (used_sanity)
  520.         printf("           - %d \t (Used sanity check?)\n",
  521.         (PERCENT_FOR_USED_SANITY*bonus_without_penalties())/100);
  522.     if (used_eautomark)
  523.         printf("           - %d \t (Used extended_automark?)\n",
  524.         (PERCENT_FOR_USED_EAUTOMARK*bonus_without_penalties())/100);
  525.     printf("Your current score is %d = %d + %d\n",
  526.         num_score,num_score-current_bonus(),current_bonus());
  527.  
  528.     show_all_bombs();
  529.  
  530.     /* now update score on screen incrementally */
  531.     {
  532.         int i;
  533.         /* this will make sure that at most 100 steps are made */
  534.         int step = current_bonus()/100;
  535.  
  536.         for (i=num_score-current_bonus();i<num_score;i+=step) {
  537.             sprintf(str,"Score: %d",i);
  538.             PrintStr(score,str);
  539.         }
  540.         sprintf(str,"Score: %d",num_score);
  541.         WindPrint(score,str);
  542.     }
  543.  
  544.     if (level == HIGHEST_PLAYABLE_RANK) {
  545.        sprintf(str,
  546.        "Congratulations, you have reached completed the highest rank!");
  547.        level++;
  548.        show_and_add_scores();
  549.     }
  550.     else
  551.        sprintf(str,"Congratulations, you have been promoted to %s",
  552.         num_rank_to_words(level+1));
  553.     print_status(str);
  554.  
  555.     /* reward additional lives and grenades */
  556.     if ((level>=LOWEST_LEVEL_FOR_REWARD) &&
  557.         (num_score>=LOWEST_SCORE_FOR_REWARD)) {
  558.         if (++num_grenades_left > NUM_GRENADES_AT_START)
  559.             num_grenades_left = NUM_GRENADES_AT_START;
  560.         sprintf(str,"Grenades: %d",num_grenades_left);
  561.         WindPrint(grenades_left,str);
  562.         if (++num_lives>MAXLIVES) num_lives=MAXLIVES;
  563.         sprintf(str,"Lives: %d",num_lives);
  564.         WindPrint(lives_left,str);
  565.     }
  566.  
  567.     sleep(3);
  568.  
  569.     print_status ("In the field, press key or click button to continue");
  570.     while (wait == TRUE) {
  571.        while (!XPending(disp))
  572.         usleep(XPENDING_UDELAY);
  573.        XNextEvent(disp,&event);
  574.        if (event.type==ButtonPress) {
  575.         eventbp = (XButtonPressedEvent *) &event;
  576.         if (eventbp->window == field)
  577.             wait = FALSE;
  578.         else if (eventbp->window == wind[quit_wind]) {
  579.             level++;
  580.             show_and_add_scores();
  581.         }
  582.        }
  583.        else if (event.type == KeyPress) {
  584.         eventkp = (XKeyPressedEvent *) &event;
  585.         if (eventkp->window == field)
  586.             wait = FALSE;
  587.        }
  588.        else if (event.type == Expose) {
  589.         refresh();
  590.         show_all_bombs();
  591.        }
  592.     }
  593. }
  594.  
  595. /* next_to_trail:  returns TRUE is at least one of the up to eight adjacent */
  596. /*                 squares is already traversed and marked as fc_trail;     */
  597. /*                 vx and vy is the square in question                      */
  598. int next_to_trail(vx,vy)
  599. int vx,vy;
  600. {
  601.     int    numbombs=0;
  602.  
  603.     if (vy>0) {
  604.         if ((vx>0) && (FIELD[vx-1][vy-1].c==fc_trail))
  605.             return (TRUE);
  606.         if (FIELD[vx][vy-1].c==fc_trail)
  607.             return (TRUE);
  608.         if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy-1].c==fc_trail))
  609.             return (TRUE);
  610.     }
  611.     if (vy<NUMROWS-1) {
  612.         if ((vx>0) && (FIELD[vx-1][vy+1].c==fc_trail))
  613.             return (TRUE);
  614.         if (FIELD[vx][vy+1].c==fc_trail)
  615.             return (TRUE);
  616.         if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy+1].c==fc_trail))
  617.             return (TRUE);
  618.     }
  619.     if ((vx>0) && (FIELD[vx-1][vy].c==fc_trail))
  620.         return (TRUE);
  621.     if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy].c==fc_trail))
  622.         return (TRUE);
  623.  
  624.     return (FALSE);
  625. }
  626.  
  627. int move_man(vx,vy)
  628. int vx,vy;
  629. {
  630.     int    ax,ay;        /* adjusted x and y */
  631.     int    reached_goal=FALSE;
  632.  
  633.     setxy(vx,vy,&ax,&ay);
  634.  
  635.     if (FIELD[vx][vy].m == fm_bomb) {
  636.         XBell(disp,0);
  637.         print_status("Square is marked as unsafe!");
  638.         return (SQUARE_IS_UNSAFE);
  639.     }
  640.     if (((abs(manvx-vx)<=1) && (abs(manvy-vy)<=1)) ||
  641.         (FIELD[vx][vy].c==fc_trail) ||
  642.         (next_to_trail(vx,vy) && (FIELD[vx][vy].m==fm_safe))) {
  643.        switch (FIELD[vx][vy].c) {
  644.         case fc_goal    :
  645.         case fc_trail    :
  646.         case fc_empty    : /* only allow movement of one square */
  647.                   if ((FIELD[vx][vy].c==fc_goal) && (!dead))
  648.                     reached_goal = TRUE;
  649.                   draw(bm_trail,manvx,manvy);
  650.                   FIELD[manvx][manvy].c = fc_trail;
  651.                   manvx = vx; manvy = vy;
  652.                   draw(bm_man,vx,vy);
  653.                   FIELD[manvx][manvy].c = fc_man;
  654.                   FIELD[manvx][manvy].m = fm_nomark;
  655.                   if (reached_goal)
  656.                     do_promotion();
  657.                   break;
  658.         case fc_man    : show_bomb_status(manvx,manvy);
  659.                   draw(bm_man,manvx,manvy);
  660.                   break;
  661.         case fc_bomb    : draw(bm_trail,manvx,manvy);
  662.                   FIELD[manvx][manvy].c = fc_trail;
  663.                   die(vx,vy);
  664.                   break;
  665.         case fc_tombstone:
  666.                   break;
  667.         default        : fprintf(stderr,
  668.                     "Error: Illegal FIELD contents\n");
  669.                   exit(2);
  670.        }
  671.        show_bomb_status(manvx,manvy);
  672.     }
  673.     else {
  674.        print_status("Can't move that far!");
  675.        XBell(disp,0);          
  676.     }
  677.     return (SUCCESS);
  678. }
  679.  
  680. int remove_mark(vx,vy)
  681. int vx,vy;
  682. {
  683.     if (FIELD[vx][vy].m == fm_nomark)
  684.         return (NO_MARK_TO_REMOVE);    
  685.     else {
  686.         FIELD[vx][vy].m = fm_nomark;
  687.         clear(vx,vy);
  688.         return (SUCCESS);
  689.     }
  690. }
  691.  
  692. int mark_ok(vx,vy)
  693. int vx,vy;
  694. {
  695.     switch (FIELD[vx][vy].c) {
  696.         case fc_empty:
  697.         case fc_bomb:    FIELD[vx][vy].m = fm_safe;
  698.                 draw(bm_safe,vx,vy);
  699.                 return (SUCCESS);
  700.         case fc_trail:
  701.         case fc_man:
  702.         case fc_tombstone:
  703.         case fc_goal:    return (CANT_MARK);
  704.         default:    fprintf(stderr,
  705.                     "Error: Illegal FIELD contents\n");
  706.                 exit(3);
  707.     }
  708. }
  709.  
  710. /* if level<0, then only mark immediately surrounding squares;  don't do
  711.    extended automarking
  712. */
  713. int mark_allaround_ok(vx,vy,level)
  714. int vx,vy,level;    /* level=level of recursion */
  715. {
  716.     int    c,r;    /* col and row to clear FIELD[][].done flags */
  717.  
  718.     /* clear all done flags if on original call */
  719.     if (level==0)
  720.         for (c=0;c<NUMCOLS;c++)
  721.            for (r=0;r<NUMROWS;r++)
  722.             FIELD[c][r].done = FALSE;
  723.  
  724.     if (vy>0) {
  725.         if ((vx>0) && (FIELD[vx-1][vy-1].m==fm_nomark))
  726.             mark_ok(vx-1,vy-1);
  727.         if (FIELD[vx][vy-1].m==fm_nomark)
  728.             mark_ok(vx,vy-1);
  729.         if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy-1].m==fm_nomark))
  730.             mark_ok(vx+1,vy-1);
  731.     }
  732.     if (vy<NUMROWS-1) {
  733.         if ((vx>0) && (FIELD[vx-1][vy+1].m==fm_nomark))
  734.             mark_ok(vx-1,vy+1);
  735.         if (FIELD[vx][vy+1].m==fm_nomark)
  736.             mark_ok(vx,vy+1);
  737.         if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy+1].m==fm_nomark))
  738.             mark_ok(vx+1,vy+1);
  739.     }
  740.     if ((vx>0) && (FIELD[vx-1][vy].m==fm_nomark))
  741.         mark_ok(vx-1,vy);
  742.     if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy].m==fm_nomark))
  743.         mark_ok(vx+1,vy);
  744.  
  745.     if ((level>=0) && (extended_automark) && (!FIELD[vx][vy].done)) {
  746.     /* mark square as being already marked-allaround to prevent repeat */
  747.         FIELD[vx][vy].done = TRUE;
  748.         if (bomb_status(vx,vy) == 0) {
  749.             draw(bm_trail,vx,vy);
  750.             FIELD[vx][vy].c = fc_trail;
  751.             FIELD[vx][vy].m = fm_nomark;
  752.         }
  753.         if (vy>0) {
  754.             if ((vx>0) && (FIELD[vx-1][vy-1].m==fm_safe) &&
  755.                 (bomb_status(vx-1,vy-1)==0))
  756.                 mark_allaround_ok(vx-1,vy-1,level+1);
  757.             if ((FIELD[vx][vy-1].m==fm_safe) &&
  758.                 (bomb_status(vx,vy-1)==0))
  759.                 mark_allaround_ok(vx,vy-1,level+1);
  760.             if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy-1].m==fm_safe) &&
  761.                 (bomb_status(vx+1,vy-1)==0))
  762.                 mark_allaround_ok(vx+1,vy-1,level+1);
  763.         }
  764.         if (vy<NUMROWS-1) {
  765.             if ((vx>0) && (FIELD[vx-1][vy+1].m==fm_safe) &&
  766.                 (bomb_status(vx-1,vy+1)==0))
  767.                 mark_allaround_ok(vx-1,vy+1,level+1);
  768.             if ((FIELD[vx][vy+1].m==fm_safe) &&
  769.                 (bomb_status(vx,vy+1)==0))
  770.                 mark_allaround_ok(vx,vy+1,level+1);
  771.             if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy+1].m==fm_safe) &&
  772.                 (bomb_status(vx+1,vy+1)==0))
  773.                 mark_allaround_ok(vx+1,vy+1,level+1);
  774.         }
  775.         if ((vx>0) && (FIELD[vx-1][vy].m==fm_safe) &&
  776.             (bomb_status(vx-1,vy)==0))
  777.             mark_allaround_ok(vx-1,vy,level+1);
  778.         if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy].m==fm_safe) &&
  779.             (bomb_status(vx+1,vy)==0))
  780.             mark_allaround_ok(vx+1,vy,level+1);
  781.     }
  782.  
  783.     /* put man marker back on field */
  784.     if (level<=0)
  785.         draw(bm_man,manvx,manvy);
  786.  
  787.     return (SUCCESS);
  788. }
  789.  
  790. int mark_bomb(vx,vy)
  791. int vx,vy;
  792. {
  793.     switch (FIELD[vx][vy].c) {
  794.         case fc_empty:
  795.         case fc_bomb:    FIELD[vx][vy].m = fm_bomb;
  796.                 draw(bm_bombmark,vx,vy);
  797.                 return (SUCCESS);
  798.         case fc_trail:
  799.         case fc_man:
  800.         case fc_tombstone:
  801.         case fc_goal:    return (CANT_MARK);
  802.         default:    fprintf(stderr,
  803.                     "Error: Illegal FIELD contents\n");
  804.                 exit(3);
  805.     }
  806. }
  807.  
  808. void die(vx,vy)
  809. int vx,vy;
  810. {
  811.     char            str[MAXSTRLEN];
  812.  
  813.     explode(vx,vy);
  814.     draw(bm_tombstone,vx,vy);
  815.     FIELD[vx][vy].c = fc_tombstone;
  816.     num_tombstones++;
  817.     if (--num_lives<0)
  818.         num_lives = 0;
  819.     sprintf(str,"Lives: %d",num_lives);
  820.     WindPrint(lives_left,str);
  821.     if ((num_lives<=0) && (!dead)) {
  822.         show_bomb_status(manvx,manvy);
  823.         dead = TRUE;
  824.         show_all_bombs();
  825.         print_status("You have just died!  GAME OVER!");
  826.         XBell(disp,0);
  827.         XBell(disp,0);
  828.         XBell(disp,0);
  829.         XFlush(disp);
  830.         sleep(3);
  831.     }
  832.     draw(bm_man,0,0);
  833.     FIELD[0][0].c = fc_man;
  834.     FIELD[0][0].m = fm_nomark;
  835.     manvx = manvy = 0;
  836.     show_bomb_status(manvx,manvy);
  837. }
  838.  
  839. int explode(vx,vy)
  840. int vx,vy;
  841. {
  842.     int    i;
  843.     char    str[MAXSTRLEN];
  844.  
  845.     if (FIELD[vx][vy].c == fc_bomb) {
  846.         num_bombs_left--;
  847.         sprintf(str,"Bombs: %d",num_bombs_left);
  848.         WindPrint(bombs_left,str);
  849.     }
  850.  
  851.     /* simulate explosion on screen */
  852.     for (i=0;i<10;i++) {
  853.         draw(bm_pow,vx,vy);
  854.         usleep(BOMB_EXPLODE_UDELAY);
  855.         draw(bm_bomb,vx,vy);
  856.         usleep(BOMB_EXPLODE_UDELAY);
  857.     }
  858.     clear(vx,vy);
  859.     FIELD[vx][vy].c = fc_empty;
  860.     FIELD[vx][vy].m = fm_nomark;
  861.  
  862.  
  863.     /* check to see if other bombs nearby--Manhattan dirs only */
  864.     if ((vx>0) && (FIELD[vx-1][vy].c==fc_bomb)) explode(vx-1,vy);
  865.     if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy].c==fc_bomb)) explode(vx+1,vy);
  866.     if ((vy>0) && (FIELD[vx][vy-1].c==fc_bomb)) explode(vx,vy-1);
  867.     if ((vy<NUMROWS-1) && (FIELD[vx][vy+1].c==fc_bomb)) explode(vx,vy+1);
  868.  
  869.     /* check to see if man nearby--Manhattan dirs only */
  870.     if ((vx>0) && (FIELD[vx-1][vy].c==fc_man)) die(vx-1,vy);
  871.     if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy].c==fc_man)) die(vx+1,vy);
  872.     if ((vy>0) && (FIELD[vx][vy-1].c==fc_man)) die(vx,vy-1);
  873.     if ((vy<NUMROWS-1) && (FIELD[vx][vy+1].c==fc_man)) die(vx,vy+1);
  874.  
  875.     return(SUCCESS);
  876. }
  877.  
  878. /* bonus_without_penalties:  returns the current bonus remaining for */
  879. /*    this level, without used_* penalties                         */
  880. int bonus_without_penalties()
  881. {
  882.     int    b;    /* temp value for current bonus */
  883.  
  884.     b = (level+1)*num_time_left
  885.         + num_bombs_left
  886.         + num_grenades_left*POINTS_PER_GRENADE
  887.         - num_tombstones*POINTS_PER_TOMBSTONE;
  888.  
  889.     if (b < 0)
  890.         b = 0;
  891.  
  892.     return (b);
  893. }
  894.  
  895. /* current_bonus:  returns the current amount of bonus */
  896. /*                    remaining for this level         */
  897. int current_bonus()
  898. {
  899.     int    b;    /* temp value for current bonus */
  900.  
  901.     b = bonus_without_penalties()
  902. /* This used to be used for ver 1.0
  903.         - used_showfig*POINTS_FOR_USED_SHOWFIG;
  904. */
  905.         - used_sanity*
  906.            (PERCENT_FOR_USED_SANITY*bonus_without_penalties())/100
  907.         - used_eautomark*
  908.            (PERCENT_FOR_USED_EAUTOMARK*bonus_without_penalties())/100;
  909.  
  910.     if (b < 0)
  911.         b = 0;
  912.  
  913.     return (b);
  914. }
  915.         
  916.  
  917. /* update_bonus:  recalculate the amount of bonus remaining for this level */
  918. /*                display the correct new bonus on screen                  */
  919. int update_bonus()
  920. {
  921.     char        str[MAXSTRLEN];
  922.     static int    last_bonus;
  923.  
  924.     if ((num_bonus = current_bonus()) != last_bonus) {
  925.         sprintf(str,"Bonus: %d",num_bonus);
  926.         WindPrint(bonus_wind,str);
  927.         last_bonus = num_bonus;
  928.     }
  929. }
  930.  
  931. int update_time()
  932. {
  933.     long    st,ct;    /* starting and current times */
  934.     char    str[MAXSTRLEN];
  935.     int    previous_num_time_left=num_time_left;
  936.  
  937.     st = time_at_start_of_level;
  938.     ct = time(0);
  939.     num_time_left = num_time_left_at_start - (ct-st-pause_time);
  940.     update_bonus();
  941.     if (num_time_left<=0) {
  942.         print_status("Time is out!  GAME OVER!");
  943.         sprintf(str,"Time: %s",clock_time_str(num_time_left));
  944.         WindPrint(time_left,str);
  945.         XBell(disp,0);
  946.         XBell(disp,0);
  947.         XBell(disp,0);
  948.         return (TIME_IS_OVER);    /* TIME_IS_OVER = TRUE */
  949.     }
  950.     else if (num_time_left != previous_num_time_left) {
  951.         sprintf(str,"Time: %s",clock_time_str(num_time_left));
  952.         WindPrint(time_left,str);
  953.         return (SUCCESS);
  954.     }
  955.     return (SUCCESS);
  956. }
  957.  
  958. int throw_grenade()
  959. {
  960.     char            str[MAXSTRLEN];
  961.     XEvent            event;
  962.     XButtonPressedEvent    *eventbp;
  963.     int            vx,vy;
  964.  
  965.     if (num_grenades_left==0) {
  966.         print_status("No grenades left!");
  967.         XBell(disp,0);
  968.         return (NO_GRENADES_LEFT);
  969.     }
  970.  
  971.     XClearWindow(disp,wind[tgrenade_wind]);
  972.     InvPrintStr(tgrenade_wind,"Throw Grenade");
  973.     print_status("Ready to throw grenade");
  974.  
  975.     /* Get position to throw grenade */
  976.     while (!XPending(disp))
  977.         usleep(XPENDING_UDELAY);
  978.     XNextEvent(disp,&event);
  979.     eventbp = (XButtonPressedEvent *) &event;
  980.     if ((event.type != ButtonPress) || (eventbp->window != field) ||
  981.         (setvxvy(eventbp->x,eventbp->y,&vx,&vy) == OUT_OF_RANGE)) {
  982.         print_status("Click on the position to throw grenade!");
  983.         XBell(disp,0);
  984.         WindPrint(tgrenade_wind,"Throw Grenade");
  985.         return (ILLEGAL_POSITION);
  986.     }
  987.  
  988.     /* check to see if within range */
  989.     if (abs(manvx-vx) + abs(manvy-vy) > GRENADE_DISTANCE) {
  990.         sprintf(str,
  991.             "Can't toss grenade that far!  Max distance is %d.\n",
  992.             GRENADE_DISTANCE);
  993.         print_status(str);
  994.         XBell(disp,0);
  995.         WindPrint(tgrenade_wind,"Throw Grenade");
  996.         return (TOO_FAR_TO_TOSS_GRENADE);
  997.     }
  998.  
  999.     /* passed checks -- toss grenade */
  1000.     if (FIELD[vx][vy].c == fc_man) {
  1001.         die(vx,vy);
  1002.         sprintf(str,"Grenades: %d",--num_grenades_left);
  1003.         WindPrint(grenades_left,str);
  1004.         WindPrint(tgrenade_wind,"Throw Grenade");
  1005.         return (DIED);
  1006.     }
  1007.     else if ((FIELD[vx][vy].c != fc_tombstone) && 
  1008.         (FIELD[vx][vy].c != fc_goal)) {
  1009.         explode(vx,vy);
  1010.         show_bomb_status(manvx,manvy);
  1011.         draw(bm_man,manvx,manvy);
  1012.         sprintf(str,"Grenades: %d",--num_grenades_left);
  1013.         WindPrint(grenades_left,str);
  1014.         WindPrint(tgrenade_wind,"Throw Grenade");
  1015.         return (SUCCESS);
  1016.     }
  1017.     else {
  1018.         strcpy(str,"No bomb at that position.  ");
  1019.         strcat(str,"Can't blow up tombstone or goal.");
  1020.         print_status(str);
  1021.         XBell(disp,0);
  1022.         WindPrint(tgrenade_wind,"Throw Grenade");
  1023.         return (CANT_EXPLODE);
  1024.     }
  1025. }
  1026.  
  1027. /* num_adj_squares_marked_bomb: returns num adjacent squares user has marked
  1028.     as being unsafe
  1029. */
  1030. int num_adj_squares_marked_bomb(vx,vy)
  1031. int vx,vy;
  1032. {
  1033.     int    nummarks=0;
  1034.  
  1035.     if (vy>0) {
  1036.         if ((vx>0) && (FIELD[vx-1][vy-1].m==fm_bomb))
  1037.             nummarks++;
  1038.         if (FIELD[vx][vy-1].m==fm_bomb)
  1039.             nummarks++;
  1040.         if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy-1].m==fm_bomb))
  1041.             nummarks++;
  1042.     }
  1043.     if (vy<NUMROWS-1) {
  1044.         if ((vx>0) && (FIELD[vx-1][vy+1].m==fm_bomb))
  1045.             nummarks++;
  1046.         if (FIELD[vx][vy+1].m==fm_bomb)
  1047.             nummarks++;
  1048.         if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy+1].m==fm_bomb))
  1049.             nummarks++;
  1050.     }
  1051.     if ((vx>0) && (FIELD[vx-1][vy].m==fm_bomb))
  1052.         nummarks++;
  1053.     if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy].m==fm_bomb))
  1054.         nummarks++;
  1055.  
  1056.     return (nummarks);
  1057. }
  1058.  
  1059. /* num_adj_squares_marked_safe: returns num adjacent squares user has marked
  1060.     as being safe
  1061. */
  1062. int num_adj_squares_marked_safe(vx,vy)
  1063. int vx,vy;
  1064. {
  1065.     int    nummarks=0;
  1066.  
  1067.     if (vy>0) {
  1068.         if ((vx>0) && (FIELD[vx-1][vy-1].m==fm_safe))
  1069.             nummarks++;
  1070.         if (FIELD[vx][vy-1].m==fm_safe)
  1071.             nummarks++;
  1072.         if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy-1].m==fm_safe))
  1073.             nummarks++;
  1074.     }
  1075.     if (vy<NUMROWS-1) {
  1076.         if ((vx>0) && (FIELD[vx-1][vy+1].m==fm_safe))
  1077.             nummarks++;
  1078.         if (FIELD[vx][vy+1].m==fm_safe)
  1079.             nummarks++;
  1080.         if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy+1].m==fm_safe))
  1081.             nummarks++;
  1082.     }
  1083.     if ((vx>0) && (FIELD[vx-1][vy].m==fm_safe))
  1084.         nummarks++;
  1085.     if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy].m==fm_safe))
  1086.         nummarks++;
  1087.  
  1088.     return (nummarks);
  1089. }
  1090.  
  1091. /* num_unvisited_adj_squares: returns num adjacent squares user has
  1092.     not yet visited (not marked with fc_trail)
  1093. */
  1094. int num_unvisited_adj_squares(vx,vy)
  1095. int vx,vy;
  1096. {
  1097.     int    num_unvisited=0;
  1098.  
  1099.     if (vy>0) {
  1100.         if ((vx>0) && (FIELD[vx-1][vy-1].c!=fc_trail))
  1101.             num_unvisited++;
  1102.         if (FIELD[vx][vy-1].c!=fc_trail)
  1103.             num_unvisited++;
  1104.         if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy-1].c!=fc_trail))
  1105.             num_unvisited++;
  1106.     }
  1107.     if (vy<NUMROWS-1) {
  1108.         if ((vx>0) && (FIELD[vx-1][vy+1].c!=fc_trail))
  1109.             num_unvisited++;
  1110.         if (FIELD[vx][vy+1].c!=fc_trail)
  1111.             num_unvisited++;
  1112.         if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy+1].c!=fc_trail))
  1113.             num_unvisited++;
  1114.     }
  1115.     if ((vx>0) && (FIELD[vx-1][vy].c!=fc_trail))
  1116.         num_unvisited++;
  1117.     if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy].c!=fc_trail))
  1118.         num_unvisited++;
  1119.  
  1120.     return (num_unvisited);
  1121. }
  1122.  
  1123. /* do_sanity_check: Make sure user is not losing his mind!
  1124.     If more adjacent squares are marked unsafe than is indicated by the
  1125.     current bomb status, warn the user.
  1126.     If more adjacent squares are marked safe than the number of unvisited
  1127.     squares - the current bomb status, warn the user.
  1128. */
  1129. int do_sanity_check(vx,vy)
  1130. int vx,vy;
  1131. {
  1132.     /* Check first for too many squares marked unsafe */
  1133.     if (num_adj_squares_marked_bomb(vx,vy) > bomb_status(vx,vy)) {
  1134.         print_status("WARNING: too many squares marked UNsafe!");
  1135.         XBell(disp,0);
  1136.         return (CHECK_FAILED);
  1137.     }
  1138.  
  1139.     /* Next check for too many squares marked safe */
  1140.     if (num_adj_squares_marked_safe(vx,vy) > 
  1141.        num_unvisited_adj_squares(vx,vy) - bomb_status(vx,vy)) {
  1142.         print_status("WARNING: too many squares marked safe!");
  1143.         XBell(disp,0);
  1144.         return (CHECK_FAILED);
  1145.     }
  1146.  
  1147.     return (SUCCESS);
  1148. }
  1149.