# 2.11BSD#431 - /usr/src/games/hack/hack.mkmaze.c

##### Functions

    makemaz           X
    mazexy            X
    move              X
    okay              X
    walkfrom          X

##### Variables

    hell_hound        X

       1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
       2: /* hack.mkmaze.c - version 1.0.2 */
       3:
       4: #include "hack.h"
       5: #include "def.mkroom.h"     /* not really used */
       6: extern struct monst *makemon();
       7: extern struct permonst pm_wizard;
       8: extern struct obj *mkobj_at();
       9: extern coord mazexy();
      10: struct permonst hell_hound =
      11:     { "hell hound", 'd', 12, 14, 2, 3, 6, 0 };
      12:
      13: makemaz()
      14: {
      15:     int x,y;
      16:     register zx,zy;
      17:     coord mm;
      18:     boolean al = (dlevel >= 30 && !flags.made_amulet);
      19:
      20:     for(x = 2; x < COLNO-1; x++)
      21:         for(y = 2; y < ROWNO-1; y++)
      22:             levl[x][y].typ = (x%2 && y%2) ? 0 : HWALL;
      23:     if(al) {
      24:         register struct monst *mtmp;
      25:
      26:         zx = 2*(COLNO/4) - 1;
      27:         zy = 2*(ROWNO/4) - 1;
      28:         for(x = zx-2; x < zx+4; x++) for(y = zy-2; y <= zy+2; y++) {
      29:         levl[x][y].typ =
      30:             (y == zy-2 || y == zy+2 || x == zx-2 || x == zx+3) ? POOL :
      31:             (y == zy-1 || y == zy+1 || x == zx-1 || x == zx+2) ? HWALL:
      32:             ROOM;
      33:         }
      34:         (void) mkobj_at(AMULET_SYM, zx, zy);
      35:         flags.made_amulet = 1;
      36:         walkfrom(zx+4, zy);
      37:         if(mtmp = makemon(&hell_hound, zx, zy))
      38:         mtmp->msleep = 1;
      39:         if(mtmp = makemon(PM_WIZARD, zx+1, zy)) {
      40:         mtmp->msleep = 1;
      41:         flags.no_of_wizards = 1;
      42:         }
      43:     } else {
      44:         mm = mazexy();
      45:         zx = mm.x;
      46:         zy = mm.y;
      47:         walkfrom(zx,zy);
      48:         (void) mksobj_at(WAN_WISHING, zx, zy);
      49:         (void) mkobj_at(ROCK_SYM, zx, zy);  /* put a rock on top of it */
      50:     }
      51:
      52:     for(x = 2; x < COLNO-1; x++)
      53:         for(y = 2; y < ROWNO-1; y++) {
      54:             switch(levl[x][y].typ) {
      55:             case HWALL:
      56:                 levl[x][y].scrsym = '-';
      57:                 break;
      58:             case ROOM:
      59:                 levl[x][y].scrsym = '.';
      60:                 break;
      61:             }
      62:         }
      63:     for(x = rn1(8,11); x; x--) {
      64:         mm = mazexy();
      65:         (void) mkobj_at(rn2(2) ? GEM_SYM : 0, mm.x, mm.y);
      66:     }
      67:     for(x = rn1(10,2); x; x--) {
      68:         mm = mazexy();
      69:         (void) mkobj_at(ROCK_SYM, mm.x, mm.y);
      70:     }
      71:     mm = mazexy();
      72:     (void) makemon(PM_MINOTAUR, mm.x, mm.y);
      73:     for(x = rn1(5,7); x; x--) {
      74:         mm = mazexy();
      75:         (void) makemon((struct permonst *) 0, mm.x, mm.y);
      76:     }
      77:     for(x = rn1(6,7); x; x--) {
      78:         mm = mazexy();
      79:         mkgold(0L,mm.x,mm.y);
      80:     }
      81:     for(x = rn1(6,7); x; x--)
      82:         mktrap(0,1,(struct mkroom *) 0);
      83:     mm = mazexy();
      84:     levl[(xupstair = mm.x)][(yupstair = mm.y)].scrsym = '<';
      85:     levl[xupstair][yupstair].typ = STAIRS;
      86:     xdnstair = ydnstair = 0;
      87: }
      88:
      89: walkfrom(x,y) int x,y; {
      90: register int q,a,dir;
      91: int dirs[4];
      92:     levl[x][y].typ = ROOM;
      93:     while(1) {
      94:         q = 0;
      95:         for(a = 0; a < 4; a++)
      96:             if(okay(x,y,a)) dirs[q++]= a;
      97:         if(!q) return;
      98:         dir = dirs[rn2(q)];
      99:         move(&x,&y,dir);
     100:         levl[x][y].typ = ROOM;
     101:         move(&x,&y,dir);
     102:         walkfrom(x,y);
     103:     }
     104: }
     105:
     106: move(x,y,dir)
     107: register int *x, *y;
     108: register int dir;
     109: {
     110:     switch(dir){
     111:         case 0: --(*y); break;
     112:         case 1: (*x)++; break;
     113:         case 2: (*y)++; break;
     114:         case 3: --(*x); break;
     115:     }
     116: }
     117:
     118: okay(x,y,dir)
     119: int x,y;
     120: register int dir;
     121: {
     122:     move(&x,&y,dir);
     123:     move(&x,&y,dir);
     124:     if(x<3 || y<3 || x>COLNO-3 || y>ROWNO-3 || levl[x][y].typ != 0)
     125:         return(0);
     126:     else
     127:         return(1);
     128: }
     129:
     130: coord
     131: mazexy(){
     132:     coord mm;
     133:     mm.x = 3 + 2*rn2(COLNO/2 - 2);
     134:     mm.y = 3 + 2*rn2(ROWNO/2 - 2);
     135:     return mm;
     136: }

#### Defined functions

makemaz defined in line 13; used 1 times

- in /usr/src/games/hack/hack.mklev.c line 52

mazexy defined in line 130; used 12 times

- in line 9, 44, 64-83(6)
- in /usr/src/games/hack/hack.mklev.c line 701-703(2), 725-727(2)

move defined in line 106; used 4 times

- in line 99-101(2), 122-123(2)

okay defined in line 118; used 1 times

- in line 96

walkfrom defined in line 89; used 3 times

- in line 36, 47, 102

#### Defined variables

hell_hound defined in line 10; used 1 times

- in line 37

Last modified: 1985-10-01 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 658 |