?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Sync assert with FreeBSD:
[dragonfly.git] / games / hack / hack.mklev.c
blob1ea80960031148a2775b4c8696b71daa501a511d
1 /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
2 /* hack.mklev.c - version 1.0.3 */
3 /* $FreeBSD: src/games/hack/hack.mklev.c,v 1.6 1999/11/16 10:26:36 marcel Exp $ */
4 /* $DragonFly: src/games/hack/hack.mklev.c,v 1.4 2006/08/21 19:45:32 pavalos Exp $ */
5
6 #include "hack.h"
7
8 #define somex() ((random()%(croom->hx-croom->lx+1))+croom->lx)
9 #define somey() ((random()%(croom->hy-croom->ly+1))+croom->ly)
10
11 #define XLIM 4 /* define minimum required space around a room */
12 #define YLIM 3
13 boolean secret; /* TRUE while making a vault: increase [XY]LIM */
14 struct mkroom rooms[MAXNROFROOMS+1];
15 int smeq[MAXNROFROOMS+1];
16 coord doors[DOORMAX];
17 int doorindex;
18 struct rm zerorm;
19 schar nxcor;
20 boolean goldseen;
21 int nroom;
22 xchar xdnstair,xupstair,ydnstair,yupstair;
23
24 /* Definitions used by makerooms() and addrs() */
25 #define MAXRS 50 /* max lth of temp rectangle table - arbitrary */
26 struct rectangle {
27 xchar rlx,rly,rhx,rhy;
28 } rs[MAXRS+1];
29 int rscnt,rsmax; /* 0..rscnt-1: currently under consideration */
30 /* rscnt..rsmax: discarded */
31
32 static bool makerooms(void);
33 static void addrs(int, int, int, int);
34 static void addrsx(int, int, int, int, bool);
35 static int comp(const void *, const void *);
36 static coord finddpos(int, int, int, int);
37 static bool okdoor(int, int);
38 static void dodoor(int, int, struct mkroom *);
39 static void dosdoor(int, int, struct mkroom *, int);
40 static bool maker(schar, schar, schar, schar);
41 static void makecorridors(void);
42 static void join(int, int);
43 static void make_niches(void);
44 static void makevtele(void);
45 static void makeniche(bool);
46
47 void
48 makelevel(void)
49 {
50 struct mkroom *croom, *troom;
51 unsigned tryct;
52 int x,y;
53
54 nroom = 0;
55 doorindex = 0;
56 rooms[0].hx = -1; /* in case we are in a maze */
57
58 for(x=0; x<COLNO; x++) for(y=0; y<ROWNO; y++)
59 levl[x][y] = zerorm;
60
61 oinit(); /* assign level dependent obj probabilities */
62
63 if(dlevel >= rn1(3, 26)) { /* there might be several mazes */
64 makemaz();
65 return;
66 }
67
68 /* construct the rooms */
69 nroom = 0;
70 secret = FALSE;
71 makerooms();
72
73 /* construct stairs (up and down in different rooms if possible) */
74 croom = &rooms[rn2(nroom)];
75 xdnstair = somex();
76 ydnstair = somey();
77 levl[xdnstair][ydnstair].scrsym ='>';
78 levl[xdnstair][ydnstair].typ = STAIRS;
79 if(nroom > 1) {
80 troom = croom;
81 croom = &rooms[rn2(nroom-1)];
82 if(croom >= troom) croom++;
83 }
84 xupstair = somex(); /* %% < and > might be in the same place */
85 yupstair = somey();
86 levl[xupstair][yupstair].scrsym ='<';
87 levl[xupstair][yupstair].typ = STAIRS;
88
89 /* for each room: put things inside */
90 for(croom = rooms; croom->hx > 0; croom++) {
91
92 /* put a sleeping monster inside */
93 /* Note: monster may be on the stairs. This cannot be
94 avoided: maybe the player fell through a trapdoor
95 while a monster was on the stairs. Conclusion:
96 we have to check for monsters on the stairs anyway. */
97 if(!rn2(3))
98 makemon((struct permonst *) 0, somex(), somey());
99
100 /* put traps and mimics inside */
101 goldseen = FALSE;
102 while(!rn2(8-(dlevel/6))) mktrap(0,0,croom);
103 if(!goldseen && !rn2(3)) mkgold(0L,somex(),somey());
104 if(!rn2(3)) {
105 mkobj_at(0, somex(), somey());
106 tryct = 0;
107 while(!rn2(5)) {
108 if(++tryct > 100){
109 printf("tryct overflow4\n");
110 break;
111 }
112 mkobj_at(0, somex(), somey());
113 }
114 }
115 }
116
117 qsort((char *) rooms, nroom, sizeof(struct mkroom), comp);
118 makecorridors();
119 make_niches();
120
121 /* make a secret treasure vault, not connected to the rest */
122 if(nroom <= (2*MAXNROFROOMS/3)) if(rn2(3)) {
123 troom = &rooms[nroom];
124 secret = TRUE;
125 if(makerooms()) {
126 troom->rtype = VAULT; /* treasure vault */
127 for(x = troom->lx; x <= troom->hx; x++)
128 for(y = troom->ly; y <= troom->hy; y++)
129 mkgold((long)(rnd(dlevel*100) + 50), x, y);
130 if(!rn2(3))
131 makevtele();
132 }
133 }
134
135 #ifndef QUEST
136 #ifdef WIZARD
137 if(wizard && getenv("SHOPTYPE")) mkshop(); else
138 #endif /* WIZARD */
139 if(dlevel > 1 && dlevel < 20 && rn2(dlevel) < 3) mkshop();
140 else
141 if(dlevel > 6 && !rn2(7)) mkzoo(ZOO);
142 else
143 if(dlevel > 9 && !rn2(5)) mkzoo(BEEHIVE);
144 else
145 if(dlevel > 11 && !rn2(6)) mkzoo(MORGUE);
146 else
147 if(dlevel > 18 && !rn2(6)) mkswamp();
148 #endif /* QUEST */
149 }
150
151 static bool
152 makerooms(void)
153 {
154 struct rectangle *rsp;
155 int lx, ly, hx, hy, lowx, lowy, hix, hiy, dx, dy;
156 int tryct = 0, xlim, ylim;
157
158 /* init */
159 xlim = XLIM + secret;
160 ylim = YLIM + secret;
161 if(nroom == 0) {
162 rsp = rs;
163 rsp->rlx = rsp->rly = 0;
164 rsp->rhx = COLNO-1;
165 rsp->rhy = ROWNO-1;
166 rsmax = 1;
167 }
168 rscnt = rsmax;
169
170 /* make rooms until satisfied */
171 while(rscnt > 0 && nroom < MAXNROFROOMS-1) {
172 if(!secret && nroom > (MAXNROFROOMS/3) &&
173 !rn2((MAXNROFROOMS-nroom)*(MAXNROFROOMS-nroom)))
174 return(0);
175
176 /* pick a rectangle */
177 rsp = &rs[rn2(rscnt)];
178 hx = rsp->rhx;
179 hy = rsp->rhy;
180 lx = rsp->rlx;
181 ly = rsp->rly;
182
183 /* find size of room */
184 if(secret)
185 dx = dy = 1;
186 else {
187 dx = 2 + rn2((hx-lx-8 > 20) ? 12 : 8);
188 dy = 2 + rn2(4);
189 if(dx*dy > 50)
190 dy = 50/dx;
191 }
192
193 /* look whether our room will fit */
194 if(hx-lx < dx + dx/2 + 2*xlim || hy-ly < dy + dy/3 + 2*ylim) {
195 /* no, too small */
196 /* maybe we throw this area out */
197 if(secret || !rn2(MAXNROFROOMS+1-nroom-tryct)) {
198 rscnt--;
199 rs[rsmax] = *rsp;
200 *rsp = rs[rscnt];
201 rs[rscnt] = rs[rsmax];
202 tryct = 0;
203 } else
204 tryct++;
205 continue;
206 }
207
208 lowx = lx + xlim + rn2(hx - lx - dx - 2*xlim + 1);
209 lowy = ly + ylim + rn2(hy - ly - dy - 2*ylim + 1);
210 hix = lowx + dx;
211 hiy = lowy + dy;
212
213 if(maker(lowx, dx, lowy, dy)) {
214 if(secret)
215 return(1);
216 addrs(lowx-1, lowy-1, hix+1, hiy+1);
217 tryct = 0;
218 } else
219 if(tryct++ > 100)
220 break;
221 }
222 return(0); /* failed to make vault - very strange */
223 }
224
225 static void
226 addrs(int lowx, int lowy, int hix, int hiy)
227 {
228 struct rectangle *rsp;
229 int lx,ly,hx,hy,xlim,ylim;
230 boolean discarded;
231
232 xlim = XLIM + secret;
233 ylim = YLIM + secret;
234
235 /* walk down since rscnt and rsmax change */
236 for(rsp = &rs[rsmax-1]; rsp >= rs; rsp--) {
237
238 if((lx = rsp->rlx) > hix || (ly = rsp->rly) > hiy ||
239 (hx = rsp->rhx) < lowx || (hy = rsp->rhy) < lowy)
240 continue;
241 if((discarded = (rsp >= &rs[rscnt]))) {
242 *rsp = rs[--rsmax];
243 } else {
244 rsmax--;
245 rscnt--;
246 *rsp = rs[rscnt];
247 if(rscnt != rsmax)
248 rs[rscnt] = rs[rsmax];
249 }
250 if(lowy - ly > 2*ylim + 4)
251 addrsx(lx,ly,hx,lowy-2,discarded);
252 if(lowx - lx > 2*xlim + 4)
253 addrsx(lx,ly,lowx-2,hy,discarded);
254 if(hy - hiy > 2*ylim + 4)
255 addrsx(lx,hiy+2,hx,hy,discarded);
256 if(hx - hix > 2*xlim + 4)
257 addrsx(hix+2,ly,hx,hy,discarded);
258 }
259 }
260
261 /* discarded = piece of a discarded area */
262 static void
263 addrsx(int lx, int ly, int hx, int hy, bool discarded)
264 {
265 struct rectangle *rsp;
266
267 /* check inclusions */
268 for(rsp = rs; rsp < &rs[rsmax]; rsp++) {
269 if(lx >= rsp->rlx && hx <= rsp->rhx &&
270 ly >= rsp->rly && hy <= rsp->rhy)
271 return;
272 }
273
274 /* make a new entry */
275 if(rsmax >= MAXRS) {
276 #ifdef WIZARD
277 if(wizard) pline("MAXRS may be too small.");
278 #endif /* WIZARD */
279 return;
280 }
281 rsmax++;
282 if(!discarded) {
283 *rsp = rs[rscnt];
284 rsp = &rs[rscnt];
285 rscnt++;
286 }
287 rsp->rlx = lx;
288 rsp->rly = ly;
289 rsp->rhx = hx;
290 rsp->rhy = hy;
291 }
292
293 static int
294 comp(const void *vx, const void *vy)
295 {
296 const struct mkroom *x, *y;
297 x = vx;
298 y = vy;
299 if(x->lx < y->lx) return(-1);
300 return(x->lx > y->lx);
301 }
302
303 static coord
304 finddpos(int xl, int yl, int xh, int yh)
305 {
306 coord ff;
307 int x,y;
308
309 x = (xl == xh) ? xl : (xl + rn2(xh-xl+1));
310 y = (yl == yh) ? yl : (yl + rn2(yh-yl+1));
311 if(okdoor(x, y))
312 goto gotit;
313
314 for(x = xl; x <= xh; x++) for(y = yl; y <= yh; y++)
315 if(okdoor(x, y))
316 goto gotit;
317
318 for(x = xl; x <= xh; x++) for(y = yl; y <= yh; y++)
319 if(levl[x][y].typ == DOOR || levl[x][y].typ == SDOOR)
320 goto gotit;
321 /* cannot find something reasonable -- strange */
322 x = xl;
323 y = yh;
324 gotit:
325 ff.x = x;
326 ff.y = y;
327 return(ff);
328 }
329
330 /* see whether it is allowable to create a door at [x,y] */
331 static bool
332 okdoor(int x, int y)
333 {
334 if(levl[x-1][y].typ == DOOR || levl[x+1][y].typ == DOOR ||
335 levl[x][y+1].typ == DOOR || levl[x][y-1].typ == DOOR ||
336 levl[x-1][y].typ == SDOOR || levl[x+1][y].typ == SDOOR ||
337 levl[x][y-1].typ == SDOOR || levl[x][y+1].typ == SDOOR ||
338 (levl[x][y].typ != HWALL && levl[x][y].typ != VWALL) ||
339 doorindex >= DOORMAX)
340 return(0);
341 return(1);
342 }
343
344 static void
345 dodoor(int x, int y, struct mkroom *aroom)
346 {
347 if(doorindex >= DOORMAX) {
348 impossible("DOORMAX exceeded?");
349 return;
350 }
351 if(!okdoor(x,y) && nxcor)
352 return;
353 dosdoor(x,y,aroom,rn2(8) ? DOOR : SDOOR);
354 }
355
356 static void
357 dosdoor(int x, int y, struct mkroom *aroom, int type)
358 {
359 struct mkroom *broom;
360 int tmp;
361
362 if(!IS_WALL(levl[x][y].typ)) /* avoid SDOORs with '+' as scrsym */
363 type = DOOR;
364 levl[x][y].typ = type;
365 if(type == DOOR)
366 levl[x][y].scrsym = '+';
367 aroom->doorct++;
368 broom = aroom+1;
369 if(broom->hx < 0) tmp = doorindex; else
370 for(tmp = doorindex; tmp > broom->fdoor; tmp--)
371 doors[tmp] = doors[tmp-1];
372 doorindex++;
373 doors[tmp].x = x;
374 doors[tmp].y = y;
375 for( ; broom->hx >= 0; broom++) broom->fdoor++;
376 }
377
378 /* Only called from makerooms() */
379 static bool
380 maker(schar lowx, schar ddx, schar lowy, schar ddy)
381 {
382 struct mkroom *croom;
383 int x, y, hix = lowx+ddx, hiy = lowy+ddy;
384 int xlim = XLIM + secret, ylim = YLIM + secret;
385
386 if(nroom >= MAXNROFROOMS) return(0);
387 if(lowx < XLIM) lowx = XLIM;
388 if(lowy < YLIM) lowy = YLIM;
389 if(hix > COLNO-XLIM-1) hix = COLNO-XLIM-1;
390 if(hiy > ROWNO-YLIM-1) hiy = ROWNO-YLIM-1;
391 chk:
392 if(hix <= lowx || hiy <= lowy) return(0);
393
394 /* check area around room (and make room smaller if necessary) */
395 for(x = lowx - xlim; x <= hix + xlim; x++) {
396 for(y = lowy - ylim; y <= hiy + ylim; y++) {
397 if(levl[x][y].typ) {
398 #ifdef WIZARD
399 if(wizard && !secret)
400 pline("Strange area [%d,%d] in maker().",x,y);
401 #endif /* WIZARD */
402 if(!rn2(3)) return(0);
403 if(x < lowx)
404 lowx = x+xlim+1;
405 else
406 hix = x-xlim-1;
407 if(y < lowy)
408 lowy = y+ylim+1;
409 else
410 hiy = y-ylim-1;
411 goto chk;
412 }
413 }
414 }
415
416 croom = &rooms[nroom];
417
418 /* on low levels the room is lit (usually) */
419 /* secret vaults are always lit */
420 if((rnd(dlevel) < 10 && rn2(77)) || (ddx == 1 && ddy == 1)) {
421 for(x = lowx-1; x <= hix+1; x++)
422 for(y = lowy-1; y <= hiy+1; y++)
423 levl[x][y].lit = 1;
424 croom->rlit = 1;
425 } else
426 croom->rlit = 0;
427 croom->lx = lowx;
428 croom->hx = hix;
429 croom->ly = lowy;
430 croom->hy = hiy;
431 croom->rtype = croom->doorct = croom->fdoor = 0;
432
433 for(x = lowx-1; x <= hix+1; x++)
434 for(y = lowy-1; y <= hiy+1; y += (hiy-lowy+2)) {
435 levl[x][y].scrsym = '-';
436 levl[x][y].typ = HWALL;
437 }
438 for(x = lowx-1; x <= hix+1; x += (hix-lowx+2))
439 for(y = lowy; y <= hiy; y++) {
440 levl[x][y].scrsym = '|';
441 levl[x][y].typ = VWALL;
442 }
443 for(x = lowx; x <= hix; x++)
444 for(y = lowy; y <= hiy; y++) {
445 levl[x][y].scrsym = '.';
446 levl[x][y].typ = ROOM;
447 }
448
449 smeq[nroom] = nroom;
450 croom++;
451 croom->hx = -1;
452 nroom++;
453 return(1);
454 }
455
456 static void
457 makecorridors(void)
458 {
459 int a,b;
460
461 nxcor = 0;
462 for(a = 0; a < nroom-1; a++)
463 join(a, a+1);
464 for(a = 0; a < nroom-2; a++)
465 if(smeq[a] != smeq[a+2])
466 join(a, a+2);
467 for(a = 0; a < nroom; a++)
468 for(b = 0; b < nroom; b++)
469 if(smeq[a] != smeq[b])
470 join(a, b);
471 if(nroom > 2)
472 for(nxcor = rn2(nroom) + 4; nxcor; nxcor--) {
473 a = rn2(nroom);
474 b = rn2(nroom-2);
475 if(b >= a) b += 2;
476 join(a, b);
477 }
478 }
479
480 static void
481 join(int a, int b)
482 {
483 coord cc,tt;
484 int tx, ty, xx, yy;
485 struct rm *crm;
486 struct mkroom *croom, *troom;
487 int dx, dy, dix, diy, cct;
488
489 croom = &rooms[a];
490 troom = &rooms[b];
491
492 /* find positions cc and tt for doors in croom and troom
493 and direction for a corridor between them */
494
495 if(troom->hx < 0 || croom->hx < 0 || doorindex >= DOORMAX) return;
496 if(troom->lx > croom->hx) {
497 dx = 1;
498 dy = 0;
499 xx = croom->hx+1;
500 tx = troom->lx-1;
501 cc = finddpos(xx,croom->ly,xx,croom->hy);
502 tt = finddpos(tx,troom->ly,tx,troom->hy);
503 } else if(troom->hy < croom->ly) {
504 dy = -1;
505 dx = 0;
506 yy = croom->ly-1;
507 cc = finddpos(croom->lx,yy,croom->hx,yy);
508 ty = troom->hy+1;
509 tt = finddpos(troom->lx,ty,troom->hx,ty);
510 } else if(troom->hx < croom->lx) {
511 dx = -1;
512 dy = 0;
513 xx = croom->lx-1;
514 tx = troom->hx+1;
515 cc = finddpos(xx,croom->ly,xx,croom->hy);
516 tt = finddpos(tx,troom->ly,tx,troom->hy);
517 } else {
518 dy = 1;
519 dx = 0;
520 yy = croom->hy+1;
521 ty = troom->ly-1;
522 cc = finddpos(croom->lx,yy,croom->hx,yy);
523 tt = finddpos(troom->lx,ty,troom->hx,ty);
524 }
525 xx = cc.x;
526 yy = cc.y;
527 tx = tt.x - dx;
528 ty = tt.y - dy;
529 if(nxcor && levl[xx+dx][yy+dy].typ)
530 return;
531 dodoor(xx,yy,croom);
532
533 cct = 0;
534 while(xx != tx || yy != ty) {
535 xx += dx;
536 yy += dy;
537
538 /* loop: dig corridor at [xx,yy] and find new [xx,yy] */
539 if(cct++ > 500 || (nxcor && !rn2(35)))
540 return;
541
542 if(xx == COLNO-1 || xx == 0 || yy == 0 || yy == ROWNO-1)
543 return; /* impossible */
544
545 crm = &levl[xx][yy];
546 if(!(crm->typ)) {
547 if(rn2(100)) {
548 crm->typ = CORR;
549 crm->scrsym = CORR_SYM;
550 if(nxcor && !rn2(50))
551 mkobj_at(ROCK_SYM, xx, yy);
552 } else {
553 crm->typ = SCORR;
554 crm->scrsym = ' ';
555 }
556 } else
557 if(crm->typ != CORR && crm->typ != SCORR) {
558 /* strange ... */
559 return;
560 }
561
562 /* find next corridor position */
563 dix = abs(xx-tx);
564 diy = abs(yy-ty);
565
566 /* do we have to change direction ? */
567 if(dy && dix > diy) {
568 int ddx = (xx > tx) ? -1 : 1;
569
570 crm = &levl[xx+ddx][yy];
571 if(!crm->typ || crm->typ == CORR || crm->typ == SCORR) {
572 dx = ddx;
573 dy = 0;
574 continue;
575 }
576 } else if(dx && diy > dix) {
577 int ddy = (yy > ty) ? -1 : 1;
578
579 crm = &levl[xx][yy+ddy];
580 if(!crm->typ || crm->typ == CORR || crm->typ == SCORR) {
581 dy = ddy;
582 dx = 0;
583 continue;
584 }
585 }
586
587 /* continue straight on? */
588 crm = &levl[xx+dx][yy+dy];
589 if(!crm->typ || crm->typ == CORR || crm->typ == SCORR)
590 continue;
591
592 /* no, what must we do now?? */
593 if(dx) {
594 dx = 0;
595 dy = (ty < yy) ? -1 : 1;
596 crm = &levl[xx+dx][yy+dy];
597 if(!crm->typ || crm->typ == CORR || crm->typ == SCORR)
598 continue;
599 dy = -dy;
600 continue;
601 } else {
602 dy = 0;
603 dx = (tx < xx) ? -1 : 1;
604 crm = &levl[xx+dx][yy+dy];
605 if(!crm->typ || crm->typ == CORR || crm->typ == SCORR)
606 continue;
607 dx = -dx;
608 continue;
609 }
610 }
611
612 /* we succeeded in digging the corridor */
613 dodoor(tt.x, tt.y, troom);
614
615 if(smeq[a] < smeq[b])
616 smeq[b] = smeq[a];
617 else
618 smeq[a] = smeq[b];
619 }
620
621 static void
622 make_niches(void)
623 {
624 int ct = rnd(nroom/2 + 1);
625 while(ct--) makeniche(FALSE);
626 }
627
628 static void
629 makevtele(void)
630 {
631 makeniche(TRUE);
632 }
633
634 static void
635 makeniche(bool with_trap)
636 {
637 struct mkroom *aroom;
638 struct rm *rm;
639 int vct = 8;
640 coord dd;
641 int dy,xx,yy;
642 struct trap *ttmp;
643
644 if(doorindex < DOORMAX)
645 while(vct--) {
646 aroom = &rooms[rn2(nroom-1)];
647 if(aroom->rtype != 0) continue; /* not an ordinary room */
648 if(aroom->doorct == 1 && rn2(5)) continue;
649 if(rn2(2)) {
650 dy = 1;
651 dd = finddpos(aroom->lx,aroom->hy+1,aroom->hx,aroom->hy+1);
652 } else {
653 dy = -1;
654 dd = finddpos(aroom->lx,aroom->ly-1,aroom->hx,aroom->ly-1);
655 }
656 xx = dd.x;
657 yy = dd.y;
658 if((rm = &levl[xx][yy+dy])->typ) continue;
659 if(with_trap || !rn2(4)) {
660 rm->typ = SCORR;
661 rm->scrsym = ' ';
662 if(with_trap) {
663 ttmp = maketrap(xx, yy+dy, TELEP_TRAP);
664 ttmp->once = 1;
665 make_engr_at(xx, yy-dy, "ad ae?ar um");
666 }
667 dosdoor(xx, yy, aroom, SDOOR);
668 } else {
669 rm->typ = CORR;
670 rm->scrsym = CORR_SYM;
671 if(rn2(7))
672 dosdoor(xx, yy, aroom, rn2(5) ? SDOOR : DOOR);
673 else {
674 mksobj_at(SCR_TELEPORTATION, xx, yy+dy);
675 if(!rn2(3)) mkobj_at(0, xx, yy+dy);
676 }
677 }
678 return;
679 }
680 }
681
682 /* make a trap somewhere (in croom if mazeflag = 0) */
683 void
684 mktrap(int num, int mazeflag, struct mkroom *croom)
685 {
686 struct trap *ttmp;
687 int kind,nopierc,nomimic,fakedoor,fakegold,tryct = 0;
688 xchar mx,my;
689
690 if(!num || num >= TRAPNUM) {
691 nopierc = (dlevel < 4) ? 1 : 0;
692 nomimic = (dlevel < 9 || goldseen ) ? 1 : 0;
693 if(index(fut_geno, 'M')) nomimic = 1;
694 kind = rn2(TRAPNUM - nopierc - nomimic);
695 /* note: PIERC = 7, MIMIC = 8, TRAPNUM = 9 */
696 } else kind = num;
697
698 if(kind == MIMIC) {
699 struct monst *mtmp;
700
701 fakedoor = (!rn2(3) && !mazeflag);
702 fakegold = (!fakedoor && !rn2(2));
703 if(fakegold) goldseen = TRUE;
704 do {
705 if(++tryct > 200) return;
706 if(fakedoor) {
707 /* note: fakedoor maybe on actual door */
708 if(rn2(2)){
709 if(rn2(2))
710 mx = croom->hx+1;
711 else mx = croom->lx-1;
712 my = somey();
713 } else {
714 if(rn2(2))
715 my = croom->hy+1;
716 else my = croom->ly-1;
717 mx = somex();
718 }
719 } else if(mazeflag) {
720 coord mm;
721 mm = mazexy();
722 mx = mm.x;
723 my = mm.y;
724 } else {
725 mx = somex();
726 my = somey();
727 }
728 } while(m_at(mx,my) || levl[mx][my].typ == STAIRS);
729 if((mtmp = makemon(PM_MIMIC,mx,my))) {
730 mtmp->mimic = 1;
731 mtmp->mappearance =
732 fakegold ? '$' : fakedoor ? '+' :
733 (mazeflag && rn2(2)) ? AMULET_SYM :
734 "=/)%?![<>" [ rn2(9) ];
735 }
736 return;
737 }
738
739 do {
740 if(++tryct > 200)
741 return;
742 if(mazeflag){
743 coord mm;
744 mm = mazexy();
745 mx = mm.x;
746 my = mm.y;
747 } else {
748 mx = somex();
749 my = somey();
750 }
751 } while(t_at(mx, my) || levl[mx][my].typ == STAIRS);
752 ttmp = maketrap(mx, my, kind);
753 if(mazeflag && !rn2(10) && ttmp->ttyp < PIERC)
754 ttmp->tseen = 1;
755 }
DragonFly BSD