nexus/map.c

#include <assert.h>
#include <ctype.h>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "defs.h"
#include "flag.h"
#include "io.h"
#include "move.h"
#include "nexus.h"
#include "lf.h"
#include "map.h"
#include "objects.h"
#include "text.h"
#include "vault.h"

extern habitat_t *firsthabitat,*lasthabitat;
extern job_t *firstjob;
extern map_t *firstmap,*lastmap;
extern region_t *firstregion,*lastregion;
extern regionoutline_t *firstregionoutline,*lastregionoutline;
extern regiontype_t *firstregiontype,*lastregiontype;
extern celltype_t *firstcelltype, *lastcelltype;
extern objecttype_t *objecttype,*lastobjecttype;
extern race_t *firstrace;
extern int viewx,viewy,vieww,viewh;
extern lifeform_t *player;

extern lifeform_t *godlf[];
extern int ngodlfs;

extern glyph_t tempglyph;

extern enum OBCLASS sortorder[];

extern enum ERROR reason;

extern enum GAMEMODE gamemode;

extern int needredraw;

extern long curtime;

cell_t *addcell(map_t *m, int x, int y) {
	cell_t *cell;
	m->cell[(y*m->w)+x] = malloc(sizeof(cell_t));
	cell = m->cell[(y*m->w)+x];
	cell->map = m;
	cell->x = x;
	cell->y = y;
	cell->habitat = m->habitat;
	cell->obpile = addobpile(NOOWNER, cell, NOOB);
	setcelltype(cell, cell->habitat->solidcelltype);
	cell->lf = NULL;
	cell->room = NULL;
	cell->lit = L_NOTLIT;
	cell->origlit = L_NOTLIT;
	cell->littimer = 0;
	cell->origlittimer = 0;
	cell->writing = NULL;
	cell->known = B_FALSE;
	cell->knowntime = 0;
	cell->knownglyph.ch = ' ';
	cell->knownglyph.colour = C_GREY;
	cell->visited = B_FALSE;
	cell->filled =  B_FALSE;
	return cell;
}

habitat_t *addhabitat(enum HABITAT id, char *name, enum CELLTYPE emptycell, enum CELLTYPE solidcell, int thingchance, int obchance, int vaultchance, int maxvisrange) {
        habitat_t *a;
        // add to the end of the list 
        if (firsthabitat == NULL) {
                firsthabitat = malloc(sizeof(habitat_t));
                a = firsthabitat;
                a->prev = NULL;
        } else {
                // go to end of list
                a = lasthabitat;
                a->next = malloc(sizeof(habitat_t));
                a->next->prev = a;
                a = a->next;
        }
        lasthabitat = a;
        a->next = NULL;

	// props
	a->id = id;
	a->name = strdup(name);
	a->emptycelltype = emptycell;
	a->solidcelltype = solidcell;
	a->randthingpct = thingchance;
	a->randobpct = obchance;
	a->randvaultpct = vaultchance;
	a->maxvisrange = maxvisrange;
	return a;
}

void addhomeobs(lifeform_t *lf) {
	flag_t *f;
	for (f = lf->flags->first ; f ; f = f->next) {
		if (f->id == F_HOMEOB) {
			addob(lf->cell->obpile, f->text);
		} else if (f->id == F_HOMELEVOB) {
			int i,amt;
			amt = rnd(f->val[0],f->val[1]);
			for (i = 0; i < amt; i++) {
				cell_t *c;
				// pick new EMPTY random spot
				c = getrandomcell(lf->cell->map);
				while (!cellwalkable(NULL, c, NULL)) {
					c = getrandomcell(lf->cell->map);
				}
				addob(c->obpile, f->text);
			}
		}
	}
}

map_t *addmap(void) {
        map_t *a;
	int id;
	int i;
	// is there already a map?
	if (lastmap) {
		id = lastmap->id + 1;
	} else {
		id = 0;
	} 

        // add to the end of the list 
        if (firstmap == NULL) {
                firstmap = malloc(sizeof(map_t));
                a = firstmap;
                a->prev = NULL;
        } else {
                // go to end of list
                a = lastmap;
                a->next = malloc(sizeof(map_t));
                a->next->prev = a;
                a = a->next;
        }
        lastmap = a;
        a->next = NULL;

	// props
	a->id = id;
	a->lf = NULL;
	for (i = 0; i < MAXDIR_ORTH; i++) {
		a->nextmap[i] = -1;
	}
	a->flags = addflagpile(NULL, NULL);
	a->beingcreated = B_TRUE;
	a->habitat = findhabitat(H_DUNGEON); // default!!!
	a->lastplayervisit = -1;
	a->nfixedrooms = 0; 
	return a;
}


// when monsters are made during level generation, autogen will be true. otherwise false;
// if "rid" RR_NONE, paste racename to get the race.
// otherwise just use the given race.
lifeform_t *addmonster(cell_t *c, enum RACE rid, char *racename, int jobok, int amt, int autogen, int *nadded) {
	lifeform_t *lf = NULL;
	race_t *r;
	int db = B_FALSE;
	flagpile_t *wantflags = NULL;
	enum JOB wantjob = J_NONE;

	if (nadded) *nadded = 0;

	// ie. don't create mosnters on closed doors!
	if (!cellwalkable(NULL, c, NULL)) {
		return NULL;
	}

	if (rid != R_SPECIFIED) {
		if (rid == R_RANDOM) {
			r = getrandomrace(c, NA);
		} else {
			r = findrace(rid);
		}
	} else {
		// get params
		wantflags = addflagpile(NULL, NULL);

		rid = parserace(racename, wantflags, &wantjob);

		if (rid == R_RANDOM) {
			r = getrandomrace(c, NA);
		} else {
			r = findrace(rid);
		}
	}
	if (!r) {
		return NULL;
	}
	
	if (db) {
		char buf[BUFLEN];
		snprintf(buf, BUFLEN, "addmonster for '%s'->%s",racename, r->name);
		dbtimestart(buf);
	}

	//if (db) dblog("adding rand lf %s to cell %d,%d",r->name,c->x,c->y);

	if (r) {
		if (db) dbtime("doing lf addition");

		if (hasflag(r->flags, F_UNIQUE)) {
			// does it already exist?
			lf = findlfunique(rid);

			// if so, move it here, then exit.
			if (lf) {
				teleportto(lf, c, B_FALSE);
				return lf;
			}
		} 

		lf = addlf(c, r->id, getrandommonlevel(r, c->map));
		if (db) dbtime("finished lf addition");
		if (lf) {
			flag_t *f;
		
			if (nadded) (*nadded)++;

			if (db) dbtime("checking for job");
			lf->born = B_FALSE;

			if (wantjob == J_NONE) {
				if (jobok) {
					for (f = lf->flags->first ; f ; f = f->next) {
						// has a job?
						if (f->id == F_STARTJOB) {
							if (rnd(1,100) <= f->val[0]) {
								if (f->val[1] == J_RANDOM) {
									job_t *j;
									j = getrandomjob(B_TRUE);
									wantjob = j->id;
								} else {
									wantjob = f->val[1];
								}
								givejob(lf, wantjob);
								break;
							}
						}
					}
				}
			} else {
				givejob(lf, wantjob);
			}

			if (autogen) {
				// sometimes start off hiding/asleep in new maps
				f = lfhasflag(lf, F_STARTHIDDENPCT);
				if (f) {
					if (rnd(1,100) <= f->val[0]) {
						// note:  if we start off hidden, we have no hide penalty.
						// this is so we can have monsters which start hidden, but
						// don't have the 'hide' skill. 
						addflag(lf->flags, F_HIDING, 0, NA, NA, NULL);
					}
				}
				if (!lfhasflag(lf, F_HIDING) && !lfhasflag(lf, F_DEAF) && cansleep(lf) ) {
					int asleepchance = 70;
					f = lfhasflag(lf, F_STARTASLEEPPCT);
					if (f) {
						asleepchance = f->val[0];
					}
					// TODO: base this on the time, and whether monster is nocturnal
					if (pctchance(asleepchance)) {
						addflag(lf->flags, F_ASLEEP, B_TRUE, NA, NA, NULL); 
					}
				}
			}

			// appears in groups?
			if (db) dbtime("handling groups");
			if (autogen) {
				f = hasflag(lf->flags, F_NUMAPPEAR);
				if (f) {
					// override amount
					amt = rnd(f->val[0], f->val[1]);
				}
				if (amt > 1) {
					cell_t *adjcell;
					amt--; // we've already added one

					//adjcell = c;
					for ( ; amt > 0; amt--) {
						lifeform_t *newlf;
						// find an adjacent cell to one of the newly added monsters,
						// starting with the first one
						adjcell = real_getrandomadjcell(c, WE_WALKABLE, B_ALLOWEXPAND, LOF_WALLSTOP, NULL);
						// did we find one?
						if (!adjcell) break;

						newlf = addlf(adjcell, r->id, getrandommonlevel(r, adjcell->map));
						if (!newlf) {
							break;
						}
						if (nadded) (*nadded)++;
						newlf->born = B_FALSE;

						// initial monster shoudl remember its minions
						addflag(lf->flags, F_MINION, newlf->id, NA, NA, NULL);

						// if master is asleep, minions will also be asleep
						if (lfhasflag(lf, F_ASLEEP)) {
							addflag(newlf->flags, F_ASLEEP, B_TRUE, NA, NA, NULL); 
						}

						// minions never have certain flags.
						killflagsofid(newlf->flags, F_DEMANDSBRIBE);

						newlf->born = B_TRUE;
					}
				}
			}

			// minons?
			// appears in groups?
			if (db) dbtime("handling minions");
			if (autogen) {
				f = hasflag(lf->flags, F_MINIONS);
				if (f) {
					if (rnd(1,100) <= f->val[0]) {
						int n;
						cell_t *adjcell;
						int nminions;
						// override amount
						nminions = rnd(f->val[1], f->val[2]);

						for (n = 0; n < nminions; n++) {
							lifeform_t *newlf;
							race_t *newr;

							adjcell = real_getrandomadjcell(c, WE_WALKABLE, B_ALLOWEXPAND, LOF_WALLSTOP, NULL);
							if (!adjcell) break;

							newr = findracebyname(f->text);
							if (!newr) break;

							newlf = addlf(adjcell, newr->id, getrandommonlevel(newr, adjcell->map));
							if (!newlf) break;

							if (nadded) (*nadded)++;

							newlf->born = B_FALSE;
							if (lfhasflag(lf, F_ASLEEP)) addflag(newlf->flags, F_ASLEEP, B_TRUE, NA, NA, NULL); 
							newlf->born = B_TRUE;
						}
					}
				}
			}

			
			if (db) dbtime("handling random objects");
			// sometimes give the lf random objects (extra monsters through 
			// 'numappears' don't get them.
			if (lfhasflag(lf, F_HUMANOID) && !lfhasflag(lf, F_NOPACK)) {
				if (rnd(1,3) == 1) {
					int nobs = rnd(1,3);
					char buf[BUFLEN];
					int i;
					for (i = 0; i < nobs; i++) {
						if (getrandomob(c->map, buf)) {
							object_t *o;
							o = addob(lf->pack, buf);
							if (o && !canpickup(lf, o, o->amt)) {
								killob(o);
							}
						}
					}
				}
			}

			if (db) dbtime("giving torches");
			// humanoids on dark levels which can't see will probably have some
			// kind of light producing device
			if (!islit(c) && !hasflag(lf->flags, F_SEEINDARK) && !hasflag(lf->flags, F_TREMORSENSE)) {
				if (lfhasflag(lf, F_HUMANOID)) {
					objecttype_t *ot, *poss[MAXCANDIDATES];
					int nposs = 0;
					// get a random light-producing object
					for (ot = objecttype ; ot ; ot = ot->next) {
						if (hasflag(ot->flags, F_OPERABLE) &&
						    hasflagval(ot->flags, F_ACTIVATECONFER, F_PRODUCESLIGHT, NA, NA, NULL)) {
							poss[nposs++] = ot;
						}
					}
					if (nposs > 0) {
						ot = poss[rnd(0,nposs-1)];
					} else {
						ot = NULL;
					}
					if (ot) {
						object_t *o;
						o = addobfast(lf->pack, ot->id);
						if (o) turnon(NULL, o);
					}
				}
			}

			if (wantflags) {
				// wantflags?
				copyflags(lf->flags, wantflags, NA);
			}
		
			lf->born = B_TRUE;
		} // end if lf
	} 

	// free mem
	if (wantflags) {
		killflagpile(wantflags);
	}

	if (db) dbtimeend("finished addmonster");

	return lf;
}

object_t *addrandomob(cell_t *c) {
	char buf[BUFLEN];
	int db = B_FALSE;
	object_t *o = NULL;

	if (c->type->solid) {
		return NULL;
	}

	if (real_getrandomob(c->map, buf, RO_NONE, NA, NA, c->habitat->id, SZ_MAX)) {
		if (db) dblog("adding rand obj %s to cell %d,%d",buf,c->x,c->y);
		o = addob(c->obpile, buf);
	}
	return o;
}

int addrandomthing(cell_t *c, int obchance, int *nadded) {
	int rv = TT_NONE;

	// if there's already someone there,
	// then add an object.
	if (!cellwalkable(NULL, c, NULL) || (rnd(1,100) <= obchance)) {
		object_t *o;
		// object
		o = addrandomob(c);
		if (o) {
			if (nadded) *nadded = o->amt;
			rv = TT_OBJECT;
		}
	} else {
		// monster
		if (addmonster(c, R_RANDOM, NULL, B_TRUE, 1, B_TRUE, nadded)) {
			rv = TT_MONSTER;
		} 
	}
	return rv;
}

map_t *getmapindir(map_t *src, int dir) {
	map_t *other = NULL;
	if (src->nextmap[dir] != -1) {
		other = findmap(src->nextmap[dir]);
	} else {
		if (dir == D_DOWN) {
			other = findregionmap(src->region->id, src->depth+1);
		} else {
			other = findregionmap(src->region->id, src->depth-1);
		}
	}
	return other;
}

// 
int getmapmaxvisrange(map_t *m) {
	int maxrange;

	maxrange = m->habitat->maxvisrange;

	// modify for darkness outside ?
	if (isoutdoors(m)) {
		int hours,mins,secs;
		float pct;
		splittime(&hours,&mins,&secs);
		pct =  ((float)mins/59.0) * 100.0;
		if (hours == 6) { // ie. 6am - 7am
			// getting lighter.  as minutes approach 59,
			// visrange gets closer to maximum.
			maxrange = pctof( pct, maxrange);
			limit(&maxrange, 1, NA);
		} else if (hours == 18) { // ie. 6pm-7pm
			// getting darker.  as minutes approach 59,
			// visrange gets closer to zero.
			maxrange = pctof( 100 - pct, maxrange);
			limit(&maxrange, 1, NA);
		}
	} else if (m->habitat->id == H_DUNGEON) {
		// in dungeon, reduce distance based on depth (ie. ambient light)
		maxrange -= m->depth;
	}

	limit(&maxrange, 0, MAXVISRANGE);

	return maxrange;
}

// populates retcell[] with all cells within given radius of centre
// if 'scatter' is >0, then not all cells will be returned - as you approach the edge of the radius,
// chances of getting the cells are lowered
void getradiuscells(cell_t *centre, int radius, int dirtype, enum LOFTYPE needlof, int wantcentre, cell_t **retcell, int *ncells, int scatterdensity) {
	int (*distfunc)(cell_t *, cell_t *);
	int x,y;
	cell_t *c;

	*ncells = 0;

	if (!centre) {
		return;
	}
	if (dirtype == DT_ORTH) {
		distfunc = getcelldistorth;
	} else {
		distfunc = getcelldist;
	}
	for (y = centre->y - radius; y <= centre->y + radius; y++) {
		for (x = centre->x - radius; x <= centre->x + radius; x++) {
			c = getcellat(centre->map, x,y);
			if (c) {
				int distance;
				distance = distfunc(centre, c);
				if (haslof(centre, c, needlof, NULL) && (distance <= radius) &&
					(wantcentre || (c != centre)) ) {
					int chance;
					if (scatterdensity) {
						chance = 100 - (((float)distance / (float)radius) * scatterdensity);
					} else {
						chance = 100;
					}
					if (pctchance(chance)) {
						retcell[*ncells] = c;
						(*ncells)++;
					}
				}
			}
		}
	}
}

int getroomid(cell_t *c) {
	if (c->room) {
		return c->room->id;
	} 
	return -1;
}

// whichside should be D_ORTH
// for now, this function will NOT include room corners
void getroomedge(map_t *map, int roomid, int minx, int miny, int maxx, int maxy, int whichside, cell_t **retcell, int *ncells, int onlywantsolid) {
	int x,y;
	cell_t *c;
	*ncells = 0;
	if (whichside == D_N) {
		y = miny;
		for (x = minx+1; x <= maxx-1; x++) {
			c = getcellat(map, x, y);
			if (!onlywantsolid || c->type->solid) {
				retcell[*ncells] = getcellat(map, x, y);
				(*ncells)++;
			}
		}
	} else if (whichside == D_S) {
		y = maxy;
		for (x = minx+1; x <= maxx-1; x++) {
			c = getcellat(map, x, y);
			if (!onlywantsolid || c->type->solid) {
				retcell[*ncells] = getcellat(map, x, y);
				(*ncells)++;
			}
		}
	} else if (whichside == D_W) {
		x = minx;
		for (y = miny+1; y <= maxy-1; y++) {
			c = getcellat(map, x, y);
			if (!onlywantsolid || c->type->solid) {
				retcell[*ncells] = getcellat(map, x, y);
				(*ncells)++;
			}
		}
	} else if (whichside == D_E) {
		x = maxx;
		for (y = miny+1; y <= maxy-1; y++) {
			c = getcellat(map, x, y);
			if (!onlywantsolid || c->type->solid) {
				retcell[*ncells] = getcellat(map, x, y);
				(*ncells)++;
			}
		}
	}
}

// if outlineid is -1, it's automatically assigned
region_t *addregion(enum REGIONTYPE rtype, region_t *parent, int outlineid) {
        region_t *a;
	regionoutline_t *ro,*poss[MAXCANDIDATES];
	int nposs = 0;
	int id;
	// is there already a region?
	if (lastregion) {
		id = lastregion->id + 1;
	} else {
		id = 0;
	} 

        // add to the end of the list 
        if (firstregion == NULL) {
                firstregion = malloc(sizeof(region_t));
                a = firstregion;
                a->prev = NULL;
        } else {
                // go to end of list
                a = lastregion;
                a->next = malloc(sizeof(region_t));
                a->next->prev = a;
                a = a->next;
        }
        lastregion = a;
        a->next = NULL;

	// props
	a->id = id;
	a->rtype = findregiontype(rtype);
	a->parentregion = parent;

	if (outlineid == -1) {
		// randomly assign a regionoutline
		for (ro = firstregionoutline; ro ; ro = ro->next) {
			if (ro->rtype->id == rtype) {
				poss[nposs++] = ro;
			}
		}
		// make sure we got one...
		if (nposs) {
			a->outline = poss[rnd(0,nposs-1)];
		} else {
			a->outline = NULL;
		}
	} else {
		a->outline = findoutline(outlineid);
		assert(a->outline);
	}
	return a;
}

regionoutline_t *addregionoutline(enum REGIONTYPE rtype) {
        regionoutline_t *a;

        // add to the end of the list 
        if (firstregionoutline == NULL) {
                firstregionoutline = malloc(sizeof(regionoutline_t));
                a = firstregionoutline;
                a->prev = NULL;
        } else {
                // go to end of list
                a = lastregionoutline;
                a->next = malloc(sizeof(regionoutline_t));
                a->next->prev = a;
                a = a->next;
        }
        lastregionoutline = a;
        a->next = NULL;

	// props
	if (a == firstregionoutline) {
		a->id = 0;
	} else {
		a->id = lastregionoutline->id + 1;
	}
	a->rtype = findregiontype(rtype);
	a->nthings = 0;
	return a;
}

regionthing_t *addregionthing(regionoutline_t *ro, int depth, int x, int y, enum REGIONTHING whatkind, int value, char *what) {
	regionthing_t *rt;
	rt = &(ro->thing[ro->nthings]);
	rt->depth = depth;
	rt->x = x;
	rt->y = y;
	rt->whatkind = whatkind;
	rt->value = value;
	if (what) {
		rt->what = strdup(what);
	} else {
		rt->what = strdup("");
	}

	ro->nthings++;

	if (ro->nthings >= MAXOUTLINETHINGS) {
		dblog("error - too many outlinethings!");
		printf("error - too many outlinethings!\n");
		exit(1);
	}
	return rt;
}

regiontype_t *addregiontype(enum REGIONTYPE id, char *name, enum HABITAT defaulthabitat, int maxdepth, int stairsperlev, int deeperdir, int major) {
        regiontype_t *a;

        // add to the end of the list 
        if (firstregiontype == NULL) {
                firstregiontype = malloc(sizeof(regiontype_t));
                a = firstregiontype;
                a->prev = NULL;
        } else {
                // go to end of list
                a = lastregiontype;
                a->next = malloc(sizeof(regiontype_t));
                a->next->prev = a;
                a = a->next;
        }
        lastregiontype = a;
        a->next = NULL;

	// props
	a->id = id;
	a->name = strdup(name);
	a->defaulthabitat = defaulthabitat;
	a->maxdepth = maxdepth;
	a->stairsperlev = stairsperlev;
	a->deeperdir = deeperdir;
	a->majorbranch = major;
	return a;
}


int autodoors(map_t *map, int roomid, int minx, int miny, int maxx, int maxy, int doorpct, int dooropenchance) {
	int i,d;
	cell_t *poss[MAXCANDIDATES], *cell[MAXCANDIDATES]; // TODO: should this be maxroomw * maxroomh ?
	int ncells = 0, npossible = 0;
	int doorsadded = 0;
	int db = B_FALSE;

	// for each side, make list of all possible door locations
	// then pick one randomly.
	// BUT if the nearby corridor only has one exit, always
	// place a door.
	for (d = D_N; d <= D_W; d++) {
		npossible = 0;
		getroomedge(map, roomid, minx, miny, maxx, maxy, d, cell, &ncells, B_TRUE);
		for (i = 0; i < ncells; i++) {
			cell_t *newcell;
			// is there empty space on the other side of this wall segment?
			newcell = getcellindir(cell[i], d);
			if (newcell && !newcell->type->solid) {
				int doorcount;
				// if so, make sure there are no other adjacent doors
				doorcount = countadjcellswithflag(cell[i], F_DOOR, DT_ORTH);
				if (doorcount == 0) {
					// if there is only one way out of the adjacent empty cell, and
					// walls to either side of the potential door location, then
					// always add a door
					if ((countcellexits(newcell) == 1) && wallstoleftright(newcell, d)) {
						if (rnd(1,100) <= doorpct) {
							makedoor(cell[i], dooropenchance);
						} else {
							setcelltype(cell[i], cell[i]->habitat->emptycelltype);
							addflag(map->flags, F_ROOMEXIT, roomid, cell[i]->x, cell[i]->y, NULL);
						}
					} else {
						// otherwise mark this as a _potential_ door location.
						poss[npossible] = cell[i];
						npossible++;
					}
				}
			}
		}

		// if we have potential door locations, add one somewhere along this wall.
		if (npossible > 0) {
			int sel;
			sel = rnd(0,npossible-1);

			if (rnd(1,100) <= doorpct) {
				makedoor(poss[sel], dooropenchance);
			} else {
				setcelltype(poss[sel], poss[sel]->habitat->emptycelltype);
				addflag(map->flags, F_ROOMEXIT, roomid, poss[sel]->x, poss[sel]->y, NULL);
			}

			doorsadded++;
		}
	} // end foreach direction


	if (doorsadded == 0) {
		int i,d,used[MAXDIR_ORTH],poss[MAXDIR_ORTH];
		int dodoor[MAXDIR_ORTH];
		int ndodoors = 0;
		int ndoors,nposs = 0;

		int sel;
		//
		for (d = D_N; d <= D_W; d++) {
			used[d] = B_FALSE;
		}
		// no possible door locations - add a random number
		ndoors = rnd(1,4);

		for (i = 0; i < ndoors; i++) {
			// find a dir we haven't already used
			nposs = 0;
			for (d = D_N; d <= D_W; d++) {
				if (!used[d]) poss[nposs++] = d;
			}
			if (nposs <= 0) {
				break;
			}
			sel = rnd(0,nposs-1);
			used[poss[sel]] = B_TRUE; 
			dodoor[ndodoors++] = poss[sel];
		}

		// actually make the doors
		for (i = 0; i < ndodoors; i++) {
			int sel;
			d = dodoor[i];
			getroomedge(map, roomid, minx, miny, maxx, maxy, d, cell, &ncells, B_TRUE);
			if (ncells) {
				sel = rnd(0,ncells-1);
				if (rnd(1,100) <= doorpct) {
					makedoor(cell[sel], dooropenchance);
					doorsadded++;
				} else {
					setcelltype(cell[sel], cell[sel]->habitat->emptycelltype);
					addflag(map->flags, F_ROOMEXIT, roomid, cell[sel]->x, cell[sel]->y, NULL);
					doorsadded++;
				}
			}
		}
	}
	if (db) dblog("autodoors() added %d doors to roomid %d", doorsadded, roomid);
	return doorsadded;
}


int cellhaslos(cell_t *c1, cell_t *dest) {
        int deltax, deltay;
        int numpixels;
        int d;
        int dinc1,dinc2,xinc1,xinc2,yinc1,yinc2;
	int xinc,yinc,dinc;
        int i;
	int x1,y1;
        int x;
        int y;
	//int wentuphill = B_FALSE;
	//int origheight;
	//int shopwall;
	int x2,y2;
	map_t *map;

	if (!dest) return B_FALSE;

	// let the player see when dead, otherwise the screen wil
	// go black when "You die" appears.
	map = c1->map;


	x1 = c1->x;
	y1 = c1->y;
	x2 = dest->x;
	y2 = dest->y;



        deltax = (x2 - x1);
        if (deltax < 0) deltax = -deltax;
        deltay = (y2 - y1);
        if (deltay < 0) deltay = -deltay;

	// can always see your own cell
	if ((deltax == 0) && (deltay == 0)) {
		return B_TRUE;
	} 

	if (deltax >= deltay) {
                numpixels = deltax + 1;
                d = (deltay*2) - deltax;
                dinc1 = deltay << 1;
                dinc2 = (deltay-deltax) << 1;
                xinc1 = 1;
                xinc2 = 1;
                yinc1 = 0;
                yinc2 = 1;
        } else {
                numpixels = deltay + 1;
                d = (deltax*2) - deltay;
                dinc1 = deltax << 1;
                dinc2 = (deltax - deltay) << 1;
                xinc1 = 0;
                xinc2 = 1;
                yinc1 = 1;
                yinc2 = 1;
        }

        if (x1 > x2) {
                xinc1 = - xinc1;
                xinc2 = - xinc2;
        }
        if (y1 > y2) {
                yinc1 = - yinc1;
                yinc2 = - yinc2;
        }

        x = x1; y = y1;

        for (i = 0; i < numpixels ; i++) {
		cell_t *cell;

		// don't need to move out of the last one
		if ((x == x2) && (y == y2)) {
			break;
		}

		if (d < 0) {
			xinc = xinc1;
			yinc = yinc1;
			dinc = dinc1;
		} else {
			xinc = xinc2;
			yinc = yinc2;
			dinc = dinc2;
		}


		// you can always see your own cell
		if (i != 0) {
			// solid cells stop los - but if you are standing on a solid
			// cell you can still see out.
			cell = getcellat(map, x, y);
			if (!cell->type->transparent) {
				return B_FALSE;
			}
			
			/*
			// check for smoke
			if ((x != x1) || (y != y1)) { // if not in first cell
				if (hasopaqueobject(viewer, x,y,z) && (getheight(x,y,z) >= origheight)) {
					if (!hasproplf(viewer, P_SEEINSMOKE)) {
						return B_FALSE;
					}
				}
			}
			*/

			// check for objects which block view
			if (hasobwithflag(cell->obpile, F_BLOCKSVIEW)) {
				return B_FALSE;
			}

		}

		// move to next cell
		d += dinc;
		x += xinc;
		y += yinc;
        }

	// made it to the target cell!
	return B_TRUE;
}

void clearcell(cell_t *c) {
	// kill everything there - (lifeforms &&  objects)
	if (c->lf && !isplayer(c->lf)) {
		killlf(c->lf);
	}
	while (c->obpile->first) {
		killob(c->obpile->first);
	}
	if (gamemode == GM_GAMESTARTED) {
		c->known = B_FALSE;
		c->knownglyph.ch = ' ';
		c->knownglyph.colour = C_GREY;
	}
}
void clearcell_exceptflags(cell_t *c, ... ) {
	va_list args;
	enum FLAG exception[MAXCANDIDATES];
	int nexceptions = 0,i;
	object_t *o,*nexto;
	va_start(args, c);
	exception[nexceptions] = va_arg(args, enum FLAG);
	while (exception[nexceptions] != F_NONE) {
		nexceptions++;
		exception[nexceptions] = va_arg(args, enum FLAG);
	}
	va_end(args);
	assert(nexceptions < MAXCANDIDATES);

	if (c->lf && !isplayer(c->lf)) {
		killlf(c->lf);
	}

	for (o = c->obpile->first ; o ; o = nexto) {
		int exclude = B_FALSE;
		nexto = o->next;
		for (i = 0; i < nexceptions; i++) {
			if (hasflag(o->flags, exception[i])) {
				exclude = B_TRUE;
				break;
			}
		}
		if (!exclude) killob(o);
	}

	if (gamemode == GM_GAMESTARTED) {
		c->known = B_FALSE;
		c->knownglyph.ch = ' ';
		c->knownglyph.colour = C_GREY;
	}
}

// returns true if something happened
int dowaterspread(cell_t *c) {
	float thisdepth;
	int i;
	int nsurround = 0;
	int db = B_FALSE;
	cell_t *surroundcell[8];

	if (!c || c->type->solid || hascloseddoor(c)) {
		return B_FALSE;
	}

	// calculate depth of this cell
	thisdepth = getcellwaterdepth(c, NULL);

	if (!thisdepth) return B_FALSE;

	// count surrounding cells of lower depth
	for (i = DC_N; i <= DC_NW; i++) {
		cell_t *newc;

		newc = getcellindir(c, i);
		if (newc && !newc->type->solid && !hascloseddoor(newc)) {
			float newcdepth;
			int ok = B_FALSE;

			/* 
			FIX THIS CODE LATER
			if (newc->type->floorheight == c->type->floorheight) {
				// same height - don't include these???
				ok = B_FALSE;
				//ok = B_TRUE;
			} else if (newc->type->floorheight < c->type->floorheight) {
				// ie. downhill. don't include these 
				ok = B_FALSE;
			} else if (newc->type->floorheight > c->type->floorheight) {
				// ie. uphill. 
				ok = B_TRUE;
			}
			*/
			if (newc->type->floorheight == c->type->floorheight) {
				ok = B_TRUE;
			} else {
				ok = B_FALSE;
			}

			if (ok) {
				newcdepth = getcellwaterdepth(newc, NULL);

				if (newcdepth < thisdepth) {
					surroundcell[nsurround] = newc;
					nsurround++;
				}
			}
		}
	}

	
	// if there were any posisble cells around us
	if (nsurround) {
		float newdepth;

		//newdepth = thisdepth / (pctof(nsurround,50)+1);
		newdepth = thisdepth / (pctof(nsurround,55)+1);
		//newdepth = thisdepth / (nsurround+1);
		limitf(&newdepth,(float)DP_NONE, (float)DP_MAX);

		if (db) dblog("waterspread:  cell %d,%d (%d/%s) spreads to %d cells-->%d/%s",
			c->x, c->y, (int)thisdepth, getwaterdepthname((int)thisdepth),
			nsurround, (int)newdepth, getwaterdepthname((int)newdepth));

		// SET our cell to new depth
		setwaterdepth(c, (int)newdepth);

		// ADD water to surrounding cells
		for (i = 0; i < nsurround; i++) {
			cell_t *sc;
			flag_t *f;

			sc = surroundcell[i];
		
			f = hasflagval(sc->map->flags, F_NEWWATERDEPTH, sc->x, sc->y, NA, NULL);
			if (f) {
				f->val[2] += newdepth;
			} else {
				addflag(sc->map->flags, F_NEWWATERDEPTH, sc->x, sc->y, (int)newdepth, NULL);
			}
		}
	
		return B_TRUE;
	}
	return B_FALSE; 
}

void fix_reachability(map_t *m) {
	int i,keepgoing = B_TRUE, nfixed = 0;
	int db = B_TRUE;
	cell_t *c = NULL;

	if (db) dblog("fix_reachability starting.");

	switch (m->habitat->id) {
		case H_FOREST:
		case H_HEAVEN:
		case H_PIT:
		case H_VILLAGE:
			if (db) dblog("fix_reachability not required for this habitat.");
			return;
		default: break;
	}

	// find first non-empty cell
	for (i = 0; i < m->w * m->h; i++) {
		if (!m->cell[i]->type->solid) {
			c = m->cell[i];
			break;
		}
	}
	// no empty cells in map?
	if (!c) return;
	while (keepgoing) {
		keepgoing = B_FALSE;
		// mark all cells as non-filled
		for (i = 0; i < m->w * m->h; i++) {
			m->cell[i]->filled = FALSE;
		}
		// floodfill
		floodfill(c);
		// any remaining non-filled empty cells?
		for (i = 0; i < m->w * m->h; i++) {
			if (!m->cell[i]->type->solid && !m->cell[i]->filled) {
				int nadded = 0;
				// found an unreachable cell!  link it back to a filled cell.
				if (db) dblog("   found unreachable area at %d,%d.  will fix it.",
					m->cell[i]->x, m->cell[i]->y);

				linkexit(m->cell[i], B_TRUE, &nadded);
				if (db) dblog("   fixed unreachable area by adding %d cells.", nadded);
				assert(nadded);
				
				// now run the test again.
				// 'c' will be where the next flood will will happen.
				keepgoing = B_TRUE;
				c = m->cell[i];
				nfixed++;
				break;
			}
		}
	}
	if (db) dblog("   fix_reachability complete.  fixed %d unreachable areas.", nfixed);
}


void floodfill(cell_t *startcell) {
	int d;
	if (startcell && 			// not off the map
		!startcell->type->solid && 	// empty cell
		!startcell->filled) {		// not already filled
		startcell->filled = B_TRUE;
	} else {
		return;
	}
	for (d = DC_N; d <= DC_NW; d++) {
		floodfill(getcellindir(startcell, d)); // recursive call
	}
}

cell_t *getcellat(map_t *map, int x, int y) {
	if (!isonmap(map, x, y)) return NULL;
	return map->cell[y*map->w + x];
}

int getcelldist(cell_t *src, cell_t *dst) {
	double xd,yd;
	// use pythag
	xd = abs(dst->x - src->x);
	yd = abs(dst->y - src->y);
	return (int)sqrt(xd*xd + yd*yd);
}

int getcelldistorth(cell_t *src, cell_t *dst) { // add x/y
	return abs(dst->x - src->x) + abs(dst->y - src->y);
}

//populates 'g' with the contects of cell 'c', as seen by 'viewer'
// if we don't have LOS to there, set g->ch to NUL.
void getcellglyph(glyph_t *g, cell_t *c, lifeform_t *viewer) {
	glyph_t tempgl;

	// default
	g->ch = ' ';
	g->colour = C_RED;

	if (haslos(viewer, c)) {
		// show cell contents
		if (c->lf && cansee(viewer, c->lf)) { // lifeform here which we can see
			// draw the lf's race glyph
			*g = *(getlfglyph(c->lf));
			if (isprone(c->lf)) {
				g->ch = flip(g->ch);
			}
			if (lfhasflag(c->lf, F_FROZEN)) {
				g->colour = C_CYAN;
			}
			return;
		} else { // we can see the floor here
			void *thing;
			// scanned lf here?
			if (isinscanrange(c, &thing, NULL, &tempgl) == TT_MONSTER) {
				*g = tempgl;
				//mvwprintw(gamewin, y-viewy, x-viewx, "%c", glyph);
				//drawglyph(&glyph, x, y);
				return;
			}
			// otherwise fall through
		}

		// objects here?
		if ((countobs(c->obpile, B_FALSE) > 0)) {
			object_t *o;

			// draw highest object in sort order
			o = gettopobject(c, B_TRUE);
			if (o && !hasflag(o->flags, F_NOGLYPH)) {
				// return the object's glyph
				*g = *(getglyph(o));
			} else {
				// objects here, but we can't see them. draw the cell.
				*g = c->type->glyph;
				if (!islit(c)) {
					g->colour = C_BLUE;
				}
			}
		} else {
			// draw cell normally
			//drawcell(cell, x, y);
			*g = c->type->glyph;
			if (!islit(c)) {
				g->colour = C_BLUE;
			}
		}
	} else { // can't see the cell
		void *thing;
		//drawscannedcell(cell, x-viewx, y-viewy);
		switch (isinscanrange(c, &thing, NULL, &tempgl)) {
			case TT_MONSTER:
			case TT_OBJECT:
				*g = tempgl;
				break;
			default:
				if (c->known) {
					// copy from cell
					/*
					*g = c->type->glyph;
					*/
					*g = c->knownglyph;
					if (g->ch == '.') {
						g->ch = ' ';
					}
					// out of LOS - show as dark 
					// TODO: if terminal supports it, use C_DARKGREY instead.
					g->colour = C_BLUE;
				}
				break;
		}
	}
}


enum DEPTH getcellwaterdepth(cell_t *c, lifeform_t *lf) {
	object_t *o;
	o = hasobwithflag(c->obpile, F_DEEPWATER);
	if (o) {
		return getobdepth(o, lf);
	}
	return DP_NONE;
}


int getdoorlockdiff(int depth) {
	return 19 + depth;
}
int getdoorsecretdiff(int depth) {
	return 20 + (depth / 2);
}

flag_t *getmapcoords(map_t *m, int *x, int *y) {
	flag_t *f;
	f = hasflag(m->flags, F_MAPCOORDS);
	if (f) {
		if (x) *x = f->val[0];
		if (y) *y = f->val[1];
		return f;
	}
	if (x) *x = -999;
	if (y) *y = -999;
	return NULL;
}


int getmapdifficulty(map_t *m) {
	int diff = 1;
	if (m) {
		if (isoutdoors(m)) {
			int x,y;
			// depth is distance from 0,0
			getmapcoords(m, &x, &y);
			diff = (abs(x) + abs(y))+1;
		} else {
			diff = m->depth;
		}
	} else {
		diff = rnd(1,MAXDEPTH);
	}
	return diff;
}


// forglyph will be true if we are using this function for the purpose
// of figuring out which glyph to draw
object_t *gettopobject(cell_t *where, int forglyph) {
	object_t *o,*oo = NULL;
	enum LFSIZE largest = SZ_MINI;
	int c;

	// get largest known impassable object first
	for (o = where->obpile->first ; o ; o = o->next) {
		flag_t *f;
		// ignore hidden traps, but not secret doors
		if (hasflag(o->flags, F_SECRET) && !isdoor(o, NULL)) {
		} else if (hasflag(o->flags, F_TRAIL) && !canseeob(player, o)) {
		} else if (forglyph && hasflag(o->flags, F_NOGLYPH)) {
		} else {
			f = hasflag(o->flags, F_IMPASSABLE);
			if (f && (f->val[1] > largest)) {
				largest = f->val[1];
				oo = o;
			}
		}
	}
	if (oo) {
		return oo;
	}

	// otherwise draw highest object in sort order
	c = 0;
	while (sortorder[c] != OC_NULL) {
		// check each object against this ob class
		// count backwards so more recently dropped objects
		// appear first.
		for (o = where->obpile->last ; o ; o = o->prev) {
			if (o->type->obclass->id == sortorder[c]) {
				if (hasflag(o->flags, F_SECRET)) {
				} else if (hasflag(o->flags, F_TRAIL) && !canseeob(player, o)) {
				} else if (forglyph && hasflag(o->flags, F_NOGLYPH)) {
				} else {
					return o;
				}
			}
		}
		c++;
	}
	return NULL;
}

void calclight(map_t *map) {
	int x,y;
	cell_t *c;
	int i;

	// remember lit values for cells in player's los
	if (gamemode == GM_GAMESTARTED) {
		for (i = 0; i < player->nlos; i++) {
			player->los[i]->lastlit = player->los[i]->lit;
		}
	}
	
	for (y = 0; y < map->h; y++) {
		for (x = 0; x < map->w; x++) {
			c = getcellat(map, x,y);
			//if (c && (c->lit == L_PERMLIGHT) && (c->lit != L_PERMDARK)) c->lit = B_FALSE;
			c->lastlit = c->lit;
			if (c && (c->lit != L_PERMLIGHT) && (c->lit != L_PERMDARK)) c->lit = B_FALSE;
		}
	}
	for (y = 0; y < map->h; y++) {
		for (x = 0; x < map->w; x++) {
			c = getcellat(map, x,y);
			if (c) {
				int radius;
				object_t *o;

				// lit based on depth
				if (isoutdoors(map)) {
					int hours,mins,secs;
					splittime(&hours,&mins,&secs);
					if (isnighttime()) {
						// ie. nighttime, after 7pm or before 5am
					} else {
						// ie. daytime
						makelit(c, L_PERMLIGHT, -1);
					}
				} else {
					if ((map->depth <= 5) && (c->lit != L_PERMDARK)) {
						makelit(c, L_PERMLIGHT, -1);
					}
				}

				// TODO: has dark producing lf?
				// TODO: has dark producing object?

				// has lightproducing lf? (ie.hasflag f_produceslight)
				if (c->lf) {
					radius = lfproduceslight(c->lf);
					if (radius) {
						makelitradius(c, radius, L_TEMP, -1);
					}
				}
				// has light-producing object on ground?
				for (o = c->obpile->first ; o ; o = o->next) {
					radius = obproduceslight(o);
					if (radius) {
						makelitradius(c, radius, L_TEMP, -1);
					}
				}
				
			}
		}
	}
	// did any lit values within player's los change?
	if (gamemode == GM_GAMESTARTED) {
		for (i = 0; i < player->nlos; i++) {
			if (player->los[i]->lastlit != player->los[i]->lit) {
				needredraw = B_TRUE;
				break;
			}
		}
	}
}

int calcroompos(map_t *map, int w, int h, int xmargin, int ymargin, int *bx, int *by, int force) {
	int x,y,i;
	int bestscore = 9888;
	coord_t coord[MAX_MAPW*MAX_MAPH];
	int coordscore[MAX_MAPW*MAX_MAPH];
	int ncoords = 0;
	coord_t poss[MAX_MAPW*MAX_MAPH];
	int nposs = 0;
	cell_t *cell;
	int sel;
	int db = B_FALSE;
	int foundvalid = B_FALSE;

	// init coords list
	for (y = 1 + ymargin; y < (map->h - ymargin); y++) {
		for (x = 1 + xmargin; x < (map->w - xmargin); x++) {
			coord[ncoords].x = x;
			coord[ncoords].y = y;
			ncoords++;
		}
	}

	// try placing room at all positions
	for (i = 0; i < ncoords; i++) {
		int score = 9999;
		x = coord[i].x;
		y = coord[i].y;
		// would the room fit here?
		if ( ((x + w) <= (map->w - xmargin)) && 
		     ((y + h) <= (map->h - ymargin))) { 
			int valid = B_TRUE;
			int rx,ry;
			score = 0;
			// calculate score if we placed the room with its top left corner here.
			for (ry = y; (ry < y+h) && valid; ry++) {
				for (rx = x; (rx < x+w) && valid; rx++) {
					int includethiscell = B_FALSE;
					cell = getcellat(map, rx,ry);
					// is this cell adjacent to an empty cell and not a
					// corner (ie. a valid door location)
					if (countcellexits(cell)) {
						score++;
						if ( ((ry == y) && (rx == x))  ||
						     ((ry == y) && (rx == (x+w-1)))  ||
						     ((ry == y+h-1) && (rx == x))  ||
						     ((ry == y+h-1) && (rx == (x+w-1))) ) {
							// corner. don't check this cell for scores.
						} else {
							includethiscell = B_TRUE;	
						}
					}
					if (includethiscell) {
						// is this cell empty itself?
						if (!cell->type->solid) score += 3;
						// avoid being adjacent to other room walls
						if (countcellexits(cell)) score++;

						score += (countadjrooms(cell)*3);

						// overlapping another room?
						if (isroom(cell)) {
							if (force) {
								score += 10;
							} else {
								valid = B_FALSE;
							}
						}
						// NEVER create it on top of the player!
						// (normally this can't happen, but debugging via 'create
						//  vault' could do it)
						if (cell->lf && isplayer(cell->lf)) { 
							valid = B_FALSE;
						}
					}
				}
			}
			if (valid) {
				if (score < bestscore) {
					bestscore = score;
					foundvalid = B_TRUE;
				}
			} else {
				score = 9999;
			}
		}
		coordscore[i] = score;
		if (db) dblog("cell %d,%d - score %d",x,y,score);
	}

	if (foundvalid) {
		// now go through and make a list of all BEST positions 
		nposs = 0;
		for (i = 0; i < ncoords; i++) {
			if (coordscore[i] == bestscore) {
				poss[nposs++] = coord[i];
			}
		}
	} else {
		nposs = 0;
	}

	if (nposs == 0) {
		*bx = -1;
		*by = -1;
		return B_TRUE;
	} else {
		// pick a random one
		sel = rnd(0,nposs-1);
		if (db) dblog("calcroompos - %d possibilities (bestscore=%d), selected #%d.", nposs, bestscore, sel);

		*bx = poss[sel].x;
		*by = poss[sel].y;
	}

	return B_FALSE;
}

int countadjcellswithflag(cell_t *cell, enum FLAG fid, int dirtype) {
	int d;
	int count = 0;
	int start, end;
	cell_t *newcell;
	if (dirtype == DT_ORTH) {
		start = D_N;
		end = D_W;
	} else {
		start = DC_N;
		end = DC_NW;
	}
	for (d = start; d <= end; d++) {
		newcell = getcellindir(cell, d);
		if (newcell && hasobwithflag(newcell->obpile, fid)) {
			count++;
		}
	}
	return count;
}

int countadjcellsoftype(cell_t *cell, int id) {
	int d;
	int count = 0;
	cell_t *newcell;
	for (d = D_N; d < MAXDIR_ORTH; d++) {
		newcell = getcellindir(cell, d);
		if (newcell && newcell->type->id == id) {
			count++;
		}
	}
	return count;
}

int countadjrooms(cell_t *cell) {
	int d;
	int count = 0;
	cell_t *newcell;
	for (d = D_N; d < MAXDIR_ORTH; d++) {
		newcell = getcellindir(cell, d);
		if (newcell && isroom(newcell)) {
			count++;
		}
	}
	return count;
}

int countadjwalls(cell_t *cell) {
	int d;
	int walls = 0;
	
	for (d = DC_N; d <= DC_NW; d++) {
		cell_t *newcell;
		newcell = getcellindir(cell, d);
		if (!newcell || newcell->type->solid) {
			walls++;
		}
	}
	return walls;
}

int countcellexits(cell_t *cell) {
	int d;
	int exits = 0;
	cell_t *newcell;
	assert(cell);
	for (d = D_N; d < MAXDIR_ORTH; d++) {
		newcell = getcellindir(cell, d);
		if (newcell && !newcell->type->solid) {
			exits++;
		}
	}
	return exits;
}

int countcellexitsfor(lifeform_t *lf) {
	int d;
	int exits = 0;
	assert(lf);
	for (d = DC_N; d <= DC_NW; d++) {
		if (moveclear(lf, d, NULL)) {
			exits++;
		}
	}
	return exits;
}

int countlfs(map_t *map) {
	lifeform_t *lf;
	int count = 0;
	for (lf = map->lf ; lf ; lf = lf->next) {
		count++;
	}
	return count;
}

int countmapobs(map_t *m, enum OBTYPE oid) {
	cell_t *c;
	int count = 0,x,y;

	for (y = 0; y < m->h; y++) {
		for (x = 0; x < m->w; x++) {
			c = getcellat(m, x, y);
			if (c) {
				count += countobsoftype(c->obpile, oid);
			}
		}
	}
	return count;
}

// 
void createdungeon(map_t *map, int depth, map_t *parentmap, int exitdir, object_t *entryob) {
	int wantrooms = B_TRUE;
	int d;
	int x,y;
	int i;
	int done,unused;
	int dir;
	int lastdir;
	int numrooms = 0;
	int roomw[MAXROOMS],roomh[MAXROOMS];
	vault_t *roomvault[MAXROOMS];
	//int roomspecial[MAX_MAPROOMS];
	//int bestx,besty;
	//int w,h;
	//int startdir,forcex,forcey,ntries;
	cell_t *cell, *c;
	object_t *o;
	int db = B_FALSE;

	// parameters
	int turnpct = DEF_TURNPCT;
	int sparseness = DEF_SPARSENESS;
	int looppct = DEF_LOOPPCT;
	int minrooms = MINROOMS;
	int maxrooms = MAXROOMS;

	int moved = 0;

	enum CELLTYPE emptycell,solidcell;
	
	// fill entire maze with walls
	for (y = 0; y < map->h; y++) {
		for (x = 0; x < map->w; x++) {
			addcell(map, x, y);
		}
	}


	// what kind of cells will 'empty' ones be?
	emptycell = map->habitat->emptycelltype;
	solidcell = map->habitat->solidcelltype;

	// pick initial random spot 
	cell = getrandomcell(map);
	setcelltype(cell, emptycell);
	cell->visited = B_TRUE;
	//if (db) printf("- Starting (%d,%d)\n",cell->x, cell->y);

	lastdir = D_UNKNOWN;
	done = B_FALSE;

	dir = D_NONE;

	while (!done) {
		// get random direction based on turnpct
		dir = D_NONE;
		while (dir == D_NONE) {	
			int badcount;
			//if (db) printf("- At (%d,%d), moved %d, finding new direction...\n",cell->x, cell->y, moved);
		
			dir = getnewdigdir(cell, lastdir, (moved < 2) ? 0 : turnpct, &moved);

			badcount = 0;
			while (dir == D_NONE) {
				badcount++;
				if (badcount > 10) {
					// finish!
					done = B_TRUE;
					break;
				}
				
				// pick new EMPTY random spot
				cell = getrandomcell(map);
				while (!isempty(cell)) {
					cell = getrandomcell(map);
				}
				//if (db) printf("--- Couldn't find a valid direction.  Jumped to (%d,%d).\n",cell->x, cell->y);
				// pick a new random dir
				dir = getnewdigdir(cell, lastdir, turnpct, &moved);
			}
			if (!done) {
				//if (db) printf("- Digging %s from (%d,%d).\n",getdirname(dir),cell->x, cell->y);
			}
		}

		if (!done) {
			// move to adjacent cell in the given direction
			cell = getcellindir(cell, dir);
			//if (db) printf("- Now at (%d,%d)\n",cell->x, cell->y);
			moved++;
			
			// blank it
			setcelltype(cell,emptycell);
			cell->visited = B_TRUE;
			// mark surrounding cells as visited
			for (d = DC_N; d < MAXDIR_COMPASS; d++) {
				cell_t *thiscell;
				thiscell = getcellindir(cell, d);
				if (thiscell) {
					//if (db) printf("* Marking surrounding cell in dir %d (%d,%d) as visited.\n",d, thiscell->x, thiscell->y);
					thiscell->visited = B_TRUE;
				}
			}
			// remember last direction
			lastdir = dir;

			// check if we have visited all valid cells
			unused = 0;
			for (y = 0; y < map->h; y++) {
				for (x = 0; x < map->w; x++) {
					cell_t *thiscell;
					thiscell = getcellat(map, x, y);
					if (!thiscell->visited) {
						unused++;
					}
				}
			}

			if (!unused) {
				done = B_TRUE;
			}
		}

		//printf("%d unused cell(s)\n",unused);
		//dumpmap(map);
		//getchar();

	}

	// use sparseness to cut down dead ends
	remove_deadends(map, sparseness);

	// introduce loops
	for (y = 0; y < map->h; y++) {
		for (x = 0; x < map->w; x++) {
			cell = getcellat(map, x, y);
			if (!cell->type->solid && countcellexits(cell) == 1) {
				// dead end - maybe make loop from here
				if (rnd(1,100) <= looppct) {
					int connected = B_FALSE;
					int loopok = B_TRUE;
					int dir;

					// pick a random directory
					dir = getnewdigdir(cell, D_UNKNOWN,100, &moved);
				
					if (dir == D_NONE) {	
						// can't make a loop from here.
						loopok = B_FALSE;
					} else { 
						int tries = 0;
						// if we go this dir, will we hit a 
						// corridor?
						while (!isloopdirok(cell, dir)) {
							tries++;
							// tried every direction?
							if (tries >= MAXDIR_ORTH) {
								loopok = B_FALSE;
								break;
							}
							// turn... 
							if (++dir >= MAXDIR_ORTH) {
								dir = 0;
							}
						}
					}

					if (loopok) {
						// keep digging until we hit another corridor
						while (!connected) { 
							cell_t *newcell;
							// find adjacent cell in the given direction
							newcell = getcellindir(cell, dir);
							if (!newcell) {
								connected = B_TRUE;
							} else {
								// have we hit another corridor yet?
								if (!newcell->type->solid) {
									connected = B_TRUE;
								} else {
									// blank adjacent cell
									setcelltype(newcell, emptycell);
									newcell->visited = B_TRUE;
								}
								cell = newcell;
							}
						}
					}
				}
			}
		}
	}

	// adjust min/maxrooms based on fixed vaults
	minrooms -= map->nfixedrooms;
	maxrooms -= map->nfixedrooms;
	limit(&minrooms, 0, NA);
	limit(&maxrooms, 0, NA);

	// create rooms
	if (wantrooms && (maxrooms > 0)) {
		numrooms = rnd(minrooms, maxrooms);

		//printf("using %d rooms\n",numrooms);
		//dblog("Adding %d rooms...\n",numrooms);
		for (i = 0; i < numrooms; i++) {
			// maybe make it a special room
			roomvault[i] = NULL;
			if (rnd(1,100) <= map->habitat->randvaultpct) {
				vault_t *v;
				v = getvaulttype(map);
				if (createvault(map, i, v, &roomw[i],&roomh[i], NULL, NULL)) {
					// failed
				} else {
					// success
					roomvault[i] = v;
				} 
			}
			if (!roomvault[i]) {
				int rx,ry;
				// just do a normal room
				createroom(map, i, NA, NA, DEF_VAULTMARGIN, DEF_VAULTMARGIN, &rx, &ry, &roomw[i],&roomh[i], 50, B_FALSE);
				roomvault[i] = B_FALSE;
			}
		}
	}

	// now clear up dead ends again.
	remove_deadends(map, sparseness);

	// link up room exits
	for (i = 0; i < map->nrooms; i++) {
		if (!map->room[i].exitslinked) {
			linkexits(map, map->room[i].id);
		}
	}

	// add staircases.
	//     first dungeon level has 1 up stairs, 3 down.
	//     subsequent levels always have 3 up and down stairs

	// UP STAIRS
	if (map->depth == 1) { 
		flag_t *f;
		// first region level. just one exit stairs
		c = NULL;
		while (!c || !isempty(c) || countobs(c->obpile, B_TRUE)) {
			c = getrandomroomcell(map, ANYROOM);
		}
		o = addobfast(c->obpile, OT_STAIRSUP);
		// have to force these stairs to go back to a different region.
		f = hasflag(o->flags, F_CLIMBABLE);
		f->val[1] = map->region->parentregion->id;
		linkstairs(o, NULL);

		// special case: first dungeon level has barriers over the exit stairs
		if (map->region->rtype->id == RG_FIRSTDUNGEON) {
			if (c->lf) killlf(c->lf);
			addobfast(c->obpile, OT_MAGICBARRIER);
			// also clear all the cells around it to prevent reachability errors
			for (d = DC_N; d <= DC_NW; d++) {
				cell_t *c2;
				c2 = getcellindir(c, d);
				if (c2) setcelltype(c2, map->habitat->emptycelltype);
			}
		}
	} else {
		for (i = 0; i < map->region->rtype->stairsperlev; i++) {
			c = NULL;
			while (!c || !isempty(c) || countobs(c->obpile, B_TRUE)) {
				c = getrandomroomcell(map, ANYROOM);
			}
			o = addobfast(c->obpile, OT_STAIRSUP);
			linkstairs(o, NULL);
		}
	}
	// make sure we have at least one up stairs
	assert(findobinmap(map, OT_STAIRSUP));

	// DOWN STAIRS
	if (map->depth < map->region->rtype->maxdepth) {
		for (i = 0; i < map->region->rtype->stairsperlev; i++) {
			c = NULL;
			while (!c || !isempty(c) || countobs(c->obpile, B_TRUE)) {
				c = getrandomroomcell(map, ANYROOM);
			}
			o = addobfast(c->obpile, OT_STAIRSDOWN);
			linkstairs(o, NULL);
		}
	}

	// add pillars & objects & monsters to rooms
	if (wantrooms && (numrooms > 0)) {
		for (i = 0; i < numrooms; i++) {
			if (!roomvault[i] || hasflag(roomvault[i]->flags, F_AUTOPOPULATE)) {
				int numobsmin,numobsmax,numobs,n;
				int maxpillars;

				//dblog("Adding obs to room %d/%d",i+1,numrooms);
				maxpillars = (roomw[i] / 4) + (roomh[i] / 4);
				// add pillars first
				if ((maxpillars > 0) && pctchance(PCTCH_PILLAR)) {
					int n;
					int numpillars;
					numpillars = rnd(1,maxpillars);
					if (db) dblog("--> Will add %d pillars",numpillars);
					for (n = 0; n < numpillars;n++ ) {
						//dblog("----> Adding pillar %d/%d",n+1,numpillars);
						cell_t *c;
						c = getrandomroomcell(map, i);

						if (c && isempty(c)  && !countobs(c->obpile, B_TRUE)) {
							setcelltype(cell, CT_WALL);
						}
					}
				}

				numobsmin = 0;
				numobsmax = MAXOF(roomw[i],roomh[i]) / 2;
				//numobsmax = MAXOF(roomw[i],roomh[i]);
		
				// then objects/monsters
				if (numobsmax <= numobsmin) {
					numobs = numobsmin;
				} else {
					numobs = rnd(numobsmin,numobsmax);
				}
				if (db) dblog("--> Will add %d objects to room %d (of %d)",numobs,i,numrooms);
				for (n = 0 ; n < numobs; n++) {
					int ntries = 0;
					int nmonsters = 0;
					cell_t *c;
					done = B_FALSE;
					while (!done) {
						c = getrandomroomcell(map, i);
						// if nothing there
						if (c && cellwalkable(NULL, c, NULL)) {

							int obchance;
							int nadded = 0;

							// limit # monster per room to depth+1
							if (nmonsters >= (depth+1)) {
								obchance = 100;
							} else {
								// slightly more chance of objects in rooms
								obchance = c->habitat->randobpct + 10;
							}

							if (addrandomthing(c,obchance, &nadded) == TT_MONSTER) {
								nmonsters += nadded;
							}
							done = B_TRUE;
						} else {
							ntries++;
						}

						if (ntries >= numobs) {
							done = B_TRUE;
							break;
						}
					}
				}
			} // end if !vault
		} // end foreach room
	} // end if wantrooms & nrooms>0
	if (db) dblog("Finished adding stuff to rooms.");

	// now do a border
	y = 0;
	for (x = 0; x < map->w; x++) {
		// n
		c = getcellat(map, x, 0);
		clearcell(c);
		setcelltype(c,solidcell);
		// s
		c = getcellat(map, x, map->h-1);
		clearcell(c);
		setcelltype(c,solidcell);
	}
	for (y = 1; y < map->h-1; y++) {
		// w
		c = getcellat(map, 0, y);
		clearcell(c);
		setcelltype(c,solidcell);
		// e
		c = getcellat(map, map->w-1, y);
		clearcell(c);
		setcelltype(c,solidcell);
	}
}

void createforest(map_t *map, int depth, map_t *parentmap, int exitdir, object_t *entryob, int nclearings) {
	int x,y;
	enum CELLTYPE emptycell;
	int i;
	int ntrees;
	int density;
	cell_t *c;
	char buf[BUFLEN];
	cell_t *retcell[MAXCANDIDATES];
	int nretcells;
	//object_t *o;
	
	// fill entire maze with emptiness
	emptycell = map->habitat->emptycelltype;
	for (y = 0; y < map->h; y++) {
		for (x = 0; x < map->w; x++) {
			c = addcell(map, x, y);
			setcelltype(c, emptycell);
		}
	}

	
	switch (rnd(1,2)) {
		case 1: // forest type 1:  add trees in x% of cells, then add some clearings
			// determine density
			density = rnd(40,70);
			// add a plant to density percent of cells 
			ntrees = (int)(((float)density/100.0) * (float)(map->w*map->h));
			for (i = 0; i < ntrees; i++) {
				c = getrandomcell(map);
				while (c->lf) c = getrandomcell(map);
				switch (rnd(0,1)) {
					default: case 0: strcpy(buf, "tree"); break;
					case 1: strcpy(buf, "shrub"); break;
				}
				addob(c->obpile, buf);
			}
			// clearings
			for (i = 0; i < nclearings; i++) {
				int w,n;
				c = getrandomcell(map);
				w = rnd(MINCLEARINGRADIUS,MAXCLEARINGRADIUS);
				// clear obs in all clearing cells
				getradiuscells(c, w, DT_ORTH, LOF_DONTNEED, B_TRUE, retcell, &nretcells, B_FALSE);
				for (n = 0; n < nretcells; n++) {
					// kill all obs here
					while (retcell[n]->obpile->first) killob(retcell[n]->obpile->first);
				}

				// fill some cells with dirt
				getradiuscells(c, w, DT_ORTH, LOF_DONTNEED, B_TRUE, retcell, &nretcells, 70);
				for (n = 0; n < nretcells; n++) {
					setcelltype(retcell[n], CT_DIRT);
				}
			}
			break;
		case 2: //  add clusters of trees
			nclearings = rnd(5,10);
			for (i = 0; i < nclearings; i++) {
				int w,n;
				c = getrandomcell(map);
				while (c->lf) c = getrandomcell(map);

				w = rnd(MINCLEARINGRADIUS,MAXCLEARINGRADIUS);

				getradiuscells(c, w, DT_ORTH, LOF_DONTNEED, B_TRUE, retcell, &nretcells, 80);
				for (n = 0; n < nretcells; n++) {
					switch (rnd(0,1)) {
						default: case 0: strcpy(buf, "tree"); break;
						case 1: strcpy(buf, "shrub"); break;
					}
					addob(retcell[n]->obpile, buf);
				}
			}
			break;
	}
}


void createhabitat(map_t *map, int depth, map_t *parentmap, int exitdir, object_t *entryob) {
	switch (map->habitat->id) {
		case H_DUNGEON:
			createdungeon(map, depth, parentmap, exitdir, entryob);
			break;
		case H_FOREST:
			createforest(map, depth, parentmap, exitdir, entryob, rnd(0,5));
			break;
		case H_VILLAGE:
			createforest(map, depth, parentmap, exitdir, entryob, 0);
			break;
		case H_HEAVEN:
			createheaven(map, depth, parentmap, exitdir, entryob);
			break;
		case H_PIT:
			createpit(map, depth, parentmap, exitdir, entryob);
			break;
		default:
			dblog("ERROR - createhabitat with invalid habitat!");
			msg("ERROR - createhabitat with invalid habitat!");
	}
}

void createheaven(map_t *map, int depth, map_t *parentmap, int exitdir, object_t *entryob) {
	int x,y;
	enum CELLTYPE emptycell;
	cell_t *c;
	race_t *r;
	lifeform_t *lf;
	//object_t *o;
	
	// what kind of cells will 'empty' ones be?
	emptycell = map->habitat->emptycelltype;
	// fill entire maze with corridors
	for (y = 0; y < map->h; y++) {
		for (x = 0; x < map->w; x++) {
			c = addcell(map, x, y);
			setcelltype(c, emptycell);
		}
	}

	// add one of each god.
	for (r = firstrace ; r ; r = r->next) {
		if (r->raceclass->id == RC_GOD) {
			// find a position
			c = getrandomcell(map);
			while (!cellwalkable(NULL, c, NULL)) {
				c = getrandomcell(map);
			}
			// place god
			lf = addmonster(c, r->id, NULL, B_FALSE, 1, B_FALSE, NULL);
			assert(lf);
			// add to god list
			godlf[ngodlfs++] = lf;
			if (ngodlfs > MAXGODS) {
				dblog("Error - number of gods(%d) exceeds MAXGODS.",ngodlfs);
				msg("Error - number of gods(%d) exceeds MAXGODS.",ngodlfs);
				exit(1);
			}
		}
	}
}


/*
	seed = random number seed
	turnpct = percentage change of a corridor turning
	sparseness = how many times to chop off dead ends
	looppct = percentage change of turning dead-end into loop
	maxrooms = max # of rooms
*/
void createmap(map_t *map, int depth, region_t *region, map_t *parentmap, int exitdir, object_t *entryob) {
	lifeform_t *lf;
	map_t *m;
	char buf[BUFLEN],buf2[BUFLEN];
	int i,x,y;
	enum HABITAT habitat;
	regionthing_t *thing[MAXOUTLINETHINGS];
	int nthings = 0;
	int db = B_FALSE;

	// determine habitat based on region
	// note: we might override this later based on our region outline
	habitat = region->rtype->defaulthabitat;

	/*
	if ((region->rtype->id == RG_WORLDMAP) && (depth == 1)) {
		firstworldmap = B_TRUE;
	}
	*/
	map->beingcreated = B_TRUE;
	
	map->depth = depth;
	map->region = region;
	
	if (db) {
		getregionname(buf, map, B_FALSE);
		dblog("Creating new map of region '%s'",buf);
	}
	map->habitat = findhabitat(habitat);

	map->nrooms = 0;

	// link to other maps if required.
	// default to no links
	for (i = D_N; i <= D_W; i++) {
		map->nextmap[i] = -1;
	}
	for (i = D_UP; i <= D_DOWN; i++) {
		map->nextmap[i] = -1;
	}

	// look for adjacent maps above/below this one
	if (db) dblog("  look for adjacent maps above/below this one");
	for (i = depth-1; i <= depth+1; i += 2) {
		map_t *othermap;
		othermap = findregionmap(map->region->id, i);
		// TODO: set upmap/downmap for use later on.
		if (othermap) {
			if (i == (depth-1)) {
				map->nextmap[D_UP] = othermap->id;
				if (db) dblog("    found mapin dir d_up: %s", othermap->name);
			} else {
				map->nextmap[D_DOWN] = othermap->id;
				if (db) dblog("    found mapin dir d_down: %s", othermap->name);
			}
		}
	}


	// did we come from a previous map in the same region?
	if (parentmap) {
		if ((parentmap->region->id == map->region->id) ||
		   (map->region->rtype->majorbranch)) {
			if (db) dblog("  linking to parentmap %s in dir %s", parentmap->name, getdirname(diropposite(exitdir)));
			parentmap->nextmap[exitdir] = map->id;
			map->nextmap[diropposite(exitdir)] = parentmap->id;
		}
	}

	/*
	if (map->region->rtype->id == RG_WORLDMAP) {
		map_t *adjmap;
		for (i = D_N; i <= D_W; i++) {
			// is there a map this dir from us???
			adjmap = findmapcoords(, x, y);
			if (i == diropposite(exitdir) ) {
				map->nextmap[i] = parentmap->id;
			} else {
				map->nextmap[i] = -1;
			}
		}
	}
	*/

	map->w = MAX_MAPW;
	map->h = MAX_MAPH;

	// map depth?
	map->depth = depth;

	// rememebr seed
	map->seed = rand() % 65535;
	srand(map->seed);

	// set map coords
	// first world map??
	if (map == firstmap) {
		if (db) dblog("  map is the first world map. setting coords to 0,0.");
		addflag(map->flags, F_MAPCOORDS, 0, 0, NA, NULL);
		x = 0;
		y = 0;
	} else {
		// set mapcoords if not already done.
		if (!hasflag(map->flags, F_MAPCOORDS)) {
			x = -999;
			y = -999;
			// set mapcoords based on parent map
			if (parentmap) {
				getmapcoords(parentmap, &x, &y);
				assert((x != -999) && (y != -999));
				switch (exitdir) {
					case D_N:
						y--;
						break;
					case D_E:
						x++;
						break;
					case D_S:
						y++;
						break;
					case D_W:
						x--;
						break;
					default:
						// no change
						break;
				}
				if (db) dblog("  setting map coords to %d,%d (based on parent map)",x,y);
			} else {
				// set it based on something else...
				if (region->rtype->id == RG_WORLDMAP) {
					// TODO: is this right???????????
					// find another map of this region and set it.
					for (m = firstmap ; m ; m = m->next) {
						if ((m != map) && (m->region == region)) {
							flag_t *ff;
							ff = hasflag(m->flags, F_MAPCOORDS);
							if (ff) {
								if (db) dblog("  setting map coords to %d,%d (based on other region map)",x,y);
								x = ff->val[0];
								y = ff->val[1];
								break;
							}
						}
					}
				} else {
					x = 0;
					y = 0;
				}
			}
			assert(x != -999);
			assert(y != -999);
			addflag(map->flags, F_MAPCOORDS, x, y, NA, NULL);
		}
	}

	// we now have the map name!
	getregionname(buf2, map, B_TRUE);
	snprintf(buf, BUFLEN, "%s (id #%d)",buf2, map->id);
	map->name = strdup(buf);

	// get a list of what things are here based on the region's outline
	map->nfixedrooms = 0;
	nthings = 0;
	if (region->outline) {
		if (db) dblog("  checking region outline for things...");
		for (i = 0; i < region->outline->nthings; i++) {
			int matched = B_FALSE;
			if (db) {
				dblog("   Checking outlinething #%d (thing:depth=%d,x=%d,y=%d  thismap:depth=%d,x=%d,y=%d  ).", i, 
					region->outline->thing[i].depth,
					region->outline->thing[i].x,
					region->outline->thing[i].y,
					depth,x,y
					);
			}

			if ((region->rtype->id == RG_WORLDMAP) && 
			    (region->outline->thing[i].depth == NA)) { // match on x/y coords
				if ((region->outline->thing[i].x == x) && (region->outline->thing[i].y == y)) {
					matched = B_TRUE;
				}
			} else { // match on depth
				if (region->outline->thing[i].depth == getmapdifficulty(map)) { 
					matched = B_TRUE;
				}
			}

			if (matched) {
				// override region
				if (region->outline->thing[i].whatkind == RT_HABITAT) {
					habitat_t *h;
					h = findhabitat(region->outline->thing[i].value);
					if (db) dblog("    setting map habitat to %s based on outlinething.",h->name);
					map->habitat = h;
				} else {
					if (db) dblog("    remembering region thing for later.");
					// remember this thing
					thing[nthings] = &region->outline->thing[i];
					switch (thing[nthings]->whatkind) {
						case RT_VAULT:
						case RT_RNDVAULTWITHFLAG:
							// this will reduce the amount of random rooms which can
							// be created on this map.
							map->nfixedrooms++;
							break;
						default:
							break;
					}
					nthings++;
				}
			}
		}
	} else {
		if (db) dblog("  region has no outline.");
	}
	if (db) dblog("      %d things remembered for later.",nthings);


	// build it...
	if (db) dblog("  creating map habitat.");
	createhabitat(map, depth, parentmap, exitdir, entryob);

	// add home objects
	if (db) dblog("  adding home objects.");
	for (lf = map->lf ; lf ; lf = lf->next) {
		addhomeobs(lf);
	}


	// add outline things
	if (db) dblog("  adding remembered region outline things...");
	for (i = 0; i < nthings ;i++) {
		vault_t *v;
		// add this thing
		switch (thing[i]->whatkind) {
			case RT_HABITAT: // already handled above
				break;
			case RT_REGIONLINK:
				if (db) dblog("    adding regionlink");
				createregionlink(map, NULL, NULL, thing[i]->what, thing[i]->value, map->region);
				 // ... don't need to do this since we know there won't be anywhere to link to.
				//linkstairs(o);
				break;
			case RT_VAULT:
				if (db) dblog("    adding vault");
				v = findvault(thing[i]->what);
				assert(v);
				if (createvault(map, map->nrooms, v, NULL, NULL, NULL, NULL)) {
					dblog("ERROR - couldn't create vault %s on map %s", v->id, map->name);
				}
				break;
			case RT_RNDVAULTWITHFLAG:
				if (db) dblog("    adding rndvaultwithflag");
				v = findvaultwithflag(thing[i]->value);
				assert(v);
				if (createvault(map, map->nrooms, v, NULL, NULL, NULL, NULL)) {
					dblog("ERROR - couldn't create rndvaultwithflag %s on map %s", v->id, map->name);
				}
				break;
		}
	}

	// ensure there are no unreachable areas
	fix_reachability(map);

	// special cases
	// village - add town walls and clear it out
	if (db) dblog("  finalising village creation...");
	if (map->habitat->id == H_VILLAGE) {
		int x1 = 999,y1 = 999,x2 = -1,y2 = -1,x,y;
		int gx[MAXDIR_ORTH],gy[MAXDIR_ORTH];
		int guardx[MAXDIR_ORTH][2], guardy[MAXDIR_ORTH][2];
		int dir;
		cell_t *c;
		// find outermost dimensions of shops
		for (y = 0; y < map->h; y++) {
			for (x = 0; x < map->w; x++) {
				c = getcellat(map, x, y);
				if (c && isroom(c)) {
					if (c->x < x1) x1 = c->x;
					if (c->y < y1) y1 = c->y;
					if (c->x > x2) x2 = c->x;
					if (c->y > y2) y2 = c->y;
				}
			}
		}

		// extend walls a bit more
		x1 -= rnd(2,4);
		y1 -= rnd(2,4);
		x2 += rnd(2,4);
		y2 += rnd(2,4);
		limit(&x1, 0, map->w-1);
		limit(&x2, 0, map->w-1);
		limit(&y1, 0, map->h-1);
		limit(&y2, 0, map->h-1);

		// decide where the gate will be (not the corner)
		for (dir = D_N; dir <= D_W; dir++) {
			switch (dir) {
				case D_N: 
					gx[dir] = rnd(x1+2,x2-2); 
					gy[dir] = y1; 
					guardx[dir][0] = gx[dir]-1;
					guardy[dir][0] = gy[dir]+1;
					guardx[dir][1] = gx[dir]+1;
					guardy[dir][1] = gy[dir]+1;
					break;
				case D_E: 
					gx[dir] = x2; 
					gy[dir] = rnd(y1+2,y2-2); 
					guardx[dir][0] = gx[dir]-1;
					guardy[dir][0] = gy[dir]-1;
					guardx[dir][1] = gx[dir]-1;
					guardy[dir][1] = gy[dir]+1;
					break;
				case D_S: 
					gx[dir] = rnd(x1+2,x2-2); 
					gy[dir] = y2; 
					guardx[dir][0] = gx[dir]-1;
					guardy[dir][0] = gy[dir]-1;
					guardx[dir][1] = gx[dir]+1;
					guardy[dir][1] = gy[dir]-1;
					break;
				case D_W: 
					gx[dir] = x1; 
					gy[dir] = rnd(y1+2,y2-2); 
					guardx[dir][0] = gx[dir]+1;
					guardy[dir][0] = gy[dir]-1;
					guardx[dir][1] = gx[dir]+1;
					guardy[dir][1] = gy[dir]+1;
					break;
			}
		}

		// fill in town walls and clearing
		for (y = 0; y <= map->h; y++) {
			for (x = 0; x <= map->w; x++) {
				c = getcellat(map, x, y);
				if (c) {
					if ((c->x >= x1) && (c->y >= y1) &&
						    (c->x <= x2) && (c->y <= y2)) {
						// ie. within the village
						if (!c->type->solid) {
							int i;

							// mark as different habitat to outside
							c->habitat = findhabitat(H_VILLAGE);
							if (!isroom(c)) { 
								// get rid of objects (ie. trees) here
								killallobs(c->obpile);
								// make the ground dirt
								setcelltype(c, CT_DIRT);
							}

							if ((c->x == x1) || (c->y == y1) ||
								    (c->x == x2) || (c->y == y2)) {
								// town perimeter (walls)
								if (!isroom(c)) {
									clearcell(c);
									setcelltype(c, CT_DIRT);
									addob(c->obpile, "wooden fence");
								}
							} 

							for (dir = D_N; dir <= D_W; dir++) {
								// town gate location
								if ((c->x == gx[dir]) && (c->y == gy[dir])) {
									int d2;
									cell_t *c2;
									clearcell(c);
									setcelltype(c, CT_DIRT);
									addob(c->obpile, "wooden gate");
									// also make surrounding forest cells be dirt and no trees, 
									for (d2 = DC_N; d2 <= DC_NW; d2++) {
										c2 = getcellindir(c, d2);
										if (c2 && (c2->habitat->id != H_VILLAGE)) { 
											clearcell(c2);
											setcelltype(c2, CT_DIRT);
										}
									}
								}
								// village guards
								for (i = 0; i < 1; i++) {
									if ((c->x == guardx[dir][i]) && (c->y == guardy[dir][i])) {
										addmonster(c, R_TOWNGUARD, NULL, B_FALSE, 1, B_TRUE, NULL);
									}
								}
							}
						}
					} else {
						// not within the village
						c->habitat = findhabitat(H_FOREST);
					}
				} // end if c
			}
		}
	}

	// try to join up any unlinked staircases in this map.
	if (db) dblog("  joining unlinked stairs...");
	for (y = 0; y < map->h; y++) {
		for (x = 0; x < map->w; x++) {
			cell_t *c;
			object_t *o;
			c = getcellat(map, x, y);
			o = hasobwithflag(c->obpile, F_CLIMBABLE);
			if (o && !getstairdestination(o)) {
				// this will join these stairs to existing ones on
				// existing adjacent maps 
				if (!linkstairs(o, NULL)) {
					if (db) {
						cell_t *dst;
						dst = getstairdestination(o);
						dblog("  linked '%s' to map %s",o->type->name, dst->map->name);
					}
				} else {
					if (db) {
						dblog("  FAILED to link stiars: '%s'",o->type->name);
					}
				
				}
			}
		}
	}


	// link up holes - this will create NEW holes in THIS map connecting to 
	// EXISTING unlinked holes in adjacent maps
	i = linkholes(map);
	if (db) {
		if (db) dblog("  autolinked to %d holes in adjacent maps.",i);
	}

	// add random objects and monsters 
	if (db) dblog("  adding random objects+monsters");
	for (y = 0; y < map->h; y++) {
		for (x = 0; x < map->w; x++) {
			cell_t *c;
			c = getcellat(map, x, y);
			// no random obs in vaults
			if (c && isempty(c) && !getcellvault(c)) {
				if (rnd(1,100) <= c->habitat->randthingpct) {
					addrandomthing(c, c->habitat->randobpct, NULL);
				}
			}
		}
	}

	// look for adjacent maps 
	if (db) dblog("  linking to adjacent maps");
	getmapcoords(map, &x, &y);
	assert(x != -999);
	assert(y != -999);
	for (m = firstmap ; m ; m = m->next) {
		if ((m != map) && (m->region == map->region)) {
			int thisx,thisy;
			getmapcoords(m, &thisx, &thisy);
			if (map->nextmap[D_N] == -1) {
				if ((thisy == (y - 1)) && (thisx == x)) {
					map->nextmap[D_N] = m->id;
					if (db) dblog("  linked to map %d (dir N)",m->id);
				}
			}
			if (map->nextmap[D_E] == -1) {
				if ((thisx == (x + 1)) && (thisy == y)) {
					map->nextmap[D_E] = m->id;
					if (db) dblog("  linked to map %d (dir E)",m->id);
				}
			}
			if (map->nextmap[D_S] == -1) {
				if ((thisy == (y + 1)) && (thisx == x)) {
					map->nextmap[D_S] = m->id;
					if (db) dblog("  linked to map %d (dir S)",m->id);
				}
			}
			if (map->nextmap[D_W] == -1) {
				if ((thisx == (x - 1)) && (thisy == y)) {
					map->nextmap[D_W] = m->id;
					if (db) dblog("  linked to map %d (dir W)",m->id);
				}
			}
		}
	}

	map->beingcreated = B_FALSE;
	if (db) dblog("  Map creation finished.");
}

int createvault(map_t *map, int roomid, vault_t *v, int *retw, int *reth, int *retx, int *rety) {
	int w,h,x,y;
	int xmargin = DEF_VAULTMARGIN,ymargin = DEF_VAULTMARGIN; // defaults
	int minx,miny,maxx,maxy;
	int db = B_FALSE;
	int rotation = 0;
	room_t *thisroom = NULL;
	flag_t *f;

	// default
	if (retw) *retw = -1;
	if (reth) *reth = -1;

	if (!v) {
		return B_TRUE;
	}

	f = hasflag(v->flags, F_KEEPMARGIN);
	if (f) {
		xmargin = f->val[0];
		ymargin = f->val[1];
	}

	// handle rotation.
	rotation = rnd(0,v->nmaps-1);

	f = hasflag(v->flags, F_VAULTRANDOMMAP);
	if (f) {
		int minw,minh;
		// just make a normal room to start with. but make sure :
		// - it is surrounded with walls!
		// - we don't do autodoors (will handle this further down) -------------
		minw = f->val[0];
		minh = f->val[1];
		if (createroom(map, roomid, minw, minh, xmargin, ymargin, &minx, &miny, &w, &h, B_NODOORS, B_TRUE)) {
			return B_TRUE;
		}
		if (db) dblog("made random vault %s at pos %d,%d on map %s", v->id, minx, miny, map->name);
		maxx = minx + w - 1;
		maxy = miny + h - 1;
	} else {
		// get width/height from vault
		//w = v->w;
		//h = v->h;
		getvaultwh(v, &w, &h, rotation);
		// find vault position
		if (calcroompos(map, w, h, xmargin, ymargin, &minx, &miny, B_TRUE)) {
			// forced calcroompos should never fail since it's
			// allowed to overlap other rooms.
			dblog("** couldn't make vault room!\n");
			//msg("** ALERT: couldn't make vault room!\n");
			return B_TRUE;
		} 
		maxx = minx + (w-1);
		maxy = miny + (h-1);

		map->room[map->nrooms].id = roomid;
		map->room[map->nrooms].x1 = minx;
		map->room[map->nrooms].y1 = miny;
		map->room[map->nrooms].x2 = maxx;
		map->room[map->nrooms].y2 = maxy;
		map->room[map->nrooms].vault = v;
		map->room[map->nrooms].exitslinked = B_FALSE;
		thisroom = &(map->room[map->nrooms]);
		map->nrooms++;


		// now make it
		if (db) dblog("making vault %s at pos %d,%d on map %s", v->id, minx, miny, map->name);
		for (y = miny; y <= maxy; y++) {
			for (x = minx; x <= maxx; x++) {
				cell_t *cell;
				celltype_t *ct;
				cell = getcellat(map, x, y);

				clearcell(cell);

				// set cell type
				ct = getvaultcelltype(v, x-minx,y-miny, rotation);
				setcelltype(cell, ct ? ct->id : cell->habitat->emptycelltype);
				// set roomid
				cell->room = thisroom;
				// add objects
				addvaultcellcontents(cell, v, x-minx,y-miny, rotation);
			}
		}
	}

	if (retw) *retw = w;
	if (reth) *reth = h;
	if (retx) *retx = minx;
	if (rety) *rety = miny;

	// add other stuff to the vault based on flags
	// this will also set cell->vault for all cells.
	addvaultcontents(map, v, minx, miny, maxx, maxy, rotation);

	// auto add doors if required
	f = hasflag(v->flags, F_AUTODOORS);
	if (f) {
		// when adding autodoors to a vault, they are ALWAYS closed.
		autodoors(map, roomid, minx, miny, maxx, maxy, f->val[0], B_NODOORS);
	}

	// link up exits from this vault
	linkexits(map, roomid);

	return B_FALSE;
}

// link a single cell up to the rest of the map.
//   make sure it links to an empty cell of a DIFFERENT roomid.
//   if 'wantfilled' is set, only link to "filled" cells.
//  return TRUE on failure.
int linkexit(cell_t *startcell, int wantfilled, int *ncellsadded) {
	int db = B_TRUE;
	int d, roomid;
	int poss2[MAXCANDIDATES],nposs2;
	int dist[MAXDIR_ORTH],hitsedge[MAXDIR_ORTH], sameroom[MAXDIR_ORTH];
	cell_t *directendcell[MAXDIR_ORTH];
	int mindist = 999,maxdist = -1;
	cell_t *c;

	if (ncellsadded) *ncellsadded = 0;

	if (db) dblog("   calling linkexit() for cell at %d,%d", startcell->x, startcell->y);

	roomid = getroomid(startcell);
	for (d = D_N; d <= D_W; d++) {
		hitsedge[d] = B_TRUE;
		directendcell[d] = NULL;
	}

	// link it. starting from the door, count the number of cells in 
	// each direction until we hit an empty (walkable) cell which isn't a room.

	// if we hit a cell of this roomid, mark this dir as invalid.
	for (d = D_N; d <= D_W; d++) {
		dist[d] = 0;
		hitsedge[d] = B_FALSE;
		sameroom[d] = B_FALSE;
		c = getcellindir(startcell, d);
		while (c) {
			dist[d]++;
			if ((roomid >= 0) && getroomid(c) == roomid) { // same room
				if (wantfilled && c->type->solid) {
					// EXCEPTION:
					// if we are calling this function from fix_reachability, then
					// startcell will actually be a cell _inside_ the room as opposed to
					// a cell inside the room's walls.
					// in this case, we ARE allowed to travel through the room's walls.
				} else {
					// mark dir as invalid
					dist[d] = 999;
					sameroom[d] = B_TRUE;
					if (db) dblog("   going %s hits same room. invalid.", getdirname(d));
					break;
				}
			} else if (cellwalkable(NULL, c, NULL)) {
				if (!wantfilled || c->filled) {
					// walkable and not in this vault. finished.
					directendcell[d] = c;
					if (db) dblog("   can make %s path (hits empty cell at dist %d)", getdirname(d), dist[d]);
					break;
				}
			} else {
				int perpdir[2],n;
				cell_t *pcell = NULL;
				perpdir[0] = d - 1; if (perpdir[0] < D_N) perpdir[0] = D_W;
				perpdir[1] = d + 1; if (perpdir[1] > D_W) perpdir[1] = D_N;
				// is there an adjacent walkable cell in a perpendicular direction 
				// which isn't from the starting room?
				for (n = 0; n <= 1; n++) {
					pcell = getcellindir(c, perpdir[n]);
					if (pcell) {
						if (((roomid == -1 ) || (getroomid(pcell) != roomid)) && 
							cellwalkable(NULL, pcell, NULL)) {
							if (!wantfilled || c->filled) {
								// finished.
								directendcell[d] = c;
								if (db) dblog("   can make %s path (hits adjacent empty cell at dist %d)", getdirname(d), dist[d]);
								break;
							}
						}
					}
				}
			} 
			// check next cell
			c = getcellindir(c, d); // getting the same cell!
		}
		if (!c) {
			if (db) dblog("   going %s hits edge of map.", getdirname(d));
			hitsedge[d] = B_TRUE;
		}
		if (dist[d] != 999) {
			if (!hitsedge[d]) {
				if (dist[d] < mindist) mindist = dist[d];
			}
			if (dist[d] > maxdist) maxdist = dist[d];
		}
	}

	if (mindist == 999) {
		cell_t *turncell = NULL,*endcell = NULL;
		cell_t *perpcell[MAX_MAPW*MAX_MAPH];
		cell_t *perpturncell1[MAX_MAPW*MAX_MAPH];
		int perpturndir1[MAX_MAPW*MAX_MAPH];
		int nperpcells = 0;
		int perpdir[2];
		int startdir = D_NONE;
		int turndir = D_NONE;
		int startdist = 0;
		int maxdist2 = -1;
		int startposs[MAXDIR_ORTH];
		int nstartposs = 0;
		// no good directions.  
		if (db) dblog("   No directions lead to valid cells. Trying turns.");
		// starting at the LONGEST distance, traverse up each dir,
		// branching off looking for rooms. 

		// find longest distance that doesn't go through same room
		for (d = D_N; d <= D_W; d++) {
			if (!sameroom[d] && (dist[d] > maxdist2)) {
				maxdist2 = dist[d];
			}
		}
		// pick one randomly
		for (d = D_N; d <= D_W; d++) {
			if (dist[d] == maxdist2) {
				startposs[nstartposs++] = d;
			}
		}
		if (nstartposs) {
			startdir = startposs[rnd(0,nstartposs-1)];
		}

		assert(startdir != D_NONE);

		// figure out perpendicular dirs
		perpdir[0] = startdir - 1; if (perpdir[0] < D_N) perpdir[0] = D_W;
		perpdir[1] = startdir + 1; if (perpdir[1] > D_W) perpdir[1] = D_N;

		if (db) dblog("   Will walk %s (dist %d), checking %s and %s.", getdirname(startdir), maxdist,
			getdirname(perpdir[0]), getdirname(perpdir[1]));

		// check in startdir
		c = getcellindir(startcell, startdir);
		while (c && !turncell) {
			int n;
			cell_t *c2;
			startdist++;
			// check left/right from this door for rooms
			for (n = 0; n <= 1; n++) {
				int turndist = 0;
				c2 = getcellindir(c, perpdir[n]);


				while (c2) {
					int gotsolution = B_FALSE;
					turndist++;


					perpcell[nperpcells] = c2; // this will be used if we need to make 2 turns
					perpturncell1[nperpcells] = c; 
					perpturndir1[nperpcells] = perpdir[n];
					nperpcells++;

					if ((roomid >= 0) && (getroomid(c2) == roomid)) {
						if (wantfilled && c2->type->solid) {
							// see EXCEPTION above.
						} else {
							// hits same room, not ok.
							break;
						}
					} else if (cellwalkable(NULL, c2, NULL)) {
						if (!wantfilled || c2->filled) {
							if (db) dblog("   Got to an empty cell here.");
							gotsolution = B_TRUE;
						}
					} else if (turndist > 1) {
						// check l/r too
						int perpdir2[2],nn;
						cell_t *pcell = NULL;
						perpdir2[0] = perpdir[n] - 1; if (perpdir2[0] < D_N) perpdir2[0] = D_W;
						perpdir2[1] = perpdir[n] + 1; if (perpdir2[1] > D_W) perpdir2[1] = D_N;
						for (nn = 0; nn <= 1; nn++) {
							pcell = getcellindir(c2, perpdir2[nn]);
							if (pcell) {
								if ( ((roomid == -1) || (getroomid(pcell) != roomid)) && 
									cellwalkable(NULL, pcell, NULL)) {
									if (!wantfilled || pcell->filled) {
										// finished.
										if (db) dblog("   Got to an empty cell next to us.");
										gotsolution = B_TRUE;
										break;
									}
								}
							}
						}
					}
					if (gotsolution) {
						if (db) dblog("   Solution found: Walk %d %s, then %d %s.", 
							startdist, getdirname(startdir),
							turndist, getdirname(perpdir[n]));
						// walkable and not in this roomid. ok!
						turncell = c;
						endcell = c2;
						turndir = perpdir[n];
						break;
					} 
					// check next cell
					c2 = getcellindir(c2, perpdir[n]);
				}
				if (turncell) break;
			}
			// now keep going in main direction.
			c = getcellindir(c, startdir); 
		}

		if (turncell) {
			// make a path up to the turn point.
			if (db) dblog("   Making path from vault to corner, initdir=%s", getdirname(startdir));
			c = getcellindir(startcell, startdir);
			while (c != turncell) {
				setcelltype(c, c->habitat->emptycelltype);
				if (ncellsadded) (*ncellsadded)++;
				c = getcellindir(c, startdir);
			}
			// clear the corner cell
			setcelltype(c, c->habitat->emptycelltype);
			if (db) dblog("   Making path from corner to rest of map, turndir=%s", getdirname(turndir));
			// now turn and clear up to the next room/empty cell
			c = getcellindir(c, turndir);
			while (c != endcell) {
				setcelltype(c, c->habitat->emptycelltype);
				if (ncellsadded) (*ncellsadded)++;
				c = getcellindir(c, turndir);
			}
		} else {
			// We need to make 2 turns.
			// for each perpcell[], look in startdir + diropposite(startdir)
			int dir3[2],i,n;
			cell_t *turncell2 = NULL;
			int turndir2;
			dir3[0] = startdir;
			dir3[1] = diropposite(startdir);
			if (db) dblog("   Need to make two turns. Searching %s and %s from each perpcell.", getdirname(dir3[0]),
						getdirname(dir3[1]));
			for (i = 0; i < nperpcells; i++) {
				for (n = 0; n < 2; n++) {
					cell_t *c2;
					int turndist = 0;

					if (db) dblog_nocr("looking %s from %d,%d: ", getdirname(dir3[n]), 
						perpcell[i]->x, perpcell[i]->y);

					c2 = getcellindir(perpcell[i], dir3[n]);
					while (c2) {
						int gotsolution = B_FALSE;
						turndist++;
						if (db) dblog_nocr("(%d,%d)",c2->x,c2->y);
						if ((roomid >= 0) && (getroomid(c2) == roomid)) {
							if (wantfilled && c2->type->solid) {
								// see EXCEPTION above.
							} else {
								// hits same room, not ok.
								break;
							}
						} else if (cellwalkable(NULL, c2, NULL)) {
							if (!wantfilled || c2->filled) {
								if (db) dblog("   Got to an empty cell here.");
								gotsolution = B_TRUE;
							}
						} else if (turndist > 1) {
							// check l/r too
							int perpdir2[2],nn;
							cell_t *pcell = NULL;
							perpdir2[0] = perpdir[n] - 1; if (perpdir2[0] < D_N) perpdir2[0] = D_W;
							perpdir2[1] = perpdir[n] + 1; if (perpdir2[1] > D_W) perpdir2[1] = D_N;
							for (nn = 0; nn <= 1; nn++) {
								pcell = getcellindir(c2, perpdir2[nn]);
								if (pcell) {
									if ( ((roomid == -1) || (getroomid(pcell) != roomid)) && 
										cellwalkable(NULL, pcell, NULL)) {
										if (!wantfilled || pcell->filled) {
											// finished.
											if (db) dblog("   Got to an empty cell next to us.");
											gotsolution = B_TRUE;
											break;
										}
									}
								}
							}
						}
						if (gotsolution) {
							turncell = perpturncell1[i];
							turndir = perpturndir1[i];
							turncell2 = perpcell[i];
							turndir2 = dir3[n];

							endcell = c2;
							break;
						} 
						// check next cell
						c2 = getcellindir(c2, dir3[n]);
					} // end while c2
					if (turncell2) break;

					if (db) dblog("");
				} // end for n=1-2
				if (turncell2) break;
			} // end foreach perpcell

			// TODO: if we find a solution, fill in turncell2 and make path.
			if (turncell2) {
				if (db) dblog("   Twoturn solution found: Walk %s, then %s, then %s.", 
					getdirname(startdir), getdirname(turndir), getdirname(turndir2));

				// make a path up to the turn point.
				if (db) dblog("   Making path from vault to first corner, initdir=%s", getdirname(startdir));
				c = getcellindir(startcell, startdir);
				while (c != turncell) {
					setcelltype(c, c->habitat->emptycelltype);
					if (ncellsadded) (*ncellsadded)++;
					c = getcellindir(c, startdir);
				}
				// clear the corner cell
				setcelltype(c, c->habitat->emptycelltype);
				// now turn and clear up to the next turn
				if (db) dblog("   Making path from 1st corner to 2nd corner, turndir=%s", getdirname(turndir));
				c = getcellindir(c, turndir);
				while (c != turncell2) {
					setcelltype(c, c->habitat->emptycelltype);
					if (ncellsadded) (*ncellsadded)++;
					c = getcellindir(c, turndir);
				}

				// now turn and clear up to the next room/empty cell
				if (db) dblog("   Making path from 2nd corner to rest of map, turndir=%s", getdirname(turndir2));
				c = getcellindir(c, turndir2);
				while (c != endcell) {
					setcelltype(c, c->habitat->emptycelltype);
					if (ncellsadded) (*ncellsadded)++;
					c = getcellindir(c, turndir2);
				}
			} else {
				if (db) dblog("    Cannot find a way to link up.");
				assert(0 == 1); // for debugging
			}
			return B_TRUE;
		}
	} else { // we found a way to go without needing to turn.
		int whichway,sel;
		int mindist2 = 999;
		// now pick the shortest one which doesn't hit the edge
		// get list of all the minimums and randomly tie-break
		nposs2 = 0;
		for (d = D_N; d <= D_W; d++) {
			if (!hitsedge[d] && (dist[d] < mindist2)) {
				mindist2 = dist[d];
			}
		}

		for (d = D_N; d <= D_W; d++) {
			if (dist[d] == mindist2) {
				poss2[nposs2++] = d;
			}
		}
		sel = rnd(0,nposs2-1);
		whichway = poss2[sel];

		// now create a path
		if (db) dblog("   Linking directly %s (distance %d).", getdirname(whichway), mindist);
		c = getcellindir(startcell, whichway);
		//while (c && !cellwalkable(NULL, c, NULL)) {
		while (c && c != directendcell[whichway]) {
			setcelltype(c, c->habitat->emptycelltype);
			if (ncellsadded) (*ncellsadded)++;
			c = getcellindir(c, whichway);
		}
	}
	return B_FALSE;
}

// make sure exits/doors in a given room link up to the rest of the map.
int linkexits(map_t *m, int roomid) {
	int x,y,i;
	cell_t *poss[MAXCANDIDATES],*c;
	int nposs = 0;
	int db = B_TRUE;
	int nadded = 0;
	int minx = -1, miny = -1, maxx = -1, maxy = -1;
	int roomidx = -1;

	// figure out room coords
	for (i = 0; i < m->nrooms; i++) {
		if (m->room[i].id == roomid) {
			minx = m->room[i].x1;
			miny = m->room[i].y1;
			maxx = m->room[i].x2;
			maxy = m->room[i].y2;
			roomidx = i;
			break;
		}
	}
	assert(roomidx != -1);


	if (db) {
		char buf[BUFLEN];
		vault_t *v;
		c = getrandomroomcell(m, roomid);
		v = getcellvault(c);
		snprintf(buf, BUFLEN, "*** linkexits for roomid %d (%s) [%d,%d-%d,%d]", roomid, 
					v ? v->id : "novault",
					minx,miny,maxx,maxy);
		dblog("%s", buf);
	}

	// find all doors or f_roomexits
	for (y = miny; y <= maxy; y++) {
		for (x = minx; x <= maxx; x++) {
			c = getcellat(m, x, y);
			if (!c) continue;

			if (hasobwithflag(c->obpile, F_DOOR)) {
				if ((x == minx) || (x == maxx) || (y == miny) || (y == maxy) ) {
					if (db) dblog("found wall door at %d,%d",x,y);
					poss[nposs++] = c;
				}
			} else if (hasflagval(m->flags, F_ROOMEXIT, roomid, x, y, NULL)) {
				if (db) dblog("found roomexit at %d,%d",x,y);
				poss[nposs++] = c;
			}
		}
	}

	if (db) dblog("%d doors/exits found.",nposs);

	// for each door, make sure it links to at least one cell which isn't
	// part of this room
	for (i = 0; i < nposs; i++) {
		int ncorridors = 0,d;

		// if exit is solid and COMPLETELY surrounded by solid, ignore it.
		if (c->type->solid && (countcellexits(c) == 0)){
			if (db) dblog("cell is solid and surrounded by solids. ignoring.");
			continue;
		}

		if (db) dblog("linking exit #%d",i);

		for (d = D_N; d <= D_W; d++) {
			c = getcellindir(poss[i], d);
			if (c && cellwalkable(NULL, c, NULL) && (getroomid(c) != roomid)) {
				ncorridors++;
			}
		}
		if (db) dblog("   This exit leads to %d corridors. ", ncorridors);

		// no corridors?
		if (ncorridors == 0) {
			if (db) dblog("   Need to link.");
			nadded += linkexit(poss[i], B_FALSE, NULL);
		}
	} // end for each door

	m->room[roomidx].exitslinked = B_TRUE;

	if (db) dblog("linkexits complete (%d added).", nadded);
	return nadded;
}

void createpit(map_t *map, int depth, map_t *parentmap, int exitdir, object_t *entryob) {
	object_t *o;
	cell_t *c;
	int x,y;
	// fill entire maze with walls
	for (y = 0; y < map->h; y++) {
		for (x = 0; x < map->w; x++) {
			addcell(map, x, y);
		}
	}
	// select random spot
	c = getrandomcell(map);
	// clear it
	setcelltype(c, CT_CORRIDOR);
	// put an exit here 
	o = addobject(c->obpile, NULL, B_FALSE, B_FALSE, OT_HOLEINROOF);
	assert(o);
	// link it
	linkstairs(o, entryob);
}

// only need to provide either obname _OR_ o
void createregionlink(map_t *m, cell_t *c, object_t *o, char *obname, enum REGIONTYPE newregiontype, region_t *parent) {
	flag_t *f;
	region_t *r;
	// create a new region
	r = addregion(newregiontype, m->region, -1);
	// add stairs to new region
	if (!c) {
		c = NULL;
		while (!c || !cellwalkable(NULL, c, NULL)) {
			c = getrandomcell(m);
		}
	}

	// create object if requested
	if (!o) {
		o = addob(c->obpile, obname);
		assert(o);
	}

	// link stairs to the new region
	f = hasflag(o->flags, F_CLIMBABLE);
	assert(f);
	f->val[1] = r->id;
}

// room w/h are returned in *w and *h if given.
int createroom(map_t *map, int roomid, int overrideminw, int overrideminh, int xmargin, int ymargin, int *retx, int *rety, int *retw, int *reth, int doorpct, int forcewalls) {
	int x,y;
	cell_t *cell;
	int minx,miny;
	int maxx,maxy;
	int w,h;
	int minroomw = MIN_ROOMW;
	int minroomh = MIN_ROOMH;
	int maxroomw = MAX_ROOMW;
	int maxroomh = MAX_ROOMH;
	room_t *thisroom = NULL;

	if (overrideminw != NA) {
		minroomw = overrideminw;
	}
	if (overrideminh != NA) {
		minroomh = overrideminh;
	}

	// select random width/height
	w = rnd(minroomw, maxroomw);
	h = rnd(minroomh, maxroomh);

	if (retw) *retw = w;
	if (reth) *reth = h;

	// find room position
	if (calcroompos(map, w, h, xmargin, ymargin, &minx, &miny, B_FALSE)) {
		dblog("** couldn't make room!\n");
		return B_TRUE;
	} 

	if (retx) *retx = minx;
	if (rety) *rety = miny;

	// we now have the room position - fill it in

//printf("trying to create room at (%d,%d) w=%d,h=%d\n", minx, miny, w, h);

	maxx = minx + (w-1);
	maxy = miny + (h-1);

	map->room[map->nrooms].id = roomid;
	map->room[map->nrooms].x1 = minx;
	map->room[map->nrooms].y1 = miny;
	map->room[map->nrooms].x2 = maxx;
	map->room[map->nrooms].y2 = maxy;
	map->room[map->nrooms].vault = NULL;
	map->room[map->nrooms].exitslinked = B_FALSE;
	thisroom = &(map->room[map->nrooms]);
	map->nrooms++;

	for (y = miny; y <= maxy; y++) {
		for (x = minx; x <= maxx; x++) {
			cell = getcellat(map, x, y);
			if (cell) {
				// kill contents, EXCEPT for staircases!
				clearcell_exceptflags(cell, F_CLIMBABLE, F_NONE);
				// make it a border or room
				if ((y == miny) || (y == maxy) ||
				    (x == minx) || (x == maxx)) {
					// ie. if you haven't forced walls then if this room overlaps
					// with another one, no walls will be created.
					if (forcewalls || (!forcewalls && cell->type->solid))  {
						setcelltype(cell, CT_ROOMWALL);
					}
					//}
				} else {
					setcelltype(cell, CT_ROOM);
				}
				cell->room = thisroom;
			}
		}
	}

	// add doors
	if (doorpct) {
		autodoors(map, roomid, minx, miny, maxx, maxy, doorpct, 50);
	}

	return B_FALSE;
}


int dirtox(int dt, int dir) {
	if (dt == DT_ORTH) {
		switch (dir) {
			case D_E:
				return 1;
			case D_W:
				return -1;
			default: 
				return 0;
		}
	} else if (dt == DT_COMPASS) {
		switch (dir) {
			case DC_NE:
			case DC_E:
			case DC_SE:
				return 1;
			case DC_NW:
			case DC_W:
			case DC_SW:
				return -1;
			default: 
				return 0;
		}
	}
	return 0;
}

int dirtoy(int dt, int dir) {
	if (dt == DT_ORTH) {
		switch (dir) {
			case D_S:
				return 1;
			case D_N:
				return -1;
			default: 
				return 0;
		}
	} else if (dt == DT_COMPASS) {
		switch (dir) {
			case DC_SW:
			case DC_S:
			case DC_SE:
				return 1;
			case DC_NE:
			case DC_N:
			case DC_NW:
				return -1;
			default: 
				return 0;
		}
	}
	return 0;
}


void dumpmap(map_t *map) {
	int x,y;
	cell_t *cell;
	char ch;
printf("dump of map '%s' (%d x %d):\n",map->name, map->w, map->h);

	// top reference row
	dblog_nocr(" ");
	for (x = 0; x < map->w; x++) {
		dblog_nocr("%d",x % 10);
	}
	dblog_nocr("\n");

	for (y = 0; y < map->h; y++) {
		dblog_nocr("%d",y % 10);
		for (x = 0; x < map->w; x++) {
			cell = getcellat(map, x, y);
			ch = cell->type->glyph.ch;
			if ((ch == '.') && cell->filled) {
				ch = 'o';
			}
			dblog_nocr("%c",ch);
		}
		dblog_nocr("\n");
	}
}

void dumpoutlines(void) {
	region_t *r;
	int i;
	for (r = firstregion ; r ; r = r->next) {
		dblog("region:%s",r->rtype->name);
		if (r->outline) {
			for (i = 0; i < r->outline->nthings; i++ ){
				regionthing_t *rt;
				char loctext[BUFLEN];
				rt = &r->outline->thing[i];
				if (rt->depth == NA) {
					snprintf(loctext, BUFLEN, "%d,%d",rt->x, rt->y);
				} else {
					snprintf(loctext, BUFLEN, "depth %d",rt->depth);
				}
				if (rt->whatkind == RT_REGIONLINK) {
					regiontype_t *rtype;
					rtype = findregiontype(rt->value);
					dblog("   at %s:  link to %s",loctext, rtype->name);
				} else if (rt->whatkind == RT_HABITAT) { 
					habitat_t *h;
					h = findhabitat(rt->value);
					dblog("   at %s:  %s",loctext, h->name);
				} else if (rt->whatkind == RT_VAULT) { 
					vault_t *v;
					v = findvault(rt->what);
					dblog("   at %s:  %s",loctext, v->id);
				}
			}
		}
	}
}


// dirtype of DT_ORTH will give a square explosion
// dirtype of DT_COMPASS will give a circular explosion
void explodecells(cell_t *c, int dam, int killwalls, object_t *o, int range, int dirtype, int wantannounce) {
	int x,y;

	if (dirtype == DT_COMPASS) {
		animradial(c, range, '}', C_RED);
	} else { // ie. DT_ORTH
		animradialorth(c, range, '}', C_RED);
	}

	if (haslos(player, c)) {
		if (wantannounce) {
			msg("You see %s explosion!", (range > 0) ? "a huge" : "an");
		}
	} else {
		noise(c, NULL, NC_OTHER, (range > 0) ? 6 : 5, "an explosion!", NULL);
	}

	for (y = c->y - range ; y <= c->y + range ; y++) {
		for (x = c->x - range ; x <= c->x + range ; x++) {
			int inrange = B_FALSE;
			cell_t *cc;
			cc = getcellat(c->map, x,y);
			if (cc) {
				if ((dirtype == DT_COMPASS) && (getcelldist(c,cc) <= range)) {
					inrange = B_TRUE;
				} else if ((dirtype == DT_ORTH) && (getcelldistorth(c,cc) <= range)) {
					inrange = B_TRUE;
				}
				if (inrange && haslof(c, cc, LOF_WALLSTOP, NULL)) {
					explodesinglecell(cc, dam, killwalls, o, c);
				}
			}
		}
	}

	// lfs up to 1 cell away are knocked back
	for (y = c->y - range-1 ; y <= c->y + range+1 ; y++) {
		for (x = c->x - range-1 ; x <= c->x + range+1 ; x++) {
			cell_t *cc;
			int mydist;
			cc = getcellat(c->map, x,y);
			mydist = getcelldist(c,cc);
			if (cc && (mydist <= (range+1))) {
				if (cc->lf && !isdead(cc->lf)) {
					// move away from centre of explosion
					knockback(cc->lf, getdiraway(cc, c, NULL, B_FALSE, DT_COMPASS, B_FALSE), 2, NULL, 40-(mydist*10));
				}
			}
		}
	}
}

// this should never be called directly - only from explodecells().
//  (otherwise knockback effect won't happen)
void explodesinglecell(cell_t *c, int dam, int killwalls, object_t *o, cell_t *centre) {
	char obname[BUFLEN];

	if (c->lf) {
		char buf[BUFLEN];
		if (o) {
			getobname(o, obname, 1);
			snprintf(buf, BUFLEN, "an exploding %s",strchr(obname, ' ')+1);
		} else {
			snprintf(buf, BUFLEN, "an explosion");
		}

		// take damage
		losehp(c->lf, dam, DT_EXPLOSIVE, NULL, buf);

	}

	damageallobs(o, c->obpile, dam, DT_EXPLOSIVE);

	if (killwalls) {
		if (c->type->solid) {
			// make it empty!
			setcelltype(c, c->habitat->emptycelltype);
			// add some rubble
			addob(c->obpile, "10-50 stones");
		}
	}
}

celltype_t *findcelltype(enum CELLTYPE cid) {
	celltype_t *ct;
	for (ct = firstcelltype ; ct ; ct = ct->next) {
		if (ct->id == cid) return ct;
	}
	return NULL;
}

celltype_t *findcelltypebyname(char *name) {
	celltype_t *ct;
	for (ct = firstcelltype ; ct ; ct = ct->next) {
		if (!strcmp(ct->name, name)) return ct;
	}
	return NULL;
}

habitat_t *findhabitat(enum HABITAT id) {
	habitat_t *h;
	for (h = firsthabitat ; h ; h = h->next) {
		if (h->id == id) return h;
	}
	return NULL;
}

habitat_t *findhabitatbyname(char *name) {
	habitat_t *h;
	for (h = firsthabitat ; h ; h = h->next) {
		if (streq(h->name, name)) return h;
	}
	return NULL;
}

map_t *findmap(int mid) {
	map_t *m;
	for (m = firstmap ; m ; m = m->next) {
		if (m->id == mid) return m;
	}
	return NULL;
}

map_t *findmapofdepth(int depth) {
	map_t *m;
	for (m = firstmap ; m ; m = m->next) {
		if (m->depth == depth) return m;
	}
	return NULL;
}

cell_t *findmapentrypoint(map_t *m, int side, lifeform_t *lf) {
	int x,y,xinc,yinc;
	
	cell_t *selection = NULL;
	cell_t *bestcell = NULL;
	int closest = 999;
	switch (side) {
		case D_N:
		case DC_N:
			x = 0;
			y = 0;
			xinc = 1;
			yinc = 0;
			bestcell = getcellat(m, lf->cell->x, 0);
			break;
		case D_E:
		case DC_E:
			x = m->w-1;
			y = 0;
			xinc = 0;
			yinc = 1;
			bestcell = getcellat(m, m->w - 1, lf->cell->y);
			break;
		case D_S:
		case DC_S:
			x = 0;
			y = m->h - 1;
			xinc = 1;
			yinc = 0;
			bestcell = getcellat(m, lf->cell->x, m->h - 1);
			break;
		case D_W:
		case DC_W:
			x = 0;
			y = 0;
			xinc = 0;
			yinc = 1;
			bestcell = getcellat(m, 0, lf->cell->y);
			break;
		default:
			dblog("error: invalid side given to mapentrypoint.");
			msg("error: invalid side given to mapentrypoint.");
			return NULL;
	}

	for (;(x < m->w) && (y < m->h);) {
		cell_t *c;
		// check cell
		c = getcellat(m, x, y);
		if (c && cellwalkable(lf, c, NULL)) {
			int dist;
			dist = getcelldist(c, bestcell);
			if (dist < closest) {
				selection = c;
				closest = dist;
			}
		}
		// go to next one
		x += xinc;
		y += yinc;
	}

	return selection;
}

// find the object with id 'id' in map 'm'
object_t *findobidinmap(map_t *m, long id) {
	cell_t *c;
	int x,y;
	for (y = 0; y < m->h; y++) {
		for (x = 0; x < m->w; x++) {
			object_t *o;
			c = getcellat(m, x, y);
			o = findobbyid(c->obpile, id);
			if (o) return o;
		}
	}
	return NULL;
}


// find the cell in 'map' which contains object oid
cell_t *findobinmap(map_t *m, enum OBTYPE oid) {
	cell_t *c;
	int x,y;
	for (y = 0; y < m->h; y++) {
		for (x = 0; x < m->w; x++) {
			c = getcellat(m, x, y);
			if (hasob(c->obpile, oid)) {
				return c;
			}
		}
	}
	return NULL;
}

regionoutline_t *findoutline(int id) {
	regionoutline_t *ro;
	for (ro = firstregionoutline ;ro ; ro = ro->next) {
		if (ro->id == id) return ro;
	}
	return NULL;
}

region_t *findregion(int regionid) {
	region_t *r;
	for (r = firstregion ; r ; r = r->next) {
		if (r->id == regionid) return r;
	}
	return NULL;
}

// this will objviously only work for unique regiontypes like
// rg_worldmap and rg_firstdungeon
region_t *findregionbytype(enum REGIONTYPE rtid) {
	region_t *r;
	for (r = firstregion ; r ; r = r->next) {
		if (r->rtype->id == rtid) return r;
	}
	return NULL;
}


map_t *findregionmap(int regionid, int depth) {
	map_t *m;
	for (m = firstmap ; m ; m = m->next) {
		if ((m->depth == depth) && (m->region->id == regionid)) return m;
	}
	return NULL;
}

regiontype_t *findregiontype(enum REGIONTYPE rtype) {
	regiontype_t *rt;
	for (rt = firstregiontype ; rt ; rt = rt->next) {
		if (rt->id == rtype)  return rt;
	}
	return NULL;
}

room_t *findroom(map_t *m, int roomid) {
	int i;
	for (i = 0; i < m->nrooms; i++) {
		if (m->room[i].id == roomid) {
			return &(m->room[i]);
		}
	}
	return NULL;
}

map_t *findsurfaceexitmap(map_t *m) {
	object_t *o;
	cell_t *c;
	int x,y;
	// find up stairs on current map
	for (y = 0; y < m->h; y++) {
		for (x = 0; x < m->w; x++) {
			c = getcellat(m, x, y);
			if (c) {
				for (o = c->obpile->first ; o ; o = o->next) {
					if (hasflagval(o->flags, F_CLIMBABLE, D_UP, NA, NA, NULL)) {
						cell_t *newc;
						newc = getstairdestination(o);
						if (newc) {
							return newc->map;
						}
					}
				}
			}
		}
	}
	return NULL;
}

void forgetcells(map_t *map, int amt) {
	int amtleft;
	//int totcells;
	int i;
	cell_t *poss[MAX_MAPW*MAX_MAPH];
	cell_t *c;
	int nposs = 0;
	// how many cells to forget?
	//totcells = (map->w * map->h);
	//amtleft = (int) (((float) pct / 100.0) * (float)totcells);
	amtleft = amt;

	// get a list of all known cells
	for (i = 0; i < (map->w*map->h); i++){
		c = map->cell[i];
		if (c && c->known && !haslos(player, c)) {
			poss[nposs] = c;
			nposs++;
		}
	}

	if (amtleft > nposs) amtleft = nposs;

	// forget cells...
	for (i = 0; i < amtleft; i++) {
		int n;
		int sel;
		sel = rnd(0,nposs-1);
		poss[sel]->known = B_FALSE;
		// shuffle down
		for (n = i; n < (amtleft-1); n++) {
			poss[n] = poss[n+1];
		}
		nposs--;
	}
}

cell_t *getcellindir(cell_t *cell, int dir) {
	cell_t *newcell;
	int newx,newy;
	int dt;
	switch (dir) {
		case D_N:
		case D_S:
		case D_E:
		case D_W:
			dt = DT_ORTH;
			break;
		case DC_N:
		case DC_E:
		case DC_S:
		case DC_W:
		case DC_NE:
		case DC_SE:
		case DC_SW:
		case DC_NW:
			dt = DT_COMPASS;
			break;
		default:
			return NULL;
	}
	newx = cell->x + dirtox(dt, dir);
	newy = cell->y + dirtoy(dt, dir);
	newcell = getcellat(cell->map, newx,newy);

	return newcell;
}

vault_t *getcellvault(cell_t *c) {
	if (c->room) {
		return c->room->vault;
	} 
	return NULL;
}

cell_t *getclosestroomcell(lifeform_t *lf, int roomid) {
	int i;
	cell_t *c,*best = NULL;
	int closest = 9999;
	for (i = 0; i < lf->cell->map->w * lf->cell->map->h; i++) {
		c = lf->cell->map->cell[i];
		if ((getroomid(c) == roomid) & cellwalkable(lf, c, NULL)) {
			if (getcelldist(lf->cell, c) < closest) {
				best = c;
			}
		}
	}
	return best;
}

// select a new direction (random chance of turnung)
int getnewdigdir(cell_t *cell, int lastdir, int turnpct, int *moved) {
	int foundvaliddir = B_FALSE;
	int dir;
	int tried[4], numtries;
	int i;
	int turned = B_FALSE;
	cell_t *newcell;
	int db = B_FALSE;
	char err[BUFLEN];

	// haven't tried any dirs yet
	numtries = 0;
	for (i = 0; i < MAXDIR_ORTH; i++) {
		tried[i] = B_FALSE;
	}

	while (!foundvaliddir) { // keep going until we get a valid direction
		if (numtries >= MAXDIR_ORTH) { // no valid dirs 
			return D_NONE; // (pick a new random spot and refresh tried dirs and current dir) 
		}

		if (lastdir == D_UNKNOWN) {
			// just pick a random dir
			dir = rnd(0, MAXDIR_ORTH-1);
			turned = B_TRUE;
		} else {
			// chance of changing dir
			if (rnd(1,100) <= turnpct) {
				dir = rnd(0, MAXDIR_ORTH-1);
				turned = B_TRUE;
			} else {
				dir = lastdir;
			}
		}

		// now validate the direction
		if (db) printf("--- Trying %s...\n",getdirname(dir));
		if (tried[dir] == B_TRUE) { // already found this dir to be invalid
			lastdir = D_UNKNOWN;
			if (db) printf("--- Already know %s is invalid.\n",getdirname(dir));
		} else {
			// check 1 cell ahead
			newcell = getcellindir(cell, dir);
			if (isnewcellok(newcell, err)) {
				cell_t *newcell1, *newcell2;
				// check 2 cells ahead and sidewars
				newcell = getcellindir(newcell, dir);
				if (newcell) {
					switch (dir) {
						case D_N:
						case D_S:
							newcell1 = getcellindir(newcell,D_E);
							newcell2 = getcellindir(newcell,D_W);
							break;
						case D_E:
						case D_W:
							newcell1 = getcellindir(newcell,D_N);
							newcell2 = getcellindir(newcell,D_S);
							break;
						default: // should never happen
							newcell1 = NULL;
							newcell2 = NULL;
							break;
					}
				} else {
					newcell1 = NULL;
					newcell2 = NULL;
				}

				if (!isnewcellok(newcell, err)) {
					if (db) printf("--- %s %s!\n",getdirname(dir), err);
					tried[dir] = B_TRUE;
					lastdir = D_UNKNOWN;
					numtries++;
				} else if (!isnewcellok(newcell1, err)) {
					if (db) printf("--- %s %s!\n",getdirname(dir), err);
					tried[dir] = B_TRUE;
					lastdir = D_UNKNOWN;
					numtries++;
				} else if (!isnewcellok(newcell2, err)) {
					if (db) printf("--- %s %s!\n",getdirname(dir), err);
					tried[dir] = B_TRUE;
					lastdir = D_UNKNOWN;
					numtries++;
				} else { // ok
					if (db) printf("--- %s %s!\n",getdirname(dir), err);
					foundvaliddir = B_TRUE;
				}
			} else {
				if (db) printf("--- %s %s!\n",getdirname(dir), err);
				tried[dir] = B_TRUE;
				lastdir = D_UNKNOWN;
				numtries++;
			} 
		}
	}
	//newcell = getcellindir(cell, dir);
	//printf("getrandomdigdir() - on cell %d,%d, returning dir %d (-> %d,%d)\n",
	//		cell->x, cell->y, dir, newcell->x, newcell->y);
	if (turned) *moved = 0;
	return dir;
}


char *getregionname(char *buf, map_t *m, int withlevel) {
	region_t *r;

	r = m->region;

	if (withlevel) {
		flag_t *f;
		int x,y;
		f = hasflag(m->flags, F_MAPCOORDS);
		if (f) {
			x = f->val[0];
			y = f->val[1];
		} else {
			x = NA;
			y = NA;
		}
		switch (r->rtype->id) {
			case RG_WORLDMAP:
				snprintf(buf, BUFLEN, "the surface(%d,%d)",x,y);
				break;
			case RG_FIRSTDUNGEON:
				snprintf(buf, BUFLEN, "dungeon L%d", m->depth);
				break;
			case RG_HEAVEN:
				snprintf(buf, BUFLEN, "the realm of gods");
				break;
			case RG_PIT:
				snprintf(buf, BUFLEN, "a pit L%d", m->depth);
				break;
			default:
				strcpy(buf, "?unknownregiontype??");
				break;
		}
	} else {
		switch (r->rtype->id) {
			case RG_WORLDMAP:
				strcpy(buf, "the surface");
				break;
			case RG_FIRSTDUNGEON:
				strcpy(buf, "a dungeon");
				break;
			case RG_HEAVEN:
				snprintf(buf, BUFLEN, "the realm of gods");
				break;
			case RG_PIT:
				snprintf(buf, BUFLEN, "a pit");
				break;
			default:
				strcpy(buf, "?unknownregiontype??");
				break;
		}
	}
	return buf;
}

cell_t *getrandomadjcell(cell_t *c, int wantempty, int allowexpand) {
	return real_getrandomadjcell(c, wantempty, allowexpand, LOF_NEED, NULL);
}

cell_t *real_getrandomadjcell(cell_t *c, int wantempty, int allowexpand, enum LOFTYPE needlof, enum OBTYPE *dontwantob) {
	int radius = 1;
	int x,y;
	cell_t *poss[MAXCANDIDATES];
	int nposs = 0;
	cell_t *new;
	int done = B_FALSE;

	while (!done) {
		int numwithlof = 0;
		for (y = c->y - radius ; y <= c->y + radius ; y++) {
			for (x = c->x - radius ; x <= c->x + radius ; x++) {
				new = getcellat(c->map, x, y);
				if (new && 
					(new != c) && 
					(getcelldist(c,new) == radius) && 
					haslof(c, new, needlof, NULL)) {
					enum OBTYPE *badoid;
					int ok = B_FALSE;
					numwithlof++;
					if (wantempty == WE_EMPTY) {
						// make sure it's empty
						if (isempty(new)) {
							ok = B_TRUE;
						}
					} else if (wantempty == WE_WALKABLE) {
						if (cellwalkable(NULL, new, NULL)) {
							ok = B_TRUE;
						}
					} else if (wantempty == WE_PORTAL) {
						if (cellwalkable(NULL, new, NULL) && !hasenterableobject(new) ) {
							if (!hasobwithflag(new->obpile, F_DOOR)) {
								ok = B_TRUE;
							}
						}
					} else if (wantempty == WE_NOTWALL) {
						if ((!new->type->solid) && !hasobwithflag(new->obpile, F_IMPASSABLE)) {
						//if (!new->type->solid) {
							ok = B_TRUE;
						}
					} else if (wantempty == WE_NOLF) {
						if (!new->lf) ok = B_TRUE;
					} else {
						// always ok
						ok = B_TRUE;
					}

					// obs we dont want?
					if (dontwantob) {
						for (badoid = dontwantob; (*badoid != OT_NONE) ; badoid++) {
							if (hasob(new->obpile, *badoid)) {
								ok = B_FALSE;
								break;
							}
						}
					}

					if (ok) {
						poss[nposs++] = new;
					}
				}
			}
		}

		// found any possibilities ?
		if (nposs) {
			done = B_TRUE;
		} else {
			if (allowexpand) {
				if (numwithlof) {
					// increment radius
					radius++;
				} else {
					return NULL;
				}
			} else {
				return NULL;
			}
		}
	}
	
	return poss[rnd(0,nposs-1)];
}

cell_t *getrandomcell(map_t *map) {
	int x,y;
	cell_t *cell;
	x = (rand() % map->w);
	y = (rand() % map->h);
	cell = getcellat(map, x, y);
	assert(cell);
	return cell;
}

cell_t *getrandomcelloftype(map_t *map, enum CELLTYPE id) {
	cell_t *cell;
	cell = getrandomcell(map);
	while (cell->type->id != id) {
		cell = getrandomcell(map);
	}
	return cell;
}


int getrandomdir(int dirtype) {
	if (dirtype == DT_ORTH) {
		return rnd(D_N, D_W);
	} else { // ie. DT_COMPASS
		return rnd(DC_N, DC_NW);
	}
	
}

cell_t *getrandomroomcell(map_t *map, int roomid) {
        int npossible = 0;
        int selidx;
        int x,y;
	cell_t *c, **poss;

	poss = malloc((map->w*map->h) * sizeof(cell_t));

	npossible = 0;
        for (y = 0; y < map->h; y++) {
                for (x = 0; x < map->w; x++) {
			c = getcellat(map, x, y);	
			// is this cell in the correct room and not a wall?
			// using c->type->solid in case we have a room 
			// filled with boulders 
			//if (c && cellwalkable(NULL, c, NULL)) {
			if (c && !c->type->solid) {
				int ok = B_FALSE;
				if (getroomid(c) == roomid) {
					ok = B_TRUE;
				} else if (roomid == ANYROOM) {
					if (isroom(c) != -1) {
						ok = B_TRUE;
					}
				}

				if (ok) {
					poss[npossible] = c;
					npossible++;
				}
                        }
                }
        }
        if (npossible <= 0) {
		return NULL;
        }

        selidx = rnd(0, npossible-1);
	c = poss[selidx];
	free(poss);
	return c;
}

// popuplates retcell[] with all cells from room
void getroomcells(map_t *m, int roomid, cell_t **retcell, int *ncells) {
	int i;
	cell_t *c;
	*ncells = 0;
	for (i = 0; i < m->w*m->h; i++) {
		c = m->cell[i];
		if (c && (getroomid(c) == roomid)) {
			retcell[*ncells] = c;
			(*ncells)++;
		}
	}
}

// returns how slippery this cell is
// if slipob is set, return the most slippery object in it.
int getslipperyness(cell_t *c, object_t **slipob) {
	object_t *o,*bestob = NULL;
	int bestslip = 0;
	int totalslip = 0;
	if (slipob) *slipob = NULL;
	for (o = c->obpile->first ; o ; o = o->next) {
		int thisslip;
		sumflags(o->flags, F_SLIPPERY, &thisslip, NULL, NULL);
		if (thisslip > 0) {
			if (thisslip > bestslip) {
				bestob = o;
				bestslip = thisslip;
			}
		}
		thisslip *= o->amt;
		totalslip += thisslip;
	}

	totalslip *= 2;

	if (slipob) {
		*slipob = bestob;
	}

	return totalslip;
}

cell_t *getstairdestination(object_t *o) {
	flag_t *f;
	cell_t *newcell = NULL;

	f = hasflag(o->flags, F_MAPLINK);
	if (f) {
		map_t *newmap;
		int newx,newy;
		newmap = findmap(f->val[0]);
		assert(newmap);
		// prefer an object id if we have it
		if (strlen(f->text)) {
			object_t *o2;
			long obid;
			obid = atol(f->text);
			o2 = findobidinmap(newmap, obid);
			if (o2) {
				newcell = getoblocation(o2);
			} else {
				dblog("stairs link to object %ld which no longer exists!",obid);
				msg("stairs link to object %ld which no longer exists!",obid);
				return NULL;
			}
		} else {
			// otherwise look for x/y coors
			newx = f->val[1];
			newy = f->val[2];
			// find dst x/y
			newcell = getcellat(newmap, newx, newy);
		}
	}
	return newcell;
}

object_t *hasenterableobject(cell_t *c) {
	return hasobwithflag(c->obpile, F_CLIMBABLE);
}

object_t *hascloseddoor(cell_t *c) {
	object_t *o;
	int isopen;
	for (o = c->obpile->first ; o ; o = o->next) {
		if (isdoor(o, &isopen)) {
			if (!isopen) {
				return o;
			}
		}
	}
	return NULL;
}

lifeform_t *haslf(cell_t *c) {
	if (c->lf && !isdead(c->lf)) {
		return c->lf;
	}
	return NULL;
}

int hasobject(cell_t *c) {
	if (c->obpile->first) {
		return B_TRUE;
	}
	return B_FALSE;
}

int hasknownobject(cell_t *c) {
	object_t *o;
	for (o = c->obpile->first ; o ; o = o->next) {
		if (o && canseeob(player, o)) {
			return B_TRUE;
		}
	}
	return B_FALSE;
}

object_t *hastrailof(obpile_t *op, lifeform_t *lf, enum OBTYPE oid, flag_t **tflag, lifeform_t *viewer) {
	object_t *o;
	flag_t *f;
	for (o = op->first ; o ; o = o->next) {
		if (viewer && !canseeob(viewer, o)) continue;
		if ((oid == NA) || (o->type->id == oid)) {
			f = hasflag(o->flags, F_TRAIL);
			// raceid and lfid must match
			if (f) {
				if ((f->val[0] == lf->race->id) && (atoi(f->text) == lf->id)) {
					if (tflag) {
						*tflag = f;
					}
					return o;
				}
			}
		}
	}
	return NULL;
}


void initmap(void) {
	int vx[4],vy[4],i;
	// habitats
	//                                                     thingchance, obchance, vaultchance
	addhabitat(H_DUNGEON, "dungeon", CT_CORRIDOR, CT_WALL, 3, 50, 30, 6);
	addhabitat(H_FOREST, "forest", CT_GRASS, CT_WALL, 3, 75, 0, MAXVISRANGE);
	addhabitat(H_HEAVEN, "heaven", CT_CORRIDOR, CT_WALL, 0, 0, 0, MAXVISRANGE);
	addhabitat(H_PIT, "pit", CT_CORRIDOR, CT_WALL, 0, 0, 0, 5);
	addhabitat(H_VILLAGE, "village", CT_GRASS, CT_WALL, 3, 70, 0, MAXVISRANGE);

	// cell types
	addcelltype(CT_WALL, "rock wall", '#', C_GREY, B_SOLID, B_OPAQUE, MT_STONE, 0);
	addcelltype(CT_WALLWOOD, "wooden wall", '#', C_BROWN, B_SOLID, B_OPAQUE, MT_WOOD, 0);
	addcelltype(CT_WALLGLASS, "glass wall", '#', C_CYAN, B_SOLID, B_TRANS, MT_GLASS, 0);
	addcelltype(CT_WALLMETAL, "metal wall", '#', C_WHITE, B_SOLID, B_OPAQUE, MT_METAL, 0);
	addcelltype(CT_ROOMWALL, "rock wall", '#', C_GREY, B_SOLID, B_OPAQUE, MT_STONE, 0);
	addcelltype(CT_CORRIDOR, "rock floor", '.', C_GREY, B_EMPTY, B_TRANS, MT_STONE, 0);
	addcelltype(CT_LOOPCORRIDOR, "rock floor", 'L', C_GREY, B_EMPTY, B_TRANS, MT_STONE, 0);
	addcelltype(CT_FLOORWOOD, "wood floor", '.', C_BROWN, B_EMPTY, B_TRANS, MT_WOOD, 0);
	addcelltype(CT_FLOORSHOP, "shop floor", '.', C_BROWN, B_EMPTY, B_TRANS, MT_WOOD, 0);
	addcelltype(CT_ROOM, "rock floor", '.', C_GREY, B_EMPTY, B_TRANS, MT_STONE, 0);
	addcelltype(CT_GRASS, "grass", '.', C_GREEN, B_EMPTY, B_TRANS, MT_PLANT, 0);
	addcelltype(CT_DIRT, "dirt", '.', C_BROWN, B_EMPTY, B_TRANS, MT_STONE, 0);
	addcelltype(CT_LOWFLOOR, "low rock floor", '.', C_GREY, B_EMPTY, B_TRANS, MT_STONE, -1);

	// region types
	addregiontype(RG_WORLDMAP, "World map", H_FOREST, 10, 0, D_NONE, B_TRUE);
	addregiontype(RG_FIRSTDUNGEON, "First Dungeon", H_DUNGEON, 10, 3, D_DOWN, B_TRUE);
	addregiontype(RG_HEAVEN, "Realm of Gods", H_HEAVEN, 1, 0, D_NONE, B_FALSE);
	addregiontype(RG_PIT, "Pit", H_PIT, 1, 1, D_DOWN, B_FALSE);
	
	// region definitions (outlines)
	addregionoutline(RG_WORLDMAP);
		// link to first dungeon
		addregionthing(lastregionoutline, NA, 0, 0, RT_REGIONLINK, RG_FIRSTDUNGEON, "staircase going down");
		// four villages
		for (i = 0; i < 4; i++) {
			vx[i] = 0; vy[i] = 0;
			while ((vx[i] == 0) && (vy[i] == 0)) {
				int n, distfromcentre;
				distfromcentre = 2 + (i*2);
				vx[i] = rnd(-distfromcentre,distfromcentre);
				vy[i] = rnd(-distfromcentre,distfromcentre);
				// check for other villages in this map...
				for (n = 0; n < i; n++) {
					if ((vx[n] == vx[i]) && (vy[n] == vy[i])) {
						vx[i] = 0; vy[i] = 0; // invalidate!
						break;
					}
				}
			}
			addregionthing(lastregionoutline, NA, vx[i], vy[i], RT_HABITAT, H_VILLAGE, NULL);
				addregionthing(lastregionoutline, NA, vx[i], vy[i], RT_VAULT, NA, "food_shop");
				addregionthing(lastregionoutline, NA, vx[i], vy[i], RT_VAULT, NA, "pub");
				addregionthing(lastregionoutline, NA, vx[i], vy[i], RT_RNDVAULTWITHFLAG, F_VAULTISSHOP, NULL);
				addregionthing(lastregionoutline, NA, vx[i], vy[i], RT_RNDVAULTWITHFLAG, F_VAULTISSHOP, NULL);
				addregionthing(lastregionoutline, NA, vx[i], vy[i], RT_RNDVAULTWITHFLAG, F_VAULTISSHOP, NULL);
		}
		//vx = 0; vy = -1;
	addregionoutline(RG_FIRSTDUNGEON);
		addregionthing(lastregionoutline, 1, NA, NA, RT_RNDVAULTWITHFLAG, F_VAULTISPLAYERSTART, NULL);
		addregionthing(lastregionoutline, 6, NA, NA, RT_VAULT, NA, "jimbos_lair");
		addregionthing(lastregionoutline, 10, NA, NA, RT_RNDVAULTWITHFLAG, F_VAULTISSHRINE, NULL); // godstone on last floor
}

int isadjacent(cell_t *src, cell_t *dst) {
	if (getcelldist(src, dst) == 1) {
		return B_TRUE;
	}
	return B_FALSE;
}

int isdark(cell_t *c) {
	switch (c->lit) {
		case L_PERMDARK:
		case L_NOTLIT:
			return B_TRUE;
		default:
			break;
	}
	return B_FALSE;
}

int isdiggable(cell_t *c) {
	switch (c->type->id) {
		case CT_WALL: return B_TRUE;
		case CT_ROOMWALL: return B_TRUE;
	}
	return B_FALSE;
}

// if isopen provided, returns whether or not the door is opened 
int isdoor(object_t *o, int *isopen) {
	int isdoor = B_FALSE;
	if (hasflag(o->flags, F_DOOR)) {
		isdoor = B_TRUE;
	} else {
		isdoor = B_FALSE;
	}

	if (isdoor) {
		if (isopen) {
			if (hasflag(o->flags, F_OPEN)) {
				*isopen = B_TRUE;
			} else {
				*isopen = B_FALSE;
			}
		}
	}
	return isdoor;
}

int isempty(cell_t *c) {
	if (!c) return B_FALSE;
	if (c->type->solid) return B_FALSE;
	if (c->lf) return B_FALSE;
	if (!cellwalkable(NULL, c, NULL)) return B_FALSE;
	return B_TRUE;
}

//returns TT_  based on what you can scan there
int isinscanrange(cell_t *c, void **thing, char *desc, glyph_t *glyph) {
	flag_t *f;
        flag_t *retflag[MAXCANDIDATES];
        int nretflags;
	int i;
	// handle scanner
	f = lfhasflag(player, F_DETECTLIFE);
	if (f) {
		if (c->lf) {
			if (getcelldistorth(player->cell, c) <= f->val[0]) {
				*thing = c->lf;
				if (f->val[1] == B_TRUE) {
					if (desc) {
						real_getlfnamea(c->lf, desc, B_FALSE);
						strcat(desc, " (detected)");
					}
					if (glyph) {
						*glyph = *(getlfglyph(c->lf));
					}
				} else {
					if (desc) {
						char *p;
						p = getsizetext(getlfsize(c->lf));
						snprintf(desc, BUFLEN, "%s %s monster", isvowel(*p) ? "an" : "a", p);
					}
					if (glyph) {
						// select glyph based on size
						glyph->ch = '0' + ((int) getlfsize(c->lf));
						glyph->colour = C_GREY;
					}
				}
				return TT_MONSTER;
			}
		}
	}
	f = lfhasflag(player, F_DETECTMETAL);
	if (f) {
		if (getcelldistorth(player->cell, c) <= f->val[0]) {
			if (c->lf && ismetal(getlfmaterial(c->lf)) ) {
				*thing = c->lf;
				if (glyph) {
					glyph->ch = '*';
					glyph->colour = C_GREY;
				}
				if (desc) snprintf(desc, BUFLEN, "something metallic");
				return TT_MONSTER;
			} else {
				object_t *o;
				for (o = c->obpile->first ; o ; o = o->next) {
					if (ismetal(o->material->id)) {
						*thing = o;
						if (glyph) {
							glyph->ch = '*';
							glyph->colour = C_GREY;
						}
						if (desc) snprintf(desc, BUFLEN, "something metallic");
						return TT_OBJECT;
					}
				}
			}
		}
	}

	// can hear them using master level listen skill?
	if (c->lf && lfhasflagval(player, F_CANHEARLF, c->lf->id, NA, NA, NULL)) {
		if (glyph) {
			*glyph = *(getlfglyph(c->lf));
		}
		if (desc) {
			real_getlfnamea(c->lf, desc, B_FALSE);
			strcat(desc, " (heard)");
		}
		
		*thing = c->lf;
		return TT_MONSTER;
	}

	// get list of all detected ob ids.
	getflags(player->flags, retflag, &nretflags, F_DETECTOBS, F_NONE);
	for (i = 0; i < nretflags; i++) {
		f = retflag[i];
		if (getcelldistorth(player->cell, c) <= f->val[0]) {
			object_t *o;
			for (o = c->obpile->first ; o ; o = o->next) {
				if ((f->val[1] == NA) || (o->type->id == f->val[1])) {
					if (!hasflag(o->flags, F_NOPICKUP) && !hasflag(o->flags, F_DOOR)) {
						*thing = o;
						if (glyph) {
							glyph->ch = '*';
							glyph->colour = C_BOLDGREEN;
						}
						if (desc) {
							if (f->val[1] == NA) {
								strcpy(desc, "a detected object");
							} else {
								getobname(o, desc, o->amt);
							}
						}
						return TT_OBJECT;
					}
				}
			}
		}
	}
	
	return B_FALSE;
}

int islit(cell_t *c) {
	switch (c->lit) {
		case L_TEMP:
		case L_PERMLIGHT:
			return B_TRUE;
		default:
			break;
	}
	return B_FALSE;
}


int isloopdirok(cell_t *cell, int dir) {
	int dirok = B_FALSE;
	cell_t *newcell;
	// is there a corridor in this direction?
	newcell = getcellindir(cell, dir);
	while (newcell) {
		// got a corridor?
		if (!newcell->type->solid) {
			dirok = B_TRUE;
			break;
		}
		// keep going
		newcell = getcellindir(newcell, dir);
	}

	// we've either gone off the map or
	// hit a corridor
	return dirok;
}

int isnewcellok(cell_t *cell, char *err) {
	if ( !cell) { // can't go that way
		if (err) snprintf(err, BUFLEN,"goes off the map.");
		return B_FALSE;
	} else if ( !cell->type->solid) { // already an empty space there
		if (err) snprintf(err, BUFLEN,"goes to an empty space (%d,%d)",cell->x,cell->y);
		return B_FALSE;
	} 

	// ok!
	if (err) snprintf(err, BUFLEN, "OK!");
	return B_TRUE;
}

int isnighttime(void) {
	int hours,mins,secs;
	splittime(&hours,&mins,&secs);
	if ((hours < 5) || (hours >= 19)) {
		return B_TRUE;
	}
	return B_FALSE;
}

int isonmap(map_t *map, int x, int y) {
	if ((x < 0) || (y < 0)) {
		return B_FALSE;
	}
	if ((x >= map->w) || (y >= map->h)) {
		return B_FALSE;
	}

	return B_TRUE;
}

int isoutdoors(map_t *m) {
	if (m->region && m->region->rtype->id == RG_WORLDMAP) {
		return B_TRUE;
	}
	return B_FALSE;
}

int isroom(cell_t *c) {
	if (c && (getroomid(c) >= 0)) {
		return B_TRUE;
	}
	return B_FALSE;
}

int iswallindir(cell_t *cell, int dir) {
	cell_t *newcell;
	newcell = getcellindir(cell, dir);
	if (!newcell) {
		return B_TRUE;
	}

	if (newcell->type->solid) {
		return B_TRUE;
	}

	return B_FALSE;
}

// search for unlinked pits/holes in roof in ADJACENT maps
// if we find any, add a matching end as close as we can in THIS map.
// returns then umber of holes linked.
int linkholes(map_t *map) {
	map_t *adjmap;
	cell_t *c;
	object_t *o, *newob;
	int x,y;
	int dir;
	int nlinked = 0;

	for (dir = D_UP ; dir <= D_DOWN; dir++) {
		adjmap = getmapindir(map, dir);
		if (adjmap) {
			for (y = 0; y < adjmap->h; y++) {
				for (x = 0; x < adjmap->w; x++) {
					c = getcellat(adjmap, x, y);
					if (c) {
						// does the adjacent map have an unlinked pit going to us?
						for (o = c->obpile->first ; o ; o = o->next) {
							if (hasflagval(o->flags, F_PIT, diropposite(dir), NA, NA, NULL) &&
							    !hasflag(o->flags, F_MAPLINK)) {
								cell_t *c2;
								objecttype_t *ot;
								ot = getoppositestairs(o->type);
								// make a link to it in this map, as close as possible to same pos
								c2 = getcellat(map, x, y);
								if (c2->lf || hasobid(c2->obpile, ot->id)) {	
									// this will automatically avoid lifeforms since we're using
									// we_walkable rather than we_notwall.  this saves problems
									// with someine coming up underneath you!
									c2 = real_getrandomadjcell(c2, WE_NOLF, B_ALLOWEXPAND, LOF_DONTNEED, &ot->id);
								}
								// clear out the cell if required
								if (c2->type->solid) {
									setcelltype(c2, c2->habitat->emptycelltype);
								}
								// note we specifically say DONT link the new hole, to avoid an infinite
								// loop!
								newob = addobject(c2->obpile, NULL, B_FALSE, B_FALSE, ot->id);
								// link holes manually now.
								linkstairs(newob, o);

								// objects above fall down
								if (dir == D_UP) {
									obsfallthrough(c, o);
								} else {
									obsfallthrough(c2, newob);
								}
								nlinked++;
							}
						}
					}
				}
			}
		}
	}
	return nlinked;
}

// link the staircase 'o' to a free one in adjacent maps.
// o2 is options.  if not probided, we will try to find 
// something to link to ourself.
//	returns TRUE if it failed because othermap doesn't exist.
int linkstairs(object_t *o, object_t *o2) {
	map_t *othermap;
	map_t *stairmap;
	cell_t *staircell;
	flag_t *f;

	assert(o);

	staircell = getoblocation(o);
	stairmap = staircell->map;
	
	if (o2) {
		cell_t *othercell;
		othercell = getoblocation(o2);
		othermap = othercell->map;
	} else {
		objecttype_t *otherstairtype;
		cell_t *c2;
		int n, dir;
		object_t *oo;
		// find a valid other end
		otherstairtype = getoppositestairs(o->type);

		f = hasflag(o->flags, F_CLIMBABLE);
		if (f) {
			if (f->val[0] == D_UP) {
				dir = -1;
			} else {
				dir = 1;
			}
		} else {
			dblog("ERROR: stair object has no f_climbable!");
			msg("ERROR: stair object has no f_climbable!");
			assert(0 == 1);
		}

		// do stairs go to a particular region?
		if (f->val[1] != NA) {
			// if so, find the first map in that region (ie depth 1)
			othermap = findregionmap(f->val[1], 1);
		} else {
			othermap = getmapindir(stairmap, f->val[0]);
		}
		if (othermap) {
			int found = B_FALSE;
			// find an empty staircase in other map
			for (n = 0; n < othermap->w*othermap->h; n++) {
				c2 = othermap->cell[n];
				oo = hasob(c2->obpile, otherstairtype->id);
				if (oo) {
					// does it go nowhere?
					if (!hasflag(oo->flags, F_MAPLINK)) {
						o2 = oo;
						found = B_TRUE;
						break;
					}
				}
			}
			if (!found) {
				dblog("ERROR - stairs link to existing map %d(depth %d), but it has no free stairs.",othermap->id, othermap->depth);
				msg("ERROR - stairs link to existing map %d(depth %d), but it has no free stairs.",othermap->id, othermap->depth);
				more();
			}
		} // end if othermap
	} // end if !o2


	if (o2) {
		char obid[BUFLEN];
		// link it to here!
		snprintf(obid, BUFLEN, "%ld", o->id);
		addflag(o2->flags, F_MAPLINK, stairmap->id, NA, NA, obid);
		// link me to there
		snprintf(obid, BUFLEN, "%ld", o2->id);
		addflag(o->flags, F_MAPLINK, othermap->id, NA, NA, obid);
		// now mark that we are not a new staircase to a new region anymore
		f = hasflag(o->flags, F_CLIMBABLE);
		if (f) {
			f->val[1] = NA;
		}
	} else {
		return B_TRUE;
	}

	return B_FALSE;
}

void makedoor(cell_t *cell, int openchance) {
	object_t *o;
	map_t *m;
	char doorbuf[BUFLEN];

	// can't have more than one door in a cell
	if (hasobwithflag(cell->obpile, F_DOOR)) {
		return;
	}

	m = cell->map;

	setcelltype(cell, cell->habitat->emptycelltype);

	if ((rnd(1,100) + m->depth) >= 66) {
		strcpy(doorbuf, "iron door");
	} else {
		strcpy(doorbuf, "wooden door");
	}

	o = addob(cell->obpile, doorbuf);
	if (o && (rnd(1,100) <= openchance)) {
		opendoor(NULL, o);
	} else {
		int chance;
		// door is closed - lock it?

		// ie. at dungeon lev 10, chance is 2 in 6
		//     at dungeon lev 20, chance is 3 in 6
		//    ...
		//     at dungeon lev 50, chance is 5 in 6
		chance = rolldie(1,6) - (m->depth / 10);


		if (chance <= 1) {
			addflag(o->flags, F_LOCKED, B_TRUE, getdoorlockdiff(m->depth), NA, NULL);
		}

		//  make it secret?
		chance = rolldie(1,6) - (m->depth / 10);

		// difficulty:
		//   l1 = 20
		//   l10 = 25
		//   l20 = 30
		if (chance <= 1) {
			addflag(o->flags, F_SECRET, getdoorsecretdiff(m->depth), NA, NA, NULL);
		}
	}
}


void makelit(cell_t *c, enum LIGHTLEV how, int howlong) {
	// don't override permenant light with temp light!
	//if ((c->lit == L_PERMLIGHT) && (how == L_TEMP)) {
	if (how == L_TEMP) {
		//if ((c->lit == L_PERMLIGHT) || (c->lit == L_PERMDARK)) {
		if (c->lit == L_PERMLIGHT) {
			// light sources can't override permenant light
			return;
		}
		if (c->lit == L_PERMDARK) {
			// light sources can't override darkness spell
			return;
		}
	}
	if (howlong > 0) {
		// TODO: use a stack here instead
		c->origlit = c->lit;
		c->origlittimer = c->littimer;
		c->littimer = howlong;
	}
	c->lit = how;
}

void makelitradius(cell_t *c, int radius, enum LIGHTLEV how, int howlong) {
	int x,y;
	cell_t *c2;
	int (*distfunc)(cell_t *, cell_t *);

	if (radius <= 0) return;

	if (radius == 1) {
		distfunc = getcelldist;
	} else {
		distfunc = getcelldistorth;
	}

	for (y = c->y - radius ; y <= c->y + radius; y++) {
		for (x = c->x - radius ; x <= c->x + radius; x++) {
			c2 = getcellat(c->map, x, y);
			if (c2 && (distfunc(c, c2) <= radius)) {
				if (cellhaslos(c,c2)) {
					makelit(c2, how,howlong);
				}
			}
		}
	}
}

void mapentereffects(map_t *m) {
	int i;
	cell_t *c;
	flag_t *f;
	for (i = 0; i < m->w * m->h; i++) {
		vault_t *v;
		// teleport shopkeepers back to their shops
		c = m->cell[i];
		if (c->lf && hasjob(c->lf, J_SHOPKEEPER) && !isplayer(c->lf)) {
			f = lfhasflag(c->lf, F_OWNSSHOP);
			if (f) {
				cell_t *where;
				int myshop;
				myshop = f->val[0];
				// find the closest cell of my shop
				where = getclosestroomcell(c->lf, myshop);
				if (where) {
					movelf(c->lf, where);
				}
			}
		}
		v = getcellvault(c);
		// replace people in the Inn
		if (v && streq(v->id, "inn") && c->lf && (c->lf->race->id == R_HUMAN)) {
			lifeform_t *lf;
			killlf(c->lf);
			lf = addmonster(c, R_HUMAN, NULL, B_TRUE, 1, B_FALSE, NULL);
			addflag(lf->flags, F_STAYINROOM, getroomid(c), B_MAYCHASE, NA, NULL);
		}
	}

	// monsters on the new level now get a bunch of turns to simulate them moving about when the player wasn't there.
	if (m->lastplayervisit != -1) {
		int nturns;
		nturns = (curtime - m->lastplayervisit) / TICK_INTERVAL;
		//nturns *= countlfs(m);
		for (i = 0; i < nturns; i++) {
			donextturn(m);
		}
	}
}

enum RACE parserace(char *name, flagpile_t *wantflags, enum JOB *wantjob) {
	int donesomething;
	char *p;
	job_t *j;

	// get params
	donesomething = B_TRUE;
	p = name;
	while (donesomething) {
		donesomething = B_FALSE;
		if (strstarts(p, "sleeping ")) {
			p += strlen("sleeping ");
			if (wantflags) addflag(wantflags, F_ASLEEP, NA, NA, NA, NULL);
			donesomething = B_TRUE;
		}
	}

	// try removing suffixes for jobs
	for (j = firstjob ; j ; j = j->next) {
		char *ep;
		char jobname[BUFLEN];
		snprintf(jobname, BUFLEN, " %s", j->name);
		jobname[1] = tolower(jobname[1]);
		ep = strends(name, jobname);
		if (ep) {
			// got it
			if (wantjob) *wantjob = j->id;
			// now strip the suffix off, starting at the space before it
			*ep = '\0';
			break;
		}
	}

	// now get raceid
	if (streq(p, "random")) {
		return R_RANDOM;
	} else {
		race_t *r;
		r = findracebyname(p);
		if (r) {
			return r->id;
		} 
	}
	return R_NONE;
}

// returns # of dead ends removed.
int remove_deadends(map_t *m, int howmuch) {
	enum CELLTYPE solidcell;
	int i,n,count = 0;

	solidcell = m->habitat->solidcelltype;
	
	for (i = 0; i < howmuch; i++) {
		for (n = 0; n < m->w * m->h; n++) {
			cell_t *c;
			c = m->cell[n];
			if (countcellexits(c) == 1) {
				// erase this cell	
				clearcell(c);
				setcelltype(c, solidcell);
				count++;
			}
		}
	}
	return count;
}
	

void setcellknown(cell_t *cell, int forcelev) {
	enum SKILLLEVEL slev;
	object_t *o;

	if (forcelev > 0) {
		slev = forcelev;
	} else {
		slev = getskill(player, SK_CARTOGRAPHY);
	}

	cell->known = B_TRUE;
	// default to remembering the cell's glyph
	cell->knownglyph = cell->type->glyph; 
	// high cartography skill lets us remember certain objects...
	if (slev >= PR_EXPERT) {
		o = gettopobject(cell, B_TRUE);
		if (o) {
			cell->knownglyph = *(getglyph(o));
		}
	}
	if (slev >= PR_ADEPT) {
		for (o = cell->obpile->first ; o ; o = o->next) {
			if ((o->type->obclass->id == OC_DFEATURE) || (o->type->obclass->id == OC_TERRAIN)) {
				if (!issecretdoor(o)) {
					cell->knownglyph = *(getglyph(o));
				}
			}
		}
	}
	if (slev >= PR_BEGINNER) {
		o = hasobwithflag(cell->obpile, F_CLIMBABLE);
		if (o) {
			cell->knownglyph = *(getglyph(o));
		}
	}

	if (slev == PR_INEPT) {
		cell->knowntime = getattr(player, A_IQ)*3;
	} else {
		cell->knowntime = PERMENANT;
	}
	//getcellglyph(&(cell->knownglyph), cell, player);
}

void setcellknownradius(cell_t *centre, int forcelev, int radius, int dirtype) {
	cell_t *cell[MAXCANDIDATES];
	int ncells,i;
	getradiuscells(centre, radius, dirtype, LOF_DONTNEED, B_TRUE, cell, &ncells, B_FALSE);
	for (i = 0; i < ncells; i++) {
		cell_t *c;
		c = cell[i];
		setcellknown(c, forcelev);
	}
}

void setcelltype(cell_t *cell, enum CELLTYPE id) {
	assert(cell);
	cell->type = findcelltype(id);
	assert(cell->type);
	if (cell->type->solid) {
		assert(!cell->obpile->first);
	}
	if ((gamemode == GM_GAMESTARTED) && haslos(player, cell)) {
		needredraw = B_TRUE;
	}
}

// returns true if something happened
int shattercell(cell_t *c, lifeform_t *fromlf, char *damstring) {
	lifeform_t *target;
	char targetname[BUFLEN], buf[BUFLEN];
	object_t *o, *nexto;
	int seen = B_FALSE;
	int rv = B_FALSE;

	target = c->lf;
	if (target) {
		getlfname(target, targetname);
	}
	// shatter solid glass cells
	if (c->type->solid && willshatter(c->type->material->id)) {
		rv = B_TRUE;
		// announce
		if (haslos(player, c)) {
			msg("%s %s shatters!",needan(c->type->name) ? "An" : "A", c->type->name);
			seen = B_TRUE;
		} else {
			// very loud
			noise(c, NULL, NC_OTHER, 7, "shattering glass.", NULL);
		}

		if (target) {
			if (seen) {
				msg("%s %s showered in %s shards!", targetname, is(target), c->type->material->name);
			}
			losehp(target, rnd(1,100), DT_SLASH, fromlf, damstring); // BIG damage
		}

		// change cell type
		setcelltype(c, c->habitat->emptycelltype);

		// place shards
		 if (c->type->material->id == MT_GLASS) {
			int numshards;
			numshards = rnd(50,100);
			snprintf(buf, BUFLEN, "%d pieces of broken glass",numshards);
			addob(c->obpile, buf);
		} else if (c->type->material->id == MT_ICE) {
			int numshards;
			numshards = rnd(50,100);
			snprintf(buf, BUFLEN, "%d chunks of ice",numshards);
			addob(c->obpile, buf);
		} 
	}

	// shatter lifeform-owned objects
	if (target) {
		for (o = target->pack->first ; o ; o = nexto) {
			nexto = o->next;
			if (willshatter(o->material->id)) {
				if (shatter(o, B_TRUE, damstring, fromlf)) {
					rv = B_TRUE;
				}
			}
		}
	}

	// shatter cell objects
	for (o = c->obpile->first ; o ; o = nexto) {
		nexto = o->next;
		if (willshatter(o->material->id)) {
			if (shatter(o, B_TRUE, damstring, fromlf)) {
				rv = B_TRUE;
			}
		}
	}
	return rv;
}

void updateknowncells(void) {
	int x,y;
	map_t *map;
	object_t *wep;
	int seenundead = B_FALSE;


	map = player->cell->map;
	wep = getweapon(player);

	for (y = viewy; y < viewy + viewh; y++) {
		for (x = viewx; x < viewx + vieww; x++) {
			cell_t *cell;
			cell = getcellat(map, x, y);
			if (cell) {
				//if ((player->cell == cell) || haslos(player, cell)) {
				if (haslos(player, cell)) {
					setcellknown(cell, B_FALSE);
					if (cell->lf && lfhasflag(cell->lf, F_UNDEAD)) {
						seenundead = B_TRUE;
					}
				}
			}
		}
	}
}

int validateregions(void) {
	regionoutline_t *ro;
	int failed = B_FALSE;
	// check outlines
	for (ro = firstregionoutline ; ro ; ro = ro->next) {
		int i;
		for (i = 0 ; i < ro->nthings; i++) {
			if (validateregionthing(&ro->thing[i])) {
				failed = B_TRUE;
			}
		}
	}
	return failed;
}

int validateregionthing(regionthing_t *thing) {
	switch (thing->whatkind) {
		case RT_HABITAT:
			if (!findhabitat(thing->value)) {
				dblog("Invalid habitat %d specified in regionthing.", thing->value);
				return B_TRUE;
			}
			break;
		case RT_REGIONLINK:
			if (!findregiontype(thing->value)) {
				dblog("Invalid regionlink to regiontype %d specified in regionthing.", thing->value);
				return B_TRUE;
			}
			break;
		case RT_VAULT:
			if (!findvault(thing->what)) {
				dblog("Invalid rt_vault to vaulttype '%s' specified in regionthing.", thing->what);
				return B_TRUE;
			}
			break;
		case RT_RNDVAULTWITHFLAG:
			if (!findvaultwithflag(thing->value)) {
				dblog("Invalid rt_rndvaultwithflag specified in regionthing.");
				return B_TRUE;
			}
			break;
	}
	return B_FALSE;
}

int wallstoleftright(cell_t *c, int dir) {
	int d1,d2;
	switch (dir) {
		case D_N: 
		case D_S:
			d1 = D_E; d2 = D_W; break;
		case D_E:
		case D_W:
			d1 = D_N; d2 = D_S; break;
		default:
			return B_FALSE;
	}
	if (iswallindir(c,d1) && iswallindir(c,d2)) {
		return B_TRUE;
	}
	return B_FALSE;
}