Fandom

Wikihack

Source:Mkroom.c

2,034pages on
this wiki
Add New Page
Talk0

Ad blocker interference detected!


Wikia is a free-to-use site that makes money from advertising. We have a modified experience for viewers using ad blockers

Wikia is not accessible if you’ve made further modifications. Remove the custom ad blocker rule(s) and the page will load as expected.

Below is the full text to src/mkroom.c from NetHack 3.4.3. To link to a particular line, write [[mkroom.c#line123]], for example. This file deals with the creation of special rooms, like shops, temples, zoos, leprechaun halls, etc..

Top of file Edit

1.    /*	SCCS Id: @(#)mkroom.c	3.4	2001/09/06	*/
2.    /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
3.    /* NetHack may be freely redistributed.  See license for details. */
4.    
The NetHack General Public License applies to screenshots, source code and other content from NetHack.
5.    /*
6.     * Entry points:
7.     *	mkroom() -- make and stock a room of a given type
8.     *	nexttodoor() -- return TRUE if adjacent to a door
9.     *	has_dnstairs() -- return TRUE if given room has a down staircase
10.    *	has_upstairs() -- return TRUE if given room has an up staircase
11.    *	courtmon() -- generate a court monster
12.    *	save_rooms() -- save rooms into file fd
13.    *	rest_rooms() -- restore rooms from file fd
14.    */
15.   
16.   #include "hack.h"
17.   
18.   #ifdef OVLB
19.   STATIC_DCL boolean FDECL(isbig, (struct mkroom *));
20.   STATIC_DCL struct mkroom * FDECL(pick_room,(BOOLEAN_P));
21.   STATIC_DCL void NDECL(mkshop), FDECL(mkzoo,(int)), NDECL(mkswamp);
22.   STATIC_DCL void NDECL(mktemple);
23.   STATIC_DCL coord * FDECL(shrine_pos, (int));
24.   STATIC_DCL struct permonst * NDECL(morguemon);
25.   STATIC_DCL struct permonst * NDECL(antholemon);
26.   STATIC_DCL struct permonst * NDECL(squadmon);
27.   STATIC_DCL void FDECL(save_room, (int,struct mkroom *));
28.   STATIC_DCL void FDECL(rest_room, (int,struct mkroom *));
29.   #endif /* OVLB */
30.   
31.   #define sq(x) ((x)*(x))
32.   
33.   extern const struct shclass shtypes[];	/* defined in shknam.c */
34.   
35.   #ifdef OVLB
36.   

isbig Edit

37.   STATIC_OVL boolean
38.   isbig(sroom)
39.   register struct mkroom *sroom;
40.   {
41.   	register int area = (sroom->hx - sroom->lx + 1)
42.   			   * (sroom->hy - sroom->ly + 1);
43.   	return((boolean)( area > 20 ));
44.   }
45.   

mkroom Edit

46.   void
47.   mkroom(roomtype)
48.   /* make and stock a room of a given type */
49.   int	roomtype;
50.   {
51.       if (roomtype >= SHOPBASE)
52.   	mkshop();	/* someday, we should be able to specify shop type */
53.       else switch(roomtype) {
54.   	case COURT:	mkzoo(COURT); break;
55.   	case ZOO:	mkzoo(ZOO); break;
56.   	case BEEHIVE:	mkzoo(BEEHIVE); break;
57.   	case MORGUE:	mkzoo(MORGUE); break;
58.   	case BARRACKS:	mkzoo(BARRACKS); break;
59.   	case SWAMP:	mkswamp(); break;
60.   	case TEMPLE:	mktemple(); break;
61.   	case LEPREHALL:	mkzoo(LEPREHALL); break;
62.   	case COCKNEST:	mkzoo(COCKNEST); break;
63.   	case ANTHOLE:	mkzoo(ANTHOLE); break;
64.   	default:	impossible("Tried to make a room of type %d.", roomtype);
65.       }
66.   }
67.   

mkshop Edit

68.   STATIC_OVL void
69.   mkshop()
70.   {
71.   	register struct mkroom *sroom;
72.   	int i = -1;
73.   #ifdef WIZARD
74.   	char *ep = (char *)0;	/* (init == lint suppression) */
75.   
76.   	/* first determine shoptype */
77.   	if(wizard){
78.   #ifndef MAC
79.   		ep = nh_getenv("SHOPTYPE");
80.   		if(ep){
81.   			if(*ep == 'z' || *ep == 'Z'){
82.   				mkzoo(ZOO);
83.   				return;
84.   			}
85.   			if(*ep == 'm' || *ep == 'M'){
86.   				mkzoo(MORGUE);
87.   				return;
88.   			}
89.   			if(*ep == 'b' || *ep == 'B'){
90.   				mkzoo(BEEHIVE);
91.   				return;
92.   			}
93.   			if(*ep == 't' || *ep == 'T' || *ep == '\\'){
94.   				mkzoo(COURT);
95.   				return;
96.   			}
97.   			if(*ep == 's' || *ep == 'S'){
98.   				mkzoo(BARRACKS);
99.   				return;
100.  			}
101.  			if(*ep == 'a' || *ep == 'A'){
102.  				mkzoo(ANTHOLE);
103.  				return;
104.  			}
105.  			if(*ep == 'c' || *ep == 'C'){
106.  				mkzoo(COCKNEST);
107.  				return;
108.  			}
109.  			if(*ep == 'l' || *ep == 'L'){
110.  				mkzoo(LEPREHALL);
111.  				return;
112.  			}
113.  			if(*ep == '_'){
114.  				mktemple();
115.  				return;
116.  			}
117.  			if(*ep == '}'){
118.  				mkswamp();
119.  				return;
120.  			}
121.  			for(i=0; shtypes[i].name; i++)
122.  				if(*ep == def_oc_syms[(int)shtypes[i].symb])
123.  				    goto gottype;
124.  			if(*ep == 'g' || *ep == 'G')
125.  				i = 0;
126.  			else
127.  				i = -1;
128.  		}
129.  #endif
130.  	}
131.  #ifndef MAC
132.  gottype:
133.  #endif
134.  #endif
135.  	for(sroom = &rooms[0]; ; sroom++){
136.  		if(sroom->hx < 0) return;
137.  		if(sroom - rooms >= nroom) {
138.  			pline("rooms not closed by -1?");
139.  			return;
140.  		}
141.  		if(sroom->rtype != OROOM) continue;
142.  		if(has_dnstairs(sroom) || has_upstairs(sroom))
143.  			continue;
144.  		if(
145.  #ifdef WIZARD
146.  		   (wizard && ep && sroom->doorct != 0) ||
147.  #endif
148.  			sroom->doorct == 1) break;
149.  	}
150.  	if (!sroom->rlit) {
151.  		int x, y;
152.  
153.  		for(x = sroom->lx - 1; x <= sroom->hx + 1; x++)
154.  		for(y = sroom->ly - 1; y <= sroom->hy + 1; y++)
155.  			levl[x][y].lit = 1;
156.  		sroom->rlit = 1;
157.  	}
158.  
159.  	if(i < 0) {			/* shoptype not yet determined */
160.  	    register int j;
161.  
162.  	    /* pick a shop type at random */
163.  	    for (j = rnd(100), i = 0; (j -= shtypes[i].prob) > 0; i++)
164.  		continue;
165.  
166.  	    /* big rooms cannot be wand or book shops,
167.  	     * - so make them general stores
168.  	     */
169.  	    if(isbig(sroom) && (shtypes[i].symb == WAND_CLASS
170.  				|| shtypes[i].symb == SPBOOK_CLASS)) i = 0;
171.  	}
172.  	sroom->rtype = SHOPBASE + i;
173.  
174.  	/* set room bits before stocking the shop */
175.  #ifdef SPECIALIZATION
176.  	topologize(sroom, FALSE); /* doesn't matter - this is a special room */
177.  #else
178.  	topologize(sroom);
179.  #endif
180.  
181.  	/* stock the room with a shopkeeper and artifacts */
182.  	stock_room(i, sroom);
183.  }
184.  

pick_room Edit

185.  STATIC_OVL struct mkroom *
186.  pick_room(strict)
187.  register boolean strict;
188.  /* pick an unused room, preferably with only one door */
189.  {
190.  	register struct mkroom *sroom;
191.  	register int i = nroom;
192.  
193.  	for(sroom = &rooms[rn2(nroom)]; i--; sroom++) {
194.  		if(sroom == &rooms[nroom])
195.  			sroom = &rooms[0];
196.  		if(sroom->hx < 0)
197.  			return (struct mkroom *)0;
198.  		if(sroom->rtype != OROOM)	continue;
199.  		if(!strict) {
200.  		    if(has_upstairs(sroom) || (has_dnstairs(sroom) && rn2(3)))
201.  			continue;
202.  		} else if(has_upstairs(sroom) || has_dnstairs(sroom))
203.  			continue;
204.  		if(sroom->doorct == 1 || !rn2(5)
205.  #ifdef WIZARD
206.  						|| wizard
207.  #endif
208.  							)
209.  			return sroom;
210.  	}
211.  	return (struct mkroom *)0;
212.  }
213.  

mkzoo Edit

214.  STATIC_OVL void
215.  mkzoo(type)
216.  int type;
217.  {
218.  	register struct mkroom *sroom;
219.  
220.  	if ((sroom = pick_room(FALSE)) != 0) {
221.  		sroom->rtype = type;
222.  		fill_zoo(sroom);
223.  	}
224.  }
225.  

fill_zoo Edit

226.  void
227.  fill_zoo(sroom)
228.  struct mkroom *sroom;
229.  {
230.  	struct monst *mon;
231.  	register int sx,sy,i;
232.  	int sh, tx, ty, goldlim, type = sroom->rtype;
233.  	int rmno = (sroom - rooms) + ROOMOFFSET;
234.  	coord mm;
235.  
236.  #ifdef GCC_WARN
237.  	tx = ty = goldlim = 0;
238.  #endif
239.  
240.  	sh = sroom->fdoor;
241.  	switch(type) {
242.  	    case COURT:
243.  		if(level.flags.is_maze_lev) {
244.  		    for(tx = sroom->lx; tx <= sroom->hx; tx++)
245.  			for(ty = sroom->ly; ty <= sroom->hy; ty++)
246.  			    if(IS_THRONE(levl[tx][ty].typ))
247.  				goto throne_placed;
248.  		}
249.  		i = 100;
250.  		do {	/* don't place throne on top of stairs */
251.  			(void) somexy(sroom, &mm);
252.  			tx = mm.x; ty = mm.y;
253.  		} while (occupied((xchar)tx, (xchar)ty) && --i > 0);
254.  	    throne_placed:
255.  		/* TODO: try to ensure the enthroned monster is an M2_PRINCE */
256.  		break;
257.  	    case BEEHIVE:
258.  		tx = sroom->lx + (sroom->hx - sroom->lx + 1)/2;
259.  		ty = sroom->ly + (sroom->hy - sroom->ly + 1)/2;
260.  		if(sroom->irregular) {
261.  		    /* center might not be valid, so put queen elsewhere */
262.  		    if ((int) levl[tx][ty].roomno != rmno ||
263.  			    levl[tx][ty].edge) {
264.  			(void) somexy(sroom, &mm);
265.  			tx = mm.x; ty = mm.y;
266.  		    }
267.  		}
268.  		break;
269.  	    case ZOO:
270.  	    case LEPREHALL:
271.  		goldlim = 500 * level_difficulty();
272.  		break;
273.  	}
274.  	for(sx = sroom->lx; sx <= sroom->hx; sx++)
275.  	    for(sy = sroom->ly; sy <= sroom->hy; sy++) {
276.  		if(sroom->irregular) {
277.  		    if ((int) levl[sx][sy].roomno != rmno ||
278.  			  levl[sx][sy].edge ||
279.  			  (sroom->doorct &&
280.  			   distmin(sx, sy, doors[sh].x, doors[sh].y) <= 1))
281.  			continue;
282.  		} else if(!SPACE_POS(levl[sx][sy].typ) ||
283.  			  (sroom->doorct &&
284.  			   ((sx == sroom->lx && doors[sh].x == sx-1) ||
285.  			    (sx == sroom->hx && doors[sh].x == sx+1) ||
286.  			    (sy == sroom->ly && doors[sh].y == sy-1) ||
287.  			    (sy == sroom->hy && doors[sh].y == sy+1))))
288.  		    continue;
289.  		/* don't place monster on explicitly placed throne */
290.  		if(type == COURT && IS_THRONE(levl[sx][sy].typ))
291.  		    continue;
292.  		mon = makemon(
293.  		    (type == COURT) ? courtmon() :
294.  		    (type == BARRACKS) ? squadmon() :
295.  		    (type == MORGUE) ? morguemon() :
296.  		    (type == BEEHIVE) ?
297.  			(sx == tx && sy == ty ? &mons[PM_QUEEN_BEE] :
298.  			 &mons[PM_KILLER_BEE]) :
299.  		    (type == LEPREHALL) ? &mons[PM_LEPRECHAUN] :
300.  		    (type == COCKNEST) ? &mons[PM_COCKATRICE] :
301.  		    (type == ANTHOLE) ? antholemon() :
302.  		    (struct permonst *) 0,
303.  		   sx, sy, NO_MM_FLAGS);
304.  		if(mon) {
305.  			mon->msleeping = 1;
306.  			if (type==COURT && mon->mpeaceful) {
307.  				mon->mpeaceful = 0;
308.  				set_malign(mon);
309.  			}
310.  		}
311.  		switch(type) {
312.  		    case ZOO:
313.  		    case LEPREHALL:
314.  			if(sroom->doorct)
315.  			{
316.  			    int distval = dist2(sx,sy,doors[sh].x,doors[sh].y);
317.  			    i = sq(distval);
318.  			}
319.  			else
320.  			    i = goldlim;
321.  			if(i >= goldlim) i = 5*level_difficulty();
322.  			goldlim -= i;
323.  			(void) mkgold((long) rn1(i, 10), sx, sy);
324.  			break;
325.  		    case MORGUE:
326.  			if(!rn2(5))
327.  			    (void) mk_tt_object(CORPSE, sx, sy);
328.  			if(!rn2(10))	/* lots of treasure buried with dead */
329.  			    (void) mksobj_at((rn2(3)) ? LARGE_BOX : CHEST,
330.  					     sx, sy, TRUE, FALSE);
331.  			if (!rn2(5))
332.  			    make_grave(sx, sy, (char *)0);
333.  			break;
334.  		    case BEEHIVE:
335.  			if(!rn2(3))
336.  			    (void) mksobj_at(LUMP_OF_ROYAL_JELLY,
337.  					     sx, sy, TRUE, FALSE);
338.  			break;
339.  		    case BARRACKS:
340.  			if(!rn2(20))	/* the payroll and some loot */
341.  			    (void) mksobj_at((rn2(3)) ? LARGE_BOX : CHEST,
342.  					     sx, sy, TRUE, FALSE);
343.  			break;
344.  		    case COCKNEST:
345.  			if(!rn2(3)) {
346.  			    struct obj *sobj = mk_tt_object(STATUE, sx, sy);
347.  
348.  			    if (sobj) {
349.  				for (i = rn2(5); i; i--)
350.  				    (void) add_to_container(sobj,
351.  						mkobj(RANDOM_CLASS, FALSE));
352.  				sobj->owt = weight(sobj);
353.  			    }
354.  			}
355.  			break;
356.  		    case ANTHOLE:
357.  			if(!rn2(3))
358.  			    (void) mkobj_at(FOOD_CLASS, sx, sy, FALSE);
359.  			break;
360.  		}
361.  	    }
362.  	switch (type) {
363.  	      case COURT:
364.  		{
365.  		  struct obj *chest;
366.  		  levl[tx][ty].typ = THRONE;
367.  		  (void) somexy(sroom, &mm);
368.  		  (void) mkgold((long) rn1(50 * level_difficulty(),10), mm.x, mm.y);
369.  		  /* the royal coffers */
370.  		  chest = mksobj_at(CHEST, mm.x, mm.y, TRUE, FALSE);
371.  		  chest->spe = 2; /* so it can be found later */
372.  		  level.flags.has_court = 1;
373.  		  break;
374.  		}
375.  	      case BARRACKS:
376.  		  level.flags.has_barracks = 1;
377.  		  break;
378.  	      case ZOO:
379.  		  level.flags.has_zoo = 1;
380.  		  break;
381.  	      case MORGUE:
382.  		  level.flags.has_morgue = 1;
383.  		  break;
384.  	      case SWAMP:
385.  		  level.flags.has_swamp = 1;
386.  		  break;
387.  	      case BEEHIVE:
388.  		  level.flags.has_beehive = 1;
389.  		  break;
390.  	}
391.  }
392.  

mkundead Edit

393.  /* make a swarm of undead around mm */
394.  void
395.  mkundead(mm, revive_corpses, mm_flags)
396.  coord *mm;
397.  boolean revive_corpses;
398.  int mm_flags;
399.  {
400.  	int cnt = (level_difficulty() + 1)/10 + rnd(5);
401.  	struct permonst *mdat;
402.  	struct obj *otmp;
403.  	coord cc;
404.  
405.  	while (cnt--) {
406.  	    mdat = morguemon();
407.  	    if (enexto(&cc, mm->x, mm->y, mdat) &&
408.  		    (!revive_corpses ||
409.  		     !(otmp = sobj_at(CORPSE, cc.x, cc.y)) ||
410.  		     !revive(otmp)))
411.  		(void) makemon(mdat, cc.x, cc.y, mm_flags);
412.  	}
413.  	level.flags.graveyard = TRUE;	/* reduced chance for undead corpse */
414.  }
415.  

morguemon Edit

416.  STATIC_OVL struct permonst *
417.  morguemon()
418.  {
419.  	register int i = rn2(100), hd = rn2(level_difficulty());
420.  
421.  	if(hd > 10 && i < 10)
422.  		return((Inhell || In_endgame(&u.uz)) ? mkclass(S_DEMON,0) :
423.  						       &mons[ndemon(A_NONE)]);
424.  	if(hd > 8 && i > 85)
425.  		return(mkclass(S_VAMPIRE,0));
426.  
427.  	return((i < 20) ? &mons[PM_GHOST]
428.  			: (i < 40) ? &mons[PM_WRAITH] : mkclass(S_ZOMBIE,0));
429.  }
430.  

antholemon Edit

431.  STATIC_OVL struct permonst *
432.  antholemon()
433.  {
434.  	int mtyp;
435.  
436.  	/* Same monsters within a level, different ones between levels */
437.  	switch ((level_difficulty() + ((long)u.ubirthday)) % 3) {
438.  	default:	mtyp = PM_GIANT_ANT; break;
439.  	case 0:		mtyp = PM_SOLDIER_ANT; break;
440.  	case 1:		mtyp = PM_FIRE_ANT; break;
441.  	}
442.  	return ((mvitals[mtyp].mvflags & G_GONE) ?
443.  			(struct permonst *)0 : &mons[mtyp]);
444.  }
445.  

mkswamp Edit

446.  STATIC_OVL void
447.  mkswamp()	/* Michiel Huisjes & Fred de Wilde */
448.  {
449.  	register struct mkroom *sroom;
450.  	register int sx,sy,i,eelct = 0;
451.  
452.  	for(i=0; i<5; i++) {		/* turn up to 5 rooms swampy */
453.  		sroom = &rooms[rn2(nroom)];
454.  		if(sroom->hx < 0 || sroom->rtype != OROOM ||
455.  		   has_upstairs(sroom) || has_dnstairs(sroom))
456.  			continue;
457.  
458.  		/* satisfied; make a swamp */
459.  		sroom->rtype = SWAMP;
460.  		for(sx = sroom->lx; sx <= sroom->hx; sx++)
461.  		for(sy = sroom->ly; sy <= sroom->hy; sy++)
462.  		if(!OBJ_AT(sx, sy) &&
463.  		   !MON_AT(sx, sy) && !t_at(sx,sy) && !nexttodoor(sx,sy)) {
464.  		    if((sx+sy)%2) {
465.  			levl[sx][sy].typ = POOL;
466.  			if(!eelct || !rn2(4)) {
467.  			    /* mkclass() won't do, as we might get kraken */
468.  			    (void) makemon(rn2(5) ? &mons[PM_GIANT_EEL]
469.  						  : rn2(2) ? &mons[PM_PIRANHA]
470.  						  : &mons[PM_ELECTRIC_EEL],
471.  						sx, sy, NO_MM_FLAGS);
472.  			    eelct++;
473.  			}
474.  		    } else
475.  			if(!rn2(4))	/* swamps tend to be moldy */
476.  			    (void) makemon(mkclass(S_FUNGUS,0),
477.  						sx, sy, NO_MM_FLAGS);
478.  		}
479.  		level.flags.has_swamp = 1;
480.  	}
481.  }
482.  

shrine_pos Edit

483.  STATIC_OVL coord *
484.  shrine_pos(roomno)
485.  int roomno;
486.  {
487.  	static coord buf;
488.  	struct mkroom *troom = &rooms[roomno - ROOMOFFSET];
489.  
490.  	buf.x = troom->lx + ((troom->hx - troom->lx) / 2);
491.  	buf.y = troom->ly + ((troom->hy - troom->ly) / 2);
492.  	return(&buf);
493.  }
494.  

mktemple Edit

495.  STATIC_OVL void
496.  mktemple()
497.  {
498.  	register struct mkroom *sroom;
499.  	coord *shrine_spot;
500.  	register struct rm *lev;
501.  
502.  	if(!(sroom = pick_room(TRUE))) return;
503.  
504.  	/* set up Priest and shrine */
505.  	sroom->rtype = TEMPLE;
506.  	/*
507.  	 * In temples, shrines are blessed altars
508.  	 * located in the center of the room
509.  	 */
510.  	shrine_spot = shrine_pos((sroom - rooms) + ROOMOFFSET);
511.  	lev = &levl[shrine_spot->x][shrine_spot->y];
512.  	lev->typ = ALTAR;
513.  	lev->altarmask = induced_align(80);
514.  	priestini(&u.uz, sroom, shrine_spot->x, shrine_spot->y, FALSE);
515.  	lev->altarmask |= AM_SHRINE;
516.  	level.flags.has_temple = 1;
517.  }
518.  

nexttodoor Edit

519.  boolean
520.  nexttodoor(sx,sy)
521.  register int sx, sy;
522.  {
523.  	register int dx, dy;
524.  	register struct rm *lev;
525.  	for(dx = -1; dx <= 1; dx++) for(dy = -1; dy <= 1; dy++) {
526.  		if(!isok(sx+dx, sy+dy)) continue;
527.  		if(IS_DOOR((lev = &levl[sx+dx][sy+dy])->typ) ||
528.  		    lev->typ == SDOOR)
529.  			return(TRUE);
530.  	}
531.  	return(FALSE);
532.  }
533.  

has_dnstairs Edit

534.  boolean
535.  has_dnstairs(sroom)
536.  register struct mkroom *sroom;
537.  {
538.  	if (sroom == dnstairs_room)
539.  		return TRUE;
540.  	if (sstairs.sx && !sstairs.up)
541.  		return((boolean)(sroom == sstairs_room));
542.  	return FALSE;
543.  }
544.  

has_upstairs Edit

545.  boolean
546.  has_upstairs(sroom)
547.  register struct mkroom *sroom;
548.  {
549.  	if (sroom == upstairs_room)
550.  		return TRUE;
551.  	if (sstairs.sx && sstairs.up)
552.  		return((boolean)(sroom == sstairs_room));
553.  	return FALSE;
554.  }
555.  
556.  #endif /* OVLB */
557.  #ifdef OVL0
558.  

somex Edit

559.  int
560.  somex(croom)
561.  register struct mkroom *croom;
562.  {
563.  	return rn2(croom->hx-croom->lx+1) + croom->lx;
564.  }
565.  

somey Edit

566.  int
567.  somey(croom)
568.  register struct mkroom *croom;
569.  {
570.  	return rn2(croom->hy-croom->ly+1) + croom->ly;
571.  }
572.  

inside_room Edit

573.  boolean
574.  inside_room(croom, x, y)
575.  struct mkroom *croom;
576.  xchar x, y;
577.  {
578.  	return((boolean)(x >= croom->lx-1 && x <= croom->hx+1 &&
579.  		y >= croom->ly-1 && y <= croom->hy+1));
580.  }
581.  

somexy Edit

582.  boolean
583.  somexy(croom, c)
584.  struct mkroom *croom;
585.  coord *c;
586.  {
587.  	int try_cnt = 0;
588.  	int i;
589.  
590.  	if (croom->irregular) {
591.  	    i = (croom - rooms) + ROOMOFFSET;
592.  
593.  	    while(try_cnt++ < 100) {
594.  		c->x = somex(croom);
595.  		c->y = somey(croom);
596.  		if (!levl[c->x][c->y].edge &&
597.  			(int) levl[c->x][c->y].roomno == i)
598.  		    return TRUE;
599.  	    }
600.  	    /* try harder; exhaustively search until one is found */
601.  	    for(c->x = croom->lx; c->x <= croom->hx; c->x++)
602.  		for(c->y = croom->ly; c->y <= croom->hy; c->y++)
603.  		    if (!levl[c->x][c->y].edge &&
604.  			    (int) levl[c->x][c->y].roomno == i)
605.  			return TRUE;
606.  	    return FALSE;
607.  	}
608.  
609.  	if (!croom->nsubrooms) {
610.  		c->x = somex(croom);
611.  		c->y = somey(croom);
612.  		return TRUE;
613.  	}
614.  
615.  	/* Check that coords doesn't fall into a subroom or into a wall */
616.  
617.  	while(try_cnt++ < 100) {
618.  		c->x = somex(croom);
619.  		c->y = somey(croom);
620.  		if (IS_WALL(levl[c->x][c->y].typ))
621.  		    continue;
622.  		for(i=0 ; i<croom->nsubrooms;i++)
623.  		    if(inside_room(croom->sbrooms[i], c->x, c->y))
624.  			goto you_lose;
625.  		break;
626.  you_lose:	;
627.  	}
628.  	if (try_cnt >= 100)
629.  	    return FALSE;
630.  	return TRUE;
631.  }
632.  

search_special Edit

633.  /*
634.   * Search for a special room given its type (zoo, court, etc...)
635.   *	Special values :
636.   *		- ANY_SHOP
637.   *		- ANY_TYPE
638.   */
639.  
640.  struct mkroom *
641.  search_special(type)
642.  schar type;
643.  {
644.  	register struct mkroom *croom;
645.  
646.  	for(croom = &rooms[0]; croom->hx >= 0; croom++)
647.  	    if((type == ANY_TYPE && croom->rtype != OROOM) ||
648.  	       (type == ANY_SHOP && croom->rtype >= SHOPBASE) ||
649.  	       croom->rtype == type)
650.  		return croom;
651.  	for(croom = &subrooms[0]; croom->hx >= 0; croom++)
652.  	    if((type == ANY_TYPE && croom->rtype != OROOM) ||
653.  	       (type == ANY_SHOP && croom->rtype >= SHOPBASE) ||
654.  	       croom->rtype == type)
655.  		return croom;
656.  	return (struct mkroom *) 0;
657.  }
658.  
659.  #endif /* OVL0 */
660.  #ifdef OVLB
661.  

courtmon Edit

662.  struct permonst *
663.  courtmon()
664.  {
665.  	int     i = rn2(60) + rn2(3*level_difficulty());
666.  	if (i > 100)		return(mkclass(S_DRAGON,0));
667.  	else if (i > 95)	return(mkclass(S_GIANT,0));
668.  	else if (i > 85)	return(mkclass(S_TROLL,0));
669.  	else if (i > 75)	return(mkclass(S_CENTAUR,0));
670.  	else if (i > 60)	return(mkclass(S_ORC,0));
671.  	else if (i > 45)	return(&mons[PM_BUGBEAR]);
672.  	else if (i > 30)	return(&mons[PM_HOBGOBLIN]);
673.  	else if (i > 15)	return(mkclass(S_GNOME,0));
674.  	else			return(mkclass(S_KOBOLD,0));
675.  }
676.  

squadmon Edit

677.  #define NSTYPES (PM_CAPTAIN - PM_SOLDIER + 1)
678.  
679.  static struct {
680.      unsigned	pm;
681.      unsigned	prob;
682.  } squadprob[NSTYPES] = {
683.      {PM_SOLDIER, 80}, {PM_SERGEANT, 15}, {PM_LIEUTENANT, 4}, {PM_CAPTAIN, 1}
684.  };
685.  
686.  STATIC_OVL struct permonst *
687.  squadmon()		/* return soldier types. */
688.  {
689.  	int sel_prob, i, cpro, mndx;
690.  
691.  	sel_prob = rnd(80+level_difficulty());
692.  
693.  	cpro = 0;
694.  	for (i = 0; i < NSTYPES; i++) {
695.  	    cpro += squadprob[i].prob;
696.  	    if (cpro > sel_prob) {
697.  		mndx = squadprob[i].pm;
698.  		goto gotone;
699.  	    }
700.  	}
701.  	mndx = squadprob[rn2(NSTYPES)].pm;
702.  gotone:
703.  	if (!(mvitals[mndx].mvflags & G_GONE)) return(&mons[mndx]);
704.  	else			    return((struct permonst *) 0);
705.  }
706.  

save_room Edit

707.  /*
708.   * save_room : A recursive function that saves a room and its subrooms
709.   * (if any).
710.   */
711.  
712.  STATIC_OVL void
713.  save_room(fd, r)
714.  int	fd;
715.  struct mkroom *r;
716.  {
717.  	short i;
718.  	/*
719.  	 * Well, I really should write only useful information instead
720.  	 * of writing the whole structure. That is I should not write
721.  	 * the subrooms pointers, but who cares ?
722.  	 */
723.  	bwrite(fd, (genericptr_t) r, sizeof(struct mkroom));
724.  	for(i=0; i<r->nsubrooms; i++)
725.  	    save_room(fd, r->sbrooms[i]);
726.  }
727.  

save_rooms Edit

728.  /*
729.   * save_rooms : Save all the rooms on disk!
730.   */
731.  
732.  void
733.  save_rooms(fd)
734.  int fd;
735.  {
736.  	short i;
737.  
738.  	/* First, write the number of rooms */
739.  	bwrite(fd, (genericptr_t) &nroom, sizeof(nroom));
740.  	for(i=0; i<nroom; i++)
741.  	    save_room(fd, &rooms[i]);
742.  }
743.  

rest_room Edit

744.  STATIC_OVL void
745.  rest_room(fd, r)
746.  int fd;
747.  struct mkroom *r;
748.  {
749.  	short i;
750.  
751.  	mread(fd, (genericptr_t) r, sizeof(struct mkroom));
752.  	for(i=0; i<r->nsubrooms; i++) {
753.  		r->sbrooms[i] = &subrooms[nsubroom];
754.  		rest_room(fd, &subrooms[nsubroom]);
755.  		subrooms[nsubroom++].resident = (struct monst *)0;
756.  	}
757.  }
758.  

rest_rooms Edit

759.  /*
760.   * rest_rooms : That's for restoring rooms. Read the rooms structure from
761.   * the disk.
762.   */
763.  
764.  void
765.  rest_rooms(fd)
766.  int	fd;
767.  {
768.  	short i;
769.  
770.  	mread(fd, (genericptr_t) &nroom, sizeof(nroom));
771.  	nsubroom = 0;
772.  	for(i = 0; i<nroom; i++) {
773.  	    rest_room(fd, &rooms[i]);
774.  	    rooms[i].resident = (struct monst *)0;
775.  	}
776.  	rooms[nroom].hx = -1;		/* restore ending flags */
777.  	subrooms[nsubroom].hx = -1;
778.  }
779.  #endif /* OVLB */
780.  
781.  /*mkroom.c*/

Also on Fandom

Random Wiki