diff --git a/include/extern.h b/include/extern.h
index d901d3641..d7d1a3d57 100644
--- a/include/extern.h
+++ b/include/extern.h
@@ -275,7 +275,7 @@ E int FDECL(use_pick_axe2, (struct obj *));
 E boolean FDECL(mdig_tunnel, (struct monst *));
 E void FDECL(watch_dig, (struct monst *,XCHAR_P,XCHAR_P,BOOLEAN_P));
 E void NDECL(zap_dig);
-E struct obj *FDECL(bury_an_obj, (struct obj *));
+E struct obj *FDECL(bury_an_obj, (struct obj *, boolean *));
 E void FDECL(bury_objs, (int,int));
 E void FDECL(unearth_objs, (int,int));
 E void FDECL(rot_organic, (ANY_P *, long));
@@ -1132,6 +1132,7 @@ E void FDECL(dodoor, (int,int,struct mkroom *));
 E void FDECL(mktrap, (int,int,struct mkroom *,coord*));
 E void FDECL(mkstairs, (XCHAR_P,XCHAR_P,CHAR_P,struct mkroom *));
 E void NDECL(mkinvokearea);
+E void FDECL(mineralize, (int, int, int, int, boolean));
 
 /* ### mkmap.c ### */
 
@@ -1141,7 +1142,7 @@ void FDECL(remove_rooms, (int,int,int,int));
 /* ### mkmaze.c ### */
 
 E void FDECL(wallification, (int,int,int,int));
-E void FDECL(walkfrom, (int,int));
+E void FDECL(walkfrom, (int,int,SCHAR_P));
 E void FDECL(makemaz, (const char *));
 E void FDECL(mazexy, (coord *));
 E void NDECL(bound_digging);
diff --git a/include/mkroom.h b/include/mkroom.h
index e9952ddfa..45f49305f 100644
--- a/include/mkroom.h
+++ b/include/mkroom.h
@@ -13,6 +13,8 @@ struct mkroom {
 	schar rtype;		/* type of room (zoo, throne, etc...) */
 	schar orig_rtype;	/* same as rtype, but not zeroed later */
 	schar rlit;		/* is the room lit ? */
+	schar needfill;		/* sp_lev: does the room need filling? */
+	schar needjoining;	/* sp_lev */
 	schar doorct;		/* door count */
 	schar fdoor;		/* index for the first door of the room */
 	schar nsubrooms;	/* number of subrooms */
diff --git a/include/rm.h b/include/rm.h
index c007f6a4f..00f0bc4c5 100644
--- a/include/rm.h
+++ b/include/rm.h
@@ -291,6 +291,7 @@ extern struct symsetentry symset[NUM_GRAPHICS];		  /* from drawing.c */
 #define D_CLOSED	4
 #define D_LOCKED	8
 #define D_TRAPPED	16
+#define D_SECRET        32 /* only used by sp_lev.c, NOT in rm-struct */
 
 /*
  * Some altars are considered as shrines, so we need a flag.
@@ -393,6 +394,19 @@ struct rm {
 	Bitfield(candig,1);	/* Exception to Can_dig_down; was a trapdoor */
 };
 
+
+#define SET_TYPLIT(x,y,ttyp,llit)				\
+{								\
+  if ((x) >= 0 && (y) >= 0 && (x) < COLNO && (y) < ROWNO) {	\
+    if ((ttyp) < MAX_TYPE) levl[(x)][(y)].typ = (ttyp);		\
+    if ((ttyp) == LAVAPOOL) levl[(x)][(y)].lit = 1;		\
+    else if ((schar)(llit) != -2) {				\
+	if ((schar)(llit) == -1) levl[(x)][(y)].lit = rn2(2);	\
+	else levl[(x)][(y)].lit = (llit);			\
+    }								\
+  }								\
+}
+
 /*
  * Add wall angle viewing by defining "modes" for each wall type.  Each
  * mode describes which parts of a wall are finished (seen as as wall)
diff --git a/include/sp_lev.h b/include/sp_lev.h
index 0a1d22173..f2c61625b 100644
--- a/include/sp_lev.h
+++ b/include/sp_lev.h
@@ -19,26 +19,315 @@
 #define MAP_Y_LIM	21
 
     /* Per level flags */
-#define NOTELEPORT	1
-#define HARDFLOOR	2
-#define NOMMAP		4
-#define SHORTSIGHTED	8
-#define ARBOREAL	16
+#define NOTELEPORT	0x00000001L
+#define HARDFLOOR	0x00000002L
+#define NOMMAP		0x00000004L
+#define SHORTSIGHTED	0x00000008L
+#define ARBOREAL	0x00000010L
+#define MAZELEVEL	0x00000020L
+#define PREMAPPED       0x00000040L
+#define SHROUD          0x00000080L
+#define STORMY          0x00000100L
+#define GRAVEYARD       0x00000200L
 
-    /* special level types */
-#define SP_LEV_ROOMS	1
-#define SP_LEV_MAZE	2
+
+/* different level layout initializers */
+#define LVLINIT_NONE		0
+#define LVLINIT_SOLIDFILL	1
+#define LVLINIT_MAZEGRID	2
+#define LVLINIT_MINES		3
+#define LVLINIT_ROGUE		4
+
+/* max. layers of object containment */
+#define MAX_CONTAINMENT 10
+
+/* max. # of random registers */
+#define MAX_REGISTERS	10
+
+/* max. nested depth of subrooms */
+#define MAX_NESTED_ROOMS 5
+
+/* max. # of opcodes per special level */
+#define SPCODER_MAX_RUNTIME	65536
+
+/* Opcodes for creating the level
+ * If you change these, also change opcodestr[] in util/lev_main.c
+ */
+enum opcode_defs {
+    SPO_NULL = 0,
+    SPO_MESSAGE,
+    SPO_MONSTER,
+    SPO_OBJECT,
+    SPO_ENGRAVING,
+    SPO_ROOM,
+    SPO_SUBROOM,
+    SPO_DOOR,
+    SPO_STAIR,
+    SPO_LADDER,
+    SPO_ALTAR,
+    SPO_FOUNTAIN,
+    SPO_SINK,
+    SPO_POOL,
+    SPO_TRAP,
+    SPO_GOLD,
+    SPO_CORRIDOR,
+    SPO_LEVREGION,
+    SPO_DRAWBRIDGE,
+    SPO_MAZEWALK,
+    SPO_NON_DIGGABLE,
+    SPO_NON_PASSWALL,
+    SPO_WALLIFY,
+    SPO_MAP,
+    SPO_ROOM_DOOR,
+    SPO_REGION,
+    SPO_MINERALIZE,
+    SPO_CMP,
+    SPO_JMP,
+    SPO_JL,
+    SPO_JLE,
+    SPO_JG,
+    SPO_JGE,
+    SPO_JE,
+    SPO_JNE,
+    SPO_TERRAIN,
+    SPO_REPLACETERRAIN,
+    SPO_EXIT,
+    SPO_ENDROOM,
+    SPO_POP_CONTAINER,
+    SPO_PUSH,
+    SPO_POP,
+    SPO_RN2,
+    SPO_DEC,
+    SPO_INC,
+    SPO_MATH_ADD,
+    SPO_MATH_SUB,
+    SPO_MATH_MUL,
+    SPO_MATH_DIV,
+    SPO_MATH_MOD,
+    SPO_MATH_SIGN,
+    SPO_COPY,
+    SPO_END_MONINVENT,
+    SPO_GRAVE,
+    SPO_FRAME_PUSH,
+    SPO_FRAME_POP,
+    SPO_CALL,
+    SPO_RETURN,
+    SPO_INITLEVEL,
+    SPO_LEVEL_FLAGS,
+    SPO_VAR_INIT, /* variable_name data */
+    SPO_SHUFFLE_ARRAY,
+    SPO_DICE,
+
+    SPO_SEL_ADD,
+    SPO_SEL_POINT,
+    SPO_SEL_RECT,
+    SPO_SEL_FILLRECT,
+    SPO_SEL_LINE,
+    SPO_SEL_RNDLINE,
+    SPO_SEL_GROW,
+    SPO_SEL_FLOOD,
+    SPO_SEL_RNDCOORD,
+    SPO_SEL_ELLIPSE,
+    SPO_SEL_FILTER,
+    SPO_SEL_GRADIENT,
+    SPO_SEL_COMPLEMENT,
+
+    MAX_SP_OPCODES
+};
+
+/* MONSTER and OBJECT can take a variable number of parameters,
+ * they also pop different # of values from the stack. So,
+ * first we pop a value that tells what the _next_ value will
+ * mean.
+ */
+/* MONSTER */
+#define SP_M_V_PEACEFUL         0
+#define SP_M_V_ALIGN            1
+#define SP_M_V_ASLEEP           2
+#define SP_M_V_APPEAR           3
+#define SP_M_V_NAME             4
+
+#define SP_M_V_FEMALE		5
+#define SP_M_V_INVIS		6
+#define SP_M_V_CANCELLED	7
+#define SP_M_V_REVIVED		8
+#define SP_M_V_AVENGE		9
+#define SP_M_V_FLEEING		10
+#define SP_M_V_BLINDED		11
+#define SP_M_V_PARALYZED	12
+#define SP_M_V_STUNNED		13
+#define SP_M_V_CONFUSED		14
+#define SP_M_V_SEENTRAPS	15
+
+#define SP_M_V_END              16 /* end of variable parameters */
+
+/* OBJECT */
+#define SP_O_V_SPE              0
+#define SP_O_V_CURSE            1
+#define SP_O_V_CORPSENM         2
+#define SP_O_V_NAME             3
+#define SP_O_V_QUAN		4
+#define SP_O_V_BURIED		5
+#define SP_O_V_LIT		6
+#define SP_O_V_ERODED		7
+#define SP_O_V_LOCKED		8
+#define SP_O_V_TRAPPED		9
+#define SP_O_V_RECHARGED	10
+#define SP_O_V_INVIS		11
+#define SP_O_V_GREASED		12
+#define SP_O_V_BROKEN		13
+#define SP_O_V_COORD		14
+#define SP_O_V_END              15 /* end of variable parameters */
+
+
+/* When creating objects, we need to know whether
+ * it's a container and/or contents.
+ */
+#define SP_OBJ_CONTENT		0x1
+#define SP_OBJ_CONTAINER	0x2
+
+
+/* SPO_FILTER types */
+#define SPOFILTER_PERCENT	0
+#define SPOFILTER_SELECTION	1
+#define SPOFILTER_MAPCHAR	2
+
+/* gradient filter types */
+#define SEL_GRADIENT_RADIAL	0
+#define SEL_GRADIENT_SQUARE	1
+
+/* variable types */
+#define SPOVAR_NULL	0x00
+#define SPOVAR_INT	0x01 /* l */
+#define SPOVAR_STRING	0x02 /* str */
+#define SPOVAR_VARIABLE	0x03 /* str (contains the variable name) */
+#define SPOVAR_COORD	0x04 /* coordinate, encoded in l; use SP_COORD_X() and SP_COORD_Y() */
+#define SPOVAR_REGION	0x05 /* region, encoded in l; use SP_REGION_X1() etc */
+#define SPOVAR_MAPCHAR	0x06 /* map char, in l */
+#define SPOVAR_MONST	0x07 /* monster class & specific monster, encoded in l; use SP_MONST_... */
+#define SPOVAR_OBJ	0x08 /* object class & specific object type, encoded in l; use SP_OBJ_... */
+#define SPOVAR_SEL	0x09 /* selection. char[COLNO][ROWNO] in str */
+#define SPOVAR_ARRAY	0x40 /* used in splev_var & lc_vardefs, not in opvar */
+
+#define SP_COORD_IS_RANDOM 0x01000000
+/* Humidity flags for get_location() and friends, used with SP_COORD_PACK_RANDOM() */
+#define DRY	0x1
+#define WET	0x2
+#define HOT	0x4
+#define SOLID	0x8
+#define ANY_LOC 0x10 /* even outside the level */
+#define NO_LOC_WARN 0x20 /* no complaints and set x & y to -1, if no loc */
+
+#define SP_COORD_X(l)	(l & 0xff)
+#define SP_COORD_Y(l)	((l >> 16) & 0xff)
+#define SP_COORD_PACK(x,y) ((( x ) & 0xff) + ((( y ) & 0xff) << 16))
+#define SP_COORD_PACK_RANDOM(f) (SP_COORD_IS_RANDOM | (f))
+
+#define SP_REGION_X1(l)	(l & 0xff)
+#define SP_REGION_Y1(l)	((l >> 8) & 0xff)
+#define SP_REGION_X2(l)	((l >> 16) & 0xff)
+#define SP_REGION_Y2(l)	((l >> 24) & 0xff)
+#define SP_REGION_PACK(x1,y1,x2,y2) ((( x1 ) & 0xff) + ((( y1 ) & 0xff) << 8) + ((( x2 ) & 0xff) << 16) + ((( y2 ) & 0xff) << 24))
+
+#define SP_MONST_CLASS(l) (l & 0xff)
+#define SP_MONST_PM(l)	  ((l >> 8) & 0xffff)
+#define SP_MONST_PACK(m,c) ((( m ) << 8) + ((char)( c )))
+
+#define SP_OBJ_CLASS(l)	  (l & 0xff)
+#define SP_OBJ_TYP(l)	  ((l >> 8) & 0xffff)
+#define SP_OBJ_PACK(o,c)  ((( o ) << 8) + ((char)( c )))
+
+#define SP_MAPCHAR_TYP(l) (l & 0xff)
+#define SP_MAPCHAR_LIT(l) ((l >> 8) & 0xff)
+#define SP_MAPCHAR_PACK(typ,lit) ((( lit ) << 8) + ((char)( typ )))
+
+
+struct opvar {
+    xchar spovartyp; /* one of SPOVAR_foo */
+    union {
+	char *str;
+	long l;
+    } vardata;
+};
+
+struct splev_var {
+    struct splev_var *next;
+    char *name;
+    xchar svtyp; /* SPOVAR_foo */
+    union {
+	struct opvar *value;
+	struct opvar **arrayvalues;
+    } data;
+    long array_len;
+};
+
+struct splevstack {
+    long depth;
+    long depth_alloc;
+    struct opvar **stackdata;
+};
+
+
+struct sp_frame {
+    struct sp_frame *next;
+    struct splevstack *stack;
+    struct splev_var *variables;
+    long n_opcode;
+};
+
+
+struct sp_coder {
+    struct splevstack *stack;
+    struct sp_frame *frame;
+    /*int allow_flips;*/
+    int premapped;
+    struct mkroom *croom;
+    struct mkroom *tmproomlist[MAX_NESTED_ROOMS+1];
+    boolean failed_room[MAX_NESTED_ROOMS+1];
+    int n_subroom;
+    boolean exit_script;
+    int  lvl_is_joined;
+
+    int opcode;  /* current opcode */
+    struct opvar *opdat; /* current push data (req. opcode == SPO_PUSH) */
+};
+
+/* special level coder CPU flags */
+#define SP_CPUFLAG_LT	1
+#define SP_CPUFLAG_GT	2
+#define SP_CPUFLAG_EQ	4
+#define SP_CPUFLAG_ZERO	8
 
 /*
  * Structures manipulated by the special levels loader & compiler
  */
 
+#define packed_coord long
+typedef struct {
+    xchar is_random;
+    long getloc_flags;
+    int x, y;
+} unpacked_coord;
+
+typedef struct {
+	int cmp_what;
+	int cmp_val;
+} opcmp;
+
+typedef struct {
+	long jmp_target;
+} opjmp;
+
+
 typedef union str_or_len {
 	char *str;
 	int   len;
 } Str_or_Len;
 
 typedef struct {
+	xchar   init_style; /* one of LVLINIT_foo */
+	long	flags;
+	schar	filling;
 	boolean init_present, padding;
 	char	fg, bg;
 	boolean smoothed, joined;
@@ -46,65 +335,62 @@ typedef struct {
 	boolean icedpools;	/* for ice locations: ICED_POOL vs ICED_MOAT */
 } lev_init;
 
-typedef struct {
-	xchar x, y, mask;
-} door;
-
 typedef struct {
 	xchar wall, pos, secret, mask;
 } room_door;
 
 typedef struct {
-	xchar x, y, chance, type;
+    packed_coord coord;
+    xchar x, y, type;
 } trap;
 
 typedef struct {
 	Str_or_Len name, appear_as;
 	short id;
 	aligntyp align;
-	xchar x, y, chance, class, appear;
+    packed_coord coord;
+	xchar x, y, class, appear;
 	schar peaceful, asleep;
+        short female, invis, cancelled, revived, avenge, fleeing, blinded, paralyzed, stunned, confused;
+        long seentraps;
+	short has_invent;
 } monster;
 
 typedef struct {
 	Str_or_Len name;
 	int   corpsenm;
 	short id, spe;
-	xchar x, y, chance, class, containment;
+    packed_coord coord;
+	xchar x, y, class, containment;
 	schar curse_state;
+	int   quan;
+	short buried;
+	short lit;
+        short eroded, locked, trapped, recharged, invis, greased, broken;
 } object;
 
 typedef struct {
+    packed_coord coord;
 	xchar		x, y;
 	aligntyp	align;
 	xchar		shrine;
 } altar;
 
-typedef struct {
-	xchar x, y, dir, db_open;
-} drawbridge;
-
-typedef struct {
-	xchar x, y, dir;
-} walk;
-
-typedef struct {
-	xchar x1, y1, x2, y2;
-} digpos;
-
-typedef struct {
-	xchar x, y, up;
-} lad;
-
-typedef struct {
-	xchar x, y, up;
-} stair;
-
 typedef struct {
 	xchar x1, y1, x2, y2;
 	xchar rtype, rlit, rirreg;
 } region;
 
+typedef struct {
+    xchar ter, tlit;
+} terrain;
+
+typedef struct {
+    xchar chance;
+    xchar x1,y1,x2,y2;
+    xchar fromter, toter, tolit;
+} replaceterrain;
+
 /* values for rtype are defined in dungeon.h */
 typedef struct {
 	struct { xchar x1, y1, x2, y2; } inarea;
@@ -114,116 +400,6 @@ typedef struct {
 	Str_or_Len rname;
 } lev_region;
 
-typedef struct {
-	xchar x, y;
-	int   amount;
-} gold;
-
-typedef struct {
-	xchar x, y;
-	Str_or_Len engr;
-	xchar etype;
-} engraving;
-
-typedef struct {
-	xchar x, y;
-} fountain;
-
-typedef struct {
-	xchar x, y;
-} sink;
-
-typedef struct {
-	xchar x, y;
-} pool;
-
-typedef struct {
-	char halign, valign;
-	char xsize, ysize;
-	char **map;
-	char nrobjects;
-	char *robjects;
-	char nloc;
-	char *rloc_x;
-	char *rloc_y;
-	char nrmonst;
-	char *rmonst;
-	char nreg;
-	region **regions;
-	char nlreg;
-	lev_region **lregions;
-	char ndoor;
-	door **doors;
-	char ntrap;
-	trap **traps;
-	char nmonster;
-	monster **monsters;
-	char nobject;
-	object **objects;
-	char ndrawbridge;
-	drawbridge **drawbridges;
-	char nwalk;
-	walk **walks;
-	char ndig;
-	digpos **digs;
-	char npass;
-	digpos **passs;
-	char nlad;
-	lad **lads;
-	char nstair;
-	stair **stairs;
-	char naltar;
-	altar **altars;
-	char ngold;
-	gold **golds;
-	char nengraving;
-	engraving **engravings;
-	char nfountain;
-	fountain **fountains;
-} mazepart;
-
-typedef struct {
-	long flags;
-	lev_init init_lev;
-	schar filling;
-	char numpart;
-	mazepart **parts;
-} specialmaze;
-
-typedef struct _room {
-	char  *name;
-	char  *parent;
-	xchar x, y, w, h;
-	xchar xalign, yalign;
-	xchar rtype, chance, rlit, filled;
-	char ndoor;
-	room_door **doors;
-	char ntrap;
-	trap **traps;
-	char nmonster;
-	monster **monsters;
-	char nobject;
-	object **objects;
-	char naltar;
-	altar **altars;
-	char nstair;
-	stair **stairs;
-	char ngold;
-	gold **golds;
-	char nengraving;
-	engraving **engravings;
-	char nfountain;
-	fountain **fountains;
-	char nsink;
-	sink **sinks;
-	char npool;
-	pool **pools;
-	/* These three fields are only used when loading the level... */
-	int nsubroom;
-	struct _room *subrooms[MAX_SUBROOMS];
-	struct mkroom *mkr;
-} room;
-
 typedef struct {
 	struct {
 		xchar room;
@@ -232,18 +408,66 @@ typedef struct {
 	} src, dest;
 } corridor;
 
-/* used only by lev_comp */
+typedef struct _room {
+	Str_or_Len name;
+	Str_or_Len parent;
+	xchar x, y, w, h;
+	xchar xalign, yalign;
+	xchar rtype, chance, rlit, filled, joined;
+} room;
+
 typedef struct {
-	long flags;
-	lev_init init_lev;
-	char nrobjects;
-	char *robjects;
-	char nrmonst;
-	char *rmonst;
-	xchar nroom;
-	room **rooms;
-	xchar ncorr;
-	corridor **corrs;
-} splev;
+	schar zaligntyp;
+	schar keep_region;
+	schar halign, valign;
+	char xsize, ysize;
+	char **map;
+} mazepart;
+
+typedef struct {
+    int opcode;
+    struct opvar *opdat;
+} _opcode;
+
+typedef struct {
+    _opcode  *opcodes;
+    long     n_opcodes;
+} sp_lev;
+
+typedef struct {
+	xchar x, y, direction, count, lit;
+	char typ;
+} spill;
+
+
+/* only used by lev_comp */
+struct lc_funcdefs_parm {
+    char *name;
+    char parmtype;
+    struct lc_funcdefs_parm *next;
+};
+
+struct lc_funcdefs {
+    struct lc_funcdefs *next;
+    char *name;
+    long addr;
+    sp_lev code;
+    long n_called;
+    struct lc_funcdefs_parm *params;
+    long n_params;
+};
+
+struct lc_vardefs {
+    struct lc_vardefs *next;
+    char *name;
+    long var_type; /* SPOVAR_foo */
+    long n_used;
+};
+
+struct lc_breakdef {
+    struct lc_breakdef *next;
+    struct opvar *breakpoint;
+    int break_depth;
+};
 
 #endif /* SP_LEV_H */
diff --git a/src/dig.c b/src/dig.c
index fa25f76a0..66d41d163 100644
--- a/src/dig.c
+++ b/src/dig.c
@@ -1683,13 +1683,15 @@ buried_ball_to_freedom()
 /* move objects from fobj/nexthere lists to buriedobjlist, keeping position */
 /* information */
 struct obj *
-bury_an_obj(otmp)
+bury_an_obj(otmp, dealloced)
 	struct obj *otmp;
+	boolean *dealloced;
 {
 	struct obj *otmp2;
 	boolean under_ice;
 
 	debugpline1("bury_an_obj: %s", xname(otmp));
+	if (dealloced) *dealloced = FALSE;
 	if (otmp == uball) {
 		unpunish();
 		u.utrap = rn1(50,20);
@@ -1720,6 +1722,7 @@ bury_an_obj(otmp)
 	under_ice = is_ice(otmp->ox, otmp->oy);
 	if (otmp->otyp == ROCK && !under_ice) {
 		/* merges into burying material */
+		if (dealloced) *dealloced = TRUE;
 		obfree(otmp, (struct obj *)0);
 		return(otmp2);
 	}
@@ -1754,7 +1757,7 @@ int x, y;
 	if(level.objects[x][y] != (struct obj *)0)
 	    debugpline2("bury_objs: at <%d,%d>", x, y);
 	for (otmp = level.objects[x][y]; otmp; otmp = otmp2)
-		otmp2 = bury_an_obj(otmp);
+	    otmp2 = bury_an_obj(otmp, NULL);
 
 	/* don't expect any engravings here, but just in case */
 	del_engr_at(x, y);
@@ -1814,7 +1817,7 @@ long timeout UNUSED;
 	    /* Everything which can be held in a container can also be
 	       buried, so bury_an_obj's use of obj_extract_self insures
 	       that Has_contents(obj) will eventually become false. */
-	    (void)bury_an_obj(obj->cobj);
+	    (void)bury_an_obj(obj->cobj, NULL);
 	}
 	obj_extract_self(obj);
 	obfree(obj, (struct obj *) 0);
diff --git a/src/hacklib.c b/src/hacklib.c
index fd4273074..78f12dea5 100644
--- a/src/hacklib.c
+++ b/src/hacklib.c
@@ -398,6 +398,20 @@ dist2(x0, y0, x1, y1)	/* square of euclidean distance between pair of pts */
     return dx * dx + dy * dy;
 }
 
+int
+isqrt(val)
+int val;
+{
+    int rt = 0;
+    int odd = 1;
+    while(val >= odd) {
+        val = val-odd;
+        odd = odd+2;
+        rt = rt + 1;
+    }
+    return rt;
+}
+
 boolean
 online2(x0, y0, x1, y1) /* are two points lined up (on a straight line)? */
     int x0, y0, x1, y1;
diff --git a/src/mklev.c b/src/mklev.c
index 4412d68aa..5b4c9634a 100644
--- a/src/mklev.c
+++ b/src/mklev.c
@@ -17,7 +17,6 @@ STATIC_DCL void FDECL(mkgrave,(struct mkroom *));
 STATIC_DCL void NDECL(makevtele);
 STATIC_DCL void NDECL(clear_level_structures);
 STATIC_DCL void NDECL(makelevel);
-STATIC_DCL void NDECL(mineralize);
 STATIC_DCL boolean FDECL(bydoor,(XCHAR_P,XCHAR_P));
 STATIC_DCL struct mkroom *FDECL(find_branch_room, (coord *));
 STATIC_DCL struct mkroom *FDECL(pos_to_room, (XCHAR_P, XCHAR_P));
@@ -814,43 +813,50 @@ skip0:
  *	Place deposits of minerals (gold and misc gems) in the stone
  *	surrounding the rooms on the map.
  *	Also place kelp in water.
+ *      mineralize(-1, -1, -1, -1, FALSE); => "default" behaviour
  */
-STATIC_OVL void
-mineralize()
+void
+mineralize(kelp_pool, kelp_moat, goldprob, gemprob, skip_lvl_checks)
+int kelp_pool, kelp_moat, goldprob, gemprob;
+boolean skip_lvl_checks;
 {
 	s_level *sp;
 	struct obj *otmp;
-	int goldprob, gemprob, x, y, cnt;
+	int x, y, cnt;
 
+	if (kelp_pool < 0) kelp_pool = 10;
+	if (kelp_moat < 0) kelp_moat = 30;
 
 	/* Place kelp, except on the plane of water */
-	if (In_endgame(&u.uz)) return;
+	if (!skip_lvl_checks && In_endgame(&u.uz)) return;
 	for (x = 2; x < (COLNO - 2); x++)
 	    for (y = 1; y < (ROWNO - 1); y++)
-		if ((levl[x][y].typ == POOL && !rn2(10)) ||
-			(levl[x][y].typ == MOAT && !rn2(30)))
+		if ((kelp_pool && levl[x][y].typ == POOL && !rn2(kelp_pool)) ||
+			(kelp_moat && levl[x][y].typ == MOAT && !rn2(kelp_moat)))
 		    (void) mksobj_at(KELP_FROND, x, y, TRUE, FALSE);
 
 	/* determine if it is even allowed;
 	   almost all special levels are excluded */
-	if (In_hell(&u.uz) || In_V_tower(&u.uz) ||
+	if (!skip_lvl_checks && (In_hell(&u.uz) || In_V_tower(&u.uz) ||
 		Is_rogue_level(&u.uz) ||
 		level.flags.arboreal ||
 		((sp = Is_special(&u.uz)) != 0 && !Is_oracle_level(&u.uz)
 					&& (!In_mines(&u.uz) || sp->flags.town)
-	    )) return;
+		 ))) return;
 
 	/* basic level-related probabilities */
-	goldprob = 20 + depth(&u.uz) / 3;
-	gemprob = goldprob / 4;
+	if (goldprob < 0) goldprob = 20 + depth(&u.uz) / 3;
+	if (gemprob < 0) gemprob = goldprob / 4;
 
 	/* mines have ***MORE*** goodies - otherwise why mine? */
-	if (In_mines(&u.uz)) {
-	    goldprob *= 2;
-	    gemprob *= 3;
-	} else if (In_quest(&u.uz)) {
-	    goldprob /= 4;
-	    gemprob /= 6;
+	if (!skip_lvl_checks) {
+	    if (In_mines(&u.uz)) {
+		goldprob *= 2;
+		gemprob *= 3;
+	    } else if (In_quest(&u.uz)) {
+		goldprob /= 4;
+		gemprob /= 6;
+	    }
 	}
 
 	/*
@@ -905,7 +911,7 @@ mklev()
 	in_mklev = TRUE;
 	makelevel();
 	bound_digging();
-	mineralize();
+	mineralize(-1, -1, -1, -1, FALSE);
 	in_mklev = FALSE;
 	/* has_morgue gets cleared once morgue is entered; graveyard stays
 	   set (graveyard might already be set even when has_morgue is clear
diff --git a/src/mkmaze.c b/src/mkmaze.c
index 87a3a870b..4270ba783 100644
--- a/src/mkmaze.c
+++ b/src/mkmaze.c
@@ -556,7 +556,7 @@ register const char *s;
 #endif
 
 	maze0xy(&mm);
-	walkfrom((int) mm.x, (int) mm.y);
+	walkfrom((int) mm.x, (int) mm.y, 0);
 	/* put a boulder at the maze center */
 	(void) mksobj_at(BOULDER, (int) mm.x, (int) mm.y, TRUE, FALSE);
 
@@ -644,14 +644,21 @@ register const char *s;
  * that is totally safe.
  */
 void
-walkfrom(x,y)
+walkfrom(x,y,typ)
 int x,y;
+schar typ;
 {
 #define CELLS (ROWNO * COLNO) / 4		/* a maze cell is 4 squares */
 	char mazex[CELLS + 1], mazey[CELLS + 1];	/* char's are OK */
 	int q, a, dir, pos;
 	int dirs[4];
 
+#ifndef WALLIFIED_MAZE
+	if (!typ) typ = CORR;
+#else
+	if (!typ) typ = ROOM;
+#endif
+
 	pos = 1;
 	mazex[pos] = (char) x;
 	mazey[pos] = (char) y;
@@ -660,11 +667,7 @@ int x,y;
 		y = (int) mazey[pos];
 		if(!IS_DOOR(levl[x][y].typ)) {
 		    /* might still be on edge of MAP, so don't overwrite */
-#ifndef WALLIFIED_MAZE
-		    levl[x][y].typ = CORR;
-#else
-		    levl[x][y].typ = ROOM;
-#endif
+		    levl[x][y].typ = typ;
 		    levl[x][y].flags = 0;
 		}
 		q = 0;
@@ -675,11 +678,7 @@ int x,y;
 		else {
 			dir = dirs[rn2(q)];
 			move(&x, &y, dir);
-#ifndef WALLIFIED_MAZE
-			levl[x][y].typ = CORR;
-#else
-			levl[x][y].typ = ROOM;
-#endif
+			levl[x][y].typ = typ;
 			move(&x, &y, dir);
 			pos++;
 			if (pos > CELLS)
@@ -692,19 +691,22 @@ int x,y;
 #else
 
 void
-walkfrom(x,y)
+walkfrom(x,y,typ)
 int x,y;
+schar typ;
 {
 	register int q,a,dir;
 	int dirs[4];
 
+#ifndef WALLIFIED_MAZE
+	if (!typ) typ = CORR;
+#else
+	if (!typ) typ = ROOM;
+#endif
+
 	if(!IS_DOOR(levl[x][y].typ)) {
 	    /* might still be on edge of MAP, so don't overwrite */
-#ifndef WALLIFIED_MAZE
-	    levl[x][y].typ = CORR;
-#else
-	    levl[x][y].typ = ROOM;
-#endif
+	    levl[x][y].typ = typ;
 	    levl[x][y].flags = 0;
 	}
 
@@ -715,13 +717,9 @@ int x,y;
 		if(!q) return;
 		dir = dirs[rn2(q)];
 		move(&x,&y,dir);
-#ifndef WALLIFIED_MAZE
-		levl[x][y].typ = CORR;
-#else
-		levl[x][y].typ = ROOM;
-#endif
+		levl[x][y].typ = typ;
 		move(&x,&y,dir);
-		walkfrom(x,y);
+		walkfrom(x,y,typ);
 	}
 }
 #endif /* MICRO */
diff --git a/src/mon.c b/src/mon.c
index fb0a75a57..cfe5cddca 100644
--- a/src/mon.c
+++ b/src/mon.c
@@ -278,9 +278,10 @@ unsigned corpseflags;
 		    obj = mkcorpstat(CORPSE, KEEPTRAITS(mtmp) ? mtmp : 0,
 				     mdat, x, y, corpstatflags);
 		    if (burythem) {
-			(void) bury_an_obj(obj);
+			boolean dealloc;
+			(void) bury_an_obj(obj, &dealloc);
 			newsym(x, y);
-			return obj;
+			return (dealloc ? NULL : obj);
 		    }
 		}
 		break;
diff --git a/src/sp_lev.c b/src/sp_lev.c
index 41a747da9..0650a7bd1 100644
--- a/src/sp_lev.c
+++ b/src/sp_lev.c
@@ -18,25 +18,24 @@
 extern void FDECL(mkmap, (lev_init *));
 
 STATIC_DCL void FDECL(get_room_loc, (schar *, schar *, struct mkroom *));
-STATIC_DCL void FDECL(get_free_room_loc, (schar *, schar *, struct mkroom *));
+STATIC_DCL void FDECL(get_free_room_loc, (schar *, schar *, struct mkroom *, packed_coord));
 STATIC_DCL void FDECL(create_trap, (trap *, struct mkroom *));
 STATIC_DCL int FDECL(noncoalignment, (ALIGNTYP_P));
 STATIC_DCL boolean FDECL(m_bad_boulder_spot, (int,int));
 STATIC_DCL void FDECL(create_monster, (monster *, struct mkroom *));
 STATIC_DCL void FDECL(create_object, (object *, struct mkroom *));
-STATIC_DCL void FDECL(create_engraving, (engraving *,struct mkroom *));
-STATIC_DCL void FDECL(create_stairs, (stair *, struct mkroom *));
 STATIC_DCL void FDECL(create_altar, (altar *, struct mkroom *));
-STATIC_DCL void FDECL(create_gold, (gold *, struct mkroom *));
-STATIC_DCL void FDECL(create_feature, (int,int,struct mkroom *,int));
 STATIC_DCL boolean FDECL(search_door, (struct mkroom *, xchar *, xchar *,
 					XCHAR_P, int));
 STATIC_DCL void NDECL(fix_stair_rooms);
 STATIC_DCL void FDECL(create_corridor, (corridor *));
+STATIC_DCL void NDECL(count_features);
 
 STATIC_DCL boolean FDECL(create_subroom, (struct mkroom *, XCHAR_P, XCHAR_P,
 					XCHAR_P, XCHAR_P, XCHAR_P, XCHAR_P));
 
+long FDECL(opvar_array_length, (struct sp_coder *));
+
 #define LEFT	1
 #define H_LEFT	2
 #define CENTER	3
@@ -57,11 +56,11 @@ STATIC_DCL boolean FDECL(create_subroom, (struct mkroom *, XCHAR_P, XCHAR_P,
 #define NewTab(type, size)	(type **) alloc(sizeof(type *) * (unsigned)size)
 #define Free(ptr)		if(ptr) free((genericptr_t) (ptr))
 
-static NEARDATA walk walklist[50];
+extern struct engr *head_engr;
+
 extern int min_rx, max_rx, min_ry, max_ry; /* from mkmap.c */
 
-static char Map[COLNO][ROWNO];
-static char robjects[10], rloc_x[10], rloc_y[10], rmonst[10];
+static char SpLev_Map[COLNO][ROWNO];
 static aligntyp	ralign[3] = { AM_CHAOTIC, AM_NEUTRAL, AM_LAWFUL };
 static NEARDATA xchar xstart, ystart;
 static NEARDATA char xsize, ysize;
@@ -69,24 +68,375 @@ static NEARDATA char xsize, ysize;
 STATIC_DCL void FDECL(set_wall_property, (XCHAR_P,XCHAR_P,XCHAR_P,XCHAR_P,int));
 STATIC_DCL int NDECL(rnddoor);
 STATIC_DCL int NDECL(rndtrap);
-STATIC_DCL void FDECL(get_location, (schar *,schar *,int));
-STATIC_DCL void FDECL(sp_lev_shuffle, (char *,char *,int));
+STATIC_DCL void FDECL(get_location, (schar *,schar *,int, struct mkroom *));
 STATIC_DCL void FDECL(light_region, (region *));
-STATIC_DCL void FDECL(load_common_data, (dlb *,int));
-STATIC_DCL void FDECL(load_one_monster, (dlb *,monster *));
-STATIC_DCL void FDECL(load_one_object, (dlb *,object *));
-STATIC_DCL void FDECL(load_one_engraving, (dlb *,engraving *));
-STATIC_DCL boolean FDECL(load_rooms, (dlb *));
 STATIC_DCL void FDECL(maze1xy, (coord *,int));
-STATIC_DCL boolean FDECL(load_maze, (dlb *));
+STATIC_DCL boolean FDECL(sp_level_loader, (dlb *, sp_lev *));
 STATIC_DCL void FDECL(create_door, (room_door *, struct mkroom *));
-STATIC_DCL void FDECL(free_rooms,(room **, int));
-STATIC_DCL void FDECL(build_room, (room *, room*));
+struct mkroom * FDECL(build_room, (room *, struct mkroom *));
 
 char *lev_message = 0;
 lev_region *lregions = 0;
 int num_lregions = 0;
-lev_init init_lev;
+
+struct obj *container_obj[MAX_CONTAINMENT];
+int container_idx = 0;
+
+struct monst *invent_carrying_monster = NULL;
+
+#define SPLEV_STACK_RESERVE 128
+
+void
+splev_stack_init(st)
+     struct splevstack *st;
+{
+    if (st) {
+	st->depth = 0;
+	st->depth_alloc = SPLEV_STACK_RESERVE;
+	st->stackdata = (struct opvar **)alloc(st->depth_alloc * sizeof(struct opvar *));
+	if (!st->stackdata) panic("stack init alloc");
+    }
+}
+
+void
+splev_stack_done(st)
+     struct splevstack *st;
+{
+    if (st) {
+	int i;
+
+	if (st->stackdata && st->depth)
+	    for (i = 0; i < st->depth; i++) {
+		switch (st->stackdata[i]->spovartyp) {
+		default:
+		case SPOVAR_NULL:
+		case SPOVAR_COORD:
+		case SPOVAR_REGION:
+		case SPOVAR_MAPCHAR:
+		case SPOVAR_MONST:
+		case SPOVAR_OBJ:
+		case SPOVAR_INT:
+		    break;
+		case SPOVAR_VARIABLE:
+		case SPOVAR_STRING:
+		case SPOVAR_SEL:
+		    if (st->stackdata[i]->vardata.str) Free(st->stackdata[i]->vardata.str);
+		    st->stackdata[i]->vardata.str = NULL;
+		    break;
+		}
+		Free(st->stackdata[i]);
+		st->stackdata[i] = NULL;
+	    }
+
+	Free(st->stackdata);
+	st->stackdata = NULL;
+	st->depth = st->depth_alloc = 0;
+	Free(st);
+    }
+}
+
+void
+splev_stack_push(st, v)
+     struct splevstack *st;
+     struct opvar *v;
+{
+    if (!st || !v) return;
+    if (!st->stackdata) panic("splev_stack_push: no stackdata allocated?");
+
+    if (st->depth >= st->depth_alloc) {
+	struct opvar **tmp = (struct opvar **)alloc((st->depth_alloc + SPLEV_STACK_RESERVE) * sizeof(struct opvar *));
+	if (!tmp) panic("stack push alloc");
+	(void)memcpy(tmp, st->stackdata, st->depth_alloc * sizeof(struct opvar *));
+	Free(st->stackdata);
+	st->stackdata = tmp;
+	st->depth_alloc += SPLEV_STACK_RESERVE;
+    }
+
+    st->stackdata[st->depth] = v;
+    st->depth++;
+}
+
+struct opvar *
+splev_stack_pop(st)
+     struct splevstack *st;
+{
+    struct opvar *ret = NULL;
+    if (!st) return ret;
+    if (!st->stackdata) panic("splev_stack_pop: no stackdata allocated?");
+
+    if (st->depth) {
+	st->depth--;
+	ret = st->stackdata[st->depth];
+	st->stackdata[st->depth] = NULL;
+	return ret;
+    } else impossible("splev_stack_pop: empty stack?");
+    return ret;
+}
+
+struct splevstack *
+splev_stack_reverse(st)
+     struct splevstack *st;
+{
+    long i;
+    struct opvar *tmp;
+    if (!st) return NULL;
+    if (!st->stackdata) panic("splev_stack_reverse: no stackdata allocated?");
+    for (i = 0; i < (st->depth / 2); i++) {
+	tmp = st->stackdata[i];
+	st->stackdata[i] = st->stackdata[st->depth - i - 1];
+	st->stackdata[st->depth - i - 1] = tmp;
+    }
+    return st;
+}
+
+#define OV_typ(o) (o->spovartyp)
+#define OV_i(o) (o->vardata.l)
+#define OV_s(o) (o->vardata.str)
+
+#define OV_pop_i(x) (x = splev_stack_getdat(coder, SPOVAR_INT))
+#define OV_pop_c(x) (x = splev_stack_getdat(coder, SPOVAR_COORD))
+#define OV_pop_r(x) (x = splev_stack_getdat(coder, SPOVAR_REGION))
+#define OV_pop_s(x) (x = splev_stack_getdat(coder, SPOVAR_STRING))
+#define OV_pop(x)   (x = splev_stack_getdat_any(coder))
+#define OV_pop_typ(x,typ) (x = splev_stack_getdat(coder, typ))
+
+
+struct opvar *
+opvar_new_str(s)
+     char *s;
+{
+    struct opvar *tmpov = (struct opvar *)alloc(sizeof(struct opvar));
+    if (!tmpov) panic("could not alloc opvar struct");
+    tmpov->spovartyp = SPOVAR_STRING;
+    if (s) {
+	int len = strlen(s);
+	tmpov->vardata.str = (char *)alloc(len + 1);
+	if (!tmpov->vardata.str) panic("opvar new str alloc");
+	(void)memcpy((genericptr_t)tmpov->vardata.str,
+		     (genericptr_t)s, len);
+	tmpov->vardata.str[len] = '\0';
+    } else
+	tmpov->vardata.str = NULL;
+    return tmpov;
+}
+
+struct opvar *
+opvar_new_int(i)
+     long i;
+{
+    struct opvar *tmpov = (struct opvar *)alloc(sizeof(struct opvar));
+    if (!tmpov) panic("could not alloc opvar struct");
+    tmpov->spovartyp = SPOVAR_INT;
+    tmpov->vardata.l = i;
+    return tmpov;
+}
+
+struct opvar *
+opvar_new_coord(x,y)
+     int x,y;
+{
+    struct opvar *tmpov = (struct opvar *)alloc(sizeof(struct opvar));
+    if (!tmpov) panic("could not alloc opvar struct");
+    tmpov->spovartyp = SPOVAR_COORD;
+    tmpov->vardata.l = SP_COORD_PACK(x,y);
+    return tmpov;
+}
+
+struct opvar *
+opvar_new_region(x1,y1,x2,y2)
+     int x1,y1,x2,y2;
+{
+    struct opvar *tmpov = (struct opvar *)alloc(sizeof(struct opvar));
+    if (!tmpov) panic("could not alloc opvar struct");
+    tmpov->spovartyp = SPOVAR_REGION;
+    tmpov->vardata.l = SP_REGION_PACK(x1,y1,x2,y2);
+    return tmpov;
+}
+
+void
+opvar_free_x(ov)
+     struct opvar *ov;
+{
+    if (!ov) return;
+    switch (ov->spovartyp) {
+    case SPOVAR_COORD:
+    case SPOVAR_REGION:
+    case SPOVAR_MAPCHAR:
+    case SPOVAR_MONST:
+    case SPOVAR_OBJ:
+    case SPOVAR_INT:
+	break;
+    case SPOVAR_VARIABLE:
+    case SPOVAR_STRING:
+    case SPOVAR_SEL:
+	Free(ov->vardata.str);
+	break;
+    default: impossible("Unknown opvar value type (%i)!", ov->spovartyp);
+    }
+    Free(ov);
+}
+
+#define opvar_free(ov) { if (ov) { opvar_free_x(ov); ov = NULL; } else impossible("opvar_free(), %s", __FUNCTION__); }
+
+struct opvar *
+opvar_clone(ov)
+     struct opvar *ov;
+{
+    struct opvar *tmpov;
+    if (!ov) panic("no opvar to clone");
+    tmpov = (struct opvar *)alloc(sizeof(struct opvar));
+    if (!tmpov) panic("could not alloc opvar struct");
+    tmpov->spovartyp = ov->spovartyp;
+    switch (ov->spovartyp) {
+    case SPOVAR_COORD:
+    case SPOVAR_REGION:
+    case SPOVAR_MAPCHAR:
+    case SPOVAR_MONST:
+    case SPOVAR_OBJ:
+    case SPOVAR_INT:
+	tmpov->vardata.l = ov->vardata.l;
+	break;
+    case SPOVAR_VARIABLE:
+    case SPOVAR_STRING:
+    case SPOVAR_SEL:
+	tmpov->vardata.str = strdup(ov->vardata.str);
+	break;
+    default: impossible("Unknown push value type (%i)!", ov->spovartyp);
+    }
+    return tmpov;
+}
+
+
+struct opvar *
+opvar_var_conversion(coder, ov)
+     struct sp_coder *coder;
+     struct opvar *ov;
+{
+    struct splev_var *tmp;
+    struct opvar *tmpov;
+    struct opvar *array_idx = NULL;
+    if (!coder || !ov) return NULL;
+    if (ov->spovartyp != SPOVAR_VARIABLE) return ov;
+    tmp = coder->frame->variables;
+    while (tmp) {
+	if (!strcmp(tmp->name, OV_s(ov))) {
+	    if ((tmp->svtyp & SPOVAR_ARRAY)) {
+		array_idx = opvar_var_conversion(coder, splev_stack_pop(coder->stack));
+		if (!array_idx || OV_typ(array_idx) != SPOVAR_INT)
+		    panic("array idx not an int");
+		if (tmp->array_len < 1) panic("array len < 1");
+		OV_i(array_idx) = (OV_i(array_idx) % tmp->array_len);
+		tmpov = opvar_clone(tmp->data.arrayvalues[OV_i(array_idx)]);
+		return tmpov;
+	    } else {
+		tmpov = opvar_clone(tmp->data.value);
+		return tmpov;
+	    }
+	}
+	tmp = tmp->next;
+    }
+    return NULL;
+}
+
+struct splev_var *
+opvar_var_defined(coder, name)
+     struct sp_coder *coder;
+     char *name;
+{
+    struct splev_var *tmp;
+    if (!coder) return NULL;
+    tmp = coder->frame->variables;
+    while (tmp) {
+	if (!strcmp(tmp->name, name)) return tmp;
+	tmp = tmp->next;
+    }
+    return NULL;
+}
+
+struct opvar *
+splev_stack_getdat(coder, typ)
+     struct sp_coder *coder;
+     xchar typ;
+{
+    if (coder && coder->stack) {
+	struct opvar *tmp = splev_stack_pop(coder->stack);
+	if (!tmp) panic("no value type %i in stack.", typ);
+	if (tmp->spovartyp == SPOVAR_VARIABLE)
+	    tmp = opvar_var_conversion(coder, tmp);
+	if (tmp->spovartyp == typ)
+	    return tmp;
+    }
+    return NULL;
+}
+
+struct opvar *
+splev_stack_getdat_any(coder)
+     struct sp_coder *coder;
+{
+    if (coder && coder->stack) {
+	struct opvar *tmp = splev_stack_pop(coder->stack);
+	if (tmp && tmp->spovartyp == SPOVAR_VARIABLE)
+	    tmp = opvar_var_conversion(coder, tmp);
+	return tmp;
+    }
+    return NULL;
+}
+
+
+
+void
+variable_list_del(varlist)
+     struct splev_var *varlist;
+{
+    struct splev_var *tmp = varlist;
+    if (!tmp) return;
+    while (tmp) {
+	Free(tmp->name);
+	if ((tmp->svtyp & SPOVAR_ARRAY)) {
+	    long idx = tmp->array_len;
+	    while (idx-- > 0) {
+		opvar_free(tmp->data.arrayvalues[idx]);
+	    };
+	    Free(tmp->data.arrayvalues);
+	} else {
+	    opvar_free(tmp->data.value);
+	}
+	tmp = varlist->next;
+	Free(varlist);
+	varlist = tmp;
+    }
+}
+
+void
+lvlfill_maze_grid(x1,y1,x2,y2,filling)
+int x1,y1,x2,y2;
+schar filling;
+{
+	int x,y;
+
+	for (x = x1; x <= x2; x++)
+		for (y = y1; y <= y2; y++) {
+#ifndef WALLIFIED_MAZE
+			levl[x][y].typ = STONE;
+#else
+			levl[x][y].typ =
+				(y < 2 || ((x % 2) && (y % 2))) ? STONE : filling;
+#endif
+		}
+}
+
+void
+lvlfill_solid(filling,lit)
+schar filling;
+schar lit;
+{
+	int x,y;
+	for (x = 2; x <= x_maze_max; x++)
+	for (y = 0; y <= y_maze_max; y++) {
+	    SET_TYPLIT(x,y,filling,lit);
+	}
+}
+
 
 /*
  * Make walls of the area (x1, y1, x2, y2) non diggable/non passwall-able
@@ -99,12 +449,78 @@ int prop;
 {
 	register xchar x, y;
 
-	for(y = y1; y <= y2; y++)
-	    for(x = x1; x <= x2; x++)
-		if(IS_STWALL(levl[x][y].typ))
+	for(y = max(y1,0); y <= min(y2, ROWNO-1); y++)
+	    for(x = max(x1,0); x <= min(x2,COLNO-1); x++)
+		if(IS_STWALL(levl[x][y].typ) || IS_TREE(levl[x][y].typ))
 		    levl[x][y].wall_info |= prop;
 }
 
+STATIC_OVL void
+shuffle_alignments()
+{
+    int	i;
+    aligntyp atmp;
+    /* shuffle 3 alignments */
+    i = rn2(3);   atmp=ralign[2]; ralign[2]=ralign[i]; ralign[i]=atmp;
+    if (rn2(2)) { atmp=ralign[1]; ralign[1]=ralign[0]; ralign[0]=atmp; }
+}
+
+/*
+ * Count the different features (sinks, fountains) in the level.
+ */
+STATIC_OVL void
+count_features()
+{
+    xchar x,y;
+    level.flags.nfountains = level.flags.nsinks = 0;
+    for (y = 0; y < ROWNO; y++)
+	for (x = 0; x < COLNO; x++) {
+	    int typ = levl[x][y].typ;
+	    if (typ == FOUNTAIN)
+		level.flags.nfountains++;
+	    else if (typ == SINK)
+		level.flags.nsinks++;
+	}
+}
+
+void
+remove_boundary_syms()
+{
+    /*
+     * If any CROSSWALLs are found, must change to ROOM after REGION's
+     * are laid out.  CROSSWALLS are used to specify "invisible"
+     * boundaries where DOOR syms look bad or aren't desirable.
+     */
+    xchar x,y;
+    boolean has_bounds = FALSE;
+    for (x = 0; x < COLNO-1; x++)
+	for (y = 0; y < ROWNO-1; y++)
+	    if (levl[x][y].typ == CROSSWALL) {
+		has_bounds = TRUE;
+		break;
+	    }
+    if (has_bounds) {
+	for(x = 0; x < x_maze_max; x++)
+	    for(y = 0; y < y_maze_max; y++)
+		if ((levl[x][y].typ == CROSSWALL) && !SpLev_Map[x][y])
+		    levl[x][y].typ = ROOM;
+    }
+}
+
+void
+fill_rooms()
+{
+    int tmpi;
+    for (tmpi = 0; tmpi < nroom; tmpi++) {
+	int m;
+	if (rooms[tmpi].needfill)
+	    fill_room(&rooms[tmpi], (rooms[tmpi].needfill == 2));
+	for (m = 0; m < rooms[tmpi].nsubrooms; m++)
+	    if (rooms[tmpi].sbrooms[m]->needfill)
+		fill_room(rooms[tmpi].sbrooms[m], FALSE);
+    }
+}
+
 /*
  * Choose randomly the state (nodoor, open, closed or locked) for a door
  */
@@ -146,55 +562,74 @@ rndtrap()
 /*
  * Coordinates in special level files are handled specially:
  *
- *	if x or y is -11, we generate a random coordinate.
- *	if x or y is between -1 and -10, we read one from the corresponding
- *	register (x0, x1, ... x9).
- *	if x or y is nonnegative, we convert it from relative to the local map
- *	to global coordinates.
+ *	if x or y is < 0, we generate a random coordinate.
  *	The "humidity" flag is used to insure that engravings aren't
  *	created underwater, or eels on dry land.
  */
-#define DRY	0x1
-#define WET	0x2
-
 STATIC_DCL boolean FDECL(is_ok_location, (SCHAR_P, SCHAR_P, int));
 
 STATIC_OVL void
-get_location(x, y, humidity)
+get_location(x, y, humidity, croom)
 schar *x, *y;
 int humidity;
+struct mkroom *croom;
 {
 	int cpt = 0;
+        int mx, my, sx, sy;
+
+        if (croom) {
+	    mx = croom->lx;
+	    my = croom->ly;
+	    sx = croom->hx - mx + 1;
+	    sy = croom->hy - my + 1;
+	} else {
+	    mx = xstart;
+	    my = ystart;
+	    sx = xsize;
+	    sy = ysize;
+	}
 
 	if (*x >= 0) {			/* normal locations */
-		*x += xstart;
-		*y += ystart;
-	} else if (*x > -11) {		/* special locations */
-		*y = ystart + rloc_y[ - *y - 1];
-		*x = xstart + rloc_x[ - *x - 1];
+		*x += mx;
+		*y += my;
 	} else {			/* random location */
 	    do {
-		*x = xstart + rn2((int)xsize);
-		*y = ystart + rn2((int)ysize);
+		if (croom) { /* handle irregular areas */
+		    coord tmpc;
+		    somexy(croom, &tmpc);
+		    *x = tmpc.x;
+		    *y = tmpc.y;
+		} else {
+		    *x = mx + rn2((int)sx);
+		    *y = my + rn2((int)sy);
+		}
 		if (is_ok_location(*x,*y,humidity)) break;
 	    } while (++cpt < 100);
 	    if (cpt >= 100) {
 		register int xx, yy;
 		/* last try */
-		for (xx = 0; xx < xsize; xx++)
-		    for (yy = 0; yy < ysize; yy++) {
-			*x = xstart + xx;
-			*y = ystart + yy;
+		for (xx = 0; xx < sx; xx++)
+		    for (yy = 0; yy < sy; yy++) {
+			*x = mx + xx;
+			*y = my + yy;
 			if (is_ok_location(*x,*y,humidity)) goto found_it;
 		    }
-		panic("get_location:  can't find a place!");
+		if (!(humidity & NO_LOC_WARN)) {
+		    impossible("get_location:  can't find a place!");
+		} else {
+		    *x = *y = -1;
+		}
 	    }
 	}
 found_it:;
 
-	if (!isok(*x,*y)) {
-	    impossible("get_location:  (%d,%d) out of bounds", *x, *y);
-	    *x = x_maze_max; *y = y_maze_max;
+	if (!(humidity & ANY_LOC) && !isok(*x,*y)) {
+	    if (!(humidity & NO_LOC_WARN)) {
+		/*warning("get_location:  (%d,%d) out of bounds", *x, *y);*/
+		*x = x_maze_max; *y = y_maze_max;
+	    } else {
+		*x = *y = -1;
+	    }
 	}
 }
 
@@ -207,42 +642,58 @@ register int humidity;
 
 	if (Is_waterlevel(&u.uz)) return TRUE;	/* accept any spot */
 
+	/* TODO: Should perhaps check if wall is diggable/passwall? */
+	if (humidity & ANY_LOC) return TRUE;
+
+	if ((humidity & SOLID) && IS_ROCK(levl[x][y].typ)) return TRUE;
+
 	if (humidity & DRY) {
 	    typ = levl[x][y].typ;
 	    if (typ == ROOM || typ == AIR ||
 		    typ == CLOUD || typ == ICE || typ == CORR)
 		return TRUE;
 	}
-	if (humidity & WET) {
-	    if (is_pool(x,y) || ((humidity & DRY) && is_lava(x,y)))
-		return TRUE;
-	}
+	if ((humidity & WET) && is_pool(x,y)) return TRUE;
+	if ((humidity & HOT) && is_lava(x,y)) return TRUE;
 	return FALSE;
 }
 
-/*
- * Shuffle the registers for locations, objects or monsters
- */
+
+unpacked_coord
+get_unpacked_coord(loc, defhumidity)
+     long loc;
+     int defhumidity;
+{
+    static unpacked_coord c;
+
+    if (loc & SP_COORD_IS_RANDOM) {
+	c.x = c.y = -1;
+	c.is_random = 1;
+	c.getloc_flags = (loc & ~SP_COORD_IS_RANDOM);
+	if (!c.getloc_flags) c.getloc_flags = defhumidity;
+    } else {
+	c.is_random = 0;
+	c.getloc_flags = defhumidity;
+	c.x = SP_COORD_X(loc);
+	c.y = SP_COORD_Y(loc);
+    }
+    return c;
+}
 
 STATIC_OVL void
-sp_lev_shuffle(list1, list2, n)
-char list1[], list2[];
-int n;
+get_location_coord(x, y, humidity, croom, crd)
+schar *x, *y;
+int humidity;
+struct mkroom *croom;
+long crd;
 {
-	register int i, j;
-	register char k;
-
-	for (i = n - 1; i > 0; i--) {
-		if ((j = rn2(i + 1)) == i) continue;
-		k = list1[j];
-		list1[j] = list1[i];
-		list1[i] = k;
-		if (list2) {
-			k = list2[j];
-			list2[j] = list2[i];
-			list2[i] = k;
-		}
-	}
+    unpacked_coord c;
+    c = get_unpacked_coord(crd, humidity);
+    *x = c.x;
+    *y = c.y;
+    get_location(x, y, c.getloc_flags | (c.is_random ? NO_LOC_WARN : 0), croom);
+    if (*x == -1 && *y == -1 && c.is_random)
+	get_location(x,y, humidity, croom);
 }
 
 /*
@@ -279,20 +730,24 @@ struct mkroom	*croom;
  */
 
 STATIC_OVL void
-get_free_room_loc(x,y, croom)
+get_free_room_loc(x,y, croom, pos)
 schar		*x, *y;
 struct mkroom	*croom;
+packed_coord	pos;
 {
 	schar try_x, try_y;
 	register int trycnt = 0;
 
-	do {
-	    try_x = *x,  try_y = *y;
-	    get_room_loc(&try_x, &try_y, croom);
-	} while (levl[try_x][try_y].typ != ROOM && ++trycnt <= 100);
+	get_location_coord(&try_x, &try_y, DRY, croom, pos);
+        if (levl[try_x][try_y].typ != ROOM) {
+	    do {
+		try_x = *x,  try_y = *y;
+		get_room_loc(&try_x, &try_y, croom);
+	    } while (levl[try_x][try_y].typ != ROOM && ++trycnt <= 100);
 
-	if (trycnt > 100)
-	    panic("get_free_room_loc:  can't find a place!");
+	    if (trycnt > 100)
+		panic("get_free_room_loc:  can't find a place!");
+	}
 	*x = try_x,  *y = try_y;
 }
 
@@ -390,7 +845,7 @@ xchar	rtype, rlit;
 		xtmp = x; ytmp = y;
 		xaltmp = xal; yaltmp = yal;
 
-		/* First case : a totaly random room */
+		/* First case : a totally random room */
 
 		if((xtmp < 0 && ytmp <0 && wtmp < 0 && xaltmp < 0 &&
 		   yaltmp < 0) || vault) {
@@ -571,8 +1026,8 @@ create_door(dd, broom)
 room_door *dd;
 struct mkroom *broom;
 {
-	int	x, y;
-	int	trycnt = 0;
+	int	x = 0, y = 0;
+	int	trycnt = 0, wtry = 0;
 
 	if (dd->secret == -1)
 	    dd->secret = rn2(2);
@@ -607,37 +1062,43 @@ struct mkroom *broom;
 		    dwall = 1 << rn2(4);
 
 		dpos = dd->pos;
-		if (dpos == -1)	/* The position is RANDOM */
-		    dpos = rn2((dwall == W_WEST || dwall == W_EAST) ?
-			       (broom->hy - broom->ly + 1) :
-			       (broom->hx - broom->lx + 1));
 
 		/* Convert wall and pos into an absolute coordinate! */
-
-		switch (dwall) {
-		      case W_NORTH:
+		wtry = rn2(4);
+		switch (wtry) {
+		      case 0:
+			if (!(dwall & W_NORTH)) goto redoloop;
 			y = broom->ly - 1;
-			x = broom->lx + dpos;
-			break;
-		      case W_SOUTH:
+			x = broom->lx + ((dpos == -1) ? rn2(1+(broom->hx - broom->lx)) : dpos);
+			if (IS_ROCK(levl[x][y-1].typ)) goto redoloop;
+			goto outdirloop;
+		      case 1:
+			if (!(dwall & W_SOUTH)) goto redoloop;
 			y = broom->hy + 1;
-			x = broom->lx + dpos;
-			break;
-		      case W_WEST:
+			x = broom->lx + ((dpos == -1) ? rn2(1+(broom->hx - broom->lx)) : dpos);
+			if (IS_ROCK(levl[x][y+1].typ)) goto redoloop;
+			goto outdirloop;
+		      case 2:
+			if (!(dwall & W_WEST)) goto redoloop;
 			x = broom->lx - 1;
-			y = broom->ly + dpos;
-			break;
-		      case W_EAST:
+			y = broom->ly + ((dpos == -1) ? rn2(1+(broom->hy - broom->ly)) : dpos);
+			if (IS_ROCK(levl[x-1][y].typ)) goto redoloop;
+			goto outdirloop;
+		      case 3:
+			if (!(dwall & W_EAST)) goto redoloop;
 			x = broom->hx + 1;
-			y = broom->ly + dpos;
-			break;
+			y = broom->ly + ((dpos == -1) ? rn2(1+(broom->hy - broom->ly)) : dpos);
+			if (IS_ROCK(levl[x+1][y].typ)) goto redoloop;
+			goto outdirloop;
 		      default:
 			x = y = 0;
 			panic("create_door: No wall for door!");
-			break;
+			goto outdirloop;
 		}
+outdirloop:
 		if (okdoor(x,y))
 		    break;
+redoloop: ;
 	} while (++trycnt <= 100);
 	if (trycnt > 100) {
 		impossible("create_door: Can't find a proper place!");
@@ -701,19 +1162,20 @@ struct mkroom	*croom;
     schar	x,y;
     coord	tm;
 
-    if (rn2(100) < t->chance) {
-	x = t->x;
-	y = t->y;
-	if (croom)
-	    get_free_room_loc(&x, &y, croom);
-	else
-	    get_location(&x, &y, DRY);
+    if (croom)
+	get_free_room_loc(&x, &y, croom, t->coord);
+    else {
+	int trycnt = 0;
+	do {
+	    get_location_coord(&x, &y, DRY, croom, t->coord);
+	} while ((levl[x][y].typ == STAIRS || levl[x][y].typ == LADDER) && ++trycnt <= 100);
+	if (trycnt > 100) return;
+    }
 
 	tm.x = x;
 	tm.y = y;
 
 	mktrap(t->type, 1, (struct mkroom*) 0, &tm);
-    }
 }
 
 /*
@@ -765,12 +1227,9 @@ struct mkroom	*croom;
     struct permonst *pm;
     unsigned g_mvflags;
 
-    if (rn2(100) < m->chance) {
 
 	if (m->class >= 0)
 	    class = (char) def_char_to_monclass((char)m->class);
-	else if (m->class > -11)
-	    class = (char) def_char_to_monclass(rmonst[- m->class - 1]);
 	else
 	    class = 0;
 
@@ -781,7 +1240,7 @@ struct mkroom	*croom;
 			Align2amask(u.ualignbase[A_ORIGINAL]) :
 		(m->align == AM_SPLEV_NONCO) ?
 			Align2amask(noncoalignment(u.ualignbase[A_ORIGINAL])) :
-		(m->align <= -11) ? induced_align(80) :
+		(m->align <= -(MAX_REGISTERS+1)) ? induced_align(80) :
 		(m->align < 0 ? ralign[-m->align-1] : m->align);
 
 	if (!class)
@@ -790,7 +1249,7 @@ struct mkroom	*croom;
 	    pm = &mons[m->id];
 	    g_mvflags = (unsigned) mvitals[monsndx(pm)].mvflags;
 	    if ((pm->geno & G_UNIQ) && (g_mvflags & G_EXTINCT))
-		goto m_done;
+		return;
 	    else if (g_mvflags & G_GONE)	/* genocided or extinct */
 		pm = (struct permonst *) 0;	/* make random monster */
 	} else {
@@ -802,23 +1261,27 @@ struct mkroom	*croom;
 			(Race_if(PM_DWARF) || Race_if(PM_GNOME)) && rn2(3))
 	    pm = (struct permonst *) 0;
 
-	x = m->x;
-	y = m->y;
-	if (croom)
-	    get_room_loc(&x, &y, croom);
-	else {
-	    if (!pm || !is_swimmer(pm))
-		get_location(&x, &y, DRY);
-	    else if (pm->mlet == S_EEL)
-		get_location(&x, &y, WET);
-	    else
-		get_location(&x, &y, DRY|WET);
+	if (pm) {
+	    int loc = DRY;
+	    if (pm->mlet == S_EEL || amphibious(pm) || is_swimmer(pm)) loc = WET;
+	    if (is_flyer(pm) || is_floater(pm)) loc |= (HOT | WET);
+	    if (passes_walls(pm) || noncorporeal(pm)) loc |= SOLID;
+	    if (flaming(pm)) loc |= HOT;
+	    /* If water-liking monster, first try is without DRY */
+	    get_location_coord(&x, &y, loc|NO_LOC_WARN, croom, m->coord);
+	    if (x == -1 && y == -1) {
+		loc |= DRY;
+		get_location_coord(&x, &y, loc, croom, m->coord);
+	    }
+	} else {
+	    get_location_coord(&x, &y, DRY, croom, m->coord);
 	}
+
 	/* try to find a close place if someone else is already there */
 	if (MON_AT(x,y) && enexto(&cc, x, y, pm))
 	    x = cc.x,  y = cc.y;
 
-	if(m->align != -12)
+	if(m->align != -(MAX_REGISTERS+2))
 	    mtmp = mk_roamer(pm, Amask2align(amask), x, y, m->peaceful);
 	else if(PM_ARCHEOLOGIST <= m->id && m->id <= PM_WIZARD)
 	         mtmp = mk_mplayer(pm, x, y, FALSE);
@@ -833,7 +1296,7 @@ struct mkroom	*croom;
 	     * This is currently hardwired for mimics only.  It should
 	     * eventually be expanded.
 	     */
-	    if (m->appear_as.str && mtmp->data->mlet == S_MIMIC) {
+	    if (m->appear_as.str && ((mtmp->data->mlet == S_MIMIC) || mtmp->cham)) {
 		int i;
 
 		switch (m->appear) {
@@ -879,10 +1342,7 @@ struct mkroom	*croom;
 				do {
 				    x = m->x;
 				    y = m->y;
-				    if (croom)
-					get_room_loc(&x, &y, croom);
-				    else
-					get_location(&x, &y, DRY);
+				    get_location(&x, &y, DRY, croom);
 				    if (MON_AT(x,y) && enexto(&cc, x, y, pm))
 					x = cc.x,  y = cc.y;
 				} while (m_bad_boulder_spot(x, y) &&
@@ -896,8 +1356,38 @@ struct mkroom	*croom;
 			break;
 
 		    case M_AP_MONSTER:
-			/* note: mimics don't appear as monsters! */
-			/*	 (but chameleons can :-)	  */
+			{
+			    int mndx;
+			    if (!strcmpi(m->appear_as.str, "random"))
+				mndx = select_newcham_form(mtmp);
+			    else
+				mndx = name_to_mon(m->appear_as.str);
+			    if ((mndx != NON_PM) && (&mons[mndx] != mtmp->data)) {
+				struct permonst *mdat = &mons[mndx];
+				struct permonst *olddata = mtmp->data;
+				/* this code duplicated from newcham() */
+				if(is_male(mdat)) {
+				    if(mtmp->female) mtmp->female = FALSE;
+				} else if (is_female(mdat)) {
+				    if(!mtmp->female) mtmp->female = TRUE;
+				} else if (!is_neuter(mdat)) {
+				    if(!rn2(10)) mtmp->female = !mtmp->female;
+				}
+				set_mon_data(mtmp, mdat, 0);
+				if (emits_light(olddata) != emits_light(mtmp->data)) {
+				    /* used to give light, now doesn't, or vice versa,
+				       or light's range has changed */
+				    if (emits_light(olddata))
+					del_light_source(LS_MONSTER, (genericptr_t)mtmp);
+				    if (emits_light(mtmp->data))
+					new_light_source(mtmp->mx, mtmp->my, emits_light(mtmp->data),
+							 LS_MONSTER, (genericptr_t)mtmp);
+				}
+				if (!mtmp->perminvis || pm_invisible(olddata))
+				    mtmp->perminvis = pm_invisible(mdat);
+			    }
+			}
+			break;
 		    default:
 			impossible(
 		"create_monster: unimplemented mon appear type [%d,\"%s\"]",
@@ -924,12 +1414,35 @@ struct mkroom	*croom;
 		mtmp->msleeping = m->asleep;
 #endif
 	    }
+	    if (m->seentraps) mtmp->mtrapseen = m->seentraps;
+	    if (m->female) mtmp->female = 1;
+	    if (m->cancelled) mtmp->mcan = 1;
+	    if (m->revived) mtmp->mrevived = 1;
+	    if (m->avenge) mtmp->mavenge = 1;
+	    if (m->stunned) mtmp->mstun = 1;
+	    if (m->confused) mtmp->mconf = 1;
+	    if (m->invis) {
+		mtmp->minvis = mtmp->perminvis = 1;
+	    }
+	    if (m->blinded) {
+		mtmp->mcansee = 0;
+		mtmp->mblinded = (m->blinded % 127);
+	    }
+	    if (m->paralyzed) {
+		mtmp->mcanmove = 0;
+		mtmp->mfrozen = (m->paralyzed % 127);
+	    }
+	    if (m->fleeing) {
+		mtmp->mflee = 1;
+		mtmp->mfleetim = (m->fleeing % 127);
+	    }
+
+	    if (m->has_invent) {
+		discard_minvent(mtmp);
+		invent_carrying_monster = mtmp;
+	    }
 	}
 
-    }		/* if (rn2(100) < m->chance) */
- m_done:
-    Free(m->name.str);
-    Free(m->appear_as.str);
 }
 
 /*
@@ -946,19 +1459,12 @@ struct mkroom	*croom;
     char c;
     boolean named;	/* has a name been supplied in level description? */
 
-    if (rn2(100) < o->chance) {
 	named = o->name.str ? TRUE : FALSE;
 
-	x = o->x; y = o->y;
-	if (croom)
-	    get_room_loc(&x, &y, croom);
-	else
-	    get_location(&x, &y, DRY);
+	get_location_coord(&x, &y, DRY, croom, o->coord);
 
 	if (o->class >= 0)
 	    c = o->class;
-	else if (o->class > -11)
-	    c = robjects[ -(o->class+1)];
 	else
 	    c = 0;
 
@@ -1005,27 +1511,78 @@ struct mkroom	*croom;
 	if (named)
 	    otmp = oname(otmp, o->name.str);
 
-	switch(o->containment) {
-	    static struct obj *container = 0;
+	if (o->eroded) {
+	    if (o->eroded < 0) otmp->oerodeproof = 1;
+	    else {
+		otmp->oeroded = (o->eroded % 4);
+		otmp->oeroded2 = ((o->eroded >> 2) % 4);
+	    }
+	}
+	if (o->recharged) otmp->recharged = (o->recharged % 8);
+	if (o->locked) otmp->olocked = 1;
+	else if (o->broken) {
+	    otmp->obroken = 1;
+	    otmp->olocked = 0; /* obj generation may set */
+	}
+	if (o->trapped) otmp->otrapped = 1;
+	if (o->greased) otmp->greased = 1;
+#ifdef INVISIBLE_OBJECTS
+	if (o->invis) otmp->oinvis = 1;
+#endif
 
-	    /* contents */
-	    case 1:
-		if (!container) {
-		    impossible("create_object: no container");
-		    break;
+	if ((o->quan > 0) && objects[otmp->otyp].oc_merge) {
+	    otmp->quan = o->quan;
+	    otmp->owt = weight(otmp);
+	}
+
+	/* contents */
+	if (o->containment & SP_OBJ_CONTENT) {
+	    if (!container_idx) {
+		if (!invent_carrying_monster) {
+		    /*impossible("create_object: no container");*/
+		    /* don't complain, the monster may be gone legally (eg. unique demon already generated)
+		       TODO: In the case of unique demon lords, they should get their inventories even when
+		       they get generated outside the des-file. Maybe another data file that determines what
+		       inventories monsters get by default?
+		     */
+		} else {
+		    int c;
+		    struct obj *objcheck = otmp;
+		    int inuse = -1;
+		    for (c = 0; c < container_idx; c++)
+			if (container_obj[c] == objcheck)
+			    inuse = c;
+		    remove_object(otmp);
+		    if (mpickobj(invent_carrying_monster, otmp)) {
+			if (inuse > -1) {
+			    impossible("container given to monster was merged or deallocated.");
+			    for (c = inuse; c < container_idx-1; c++)
+				container_obj[c] = container_obj[c+1];
+			    container_obj[container_idx] = NULL;
+			    container_idx--;
+			}
+			/* we lost track of it. */
+			return;
+		    }
 		}
+	    } else {
 		remove_object(otmp);
-		(void) add_to_container(container, otmp);
-		goto o_done;		/* don't stack, but do other cleanup */
-	    /* container */
-	    case 2:
-		delete_contents(otmp);
-		container = otmp;
-		break;
-	    /* nothing */
-	    case 0: break;
-
-	    default: impossible("containment type %d?", (int) o->containment);
+		if (container_obj[container_idx-1])
+		    (void) add_to_container(container_obj[container_idx-1], otmp);
+		else {
+		    obj_extract_self(otmp);
+		    obfree(otmp, NULL);
+		    return;
+		}
+	    }
+	}
+	/* container */
+	if (o->containment & SP_OBJ_CONTAINER) {
+	    delete_contents(otmp);
+	    if (container_idx < MAX_CONTAINMENT) {
+		container_obj[container_idx] = otmp;
+		container_idx++;
+	    } else impossible("create_object: too deeply nested containers.");
 	}
 
 	/* Medusa level special case: statues are petrified monsters, so they
@@ -1037,73 +1594,48 @@ struct mkroom	*croom;
 	    struct monst *was;
 	    struct obj *obj;
 	    int wastyp;
+	    int i = 0; /* prevent endless loop in case makemon always fails */
 
 	    /* Named random statues are of player types, and aren't stone-
 	     * resistant (if they were, we'd have to reset the name as well as
 	     * setting corpsenm).
 	     */
-	    for (wastyp = otmp->corpsenm; ; wastyp = rndmonnum()) {
+	    for (wastyp = otmp->corpsenm; i < 1000 ; i++, wastyp = rndmonnum()) {
 		/* makemon without rndmonst() might create a group */
 		was = makemon(&mons[wastyp], 0, 0, MM_NOCOUNTBIRTH);
-		if (!resists_ston(was)) {
+		if (was && !resists_ston(was)) {
 	    		(void) propagate(wastyp, TRUE, FALSE);
 			break;
 		}
 		mongone(was);
 	    }
-	    set_corpsenm(otmp, wastyp);
-	    while(was->minvent) {
-		obj = was->minvent;
-		obj->owornmask = 0;
-		obj_extract_self(obj);
-		(void) add_to_container(otmp, obj);
+	    if (was) {
+		set_corpsenm(otmp, wastyp);
+		while(was->minvent) {
+		    obj = was->minvent;
+		    obj->owornmask = 0;
+		    obj_extract_self(obj);
+		    (void) add_to_container(otmp, obj);
+		}
+		otmp->owt = weight(otmp);
+		mongone(was);
 	    }
-	    otmp->owt = weight(otmp);
-	    mongone(was);
 	}
 
 	stackobj(otmp);
 
-    }		/* if (rn2(100) < o->chance) */
- o_done:
-    Free(o->name.str);
-}
+	if (o->lit) {
+	    begin_burn(otmp, FALSE);
+	}
 
-/*
- * Randomly place a specific engraving, then release its memory.
- */
-STATIC_OVL void
-create_engraving(e, croom)
-engraving *e;
-struct mkroom *croom;
-{
-	xchar x, y;
+	if (o->buried) {
+	    boolean dealloced;
+	    (void) bury_an_obj(otmp, &dealloced);
+	    if (dealloced && container_idx) {
+		container_obj[container_idx-1] = NULL;
+	    }
+	}
 
-	x = e->x,  y = e->y;
-	if (croom)
-	    get_room_loc(&x, &y, croom);
-	else
-	    get_location(&x, &y, DRY);
-
-	make_engr_at(x, y, e->engr.str, 0L, e->etype);
-	free((genericptr_t) e->engr.str);
-}
-
-/*
- * Create stairs in a room.
- *
- */
-
-STATIC_OVL void
-create_stairs(s,croom)
-stair	*s;
-struct mkroom	*croom;
-{
-	schar		x,y;
-
-	x = s->x; y = s->y;
-	get_free_room_loc(&x, &y, croom);
-	mkstairs(x,y,(char)s->up, croom);
 }
 
 /*
@@ -1118,16 +1650,14 @@ create_altar(a, croom)
 	schar		sproom,x,y;
 	aligntyp	amask;
 	boolean		croom_is_temple = TRUE;
-	int oldtyp; 
-
-	x = a->x; y = a->y;
+	int oldtyp;
 
 	if (croom) {
-	    get_free_room_loc(&x, &y, croom);
+	    get_free_room_loc(&x, &y, croom, a->coord);
 	    if (croom->rtype != TEMPLE)
 		croom_is_temple = FALSE;
 	} else {
-	    get_location(&x, &y, DRY);
+	    get_location_coord(&x, &y, DRY, croom, a->coord);
 	    if ((sproom = (schar) *in_rooms(x, y, TEMPLE)) != 0)
 		croom = &rooms[sproom - ROOMOFFSET];
 	    else
@@ -1139,9 +1669,6 @@ create_altar(a, croom)
 	if (oldtyp == STAIRS || oldtyp == LADDER)
 	    return;
 
-	a->x = x;
-	a->y = y;
-
 	/* Is the alignment random ?
 	 * If so, it's an 80% chance that the altar will be co-aligned.
 	 *
@@ -1154,7 +1681,7 @@ create_altar(a, croom)
 			Align2amask(u.ualignbase[A_ORIGINAL]) :
 		(a->align == AM_SPLEV_NONCO) ?
 			Align2amask(noncoalignment(u.ualignbase[A_ORIGINAL])) :
-		(a->align == -11) ? induced_align(80) :
+		(a->align == -(MAX_REGISTERS+1)) ? induced_align(80) :
 		(a->align < 0 ? ralign[-a->align-1] : a->align);
 
 	levl[x][y].typ = ALTAR;
@@ -1162,11 +1689,6 @@ create_altar(a, croom)
 
 	if (a->shrine < 0) a->shrine = rn2(2);	/* handle random case */
 
-	if (oldtyp == FOUNTAIN)
-	    level.flags.nfountains--;
-	else if (oldtyp == SINK)
-	    level.flags.nsinks--;
-
 	if (!croom_is_temple || !a->shrine) return;
 
 	if (a->shrine) {	/* Is it a shrine  or sanctum? */
@@ -1176,68 +1698,29 @@ create_altar(a, croom)
 	}
 }
 
-/*
- * Create a gold pile in a room.
- */
 
-STATIC_OVL void
-create_gold(g,croom)
-gold *g;
-struct mkroom	*croom;
+void
+replace_terrain(terr, croom)
+replaceterrain *terr;
+struct mkroom *croom;
 {
-	schar		x,y;
+    schar x, y, x1, y1, x2, y2;
 
-	x = g->x; y= g->y;
-	if (croom)
-	    get_room_loc(&x, &y, croom);
-	else
-	    get_location(&x, &y, DRY);
+    if (terr->toter >= MAX_TYPE) return;
 
-	if (g->amount == -1)
-	    g->amount = rnd(200);
-	(void) mkgold((long) g->amount, x, y);
+    x1 = terr->x1;  y1 = terr->y1;
+    get_location(&x1, &y1, ANY_LOC, croom);
+
+    x2 = terr->x2;  y2 = terr->y2;
+    get_location(&x2, &y2, ANY_LOC, croom);
+
+    for (x = max(x1,0); x <= min(x2,COLNO-1); x++)
+	for (y = max(y1,0); y <= min(y2,ROWNO-1); y++)
+	    if ((levl[x][y].typ == terr->fromter) && (rn2(100) < terr->chance)) {
+		SET_TYPLIT(x,y, terr->toter, terr->tolit);
+	    }
 }
 
-/*
- * Create a feature (e.g a fountain) in a room.
- */
-
-STATIC_OVL void
-create_feature(fx, fy, croom, typ)
-int		fx, fy;
-struct mkroom	*croom;
-int		typ;
-{
-	schar		x,y;
-	int		trycnt = 0;
-
-	x = fx;  y = fy;
-	if (croom) {
-	    if (x < 0 && y < 0)
-		do {
-		    x = -1;  y = -1;
-		    get_room_loc(&x, &y, croom);
-		} while (++trycnt <= 200 && occupied(x,y));
-	    else
-		get_room_loc(&x, &y, croom);
-	    if(trycnt > 200)
-		return;
-	} else {
-	    get_location(&x, &y, DRY);
-	}
-	/* Don't cover up an existing feature (particularly randomly
-	   placed stairs).  However, if the _same_ feature is already
-	   here, it came from the map drawing and we still need to
-	   update the special counters. */
-	if (IS_FURNITURE(levl[x][y].typ) && levl[x][y].typ != typ)
-	    return;
-
-	levl[x][y].typ = typ;
-	if (typ == FOUNTAIN)
-	    level.flags.nfountains++;
-	else if (typ == SINK)
-	    level.flags.nsinks++;
-}
 
 /*
  * Search for a door in a room on a specified wall.
@@ -1451,9 +1934,9 @@ corridor	*c;
 	coord org, dest;
 
 	if (c->src.room == -1) {
-		sort_rooms();
+	    /*sort_rooms();*/
 		fix_stair_rooms();
-		makecorridors();
+		makecorridors(); /*makecorridors(c->src.door);*/
 		return;
 	}
 
@@ -1547,154 +2030,38 @@ boolean prefilled;
 	}
 }
 
-STATIC_OVL void
-free_rooms(ro, n)
-room **ro;
-int n;
-{
-	short j;
-	room *r;
 
-	while(n--) {
-		r = ro[n];
-		Free(r->name);
-		Free(r->parent);
-		if ((j = r->ndoor) != 0) {
-			while(j--)
-			    Free(r->doors[j]);
-			Free(r->doors);
-		}
-		if ((j = r->nstair) != 0) {
-			while(j--)
-			    Free(r->stairs[j]);
-			Free(r->stairs);
-		}
-		if ((j = r->naltar) != 0) {
-			while (j--)
-			    Free(r->altars[j]);
-			Free(r->altars);
-		}
-		if ((j = r->nfountain) != 0) {
-			while(j--)
-			    Free(r->fountains[j]);
-			Free(r->fountains);
-		}
-		if ((j = r->nsink) != 0) {
-			while(j--)
-			    Free(r->sinks[j]);
-			Free(r->sinks);
-		}
-		if ((j = r->npool) != 0) {
-			while(j--)
-			    Free(r->pools[j]);
-			Free(r->pools);
-		}
-		if ((j = r->ntrap) != 0) {
-			while (j--)
-			    Free(r->traps[j]);
-			Free(r->traps);
-		}
-		if ((j = r->nmonster) != 0) {
-			while (j--)
-				Free(r->monsters[j]);
-			Free(r->monsters);
-		}
-		if ((j = r->nobject) != 0) {
-			while (j--)
-				Free(r->objects[j]);
-			Free(r->objects);
-		}
-		if ((j = r->ngold) != 0) {
-			while(j--)
-			    Free(r->golds[j]);
-			Free(r->golds);
-		}
-		if ((j = r->nengraving) != 0) {
-			while (j--)
-				Free(r->engravings[j]);
-			Free(r->engravings);
-		}
-		Free(r);
-	}
-	Free(ro);
-}
-
-STATIC_OVL void
-build_room(r, pr)
-room *r, *pr;
+struct mkroom *
+build_room(r, mkr)
+room *r;
+struct mkroom *mkr;
 {
 	boolean okroom;
 	struct mkroom	*aroom;
 	short i;
 	xchar rtype = (!r->chance || rn2(100) < r->chance) ? r->rtype : OROOM;
 
-	if(pr) {
+	if(mkr) {
 		aroom = &subrooms[nsubroom];
-		okroom = create_subroom(pr->mkr, r->x, r->y, r->w, r->h,
+		okroom = create_subroom(mkr, r->x, r->y, r->w, r->h,
 					rtype, r->rlit);
 	} else {
 		aroom = &rooms[nroom];
 		okroom = create_room(r->x, r->y, r->w, r->h, r->xalign,
 				     r->yalign, rtype, r->rlit);
-		r->mkr = aroom;
 	}
 
 	if (okroom) {
-		/* Create subrooms if necessary... */
-		for(i=0; i < r->nsubroom; i++)
-		    build_room(r->subrooms[i], r);
-		/* And now we can fill the room! */
-
-		/* Priority to the stairs */
-
-		for(i=0; i <r->nstair; i++)
-		    create_stairs(r->stairs[i], aroom);
-
-		/* Then to the various elements (sinks, etc..) */
-		for(i = 0; i<r->nsink; i++)
-		    create_feature(r->sinks[i]->x, r->sinks[i]->y, aroom, SINK);
-		for(i = 0; i<r->npool; i++)
-		    create_feature(r->pools[i]->x, r->pools[i]->y, aroom, POOL);
-		for(i = 0; i<r->nfountain; i++)
-		    create_feature(r->fountains[i]->x, r->fountains[i]->y,
-				   aroom, FOUNTAIN);
-		for(i = 0; i<r->naltar; i++)
-		    create_altar(r->altars[i], aroom);
-		for(i = 0; i<r->ndoor; i++)
-		    create_door(r->doors[i], aroom);
-
-		/* The traps */
-		for(i = 0; i<r->ntrap; i++)
-		    create_trap(r->traps[i], aroom);
-
-		/* The monsters */
-		for(i = 0; i<r->nmonster; i++)
-		    create_monster(r->monsters[i], aroom);
-
-		/* The objects */
-		for(i = 0; i<r->nobject; i++)
-		    create_object(r->objects[i], aroom);
-
-		/* The gold piles */
-		for(i = 0; i<r->ngold; i++)
-		    create_gold(r->golds[i], aroom);
-
-		/* The engravings */
-		for (i = 0; i < r->nengraving; i++)
-		    create_engraving(r->engravings[i], aroom);
-
 #ifdef SPECIALIZATION
 		topologize(aroom,FALSE);		/* set roomno */
 #else
 		topologize(aroom);			/* set roomno */
 #endif
-		/* MRS - 07/04/91 - This is temporary but should result
-		 * in proper filling of shops, etc.
-		 * DLC - this can fail if corridors are added to this room
-		 * at a later point.  Currently no good way to fix this.
-		 */
-		if(aroom->rtype != OROOM && r->filled) fill_room(aroom, FALSE);
+		aroom->needfill = r->filled;
+		aroom->needjoining = r->joined;
+	        return aroom;
 	}
+	return (struct mkroom *)0;
 }
 
 /*
@@ -1728,328 +2095,29 @@ light_region(tmpregion)
     }
 }
 
-/* initialization common to all special levels */
-STATIC_OVL void
-load_common_data(fd, typ)
-dlb *fd;
-int typ;
+void
+wallify_map(x1,y1,x2,y2)
+int x1,y1,x2,y2;
 {
-	uchar	n;
-	long	lev_flags;
-	int	i;
+	int x, y, xx, yy, lo_xx, lo_yy, hi_xx, hi_yy;
 
-      {
-	aligntyp atmp;
-	/* shuffle 3 alignments; can't use sp_lev_shuffle() on aligntyp's */
-	i = rn2(3);   atmp=ralign[2]; ralign[2]=ralign[i]; ralign[i]=atmp;
-	if (rn2(2)) { atmp=ralign[1]; ralign[1]=ralign[0]; ralign[0]=atmp; }
-      }
-
-	level.flags.is_maze_lev = typ == SP_LEV_MAZE;
-
-	/* Read the level initialization data */
-	Fread((genericptr_t) &init_lev, 1, sizeof(lev_init), fd);
-	if(init_lev.init_present) {
-	    if(init_lev.lit < 0)
-		init_lev.lit = rn2(2);
-	    mkmap(&init_lev);
-	}
-
-	/* Read the per level flags */
-	Fread((genericptr_t) &lev_flags, 1, sizeof(lev_flags), fd);
-	if (lev_flags & NOTELEPORT)
-	    level.flags.noteleport = 1;
-	if (lev_flags & HARDFLOOR)
-	    level.flags.hardfloor = 1;
-	if (lev_flags & NOMMAP)
-	    level.flags.nommap = 1;
-	if (lev_flags & SHORTSIGHTED)
-	    level.flags.shortsighted = 1;
-	if (lev_flags & ARBOREAL)
-	    level.flags.arboreal = 1;
-
-	/* Read message */
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-	if (n) {
-	    lev_message = (char *) alloc(n + 1);
-	    Fread((genericptr_t) lev_message, 1, (int) n, fd);
-	    lev_message[n] = 0;
-	}
-}
-
-STATIC_OVL void
-load_one_monster(fd, m)
-dlb *fd;
-monster *m;
-{
-	int size;
-
-	Fread((genericptr_t) m, 1, sizeof *m, fd);
-	if ((size = m->name.len) != 0) {
-	    m->name.str = (char *) alloc((unsigned)size + 1);
-	    Fread((genericptr_t) m->name.str, 1, size, fd);
-	    m->name.str[size] = '\0';
-	} else
-	    m->name.str = (char *) 0;
-	if ((size = m->appear_as.len) != 0) {
-	    m->appear_as.str = (char *) alloc((unsigned)size + 1);
-	    Fread((genericptr_t) m->appear_as.str, 1, size, fd);
-	    m->appear_as.str[size] = '\0';
-	} else
-	    m->appear_as.str = (char *) 0;
-}
-
-STATIC_OVL void
-load_one_object(fd, o)
-dlb *fd;
-object *o;
-{
-	int size;
-
-	Fread((genericptr_t) o, 1, sizeof *o, fd);
-	if ((size = o->name.len) != 0) {
-	    o->name.str = (char *) alloc((unsigned)size + 1);
-	    Fread((genericptr_t) o->name.str, 1, size, fd);
-	    o->name.str[size] = '\0';
-	} else
-	    o->name.str = (char *) 0;
-}
-
-STATIC_OVL void
-load_one_engraving(fd, e)
-dlb *fd;
-engraving *e;
-{
-	int size;
-
-	Fread((genericptr_t) e, 1, sizeof *e, fd);
-	size = e->engr.len;
-	e->engr.str = (char *) alloc((unsigned)size+1);
-	Fread((genericptr_t) e->engr.str, 1, size, fd);
-	e->engr.str[size] = '\0';
-}
-
-STATIC_OVL boolean
-load_rooms(fd)
-dlb *fd;
-{
-	xchar		nrooms, ncorr;
-	char		n;
-	short		size;
-	corridor	tmpcor;
-	room**		tmproom;
-	int		i, j;
-
-	load_common_data(fd, SP_LEV_ROOMS);
-
-	Fread((genericptr_t) &n, 1, sizeof(n), fd); /* nrobjects */
-	if (n) {
-		Fread((genericptr_t)robjects, sizeof(*robjects), n, fd);
-		sp_lev_shuffle(robjects, (char *)0, (int)n);
-	}
-
-	Fread((genericptr_t) &n, 1, sizeof(n), fd); /* nrmonst */
-	if (n) {
-		Fread((genericptr_t)rmonst, sizeof(*rmonst), n, fd);
-		sp_lev_shuffle(rmonst, (char *)0, (int)n);
-	}
-
-	Fread((genericptr_t) &nrooms, 1, sizeof(nrooms), fd);
-						/* Number of rooms to read */
-	tmproom = NewTab(room,nrooms);
-	for (i=0;i<nrooms;i++) {
-		room *r;
-
-		r = tmproom[i] = New(room);
-
-		/* Let's see if this room has a name */
-		Fread((genericptr_t) &size, 1, sizeof(size), fd);
-		if (size > 0) {	/* Yup, it does! */
-			r->name = (char *) alloc((unsigned)size + 1);
-			Fread((genericptr_t) r->name, 1, size, fd);
-			r->name[size] = 0;
-		} else
-		    r->name = (char *) 0;
-
-		/* Let's see if this room has a parent */
-		Fread((genericptr_t) &size, 1, sizeof(size), fd);
-		if (size > 0) {	/* Yup, it does! */
-			r->parent = (char *) alloc((unsigned)size + 1);
-			Fread((genericptr_t) r->parent, 1, size, fd);
-			r->parent[size] = 0;
-		} else
-		    r->parent = (char *) 0;
-
-		Fread((genericptr_t) &r->x, 1, sizeof(r->x), fd);
-					/* x pos on the grid (1-5) */
-		Fread((genericptr_t) &r->y, 1, sizeof(r->y), fd);
-					 /* y pos on the grid (1-5) */
-		Fread((genericptr_t) &r->w, 1, sizeof(r->w), fd);
-					 /* width of the room */
-		Fread((genericptr_t) &r->h, 1, sizeof(r->h), fd);
-					 /* height of the room */
-		Fread((genericptr_t) &r->xalign, 1, sizeof(r->xalign), fd);
-					 /* horizontal alignment */
-		Fread((genericptr_t) &r->yalign, 1, sizeof(r->yalign), fd);
-					 /* vertical alignment */
-		Fread((genericptr_t) &r->rtype, 1, sizeof(r->rtype), fd);
-					 /* type of room (zoo, shop, etc.) */
-		Fread((genericptr_t) &r->chance, 1, sizeof(r->chance), fd);
-					 /* chance of room being special. */
-		Fread((genericptr_t) &r->rlit, 1, sizeof(r->rlit), fd);
-					 /* lit or not ? */
-		Fread((genericptr_t) &r->filled, 1, sizeof(r->filled), fd);
-					 /* to be filled? */
-		r->nsubroom= 0;
-
-		/* read the doors */
-		Fread((genericptr_t) &r->ndoor, 1, sizeof(r->ndoor), fd);
-		if ((n = r->ndoor) != 0)
-		    r->doors = NewTab(room_door, n);
-		while(n--) {
-			r->doors[(int)n] = New(room_door);
-			Fread((genericptr_t) r->doors[(int)n], 1,
-				sizeof(room_door), fd);
-		}
-
-		/* read the stairs */
-		Fread((genericptr_t) &r->nstair, 1, sizeof(r->nstair), fd);
-		if ((n = r->nstair) != 0)
-		    r->stairs = NewTab(stair, n);
-		while (n--) {
-			r->stairs[(int)n] = New(stair);
-			Fread((genericptr_t) r->stairs[(int)n], 1,
-				sizeof(stair), fd);
-		}
-
-		/* read the altars */
-		Fread((genericptr_t) &r->naltar, 1, sizeof(r->naltar), fd);
-		if ((n = r->naltar) != 0)
-		    r->altars = NewTab(altar, n);
-		while (n--) {
-			r->altars[(int)n] = New(altar);
-			Fread((genericptr_t) r->altars[(int)n], 1,
-				sizeof(altar), fd);
-		}
-
-		/* read the fountains */
-		Fread((genericptr_t) &r->nfountain, 1,
-			sizeof(r->nfountain), fd);
-		if ((n = r->nfountain) != 0)
-		    r->fountains = NewTab(fountain, n);
-		while (n--) {
-			r->fountains[(int)n] = New(fountain);
-			Fread((genericptr_t) r->fountains[(int)n], 1,
-				sizeof(fountain), fd);
-		}
-
-		/* read the sinks */
-		Fread((genericptr_t) &r->nsink, 1, sizeof(r->nsink), fd);
-		if ((n = r->nsink) != 0)
-		    r->sinks = NewTab(sink, n);
-		while (n--) {
-			r->sinks[(int)n] = New(sink);
-			Fread((genericptr_t) r->sinks[(int)n], 1, sizeof(sink), fd);
-		}
-
-		/* read the pools */
-		Fread((genericptr_t) &r->npool, 1, sizeof(r->npool), fd);
-		if ((n = r->npool) != 0)
-		    r->pools = NewTab(pool,n);
-		while (n--) {
-			r->pools[(int)n] = New(pool);
-			Fread((genericptr_t) r->pools[(int)n], 1, sizeof(pool), fd);
-		}
-
-		/* read the traps */
-		Fread((genericptr_t) &r->ntrap, 1, sizeof(r->ntrap), fd);
-		if ((n = r->ntrap) != 0)
-		    r->traps = NewTab(trap, n);
-		while(n--) {
-			r->traps[(int)n] = New(trap);
-			Fread((genericptr_t) r->traps[(int)n], 1, sizeof(trap), fd);
-		}
-
-		/* read the monsters */
-		Fread((genericptr_t) &r->nmonster, 1, sizeof(r->nmonster), fd);
-		if ((n = r->nmonster) != 0) {
-		    r->monsters = NewTab(monster, n);
-		    while(n--) {
-			r->monsters[(int)n] = New(monster);
-			load_one_monster(fd, r->monsters[(int)n]);
-		    }
-		} else
-		    r->monsters = 0;
-
-		/* read the objects, in same order as mazes */
-		Fread((genericptr_t) &r->nobject, 1, sizeof(r->nobject), fd);
-		if ((n = r->nobject) != 0) {
-		    r->objects = NewTab(object, n);
-		    for (j = 0; j < n; ++j) {
-			r->objects[j] = New(object);
-			load_one_object(fd, r->objects[j]);
-		    }
-		} else
-		    r->objects = 0;
-
-		/* read the gold piles */
-		Fread((genericptr_t) &r->ngold, 1, sizeof(r->ngold), fd);
-		if ((n = r->ngold) != 0)
-		    r->golds = NewTab(gold, n);
-		while (n--) {
-			r->golds[(int)n] = New(gold);
-			Fread((genericptr_t) r->golds[(int)n], 1, sizeof(gold), fd);
-		}
-
-		/* read the engravings */
-		Fread((genericptr_t) &r->nengraving, 1,
-			sizeof(r->nengraving), fd);
-		if ((n = r->nengraving) != 0) {
-		    r->engravings = NewTab(engraving,n);
-		    while (n--) {
-			r->engravings[(int)n] = New(engraving);
-			load_one_engraving(fd, r->engravings[(int)n]);
-		    }
-		} else
-		    r->engravings = 0;
-
-	}
-
-	/* Now that we have loaded all the rooms, search the
-	 * subrooms and create the links.
-	 */
-
-	for (i = 0; i<nrooms; i++)
-	    if (tmproom[i]->parent) {
-		    /* Search the parent room */
-		    for(j=0; j<nrooms; j++)
-			if (tmproom[j]->name && !strcmp(tmproom[j]->name,
-						       tmproom[i]->parent)) {
-				n = tmproom[j]->nsubroom++;
-				tmproom[j]->subrooms[(int)n] = tmproom[i];
-				break;
+	for (y = y1; y <= y2; y++) {
+	    lo_yy = (y > 0) ? y - 1 : 0;
+	    hi_yy = (y < y2) ? y + 1 : y2;
+	    for (x = x1; x <= x2; x++) {
+		if (levl[x][y].typ != STONE) continue;
+		lo_xx = (x > 0) ? x - 1 : 0;
+		hi_xx = (x < x2) ? x + 1 : x2;
+		for (yy = lo_yy; yy <= hi_yy; yy++)
+		    for (xx = lo_xx; xx <= hi_xx; xx++)
+			if (IS_ROOM(levl[xx][yy].typ) ||
+				levl[xx][yy].typ == CROSSWALL) {
+			    levl[x][y].typ = (yy != y) ? HWALL : VWALL;
+			    yy = hi_yy;		/* end `yy' loop */
+			    break;		/* end `xx' loop */
 			}
 	    }
-
-	/*
-	 * Create the rooms now...
-	 */
-
-	for (i=0; i < nrooms; i++)
-	    if(!tmproom[i]->parent)
-		build_room(tmproom[i], (room *) 0);
-
-	free_rooms(tmproom, nrooms);
-
-	/* read the corridors */
-
-	Fread((genericptr_t) &ncorr, sizeof(ncorr), 1, fd);
-	for (i=0; i<ncorr; i++) {
-		Fread((genericptr_t) &tmpcor, 1, sizeof(tmpcor), fd);
-		create_corridor(&tmpcor);
 	}
-
-	return TRUE;
 }
 
 /*
@@ -2073,590 +2141,34 @@ int humidity;
 	    x = rn1(x_maze_max - 3, 3);
 	    y = rn1(y_maze_max - 3, 3);
 	    if (--tryct < 0) break;	/* give up */
-	} while (!(x % 2) || !(y % 2) || Map[x][y] ||
+	} while (!(x % 2) || !(y % 2) || !SpLev_Map[x][y] ||
 		 !is_ok_location((schar)x, (schar)y, humidity));
 
 	m->x = (xchar)x,  m->y = (xchar)y;
 }
 
 /*
- * The Big Thing: special maze loader
+ * If there's a significant portion of maze unused by the special level,
+ * we don't want it empty.
  *
- * Could be cleaner, but it works.
+ * Makes the number of traps, monsters, etc. proportional
+ * to the size of the maze.
  */
-
-STATIC_OVL boolean
-load_maze(fd)
-dlb *fd;
+STATIC_OVL void
+fill_empty_maze()
 {
-    xchar   x, y, typ;
-    boolean prefilled, room_not_needed;
+    int mapcountmax, mapcount, mapfact;
+    xchar x,y;
+    coord mm;
 
-    char    n, numpart = 0;
-    xchar   nwalk = 0, nwalk_sav;
-    schar   filling;
-    char    halign, valign;
-
-    int     xi, dir, size;
-    coord   mm;
-    int     mapcount, mapcountmax, mapfact;
-
-    lev_region  tmplregion;
-    region  tmpregion;
-    door    tmpdoor;
-    trap    tmptrap;
-    monster tmpmons;
-    object  tmpobj;
-    drawbridge tmpdb;
-    walk    tmpwalk;
-    digpos  tmpdig;
-    lad     tmplad;
-    stair   tmpstair, prevstair;
-    altar   tmpaltar;
-    gold    tmpgold;
-    fountain tmpfountain;
-    engraving tmpengraving;
-    xchar   mustfill[(MAXNROFROOMS+1)*2];
-    struct trap *badtrap;
-    boolean has_bounds;
-    boolean bounds_nodigpass;
-
-    (void) memset((genericptr_t)&Map[0][0], 0, sizeof Map);
-    load_common_data(fd, SP_LEV_MAZE);
-
-    /* Initialize map */
-    Fread((genericptr_t) &filling, 1, sizeof(filling), fd);
-    if (!init_lev.init_present) { /* don't init if mkmap() has been called */
-      for(x = 2; x <= x_maze_max; x++)
-	for(y = 0; y <= y_maze_max; y++)
-	    if (filling == -1) {
-#ifndef WALLIFIED_MAZE
-		    levl[x][y].typ = STONE;
-#else
-		    levl[x][y].typ =
-			(y < 2 || ((x % 2) && (y % 2))) ? STONE : HWALL;
-#endif
-	    } else {
-		    levl[x][y].typ = filling;
-	    }
-    }
-
-    /* if filling with stone, surrounding stone may all be nondig, nonpass */
-    bounds_nodigpass = (filling == STONE);
-
-    /* Start reading the file */
-    Fread((genericptr_t) &numpart, 1, sizeof(numpart), fd);
-						/* Number of parts */
-    if (!numpart || numpart > 9)
-	panic("load_maze error: numpart = %d", (int) numpart);
-
-    while (numpart--) {
-	Fread((genericptr_t) &halign, 1, sizeof(halign), fd);
-					/* Horizontal alignment */
-	Fread((genericptr_t) &valign, 1, sizeof(valign), fd);
-					/* Vertical alignment */
-	Fread((genericptr_t) &xsize, 1, sizeof(xsize), fd);
-					/* size in X */
-	Fread((genericptr_t) &ysize, 1, sizeof(ysize), fd);
-					/* size in Y */
-	switch((int) halign) {
-	    /* mkmap always creates levels starting at x==1 */
-	    case LEFT:	    xstart = init_lev.init_present ? 1 : 3;	break;
-	    case H_LEFT:    xstart = 2+((x_maze_max-2-xsize)/4);	break;
-	    case CENTER:    xstart = 2+((x_maze_max-2-xsize)/2);	break;
-	    case H_RIGHT:   xstart = 2+((x_maze_max-2-xsize)*3/4);	break;
-	    case RIGHT:     xstart = x_maze_max-xsize-1;		break;
-	}
-	switch((int) valign) {
-	    case TOP:	    ystart = 3;					break;
-	    case CENTER:    ystart = 2+((y_maze_max-2-ysize)/2);	break;
-	    case BOTTOM:    ystart = y_maze_max-ysize-1;		break;
-	}
-	if (!(xstart % 2)) xstart++;
-	if (!(ystart % 2)) ystart++;
-	if ((ystart < 0) || (ystart + ysize > ROWNO)) {
-	    /* try to move the start a bit */
-	    ystart += (ystart > 0) ? -2 : 2;
-	    if(ysize == ROWNO) ystart = 0;
-	    if(ystart < 0 || ystart + ysize > ROWNO)
-		panic("reading special level with ysize too large");
-	}
-
-	/*
-	 * If any CROSSWALLs are found, must change to ROOM after REGION's
-	 * are laid out.  CROSSWALLS are used to specify "invisible"
-	 * boundaries where DOOR syms look bad or aren't desirable.
-	 */
-	has_bounds = FALSE;
-
-	if(init_lev.init_present && xsize <= 1 && ysize <= 1) {
-	    xstart = 1;
-	    ystart = 0;
-	    xsize = COLNO-1;
-	    ysize = ROWNO;
-	    bounds_nodigpass = FALSE;
-	} else {
-	    /* Load the map */
-	    for(y = ystart; y < ystart+ysize; y++)
-		for(x = xstart; x < xstart+xsize; x++) {
-		    levl[x][y].typ = Fgetc(fd);
-		    levl[x][y].lit = FALSE;
-		    /* clear out levl: load_common_data may set them */
-		    levl[x][y].flags = 0;
-		    levl[x][y].horizontal = 0;
-		    levl[x][y].roomno = 0;
-		    levl[x][y].edge = 0;
-		    /*
-		     * Note: Even though levl[x][y].typ is type schar,
-		     *	 lev_comp.y saves it as type char. Since schar != char
-		     *	 all the time we must make this exception or hack
-		     *	 through lev_comp.y to fix.
-		     */
-
-		    /*
-		     *  Set secret doors to closed (why not trapped too?).  Set
-		     *  the horizontal bit.
-		     */
-		    if (levl[x][y].typ == SDOOR || IS_DOOR(levl[x][y].typ)) {
-			if(levl[x][y].typ == SDOOR)
-			    levl[x][y].doormask = D_CLOSED;
-			/*
-			 *  If there is a wall to the left that connects to a
-			 *  (secret) door, then it is horizontal.  This does
-			 *  not allow (secret) doors to be corners of rooms.
-			 */
-			if (x != xstart && (IS_WALL(levl[x-1][y].typ) ||
-					    levl[x-1][y].horizontal))
-			    levl[x][y].horizontal = 1;
-		    } else if(levl[x][y].typ == HWALL ||
-				levl[x][y].typ == IRONBARS)
-			levl[x][y].horizontal = 1;
-		    else if(levl[x][y].typ == LAVAPOOL)
-			levl[x][y].lit = 1;
-		    else if (init_lev.init_present && levl[x][y].typ == ICE)
-			levl[x][y].icedpool = init_lev.icedpools ? ICED_POOL :
-								   ICED_MOAT;
-		    else if(levl[x][y].typ == CROSSWALL)
-			has_bounds = TRUE;
-		    Map[x][y] = 1;
-		}
-	    if (init_lev.init_present && init_lev.joined)
-		remove_rooms(xstart, ystart, xstart+xsize, ystart+ysize);
-	}
-
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-						/* Number of level regions */
-	if(n) {
-	    if(num_lregions) {
-		/* realloc the lregion space to add the new ones */
-		/* don't really free it up until the whole level is done */
-		lev_region *newl = (lev_region *) alloc(sizeof(lev_region) *
-						(unsigned)(n+num_lregions));
-		(void) memcpy((genericptr_t)(newl+n), (genericptr_t)lregions,
-					sizeof(lev_region) * num_lregions);
-		Free(lregions);
-		num_lregions += n;
-		lregions = newl;
-	    } else {
-		num_lregions = n;
-		lregions = (lev_region *)
-				alloc(sizeof(lev_region) * (unsigned)n);
-	    }
-	}
-
-	while(n--) {
-	    Fread((genericptr_t) &tmplregion, sizeof(tmplregion), 1, fd);
-	    if ((size = tmplregion.rname.len) != 0) {
-		tmplregion.rname.str = (char *) alloc((unsigned)size + 1);
-		Fread((genericptr_t) tmplregion.rname.str, size, 1, fd);
-		tmplregion.rname.str[size] = '\0';
-	    } else
-		tmplregion.rname.str = (char *) 0;
-	    if(!tmplregion.in_islev) {
-		get_location(&tmplregion.inarea.x1, &tmplregion.inarea.y1,
-								DRY|WET);
-		get_location(&tmplregion.inarea.x2, &tmplregion.inarea.y2,
-								DRY|WET);
-	    }
-	    if(!tmplregion.del_islev) {
-		get_location(&tmplregion.delarea.x1, &tmplregion.delarea.y1,
-								DRY|WET);
-		get_location(&tmplregion.delarea.x2, &tmplregion.delarea.y2,
-								DRY|WET);
-	    }
-	    lregions[(int)n] = tmplregion;
-	}
-
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-						/* Random objects */
-	if(n) {
-		Fread((genericptr_t)robjects, sizeof(*robjects), (int) n, fd);
-		sp_lev_shuffle(robjects, (char *)0, (int)n);
-	}
-
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-						/* Random locations */
-	if(n) {
-		Fread((genericptr_t)rloc_x, sizeof(*rloc_x), (int) n, fd);
-		Fread((genericptr_t)rloc_y, sizeof(*rloc_y), (int) n, fd);
-		sp_lev_shuffle(rloc_x, rloc_y, (int)n);
-	}
-
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-						/* Random monsters */
-	if(n) {
-		Fread((genericptr_t)rmonst, sizeof(*rmonst), (int) n, fd);
-		sp_lev_shuffle(rmonst, (char *)0, (int)n);
-	}
-
-	(void) memset((genericptr_t)mustfill, 0, sizeof(mustfill));
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-						/* Number of subrooms */
-	while(n--) {
-		register struct mkroom *troom;
-
-		Fread((genericptr_t)&tmpregion, 1, sizeof(tmpregion), fd);
-
-		if(tmpregion.rtype > MAXRTYPE) {
-		    tmpregion.rtype -= MAXRTYPE+1;
-		    prefilled = TRUE;
-		} else
-		    prefilled = FALSE;
-
-		if(tmpregion.rlit < 0)
-		    tmpregion.rlit = (rnd(1+abs(depth(&u.uz))) < 11 && rn2(77))
-			? TRUE : FALSE;
-
-		get_location(&tmpregion.x1, &tmpregion.y1, DRY|WET);
-		get_location(&tmpregion.x2, &tmpregion.y2, DRY|WET);
-
-		/* for an ordinary room, `prefilled' is a flag to force
-		   an actual room to be created (such rooms are used to
-		   control placement of migrating monster arrivals) */
-		room_not_needed = (tmpregion.rtype == OROOM &&
-				   !tmpregion.rirreg && !prefilled);
-		if (room_not_needed || nroom >= MAXNROFROOMS) {
-		    if (!room_not_needed)
-			impossible("Too many rooms on new level!");
-		    light_region(&tmpregion);
-		    continue;
-		}
-
-		troom = &rooms[nroom];
-
-		/* mark rooms that must be filled, but do it later */
-		if (tmpregion.rtype != OROOM)
-		    mustfill[nroom] = (prefilled ? 2 : 1);
-
-		if(tmpregion.rirreg) {
-		    min_rx = max_rx = tmpregion.x1;
-		    min_ry = max_ry = tmpregion.y1;
-		    flood_fill_rm(tmpregion.x1, tmpregion.y1,
-				  nroom+ROOMOFFSET, tmpregion.rlit, TRUE);
-		    add_room(min_rx, min_ry, max_rx, max_ry,
-			     FALSE, tmpregion.rtype, TRUE);
-		    troom->rlit = tmpregion.rlit;
-		    troom->irregular = TRUE;
-		} else {
-		    add_room(tmpregion.x1, tmpregion.y1,
-			     tmpregion.x2, tmpregion.y2,
-			     tmpregion.rlit, tmpregion.rtype, TRUE);
-#ifdef SPECIALIZATION
-		    topologize(troom,FALSE);		/* set roomno */
-#else
-		    topologize(troom);			/* set roomno */
-#endif
-		}
-	}
-
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-						/* Number of doors */
-	while(n--) {
-		struct mkroom *croom = &rooms[0];
-
-		Fread((genericptr_t)&tmpdoor, 1, sizeof(tmpdoor), fd);
-
-		x = tmpdoor.x;	y = tmpdoor.y;
-		typ = tmpdoor.mask == -1 ? rnddoor() : tmpdoor.mask;
-
-		get_location(&x, &y, DRY);
-		if(levl[x][y].typ != SDOOR)
-			levl[x][y].typ = DOOR;
-		else {
-			if(typ < D_CLOSED)
-			    typ = D_CLOSED; /* force it to be closed */
-		}
-		levl[x][y].doormask = typ;
-
-		/* Now the complicated part, list it with each subroom */
-		/* The dog move and mail daemon routines use this */
-		while(croom->hx >= 0 && doorindex < DOORMAX) {
-		    if(croom->hx >= x-1 && croom->lx <= x+1 &&
-		       croom->hy >= y-1 && croom->ly <= y+1) {
-			/* Found it */
-			add_door(x, y, croom);
-		    }
-		    croom++;
-		}
-	}
-
-	/* now that we have rooms _and_ associated doors, fill the rooms */
-	for(n = 0; n < SIZE(mustfill); n++)
-	    if(mustfill[(int)n])
-		fill_room(&rooms[(int)n], (mustfill[(int)n] == 2));
-
-	/* if special boundary syms (CROSSWALL) in map, remove them now */
-	if(has_bounds) {
-	    for(x = xstart; x < xstart+xsize; x++)
-		for(y = ystart; y < ystart+ysize; y++)
-		    if(levl[x][y].typ == CROSSWALL)
-			levl[x][y].typ = ROOM;
-	}
-
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-						/* Number of drawbridges */
-	while(n--) {
-		Fread((genericptr_t)&tmpdb, 1, sizeof(tmpdb), fd);
-
-		x = tmpdb.x;  y = tmpdb.y;
-		get_location(&x, &y, DRY|WET);
-
-		typ = tmpdb.db_open;
-		if (typ == 127) typ = rn2(2);	/* 0 => closed, 1 => open */
-		if (!create_drawbridge(x, y, tmpdb.dir, typ))
-		    impossible("Cannot create drawbridge.");
-	}
-
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-						/* Number of mazewalks */
-	while(n--) {
-		Fread((genericptr_t)&tmpwalk, 1, sizeof(tmpwalk), fd);
-
-		get_location(&tmpwalk.x, &tmpwalk.y, DRY|WET);
-
-		walklist[nwalk++] = tmpwalk;
-	}
-
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-						/* Number of non_diggables */
-	while(n--) {
-		Fread((genericptr_t)&tmpdig, 1, sizeof(tmpdig), fd);
-
-		get_location(&tmpdig.x1, &tmpdig.y1, DRY|WET);
-		get_location(&tmpdig.x2, &tmpdig.y2, DRY|WET);
-
-		set_wall_property(tmpdig.x1, tmpdig.y1,
-				  tmpdig.x2, tmpdig.y2, W_NONDIGGABLE);
-	}
-
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-						/* Number of non_passables */
-	while(n--) {
-		Fread((genericptr_t)&tmpdig, 1, sizeof(tmpdig), fd);
-
-		get_location(&tmpdig.x1, &tmpdig.y1, DRY|WET);
-		get_location(&tmpdig.x2, &tmpdig.y2, DRY|WET);
-
-		set_wall_property(tmpdig.x1, tmpdig.y1,
-				  tmpdig.x2, tmpdig.y2, W_NONPASSWALL);
-	}
-
-	/* walk bounds, reset bounds_nodigpass diggable or passable */
-	if (bounds_nodigpass) {
-	    for (x = xstart; x < xstart+xsize; x++) {
-		if (!IS_STWALL(levl[x][ystart].typ) ||
-		    (levl[x][ystart].wall_info &
-		     (W_NONDIGGABLE|W_NONPASSWALL)) !=
-		    (W_NONDIGGABLE|W_NONPASSWALL) ||
-		    !IS_STWALL(levl[x][ystart+ysize-1].typ) ||
-		    (levl[x][ystart+ysize-1].wall_info &
-		     (W_NONDIGGABLE|W_NONPASSWALL)) !=
-		    (W_NONDIGGABLE|W_NONPASSWALL)) {
-		    bounds_nodigpass = FALSE;
-		    break;
-		}
-	    }
-	}
-	if (bounds_nodigpass) {
-	    for(y = ystart; y < ystart+ysize; y++) {
-		if (!IS_STWALL(levl[xstart][y].typ) ||
-		    (levl[xstart][y].wall_info &
-		     (W_NONDIGGABLE|W_NONPASSWALL)) !=
-		    (W_NONDIGGABLE|W_NONPASSWALL) ||
-		    !IS_STWALL(levl[xstart+xsize-1][y].typ) ||
-		    (levl[xstart+xsize-1][y].wall_info &
-		     (W_NONDIGGABLE|W_NONPASSWALL)) !=
-		    (W_NONDIGGABLE|W_NONPASSWALL)) {
-		    bounds_nodigpass = FALSE;
-		    break;
-		}
-	    }
-	}
-
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-						/* Number of ladders */
-	while(n--) {
-		Fread((genericptr_t)&tmplad, 1, sizeof(tmplad), fd);
-
-		x = tmplad.x;  y = tmplad.y;
-		get_location(&x, &y, DRY);
-
-		levl[x][y].typ = LADDER;
-		if (tmplad.up == 1) {
-			xupladder = x;	yupladder = y;
-			levl[x][y].ladder = LA_UP;
-		} else {
-			xdnladder = x;	ydnladder = y;
-			levl[x][y].ladder = LA_DOWN;
-		}
-	}
-
-	prevstair.x = prevstair.y = 0;
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-						/* Number of stairs */
-	while(n--) {
-		Fread((genericptr_t)&tmpstair, 1, sizeof(tmpstair), fd);
-
-		xi = 0;
-		do {
-		    x = tmpstair.x;  y = tmpstair.y;
-		    get_location(&x, &y, DRY);
-		} while(prevstair.x && xi++ < 100 &&
-			distmin(x,y,prevstair.x,prevstair.y) <= 8);
-		if ((badtrap = t_at(x,y)) != 0) deltrap(badtrap);
-		mkstairs(x, y, (char)tmpstair.up, (struct mkroom *)0);
-		prevstair.x = x;
-		prevstair.y = y;
-	}
-
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-						/* Number of altars */
-	while(n--) {
-		Fread((genericptr_t)&tmpaltar, 1, sizeof(tmpaltar), fd);
-
-		create_altar(&tmpaltar, (struct mkroom *)0);
-	}
-
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-						/* Number of fountains */
-	while (n--) {
-		Fread((genericptr_t)&tmpfountain, 1, sizeof(tmpfountain), fd);
-
-		create_feature(tmpfountain.x, tmpfountain.y,
-			       (struct mkroom *)0, FOUNTAIN);
-	}
-
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-						/* Number of traps */
-	while(n--) {
-		Fread((genericptr_t)&tmptrap, 1, sizeof(tmptrap), fd);
-
-		create_trap(&tmptrap, (struct mkroom *)0);
-	}
-
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-						/* Number of monsters */
-	while(n--) {
-		load_one_monster(fd, &tmpmons);
-
-		create_monster(&tmpmons, (struct mkroom *)0);
-	}
-
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-						/* Number of objects */
-	while(n--) {
-		load_one_object(fd, &tmpobj);
-
-		create_object(&tmpobj, (struct mkroom *)0);
-	}
-
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-						/* Number of gold piles */
-	while (n--) {
-		Fread((genericptr_t)&tmpgold, 1, sizeof(tmpgold), fd);
-
-		create_gold(&tmpgold, (struct mkroom *)0);
-	}
-
-	Fread((genericptr_t) &n, 1, sizeof(n), fd);
-						/* Number of engravings */
-	while(n--) {
-		load_one_engraving(fd, &tmpengraving);
-
-		create_engraving(&tmpengraving, (struct mkroom *)0);
-	}
-
-    }		/* numpart loop */
-
-    nwalk_sav = nwalk;
-    while(nwalk--) {
-	    x = (xchar) walklist[nwalk].x;
-	    y = (xchar) walklist[nwalk].y;
-	    dir = walklist[nwalk].dir;
-
-	    /* don't use move() - it doesn't use W_NORTH, etc. */
-	    switch (dir) {
-		case W_NORTH: --y; break;
-		case W_SOUTH: y++; break;
-		case W_EAST:  x++; break;
-		case W_WEST:  --x; break;
-		default: panic("load_maze: bad MAZEWALK direction");
-	    }
-
-	    if(!IS_DOOR(levl[x][y].typ)) {
-#ifndef WALLIFIED_MAZE
-		levl[x][y].typ = CORR;
-#else
-		levl[x][y].typ = ROOM;
-#endif
-		levl[x][y].flags = 0;
-	    }
-
-	    /*
-	     * We must be sure that the parity of the coordinates for
-	     * walkfrom() is odd.  But we must also take into account
-	     * what direction was chosen.
-	     */
-	    if(!(x % 2)) {
-		if (dir == W_EAST)
-		    x++;
-		else
-		    x--;
-
-		/* no need for IS_DOOR check; out of map bounds */
-#ifndef WALLIFIED_MAZE
-		levl[x][y].typ = CORR;
-#else
-		levl[x][y].typ = ROOM;
-#endif
-		levl[x][y].flags = 0;
-	    }
-
-	    if (!(y % 2)) {
-		if (dir == W_SOUTH)
-		    y++;
-		else
-		    y--;
-	    }
-
-	    walkfrom(x, y);
-    }
-    wallification(1, 0, COLNO-1, ROWNO-1);
-
-    /*
-     * If there's a significant portion of maze unused by the special level,
-     * we don't want it empty.
-     *
-     * Makes the number of traps, monsters, etc. proportional
-     * to the size of the maze.
-     */
     mapcountmax = mapcount = (x_maze_max - 2) * (y_maze_max - 2);
+    mapcountmax = mapcountmax / 2;
 
     for(x = 2; x < x_maze_max; x++)
 	for(y = 0; y < y_maze_max; y++)
-	    if(Map[x][y]) mapcount--;
+	    if(!SpLev_Map[x][y]) mapcount--;
 
-    if (nwalk_sav && (mapcount > (int) (mapcountmax / 10))) {
+    if ((mapcount > (int) (mapcountmax / 10))) {
 	    mapfact = (int) ((mapcount * 100L) / mapcountmax);
 	    for(x = rnd((int) (20 * mapfact) / 100); x; x--) {
 		    maze1xy(&mm, DRY);
@@ -2672,7 +2184,7 @@ dlb *fd;
 		(void) makemon(&mons[PM_MINOTAUR], mm.x, mm.y, NO_MM_FLAGS);
 	    }
 	    for(x = rnd((int) (12 * mapfact) / 100); x; x--) {
-		    maze1xy(&mm, WET|DRY);
+		    maze1xy(&mm, DRY);
 		    (void) makemon((struct permonst *) 0, mm.x, mm.y, NO_MM_FLAGS);
 	    }
 	    for(x = rn2((int) (15 * mapfact) / 100); x; x--) {
@@ -2691,17 +2203,2864 @@ dlb *fd;
 		    (void) maketrap(mm.x, mm.y, trytrap);
 	    }
     }
+}
+
+/*
+ * special level loader
+ */
+STATIC_OVL boolean
+sp_level_loader(fd, lvl)
+dlb *fd;
+sp_lev *lvl;
+{
+    long n_opcode = 0;
+    struct opvar *opdat;
+    int opcode;
+
+    Fread((genericptr_t)&(lvl->n_opcodes), 1, sizeof(lvl->n_opcodes), fd);
+
+    lvl->opcodes = (_opcode *)alloc(sizeof(_opcode) * (lvl->n_opcodes));
+    if (!lvl->opcodes) panic("sp lvl load opcodes alloc");
+    while (n_opcode < lvl->n_opcodes) {
+
+	Fread((genericptr_t) &lvl->opcodes[n_opcode].opcode, 1,
+	      sizeof(lvl->opcodes[n_opcode].opcode), fd);
+	opcode = lvl->opcodes[n_opcode].opcode;
+
+	opdat = NULL;
+
+	if (opcode < SPO_NULL || opcode >= MAX_SP_OPCODES)
+	    panic("sp_level_loader: impossible opcode %i.", opcode);
+
+	if (opcode == SPO_PUSH) {
+	    struct opvar *ov = (opdat = (struct opvar *)alloc(sizeof(struct opvar)));
+	    int nsize;
+
+	    if (!ov) panic("push ov alloc");
+	    ov->spovartyp = SPO_NULL;
+	    ov->vardata.l = 0;
+	    Fread((genericptr_t)&(ov->spovartyp), 1, sizeof(ov->spovartyp), fd);
+
+	    switch (ov->spovartyp) {
+	    case SPOVAR_NULL: break;
+	    case SPOVAR_COORD:
+	    case SPOVAR_REGION:
+	    case SPOVAR_MAPCHAR:
+	    case SPOVAR_MONST:
+	    case SPOVAR_OBJ:
+	    case SPOVAR_INT:
+		Fread((genericptr_t)&(ov->vardata.l), 1, sizeof(ov->vardata.l), fd);
+		break;
+	    case SPOVAR_VARIABLE:
+	    case SPOVAR_STRING:
+	    case SPOVAR_SEL:
+		{
+		    char *opd;
+		    Fread((genericptr_t) &nsize, 1, sizeof(nsize), fd);
+		    opd = (char *)alloc(nsize + 1);
+		    if (!opd) panic("sp lvl load opd alloc");
+		    if (nsize) Fread(opd, 1, nsize, fd);
+		    opd[nsize] = 0;
+		    ov->vardata.str = opd;
+		}
+		break;
+	    default:
+		panic("sp_level_loader: unknown opvar type %i", ov->spovartyp);
+	    }
+	}
+
+	lvl->opcodes[n_opcode].opdat = opdat;
+	n_opcode++;
+    } /*while*/
+
+    return TRUE;
+}
+
+
+/* Frees the memory allocated for special level creation structs */
+STATIC_OVL boolean
+sp_level_free(lvl)
+sp_lev *lvl;
+{
+    long n_opcode = 0;
+
+    while (n_opcode < lvl->n_opcodes) {
+	int opcode = lvl->opcodes[n_opcode].opcode;
+	struct opvar *opdat = lvl->opcodes[n_opcode].opdat;
+
+	if (opcode < SPO_NULL || opcode >= MAX_SP_OPCODES)
+	    panic("sp_level_free: unknown opcode %i", opcode);
+
+	if (opdat) opvar_free(opdat);
+	n_opcode++;
+    }
+    Free(lvl->opcodes);
+    lvl->opcodes = NULL;
+    return TRUE;
+}
+
+void
+splev_initlev(linit)
+lev_init *linit;
+{
+    switch (linit->init_style) {
+    default: impossible("Unrecognized level init style."); break;
+    case LVLINIT_NONE: break;
+    case LVLINIT_SOLIDFILL:
+	if (linit->lit == -1) linit->lit = rn2(2);
+	lvlfill_solid(linit->filling, linit->lit);
+	break;
+    case LVLINIT_MAZEGRID:
+	lvlfill_maze_grid(2,0, x_maze_max,y_maze_max, linit->filling);
+	break;
+#ifdef REINCARNATION
+    case LVLINIT_ROGUE:
+	makeroguerooms();
+	break;
+#endif
+    case LVLINIT_MINES:
+	if (linit->lit == -1) linit->lit = rn2(2);
+	if (linit->filling > -1) lvlfill_solid(linit->filling, 0);
+	mkmap(linit);
+	break;
+    }
+}
+
+struct sp_frame *
+frame_new(execptr)
+     long execptr;
+{
+    struct sp_frame *frame = (struct sp_frame *)alloc(sizeof(struct sp_frame));
+    if (!frame) panic("could not create execution frame.");
+    frame->next = NULL;
+    frame->variables = NULL;
+    frame->n_opcode = execptr;
+    frame->stack = (struct splevstack *)alloc(sizeof(struct splevstack));
+    if (!frame->stack) panic("could not create execution frame stack.");
+    splev_stack_init(frame->stack);
+    return frame;
+}
+
+void
+frame_del(frame)
+     struct sp_frame *frame;
+{
+    if (!frame) return;
+    if (frame->stack) {
+	splev_stack_done(frame->stack);
+	frame->stack = NULL;
+    }
+    if (frame->variables) {
+	variable_list_del(frame->variables);
+	frame->variables = NULL;
+    }
+    Free(frame);
+}
+
+void
+spo_frame_push(coder)
+     struct sp_coder *coder;
+{
+    struct sp_frame *tmpframe = frame_new(coder->frame->n_opcode);
+    tmpframe->next = coder->frame;
+    coder->frame = tmpframe;
+}
+
+void
+spo_frame_pop(coder)
+     struct sp_coder *coder;
+{
+    if (coder->frame && coder->frame->next) {
+	struct sp_frame *tmpframe = coder->frame->next;
+	frame_del(coder->frame);
+	coder->frame = tmpframe;
+	coder->stack = coder->frame->stack;
+    }
+}
+
+long
+sp_code_jmpaddr(curpos, jmpaddr)
+     long curpos, jmpaddr;
+{
+    return (curpos + jmpaddr);
+}
+
+void
+spo_call(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *addr;
+    struct opvar *params;
+    struct sp_frame *tmpframe;
+
+    if (!OV_pop_i(addr) || !OV_pop_i(params)) return;
+    if (OV_i(params) < 0) return;
+
+    tmpframe = frame_new(sp_code_jmpaddr(coder->frame->n_opcode, OV_i(addr)-1));
+
+    while (OV_i(params)-- > 0) {
+	splev_stack_push(tmpframe->stack, splev_stack_getdat_any(coder));
+    }
+    splev_stack_reverse(tmpframe->stack);
+
+    /* push a frame */
+    tmpframe->next = coder->frame;
+    coder->frame = tmpframe;
+
+    opvar_free(addr);
+    opvar_free(params);
+}
+
+void
+spo_return(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *params;
+    if (!coder->frame || !coder->frame->next) panic("return: no frame.");
+    if (!OV_pop_i(params)) return;
+    if (OV_i(params) < 0) return;
+
+    while (OV_i(params)-- > 0) {
+	splev_stack_push(coder->frame->next->stack, splev_stack_pop(coder->stack));
+    }
+
+    /* pop the frame */
+    if (coder->frame->next) {
+	struct sp_frame *tmpframe = coder->frame->next;
+	frame_del(coder->frame);
+	coder->frame = tmpframe;
+	coder->stack = coder->frame->stack;
+    }
+
+    opvar_free(params);
+}
+
+void
+spo_end_moninvent(coder)
+     struct sp_coder *coder;
+{
+    if (invent_carrying_monster)
+	m_dowear(invent_carrying_monster, TRUE);
+    invent_carrying_monster = NULL;
+}
+
+void
+spo_pop_container(coder)
+     struct sp_coder *coder;
+{
+    if (container_idx > 0) {
+	container_idx--;
+	container_obj[container_idx] = NULL;
+    }
+}
+
+
+void
+spo_message(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *op;
+    char *msg, *levmsg;
+    int old_n, n;
+    if (!OV_pop_s(op)) return;
+    msg = OV_s(op);
+    if (!msg) return;
+
+    old_n = lev_message ? (strlen(lev_message)+1) : 0;
+    n = strlen(msg);
+
+    levmsg = (char *) alloc(old_n+n+1);
+    if (!levmsg) panic("spo_message alloc");
+    if (old_n) levmsg[old_n-1] = '\n';
+    if (lev_message)
+	(void) memcpy((genericptr_t)levmsg, (genericptr_t)lev_message, old_n-1);
+    (void) memcpy((genericptr_t)&levmsg[old_n], msg, n);
+    levmsg[old_n+n] = '\0';
+    Free(lev_message);
+    lev_message = levmsg;
+    opvar_free(op);
+}
+
+void
+spo_monster(coder)
+     struct sp_coder *coder;
+{
+    int nparams = 0;
+
+    struct opvar *varparam;
+    struct opvar *id, *coord, *has_inv;
+    monster tmpmons;
+
+    tmpmons.peaceful = -1;
+    tmpmons.asleep = -1;
+    tmpmons.name.str = (char *)0;
+    tmpmons.appear = 0;
+    tmpmons.appear_as.str = (char *)0;
+    tmpmons.align = - MAX_REGISTERS - 2;
+    tmpmons.female = 0;
+    tmpmons.invis = 0;
+    tmpmons.cancelled = 0;
+    tmpmons.revived = 0;
+    tmpmons.avenge = 0;
+    tmpmons.fleeing = 0;
+    tmpmons.blinded = 0;
+    tmpmons.paralyzed = 0;
+    tmpmons.stunned = 0;
+    tmpmons.confused = 0;
+    tmpmons.seentraps = 0;
+    tmpmons.has_invent = 0;
+
+    if (!OV_pop_i(has_inv)) return;
+
+    if (!OV_pop_i(varparam)) return;
+
+    while ((nparams++ < (SP_M_V_END+1)) &&
+	   (OV_typ(varparam) == SPOVAR_INT) &&
+	   (OV_i(varparam) >= 0) &&
+	   (OV_i(varparam) < SP_M_V_END)) {
+	struct opvar *parm = NULL;
+	OV_pop(parm);
+	switch (OV_i(varparam)) {
+	case SP_M_V_NAME:
+	    if ((OV_typ(parm) == SPOVAR_STRING) &&
+		!tmpmons.name.str)
+		tmpmons.name.str = strdup(OV_s(parm));
+	    break;
+	case SP_M_V_APPEAR:
+	    if ((OV_typ(parm) == SPOVAR_INT) &&
+		!tmpmons.appear_as.str) {
+		tmpmons.appear = OV_i(parm);
+		opvar_free(parm);
+		OV_pop(parm);
+		tmpmons.appear_as.str = strdup(OV_s(parm));
+	    }
+	    break;
+	case SP_M_V_ASLEEP:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpmons.asleep = OV_i(parm);
+	    break;
+	case SP_M_V_ALIGN:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpmons.align = OV_i(parm);
+	    break;
+	case SP_M_V_PEACEFUL:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpmons.peaceful = OV_i(parm);
+	    break;
+	case SP_M_V_FEMALE:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpmons.female = OV_i(parm);
+	    break;
+	case SP_M_V_INVIS:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpmons.invis = OV_i(parm);
+	    break;
+	case SP_M_V_CANCELLED:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpmons.cancelled = OV_i(parm);
+	    break;
+	case SP_M_V_REVIVED:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpmons.revived = OV_i(parm);
+	    break;
+	case SP_M_V_AVENGE:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpmons.avenge = OV_i(parm);
+	    break;
+	case SP_M_V_FLEEING:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpmons.fleeing = OV_i(parm);
+	    break;
+	case SP_M_V_BLINDED:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpmons.blinded = OV_i(parm);
+	    break;
+	case SP_M_V_PARALYZED:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpmons.paralyzed = OV_i(parm);
+	    break;
+	case SP_M_V_STUNNED:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpmons.stunned = OV_i(parm);
+	    break;
+	case SP_M_V_CONFUSED:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpmons.confused = OV_i(parm);
+	    break;
+	case SP_M_V_SEENTRAPS:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpmons.seentraps = OV_i(parm);
+	    break;
+	case SP_M_V_END:
+	    nparams = SP_M_V_END+1;
+	    break;
+	default:
+	    impossible("MONSTER with unknown variable param type!");
+	    break;
+	}
+	opvar_free(parm);
+	if (OV_i(varparam) != SP_M_V_END) {
+	    opvar_free(varparam);
+	    OV_pop(varparam);
+	}
+    }
+
+    if (!OV_pop_c(coord)) panic("no monster coord?");
+
+    if (!OV_pop_typ(id, SPOVAR_MONST)) panic("no mon type");
+
+    tmpmons.id = SP_MONST_PM(OV_i(id));
+    tmpmons.class = SP_MONST_CLASS(OV_i(id));
+    tmpmons.coord = OV_i(coord);
+    tmpmons.has_invent = OV_i(has_inv);
+
+    create_monster(&tmpmons, coder->croom);
+
+    Free(tmpmons.name.str);
+    Free(tmpmons.appear_as.str);
+
+    opvar_free(id);
+    opvar_free(coord);
+    opvar_free(has_inv);
+    opvar_free(varparam);
+}
+
+void
+spo_object(coder)
+     struct sp_coder *coder;
+{
+    int nparams = 0;
+    long quancnt;
+
+    struct opvar *varparam;
+    struct opvar *id, *containment;
+
+    object tmpobj;
+
+    tmpobj.spe = -127;
+    tmpobj.curse_state = -1;
+    tmpobj.corpsenm = NON_PM;
+    tmpobj.name.str = (char *)0;
+    tmpobj.quan = -1;
+    tmpobj.buried = 0;
+    tmpobj.lit = 0;
+    tmpobj.eroded = 0;
+    tmpobj.locked = 0;
+    tmpobj.trapped = 0;
+    tmpobj.recharged = 0;
+    tmpobj.invis = 0;
+    tmpobj.greased = 0;
+    tmpobj.broken = 0;
+    tmpobj.coord = SP_COORD_PACK_RANDOM(0);
+
+    if (!OV_pop_i(containment)) return;
+
+    if (!OV_pop_i(varparam)) return;
+
+    while ((nparams++ < (SP_O_V_END+1)) &&
+	   (OV_typ(varparam) == SPOVAR_INT) &&
+	   (OV_i(varparam) >= 0) &&
+	   (OV_i(varparam) < SP_O_V_END)) {
+	struct opvar *parm;
+	OV_pop(parm);
+	switch (OV_i(varparam)) {
+	case SP_O_V_NAME:
+	    if ((OV_typ(parm) == SPOVAR_STRING) &&
+		!tmpobj.name.str)
+		tmpobj.name.str = strdup(OV_s(parm));
+	    break;
+	case SP_O_V_CORPSENM:
+	    if (OV_typ(parm) == SPOVAR_MONST) {
+		char monclass = SP_MONST_CLASS(OV_i(parm));
+		int monid = SP_MONST_PM(OV_i(parm));
+		if (monid >= 0 && monid < NUMMONS) {
+		    tmpobj.corpsenm = monid;
+		    break; /* we're done! */
+		} else {
+		    struct permonst *pm = (struct permonst *)0;
+		    if (def_char_to_monclass(monclass) != MAXMCLASSES) {
+			pm = mkclass(def_char_to_monclass(monclass), G_NOGEN);
+		    } else {
+			pm = rndmonst();
+		    }
+		    if (pm)
+			tmpobj.corpsenm = monsndx(pm);
+		}
+	    }
+	    break;
+	case SP_O_V_CURSE:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpobj.curse_state = OV_i(parm);
+	    break;
+	case SP_O_V_SPE:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpobj.spe = OV_i(parm);
+	    break;
+	case SP_O_V_QUAN:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpobj.quan = OV_i(parm);
+	    break;
+	case SP_O_V_BURIED:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpobj.buried = OV_i(parm);
+	    break;
+	case SP_O_V_LIT:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpobj.lit = OV_i(parm);
+	    break;
+	case SP_O_V_ERODED:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpobj.eroded = OV_i(parm);
+	    break;
+	case SP_O_V_LOCKED:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpobj.locked = OV_i(parm);
+	    break;
+	case SP_O_V_TRAPPED:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpobj.trapped = OV_i(parm);
+	    break;
+	case SP_O_V_RECHARGED:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpobj.recharged = OV_i(parm);
+	    break;
+	case SP_O_V_INVIS:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpobj.invis = OV_i(parm);
+	    break;
+	case SP_O_V_GREASED:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpobj.greased = OV_i(parm);
+	    break;
+	case SP_O_V_BROKEN:
+	    if (OV_typ(parm) == SPOVAR_INT)
+		tmpobj.broken = OV_i(parm);
+	    break;
+	case SP_O_V_COORD:
+	    if (OV_typ(parm) != SPOVAR_COORD)
+		panic("no coord for obj?");
+	    tmpobj.coord = OV_i(parm);
+	    break;
+	case SP_O_V_END:
+	    nparams = SP_O_V_END+1;
+	    break;
+	default:
+	    impossible("OBJECT with unknown variable param type!");
+	    break;
+	}
+	opvar_free(parm);
+	if (OV_i(varparam) != SP_O_V_END) {
+	    opvar_free(varparam);
+	    OV_pop(varparam);
+	}
+    }
+
+    if (!OV_pop_typ(id, SPOVAR_OBJ)) panic("no obj type");
+
+    tmpobj.id = SP_OBJ_TYP(OV_i(id));
+    tmpobj.class = SP_OBJ_CLASS(OV_i(id));
+    tmpobj.containment = OV_i(containment);
+
+    quancnt = (tmpobj.id > STRANGE_OBJECT) ? tmpobj.quan : 0;
+
+    do {
+	create_object(&tmpobj, coder->croom);
+	quancnt--;
+    } while ((quancnt > 0) &&
+	     ((tmpobj.id > STRANGE_OBJECT) &&
+	      !objects[tmpobj.id].oc_merge));
+
+    Free(tmpobj.name.str);
+
+    opvar_free(varparam);
+    opvar_free(id);
+    opvar_free(containment);
+}
+
+void
+spo_level_flags(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *flagdata;
+    long flags;
+
+    if (!OV_pop_i(flagdata)) return;
+    flags = OV_i(flagdata);
+
+    if (flags & NOTELEPORT)   level.flags.noteleport = 1;
+    if (flags & HARDFLOOR)    level.flags.hardfloor = 1;
+    if (flags & NOMMAP)       level.flags.nommap = 1;
+    if (flags & SHORTSIGHTED) level.flags.shortsighted = 1;
+    if (flags & ARBOREAL)     level.flags.arboreal = 1;
+    /*
+    if (flags & NOFLIPX)      coder->allow_flips &= ~1;
+    if (flags & NOFLIPY)      coder->allow_flips &= ~2;
+    if (flags & MAZELEVEL)    level.flags.is_maze_lev = 1;
+    if (flags & PREMAPPED)    coder->premapped = TRUE;
+    if (flags & SHROUD)       level.flags.hero_memory = 0;
+    if (flags & STORMY)       level.flags.stormy = 1;
+    if (flags & GRAVEYARD)    level.flags.graveyard = 1;
+    if (flags & SKYMAP)       level.flags.sky = 1;
+    if (flags & FLAG_RNDVAULT) coder->allow_flips = 0;
+    */
+
+    opvar_free(flagdata);
+}
+
+void
+spo_initlevel(coder)
+     struct sp_coder *coder;
+{
+    lev_init init_lev;
+    struct opvar *init_style, *fg, *bg, *smoothed, *joined, *lit, *walled, *filling;
+
+    if (!OV_pop_i(fg) ||
+	!OV_pop_i(bg) ||
+	!OV_pop_i(smoothed) ||
+	!OV_pop_i(joined) ||
+	!OV_pop_i(lit) ||
+	!OV_pop_i(walled) ||
+	!OV_pop_i(filling) ||
+	!OV_pop_i(init_style)) return;
+
+    init_lev.init_style = OV_i(init_style);
+    init_lev.fg = OV_i(fg);
+    init_lev.bg = OV_i(bg);
+    init_lev.smoothed = OV_i(smoothed);
+    init_lev.joined = OV_i(joined);
+    init_lev.lit = OV_i(lit);
+    init_lev.walled = OV_i(walled);
+    init_lev.filling = OV_i(filling);
+
+    coder->lvl_is_joined = OV_i(joined);
+
+    splev_initlev(&init_lev);
+
+    opvar_free(init_style);
+    opvar_free(fg);
+    opvar_free(bg);
+    opvar_free(smoothed);
+    opvar_free(joined);
+    opvar_free(lit);
+    opvar_free(walled);
+    opvar_free(filling);
+}
+
+void
+spo_engraving(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *etyp, *txt, *coord;
+    xchar x,y;
+
+    if (!OV_pop_i(etyp) ||
+	!OV_pop_s(txt) ||
+	!OV_pop_c(coord)) return;
+
+    get_location_coord(&x, &y, DRY, coder->croom, OV_i(coord));
+    make_engr_at(x, y, OV_s(txt), 0L, OV_i(etyp));
+
+    opvar_free(etyp);
+    opvar_free(txt);
+    opvar_free(coord);
+}
+
+void
+spo_mineralize(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *kelp_pool, *kelp_moat, *gold_prob, *gem_prob;
+
+    if (!OV_pop_i(gem_prob) ||
+	!OV_pop_i(gold_prob) ||
+	!OV_pop_i(kelp_moat) ||
+	!OV_pop_i(kelp_pool)) return;
+
+    mineralize(OV_i(kelp_pool), OV_i(kelp_moat), OV_i(gold_prob), OV_i(gem_prob), TRUE);
+
+    opvar_free(gem_prob);
+    opvar_free(gold_prob);
+    opvar_free(kelp_moat);
+    opvar_free(kelp_pool);
+}
+
+void
+spo_room(coder)
+     struct sp_coder *coder;
+{
+    int isbigrm = FALSE;
+    if (coder->n_subroom > MAX_NESTED_ROOMS)
+	panic("Too deeply nested rooms?!");
+    else {
+	struct opvar *flags, *h, *w, *yalign, *xalign,
+	    *y, *x, *rlit, *chance, *rtype;
+
+	room tmproom;
+	struct mkroom *tmpcr;
+
+	if (!OV_pop_i(h) ||
+	    !OV_pop_i(w) ||
+	    !OV_pop_i(y) ||
+	    !OV_pop_i(x) ||
+	    !OV_pop_i(yalign) ||
+	    !OV_pop_i(xalign) ||
+	    !OV_pop_i(flags) ||
+	    !OV_pop_i(rlit) ||
+	    !OV_pop_i(chance) ||
+	    !OV_pop_i(rtype)) return;
+
+
+	tmproom.x = OV_i(x);
+	tmproom.y = OV_i(y);
+	tmproom.w = OV_i(w);
+	tmproom.h = OV_i(h);
+	tmproom.xalign = OV_i(xalign);
+	tmproom.yalign = OV_i(yalign);
+	tmproom.rtype = OV_i(rtype);
+	tmproom.chance = OV_i(chance);
+	tmproom.rlit = OV_i(rlit);
+	tmproom.filled = (OV_i(flags) & (1 << 0));
+	/*tmproom.irregular = (OV_i(flags) & (1 << 1));*/
+	tmproom.joined = !(OV_i(flags) & (1 << 2));
+
+	isbigrm = ((tmproom.w * tmproom.h) > 20);
+
+	opvar_free(x);
+	opvar_free(y);
+	opvar_free(w);
+	opvar_free(h);
+	opvar_free(xalign);
+	opvar_free(yalign);
+	opvar_free(rtype);
+	opvar_free(chance);
+	opvar_free(rlit);
+	opvar_free(flags);
+
+	if (!coder->failed_room[coder->n_subroom-1]) {
+	    tmpcr = build_room(&tmproom, coder->croom);
+	    if (tmpcr) {
+		coder->tmproomlist[coder->n_subroom] = tmpcr;
+		coder->failed_room[coder->n_subroom] = FALSE;
+		coder->n_subroom++;
+		return;
+	    }
+	} /* failed to create parent room, so fail this too */
+    }
+    coder->tmproomlist[coder->n_subroom] = (struct mkroom *)0;
+    coder->failed_room[coder->n_subroom] = TRUE;
+    coder->n_subroom++;
+}
+
+void
+spo_endroom(coder)
+     struct sp_coder *coder;
+{
+    if (coder->n_subroom > 1) {
+	coder->n_subroom--;
+	coder->tmproomlist[coder->n_subroom] = NULL;
+	coder->failed_room[coder->n_subroom] = TRUE;
+    } else {
+	/* no subroom, get out of top-level room */
+	/* Need to ensure xstart/ystart/xsize/ysize have something sensible,
+	   in case there's some stuff to be created outside the outermost room,
+	   and there's no MAP.
+	*/
+	if(xsize <= 1 && ysize <= 1) {
+	    xstart = 1;
+	    ystart = 0;
+	    xsize = COLNO-1;
+	    ysize = ROWNO;
+	}
+    }
+}
+
+void
+spo_stair(coder)
+     struct sp_coder *coder;
+{
+    xchar x,y;
+    struct opvar *up, *coord;
+    struct trap *badtrap;
+
+    if (!OV_pop_i(up) ||
+	!OV_pop_c(coord)) return;
+
+    if (coder->croom) {
+	get_location_coord(&x, &y, DRY, coder->croom, OV_i(coord));
+	mkstairs(x,y,(char)OV_i(up), coder->croom);
+	SpLev_Map[x][y] = 1;
+    } else {
+	get_location_coord(&x, &y, DRY, coder->croom, OV_i(coord));
+	if ((badtrap = t_at(x,y)) != 0) deltrap(badtrap);
+	mkstairs(x, y, (char)OV_i(up), coder->croom);
+	SpLev_Map[x][y] = 1;
+    }
+
+    opvar_free(coord);
+    opvar_free(up);
+}
+
+void
+spo_ladder(coder)
+     struct sp_coder *coder;
+{
+    xchar x,y;
+    struct opvar *up, *coord;
+
+    if (!OV_pop_i(up) ||
+	!OV_pop_c(coord)) return;
+
+    get_location_coord(&x, &y, DRY, coder->croom, OV_i(coord));
+
+    levl[x][y].typ = LADDER;
+    SpLev_Map[x][y] = 1;
+    if (OV_i(up)) {
+	xupladder = x; yupladder = y;
+	levl[x][y].ladder = LA_UP;
+    } else {
+	xdnladder = x; ydnladder = y;
+	levl[x][y].ladder = LA_DOWN;
+    }
+    opvar_free(coord);
+    opvar_free(up);
+}
+
+void
+spo_grave(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *coord, *typ, *txt;
+    schar x,y;
+    if (!OV_pop_i(typ) ||
+	!OV_pop_s(txt) ||
+	!OV_pop_c(coord)) return;
+
+    get_location_coord(&x, &y, DRY, coder->croom, OV_i(coord));
+
+    if (isok(x, y) && !t_at(x, y)) {
+	levl[x][y].typ = GRAVE;
+	switch (OV_i(typ)) {
+	case 2: make_grave(x, y, OV_s(txt)); break;
+	case 1: make_grave(x, y, NULL); break;
+	default: del_engr_at(x, y); break;
+	}
+    }
+
+    opvar_free(coord);
+    opvar_free(typ);
+    opvar_free(txt);
+}
+
+void
+spo_altar(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *al, *shrine, *coord;
+    altar tmpaltar;
+
+    if (!OV_pop_i(al) ||
+	!OV_pop_i(shrine) ||
+	!OV_pop_c(coord)) return;
+
+    tmpaltar.coord = OV_i(coord);
+    tmpaltar.align = OV_i(al);
+    tmpaltar.shrine = OV_i(shrine);
+
+    create_altar(&tmpaltar, coder->croom);
+
+    opvar_free(coord);
+    opvar_free(shrine);
+    opvar_free(al);
+}
+
+void
+spo_trap(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *type;
+    struct opvar *coord;
+    trap tmptrap;
+
+    if (!OV_pop_i(type) ||
+	!OV_pop_c(coord)) return;
+
+    tmptrap.coord = OV_i(coord);
+    tmptrap.type = OV_i(type);
+
+    create_trap(&tmptrap, coder->croom);
+    opvar_free(coord);
+    opvar_free(type);
+}
+
+void
+spo_gold(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *coord, *amt;
+    schar x,y;
+    long amount;
+    if (!OV_pop_c(coord) || !OV_pop_i(amt)) return;
+    amount = OV_i(amt);
+    get_location_coord(&x, &y, DRY, coder->croom, OV_i(coord));
+    if (amount == -1) amount = rnd(200);
+    mkgold(amount, x,y);
+    opvar_free(coord);
+    opvar_free(amt);
+}
+
+void
+spo_corridor(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *deswall, *desdoor, *desroom,
+	*srcwall, *srcdoor, *srcroom;
+    corridor tc;
+
+    if (!OV_pop_i(deswall) ||
+	!OV_pop_i(desdoor) ||
+	!OV_pop_i(desroom) ||
+	!OV_pop_i(srcwall) ||
+	!OV_pop_i(srcdoor) ||
+	!OV_pop_i(srcroom)) return;
+
+    tc.src.room = OV_i(srcroom);
+    tc.src.door = OV_i(srcdoor);
+    tc.src.wall = OV_i(srcwall);
+    tc.dest.room = OV_i(desroom);
+    tc.dest.door = OV_i(desdoor);
+    tc.dest.wall = OV_i(deswall);
+
+    create_corridor(&tc);
+
+    opvar_free(deswall);
+    opvar_free(desdoor);
+    opvar_free(desroom);
+    opvar_free(srcwall);
+    opvar_free(srcdoor);
+    opvar_free(srcroom);
+}
+
+
+struct opvar *
+selection_opvar(nbuf)
+     char *nbuf;
+{
+    struct opvar *ov;
+    char buf[(COLNO*ROWNO)+1];
+
+    if (!nbuf) {
+	(void) memset(buf, 1, sizeof(buf));
+	buf[(COLNO*ROWNO)] = '\0';
+	ov = opvar_new_str(buf);
+    } else {
+	ov = opvar_new_str(nbuf);
+    }
+    ov->spovartyp = SPOVAR_SEL;
+    return ov;
+}
+
+char
+selection_getpoint(x,y,ov)
+     int x,y;
+     struct opvar *ov;
+{
+    if (!ov || ov->spovartyp != SPOVAR_SEL) return 0;
+    if (x < 0 || y < 0 || x >= COLNO || y >= ROWNO) return 0;
+
+    return (ov->vardata.str[COLNO*y + x] - 1);
+}
+
+void
+selection_setpoint(x,y,ov, c)
+     int x,y;
+     struct opvar *ov;
+     char c;
+{
+    if (!ov || ov->spovartyp != SPOVAR_SEL) return;
+    if (x < 0 || y < 0 || x >= COLNO || y >= ROWNO) return;
+
+    ov->vardata.str[COLNO*y + x] = (c + 1);
+}
+
+struct opvar *
+selection_not(s)
+     struct opvar *s;
+{
+    struct opvar *ov;
+    int x,y;
+    ov = selection_opvar(NULL);
+    if (!ov) return NULL;
+
+    for (x = 0; x < COLNO; x++)
+	for (y = 0; y < ROWNO; y++)
+	    if (!selection_getpoint(x,y,s))
+		selection_setpoint(x,y,ov,1);
+
+    return ov;
+}
+
+struct opvar *
+selection_logical_oper(s1, s2, oper)
+     struct opvar *s1, *s2;
+     char oper;
+{
+    struct opvar *ov;
+    int x,y;
+
+    ov = selection_opvar(NULL);
+    if (!ov) return NULL;
+
+    for (x = 0; x < COLNO; x++)
+	for (y = 0; y < ROWNO; y++) {
+	    switch (oper) {
+	    default:
+	    case '|':
+		if (selection_getpoint(x,y,s1) || selection_getpoint(x,y,s2))
+		    selection_setpoint(x,y,ov,1);
+		break;
+	    case '&':
+		if (selection_getpoint(x,y,s1) && selection_getpoint(x,y,s2))
+		    selection_setpoint(x,y,ov,1);
+		break;
+	    }
+	}
+
+    return ov;
+}
+
+struct opvar *
+selection_filter_mapchar(ov, mc)
+    struct opvar *ov;
+    struct opvar *mc;
+{
+    int x,y;
+    schar mapc;
+    xchar lit;
+    struct opvar *ret = selection_opvar(NULL);
+    if (!ov || !mc || !ret) return NULL;
+    mapc = SP_MAPCHAR_TYP(OV_i(mc));
+    lit = SP_MAPCHAR_LIT(OV_i(mc));
+    for (x = 0; x < COLNO; x++)
+	for (y = 0; y < ROWNO; y++)
+	    if (selection_getpoint(x,y,ov) && (levl[x][y].typ == mapc)) {
+		switch (lit) {
+		default:
+		case -2: selection_setpoint(x,y,ret, 1); break;
+		case -1: selection_setpoint(x,y,ret, rn2(2)); break;
+		case 0:
+		case 1: if (levl[x][y].lit == lit) selection_setpoint(x,y,ret, 1); break;
+		}
+	    }
+    return ret;
+}
+
+
+void
+selection_filter_percent(ov, percent)
+    struct opvar *ov;
+    int percent;
+{
+    int x,y;
+    if (!ov) return;
+    for (x = 0; x < COLNO; x++)
+	for (y = 0; y < ROWNO; y++)
+	    if (selection_getpoint(x,y,ov) && (rn2(100) >= percent))
+		selection_setpoint(x,y,ov,0);
+}
+
+int
+selection_rndcoord(ov, x,y)
+    struct opvar *ov;
+    schar *x, *y;
+{
+    int idx = 0;
+    int c;
+    int dx,dy;
+
+    for (dx = 0; dx < COLNO; dx++)
+	for (dy = 0; dy < ROWNO; dy++)
+	    if (isok(dx,dy) && selection_getpoint(dx,dy,ov)) idx++;
+
+    if (idx) {
+	c = rn2(idx);
+	for (dx = 0; dx < COLNO; dx++)
+	    for (dy = 0; dy < ROWNO; dy++)
+		if (isok(dx,dy) && selection_getpoint(dx,dy, ov)) {
+		    if (!c) {
+			*x = dx;
+			*y = dy;
+			return 1;
+		    }
+		    c--;
+		}
+    }
+    *x = *y = -1;
+    return 0;
+}
+
+void
+selection_do_grow(ov, dir)
+     struct opvar *ov;
+     int dir;
+{
+    int x,y, c;
+    char tmp[COLNO][ROWNO];
+
+    if (ov->spovartyp != SPOVAR_SEL) return;
+    if (!ov) return;
+
+    (void) memset(tmp, 0, sizeof(tmp));
+
+    for (x = 0; x < COLNO; x++)
+	for (y = 0; y < ROWNO; y++) {
+	    c = 0;
+	    if ((dir & W_WEST) && (x > 0) && (selection_getpoint(x-1,y, ov))) c++;
+	    if ((dir & (W_WEST|W_NORTH)) && (x > 0) && (y > 0) && (selection_getpoint(x-1,y-1, ov))) c++;
+	    if ((dir & W_NORTH) && (y > 0) && (selection_getpoint(x,y-1, ov))) c++;
+	    if ((dir & (W_NORTH|W_EAST)) && (y > 0) && (x < COLNO-1) && (selection_getpoint(x+1,y-1, ov))) c++;
+	    if ((dir & W_EAST) && (x < COLNO-1) && (selection_getpoint(x+1,y, ov))) c++;
+	    if ((dir & (W_EAST|W_SOUTH)) && (x < COLNO-1) && (y < ROWNO-1) && (selection_getpoint(x+1,y+1, ov))) c++;
+	    if ((dir & W_SOUTH) && (y < ROWNO-1) && (selection_getpoint(x,y+1, ov))) c++;
+	    if ((dir & (W_SOUTH|W_WEST)) && (y < ROWNO-1) && (x > 0) && (selection_getpoint(x-1,y+1, ov))) c++;
+	    if (c) tmp[x][y] = 1;
+	}
+
+    for (x = 0; x < COLNO; x++)
+	for (y = 0; y < ROWNO; y++)
+	    if (tmp[x][y]) selection_setpoint(x,y,ov,1);
+}
+
+void
+selection_floodfill(ov, x,y)
+     struct opvar *ov;
+     int x,y;
+{
+    struct opvar *tmp = selection_opvar(NULL);
+#define SEL_FLOOD_STACK (COLNO*ROWNO)
+#define SEL_FLOOD(nx,ny) {if (idx<SEL_FLOOD_STACK) { dx[idx]=(nx); dy[idx]=(ny); idx++; } else panic("floodfill stack overrun");}
+    int idx = 0;
+    xchar dx[SEL_FLOOD_STACK];
+    xchar dy[SEL_FLOOD_STACK];
+    schar under = levl[x][y].typ;
+    SEL_FLOOD(x,y);
+    do {
+	idx--;
+	x = dx[idx];
+	y = dy[idx];
+	if (isok(x,y)) {
+	    selection_setpoint(x,y, ov, 1);
+	    selection_setpoint(x,y, tmp, 1);
+	}
+	if (isok(x+1,y) && (levl[x+1][y].typ == under) && !selection_getpoint(x+1,y,tmp)) SEL_FLOOD(x+1, y);
+	if (isok(x-1,y) && (levl[x-1][y].typ == under) && !selection_getpoint(x-1,y,tmp)) SEL_FLOOD(x-1, y);
+	if (isok(x,y+1) && (levl[x][y+1].typ == under) && !selection_getpoint(x,y+1,tmp)) SEL_FLOOD(x, y+1);
+	if (isok(x,y-1) && (levl[x][y-1].typ == under) && !selection_getpoint(x,y-1,tmp)) SEL_FLOOD(x, y-1);
+    } while (idx > 0);
+#undef SEL_FLOOD
+#undef SEL_FLOOD_STACK
+    opvar_free(tmp);
+}
+
+/* McIlroy's Ellipse Algorithm */
+void
+selection_do_ellipse(ov, xc,yc, a,b, filled)
+    struct opvar *ov;
+    int xc,yc,a,b,filled;
+{                       /* e(x,y) = b^2*x^2 + a^2*y^2 - a^2*b^2 */
+    int x = 0, y = b;
+    long a2 = (long)a*a, b2 = (long)b*b;
+    long crit1 = -(a2/4 + a%2 + b2);
+    long crit2 = -(b2/4 + b%2 + a2);
+    long crit3 = -(b2/4 + b%2);
+    long t = -a2*y; /* e(x+1/2,y-1/2) - (a^2+b^2)/4 */
+    long dxt = 2*b2*x, dyt = -2*a2*y;
+    long d2xt = 2*b2, d2yt = 2*a2;
+    long width = 1;
+    long i;
+
+    if (!ov) return;
+
+    filled = !filled;
+
+    if (!filled) {
+	while (y>=0 && x<=a) {
+	    selection_setpoint(xc+x, yc+y, ov, 1);
+	    if (x!=0 || y!=0)
+		selection_setpoint(xc-x, yc-y, ov, 1);
+	    if (x!=0 && y!=0) {
+		selection_setpoint(xc+x, yc-y, ov, 1);
+		selection_setpoint(xc-x, yc+y, ov, 1);
+	    }
+	    if (t + b2*x <= crit1 ||   /* e(x+1,y-1/2) <= 0 */
+		t + a2*y <= crit3) {     /* e(x+1/2,y) <= 0 */
+		x++; dxt += d2xt; t += dxt;
+	    } else if (t - a2*y > crit2) { /* e(x+1/2,y-1) > 0 */
+		y--; dyt += d2yt; t += dyt;
+	    } else {
+		x++; dxt += d2xt; t += dxt;
+		y--; dyt += d2yt; t += dyt;
+	    }
+	}
+    } else {
+	while (y>=0 && x<=a) {
+	    if (t + b2*x <= crit1 ||   /* e(x+1,y-1/2) <= 0 */
+		t + a2*y <= crit3) {     /* e(x+1/2,y) <= 0 */
+		x++; dxt += d2xt; t += dxt;
+		width += 2;
+	    } else if (t - a2*y > crit2) { /* e(x+1/2,y-1) > 0 */
+		for (i = 0; i < width; i++) selection_setpoint(xc-x+i, yc-y, ov, 1);
+		if (y!=0)
+		    for (i = 0; i < width; i++) selection_setpoint(xc-x+i, yc+y, ov, 1);
+		y--; dyt += d2yt; t += dyt;
+	    } else {
+		for (i = 0; i < width; i++) selection_setpoint(xc-x+i, yc-y, ov, 1);
+		if (y!=0)
+		    for (i = 0; i < width; i++) selection_setpoint(xc-x+i, yc+y, ov, 1);
+		x++; dxt += d2xt; t += dxt;
+		y--; dyt += d2yt; t += dyt;
+		width += 2;
+	    }
+	}
+    }
+}
+
+/* distance from line segment (x1,y1, x2,y2) to point (x3,y3) */
+long
+line_dist_coord(x1,y1, x2,y2, x3,y3)
+     long x1,y1,x2,y2,x3,y3;
+{
+    long px = x2-x1;
+    long py = y2-y1;
+
+    if (x1 == x2 && y1 == y2) return isqrt(dist2(x1,y1, x3,y3));
+
+    long s = px*px + py*py;
+    float u = ((x3 - x1) * px + (y3 - y1) * py) / (float)s;
+
+    if (u > 1) u = 1;
+    else if (u < 0) u = 0;
+
+    long x = x1 + u * px;
+    long y = y1 + u * py;
+    long dx = x - x3;
+    long dy = y - y3;
+    long dist = isqrt(dx*dx + dy*dy);
+
+    return dist;
+}
+
+void
+selection_do_gradient(ov, x,y, x2,y2, gtyp, mind, maxd, limit)
+     struct opvar *ov;
+     long x, y, x2,y2, gtyp, mind, maxd, limit;
+{
+    long dx,dy, dofs;
+
+    if (mind > maxd) {
+	long tmp = mind;
+	mind = maxd;
+	maxd = tmp;
+    }
+
+    dofs = maxd - mind;
+    if (dofs < 1) dofs = 1;
+
+    switch (gtyp) {
+    default:
+    case SEL_GRADIENT_RADIAL:
+	{
+	    for (dx = 0; dx < COLNO; dx++)
+		for (dy = 0; dy < ROWNO; dy++) {
+		    long d = line_dist_coord(x,y, x2,y2, dx,dy);
+		    if (d >= mind && (!limit || (d <= maxd))) {
+			if ((d - mind) > rn2(dofs))
+			    selection_setpoint(dx,dy, ov, 1);
+		    }
+		}
+	}
+	break;
+    case SEL_GRADIENT_SQUARE:
+	{
+	    for (dx = 0; dx < COLNO; dx++)
+		for (dy = 0; dy < ROWNO; dy++) {
+		    long d1 = line_dist_coord(x,y, x2,y2, x,dy);
+		    long d2 = line_dist_coord(x,y, x2,y2, dx,y);
+		    long d3 = line_dist_coord(x,y, x2,y2, x2,dy);
+		    long d4 = line_dist_coord(x,y, x2,y2, dx,y2);
+		    long d5 = line_dist_coord(x,y, x2,y2, dx,dy);
+		    long d = min(d5, min(max(d1, d2),max(d3,d4)));
+
+		    if (d >= mind && (!limit || (d <= maxd))) {
+			if ((d - mind) > rn2(dofs))
+			    selection_setpoint(dx,dy, ov, 1);
+		    }
+		}
+	}
+	break;
+    }
+}
+
+void
+selection_do_line(x1,y1,x2,y2, ov) /* bresenham line algo */
+     schar x1,y1,x2,y2;
+     struct opvar *ov;
+{
+    int d,dx,dy,ai,bi,xi,yi;
+
+    if (x1 < x2) {
+	xi = 1;
+	dx = x2 - x1;
+    } else {
+	xi = - 1;
+	dx = x1 - x2;
+    }
+
+    if (y1 < y2) {
+	yi = 1;
+	dy = y2 - y1;
+    } else {
+	yi = - 1;
+	dy = y1 - y2;
+    }
+
+    selection_setpoint(x1,y1, ov, 1);
+
+    if (dx > dy) {
+	ai = (dy - dx) * 2;
+	bi = dy * 2;
+	d  = bi - dx;
+	do {
+	    if (d >= 0) {
+		y1 += yi;
+		d += ai;
+	    } else d += bi;
+	    x1 += xi;
+	    selection_setpoint(x1,y1, ov, 1);
+	} while (x1 != x2);
+    } else {
+	ai = (dx - dy) * 2;
+	bi = dx * 2;
+	d  = bi - dy;
+	do {
+	    if (d >= 0) {
+		x1 += xi;
+		d += ai;
+	    } else d += bi;
+	    y1 += yi;
+	    selection_setpoint(x1,y1, ov, 1);
+	} while (y1 != y2);
+    }
+}
+
+void
+selection_do_randline(x1,y1,x2,y2,rough, rec, ov)
+     schar x1,y1,x2,y2,rough,rec;
+     struct opvar *ov;
+{
+    int mx, my;
+    int dx, dy;
+
+    if (rec < 1) {
+	return;
+    }
+
+    if ((x2 == x1) && (y2 == y1)) {
+	selection_setpoint(x1,y1, ov, 1);
+	return;
+    }
+
+    if (rough > max(abs(x2-x1), abs(y2-y1)))
+	rough = max(abs(x2-x1), abs(y2-y1));
+
+    if (rough < 2) {
+	mx = ((x1 + x2) / 2);
+	my = ((y1 + y2) / 2);
+    } else {
+	do {
+	    dx = (rand() % rough) - (rough / 2);
+	    dy = (rand() % rough) - (rough / 2);
+	    mx = ((x1 + x2) / 2) + dx;
+	    my = ((y1 + y2) / 2) + dy;
+	} while ((mx > COLNO-1 || mx < 0 || my < 0 || my > ROWNO-1));
+    }
+
+    selection_setpoint(mx,my, ov, 1);
+
+    rough = (rough * 2) / 3;
+
+    rec--;
+
+    selection_do_randline(x1,y1,mx,my, rough, rec, ov);
+    selection_do_randline(mx,my,x2,y2, rough, rec, ov);
+}
+
+
+void
+selection_iterate(ov, func, arg)
+     struct opvar *ov;
+     void FDECL((*func), (int,int,genericptr_t));
+     genericptr_t arg;
+{
+    int x,y;
+    /* yes, this is very naive, but it's not _that_ expensive. */
+    for (x = 0; x < COLNO; x++)
+	for (y = 0; y < ROWNO; y++)
+	    if (selection_getpoint(x,y, ov)) (*func)(x,y, arg);
+}
+
+void
+sel_set_ter(x,y,arg)
+     int x,y;
+     genericptr_t arg;
+{
+    terrain terr;
+    terr = (*(terrain *)arg);
+    SET_TYPLIT(x,y, terr.ter, terr.tlit);
+    /* handle doors and secret doors */
+    if (levl[x][y].typ == SDOOR || IS_DOOR(levl[x][y].typ)) {
+	if(levl[x][y].typ == SDOOR)
+	    levl[x][y].doormask = D_CLOSED;
+	if (x && (IS_WALL(levl[x-1][y].typ) ||
+		  levl[x-1][y].horizontal))
+	    levl[x][y].horizontal = 1;
+    }
+}
+
+void
+sel_set_feature(x,y,arg)
+     int x,y;
+     genericptr_t arg;
+{
+    if (IS_FURNITURE(levl[x][y].typ)) return;
+    levl[x][y].typ = (*(int *)arg);
+}
+
+void
+sel_set_door(dx,dy,arg)
+     int dx,dy;
+     genericptr_t arg;
+{
+    xchar typ = (*(xchar *)arg);
+    xchar x = dx;
+    xchar y = dy;
+    struct mkroom *droom;
+    droom = &rooms[0];
+    /*get_location(&x, &y, DRY, (struct mkroom *)0);*/
+    if (!IS_DOOR(levl[x][y].typ) && levl[x][y].typ != SDOOR)
+	levl[x][y].typ = (typ & D_SECRET) ? SDOOR : DOOR;
+    if (typ & D_SECRET) {
+	typ &= ~D_SECRET;
+	if (typ < D_CLOSED)
+	    typ = D_CLOSED;
+    }
+    levl[x][y].doormask = typ;
+    /*SpLev_Map[x][y] = 1;*/
+
+    /* Now the complicated part, list it with each subroom */
+    /* The dog move and mail daemon routines use this */
+    while(droom->hx >= 0 && doorindex < DOORMAX) {
+	if(droom->hx >= x-1 && droom->lx <= x+1 &&
+	   droom->hy >= y-1 && droom->ly <= y+1) {
+	    /* Found it */
+	    add_door(x, y, droom);
+	}
+	droom++;
+    }
+
+}
+
+
+
+void
+spo_door(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *msk, *sel;
+    xchar typ;
+
+    if (!OV_pop_i(msk) ||
+	!OV_pop_typ(sel, SPOVAR_SEL)) return;
+
+    typ = OV_i(msk) == -1 ? rnddoor() : (xchar)OV_i(msk);
+
+    selection_iterate(sel, sel_set_door, (genericptr_t)&typ);
+
+    opvar_free(sel);
+    opvar_free(msk);
+}
+
+void
+spo_feature(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *sel;
+    int typ;
+
+    if (!OV_pop_typ(sel, SPOVAR_SEL)) return;
+
+    switch (coder->opcode) {
+    default: impossible("spo_feature called with wrong opcode %i.", coder->opcode); break;
+    case SPO_FOUNTAIN: typ = FOUNTAIN; break;
+    case SPO_SINK:     typ = SINK;     break;
+    case SPO_POOL:     typ = POOL;     break;
+    }
+    selection_iterate(sel, sel_set_feature, (genericptr_t)&typ);
+    opvar_free(sel);
+}
+
+void
+spo_terrain(coder)
+     struct sp_coder *coder;
+{
+    terrain tmpterrain;
+    struct opvar *ter, *sel;
+
+    if (!OV_pop_typ(ter, SPOVAR_MAPCHAR) ||
+	!OV_pop_typ(sel, SPOVAR_SEL)) return;
+
+    tmpterrain.ter = SP_MAPCHAR_TYP(OV_i(ter));
+    tmpterrain.tlit = SP_MAPCHAR_LIT(OV_i(ter));
+    selection_iterate(sel, sel_set_ter, (genericptr_t)&tmpterrain);
+
+    opvar_free(ter);
+    opvar_free(sel);
+}
+
+void
+spo_replace_terrain(coder)
+     struct sp_coder *coder;
+{
+    replaceterrain rt;
+    struct opvar *reg,*from_ter,*to_ter,*chance;
+
+    if (!OV_pop_i(chance) ||
+	!OV_pop_typ(to_ter, SPOVAR_MAPCHAR) ||
+	!OV_pop_typ(from_ter, SPOVAR_MAPCHAR) ||
+	!OV_pop_r(reg)) return;
+
+    rt.chance = OV_i(chance);
+    rt.tolit = SP_MAPCHAR_LIT(OV_i(to_ter));
+    rt.toter = SP_MAPCHAR_TYP(OV_i(to_ter));
+    rt.fromter = SP_MAPCHAR_TYP(OV_i(from_ter));
+    /* TODO: use SP_MAPCHAR_LIT(OV_i(from_ter)) too */
+    rt.x1 = SP_REGION_X1(OV_i(reg));
+    rt.y1 = SP_REGION_Y1(OV_i(reg));
+    rt.x2 = SP_REGION_X2(OV_i(reg));
+    rt.y2 = SP_REGION_Y2(OV_i(reg));
+
+    replace_terrain(&rt, coder->croom);
+
+    opvar_free(reg);
+    opvar_free(from_ter);
+    opvar_free(to_ter);
+    opvar_free(chance);
+}
+
+void
+spo_levregion(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *rname, *padding, *rtype,
+	*del_islev, *dy2, *dx2, *dy1, *dx1,
+	*in_islev,  *iy2, *ix2, *iy1, *ix1;
+
+    lev_region *tmplregion;
+
+    if (!OV_pop_s(rname) ||
+	!OV_pop_i(padding) ||
+	!OV_pop_i(rtype) ||
+	!OV_pop_i(del_islev) ||
+	!OV_pop_i(dy2) ||
+	!OV_pop_i(dx2) ||
+	!OV_pop_i(dy1) ||
+	!OV_pop_i(dx1) ||
+	!OV_pop_i(in_islev) ||
+	!OV_pop_i(iy2) ||
+	!OV_pop_i(ix2) ||
+	!OV_pop_i(iy1) ||
+	!OV_pop_i(ix1)) return;
+
+    tmplregion = (lev_region *)alloc(sizeof(lev_region));
+    if (!tmplregion) panic("levreg alloc");
+    tmplregion->inarea.x1 = OV_i(ix1);
+    tmplregion->inarea.y1 = OV_i(iy1);
+    tmplregion->inarea.x2 = OV_i(ix2);
+    tmplregion->inarea.y2 = OV_i(iy2);
+
+    tmplregion->delarea.x1 = OV_i(dx1);
+    tmplregion->delarea.y1 = OV_i(dy1);
+    tmplregion->delarea.x2 = OV_i(dx2);
+    tmplregion->delarea.y2 = OV_i(dy2);
+
+    tmplregion->in_islev = OV_i(in_islev);
+    tmplregion->del_islev = OV_i(del_islev);
+    tmplregion->rtype = OV_i(rtype);
+    tmplregion->padding = OV_i(padding);
+    tmplregion->rname.str = strdup(OV_s(rname));
+
+    if(!tmplregion->in_islev) {
+	get_location(&tmplregion->inarea.x1, &tmplregion->inarea.y1,
+		     ANY_LOC, (struct mkroom *)0);
+	get_location(&tmplregion->inarea.x2, &tmplregion->inarea.y2,
+		     ANY_LOC, (struct mkroom *)0);
+    }
+
+    if(!tmplregion->del_islev) {
+	get_location(&tmplregion->delarea.x1, &tmplregion->delarea.y1,
+		     ANY_LOC, (struct mkroom *)0);
+	get_location(&tmplregion->delarea.x2, &tmplregion->delarea.y2,
+		     ANY_LOC, (struct mkroom *)0);
+    }
+    if(num_lregions) {
+	/* realloc the lregion space to add the new one */
+	lev_region *newl = (lev_region *) alloc(sizeof(lev_region) *
+						(unsigned)(1+num_lregions));
+	if (!newl) panic("levreg newl alloc");
+	(void) memcpy((genericptr_t)(newl), (genericptr_t)lregions,
+		      sizeof(lev_region) * num_lregions);
+	Free(lregions);
+	num_lregions++;
+	lregions = newl;
+    } else {
+	num_lregions = 1;
+	lregions = (lev_region *) alloc(sizeof(lev_region));
+	if (!lregions) panic("lregions alloc");
+    }
+    (void) memcpy(&lregions[num_lregions-1], tmplregion, sizeof(lev_region));
+
+    opvar_free(dx1);
+    opvar_free(dy1);
+    opvar_free(dx2);
+    opvar_free(dy2);
+
+    opvar_free(ix1);
+    opvar_free(iy1);
+    opvar_free(ix2);
+    opvar_free(iy2);
+
+    opvar_free(del_islev);
+    opvar_free(in_islev);
+    opvar_free(rname);
+    opvar_free(rtype);
+    opvar_free(padding);
+}
+
+void
+spo_region(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *rtype, *rlit, *flags, *area;
+    xchar dx1,dy1,dx2,dy2;
+    register struct mkroom *troom;
+    boolean prefilled, room_not_needed, irregular, joined;
+
+    if (!OV_pop_i(flags) ||
+	!OV_pop_i(rtype) ||
+	!OV_pop_i(rlit) ||
+	!OV_pop_r(area)) return;
+
+    prefilled = !(OV_i(flags) & (1 << 0));
+    irregular = (OV_i(flags) & (1 << 1));
+    joined = !(OV_i(flags) & (1 << 2));
+
+    if(OV_i(rtype) > MAXRTYPE) {
+	OV_i(rtype) -= MAXRTYPE+1;
+	prefilled = TRUE;
+    } else
+	prefilled = FALSE;
+
+    if(OV_i(rlit) < 0)
+	OV_i(rlit) = (rnd(1+abs(depth(&u.uz))) < 11 && rn2(77))
+	    ? TRUE : FALSE;
+
+    dx1 = SP_REGION_X1(OV_i(area));
+    dy1 = SP_REGION_Y1(OV_i(area));
+    dx2 = SP_REGION_X2(OV_i(area));
+    dy2 = SP_REGION_Y2(OV_i(area));
+
+    get_location(&dx1, &dy1, ANY_LOC, (struct mkroom *)0);
+    get_location(&dx2, &dy2, ANY_LOC, (struct mkroom *)0);
+
+    /* for an ordinary room, `prefilled' is a flag to force
+       an actual room to be created (such rooms are used to
+       control placement of migrating monster arrivals) */
+    room_not_needed = (OV_i(rtype) == OROOM &&
+		       !irregular && !prefilled);
+    if (room_not_needed || nroom >= MAXNROFROOMS) {
+	region tmpregion;
+	if (!room_not_needed)
+	    impossible("Too many rooms on new level!");
+	tmpregion.rlit = OV_i(rlit);
+	tmpregion.x1 = dx1;
+	tmpregion.y1 = dy1;
+	tmpregion.x2 = dx2;
+	tmpregion.y2 = dy2;
+	light_region(&tmpregion);
+
+	opvar_free(area);
+	opvar_free(flags);
+	opvar_free(rlit);
+	opvar_free(rtype);
+
+	return;
+    }
+
+    troom = &rooms[nroom];
+
+    /* mark rooms that must be filled, but do it later */
+    if (OV_i(rtype) != OROOM)
+	troom->needfill = (prefilled ? 2 : 1);
+
+    troom->needjoining = joined;
+
+    if (irregular) {
+	min_rx = max_rx = dx1;
+	min_ry = max_ry = dy1;
+	smeq[nroom] = nroom;
+	flood_fill_rm(dx1, dy1, nroom+ROOMOFFSET,
+		      OV_i(rlit), TRUE);
+	add_room(min_rx, min_ry, max_rx, max_ry,
+		 FALSE, OV_i(rtype), TRUE);
+	troom->rlit = OV_i(rlit);
+	troom->irregular = TRUE;
+    } else {
+	add_room(dx1, dy1, dx2, dy2,
+		 OV_i(rlit), OV_i(rtype), TRUE);
+#ifdef SPECIALIZATION
+	topologize(troom,FALSE);              /* set roomno */
+#else
+	topologize(troom);                    /* set roomno */
+#endif
+    }
+
+    if (!room_not_needed) {
+	if (coder->n_subroom > 1)
+	    impossible("region as subroom");
+	else {
+	    coder->tmproomlist[coder->n_subroom] = troom;
+	    coder->failed_room[coder->n_subroom] = FALSE;
+	    coder->n_subroom++;
+	}
+    }
+
+    opvar_free(area);
+    opvar_free(flags);
+    opvar_free(rlit);
+    opvar_free(rtype);
+}
+
+void
+spo_drawbridge(coder)
+     struct sp_coder *coder;
+{
+    xchar x,y;
+    struct opvar *dir, *db_open, *coord;
+
+    if (!OV_pop_i(dir) ||
+	!OV_pop_i(db_open) ||
+	!OV_pop_c(coord)) return;
+
+    get_location_coord(&x, &y, DRY|WET|HOT, coder->croom, OV_i(coord));
+    if (!create_drawbridge(x, y, OV_i(dir), OV_i(db_open)))
+	impossible("Cannot create drawbridge.");
+    SpLev_Map[x][y] = 1;
+
+    opvar_free(coord);
+    opvar_free(db_open);
+    opvar_free(dir);
+}
+
+void
+spo_mazewalk(coder)
+     struct sp_coder *coder;
+{
+    xchar x,y;
+    struct opvar *ftyp, *fstocked,*fdir, *coord;
+    int dir;
+
+    if (!OV_pop_i(ftyp) ||
+	!OV_pop_i(fstocked) ||
+	!OV_pop_i(fdir) ||
+	!OV_pop_c(coord)) return;
+
+    dir = OV_i(fdir);
+
+    get_location_coord(&x, &y, ANY_LOC, coder->croom, OV_i(coord));
+    if (!isok(x,y)) return;
+
+    if (OV_i(ftyp) < 1) {
+#ifndef WALLIFIED_MAZE
+	OV_i(ftyp) = CORR;
+#else
+	OV_i(ftyp) = ROOM;
+#endif
+    }
+
+    /* don't use move() - it doesn't use W_NORTH, etc. */
+    switch (dir) {
+    case W_NORTH: --y; break;
+    case W_SOUTH: y++; break;
+    case W_EAST:  x++; break;
+    case W_WEST:  --x; break;
+    default:
+	impossible("sp_level_coder: Bad MAZEWALK direction");
+    }
+
+    if(!IS_DOOR(levl[x][y].typ)) {
+	levl[x][y].typ = OV_i(ftyp);
+	levl[x][y].flags = 0;
+    }
 
     /*
-     * If bounds_nodigpass, and no mazewalks, mark all locations outside
-     * the map are mapped as nodig and nopass as well.  This avoids passwall
-     * monsters like Xorns from appearing outside the accessible area.
+     * We must be sure that the parity of the coordinates for
+     * walkfrom() is odd.  But we must also take into account
+     * what direction was chosen.
      */
-    if (bounds_nodigpass && !nwalk_sav) {
-	for(x = 1; x < COLNO; x++)
-	    for(y = 0; y < ROWNO; y++)
-	    if(!Map[x][y])
-		levl[x][y].wall_info |= W_NONDIGGABLE|W_NONPASSWALL;
+    if(!(x % 2)) {
+	if (dir == W_EAST)
+	    x++;
+	else
+	    x--;
+
+	/* no need for IS_DOOR check; out of map bounds */
+	levl[x][y].typ = OV_i(ftyp);
+	levl[x][y].flags = 0;
+    }
+
+    if (!(y % 2)) {
+	if (dir == W_SOUTH)
+	    y++;
+	else
+	    y--;
+    }
+
+    walkfrom(x, y, OV_i(ftyp));
+    if (OV_i(fstocked)) fill_empty_maze();
+
+    opvar_free(coord);
+    opvar_free(fdir);
+    opvar_free(fstocked);
+    opvar_free(ftyp);
+}
+
+void
+spo_wall_property(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *r;
+    xchar dx1,dy1,dx2,dy2;
+    int wprop = (coder->opcode == SPO_NON_DIGGABLE) ? W_NONDIGGABLE : W_NONPASSWALL;
+
+    if (!OV_pop_r(r)) return;
+
+    dx1 = SP_REGION_X1(OV_i(r));
+    dy1 = SP_REGION_Y1(OV_i(r));
+    dx2 = SP_REGION_X2(OV_i(r));
+    dy2 = SP_REGION_Y2(OV_i(r));
+
+    get_location(&dx1, &dy1, ANY_LOC, (struct mkroom *)0);
+    get_location(&dx2, &dy2, ANY_LOC, (struct mkroom *)0);
+
+    set_wall_property(dx1, dy1, dx2, dy2, wprop);
+
+    opvar_free(r);
+}
+
+void
+spo_room_door(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *wall, *secret, *mask, *pos;
+    room_door tmpd;
+
+    if (!OV_pop_i(wall) ||
+	!OV_pop_i(secret) ||
+	!OV_pop_i(mask) ||
+	!OV_pop_i(pos) ||
+	!coder->croom) return;
+
+    tmpd.secret = OV_i(secret);
+    tmpd.mask = OV_i(mask);
+    tmpd.pos = OV_i(pos);
+    tmpd.wall = OV_i(wall);
+
+    create_door(&tmpd, coder->croom);
+
+    opvar_free(wall);
+    opvar_free(secret);
+    opvar_free(mask);
+    opvar_free(pos);
+}
+
+void
+sel_set_wallify(x,y,arg)
+     int x, y;
+     genericptr_t arg;
+{
+    wallify_map(x,y, x,y);
+}
+
+void
+spo_wallify(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *typ, *r;
+    int dx1,dy1,dx2,dy2;
+    if (!OV_pop_i(typ)) return;
+    switch (OV_i(typ)) {
+    default:
+    case 0:
+	{
+	    if (!OV_pop_r(r)) return;
+	    dx1 = (xchar)SP_REGION_X1(OV_i(r));
+	    dy1 = (xchar)SP_REGION_Y1(OV_i(r));
+	    dx2 = (xchar)SP_REGION_X2(OV_i(r));
+	    dy2 = (xchar)SP_REGION_Y2(OV_i(r));
+	    wallify_map(dx1 < 0 ? xstart : dx1,
+			dy1 < 0 ? ystart : dy1,
+			dx2 < 0 ? xstart+xsize : dx2,
+			dy2 < 0 ? ystart+ysize : dy2);
+	}
+	break;
+    case 1:
+	{
+	    if (!OV_pop_typ(r, SPOVAR_SEL)) return;
+	    selection_iterate(r, sel_set_wallify, NULL);
+	}
+	break;
+    }
+    opvar_free(r);
+}
+
+void
+spo_map(coder)
+     struct sp_coder *coder;
+{
+    mazepart tmpmazepart;
+    struct opvar *mpxs, *mpys, *mpmap, *mpa, *mpkeepr, *mpzalign;
+    xchar halign, valign;
+    xchar tmpxstart, tmpystart, tmpxsize, tmpysize;
+    int tryct = 0;
+    unpacked_coord upc;
+
+    if (!OV_pop_i(mpxs) ||
+	!OV_pop_i(mpys) ||
+	!OV_pop_s(mpmap) ||
+	!OV_pop_i(mpkeepr) ||
+	!OV_pop_i(mpzalign) ||
+	!OV_pop_c(mpa)) return;
+
+redo_maploc:
+
+    tmpmazepart.xsize = OV_i(mpxs);
+    tmpmazepart.ysize = OV_i(mpys);
+    tmpmazepart.zaligntyp = OV_i(mpzalign);
+
+    upc = get_unpacked_coord(OV_i(mpa), ANY_LOC);
+    tmpmazepart.halign = upc.x;
+    tmpmazepart.valign = upc.y;
+
+    tmpxsize = xsize; tmpysize = ysize;
+    tmpxstart = xstart; tmpystart = ystart;
+
+    halign = tmpmazepart.halign;
+    valign = tmpmazepart.valign;
+    xsize = tmpmazepart.xsize;
+    ysize = tmpmazepart.ysize;
+    switch (tmpmazepart.zaligntyp) {
+    default:
+    case 0:
+	break;
+    case 1:
+	switch((int) halign) {
+	case LEFT:	    xstart = 3;					break;
+	case H_LEFT:    xstart = 2+((x_maze_max-2-xsize)/4);	break;
+	case CENTER:    xstart = 2+((x_maze_max-2-xsize)/2);	break;
+	case H_RIGHT:   xstart = 2+((x_maze_max-2-xsize)*3/4);	break;
+	case RIGHT:     xstart = x_maze_max-xsize-1;		break;
+	}
+	switch((int) valign) {
+	case TOP:	    ystart = 3;					break;
+	case CENTER:    ystart = 2+((y_maze_max-2-ysize)/2);	break;
+	case BOTTOM:    ystart = y_maze_max-ysize-1;		break;
+	}
+	if (!(xstart % 2)) xstart++;
+	if (!(ystart % 2)) ystart++;
+	break;
+    case 2:
+	if (!coder->croom) {
+	    xstart = 1;
+	    ystart = 0;
+	    xsize = COLNO-1-tmpmazepart.xsize;
+	    ysize = ROWNO-tmpmazepart.ysize;
+	}
+	get_location_coord(&halign, &valign, ANY_LOC, coder->croom, OV_i(mpa));
+	xsize = tmpmazepart.xsize;
+	ysize = tmpmazepart.ysize;
+	xstart = halign;
+	ystart = valign;
+	break;
+    }
+    if ((ystart < 0) || (ystart + ysize > ROWNO)) {
+	/* try to move the start a bit */
+	ystart += (ystart > 0) ? -2 : 2;
+	if(ysize == ROWNO) ystart = 0;
+	if(ystart < 0 || ystart + ysize > ROWNO)
+	    panic("reading special level with ysize too large");
+    }
+    if (xsize <= 1 && ysize <= 1) {
+	xstart = 1;
+	ystart = 0;
+	xsize = COLNO-1;
+	ysize = ROWNO;
+    } else {
+	xchar x,y;
+	/* Load the map */
+	for(y = ystart; y < ystart+ysize; y++)
+	    for(x = xstart; x < xstart+xsize; x++) {
+		xchar mptyp = (mpmap->vardata.str[(y-ystart) * xsize + (x-xstart)] - 1);
+		if (mptyp >= MAX_TYPE) continue;
+		levl[x][y].typ = mptyp;
+		levl[x][y].lit = FALSE;
+		/* clear out levl: load_common_data may set them */
+		levl[x][y].flags = 0;
+		levl[x][y].horizontal = 0;
+		levl[x][y].roomno = 0;
+		levl[x][y].edge = 0;
+		/*
+		 *  Set secret doors to closed (why not trapped too?).  Set
+		 *  the horizontal bit.
+		 */
+		if (levl[x][y].typ == SDOOR || IS_DOOR(levl[x][y].typ)) {
+		    if(levl[x][y].typ == SDOOR)
+			levl[x][y].doormask = D_CLOSED;
+		    /*
+		     *  If there is a wall to the left that connects to a
+		     *  (secret) door, then it is horizontal.  This does
+		     *  not allow (secret) doors to be corners of rooms.
+		     */
+		    if (x != xstart && (IS_WALL(levl[x-1][y].typ) ||
+					levl[x-1][y].horizontal))
+			levl[x][y].horizontal = 1;
+		} else if(levl[x][y].typ == HWALL ||
+			  levl[x][y].typ == IRONBARS)
+		    levl[x][y].horizontal = 1;
+		else if(levl[x][y].typ == LAVAPOOL)
+		    levl[x][y].lit = 1;
+	    }
+	if (coder->lvl_is_joined)
+	    remove_rooms(xstart, ystart, xstart+xsize, ystart+ysize);
+    }
+    if (!OV_i(mpkeepr)) {
+	xstart = tmpxstart; ystart = tmpystart;
+	xsize = tmpxsize; ysize = tmpysize;
+    }
+
+skipmap:
+    opvar_free(mpxs);
+    opvar_free(mpys);
+    opvar_free(mpmap);
+    opvar_free(mpa);
+    opvar_free(mpkeepr);
+    opvar_free(mpzalign);
+}
+
+void
+spo_jmp(coder, lvl)
+     struct sp_coder *coder;
+     sp_lev *lvl;
+{
+    struct opvar *tmpa;
+    long a;
+    if (!OV_pop_i(tmpa)) return;
+    a = sp_code_jmpaddr(coder->frame->n_opcode, (OV_i(tmpa) - 1));
+    if ((a >= 0) && (a < lvl->n_opcodes) &&
+	(a != coder->frame->n_opcode))
+	coder->frame->n_opcode = a;
+    opvar_free(tmpa);
+}
+
+void
+spo_conditional_jump(coder,lvl)
+     struct sp_coder *coder;
+     sp_lev *lvl;
+{
+    struct opvar *oa, *oc;
+    long a,c;
+    int test = 0;
+    if (!OV_pop_i(oa) || !OV_pop_i(oc)) return;
+
+    a = sp_code_jmpaddr(coder->frame->n_opcode, (OV_i(oa) - 1));
+    c = OV_i(oc);
+
+    switch (coder->opcode) {
+    default: impossible("spo_conditional_jump: illegal opcode"); break;
+    case SPO_JL:  test = (c & SP_CPUFLAG_LT); break;
+    case SPO_JLE: test = (c & (SP_CPUFLAG_LT|SP_CPUFLAG_EQ)); break;
+    case SPO_JG:  test = (c & SP_CPUFLAG_GT); break;
+    case SPO_JGE: test = (c & (SP_CPUFLAG_GT|SP_CPUFLAG_EQ)); break;
+    case SPO_JE:  test = (c & SP_CPUFLAG_EQ); break;
+    case SPO_JNE: test = (c & ~SP_CPUFLAG_EQ); break;
+    }
+
+    if ((test) && (a >= 0) &&
+	(a < lvl->n_opcodes) &&
+	(a != coder->frame->n_opcode))
+	coder->frame->n_opcode = a;
+
+    opvar_free(oa);
+    opvar_free(oc);
+}
+
+
+void
+spo_var_init(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *vname;
+    struct opvar *arraylen;
+    struct opvar *vvalue;
+    struct splev_var *tmpvar;
+    struct splev_var *tmp2;
+    long idx;
+
+    OV_pop_s(vname);
+    OV_pop_i(arraylen);
+
+    if (!vname || !arraylen)
+	panic("no values for SPO_VAR_INIT");
+
+    tmpvar = opvar_var_defined(coder, OV_s(vname));
+
+    if (tmpvar) {
+	/* variable redefinition */
+	if (OV_i(arraylen) < 0) {
+	    /* copy variable */
+	    if (tmpvar->array_len) {
+		idx = tmpvar->array_len;
+		while (idx-- > 0) {
+		    opvar_free(tmpvar->data.arrayvalues[idx]);
+		}
+		Free(tmpvar->data.arrayvalues);
+	    } else {
+		opvar_free(tmpvar->data.value);
+	    }
+	    tmpvar->data.arrayvalues = NULL;
+	    goto copy_variable;
+	} else if (OV_i(arraylen)) {
+	    /* redefined array */
+	    idx = tmpvar->array_len;
+	    while (idx-- > 0) {
+		opvar_free(tmpvar->data.arrayvalues[idx]);
+	    }
+	    Free(tmpvar->data.arrayvalues);
+	    tmpvar->data.arrayvalues = NULL;
+	    goto create_new_array;
+	} else {
+	    /* redefined single value */
+	    OV_pop(vvalue);
+	    if (tmpvar->svtyp != vvalue->spovartyp) panic("redefining variable as different type");
+	    opvar_free(tmpvar->data.value);
+	    tmpvar->data.value = vvalue;
+	    tmpvar->array_len = 0;
+	}
+    } else {
+	/* new variable definition */
+	tmpvar = (struct splev_var *)malloc(sizeof(struct splev_var));
+	if (!tmpvar) panic("newvar tmpvar alloc");
+	tmpvar->next = coder->frame->variables;
+	tmpvar->name = strdup(OV_s(vname));
+	coder->frame->variables = tmpvar;
+
+	if (OV_i(arraylen) < 0) {
+	    /* copy variable */
+copy_variable:
+	    OV_pop(vvalue);
+	    tmp2 = opvar_var_defined(coder, OV_s(vvalue));
+	    if (!tmp2) panic("no copyable var");
+	    tmpvar->svtyp = tmp2->svtyp;
+	    tmpvar->array_len = tmp2->array_len;
+	    if (tmpvar->array_len) {
+		idx = tmpvar->array_len;
+		tmpvar->data.arrayvalues = (struct opvar **)malloc(sizeof(struct opvar *) * idx);
+		if (!tmpvar->data.arrayvalues) panic("tmpvar->data.arrayvalues alloc");
+		while (idx-- > 0) {
+		    tmpvar->data.arrayvalues[idx] = opvar_clone(tmp2->data.arrayvalues[idx]);
+		}
+	    } else {
+		tmpvar->data.value = opvar_clone(tmp2->data.value);
+	    }
+	    opvar_free(vvalue);
+	} else if (OV_i(arraylen)) {
+	    /* new array */
+create_new_array:
+	    idx = OV_i(arraylen);
+	    tmpvar->array_len = idx;
+	    tmpvar->data.arrayvalues = (struct opvar **)malloc(sizeof(struct opvar *) * idx);
+	    if (!tmpvar->data.arrayvalues) panic("malloc tmpvar->data.arrayvalues");
+	    while (idx-- > 0) {
+		OV_pop(vvalue);
+		if (!vvalue) panic("no value for arrayvariable");
+		tmpvar->data.arrayvalues[idx] = vvalue;
+	    }
+	    tmpvar->svtyp = SPOVAR_ARRAY;
+	} else {
+	    /* new single value */
+	    OV_pop(vvalue);
+	    if (!vvalue) panic("no value for variable");
+	    tmpvar->svtyp = OV_typ(vvalue);
+	    tmpvar->data.value = vvalue;
+	    tmpvar->array_len = 0;
+	}
+    }
+
+    opvar_free(vname);
+    opvar_free(arraylen);
+}
+
+
+long
+opvar_array_length(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *vname;
+    struct splev_var *tmp;
+    long len = 0;
+
+    if (!coder) return 0;
+
+    vname = splev_stack_pop(coder->stack);
+    if (!vname) return 0;
+    if (vname->spovartyp != SPOVAR_VARIABLE) goto pass;
+
+    tmp = coder->frame->variables;
+    while (tmp) {
+	if (!strcmp(tmp->name, OV_s(vname))) {
+	    if ((tmp->svtyp & SPOVAR_ARRAY)) {
+		len = tmp->array_len;
+		if (len < 1) len = 0;
+	    }
+	    goto pass;
+	}
+	tmp = tmp->next;
+    }
+
+pass:
+    opvar_free(vname);
+    return len;
+}
+
+
+void
+spo_shuffle_array(coder)
+     struct sp_coder *coder;
+{
+    struct opvar *vname;
+    struct splev_var *tmp;
+    struct opvar *tmp2;
+    long i,j;
+
+    if (!OV_pop_s(vname)) return;
+
+    tmp = opvar_var_defined(coder, OV_s(vname));
+    if (!tmp || (tmp->array_len < 1)) {
+	opvar_free(vname);
+	return;
+    }
+    for (i = tmp->array_len - 1; i > 0; i--) {
+	if ((j = rn2(i + 1)) == i) continue;
+	tmp2 = tmp->data.arrayvalues[j];
+	tmp->data.arrayvalues[j] = tmp->data.arrayvalues[i];
+	tmp->data.arrayvalues[i] = tmp2;
+    }
+
+    opvar_free(vname);
+}
+
+
+
+/* Special level coder, creates the special level from the sp_lev codes.
+ * Does not free the allocated memory.
+ */
+STATIC_OVL boolean
+sp_level_coder(lvl)
+sp_lev *lvl;
+{
+    unsigned long exec_opcodes = 0;
+    int     tmpi;
+    long room_stack = 0;
+    unsigned long max_execution = SPCODER_MAX_RUNTIME;
+    struct sp_coder *coder = (struct sp_coder *)alloc(sizeof(struct sp_coder));
+    if (!coder) panic("coder alloc");
+    coder->frame = frame_new(0);
+    coder->stack = NULL;
+    coder->premapped = FALSE;
+    /*coder->allow_flips = 3;*/
+    coder->croom = NULL;
+    coder->n_subroom = 1;
+    coder->exit_script = FALSE;
+    coder->lvl_is_joined = 0;
+
+    if (wizard) {
+	char *met = nh_getenv("SPCODER_MAX_RUNTIME");
+	if (met && met[0] == '1') max_execution = (1<<30) - 1;
+    }
+
+    for (tmpi = 0; tmpi <= MAX_NESTED_ROOMS; tmpi++) {
+	coder->tmproomlist[tmpi] = (struct mkroom *)0;
+	coder->failed_room[tmpi] = FALSE;
+    }
+
+    shuffle_alignments();
+
+    for (tmpi = 0; tmpi < MAX_CONTAINMENT; tmpi++) container_obj[tmpi] = NULL;
+    container_idx = 0;
+
+    invent_carrying_monster = NULL;
+
+    (void) memset((genericptr_t)&SpLev_Map[0][0], 0, sizeof SpLev_Map);
+
+    level.flags.is_maze_lev = 0;
+
+    xstart = 1;
+    ystart = 0;
+    xsize = COLNO-1;
+    ysize = ROWNO;
+
+    while (coder->frame->n_opcode < lvl->n_opcodes && !coder->exit_script) {
+	coder->opcode = lvl->opcodes[coder->frame->n_opcode].opcode;
+	coder->opdat = lvl->opcodes[coder->frame->n_opcode].opdat;
+
+	coder->stack = coder->frame->stack;
+
+	if (exec_opcodes++ > max_execution) {
+	    impossible("Level script is taking too much time, stopping.");
+	    coder->exit_script = TRUE;
+	}
+
+	if (coder->failed_room[coder->n_subroom-1] &&
+	    coder->opcode != SPO_ENDROOM &&
+	    coder->opcode != SPO_ROOM &&
+	    coder->opcode != SPO_SUBROOM) goto next_opcode;
+
+	coder->croom = coder->tmproomlist[coder->n_subroom-1];
+
+	switch (coder->opcode) {
+        case SPO_NULL: break;
+	case SPO_EXIT: coder->exit_script = TRUE; break;
+	case SPO_FRAME_PUSH: spo_frame_push(coder); break;
+	case SPO_FRAME_POP:  spo_frame_pop(coder); break;
+	case SPO_CALL:       spo_call(coder); break;
+	case SPO_RETURN:     spo_return(coder); break;
+	case SPO_END_MONINVENT: spo_end_moninvent(coder); break;
+	case SPO_POP_CONTAINER: spo_pop_container(coder); break;
+	case SPO_POP:
+	    {
+		struct opvar *ov = splev_stack_pop(coder->stack);
+		opvar_free(ov);
+	    }
+	    break;
+	case SPO_PUSH: splev_stack_push(coder->stack, opvar_clone(coder->opdat)); break;
+	case SPO_MESSAGE:        spo_message(coder);        break;
+	case SPO_MONSTER:        spo_monster(coder);        break;
+	case SPO_OBJECT:         spo_object(coder);         break;
+	case SPO_LEVEL_FLAGS:    spo_level_flags(coder);    break;
+	case SPO_INITLEVEL:      spo_initlevel(coder);      break;
+	    /*case SPO_MON_GENERATION: spo_mon_generation(coder); break;*/
+	    /*case SPO_LEVEL_SOUNDS:   spo_level_sounds(coder);   break;*/
+	case SPO_ENGRAVING:      spo_engraving(coder);      break;
+	case SPO_MINERALIZE:     spo_mineralize(coder);     break;
+	case SPO_SUBROOM:
+	case SPO_ROOM:
+	    if (!coder->failed_room[coder->n_subroom-1]) {
+		spo_room(coder);
+	    } else room_stack++;
+	    break;
+	case SPO_ENDROOM:
+	    if (coder->failed_room[coder->n_subroom-1]) {
+		if (!room_stack)
+		    spo_endroom(coder);
+		else
+		    room_stack--;
+	    } else {
+		spo_endroom(coder);
+	    }
+	    break;
+	case SPO_DOOR:           spo_door(coder);           break;
+	case SPO_STAIR:          spo_stair(coder);          break;
+	case SPO_LADDER:         spo_ladder(coder);         break;
+	case SPO_GRAVE:          spo_grave(coder);          break;
+	case SPO_ALTAR:          spo_altar(coder);          break;
+	case SPO_SINK:
+	case SPO_POOL:
+	case SPO_FOUNTAIN:       spo_feature(coder);        break;
+	    /*case SPO_WALLWALK:       spo_wallwalk(coder);        break;*/
+	case SPO_TRAP:           spo_trap(coder);           break;
+	case SPO_GOLD:           spo_gold(coder);           break;
+	case SPO_CORRIDOR:       spo_corridor(coder);       break;
+	case SPO_TERRAIN:        spo_terrain(coder);        break;
+	case SPO_REPLACETERRAIN: spo_replace_terrain(coder); break;
+	    /*case SPO_SPILL:          spo_spill(coder);    break;*/
+	case SPO_LEVREGION:      spo_levregion(coder); break;
+	case SPO_REGION:         spo_region(coder);    break;
+	case SPO_DRAWBRIDGE:      spo_drawbridge(coder);  break;
+	case SPO_MAZEWALK:        spo_mazewalk(coder);    break;
+	case SPO_NON_PASSWALL:
+	case SPO_NON_DIGGABLE:    spo_wall_property(coder);   break;
+	case SPO_ROOM_DOOR:       spo_room_door(coder);    break;
+	case SPO_WALLIFY:         spo_wallify(coder);    break;
+	case SPO_COPY:
+	    {
+		struct opvar *a = splev_stack_pop(coder->stack);
+		splev_stack_push(coder->stack, opvar_clone(a));
+		splev_stack_push(coder->stack, opvar_clone(a));
+		opvar_free(a);
+	    }
+	    break;
+	case SPO_DEC:
+	    {
+		struct opvar *a;
+		if (!OV_pop_i(a)) break;
+		OV_i(a)--;
+		splev_stack_push(coder->stack, a);
+	    }
+	    break;
+	case SPO_INC:
+	    {
+		struct opvar *a;
+		if (!OV_pop_i(a)) break;
+		OV_i(a)++;
+		splev_stack_push(coder->stack, a);
+	    }
+	    break;
+	case SPO_MATH_SIGN:
+	    {
+		struct opvar *a;
+		if (!OV_pop_i(a)) break;
+		OV_i(a) = ((OV_i(a) < 0) ? -1 : ((OV_i(a) > 0) ? 1 : 0));
+		splev_stack_push(coder->stack, a);
+	    }
+	    break;
+	case SPO_MATH_ADD:
+	    {
+		struct opvar *a, *b;
+		if (!OV_pop(b) || !OV_pop(a)) break;
+		if (OV_typ(b) == OV_typ(a)) {
+		    if (OV_typ(a) == SPOVAR_INT) {
+			OV_i(a) = OV_i(a) + OV_i(b);
+			splev_stack_push(coder->stack, a);
+			opvar_free(b);
+		    } else if (OV_typ(a) == SPOVAR_STRING) {
+			char *tmpbuf = (char *)alloc(strlen(OV_s(a)) + strlen(OV_s(b)) + 1);
+			if (tmpbuf) {
+			    struct opvar *c;
+			    (void) sprintf(tmpbuf, "%s%s", OV_s(a), OV_s(b));
+			    c = opvar_new_str(tmpbuf);
+			    splev_stack_push(coder->stack, c);
+			    opvar_free(a);
+			    opvar_free(b);
+			    Free(tmpbuf);
+			} else {
+			    splev_stack_push(coder->stack, a);
+			    opvar_free(b);
+			    impossible("malloc at str concat");
+			}
+		    } else {
+			splev_stack_push(coder->stack, a);
+			opvar_free(b);
+			impossible("adding weird types");
+		    }
+		} else {
+		    splev_stack_push(coder->stack, a);
+		    opvar_free(b);
+		    impossible("adding different types");
+		}
+	    }
+	    break;
+	case SPO_MATH_SUB:
+	    {
+		struct opvar *a, *b;
+		if (!OV_pop_i(b) || !OV_pop_i(a)) break;
+		OV_i(a) = OV_i(a) - OV_i(b);
+		splev_stack_push(coder->stack, a);
+		opvar_free(b);
+	    }
+	    break;
+	case SPO_MATH_MUL:
+	    {
+		struct opvar *a, *b;
+		if (!OV_pop_i(b) || !OV_pop_i(a)) break;
+		OV_i(a) = OV_i(a) * OV_i(b);
+		splev_stack_push(coder->stack, a);
+		opvar_free(b);
+	    }
+	    break;
+	case SPO_MATH_DIV:
+	    {
+		struct opvar *a, *b;
+		if (!OV_pop_i(b) || !OV_pop_i(a)) break;
+		if (OV_i(b) >= 1) {
+		    OV_i(a) = OV_i(a) / OV_i(b);
+		} else {
+		    OV_i(a) = 0;
+		}
+		splev_stack_push(coder->stack, a);
+		opvar_free(b);
+	    }
+	    break;
+	case SPO_MATH_MOD:
+	    {
+		struct opvar *a, *b;
+		if (!OV_pop_i(b) || !OV_pop_i(a)) break;
+		if (OV_i(b) > 0) {
+		    OV_i(a) = OV_i(a) % OV_i(b);
+		} else {
+		    OV_i(a) = 0;
+		}
+		splev_stack_push(coder->stack, a);
+		opvar_free(b);
+	    }
+	    break;
+        case SPO_CMP:
+	    {
+		struct opvar *a;
+		struct opvar *b;
+		struct opvar *c;
+		long val = 0;
+
+		OV_pop(b);
+		OV_pop(a);
+
+		if (!a || !b) {
+		    impossible("spo_cmp: no values in stack");
+		    break;
+		}
+
+		if (OV_typ(a) != OV_typ(b)) {
+		    impossible("spo_cmp: trying to compare differing datatypes");
+		    break;
+		}
+
+		switch (OV_typ(a)) {
+		case SPOVAR_COORD:
+		case SPOVAR_REGION:
+		case SPOVAR_MAPCHAR:
+		case SPOVAR_MONST:
+		case SPOVAR_OBJ:
+		case SPOVAR_INT:
+		    if (OV_i(b) > OV_i(a)) val |= SP_CPUFLAG_LT;
+		    if (OV_i(b) < OV_i(a)) val |= SP_CPUFLAG_GT;
+		    if (OV_i(b) == OV_i(a)) val |= SP_CPUFLAG_EQ;
+		    c = opvar_new_int(val);
+		    break;
+		case SPOVAR_STRING:
+		    c = opvar_new_int(((!strcmp(OV_s(b), OV_s(a))) ? SP_CPUFLAG_EQ : 0));
+		    break;
+		default:
+		    c = opvar_new_int(0);
+		    break;
+		}
+		splev_stack_push(coder->stack, c);
+		opvar_free(a);
+		opvar_free(b);
+	    }
+	    break;
+        case SPO_JMP:
+	    spo_jmp(coder, lvl); break;
+        case SPO_JL:
+        case SPO_JLE:
+        case SPO_JG:
+        case SPO_JGE:
+        case SPO_JE:
+        case SPO_JNE:
+	    spo_conditional_jump(coder, lvl); break;
+	case SPO_RN2:
+	    {
+		struct opvar *tmpv;
+		struct opvar *t;
+		if (!OV_pop_i(tmpv)) break;
+		t = opvar_new_int((OV_i(tmpv) > 1) ? rn2(OV_i(tmpv)) : 0);
+		splev_stack_push(coder->stack, t);
+		opvar_free(tmpv);
+	    }
+         break;
+	 /*
+	case SPO_COREFUNC:
+	    {
+		struct opvar *a;
+		if (!OV_pop_i(a)) break;
+		spo_corefunc(coder, OV_i(a));
+	    }
+	    break;
+	 */
+	case SPO_DICE:
+	    {
+		struct opvar *a, *b, *t;
+		if (!OV_pop_i(b) || !OV_pop_i(a)) break;
+		if (OV_i(b) < 1) OV_i(b) = 1;
+		if (OV_i(a) < 1) OV_i(a) = 1;
+		t = opvar_new_int(d(OV_i(a), OV_i(b)));
+		splev_stack_push(coder->stack, t);
+		opvar_free(a);
+		opvar_free(b);
+	    }
+	    break;
+	case SPO_MAP:
+	    spo_map(coder); break;
+	case SPO_VAR_INIT:
+	    spo_var_init(coder); break;
+	case SPO_SHUFFLE_ARRAY:
+	    spo_shuffle_array(coder); break;
+	case SPO_SEL_ADD: /* actually, logical or */
+	    {
+		struct opvar *sel1, *sel2, *pt;
+		if (!OV_pop_typ(sel1, SPOVAR_SEL)) panic("no sel1 for add");
+		if (!OV_pop_typ(sel2, SPOVAR_SEL)) panic("no sel1 for add");
+		pt = selection_logical_oper(sel1, sel2, '|');
+		opvar_free(sel1);
+		opvar_free(sel2);
+		splev_stack_push(coder->stack, pt);
+	    }
+	    break;
+	case SPO_SEL_COMPLEMENT:
+	    {
+		struct opvar *sel, *pt;
+		if (!OV_pop_typ(sel, SPOVAR_SEL)) panic("no sel for not");
+		pt = selection_not(sel);
+		opvar_free(sel);
+		splev_stack_push(coder->stack, pt);
+	    }
+	    break;
+	case SPO_SEL_FILTER: /* sorta like logical and */
+	    {
+		struct opvar *filtertype;
+		if (!OV_pop_i(filtertype)) panic("no sel filter type");
+		switch (OV_i(filtertype)) {
+		case SPOFILTER_PERCENT:
+		    {
+			struct opvar *tmp1, *sel;
+			if (!OV_pop_i(tmp1)) panic("no sel filter percent");
+			if (!OV_pop_typ(sel, SPOVAR_SEL)) panic("no sel filter");
+			selection_filter_percent(sel, OV_i(tmp1));
+			splev_stack_push(coder->stack, sel);
+			opvar_free(tmp1);
+		    }
+		    break;
+		case SPOFILTER_SELECTION: /* logical and */
+		    {
+			struct opvar *pt, *sel1, *sel2;
+			if (!OV_pop_typ(sel1, SPOVAR_SEL)) panic("no sel filter sel1");
+			if (!OV_pop_typ(sel2, SPOVAR_SEL)) panic("no sel filter sel2");
+			pt = selection_logical_oper(sel1, sel2, '&');
+			splev_stack_push(coder->stack, pt);
+			opvar_free(sel1);
+			opvar_free(sel2);
+		    }
+		    break;
+		case SPOFILTER_MAPCHAR:
+		    {
+			struct opvar *pt, *tmp1, *sel;
+			if (!OV_pop_typ(sel, SPOVAR_SEL)) panic("no sel filter");
+			if (!OV_pop_typ(tmp1, SPOVAR_MAPCHAR)) panic("no sel filter mapchar");
+			pt = selection_filter_mapchar(sel, tmp1);
+			splev_stack_push(coder->stack, pt);
+			opvar_free(tmp1);
+			opvar_free(sel);
+		    }
+		    break;
+		default: panic("unknown sel filter type");
+		}
+		opvar_free(filtertype);
+	    }
+	    break;
+	case SPO_SEL_POINT:
+	    {
+		struct opvar *tmp;
+		struct opvar *pt = selection_opvar(NULL);
+		schar x,y;
+		if (!OV_pop_c(tmp)) panic("no ter sel coord");
+		get_location_coord(&x, &y, ANY_LOC, coder->croom, OV_i(tmp));
+		selection_setpoint(x,y, pt, 1);
+		splev_stack_push(coder->stack, pt);
+		opvar_free(tmp);
+	    }
+	    break;
+	case SPO_SEL_RECT:
+	case SPO_SEL_FILLRECT:
+	    {
+		struct opvar *tmp, *pt = selection_opvar(NULL);
+		schar x,y,x1,y1,x2,y2;
+		if (!OV_pop_r(tmp)) panic("no ter sel region");
+		x1 = min(SP_REGION_X1(OV_i(tmp)), SP_REGION_X2(OV_i(tmp)));
+		y1 = min(SP_REGION_Y1(OV_i(tmp)), SP_REGION_Y2(OV_i(tmp)));
+		x2 = max(SP_REGION_X1(OV_i(tmp)), SP_REGION_X2(OV_i(tmp)));
+		y2 = max(SP_REGION_Y1(OV_i(tmp)), SP_REGION_Y2(OV_i(tmp)));
+		get_location(&x1, &y1, ANY_LOC, coder->croom);
+		get_location(&x2, &y2, ANY_LOC, coder->croom);
+		x1 = (x1 < 0) ? 0 : x1;
+		y1 = (y1 < 0) ? 0 : y1;
+		x2 = (x2 >= COLNO) ? COLNO-1 : x2;
+		y2 = (y2 >= ROWNO) ? ROWNO-1 : y2;
+		if (coder->opcode == SPO_SEL_RECT) {
+		    for (x = x1; x <= x2; x++) {
+			selection_setpoint(x,y1, pt, 1);
+			selection_setpoint(x,y2, pt, 1);
+		    }
+		    for (y = y1; y <= y2; y++) {
+			selection_setpoint(x1,y, pt, 1);
+			selection_setpoint(x2,y, pt, 1);
+		    }
+		} else {
+		    for (x = x1; x <= x2; x++)
+			for (y = y1; y <= y2; y++)
+			    selection_setpoint(x,y, pt, 1);
+		}
+		splev_stack_push(coder->stack, pt);
+		opvar_free(tmp);
+	    }
+	    break;
+	case SPO_SEL_LINE:
+	    {
+		struct opvar *tmp, *tmp2, *pt = selection_opvar(NULL);
+		schar x1,y1,x2,y2;
+		if (!OV_pop_c(tmp) || !OV_pop_c(tmp2)) panic("no ter sel linecoord");
+		get_location_coord(&x1, &y1, ANY_LOC, coder->croom, OV_i(tmp));
+		get_location_coord(&x2, &y2, ANY_LOC, coder->croom, OV_i(tmp2));
+		x1 = (x1 < 0) ? 0 : x1;
+		y1 = (y1 < 0) ? 0 : y1;
+		x2 = (x2 >= COLNO) ? COLNO-1 : x2;
+		y2 = (y2 >= ROWNO) ? ROWNO-1 : y2;
+		selection_do_line(x1,y1,x2,y2, pt);
+		splev_stack_push(coder->stack, pt);
+		opvar_free(tmp);
+		opvar_free(tmp2);
+	    }
+	    break;
+	case SPO_SEL_RNDLINE:
+	    {
+		struct opvar *tmp, *tmp2, *tmp3, *pt = selection_opvar(NULL);
+		schar x1,y1,x2,y2;
+		if (!OV_pop_i(tmp3) || !OV_pop_c(tmp) || !OV_pop_c(tmp2)) panic("no ter sel randline");
+		get_location_coord(&x1, &y1, ANY_LOC, coder->croom, OV_i(tmp));
+		get_location_coord(&x2, &y2, ANY_LOC, coder->croom, OV_i(tmp2));
+		x1 = (x1 < 0) ? 0 : x1;
+		y1 = (y1 < 0) ? 0 : y1;
+		x2 = (x2 >= COLNO) ? COLNO-1 : x2;
+		y2 = (y2 >= ROWNO) ? ROWNO-1 : y2;
+		selection_do_randline(x1,y1,x2,y2, OV_i(tmp3), 12, pt);
+		splev_stack_push(coder->stack, pt);
+		opvar_free(tmp);
+		opvar_free(tmp2);
+		opvar_free(tmp3);
+	    }
+	    break;
+	case SPO_SEL_GROW:
+	    {
+		struct opvar *dirs, *pt;
+		if (!OV_pop_i(dirs)) panic("no dirs for grow");
+		if (!OV_pop_typ(pt, SPOVAR_SEL)) panic("no selection for grow");
+		selection_do_grow(pt, OV_i(dirs));
+		splev_stack_push(coder->stack, pt);
+		opvar_free(dirs);
+	    }
+	    break;
+	case SPO_SEL_FLOOD:
+	    {
+		struct opvar *tmp;
+		schar x,y;
+		if (!OV_pop_c(tmp)) panic("no ter sel flood coord");
+		get_location_coord(&x, &y, ANY_LOC, coder->croom, OV_i(tmp));
+		if (isok(x,y)) {
+		    struct opvar *pt = selection_opvar(NULL);
+		    selection_floodfill(pt, x,y);
+		    splev_stack_push(coder->stack, pt);
+		}
+		opvar_free(tmp);
+	    }
+	    break;
+	case SPO_SEL_RNDCOORD:
+	    {
+		struct opvar *pt;
+		schar x,y;
+		if (!OV_pop_typ(pt, SPOVAR_SEL)) panic("no selection for rndcoord");
+		if (selection_rndcoord(pt, &x, &y)) {
+		    x -= xstart;
+		    y -= ystart;
+		}
+		/*get_location(&x, &y, DRY|WET, coder->croom);*/
+		splev_stack_push(coder->stack, opvar_new_coord(x,y));
+		opvar_free(pt);
+	    }
+	    break;
+	case SPO_SEL_ELLIPSE:
+	    {
+		struct opvar *filled, *xaxis, *yaxis, *pt;
+		struct opvar *sel = selection_opvar(NULL);
+		schar x,y;
+		if (!OV_pop_i(filled)) panic("no filled for ellipse");
+		if (!OV_pop_i(yaxis)) panic("no yaxis for ellipse");
+		if (!OV_pop_i(xaxis)) panic("no xaxis for ellipse");
+		if (!OV_pop_c(pt)) panic("no pt for ellipse");
+		get_location_coord(&x, &y, ANY_LOC, coder->croom, OV_i(pt));
+		selection_do_ellipse(sel, x,y, OV_i(xaxis), OV_i(yaxis), OV_i(filled));
+		splev_stack_push(coder->stack, sel);
+		opvar_free(filled);
+		opvar_free(yaxis);
+		opvar_free(xaxis);
+		opvar_free(pt);
+	    }
+	    break;
+	case SPO_SEL_GRADIENT:
+	    {
+		struct opvar *gtyp, *glim, *mind, *maxd, *coord, *coord2;
+		struct opvar *sel;
+		schar x,y, x2,y2;
+		if (!OV_pop_i(gtyp)) panic("no gtyp for grad");
+		if (!OV_pop_i(glim)) panic("no glim for grad");
+		if (!OV_pop_c(coord2)) panic("no coord2 for grad");
+		if (!OV_pop_c(coord)) panic("no coord for grad");
+		if (!OV_pop_i(maxd)) panic("no maxd for grad");
+		if (!OV_pop_i(mind)) panic("no mind for grad");
+		get_location_coord(&x, &y, ANY_LOC, coder->croom, OV_i(coord));
+		get_location_coord(&x2, &y2, ANY_LOC, coder->croom, OV_i(coord2));
+
+		sel = selection_opvar(NULL);
+		selection_do_gradient(sel, x,y, x2,y2, OV_i(gtyp), OV_i(mind), OV_i(maxd), OV_i(glim));
+		splev_stack_push(coder->stack, sel);
+
+		opvar_free(gtyp);
+		opvar_free(glim);
+		opvar_free(coord);
+		opvar_free(coord2);
+		opvar_free(maxd);
+		opvar_free(mind);
+	    }
+	    break;
+	default:
+	    panic("sp_level_coder: Unknown opcode %i", coder->opcode);
+	}
+
+next_opcode:
+	coder->frame->n_opcode++;
+    } /*while*/
+
+    fill_rooms();
+    remove_boundary_syms();
+    wallification(1, 0, COLNO-1, ROWNO-1);
+
+    /*flip_level_rnd(coder->allow_flips);*/
+
+    count_features();
+
+    if (coder->premapped) sokoban_detect();
+
+    if (coder->frame) {
+	struct sp_frame *tmpframe;
+	do {
+	    tmpframe = coder->frame->next;
+	    frame_del(coder->frame);
+	    coder->frame = tmpframe;
+	} while (coder->frame);
     }
 
     return TRUE;
@@ -2716,32 +5075,28 @@ load_special(name)
 const char *name;
 {
 	dlb *fd;
+	sp_lev *lvl = NULL;
 	boolean result = FALSE;
-	char c;
 	struct version_info vers_info;
 
 	fd = dlb_fopen(name, RDBMODE);
 	if (!fd) return FALSE;
-
 	Fread((genericptr_t) &vers_info, sizeof vers_info, 1, fd);
-	if (!check_version(&vers_info, name, TRUE))
+	if (!check_version(&vers_info, name, TRUE)) {
+	    (void)dlb_fclose(fd);
 	    goto give_up;
-
-	Fread((genericptr_t) &c, sizeof c, 1, fd); /* c Header */
-
-	switch (c) {
-		case SP_LEV_ROOMS:
-		    result = load_rooms(fd);
-		    break;
-		case SP_LEV_MAZE:
-		    result = load_maze(fd);
-		    break;
-		default:	/* ??? */
-		    result = FALSE;
 	}
- give_up:
+	lvl = (sp_lev *)alloc(sizeof(sp_lev));
+	if (!lvl) panic("alloc sp_lev");
+	result = sp_level_loader(fd, lvl);
 	(void)dlb_fclose(fd);
+	if (result) result = sp_level_coder(lvl);
+	sp_level_free(lvl);
+	Free(lvl);
+
+ give_up:
 	return result;
 }
 
+
 /*sp_lev.c*/
diff --git a/src/trap.c b/src/trap.c
index 36c1ee632..8fa07cbe4 100644
--- a/src/trap.c
+++ b/src/trap.c
@@ -3535,7 +3535,7 @@ boolean bury_it;
 	place_object(otmp, ttmp->tx, ttmp->ty);
 	if (bury_it) {
 	    /* magical digging first disarms this trap, then will unearth it */
-	    (void) bury_an_obj(otmp);
+	    (void) bury_an_obj(otmp, NULL);
 	} else {
 	    /* Sell your own traps only... */
 	    if (ttmp->madeby_u) sellobj(otmp, ttmp->tx, ttmp->ty);
diff --git a/util/lev_comp.l b/util/lev_comp.l
index 2b0ad5188..02ca2d4ee 100644
--- a/util/lev_comp.l
+++ b/util/lev_comp.l
@@ -66,16 +66,36 @@ int FDECL(yyoutput, (int));
 void FDECL(init_yyin, (FILE *));
 void FDECL(init_yyout, (FILE *));
 
+long NDECL(handle_varstring_check);
+long FDECL(corefunc_str_check, (char *, long));
+
+extern struct lc_vardefs *FDECL(vardef_defined,(struct lc_vardefs *,char *, int));
+
+extern struct lc_vardefs *variable_definitions;
+
+extern long FDECL(method_defined, (char *, long, long *));
+
+void FDECL(savetoken, (char *));
+void NDECL(newline);
+void FDECL(advancepos, (char *));
+
 /*
  * This doesn't always get put in lev_comp.h
  * (esp. when using older versions of bison).
  */
 extern YYSTYPE yylval;
 
-int nh_line_number = 1, colon_line_number = 1;
+int nh_line_number = 1;
+int token_start_pos = 0;
+char curr_token[512];
 static char map[4096];
 static int map_cnt = 0;
 
+FILE *orig_yyin = NULL;
+
+#define ST_RET(x) do { savetoken(yytext); return x; } while (0);
+#define ST_RETF(y, x) do { savetoken(yytext); y; return x; } while (0);
+
 %}
 %e 1500
 %p 5000
@@ -83,6 +103,7 @@ static int map_cnt = 0;
 %s MAPC
 %%
 <MAPC>ENDMAP	{
+		  savetoken(yytext);
 		  BEGIN(INITIAL);
 		  yylval.map = (char *) alloc(map_cnt + 1);
 		  (void) strncpy(yylval.map, map, map_cnt);
@@ -90,129 +111,229 @@ static int map_cnt = 0;
 		  map_cnt = 0;
 		  return MAP_ID;
 		}
-<MAPC>[-|}{+ABCISHKPLWTF\\#. 0123456789]*\r?\n	{
+<MAPC>[-|}{+xABCISHKMPLWTtFYU\\#. 0123456789]*\r?\n	{
 		  int len = yyleng;
+		  savetoken(yytext);
 		  /* convert \r\n to \n */
 		  if (len >= 2 && yytext[len - 2] == '\r') len -= 1;
-		  nh_line_number++;
 		  (void) strncpy(map + map_cnt, yytext, len);
 		  map_cnt += len;
 		  map[map_cnt - 1] = '\n';
 		  map[map_cnt] = '\0';
+		  newline();
 		}
-^#.*\n		{ nh_line_number++; }
-:		{ colon_line_number = nh_line_number; return ':'; }
-MESSAGE		return MESSAGE_ID;
-MAZE		return MAZE_ID;
-NOMAP		return NOMAP_ID;
-LEVEL		return LEVEL_ID;
-INIT_MAP	return LEV_INIT_ID;
-FLAGS		return FLAGS_ID;
-GEOMETRY	return GEOMETRY_ID;
-^MAP\r?\n		{ BEGIN(MAPC); nh_line_number++; }
-OBJECT		return OBJECT_ID;
-CONTAINER	return COBJECT_ID;
-MONSTER		return MONSTER_ID;
-TRAP		return TRAP_ID;
-DOOR		return DOOR_ID;
-DRAWBRIDGE	return DRAWBRIDGE_ID;
-MAZEWALK	return MAZEWALK_ID;
-WALLIFY		return WALLIFY_ID;
-REGION		return REGION_ID;
-RANDOM_OBJECTS	return RANDOM_OBJECTS_ID;
-RANDOM_MONSTERS	return RANDOM_MONSTERS_ID;
-RANDOM_PLACES	return RANDOM_PLACES_ID;
-ALTAR		return ALTAR_ID;
-LADDER		return LADDER_ID;
-STAIR		return STAIR_ID;
-PORTAL		return PORTAL_ID;
-TELEPORT_REGION	return TELEPRT_ID;
-BRANCH		return BRANCH_ID;
-FOUNTAIN	return FOUNTAIN_ID;
-SINK		return SINK_ID;
-POOL		return POOL_ID;
-NON_DIGGABLE	return NON_DIGGABLE_ID;
-NON_PASSWALL	return NON_PASSWALL_ID;
-ROOM		return ROOM_ID;
-SUBROOM		return SUBROOM_ID;
-RANDOM_CORRIDORS	return RAND_CORRIDOR_ID;
-CORRIDOR	return CORRIDOR_ID;
-GOLD		return GOLD_ID;
-ENGRAVING	return ENGRAVING_ID;
-NAME		return NAME_ID;
-CHANCE		return CHANCE_ID;
-levregion	return LEV;
-open		{ yylval.i=D_ISOPEN; return DOOR_STATE; }
-closed		{ yylval.i=D_CLOSED; return DOOR_STATE; }
-locked		{ yylval.i=D_LOCKED; return DOOR_STATE; }
-nodoor		{ yylval.i=D_NODOOR; return DOOR_STATE; }
-broken		{ yylval.i=D_BROKEN; return DOOR_STATE; }
-north		{ yylval.i=W_NORTH; return DIRECTION; }
-east		{ yylval.i=W_EAST; return DIRECTION; }
-south		{ yylval.i=W_SOUTH; return DIRECTION; }
-west		{ yylval.i=W_WEST; return DIRECTION; }
-random		{ yylval.i = -1; return RANDOM_TYPE; }
-none		{ yylval.i = -2; return NONE; }
-object		return O_REGISTER;
-monster		return M_REGISTER;
-place		return P_REGISTER;
-align		return A_REGISTER;
-left		{ yylval.i=1; return LEFT_OR_RIGHT; }
-half-left	{ yylval.i=2; return LEFT_OR_RIGHT; }
-center		{ yylval.i=3; return CENTER; }
-half-right	{ yylval.i=4; return LEFT_OR_RIGHT; }
-right		{ yylval.i=5; return LEFT_OR_RIGHT; }
-top		{ yylval.i=1; return TOP_OR_BOT; }
-bottom		{ yylval.i=5; return TOP_OR_BOT; }
-lit		{ yylval.i=1; return LIGHT_STATE; }
-unlit		{ yylval.i=0; return LIGHT_STATE; }
-filled		{ yylval.i=0; return FILLING; }
-unfilled	{ yylval.i=1; return FILLING; }
-noalign		{ yylval.i= AM_NONE; return ALIGNMENT; }
-law		{ yylval.i= AM_LAWFUL; return ALIGNMENT; }
-neutral		{ yylval.i= AM_NEUTRAL; return ALIGNMENT; }
-chaos		{ yylval.i= AM_CHAOTIC; return ALIGNMENT; }
-coaligned	{ yylval.i= AM_SPLEV_CO; return ALIGNMENT; }
-noncoaligned	{ yylval.i= AM_SPLEV_NONCO; return ALIGNMENT; }
-peaceful	{ yylval.i=1; return MON_ATTITUDE; }
-hostile		{ yylval.i=0; return MON_ATTITUDE; }
-asleep		{ yylval.i=1; return MON_ALERTNESS; }
-awake		{ yylval.i=0; return MON_ALERTNESS; }
-m_feature	{ yylval.i= M_AP_FURNITURE; return MON_APPEARANCE; }
-m_monster	{ yylval.i= M_AP_MONSTER;   return MON_APPEARANCE; }
-m_object	{ yylval.i= M_AP_OBJECT;    return MON_APPEARANCE; }
-sanctum		{ yylval.i=2; return ALTAR_TYPE; }
-shrine		{ yylval.i=1; return ALTAR_TYPE; }
-altar		{ yylval.i=0; return ALTAR_TYPE; }
-up		{ yylval.i=1; return UP_OR_DOWN; }
-down		{ yylval.i=0; return UP_OR_DOWN; }
-false		{ yylval.i=0; return BOOLEAN; }
-true		{ yylval.i=1; return BOOLEAN; }
-dust		{ yylval.i=DUST; return ENGRAVING_TYPE; }
-engrave		{ yylval.i=ENGRAVE; return ENGRAVING_TYPE; }
-burn		{ yylval.i=BURN; return ENGRAVING_TYPE; }
-mark		{ yylval.i=MARK; return ENGRAVING_TYPE; }
-blood		{ yylval.i=ENGR_BLOOD; return ENGRAVING_TYPE; }
-blessed		{ yylval.i=1; return CURSE_TYPE; }
-uncursed	{ yylval.i=2; return CURSE_TYPE; }
-cursed		{ yylval.i=3; return CURSE_TYPE; }
-contained	{ return CONTAINED; }
-noteleport	{ yylval.i=NOTELEPORT; return FLAG_TYPE; }
-hardfloor	{ yylval.i=HARDFLOOR; return FLAG_TYPE; }
-nommap		{ yylval.i=NOMMAP; return FLAG_TYPE; }
-arboreal	{ yylval.i=ARBOREAL; return FLAG_TYPE; }	/* KMH */
-shortsighted	{ yylval.i=SHORTSIGHTED; return FLAG_TYPE; }
-\[\ *[0-9]+\%\ *\] { yylval.i = atoi(yytext + 1); return PERCENT; }
-[+\-]?[0-9]+	{ yylval.i=atoi(yytext); return INTEGER; }
-\"[^"]*\"	{ yytext[yyleng-1] = 0; /* Discard the trailing \" */
+^[ \t]*#.*\n		{ savetoken(yytext); newline(); }
+MESSAGE		ST_RET(MESSAGE_ID);
+NOMAP		ST_RET(NOMAP_ID);
+MAZE		ST_RET(MAZE_ID);
+LEVEL		ST_RET(LEVEL_ID);
+INIT_MAP	ST_RET(LEV_INIT_ID);
+mazegrid	ST_RET(MAZE_GRID_ID);
+solidfill	ST_RET(SOLID_FILL_ID);
+mines		ST_RET(MINES_ID);
+rogue		ST_RET(ROGUELEV_ID);
+FLAGS		ST_RET(FLAGS_ID);
+GEOMETRY	ST_RET(GEOMETRY_ID);
+^MAP\r?\n	{ savetoken(yytext); BEGIN(MAPC); newline(); }
+obj(ect)?	ST_RET(object_ID);
+OBJECT		ST_RET(OBJECT_ID);
+CONTAINER	ST_RET(COBJECT_ID);
+MONSTER		ST_RET(MONSTER_ID);
+monster		ST_RET(monster_ID);
+TRAP		ST_RET(TRAP_ID);
+DOOR		ST_RET(DOOR_ID);
+ROOMDOOR	ST_RET(ROOMDOOR_ID);
+DRAWBRIDGE	ST_RET(DRAWBRIDGE_ID);
+MAZEWALK	ST_RET(MAZEWALK_ID);
+WALLIFY		ST_RET(WALLIFY_ID);
+REGION		ST_RET(REGION_ID);
+ALTAR		ST_RET(ALTAR_ID);
+LADDER		ST_RET(LADDER_ID);
+STAIR		ST_RET(STAIR_ID);
+PORTAL		ST_RET(PORTAL_ID);
+TELEPORT_REGION	ST_RET(TELEPRT_ID);
+BRANCH		ST_RET(BRANCH_ID);
+FOUNTAIN	ST_RET(FOUNTAIN_ID);
+SINK		ST_RET(SINK_ID);
+POOL		ST_RET(POOL_ID);
+NON_DIGGABLE	ST_RET(NON_DIGGABLE_ID);
+NON_PASSWALL	ST_RET(NON_PASSWALL_ID);
+IF		ST_RET(IF_ID);
+ELSE		ST_RET(ELSE_ID);
+EXIT		ST_RET(EXIT_ID);
+ROOM		ST_RET(ROOM_ID);
+SUBROOM		ST_RET(SUBROOM_ID);
+RANDOM_CORRIDORS	ST_RET(RAND_CORRIDOR_ID);
+CORRIDOR	ST_RET(CORRIDOR_ID);
+TERRAIN		ST_RET(TERRAIN_ID);
+terrain		ST_RET(terrain_ID);
+REPLACE_TERRAIN	ST_RET(REPLACE_TERRAIN_ID);
+GOLD		ST_RET(GOLD_ID);
+GRAVE		ST_RET(GRAVE_ID);
+ENGRAVING	ST_RET(ENGRAVING_ID);
+MINERALIZE	ST_RET(MINERALIZE_ID);
+(NAME|name)	ST_RET(NAME_ID);
+FOR		ST_RET(FOR_ID);
+TO		ST_RET(TO_ID);
+LOOP		ST_RET(LOOP_ID);
+SWITCH		ST_RET(SWITCH_ID);
+CASE		ST_RET(CASE_ID);
+BREAK		ST_RET(BREAK_ID);
+DEFAULT		ST_RET(DEFAULT_ID);
+FUNCTION	ST_RET(FUNCTION_ID);
+SHUFFLE		ST_RET(SHUFFLE_ID);
+montype		ST_RET(MONTYPE_ID);
+selection	ST_RET(selection_ID);
+rect		ST_RET(rect_ID);
+fillrect	ST_RET(fillrect_ID);
+line		ST_RET(line_ID);
+randline	ST_RET(randline_ID);
+grow		ST_RET(grow_ID);
+floodfill	ST_RET(flood_ID);
+rndcoord	ST_RET(rndcoord_ID);
+circle		ST_RET(circle_ID);
+ellipse		ST_RET(ellipse_ID);
+filter		ST_RET(filter_ID);
+gradient	ST_RET(gradient_ID);
+complement	ST_RET(complement_ID);
+radial		{ savetoken(yytext); yylval.i=SEL_GRADIENT_RADIAL;  return GRADIENT_TYPE; }
+square		{ savetoken(yytext); yylval.i=SEL_GRADIENT_SQUARE;  return GRADIENT_TYPE; }
+dry		{ savetoken(yytext); yylval.i=DRY;  return HUMIDITY_TYPE; }
+wet		{ savetoken(yytext); yylval.i=WET;  return HUMIDITY_TYPE; }
+hot		{ savetoken(yytext); yylval.i=HOT;  return HUMIDITY_TYPE; }
+solid		{ savetoken(yytext); yylval.i=SOLID;  return HUMIDITY_TYPE; }
+any		{ savetoken(yytext); yylval.i=ANY_LOC;  return HUMIDITY_TYPE; }
+levregion	ST_RET(LEV);
+quantity	ST_RET(QUANTITY_ID);
+buried		ST_RET(BURIED_ID);
+eroded		ST_RET(ERODED_ID);
+erodeproof	ST_RET(ERODEPROOF_ID);
+trapped		ST_RET(TRAPPED_ID);
+recharged	ST_RET(RECHARGED_ID);
+invisible	ST_RET(INVIS_ID);
+greased		ST_RET(GREASED_ID);
+female		ST_RET(FEMALE_ID);
+cancelled	ST_RET(CANCELLED_ID);
+revived		ST_RET(REVIVED_ID);
+avenge		ST_RET(AVENGE_ID);
+fleeing		ST_RET(FLEEING_ID);
+blinded		ST_RET(BLINDED_ID);
+paralyzed	ST_RET(PARALYZED_ID);
+stunned		ST_RET(STUNNED_ID);
+confused	ST_RET(CONFUSED_ID);
+seen_traps	ST_RET(SEENTRAPS_ID);
+all		ST_RET(ALL_ID);
+horizontal	ST_RETF((yylval.i=1), HORIZ_OR_VERT);
+vertical	{ savetoken(yytext); yylval.i=2; return HORIZ_OR_VERT; }
+open		{ savetoken(yytext); yylval.i=D_ISOPEN; return DOOR_STATE; }
+closed		{ savetoken(yytext); yylval.i=D_CLOSED; return DOOR_STATE; }
+locked		{ savetoken(yytext); yylval.i=D_LOCKED; return DOOR_STATE; }
+nodoor		{ savetoken(yytext); yylval.i=D_NODOOR; return DOOR_STATE; }
+broken		{ savetoken(yytext); yylval.i=D_BROKEN; return DOOR_STATE; }
+secret		{ savetoken(yytext); yylval.i=D_SECRET; return DOOR_STATE; }
+north		{ savetoken(yytext); yylval.i=W_NORTH; return DIRECTION; }
+east		{ savetoken(yytext); yylval.i=W_EAST; return DIRECTION; }
+south		{ savetoken(yytext); yylval.i=W_SOUTH; return DIRECTION; }
+west		{ savetoken(yytext); yylval.i=W_WEST; return DIRECTION; }
+random		{ savetoken(yytext); yylval.i = -1; return RANDOM_TYPE; }
+random\[	{ savetoken(yytext); yylval.i = -1; return RANDOM_TYPE_BRACKET; }
+none		{ savetoken(yytext); yylval.i = -2; return NONE; }
+align		ST_RET(A_REGISTER);
+left		{ savetoken(yytext); yylval.i=1; return LEFT_OR_RIGHT; }
+half-left	{ savetoken(yytext); yylval.i=2; return LEFT_OR_RIGHT; }
+center		{ savetoken(yytext); yylval.i=3; return CENTER; }
+half-right	{ savetoken(yytext); yylval.i=4; return LEFT_OR_RIGHT; }
+right		{ savetoken(yytext); yylval.i=5; return LEFT_OR_RIGHT; }
+top		{ savetoken(yytext); yylval.i=1; return TOP_OR_BOT; }
+bottom		{ savetoken(yytext); yylval.i=5; return TOP_OR_BOT; }
+lit		{ savetoken(yytext); yylval.i=1; return LIGHT_STATE; }
+unlit		{ savetoken(yytext); yylval.i=0; return LIGHT_STATE; }
+filled		{ savetoken(yytext); yylval.i=1; return FILLING; }
+unfilled	{ savetoken(yytext); yylval.i=0; return FILLING; }
+regular		{ savetoken(yytext); yylval.i=0; return IRREGULAR; }
+irregular	{ savetoken(yytext); yylval.i=1; return IRREGULAR; }
+unjoined	{ savetoken(yytext); yylval.i=1; return JOINED; }
+joined		{ savetoken(yytext); yylval.i=0; return JOINED; }
+limited		{ savetoken(yytext); yylval.i=1; return LIMITED; }
+unlimited	{ savetoken(yytext); yylval.i=0; return LIMITED; }
+noalign		{ savetoken(yytext); yylval.i= AM_NONE; return ALIGNMENT; }
+law		{ savetoken(yytext); yylval.i= AM_LAWFUL; return ALIGNMENT; }
+neutral		{ savetoken(yytext); yylval.i= AM_NEUTRAL; return ALIGNMENT; }
+chaos		{ savetoken(yytext); yylval.i= AM_CHAOTIC; return ALIGNMENT; }
+coaligned	{ savetoken(yytext); yylval.i= AM_SPLEV_CO; return ALIGNMENT; }
+noncoaligned	{ savetoken(yytext); yylval.i= AM_SPLEV_NONCO; return ALIGNMENT; }
+peaceful	{ savetoken(yytext); yylval.i=1; return MON_ATTITUDE; }
+hostile		{ savetoken(yytext); yylval.i=0; return MON_ATTITUDE; }
+asleep		{ savetoken(yytext); yylval.i=1; return MON_ALERTNESS; }
+awake		{ savetoken(yytext); yylval.i=0; return MON_ALERTNESS; }
+m_feature	{ savetoken(yytext); yylval.i= M_AP_FURNITURE; return MON_APPEARANCE; }
+m_monster	{ savetoken(yytext); yylval.i= M_AP_MONSTER;   return MON_APPEARANCE; }
+m_object	{ savetoken(yytext); yylval.i= M_AP_OBJECT;    return MON_APPEARANCE; }
+sanctum		{ savetoken(yytext); yylval.i=2; return ALTAR_TYPE; }
+shrine		{ savetoken(yytext); yylval.i=1; return ALTAR_TYPE; }
+altar		{ savetoken(yytext); yylval.i=0; return ALTAR_TYPE; }
+up		{ savetoken(yytext); yylval.i=1; return UP_OR_DOWN; }
+down		{ savetoken(yytext); yylval.i=0; return UP_OR_DOWN; }
+false		{ savetoken(yytext); yylval.i=0; return BOOLEAN; }
+true		{ savetoken(yytext); yylval.i=1; return BOOLEAN; }
+dust		{ savetoken(yytext); yylval.i=DUST; return ENGRAVING_TYPE; }
+engrave		{ savetoken(yytext); yylval.i=ENGRAVE; return ENGRAVING_TYPE; }
+burn		{ savetoken(yytext); yylval.i=BURN; return ENGRAVING_TYPE; }
+mark		{ savetoken(yytext); yylval.i=MARK; return ENGRAVING_TYPE; }
+blood		{ savetoken(yytext); yylval.i=ENGR_BLOOD; return ENGRAVING_TYPE; }
+blessed		{ savetoken(yytext); yylval.i=1; return CURSE_TYPE; }
+uncursed	{ savetoken(yytext); yylval.i=2; return CURSE_TYPE; }
+cursed		{ savetoken(yytext); yylval.i=3; return CURSE_TYPE; }
+noteleport	{ savetoken(yytext); yylval.i=NOTELEPORT; return FLAG_TYPE; }
+hardfloor	{ savetoken(yytext); yylval.i=HARDFLOOR; return FLAG_TYPE; }
+nommap		{ savetoken(yytext); yylval.i=NOMMAP; return FLAG_TYPE; }
+arboreal	{ savetoken(yytext); yylval.i=ARBOREAL; return FLAG_TYPE; }	/* KMH */
+shortsighted	{ savetoken(yytext); yylval.i=SHORTSIGHTED; return FLAG_TYPE; }
+mazelevel	{ savetoken(yytext); yylval.i=MAZELEVEL; return FLAG_TYPE; }
+premapped	{ savetoken(yytext); yylval.i=PREMAPPED; return FLAG_TYPE; }
+shroud		{ savetoken(yytext); yylval.i=SHROUD; return FLAG_TYPE; }
+stormy		{ savetoken(yytext); yylval.i=STORMY; return FLAG_TYPE; }
+graveyard	{ savetoken(yytext); yylval.i=GRAVEYARD; return FLAG_TYPE; }
+[0-9]+d[0-9]+	{ char *p = strchr(yytext, 'd');
+		  savetoken(yytext);
+		  if (p) {
+			*p = '\0';
+			p++;
+			yylval.dice.num=atoi(yytext);
+			yylval.dice.die=atoi(p);
+		  } else { yylval.dice.num = yylval.dice.die = 1; }
+		  return DICE;
+		}
+\[\ *[0-9]+\%\ *\] { savetoken(yytext); yylval.i = atoi(yytext + 1);
+		     if (yylval.i < 0 || yylval.i > 100)
+			lc_error("Unexpected percentile '%li%%'", yylval.i);
+		     return PERCENT; }
+-[0-9]+		{ savetoken(yytext); yylval.i=atoi(yytext); return MINUS_INTEGER; }
+\+[0-9]+	{ savetoken(yytext); yylval.i=atoi(yytext); return PLUS_INTEGER; }
+[0-9]+\%	{ savetoken(yytext); yylval.i = atoi(yytext);
+		  if (yylval.i < 0 || yylval.i > 100)
+		     lc_error("Unexpected percentile '%li%%'", yylval.i);
+		  return SPERCENT; }
+[0-9]+		{ savetoken(yytext); yylval.i=atoi(yytext); return INTEGER; }
+\"[^"]*\"	{ savetoken(yytext);
+		  yytext[yyleng-1] = 0; /* Discard the trailing \" */
 		  yylval.map = (char *) alloc(strlen(yytext+1)+1);
 		  Strcpy(yylval.map, yytext+1); /* Discard the first \" */
 		  return STRING; }
-\r?\n		{ nh_line_number++; }
-[ \t]+		;
-'\\.'		{ yylval.i = yytext[2]; return CHAR; }
-'.'		{ yylval.i = yytext[1]; return CHAR; }
-.		{ return yytext[0]; }
+\$[a-zA-Z_]+	{ savetoken(yytext); return handle_varstring_check(); }
+"=="		{ savetoken(yytext); yylval.i = SPO_JE; return COMPARE_TYPE; }
+"!="		{ savetoken(yytext); yylval.i = SPO_JNE; return COMPARE_TYPE; }
+"<>"		{ savetoken(yytext); yylval.i = SPO_JNE; return COMPARE_TYPE; }
+"<="		{ savetoken(yytext); yylval.i = SPO_JLE; return COMPARE_TYPE; }
+">="		{ savetoken(yytext); yylval.i = SPO_JGE; return COMPARE_TYPE; }
+"<"		{ savetoken(yytext); yylval.i = SPO_JL; return COMPARE_TYPE; }
+">"		{ savetoken(yytext); yylval.i = SPO_JG; return COMPARE_TYPE; }
+\r?\n		{ newline(); }
+[ \t]+		{ advancepos(yytext); }
+'\\.'		{ savetoken(yytext); yylval.i = yytext[2]; return CHAR; }
+'.'		{ savetoken(yytext); yylval.i = yytext[1]; return CHAR; }
+[-_a-zA-Z0-9]+	ST_RET(UNKNOWN_TYPE);
+.		{ savetoken(yytext); return yytext[0]; }
 %%
 #ifdef	AMIGA
 long *alloc(n)
@@ -232,6 +353,7 @@ FILE *input_f;
 	else
 #endif
 	    yyin = input_f;
+	    if (!orig_yyin) orig_yyin = yyin;
 }
 /* analogous routine (for completeness) */
 void init_yyout( output_f )
@@ -240,4 +362,51 @@ FILE *output_f;
 	yyout = output_f;
 }
 
+long
+handle_varstring_check()
+{
+  struct lc_vardefs *vd;
+  yylval.map = (char *) alloc(strlen(yytext)+1);
+  Strcpy(yylval.map, yytext);
+  if ((vd = vardef_defined(variable_definitions, yytext, 1))) {
+     long l = vd->var_type;
+     long a = ((l & SPOVAR_ARRAY) == SPOVAR_ARRAY);
+     l = (l & ~SPOVAR_ARRAY);
+     if (l == SPOVAR_INT) return (a ? VARSTRING_INT_ARRAY : VARSTRING_INT);
+     if (l == SPOVAR_STRING) return (a ? VARSTRING_STRING_ARRAY : VARSTRING_STRING);
+     if (l == SPOVAR_VARIABLE) return (a ? VARSTRING_VAR_ARRAY : VARSTRING_VAR);
+     if (l == SPOVAR_COORD) return (a ? VARSTRING_COORD_ARRAY : VARSTRING_COORD);
+     if (l == SPOVAR_REGION) return (a ? VARSTRING_REGION_ARRAY : VARSTRING_REGION);
+     if (l == SPOVAR_MAPCHAR) return (a ? VARSTRING_MAPCHAR_ARRAY : VARSTRING_MAPCHAR);
+     if (l == SPOVAR_MONST) return (a ? VARSTRING_MONST_ARRAY : VARSTRING_MONST);
+     if (l == SPOVAR_OBJ) return (a ? VARSTRING_OBJ_ARRAY : VARSTRING_OBJ);
+     if (l == SPOVAR_SEL) return (a ? VARSTRING_SEL_ARRAY : VARSTRING_SEL);
+  }
+  return VARSTRING;
+}
+
+
+void
+newline()
+{
+  nh_line_number++;
+  token_start_pos = 0;
+  memset(curr_token, 0, 512);
+}
+
+void
+savetoken(s)
+char *s;
+{
+   sprintf(curr_token, "%s", s);
+   advancepos(s);
+}
+
+void
+advancepos(s)
+char *s;
+{
+   token_start_pos += strlen(s);
+}
+
 /*lev_comp.l*/
diff --git a/util/lev_comp.y b/util/lev_comp.y
index c2fe15fb6..fab3a9450 100644
--- a/util/lev_comp.y
+++ b/util/lev_comp.y
@@ -26,7 +26,6 @@
 #include "hack.h"
 #include "sp_lev.h"
 
-#define MAX_REGISTERS	10
 #define ERR		(-1)
 /* many types of things are put in chars for transference to NetHack.
  * since some systems will use signed chars, limit everybody to the
@@ -34,11 +33,16 @@
  */
 #define MAX_OF_TYPE	128
 
+#define MAX_NESTED_IFS	20
+#define MAX_SWITCH_CASES 20
+
 #define New(type)		\
 	(type *) memset((genericptr_t)alloc(sizeof(type)), 0, sizeof(type))
 #define NewTab(type, size)	(type **) alloc(sizeof(type *) * size)
 #define Free(ptr)		free((genericptr_t)ptr)
 
+extern void VDECL(lc_error, (const char *, ...));
+extern void VDECL(lc_warning, (const char *, ...));
 extern void FDECL(yyerror, (const char *));
 extern void FDECL(yywarning, (const char *));
 extern int NDECL(yylex);
@@ -52,119 +56,219 @@ extern int FDECL(get_object_id, (char *,CHAR_P));
 extern boolean FDECL(check_monster_char, (CHAR_P));
 extern boolean FDECL(check_object_char, (CHAR_P));
 extern char FDECL(what_map_char, (CHAR_P));
-extern void FDECL(scan_map, (char *));
-extern void NDECL(wallify_map);
-extern boolean NDECL(check_subrooms);
-extern void FDECL(check_coord, (int,int,const char *));
-extern void NDECL(store_part);
-extern void NDECL(store_room);
-extern boolean FDECL(write_level_file, (char *,splev *,specialmaze *));
-extern void FDECL(free_rooms, (splev *));
+extern void FDECL(scan_map, (char *, sp_lev *));
+extern void FDECL(add_opcode, (sp_lev *, int, genericptr_t));
+extern genericptr_t FDECL(get_last_opcode_data1, (sp_lev *, int));
+extern genericptr_t FDECL(get_last_opcode_data2, (sp_lev *, int,int));
+extern boolean FDECL(check_subrooms, (sp_lev *));
+extern boolean FDECL(write_level_file, (char *,sp_lev *));
+extern struct opvar *FDECL(set_opvar_int, (struct opvar *, long));
+extern void VDECL(add_opvars, (sp_lev *, const char *, ...));
+extern void FDECL(start_level_def, (sp_lev * *, char *));
 
-static struct reg {
-	int x1, y1;
-	int x2, y2;
-}		current_region;
+extern struct lc_funcdefs *FDECL(funcdef_new,(long,char *));
+extern void FDECL(funcdef_free_all,(struct lc_funcdefs *));
+extern struct lc_funcdefs *FDECL(funcdef_defined,(struct lc_funcdefs *,char *, int));
+extern char *FDECL(funcdef_paramtypes, (struct lc_funcdefs *));
+extern char *FDECL(decode_parm_str, (char *));
 
-static struct coord {
-	int x;
-	int y;
-}		current_coord, current_align;
+extern struct lc_vardefs *FDECL(vardef_new,(long,char *));
+extern void FDECL(vardef_free_all,(struct lc_vardefs *));
+extern struct lc_vardefs *FDECL(vardef_defined,(struct lc_vardefs *,char *, int));
 
-static struct size {
-	int height;
-	int width;
-}		current_size;
+extern void NDECL(break_stmt_start);
+extern void FDECL(break_stmt_end, (sp_lev *));
+extern void FDECL(break_stmt_new, (sp_lev *, long));
 
-char tmpmessage[256];
-digpos *tmppass[32];
-char *tmpmap[ROWNO];
+extern void FDECL(splev_add_from, (sp_lev *, sp_lev *));
 
-digpos *tmpdig[MAX_OF_TYPE];
-region *tmpreg[MAX_OF_TYPE];
-lev_region *tmplreg[MAX_OF_TYPE];
-door *tmpdoor[MAX_OF_TYPE];
-drawbridge *tmpdb[MAX_OF_TYPE];
-walk *tmpwalk[MAX_OF_TYPE];
+extern void FDECL(check_vardef_type, (struct lc_vardefs *, char *, long));
+extern void FDECL(vardef_used, (struct lc_vardefs *, char *));
+extern struct lc_vardefs *FDECL(add_vardef_type, (struct lc_vardefs *, char *, long));
 
-room_door *tmprdoor[MAX_OF_TYPE];
-trap *tmptrap[MAX_OF_TYPE];
-monster *tmpmonst[MAX_OF_TYPE];
-object *tmpobj[MAX_OF_TYPE];
-altar *tmpaltar[MAX_OF_TYPE];
-lad *tmplad[MAX_OF_TYPE];
-stair *tmpstair[MAX_OF_TYPE];
-gold *tmpgold[MAX_OF_TYPE];
-engraving *tmpengraving[MAX_OF_TYPE];
-fountain *tmpfountain[MAX_OF_TYPE];
-sink *tmpsink[MAX_OF_TYPE];
-pool *tmppool[MAX_OF_TYPE];
+extern int FDECL(reverse_jmp_opcode, (int));
 
-mazepart *tmppart[10];
-room *tmproom[MAXNROFROOMS*2];
-corridor *tmpcor[MAX_OF_TYPE];
+struct coord {
+	long x;
+	long y;
+};
 
-static specialmaze maze;
-static splev special_lev;
-static lev_init init_lev;
+struct forloopdef {
+    char *varname;
+    long jmp_point;
+};
+static struct forloopdef forloop_list[MAX_NESTED_IFS];
+static short n_forloops = 0;
 
-static char olist[MAX_REGISTERS], mlist[MAX_REGISTERS];
-static struct coord plist[MAX_REGISTERS];
 
-int n_olist = 0, n_mlist = 0, n_plist = 0;
+sp_lev *splev = NULL;
 
-unsigned int nlreg = 0, nreg = 0, ndoor = 0, ntrap = 0, nmons = 0, nobj = 0;
-unsigned int ndb = 0, nwalk = 0, npart = 0, ndig = 0, nlad = 0, nstair = 0;
-unsigned int naltar = 0, ncorridor = 0, nrooms = 0, ngold = 0, nengraving = 0;
-unsigned int nfountain = 0, npool = 0, nsink = 0, npass = 0;
+static struct opvar *if_list[MAX_NESTED_IFS];
 
-static int lev_flags = 0;
+static short n_if_list = 0;
 
 unsigned int max_x_map, max_y_map;
+int obj_containment = 0;
 
-static xchar in_room;
+int in_container_obj = 0;
+
+/* integer value is possibly an inconstant value (eg. dice notation or a variable) */
+int is_inconstant_number = 0;
+
+int in_switch_statement = 0;
+static struct opvar *switch_check_jump = NULL;
+static struct opvar *switch_default_case = NULL;
+static struct opvar *switch_case_list[MAX_SWITCH_CASES];
+static long switch_case_value[MAX_SWITCH_CASES];
+int n_switch_case_list = 0;
+
+int allow_break_statements = 0;
+struct lc_breakdef *break_list = NULL;
+
+extern struct lc_vardefs *variable_definitions;
+
+
+struct lc_vardefs *function_tmp_var_defs = NULL;
+extern struct lc_funcdefs *function_definitions;
+struct lc_funcdefs *curr_function = NULL;
+struct lc_funcdefs_parm * curr_function_param = NULL;
+int in_function_definition = 0;
+sp_lev *function_splev_backup = NULL;
 
 extern int fatal_error;
-extern int want_warnings;
+extern int got_errors;
+extern int line_number;
 extern const char *fname;
 
+extern char curr_token[512];
+
 %}
 
 %union
 {
-	int	i;
+	long	i;
 	char*	map;
 	struct {
-		xchar room;
-		xchar wall;
-		xchar door;
+		long room;
+		long wall;
+		long door;
 	} corpos;
+    struct {
+	long area;
+	long x1;
+	long y1;
+	long x2;
+	long y2;
+    } lregn;
+    struct {
+	long x;
+	long y;
+    } crd;
+    struct {
+	long ter;
+	long lit;
+    } terr;
+    struct {
+	long height;
+	long width;
+    } sze;
+    struct {
+	long die;
+	long num;
+    } dice;
+    struct {
+	long cfunc;
+	char *varstr;
+    } meth;
 }
 
 
-%token	<i> CHAR INTEGER BOOLEAN PERCENT
+%token	<i> CHAR INTEGER BOOLEAN PERCENT SPERCENT
+%token	<i> MINUS_INTEGER PLUS_INTEGER
+%token	<i> MAZE_GRID_ID SOLID_FILL_ID MINES_ID ROGUELEV_ID
 %token	<i> MESSAGE_ID MAZE_ID LEVEL_ID LEV_INIT_ID GEOMETRY_ID NOMAP_ID
 %token	<i> OBJECT_ID COBJECT_ID MONSTER_ID TRAP_ID DOOR_ID DRAWBRIDGE_ID
-%token	<i> MAZEWALK_ID WALLIFY_ID REGION_ID FILLING
-%token	<i> RANDOM_OBJECTS_ID RANDOM_MONSTERS_ID RANDOM_PLACES_ID
+%token	<i> object_ID monster_ID terrain_ID
+%token	<i> MAZEWALK_ID WALLIFY_ID REGION_ID FILLING IRREGULAR JOINED
 %token	<i> ALTAR_ID LADDER_ID STAIR_ID NON_DIGGABLE_ID NON_PASSWALL_ID ROOM_ID
-%token	<i> PORTAL_ID TELEPRT_ID BRANCH_ID LEV CHANCE_ID
+%token	<i> PORTAL_ID TELEPRT_ID BRANCH_ID LEV MINERALIZE_ID
 %token	<i> CORRIDOR_ID GOLD_ID ENGRAVING_ID FOUNTAIN_ID POOL_ID SINK_ID NONE
 %token	<i> RAND_CORRIDOR_ID DOOR_STATE LIGHT_STATE CURSE_TYPE ENGRAVING_TYPE
-%token	<i> DIRECTION RANDOM_TYPE O_REGISTER M_REGISTER P_REGISTER A_REGISTER
+%token	<i> DIRECTION RANDOM_TYPE RANDOM_TYPE_BRACKET A_REGISTER
 %token	<i> ALIGNMENT LEFT_OR_RIGHT CENTER TOP_OR_BOT ALTAR_TYPE UP_OR_DOWN
 %token	<i> SUBROOM_ID NAME_ID FLAGS_ID FLAG_TYPE MON_ATTITUDE MON_ALERTNESS
-%token	<i> MON_APPEARANCE
-%token	<i> CONTAINED
-%token	<i> ',' ':' '(' ')' '[' ']'
+%token	<i> MON_APPEARANCE ROOMDOOR_ID IF_ID ELSE_ID
+%token	<i> TERRAIN_ID HORIZ_OR_VERT REPLACE_TERRAIN_ID
+%token	<i> EXIT_ID SHUFFLE_ID
+%token	<i> QUANTITY_ID BURIED_ID LOOP_ID
+%token	<i> FOR_ID TO_ID
+%token	<i> SWITCH_ID CASE_ID BREAK_ID DEFAULT_ID
+%token	<i> ERODED_ID TRAPPED_ID RECHARGED_ID INVIS_ID GREASED_ID
+%token	<i> FEMALE_ID CANCELLED_ID REVIVED_ID AVENGE_ID FLEEING_ID BLINDED_ID
+%token	<i> PARALYZED_ID STUNNED_ID CONFUSED_ID SEENTRAPS_ID ALL_ID
+%token	<i> MONTYPE_ID
+%token	<i> GRAVE_ID ERODEPROOF_ID
+%token	<i> FUNCTION_ID
+%token	<i> MSG_OUTPUT_TYPE
+%token	<i> COMPARE_TYPE
+%token  <i> UNKNOWN_TYPE
+%token	<i> rect_ID fillrect_ID line_ID randline_ID grow_ID selection_ID flood_ID
+%token	<i> rndcoord_ID circle_ID ellipse_ID filter_ID complement_ID
+%token	<i> gradient_ID GRADIENT_TYPE LIMITED HUMIDITY_TYPE
+%token	<i> ',' ':' '(' ')' '[' ']' '{' '}'
 %token	<map> STRING MAP_ID
+%token	<map> NQSTRING VARSTRING
+%token	<map> CFUNC CFUNC_INT CFUNC_STR CFUNC_COORD CFUNC_REGION
+%token	<map> VARSTRING_INT VARSTRING_INT_ARRAY
+%token	<map> VARSTRING_STRING VARSTRING_STRING_ARRAY
+%token	<map> VARSTRING_VAR VARSTRING_VAR_ARRAY
+%token	<map> VARSTRING_COORD VARSTRING_COORD_ARRAY
+%token	<map> VARSTRING_REGION VARSTRING_REGION_ARRAY
+%token	<map> VARSTRING_MAPCHAR VARSTRING_MAPCHAR_ARRAY
+%token	<map> VARSTRING_MONST VARSTRING_MONST_ARRAY
+%token	<map> VARSTRING_OBJ VARSTRING_OBJ_ARRAY
+%token	<map> VARSTRING_SEL VARSTRING_SEL_ARRAY
+%token	<meth> METHOD_INT METHOD_INT_ARRAY
+%token	<meth> METHOD_STRING METHOD_STRING_ARRAY
+%token	<meth> METHOD_VAR METHOD_VAR_ARRAY
+%token	<meth> METHOD_COORD METHOD_COORD_ARRAY
+%token	<meth> METHOD_REGION METHOD_REGION_ARRAY
+%token	<meth> METHOD_MAPCHAR METHOD_MAPCHAR_ARRAY
+%token	<meth> METHOD_MONST METHOD_MONST_ARRAY
+%token	<meth> METHOD_OBJ METHOD_OBJ_ARRAY
+%token	<meth> METHOD_SEL METHOD_SEL_ARRAY
+%token	<dice> DICE
 %type	<i> h_justif v_justif trap_name room_type door_state light_state
-%type	<i> alignment altar_type a_register roomfill filling door_pos
-%type	<i> door_wall walled secret amount chance
-%type	<i> engraving_type flags flag_list prefilled lev_region lev_init
-%type	<i> monster monster_c m_register object object_c o_register
-%type	<map> string maze_def level_def m_name o_name
+%type	<i> alignment altar_type a_register roomfill door_pos
+%type	<i> alignment_prfx
+%type	<i> door_wall walled secret
+%type	<i> dir_list teleprt_detail
+%type	<i> object_infos object_info monster_infos monster_info
+%type	<i> levstatements stmt_block region_detail_end
+%type	<i> engraving_type flag_list roomregionflag roomregionflags optroomregionflags
+%type	<i> humidity_flags
+%type	<i> comparestmt encodecoord encoderegion mapchar
+%type	<i> seen_trap_mask
+%type	<i> encodemonster encodeobj encodeobj_list
+%type	<i> integer_list string_list encodecoord_list encoderegion_list mapchar_list encodemonster_list
+%type	<i> opt_percent opt_fillchar
+%type	<i> all_integers
+%type	<i> ter_selection ter_selection_x
+%type	<i> func_param_type
+%type	<i> objectid monsterid terrainid
+%type	<i> opt_coord_or_var opt_limited
+%type   <i> mazefiller
+%type	<map> level_def
+%type	<map> any_var any_var_array any_var_or_arr any_var_or_unk
+%type	<map> func_call_params_list func_call_param_list
+%type	<i> func_call_param_part
 %type	<corpos> corr_spec
+%type	<lregn> region lev_region
+%type	<crd> room_pos subroom_pos room_align
+%type	<sze> room_size
+%type	<terr> terrain_type
+%left  '+' '-'
+%left  '*' '/' '%'
 %start	file
 
 %%
@@ -176,331 +280,926 @@ levels		: level
 		| level levels
 		;
 
-level		: maze_level
-		| room_level
-		;
-
-maze_level	: maze_def flags lev_init messages regions
+level		: level_def flags levstatements
 		  {
-			unsigned i;
-
 			if (fatal_error > 0) {
 				(void) fprintf(stderr,
-				"%s : %d errors detected. No output created!\n",
-					fname, fatal_error);
-			} else {
-				maze.flags = $2;
-				(void) memcpy((genericptr_t)&(maze.init_lev),
-						(genericptr_t)&(init_lev),
-						sizeof(lev_init));
-				maze.numpart = npart;
-				maze.parts = NewTab(mazepart, npart);
-				for(i=0;i<npart;i++)
-				    maze.parts[i] = tmppart[i];
-				if (!write_level_file($1, (splev *)0, &maze)) {
-					yyerror("Can't write output file!!");
-					exit(EXIT_FAILURE);
+				"%s: %d errors detected for level \"%s\". No output created!\n",
+					       fname, fatal_error, $1);
+				fatal_error = 0;
+				got_errors++;
+			} else if (!got_errors) {
+				if (!write_level_file($1, splev)) {
+				    lc_error("Can't write output file for '%s'!", $1);
+				    exit(EXIT_FAILURE);
 				}
-				npart = 0;
 			}
 			Free($1);
+			Free(splev);
+			splev = NULL;
+			vardef_free_all(variable_definitions);
+			variable_definitions = NULL;
 		  }
 		;
 
-room_level	: level_def flags lev_init messages rreg_init rooms corridors_def
+level_def	: LEVEL_ID ':' STRING
 		  {
-			unsigned i;
-
-			if (fatal_error > 0) {
-			    (void) fprintf(stderr,
-			      "%s : %d errors detected. No output created!\n",
-					fname, fatal_error);
-			} else {
-				special_lev.flags = (long) $2;
-				(void) memcpy(
-					(genericptr_t)&(special_lev.init_lev),
-					(genericptr_t)&(init_lev),
-					sizeof(lev_init));
-				special_lev.nroom = nrooms;
-				special_lev.rooms = NewTab(room, nrooms);
-				for(i=0; i<nrooms; i++)
-				    special_lev.rooms[i] = tmproom[i];
-				special_lev.ncorr = ncorridor;
-				special_lev.corrs = NewTab(corridor, ncorridor);
-				for(i=0; i<ncorridor; i++)
-				    special_lev.corrs[i] = tmpcor[i];
-				if (check_subrooms()) {
-				    if (!write_level_file($1, &special_lev,
-							  (specialmaze *)0)) {
-					yyerror("Can't write output file!!");
-					exit(EXIT_FAILURE);
-				    }
-				}
-				free_rooms(&special_lev);
-				nrooms = 0;
-				ncorridor = 0;
-			}
-			Free($1);
+		      start_level_def(&splev, $3);
+		      $$ = $3;
+		  }
+		| MAZE_ID ':' STRING ',' mazefiller
+		  {
+		      start_level_def(&splev, $3);
+		      if ($5 == -1) {
+			  add_opvars(splev, "iiiiiiiio", LVLINIT_MAZEGRID,HWALL,0,0, 0,0,0,0, SPO_INITLEVEL);
+		      } else {
+			  long bg = what_map_char((char) $5);
+			  add_opvars(splev, "iiiiiiiio", LVLINIT_SOLIDFILL, bg, 0,0, 0,0,0,0, SPO_INITLEVEL);
+		      }
+		      add_opvars(splev, "io", MAZELEVEL, SPO_LEVEL_FLAGS);
+		      max_x_map = COLNO-1;
+		      max_y_map = ROWNO;
+		      $$ = $3;
 		  }
 		;
 
-level_def	: LEVEL_ID ':' string
+mazefiller	: RANDOM_TYPE
 		  {
-			if (index($3, '.'))
-			    yyerror("Invalid dot ('.') in level name.");
-			if ((int) strlen($3) > 8)
-			    yyerror("Level names limited to 8 characters.");
-			$$ = $3;
-			special_lev.nrmonst = special_lev.nrobjects = 0;
-			n_mlist = n_olist = 0;
+		      $$ = -1;
+		  }
+		| CHAR
+		  {
+		      $$ = what_map_char((char) $1);
 		  }
 		;
 
-lev_init	: /* nothing */
+lev_init	: LEV_INIT_ID ':' SOLID_FILL_ID ',' terrain_type
 		  {
-			/* in case we're processing multiple files,
-			   explicitly clear any stale settings */
-			(void) memset((genericptr_t) &init_lev, 0,
-					sizeof init_lev);
-			init_lev.init_present = FALSE;
-			$$ = 0;
+		      long filling = $5.ter;
+		      if (filling == INVALID_TYPE || filling >= MAX_TYPE)
+			  lc_error("INIT_MAP: Invalid fill char type.");
+		      add_opvars(splev, "iiiiiiiio", LVLINIT_SOLIDFILL,filling,0,(long)$5.lit, 0,0,0,0, SPO_INITLEVEL);
+		      max_x_map = COLNO-1;
+		      max_y_map = ROWNO;
 		  }
-		| LEV_INIT_ID ':' CHAR ',' CHAR ',' BOOLEAN ',' BOOLEAN ',' light_state ',' walled
+		| LEV_INIT_ID ':' MAZE_GRID_ID ',' CHAR
 		  {
-			init_lev.init_present = TRUE;
-			init_lev.fg = what_map_char((char) $3);
-			if (init_lev.fg == INVALID_TYPE)
-			    yyerror("Invalid foreground type.");
-			init_lev.bg = what_map_char((char) $5);
-			if (init_lev.bg == INVALID_TYPE)
-			    yyerror("Invalid background type.");
-			init_lev.smoothed = $7;
-			init_lev.joined = $9;
-			if (init_lev.joined &&
-			    init_lev.fg != CORR && init_lev.fg != ROOM)
-			    yyerror("Invalid foreground type for joined map.");
-			init_lev.lit = $11;
-			init_lev.walled = $13;
-			init_lev.icedpools = FALSE;
-			$$ = 1;
+		      long filling = what_map_char((char) $5);
+		      if (filling == INVALID_TYPE || filling >= MAX_TYPE)
+			  lc_error("INIT_MAP: Invalid fill char type.");
+		      add_opvars(splev, "iiiiiiiio", LVLINIT_MAZEGRID,filling,0,0, 0,0,0,0, SPO_INITLEVEL);
+		      max_x_map = COLNO-1;
+		      max_y_map = ROWNO;
 		  }
-		| LEV_INIT_ID ':' CHAR ',' CHAR ',' BOOLEAN ',' BOOLEAN ',' light_state ',' walled ',' BOOLEAN
+		| LEV_INIT_ID ':' ROGUELEV_ID
 		  {
-			init_lev.init_present = TRUE;
-			init_lev.fg = what_map_char((char) $3);
-			if (init_lev.fg == INVALID_TYPE)
-			    yyerror("Invalid foreground type.");
-			init_lev.bg = what_map_char((char) $5);
-			if (init_lev.bg == INVALID_TYPE)
-			    yyerror("Invalid background type.");
-			init_lev.smoothed = $7;
-			init_lev.joined = $9;
-			if (init_lev.joined &&
-			    init_lev.fg != CORR && init_lev.fg != ROOM)
-			    yyerror("Invalid foreground type for joined map.");
-			init_lev.lit = $11;
-			init_lev.walled = $13;
-			init_lev.icedpools = $15;
-			$$ = 1;
+		      add_opvars(splev, "iiiiiiiio", LVLINIT_ROGUE,0,0,0,0,0,0,0, SPO_INITLEVEL);
+		  }
+		| LEV_INIT_ID ':' MINES_ID ',' CHAR ',' CHAR ',' BOOLEAN ',' BOOLEAN ',' light_state ',' walled opt_fillchar
+		  {
+		      long fg = what_map_char((char) $5);
+		      long bg = what_map_char((char) $7);
+		      long smoothed = $9;
+		      long joined = $11;
+		      long lit = $13;
+		      long walled = $15;
+		      long filling = $16;
+		      if (fg == INVALID_TYPE || fg >= MAX_TYPE)
+			  lc_error("INIT_MAP: Invalid foreground type.");
+		      if (bg == INVALID_TYPE || bg >= MAX_TYPE)
+			  lc_error("INIT_MAP: Invalid background type.");
+		      if (joined && fg != CORR && fg != ROOM)
+			  lc_error("INIT_MAP: Invalid foreground type for joined map.");
+
+		      if (filling == INVALID_TYPE)
+			  lc_error("INIT_MAP: Invalid fill char type.");
+
+		      add_opvars(splev, "iiiiiiiio", LVLINIT_MINES,filling,walled,lit, joined,smoothed,bg,fg, SPO_INITLEVEL);
+			max_x_map = COLNO-1;
+			max_y_map = ROWNO;
 		  }
 		;
 
+opt_limited	: /* nothing */
+		  {
+		      $$ = 0;
+		  }
+		| ',' LIMITED
+		  {
+		      $$ = $2;
+		  }
+		;
+
+opt_coord_or_var	: /* nothing */
+		  {
+		      add_opvars(splev, "o", SPO_COPY);
+		      $$ = 0;
+		  }
+		| ',' coord_or_var
+		  {
+		      $$ = 1;
+		  }
+		;
+
+opt_fillchar	: /* nothing */
+		  {
+		      $$ = -1;
+		  }
+		| ',' CHAR
+		  {
+		      $$ = what_map_char((char) $2);
+		  }
+		;
+
+
 walled		: BOOLEAN
 		| RANDOM_TYPE
 		;
 
 flags		: /* nothing */
 		  {
-			$$ = 0;
+		      add_opvars(splev, "io", 0, SPO_LEVEL_FLAGS);
 		  }
 		| FLAGS_ID ':' flag_list
 		  {
-			$$ = lev_flags;
-			lev_flags = 0;	/* clear for next user */
+		      add_opvars(splev, "io", $3, SPO_LEVEL_FLAGS);
 		  }
 		;
 
 flag_list	: FLAG_TYPE ',' flag_list
 		  {
-			lev_flags |= $1;
+		      $$ = ($1 | $3);
 		  }
 		| FLAG_TYPE
 		  {
-			lev_flags |= $1;
+		      $$ = $1;
 		  }
 		;
 
-messages	: /* nothing */
-		| message messages
-		;
-
-message		: MESSAGE_ID ':' STRING
+levstatements	: /* nothing */
 		  {
-			int i, j;
-
-			i = (int) strlen($3) + 1;
-			j = (int) strlen(tmpmessage);
-			if (i + j > 255) {
-			   yyerror("Message string too long (>256 characters)");
-			} else {
-			    if (j) tmpmessage[j++] = '\n';
-			    (void) strncpy(tmpmessage+j, $3, i - 1);
-			    tmpmessage[j + i - 1] = 0;
-			}
-			Free($3);
+		      $$ = 0;
+		  }
+		| levstatement levstatements
+		  {
+		      $$ = 1 + $2;
 		  }
 		;
 
-rreg_init	: /* nothing */
-		| rreg_init init_rreg
+stmt_block	: '{' levstatements '}'
+		  {
+		      $$ = $2;
+		  }
 		;
 
-init_rreg	: RANDOM_OBJECTS_ID ':' object_list
+levstatement 	: message
+		| lev_init
+		| altar_detail
+		| grave_detail
+		| branch_region
+		| corridor
+		| variable_define
+		| shuffle_detail
+		| diggable_detail
+		| door_detail
+		| drawbridge_detail
+		| engraving_detail
+		| mineralize
+		| fountain_detail
+		| gold_detail
+		| switchstatement
+		| forstatement
+		| loopstatement
+		| ifstatement
+		| chancestatement
+		| exitstatement
+		| breakstatement
+		| function_define
+		| function_call
+		| ladder_detail
+		| map_definition
+		| mazewalk_detail
+		| monster_detail
+		| object_detail
+		| passwall_detail
+		| pool_detail
+		| portal_region
+		| random_corridors
+		| region_detail
+		| room_def
+		| subroom_def
+		| sink_detail
+		| terrain_detail
+		| replace_terrain_detail
+		| stair_detail
+		| stair_region
+		| teleprt_region
+		| trap_detail
+		| wallify_detail
+		;
+
+any_var_array	: VARSTRING_INT_ARRAY
+		| VARSTRING_STRING_ARRAY
+		| VARSTRING_VAR_ARRAY
+		| VARSTRING_COORD_ARRAY
+		| VARSTRING_REGION_ARRAY
+		| VARSTRING_MAPCHAR_ARRAY
+		| VARSTRING_MONST_ARRAY
+		| VARSTRING_OBJ_ARRAY
+		| VARSTRING_SEL_ARRAY
+		;
+
+any_var		: VARSTRING_INT
+		| VARSTRING_STRING
+		| VARSTRING_VAR
+		| VARSTRING_COORD
+		| VARSTRING_REGION
+		| VARSTRING_MAPCHAR
+		| VARSTRING_MONST
+		| VARSTRING_OBJ
+		| VARSTRING_SEL
+		;
+
+any_var_or_arr	: any_var_array
+		| any_var
+		| VARSTRING
+		;
+
+any_var_or_unk	: VARSTRING
+		| any_var
+		;
+
+shuffle_detail	: SHUFFLE_ID ':' any_var_array
 		  {
-			if(special_lev.nrobjects) {
-			    yyerror("Object registers already initialized!");
-			} else {
-			    special_lev.nrobjects = n_olist;
-			    special_lev.robjects = (char *) alloc(n_olist);
-			    (void) memcpy((genericptr_t)special_lev.robjects,
-					  (genericptr_t)olist, n_olist);
-			}
+		      struct lc_vardefs *vd;
+		      if ((vd = vardef_defined(variable_definitions, $3, 1))) {
+			  if (!(vd->var_type & SPOVAR_ARRAY))
+			      lc_error("Trying to shuffle non-array variable '%s'", $3);
+		      } else lc_error("Trying to shuffle undefined variable '%s'", $3);
+		      add_opvars(splev, "so", $3, SPO_SHUFFLE_ARRAY);
+		      Free($3);
 		  }
-		| RANDOM_MONSTERS_ID ':' monster_list
+		;
+
+variable_define	: any_var_or_arr '=' math_expr_var
 		  {
-			if(special_lev.nrmonst) {
-			    yyerror("Monster registers already initialized!");
-			} else {
-			    special_lev.nrmonst = n_mlist;
-			    special_lev.rmonst = (char *) alloc(n_mlist);
-			    (void) memcpy((genericptr_t)special_lev.rmonst,
-					  (genericptr_t)mlist, n_mlist);
+		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_INT);
+		      add_opvars(splev, "iso", 0, $1, SPO_VAR_INIT);
+		      Free($1);
+		  }
+		| any_var_or_arr '=' selection_ID ':' ter_selection
+		  {
+		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_SEL);
+		      add_opvars(splev, "iso", 0, $1, SPO_VAR_INIT);
+		      Free($1);
+		  }
+		| any_var_or_arr '=' string_expr
+		  {
+		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_STRING);
+		      add_opvars(splev, "iso", 0, $1, SPO_VAR_INIT);
+		      Free($1);
+		  }
+		| any_var_or_arr '=' terrainid ':' mapchar_or_var
+		  {
+		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_MAPCHAR);
+		      add_opvars(splev, "iso", 0, $1, SPO_VAR_INIT);
+		      Free($1);
+		  }
+		| any_var_or_arr '=' monsterid ':' monster_or_var
+		  {
+		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_MONST);
+		      add_opvars(splev, "iso", 0, $1, SPO_VAR_INIT);
+		      Free($1);
+		  }
+		| any_var_or_arr '=' objectid ':' object_or_var
+		  {
+		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_OBJ);
+		      add_opvars(splev, "iso", 0, $1, SPO_VAR_INIT);
+		      Free($1);
+		  }
+		| any_var_or_arr '=' coord_or_var
+		  {
+		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_COORD);
+		      add_opvars(splev, "iso", 0, $1, SPO_VAR_INIT);
+		      Free($1);
+		  }
+		| any_var_or_arr '=' region_or_var
+		  {
+		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_REGION);
+		      add_opvars(splev, "iso", 0, $1, SPO_VAR_INIT);
+		      Free($1);
+		  }
+		| any_var_or_arr '=' '{' integer_list '}'
+		  {
+		      long n_items = $4;
+		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_INT|SPOVAR_ARRAY);
+		      add_opvars(splev, "iso", n_items, $1, SPO_VAR_INIT);
+		      Free($1);
+		  }
+		| any_var_or_arr '=' '{' encodecoord_list '}'
+		  {
+		      long n_items = $4;
+		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_COORD|SPOVAR_ARRAY);
+		      add_opvars(splev, "iso", n_items, $1, SPO_VAR_INIT);
+		      Free($1);
+		  }
+		| any_var_or_arr '=' '{' encoderegion_list '}'
+		  {
+		      long n_items = $4;
+		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_REGION|SPOVAR_ARRAY);
+		      add_opvars(splev, "iso", n_items, $1, SPO_VAR_INIT);
+		      Free($1);
+		  }
+		| any_var_or_arr '=' terrainid ':' '{' mapchar_list '}'
+		  {
+		      long n_items = $6;
+		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_MAPCHAR|SPOVAR_ARRAY);
+		      add_opvars(splev, "iso", n_items, $1, SPO_VAR_INIT);
+		      Free($1);
+		  }
+		| any_var_or_arr '=' monsterid ':' '{' encodemonster_list '}'
+		  {
+		      long n_items = $6;
+		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_MONST|SPOVAR_ARRAY);
+		      add_opvars(splev, "iso", n_items, $1, SPO_VAR_INIT);
+		      Free($1);
+		  }
+		| any_var_or_arr '=' objectid ':' '{' encodeobj_list '}'
+		  {
+		      long n_items = $6;
+		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_OBJ|SPOVAR_ARRAY);
+		      add_opvars(splev, "iso", n_items, $1, SPO_VAR_INIT);
+		      Free($1);
+		  }
+		| any_var_or_arr '=' '{' string_list '}'
+		  {
+		      long n_items = $4;
+		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_STRING|SPOVAR_ARRAY);
+		      add_opvars(splev, "iso", n_items, $1, SPO_VAR_INIT);
+		      Free($1);
+		  }
+		;
+
+encodeobj_list	: encodeobj
+		  {
+		      add_opvars(splev, "O", $1);
+		      $$ = 1;
+		  }
+		| encodeobj_list ',' encodeobj
+		  {
+		      add_opvars(splev, "O", $3);
+		      $$ = 1 + $1;
+		  }
+		;
+
+encodemonster_list	: encodemonster
+		  {
+		      add_opvars(splev, "M", $1);
+		      $$ = 1;
+		  }
+		| encodemonster_list ',' encodemonster
+		  {
+		      add_opvars(splev, "M", $3);
+		      $$ = 1 + $1;
+		  }
+		;
+
+mapchar_list	: mapchar
+		  {
+		      add_opvars(splev, "m", $1);
+		      $$ = 1;
+		  }
+		| mapchar_list ',' mapchar
+		  {
+		      add_opvars(splev, "m", $3);
+		      $$ = 1 + $1;
+		  }
+		;
+
+encoderegion_list	: encoderegion
+		  {
+		      $$ = 1;
+		  }
+		| encoderegion_list ',' encoderegion
+		  {
+		      $$ = 1 + $1;
+		  }
+		;
+
+encodecoord_list	: encodecoord
+		  {
+		      add_opvars(splev, "c", $1);
+		      $$ = 1;
+		  }
+		| encodecoord_list ',' encodecoord
+		  {
+		      add_opvars(splev, "c", $3);
+		      $$ = 1 + $1;
+		  }
+		;
+
+integer_list	: math_expr_var
+		  {
+		      $$ = 1;
+		  }
+		| integer_list ',' math_expr_var
+		  {
+		      $$ = 1 + $1;
+		  }
+		;
+
+string_list	: string_expr
+		  {
+		      $$ = 1;
+		  }
+		| string_list ',' string_expr
+		  {
+		      $$ = 1 + $1;
+		  }
+		;
+
+function_define	: FUNCTION_ID NQSTRING '('
+		  {
+		      struct lc_funcdefs *funcdef;
+
+		      if (in_function_definition)
+			  lc_error("Recursively defined functions not allowed (function %s).", $2);
+
+		      in_function_definition++;
+
+		      if (funcdef_defined(function_definitions, $2, 1))
+			  lc_error("Function '%s' already defined once.", $2);
+
+		      funcdef = funcdef_new(-1, $2);
+		      funcdef->next = function_definitions;
+		      function_definitions = funcdef;
+		      function_splev_backup = splev;
+		      splev = &(funcdef->code);
+		      Free($2);
+		      curr_function = funcdef;
+		      function_tmp_var_defs = variable_definitions;
+		      variable_definitions = NULL;
+		  }
+		func_params_list ')'
+		  {
+		      /* nothing */
+		  }
+		stmt_block
+		  {
+		      add_opvars(splev, "io", 0, SPO_RETURN);
+		      splev = function_splev_backup;
+		      in_function_definition--;
+		      curr_function = NULL;
+		      vardef_free_all(variable_definitions);
+		      variable_definitions = function_tmp_var_defs;
+		  }
+		;
+
+function_call	: NQSTRING '(' func_call_params_list ')'
+		  {
+		      struct lc_funcdefs *tmpfunc;
+		      tmpfunc = funcdef_defined(function_definitions, $1, 1);
+		      if (tmpfunc) {
+			  long l;
+			  long nparams = strlen( $3 );
+			  char *fparamstr = funcdef_paramtypes(tmpfunc);
+			  if (strcmp($3, fparamstr)) {
+			      char *tmps = strdup(decode_parm_str(fparamstr));
+			      lc_error("Function '%s' requires params '%s', got '%s' instead.", $1, tmps, decode_parm_str($3));
+			      Free(tmps);
 			  }
+			  Free(fparamstr);
+			  Free($3);
+			  if (!(tmpfunc->n_called)) {
+			      /* we haven't called the function yet, so insert it in the code */
+			      struct opvar *jmp = New(struct opvar);
+			      set_opvar_int(jmp, splev->n_opcodes+1);
+			      add_opcode(splev, SPO_PUSH, jmp);
+			      add_opcode(splev, SPO_JMP, NULL); /* we must jump past it first, then CALL it, due to RETURN. */
+
+			      tmpfunc->addr = splev->n_opcodes;
+
+			      { /* init function parameter variables */
+				  struct lc_funcdefs_parm *tfp = tmpfunc->params;
+				  while (tfp) {
+				      add_opvars(splev, "iso", 0, tfp->name, SPO_VAR_INIT);
+				      tfp = tfp->next;
+				  }
+			      }
+
+			      splev_add_from(splev, &(tmpfunc->code));
+			      set_opvar_int(jmp, splev->n_opcodes - jmp->vardata.l);
+			  }
+			  l = tmpfunc->addr - splev->n_opcodes - 2;
+			  add_opvars(splev, "iio", nparams, l, SPO_CALL);
+			  tmpfunc->n_called++;
+		      } else {
+			  lc_error("Function '%s' not defined.", $1);
+		      }
+		      Free($1);
 		  }
 		;
 
-rooms		: /* Nothing  -  dummy room for use with INIT_MAP */
+exitstatement	: EXIT_ID
 		  {
-			tmproom[nrooms] = New(room);
-			tmproom[nrooms]->name = (char *) 0;
-			tmproom[nrooms]->parent = (char *) 0;
-			tmproom[nrooms]->rtype = 0;
-			tmproom[nrooms]->rlit = 0;
-			tmproom[nrooms]->xalign = ERR;
-			tmproom[nrooms]->yalign = ERR;
-			tmproom[nrooms]->x = 0;
-			tmproom[nrooms]->y = 0;
-			tmproom[nrooms]->w = 2;
-			tmproom[nrooms]->h = 2;
-			in_room = 1;
+		      add_opcode(splev, SPO_EXIT, NULL);
 		  }
-		| roomlist
 		;
 
-roomlist	: aroom
-		| aroom roomlist
+opt_percent	: /* nothing */
+		  {
+		      $$ = 100;
+		  }
+		| PERCENT
+		  {
+		      $$ = $1;
+		  }
 		;
 
-corridors_def	: random_corridors
-		| corridors
+comparestmt     : PERCENT
+                  {
+		      /* val > rn2(100) */
+		      add_opvars(splev, "iio", (long)$1, 100, SPO_RN2);
+		      $$ = SPO_JG;
+                  }
+		| '[' math_expr_var COMPARE_TYPE math_expr_var ']'
+                  {
+		      $$ = $3;
+                  }
+		| '[' math_expr_var ']'
+                  {
+		      /* boolean, explicit foo != 0 */
+		      add_opvars(splev, "i", 0);
+		      $$ = SPO_JNE;
+                  }
+		;
+
+switchstatement	: SWITCH_ID
+		  {
+		      is_inconstant_number = 0;
+		  }
+		  '[' integer_or_var ']'
+		  {
+		      struct opvar *chkjmp;
+		      if (in_switch_statement > 0)
+			  lc_error("Cannot nest switch-statements.");
+
+		      in_switch_statement++;
+
+		      n_switch_case_list = 0;
+		      switch_default_case = NULL;
+
+		      if (!is_inconstant_number)
+			  add_opvars(splev, "o", SPO_RN2);
+		      is_inconstant_number = 0;
+
+		      chkjmp = New(struct opvar);
+		      set_opvar_int(chkjmp, splev->n_opcodes+1);
+		      switch_check_jump = chkjmp;
+		      add_opcode(splev, SPO_PUSH, chkjmp);
+		      add_opcode(splev, SPO_JMP, NULL);
+		      break_stmt_start();
+		  }
+		'{' switchcases '}'
+		  {
+		      struct opvar *endjump = New(struct opvar);
+		      int i;
+
+		      set_opvar_int(endjump, splev->n_opcodes+1);
+
+		      add_opcode(splev, SPO_PUSH, endjump);
+		      add_opcode(splev, SPO_JMP, NULL);
+
+		      set_opvar_int(switch_check_jump, splev->n_opcodes - switch_check_jump->vardata.l);
+
+		      for (i = 0; i < n_switch_case_list; i++) {
+			  add_opvars(splev, "oio", SPO_COPY, switch_case_value[i], SPO_CMP);
+			  set_opvar_int(switch_case_list[i], switch_case_list[i]->vardata.l - splev->n_opcodes-1);
+			  add_opcode(splev, SPO_PUSH, switch_case_list[i]);
+			  add_opcode(splev, SPO_JE, NULL);
+		      }
+
+		      if (switch_default_case) {
+			  set_opvar_int(switch_default_case, switch_default_case->vardata.l - splev->n_opcodes-1);
+			  add_opcode(splev, SPO_PUSH, switch_default_case);
+			  add_opcode(splev, SPO_JMP, NULL);
+		      }
+
+		      set_opvar_int(endjump, splev->n_opcodes - endjump->vardata.l);
+
+		      break_stmt_end(splev);
+
+		      add_opcode(splev, SPO_POP, NULL); /* get rid of the value in stack */
+		      in_switch_statement--;
+
+
+		  }
+		;
+
+switchcases	: /* nothing */
+		| switchcase switchcases
+		;
+
+switchcase	: CASE_ID all_integers ':'
+		  {
+		      if (n_switch_case_list < MAX_SWITCH_CASES) {
+			  struct opvar *tmppush = New(struct opvar);
+			  set_opvar_int(tmppush, splev->n_opcodes);
+			  switch_case_value[n_switch_case_list] = $2;
+			  switch_case_list[n_switch_case_list++] = tmppush;
+		      } else lc_error("Too many cases in a switch.");
+		  }
+		levstatements
+		  {
+		  }
+		| DEFAULT_ID ':'
+		  {
+		      struct opvar *tmppush = New(struct opvar);
+
+		      if (switch_default_case)
+			  lc_error("Switch default case already used.");
+
+		      set_opvar_int(tmppush, splev->n_opcodes);
+		      switch_default_case = tmppush;
+		  }
+		levstatements
+		  {
+		  }
+		;
+
+breakstatement	: BREAK_ID
+		  {
+		      if (!allow_break_statements)
+			  lc_error("Cannot use BREAK outside a statement block.");
+		      else {
+			  break_stmt_new(splev, splev->n_opcodes);
+		      }
+		  }
+		;
+
+for_to_span	: '.' '.'
+		| TO_ID
+		;
+
+forstmt_start	: FOR_ID any_var_or_unk '=' math_expr_var for_to_span math_expr_var
+		  {
+		      char buf[256], buf2[256];
+
+		      if (n_forloops >= MAX_NESTED_IFS) {
+			  lc_error("FOR: Too deeply nested loops.");
+			  n_forloops = MAX_NESTED_IFS - 1;
+		      }
+
+		      /* first, define a variable for the for-loop end value */
+		      snprintf(buf, 255, "%s end", $2);
+		      /* the value of which is already in stack (the 2nd math_expr) */
+		      add_opvars(splev, "iso", 0, buf, SPO_VAR_INIT);
+
+		      variable_definitions = add_vardef_type(variable_definitions, $2, SPOVAR_INT);
+		      /* define the for-loop variable. value is in stack (1st math_expr) */
+		      add_opvars(splev, "iso", 0, $2, SPO_VAR_INIT);
+
+		      /* calculate value for the loop "step" variable */
+		      snprintf(buf2, 255, "%s step", $2);
+		      add_opvars(splev, "vvo", buf, $2, SPO_MATH_SUB); /* end - start */
+		      add_opvars(splev, "o", SPO_MATH_SIGN); /* sign of that */
+		      add_opvars(splev, "iso", 0, buf2, SPO_VAR_INIT); /* save the sign into the step var */
+
+		      forloop_list[n_forloops].varname = strdup($2);
+		      forloop_list[n_forloops].jmp_point = splev->n_opcodes;
+
+		      n_forloops++;
+		      Free($2);
+		  }
+		;
+
+forstatement	: forstmt_start
+		  {
+		      /* nothing */
+		      break_stmt_start();
+		  }
+		 stmt_block
+		  {
+		      char buf[256], buf2[256];
+		      n_forloops--;
+		      snprintf(buf, 255, "%s step", forloop_list[n_forloops].varname);
+		      snprintf(buf2, 255, "%s end", forloop_list[n_forloops].varname);
+		      /* compare for-loop var to end value */
+		      add_opvars(splev, "vvo", forloop_list[n_forloops].varname, buf2, SPO_CMP);
+		      /* var + step */
+		      add_opvars(splev, "vvo", buf,
+				 forloop_list[n_forloops].varname, SPO_MATH_ADD);
+		      /* for-loop var = (for-loop var + step) */
+		      add_opvars(splev, "iso", 0, forloop_list[n_forloops].varname, SPO_VAR_INIT);
+		      /* jump back if compared values were not equal */
+		      add_opvars(splev, "io", forloop_list[n_forloops].jmp_point - splev->n_opcodes - 1, SPO_JNE);
+		      Free(forloop_list[n_forloops].varname);
+		      break_stmt_end(splev);
+		  }
+		;
+
+loopstatement	: LOOP_ID '[' integer_or_var ']'
+		  {
+		      struct opvar *tmppush = New(struct opvar);
+
+		      if (n_if_list >= MAX_NESTED_IFS) {
+			  lc_error("LOOP: Too deeply nested conditionals.");
+			  n_if_list = MAX_NESTED_IFS - 1;
+		      }
+		      set_opvar_int(tmppush, splev->n_opcodes);
+		      if_list[n_if_list++] = tmppush;
+
+		      add_opvars(splev, "o", SPO_DEC);
+		      break_stmt_start();
+		  }
+		 stmt_block
+		  {
+		      struct opvar *tmppush;
+
+		      add_opvars(splev, "oio", SPO_COPY, 0, SPO_CMP);
+
+		      tmppush = (struct opvar *) if_list[--n_if_list];
+		      set_opvar_int(tmppush, tmppush->vardata.l - splev->n_opcodes-1);
+		      add_opcode(splev, SPO_PUSH, tmppush);
+		      add_opcode(splev, SPO_JG, NULL);
+		      add_opcode(splev, SPO_POP, NULL); /* get rid of the count value in stack */
+		      break_stmt_end(splev);
+		  }
+		;
+
+chancestatement	: comparestmt ':'
+		  {
+		      struct opvar *tmppush2 = New(struct opvar);
+
+		      if (n_if_list >= MAX_NESTED_IFS) {
+			  lc_error("IF: Too deeply nested conditionals.");
+			  n_if_list = MAX_NESTED_IFS - 1;
+		      }
+
+		      add_opcode(splev, SPO_CMP, NULL);
+
+		      set_opvar_int(tmppush2, splev->n_opcodes+1);
+
+		      if_list[n_if_list++] = tmppush2;
+
+		      add_opcode(splev, SPO_PUSH, tmppush2);
+
+		      add_opcode(splev, reverse_jmp_opcode( $1 ), NULL);
+
+		  }
+		levstatement
+		  {
+		      if (n_if_list > 0) {
+			  struct opvar *tmppush;
+			  tmppush = (struct opvar *) if_list[--n_if_list];
+			  set_opvar_int(tmppush, splev->n_opcodes - tmppush->vardata.l);
+		      } else lc_error("IF: Huh?!  No start address?");
+		  }
+		;
+
+ifstatement 	: IF_ID comparestmt
+		  {
+		      struct opvar *tmppush2 = New(struct opvar);
+
+		      if (n_if_list >= MAX_NESTED_IFS) {
+			  lc_error("IF: Too deeply nested conditionals.");
+			  n_if_list = MAX_NESTED_IFS - 1;
+		      }
+
+		      add_opcode(splev, SPO_CMP, NULL);
+
+		      set_opvar_int(tmppush2, splev->n_opcodes+1);
+
+		      if_list[n_if_list++] = tmppush2;
+
+		      add_opcode(splev, SPO_PUSH, tmppush2);
+
+		      add_opcode(splev, reverse_jmp_opcode( $2 ), NULL);
+
+		  }
+		 if_ending
+		  {
+		     /* do nothing */
+		  }
+		;
+
+if_ending	: stmt_block
+		  {
+		      if (n_if_list > 0) {
+			  struct opvar *tmppush;
+			  tmppush = (struct opvar *) if_list[--n_if_list];
+			  set_opvar_int(tmppush, splev->n_opcodes - tmppush->vardata.l);
+		      } else lc_error("IF: Huh?!  No start address?");
+		  }
+		| stmt_block
+		  {
+		      if (n_if_list > 0) {
+			  struct opvar *tmppush = New(struct opvar);
+			  struct opvar *tmppush2;
+
+			  set_opvar_int(tmppush, splev->n_opcodes+1);
+			  add_opcode(splev, SPO_PUSH, tmppush);
+
+			  add_opcode(splev, SPO_JMP, NULL);
+
+			  tmppush2 = (struct opvar *) if_list[--n_if_list];
+
+			  set_opvar_int(tmppush2, splev->n_opcodes - tmppush2->vardata.l);
+			  if_list[n_if_list++] = tmppush;
+		      } else lc_error("IF: Huh?!  No else-part address?");
+		  }
+		 ELSE_ID stmt_block
+		  {
+		      if (n_if_list > 0) {
+			  struct opvar *tmppush;
+			  tmppush = (struct opvar *) if_list[--n_if_list];
+			  set_opvar_int(tmppush, splev->n_opcodes - tmppush->vardata.l);
+		      } else lc_error("IF: Huh?! No end address?");
+		  }
+		;
+
+message		: MESSAGE_ID ':' string_expr
+		  {
+		      add_opvars(splev, "o", SPO_MESSAGE);
+		  }
 		;
 
 random_corridors: RAND_CORRIDOR_ID
 		  {
-			tmpcor[0] = New(corridor);
-			tmpcor[0]->src.room = -1;
-			ncorridor = 1;
+		      add_opvars(splev, "iiiiiio", -1,  0, -1, -1, -1, -1, SPO_CORRIDOR);
+		  }
+		| RAND_CORRIDOR_ID ':' all_integers
+		  {
+		      add_opvars(splev, "iiiiiio", -1, $3, -1, -1, -1, -1, SPO_CORRIDOR);
+		  }
+		| RAND_CORRIDOR_ID ':' RANDOM_TYPE
+		  {
+		      add_opvars(splev, "iiiiiio", -1, -1, -1, -1, -1, -1, SPO_CORRIDOR);
 		  }
-		;
-
-corridors	: /* nothing */
-		| corridors corridor
 		;
 
 corridor	: CORRIDOR_ID ':' corr_spec ',' corr_spec
 		  {
-			tmpcor[ncorridor] = New(corridor);
-			tmpcor[ncorridor]->src.room = $3.room;
-			tmpcor[ncorridor]->src.wall = $3.wall;
-			tmpcor[ncorridor]->src.door = $3.door;
-			tmpcor[ncorridor]->dest.room = $5.room;
-			tmpcor[ncorridor]->dest.wall = $5.wall;
-			tmpcor[ncorridor]->dest.door = $5.door;
-			ncorridor++;
-			if (ncorridor >= MAX_OF_TYPE) {
-				yyerror("Too many corridors in level!");
-				ncorridor--;
-			}
+		      add_opvars(splev, "iiiiiio",
+				 $3.room, $3.door, $3.wall,
+				 $5.room, $5.door, $5.wall,
+				 SPO_CORRIDOR);
 		  }
-		| CORRIDOR_ID ':' corr_spec ',' INTEGER
+		| CORRIDOR_ID ':' corr_spec ',' all_integers
 		  {
-			tmpcor[ncorridor] = New(corridor);
-			tmpcor[ncorridor]->src.room = $3.room;
-			tmpcor[ncorridor]->src.wall = $3.wall;
-			tmpcor[ncorridor]->src.door = $3.door;
-			tmpcor[ncorridor]->dest.room = -1;
-			tmpcor[ncorridor]->dest.wall = $5;
-			ncorridor++;
-			if (ncorridor >= MAX_OF_TYPE) {
-				yyerror("Too many corridors in level!");
-				ncorridor--;
-			}
+		      add_opvars(splev, "iiiiiio",
+				 $3.room, $3.door, $3.wall,
+				 -1, -1, (long)$5,
+				 SPO_CORRIDOR);
 		  }
 		;
 
 corr_spec	: '(' INTEGER ',' DIRECTION ',' door_pos ')'
 		  {
-			if ((unsigned) $2 >= nrooms)
-			    yyerror("Wrong room number!");
 			$$.room = $2;
 			$$.wall = $4;
 			$$.door = $6;
 		  }
 		;
 
-aroom		: room_def room_details
+room_begin      : room_type opt_percent ',' light_state
+                  {
+		      if (($2 < 100) && ($1 == OROOM))
+			  lc_error("Only typed rooms can have a chance.");
+		      else {
+			  add_opvars(splev, "iii", (long)$1, (long)$2, (long)$4);
+		      }
+                  }
+                ;
+
+subroom_def	: SUBROOM_ID ':' room_begin ',' subroom_pos ',' room_size optroomregionflags
 		  {
-			store_room();
+		      long flags = $8;
+		      if (flags == -1) flags = (1 << 0);
+		      add_opvars(splev, "iiiiiiio", flags, ERR, ERR,
+				 $5.x, $5.y, $7.width, $7.height, SPO_SUBROOM);
+		      break_stmt_start();
 		  }
-		| subroom_def room_details
+		  stmt_block
 		  {
-			store_room();
+		      break_stmt_end(splev);
+		      add_opcode(splev, SPO_ENDROOM, NULL);
 		  }
 		;
 
-subroom_def	: SUBROOM_ID ':' room_type ',' light_state ',' subroom_pos ',' room_size ',' string roomfill
+room_def	: ROOM_ID ':' room_begin ',' room_pos ',' room_align ',' room_size optroomregionflags
 		  {
-			tmproom[nrooms] = New(room);
-			tmproom[nrooms]->parent = $11;
-			tmproom[nrooms]->name = (char *) 0;
-			tmproom[nrooms]->rtype = $3;
-			tmproom[nrooms]->rlit = $5;
-			tmproom[nrooms]->filled = $12;
-			tmproom[nrooms]->xalign = ERR;
-			tmproom[nrooms]->yalign = ERR;
-			tmproom[nrooms]->x = current_coord.x;
-			tmproom[nrooms]->y = current_coord.y;
-			tmproom[nrooms]->w = current_size.width;
-			tmproom[nrooms]->h = current_size.height;
-			in_room = 1;
+		      long flags = $8;
+		      if (flags == -1) flags = (1 << 0);
+		      add_opvars(splev, "iiiiiiio", flags,
+				 $7.x, $7.y, $5.x, $5.y,
+				 $9.width, $9.height, SPO_ROOM);
+		      break_stmt_start();
 		  }
-		;
-
-room_def	: ROOM_ID ':' room_type ',' light_state ',' room_pos ',' room_align ',' room_size roomfill
+		  stmt_block
 		  {
-			tmproom[nrooms] = New(room);
-			tmproom[nrooms]->name = (char *) 0;
-			tmproom[nrooms]->parent = (char *) 0;
-			tmproom[nrooms]->rtype = $3;
-			tmproom[nrooms]->rlit = $5;
-			tmproom[nrooms]->filled = $12;
-			tmproom[nrooms]->xalign = current_align.x;
-			tmproom[nrooms]->yalign = current_align.y;
-			tmproom[nrooms]->x = current_coord.x;
-			tmproom[nrooms]->y = current_coord.y;
-			tmproom[nrooms]->w = current_size.width;
-			tmproom[nrooms]->h = current_size.height;
-			in_room = 1;
+		      break_stmt_end(splev);
+		      add_opcode(splev, SPO_ENDROOM, NULL);
 		  }
 		;
 
@@ -518,193 +1217,109 @@ room_pos	: '(' INTEGER ',' INTEGER ')'
 		  {
 			if ( $2 < 1 || $2 > 5 ||
 			    $4 < 1 || $4 > 5 ) {
-			    yyerror("Room position should be between 1 & 5!");
+			    lc_error("Room positions should be between 1-5: (%li,%li)!", $2, $4);
 			} else {
-			    current_coord.x = $2;
-			    current_coord.y = $4;
+			    $$.x = $2;
+			    $$.y = $4;
 			}
 		  }
 		| RANDOM_TYPE
 		  {
-			current_coord.x = current_coord.y = ERR;
+			$$.x = $$.y = ERR;
 		  }
 		;
 
 subroom_pos	: '(' INTEGER ',' INTEGER ')'
 		  {
 			if ( $2 < 0 || $4 < 0) {
-			    yyerror("Invalid subroom position !");
+			    lc_error("Invalid subroom position (%li,%li)!", $2, $4);
 			} else {
-			    current_coord.x = $2;
-			    current_coord.y = $4;
+			    $$.x = $2;
+			    $$.y = $4;
 			}
 		  }
 		| RANDOM_TYPE
 		  {
-			current_coord.x = current_coord.y = ERR;
+			$$.x = $$.y = ERR;
 		  }
 		;
 
 room_align	: '(' h_justif ',' v_justif ')'
 		  {
-			current_align.x = $2;
-			current_align.y = $4;
+		      $$.x = $2;
+		      $$.y = $4;
 		  }
 		| RANDOM_TYPE
 		  {
-			current_align.x = current_align.y = ERR;
+		      $$.x = $$.y = ERR;
 		  }
 		;
 
 room_size	: '(' INTEGER ',' INTEGER ')'
 		  {
-			current_size.width = $2;
-			current_size.height = $4;
+			$$.width = $2;
+			$$.height = $4;
 		  }
 		| RANDOM_TYPE
 		  {
-			current_size.height = current_size.width = ERR;
+			$$.height = $$.width = ERR;
 		  }
 		;
 
-room_details	: /* nothing */
-		| room_details room_detail
-		;
-
-room_detail	: room_name
-		| room_chance
-		| room_door
-		| monster_detail
-		| object_detail
-		| trap_detail
-		| altar_detail
-		| fountain_detail
-		| sink_detail
-		| pool_detail
-		| gold_detail
-		| engraving_detail
-		| stair_detail
-		;
-
-room_name	: NAME_ID ':' string
-		  {
-			if (tmproom[nrooms]->name)
-			    yyerror("This room already has a name!");
-			else
-			    tmproom[nrooms]->name = $3;
-		  }
-		;
-
-room_chance	: CHANCE_ID ':' INTEGER
-		   {
-			if (tmproom[nrooms]->chance)
-			    yyerror("This room already assigned a chance!");
-			else if (tmproom[nrooms]->rtype == OROOM)
-			    yyerror("Only typed rooms can have a chance!");
-			else if ($3 < 1 || $3 > 99)
-			    yyerror("The chance is supposed to be percentile.");
-			else
-			    tmproom[nrooms]->chance = $3;
-		   }
-		;
-
-room_door	: DOOR_ID ':' secret ',' door_state ',' door_wall ',' door_pos
+door_detail	: ROOMDOOR_ID ':' secret ',' door_state ',' door_wall ',' door_pos
 		  {
 			/* ERR means random here */
 			if ($7 == ERR && $9 != ERR) {
-		     yyerror("If the door wall is random, so must be its pos!");
+			    lc_error("If the door wall is random, so must be its pos!");
 			} else {
-			    tmprdoor[ndoor] = New(room_door);
-			    tmprdoor[ndoor]->secret = $3;
-			    tmprdoor[ndoor]->mask = $5;
-			    tmprdoor[ndoor]->wall = $7;
-			    tmprdoor[ndoor]->pos = $9;
-			    ndoor++;
-			    if (ndoor >= MAX_OF_TYPE) {
-				    yyerror("Too many doors in room!");
-				    ndoor--;
-			    }
+			    add_opvars(splev, "iiiio", (long)$9, (long)$5, (long)$3, (long)$7, SPO_ROOM_DOOR);
 			}
 		  }
+		| DOOR_ID ':' door_state ',' ter_selection
+		  {
+		      add_opvars(splev, "io", (long)$3, SPO_DOOR);
+		  }
 		;
 
 secret		: BOOLEAN
 		| RANDOM_TYPE
 		;
 
-door_wall	: DIRECTION
+door_wall	: dir_list
 		| RANDOM_TYPE
 		;
 
+dir_list	: DIRECTION
+		  {
+		      $$ = $1;
+		  }
+		| DIRECTION '|' dir_list
+		  {
+		      $$ = ($1 | $3);
+		  }
+		;
+
 door_pos	: INTEGER
 		| RANDOM_TYPE
 		;
 
-maze_def	: MAZE_ID ':' string ',' filling
-		  {
-			maze.filling = (schar) $5;
-			if (index($3, '.'))
-			    yyerror("Invalid dot ('.') in level name.");
-			if ((int) strlen($3) > 8)
-			    yyerror("Level names limited to 8 characters.");
-			$$ = $3;
-			in_room = 0;
-			n_plist = n_mlist = n_olist = 0;
-		  }
-		;
-
-filling		: CHAR
-		  {
-			$$ = get_floor_type((char)$1);
-		  }
-		| RANDOM_TYPE
-		  {
-			$$ = -1;
-		  }
-		;
-
-regions		: aregion
-		| aregion regions
-		;
-
-aregion		: map_definition reg_init map_details
-		  {
-			store_part();
-		  }
-		;
-
 map_definition	: NOMAP_ID
 		  {
-			tmppart[npart] = New(mazepart);
-			tmppart[npart]->halign = 1;
-			tmppart[npart]->valign = 1;
-			tmppart[npart]->nrobjects = 0;
-			tmppart[npart]->nloc = 0;
-			tmppart[npart]->nrmonst = 0;
-			tmppart[npart]->xsize = 1;
-			tmppart[npart]->ysize = 1;
-			tmppart[npart]->map = (char **) alloc(sizeof(char *));
-			tmppart[npart]->map[0] = (char *) alloc(1);
-			tmppart[npart]->map[0][0] = STONE;
-			max_x_map = COLNO-1;
-			max_y_map = ROWNO;
+		      add_opvars(splev, "ciisiio", 0, 0, 1, (char *)0, 0, 0, SPO_MAP);
+		      max_x_map = COLNO-1;
+		      max_y_map = ROWNO;
 		  }
-		| map_geometry MAP_ID
+		| GEOMETRY_ID ':' h_justif ',' v_justif roomfill MAP_ID
 		  {
-			tmppart[npart] = New(mazepart);
-			tmppart[npart]->halign = $<i>1 % 10;
-			tmppart[npart]->valign = $<i>1 / 10;
-			tmppart[npart]->nrobjects = 0;
-			tmppart[npart]->nloc = 0;
-			tmppart[npart]->nrmonst = 0;
-			scan_map($2);
-			Free($2);
+		      add_opvars(splev, "cii", SP_COORD_PACK(($3),($5)), 1, (long)$6);
+		      scan_map($7, splev);
+		      Free($7);
 		  }
-		;
-
-map_geometry	: GEOMETRY_ID ':' h_justif ',' v_justif
+		| GEOMETRY_ID ':' coord_or_var roomfill MAP_ID
 		  {
-			$<i>$ = $<i>3 + ($<i>5 * 10);
+		      add_opvars(splev, "ii", 2, (long)$4);
+		      scan_map($5, splev);
+		      Free($5);
 		  }
 		;
 
@@ -716,852 +1331,587 @@ v_justif	: TOP_OR_BOT
 		| CENTER
 		;
 
-reg_init	: /* nothing */
-		| reg_init init_reg
+monster_detail	: MONSTER_ID ':' monster_desc
+		  {
+		      add_opvars(splev, "io", 0, SPO_MONSTER);
+		  }
+		| MONSTER_ID ':' monster_desc
+		  {
+		      add_opvars(splev, "io", 1, SPO_MONSTER);
+		      in_container_obj++;
+		      break_stmt_start();
+		  }
+		stmt_block
+		 {
+		     break_stmt_end(splev);
+		     in_container_obj--;
+		     add_opvars(splev, "o", SPO_END_MONINVENT);
+		 }
 		;
 
-init_reg	: RANDOM_OBJECTS_ID ':' object_list
+monster_desc	: monster_or_var ',' coord_or_var monster_infos
 		  {
-			if (tmppart[npart]->nrobjects) {
-			    yyerror("Object registers already initialized!");
-			} else {
-			    tmppart[npart]->robjects = (char *)alloc(n_olist);
-			    (void) memcpy((genericptr_t)tmppart[npart]->robjects,
-					  (genericptr_t)olist, n_olist);
-			    tmppart[npart]->nrobjects = n_olist;
-			}
-		  }
-		| RANDOM_PLACES_ID ':' place_list
-		  {
-			if (tmppart[npart]->nloc) {
-			    yyerror("Location registers already initialized!");
-			} else {
-			    register int i;
-			    tmppart[npart]->rloc_x = (char *) alloc(n_plist);
-			    tmppart[npart]->rloc_y = (char *) alloc(n_plist);
-			    for(i=0;i<n_plist;i++) {
-				tmppart[npart]->rloc_x[i] = plist[i].x;
-				tmppart[npart]->rloc_y[i] = plist[i].y;
-			    }
-			    tmppart[npart]->nloc = n_plist;
-			}
-		  }
-		| RANDOM_MONSTERS_ID ':' monster_list
-		  {
-			if (tmppart[npart]->nrmonst) {
-			    yyerror("Monster registers already initialized!");
-			} else {
-			    tmppart[npart]->rmonst = (char *) alloc(n_mlist);
-			    (void) memcpy((genericptr_t)tmppart[npart]->rmonst,
-					  (genericptr_t)mlist, n_mlist);
-			    tmppart[npart]->nrmonst = n_mlist;
-			}
-		  }
-		;
-
-object_list	: object
-		  {
-			if (n_olist < MAX_REGISTERS)
-			    olist[n_olist++] = $<i>1;
-			else
-			    yyerror("Object list too long!");
-		  }
-		| object ',' object_list
-		  {
-			if (n_olist < MAX_REGISTERS)
-			    olist[n_olist++] = $<i>1;
-			else
-			    yyerror("Object list too long!");
-		  }
-		;
-
-monster_list	: monster
-		  {
-			if (n_mlist < MAX_REGISTERS)
-			    mlist[n_mlist++] = $<i>1;
-			else
-			    yyerror("Monster list too long!");
-		  }
-		| monster ',' monster_list
-		  {
-			if (n_mlist < MAX_REGISTERS)
-			    mlist[n_mlist++] = $<i>1;
-			else
-			    yyerror("Monster list too long!");
-		  }
-		;
-
-place_list	: place
-		  {
-			if (n_plist < MAX_REGISTERS)
-			    plist[n_plist++] = current_coord;
-			else
-			    yyerror("Location list too long!");
-		  }
-		| place
-		  {
-			if (n_plist < MAX_REGISTERS)
-			    plist[n_plist++] = current_coord;
-			else
-			    yyerror("Location list too long!");
-		  }
-		 ',' place_list
-		;
-
-map_details	: /* nothing */
-		| map_details map_detail
-		;
-
-map_detail	: monster_detail
-		| object_detail
-		| door_detail
-		| trap_detail
-		| drawbridge_detail
-		| region_detail
-		| stair_region
-		| portal_region
-		| teleprt_region
-		| branch_region
-		| altar_detail
-		| fountain_detail
-		| mazewalk_detail
-		| wallify_detail
-		| ladder_detail
-		| stair_detail
-		| gold_detail
-		| engraving_detail
-		| diggable_detail
-		| passwall_detail
-		;
-
-monster_detail	: MONSTER_ID chance ':' monster_c ',' m_name ',' coordinate
-		  {
-			tmpmonst[nmons] = New(monster);
-			tmpmonst[nmons]->x = current_coord.x;
-			tmpmonst[nmons]->y = current_coord.y;
-			tmpmonst[nmons]->class = $<i>4;
-			tmpmonst[nmons]->peaceful = -1; /* no override */
-			tmpmonst[nmons]->asleep = -1;
-			tmpmonst[nmons]->align = - MAX_REGISTERS - 2;
-			tmpmonst[nmons]->name.str = 0;
-			tmpmonst[nmons]->appear = 0;
-			tmpmonst[nmons]->appear_as.str = 0;
-			tmpmonst[nmons]->chance = $2;
-			tmpmonst[nmons]->id = NON_PM;
-			if (!in_room)
-			    check_coord(current_coord.x, current_coord.y,
-					"Monster");
-			if ($6) {
-			    int token = get_monster_id($6, (char) $<i>4);
-			    if (token == ERR)
-				yywarning(
-			      "Invalid monster name!  Making random monster.");
-			    else
-				tmpmonst[nmons]->id = token;
-			    Free($6);
-			}
-		  }
-		 monster_infos
-		  {
-			if (++nmons >= MAX_OF_TYPE) {
-			    yyerror("Too many monsters in room or mazepart!");
-			    nmons--;
-			}
+		      /* nothing */
 		  }
 		;
 
 monster_infos	: /* nothing */
-		| monster_infos monster_info
-		;
-
-monster_info	: ',' string
 		  {
-			tmpmonst[nmons]->name.str = $2;
+		      struct opvar *stopit = New(struct opvar);
+		      set_opvar_int(stopit, SP_M_V_END);
+		      add_opcode(splev, SPO_PUSH, stopit);
+		      $$ = 0x0000;
 		  }
-		| ',' MON_ATTITUDE
+		| monster_infos ',' monster_info
 		  {
-			tmpmonst[nmons]->peaceful = $<i>2;
-		  }
-		| ',' MON_ALERTNESS
-		  {
-			tmpmonst[nmons]->asleep = $<i>2;
-		  }
-		| ',' alignment
-		  {
-			tmpmonst[nmons]->align = $<i>2;
-		  }
-		| ',' MON_APPEARANCE string
-		  {
-			tmpmonst[nmons]->appear = $<i>2;
-			tmpmonst[nmons]->appear_as.str = $3;
+		      if (( $1 & $3 ))
+			  lc_error("MONSTER extra info defined twice.");
+		      $$ = ( $1 | $3 );
 		  }
 		;
 
-object_detail	: OBJECT_ID object_desc
+monster_info	: string_expr
 		  {
+		      add_opvars(splev, "i", SP_M_V_NAME);
+		      $$ = 0x0001;
 		  }
-		| COBJECT_ID object_desc
+		| MON_ATTITUDE
 		  {
-			/* 1: is contents of preceeding object with 2 */
-			/* 2: is a container */
-			/* 0: neither */
-			tmpobj[nobj-1]->containment = 2;
+		      add_opvars(splev, "ii", (long)$<i>1, SP_M_V_PEACEFUL);
+		      $$ = 0x0002;
+		  }
+		| MON_ALERTNESS
+		  {
+		      add_opvars(splev, "ii", (long)$<i>1, SP_M_V_ASLEEP);
+		      $$ = 0x0004;
+		  }
+		| alignment_prfx
+		  {
+		      add_opvars(splev, "ii", (long)$1, SP_M_V_ALIGN);
+		      $$ = 0x0008;
+		  }
+		| MON_APPEARANCE string_expr
+		  {
+		      add_opvars(splev, "ii", (long)$<i>1, SP_M_V_APPEAR);
+		      $$ = 0x0010;
+		  }
+		| FEMALE_ID
+		  {
+		      add_opvars(splev, "ii", 1, SP_M_V_FEMALE);
+		      $$ = 0x0020;
+		  }
+		| INVIS_ID
+		  {
+		      add_opvars(splev, "ii", 1, SP_M_V_INVIS);
+		      $$ = 0x0040;
+		  }
+		| CANCELLED_ID
+		  {
+		      add_opvars(splev, "ii", 1, SP_M_V_CANCELLED);
+		      $$ = 0x0080;
+		  }
+		| REVIVED_ID
+		  {
+		      add_opvars(splev, "ii", 1, SP_M_V_REVIVED);
+		      $$ = 0x0100;
+		  }
+		| AVENGE_ID
+		  {
+		      add_opvars(splev, "ii", 1, SP_M_V_AVENGE);
+		      $$ = 0x0200;
+		  }
+		| FLEEING_ID ':' integer_or_var
+		  {
+		      add_opvars(splev, "i", SP_M_V_FLEEING);
+		      $$ = 0x0400;
+		  }
+		| BLINDED_ID ':' integer_or_var
+		  {
+		      add_opvars(splev, "i", SP_M_V_BLINDED);
+		      $$ = 0x0800;
+		  }
+		| PARALYZED_ID ':' integer_or_var
+		  {
+		      add_opvars(splev, "i", SP_M_V_PARALYZED);
+		      $$ = 0x1000;
+		  }
+		| STUNNED_ID
+		  {
+		      add_opvars(splev, "ii", 1, SP_M_V_STUNNED);
+		      $$ = 0x2000;
+		  }
+		| CONFUSED_ID
+		  {
+		      add_opvars(splev, "ii", 1, SP_M_V_CONFUSED);
+		      $$ = 0x4000;
+		  }
+		| SEENTRAPS_ID ':' seen_trap_mask
+		  {
+		      add_opvars(splev, "ii", (long)$3, SP_M_V_SEENTRAPS);
+		      $$ = 0x8000;
 		  }
 		;
 
-object_desc	: chance ':' object_c ',' o_name
+seen_trap_mask	: STRING
 		  {
-			tmpobj[nobj] = New(object);
-			tmpobj[nobj]->class = $<i>3;
-			tmpobj[nobj]->corpsenm = NON_PM;
-			tmpobj[nobj]->curse_state = -1;
-			tmpobj[nobj]->name.str = 0;
-			tmpobj[nobj]->chance = $1;
-			tmpobj[nobj]->id = -1;
-			if ($5) {
-			    int token = get_object_id($5, $<i>3);
-			    if (token == ERR)
-				yywarning(
-				"Illegal object name!  Making random object.");
-			     else
-				tmpobj[nobj]->id = token;
-			    Free($5);
-			}
+		      int token = get_trap_type($1);
+		      if (token == ERR || token == 0)
+			  lc_error("Unknown trap type '%s'!", $1);
+		      $$ = (1L << (token - 1));
 		  }
-		 ',' object_where object_infos
+		| ALL_ID
 		  {
-			if (++nobj >= MAX_OF_TYPE) {
-			    yyerror("Too many objects in room or mazepart!");
-			    nobj--;
-			}
+		      $$ = (long) ~0;
+		  }
+		| STRING '|' seen_trap_mask
+		  {
+		      int token = get_trap_type($1);
+		      if (token == ERR || token == 0)
+			  lc_error("Unknown trap type '%s'!", $1);
+
+		      if ((1L << (token - 1)) & $3)
+			  lc_error("Monster seen_traps, trap '%s' listed twice.", $1);
+
+		      $$ = ((1L << (token - 1)) | $3);
 		  }
 		;
 
-object_where	: coordinate
+object_detail	: OBJECT_ID ':' object_desc
 		  {
-			tmpobj[nobj]->containment = 0;
-			tmpobj[nobj]->x = current_coord.x;
-			tmpobj[nobj]->y = current_coord.y;
-			if (!in_room)
-			    check_coord(current_coord.x, current_coord.y,
-					"Object");
+		      long cnt = 0;
+		      if (in_container_obj) cnt |= SP_OBJ_CONTENT;
+		      add_opvars(splev, "io", cnt, SPO_OBJECT);
 		  }
-		| CONTAINED
+		| COBJECT_ID ':' object_desc
 		  {
-			tmpobj[nobj]->containment = 1;
-			/* random coordinate, will be overridden anyway */
-			tmpobj[nobj]->x = -MAX_REGISTERS-1;
-			tmpobj[nobj]->y = -MAX_REGISTERS-1;
+		      long cnt = SP_OBJ_CONTAINER;
+		      if (in_container_obj) cnt |= SP_OBJ_CONTENT;
+		      add_opvars(splev, "io", cnt, SPO_OBJECT);
+		      in_container_obj++;
+		      break_stmt_start();
+		  }
+		stmt_block
+		 {
+		     break_stmt_end(splev);
+		     in_container_obj--;
+		     add_opcode(splev, SPO_POP_CONTAINER, NULL);
+		 }
+		;
+
+object_desc	: object_or_var object_infos
+		  {
+		      if (( $2 & 0x4000) && in_container_obj) lc_error("Object cannot have a coord when contained.");
+		      else if (!( $2 & 0x4000) && !in_container_obj) lc_error("Object needs a coord when not contained.");
 		  }
 		;
 
 object_infos	: /* nothing */
 		  {
-			tmpobj[nobj]->spe = -127;
-	/* Note below: we're trying to make as many of these optional as
-	 * possible.  We clearly can't make curse_state, enchantment, and
-	 * monster_id _all_ optional, since ",random" would be ambiguous.
-	 * We can't even just make enchantment mandatory, since if we do that
-	 * alone, ",random" requires too much lookahead to parse.
-	 */
+		      struct opvar *stopit = New(struct opvar);
+		      set_opvar_int(stopit, SP_O_V_END);
+		      add_opcode(splev, SPO_PUSH, stopit);
+		      $$ = 0x00;
 		  }
-		| ',' curse_state ',' monster_id ',' enchantment optional_name
-		  {
-		  }
-		| ',' curse_state ',' enchantment optional_name
-		  {
-		  }
-		| ',' monster_id ',' enchantment optional_name
+		| object_infos ',' object_info
 		  {
+		      if (( $1 & $3 ))
+			  lc_error("OBJECT extra info '%s' defined twice.", curr_token);
+		      $$ = ( $1 | $3 );
 		  }
 		;
 
-curse_state	: RANDOM_TYPE
+object_info	: CURSE_TYPE
 		  {
-			tmpobj[nobj]->curse_state = -1;
+		      add_opvars(splev, "ii", (long)$1, SP_O_V_CURSE);
+		      $$ = 0x0001;
 		  }
-		| CURSE_TYPE
+		| MONTYPE_ID ':' monster_or_var
 		  {
-			tmpobj[nobj]->curse_state = $1;
+		      add_opvars(splev, "i", SP_O_V_CORPSENM);
+		      $$ = 0x0002;
+		  }
+		| all_ints_push
+		  {
+		      add_opvars(splev, "i", SP_O_V_SPE);
+		      $$ = 0x0004;
+		  }
+		| NAME_ID ':' string_expr
+		  {
+		      add_opvars(splev, "i", SP_O_V_NAME);
+		      $$ = 0x0008;
+		  }
+		| QUANTITY_ID ':' integer_or_var
+		  {
+		      add_opvars(splev, "i", SP_O_V_QUAN);
+		      $$ = 0x0010;
+		  }
+		| BURIED_ID
+		  {
+		      add_opvars(splev, "ii", 1, SP_O_V_BURIED);
+		      $$ = 0x0020;
+		  }
+		| LIGHT_STATE
+		  {
+		      add_opvars(splev, "ii", (long)$1, SP_O_V_LIT);
+		      $$ = 0x0040;
+		  }
+		| ERODED_ID ':' integer_or_var
+		  {
+		      add_opvars(splev, "i", SP_O_V_ERODED);
+		      $$ = 0x0080;
+		  }
+		| ERODEPROOF_ID
+		  {
+		      add_opvars(splev, "ii", -1, SP_O_V_ERODED);
+		      $$ = 0x0080;
+		  }
+		| DOOR_STATE
+		  {
+		      if ($1 == D_LOCKED) {
+			  add_opvars(splev, "ii", 1, SP_O_V_LOCKED);
+			  $$ = 0x0100;
+		      } else if ($1 == D_BROKEN) {
+			  add_opvars(splev, "ii", 1, SP_O_V_BROKEN);
+			  $$ = 0x0200;
+		      } else
+			  lc_error("OBJECT state can only be locked or broken.");
+		  }
+		| TRAPPED_ID
+		  {
+		      add_opvars(splev, "ii", 1, SP_O_V_TRAPPED);
+		      $$ = 0x0400;
+		  }
+		| RECHARGED_ID ':' integer_or_var
+		  {
+		      add_opvars(splev, "i", SP_O_V_RECHARGED);
+		      $$ = 0x0800;
+		  }
+		| INVIS_ID
+		  {
+		      add_opvars(splev, "ii", 1, SP_O_V_INVIS);
+		      $$ = 0x1000;
+		  }
+		| GREASED_ID
+		  {
+		      add_opvars(splev, "ii", 1, SP_O_V_GREASED);
+		      $$ = 0x2000;
+		  }
+		| coord_or_var
+		  {
+		      add_opvars(splev, "i", SP_O_V_COORD);
+		      $$ = 0x4000;
 		  }
 		;
 
-monster_id	: STRING
+trap_detail	: TRAP_ID ':' trap_name ',' coord_or_var
 		  {
-			int token = get_monster_id($1, (char)0);
-			if (token == ERR)	/* "random" */
-			    tmpobj[nobj]->corpsenm = NON_PM - 1;
-			else
-			    tmpobj[nobj]->corpsenm = token;
-			Free($1);
+		      add_opvars(splev, "io", (long)$3, SPO_TRAP);
 		  }
 		;
 
-enchantment	: RANDOM_TYPE
-		  {
-			tmpobj[nobj]->spe = -127;
-		  }
-		| INTEGER
-		  {
-			tmpobj[nobj]->spe = $1;
-		  }
-		;
-
-optional_name	: /* nothing */
-		| ',' NONE
-		  {
-		  }
-		| ',' STRING
-		  {
-			tmpobj[nobj]->name.str = $2;
-		  }
-		;
-
-door_detail	: DOOR_ID ':' door_state ',' coordinate
-		  {
-			tmpdoor[ndoor] = New(door);
-			tmpdoor[ndoor]->x = current_coord.x;
-			tmpdoor[ndoor]->y = current_coord.y;
-			tmpdoor[ndoor]->mask = $<i>3;
-			if(current_coord.x >= 0 && current_coord.y >= 0 &&
-			   tmpmap[current_coord.y][current_coord.x] != DOOR &&
-			   tmpmap[current_coord.y][current_coord.x] != SDOOR)
-			    yyerror("Door decl doesn't match the map");
-			ndoor++;
-			if (ndoor >= MAX_OF_TYPE) {
-				yyerror("Too many doors in mazepart!");
-				ndoor--;
-			}
-		  }
-		;
-
-trap_detail	: TRAP_ID chance ':' trap_name ',' coordinate
-		  {
-			tmptrap[ntrap] = New(trap);
-			tmptrap[ntrap]->x = current_coord.x;
-			tmptrap[ntrap]->y = current_coord.y;
-			tmptrap[ntrap]->type = $<i>4;
-			tmptrap[ntrap]->chance = $2;
-			if (!in_room)
-			    check_coord(current_coord.x, current_coord.y,
-					"Trap");
-			if (++ntrap >= MAX_OF_TYPE) {
-				yyerror("Too many traps in room or mazepart!");
-				ntrap--;
-			}
-		  }
-		;
-
-drawbridge_detail: DRAWBRIDGE_ID ':' coordinate ',' DIRECTION ',' door_state
+drawbridge_detail: DRAWBRIDGE_ID ':' coord_or_var ',' DIRECTION ',' door_state
 		   {
-		        int x, y, dir;
+		       long d, state = 0;
+		       /* convert dir from a DIRECTION to a DB_DIR */
+		       d = $5;
+		       switch(d) {
+		       case W_NORTH: d = DB_NORTH; break;
+		       case W_SOUTH: d = DB_SOUTH; break;
+		       case W_EAST:  d = DB_EAST;  break;
+		       case W_WEST:  d = DB_WEST;  break;
+		       default:
+			   lc_error("Invalid drawbridge direction.");
+			   break;
+		       }
 
-			tmpdb[ndb] = New(drawbridge);
-			x = tmpdb[ndb]->x = current_coord.x;
-			y = tmpdb[ndb]->y = current_coord.y;
-			/* convert dir from a DIRECTION to a DB_DIR */
-			dir = $5;
-			switch(dir) {
-			case W_NORTH: dir = DB_NORTH; y--; break;
-			case W_SOUTH: dir = DB_SOUTH; y++; break;
-			case W_EAST:  dir = DB_EAST;  x++; break;
-			case W_WEST:  dir = DB_WEST;  x--; break;
-			default:
-			    yyerror("Invalid drawbridge direction");
-			    break;
-			}
-			tmpdb[ndb]->dir = dir;
-			if (current_coord.x >= 0 && current_coord.y >= 0 &&
-			    !IS_WALL(tmpmap[y][x])) {
-			    char ebuf[60];
-			    Sprintf(ebuf,
-				    "Wall needed for drawbridge (%02d, %02d)",
-				    current_coord.x, current_coord.y);
-			    yyerror(ebuf);
-			}
-
-			if ( $<i>7 == D_ISOPEN )
-			    tmpdb[ndb]->db_open = 1;
-			else if ( $<i>7 == D_CLOSED )
-			    tmpdb[ndb]->db_open = 0;
-			else if ($<i>7 == -1)	/* RANDOM_TYPE */
-			    tmpdb[ndb]->db_open = 127;	/* random */
-			else
-			    yyerror("A drawbridge can only be open, closed, or random!");
-			ndb++;
-			if (ndb >= MAX_OF_TYPE) {
-				yyerror("Too many drawbridges in mazepart!");
-				ndb--;
-			}
+		       if ( $7 == D_ISOPEN )
+			   state = 1;
+		       else if ( $7 == D_CLOSED )
+			   state = 0;
+		       else if ( $7 == -1 )
+			   state = -1;
+		       else
+			   lc_error("A drawbridge can only be open, closed or random!");
+		       add_opvars(splev, "iio", state, d, SPO_DRAWBRIDGE);
 		   }
 		;
 
-mazewalk_detail : MAZEWALK_ID ':' coordinate ',' DIRECTION
+mazewalk_detail : MAZEWALK_ID ':' coord_or_var ',' DIRECTION
 		  {
-			tmpwalk[nwalk] = New(walk);
-			tmpwalk[nwalk]->x = current_coord.x;
-			tmpwalk[nwalk]->y = current_coord.y;
-			tmpwalk[nwalk]->dir = $5;
-			nwalk++;
-			if (nwalk >= MAX_OF_TYPE) {
-				yyerror("Too many mazewalks in mazepart!");
-				nwalk--;
-			}
+		      add_opvars(splev, "iiio",
+				 (long)$5, 1, 0, SPO_MAZEWALK);
+		  }
+		| MAZEWALK_ID ':' coord_or_var ',' DIRECTION ',' BOOLEAN opt_fillchar
+		  {
+		      add_opvars(splev, "iiio",
+				 (long)$5, (long)$<i>7, (long)$8, SPO_MAZEWALK);
 		  }
 		;
 
 wallify_detail	: WALLIFY_ID
 		  {
-			wallify_map();
+		      add_opvars(splev, "rio", SP_REGION_PACK(-1,-1,-1,-1), 0, SPO_WALLIFY);
+		  }
+		| WALLIFY_ID ':' ter_selection
+		  {
+		      add_opvars(splev, "io", 1, SPO_WALLIFY);
 		  }
 		;
 
-ladder_detail	: LADDER_ID ':' coordinate ',' UP_OR_DOWN
+ladder_detail	: LADDER_ID ':' coord_or_var ',' UP_OR_DOWN
 		  {
-			tmplad[nlad] = New(lad);
-			tmplad[nlad]->x = current_coord.x;
-			tmplad[nlad]->y = current_coord.y;
-			tmplad[nlad]->up = $<i>5;
-			if (!in_room)
-			    check_coord(current_coord.x, current_coord.y,
-					"Ladder");
-			nlad++;
-			if (nlad >= MAX_OF_TYPE) {
-				yyerror("Too many ladders in mazepart!");
-				nlad--;
-			}
+		      add_opvars(splev, "io", (long)$<i>5, SPO_LADDER);
 		  }
 		;
 
-stair_detail	: STAIR_ID ':' coordinate ',' UP_OR_DOWN
+stair_detail	: STAIR_ID ':' coord_or_var ',' UP_OR_DOWN
 		  {
-			tmpstair[nstair] = New(stair);
-			tmpstair[nstair]->x = current_coord.x;
-			tmpstair[nstair]->y = current_coord.y;
-			tmpstair[nstair]->up = $<i>5;
-			if (!in_room)
-			    check_coord(current_coord.x, current_coord.y,
-					"Stairway");
-			nstair++;
-			if (nstair >= MAX_OF_TYPE) {
-				yyerror("Too many stairs in room or mazepart!");
-				nstair--;
-			}
+		      add_opvars(splev, "io", (long)$<i>5, SPO_STAIR);
 		  }
 		;
 
-stair_region	: STAIR_ID ':' lev_region
+stair_region	: STAIR_ID ':' lev_region ',' lev_region ',' UP_OR_DOWN
 		  {
-			tmplreg[nlreg] = New(lev_region);
-			tmplreg[nlreg]->in_islev = $3;
-			tmplreg[nlreg]->inarea.x1 = current_region.x1;
-			tmplreg[nlreg]->inarea.y1 = current_region.y1;
-			tmplreg[nlreg]->inarea.x2 = current_region.x2;
-			tmplreg[nlreg]->inarea.y2 = current_region.y2;
-		  }
-		 ',' lev_region ',' UP_OR_DOWN
-		  {
-			tmplreg[nlreg]->del_islev = $6;
-			tmplreg[nlreg]->delarea.x1 = current_region.x1;
-			tmplreg[nlreg]->delarea.y1 = current_region.y1;
-			tmplreg[nlreg]->delarea.x2 = current_region.x2;
-			tmplreg[nlreg]->delarea.y2 = current_region.y2;
-			if($8)
-			    tmplreg[nlreg]->rtype = LR_UPSTAIR;
-			else
-			    tmplreg[nlreg]->rtype = LR_DOWNSTAIR;
-			tmplreg[nlreg]->rname.str = 0;
-			nlreg++;
-			if (nlreg >= MAX_OF_TYPE) {
-				yyerror("Too many levregions in mazepart!");
-				nlreg--;
-			}
+		      add_opvars(splev, "iiiii iiiii iiso",
+				 $3.x1, $3.y1, $3.x2, $3.y2, $3.area,
+				 $5.x1, $5.y1, $5.x2, $5.y2, $5.area,
+				 (long)(($7) ? LR_UPSTAIR : LR_DOWNSTAIR),
+				 0, (char *)0, SPO_LEVREGION);
 		  }
 		;
 
-portal_region	: PORTAL_ID ':' lev_region
+portal_region	: PORTAL_ID ':' lev_region ',' lev_region ',' STRING
 		  {
-			tmplreg[nlreg] = New(lev_region);
-			tmplreg[nlreg]->in_islev = $3;
-			tmplreg[nlreg]->inarea.x1 = current_region.x1;
-			tmplreg[nlreg]->inarea.y1 = current_region.y1;
-			tmplreg[nlreg]->inarea.x2 = current_region.x2;
-			tmplreg[nlreg]->inarea.y2 = current_region.y2;
-		  }
-		 ',' lev_region ',' string
-		  {
-			tmplreg[nlreg]->del_islev = $6;
-			tmplreg[nlreg]->delarea.x1 = current_region.x1;
-			tmplreg[nlreg]->delarea.y1 = current_region.y1;
-			tmplreg[nlreg]->delarea.x2 = current_region.x2;
-			tmplreg[nlreg]->delarea.y2 = current_region.y2;
-			tmplreg[nlreg]->rtype = LR_PORTAL;
-			tmplreg[nlreg]->rname.str = $8;
-			nlreg++;
-			if (nlreg >= MAX_OF_TYPE) {
-				yyerror("Too many levregions in mazepart!");
-				nlreg--;
-			}
+		      add_opvars(splev, "iiiii iiiii iiso",
+				 $3.x1, $3.y1, $3.x2, $3.y2, $3.area,
+				 $5.x1, $5.y1, $5.x2, $5.y2, $5.area,
+				 LR_PORTAL, 0, $7, SPO_LEVREGION);
+		      Free($7);
 		  }
 		;
 
-teleprt_region	: TELEPRT_ID ':' lev_region
+teleprt_region	: TELEPRT_ID ':' lev_region ',' lev_region teleprt_detail
 		  {
-			tmplreg[nlreg] = New(lev_region);
-			tmplreg[nlreg]->in_islev = $3;
-			tmplreg[nlreg]->inarea.x1 = current_region.x1;
-			tmplreg[nlreg]->inarea.y1 = current_region.y1;
-			tmplreg[nlreg]->inarea.x2 = current_region.x2;
-			tmplreg[nlreg]->inarea.y2 = current_region.y2;
-		  }
-		 ',' lev_region
-		  {
-			tmplreg[nlreg]->del_islev = $6;
-			tmplreg[nlreg]->delarea.x1 = current_region.x1;
-			tmplreg[nlreg]->delarea.y1 = current_region.y1;
-			tmplreg[nlreg]->delarea.x2 = current_region.x2;
-			tmplreg[nlreg]->delarea.y2 = current_region.y2;
-		  }
-		teleprt_detail
-		  {
-			switch($<i>8) {
-			case -1: tmplreg[nlreg]->rtype = LR_TELE; break;
-			case 0: tmplreg[nlreg]->rtype = LR_DOWNTELE; break;
-			case 1: tmplreg[nlreg]->rtype = LR_UPTELE; break;
-			}
-			tmplreg[nlreg]->rname.str = 0;
-			nlreg++;
-			if (nlreg >= MAX_OF_TYPE) {
-				yyerror("Too many levregions in mazepart!");
-				nlreg--;
-			}
+		      long rtype = 0;
+		      switch($6) {
+		      case -1: rtype = LR_TELE; break;
+		      case  0: rtype = LR_DOWNTELE; break;
+		      case  1: rtype = LR_UPTELE; break;
+		      }
+		      add_opvars(splev, "iiiii iiiii iiso",
+				 $3.x1, $3.y1, $3.x2, $3.y2, $3.area,
+				 $5.x1, $5.y1, $5.x2, $5.y2, $5.area,
+				 rtype, 0, (char *)0, SPO_LEVREGION);
 		  }
 		;
 
-branch_region	: BRANCH_ID ':' lev_region
+branch_region	: BRANCH_ID ':' lev_region ',' lev_region
 		  {
-			tmplreg[nlreg] = New(lev_region);
-			tmplreg[nlreg]->in_islev = $3;
-			tmplreg[nlreg]->inarea.x1 = current_region.x1;
-			tmplreg[nlreg]->inarea.y1 = current_region.y1;
-			tmplreg[nlreg]->inarea.x2 = current_region.x2;
-			tmplreg[nlreg]->inarea.y2 = current_region.y2;
-		  }
-		 ',' lev_region
-		  {
-			tmplreg[nlreg]->del_islev = $6;
-			tmplreg[nlreg]->delarea.x1 = current_region.x1;
-			tmplreg[nlreg]->delarea.y1 = current_region.y1;
-			tmplreg[nlreg]->delarea.x2 = current_region.x2;
-			tmplreg[nlreg]->delarea.y2 = current_region.y2;
-			tmplreg[nlreg]->rtype = LR_BRANCH;
-			tmplreg[nlreg]->rname.str = 0;
-			nlreg++;
-			if (nlreg >= MAX_OF_TYPE) {
-				yyerror("Too many levregions in mazepart!");
-				nlreg--;
-			}
+		      add_opvars(splev, "iiiii iiiii iiso",
+				 $3.x1, $3.y1, $3.x2, $3.y2, $3.area,
+				 $5.x1, $5.y1, $5.x2, $5.y2, $5.area,
+				 (long)LR_BRANCH, 0, (char *)0, SPO_LEVREGION);
 		  }
 		;
 
 teleprt_detail	: /* empty */
 		  {
-			$<i>$ = -1;
+			$$ = -1;
 		  }
 		| ',' UP_OR_DOWN
 		  {
-			$<i>$ = $2;
+			$$ = $2;
 		  }
 		;
 
-lev_region	: region
+fountain_detail : FOUNTAIN_ID ':' ter_selection
 		  {
-			$$ = 0;
-		  }
-		| LEV '(' INTEGER ',' INTEGER ',' INTEGER ',' INTEGER ')'
-		  {
-/* This series of if statements is a hack for MSC 5.1.  It seems that its
-   tiny little brain cannot compile if these are all one big if statement. */
-			if ($3 <= 0 || $3 >= COLNO)
-				yyerror("Region out of level range!");
-			else if ($5 < 0 || $5 >= ROWNO)
-				yyerror("Region out of level range!");
-			else if ($7 <= 0 || $7 >= COLNO)
-				yyerror("Region out of level range!");
-			else if ($9 < 0 || $9 >= ROWNO)
-				yyerror("Region out of level range!");
-			current_region.x1 = $3;
-			current_region.y1 = $5;
-			current_region.x2 = $7;
-			current_region.y2 = $9;
-			$$ = 1;
+		      add_opvars(splev, "o", SPO_FOUNTAIN);
 		  }
 		;
 
-fountain_detail : FOUNTAIN_ID ':' coordinate
+sink_detail : SINK_ID ':' ter_selection
 		  {
-			tmpfountain[nfountain] = New(fountain);
-			tmpfountain[nfountain]->x = current_coord.x;
-			tmpfountain[nfountain]->y = current_coord.y;
-			if (!in_room)
-			    check_coord(current_coord.x, current_coord.y,
-					"Fountain");
-			nfountain++;
-			if (nfountain >= MAX_OF_TYPE) {
-			    yyerror("Too many fountains in room or mazepart!");
-			    nfountain--;
-			}
+		      add_opvars(splev, "o", SPO_SINK);
 		  }
 		;
 
-sink_detail : SINK_ID ':' coordinate
+pool_detail : POOL_ID ':' ter_selection
 		  {
-			tmpsink[nsink] = New(sink);
-			tmpsink[nsink]->x = current_coord.x;
-			tmpsink[nsink]->y = current_coord.y;
-			nsink++;
-			if (nsink >= MAX_OF_TYPE) {
-				yyerror("Too many sinks in room!");
-				nsink--;
-			}
+		      add_opvars(splev, "o", SPO_POOL);
 		  }
 		;
 
-pool_detail : POOL_ID ':' coordinate
+terrain_type	: CHAR
 		  {
-			tmppool[npool] = New(pool);
-			tmppool[npool]->x = current_coord.x;
-			tmppool[npool]->y = current_coord.y;
-			npool++;
-			if (npool >= MAX_OF_TYPE) {
-				yyerror("Too many pools in room!");
-				npool--;
-			}
+		      $$.lit = -2;
+		      $$.ter = what_map_char((char) $<i>1);
+		  }
+		| '(' CHAR ',' light_state ')'
+		  {
+		      $$.lit = $4;
+		      $$.ter = what_map_char((char) $<i>2);
 		  }
 		;
 
-diggable_detail : NON_DIGGABLE_ID ':' region
+replace_terrain_detail : REPLACE_TERRAIN_ID ':' region_or_var ',' mapchar_or_var ',' mapchar_or_var ',' SPERCENT
 		  {
-			tmpdig[ndig] = New(digpos);
-			tmpdig[ndig]->x1 = current_region.x1;
-			tmpdig[ndig]->y1 = current_region.y1;
-			tmpdig[ndig]->x2 = current_region.x2;
-			tmpdig[ndig]->y2 = current_region.y2;
-			ndig++;
-			if (ndig >= MAX_OF_TYPE) {
-				yyerror("Too many diggables in mazepart!");
-				ndig--;
-			}
+		      add_opvars(splev, "io", $9, SPO_REPLACETERRAIN);
 		  }
 		;
 
-passwall_detail : NON_PASSWALL_ID ':' region
+terrain_detail : TERRAIN_ID ':' ter_selection ',' mapchar_or_var
+		 {
+		     add_opvars(splev, "o", SPO_TERRAIN);
+		 }
+	       ;
+
+diggable_detail : NON_DIGGABLE_ID ':' region_or_var
 		  {
-			tmppass[npass] = New(digpos);
-			tmppass[npass]->x1 = current_region.x1;
-			tmppass[npass]->y1 = current_region.y1;
-			tmppass[npass]->x2 = current_region.x2;
-			tmppass[npass]->y2 = current_region.y2;
-			npass++;
-			if (npass >= 32) {
-				yyerror("Too many passwalls in mazepart!");
-				npass--;
-			}
+		     add_opvars(splev, "o", SPO_NON_DIGGABLE);
 		  }
 		;
 
-region_detail	: REGION_ID ':' region ',' light_state ',' room_type prefilled
+passwall_detail : NON_PASSWALL_ID ':' region_or_var
 		  {
-			tmpreg[nreg] = New(region);
-			tmpreg[nreg]->x1 = current_region.x1;
-			tmpreg[nreg]->y1 = current_region.y1;
-			tmpreg[nreg]->x2 = current_region.x2;
-			tmpreg[nreg]->y2 = current_region.y2;
-			tmpreg[nreg]->rlit = $<i>5;
-			tmpreg[nreg]->rtype = $<i>7;
-			if($<i>8 & 1) tmpreg[nreg]->rtype += MAXRTYPE+1;
-			tmpreg[nreg]->rirreg = (($<i>8 & 2) != 0);
-			if(current_region.x1 > current_region.x2 ||
-			   current_region.y1 > current_region.y2)
-			   yyerror("Region start > end!");
-			if(tmpreg[nreg]->rtype == VAULT &&
-			   (tmpreg[nreg]->rirreg ||
-			    (tmpreg[nreg]->x2 - tmpreg[nreg]->x1 != 1) ||
-			    (tmpreg[nreg]->y2 - tmpreg[nreg]->y1 != 1)))
-				yyerror("Vaults must be exactly 2x2!");
-			if(want_warnings && !tmpreg[nreg]->rirreg &&
-			   current_region.x1 > 0 && current_region.y1 > 0 &&
-			   current_region.x2 < (int)max_x_map &&
-			   current_region.y2 < (int)max_y_map) {
-			    /* check for walls in the room */
-			    char ebuf[60];
-			    register int x, y, nrock = 0;
-
-			    for(y=current_region.y1; y<=current_region.y2; y++)
-				for(x=current_region.x1;
-				    x<=current_region.x2; x++)
-				    if(IS_ROCK(tmpmap[y][x]) ||
-				       IS_DOOR(tmpmap[y][x])) nrock++;
-			    if(nrock) {
-				Sprintf(ebuf,
-					"Rock in room (%02d,%02d,%02d,%02d)?!",
-					current_region.x1, current_region.y1,
-					current_region.x2, current_region.y2);
-				yywarning(ebuf);
-			    }
-			    if (
-		!IS_ROCK(tmpmap[current_region.y1-1][current_region.x1-1]) ||
-		!IS_ROCK(tmpmap[current_region.y2+1][current_region.x1-1]) ||
-		!IS_ROCK(tmpmap[current_region.y1-1][current_region.x2+1]) ||
-		!IS_ROCK(tmpmap[current_region.y2+1][current_region.x2+1])) {
-				Sprintf(ebuf,
-				"NonRock edge in room (%02d,%02d,%02d,%02d)?!",
-					current_region.x1, current_region.y1,
-					current_region.x2, current_region.y2);
-				yywarning(ebuf);
-			    }
-			} else if(tmpreg[nreg]->rirreg &&
-		!IS_ROOM(tmpmap[current_region.y1][current_region.x1])) {
-			    char ebuf[60];
-			    Sprintf(ebuf,
-				    "Rock in irregular room (%02d,%02d)?!",
-				    current_region.x1, current_region.y1);
-			    yyerror(ebuf);
-			}
-			nreg++;
-			if (nreg >= MAX_OF_TYPE) {
-				yyerror("Too many regions in mazepart!");
-				nreg--;
-			}
+		     add_opvars(splev, "o", SPO_NON_PASSWALL);
 		  }
 		;
 
-altar_detail	: ALTAR_ID ':' coordinate ',' alignment ',' altar_type
+region_detail	: REGION_ID ':' region_or_var ',' light_state ',' room_type optroomregionflags
 		  {
-			tmpaltar[naltar] = New(altar);
-			tmpaltar[naltar]->x = current_coord.x;
-			tmpaltar[naltar]->y = current_coord.y;
-			tmpaltar[naltar]->align = $<i>5;
-			tmpaltar[naltar]->shrine = $<i>7;
-			if (!in_room)
-			    check_coord(current_coord.x, current_coord.y,
-					"Altar");
-			naltar++;
-			if (naltar >= MAX_OF_TYPE) {
-				yyerror("Too many altars in room or mazepart!");
-				naltar--;
-			}
+		      long irr;
+		      long rt = $7;
+		      long flags = $8;
+		      if (flags == -1) flags = (1 << 0);
+		      if (!(( flags ) & 1)) rt += MAXRTYPE+1;
+		      irr = ((( flags ) & 2) != 0);
+		      add_opvars(splev, "iiio",
+				 (long)$5, rt, flags, SPO_REGION);
+		      $<i>$ = (irr || (flags & 1) || rt != OROOM);
+		      break_stmt_start();
+		  }
+		  region_detail_end
+		  {
+		      break_stmt_end(splev);
+		      if ( $<i>9 ) {
+			  add_opcode(splev, SPO_ENDROOM, NULL);
+		      } else if ( $<i>10 )
+			  lc_error("Cannot use lev statements in non-permanent REGION");
 		  }
 		;
 
-gold_detail	: GOLD_ID ':' amount ',' coordinate
+region_detail_end : /* nothing */
 		  {
-			tmpgold[ngold] = New(gold);
-			tmpgold[ngold]->x = current_coord.x;
-			tmpgold[ngold]->y = current_coord.y;
-			tmpgold[ngold]->amount = $<i>3;
-			if (!in_room)
-			    check_coord(current_coord.x, current_coord.y,
-					"Gold");
-			ngold++;
-			if (ngold >= MAX_OF_TYPE) {
-				yyerror("Too many golds in room or mazepart!");
-				ngold--;
-			}
+		      $$ = 0;
+		  }
+		| stmt_block
+		  {
+		      $$ = $1;
 		  }
 		;
 
-engraving_detail: ENGRAVING_ID ':' coordinate ',' engraving_type ',' string
+altar_detail	: ALTAR_ID ':' coord_or_var ',' alignment ',' altar_type
 		  {
-			tmpengraving[nengraving] = New(engraving);
-			tmpengraving[nengraving]->x = current_coord.x;
-			tmpengraving[nengraving]->y = current_coord.y;
-			tmpengraving[nengraving]->engr.str = $7;
-			tmpengraving[nengraving]->etype = $<i>5;
-			if (!in_room)
-			    check_coord(current_coord.x, current_coord.y,
-					"Engraving");
-			nengraving++;
-			if (nengraving >= MAX_OF_TYPE) {
-			    yyerror("Too many engravings in room or mazepart!");
-			    nengraving--;
-			}
+		      add_opvars(splev, "iio", (long)$7, (long)$5, SPO_ALTAR);
 		  }
 		;
 
-monster_c	: monster
-		| RANDOM_TYPE
+grave_detail	: GRAVE_ID ':' coord_or_var ',' string_expr
 		  {
-			$<i>$ = - MAX_REGISTERS - 1;
+		      add_opvars(splev, "io", 2, SPO_GRAVE);
 		  }
-		| m_register
-		;
-
-object_c	: object
-		| RANDOM_TYPE
+		| GRAVE_ID ':' coord_or_var ',' RANDOM_TYPE
 		  {
-			$<i>$ = - MAX_REGISTERS - 1;
+		      add_opvars(splev, "sio",
+				 (char *)0, 1, SPO_GRAVE);
 		  }
-		| o_register
-		;
-
-m_name		: string
-		| RANDOM_TYPE
+		| GRAVE_ID ':' coord_or_var
 		  {
-			$$ = (char *) 0;
+		      add_opvars(splev, "sio",
+				 (char *)0, 0, SPO_GRAVE);
 		  }
 		;
 
-o_name		: string
-		| RANDOM_TYPE
+gold_detail	: GOLD_ID ':' math_expr_var ',' coord_or_var
 		  {
-			$$ = (char *) 0;
+		      add_opvars(splev, "o", SPO_GOLD);
 		  }
 		;
 
-trap_name	: string
+engraving_detail: ENGRAVING_ID ':' coord_or_var ',' engraving_type ',' string_expr
+		  {
+		      add_opvars(splev, "io",
+				 (long)$5, SPO_ENGRAVING);
+		  }
+		;
+
+mineralize	: MINERALIZE_ID ':' integer_or_var ',' integer_or_var ',' integer_or_var ',' integer_or_var
+		  {
+		      add_opvars(splev, "o", SPO_MINERALIZE);
+		  }
+		| MINERALIZE_ID
+		  {
+		      add_opvars(splev, "iiiio", -1L, -1L, -1L, -1L, SPO_MINERALIZE);
+		  }
+		;
+
+trap_name	: STRING
 		  {
 			int token = get_trap_type($1);
 			if (token == ERR)
-				yyerror("Unknown trap type!");
-			$<i>$ = token;
+			    lc_error("Unknown trap type '%s'!", $1);
+			$$ = token;
 			Free($1);
 		  }
 		| RANDOM_TYPE
 		;
 
-room_type	: string
+room_type	: STRING
 		  {
 			int token = get_room_type($1);
 			if (token == ERR) {
-				yywarning("Unknown room type!  Making ordinary room...");
-				$<i>$ = OROOM;
+			    lc_warning("Unknown room type \"%s\"!  Making ordinary room...", $1);
+				$$ = OROOM;
 			} else
-				$<i>$ = token;
+				$$ = token;
 			Free($1);
 		  }
 		| RANDOM_TYPE
 		;
 
-prefilled	: /* empty */
+optroomregionflags : /* empty */
 		  {
-			$<i>$ = 0;
+			$$ = -1;
 		  }
-		| ',' FILLING
+		| ',' roomregionflags
 		  {
-			$<i>$ = $2;
-		  }
-		| ',' FILLING ',' BOOLEAN
-		  {
-			$<i>$ = $2 + ($4 << 1);
+			$$ = $2;
 		  }
 		;
 
-coordinate	: coord
-		| p_register
-		| RANDOM_TYPE
+roomregionflags : roomregionflag
 		  {
-			current_coord.x = current_coord.y = -MAX_REGISTERS-1;
+			$$ = $1;
+		  }
+		| roomregionflag ',' roomregionflags
+		  {
+			$$ = $1 | $3;
+		  }
+		;
+
+/* 0 is the "default" here */
+roomregionflag : FILLING
+		  {
+		      $$ = ($1 << 0);
+		  }
+		| IRREGULAR
+		  {
+		      $$ = ($1 << 1);
+		  }
+		| JOINED
+		  {
+		      $$ = ($1 << 2);
 		  }
 		;
 
@@ -1577,7 +1927,15 @@ alignment	: ALIGNMENT
 		| a_register
 		| RANDOM_TYPE
 		  {
-			$<i>$ = - MAX_REGISTERS - 1;
+			$$ = - MAX_REGISTERS - 1;
+		  }
+		;
+
+alignment_prfx	: ALIGNMENT
+		| a_register
+		| A_REGISTER ':' RANDOM_TYPE
+		  {
+			$$ = - MAX_REGISTERS - 1;
 		  }
 		;
 
@@ -1585,99 +1943,555 @@ altar_type	: ALTAR_TYPE
 		| RANDOM_TYPE
 		;
 
-p_register	: P_REGISTER '[' INTEGER ']'
-		  {
-			if ( $3 >= MAX_REGISTERS )
-				yyerror("Register Index overflow!");
-			else
-				current_coord.x = current_coord.y = - $3 - 1;
-		  }
-		;
-
-o_register	: O_REGISTER '[' INTEGER ']'
-		  {
-			if ( $3 >= MAX_REGISTERS )
-				yyerror("Register Index overflow!");
-			else
-				$<i>$ = - $3 - 1;
-		  }
-		;
-
-m_register	: M_REGISTER '[' INTEGER ']'
-		  {
-			if ( $3 >= MAX_REGISTERS )
-				yyerror("Register Index overflow!");
-			else
-				$<i>$ = - $3 - 1;
-		  }
-		;
-
 a_register	: A_REGISTER '[' INTEGER ']'
 		  {
 			if ( $3 >= 3 )
-				yyerror("Register Index overflow!");
+				lc_error("Register Index overflow!");
 			else
-				$<i>$ = - $3 - 1;
+				$$ = - $3 - 1;
 		  }
 		;
 
-place		: coord
-		;
-
-monster		: CHAR
+string_or_var	: STRING
 		  {
-			if (check_monster_char((char) $1))
-				$<i>$ = $1 ;
-			else {
-				yyerror("Unknown monster class!");
-				$<i>$ = ERR;
-			}
+		      add_opvars(splev, "s", $1);
+		      Free($1);
 		  }
-		;
-
-object		: CHAR
+		| VARSTRING_STRING
 		  {
-			char c = $1;
-			if (check_object_char(c))
-				$<i>$ = c;
-			else {
-				yyerror("Unknown char class!");
-				$<i>$ = ERR;
-			}
+		      check_vardef_type(variable_definitions, $1, SPOVAR_STRING);
+		      vardef_used(variable_definitions, $1);
+		      add_opvars(splev, "v", $1);
+		      Free($1);
+		  }
+		| VARSTRING_STRING_ARRAY '[' math_expr_var ']'
+		  {
+		      check_vardef_type(variable_definitions, $1, SPOVAR_STRING|SPOVAR_ARRAY);
+		      vardef_used(variable_definitions, $1);
+		      add_opvars(splev, "v", $1);
+		      Free($1);
 		  }
 		;
 
-string		: STRING
+
+integer_or_var	: math_expr_var
+		  {
+		      /* nothing */
+		  }
 		;
 
-amount		: INTEGER
+coord_or_var	: encodecoord
+		  {
+		      add_opvars(splev, "c", $1);
+		  }
+		| rndcoord_ID '(' ter_selection ')'
+		  {
+		      add_opvars(splev, "o", SPO_SEL_RNDCOORD);
+		  }
+		| VARSTRING_COORD
+		  {
+		      check_vardef_type(variable_definitions, $1, SPOVAR_COORD);
+		      vardef_used(variable_definitions, $1);
+		      add_opvars(splev, "v", $1);
+		      Free($1);
+		  }
+		| VARSTRING_COORD_ARRAY '[' math_expr_var ']'
+		  {
+		      check_vardef_type(variable_definitions, $1, SPOVAR_COORD|SPOVAR_ARRAY);
+		      vardef_used(variable_definitions, $1);
+		      add_opvars(splev, "v", $1);
+		      Free($1);
+		  }
+		;
+
+encodecoord	: '(' INTEGER ',' INTEGER ')'
+		  {
+		      if ($2 < 0 || $4 < 0 || $2 >= COLNO || $4 >= ROWNO)
+			  lc_error("Coordinates (%li,%li) out of map range!", $2, $4);
+		      $$ = SP_COORD_PACK($2, $4);
+		  }
 		| RANDOM_TYPE
+		  {
+		      $$ = SP_COORD_PACK_RANDOM(0);
+		  }
+		| RANDOM_TYPE_BRACKET humidity_flags ']'
+		  {
+		      $$ = SP_COORD_PACK_RANDOM( $2 );
+		  }
 		;
 
-chance		: /* empty */
+humidity_flags	: HUMIDITY_TYPE
 		  {
-			$$ = 100;	/* default is 100% */
+		      $$ = $1;
 		  }
-		| PERCENT
+		| HUMIDITY_TYPE ',' humidity_flags
 		  {
-			if ($1 <= 0 || $1 > 100)
-			    yyerror("Expected percentile chance.");
-			$$ = $1;
+		      if (($1 & $3))
+			  lc_warning("Humidity flag used twice.");
+		      $$ = ($1 | $3);
 		  }
 		;
 
+region_or_var	: encoderegion
+		  {
+		      /* nothing */
+		  }
+		| VARSTRING_REGION
+		  {
+		      check_vardef_type(variable_definitions, $1, SPOVAR_REGION);
+		      vardef_used(variable_definitions, $1);
+		      add_opvars(splev, "v", $1);
+		      Free($1);
+		  }
+		| VARSTRING_REGION_ARRAY '[' math_expr_var ']'
+		  {
+		      check_vardef_type(variable_definitions, $1, SPOVAR_REGION|SPOVAR_ARRAY);
+		      vardef_used(variable_definitions, $1);
+		      add_opvars(splev, "v", $1);
+		      Free($1);
+		  }
+		;
+
+encoderegion	: '(' INTEGER ',' INTEGER ',' INTEGER ',' INTEGER ')'
+		  {
+		      long r = SP_REGION_PACK($2, $4, $6, $8);
+		      if ( $2 > $6 || $4 > $8 )
+			  lc_error("Region start > end: (%li,%li,%li,%li)!", $2, $4, $6, $8);
+
+		      add_opvars(splev, "r", r);
+		      $$ = r;
+		  }
+		;
+
+mapchar_or_var	: mapchar
+		  {
+		      add_opvars(splev, "m", $1);
+		  }
+		| VARSTRING_MAPCHAR
+		  {
+		      check_vardef_type(variable_definitions, $1, SPOVAR_MAPCHAR);
+		      vardef_used(variable_definitions, $1);
+		      add_opvars(splev, "v", $1);
+		      Free($1);
+		  }
+		| VARSTRING_MAPCHAR_ARRAY '[' math_expr_var ']'
+		  {
+		      check_vardef_type(variable_definitions, $1, SPOVAR_MAPCHAR|SPOVAR_ARRAY);
+		      vardef_used(variable_definitions, $1);
+		      add_opvars(splev, "v", $1);
+		      Free($1);
+		  }
+		;
+
+mapchar		: CHAR
+		  {
+		      if (what_map_char((char) $1) != INVALID_TYPE)
+			  $$ = SP_MAPCHAR_PACK(what_map_char((char) $1), -2);
+		      else {
+			  lc_error("Unknown map char type '%c'!", $1);
+			  $$ = SP_MAPCHAR_PACK(STONE, -2);
+		      }
+		  }
+		| '(' CHAR ',' light_state ')'
+		  {
+		      if (what_map_char((char) $2) != INVALID_TYPE)
+			  $$ = SP_MAPCHAR_PACK(what_map_char((char) $2), $4);
+		      else {
+			  lc_error("Unknown map char type '%c'!", $2);
+			  $$ = SP_MAPCHAR_PACK(STONE, $4);
+		      }
+		  }
+		;
+
+monster_or_var	: encodemonster
+		  {
+		      add_opvars(splev, "M", $1);
+		  }
+		| VARSTRING_MONST
+		  {
+		      check_vardef_type(variable_definitions, $1, SPOVAR_MONST);
+		      vardef_used(variable_definitions, $1);
+		      add_opvars(splev, "v", $1);
+		      Free($1);
+		  }
+		| VARSTRING_MONST_ARRAY '[' math_expr_var ']'
+		  {
+		      check_vardef_type(variable_definitions, $1, SPOVAR_MONST|SPOVAR_ARRAY);
+		      vardef_used(variable_definitions, $1);
+		      add_opvars(splev, "v", $1);
+		      Free($1);
+		  }
+		;
+
+encodemonster	: STRING
+                  {
+                      long m = get_monster_id($1, (char)0);
+                      if (m == ERR) {
+                          lc_error("Unknown monster \"%s\"!", $1);
+                          $$ = -1;
+                      } else
+                          $$ = SP_MONST_PACK(m, def_monsyms[(int)mons[m].mlet].sym);
+                  }
+                | CHAR
+                  {
+                        if (check_monster_char((char) $1))
+                            $$ = SP_MONST_PACK(-1, $1);
+                        else {
+                            lc_error("Unknown monster class '%c'!", $1);
+                            $$ = -1;
+                        }
+                  }
+                | '(' CHAR ',' STRING ')'
+                  {
+                      long m = get_monster_id($4, (char) $2);
+                      if (m == ERR) {
+                          lc_error("Unknown monster ('%c', \"%s\")!", $2, $4);
+                          $$ = -1;
+                      } else
+                          $$ = SP_MONST_PACK(m, $2);
+                  }
+                | RANDOM_TYPE
+                  {
+                      $$ = -1;
+                  }
+                ;
+
+object_or_var	: encodeobj
+		  {
+		      add_opvars(splev, "O", $1);
+		  }
+		| VARSTRING_OBJ
+		  {
+		      check_vardef_type(variable_definitions, $1, SPOVAR_OBJ);
+		      vardef_used(variable_definitions, $1);
+		      add_opvars(splev, "v", $1);
+		      Free($1);
+		  }
+		| VARSTRING_OBJ_ARRAY '[' math_expr_var ']'
+		  {
+		      check_vardef_type(variable_definitions, $1, SPOVAR_OBJ|SPOVAR_ARRAY);
+		      vardef_used(variable_definitions, $1);
+		      add_opvars(splev, "v", $1);
+		      Free($1);
+		  }
+		;
+
+encodeobj	: STRING
+		  {
+		      long m = get_object_id($1, (char)0);
+		      if (m == ERR) {
+			  lc_error("Unknown object \"%s\"!", $1);
+			  $$ = -1;
+		      } else
+			  $$ = SP_OBJ_PACK(m, 1); /* obj class != 0 to force generation of a specific item */
+
+		  }
+		| CHAR
+		  {
+			if (check_object_char((char) $1))
+			    $$ = SP_OBJ_PACK(-1, $1);
+			else {
+			    lc_error("Unknown object class '%c'!", $1);
+			    $$ = -1;
+			}
+		  }
+		| '(' CHAR ',' STRING ')'
+		  {
+		      long m = get_object_id($4, (char) $2);
+		      if (m == ERR) {
+			  lc_error("Unknown object ('%c', \"%s\")!", $2, $4);
+			  $$ = -1;
+		      } else
+			  $$ = SP_OBJ_PACK(m, $2);
+		  }
+		| RANDOM_TYPE
+		  {
+		      $$ = -1;
+		  }
+		;
+
+
+string_expr	: string_or_var                 { }
+		| string_expr '.' string_or_var
+		  {
+		      add_opvars(splev, "o", SPO_MATH_ADD);
+		  }
+		;
+
+math_expr_var	: INTEGER                       { add_opvars(splev, "i", $1 ); }
+		| dice				{ is_inconstant_number = 1; }
+		| '(' MINUS_INTEGER ')'         { add_opvars(splev, "i", $2 ); }
+		| VARSTRING_INT
+		  {
+		      check_vardef_type(variable_definitions, $1, SPOVAR_INT);
+		      vardef_used(variable_definitions, $1);
+		      add_opvars(splev, "v", $1);
+		      Free($1);
+		      is_inconstant_number = 1;
+		  }
+		| VARSTRING_INT_ARRAY '[' math_expr_var ']'
+		  {
+		      check_vardef_type(variable_definitions, $1, SPOVAR_INT|SPOVAR_ARRAY);
+		      vardef_used(variable_definitions, $1);
+		      add_opvars(splev, "v", $1);
+		      Free($1);
+		      is_inconstant_number = 1;
+		  }
+		| math_expr_var '+' math_expr_var       { add_opvars(splev, "o", SPO_MATH_ADD); }
+		| math_expr_var '-' math_expr_var       { add_opvars(splev, "o", SPO_MATH_SUB); }
+		| math_expr_var '*' math_expr_var       { add_opvars(splev, "o", SPO_MATH_MUL); }
+		| math_expr_var '/' math_expr_var       { add_opvars(splev, "o", SPO_MATH_DIV); }
+		| math_expr_var '%' math_expr_var       { add_opvars(splev, "o", SPO_MATH_MOD); }
+		| '(' math_expr_var ')'             { }
+		;
+
+func_param_type		: CFUNC_INT
+			  {
+			      if (!strcmp("int", $1) || !strcmp("integer", $1)) {
+				  $$ = (int)'i';
+			      } else lc_error("Unknown function parameter type '%s'", $1);
+			  }
+			| CFUNC_STR
+			  {
+			      if (!strcmp("str", $1) || !strcmp("string", $1)) {
+				  $$ = (int)'s';
+			      } else lc_error("Unknown function parameter type '%s'", $1);
+			  }
+			;
+
+func_param_part		: any_var_or_arr ':' func_param_type
+			  {
+			      struct lc_funcdefs_parm *tmp = New(struct lc_funcdefs_parm);
+
+			      if (!curr_function)
+				  lc_error("Function parameters outside function definition.");
+			      else if (!tmp)
+				  lc_error("Could not alloc function params.");
+			      else {
+				  tmp->name = strdup($1);
+				  tmp->parmtype = (char) $3;
+				  tmp->next = curr_function->params;
+				  curr_function->params = tmp;
+				  curr_function->n_params++;
+				  {
+				      long vt;
+				      switch (tmp->parmtype) {
+				      case 'i': vt = SPOVAR_INT; break;
+				      case 's': vt = SPOVAR_STRING; break;
+				      default: lc_error("Unknown func param conversion."); break;
+				      }
+				      variable_definitions = add_vardef_type(variable_definitions, $1, vt);
+				  }
+			      }
+			      Free($1);
+			  }
+			;
+
+
+func_param_list		: func_param_part
+			| func_param_list ',' func_param_part
+			;
+
+func_params_list	: /* nothing */
+			| func_param_list
+			;
+
+func_call_param_part	: math_expr_var
+			  {
+			      $$ = (int)'i';
+			  }
+			| string_expr
+			  {
+			      $$ = (int)'s';
+			  }
+			;
+
+
+func_call_param_list   	: func_call_param_part
+			  {
+			      char tmpbuf[2];
+			      tmpbuf[0] = (char) $1;
+			      tmpbuf[1] = '\0';
+			      $$ = strdup(tmpbuf);
+			  }
+			| func_call_param_list ',' func_call_param_part
+			  {
+			      long len = strlen( $1 );
+			      char *tmp = (char *)alloc(len + 2);
+			      sprintf(tmp, "%c%s", (char) $3, $1 );
+			      Free( $1 );
+			      $$ = tmp;
+			  }
+			;
+
+func_call_params_list	: /* nothing */
+			  {
+			      $$ = strdup("");
+			  }
+			| func_call_param_list
+			  {
+			      char *tmp = strdup( $1 );
+			      Free( $1 );
+			      $$ = tmp;
+			  }
+			;
+
+ter_selection_x	: coord_or_var
+		  {
+		      add_opvars(splev, "o", SPO_SEL_POINT);
+		  }
+		| rect_ID region_or_var
+		  {
+		      add_opvars(splev, "o", SPO_SEL_RECT);
+		  }
+		| fillrect_ID region_or_var
+		  {
+		      add_opvars(splev, "o", SPO_SEL_FILLRECT);
+		  }
+		| line_ID coord_or_var '-' coord_or_var
+		  {
+		      add_opvars(splev, "o", SPO_SEL_LINE);
+		  }
+		| randline_ID coord_or_var '-' coord_or_var ',' math_expr_var
+		  {
+		      /* randline (x1,y1),(x2,y2), roughness */
+		      add_opvars(splev, "o", SPO_SEL_RNDLINE);
+		  }
+		| grow_ID '(' ter_selection ')'
+		  {
+		      add_opvars(splev, "io", W_ANY, SPO_SEL_GROW);
+		  }
+		| grow_ID '(' dir_list ',' ter_selection ')'
+		  {
+		      add_opvars(splev, "io", $3, SPO_SEL_GROW);
+		  }
+		| filter_ID '(' SPERCENT ',' ter_selection ')'
+		  {
+		      add_opvars(splev, "iio", $3, SPOFILTER_PERCENT, SPO_SEL_FILTER);
+		  }
+		| filter_ID '(' ter_selection ',' ter_selection ')'
+		  {
+		      add_opvars(splev, "io", SPOFILTER_SELECTION, SPO_SEL_FILTER);
+		  }
+		| filter_ID '(' mapchar_or_var ',' ter_selection ')'
+		  {
+		      add_opvars(splev, "io", SPOFILTER_MAPCHAR, SPO_SEL_FILTER);
+		  }
+		| flood_ID coord_or_var
+		  {
+		      add_opvars(splev, "o", SPO_SEL_FLOOD);
+		  }
+		| circle_ID '(' coord_or_var ',' math_expr_var ')'
+		  {
+		      add_opvars(splev, "oio", SPO_COPY, 1, SPO_SEL_ELLIPSE);
+		  }
+		| circle_ID '(' coord_or_var ',' math_expr_var ',' FILLING ')'
+		  {
+		      add_opvars(splev, "oio", SPO_COPY, $7, SPO_SEL_ELLIPSE);
+		  }
+		| ellipse_ID '(' coord_or_var ',' math_expr_var ',' math_expr_var ')'
+		  {
+		      add_opvars(splev, "io", 1, SPO_SEL_ELLIPSE);
+		  }
+		| ellipse_ID '(' coord_or_var ',' math_expr_var ',' math_expr_var ',' FILLING ')'
+		  {
+		      add_opvars(splev, "io", $9, SPO_SEL_ELLIPSE);
+		  }
+		| gradient_ID '(' GRADIENT_TYPE ',' '(' math_expr_var '-' math_expr_var opt_limited ')' ',' coord_or_var opt_coord_or_var ')'
+		  {
+		      add_opvars(splev, "iio", $9, $3, SPO_SEL_GRADIENT);
+		  }
+		| complement_ID ter_selection_x
+		  {
+		      add_opvars(splev, "o", SPO_SEL_COMPLEMENT);
+		  }
+		| VARSTRING_SEL
+		  {
+		      check_vardef_type(variable_definitions, $1, SPOVAR_SEL);
+		      vardef_used(variable_definitions, $1);
+		      add_opvars(splev, "v", $1);
+		      Free($1);
+		  }
+		| '(' ter_selection ')'
+		  {
+		      /* nothing */
+		  }
+		;
+
+ter_selection	: ter_selection_x
+		  {
+		      /* nothing */
+		  }
+		| ter_selection_x '&' ter_selection
+		  {
+		      add_opvars(splev, "o", SPO_SEL_ADD);
+		  }
+		;
+
+dice		: DICE
+		  {
+		      add_opvars(splev, "iio", $1.num, $1.die, SPO_DICE);
+		  }
+		;
+
+all_integers	: MINUS_INTEGER
+		| PLUS_INTEGER
+		| INTEGER
+		;
+
+all_ints_push	: MINUS_INTEGER
+		  {
+		      add_opvars(splev, "i", $1 );
+		  }
+		| PLUS_INTEGER
+		  {
+		      add_opvars(splev, "i", $1 );
+		  }
+		| INTEGER
+		  {
+		      add_opvars(splev, "i", $1 );
+		  }
+		| dice
+		  {
+		      /* nothing */
+		  }
+		;
+
+objectid	: object_ID
+		| OBJECT_ID
+		;
+
+monsterid	: monster_ID
+		| MONSTER_ID
+		;
+
+terrainid	: terrain_ID
+		| TERRAIN_ID
+		;
+
 engraving_type	: ENGRAVING_TYPE
 		| RANDOM_TYPE
 		;
 
-coord		: '(' INTEGER ',' INTEGER ')'
+lev_region	: region
 		  {
-			if (!in_room && !init_lev.init_present &&
-			    ($2 < 0 || $2 > (int)max_x_map ||
-			     $4 < 0 || $4 > (int)max_y_map))
-			    yyerror("Coordinates out of map range!");
-			current_coord.x = $2;
-			current_coord.y = $4;
+			$$ = $1;
+		  }
+		| LEV '(' INTEGER ',' INTEGER ',' INTEGER ',' INTEGER ')'
+		  {
+			if ($3 <= 0 || $3 >= COLNO)
+			    lc_error("Region (%li,%li,%li,%li) out of level range (x1)!", $3, $5, $7, $9);
+			else if ($5 < 0 || $5 >= ROWNO)
+			    lc_error("Region (%li,%li,%li,%li) out of level range (y1)!", $3, $5, $7, $9);
+			else if ($7 <= 0 || $7 >= COLNO)
+			    lc_error("Region (%li,%li,%li,%li) out of level range (x2)!", $3, $5, $7, $9);
+			else if ($9 < 0 || $9 >= ROWNO)
+			    lc_error("Region (%li,%li,%li,%li) out of level range (y2)!", $3, $5, $7, $9);
+			$$.x1 = $3;
+			$$.y1 = $5;
+			$$.x2 = $7;
+			$$.y2 = $9;
+			$$.area = 1;
 		  }
 		;
 
@@ -1686,20 +2500,22 @@ region		: '(' INTEGER ',' INTEGER ',' INTEGER ',' INTEGER ')'
 /* This series of if statements is a hack for MSC 5.1.  It seems that its
    tiny little brain cannot compile if these are all one big if statement. */
 			if ($2 < 0 || $2 > (int)max_x_map)
-				yyerror("Region out of map range!");
+			    lc_error("Region (%li,%li,%li,%li) out of map range (x1)!", $2, $4, $6, $8);
 			else if ($4 < 0 || $4 > (int)max_y_map)
-				yyerror("Region out of map range!");
+			    lc_error("Region (%li,%li,%li,%li) out of map range (y1)!", $2, $4, $6, $8);
 			else if ($6 < 0 || $6 > (int)max_x_map)
-				yyerror("Region out of map range!");
+			    lc_error("Region (%li,%li,%li,%li) out of map range (x2)!", $2, $4, $6, $8);
 			else if ($8 < 0 || $8 > (int)max_y_map)
-				yyerror("Region out of map range!");
-			current_region.x1 = $2;
-			current_region.y1 = $4;
-			current_region.x2 = $6;
-			current_region.y2 = $8;
+			    lc_error("Region (%li,%li,%li,%li) out of map range (y2)!", $2, $4, $6, $8);
+			$$.area = 0;
+			$$.x1 = $2;
+			$$.y1 = $4;
+			$$.x2 = $6;
+			$$.y2 = $8;
 		  }
 		;
 
+
 %%
 
 /*lev_comp.y*/
diff --git a/util/lev_main.c b/util/lev_main.c
index fa539f5e2..1045bdf34 100644
--- a/util/lev_main.c
+++ b/util/lev_main.c
@@ -11,6 +11,8 @@
 #define SPEC_LEV	/* for MPW */
 /* although, why don't we move those special defines here.. and in dgn_main? */
 
+#include <stdarg.h>
+
 #include "hack.h"
 #include "date.h"
 #include "sp_lev.h"
@@ -90,27 +92,34 @@ int FDECL(get_object_id, (char *,CHAR_P));
 boolean FDECL(check_monster_char, (CHAR_P));
 boolean FDECL(check_object_char, (CHAR_P));
 char FDECL(what_map_char, (CHAR_P));
-void FDECL(scan_map, (char *));
-void NDECL(wallify_map);
+void FDECL(scan_map, (char *, sp_lev *));
 boolean NDECL(check_subrooms);
-void FDECL(check_coord, (int,int,const char *));
-void NDECL(store_part);
-void NDECL(store_room);
-boolean FDECL(write_level_file, (char *,splev *,specialmaze *));
-void FDECL(free_rooms, (splev *));
+boolean FDECL(write_level_file, (char *,sp_lev *));
+
+struct lc_funcdefs *FDECL(funcdef_new,(long,char *));
+void FDECL(funcdef_free_all,(struct lc_funcdefs *));
+struct lc_funcdefs *FDECL(funcdef_defined,(struct lc_funcdefs *,char *, int));
+
+struct lc_vardefs *FDECL(vardef_new,(long,char *));
+void FDECL(vardef_free_all,(struct lc_vardefs *));
+struct lc_vardefs *FDECL(vardef_defined,(struct lc_vardefs *,char *, int));
+
+void FDECL(splev_add_from, (sp_lev *, sp_lev *));
 
 extern void NDECL(monst_init);
 extern void NDECL(objects_init);
 extern void NDECL(decl_init);
 
-static boolean FDECL(write_common_data, (int,int,lev_init *,long));
-static boolean FDECL(write_monsters, (int,char *,monster ***));
-static boolean FDECL(write_objects, (int,char *,object ***));
-static boolean FDECL(write_engravings, (int,char *,engraving ***));
-static boolean FDECL(write_maze, (int,specialmaze *));
-static boolean FDECL(write_rooms, (int,splev *));
+void FDECL(add_opcode, (sp_lev *, int, genericptr_t));
+
+static boolean FDECL(write_common_data, (int,sp_lev *));
+static boolean FDECL(write_maze, (int,sp_lev *));
 static void NDECL(init_obj_classes);
 
+void VDECL(lc_error, (const char *, ...));
+void VDECL(add_opvars, (sp_lev *, const char *, ...));
+
+
 static struct {
 	const char *name;
 	int type;
@@ -176,47 +185,27 @@ static struct {
 
 const char *fname = "(stdin)";
 int fatal_error = 0;
-int want_warnings = 0;
+int got_errors = 0;
+int be_verbose = 0;
+int fname_counter = 1;
 
 #ifdef FLEX23_BUG
 /* Flex 2.3 bug work around; not needed for 2.3.6 or later */
 int yy_more_len = 0;
 #endif
 
-extern char tmpmessage[];
-extern altar *tmpaltar[];
-extern lad *tmplad[];
-extern stair *tmpstair[];
-extern digpos *tmpdig[];
-extern digpos *tmppass[];
-extern char *tmpmap[];
-extern region *tmpreg[];
-extern lev_region *tmplreg[];
-extern door *tmpdoor[];
-extern room_door *tmprdoor[];
-extern trap *tmptrap[];
-extern monster *tmpmonst[];
-extern object *tmpobj[];
-extern drawbridge *tmpdb[];
-extern walk *tmpwalk[];
-extern gold *tmpgold[];
-extern fountain *tmpfountain[];
-extern sink *tmpsink[];
-extern pool *tmppool[];
-extern engraving *tmpengraving[];
-extern mazepart *tmppart[];
-extern room *tmproom[];
-
-extern int n_olist, n_mlist, n_plist;
-
-extern unsigned int nlreg, nreg, ndoor, ntrap, nmons, nobj;
-extern unsigned int ndb, nwalk, npart, ndig, npass, nlad, nstair;
-extern unsigned int naltar, ncorridor, nrooms, ngold, nengraving;
-extern unsigned int nfountain, npool, nsink;
-
 extern unsigned int max_x_map, max_y_map;
 
-extern int nh_line_number, colon_line_number;
+extern int nh_line_number;
+
+extern int token_start_pos;
+extern char curr_token[512];
+
+struct lc_vardefs *variable_definitions = NULL;
+struct lc_funcdefs *function_definitions = NULL;
+
+extern int allow_break_statements;
+extern struct lc_breakdef *break_list;
 
 int
 main(argc, argv)
@@ -276,8 +265,8 @@ char **argv;
 	} else {			/* Otherwise every argument is a filename */
 	    for(i=1; i<argc; i++) {
 		    fname = argv[i];
-		    if(!strcmp(fname, "-w")) {
-			want_warnings++;
+		    if(!strcmp(fname, "-v")) {
+			be_verbose++;
 			continue;
 		    }
 		    fin = freopen(fname, "r", stdin);
@@ -287,10 +276,11 @@ char **argv;
 			perror(fname);
 			errors_encountered = TRUE;
 		    } else {
+			fname_counter = 1;
 			init_yyin(fin);
 			(void) yyparse();
 			nh_line_number = 1;
-			if (fatal_error > 0) {
+			if (fatal_error > 0 || got_errors > 0) {
 				errors_encountered = TRUE;
 				fatal_error = 0;
 			}
@@ -314,8 +304,14 @@ void
 yyerror(s)
 const char *s;
 {
-	(void) fprintf(stderr, "%s: line %d : %s\n", fname,
-		(*s >= 'A' && *s <= 'Z') ? colon_line_number : nh_line_number, s);
+	char *e = ((char *)s + strlen(s) - 1);
+	(void) fprintf(stderr, "%s: line %d, pos %d: %s",
+		       fname, nh_line_number,
+		       token_start_pos-strlen(curr_token), s);
+	if (*e != '.' && *e != '!')
+	    (void) fprintf(stderr, " at \"%s\"", curr_token);
+	(void) fprintf(stderr, "\n");
+
 	if (++fatal_error > MAX_ERRORS) {
 		(void) fprintf(stderr,"Too many errors, good bye!\n");
 		exit(EXIT_FAILURE);
@@ -330,7 +326,7 @@ yywarning(s)
 const char *s;
 {
 	(void) fprintf(stderr, "%s: line %d : WARNING : %s\n",
-				fname, colon_line_number, s);
+				fname, nh_line_number, s);
 }
 
 /*
@@ -342,6 +338,586 @@ yywrap()
 	return 1;
 }
 
+void
+lc_error(const char *fmt, ...)
+{
+    char buf[512];
+    va_list argp;
+
+    va_start(argp, fmt);
+    (void) vsnprintf(buf, 511, fmt, argp);
+    va_end(argp);
+
+    yyerror(buf);
+}
+
+void
+lc_warning(const char *fmt, ...)
+{
+    char buf[512];
+    va_list argp;
+
+    va_start(argp, fmt);
+    (void) vsnprintf(buf, 511, fmt, argp);
+    va_end(argp);
+
+    yywarning(buf);
+}
+
+
+char *
+decode_parm_chr(chr)
+char chr;
+{
+    static char buf[32];
+    switch (chr) {
+    default: sprintf(buf, "unknown"); break;
+    case 'i': sprintf(buf, "int"); break;
+    case 'r': sprintf(buf, "region"); break;
+    case 's': sprintf(buf, "str"); break;
+    case 'O': sprintf(buf, "obj"); break;
+    case 'c': sprintf(buf, "coord"); break;
+    case ' ': sprintf(buf, "nothing"); break;
+    case 'm': sprintf(buf, "mapchar"); break;
+    case 'M': sprintf(buf, "monster"); break;
+    }
+    return buf;
+}
+
+char *
+decode_parm_str(str)
+char *str;
+{
+    static char tmpbuf[1024];
+    char *p = str;
+    tmpbuf[0] = '\0';
+    if (str) {
+	for ( ; *p; p++) {
+	    Strcat(tmpbuf, decode_parm_chr(*p));
+	    if (*(p + 1)) Strcat(tmpbuf, ", ");
+	}
+    }
+    return tmpbuf;
+}
+
+
+struct opvar *
+set_opvar_int(ov, val)
+struct opvar *ov;
+long  val;
+{
+    if (ov) {
+        ov->spovartyp = SPOVAR_INT;
+        ov->vardata.l = val;
+    }
+    return ov;
+}
+
+struct opvar *
+set_opvar_coord(ov, val)
+struct opvar *ov;
+long  val;
+{
+    if (ov) {
+        ov->spovartyp = SPOVAR_COORD;
+        ov->vardata.l = val;
+    }
+    return ov;
+}
+
+struct opvar *
+set_opvar_region(ov, val)
+struct opvar *ov;
+long  val;
+{
+    if (ov) {
+        ov->spovartyp = SPOVAR_REGION;
+        ov->vardata.l = val;
+    }
+    return ov;
+}
+
+struct opvar *
+set_opvar_mapchar(ov, val)
+struct opvar *ov;
+long  val;
+{
+    if (ov) {
+        ov->spovartyp = SPOVAR_MAPCHAR;
+        ov->vardata.l = val;
+    }
+    return ov;
+}
+
+struct opvar *
+set_opvar_monst(ov, val)
+struct opvar *ov;
+long  val;
+{
+    if (ov) {
+        ov->spovartyp = SPOVAR_MONST;
+        ov->vardata.l = val;
+    }
+    return ov;
+}
+
+struct opvar *
+set_opvar_obj(ov, val)
+struct opvar *ov;
+long  val;
+{
+    if (ov) {
+        ov->spovartyp = SPOVAR_OBJ;
+        ov->vardata.l = val;
+    }
+    return ov;
+}
+
+struct opvar *
+set_opvar_str(ov, val)
+struct opvar *ov;
+char *val;
+{
+    if (ov) {
+        ov->spovartyp = SPOVAR_STRING;
+	ov->vardata.str = (val) ? strdup(val) : NULL;
+    }
+    return ov;
+}
+
+struct opvar *
+set_opvar_var(ov, val)
+struct opvar *ov;
+char *val;
+{
+    if (ov) {
+        ov->spovartyp = SPOVAR_VARIABLE;
+	ov->vardata.str = (val) ? strdup(val) : NULL;
+    }
+    return ov;
+}
+
+#define New(type)		\
+	(type *) memset((genericptr_t)alloc(sizeof(type)), 0, sizeof(type))
+
+void
+add_opvars(sp_lev *sp, const char *fmt, ...)
+{
+    const char *p;
+    va_list argp;
+
+    va_start(argp, fmt);
+
+    for(p = fmt; *p != '\0'; p++) {
+	switch(*p) {
+	case ' ': break;
+	case 'i': /* integer */
+	    {
+		struct opvar *ov = New(struct opvar);
+		set_opvar_int(ov, va_arg(argp, long));
+		add_opcode(sp, SPO_PUSH, ov);
+		break;
+	    }
+	case 'c': /* coordinate */
+	    {
+		struct opvar *ov = New(struct opvar);
+		set_opvar_coord(ov, va_arg(argp, long));
+		add_opcode(sp, SPO_PUSH, ov);
+		break;
+	    }
+	case 'r': /* region */
+	    {
+		struct opvar *ov = New(struct opvar);
+		set_opvar_region(ov, va_arg(argp, long));
+		add_opcode(sp, SPO_PUSH, ov);
+		break;
+	    }
+	case 'm': /* mapchar */
+	    {
+		struct opvar *ov = New(struct opvar);
+		set_opvar_mapchar(ov, va_arg(argp, long));
+		add_opcode(sp, SPO_PUSH, ov);
+		break;
+	    }
+	case 'M': /* monster */
+	    {
+		struct opvar *ov = New(struct opvar);
+		set_opvar_monst(ov, va_arg(argp, long));
+		add_opcode(sp, SPO_PUSH, ov);
+		break;
+	    }
+	case 'O': /* object */
+	    {
+		struct opvar *ov = New(struct opvar);
+		set_opvar_obj(ov, va_arg(argp, long));
+		add_opcode(sp, SPO_PUSH, ov);
+		break;
+	    }
+	case 's': /* string */
+	    {
+		struct opvar *ov = New(struct opvar);
+		set_opvar_str(ov, va_arg(argp, char *));
+		add_opcode(sp, SPO_PUSH, ov);
+		break;
+	    }
+	case 'v': /* variable */
+	    {
+		struct opvar *ov = New(struct opvar);
+		set_opvar_var(ov, va_arg(argp, char *));
+		add_opcode(sp, SPO_PUSH, ov);
+		break;
+	    }
+	case 'o': /* opcode */
+	    {
+		long i = va_arg(argp, int);
+		if (i < 0 || i >= MAX_SP_OPCODES)
+		    fprintf(stderr, "add_opvars: unknown opcode '%li'.\n", i);
+		add_opcode(sp, i, NULL);
+		break;
+	    }
+	default:
+	    fprintf(stderr, "add_opvars: illegal format character '%c'.\n", *p);
+	    break;
+	}
+    }
+
+    va_end(argp);
+}
+
+void
+break_stmt_start()
+{
+    allow_break_statements++;
+}
+
+void
+break_stmt_end(splev)
+     sp_lev *splev;
+{
+    struct lc_breakdef *tmp = break_list;
+    struct lc_breakdef *prv = NULL;
+    while (tmp) {
+	if (tmp->break_depth == allow_break_statements) {
+	    struct lc_breakdef *nxt = tmp->next;
+	    set_opvar_int(tmp->breakpoint, splev->n_opcodes - tmp->breakpoint->vardata.l-1);
+	    tmp->next = NULL;
+	    Free(tmp);
+	    if (!prv) break_list = NULL;
+	    else prv->next = nxt;
+	    tmp = nxt;
+	} else {
+	    prv = tmp;
+	    tmp = tmp->next;
+	}
+    }
+    allow_break_statements--;
+}
+
+void
+break_stmt_new(splev,i)
+     sp_lev *splev;
+     long i;
+{
+    struct lc_breakdef *tmp = New(struct lc_breakdef);
+    tmp->breakpoint = New(struct opvar);
+    tmp->break_depth = allow_break_statements;
+    tmp->next = break_list;
+    break_list = tmp;
+    set_opvar_int(tmp->breakpoint, i);
+    add_opcode(splev, SPO_PUSH, tmp->breakpoint);
+    add_opcode(splev, SPO_JMP, NULL);
+}
+
+struct lc_funcdefs *
+funcdef_new(addr, name)
+     long addr;
+     char *name;
+{
+    struct lc_funcdefs *f = New(struct lc_funcdefs);
+    if (!f) {
+	lc_error("Could not alloc function definition for '%s'.", name);
+	return NULL;
+    }
+    f->next = NULL;
+    f->addr = addr;
+    f->name = strdup(name);
+    f->n_called = 0;
+    f->n_params = 0;
+    f->params = NULL;
+    f->code.opcodes = NULL;
+    f->code.n_opcodes = 0;
+    return f;
+}
+
+void
+funcdef_free_all(fchain)
+     struct lc_funcdefs *fchain;
+{
+    struct lc_funcdefs *tmp = fchain;
+    struct lc_funcdefs *nxt;
+    struct lc_funcdefs_parm *tmpparam;
+    while (tmp) {
+	nxt = tmp->next;
+	Free(tmp->name);
+	while (tmp->params) {
+	    tmpparam = tmp->params->next;
+	    Free(tmp->params->name);
+	    tmp->params = tmpparam;
+	}
+	/* FIXME: free tmp->code */
+	Free(tmp);
+	tmp = nxt;
+    }
+}
+
+
+char *
+funcdef_paramtypes(f)
+     struct lc_funcdefs *f;
+{
+    int i = 0;
+    struct lc_funcdefs_parm *fp = f->params;
+    char *tmp = (char *)alloc((f->n_params) + 1);
+    if (!tmp) return NULL;
+    while (fp) {
+	tmp[i++] = fp->parmtype;
+	fp = fp->next;
+    }
+    tmp[i] = '\0';
+    return tmp;
+}
+
+struct lc_funcdefs *
+funcdef_defined(f, name, casesense)
+     struct lc_funcdefs *f;
+     char *name;
+     int casesense;
+{
+    while (f) {
+	if (casesense) {
+	    if (!strcmp(name, f->name)) return f;
+	} else {
+	    if (!strcasecmp(name, f->name)) return f;
+	}
+	f = f->next;
+    }
+    return NULL;
+}
+
+
+struct lc_vardefs *
+vardef_new(typ, name)
+     long typ;
+     char *name;
+{
+    struct lc_vardefs *f = New(struct lc_vardefs);
+    if (!f) {
+	lc_error("Could not alloc variable definition for '%s'.", name);
+	return NULL;
+    }
+    f->next = NULL;
+    f->var_type = typ;
+    f->name = strdup(name);
+    f->n_used = 0;
+    return f;
+}
+
+void
+vardef_free_all(fchain)
+     struct lc_vardefs *fchain;
+{
+    struct lc_vardefs *tmp = fchain;
+    struct lc_vardefs *nxt;
+    while (tmp) {
+	if (be_verbose && (tmp->n_used == 0))
+	    lc_warning("Unused variable '%s'", tmp->name);
+	nxt = tmp->next;
+	Free(tmp->name);
+	Free(tmp);
+	tmp = nxt;
+    }
+}
+
+struct lc_vardefs *
+vardef_defined(f, name, casesense)
+     struct lc_vardefs *f;
+     char *name;
+     int casesense;
+{
+    while (f) {
+	if (casesense) {
+	    if (!strcmp(name, f->name)) return f;
+	} else {
+	    if (!strcasecmp(name, f->name)) return f;
+	}
+	f = f->next;
+    }
+    return NULL;
+}
+
+const char *
+spovar2str(spovar)
+     long spovar;
+{
+    static int togl = 0;
+    static char buf[2][128];
+    char *n = NULL;
+    int is_array = (spovar & SPOVAR_ARRAY);
+    spovar &= ~SPOVAR_ARRAY;
+
+    switch (spovar) {
+    default:		  lc_error("spovar2str(%li)", spovar); break;
+    case SPOVAR_INT:	  n = "integer"; break;
+    case SPOVAR_STRING:   n = "string"; break;
+    case SPOVAR_VARIABLE: n = "variable"; break;
+    case SPOVAR_COORD:	  n = "coordinate"; break;
+    case SPOVAR_REGION:	  n = "region"; break;
+    case SPOVAR_MAPCHAR:  n = "mapchar"; break;
+    case SPOVAR_MONST:	  n = "monster"; break;
+    case SPOVAR_OBJ:	  n = "object"; break;
+    }
+
+    togl = ((togl + 1) % 2);
+
+    snprintf(buf[togl], 127, "%s%s", n, (is_array ? " array" : ""));
+    return buf[togl];
+}
+
+void
+vardef_used(vd, varname)
+     struct lc_vardefs *vd;
+     char *varname;
+{
+    struct lc_vardefs *tmp;
+    if ((tmp = vardef_defined(vd, varname, 1))) tmp->n_used++;
+}
+
+void
+check_vardef_type(vd, varname, vartype)
+     struct lc_vardefs *vd;
+     char *varname;
+     long vartype;
+{
+    struct lc_vardefs *tmp;
+    if ((tmp = vardef_defined(vd, varname, 1))) {
+	if (tmp->var_type != vartype)
+	    lc_error("Trying to use variable '%s' as %s, when it is %s.",
+		     varname, spovar2str(vartype), spovar2str(tmp->var_type));
+    } else lc_error("Variable '%s' not defined.", varname);
+}
+
+struct lc_vardefs *
+add_vardef_type(vd, varname, vartype)
+     struct lc_vardefs *vd;
+     char *varname;
+     long vartype;
+{
+    struct lc_vardefs *tmp;
+    if ((tmp = vardef_defined(vd, varname, 1))) {
+	if (tmp->var_type != vartype)
+	    lc_error("Trying to redefine variable '%s' as %s, when it is %s.",
+		     varname, spovar2str(vartype), spovar2str(tmp->var_type));
+    } else {
+	tmp = vardef_new(vartype, varname);
+	tmp->next = vd;
+	return tmp;
+    }
+    return vd;
+}
+
+int
+reverse_jmp_opcode(opcode)
+     int opcode;
+{
+    switch (opcode) {
+    case SPO_JE:  return SPO_JNE;
+    case SPO_JNE: return SPO_JE;
+    case SPO_JL:  return SPO_JGE;
+    case SPO_JG:  return SPO_JLE;
+    case SPO_JLE: return SPO_JG;
+    case SPO_JGE: return SPO_JL;
+    default: lc_error("Cannot reverse comparison jmp opcode %i.", opcode); return SPO_NULL;
+    }
+}
+
+/* basically copied from src/sp_lev.c */
+struct opvar *
+opvar_clone(ov)
+     struct opvar *ov;
+{
+    if (ov) {
+	struct opvar *tmpov = (struct opvar *)alloc(sizeof(struct opvar));
+	if (!tmpov) panic("could not alloc opvar struct");
+	switch (ov->spovartyp) {
+	case SPOVAR_COORD:
+	case SPOVAR_REGION:
+	case SPOVAR_MAPCHAR:
+	case SPOVAR_MONST:
+	case SPOVAR_OBJ:
+	case SPOVAR_INT:
+	    {
+		tmpov->spovartyp = ov->spovartyp;
+		tmpov->vardata.l = ov->vardata.l;
+	    }
+	    break;
+	case SPOVAR_VARIABLE:
+	case SPOVAR_STRING:
+	    {
+		int len = strlen(ov->vardata.str);
+		tmpov->spovartyp = ov->spovartyp;
+		tmpov->vardata.str = (char *)alloc(len+1);
+		(void)memcpy((genericptr_t)tmpov->vardata.str,
+			     (genericptr_t)ov->vardata.str, len);
+		tmpov->vardata.str[len] = '\0';
+	    }
+	    break;
+	default:
+	    {
+		lc_error("Unknown opvar_clone value type (%i)!", ov->spovartyp);
+	    }
+	}
+	return tmpov;
+    }
+    return NULL;
+}
+
+
+void
+splev_add_from(splev, from_splev)
+     sp_lev *splev;
+     sp_lev *from_splev;
+{
+    int i;
+    if (splev && from_splev)
+	for (i = 0; i < from_splev->n_opcodes; i++)
+	    add_opcode(splev, from_splev->opcodes[i].opcode, opvar_clone(from_splev->opcodes[i].opdat));
+}
+
+
+void
+start_level_def(splev, fname)
+sp_lev **splev;
+char *fname;
+{
+    struct lc_funcdefs *f;
+    if (index(fname, '.'))
+	lc_error("Invalid dot ('.') in level name '%s'.", fname);
+    if ((int) strlen(fname) > 14)
+	lc_error("Level names limited to 14 characters ('%s').", fname);
+    f = function_definitions;
+    while (f) {
+	f->n_called = 0;
+	f = f->next;
+    }
+    *splev = (sp_lev *)alloc(sizeof(sp_lev));
+    (*splev)->n_opcodes = 0;
+    (*splev)->opcodes = NULL;
+
+    vardef_free_all(variable_definitions);
+    variable_definitions = NULL;
+}
+
+
 /*
  * Find the type of floor, knowing its char representation.
  */
@@ -409,6 +985,14 @@ char c;
 	for (i = LOW_PM; i < NUMMONS; i++)
 	    if (!class || class == mons[i].mlet)
 		if (!strcmp(s, mons[i].mname)) return i;
+	/* didn't find it; lets try case insensitive search */
+	for (i = LOW_PM; i < NUMMONS; i++)
+	    if (!class || class == mons[i].mlet)
+		if (!strcasecmp(s, mons[i].mname)) {
+		    if (be_verbose)
+			lc_warning("Monster type \"%s\" matches \"%s\".", s, mons[i].mname);
+		    return i;
+		}
 	return ERR;
 }
 
@@ -433,6 +1017,15 @@ char c;		/* class */
 	    if (objname && !strcmp(s, objname))
 		return i;
 	}
+	for (i = class ? bases[class] : 0; i < NUM_OBJECTS; i++) {
+	    if (class && objects[i].oc_class != class) break;
+	    objname = obj_descr[i].oc_name;
+	    if (objname && !strcasecmp(s, objname)) {
+		if (be_verbose)
+		    lc_warning("Object type \"%s\" matches \"%s\".", s, objname);
+		return i;
+	    }
+	}
 	return ERR;
 }
 
@@ -506,19 +1099,50 @@ char c;
 	return(INVALID_TYPE);
 }
 
+void
+add_opcode(sp, opc, dat)
+sp_lev *sp;
+int opc;
+genericptr_t dat;
+{
+   long nop = sp->n_opcodes;
+   _opcode *tmp;
+
+   if ((opc < 0) || (opc >= MAX_SP_OPCODES))
+       lc_error("Unknown opcode '%i'", opc);
+
+   tmp = (_opcode *)alloc(sizeof(_opcode)*(nop+1));
+   if (sp->opcodes && nop) {
+       (void) memcpy(tmp, sp->opcodes, sizeof(_opcode)*nop);
+       free(sp->opcodes);
+   } else if (!tmp)
+       lc_error("Could not alloc opcode space");
+
+   sp->opcodes = tmp;
+
+   sp->opcodes[nop].opcode = opc;
+   sp->opcodes[nop].opdat = dat;
+
+   sp->n_opcodes++;
+}
+
+
 /*
  * Yep! LEX gives us the map in a raw mode.
  * Just analyze it here.
  */
 void
-scan_map(map)
+scan_map(map, sp)
 char *map;
+sp_lev *sp;
 {
 	register int i, len;
 	register char *s1, *s2;
 	int max_len = 0;
 	int max_hig = 0;
-	char msg[256];
+	char *tmpmap[ROWNO];
+	int dx,dy;
+	char *mbuf;
 
 	/* First, strip out digits 0-9 (line numbering) */
 	for (s1 = s2 = map; *s1; s1++)
@@ -553,10 +1177,7 @@ char *map;
 		}
 		for(i=0; i<len; i++)
 		  if((tmpmap[max_hig][i] = what_map_char(map[i])) == INVALID_TYPE) {
-		      Sprintf(msg,
-			 "Invalid character @ (%d, %d) - replacing with stone",
-			      max_hig, i);
-		      yywarning(msg);
+		      lc_warning("Invalid character '%c' @ (%d, %d) - replacing with stone", map[i], max_hig, i);
 		      tmpmap[max_hig][i] = STONE;
 		    }
 		while(i < max_len)
@@ -570,547 +1191,127 @@ char *map;
 	max_x_map = max_len - 1;
 	max_y_map = max_hig - 1;
 
-	/* Store the map into the mazepart structure */
-
 	if(max_len > MAP_X_LIM || max_hig > MAP_Y_LIM) {
-	    Sprintf(msg, "Map too large! (max %d x %d)", MAP_X_LIM, MAP_Y_LIM);
-	    yyerror(msg);
+	    lc_error("Map too large at (%d x %d), max is (%d x %d)", max_len, max_hig, MAP_X_LIM, MAP_Y_LIM);
 	}
 
-	tmppart[npart]->xsize = max_len;
-	tmppart[npart]->ysize = max_hig;
-	tmppart[npart]->map = (char **) alloc(max_hig*sizeof(char *));
-	for(i = 0; i< max_hig; i++)
-	    tmppart[npart]->map[i] = tmpmap[i];
+	mbuf = (char *) alloc(((max_hig-1) * max_len) + (max_len-1) + 2);
+	for (dy = 0; dy < max_hig; dy++)
+	    for (dx = 0; dx < max_len; dx++)
+		mbuf[(dy * max_len) + dx] = (tmpmap[dy][dx] + 1);
+
+	mbuf[((max_hig-1) * max_len) + (max_len-1) + 1] = '\0';
+
+	add_opvars(sp, "siio", mbuf, max_hig, max_len, SPO_MAP);
+
+	for (dy = 0; dy < max_hig; dy++)
+	    Free(tmpmap[dy]);
+	Free(mbuf);
 }
 
-/*
- *	If we have drawn a map without walls, this allows us to
- *	auto-magically wallify it.
- */
-#define Map_point(x,y) *(tmppart[npart]->map[y] + x)
 
-void
-wallify_map()
-{
-	unsigned int x, y, xx, yy, lo_xx, lo_yy, hi_xx, hi_yy;
 
-	for (y = 0; y <= max_y_map; y++) {
-	    SpinCursor(3);
-	    lo_yy = (y > 0) ? y - 1 : 0;
-	    hi_yy = (y < max_y_map) ? y + 1 : max_y_map;
-	    for (x = 0; x <= max_x_map; x++) {
-		if (Map_point(x,y) != STONE) continue;
-		lo_xx = (x > 0) ? x - 1 : 0;
-		hi_xx = (x < max_x_map) ? x + 1 : max_x_map;
-		for (yy = lo_yy; yy <= hi_yy; yy++)
-		    for (xx = lo_xx; xx <= hi_xx; xx++)
-			if (IS_ROOM(Map_point(xx,yy)) ||
-				Map_point(xx,yy) == CROSSWALL) {
-			    Map_point(x,y) = (yy != y) ? HWALL : VWALL;
-			    yy = hi_yy;		/* end `yy' loop */
-			    break;		/* end `xx' loop */
-			}
-	    }
-	}
-}
-
-/*
- * We need to check the subrooms apartenance to an existing room.
- */
-boolean
-check_subrooms()
-{
-	unsigned i, j, n_subrooms;
-	boolean	found, ok = TRUE;
-	char	*last_parent, msg[256];
-
-	for (i = 0; i < nrooms; i++)
-	    if (tmproom[i]->parent) {
-		found = FALSE;
-		for(j = 0; j < nrooms; j++)
-		    if (tmproom[j]->name &&
-			    !strcmp(tmproom[i]->parent, tmproom[j]->name)) {
-			found = TRUE;
-			break;
-		    }
-		if (!found) {
-		    Sprintf(msg,
-			    "Subroom error : parent room '%s' not found!",
-			    tmproom[i]->parent);
-		    yyerror(msg);
-		    ok = FALSE;
-		}
-	    }
-
-	msg[0] = '\0';
-	last_parent = msg;
-	for (i = 0; i < nrooms; i++)
-	    if (tmproom[i]->parent) {
-		n_subrooms = 0;
-		for(j = i; j < nrooms; j++) {
-/*
- *	This is by no means perfect, but should cut down the duplicate error
- *	messages by over 90%.  The only problem will be when either subrooms
- *	are mixed in the level definition (not likely but possible) or rooms
- *	have subrooms that have subrooms.
- */
-		    if (!strcmp(tmproom[i]->parent, last_parent)) continue;
-		    if (tmproom[j]->parent &&
-			    !strcmp(tmproom[i]->parent, tmproom[j]->parent)) {
-			n_subrooms++;
-			if(n_subrooms > MAX_SUBROOMS) {
-
-			    Sprintf(msg,
-	      "Subroom error: too many subrooms attached to parent room '%s'!",
-				    tmproom[i]->parent);
-			    yyerror(msg);
-			    last_parent = tmproom[i]->parent;
-			    ok = FALSE;
-			    break;
-			}
-		    }
-		}
-	    }
-	return ok;
-}
-
-/*
- * Check that coordinates (x,y) are roomlike locations.
- * Print warning "str" if they aren't.
- */
-void
-check_coord(x, y, str)
-int x, y;
-const char *str;
-{
-    char ebuf[60];
-
-    if (x >= 0 && y >= 0 && x <= (int)max_x_map && y <= (int)max_y_map &&
-	(IS_ROCK(tmpmap[y][x]) || IS_DOOR(tmpmap[y][x]))) {
-	Sprintf(ebuf, "%s placed in wall at (%02d,%02d)?!", str, x, y);
-	yywarning(ebuf);
-    }
-}
-
-/*
- * Here we want to store the maze part we just got.
- */
-void
-store_part()
-{
-	register unsigned i;
-
-	/* Ok, We got the whole part, now we store it. */
-
-	/* The Regions */
-
-	if ((tmppart[npart]->nreg = nreg) != 0) {
-		tmppart[npart]->regions = NewTab(region, nreg);
-		for(i=0;i<nreg;i++)
-		    tmppart[npart]->regions[i] = tmpreg[i];
-	}
-	nreg = 0;
-
-	/* The Level Regions */
-
-	if ((tmppart[npart]->nlreg = nlreg) != 0) {
-		tmppart[npart]->lregions = NewTab(lev_region, nlreg);
-		for(i=0;i<nlreg;i++)
-		    tmppart[npart]->lregions[i] = tmplreg[i];
-	}
-	nlreg = 0;
-
-	/* the doors */
-
-	if ((tmppart[npart]->ndoor = ndoor) != 0) {
-		tmppart[npart]->doors = NewTab(door, ndoor);
-		for(i=0;i<ndoor;i++)
-		    tmppart[npart]->doors[i] = tmpdoor[i];
-	}
-	ndoor = 0;
-
-	/* the drawbridges */
-
-	if ((tmppart[npart]->ndrawbridge = ndb) != 0) {
-		tmppart[npart]->drawbridges = NewTab(drawbridge, ndb);
-		for(i=0;i<ndb;i++)
-		    tmppart[npart]->drawbridges[i] = tmpdb[i];
-	}
-	ndb = 0;
-
-	/* The walkmaze directives */
-
-	if ((tmppart[npart]->nwalk = nwalk) != 0) {
-		tmppart[npart]->walks = NewTab(walk, nwalk);
-		for(i=0;i<nwalk;i++)
-		    tmppart[npart]->walks[i] = tmpwalk[i];
-	}
-	nwalk = 0;
-
-	/* The non_diggable directives */
-
-	if ((tmppart[npart]->ndig = ndig) != 0) {
-		tmppart[npart]->digs = NewTab(digpos, ndig);
-		for(i=0;i<ndig;i++)
-		    tmppart[npart]->digs[i] = tmpdig[i];
-	}
-	ndig = 0;
-
-	/* The non_passwall directives */
-
-	if ((tmppart[npart]->npass = npass) != 0) {
-		tmppart[npart]->passs = NewTab(digpos, npass);
-		for(i=0;i<npass;i++)
-		    tmppart[npart]->passs[i] = tmppass[i];
-	}
-	npass = 0;
-
-	/* The ladders */
-
-	if ((tmppart[npart]->nlad = nlad) != 0) {
-		tmppart[npart]->lads = NewTab(lad, nlad);
-		for(i=0;i<nlad;i++)
-		    tmppart[npart]->lads[i] = tmplad[i];
-	}
-	nlad = 0;
-
-	/* The stairs */
-
-	if ((tmppart[npart]->nstair = nstair) != 0) {
-		tmppart[npart]->stairs = NewTab(stair, nstair);
-		for(i=0;i<nstair;i++)
-		    tmppart[npart]->stairs[i] = tmpstair[i];
-	}
-	nstair = 0;
-
-	/* The altars */
-	if ((tmppart[npart]->naltar = naltar) != 0) {
-		tmppart[npart]->altars = NewTab(altar, naltar);
-		for(i=0;i<naltar;i++)
-		    tmppart[npart]->altars[i] = tmpaltar[i];
-	}
-	naltar = 0;
-
-	/* The fountains */
-
-	if ((tmppart[npart]->nfountain = nfountain) != 0) {
-		tmppart[npart]->fountains = NewTab(fountain, nfountain);
-		for(i=0;i<nfountain;i++)
-		    tmppart[npart]->fountains[i] = tmpfountain[i];
-	}
-	nfountain = 0;
-
-	/* the traps */
-
-	if ((tmppart[npart]->ntrap = ntrap) != 0) {
-		tmppart[npart]->traps = NewTab(trap, ntrap);
-		for(i=0;i<ntrap;i++)
-		    tmppart[npart]->traps[i] = tmptrap[i];
-	}
-	ntrap = 0;
-
-	/* the monsters */
-
-	if ((tmppart[npart]->nmonster = nmons) != 0) {
-		tmppart[npart]->monsters = NewTab(monster, nmons);
-		for(i=0;i<nmons;i++)
-		    tmppart[npart]->monsters[i] = tmpmonst[i];
-	} else
-		tmppart[npart]->monsters = 0;
-	nmons = 0;
-
-	/* the objects */
-
-	if ((tmppart[npart]->nobject = nobj) != 0) {
-		tmppart[npart]->objects = NewTab(object, nobj);
-		for(i=0;i<nobj;i++)
-		    tmppart[npart]->objects[i] = tmpobj[i];
-	} else
-		tmppart[npart]->objects = 0;
-	nobj = 0;
-
-	/* The gold piles */
-
-	if ((tmppart[npart]->ngold = ngold) != 0) {
-		tmppart[npart]->golds = NewTab(gold, ngold);
-		for(i=0;i<ngold;i++)
-		    tmppart[npart]->golds[i] = tmpgold[i];
-	}
-	ngold = 0;
-
-	/* The engravings */
-
-	if ((tmppart[npart]->nengraving = nengraving) != 0) {
-		tmppart[npart]->engravings = NewTab(engraving, nengraving);
-		for(i=0;i<nengraving;i++)
-		    tmppart[npart]->engravings[i] = tmpengraving[i];
-	} else
-		tmppart[npart]->engravings = 0;
-	nengraving = 0;
-
-	npart++;
-	n_plist = n_mlist = n_olist = 0;
-}
-
-/*
- * Here we want to store the room part we just got.
- */
-void
-store_room()
-{
-	register unsigned i;
-
-	/* Ok, We got the whole room, now we store it. */
-
-	/* the doors */
-
-	if ((tmproom[nrooms]->ndoor = ndoor) != 0) {
-		tmproom[nrooms]->doors = NewTab(room_door, ndoor);
-		for(i=0;i<ndoor;i++)
-		    tmproom[nrooms]->doors[i] = tmprdoor[i];
-	}
-	ndoor = 0;
-
-	/* The stairs */
-
-	if ((tmproom[nrooms]->nstair = nstair) != 0) {
-		tmproom[nrooms]->stairs = NewTab(stair, nstair);
-		for(i=0;i<nstair;i++)
-		    tmproom[nrooms]->stairs[i] = tmpstair[i];
-	}
-	nstair = 0;
-
-	/* The altars */
-	if ((tmproom[nrooms]->naltar = naltar) != 0) {
-		tmproom[nrooms]->altars = NewTab(altar, naltar);
-		for(i=0;i<naltar;i++)
-		    tmproom[nrooms]->altars[i] = tmpaltar[i];
-	}
-	naltar = 0;
-
-	/* The fountains */
-
-	if ((tmproom[nrooms]->nfountain = nfountain) != 0) {
-		tmproom[nrooms]->fountains = NewTab(fountain, nfountain);
-		for(i=0;i<nfountain;i++)
-		    tmproom[nrooms]->fountains[i] = tmpfountain[i];
-	}
-	nfountain = 0;
-
-	/* The sinks */
-
-	if ((tmproom[nrooms]->nsink = nsink) != 0) {
-		tmproom[nrooms]->sinks = NewTab(sink, nsink);
-		for(i=0;i<nsink;i++)
-		    tmproom[nrooms]->sinks[i] = tmpsink[i];
-	}
-	nsink = 0;
-
-	/* The pools */
-
-	if ((tmproom[nrooms]->npool = npool) != 0) {
-		tmproom[nrooms]->pools = NewTab(pool, npool);
-		for(i=0;i<npool;i++)
-		    tmproom[nrooms]->pools[i] = tmppool[i];
-	}
-	npool = 0;
-
-	/* the traps */
-
-	if ((tmproom[nrooms]->ntrap = ntrap) != 0) {
-		tmproom[nrooms]->traps = NewTab(trap, ntrap);
-		for(i=0;i<ntrap;i++)
-		    tmproom[nrooms]->traps[i] = tmptrap[i];
-	}
-	ntrap = 0;
-
-	/* the monsters */
-
-	if ((tmproom[nrooms]->nmonster = nmons) != 0) {
-		tmproom[nrooms]->monsters = NewTab(monster, nmons);
-		for(i=0;i<nmons;i++)
-		    tmproom[nrooms]->monsters[i] = tmpmonst[i];
-	} else
-		tmproom[nrooms]->monsters = 0;
-	nmons = 0;
-
-	/* the objects */
-
-	if ((tmproom[nrooms]->nobject = nobj) != 0) {
-		tmproom[nrooms]->objects = NewTab(object, nobj);
-		for(i=0;i<nobj;i++)
-		    tmproom[nrooms]->objects[i] = tmpobj[i];
-	} else
-		tmproom[nrooms]->objects = 0;
-	nobj = 0;
-
-	/* The gold piles */
-
-	if ((tmproom[nrooms]->ngold = ngold) != 0) {
-		tmproom[nrooms]->golds = NewTab(gold, ngold);
-		for(i=0;i<ngold;i++)
-		    tmproom[nrooms]->golds[i] = tmpgold[i];
-	}
-	ngold = 0;
-
-	/* The engravings */
-
-	if ((tmproom[nrooms]->nengraving = nengraving) != 0) {
-		tmproom[nrooms]->engravings = NewTab(engraving, nengraving);
-		for(i=0;i<nengraving;i++)
-		    tmproom[nrooms]->engravings[i] = tmpengraving[i];
-	} else
-		tmproom[nrooms]->engravings = 0;
-	nengraving = 0;
-
-	nrooms++;
-}
 
 /*
  * Output some info common to all special levels.
  */
 static boolean
-write_common_data(fd, typ, init, flgs)
-int fd, typ;
-lev_init *init;
-long flgs;
+write_common_data(fd, lvl)
+int fd;
+sp_lev *lvl;
 {
-	char c;
-	uchar len;
 	static struct version_info version_data = {
 			VERSION_NUMBER, VERSION_FEATURES,
 			VERSION_SANITY1, VERSION_SANITY2, VERSION_SANITY3
 	};
 
 	Write(fd, &version_data, sizeof version_data);
-	c = typ;
-	Write(fd, &c, sizeof(c));	/* 1 byte header */
-	Write(fd, init, sizeof(lev_init));
-	Write(fd, &flgs, sizeof flgs);
-
-	len = (uchar) strlen(tmpmessage);
-	Write(fd, &len, sizeof len);
-	if (len) Write(fd, tmpmessage, (int) len);
-	tmpmessage[0] = '\0';
 	return TRUE;
 }
 
 /*
- * Output monster info, which needs string fixups, then release memory.
+ * Here we write the sp_lev structure in the specified file (fd).
+ * Also, we have to free the memory allocated via alloc().
  */
 static boolean
-write_monsters(fd, nmonster_p, monsters_p)
+write_maze(fd, maze)
 int fd;
-char *nmonster_p;
-monster ***monsters_p;
+sp_lev *maze;
 {
-	monster *m;
-	char *name, *appr;
-	int j, n = (int)*nmonster_p;
+        int i;
+
+        if (!write_common_data(fd, maze))
+            return FALSE;
+
+	Write(fd, &(maze->n_opcodes), sizeof(maze->n_opcodes));
+
+        for (i = 0; i < maze->n_opcodes; i++) {
+	   _opcode tmpo = maze->opcodes[i];
+
+	   Write(fd, &(tmpo.opcode), sizeof(tmpo.opcode));
+
+	   if (tmpo.opcode < SPO_NULL || tmpo.opcode >= MAX_SP_OPCODES)
+	       panic("write_maze: unknown opcode (%i).", tmpo.opcode);
+
+	   if (tmpo.opcode == SPO_PUSH) {
+	       genericptr_t opdat = tmpo.opdat;
+	       if (opdat) {
+		   struct opvar *ov = (struct opvar *)opdat;
+		   int size;
+		   Write(fd, &(ov->spovartyp), sizeof(ov->spovartyp));
+		   switch (ov->spovartyp) {
+		   case SPOVAR_NULL: break;
+		   case SPOVAR_COORD:
+		   case SPOVAR_REGION:
+		   case SPOVAR_MAPCHAR:
+		   case SPOVAR_MONST:
+		   case SPOVAR_OBJ:
+		   case SPOVAR_INT:
+		       Write(fd, &(ov->vardata.l), sizeof(ov->vardata.l));
+		       break;
+		   case SPOVAR_VARIABLE:
+		   case SPOVAR_STRING:
+		       if (ov->vardata.str)
+			   size = strlen(ov->vardata.str);
+		       else size = 0;
+		       Write(fd, &size, sizeof(size));
+		       if (size) {
+			   Write(fd, ov->vardata.str, size);
+			   Free(ov->vardata.str);
+		       }
+		       break;
+		   default: panic("write_maze: unknown data type (%i).", ov->spovartyp);
+		   }
+	       } else panic("write_maze: PUSH with no data.");
+	   } else {
+	       /* sanity check */
+	       genericptr_t opdat = tmpo.opdat;
+	       if (opdat)
+		   panic("write_maze: opcode (%i) has data.", tmpo.opcode);
+	   }
+
+	   Free(tmpo.opdat);
 
-	Write(fd, nmonster_p, sizeof *nmonster_p);
-	for (j = 0; j < n; j++) {
-	    m = (*monsters_p)[j];
-	    name = m->name.str;
-	    appr = m->appear_as.str;
-	    m->name.str = m->appear_as.str = 0;
-	    m->name.len = name ? strlen(name) : 0;
-	    m->appear_as.len = appr ? strlen(appr) : 0;
-	    Write(fd, m, sizeof *m);
-	    if (name) {
-		Write(fd, name, m->name.len);
-		Free(name);
-	    }
-	    if (appr) {
-		Write(fd, appr, m->appear_as.len);
-		Free(appr);
-	    }
-	    Free(m);
 	}
-	if (*monsters_p) {
-	    Free(*monsters_p);
-	    *monsters_p = 0;
-	}
-	*nmonster_p = 0;
+        /* clear the struct for next user */
+	Free(maze->opcodes);
+	maze->opcodes = NULL;
+        /*(void) memset((genericptr_t) &maze->init_lev, 0, sizeof maze->init_lev);*/
+
 	return TRUE;
 }
 
-/*
- * Output object info, which needs string fixup, then release memory.
- */
-static boolean
-write_objects(fd, nobject_p, objects_p)
-int fd;
-char *nobject_p;
-object ***objects_p;
-{
-	object *o;
-	char *name;
-	int j, n = (int)*nobject_p;
 
-	Write(fd, nobject_p, sizeof *nobject_p);
-	for (j = 0; j < n; j++) {
-	    o = (*objects_p)[j];
-	    name = o->name.str;
-	    o->name.str = 0;	/* reset in case `len' is narrower */
-	    o->name.len = name ? strlen(name) : 0;
-	    Write(fd, o, sizeof *o);
-	    if (name) {
-		Write(fd, name, o->name.len);
-		Free(name);
-	    }
-	    Free(o);
-	}
-	if (*objects_p) {
-	    Free(*objects_p);
-	    *objects_p = 0;
-	}
-	*nobject_p = 0;
-	return TRUE;
-}
 
-/*
- * Output engraving info, which needs string fixup, then release memory.
- */
-static boolean
-write_engravings(fd, nengraving_p, engravings_p)
-int fd;
-char *nengraving_p;
-engraving ***engravings_p;
-{
-	engraving *e;
-	char *engr;
-	int j, n = (int)*nengraving_p;
-
-	Write(fd, nengraving_p, sizeof *nengraving_p);
-	for (j = 0; j < n; j++) {
-	    e = (*engravings_p)[j];
-	    engr = e->engr.str;
-	    e->engr.str = 0;	/* reset in case `len' is narrower */
-	    e->engr.len = strlen(engr);
-	    Write(fd, e, sizeof *e);
-	    Write(fd, engr, e->engr.len);
-	    Free(engr);
-	    Free(e);
-	}
-	if (*engravings_p) {
-	    Free(*engravings_p);
-	    *engravings_p = 0;
-	}
-	*nengraving_p = 0;
-	return TRUE;
-}
 
 /*
  * Open and write maze or rooms file, based on which pointer is non-null.
  * Return TRUE on success, FALSE on failure.
  */
 boolean
-write_level_file(filename, room_level, maze_level)
+write_level_file(filename, lvl)
 char *filename;
-splev *room_level;
-specialmaze *maze_level;
+sp_lev *lvl;
 {
 	int fout;
 	char lbuf[60];
@@ -1129,410 +1330,19 @@ specialmaze *maze_level;
 #endif
 	if (fout < 0) return FALSE;
 
-	if (room_level) {
-	    if (!write_rooms(fout, room_level))
-		return FALSE;
-	} else if (maze_level) {
-	    if (!write_maze(fout, maze_level))
-		return FALSE;
-	} else
-	    panic("write_level_file");
+        if (!lvl) panic("write_level_file");
+
+	if (be_verbose)
+	    fprintf(stdout, "File: '%s', opcodes: %li\n", lbuf, lvl->n_opcodes);
+
+        if (!write_maze(fout, lvl))
+          return FALSE;
 
 	(void) close(fout);
+
 	return TRUE;
 }
 
-/*
- * Here we write the structure of the maze in the specified file (fd).
- * Also, we have to free the memory allocated via alloc().
- */
-static boolean
-write_maze(fd, maze)
-int fd;
-specialmaze *maze;
-{
-	short i,j;
-	mazepart *pt;
-
-	if (!write_common_data(fd, SP_LEV_MAZE, &(maze->init_lev), maze->flags))
-	    return FALSE;
-
-	Write(fd, &(maze->filling), sizeof(maze->filling));
-	Write(fd, &(maze->numpart), sizeof(maze->numpart));
-					 /* Number of parts */
-	for(i=0;i<maze->numpart;i++) {
-	    pt = maze->parts[i];
-
-	    /* First, write the map */
-
-	    Write(fd, &(pt->halign), sizeof(pt->halign));
-	    Write(fd, &(pt->valign), sizeof(pt->valign));
-	    Write(fd, &(pt->xsize), sizeof(pt->xsize));
-	    Write(fd, &(pt->ysize), sizeof(pt->ysize));
-	    for(j=0;j<pt->ysize;j++) {
-		if(!maze->init_lev.init_present ||
-		   pt->xsize > 1 || pt->ysize > 1) {
-			Write(fd, pt->map[j], pt->xsize * sizeof *pt->map[j]);
-		}
-		Free(pt->map[j]);
-	    }
-	    Free(pt->map);
-
-	    /* level region stuff */
-	    Write(fd, &pt->nlreg, sizeof pt->nlreg);
-	    for (j = 0; j < pt->nlreg; j++) {
-		lev_region *l = pt->lregions[j];
-		char *rname = l->rname.str;
-		l->rname.str = 0;	/* reset in case `len' is narrower */
-		l->rname.len = rname ? strlen(rname) : 0;
-		Write(fd, l, sizeof *l);
-		if (rname) {
-		    Write(fd, rname, l->rname.len);
-		    Free(rname);
-		}
-		Free(l);
-	    }
-	    if (pt->nlreg > 0)
-		Free(pt->lregions);
-
-	    /* The random registers */
-	    Write(fd, &(pt->nrobjects), sizeof(pt->nrobjects));
-	    if(pt->nrobjects) {
-		    Write(fd, pt->robjects, pt->nrobjects);
-		    Free(pt->robjects);
-	    }
-	    Write(fd, &(pt->nloc), sizeof(pt->nloc));
-	    if(pt->nloc) {
-		    Write(fd, pt->rloc_x, pt->nloc);
-		    Write(fd, pt->rloc_y, pt->nloc);
-		    Free(pt->rloc_x);
-		    Free(pt->rloc_y);
-	    }
-	    Write(fd, &(pt->nrmonst), sizeof(pt->nrmonst));
-	    if(pt->nrmonst) {
-		    Write(fd, pt->rmonst, pt->nrmonst);
-		    Free(pt->rmonst);
-	    }
-
-	    /* subrooms */
-	    Write(fd, &(pt->nreg), sizeof(pt->nreg));
-	    for(j=0;j<pt->nreg;j++) {
-		    Write(fd, pt->regions[j], sizeof(region));
-		    Free(pt->regions[j]);
-	    }
-	    if(pt->nreg > 0)
-		    Free(pt->regions);
-
-	    /* the doors */
-	    Write(fd, &(pt->ndoor), sizeof(pt->ndoor));
-	    for(j=0;j<pt->ndoor;j++) {
-		    Write(fd, pt->doors[j], sizeof(door));
-		    Free(pt->doors[j]);
-	    }
-	    if (pt->ndoor > 0)
-		    Free(pt->doors);
-
-	    /* The drawbridges */
-	    Write(fd, &(pt->ndrawbridge), sizeof(pt->ndrawbridge));
-	    for(j=0;j<pt->ndrawbridge;j++) {
-		    Write(fd, pt->drawbridges[j], sizeof(drawbridge));
-		    Free(pt->drawbridges[j]);
-	    }
-	    if(pt->ndrawbridge > 0)
-		    Free(pt->drawbridges);
-
-	    /* The mazewalk directives */
-	    Write(fd, &(pt->nwalk), sizeof(pt->nwalk));
-	    for(j=0; j<pt->nwalk; j++) {
-		    Write(fd, pt->walks[j], sizeof(walk));
-		    Free(pt->walks[j]);
-	    }
-	    if (pt->nwalk > 0)
-		    Free(pt->walks);
-
-	    /* The non_diggable directives */
-	    Write(fd, &(pt->ndig), sizeof(pt->ndig));
-	    for(j=0;j<pt->ndig;j++) {
-		    Write(fd, pt->digs[j], sizeof(digpos));
-		    Free(pt->digs[j]);
-	    }
-	    if (pt->ndig > 0)
-		    Free(pt->digs);
-
-	    /* The non_passwall directives */
-	    Write(fd, &(pt->npass), sizeof(pt->npass));
-	    for(j=0;j<pt->npass;j++) {
-		    Write(fd, pt->passs[j], sizeof(digpos));
-		    Free(pt->passs[j]);
-	    }
-	    if (pt->npass > 0)
-		    Free(pt->passs);
-
-	    /* The ladders */
-	    Write(fd, &(pt->nlad), sizeof(pt->nlad));
-	    for(j=0;j<pt->nlad;j++) {
-		    Write(fd, pt->lads[j], sizeof(lad));
-		    Free(pt->lads[j]);
-	    }
-	    if (pt->nlad > 0)
-		    Free(pt->lads);
-
-	    /* The stairs */
-	    Write(fd, &(pt->nstair), sizeof(pt->nstair));
-	    for(j=0;j<pt->nstair;j++) {
-		    Write(fd, pt->stairs[j], sizeof(stair));
-		    Free(pt->stairs[j]);
-	    }
-	    if (pt->nstair > 0)
-		    Free(pt->stairs);
-
-	    /* The altars */
-	    Write(fd, &(pt->naltar), sizeof(pt->naltar));
-	    for(j=0;j<pt->naltar;j++) {
-		    Write(fd, pt->altars[j], sizeof(altar));
-		    Free(pt->altars[j]);
-	    }
-	    if (pt->naltar > 0)
-		    Free(pt->altars);
-
-	    /* The fountains */
-	    Write(fd, &(pt->nfountain), sizeof(pt->nfountain));
-	    for(j=0;j<pt->nfountain;j++) {
-		Write(fd, pt->fountains[j], sizeof(fountain));
-		Free(pt->fountains[j]);
-	    }
-	    if (pt->nfountain > 0)
-		    Free(pt->fountains);
-
-	    /* The traps */
-	    Write(fd, &(pt->ntrap), sizeof(pt->ntrap));
-	    for(j=0;j<pt->ntrap;j++) {
-		    Write(fd, pt->traps[j], sizeof(trap));
-		    Free(pt->traps[j]);
-	    }
-	    if (pt->ntrap)
-		    Free(pt->traps);
-
-	    /* The monsters */
-	    if (!write_monsters(fd, &pt->nmonster, &pt->monsters))
-		    return FALSE;
-
-	    /* The objects */
-	    if (!write_objects(fd, &pt->nobject, &pt->objects))
-		    return FALSE;
-
-	    /* The gold piles */
-	    Write(fd, &(pt->ngold), sizeof(pt->ngold));
-	    for(j=0;j<pt->ngold;j++) {
-		    Write(fd, pt->golds[j], sizeof(gold));
-		    Free(pt->golds[j]);
-	    }
-	    if (pt->ngold > 0)
-		    Free(pt->golds);
-
-	    /* The engravings */
-	    if (!write_engravings(fd, &pt->nengraving, &pt->engravings))
-		    return FALSE;
-
-	    Free(pt);
-	}
-
-	Free(maze->parts);
-	maze->parts = (mazepart **)0;
-	maze->numpart = 0;
-	return TRUE;
-}
-
-/*
- * Here we write the structure of the room level in the specified file (fd).
- */
-static boolean
-write_rooms(fd, lev)
-int fd;
-splev *lev;
-{
-	short i,j, size;
-	room *pt;
-
-	if (!write_common_data(fd, SP_LEV_ROOMS, &(lev->init_lev), lev->flags))
-		return FALSE;
-
-	/* Random registers */
-
-	Write(fd, &lev->nrobjects, sizeof(lev->nrobjects));
-	if (lev->nrobjects)
-		Write(fd, lev->robjects, lev->nrobjects);
-	Write(fd, &lev->nrmonst, sizeof(lev->nrmonst));
-	if (lev->nrmonst)
-		Write(fd, lev->rmonst, lev->nrmonst);
-
-	Write(fd, &(lev->nroom), sizeof(lev->nroom));
-							/* Number of rooms */
-	for(i=0;i<lev->nroom;i++) {
-		pt = lev->rooms[i];
-
-		/* Room characteristics */
-
-		size = (short) (pt->name ? strlen(pt->name) : 0);
-		Write(fd, &size, sizeof(size));
-		if (size)
-			Write(fd, pt->name, size);
-
-		size = (short) (pt->parent ? strlen(pt->parent) : 0);
-		Write(fd, &size, sizeof(size));
-		if (size)
-			Write(fd, pt->parent, size);
-
-		Write(fd, &(pt->x), sizeof(pt->x));
-		Write(fd, &(pt->y), sizeof(pt->y));
-		Write(fd, &(pt->w), sizeof(pt->w));
-		Write(fd, &(pt->h), sizeof(pt->h));
-		Write(fd, &(pt->xalign), sizeof(pt->xalign));
-		Write(fd, &(pt->yalign), sizeof(pt->yalign));
-		Write(fd, &(pt->rtype), sizeof(pt->rtype));
-		Write(fd, &(pt->chance), sizeof(pt->chance));
-		Write(fd, &(pt->rlit), sizeof(pt->rlit));
-		Write(fd, &(pt->filled), sizeof(pt->filled));
-
-		/* the doors */
-		Write(fd, &(pt->ndoor), sizeof(pt->ndoor));
-		for(j=0;j<pt->ndoor;j++)
-			Write(fd, pt->doors[j], sizeof(room_door));
-
-		/* The stairs */
-		Write(fd, &(pt->nstair), sizeof(pt->nstair));
-		for(j=0;j<pt->nstair;j++)
-			Write(fd, pt->stairs[j], sizeof(stair));
-
-		/* The altars */
-		Write(fd, &(pt->naltar), sizeof(pt->naltar));
-		for(j=0;j<pt->naltar;j++)
-			Write(fd, pt->altars[j], sizeof(altar));
-
-		/* The fountains */
-		Write(fd, &(pt->nfountain), sizeof(pt->nfountain));
-		for(j=0;j<pt->nfountain;j++)
-			Write(fd, pt->fountains[j], sizeof(fountain));
-
-		/* The sinks */
-		Write(fd, &(pt->nsink), sizeof(pt->nsink));
-		for(j=0;j<pt->nsink;j++)
-			Write(fd, pt->sinks[j], sizeof(sink));
-
-		/* The pools */
-		Write(fd, &(pt->npool), sizeof(pt->npool));
-		for(j=0;j<pt->npool;j++)
-			Write(fd, pt->pools[j], sizeof(pool));
-
-		/* The traps */
-		Write(fd, &(pt->ntrap), sizeof(pt->ntrap));
-		for(j=0;j<pt->ntrap;j++)
-			Write(fd, pt->traps[j], sizeof(trap));
-
-		/* The monsters */
-		if (!write_monsters(fd, &pt->nmonster, &pt->monsters))
-			return FALSE;
-
-		/* The objects */
-		if (!write_objects(fd, &pt->nobject, &pt->objects))
-			return FALSE;
-
-		/* The gold piles */
-		Write(fd, &(pt->ngold), sizeof(pt->ngold));
-		for(j=0;j<pt->ngold;j++)
-			Write(fd, pt->golds[j], sizeof(gold));
-
-		/* The engravings */
-		if (!write_engravings(fd, &pt->nengraving, &pt->engravings))
-			return FALSE;
-
-	}
-
-	/* The corridors */
-	Write(fd, &lev->ncorr, sizeof(lev->ncorr));
-	for (i=0; i < lev->ncorr; i++)
-		Write(fd, lev->corrs[i], sizeof(corridor));
-	return TRUE;
-}
-
-/*
- * Release memory allocated to a rooms-style special level; maze-style
- * levels have the fields freed as they're written; monsters, objects, and
- * engravings are freed as written for both styles, so not handled here.
- */
-void
-free_rooms(lev)
-splev *lev;
-{
-	room *r;
-	int j, n = lev->nroom;
-
-	while(n--) {
-		r = lev->rooms[n];
-		Free(r->name);
-		Free(r->parent);
-		if ((j = r->ndoor) != 0) {
-			while(j--)
-				Free(r->doors[j]);
-			Free(r->doors);
-		}
-		if ((j = r->nstair) != 0) {
-			while(j--)
-				Free(r->stairs[j]);
-			Free(r->stairs);
-		}
-		if ((j = r->naltar) != 0) {
-			while (j--)
-				Free(r->altars[j]);
-			Free(r->altars);
-		}
-		if ((j = r->nfountain) != 0) {
-			while(j--)
-				Free(r->fountains[j]);
-			Free(r->fountains);
-		}
-		if ((j = r->nsink) != 0) {
-			while(j--)
-				Free(r->sinks[j]);
-			Free(r->sinks);
-		}
-		if ((j = r->npool) != 0) {
-			while(j--)
-				Free(r->pools[j]);
-			Free(r->pools);
-		}
-		if ((j = r->ntrap) != 0) {
-			while (j--)
-				Free(r->traps[j]);
-			Free(r->traps);
-		}
-		if ((j = r->ngold) != 0) {
-			while(j--)
-				Free(r->golds[j]);
-			Free(r->golds);
-		}
-		Free(r);
-		lev->rooms[n] = (room *)0;
-	}
-	Free(lev->rooms);
-	lev->rooms = (room **)0;
-	lev->nroom = 0;
-
-	for (j = 0; j < lev->ncorr; j++) {
-		Free(lev->corrs[j]);
-		lev->corrs[j] = (corridor *)0;
-	}
-	Free(lev->corrs);
-	lev->corrs = (corridor **)0;
-	lev->ncorr = 0;
-
-	Free(lev->robjects);
-	lev->robjects = (char *)0;
-	lev->nrobjects = 0;
-	Free(lev->rmonst);
-	lev->rmonst = (char *)0;
-	lev->nrmonst = 0;
-}
 
 #ifdef STRICT_REF_DEF
 /*