home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume19 / xtmines / part01 / init.c next >
C/C++ Source or Header  |  1993-04-28  |  17KB  |  495 lines
  1. /* xtmines: game where you try to cross a minefield */
  2. /* windows.c: routines to initialize windows, fonts, GCs, etc */
  3. /* Written by Timothy Tsai  April 13, 1992 */
  4.  
  5. #include "xtmines.h"
  6.  
  7. /* open_display:  open the display;                */
  8. /*                set up default values            */
  9. /*                   (eg. root, white, black, etc) */
  10. /*                set random seed                  */
  11. void open_display()
  12. {
  13.     if ((disp = XOpenDisplay(NULL)) == NULL) {
  14.         fprintf(stderr, "Can't Open Display\n");
  15.         exit(1);
  16.     }
  17.     root    = DefaultRootWindow(disp);
  18.     screen    = DefaultScreen(disp);
  19.     depth    = DefaultDepth(disp,screen);
  20.     visual    = DefaultVisual(disp,screen);
  21.     white    = WhitePixel(disp,screen);
  22.     black    = BlackPixel(disp,screen);
  23.  
  24.     srandom(time(0));
  25. }
  26.  
  27. /* load_fonts:  load 3 fonts:  fonts (status line and showfig) */
  28. /*                             fontm (main -- for most text)   */
  29. /*                             fontt (time and hiscores list)  */
  30. void load_fonts()
  31. {
  32.     fonts        = XLoadFont(disp,FONTS);
  33.     fontsstruct    = XQueryFont(disp,fonts);
  34.     /* fontsw, fontsh, fontsa are used by PrintStr() for status line */
  35.     fontsw        = fontsstruct->max_bounds.rbearing -
  36.                 fontsstruct->min_bounds.lbearing;
  37.     fontsh        = fontsstruct->ascent + fontsstruct->descent;
  38.     fontsa        = fontsstruct->ascent;
  39.     /* fonstshoww, fontshowh, fontshowa are used by draw() for showfig */
  40.     fontshoww    = (fontsstruct->per_char + '0')->rbearing -
  41.                 (fontsstruct->per_char + '0')->lbearing;
  42.     fontshowh    = (fontsstruct->per_char + '0')->ascent +
  43.                 (fontsstruct->per_char + '0')->descent;
  44.     fontshowa    = (fontsstruct->per_char + '0')->ascent;
  45.  
  46.     fontm        = XLoadFont(disp,FONTM);
  47.     fontmstruct    = XQueryFont(disp,fontm);
  48.     fontmw        = fontmstruct->max_bounds.rbearing -
  49.                 fontmstruct->min_bounds.lbearing;
  50.     fontmh        = fontmstruct->ascent + fontmstruct->descent;
  51.     fontma        = fontmstruct->ascent;
  52.  
  53.     fontt        = XLoadFont(disp,FONTT);
  54.     fonttstruct    = XQueryFont(disp,fontt);
  55.     fonttw        = fonttstruct->max_bounds.rbearing -
  56.                 fonttstruct->min_bounds.lbearing;
  57.     fontth        = fonttstruct->ascent + fonttstruct->descent;
  58.     fontta        = fonttstruct->ascent;
  59. }
  60.  
  61. /* create_map_frame:  actually create each window and map to screen */
  62. /*                    this is where each window's position and size */
  63. /*                    are specified;  also, create all bitmaps and  */
  64. /*                    initialize bitmaps dimension arrays           */
  65. void create_map_frame()
  66. {
  67.     int    ww,    /* window width of small button windows */
  68.         wh1,    /* window height of status line right under field */
  69.         wh2,    /*                  2nd row of buttons */
  70.         wh3,    /*                  3rd row of buttons */
  71.         wh4;    /*                  last row of buttons */
  72.  
  73.     /*---First, create and map windows----------------------------*/
  74.  
  75.     /* first wind button widths and heights */
  76.     /* NUM1WINDS = num of buttons in one row */
  77.     ww = (w-(NUM1WINDS+1)*bw)/(NUM1WINDS);
  78.     wh1 = wh2 = wh3 = (h-fh-6*bw)/4;  wh4 = h-fh-6*bw-wh1-wh2-wh3;
  79.  
  80.     /* create frame and field */
  81.     frame    = XCreateSimpleWindow(disp,root,x,y,w,h,bw,black,white);
  82.     field            = XCreateSimpleWindow(disp,frame,
  83.                     0,0,w-2*bw,fh,bw,
  84.                     black,white);
  85.  
  86.     /* create status line */
  87.     wind[status]        = XCreateSimpleWindow(disp,frame,
  88.                     0,fh+bw,w-2*bw,wh1,bw,
  89.                     black,white);
  90.  
  91.     /* create 2nd button row */
  92.     wind[bombs_left]    = XCreateSimpleWindow(disp,frame,
  93.                     0,fh+wh1+2*bw,ww,
  94.                     wh2,bw,black,white);
  95.     wind[bonus_wind]    = XCreateSimpleWindow(disp,frame,
  96.                     bonus_wind*(ww+bw),
  97.                     fh+wh1+2*bw,ww,
  98.                     wh2,bw,black,white);
  99.     wind[time_left]        = XCreateSimpleWindow(disp,frame,
  100.                     time_left*(ww+bw),
  101.                     fh+wh1+2*bw,ww,
  102.                     wh2,bw,black,white);
  103.     wind[score]        = XCreateSimpleWindow(disp,frame,
  104.                     score*(ww+bw),
  105.                     fh+wh1+2*bw,ww,
  106.                     wh2,bw,black,white);
  107.     wind[grenades_left]    = XCreateSimpleWindow(disp,frame,
  108.                     grenades_left*(ww+bw),
  109.                     fh+wh1+2*bw,ww,
  110.                     wh2,bw,black,white);
  111.     wind[rank]        = XCreateSimpleWindow(disp,frame,
  112.                     rank*(ww+bw),
  113.                     fh+wh1+2*bw,w-2*bw-(rank)*(ww+bw),
  114.                     wh2,bw,black,white);
  115.  
  116.     /* create 3rd button row */
  117.     wind[quit_wind]        = XCreateSimpleWindow(disp,frame,
  118.                     rank*(ww+bw),
  119.                     fh+3*bw+wh1+wh2,w-2*bw-(rank)*(ww+bw),
  120.                     wh3,bw,black,white);
  121.     wind[show_wind]        = XCreateSimpleWindow(disp,frame,
  122.                     grenades_left*(ww+bw),
  123.                     fh+3*bw+wh1+wh2,ww,
  124.                     wh3,bw,black,white);
  125.     wind[tgrenade_wind]    = XCreateSimpleWindow(disp,frame,
  126.                     score*(ww+bw),
  127.                     fh+3*bw+wh1+wh2,ww,
  128.                     wh3,bw,black,white);
  129.     wind[giveup_wind]    = XCreateSimpleWindow(disp,frame,
  130.                     time_left*(ww+bw),
  131.                     fh+3*bw+wh1+wh2,ww,
  132.                     wh3,bw,black,white);
  133.     wind[automark_wind]    = XCreateSimpleWindow(disp,frame,
  134.                     bonus_wind*(ww+bw),
  135.                     fh+3*bw+wh1+wh2,ww,
  136.                     wh3,bw,black,white);
  137.     wind[lives_left]    = XCreateSimpleWindow(disp,frame,
  138.                     0,fh+3*bw+wh1+wh2,ww,
  139.                     wh3,bw,black,white);
  140.  
  141.     /* create last button row */
  142. /* These are for future expansion
  143.     wind[]            = XCreateSimpleWindow(disp,frame,
  144.                     rank*(ww+bw),
  145.                     fh+4*bw+wh1+wh2+wh3,
  146.                     w-2*bw-(rank)*(ww+bw),
  147.                     wh4,bw,black,white);
  148.     wind[]            = XCreateSimpleWindow(disp,frame,
  149.                     grenades_left*(ww+bw),
  150.                     fh+4*bw+wh1+wh2+wh3,ww,
  151.                     wh4,bw,black,white);
  152. */
  153.     wind[pause_wind]    = XCreateSimpleWindow(disp,frame,
  154.                     score*(ww+bw),
  155.                     fh+4*bw+wh1+wh2+wh3,ww,
  156.                     wh4,bw,black,white);
  157.     wind[sanitycheck_wind]    = XCreateSimpleWindow(disp,frame,
  158.                     time_left*(ww+bw),
  159.                     fh+4*bw+wh1+wh2+wh3,ww,
  160.                     wh4,bw,black,white);
  161.     wind[eautomark_wind]    = XCreateSimpleWindow(disp,frame,
  162.                     bonus_wind*(ww+bw),
  163.                     fh+4*bw+wh1+wh2+wh3,ww,
  164.                     wh4,bw,black,white);
  165.     wind[refresh_wind]    = XCreateSimpleWindow(disp,frame,
  166.                     0,fh+4*bw+wh1+wh2+wh3,ww,
  167.                     wh4,bw,black,white);
  168.  
  169.     /* set window and icon names */
  170.     XStoreName(disp,frame,"xtmines");
  171.     XSetIconName(disp,frame,"xtmines");
  172.  
  173.     /* Map all windows to screen */
  174.     XMapRaised(disp,frame);
  175.     XMapRaised(disp,field);
  176.     XMapRaised(disp,wind[bombs_left]);
  177.     XMapRaised(disp,wind[bonus_wind]);
  178.     XMapRaised(disp,wind[time_left]);
  179.     XMapRaised(disp,wind[score]);
  180.     XMapRaised(disp,wind[grenades_left]);
  181.     XMapRaised(disp,wind[rank]);
  182.     XMapRaised(disp,wind[quit_wind]);
  183.     XMapRaised(disp,wind[show_wind]);
  184.     XMapRaised(disp,wind[tgrenade_wind]);
  185.     XMapRaised(disp,wind[giveup_wind]);
  186.     XMapRaised(disp,wind[automark_wind]);
  187.     XMapRaised(disp,wind[lives_left]); 
  188.     XMapRaised(disp,wind[pause_wind]); 
  189.     XMapRaised(disp,wind[sanitycheck_wind]); 
  190.     XMapRaised(disp,wind[eautomark_wind]); 
  191.     XMapRaised(disp,wind[refresh_wind]); 
  192.     XMapRaised(disp,wind[status]);
  193.  
  194.     /*---Now initialize all bitmaps and accompanying dimensions---*/
  195.     
  196.     /* load all bitmaps into memory */
  197.     bitmap[bm_safe]        = XCreateBitmapFromData(disp,field, 
  198.                     safe_bits,safe_width,safe_height);
  199.     bitmap[bm_man]        = XCreateBitmapFromData(disp,field,
  200.                     man_bits,man_width,man_height);
  201.     bitmap[bm_bomb]        = XCreateBitmapFromData(disp,field,
  202.                     bomb_bits,bomb_width,bomb_height);
  203.     bitmap[bm_tombstone]    = XCreateBitmapFromData(disp,field,
  204.                     tstone_bits,tstone_width,tstone_height);
  205.     bitmap[bm_goal]        = XCreateBitmapFromData(disp,field,
  206.                     goal_bits,goal_width,goal_height);
  207.     bitmap[bm_trail]    = XCreateBitmapFromData(disp,field,
  208.                     trail_bits,trail_width,trail_height);
  209.     bitmap[bm_pow]        = XCreateBitmapFromData(disp,field,
  210.                     pow_bits,pow_width,pow_height);
  211.     bitmap[bm_bombmark]    = XCreateBitmapFromData(disp,field,
  212.                     bombmark_bits,bombmark_width,
  213.                     bombmark_height);
  214.     bitmap[bm_safewrong]    = XCreateBitmapFromData(disp,field,
  215.                     safewrong_bits,safewrong_width,
  216.                     safewrong_height);
  217.     bitmap[bm_bombmarkwrong]= XCreateBitmapFromData(disp,field,
  218.                     bombmarkwrong_bits,bombmarkwrong_width,
  219.                     bombmarkwrong_height);
  220.  
  221.     /* put all bitmap dimensions into width and height arrays */
  222.     bmwidth[bm_safe]    = safe_width;
  223.     bmwidth[bm_man]        = man_width;
  224.     bmwidth[bm_bomb]    = bomb_width;
  225.     bmwidth[bm_tombstone]    = tstone_width;
  226.     bmwidth[bm_goal]    = goal_width;
  227.     bmwidth[bm_trail]    = trail_width;
  228.     bmwidth[bm_pow]        = pow_width;
  229.     bmwidth[bm_bombmark]    = bombmark_width;
  230.     bmwidth[bm_safewrong]    = safewrong_width;
  231.     bmwidth[bm_bombmarkwrong]    = bombmarkwrong_width;
  232.  
  233.     bmheight[bm_safe]    = safe_height;
  234.     bmheight[bm_man]    = man_height;
  235.     bmheight[bm_bomb]    = bomb_height;
  236.     bmheight[bm_tombstone]    = tstone_height;
  237.     bmheight[bm_goal]    = goal_height;
  238.     bmheight[bm_trail]    = trail_height;
  239.     bmheight[bm_pow]    = pow_height;
  240.     bmheight[bm_bombmark]    = bombmark_height;
  241.     bmheight[bm_safewrong]    = safewrong_height;
  242.     bmheight[bm_bombmarkwrong]    = bombmarkwrong_height;
  243. }
  244.  
  245. /* create_GC_colormap:  set up Graphics Contexts and colormaps             */
  246. /*                      right now, there are only 2 colors (black & white) */
  247. void create_GC_colormap()
  248. {
  249.     XGCValues    gcv;    /* to determine attributes to set */
  250.     XColor        exact;    /* used by XAllocNamedColor;     */
  251.                 /*    return value is never used */
  252.     
  253.     /* set up gcs -- GC for status line and showfig */
  254.     gcv.font = fonts;
  255.     gcv.line_width = 1;
  256.     gcv.graphics_exposures = FALSE;
  257.     gcs     = XCreateGC(disp,frame,
  258.             GCFont | GCLineWidth | GCGraphicsExposures,
  259.             &gcv);
  260.  
  261.     /* set up gcm -- GC for main (most text) */
  262.     gcv.font = fontm;
  263.     gcv.line_width = 1;
  264.     gcv.graphics_exposures = FALSE;
  265.     gcm     = XCreateGC(disp,frame,
  266.             GCFont | GCLineWidth | GCGraphicsExposures,
  267.             &gcv);
  268.  
  269.     /* set up gct -- GC for time and hiscores list */
  270.     gcv.font = fontt;
  271.     gcv.line_width = 1;
  272.     gcv.graphics_exposures = FALSE;
  273.     gct     = XCreateGC(disp,frame,
  274.             GCFont | GCLineWidth | GCGraphicsExposures,
  275.             &gcv);
  276.  
  277.     /* Set up colormap */
  278.     cmap     = XDefaultColormap(disp,screen);
  279.     XAllocNamedColor(disp,cmap,FONTCOLOR,&color[font_color],&exact);
  280.     XAllocNamedColor(disp,cmap,BACKGROUNDCOLOR,&color[background_color],
  281.         &exact);
  282.     XAllocNamedColor(disp,cmap,FIELDCOLOR,&color[field_color],
  283.         &exact);
  284. }
  285.  
  286. /* set_event_masks:  all event masks are set here */
  287. void set_event_masks()
  288. {
  289.     int i;
  290.     windtype windownum;
  291.  
  292.     /* set exposure mask for all windows */
  293.     XSelectInput(disp,frame,ExposureMask);
  294.     for (windownum=0;windownum<NUMWINDS;windownum++)
  295.         XSelectInput(disp,wind[windownum],ExposureMask);
  296.  
  297.     /* check to see if quit */
  298.     XSelectInput(disp,wind[quit_wind],ButtonPressMask|ExposureMask);
  299.  
  300.     /* check to see if toggle show */
  301.     XSelectInput(disp,wind[show_wind],ButtonPressMask|ExposureMask);
  302.  
  303.     /* check to see if throw grenades */
  304.     XSelectInput(disp,wind[tgrenade_wind],ButtonPressMask|ExposureMask);
  305.  
  306.     /* check to see if give up */
  307.     XSelectInput(disp,wind[giveup_wind],ButtonPressMask|ExposureMask);
  308.  
  309.     /* check to see if toggle automark */
  310.     XSelectInput(disp,wind[automark_wind],ButtonPressMask|ExposureMask);
  311.  
  312.     /* check to see if toggle pause */
  313.     XSelectInput(disp,wind[pause_wind],ButtonPressMask|ExposureMask);
  314.  
  315.     /* check to see if toggle sanity check */
  316.     XSelectInput(disp,wind[sanitycheck_wind],ButtonPressMask|ExposureMask);
  317.  
  318.     /* check to see if toggle extended_automark */
  319.     XSelectInput(disp,wind[eautomark_wind],ButtonPressMask|ExposureMask);
  320.  
  321.     /* check to see if refresh */
  322.     XSelectInput(disp,wind[refresh_wind],ButtonPressMask|ExposureMask);
  323.  
  324.     /* allow mouse button and key presses in field */
  325.     XSelectInput(disp,field,KeyPressMask|ButtonPressMask|ExposureMask);
  326. }
  327.  
  328. /* init_values:  called at the beginning of every level      */
  329. /*               sets num_bombs_left, num_time_left_at_start */
  330. /*                    num_time_left, used_showfig,           */
  331. /*                    used_sanity, used_eautomark            */
  332. int    num_bombs_at_start[NUMRANKS];
  333. void init_values()
  334. {
  335.     num_bombs_at_start[grunt]    = 50;
  336.     num_bombs_at_start[corporal]    = 100;
  337.     num_bombs_at_start[lieutenant]    = 150;
  338.     num_bombs_at_start[captain]    = 200;
  339.     num_bombs_at_start[mmajor]    = 250;
  340.     num_bombs_at_start[general]    = 300;
  341.     num_bombs_at_start[president]    = 350;
  342.     num_bombs_at_start[king]    = 400;
  343.     num_bombs_at_start[emperor]    = 450;
  344.     num_bombs_at_start[angel]    = 500;
  345.  
  346.     num_tombstones        = 0;
  347.     num_bombs_left        = num_bombs_at_start[level];
  348.     num_time_left_at_start    = SECONDS_PER_LEVEL*(level+1);
  349.     num_time_left        = num_time_left_at_start;
  350.     pause_time        = 0;
  351.     used_showfig        = (show==sh_fig) ? TRUE : FALSE;
  352.     used_sanity        = (sanity) ? TRUE : FALSE;
  353.     used_eautomark        = (extended_automark) ? TRUE : FALSE;
  354.  
  355.     num_bonus        = current_bonus();
  356. }
  357.  
  358. /* illegal_bomb_position:  input a virtual field position             */
  359. /*                         output a boolean=is bomb allowed here?     */
  360. /*                         illegal is more than two bombs around goal */
  361. /*                                    4 most top-left squares         */
  362. int illegal_bomb_position(vx,vy)
  363. int vx,vy;
  364. {
  365.     int    num_bombs_around_goal;
  366.  
  367.     /* find how many of the 3 squares around the goal has bombs */
  368.     num_bombs_around_goal =
  369.         (FIELD[NUMCOLS-1][NUMROWS-2].c==fc_bomb) +
  370.         (FIELD[NUMCOLS-2][NUMROWS-2].c==fc_bomb) +
  371.         (FIELD[NUMCOLS-2][NUMROWS-1].c==fc_bomb);
  372.  
  373.     /* check to see if 4 most top-left squares are free */ 
  374.     if (((vx==0) && (vy==0)) || ((vx==0) && (vy==1)) ||
  375.         ((vx==1) && (vy==0)) || ((vx==1) && (vy==1)) ||
  376.         ((vx==NUMCOLS-1) && (vy==NUMROWS-1)) ||
  377.         (FIELD[vx][vy].c==fc_bomb) ||
  378.         ((((vx==NUMCOLS-1) && (vy=NUMROWS-2)) ||
  379.           ((vx==NUMCOLS-2) && (vy=NUMROWS-2)) ||
  380.           ((vx==NUMCOLS-2) && (vy=NUMROWS-1))) &&
  381.          (num_bombs_around_goal==2)))
  382.         return (TRUE);
  383.     else
  384.         return (FALSE);
  385. }
  386.  
  387. /* blocked:  returns a boolean indicating whether a continuous line of bombs */
  388. /*              from square vx,vy (where vx,vy is on top or right edge) to   */
  389. /*              the bottom or left edge of the field.  If so, then return    */
  390. /*              TRUE, else return FALSE.  As each */
  391. int blocked(vx,vy)
  392. int vx,vy;
  393. {
  394.     /* marked as safe means that square has already been looked at */
  395.     if (FIELD[vx][vy].m == fm_safe)
  396.         return (FALSE);        /* square has already been looked at */
  397.     else
  398.         FIELD[vx][vy].m = fm_safe;    
  399.                     /* else mark square as having */
  400.                     /*    been looked at          */
  401.  
  402.     if (FIELD[vx][vy].c != fc_bomb)
  403.         return (FALSE);        /* square has no bomb; thus, */
  404.                     /*    no path through here   */
  405.     else {
  406.         if ((vx==0) || (vy==NUMROWS-1))
  407.            return (TRUE);    /* we have reached the bottom or */
  408.                     /*    left edge and found a bomb */
  409.         if ((vy>0) && (FIELD[vx][vy-1].m==fm_nomark) &&
  410.             (blocked(vx,vy-1)))
  411.                 return (TRUE);
  412.         if ((vy<NUMROWS-1) && (FIELD[vx][vy+1].m==fm_nomark) &&
  413.             (blocked(vx,vy+1)))
  414.                 return (TRUE);
  415.         if ((vx>0) && (FIELD[vx-1][vy].m==fm_nomark) &&
  416.             (blocked(vx-1,vy)))
  417.                 return (TRUE);
  418.         if ((vx<NUMCOLS-1) && (FIELD[vx+1][vy].m==fm_nomark) &&
  419.             (blocked(vx+1,vy)))
  420.                 return (TRUE);
  421.  
  422.         /* if we got this far, then there are no path of bombs */
  423.         /*    through this square;  thus, return not blocked   */
  424.         return (FALSE);
  425.     } /* else FIELD[vx][vy] == fc_bomb */
  426. }
  427.  
  428. /* guaranteed_path:  returns a boolean indicating whether there is a path     */
  429. /*                      through the from start to goal without using grenades */
  430. /*                   all field contents must be set first                     */
  431. /*                   all field marks must be cleared first                    */
  432. int guaranteed_path()
  433. {
  434.     int    c,r;    /* current column and row being considered */
  435.  
  436.     for (c=1;c<NUMCOLS;c++)        /* c=1, skip starting square */
  437.         if (blocked(c,0))
  438.             return (FALSE);    /* no path from start to finish */
  439.     for (r=0;r<NUMROWS-1;r++)    /* NUMROWS-1, skip goal square */
  440.         if (blocked(NUMCOLS-1,r))
  441.             return (FALSE);    /* no path from start to finish */
  442.  
  443.     return (TRUE);            /* else there is a guaranteed path */
  444. }
  445.  
  446. /* manvx, manvy:  current virtual man position on field */
  447. int    manvx,manvy;
  448.  
  449. /* set_field:  will put the appropriate number of bombs in field */
  450. /*                according to level (makes sure that no illegal */
  451. /*                squares have bombs                             */
  452. /*             places man in top-left corner                     */
  453. /*             places goal in bottom-right corner                */
  454. /*             guarantees that there is a path from start to end */
  455. /*                by repeating until that is true                */
  456. void set_field()
  457. {
  458.     int    c,r,    /* column and row for clearing field */
  459.         i;    /* counter for number of bombs */
  460.             /*    placed so far            */
  461.     int    vx,vy;    /* current bomb position being considered */
  462.  
  463.     do {
  464.         /* first clear the entire field of all contents and marks */
  465.         for (c=0;c<NUMCOLS;c++)
  466.            for (r=0;r<NUMROWS;r++) {
  467.             FIELD[c][r].c = fc_empty;    /* clear contents */
  468.             FIELD[c][r].m = fm_nomark;    /* clear marks */
  469.             clear(c,r);            /* erase bitmaps */
  470.            }
  471.  
  472.         /* put man in top-left corner */
  473.         FIELD[0][0].c = fc_man;
  474.         manvx = 0; manvy = 0;
  475.  
  476.         /* place bombs in field */
  477.         for (i=0;i<num_bombs_at_start[level];i++) {
  478.            do {
  479.             vx = random()%NUMCOLS;
  480.             vy = random()%NUMROWS;
  481.            } while (illegal_bomb_position(vx,vy));
  482.            FIELD[vx][vy].c = fc_bomb;
  483.         }
  484.  
  485.         /* place goal in bottom-right corner */
  486.         FIELD[NUMCOLS-1][NUMROWS-1].c = fc_goal;
  487.  
  488.     } while (!guaranteed_path());
  489.  
  490.     /* now clear all marks from field */
  491.     for (c=0;c<NUMCOLS;c++)
  492.        for (r=0;r<NUMROWS;r++)
  493.         FIELD[c][r].m = fm_nomark;      /* clear marks */
  494. }
  495.