1: /*
   2:  *  Hunt
   3:  *  Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold
   4:  *  San Francisco, California
   5:  *
   6:  *  Copyright (c) 1985 Regents of the University of California.
   7:  *  All rights reserved.  The Berkeley software License Agreement
   8:  *  specifies the terms and conditions for redistribution.
   9:  */
  10: 
  11: # include   "hunt.h"
  12: 
  13: # define    ISCLEAR(y,x)    (Maze[y][x] == SPACE)
  14: # define    ODD(n)      ((n) & 01)
  15: 
  16: makemaze()
  17: {
  18:     register char   *sp;
  19:     register int    y, x;
  20: 
  21:     /*
  22: 	 * fill maze with walls
  23: 	 */
  24:     sp = &Maze[0][0];
  25:     while (sp < &Maze[HEIGHT - 1][WIDTH])
  26:         *sp++ = DOOR;
  27: 
  28:     y = rand_num(DBOUND - UBOUND) + UBOUND;
  29:     x = rand_num(RBOUND - LBOUND) + LBOUND;
  30:     dig(y, x);              /* Dig out the maze */
  31:     remap();
  32: }
  33: 
  34: # define    NPERM   24
  35: # define    NDIR    4
  36: 
  37: int dirs[NPERM][NDIR] = {
  38:         {0,1,2,3},  {3,0,1,2},  {0,2,3,1},  {0,3,2,1},
  39:         {1,0,2,3},  {2,3,0,1},  {0,2,1,3},  {2,3,1,0},
  40:         {1,0,3,2},  {1,2,0,3},  {3,1,2,0},  {2,0,3,1},
  41:         {1,3,0,2},  {0,3,1,2},  {1,3,2,0},  {2,0,1,3},
  42:         {0,1,3,2},  {3,1,0,2},  {2,1,0,3},  {1,2,3,0},
  43:         {2,1,3,0},  {3,0,2,1},  {3,2,0,1},  {3,2,1,0}
  44:     };
  45: 
  46: int incr[NDIR][2] = {
  47:         {0, 1}, {1, 0}, {0, -1}, {-1, 0}
  48:     };
  49: 
  50: dig(y, x)
  51: int y, x;
  52: {
  53:     register int    *dp;
  54:     register int    *ip;
  55:     register int    ny, nx;
  56:     register int    *endp;
  57: 
  58:     Maze[y][x] = SPACE;         /* Clear this spot */
  59:     dp = dirs[rand_num(NPERM)];
  60:     endp = &dp[NDIR];
  61:     while (dp < endp) {
  62:         ip = &incr[*dp++][0];
  63:         ny = y + *ip++;
  64:         nx = x + *ip;
  65:         if (candig(ny, nx))
  66:             dig(ny, nx);
  67:     }
  68: }
  69: 
  70: /*
  71:  * candig:
  72:  *	Is it legal to clear this spot?
  73:  */
  74: candig(y, x)
  75: register int    y, x;
  76: {
  77:     register int    i;
  78: 
  79:     if (ODD(x) && ODD(y))
  80:         return FALSE;       /* can't touch ODD spots */
  81: 
  82:     if (y < UBOUND || y >= DBOUND)
  83:         return FALSE;       /* Beyond vertical bounds, NO */
  84:     if (x < LBOUND || x >= RBOUND)
  85:         return FALSE;       /* Beyond horizontal bounds, NO */
  86: 
  87:     if (ISCLEAR(y, x))
  88:         return FALSE;       /* Already clear, NO */
  89: 
  90:     i = ISCLEAR(y, x + 1);
  91:     i += ISCLEAR(y, x - 1);
  92:     if (i > 1)
  93:         return FALSE;       /* Introduces cycle, NO */
  94:     i += ISCLEAR(y + 1, x);
  95:     if (i > 1)
  96:         return FALSE;       /* Introduces cycle, NO */
  97:     i += ISCLEAR(y - 1, x);
  98:     if (i > 1)
  99:         return FALSE;       /* Introduces cycle, NO */
 100: 
 101:     return TRUE;            /* OK */
 102: }
 103: 
 104: remap()
 105: {
 106:     register int    y, x;
 107:     register char   *sp;
 108:     register int    stat;
 109: 
 110:     for (y = 0; y < HEIGHT; y++)
 111:         for (x = 0; x < WIDTH; x++) {
 112:             sp = &Maze[y][x];
 113:             if (*sp == SPACE)
 114:                 continue;
 115:             stat = 0;
 116:             if (y - 1 >= 0 && Maze[y - 1][x] != SPACE)
 117:                 stat |= NORTH;
 118:             if (y + 1 < HEIGHT && Maze[y + 1][x] != SPACE)
 119:                 stat |= SOUTH;
 120:             if (x + 1 < WIDTH && Maze[y][x + 1] != SPACE)
 121:                 stat |= EAST;
 122:             if (x - 1 >= 0 && Maze[y][x - 1] != SPACE)
 123:                 stat |= WEST;
 124:             switch (stat) {
 125:               case WEST | EAST:
 126:                 *sp = WALL1;
 127:                 break;
 128:               case NORTH | SOUTH:
 129:                 *sp = WALL2;
 130:                 break;
 131:               case 0:
 132: # ifdef RANDOM
 133:                 *sp = DOOR;
 134: # endif RANDOM
 135: # ifdef REFLECT
 136:                 *sp = rand_num(2) ? WALL4 : WALL5;
 137: # endif REFLECT
 138:                 break;
 139:               default:
 140:                 *sp = WALL3;
 141:                 break;
 142:             }
 143:         }
 144:     bcopy((char *) Maze, (char *) Orig_maze, sizeof Maze);
 145: }

Defined functions

candig defined in line 74; used 1 times
  • in line 65
dig defined in line 50; used 2 times
makemaze defined in line 16; used 1 times
remap defined in line 104; used 1 times
  • in line 31

Defined variables

dirs defined in line 37; used 1 times
  • in line 59
incr defined in line 46; used 1 times
  • in line 62

Defined macros

ISCLEAR defined in line 13; used 5 times
NDIR defined in line 35; used 3 times
NPERM defined in line 34; used 2 times
ODD defined in line 14; used 2 times
  • in line 79(2)
Last modified: 1985-11-15
Generated: 2016-12-26
Generated by src2html V0.67
page hit count: 1345
Valid CSS Valid XHTML 1.0 Strict