//
// Stairs.
//

#include "game.h"
#include "id.h"
#include "stair.h"



//
// The bounding box of the building.
//

UBYTE STAIR_x1;
UBYTE STAIR_z1;
UBYTE STAIR_x2;
UBYTE STAIR_z2;

//
// The height of the roof of the building, 1 + the height of
// the highest storey.
// 

UBYTE STAIR_roof_height;

//
// The maximum dimensions of the bounding box.
// This must be a multiple of 8.
//

#define STAIR_MAX_SIZE 32

//
// The array where we store the positions of the stairs.
//

//
// NB. Both flags can be set at once!
//

// in building.h
//#define STAIR_FLAG_UP	(1 << 0)	// The staircase goes up
//#define STAIR_FLAG_DOWN (1 << 1)	// The staircase goes down.

typedef struct
{
	UBYTE flag;
	UBYTE up;	// The storey you go up to   (if (flag & STAIR_FLAG_UP))
	UBYTE down;	// The storey you go down to (if (flag & STAIR_FLAG_DOWN))
	UBYTE x1;
	UBYTE z1;
	UBYTE x2;
	UBYTE z2;

} STAIR_Stair;

#define STAIR_MAX_STAIRS 32

STAIR_Stair STAIR_stair[STAIR_MAX_STAIRS];
SLONG       STAIR_stair_upto;

//
// The info for each storey.
//

#define STAIR_MAX_PER_STOREY 3

typedef struct
{
	SLONG handle;	// How the storey is identified.
	UBYTE opp_x1;	// A wall is it good to have a staircase opposite on.
	UBYTE opp_z1;
	UBYTE opp_x2;
	UBYTE opp_z2;
	UBYTE height;
	UBYTE stair[STAIR_MAX_PER_STOREY];	// Indices into the STAIR_stair array. 0 => NULL index.
	UBYTE square[STAIR_MAX_SIZE][STAIR_MAX_SIZE / 8];

} STAIR_Storey;

#define STAIR_MAX_STOREYS 32

STAIR_Storey STAIR_storey[STAIR_MAX_STOREYS];
SLONG        STAIR_storey_upto;

//
// Sets the given square on the given storey.
//

void STAIR_set_bit(SLONG storey, SLONG x, SLONG z)
{
	SLONG off_x;
	SLONG off_z;

	SLONG byte;
	SLONG bit;

	ASSERT(WITHIN(storey, 0, STAIR_storey_upto - 1));
	ASSERT(WITHIN(x, STAIR_x1, STAIR_x2 - 1));
	ASSERT(WITHIN(z, STAIR_z1, STAIR_z2 - 1));

	off_x = x - STAIR_x1;
	off_z = z - STAIR_z1;

	ASSERT(WITHIN(off_x, 0, STAIR_MAX_SIZE - 1));
	ASSERT(WITHIN(off_z, 0, STAIR_MAX_SIZE - 1));

	byte = off_x >> 3;
	bit  = off_x  & 7;

	STAIR_storey[storey].square[off_z][byte] |= (1 << bit);
}

UBYTE STAIR_get_bit(SLONG storey, SLONG x, SLONG z)
{
	SLONG off_x;
	SLONG off_z;		

	SLONG byte;
	SLONG bit;

	ASSERT(WITHIN(storey, 0, STAIR_storey_upto - 1));
	ASSERT(WITHIN(x, STAIR_x1, STAIR_x2 - 1));
	ASSERT(WITHIN(z, STAIR_z1, STAIR_z2 - 1));

	off_x = x - STAIR_x1;
	off_z = z - STAIR_z1;

	ASSERT(WITHIN(off_x, 0, STAIR_MAX_SIZE - 1));
	ASSERT(WITHIN(off_z, 0, STAIR_MAX_SIZE - 1));

	byte = off_x >> 3;
	bit  = off_x  & 7;

	return STAIR_storey[storey].square[off_z][byte] & (1 << bit);
}

UBYTE STAIR_get_bit_from_square(UBYTE square[STAIR_MAX_SIZE][STAIR_MAX_SIZE / 8], SLONG x, SLONG z)
{
	SLONG off_x;
	SLONG off_z;

	SLONG byte;
	SLONG bit;

	ASSERT(WITHIN(x, STAIR_x1, STAIR_x2 - 1));
	ASSERT(WITHIN(z, STAIR_z1, STAIR_z2 - 1));

	off_x = x - STAIR_x1;
	off_z = z - STAIR_z1;

	ASSERT(WITHIN(off_x, 0, STAIR_MAX_SIZE - 1));
	ASSERT(WITHIN(off_z, 0, STAIR_MAX_SIZE - 1));

	byte = off_x >> 3;
	bit  = off_x  & 7;

	return square[off_z][byte] & (1 << bit);
}



//
// For working out the inside squares on each floor of the building.
//

//
// For ENTER link types, the square field is the first x-line that
// the wall encloses a complete square. For a LEAVE link, square is
// the last x-line that the wall encloses a complete square.
//

#define STAIR_LINK_T_ENTER 1
#define STAIR_LINK_T_LEAVE 2

typedef struct
{
	UBYTE next;
	UBYTE square;
	UWORD pos;		// 8-bit fixed point.

} STAIR_Link;

#define STAIR_MAX_LINKS 128

STAIR_Link STAIR_link[STAIR_MAX_LINKS];
SLONG      STAIR_link_upto;

//
// One linked list per z-row of floor square.
// 0 is the NULL index
//

UBYTE STAIR_edge[STAIR_MAX_SIZE];

//
// How to access the EDGE list. It is relative to
// the bounding box, so it takes up less memory.
//

#ifndef NDEBUG
#define STAIR_EDGE(z) (STAIR_check_edge((z)), STAIR_edge[(z) - STAIR_z1])
#else
#define STAIR_EDGE(z) (STAIR_edge[(z) - STAIR_z1])
#endif

void STAIR_check_edge(SLONG z)
{
	SLONG sz;

	ASSERT(WITHIN(z, STAIR_z1, STAIR_z2 - 1));

	sz = z - STAIR_z1;

	ASSERT(WITHIN(sz, 0, STAIR_MAX_SIZE - 1));
}


//
// Random numbers for the STAIR module.
//

ULONG STAIR_rand_seed;

inline void STAIR_srand(ULONG seed)
{
	STAIR_rand_seed = seed;
}

inline ULONG STAIR_grand(void)
{
	return STAIR_rand_seed;
}

inline UWORD STAIR_rand(void)
{
	UWORD ans;

	STAIR_rand_seed *= 328573;
	STAIR_rand_seed += 123456789;

	ans = STAIR_rand_seed >> 7;

	return ans;
}



//
// Adds the stair to the given storey.
//

void STAIR_add_to_storey(SLONG storey, SLONG stair)
{
	SLONG i;

	ASSERT(WITHIN(storey, 0, STAIR_storey_upto - 1));
	ASSERT(WITHIN(stair,  1, STAIR_stair_upto  - 1));

	for (i = 0; i < STAIR_MAX_PER_STOREY; i++)
	{
		if (STAIR_storey[storey].stair[i] == NULL)
		{
			STAIR_storey[storey].stair[i] = stair;

			return;
		}
	}

	//
	// No more room!
	//

	ASSERT(0);
}


void STAIR_init()
{
	//
	// Clear the bounding box.
	//

	STAIR_x1 = 255;
	STAIR_z1 = 255;
	STAIR_x2 = 0;
	STAIR_z2 = 0;

	//
	// Clear the stair and storey array.
	//

	STAIR_stair_upto  = 1;	// 0 is the NULL stair...
	STAIR_storey_upto = 0;

	//
	// Reset the roof height.
	//

	STAIR_roof_height = 0;
}

void STAIR_set_bounding_box(UBYTE x1, UBYTE z1, UBYTE x2, UBYTE z2)
{
	ASSERT(WITHIN(x1, 0, 255));
	ASSERT(WITHIN(z1, 0, 255));
	ASSERT(WITHIN(x2, 0, 255));
	ASSERT(WITHIN(z2, 0, 255));

	STAIR_x1 = x1;
	STAIR_z1 = z1;
	STAIR_x2 = x2;
	STAIR_z2 = z2;

	ASSERT(WITHIN(STAIR_x2 - STAIR_x1, 0, STAIR_MAX_SIZE));
	ASSERT(WITHIN(STAIR_z2 - STAIR_z1, 0, STAIR_MAX_SIZE));
}

void STAIR_storey_new(SLONG handle, UBYTE height)
{
	SLONG i;

	STAIR_Storey *st;

	ASSERT(WITHIN(STAIR_storey_upto, 0, STAIR_MAX_STOREYS - 1));

	st = &STAIR_storey[STAIR_storey_upto];

	//
	// Work out the new roof height.
	//

	if (STAIR_roof_height < height + 1)
	{
		STAIR_roof_height = height + 1;
	}

	//
	// Initialise the new storey.
	//

	memset ((UBYTE*)st, 0, sizeof(STAIR_Storey));

	st->handle = handle;
	st->height = height;
	st->opp_x1 = 0;
	st->opp_z1 = 0;
	st->opp_x2 = 0;
	st->opp_z2 = 0;

	//
	// Initialise the link lists with which we calculate
	// the inside squares of each storey.
	//

	for (i = 0; i < STAIR_MAX_SIZE; i++)
	{
		STAIR_edge[i] = 0;
	}

	//
	// We don't use link zero because that is the NULL link index.
	//

	STAIR_link_upto = 1;

	//
	// Next storey...
	//

	STAIR_storey_upto += 1;
}

void STAIR_storey_wall(UBYTE x1, UBYTE z1, UBYTE x2, UBYTE z2, SLONG opposite)
{
	SLONG x;
	SLONG z;

	SLONG dx;
	SLONG dz;

	SLONG dxdz;
	SLONG pos;
	SLONG square;

	UBYTE  link_t;
	UBYTE  next;
	UBYTE *prev;

	//
	// Make sure this wall is inside the bounding rectangle of
	// the building.
	//

	ASSERT(WITHIN(x1, STAIR_x1, STAIR_x2));
	ASSERT(WITHIN(z1, STAIR_z1, STAIR_z2));

	if (opposite)
	{
		STAIR_Storey *st;

		ASSERT(WITHIN(STAIR_storey_upto - 1, 0, STAIR_MAX_STOREYS - 1));

		st = &STAIR_storey[STAIR_storey_upto - 1];
		
		st->opp_x1 = x1;
		st->opp_z1 = z1;
		st->opp_x2 = x2;
		st->opp_z2 = z2;

		if (x1 > x2) {SWAP(st->opp_x1, st->opp_x2);}
		if (z1 > z2) {SWAP(st->opp_z1, st->opp_z2);}
	}

	if (z1 == z2)
	{
		//
		// Ignore this line because it does not cross any
		// z-lines.
		//

		return;
	}

	if (z1 > z2)
	{
		link_t = STAIR_LINK_T_ENTER;

		//
		// Always go from top to bottom.
		//

		SWAP(x1, x2);
		SWAP(z1, z2);
	}
	else
	{
		link_t = STAIR_LINK_T_LEAVE;
	}

	dx = x2 - x1 << 16;
	dz = z2 - z1 << 16;

	dxdz = DIV64(dx, dz);

	x = x1 << 16;
	z = z1;

	while(z < z2)
	{
		switch(link_t)
		{
			case STAIR_LINK_T_ENTER:
				pos      = x >> 8;	// 8-bit fixed point.
				square   = MAX(x, x + dxdz);
				square  += 0xffff;
				square >>= 16;
				break;
			case STAIR_LINK_T_LEAVE:
				pos      = x >> 8;	// 8-bit fixed point.
				square   = MIN(x, x + dxdz);
				square >>= 16;
				break;

			default:
				ASSERT(0);
				break;
		}

		//
		// Create a new link.
		//

		ASSERT(WITHIN(STAIR_link_upto, 1, STAIR_MAX_LINKS - 1));

		STAIR_link[STAIR_link_upto].square = square;
		STAIR_link[STAIR_link_upto].pos    = pos;
		STAIR_link[STAIR_link_upto].next   = 0;

		//
		// Insert it in the correct place in the linked list.
		//

		prev = &STAIR_EDGE(z);
		next =  STAIR_EDGE(z);

		while(1)
		{
			if (next == NULL)
			{
				//
				// We have reached end of the linked list.
				//

				break;
			}

			ASSERT(WITHIN(next, 1, STAIR_link_upto - 1));

			if (STAIR_link[next].pos >= STAIR_link[STAIR_link_upto].pos)
			{
				if (STAIR_link[next].pos == STAIR_LINK_T_ENTER)
				{
					//
					// Make the ENTER link appear first in the linked list.
					//
				}
				else
				{
					//
					// This is the right place to insert it.
					//

					break;
				}
			}

			//
			// Go onto the next link.
			//

			prev = &STAIR_link[next].next;
			next =  STAIR_link[next].next;
		}

		ASSERT(*prev == next);

		//
		// Insert it.
		//

		STAIR_link[STAIR_link_upto].next = next;
	   *prev                             = STAIR_link_upto;
		STAIR_link_upto					+= 1;

		//
		// Do the next line.
		//

		x += dxdz;
		z += 1;
	}
}

SLONG STAIR_storey_finish()
{
	SLONG i;

	SLONG x;
	SLONG z;

	SLONG x1;
	SLONG x2;

	UBYTE next;
	UBYTE next1;
	UBYTE next2;

	STAIR_Storey *st;

	ASSERT(WITHIN(STAIR_storey_upto - 1, 0, STAIR_MAX_STOREYS - 1));

	st = &STAIR_storey[STAIR_storey_upto - 1];

	//
	// Go through the linked lists and mark each square as
	// being inside or outside.
	//

	for (z = STAIR_z1; z < STAIR_z2; z++)
	{
		next = STAIR_EDGE(z);

		if (next == NULL)
		{
			//
			// This whole z-row is outside.
			//

			continue;
		}

		//
		// These should come in pairs.
		//

		next1 = next;
		next2 = STAIR_link[next].next;

		//
		// The pairs should be start and end.
		//

		if (next1 == NULL ||
			next2 == NULL)
		{
			//
			// An invalid storey.
			//

			return FALSE;
		}

		ASSERT(WITHIN(next1, 1, STAIR_link_upto - 1));
		ASSERT(WITHIN(next2, 1, STAIR_link_upto - 1));

		x1 = STAIR_link[next1].square;
		x2 = STAIR_link[next2].square;

		//
		// We only mark squares that are completely inside.
		//

		for (x = x1; x < x2; x++)
		{
			//
			// Mark these squares as inside.
			//

			STAIR_set_bit(STAIR_storey_upto - 1, x, z);
		}
	}

	return TRUE;
}

//
// Returns whether there is an outside door opening
// onto the given square on the given storey.
// 

SLONG STAIR_is_door(SLONG storey, SLONG x, SLONG z)
{
	return 0;
}


void STAIR_calculate(UWORD seed)
{
	SLONG i;
	SLONG j;
	SLONG k;
	SLONG l;

	SLONG x;
	SLONG z;

	SLONG dx;
	SLONG dz;

	SLONG x1;
	SLONG x2;
	SLONG z1;
	SLONG z2;
	SLONG score;

	SLONG ox;
	SLONG oz;
	SLONG outside;

	SLONG best_x1;
	SLONG best_z1;
	SLONG best_x2;
	SLONG best_z2;
	SLONG best_score;

	STAIR_Storey *st;
	STAIR_Storey *st_n;

	STAIR_Stair *ss;
	STAIR_Stair *ss_new;

	SLONG dox;
	SLONG doz;

	SLONG height;
	SLONG height_n;

	UBYTE square[STAIR_MAX_SIZE][STAIR_MAX_SIZE / 8];
	UBYTE go_up;
	UBYTE go_down;

	//
	// Randomise the order we do the storeys in.
	//

	UBYTE storey_order1[STAIR_MAX_STOREYS];

	STAIR_srand(seed);

	for (i = 0; i < STAIR_MAX_STOREYS; i++)
	{
		storey_order1[i] = i;
	}

	for (i = 0; i < STAIR_MAX_STOREYS; i++)
	{
		j = STAIR_rand() % STAIR_MAX_STOREYS;
		k = STAIR_rand() % STAIR_MAX_STOREYS;

		SWAP(storey_order1[j], storey_order1[k]);
	}

	//
	// Workout where the stairs should be for each storey.
	//

	for (i = 0; i < STAIR_storey_upto; i++)
	{
		st = &STAIR_storey[i];

		//
		// The height of this storey.
		//

		height = st->height;

		for (j = 0; j < STAIR_storey_upto; j++)
		{
			//
			// Look for neighbouring storeys.
			//

			st_n = &STAIR_storey[j];

			//
			// The height of this storey.
			//

			height_n = st_n->height;

			if (abs(height - height_n) == 1)
			{
				//
				// This is a neighbouring storey. AND in this storeys
				// squares.
				//

				memcpy(square, st->square, sizeof(square));

				for (z = 0; z < STAIR_MAX_SIZE;     z++)
				for (x = 0; x < STAIR_MAX_SIZE / 8; x++)
				{
					square[z][x] &= st_n->square[z][x];
				}

				//
				// Is this storey higher or lower?
				//

				go_up   = 0;
				go_down = 0;

				     if (height_n == height + 1) {go_up   = 1;}
				else if (height_n == height - 1) {go_down = 1;}
				else {ASSERT(0);}

				//
				// Is there a staircase on this storey we use?
				//

				for (k = 0; k < STAIR_MAX_PER_STOREY; k++)
				{
					if (st->stair[k] != NULL)
					{
						ASSERT(WITHIN(st->stair[k], 1, STAIR_stair_upto - 1));

						ss = &STAIR_stair[st->stair[k]];

						//
						// There is already a staircase on this storey. It is
						// in an okay place?
						//

						if (STAIR_get_bit_from_square(square, ss->x1, ss->z1) &&
							STAIR_get_bit_from_square(square, ss->x2, ss->z2))
						{
							//
							// We can just use this staircase.
							//

							if (go_up)
							{
								if (ss->flag & STAIR_FLAG_UP)
								{
									//
									// There is already a staircase up to this floor!
									//

									goto placed_stairs;
								}
								else
								{
									//
									// Make this staircase go upto the next floor and
									// create a down staircase on the next floor.
									//

									ss->flag |= STAIR_FLAG_UP;
									ss->up    = j;

									//
									// New stair...
									//

									ss_new = &STAIR_stair[STAIR_stair_upto++];

									ss_new->flag = STAIR_FLAG_DOWN;
									ss_new->down = i;
									ss_new->x1   = ss->x1;
									ss_new->z1   = ss->z1;
									ss_new->x2   = ss->x2;
									ss_new->z2   = ss->z2;

									STAIR_add_to_storey(j, STAIR_stair_upto - 1);

									goto placed_stairs;
								}
							}

							if (go_down)
							{
								if (ss->flag & STAIR_FLAG_DOWN)
								{
									//
									// There is already a staircase down to this floor!
									//

									goto placed_stairs;
								}
								else
								{
									//
									// Make this staircase go down to the next floor and
									// create a down staircase on the next floor.
									//

									ss->flag |= STAIR_FLAG_DOWN;
									ss->down  = j;

									//
									// New stair...
									//

									ss_new = &STAIR_stair[STAIR_stair_upto++];

									ss_new->flag = STAIR_FLAG_UP;
									ss_new->up   = i;
									ss_new->x1   = ss->x1;
									ss_new->z1   = ss->z1;
									ss_new->x2   = ss->x2;
									ss_new->z2   = ss->z2;

									STAIR_add_to_storey(j, STAIR_stair_upto - 1);

									goto placed_stairs;
								}
							}
						}
					}
				}

				//
				// Does the neighbour have a suitable staircase already?
				//

				for (k = 0; k < STAIR_MAX_PER_STOREY; k++)
				{
					if (st_n->stair[k] != NULL)
					{
						ASSERT(WITHIN(st_n->stair[k], 1, STAIR_stair_upto - 1));

						ss = &STAIR_stair[st_n->stair[k]];

						//
						// There is a staircase on this storey.  Is is in an
						// okay place?
						//

						if (STAIR_get_bit_from_square(square, ss->x1, ss->z1) &&
							STAIR_get_bit_from_square(square, ss->x2, ss->z2))
						{
							//
							// We could just use this staircase.
							//

							if (go_up)
							{
								if (ss->flag & STAIR_FLAG_DOWN)
								{
									//
									// There is staircase going down from the floor above, but
									// we didn't find a staircase going up!
									// 

									ASSERT(0);
								}

								//
								// Use this staircase.
								//

								ss->flag |= STAIR_FLAG_DOWN;
								ss->down  = i;

								//
								// Create a new staircase on this floor.
								//

								ss_new = &STAIR_stair[STAIR_stair_upto++];

								ss_new->flag = STAIR_FLAG_UP;
								ss_new->up   = j;
								ss_new->x1   = ss->x1;
								ss_new->z1   = ss->z1;
								ss_new->x2   = ss->x2;
								ss_new->z2   = ss->z2;

								STAIR_add_to_storey(i, STAIR_stair_upto - 1);

								goto placed_stairs;
							}

							if (go_down)
							{
								if (ss->flag & STAIR_FLAG_UP)
								{
									//
									// There is a staircase going up to this floor, but
									// we didn't find a staircase going down to it!
									//

									ASSERT(0);
								}

								//
								// Use this staircase.
								//

								ss->flag |= STAIR_FLAG_UP;
								ss->up    = i;

								//
								// Create a new staircase on this floor.
								//

								ss_new = &STAIR_stair[STAIR_stair_upto++];

								ss_new->flag = STAIR_FLAG_DOWN;
								ss_new->down = j;
								ss_new->x1   = ss->x1;
								ss_new->z1   = ss->z1;
								ss_new->x2   = ss->x2;
								ss_new->z2   = ss->z2;

								STAIR_add_to_storey(i, STAIR_stair_upto - 1);

								goto placed_stairs;
							}
						}
					}
				}

				//
				// Look for the best place for a new staircase in the bounding
				// box of the building.
				//

				best_score = -INFINITY;

				for (x = STAIR_x1; x < STAIR_x2; x++)
				for (z = STAIR_z1; z < STAIR_z2; z++)
				{
					x1 = x;
					z1 = z;

					for (k = 0; k < 4; k++)
					{
						x2 = x1;
						z2 = z1;

						switch(k)
						{
							case 0: x2 += 1; break;
							case 1: x2 -= 1; break;
							case 2: z2 += 1; break;
							case 3: z2 -= 1; break;
							default:
								ASSERT(0);
								break;
						}

						if (!WITHIN(x2, STAIR_x1, STAIR_x2 - 1) ||
							!WITHIN(z2, STAIR_z1, STAIR_z2 - 1))
						{
							//
							// Outside the building!
							//

							continue;
						}

						//
						// Make sure these two squares exist on both storeys.
						//

						if (STAIR_get_bit_from_square(square, x1, z1) &&
							STAIR_get_bit_from_square(square, x2, z2))
						{
							//
							// Score this choice of staircase.
							//

							score   = STAIR_rand() & 0xffff;
							outside = 0;

							dx = x2 - x1;
							dz = z2 - z1;

							//
							// If both squares of the staircase are against an outside wall
							// then that is good. If only one is than that is bad, but not
							// disasterous. If the staircase is in the way of an outside door
							// than that is disasterous.
							//

							for (l = 0; l < 2; l++)
							{
								switch(l)
								{	
									case 0: ox = x1 + (+dz); oz = z1 + (-dx); break;
									case 1: ox = x2 + (+dz); oz = z2 + (-dx); break;
									default:
										ASSERT(0);
										break;
								}

								if (!WITHIN(ox, STAIR_x1, STAIR_x2 - 1) ||
									!WITHIN(oz, STAIR_z1, STAIR_z2 - 1) ||
									!STAIR_get_bit(i, ox, oz))
								{
									//
									// (ox,oz) is outside, so this square of the staircase lies
									// outside of the storey.
									//

									outside += 1;

									if (STAIR_is_door(i, ox, oz))
									{
										//
										// Arghh! A staircase here would block a door from the
										// outside.
										//

										score = -INFINITY;
									}
								}
							}

							//
							// Favour stairs on outside walls.
							//

							switch(outside)
							{
								case 0: score  = 0x0;	  break;
								case 1: score -= 0x10000; break;
								case 2: score += 0x10000; break;
								default:
									ASSERT(0);
									break;
							}

							//
							// We like stairs in corners.
							//

							if (x1 == STAIR_x1) {score += 0x5000;}
							if (x1 == STAIR_x2) {score += 0x5000;}
							if (x2 == STAIR_x1) {score += 0x5000;}
							if (x2 == STAIR_x2) {score += 0x5000;}

							if (z1 == STAIR_z1) {score += 0x5000;}
							if (z1 == STAIR_z2) {score += 0x5000;}
							if (z2 == STAIR_z1) {score += 0x5000;}
							if (z2 == STAIR_z2) {score += 0x5000;}

							//
							// We like stairs opposite the 'opposite' wall.
							//

							if (z1 == z2 && st->opp_z1 == st->opp_z2)
							{
								doz = st->opp_z1 - z1;

								if (abs(doz) > 2)
								{
									if (WITHIN(x1, st->opp_x1, st->opp_x2)) {score += 0xbabe;}
									if (WITHIN(x2, st->opp_x1, st->opp_x2)) {score += 0xbabe;}
									
								}
							}

							if (x1 == x2 && st->opp_x1 == st->opp_x2)
							{
								dox = st->opp_x1 - x1;

								if (abs(dox) > 2)
								{
									if (WITHIN(z1, st->opp_z1, st->opp_z2)) {score += 0xbabe;}
									if (WITHIN(z2, st->opp_z1, st->opp_z2)) {score += 0xbabe;}
									
								}
							}

							if (score > best_score)
							{
								best_x1    = x1;
								best_z1    = z1;
								best_x2    = x2;
								best_z2    = z2;
								best_score = score;
							}
						}
					}
				}

				if (best_score >= 0)
				{
					ASSERT(WITHIN(STAIR_stair_upto, 1, STAIR_MAX_STAIRS - 2));

					//
					// Put a staircase here and on the other floor.
					//

					ss = &STAIR_stair[STAIR_stair_upto++];

					ss->flag = 0;
					ss->x1   = best_x1;
					ss->z1   = best_z1;
					ss->x2   = best_x2;
					ss->z2   = best_z2;

					if (go_up)   {ss->flag |= STAIR_FLAG_UP;   ss->up   = j;}
					if (go_down) {ss->flag |= STAIR_FLAG_DOWN; ss->down = j;}

					STAIR_add_to_storey(i, STAIR_stair_upto - 1);

					//
					// The other floor.
					//

					ss = &STAIR_stair[STAIR_stair_upto++];

					ss->flag = 0;
					ss->x1   = best_x1;
					ss->z1   = best_z1;
					ss->x2   = best_x2;
					ss->z2   = best_z2;

					//
					// These are swapped around for the other floor.
					//

					if (go_up)   {ss->flag |= STAIR_FLAG_DOWN; ss->down = i;}
					if (go_down) {ss->flag |= STAIR_FLAG_UP;   ss->up   = j;}

					STAIR_add_to_storey(j, STAIR_stair_upto - 1);
				}
				else
				{
					//
					// We need some stairs, but there is nowhere to put
					// them!
					//

					TRACE("Oh no! Can't place stairs.\n");
				}

              placed_stairs:;
			}
			else
			{
				//
				// Storeys i and j are more than one floor apart.
				//
			}
		}
	}
}


ID_Stair STAIR_id_stair[STAIR_MAX_PER_STOREY];

SLONG STAIR_get(SLONG handle, ID_Stair **stair, SLONG *num_stairs)
{
	SLONG i;
	SLONG storey;

	STAIR_Storey *st;
	STAIR_Stair  *ss;
	ID_Stair     *is;

	for (i = 0; i < STAIR_storey_upto; i++)
	{
		st = &STAIR_storey[i];

		if (st->handle == handle)
		{
			//
			// Found the storey.
			//

			goto found_storey_handle;
		}
		
	}

	//
	// Could not find a storey with the given handle.
	//

	return FALSE;

  found_storey_handle:

   *num_stairs = 0;	

	for (i = 0; i < STAIR_MAX_PER_STOREY; i++)
	{
		if (st->stair[i] != NULL)
		{
			ASSERT(WITHIN(*num_stairs,  0, STAIR_MAX_PER_STOREY - 1));
			ASSERT(WITHIN(st->stair[i], 1, STAIR_stair_upto - 1));

			ss = &STAIR_stair   [st->stair[i]];
			is = &STAIR_id_stair[*num_stairs];

			//
			// Add this stair to the array of ID_stairs...
			//

			is->x1 = ss->x1;
			is->z1 = ss->z1;
			is->x2 = ss->x2;
			is->z2 = ss->z2;

			if (ss->flag == STAIR_FLAG_UP)
			{
				ASSERT(WITHIN(ss->up, 0, STAIR_storey_upto - 1));

				is->type      = ID_STAIR_TYPE_BOTTOM;
				is->handle_up = STAIR_storey[ss->up].handle;
			}
			else
			if (ss->flag == STAIR_FLAG_DOWN)
			{
				ASSERT(WITHIN(ss->down, 0, STAIR_storey_upto - 1));

				is->type        = ID_STAIR_TYPE_TOP;
				is->handle_down = STAIR_storey[ss->down].handle;
			}
			else
			{
				ASSERT(ss->flag == (STAIR_FLAG_UP | STAIR_FLAG_DOWN));

				ASSERT(WITHIN(ss->up,   0, STAIR_storey_upto - 1));
				ASSERT(WITHIN(ss->down, 0, STAIR_storey_upto - 1));

				is->type = ID_STAIR_TYPE_MIDDLE;

				is->handle_up   = STAIR_storey[ss->up  ].handle;
				is->handle_down = STAIR_storey[ss->down].handle;
			}

			//
			// Do not define the id...
			//

			is->id = 0;

		   *num_stairs += 1;
		}
	}

	//
	// Return the array...
	//

   *stair = STAIR_id_stair;

    return TRUE;
}