Fandom

Wikihack

Source:SLASH'EM 0.0.7E7F2/dungeon.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 dungeon.c from the source code of SLASH'EM 0.0.7E7F2. To link to a particular line, write [[SLASH'EM 0.0.7E7F2/dungeon.c#line123]], for example.

The latest source code for vanilla NetHack is at Source code.


The NetHack General Public License applies to screenshots, source code and other content from NetHack.
1.    /*	SCCS Id: @(#)dungeon.c	3.4	1999/10/30	*/
2.    /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
3.    /* NetHack may be freely redistributed.  See license for details. */
4.    
5.    #include "hack.h"
6.    #include "dgn_file.h"
7.    #include "dlb.h"
8.    
9.    #ifdef OVL1
10.   
11.   #define DUNGEON_AREA    FILE_AREA_UNSHARE
12.   #define DUNGEON_FILE	"dungeon"
13.   
14.   #define X_START		"x-strt"
15.   #define X_LOCATE	"x-loca"
16.   #define X_GOAL		"x-goal"
17.   
18.   struct proto_dungeon {
19.   	struct	tmpdungeon tmpdungeon[MAXDUNGEON];
20.   	struct	tmplevel   tmplevel[LEV_LIMIT];
21.   	s_level *final_lev[LEV_LIMIT];	/* corresponding level pointers */
22.   	struct	tmpbranch  tmpbranch[BRANCH_LIMIT];
23.   	int	tmpparent[BRANCH_LIMIT];
24.   
25.   	int	start;	/* starting index of current dungeon sp levels */
26.   	int	n_levs;	/* number of tmplevel entries */
27.   	int	n_brs;	/* number of tmpbranch entries */
28.   };
29.   
30.   int n_dgns;				/* number of dungeons (used here,  */
31.   					/*   and mklev.c)		   */
32.   static branch *branches = (branch *) 0;	/* dungeon branch list		   */
33.   
34.   struct lchoice {
35.   	int idx;
36.   	schar lev[MAXLINFO];
37.   	schar playerlev[MAXLINFO];
38.   	xchar dgn[MAXLINFO];
39.   	char menuletter;
40.   };
41.   
42.   static void FDECL(Fread, (genericptr_t, int, int, dlb *));
43.   STATIC_DCL xchar FDECL(dname_to_dnum, (const char *));
44.   STATIC_DCL int FDECL(find_branch, (const char *, struct proto_dungeon *));
45.   STATIC_DCL int FDECL(level_range, (XCHAR_P,int,int,int,struct proto_dungeon *,int *));
46.   STATIC_DCL xchar FDECL(parent_dlevel, (int, struct proto_dungeon *));
47.   STATIC_DCL int FDECL(correct_branch_type, (struct tmpbranch *));
48.   STATIC_DCL branch *FDECL(add_branch, (int, int, struct proto_dungeon *));
49.   STATIC_DCL void FDECL(add_level, (s_level *));
50.   STATIC_DCL void FDECL(init_level, (int,int,struct proto_dungeon *));
51.   STATIC_DCL int FDECL(possible_places, (int, boolean *, struct proto_dungeon *));
52.   STATIC_DCL xchar FDECL(pick_level, (boolean *, int));
53.   STATIC_DCL boolean FDECL(place_level, (int, struct proto_dungeon *));
54.   #ifdef WIZARD
55.   STATIC_DCL const char *FDECL(br_string, (int));
56.   STATIC_DCL void FDECL(print_branch, (winid, int, int, int, BOOLEAN_P, struct lchoice *));
57.   #endif
58.   
59.   #if defined(DEBUG) || defined(DEBUG_420942)
60.   #define DD	dungeons[i]
61.   STATIC_DCL void NDECL(dumpit);
62.   
63.   STATIC_OVL void
64.   dumpit()
65.   {
66.   	int	i;
67.   	s_level	*x;
68.   	branch *br;
69.   
70.   	for(i = 0; i < n_dgns; i++)  {
71.   	    fprintf(stderr, "\n#%d \"%s\" (%s):\n", i,
72.   				DD.dname, DD.proto);
73.   	    fprintf(stderr, "    num_dunlevs %d, dunlev_ureached %d\n",
74.   				DD.num_dunlevs, DD.dunlev_ureached);
75.   	    fprintf(stderr, "    depth_start %d, ledger_start %d\n",
76.   				DD.depth_start, DD.ledger_start);
77.   	    fprintf(stderr, "    flags:%s%s%s\n",
78.   		    DD.flags.rogue_like ? " rogue_like" : "",
79.   		    DD.flags.maze_like  ? " maze_like"  : "",
80.   		    DD.flags.hellish    ? " hellish"    : "");
81.   	    getchar();
82.   	}
83.   	fprintf(stderr,"\nSpecial levels:\n");
84.   	for(x = sp_levchn; x; x = x->next) {
85.   	    fprintf(stderr, "%s (%d): ", x->proto, x->rndlevs);
86.   	    fprintf(stderr, "on %d, %d; ", x->dlevel.dnum, x->dlevel.dlevel);
87.   	    fprintf(stderr, "flags:%s%s%s%s\n",
88.   		    x->flags.rogue_like	? " rogue_like" : "",
89.   		    x->flags.maze_like  ? " maze_like"  : "",
90.   		    x->flags.hellish    ? " hellish"    : "",
91.   		    x->flags.town       ? " town"       : "");
92.   	    getchar();
93.   	}
94.   	fprintf(stderr,"\nBranches:\n");
95.   	for (br = branches; br; br = br->next) {
96.   	    fprintf(stderr, "%d: %s, end1 %d %d, end2 %d %d, %s\n",
97.   		br->id,
98.   		br->type == BR_STAIR ? "stair" :
99.   		    br->type == BR_NO_END1 ? "no end1" :
100.  		    br->type == BR_NO_END2 ? "no end2" :
101.  		    br->type == BR_PORTAL  ? "portal"  :
102.  					     "unknown",
103.  		br->end1.dnum, br->end1.dlevel,
104.  		br->end2.dnum, br->end2.dlevel,
105.  		br->end1_up ? "end1 up" : "end1 down");
106.  	}
107.  	getchar();
108.  	fprintf(stderr,"\nDone\n");
109.  	getchar();
110.  }
111.  #endif
112.  
113.  /* Save the dungeon structures. */
114.  void
115.  save_dungeon(fd, perform_write, free_data)
116.      int fd;
117.      boolean perform_write, free_data;
118.  {
119.      branch *curr, *next;
120.      int    count;
121.  
122.      if (perform_write) {
123.  	bwrite(fd, (genericptr_t) &n_dgns, sizeof n_dgns);
124.  	bwrite(fd, (genericptr_t) dungeons, sizeof(dungeon) * (unsigned)n_dgns);
125.  	bwrite(fd, (genericptr_t) &dungeon_topology, sizeof dungeon_topology);
126.  	bwrite(fd, (genericptr_t) tune, sizeof tune);
127.  
128.  	for (count = 0, curr = branches; curr; curr = curr->next)
129.  	    count++;
130.  	bwrite(fd, (genericptr_t) &count, sizeof(count));
131.  
132.  	for (curr = branches; curr; curr = curr->next)
133.  	    bwrite(fd, (genericptr_t) curr, sizeof (branch));
134.  
135.  	count = maxledgerno();
136.  	bwrite(fd, (genericptr_t) &count, sizeof count);
137.  	bwrite(fd, (genericptr_t) level_info,
138.  			(unsigned)count * sizeof (struct linfo));
139.  	bwrite(fd, (genericptr_t) &inv_pos, sizeof inv_pos);
140.      }
141.  
142.      if (free_data) {
143.  	for (curr = branches; curr; curr = next) {
144.  	    next = curr->next;
145.  	    free((genericptr_t) curr);
146.  	}
147.  	branches = 0;
148.      }
149.  }
150.  
151.  /* Restore the dungeon structures. */
152.  void
153.  restore_dungeon(fd)
154.      int fd;
155.  {
156.      branch *curr, *last;
157.      int    count, i;
158.  
159.      mread(fd, (genericptr_t) &n_dgns, sizeof(n_dgns));
160.      mread(fd, (genericptr_t) dungeons, sizeof(dungeon) * (unsigned)n_dgns);
161.      mread(fd, (genericptr_t) &dungeon_topology, sizeof dungeon_topology);
162.      mread(fd, (genericptr_t) tune, sizeof tune);
163.  
164.      last = branches = (branch *) 0;
165.  
166.      mread(fd, (genericptr_t) &count, sizeof(count));
167.      for (i = 0; i < count; i++) {
168.  	curr = (branch *) alloc(sizeof(branch));
169.  	mread(fd, (genericptr_t) curr, sizeof(branch));
170.  	curr->next = (branch *) 0;
171.  	if (last)
172.  	    last->next = curr;
173.  	else
174.  	    branches = curr;
175.  	last = curr;
176.      }
177.  
178.      mread(fd, (genericptr_t) &count, sizeof(count));
179.      if (count >= MAXLINFO)
180.  	panic("level information count larger (%d) than allocated size", count);
181.      mread(fd, (genericptr_t) level_info, (unsigned)count*sizeof(struct linfo));
182.      mread(fd, (genericptr_t) &inv_pos, sizeof inv_pos);
183.  }
184.  
185.  static void
186.  Fread(ptr, size, nitems, stream)
187.  	genericptr_t	ptr;
188.  	int	size, nitems;
189.  	dlb	*stream;
190.  {
191.  	int cnt;
192.  
193.  	if((cnt = dlb_fread(ptr, size, nitems, stream)) != nitems) {
194.  	    panic(
195.   "Premature EOF on dungeon description file!\r\nExpected %d bytes - got %d.",
196.  		  (size * nitems), (size * cnt));
197.  	    terminate(EXIT_FAILURE);
198.  	}
199.  }
200.  
201.  STATIC_OVL xchar
202.  dname_to_dnum(s)
203.  const char	*s;
204.  {
205.  	xchar	i;
206.  
207.  	for (i = 0; i < n_dgns; i++)
208.  	    if (!strcmp(dungeons[i].dname, s)) return i;
209.  
210.  	panic("Couldn't resolve dungeon number for name \"%s\".", s);
211.  	/*NOT REACHED*/
212.  	return (xchar)0;
213.  }
214.  
215.  s_level *
216.  find_level(s)
217.  	const char *s;
218.  {
219.  	s_level *curr;
220.  	for(curr = sp_levchn; curr; curr = curr->next)
221.  	    if (!strcmpi(s, curr->proto)) break;
222.  	return curr;
223.  }
224.  
225.  /* Find the branch that links the named dungeon. */
226.  STATIC_OVL int
227.  find_branch(s, pd)
228.  	const char *s;		/* dungeon name */
229.  	struct proto_dungeon *pd;
230.  {
231.  	int i;
232.  
233.  	if (pd) {
234.  	    for (i = 0; i < pd->n_brs; i++)
235.  		if (!strcmp(pd->tmpbranch[i].name, s)) break;
236.  	    if (i == pd->n_brs) panic("find_branch: can't find %s", s);
237.  	} else {
238.  	    /* support for level tport by name */
239.  	    branch *br;
240.  	    const char *dnam;
241.  
242.  	    for (br = branches; br; br = br->next) {
243.  		dnam = dungeons[br->end2.dnum].dname;
244.  		if (!strcmpi(dnam, s) ||
245.  			(!strncmpi(dnam, "The ", 4) && !strcmpi(dnam + 4, s)))
246.  		    break;
247.  	    }
248.  	    i = br ? ((ledger_no(&br->end1) << 8) | ledger_no(&br->end2)) : -1;
249.  	}
250.  	return i;
251.  }
252.  
253.  /*
254.   * Return a starting point and number of successive positions a level
255.   * or dungeon entrance can occupy.
256.   *
257.   * Note: This follows the acouple (instead of the rcouple) rules for a
258.   *	 negative random component (rand < 0).  These rules are found
259.   *	 in dgn_comp.y.  The acouple [absolute couple] section says that
260.   *	 a negative random component means from the (adjusted) base to the
261.   *	 end of the dungeon.
262.   */
263.  STATIC_OVL int
264.  level_range(dgn, base, rand, chain, pd, adjusted_base)
265.  	xchar	dgn;
266.  	int	base, rand, chain;
267.  	struct proto_dungeon *pd;
268.  	int *adjusted_base;
269.  {
270.  	int lmax = dungeons[dgn].num_dunlevs;
271.  
272.  	if (chain >= 0) {		 /* relative to a special level */
273.  	    s_level *levtmp = pd->final_lev[chain];
274.  	    if (!levtmp) panic("level_range: empty chain level!");
275.  
276.  	    base += levtmp->dlevel.dlevel;
277.  	} else {			/* absolute in the dungeon */
278.  	    /* from end of dungeon */
279.  	    if (base < 0) base = (lmax + base + 1);
280.  	}
281.  
282.  	if (base < 1 || base > lmax)
283.  	    panic("level_range: base value out of range");
284.  
285.  	*adjusted_base = base;
286.  
287.  	if (rand == -1) {	/* from base to end of dungeon */
288.  	    return (lmax - base + 1);
289.  	} else if (rand) {
290.  	    /* make sure we don't run off the end of the dungeon */
291.  	    return (((base + rand - 1) > lmax) ? lmax-base+1 : rand);
292.  	} /* else only one choice */
293.  	return 1;
294.  }
295.  
296.  STATIC_OVL xchar
297.  parent_dlevel(i, pd)
298.  	int i;
299.  	struct proto_dungeon *pd;
300.  {
301.  	int j, num, base, dnum = pd->tmpparent[i];
302.  	branch *curr;
303.  
304.  	num = level_range(dnum, pd->tmpbranch[i].lev.base,
305.  					      pd->tmpbranch[i].lev.rand,
306.  					      pd->tmpbranch[i].chain,
307.  					      pd, &base);
308.  
309.  	/* KMH -- Try our best to find a level without an existing branch */
310.  	i = j = rn2(num);
311.  	do {
312.  		if (++i >= num) i = 0;
313.  		for (curr = branches; curr; curr = curr->next)
314.  			if ((curr->end1.dnum == dnum && curr->end1.dlevel == base+i) ||
315.  				(curr->end2.dnum == dnum && curr->end2.dlevel == base+i))
316.  				break;
317.  	} while (curr && i != j);
318.  	return (base + i);
319.  }
320.  
321.  /* Convert from the temporary branch type to the dungeon branch type. */
322.  STATIC_OVL int
323.  correct_branch_type(tbr)
324.      struct tmpbranch *tbr;
325.  {
326.      switch (tbr->type) {
327.  	case TBR_STAIR:		return BR_STAIR;
328.  	case TBR_NO_UP:		return tbr->up ? BR_NO_END1 : BR_NO_END2;
329.  	case TBR_NO_DOWN:	return tbr->up ? BR_NO_END2 : BR_NO_END1;
330.  	case TBR_PORTAL:	return BR_PORTAL;
331.      }
332.      impossible("correct_branch_type: unknown branch type");
333.      return BR_STAIR;
334.  }
335.  
336.  /*
337.   * Add the given branch to the branch list.  The branch list is ordered
338.   * by end1 dungeon and level followed by end2 dungeon and level.  If
339.   * extract_first is true, then the branch is already part of the list
340.   * but needs to be repositioned.
341.   */
342.  void
343.  insert_branch(new_branch, extract_first)
344.     branch *new_branch;
345.     boolean extract_first;
346.  {
347.      branch *curr, *prev;
348.      long new_val, curr_val, prev_val;
349.  
350.      if (extract_first) {
351.  	for (prev = 0, curr = branches; curr; prev = curr, curr = curr->next)
352.  	    if (curr == new_branch) break;
353.  
354.  	if (!curr) panic("insert_branch: not found");
355.  	if (prev)
356.  	    prev->next = curr->next;
357.  	else
358.  	    branches = curr->next;
359.      }
360.      new_branch->next = (branch *) 0;
361.  
362.  /* Convert the branch into a unique number so we can sort them. */
363.  #define branch_val(bp) \
364.  	((((long)(bp)->end1.dnum * (MAXLEVEL+1) + \
365.  	  (long)(bp)->end1.dlevel) * (MAXDUNGEON+1) * (MAXLEVEL+1)) + \
366.  	 ((long)(bp)->end2.dnum * (MAXLEVEL+1) + (long)(bp)->end2.dlevel))
367.  
368.      /*
369.       * Insert the new branch into the correct place in the branch list.
370.       */
371.      prev = (branch *) 0;
372.      prev_val = -1;
373.      new_val = branch_val(new_branch);
374.      for (curr = branches; curr;
375.  		    prev_val = curr_val, prev = curr, curr = curr->next) {
376.  	curr_val = branch_val(curr);
377.  	if (prev_val < new_val && new_val <= curr_val) break;
378.      }
379.      if (prev) {
380.  	new_branch->next = curr;
381.  	prev->next = new_branch;
382.      } else {
383.  	new_branch->next = branches;
384.  	branches = new_branch;
385.      }
386.  }
387.  
388.  /* Add a dungeon branch to the branch list. */
389.  STATIC_OVL branch *
390.  add_branch(dgn, branch_num, pd)
391.      int dgn, branch_num;
392.      struct proto_dungeon *pd;
393.  {
394.      static int branch_id = 0;
395.      branch *new_branch;
396.      int entry_lev;
397.  
398.      new_branch = (branch *) alloc(sizeof(branch));
399.      new_branch->next = (branch *) 0;
400.      new_branch->id = branch_id++;
401.      new_branch->type = correct_branch_type(&pd->tmpbranch[branch_num]);
402.      new_branch->end1.dnum = pd->tmpparent[branch_num];
403.      new_branch->end1.dlevel = parent_dlevel(branch_num, pd);
404.      new_branch->end2.dnum = dgn;
405.      /*
406.       * Calculate the entry level for target dungeon.  The pd.tmpbranch entry
407.       * value means:
408.       *		< 0	from bottom (-1 == bottom level)
409.       *		  0	default (top)
410.       *		> 0	actual level (1 = top)
411.       */
412.      if (pd->tmpbranch[branch_num].entry_lev < 0) {
413.  	entry_lev = dungeons[dgn].num_dunlevs +	pd->tmpbranch[branch_num].entry_lev + 1;
414.  	if (entry_lev <= 0) entry_lev = 1;
415.      } else if (pd->tmpbranch[dgn].entry_lev > 0) {
416.  	entry_lev = pd->tmpbranch[branch_num].entry_lev;
417.  	if (entry_lev > dungeons[dgn].num_dunlevs)
418.  	    entry_lev = dungeons[dgn].num_dunlevs;
419.      }
420.      else
421.  	entry_lev = 1;	/* defaults to top level */
422.  
423.      new_branch->end2.dlevel = entry_lev;
424.      new_branch->end1_up = pd->tmpbranch[branch_num].up ? TRUE : FALSE;
425.  
426.      insert_branch(new_branch, FALSE);
427.      return new_branch;
428.  }
429.  
430.  /*
431.   * Add new level to special level chain.  Insert it in level order with the
432.   * other levels in this dungeon.  This assumes that we are never given a
433.   * level that has a dungeon number less than the dungeon number of the
434.   * last entry.
435.   */
436.  STATIC_OVL void
437.  add_level(new_lev)
438.      s_level *new_lev;
439.  {
440.  	s_level *prev, *curr;
441.  
442.  	prev = (s_level *) 0;
443.  	for (curr = sp_levchn; curr; curr = curr->next) {
444.  	    if (curr->dlevel.dnum == new_lev->dlevel.dnum &&
445.  		    curr->dlevel.dlevel > new_lev->dlevel.dlevel)
446.  		break;
447.  	    prev = curr;
448.  	}
449.  	if (!prev) {
450.  	    new_lev->next = sp_levchn;
451.  	    sp_levchn = new_lev;
452.  	} else {
453.  	    new_lev->next = curr;
454.  	    prev->next = new_lev;
455.  	}
456.  }
457.  
458.  STATIC_OVL void
459.  init_level(dgn, proto_index, pd)
460.  	int dgn, proto_index;
461.  	struct proto_dungeon *pd;
462.  {
463.  	s_level	*new_level;
464.  	struct tmplevel *tlevel = &pd->tmplevel[proto_index];
465.  
466.  	pd->final_lev[proto_index] = (s_level *) 0; /* no "real" level */
467.  #ifdef WIZARD
468.  /*      if (!wizard)   */
469.  #endif
470.  	    if (tlevel->chance <= rn2(100)) return;
471.  
472.  	pd->final_lev[proto_index] = new_level =
473.  					(s_level *) alloc(sizeof(s_level));
474.  	/* load new level with data */
475.  	Strcpy(new_level->proto, tlevel->name);
476.  	new_level->boneid = tlevel->boneschar;
477.  	new_level->dlevel.dnum = dgn;
478.  	new_level->dlevel.dlevel = 0;	/* for now */
479.  
480.  	new_level->flags.town = !!(tlevel->flags & TOWN);
481.  	new_level->flags.hellish = !!(tlevel->flags & HELLISH);
482.  	new_level->flags.maze_like = !!(tlevel->flags & MAZELIKE);
483.  	new_level->flags.rogue_like = !!(tlevel->flags & ROGUELIKE);
484.  	new_level->flags.align = ((tlevel->flags & D_ALIGN_MASK) >> 4);
485.  	if (!new_level->flags.align) 
486.  	    new_level->flags.align =
487.  		((pd->tmpdungeon[dgn].flags & D_ALIGN_MASK) >> 4);
488.  
489.  	new_level->rndlevs = tlevel->rndlevs;
490.  	new_level->next    = (s_level *) 0;
491.  }
492.  
493.  STATIC_OVL int
494.  possible_places(idx, map, pd)
495.      int idx;		/* prototype index */
496.      boolean *map;	/* array MAXLEVEL+1 in length */
497.      struct proto_dungeon *pd;
498.  {
499.      int i, start, count;
500.      s_level *lev = pd->final_lev[idx];
501.  
502.      /* init level possibilities */
503.      for (i = 0; i <= MAXLEVEL; i++) map[i] = FALSE;
504.  
505.      /* get base and range and set those entried to true */
506.      count = level_range(lev->dlevel.dnum, pd->tmplevel[idx].lev.base,
507.  					pd->tmplevel[idx].lev.rand,
508.  					pd->tmplevel[idx].chain,
509.  					pd, &start);
510.      for (i = start; i < start+count; i++)
511.  	map[i] = TRUE;
512.  
513.      /* mark off already placed levels */
514.      for (i = pd->start; i < idx; i++) {
515.  	if (pd->final_lev[i] && map[pd->final_lev[i]->dlevel.dlevel]) {
516.  	    map[pd->final_lev[i]->dlevel.dlevel] = FALSE;
517.  	    --count;
518.  	}
519.      }
520.  
521.      return count;
522.  }
523.  
524.  /* Pick the nth TRUE entry in the given boolean array. */
525.  STATIC_OVL xchar
526.  pick_level(map, nth)
527.      boolean *map;	/* an array MAXLEVEL+1 in size */
528.      int nth;
529.  {
530.      int i;
531.      for (i = 1; i <= MAXLEVEL; i++)
532.  	if (map[i] && !nth--) return (xchar) i;
533.      panic("pick_level:  ran out of valid levels");
534.      return 0;
535.  }
536.  
537.  #ifdef DDEBUG
538.  static void FDECL(indent,(int));
539.  
540.  static void
541.  indent(d)
542.  int d;
543.  {
544.      while (d-- > 0) fputs("    ", stderr);
545.  }
546.  #endif
547.  
548.  /*
549.   * Place a level.  First, find the possible places on a dungeon map
550.   * template.  Next pick one.  Then try to place the next level.  If
551.   * sucessful, we're done.  Otherwise, try another (and another) until
552.   * all possible places have been tried.  If all possible places have
553.   * been exausted, return false.
554.   */
555.  STATIC_OVL boolean
556.  place_level(proto_index, pd)
557.      int proto_index;
558.      struct proto_dungeon *pd;
559.  {
560.      boolean map[MAXLEVEL+1];	/* valid levels are 1..MAXLEVEL inclusive */
561.      s_level *lev;
562.      int npossible;
563.  #ifdef DDEBUG
564.      int i;
565.  #endif
566.  
567.      if (proto_index == pd->n_levs) return TRUE;	/* at end of proto levels */
568.  
569.      lev = pd->final_lev[proto_index];
570.  
571.      /* No level created for this prototype, goto next. */
572.      if (!lev) return place_level(proto_index+1, pd);
573.  
574.      npossible = possible_places(proto_index, map, pd);
575.  
576.      for (; npossible; --npossible) {
577.  	lev->dlevel.dlevel = pick_level(map, rn2(npossible));
578.  #ifdef DDEBUG
579.  	indent(proto_index-pd->start);
580.  	fprintf(stderr,"%s: trying %d [ ", lev->proto, lev->dlevel.dlevel);
581.  	for (i = 1; i <= MAXLEVEL; i++)
582.  	    if (map[i]) fprintf(stderr,"%d ", i);
583.  	fprintf(stderr,"]\n");
584.  #endif
585.  	if (place_level(proto_index+1, pd)) return TRUE;
586.  	map[lev->dlevel.dlevel] = FALSE;	/* this choice didn't work */
587.      }
588.  #ifdef DDEBUG
589.      indent(proto_index-pd->start);
590.      fprintf(stderr,"%s: failed\n", lev->proto);
591.  #endif
592.      return FALSE;
593.  }
594.  
595.  
596.  struct level_map {
597.  	const char *lev_name;
598.  	d_level *lev_spec;
599.  } level_map[] = {
600.  	{ "air",	&air_level },
601.  	{ "asmodeus",	&asmodeus_level },
602.  	{ "demogorg",   &demogorgon_level },
603.  	{ "geryon",     &geryon_level },
604.  	{ "dispater",   &dispater_level },
605.  	{ "yeenoghu",   &yeenoghu_level },
606.  	{ "astral",	&astral_level },
607.  	{ "baalz",	&baalzebub_level },
608.  	{ "bigroom",	&bigroom_level },
609.  	{ "castle",	&stronghold_level },
610.  	{ "earth",	&earth_level },
611.  	{ "fakewiz1",	&portal_level },
612.  	{ "fire",	&fire_level },
613.  	{ "juiblex",	&juiblex_level },
614.  	{ "knox",	&knox_level },
615.  #ifdef BLACKMARKET        
616.  	{ "blkmar",     &blackmarket_level },
617.  #endif /* BLACKMARKET */
618.  	{ "medusa",	&medusa_level },
619.  	{ "mine_end",   &mineend_level },        
620.  	{ "oracle",	&oracle_level },
621.  	{ "orcus",	&orcus_level },
622.  #ifdef REINCARNATION
623.  	{ "rogue",	&rogue_level },
624.  #endif
625.  	{ "sanctum",	&sanctum_level },
626.  	{ "valley",	&valley_level },
627.  	{ "water",	&water_level },
628.  	{ "wizard1",	&wiz1_level },
629.  	{ "wizard2",	&wiz2_level },
630.  	{ "wizard3",	&wiz3_level },
631.  	{ "nightmar",	&lawful_quest_level },
632.  	{ "beholder",	&neutral_quest_level },
633.  	{ "lich",	&chaotic_quest_level },
634.  	{ X_START,	&qstart_level },
635.  	{ X_LOCATE,	&qlocate_level },
636.  	{ X_GOAL,	&nemesis_level },
637.  	{ "",		(d_level *)0 }
638.  };
639.  
640.  void
641.  init_dungeons()
642.  {
643.  	dlb	*dgn_file;
644.  	register int i, cl = 0, cb = 0;
645.  	register s_level *x;
646.  	struct proto_dungeon pd;
647.  	struct level_map *lev_map;
648.  	struct version_info vers_info;
649.  
650.  	/* [ALI] Cope with being called more than once. The GTK interface
651.  	 * can currently do this, although it really should use popen().
652.  	 */
653.  	free_dungeons();
654.  
655.  	pd.n_levs = pd.n_brs = 0;
656.  
657.  	dgn_file = dlb_fopen_area(DUNGEON_AREA, DUNGEON_FILE, RDBMODE);
658.  	if (!dgn_file) {
659.  	    char tbuf[BUFSZ];
660.  	    Sprintf(tbuf, "Cannot open dungeon description - \"%s",
661.  		DUNGEON_FILE);
662.  #ifdef DLBRSRC /* using a resource from the executable */
663.  	    Strcat(tbuf, "\" resource!");
664.  #else /* using a file or DLB file */
665.  # if defined(DLB)
666.  	    Strcat(tbuf, "\" from ");
667.  #  ifdef PREFIXES_IN_USE
668.  	    Strcat(tbuf, "\n\"");
669.  	    if (fqn_prefix[DATAPREFIX]) Strcat(tbuf, fqn_prefix[DATAPREFIX]);
670.  #  else
671.  	    Strcat(tbuf, "\"");
672.  #  endif
673.  	    Strcat(tbuf, DLBFILE);
674.  # endif
675.  	    Strcat(tbuf, "\" file!");
676.  #endif
677.  #ifdef WIN32
678.  	    interject_assistance(1, INTERJECT_PANIC, (genericptr_t)tbuf,
679.  				 (genericptr_t)fqn_prefix[DATAPREFIX]);
680.  #endif
681.  	    panic(tbuf);
682.  	}
683.  
684.  	/* validate the data's version against the program's version */
685.  	Fread((genericptr_t) &vers_info, sizeof vers_info, 1, dgn_file);
686.  	/* we'd better clear the screen now, since when error messages come from
687.  	 * check_version() they will be printed using pline(), which doesn't
688.  	 * mix with the raw messages that might be already on the screen
689.  	 */
690.  	if (iflags.window_inited) clear_nhwindow(WIN_MAP);
691.  	if (!check_version(&vers_info, DUNGEON_FILE, TRUE))
692.  	    panic("Dungeon description not valid.");
693.  
694.  	/*
695.  	 * Read in each dungeon and transfer the results to the internal
696.  	 * dungeon arrays.
697.  	 */
698.  	sp_levchn = (s_level *) 0;
699.  	Fread((genericptr_t)&n_dgns, sizeof(int), 1, dgn_file);
700.  	if (n_dgns >= MAXDUNGEON)
701.  	    panic("init_dungeons: too many dungeons");
702.  
703.  	for (i = 0; i < n_dgns; i++) {
704.  	    Fread((genericptr_t)&pd.tmpdungeon[i],
705.  				    sizeof(struct tmpdungeon), 1, dgn_file);
706.  #ifdef WIZARD
707.  	    if(!wizard)
708.  #endif
709.  	      if(pd.tmpdungeon[i].chance && (pd.tmpdungeon[i].chance <= rn2(100))) {
710.  		int j;
711.  
712.  		/* skip over any levels or branches */
713.  		for(j = 0; j < pd.tmpdungeon[i].levels; j++)
714.  		    Fread((genericptr_t)&pd.tmplevel[cl], sizeof(struct tmplevel),
715.  							1, dgn_file);
716.  
717.  		for(j = 0; j < pd.tmpdungeon[i].branches; j++)
718.  		    Fread((genericptr_t)&pd.tmpbranch[cb],
719.  					sizeof(struct tmpbranch), 1, dgn_file);
720.  		n_dgns--; i--;
721.  		continue;
722.  	      }
723.  
724.  	    Strcpy(dungeons[i].dname, pd.tmpdungeon[i].name);
725.  	    Strcpy(dungeons[i].proto, pd.tmpdungeon[i].protoname);
726.  	    dungeons[i].boneid = pd.tmpdungeon[i].boneschar;
727.  
728.  	    if(pd.tmpdungeon[i].lev.rand)
729.  		dungeons[i].num_dunlevs = (xchar)rn1(pd.tmpdungeon[i].lev.rand,
730.  						     pd.tmpdungeon[i].lev.base);
731.  	    else dungeons[i].num_dunlevs = (xchar)pd.tmpdungeon[i].lev.base;
732.  
733.  	    if(!i) {
734.  		dungeons[i].ledger_start = 0;
735.  		dungeons[i].depth_start = 1;
736.  		dungeons[i].dunlev_ureached = 1;
737.  	    } else {
738.  		dungeons[i].ledger_start = dungeons[i-1].ledger_start +
739.  					      dungeons[i-1].num_dunlevs;
740.  		dungeons[i].dunlev_ureached = 0;
741.  
742.  		if (dungeons[i].ledger_start + dungeons[i].num_dunlevs > 127)
743.  		    panic("init_dungeons: too many levels");
744.  	    }
745.  
746.  	    dungeons[i].flags.hellish = !!(pd.tmpdungeon[i].flags & HELLISH);
747.  	    dungeons[i].flags.maze_like = !!(pd.tmpdungeon[i].flags & MAZELIKE);
748.  	    dungeons[i].flags.rogue_like = !!(pd.tmpdungeon[i].flags & ROGUELIKE);
749.  	    dungeons[i].flags.align = ((pd.tmpdungeon[i].flags & D_ALIGN_MASK) >> 4);
750.  	    dungeons[i].entry_lev = 1;	/* defaults to top level */
751.  
752.  	    if (i) {	/* set depth */
753.  		branch *br;
754.  		schar from_depth;
755.  		boolean from_up;
756.  		int branch_num;
757.  
758.  		for (branch_num = 0; branch_num < pd.n_brs; branch_num++)
759.  		    if (!strcmp(pd.tmpbranch[branch_num].name, dungeons[i].dname)) {
760.  			br = add_branch(i, branch_num, &pd);
761.  			break;
762.  		    }
763.  		
764.  		/* Set the dungeon entry level from the first branch */
765.  		dungeons[i].entry_lev = br->end2.dlevel;
766.  
767.  		/* Get the depth of the connecting end. */
768.  		if (br->end1.dnum == i) {
769.  		    from_depth = depth(&br->end2);
770.  		    from_up = !br->end1_up;
771.  		} else {
772.  		    from_depth = depth(&br->end1);
773.  		    from_up = br->end1_up;
774.  		}
775.  
776.  		/*
777.  		 * Calculate the depth of the top of the dungeon via
778.  		 * its branch.  First, the depth of the entry point:
779.  		 *
780.  		 *	depth of branch from "parent" dungeon
781.  		 *	+ -1 or 1 depending on a up or down stair or
782.  		 *	  0 if portal
783.  		 *
784.  		 * Followed by the depth of the top of the dungeon:
785.  		 *
786.  		 *	- (entry depth - 1)
787.  		 *
788.  		 * We'll say that portals stay on the same depth.
789.  		 */
790.  		dungeons[i].depth_start = from_depth
791.  					+ (br->type == BR_PORTAL ? 0 :
792.  							(from_up ? -1 : 1))
793.  					- (dungeons[i].entry_lev - 1);
794.  	    }
795.  
796.  	    /* this is redundant - it should have been flagged by dgn_comp */
797.  	    if(dungeons[i].num_dunlevs > MAXLEVEL)
798.  		dungeons[i].num_dunlevs = MAXLEVEL;
799.  
800.  	    pd.start = pd.n_levs;	/* save starting point */
801.  	    pd.n_levs += pd.tmpdungeon[i].levels;
802.  	    if (pd.n_levs > LEV_LIMIT)
803.  		panic("init_dungeon: too many special levels");
804.  	    /*
805.  	     * Read in the prototype special levels.  Don't add generated
806.  	     * special levels until they are all placed.
807.  	     */
808.  	    for(; cl < pd.n_levs; cl++) {
809.  		Fread((genericptr_t)&pd.tmplevel[cl],
810.  					sizeof(struct tmplevel), 1, dgn_file);
811.  		init_level(i, cl, &pd);
812.  	    }
813.  	    /*
814.  	     * Recursively place the generated levels for this dungeon.  This
815.  	     * routine will attempt all possible combinations before giving
816.  	     * up.
817.  	     */
818.  	    if (!place_level(pd.start, &pd))
819.  		panic("init_dungeon:  couldn't place levels");
820.  #ifdef DDEBUG
821.  	    fprintf(stderr, "--- end of dungeon %d ---\n", i);
822.  	    fflush(stderr);
823.  	    getchar();
824.  #endif
825.  	    for (; pd.start < pd.n_levs; pd.start++)
826.  		if (pd.final_lev[pd.start]) add_level(pd.final_lev[pd.start]);
827.  
828.  
829.  	    pd.n_brs += pd.tmpdungeon[i].branches;
830.  	    if (pd.n_brs > BRANCH_LIMIT)
831.  		panic("init_dungeon: too many branches");
832.  	    for(; cb < pd.n_brs; cb++) {
833.  		int dgn;
834.  		Fread((genericptr_t)&pd.tmpbranch[cb],
835.  					sizeof(struct tmpbranch), 1, dgn_file);
836.  		pd.tmpparent[cb] = i;
837.  		for (dgn = 0; dgn < i; dgn++)
838.  		    if (!strcmp(pd.tmpbranch[cb].name, dungeons[dgn].dname)) {
839.  			(void)add_branch(dgn, cb, &pd);
840.  			break;
841.  		    }
842.  	    }
843.  	}
844.  	(void) dlb_fclose(dgn_file);
845.  
846.  	for (i = 0; i < 5; i++) tune[i] = 'A' + rn2(7);
847.  	tune[5] = 0;
848.  
849.  	/*
850.  	 * Find most of the special levels and dungeons so we can access their
851.  	 * locations quickly.
852.  	 */
853.  	for (lev_map = level_map; lev_map->lev_name[0]; lev_map++) {
854.  		x = find_level(lev_map->lev_name);
855.  		if (x) {
856.  			assign_level(lev_map->lev_spec, &x->dlevel);
857.  			if (!strncmp(lev_map->lev_name, "x-", 2)) {
858.  				/* This is where the name substitution on the
859.  				 * levels of the quest dungeon occur.
860.  				 */
861.  				Sprintf(x->proto, "%s%s", urole.filecode, &lev_map->lev_name[1]);
862.  			} else if (lev_map->lev_spec == &knox_level) {
863.  				branch *br;
864.  				/*
865.  				 * Kludge to allow floating Knox entrance.  We
866.  				 * specify a floating entrance by the fact that
867.  				 * its entrance (end1) has a bogus dnum, namely
868.  				 * n_dgns.
869.  				 */
870.  				for (br = branches; br; br = br->next)
871.  				    if (on_level(&br->end2, &knox_level)) break;
872.  
873.  				if (br) br->end1.dnum = n_dgns;
874.  				/* adjust the branch's position on the list */
875.  				insert_branch(br, TRUE);
876.  			}
877.  		}
878.  	}
879.  /*
880.   *	I hate hardwiring these names. :-(
881.   */
882.  	quest_dnum = dname_to_dnum("The Quest");
883.  	sokoban_dnum = dname_to_dnum("Sokoban");
884.  	mines_dnum = dname_to_dnum("The Gnomish Mines");
885.  	spiders_dnum = dname_to_dnum("The Spider Caves");        
886.  	tower_dnum = dname_to_dnum("Vlad's Tower");
887.  /*
888.  #ifdef BLACKMARKET
889.  	blackmarket_dnum = dname_to_dnum("The Black Market");
890.  #endif
891.  */
892.  
893.  	/* one special fixup for dummy surface level */
894.  	if ((x = find_level("dummy")) != 0) {
895.  	    i = x->dlevel.dnum;
896.  	    /* the code above puts earth one level above dungeon level #1,
897.  	       making the dummy level overlay level 1; but the whole reason
898.  	       for having the dummy level is to make earth have depth -1
899.  	       instead of 0, so adjust the start point to shift endgame up */
900.  	    if (dunlevs_in_dungeon(&x->dlevel) > 1 - dungeons[i].depth_start)
901.  		dungeons[i].depth_start -= 1;
902.  	    /* TO DO: strip "dummy" out all the way here,
903.  	       so that it's hidden from <ctrl/O> feedback. */
904.  	}
905.  
906.  #ifdef DEBUG
907.  	dumpit();
908.  #endif
909.  }
910.  
911.  xchar
912.  dunlev(lev)	/* return the level number for lev in *this* dungeon */
913.  d_level	*lev;
914.  {
915.  	return(lev->dlevel);
916.  }
917.  
918.  xchar
919.  dunlevs_in_dungeon(lev)	/* return the lowest level number for *this* dungeon*/
920.  d_level	*lev;
921.  {
922.  	/* lowest level of Gnome Mines is gone for Gnomes */        
923.  	if (Role_if(PM_GNOME) && lev->dnum == mines_dnum) {
924.  		return((dungeons[lev->dnum].num_dunlevs)-1);
925.  	} else return(dungeons[lev->dnum].num_dunlevs);
926.  }
927.  
928.  xchar
929.  real_dunlevs_in_dungeon(lev)  /* return the lowest level number for *this* dungeon*/
930.  d_level       *lev;
931.  {
932.       /* this one is not altered for Gnomes */
933.  	return(dungeons[lev->dnum].num_dunlevs);
934.  }
935.  
936.  xchar
937.  deepest_lev_reached(noquest) /* return the lowest level explored in the game*/
938.  boolean noquest;
939.  {
940.  	/* this function is used for three purposes: to provide a factor
941.  	 * of difficulty in monster generation; to provide a factor of
942.  	 * difficulty in experience calculations (botl.c and end.c); and
943.  	 * to insert the deepest level reached in the game in the topten
944.  	 * display.  the 'noquest' arg switch is required for the latter.
945.  	 *
946.  	 * from the player's point of view, going into the Quest is _not_
947.  	 * going deeper into the dungeon -- it is going back "home", where
948.  	 * the dungeon starts at level 1.  given the setup in dungeon.def,
949.  	 * the depth of the Quest (thought of as starting at level 1) is
950.  	 * never lower than the level of entry into the Quest, so we exclude
951.  	 * the Quest from the topten "deepest level reached" display
952.  	 * calculation.  _However_ the Quest is a difficult dungeon, so we
953.  	 * include it in the factor of difficulty calculations.
954.  	 */
955.  	register int i;
956.  	d_level tmp;
957.  	register schar ret = 0;
958.  
959.  	for(i = 0; i < n_dgns; i++) {
960.  	    if((tmp.dlevel = dungeons[i].dunlev_ureached) == 0) continue;
961.  	    if(!strcmp(dungeons[i].dname, "The Quest") && noquest) continue;
962.  
963.  	    tmp.dnum = i;
964.  	    if(depth(&tmp) > ret) ret = depth(&tmp);
965.  	}
966.  	return((xchar) ret);
967.  }
968.  
969.  /* return a bookkeeping level number for purpose of comparisons and
970.   * save/restore */
971.  xchar
972.  ledger_no(lev)
973.  d_level	*lev;
974.  {
975.  	return((xchar)(lev->dlevel + dungeons[lev->dnum].ledger_start));
976.  }
977.  
978.  /*
979.   * The last level in the bookkeeping list of level is the bottom of the last
980.   * dungeon in the dungeons[] array.
981.   *
982.   * Maxledgerno() -- which is the max number of levels in the bookkeeping
983.   * list, should not be confused with dunlevs_in_dungeon(lev) -- which
984.   * returns the max number of levels in lev's dungeon, and both should
985.   * not be confused with deepest_lev_reached() -- which returns the lowest
986.   * depth visited by the player.
987.   */
988.  xchar
989.  maxledgerno()
990.  {
991.      return (xchar) (dungeons[n_dgns-1].ledger_start +
992.  				dungeons[n_dgns-1].num_dunlevs);
993.  }
994.  
995.  /* return the dungeon that this ledgerno exists in */
996.  xchar
997.  ledger_to_dnum(ledgerno)
998.  xchar	ledgerno;
999.  {
1000. 	register int i;
1001. 
1002. 	/* find i such that (i->base + 1) <= ledgerno <= (i->base + i->count) */
1003. 	for (i = 0; i < n_dgns; i++)
1004. 	    if (dungeons[i].ledger_start < ledgerno &&
1005. 		ledgerno <= dungeons[i].ledger_start + dungeons[i].num_dunlevs)
1006. 		return (xchar)i;
1007. 
1008. 	panic("level number out of range [ledger_to_dnum(%d)]", (int)ledgerno);
1009. 	/*NOT REACHED*/
1010. 	return (xchar)0;
1011. }
1012. 
1013. /* return the level of the dungeon this ledgerno exists in */
1014. xchar
1015. ledger_to_dlev(ledgerno)
1016. xchar	ledgerno;
1017. {
1018. 	return((xchar)(ledgerno - dungeons[ledger_to_dnum(ledgerno)].ledger_start));
1019. }
1020. 
1021. #endif /* OVL1 */
1022. #ifdef OVL0
1023. 
1024. /* returns the depth of a level, in floors below the surface	*/
1025. /* (note levels in different dungeons can have the same depth).	*/
1026. schar
1027. depth(lev)
1028. d_level	*lev;
1029. {
1030. 	return((schar)( dungeons[lev->dnum].depth_start + lev->dlevel - 1));
1031. }
1032. 
1033. boolean
1034. on_level(lev1, lev2)	/* are "lev1" and "lev2" actually the same? */
1035. d_level	*lev1, *lev2;
1036. {
1037. 	return((boolean)((lev1->dnum == lev2->dnum) && (lev1->dlevel == lev2->dlevel)));
1038. }
1039. 
1040. #endif /* OVL0 */
1041. #ifdef OVL1
1042. 
1043. /* is this level referenced in the special level chain? */
1044. s_level *
1045. Is_special(lev)
1046. d_level	*lev;
1047. {
1048. 	s_level *levtmp;
1049. 
1050. 	for (levtmp = sp_levchn; levtmp; levtmp = levtmp->next)
1051. 	    if (on_level(lev, &levtmp->dlevel)) return(levtmp);
1052. 
1053. 	return((s_level *)0);
1054. }
1055. 
1056. /*
1057.  * Is this a multi-dungeon branch level?  If so, return a pointer to the
1058.  * branch.  Otherwise, return null.
1059.  */
1060. branch *
1061. Is_branchlev(lev)
1062. d_level *lev;
1063. {
1064. 	branch *curr;
1065. 
1066. 	for (curr = branches; curr; curr = curr->next) {
1067. 	    if (on_level(lev, &curr->end1) || on_level(lev, &curr->end2))
1068. 		return curr;
1069. 	}
1070. 	return (branch *) 0;
1071. }
1072. 
1073. /* goto the next level (or appropriate dungeon) */
1074. void
1075. next_level(at_stairs)
1076. boolean	at_stairs;
1077. {
1078. 	if (at_stairs && u.ux == sstairs.sx && u.uy == sstairs.sy) {
1079. 		/* Taking a down dungeon branch. */
1080. 		goto_level(&sstairs.tolev, at_stairs, FALSE, FALSE);
1081. 	} else {
1082. 		/* Going down a stairs or jump in a trap door. */
1083. 		d_level	newlevel;
1084. 
1085. 		newlevel.dnum = u.uz.dnum;
1086. 		newlevel.dlevel = u.uz.dlevel + 1;
1087. 		goto_level(&newlevel, at_stairs, !at_stairs, FALSE);
1088. 	}
1089. }
1090. 
1091. /* goto the previous level (or appropriate dungeon) */
1092. void
1093. prev_level(at_stairs)
1094. boolean	at_stairs;
1095. {
1096. 	if (at_stairs && u.ux == sstairs.sx && u.uy == sstairs.sy) {
1097. 		/* Taking an up dungeon branch. */
1098. 		/* KMH -- Upwards branches are okay if not level 1 */
1099. 		/* (Just make sure it doesn't go above depth 1) */
1100. 		if(!u.uz.dnum && u.uz.dlevel == 1 && !u.uhave.amulet) done(ESCAPED);
1101. 		else goto_level(&sstairs.tolev, at_stairs, FALSE, FALSE);
1102. 	} else {
1103. 		/* Going up a stairs or rising through the ceiling. */
1104. 		d_level	newlevel;
1105. 		newlevel.dnum = u.uz.dnum;
1106. 		newlevel.dlevel = u.uz.dlevel - 1;
1107. 		goto_level(&newlevel, at_stairs, FALSE, FALSE);
1108. 	}
1109. }
1110. 
1111. void
1112. u_on_newpos(x, y)
1113. int x, y;
1114. {
1115. 	u.ux = x;
1116. 	u.uy = y;
1117. #ifdef CLIPPING
1118. 	cliparound(u.ux, u.uy);
1119. #endif
1120. #ifdef STEED
1121. 	/* ridden steed always shares hero's location */
1122. 	if (u.usteed) u.usteed->mx = u.ux, u.usteed->my = u.uy;
1123. #endif
1124. }
1125. 
1126. void
1127. u_on_sstairs() {	/* place you on the special staircase */
1128. 
1129. 	if (sstairs.sx) {
1130. 	    u_on_newpos(sstairs.sx, sstairs.sy);
1131. 	} else {
1132. 	    /* code stolen from goto_level */
1133. 	    int trycnt = 0;
1134. 	    xchar x, y;
1135. #ifdef DEBUG
1136. 	    pline("u_on_sstairs: picking random spot");
1137. #endif
1138. #define badspot(x,y) ((levl[x][y].typ != ROOM && levl[x][y].typ != CORR) || MON_AT(x, y))
1139. 	    do {
1140. 		x = rnd(COLNO-1);
1141. 		y = rn2(ROWNO);
1142. 		if (!badspot(x, y)) {
1143. 		    u_on_newpos(x, y);
1144. 		    return;
1145. 		}
1146. 	    } while (++trycnt <= 500);
1147. 	    panic("u_on_sstairs: could not relocate player!");
1148. #undef badspot
1149. 	}
1150. }
1151. 
1152. void
1153. u_on_upstairs()	/* place you on upstairs (or special equivalent) */
1154. {
1155. 	if (xupstair) {
1156. 		u_on_newpos(xupstair, yupstair);
1157. 	} else
1158. 		u_on_sstairs();
1159. }
1160. 
1161. void
1162. u_on_dnstairs()	/* place you on dnstairs (or special equivalent) */
1163. {
1164. 	if (xdnstair) {
1165. 		u_on_newpos(xdnstair, ydnstair);
1166. 	} else
1167. 		u_on_sstairs();
1168. }
1169. 
1170. boolean
1171. On_stairs(x, y)
1172. xchar x, y;
1173. {
1174. 	return((boolean)((x == xupstair && y == yupstair) ||
1175. 	       (x == xdnstair && y == ydnstair) ||
1176. 	       (x == xdnladder && y == ydnladder) ||
1177. 	       (x == xupladder && y == yupladder) ||
1178. 	       (x == sstairs.sx && y == sstairs.sy)));
1179. }
1180. 
1181. boolean
1182. Is_botlevel(lev)
1183. d_level *lev;
1184. {
1185. 	return((boolean)(lev->dlevel == dungeons[lev->dnum].num_dunlevs));
1186. }
1187. 
1188. boolean
1189. Can_dig_down(lev)
1190. d_level *lev;
1191. {
1192. 	return((boolean)(!level.flags.hardfloor
1193. 	    && !Is_botlevel(lev) && !Invocation_lev(lev)));
1194. }
1195. 
1196. /*
1197.  * Like Can_dig_down (above), but also allows falling through on the
1198.  * stronghold level.  Normally, the bottom level of a dungeon resists
1199.  * both digging and falling.
1200.  */
1201. boolean
1202. Can_fall_thru(lev)
1203. d_level *lev;
1204. {
1205. 	return((boolean)(Can_dig_down(lev) || Is_stronghold(lev)));
1206. }
1207. 
1208. /*
1209.  * True if one can rise up a level (e.g. cursed gain level).
1210.  * This happens on intermediate dungeon levels or on any top dungeon
1211.  * level that has a stairwell style branch to the next higher dungeon.
1212.  * Checks for amulets and such must be done elsewhere.
1213.  */
1214. boolean
1215. Can_rise_up(x, y, lev)
1216. int	x, y;
1217. d_level *lev;
1218. {
1219.     /* can't rise up from inside the top of the Wizard's tower */
1220.     /* KMH -- or in sokoban */
1221.     if (In_endgame(lev) || In_sokoban(lev) ||
1222. 			(Is_wiz1_level(lev) && In_W_tower(x, y, lev)))
1223. 	return FALSE;
1224.     return (boolean)(lev->dlevel > 1 ||
1225. 		(dungeons[lev->dnum].entry_lev == 1 && ledger_no(lev) != 1 &&
1226. 		 sstairs.sx && sstairs.up));
1227. }
1228. 
1229. /*
1230.  * It is expected that the second argument of get_level is a depth value,
1231.  * either supplied by the user (teleport control) or randomly generated.
1232.  * But more than one level can be at the same depth.  If the target level
1233.  * is "above" the present depth location, get_level must trace "up" from
1234.  * the player's location (through the ancestors dungeons) the dungeon
1235.  * within which the target level is located.  With only one exception
1236.  * which does not pass through this routine (see level_tele), teleporting
1237.  * "down" is confined to the current dungeon.  At present, level teleport
1238.  * in dungeons that build up is confined within them.
1239.  */
1240. void
1241. get_level(newlevel, levnum)
1242. d_level *newlevel;
1243. int levnum;
1244. {
1245. 	branch *br;
1246. 	xchar dgn = u.uz.dnum;
1247. 
1248. 	if (levnum <= 0) {
1249. 	    /* can only currently happen in endgame */
1250. 	    levnum = u.uz.dlevel;
1251. 	} else if (levnum > dungeons[dgn].depth_start
1252. 			    + dungeons[dgn].num_dunlevs - 1) {
1253. 	    /* beyond end of dungeon, jump to last level */
1254. 	    levnum = dungeons[dgn].num_dunlevs;
1255. 	} else {
1256. 	    /* The desired level is in this dungeon or a "higher" one. */
1257. 
1258. 	    /*
1259. 	     * Branch up the tree until we reach a dungeon that contains the
1260. 	     * levnum.
1261. 	     */
1262. 	    if (levnum < dungeons[dgn].depth_start) {
1263. 
1264. 		do {
1265. 		    /*
1266. 		     * Find the parent dungeon of this dungeon.
1267. 		     *
1268. 		     * This assumes that end2 is always the "child" and it is
1269. 		     * unique.
1270. 		     */
1271. 		    for (br = branches; br; br = br->next)
1272. 			if (br->end2.dnum == dgn) break;
1273. 		    if (!br)
1274. 			panic("get_level: can't find parent dungeon");
1275. 
1276. 		    dgn = br->end1.dnum;
1277. 		} while (levnum < dungeons[dgn].depth_start);
1278. 	    }
1279. 
1280. 	    /* We're within the same dungeon; calculate the level. */
1281. 	    levnum = levnum - dungeons[dgn].depth_start + 1;
1282. 	}
1283. 
1284. 	newlevel->dnum = dgn;
1285. 	newlevel->dlevel = levnum;
1286. }
1287. 
1288. #endif /* OVL1 */
1289. #ifdef OVL0
1290. 
1291. boolean
1292. In_quest(lev)	/* are you in the quest dungeon? */
1293. d_level *lev;
1294. {
1295. 	return((boolean)(lev->dnum == quest_dnum));
1296. }
1297. 
1298. #endif /* OVL0 */
1299. #ifdef OVL1
1300. 
1301. boolean
1302. In_mines(lev)	/* are you in the mines dungeon? */
1303. d_level	*lev;
1304. {
1305. 	return((boolean)(lev->dnum == mines_dnum));
1306. }
1307. 
1308. boolean
1309. In_spiders(lev) /* are you in the spider dungeon? */
1310. d_level *lev;
1311. {
1312. 	return((boolean)(lev->dnum == spiders_dnum));
1313. }
1314. 
1315. /*
1316.  * Return the branch for the given dungeon.
1317.  *
1318.  * This function assumes:
1319.  *	+ This is not called with "Dungeons of Doom".
1320.  *	+ There is only _one_ branch to a given dungeon.
1321.  *	+ Field end2 is the "child" dungeon.
1322.  */
1323. branch *
1324. dungeon_branch(s)
1325.     const char *s;
1326. {
1327.     branch *br;
1328.     xchar  dnum;
1329. 
1330.     dnum = dname_to_dnum(s);
1331. 
1332.     /* Find the branch that connects to dungeon i's branch. */
1333.     for (br = branches; br; br = br->next)
1334. 	if (br->end2.dnum == dnum) break;
1335. 
1336.     if (!br) panic("dgn_entrance: can't find entrance to %s", s);
1337. 
1338.     return br;
1339. }
1340. 
1341. /*
1342.  * This returns true if the hero is on the same level as the entrance to
1343.  * the named dungeon.
1344.  *
1345.  * Called from do.c and mklev.c.
1346.  *
1347.  * Assumes that end1 is always the "parent".
1348.  */
1349. boolean
1350. at_dgn_entrance(s)
1351.     const char *s;
1352. {
1353.     branch *br;
1354. 
1355.     br = dungeon_branch(s);
1356.     return((boolean)(on_level(&u.uz, &br->end1) ? TRUE : FALSE));
1357. }
1358. 
1359. boolean
1360. In_V_tower(lev)	/* is `lev' part of Vlad's tower? */
1361. d_level	*lev;
1362. {
1363. 	return((boolean)(lev->dnum == tower_dnum));
1364. }
1365. 
1366. boolean
1367. On_W_tower_level(lev)	/* is `lev' a level containing the Wizard's tower? */
1368. d_level	*lev;
1369. {
1370. 	return (boolean)(Is_wiz1_level(lev) ||
1371. 			 Is_wiz2_level(lev) ||
1372. 			 Is_wiz3_level(lev));
1373. }
1374. 
1375. boolean
1376. In_W_tower(x, y, lev)	/* is <x,y> of `lev' inside the Wizard's tower? */
1377. int	x, y;
1378. d_level	*lev;
1379. {
1380. 	if (!On_W_tower_level(lev)) return FALSE;
1381. 	/*
1382. 	 * Both of the exclusion regions for arriving via level teleport
1383. 	 * (from above or below) define the tower's boundary.
1384. 	 *	assert( updest.nIJ == dndest.nIJ for I={l|h},J={x|y} );
1385. 	 */
1386. 	if (dndest.nlx > 0)
1387. 	    return (boolean)within_bounded_area(x, y, dndest.nlx, dndest.nly,
1388. 						dndest.nhx, dndest.nhy);
1389. 	else
1390. 	    impossible("No boundary for Wizard's Tower?");
1391. 	return FALSE;
1392. }
1393. 
1394. #endif /* OVL1 */
1395. #ifdef OVL0
1396. 
1397. boolean
1398. In_hell(lev)	/* are you in one of the Hell levels? */
1399. d_level	*lev;
1400. {
1401. 	return((boolean)(dungeons[lev->dnum].flags.hellish));
1402. }
1403. 
1404. #endif /* OVL0 */
1405. #ifdef OVL1
1406. 
1407. void
1408. find_hell(lev)	/* sets *lev to be the gateway to Gehennom... */
1409. d_level *lev;
1410. {
1411. 	lev->dnum = valley_level.dnum;
1412. 	lev->dlevel = 1;
1413. }
1414. 
1415. void
1416. goto_hell(at_stairs, falling)	/* go directly to hell... */
1417. boolean	at_stairs, falling;
1418. {
1419. 	d_level lev;
1420. 
1421. 	find_hell(&lev);
1422. 	goto_level(&lev, at_stairs, falling, FALSE);
1423. }
1424. 
1425. void
1426. assign_level(dest, src)		/* equivalent to dest = source */
1427. d_level	*dest, *src;
1428. {
1429. 	dest->dnum = src->dnum;
1430. 	dest->dlevel = src->dlevel;
1431. }
1432. 
1433. void
1434. assign_rnd_level(dest, src, range)	/* dest = src + rn1(range) */
1435. d_level	*dest, *src;
1436. int range;
1437. {
1438. 	dest->dnum = src->dnum;
1439. 	dest->dlevel = src->dlevel + ((range > 0) ? rnd(range) : -rnd(-range)) ;
1440. 
1441. 	if(dest->dlevel > dunlevs_in_dungeon(dest))
1442. 		dest->dlevel = dunlevs_in_dungeon(dest);
1443. 	else if(dest->dlevel < 1)
1444. 		dest->dlevel = 1;
1445. }
1446. 
1447. #endif /* OVL1 */
1448. #ifdef OVL0
1449. 
1450. int
1451. induced_align(pct)
1452. int	pct;
1453. {
1454. 	s_level	*lev = Is_special(&u.uz);
1455. 	aligntyp al;
1456. 
1457. 	if (lev && lev->flags.align)
1458. 		if(rn2(100) < pct) return(lev->flags.align);
1459. 
1460. 	if(dungeons[u.uz.dnum].flags.align)
1461. 		if(rn2(100) < pct) return(dungeons[u.uz.dnum].flags.align);
1462. 
1463. 	al = rn2(3) - 1;
1464. 	return(Align2amask(al));
1465. }
1466. 
1467. #endif /* OVL0 */
1468. #ifdef OVL1
1469. 
1470. boolean
1471. Invocation_lev(lev)
1472. d_level *lev;
1473. {
1474. 	return((boolean)(In_hell(lev) &&
1475. 		lev->dlevel == (dungeons[lev->dnum].num_dunlevs - 1)));
1476. }
1477. 
1478. /* use instead of depth() wherever a degree of difficulty is made
1479.  * dependent on the location in the dungeon (eg. monster creation).
1480.  */
1481. xchar
1482. level_difficulty()
1483. {
1484. 	if (In_endgame(&u.uz))
1485. 		return((xchar)(depth(&sanctum_level) + u.ulevel/2));
1486. 	else
1487. 		if (u.uhave.amulet)
1488. 			return(deepest_lev_reached(FALSE));
1489. 		else
1490. 			return((xchar) depth(&u.uz));
1491. }
1492. 
1493. /* Take one word and try to match it to a level.
1494.  * Recognized levels are as shown by print_dungeon().
1495.  */
1496. schar
1497. lev_by_name(nam)
1498. const char *nam;
1499. {
1500.     schar lev = 0;
1501.     s_level *slev;
1502.     d_level dlev;
1503.     const char *p;
1504.     int idx, idxtoo;
1505.     char buf[BUFSZ];
1506. 
1507.     /* allow strings like "the oracle level" to find "oracle" */
1508.     if (!strncmpi(nam, "the ", 4)) nam += 4;
1509.     if ((p = strstri(nam, " level")) != 0 && p == eos((char*)nam) - 6) {
1510. 	nam = strcpy(buf, nam);
1511. 	*(eos(buf) - 6) = '\0';
1512.     }
1513.     /* hell is the old name, and wouldn't match; gehennom would match its
1514.        branch, yielding the castle level instead of the valley of the dead */
1515.     if (!strcmpi(nam, "gehennom") || !strcmpi(nam, "hell")) {
1516. 	if (In_V_tower(&u.uz)) nam = " to Vlad's tower";  /* branch to... */
1517. 	else nam = "valley";
1518.     }
1519. 
1520.     if ((slev = find_level(nam)) != 0) {
1521. 	dlev = slev->dlevel;
1522. 	idx = ledger_no(&dlev);
1523. 	if ((dlev.dnum == u.uz.dnum ||
1524. 		/* within same branch, or else main dungeon <-> gehennom */
1525. 		(u.uz.dnum == valley_level.dnum &&
1526. 			dlev.dnum == medusa_level.dnum) ||
1527. 		(u.uz.dnum == medusa_level.dnum &&
1528. 			dlev.dnum == valley_level.dnum)) &&
1529. 	    (	/* either wizard mode or else seen and not forgotten */
1530. #ifdef WIZARD
1531. 	     wizard ||
1532. #endif
1533. 		(level_info[idx].flags & (FORGOTTEN|VISITED)) == VISITED)) {
1534. 	    lev = depth(&slev->dlevel);
1535. 	}
1536.     } else {	/* not a specific level; try branch names */
1537. 	idx = find_branch(nam, (struct proto_dungeon *)0);
1538. 	/* "<branch> to Xyzzy" */
1539. 	if (idx < 0 && (p = strstri(nam, " to ")) != 0)
1540. 	    idx = find_branch(p + 4, (struct proto_dungeon *)0);
1541. 
1542. 	if (idx >= 0) {
1543. 	    idxtoo = (idx >> 8) & 0x00FF;
1544. 	    idx &= 0x00FF;
1545. 	    if (  /* either wizard mode, or else _both_ sides of branch seen */
1546. #ifdef WIZARD
1547. 		wizard ||
1548. #endif
1549. 		((level_info[idx].flags & (FORGOTTEN|VISITED)) == VISITED &&
1550. 		 (level_info[idxtoo].flags & (FORGOTTEN|VISITED)) == VISITED)) {
1551. 		if (ledger_to_dnum(idxtoo) == u.uz.dnum) idx = idxtoo;
1552. 		dlev.dnum = ledger_to_dnum(idx);
1553. 		dlev.dlevel = ledger_to_dlev(idx);
1554. 		lev = depth(&dlev);
1555. 	    }
1556. 	}
1557.     }
1558.     return lev;
1559. }
1560. 
1561. #ifdef WIZARD
1562. 
1563. /* Convert a branch type to a string usable by print_dungeon(). */
1564. STATIC_OVL const char *
1565. br_string(type)
1566.     int type;
1567. {
1568.     switch (type) {
1569. 	case BR_PORTAL:	 return "Portal";
1570. 	case BR_NO_END1: return "Connection";
1571. 	case BR_NO_END2: return "One way stair";
1572. 	case BR_STAIR:	 return "Stair";
1573.     }
1574.     return " (unknown)";
1575. }
1576. 
1577. /* Print all child branches between the lower and upper bounds. */
1578. STATIC_OVL void
1579. print_branch(win, dnum, lower_bound, upper_bound, bymenu, lchoices)
1580.     winid win;
1581.     int   dnum;
1582.     int   lower_bound;
1583.     int   upper_bound;
1584.     boolean bymenu;
1585.     struct lchoice *lchoices;
1586. {
1587.     branch *br;
1588.     char buf[BUFSZ];
1589.     anything any;
1590. 
1591.     /* This assumes that end1 is the "parent". */
1592.     for (br = branches; br; br = br->next) {
1593. 	if (br->end1.dnum == dnum && lower_bound < br->end1.dlevel &&
1594. 					br->end1.dlevel <= upper_bound) {
1595. 	    Sprintf(buf,"   %s to %s: %d",
1596. 		    br_string(br->type),
1597. 		    dungeons[br->end2.dnum].dname,
1598. 		    depth(&br->end1));
1599. 	    if (bymenu) {
1600. 		lchoices->lev[lchoices->idx] = br->end1.dlevel;
1601. 		lchoices->dgn[lchoices->idx] = br->end1.dnum;
1602. 		lchoices->playerlev[lchoices->idx] = depth(&br->end1);
1603. 		any.a_void = 0;
1604. 		any.a_int = lchoices->idx + 1;
1605. 		add_menu(win, NO_GLYPH, &any, lchoices->menuletter,
1606. 				0, ATR_NONE, buf, MENU_UNSELECTED);
1607. 		if (lchoices->menuletter == 'z') lchoices->menuletter = 'A';
1608. 		else lchoices->menuletter++;
1609. 		lchoices->idx++;
1610. 	    } else
1611. 		putstr(win, 0, buf);
1612. 	}
1613.     }
1614. }
1615. 
1616. /* Print available dungeon information. */
1617. schar
1618. print_dungeon(bymenu, rlev, rdgn)
1619. boolean bymenu;
1620. schar *rlev;
1621. xchar *rdgn;
1622. {
1623.     int     i, last_level, nlev;
1624.     char    buf[BUFSZ];
1625.     boolean first;
1626.     s_level *slev;
1627.     dungeon *dptr;
1628.     branch  *br;
1629.     anything any;
1630.     struct lchoice lchoices;
1631. 
1632.     winid   win = create_nhwindow(NHW_MENU);
1633.     if (bymenu) {
1634. 	start_menu(win);
1635. 	lchoices.idx = 0;
1636. 	lchoices.menuletter = 'a';
1637.     }
1638. 
1639.     for (i = 0, dptr = dungeons; i < n_dgns; i++, dptr++) {
1640. 	nlev = dptr->num_dunlevs;
1641. 	if (nlev > 1)
1642. 	    Sprintf(buf, "%s: levels %d to %d", dptr->dname, dptr->depth_start,
1643. 						dptr->depth_start + nlev - 1);
1644. 	else
1645. 	    Sprintf(buf, "%s: level %d", dptr->dname, dptr->depth_start);
1646. 
1647. 	/* Most entrances are uninteresting. */
1648. 	if (dptr->entry_lev != 1) {
1649. 	    if (dptr->entry_lev == nlev)
1650. 		Strcat(buf, ", entrance from below");
1651. 	    else
1652. 		Sprintf(eos(buf), ", entrance on %d",
1653. 			dptr->depth_start + dptr->entry_lev - 1);
1654. 	}
1655. 	if (bymenu) {
1656. 	    any.a_void = 0;
1657. 	    add_menu(win, NO_GLYPH, &any, 0, 0, iflags.menu_headings, buf, MENU_UNSELECTED);
1658. 	} else
1659. 	    putstr(win, 0, buf);
1660. 
1661. 	/*
1662. 	 * Circle through the special levels to find levels that are in
1663. 	 * this dungeon.
1664. 	 */
1665. 	for (slev = sp_levchn, last_level = 0; slev; slev = slev->next) {
1666. 	    if (slev->dlevel.dnum != i) continue;
1667. 
1668. 	    /* print any branches before this level */
1669. 	    print_branch(win, i, last_level, slev->dlevel.dlevel, bymenu, &lchoices);
1670. 
1671. 	    Sprintf(buf, "   %s: %d", slev->proto, depth(&slev->dlevel));
1672. 	    if (Is_stronghold(&slev->dlevel))
1673. 		Sprintf(eos(buf), " (tune %s)", tune);
1674. 	    if (bymenu) {
1675. 	    	/* If other floating branches are added, this will need to change */
1676. 	    	if (i != knox_level.dnum) {
1677. 			lchoices.lev[lchoices.idx] = slev->dlevel.dlevel;
1678. 			lchoices.dgn[lchoices.idx] = i;
1679. 		} else {
1680. 			lchoices.lev[lchoices.idx] = depth(&slev->dlevel);
1681. 			lchoices.dgn[lchoices.idx] = 0;
1682. 		}
1683. 		lchoices.playerlev[lchoices.idx] = depth(&slev->dlevel);
1684. 		any.a_void = 0;
1685. 		any.a_int = lchoices.idx + 1;
1686. 		add_menu(win, NO_GLYPH, &any, lchoices.menuletter,
1687. 				0, ATR_NONE, buf, MENU_UNSELECTED);
1688. 		if (lchoices.menuletter == 'z') lchoices.menuletter = 'A';
1689. 		else lchoices.menuletter++;
1690. 		lchoices.idx++;
1691. 	    } else
1692. 		putstr(win, 0, buf);
1693. 
1694. 	    last_level = slev->dlevel.dlevel;
1695. 	}
1696. 	/* print branches after the last special level */
1697. 	print_branch(win, i, last_level, MAXLEVEL, bymenu, &lchoices);
1698.     }
1699. 
1700.     /* Print out floating branches (if any). */
1701.     for (first = TRUE, br = branches; br; br = br->next) {
1702. 	if (br->end1.dnum == n_dgns) {
1703. 	    if (first) {
1704. 	    	if (!bymenu) {
1705. 		    putstr(win, 0, "");
1706. 		    putstr(win, 0, "Floating branches");
1707. 		}
1708. 		first = FALSE;
1709. 	    }
1710. 	    Sprintf(buf, "   %s to %s",
1711. 			br_string(br->type), dungeons[br->end2.dnum].dname);
1712. 	    if (!bymenu)
1713. 		putstr(win, 0, buf);
1714. 	}
1715.     }
1716.     if (bymenu) {
1717.     	int n;
1718. 	menu_item *selected;
1719. 	int idx;
1720. 
1721. 	end_menu(win, "Level teleport to where:");
1722. 	n = select_menu(win, PICK_ONE, &selected);
1723. 	destroy_nhwindow(win);
1724. 	if (n > 0) {
1725. 		idx = selected[0].item.a_int - 1;
1726. 		free((genericptr_t)selected);
1727. 		if (rlev && rdgn) {
1728. 			*rlev = lchoices.lev[idx];
1729. 			*rdgn = lchoices.dgn[idx];
1730. 			return lchoices.playerlev[idx];
1731. 		}
1732. 	}
1733. 	return 0;
1734.     }
1735. 
1736.     /* I hate searching for the invocation pos while debugging. -dean */
1737.     if (Invocation_lev(&u.uz)) {
1738. 	putstr(win, 0, "");
1739. 	Sprintf(buf, "Invocation position @ (%d,%d), hero @ (%d,%d)",
1740. 		inv_pos.x, inv_pos.y, u.ux, u.uy);
1741. 	putstr(win, 0, buf);
1742.     }
1743.     /*
1744.      * The following is based on the assumption that the inter-level portals
1745.      * created by the level compiler (not the dungeon compiler) only exist
1746.      * one per level (currently true, of course).
1747.      */
1748.     else if (Is_earthlevel(&u.uz) || Is_waterlevel(&u.uz)
1749. 				|| Is_firelevel(&u.uz) || Is_airlevel(&u.uz)) {
1750. 	struct trap *trap;
1751. 	for (trap = ftrap; trap; trap = trap->ntrap)
1752. 	    if (trap->ttyp == MAGIC_PORTAL) break;
1753. 
1754. 	putstr(win, 0, "");
1755. 	if (trap)
1756. 	    Sprintf(buf, "Portal @ (%d,%d), hero @ (%d,%d)",
1757. 		trap->tx, trap->ty, u.ux, u.uy);
1758. 	else
1759. 	    Sprintf(buf, "No portal found.");
1760. 	putstr(win, 0, buf);
1761.     }
1762. 
1763.     display_nhwindow(win, TRUE);
1764.     destroy_nhwindow(win);
1765.     return 0;
1766. }
1767. #endif /* WIZARD */
1768. 
1769. #endif /* OVL1 */
1770. 
1771. /*dungeon.c*/

Also on Fandom

Random Wiki