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

##### Functions

    dist2             X
    has_dnstairs      X
    has_upstairs      X
    isbig             X
    mkshop            X
    mkswamp           X
    mkzoo             X
    morguemon         X
    nexttodoor        X
    sq                X

##### Variables

    shprobs           X

##### Macros

    ESHK              X

       1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
       2: /* hack.mkshop.c - version 1.0.3 */
       3:
       4: #ifndef QUEST
       5: #include "hack.h"
       6: #include "def.mkroom.h"
       7: #include "def.eshk.h"
       8: #define ESHK    ((struct eshk *)(&(shk->mextra[0])))
       9: extern struct monst *makemon();
      10: extern struct obj *mkobj_at();
      11: extern int nroom;
      12: extern char shtypes[];  /* = "=/)%?!["; 8 types: 7 specialized, 1 mixed */
      13: schar shprobs[] = { 3,3,5,5,10,10,14,50 };  /* their probabilities */
      14:
      15: mkshop(){
      16: register struct mkroom *sroom;
      17: register int sh,sx,sy,i = -1;
      18: register char let;
      19: int roomno;
      20: register struct monst *shk;
      21: #ifdef WIZARD
      22:     /* first determine shoptype */
      23:     if(wizard){
      24:         extern char *getenv();
      25:         register char *ep = getenv("SHOPTYPE");
      26:         if(ep){
      27:             if(*ep == 'z' || *ep == 'Z'){
      28:                 mkzoo(ZOO);
      29:                 return;
      30:             }
      31:             if(*ep == 'm' || *ep == 'M'){
      32:                 mkzoo(MORGUE);
      33:                 return;
      34:             }
      35:             if(*ep == 'b' || *ep == 'B'){
      36:                 mkzoo(BEEHIVE);
      37:                 return;
      38:             }
      39:             if(*ep == 's' || *ep == 'S'){
      40:                 mkswamp();
      41:                 return;
      42:             }
      43:             for(i=0; shtypes[i]; i++)
      44:                 if(*ep == shtypes[i]) break;
      45:             goto gottype;
      46:         }
      47:     }
      48: gottype:
      49: #endif WIZARD
      50:     for(sroom = &rooms[0], roomno = 0; ; sroom++, roomno++){
      51:         if(sroom->hx < 0) return;
      52:         if(sroom - rooms >= nroom) {
      53:             pline("rooms not closed by -1?");
      54:             return;
      55:         }
      56:         if(sroom->rtype) continue;
      57:         if(!sroom->rlit || has_dnstairs(sroom) || has_upstairs(sroom))
      58:             continue;
      59:         if(
      60: #ifdef WIZARD
      61:            (wizard && getenv("SHOPTYPE") && sroom->doorct != 0) ||
      62: #endif WIZARD
      63:             sroom->doorct == 1) break;
      64:     }
      65:
      66:     if(i < 0) {         /* shoptype not yet determined */
      67:         register int j;
      68:
      69:         for(j = rn2(100), i = 0; (j -= shprobs[i])>= 0; i++)
      70:         if(!shtypes[i]) break;          /* superfluous */
      71:         if(isbig(sroom) && i + SHOPBASE == WANDSHOP)
      72:         i = GENERAL-SHOPBASE;
      73:     }
      74:     sroom->rtype = i + SHOPBASE;
      75:     let = shtypes[i];
      76:     sh = sroom->fdoor;
      77:     sx = doors[sh].x;
      78:     sy = doors[sh].y;
      79:     if(sx == sroom->lx-1) sx++; else
      80:     if(sx == sroom->hx+1) sx--; else
      81:     if(sy == sroom->ly-1) sy++; else
      82:     if(sy == sroom->hy+1) sy--; else {
      83: #ifdef WIZARD
      84:         /* This is said to happen sometimes, but I've never seen it. */
      85:         if(wizard) {
      86:         register int j = sroom->doorct;
      87:         extern int doorindex;
      88:
      89:         pline("Where is shopdoor?");
      90:         pline("Room at (%d,%d),(%d,%d).", sroom->lx, sroom->ly,
      91:             sroom->hx, sroom->hy);
      92:         pline("doormax=%d doorct=%d fdoor=%d",
      93:             doorindex, sroom->doorct, sh);
      94:         while(j--) {
      95:             pline("door [%d,%d]", doors[sh].x, doors[sh].y);
      96:             sh++;
      97:         }
      98:         more();
      99:         }
     100: #endif WIZARD
     101:         return;
     102:     }
     103:     if(!(shk = makemon(PM_SHK,sx,sy))) return;
     104:     shk->isshk = shk->mpeaceful = 1;
     105:     shk->msleep = 0;
     106:     shk->mtrapseen = ~0;    /* we know all the traps already */
     107:     ESHK->shoproom = roomno;
     108:     ESHK->shoplevel = dlevel;
     109:     ESHK->shd = doors[sh];
     110:     ESHK->shk.x = sx;
     111:     ESHK->shk.y = sy;
     112:     ESHK->robbed = 0;
     113:     ESHK->visitct = 0;
     114:     ESHK->following = 0;
     115:     shk->mgold = 1000 + 30*rnd(100);    /* initial capital */
     116:     ESHK->billct = 0;
     117:     findname(ESHK->shknam, let);
     118:     for(sx = sroom->lx; sx <= sroom->hx; sx++)
     119:     for(sy = sroom->ly; sy <= sroom->hy; sy++){
     120:         register struct monst *mtmp;
     121:         if((sx == sroom->lx && doors[sh].x == sx-1) ||
     122:            (sx == sroom->hx && doors[sh].x == sx+1) ||
     123:            (sy == sroom->ly && doors[sh].y == sy-1) ||
     124:            (sy == sroom->hy && doors[sh].y == sy+1)) continue;
     125:         if(rn2(100) < dlevel && !m_at(sx,sy) &&
     126:            (mtmp = makemon(PM_MIMIC, sx, sy))){
     127:             mtmp->mimic = 1;
     128:             mtmp->mappearance =
     129:                 (let && rn2(10) < dlevel) ? let : ']';
     130:             continue;
     131:         }
     132:         (void) mkobj_at(let, sx, sy);
     133:     }
     134: }
     135:
     136: mkzoo(type)
     137: int type;
     138: {
     139:     register struct mkroom *sroom;
     140:     register struct monst *mon;
     141:     register int sh,sx,sy,i;
     142:     int goldlim = 500 * dlevel;
     143:     int moct = 0;
     144:     struct permonst *morguemon();
     145:
     146:     i = nroom;
     147:     for(sroom = &rooms[rn2(nroom)]; ; sroom++) {
     148:         if(sroom == &rooms[nroom])
     149:             sroom = &rooms[0];
     150:         if(!i-- || sroom->hx < 0)
     151:             return;
     152:         if(sroom->rtype)
     153:             continue;
     154:         if(type == MORGUE && sroom->rlit)
     155:             continue;
     156:         if(has_upstairs(sroom) || (has_dnstairs(sroom) && rn2(3)))
     157:             continue;
     158:         if(sroom->doorct == 1 || !rn2(5))
     159:             break;
     160:     }
     161:     sroom->rtype = type;
     162:     sh = sroom->fdoor;
     163:     for(sx = sroom->lx; sx <= sroom->hx; sx++)
     164:     for(sy = sroom->ly; sy <= sroom->hy; sy++){
     165:         if((sx == sroom->lx && doors[sh].x == sx-1) ||
     166:            (sx == sroom->hx && doors[sh].x == sx+1) ||
     167:            (sy == sroom->ly && doors[sh].y == sy-1) ||
     168:            (sy == sroom->hy && doors[sh].y == sy+1)) continue;
     169:         mon = makemon(
     170:            (type == MORGUE) ? morguemon() :
     171:            (type == BEEHIVE) ? PM_KILLER_BEE : (struct permonst *) 0,
     172:            sx, sy);
     173:         if(mon) mon->msleep = 1;
     174:         switch(type) {
     175:         case ZOO:
     176:            i = sq(dist2(sx,sy,doors[sh].x,doors[sh].y));
     177:            if(i >= goldlim) i = 5*dlevel;
     178:            goldlim -= i;
     179:            mkgold((long)(10 + rn2(i)), sx, sy);
     180:            break;
     181:         case MORGUE:
     182:            /* Usually there is one dead body in the morgue */
     183:            if(!moct && rn2(3)) {
     184:             mksobj_at(CORPSE, sx, sy);
     185:             moct++;
     186:            }
     187:            break;
     188:         case BEEHIVE:
     189:            if(!rn2(3)) mksobj_at(LUMP_OF_ROYAL_JELLY, sx, sy);
     190:            break;
     191:         }
     192:     }
     193: }
     194:
     195: struct permonst *
     196: morguemon()
     197: {
     198:     extern struct permonst pm_ghost;
     199:     register int i = rn2(100), hd = rn2(dlevel);
     200:
     201:     if(hd > 10 && i < 10) return(PM_DEMON);
     202:     if(hd > 8 && i > 85) return(PM_VAMPIRE);
     203:     return((i < 40) ? PM_GHOST : (i < 60) ? PM_WRAITH : PM_ZOMBIE);
     204: }
     205:
     206: mkswamp()   /* Michiel Huisjes & Fred de Wilde */
     207: {
     208:     register struct mkroom *sroom;
     209:     register int sx,sy,i,eelct = 0;
     210:     extern struct permonst pm_eel;
     211:
     212:     for(i=0; i<5; i++) {        /* 5 tries */
     213:         sroom = &rooms[rn2(nroom)];
     214:         if(sroom->hx < 0 || sroom->rtype ||
     215:            has_upstairs(sroom) || has_dnstairs(sroom))
     216:             continue;
     217:
     218:         /* satisfied; make a swamp */
     219:         sroom->rtype = SWAMP;
     220:         for(sx = sroom->lx; sx <= sroom->hx; sx++)
     221:         for(sy = sroom->ly; sy <= sroom->hy; sy++)
     222:         if((sx+sy)%2 && !o_at(sx,sy) && !t_at(sx,sy)
     223:                  && !m_at(sx,sy) && !nexttodoor(sx,sy)){
     224:             levl[sx][sy].typ = POOL;
     225:             levl[sx][sy].scrsym = POOL_SYM;
     226:             if(!eelct || !rn2(4)) {
     227:                 (void) makemon(PM_EEL, sx, sy);
     228:                 eelct++;
     229:             }
     230:         }
     231:     }
     232: }
     233:
     234: nexttodoor(sx,sy)
     235: register sx,sy;
     236: {
     237:     register dx,dy;
     238:     register struct rm *lev;
     239:     for(dx = -1; dx <= 1; dx++) for(dy = -1; dy <= 1; dy++)
     240:         if((lev = &levl[sx+dx][sy+dy])->typ == DOOR ||
     241:             lev->typ == SDOOR || lev->typ == LDOOR)
     242:             return(1);
     243:     return(0);
     244: }
     245:
     246: has_dnstairs(sroom)
     247: register struct mkroom *sroom;
     248: {
     249:     return(sroom->lx <= xdnstair && xdnstair <= sroom->hx &&
     250:            sroom->ly <= ydnstair && ydnstair <= sroom->hy);
     251: }
     252:
     253: has_upstairs(sroom)
     254: register struct mkroom *sroom;
     255: {
     256:     return(sroom->lx <= xupstair && xupstair <= sroom->hx &&
     257:            sroom->ly <= yupstair && yupstair <= sroom->hy);
     258: }
     259:
     260: isbig(sroom)
     261: register struct mkroom *sroom;
     262: {
     263:     register int area = (sroom->hx - sroom->lx) * (sroom->hy - sroom->ly);
     264:     return( area > 20 );
     265: }
     266:
     267: dist2(x0,y0,x1,y1){
     268:     return((x0-x1)*(x0-x1) + (y0-y1)*(y0-y1));
     269: }
     270:
     271: sq(a) int a; {
     272:     return(a*a);
     273: }
     274: #endif QUEST

#### Defined functions

dist2 defined in line 267; used 1 times

- in line 176

has_dnstairs defined in line 246; used 3 times

- in line 57, 156, 215

has_upstairs defined in line 253; used 3 times

- in line 57, 156, 215

isbig defined in line 260; used 1 times

- in line 71

mkshop defined in line 15; used 2 times

- in /usr/src/games/hack/hack.mklev.c line 124-126(2)

mkswamp defined in line 206; used 2 times

- in line 40
- in /usr/src/games/hack/hack.mklev.c line 134

mkzoo defined in line 136; used 6 times

- in line 28-36(3)
- in /usr/src/games/hack/hack.mklev.c line 128-132(3)

morguemon defined in line 195; used 2 times

- in line 144, 170

nexttodoor defined in line 234; used 1 times

- in line 223

sq defined in line 271; used 1 times

- in line 176

#### Defined variables

shprobs defined in line 13; used 1 times

- in line 69

#### Defined macros

ESHK defined in line 8; used 10 times

- in line 107-117(10)

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