#include "hack.h"

#include "dlb.h"

#include "sp_lev.h"

#ifdef _MSC_VER

#pragma warning(push)

#pragma warning(disable : 4244)

typedef void FDECL((*select_iter_func), (int, int, genericptr));

extern void FDECL(mkmap, (lev_init *));

STATIC_DCL void NDECL(solidify_map);

STATIC_DCL void FDECL(splev_stack_init, (struct splevstack *));

STATIC_DCL void FDECL(splev_stack_done, (struct splevstack *));

STATIC_DCL void FDECL(splev_stack_push, (struct splevstack *,

struct opvar *));

STATIC_DCL struct opvar *FDECL(splev_stack_pop, (struct splevstack *));

STATIC_DCL struct splevstack *FDECL(splev_stack_reverse,

(struct splevstack *));

STATIC_DCL struct opvar *FDECL(opvar_new_str, (char *));

STATIC_DCL struct opvar *FDECL(opvar_new_int, (long));

STATIC_DCL struct opvar *FDECL(opvar_new_coord, (int, int));

#if 0

STATIC_DCL struct opvar * FDECL(opvar_new_region, (int,int, int,int));

#endif /*0*/

STATIC_DCL struct opvar *FDECL(opvar_clone, (struct opvar *));

STATIC_DCL struct opvar *FDECL(opvar_var_conversion, (struct sp_coder *,

struct opvar *));

STATIC_DCL struct splev_var *FDECL(opvar_var_defined, (struct sp_coder *,

char *));

STATIC_DCL struct opvar *FDECL(splev_stack_getdat, (struct sp_coder *,

XCHAR_P));

STATIC_DCL struct opvar *FDECL(splev_stack_getdat_any, (struct sp_coder *));

STATIC_DCL void FDECL(variable_list_del, (struct splev_var *));

STATIC_DCL void FDECL(lvlfill_maze_grid, (int, int, int, int, SCHAR_P));

STATIC_DCL void FDECL(lvlfill_solid, (SCHAR_P, SCHAR_P));

STATIC_DCL void FDECL(set_wall_property, (XCHAR_P, XCHAR_P, XCHAR_P, XCHAR_P,

int));

STATIC_DCL void NDECL(shuffle_alignments);

STATIC_DCL void NDECL(count_features);

STATIC_DCL void NDECL(remove_boundary_syms);

STATIC_DCL void FDECL(set_door_orientation, (int, int));

STATIC_DCL void FDECL(maybe_add_door, (int, int, struct mkroom *));

STATIC_DCL void NDECL(link_doors_rooms);

STATIC_DCL void NDECL(fill_rooms);

STATIC_DCL int NDECL(rnddoor);

STATIC_DCL int NDECL(rndtrap);

STATIC_DCL void FDECL(get_location, (schar *, schar *, int, struct mkroom *));

STATIC_DCL boolean FDECL(is_ok_location, (SCHAR_P, SCHAR_P, int));

STATIC_DCL unpacked_coord FDECL(get_unpacked_coord, (long, int));

STATIC_DCL void FDECL(get_location_coord, (schar *, schar *, int,

struct mkroom *, long));

STATIC_DCL void FDECL(get_room_loc, (schar *, schar *, struct mkroom *));

STATIC_DCL void FDECL(get_free_room_loc, (schar *, schar *,

struct mkroom *, packed_coord));

STATIC_DCL boolean FDECL(create_subroom, (struct mkroom *, XCHAR_P, XCHAR_P,

XCHAR_P, XCHAR_P, XCHAR_P, XCHAR_P));

STATIC_DCL void FDECL(create_door, (room_door *, struct mkroom *));

STATIC_DCL void FDECL(create_trap, (spltrap *, struct mkroom *));

STATIC_DCL int FDECL(noncoalignment, (ALIGNTYP_P));

STATIC_DCL boolean FDECL(m_bad_boulder_spot, (int, int));

STATIC_DCL int FDECL(pm_to_humidity, (struct permonst *));

STATIC_DCL void FDECL(create_monster, (monster *, struct mkroom *));

STATIC_DCL void FDECL(create_object, (object *, struct mkroom *));

STATIC_DCL void FDECL(create_altar, (altar *, struct mkroom *));

STATIC_DCL void FDECL(replace_terrain, (replaceterrain *, struct mkroom *));

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 struct mkroom *FDECL(build_room, (room *, struct mkroom *));

STATIC_DCL void FDECL(light_region, (region *));

STATIC_DCL void FDECL(wallify_map, (int, int, int, int));

STATIC_DCL void FDECL(maze1xy, (coord *, int));

STATIC_DCL void NDECL(fill_empty_maze);

STATIC_DCL boolean FDECL(sp_level_loader, (dlb *, sp_lev *));

STATIC_DCL boolean FDECL(sp_level_free, (sp_lev *));

STATIC_DCL void FDECL(splev_initlev, (lev_init *));

STATIC_DCL struct sp_frame *FDECL(frame_new, (long));

STATIC_DCL void FDECL(frame_del, (struct sp_frame *));

STATIC_DCL void FDECL(spo_frame_push, (struct sp_coder *));

STATIC_DCL void FDECL(spo_frame_pop, (struct sp_coder *));

STATIC_DCL long FDECL(sp_code_jmpaddr, (long, long));

STATIC_DCL void FDECL(spo_call, (struct sp_coder *));

STATIC_DCL void FDECL(spo_return, (struct sp_coder *));

STATIC_DCL void FDECL(spo_end_moninvent, (struct sp_coder *));

STATIC_DCL void FDECL(spo_pop_container, (struct sp_coder *));

STATIC_DCL void FDECL(spo_message, (struct sp_coder *));

STATIC_DCL void FDECL(spo_monster, (struct sp_coder *));

STATIC_DCL void FDECL(spo_object, (struct sp_coder *));

STATIC_DCL void FDECL(spo_level_flags, (struct sp_coder *));

STATIC_DCL void FDECL(spo_initlevel, (struct sp_coder *));

STATIC_DCL void FDECL(spo_engraving, (struct sp_coder *));

STATIC_DCL void FDECL(spo_mineralize, (struct sp_coder *));

STATIC_DCL void FDECL(spo_room, (struct sp_coder *));

STATIC_DCL void FDECL(spo_endroom, (struct sp_coder *));

STATIC_DCL void FDECL(spo_stair, (struct sp_coder *));

STATIC_DCL void FDECL(spo_ladder, (struct sp_coder *));

STATIC_DCL void FDECL(spo_grave, (struct sp_coder *));

STATIC_DCL void FDECL(spo_altar, (struct sp_coder *));

STATIC_DCL void FDECL(spo_trap, (struct sp_coder *));

STATIC_DCL void FDECL(spo_gold, (struct sp_coder *));

STATIC_DCL void FDECL(spo_corridor, (struct sp_coder *));

STATIC_DCL void FDECL(selection_setpoint, (int, int, struct opvar *, XCHAR_P));

STATIC_DCL struct opvar *FDECL(selection_not, (struct opvar *));

STATIC_DCL struct opvar *FDECL(selection_logical_oper, (struct opvar *,

struct opvar *, CHAR_P));

STATIC_DCL struct opvar *FDECL(selection_filter_mapchar, (struct opvar *,

struct opvar *));

STATIC_DCL void FDECL(selection_filter_percent, (struct opvar *, int));

STATIC_DCL int FDECL(selection_rndcoord, (struct opvar *, schar *, schar *,

BOOLEAN_P));

STATIC_DCL void FDECL(selection_do_grow, (struct opvar *, int));

STATIC_DCL int FDECL(floodfillchk_match_under, (int, int));

STATIC_DCL int FDECL(floodfillchk_match_accessible, (int, int));

STATIC_DCL boolean FDECL(sel_flood_havepoint, (int, int,

xchar *, xchar *, int));

STATIC_DCL void FDECL(selection_do_ellipse, (struct opvar *, int, int,

int, int, int));

STATIC_DCL long FDECL(line_dist_coord, (long, long, long, long, long, long));

STATIC_DCL void FDECL(selection_do_gradient, (struct opvar *, long, long, long,

long, long, long, long, long));

STATIC_DCL void FDECL(selection_do_line, (SCHAR_P, SCHAR_P, SCHAR_P, SCHAR_P,

struct opvar *));

STATIC_DCL void FDECL(selection_do_randline, (SCHAR_P, SCHAR_P, SCHAR_P,

SCHAR_P, SCHAR_P, SCHAR_P,

struct opvar *));

STATIC_DCL void FDECL(selection_iterate, (struct opvar *, select_iter_func,

genericptr_t));

STATIC_DCL void FDECL(sel_set_ter, (int, int, genericptr_t));

STATIC_DCL void FDECL(sel_set_feature, (int, int, genericptr_t));

STATIC_DCL void FDECL(sel_set_door, (int, int, genericptr_t));

STATIC_DCL void FDECL(spo_door, (struct sp_coder *));

STATIC_DCL void FDECL(spo_feature, (struct sp_coder *));

STATIC_DCL void FDECL(spo_terrain, (struct sp_coder *));

STATIC_DCL void FDECL(spo_replace_terrain, (struct sp_coder *));

STATIC_DCL boolean FDECL(generate_way_out_method, (int, int, struct opvar *));

STATIC_DCL void NDECL(ensure_way_out);

STATIC_DCL void FDECL(spo_levregion, (struct sp_coder *));

STATIC_DCL void FDECL(spo_region, (struct sp_coder *));

STATIC_DCL void FDECL(spo_drawbridge, (struct sp_coder *));

STATIC_DCL void FDECL(spo_mazewalk, (struct sp_coder *));

STATIC_DCL void FDECL(spo_wall_property, (struct sp_coder *));

STATIC_DCL void FDECL(spo_room_door, (struct sp_coder *));

STATIC_DCL void FDECL(sel_set_wallify, (int, int, genericptr_t));

STATIC_DCL void FDECL(spo_wallify, (struct sp_coder *));

STATIC_DCL void FDECL(spo_map, (struct sp_coder *));

STATIC_DCL void FDECL(spo_jmp, (struct sp_coder *, sp_lev *));

STATIC_DCL void FDECL(spo_conditional_jump, (struct sp_coder *, sp_lev *));

STATIC_DCL void FDECL(spo_var_init, (struct sp_coder *));

#if 0

STATIC_DCL long FDECL(opvar_array_length, (struct sp_coder *));

#endif /*0*/

STATIC_DCL void FDECL(spo_shuffle_array, (struct sp_coder *));

STATIC_DCL boolean FDECL(sp_level_coder, (sp_lev *));

#define LEFT 1

#define H_LEFT 2

#define CENTER 3

#define H_RIGHT 4

#define RIGHT 5

#define TOP 1

#define BOTTOM 5

#define sq(x) ((x) * (x))

#define XLIM 4

#define YLIM 3

#define Fread (void) dlb_fread

#define Fgetc (schar) dlb_fgetc

#define New(type) (type *) alloc(sizeof(type))

#define NewTab(type, size) (type **) alloc(sizeof(type *) * (unsigned) size)

#define Free(ptr) if (ptr) free((genericptr_t) (ptr))

extern struct engr *head_engr;

extern int min_rx, max_rx, min_ry, max_ry; /* from mkmap.c */

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;

char *lev_message = 0;

lev_region *lregions = 0;

int num_lregions = 0;

static boolean splev_init_present = FALSE;

static boolean icedpools = FALSE;

static int mines_prize_count = 0, soko_prize_count = 0; /* achievements */

static struct obj *container_obj[MAX_CONTAINMENT];

static int container_idx = 0;

static struct monst *invent_carrying_monster = NULL;

#define SPLEV_STACK_RESERVE 128

solidify_map()

{

xchar x, y;

for (x = 0; x < COLNO; x++)

for (y = 0; y < ROWNO; y++)

if (IS_STWALL(levl[x][y].typ) && !SpLev_Map[x][y])

levl[x][y].wall_info |= (W_NONDIGGABLE | W_NONPASSWALL);

}

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 *));

}

}

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:

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);

}

}

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 *));

(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));

tmpov->spovartyp = SPOVAR_STRING;

if (s) {

int len = strlen(s);

tmpov->vardata.str = (char *) alloc(len + 1);

(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));

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));

tmpov->spovartyp = SPOVAR_COORD;

tmpov->vardata.l = SP_COORD_PACK(x, y);

return tmpov;

}

#if 0

struct opvar *

opvar_new_region(x1,y1,x2,y2)

int x1,y1,x2,y2;

{

struct opvar *tmpov = (struct opvar *) alloc(sizeof (struct opvar));

tmpov->spovartyp = SPOVAR_REGION;

tmpov->vardata.l = SP_REGION_PACK(x1,y1,x2,y2);

return tmpov;

}

#endif /*0*/

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);

}

void flip_drawbridge_horizontal(lev)

struct rm *lev;

{

if (IS_DRAWBRIDGE(lev->typ)) {

if ((lev->drawbridgemask & DB_DIR) == DB_WEST) {

lev->drawbridgemask &= ~DB_WEST;

lev->drawbridgemask |= DB_EAST;

} else if ((lev->drawbridgemask & DB_DIR) == DB_EAST) {

lev->drawbridgemask &= ~DB_EAST;

lev->drawbridgemask |= DB_WEST;

}

}

}

void flip_drawbridge_vertical(lev)

struct rm *lev;

{

if (IS_DRAWBRIDGE(lev->typ)) {

if ((lev->drawbridgemask & DB_DIR) == DB_NORTH) {

lev->drawbridgemask &= ~DB_NORTH;

lev->drawbridgemask |= DB_SOUTH;

} else if ((lev->drawbridgemask & DB_DIR) == DB_SOUTH) {

lev->drawbridgemask &= ~DB_SOUTH;

lev->drawbridgemask |= DB_NORTH;

}

}

}

flip_level(int flp)

{

int x2 = COLNO-1;

int y2 = ROWNO-1;

int x, y, i;

struct rm trm;

struct trap *ttmp;

struct obj *otmp;

struct monst *mtmp;

struct engr *etmp;

struct mkroom *sroom;

/* stairs and ladders */

if (flp & 1) {

yupstair = y2 - yupstair;

ydnstair = y2 - ydnstair;

yupladder = y2 - yupladder;

ydnladder = y2 - ydnladder;

}

if (flp & 2) {

xupstair = x2 - xupstair;

xdnstair = x2 - xdnstair;

xupladder = x2 - xupladder;

xdnladder = x2 - xdnladder;

}

/* traps */

for (ttmp = ftrap; ttmp; ttmp = ttmp->ntrap) {

if (flp & 1) {

ttmp->ty = y2 - ttmp->ty;

if (ttmp->ttyp == ROLLING_BOULDER_TRAP) {

ttmp->launch.y = y2 - ttmp->launch.y;

ttmp->launch2.y = y2 - ttmp->launch2.y;

}

}

if (flp & 2) {

ttmp->tx = x2 - ttmp->tx;

if (ttmp->ttyp == ROLLING_BOULDER_TRAP) {

ttmp->launch.x = x2 - ttmp->launch.x;

ttmp->launch2.x = x2 - ttmp->launch2.x;

}

}

}

/* objects */

for (otmp = fobj; otmp; otmp = otmp->nobj) {

if (flp & 1)

otmp->oy = y2 - otmp->oy;

if (flp & 2)

otmp->ox = x2 - otmp->ox;

}

/* buried objects */

for (otmp = level.buriedobjlist; otmp; otmp = otmp->nobj) {

if (flp & 1)

otmp->oy = y2 - otmp->oy;

if (flp & 2)

otmp->ox = x2 - otmp->ox;

}

/* monsters */

for (mtmp = fmon; mtmp; mtmp = mtmp->nmon) {

if (flp & 1) {

mtmp->my = y2 - mtmp->my;

if (mtmp->ispriest)

EPRI(mtmp)->shrpos.y = y2 - EPRI(mtmp)->shrpos.y;

else if (mtmp->isshk) {

ESHK(mtmp)->shk.y = y2 - ESHK(mtmp)->shk.y;

ESHK(mtmp)->shd.y = y2 - ESHK(mtmp)->shd.y;

} else if (mtmp->wormno) {

flip_worm_segs_vertical(mtmp, y2);

}

}

if (flp & 2) {

mtmp->mx = x2 - mtmp->mx;

if (mtmp->ispriest)

EPRI(mtmp)->shrpos.x = x2 - EPRI(mtmp)->shrpos.x;

else if (mtmp->isshk) {

ESHK(mtmp)->shk.x = x2 - ESHK(mtmp)->shk.x;

ESHK(mtmp)->shd.x = x2 - ESHK(mtmp)->shd.x;

} else if (mtmp->wormno) {

flip_worm_segs_horizontal(mtmp, x2);

}

}

}

/* engravings */

for (etmp = head_engr; etmp; etmp = etmp->nxt_engr) {

if (flp & 1)

etmp->engr_y = y2 - etmp->engr_y;

if (flp & 2)

etmp->engr_x = x2 - etmp->engr_x;

}

/* regions */

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

if (flp & 1) {

lregions[i].inarea.y1 = y2 - lregions[i].inarea.y1;

lregions[i].inarea.y2 = y2 - lregions[i].inarea.y2;

if (lregions[i].inarea.y1 > lregions[i].inarea.y2) {

int tmp = lregions[i].inarea.y1;

lregions[i].inarea.y1 = lregions[i].inarea.y2;

lregions[i].inarea.y2 = tmp;

}

lregions[i].delarea.y1 = y2 - lregions[i].delarea.y1;

lregions[i].delarea.y2 = y2 - lregions[i].delarea.y2;

if (lregions[i].delarea.y1 > lregions[i].delarea.y2) {

int tmp = lregions[i].delarea.y1;

lregions[i].delarea.y1 = lregions[i].delarea.y2;

lregions[i].delarea.y2 = tmp;

}

}

if (flp & 2) {

lregions[i].inarea.x1 = x2 - lregions[i].inarea.x1;

lregions[i].inarea.x2 = x2 - lregions[i].inarea.x2;

if (lregions[i].inarea.x1 > lregions[i].inarea.x2) {

int tmp = lregions[i].inarea.x1;

lregions[i].inarea.x1 = lregions[i].inarea.x2;

lregions[i].inarea.x2 = tmp;

}

lregions[i].delarea.x1 = x2 - lregions[i].delarea.x1;

lregions[i].delarea.x2 = x2 - lregions[i].delarea.x2;

if (lregions[i].delarea.x1 > lregions[i].delarea.x2) {

int tmp = lregions[i].delarea.x1;

lregions[i].delarea.x1 = lregions[i].delarea.x2;

lregions[i].delarea.x2 = tmp;

}

}

}

/* rooms */

for(sroom = &rooms[0]; ; sroom++) {

if (sroom->hx < 0) break;

if (flp & 1) {

sroom->ly = y2 - sroom->ly;

sroom->hy = y2 - sroom->hy;

if (sroom->ly > sroom->hy) {

int tmp = sroom->ly;

sroom->ly = sroom->hy;

sroom->hy = tmp;

}

}

if (flp & 2) {

sroom->lx = x2 - sroom->lx;

sroom->hx = x2 - sroom->hx;

if (sroom->lx > sroom->hx) {

int tmp = sroom->lx;

sroom->lx = sroom->hx;

sroom->hx = tmp;

}

}

if (sroom->nsubrooms)

for (i = 0; i < sroom->nsubrooms; i++) {

struct mkroom *rroom = sroom->sbrooms[i];

if (flp & 1) {

rroom->ly = y2 - rroom->ly;

rroom->hy = y2 - rroom->hy;

if (rroom->ly > rroom->hy) {

int tmp = rroom->ly;

rroom->ly = rroom->hy;

rroom->hy = tmp;

}

}

if (flp & 2) {

rroom->lx = x2 - rroom->lx;

rroom->hx = x2 - rroom->hx;

if (rroom->lx > rroom->hx) {

int tmp = rroom->lx;

rroom->lx = rroom->hx;

rroom->hx = tmp;

}

}

}

}

/* doors */

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

if (flp & 1)

doors[i].y = y2 - doors[i].y;

if (flp & 2)

doors[i].x = x2 - doors[i].x;

}

/* the map */

if (flp & 1) {

for (x = 0; x <= x2; x++)

for (y = 0; y <= (y2 / 2); y++) {

flip_drawbridge_vertical(&levl[x][y]);

flip_drawbridge_vertical(&levl[x][y2-y]);

trm = levl[x][y];

levl[x][y] = levl[x][y2-y];

levl[x][y2-y] = trm;

otmp = level.objects[x][y];

level.objects[x][y] = level.objects[x][y2-y];

level.objects[x][y2-y] = otmp;

mtmp = level.monsters[x][y];

level.monsters[x][y] = level.monsters[x][y2-y];

level.monsters[x][y2-y] = mtmp;

}

}

if (flp & 2) {

for (x = 0; x <= (x2 / 2); x++)

for (y = 0; y <= y2; y++) {

flip_drawbridge_horizontal(&levl[x][y]);

flip_drawbridge_horizontal(&levl[x2-x][y]);

trm = levl[x][y];

levl[x][y] = levl[x2-x][y];

levl[x2-x][y] = trm;

otmp = level.objects[x][y];

level.objects[x][y] = level.objects[x2-x][y];

level.objects[x2-x][y] = otmp;

mtmp = level.monsters[x][y];

level.monsters[x][y] = level.monsters[x2-x][y];

level.monsters[x2-x][y] = mtmp;

}

}

wall_extends(1, 0, COLNO-1, ROWNO-1);

}

flip_level_rnd(int flp)

{

int c = 0;

if ((flp & 1) && rn2(2)) c |= 1;

if ((flp & 2) && rn2(2)) c |= 2;

/* Workaround for preventing the stairs to Vlad's tower appearing

if (On_W_tower_level(&u.uz)) { flp &= 1; }

flip_level(c);

}

#define opvar_free(ov) \

do { \

if (ov) { \

opvar_free_x(ov); \

ov = NULL; \

} else \

impossible("opvar_free(), %s", nhFunc); \

} while (0)

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));

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 = dupstr(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;

{

static const char nhFunc[] = "opvar_var_conversion";

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)]);

opvar_free(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;

{

static const char nhFunc[] = "splev_stack_getdat";

if (coder && coder->stack) {

struct opvar *tmp = splev_stack_pop(coder->stack);

struct opvar *ret = NULL;

if (!tmp)

panic("no value type %i in stack.", typ);

if (tmp->spovartyp == SPOVAR_VARIABLE) {

ret = opvar_var_conversion(coder, tmp);

opvar_free(tmp);

tmp = ret;

}

if (tmp->spovartyp == typ)

return tmp;

else opvar_free(tmp);

}

return NULL;

}

struct opvar *

splev_stack_getdat_any(coder)

struct sp_coder *coder;

{

static const char nhFunc[] = "splev_stack_getdat_any";

if (coder && coder->stack) {

struct opvar *tmp = splev_stack_pop(coder->stack);

if (tmp && tmp->spovartyp == SPOVAR_VARIABLE) {

struct opvar *ret = opvar_var_conversion(coder, tmp);

opvar_free(tmp);

return ret;

}

return tmp;

}

return NULL;

}

variable_list_del(varlist)

struct splev_var *varlist;

{

static const char nhFunc[] = "variable_list_del";

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;

}

}

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++) {

if (level.flags.corrmaze)

levl[x][y].typ = STONE;

else

levl[x][y].typ = (y < 2 || ((x % 2) && (y % 2))) ? STONE

: filling;

}

}

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);

}

}

STATIC_OVL void

set_wall_property(x1, y1, x2, y2, prop)

xchar x1, y1, x2, y2;

int prop;

{

register xchar x, y;

struct rm *lev;

x1 = max(x1, 1);

x2 = min(x2, COLNO - 1);

y1 = max(y1, 0);

y2 = min(y2, ROWNO - 1);

for (y = y1; y <= y2; y++)

for (x = x1; x <= x2; x++) {

lev = &levl[x][y];

if (IS_STWALL(lev->typ) || IS_TREE(lev->typ)

/* 3.6.2: made iron bars eligible to be flagged nondiggable

|| lev->typ == IRONBARS)

lev->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;

}

}

STATIC_OVL void

count_features()

{

xchar x, y;

level.flags.nfountains = level.flags.nsinks = level.flags.nfurnaces = 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++;