/* NetHack 5.0 dungeon.c $NHDT-Date: 1781973047 2026/06/20 16:30:47 $ $NHDT-Branch: NetHack-5.0 $:$NHDT-Revision: 1.239 $ */

/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */

/*-Copyright (c) Robert Patrick Rankin, 2012. */

/* NetHack may be freely redistributed. See license for details. */

#include "hack.h"

#include "dgn_file.h"

#include "dlb.h"

#define DUNGEON_FILE "dungeon.lua"

#define X_START "x-strt"

#define X_LOCATE "x-loca"

#define X_GOAL "x-goal"

struct proto_dungeon {

struct tmpdungeon tmpdungeon[MAXDUNGEON];

struct tmplevel tmplevel[LEV_LIMIT];

s_level *final_lev[LEV_LIMIT]; /* corresponding level pointers */

struct tmpbranch tmpbranch[BRANCH_LIMIT];

int start; /* starting index of current dungeon sp levels */

int n_levs; /* number of tmplevel entries */

int n_brs; /* number of tmpbranch entries */

};

struct lchoice {

int idx;

schar lev[MAXLINFO];

schar playerlev[MAXLINFO];

xint16 dgn[MAXLINFO];

char menuletter;

};

static mapseen *load_mapseen(NHFILE *);

#ifndef SFCTOOL

#if 0

staticfn void Fread(genericptr_t, int, int, dlb *);

#endif

staticfn xint16 dname_to_dnum(const char *);

staticfn int find_branch(const char *, struct proto_dungeon *);

staticfn xint16 parent_dnum(const char *, struct proto_dungeon *);

staticfn int level_range(xint16, int, int, int, struct proto_dungeon *,

int *);

staticfn xint16 parent_dlevel(const char *, struct proto_dungeon *);

staticfn int correct_branch_type(struct tmpbranch *);

staticfn branch *add_branch(int, int, struct proto_dungeon *);

staticfn void add_level(s_level *);

staticfn void init_level(int, int, struct proto_dungeon *);

staticfn int possible_places(int, boolean *, struct proto_dungeon *);

staticfn xint16 pick_level(boolean *, int);

staticfn boolean place_level(int, struct proto_dungeon *);

staticfn int get_dgn_flags(lua_State *);

staticfn int get_dgn_align(lua_State *);

staticfn void init_dungeon_levels(lua_State *, struct proto_dungeon *, int);

staticfn void init_dungeon_branches(lua_State *, struct proto_dungeon *, int);

staticfn void init_dungeon_set_entry(struct proto_dungeon *, int);

staticfn void init_dungeon_set_depth(struct proto_dungeon *, int);

staticfn void init_castle_tune(void);

staticfn void fixup_level_locations(void);

staticfn void free_proto_dungeon(struct proto_dungeon *);

staticfn void earth_sense(void);

staticfn boolean init_dungeon_dungeons(lua_State *, struct proto_dungeon *,

int);

staticfn boolean unplaced_floater(struct dungeon *);

staticfn boolean unreachable_level(d_level *, boolean);

staticfn void tport_menu(winid, char *, struct lchoice *, d_level *, boolean);

staticfn const char *br_string(int) NONNULL;

staticfn char chr_u_on_lvl(d_level *);

staticfn void print_branch(winid, int, int, int, boolean, struct lchoice *);

staticfn char *get_annotation(d_level *);

staticfn void query_annotation(d_level *);

staticfn mapseen *load_mapseen(NHFILE *);

staticfn void save_mapseen(NHFILE *, mapseen *);

staticfn mapseen *find_mapseen(d_level *);

staticfn mapseen *find_mapseen_by_str(const char *);

staticfn void print_mapseen(winid, mapseen *, int, int, boolean);

staticfn boolean interest_mapseen(mapseen *);

staticfn void count_feat_lastseentyp(mapseen *, coordxy, coordxy);

staticfn void traverse_mapseenchn(int, winid, int, int, int *);

staticfn const char *seen_string(xint16, const char *) NONNULL NONNULLARG2;

staticfn const char *br_string2(branch *) NONNULL NONNULLARG1;

staticfn const char *shop_string(int) NONNULL;

staticfn char *tunesuffix(mapseen *, char *, size_t) NONNULL NONNULLPTRS;

#ifdef DEBUG

staticfn void dumpit(void);

staticfn void

dumpit(void)

{

#define DD svd.dungeons[i]

int i;

s_level *x;

branch *br;

if (!explicitdebug(__FILE__))

return;

for (i = 0; i < svn.n_dgns; i++) {

fprintf(stderr, "\n#%d \"%s\" (%s):\n", i, DD.dname, DD.proto);

fprintf(stderr, " num_dunlevs %d, dunlev_ureached %d\n",

DD.num_dunlevs, DD.dunlev_ureached);

fprintf(stderr, " depth_start %d, ledger_start %d\n",

DD.depth_start, DD.ledger_start);

fprintf(stderr, " flags:%s%s%s\n",

DD.flags.rogue_like ? " rogue_like" : "",

DD.flags.maze_like ? " maze_like" : "",

DD.flags.hellish ? " hellish" : "");

(void) getchar();

}

fprintf(stderr, "\nSpecial levels:\n");

for (x = svs.sp_levchn; x; x = x->next) {

fprintf(stderr, "%s (%d): ", x->proto, x->rndlevs);

fprintf(stderr, "on %d, %d; ", x->dlevel.dnum, x->dlevel.dlevel);

fprintf(stderr, "flags:%s%s%s%s\n",

x->flags.rogue_like ? " rogue_like" : "",

x->flags.maze_like ? " maze_like" : "",

x->flags.hellish ? " hellish" : "",

x->flags.town ? " town" : "");

(void) getchar();

}

fprintf(stderr, "\nBranches:\n");

for (br = svb.branches; br; br = br->next) {

fprintf(stderr, "%d: %s, end1 %d %d, end2 %d %d, %s\n", br->id,

br->type == BR_STAIR

? "stair"

: br->type == BR_NO_END1

? "no end1"

: br->type == BR_NO_END2

? "no end2"

: br->type == BR_PORTAL

? "portal"

: "unknown",

br->end1.dnum, br->end1.dlevel, br->end2.dnum,

br->end2.dlevel, br->end1_up ? "end1 up" : "end1 down");

}

(void) getchar();

fprintf(stderr, "\nDone\n");

(void) getchar();

return;

#undef DD

}

#endif

/* Save the dungeon structures. */

void

save_dungeon(

NHFILE *nhfp,

boolean perform_write,

boolean free_data)

{

int i, count;

branch *curr, *next;

mapseen *curr_ms, *next_ms;

if (perform_write) {

Sfo_int(nhfp, &svn.n_dgns, "dungeon_count");

for (i = 0; i < svn.n_dgns; ++i) {

Sfo_dungeon(nhfp, &svd.dungeons[i], "dungeon");

}

Sfo_dgn_topology(nhfp, &svd.dungeon_topology, "svd.dungeon_topology");

Sfo_char(nhfp, svt.tune, "tune", (int) sizeof tune);

for (count = 0, curr = svb.branches; curr; curr = curr->next)

count++;

Sfo_int(nhfp, &count, "branch_count");

for (curr = svb.branches; curr; curr = curr->next) {

Sfo_branch(nhfp, curr, "branch");

}

count = maxledgerno();

Sfo_int(nhfp, &count, "level_info_count");

for (i = 0; i < count; ++i) {

Sfo_linfo(nhfp, &svl.level_info[i], "svl.level_info");

}

Sfo_nhcoord(nhfp, &svi.inv_pos, "svi.inv_pos");

for (count = 0, curr_ms = svm.mapseenchn; curr_ms;

curr_ms = curr_ms->next)

count++;

Sfo_int(nhfp, &count, "mapseen_count");

for (curr_ms = svm.mapseenchn; curr_ms; curr_ms = curr_ms->next) {

save_mapseen(nhfp, curr_ms);

}

}

if (free_data) {

for (curr = svb.branches; curr; curr = next) {

next = curr->next;

free((genericptr_t) curr);

}

svb.branches = 0;

for (curr_ms = svm.mapseenchn; curr_ms; curr_ms = next_ms) {

next_ms = curr_ms->next;

if (curr_ms->custom)

free((genericptr_t) curr_ms->custom);

if (curr_ms->final_resting_place)

savecemetery(nhfp, &curr_ms->final_resting_place);

free((genericptr_t) curr_ms);

}

svm.mapseenchn = 0;

}

}

#endif /* !SFCTOOL */

/* Restore the dungeon structures. */

void

restore_dungeon(NHFILE *nhfp)

{

branch *curr, *last;

int count = 0;

int i;

mapseen *curr_ms, *last_ms;

Sfi_int(nhfp, &svn.n_dgns, "dungeon_count");

for (i = 0; i < svn.n_dgns; ++i) {

Sfi_dungeon(nhfp, &svd.dungeons[i], "dungeon");

}

Sfi_dgn_topology(nhfp, &svd.dungeon_topology, "svd.dungeon_topology");

Sfi_char(nhfp, svt.tune, "tune", (int) sizeof tune);

last = svb.branches = (branch *) 0;

Sfi_int(nhfp, &count, "branch_count");

for (i = 0; i < count; i++) {

curr = (branch *) alloc(sizeof *curr);

Sfi_branch(nhfp, curr, "branch");

curr->next = (branch *) 0;

if (last)

last->next = curr;

else

svb.branches = curr;

last = curr;

}

Sfi_int(nhfp, &count, "level_info_count");

if (count >= MAXLINFO)

panic("level information count larger (%d) than allocated size",

count);

for (i = 0; i < count; ++i) {

Sfi_linfo(nhfp, &svl.level_info[i], "svl.level_info");

}

Sfi_nhcoord(nhfp, &svi.inv_pos, "svi.inv_pos");

Sfi_int(nhfp, &count, "mapseen_count");

last_ms = (mapseen *) 0;

for (i = 0; i < count; i++) {

curr_ms = load_mapseen(nhfp);

curr_ms->next = (mapseen *) 0;

if (last_ms)

last_ms->next = curr_ms;

else

svm.mapseenchn = curr_ms;

last_ms = curr_ms;

}

}

#ifndef SFCTOOL

#if 0

staticfn void

Fread(genericptr_t ptr, int size, int nitems, dlb *stream)

{

int cnt;

if ((cnt = dlb_fread(ptr, size, nitems, stream)) != nitems) {

panic(

"Premature EOF on dungeon description file!\r\nExpected %d bytes - got %d.",

(size * nitems), (size * cnt));

nh_terminate(EXIT_FAILURE);

}

}

#endif

DISABLE_WARNING_UNREACHABLE_CODE

staticfn xint16

dname_to_dnum(const char *s)

{

xint16 i;

for (i = 0; i < svn.n_dgns; i++)

if (!strcmp(svd.dungeons[i].dname, s))

return i;

panic("Couldn't resolve dungeon number for name \"%s\".", s);

/*NOT REACHED*/

return (xint16) 0;

}

RESTORE_WARNING_UNREACHABLE_CODE

s_level *

find_level(const char *s)

{

s_level *curr;

for (curr = svs.sp_levchn; curr; curr = curr->next)

if (!strcmpi(s, curr->proto))

break;

return curr;

}

/* Find the branch that links the named dungeon. */

staticfn int

find_branch(

const char *s, /* dungeon name */

struct proto_dungeon *pd)

{

int i;

if (pd) {

for (i = 0; i < pd->n_brs; i++)

if (!strcmp(pd->tmpbranch[i].name, s))

break;

if (i == pd->n_brs)

panic("find_branch: can't find %s", s);

} else {

/* support for level tport by name */

branch *br;

const char *dnam;

for (br = svb.branches; br; br = br->next) {

dnam = svd.dungeons[br->end2.dnum].dname;

if (!strcmpi(dnam, s)

|| (!strncmpi(dnam, "The ", 4) && !strcmpi(dnam + 4, s)))

break;

}

i = br ? ((ledger_no(&br->end1) << 8) | ledger_no(&br->end2)) : -1;

}

return i;

}

DISABLE_WARNING_UNREACHABLE_CODE

/*

* Find the "parent" by searching the prototype branch list for the branch

* listing, then figuring out to which dungeon it belongs.

*/

staticfn xint16

parent_dnum(

const char *s, /* dungeon name */

struct proto_dungeon *pd)

{

int i;

xint16 pdnum;

i = find_branch(s, pd);

/*

* Got branch, now find parent dungeon. Stop if we have reached

* "this" dungeon (if we haven't found it by now it is an error).

*/

for (pdnum = 0; strcmp(pd->tmpdungeon[pdnum].name, s); pdnum++)

if ((i -= pd->tmpdungeon[pdnum].branches) < 0)

return pdnum;

panic("parent_dnum: couldn't resolve branch.");

/*NOT REACHED*/

return (xint16) 0;

}

RESTORE_WARNING_UNREACHABLE_CODE

/*

* Return a starting point and number of successive positions a level

* or dungeon entrance can occupy.

*

* Note: This follows the acouple (instead of the rcouple) rules for a

* negative random component (randc < 0). These rules are found

* in dgn_comp.y. The acouple [absolute couple] section says that

* a negative random component means from the (adjusted) base to the

* end of the dungeon.

*/

staticfn int

level_range(

xint16 dgn,

int base, int randc, int chain,

struct proto_dungeon *pd,

int *adjusted_base)

{

int lmax = svd.dungeons[dgn].num_dunlevs;

if (chain >= 0) { /* relative to a special level */

s_level *levtmp = pd->final_lev[chain];

if (!levtmp)

panic("level_range: empty chain level!");

base += levtmp->dlevel.dlevel;

} else { /* absolute in the dungeon */

/* from end of dungeon */

if (base < 0)

base = (lmax + base + 1);

}

if (base < 1 || base > lmax)

panic("level_range: base value out of range");

*adjusted_base = base;

if (randc == -1) { /* from base to end of dungeon */

return (lmax - base + 1);

} else if (randc) {

/* make sure we don't run off the end of the dungeon */

return (((base + randc - 1) > lmax) ? lmax - base + 1 : randc);

} /* else only one choice */

return 1;

}

staticfn xint16

parent_dlevel(const char *s, struct proto_dungeon *pd)

{

int i, j, num, base, dnum = parent_dnum(s, pd);

branch *curr;

i = find_branch(s, pd);

num = level_range(dnum, pd->tmpbranch[i].lev.base,

pd->tmpbranch[i].lev.rand, pd->tmpbranch[i].chain, pd,

&base);

/* KMH -- Try our best to find a level without an existing branch */

i = j = rn2(num);

do {

if (++i >= num)

i = 0;

for (curr = svb.branches; curr; curr = curr->next)

if ((curr->end1.dnum == dnum && curr->end1.dlevel == base + i)

|| (curr->end2.dnum == dnum && curr->end2.dlevel == base + i))

break;

} while (curr && i != j);

return (base + i);

}

/* Convert from the temporary branch type to the dungeon branch type. */

staticfn int

correct_branch_type(struct tmpbranch *tbr)

{

switch (tbr->type) {

case TBR_STAIR:

return BR_STAIR;

case TBR_NO_UP:

return tbr->up ? BR_NO_END1 : BR_NO_END2;

case TBR_NO_DOWN:

return tbr->up ? BR_NO_END2 : BR_NO_END1;

case TBR_PORTAL:

return BR_PORTAL;

}

impossible("correct_branch_type: unknown branch type");

return BR_STAIR;

}

/*

* Add the given branch to the branch list. The branch list is ordered

* by end1 dungeon and level followed by end2 dungeon and level. If

* extract_first is true, then the branch is already part of the list

* but needs to be repositioned.

*/

void

insert_branch(branch *new_branch, boolean extract_first)

{

branch *curr, *prev;

long new_val, curr_val, prev_val;

if (extract_first) {

for (prev = 0, curr = svb.branches; curr;

prev = curr, curr = curr->next)

if (curr == new_branch)

break;

if (!curr)

panic("insert_branch: not found");

if (prev)

prev->next = curr->next;

else

svb.branches = curr->next;

}

new_branch->next = (branch *) 0;

/* Convert the branch into a unique number so we can sort them. */

#define branch_val(bp) \

((((long) (bp)->end1.dnum * (MAXLEVEL + 1) + (long) (bp)->end1.dlevel) \

* (MAXDUNGEON + 1) * (MAXLEVEL + 1)) \

+ ((long) (bp)->end2.dnum * (MAXLEVEL + 1) + (long) (bp)->end2.dlevel))

/*

* Insert the new branch into the correct place in the branch list.

*/

prev = (branch *) 0;

prev_val = -1;

new_val = branch_val(new_branch);

for (curr = svb.branches; curr;

prev_val = curr_val, prev = curr, curr = curr->next) {

curr_val = branch_val(curr);

if (prev_val < new_val && new_val <= curr_val)

break;

}

if (prev) {

new_branch->next = curr;

prev->next = new_branch;

} else {

new_branch->next = svb.branches;

svb.branches = new_branch;

}

}

#undef branch_val

/* Add a dungeon branch to the branch list. */

staticfn branch *

add_branch(

int dgn, int child_entry_level,

struct proto_dungeon *pd)

{

static int branch_id = 0;

int branch_num;

branch *new_branch;

branch_num = find_branch(svd.dungeons[dgn].dname, pd);

new_branch = (branch *) alloc(sizeof(branch));

(void) memset((genericptr_t) new_branch, 0, sizeof(branch));

new_branch->next = (branch *) 0;

new_branch->id = branch_id++;

new_branch->type = correct_branch_type(&pd->tmpbranch[branch_num]);

new_branch->end1.dnum = parent_dnum(svd.dungeons[dgn].dname, pd);

new_branch->end1.dlevel = parent_dlevel(svd.dungeons[dgn].dname, pd);

new_branch->end2.dnum = dgn;

new_branch->end2.dlevel = child_entry_level;

new_branch->end1_up = pd->tmpbranch[branch_num].up ? TRUE : FALSE;

insert_branch(new_branch, FALSE);

return new_branch;

}

/*

* Add new level to special level chain. Insert it in level order with the

* other levels in this dungeon. This assumes that we are never given a

* level that has a dungeon number less than the dungeon number of the

* last entry.

*/

staticfn void

add_level(s_level *new_lev)

{

s_level *prev, *curr;

prev = (s_level *) 0;

for (curr = svs.sp_levchn; curr; curr = curr->next) {

if (curr->dlevel.dnum == new_lev->dlevel.dnum

&& curr->dlevel.dlevel > new_lev->dlevel.dlevel)

break;

prev = curr;

}

if (!prev) {

new_lev->next = svs.sp_levchn;

svs.sp_levchn = new_lev;

} else {

new_lev->next = curr;

prev->next = new_lev;

}

}

staticfn void

init_level(int dgn, int proto_index, struct proto_dungeon *pd)

{

s_level *new_level;

struct tmplevel *tlevel = &pd->tmplevel[proto_index];

pd->final_lev[proto_index] = (s_level *) 0; /* no "real" level */

if (!wizard && tlevel->chance <= rn2(100))

return;

pd->final_lev[proto_index] = new_level =

(s_level *) alloc(sizeof(s_level));

(void) memset((genericptr_t) new_level, 0, sizeof(s_level));

/* load new level with data */

Strcpy(new_level->proto, tlevel->name);

new_level->boneid = tlevel->boneschar;

new_level->dlevel.dnum = dgn;

new_level->dlevel.dlevel = 0; /* for now */

new_level->flags.town = !!(tlevel->flags & TOWN);

new_level->flags.hellish = !!(tlevel->flags & HELLISH);

new_level->flags.maze_like = !!(tlevel->flags & MAZELIKE);

new_level->flags.rogue_like = !!(tlevel->flags & ROGUELIKE);

new_level->flags.align = ((tlevel->flags & D_ALIGN_MASK) >> 4);

if (!new_level->flags.align)

new_level->flags.align =

((pd->tmpdungeon[dgn].flags & D_ALIGN_MASK) >> 4);

new_level->rndlevs = tlevel->rndlevs;

new_level->next = (s_level *) 0;

}

staticfn int

possible_places(

int idx, /* prototype index */

boolean *map, /* array MAXLEVEL+1 in length */

struct proto_dungeon *pd)

{

int i, start, count;

s_level *lev = pd->final_lev[idx];

/* init level possibilities */

for (i = 0; i <= MAXLEVEL; i++)

map[i] = FALSE;

/* get base and range and set those entries to true */

count = level_range(lev->dlevel.dnum, pd->tmplevel[idx].lev.base,

pd->tmplevel[idx].lev.rand, pd->tmplevel[idx].chain,

pd, &start);

for (i = start; i < start + count; i++)

map[i] = TRUE;

/* mark off already placed levels */

for (i = pd->start; i < idx; i++) {

if (pd->final_lev[i] && map[pd->final_lev[i]->dlevel.dlevel]) {

map[pd->final_lev[i]->dlevel.dlevel] = FALSE;

--count;

}

}

return count;

}

DISABLE_WARNING_UNREACHABLE_CODE

/* Pick the nth TRUE entry in the given boolean array. */

staticfn xint16

pick_level(

boolean *map, /* an array MAXLEVEL+1 in size */

int nth)

{

xint16 i;

for (i = 1; i <= MAXLEVEL; i++)

if (map[i] && !nth--)

return i;

panic("pick_level: ran out of valid levels");

/*NOTREACHED*/

return 0;

}

RESTORE_WARNING_UNREACHABLE_CODE

#ifdef DDEBUG

staticfn void indent(int);

staticfn void

indent(int d)

{

while (d-- > 0)

fputs(" ", stderr);

}

#endif

/*

* Place a level. First, find the possible places on a dungeon map

* template. Next pick one. Then try to place the next level. If

* successful, we're done. Otherwise, try another (and another) until

* all possible places have been tried. If all possible places have

* been exhausted, return false.

*/

staticfn boolean

place_level(int proto_index, struct proto_dungeon *pd)

{

boolean map[MAXLEVEL + 1]; /* valid levels are 1..MAXLEVEL inclusive */

s_level *lev;

int npossible;

#ifdef DDEBUG

int i;

#endif

if (proto_index == pd->n_levs)

return TRUE; /* at end of proto levels */

lev = pd->final_lev[proto_index];

/* No level created for this prototype, goto next. */

if (!lev)

return place_level(proto_index + 1, pd);

npossible = possible_places(proto_index, map, pd);

for (; npossible; --npossible) {

lev->dlevel.dlevel = pick_level(map, rn2(npossible));

#ifdef DDEBUG

indent(proto_index - pd->start);

fprintf(stderr, "%s: trying %d [ ", lev->proto, lev->dlevel.dlevel);

for (i = 1; i <= MAXLEVEL; i++)

if (map[i])

fprintf(stderr, "%d ", i);

fprintf(stderr, "]\n");

#endif

if (place_level(proto_index + 1, pd))

return TRUE;

map[lev->dlevel.dlevel] = FALSE; /* this choice didn't work */

}

#ifdef DDEBUG

indent(proto_index - pd->start);

fprintf(stderr, "%s: failed\n", lev->proto);

#endif

return FALSE;

}

static struct level_map {

const char *lev_name;

d_level *lev_spec;

} level_map[] = { { "air", &air_level },

{ "asmodeus", &asmodeus_level },

{ "astral", &astral_level },

{ "baalz", &baalzebub_level },

{ "bigrm", &bigroom_level },

{ "castle", &stronghold_level },

{ "earth", &earth_level },

{ "fakewiz1", &portal_level },

{ "fire", &fire_level },

{ "juiblex", &juiblex_level },

{ "knox", &knox_level },

{ "medusa", &medusa_level },

{ "oracle", &oracle_level },

{ "orcus", &orcus_level },

{ "rogue", &rogue_level },

{ "sanctum", &sanctum_level },

{ "valley", &valley_level },

{ "water", &water_level },

{ "wizard1", &wiz1_level },

{ "wizard2", &wiz2_level },

{ "wizard3", &wiz3_level },

{ "minend", &mineend_level },

{ "soko1", &sokoend_level },

{ X_START, &qstart_level },

{ X_LOCATE, &qlocate_level },

{ X_GOAL, &nemesis_level },

{ "", (d_level *) 0 }

};

#undef X_START

#undef X_LOCATE

#undef X_GOAL

staticfn int

get_dgn_flags(lua_State *L)

{

int dgn_flags = 0;

static const char *const flagstrs[] = {

"town", "hellish", "mazelike", "roguelike", "unconnected", NULL

};

static const int flagstrs2i[] = {

TOWN, HELLISH, MAZELIKE, ROGUELIKE, UNCONNECTED, 0

};

lua_getfield(L, -1, "flags");

if (lua_type(L, -1) == LUA_TTABLE) {

int f, nflags;

lua_len(L, -1);

nflags = (int) lua_tointeger(L, -1);

lua_pop(L, 1);

for (f = 0; f < nflags; f++) {

lua_pushinteger(L, f + 1);

lua_gettable(L, -2);

if (lua_type(L, -1) == LUA_TSTRING) {

dgn_flags |= flagstrs2i[luaL_checkoption(L, -1, NULL,

flagstrs)];

lua_pop(L, 1);

} else

impossible("flags[%i] is not a string", f);

}

} else if (lua_type(L, -1) == LUA_TSTRING) {

dgn_flags |= flagstrs2i[luaL_checkoption(L, -1, NULL, flagstrs)];

} else if (lua_type(L, -1) != LUA_TNIL)

impossible("flags is not an array or string");

lua_pop(L, 1);

return dgn_flags;

}

staticfn int

get_dgn_align(lua_State *L)

{

static const char *const dgnaligns[] = {

"unaligned", "noalign", "lawful", "neutral", "chaotic", NULL

};

static const int dgnaligns2i[] = {

D_ALIGN_NONE, D_ALIGN_NONE, D_ALIGN_LAWFUL,

D_ALIGN_NEUTRAL, D_ALIGN_CHAOTIC, D_ALIGN_NONE

};

int a = dgnaligns2i[get_table_option(L, "alignment",

"unaligned", dgnaligns)];

return a;

}

staticfn void

init_dungeon_levels(

lua_State *L,

struct proto_dungeon *pd,

int dngidx)

{

char *lvl_name, *lvl_bonetag, *lvl_chain;

int lvl_base, lvl_range, lvl_nlevels, lvl_chance,

lvl_align, lvl_flags;

struct tmplevel *tmpl;

int bi, f, nlevels;

lua_len(L, -1);

nlevels = (int) lua_tointeger(L, -1);

pd->tmpdungeon[dngidx].levels = nlevels;

lua_pop(L, 1);

for (f = 0; f < nlevels; f++) {

lua_pushinteger(L, f + 1);

lua_gettable(L, -2);

if (lua_type(L, -1) == LUA_TTABLE) {

lvl_name = get_table_str(L, "name");

lvl_bonetag = get_table_str_opt(L, "bonetag", emptystr);

lvl_chain = get_table_str_opt(L, "chainlevel", NULL);

lvl_base = get_table_int(L, "base");

lvl_range = get_table_int_opt(L, "range", 0);

lvl_nlevels = get_table_int_opt(L, "nlevels", 0);

lvl_chance = get_table_int_opt(L, "chance", 100);

lvl_align = get_dgn_align(L);

lvl_flags = get_dgn_flags(L);

/* array index is offset by cumulative number of levels

defined for preceding branches (iterations of 'while'

loop we're inside, not branch connections below) */

tmpl = &pd->tmplevel[pd->n_levs + f];

debugpline4("LEVEL[%i]:%s,(%i,%i)",

f, lvl_name, lvl_base, lvl_range);

tmpl->name = lvl_name;

tmpl->chainlvl = lvl_chain;

tmpl->lev.base = lvl_base;

tmpl->lev.rand = lvl_range;

tmpl->chance = lvl_chance;

tmpl->rndlevs = lvl_nlevels;

tmpl->flags = lvl_flags | lvl_align;

tmpl->boneschar = *lvl_bonetag ? *lvl_bonetag : 0;

free(lvl_bonetag);

tmpl->chain = -1;

if (lvl_chain) {

debugpline1("CHAINLEVEL: %s", lvl_chain);

for (bi = 0; bi < pd->n_levs + f; bi++) {

debugpline2("checking(%i):%s",

bi, pd->tmplevel[bi].name);

if (!strcmp(pd->tmplevel[bi].name, lvl_chain)) {

tmpl->chain = bi;

break;

}

}

if (tmpl->chain == -1)

panic("Could not chain level %s to %s",

lvl_name, lvl_chain);

/* free(lvl_chain); -- recorded in pd.tmplevel[] */

}

} else

panic("dungeon[%i].levels[%i] is not a hash", dngidx, f);

lua_pop(L, 1);

}

pd->n_levs += nlevels;

if (pd->n_levs > LEV_LIMIT)

panic("init_dungeon: too many special levels");

}

staticfn void

init_dungeon_branches(

lua_State *L,

struct proto_dungeon *pd,

int dngidx)

{

static const char *const brdirstr[] = { "up", "down", 0 };

static const int brdirstr2i[] = { TRUE, FALSE, FALSE };

static const char *const brtypes[] = {

"stair", "portal", "no_down", "no_up", 0

};

static const int brtypes2i[] = {

TBR_STAIR, TBR_PORTAL, TBR_NO_DOWN, TBR_NO_UP, TBR_STAIR

};

char *br_name, *br_chain;

int br_base, br_range, br_type, br_up;

struct tmpbranch *tmpb;

int bi, f, nbranches;

lua_len(L, -1);

nbranches = (int) lua_tointeger(L, -1);

pd->tmpdungeon[dngidx].branches = nbranches;

lua_pop(L, 1);

for (f = 0; f < nbranches; f++) {

lua_pushinteger(L, f + 1);

lua_gettable(L, -2);

if (lua_type(L, -1) == LUA_TTABLE) {

br_name = get_table_str(L, "name");

br_chain = get_table_str_opt(L, "chainlevel", NULL);

br_base = get_table_int(L, "base");

br_range = get_table_int_opt(L, "range", 0);

br_type = brtypes2i[get_table_option(L, "branchtype",

"stair", brtypes)];

br_up = brdirstr2i[get_table_option(L, "direction",

"down", brdirstr)];

tmpb = &(pd->tmpbranch[pd->n_brs + f]);

debugpline4("BRANCH[%i]:%s,(%i,%i)",

f, br_name, br_base, br_range);

tmpb->name = br_name;

tmpb->lev.base = br_base;

tmpb->lev.rand = br_range;

tmpb->type = br_type;

tmpb->up = br_up;

tmpb->chain = -1;

if (br_chain) {

debugpline1("CHAINBRANCH:%s", br_chain);

for (bi = 0; bi < pd->n_levs + f - 1; bi++)

if (!strcmp(pd->tmplevel[bi].name, br_chain)) {

tmpb->chain = bi;

break;

}

if (tmpb->chain == -1)

panic("Could not chain branch %s to level %s",

br_name, br_chain);

free(br_chain);

}

} else

panic("dungeon[%i].branches[%i] is not a hash", dngidx, f);

lua_pop(L, 1);

}

pd->n_brs += nbranches;

if (pd->n_brs > BRANCH_LIMIT)

panic("init_dungeon: too many branches");

}

staticfn void

init_dungeon_set_entry(struct proto_dungeon *pd, int dngidx)

{

int dgn_entry = pd->tmpdungeon[dngidx].entry_lev;

/*

* Set the entry level for this dungeon. The entry value means:

* < 0 from bottom (-1 == bottom level)

* 0 default (top)

* > 0 actual level (1 = top)

*

* Note that the entry_lev field in the dungeon structure is

* redundant. It is used only here and in print_dungeon().

*/

if (dgn_entry < 0) {

svd.dungeons[dngidx].entry_lev =

svd.dungeons[dngidx].num_dunlevs + dgn_entry + 1;

if (svd.dungeons[dngidx].entry_lev <= 0)

svd.dungeons[dngidx].entry_lev = 1;

} else if (dgn_entry > 0) {

svd.dungeons[dngidx].entry_lev = dgn_entry;

if (svd.dungeons[dngidx].entry_lev > svd.dungeons[dngidx].num_dunlevs)

svd.dungeons[dngidx].entry_lev = svd.dungeons[dngidx].num_dunlevs;

} else { /* default */

svd.dungeons[dngidx].entry_lev = 1; /* defaults to top level */

}

}

staticfn void

init_dungeon_set_depth(struct proto_dungeon *pd, int dngidx)

{

branch *br;

schar from_depth;

boolean from_up;

br = add_branch(dngidx, svd.dungeons[dngidx].entry_lev, pd);

/* Get the depth of the connecting end. */

if (br->end1.dnum == dngidx) {

from_depth = depth(&br->end2);

from_up = !br->end1_up;

} else {

from_depth = depth(&br->end1);

from_up = br->end1_up;

}

/*

* Calculate the depth of the top of the dungeon via

* its branch. First, the depth of the entry point:

*

* depth of branch from "parent" dungeon

* + -1 or 1 depending on an up or down stair or

* 0 if portal

*

* Followed by the depth of the top of the dungeon:

*

* - (entry depth - 1)

*

* We'll say that portals stay on the same depth.

*/

svd.dungeons[dngidx].depth_start =

from_depth + (br->type == BR_PORTAL ? 0 : (from_up ? -1 : 1))

- (svd.dungeons[dngidx].entry_lev - 1);

}

staticfn boolean

init_dungeon_dungeons(

lua_State *L,

struct proto_dungeon *pd,

int dngidx)