![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hack.mkshop.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / games / hack|
Return to hack.mkshop.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / games / hack |
1.1 root 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 <= 2 && sroom->doorct > 0) 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
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.