/*
 * Author: Markus Stenberg <fingon@iki.fi>
 *
 *  Copyright (c) 1996 Markus Stenberg
 *  Copyright (c) 1998-2002 Thomas Wouters
 *  Copyright (c) 2000-2002 Cord Awtry
 *  Copyright (c) 1999-2005 Kevin Stevens
 *       All rights reserved
 */

#include "config.h"

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <sys/file.h>

#include "mech.h"
#include "create.h"
#include "mech.events.h"
#include "map.los.h"
#include "p.mech.utils.h"
#include "p.mech.los.h"
#include "p.eject.h"
#include "p.mech.restrict.h"
#include "p.mech.maps.h"
#include "p.mech.notify.h"
#include "p.ds.bay.h"
#include "p.bsuit.h"
#include "p.mech.utils.h"
#include "autopilot.h"

void mech_findcenter(dbref player, void *data, char *buffer)
{
	MECH *mech = (MECH *) data;
	float fx, fy;
	int x, y;

	cch(MECH_USUAL);
	x = MechX(mech);
	y = MechY(mech);
	MapCoordToRealCoord(x, y, &fx, &fy);
	notify_printf(player, "Current hex: (%d,%d,%d)\tRange to center: %.2f\t"
				  "Bearing to center: %d", x, y, MechZ(mech),
				  FindHexRange(fx, fy, MechFX(mech), MechFY(mech)),
				  FindBearing(MechFX(mech), MechFY(mech), fx, fy));
}

static int parse_tacargs(dbref player, MECH * mech, char **args, int argc,
						 int maxrange, short *x, short *y)
{
	int bearing;
	float range, fx, fy;
	MECH *tempMech;
	MAP *map;

	switch (argc) {
	case 2:
		bearing = atoi(args[0]);
		range = atof(args[1]);
		DOCHECK0(!MechIsObservator(mech) &&
				 abs((int) range) > maxrange,
				 "Those coordinates are out of sensor range!");
		FindXY(MechFX(mech), MechFY(mech), bearing, range, &fx, &fy);
		RealCoordToMapCoord(x, y, fx, fy);
		return 1;
	case 1:
		map = getMap(mech->mapindex);
		tempMech = getMech(FindMechOnMap(map, args[0]));
		DOCHECK0(!tempMech, "No such target.");
		range = FlMechRange(mech_map, mech, tempMech);
		DOCHECK0(!InLineOfSight(mech, tempMech, MechX(tempMech),
								MechY(tempMech), range), "No such target.");
		DOCHECK0(abs((int) range) > maxrange,
				 "Target is out of scanner range.");
		*x = MechX(tempMech);
		*y = MechY(tempMech);
		return 1;
	case 0:
		*x = MechX(mech);
		*y = MechY(mech);
		return 1;
	default:
		notify(player, "Invalid number of parameters!");
		return 0;
	}
}

const char *GetTerrainName_base(int t)
{
	switch (t) {
	case GRASSLAND:
	case '_':
		return "Grassland";
	case HEAVY_FOREST:
		return "Heavy Forest";
	case LIGHT_FOREST:
		return "Light Forest";
	case ICE:
		return "Ice";
	case BRIDGE:
		return "Bridge";
	case HIGHWATER:
	case WATER:
		return "Water";
	case ROUGH:
		return "Rough";
	case MOUNTAINS:
		return "Mountains";
	case ROAD:
		return "Road";
	case BUILDING:
		return "Building";
	case FIRE:
		return "Fire";
	case SMOKE:
		return "Smoke";
	case WALL:
		return "Wall";
	}
	return "Unknown";
}

const char *GetTerrainName(MAP * map, int x, int y)
{
	return GetTerrainName_base(GetTerrain(map, x, y));
}

/* Player-customizable colors */

enum { SWATER_IDX, DWATER_IDX, BUILDING_IDX, ROAD_IDX, ROUGH_IDX,
		MOUNTAIN_IDX,
	FIRE_IDX, ICE_IDX, WALL_IDX, SNOW_IDX, SMOKE_IDX, LWOOD_IDX, HWOOD_IDX,
	UNKNOWN_IDX, CLIFF_IDX, SELF_IDX, FRIEND_IDX, ENEMY_IDX, DS_IDX,
	GOODLZ_IDX, BADLZ_IDX, NUM_COLOR_IDX
};

/* Default colour string is "BbWnYyRWWWXGgbRHYRn" */
/* internal rep has H instead of h and \0 instead of n */

#define DEFAULT_COLOR_STRING "BbWXYyRWWWXGgbRhYRnGR"
#define DEFAULT_COLOR_SCHEME "BbWXYyRWWWXGgbRHYR\0GR"

static char custom_color_str[NUM_COLOR_IDX + 1] = DEFAULT_COLOR_SCHEME;

static void set_colorscheme(dbref player)
{
	char *str = silly_atr_get(player, A_MAPCOLOR);
	int i;

	if(*str && strlen(str) <= NUM_COLOR_IDX) {
		strncpy(custom_color_str, DEFAULT_COLOR_STRING, NUM_COLOR_IDX);
		strncpy(custom_color_str, str, strlen(str));
		for(i = 0; i < NUM_COLOR_IDX; i++) {
			switch (custom_color_str[i]) {
			case 'f':
			case 'F':
			case 'I':
			case 'i':
			case 'H':
			case 'x':
			case 'X':
			case 'r':
			case 'R':
			case 'g':
			case 'G':
			case 'y':
			case 'Y':
			case 'b':
			case 'B':
			case 'm':
			case 'M':
			case 'c':
			case 'C':
			case 'w':
			case 'W':
				break;
			case 'h':
				custom_color_str[i] = 'H';
				break;
			case 'n':
				custom_color_str[i] = '\0';
				break;
			default:
				notify_printf(player, "Invalid character '%c' in MAPCOLOR "
							  "attribute!", custom_color_str[i]);
				notify(player, "Using default: " DEFAULT_COLOR_STRING);
				memcpy(custom_color_str, DEFAULT_COLOR_SCHEME, NUM_COLOR_IDX);
				return;
			}
		}
		return;
	} else if(*str) {
		notify(player, "Invalid MAPCOLOR attribute!");
		notify(player, "Using default: " DEFAULT_COLOR_STRING);
	}
	memcpy(custom_color_str, DEFAULT_COLOR_SCHEME, NUM_COLOR_IDX);
}

void mech_navigate(dbref player, void *data, char *buffer)
{
	MECH *mech = (MECH *) data;
	char mybuff[NAVIGATE_LINES][MBUF_SIZE];
	MAP *mech_map;
	char **maptext, *args[3];
	int i, dolos, argc;
	short x, y;

	cch(MECH_USUAL);

	mech_map = getMap(mech->mapindex);

	dolos = MapIsDark(mech_map) || (MechType(mech) == CLASS_MW &&
									mudconf.btech_mw_losmap);

	DOCHECK(mech_map->map_width <= 0 || mech_map->map_height <= 0,
			"Nothing to see on this map, move along.");

	argc = mech_parseattributes(buffer, args, 3);
	if(!parse_tacargs(player, mech, args, argc, MechTacRange(mech), &x, &y))
		return;

	set_colorscheme(player);
	maptext = MakeMapText(player, mech, mech_map, x, y, 5, 5, 4, dolos);

	sprintf(mybuff[0],
			"              0                                          %.150s",
			maptext[0]);
	sprintf(mybuff[1],
			"         ___________                                     %.150s",
			maptext[1]);
	sprintf(mybuff[2],
			"        /           \\          Location:%4d,%4d, %3d   %.150s",
			MechX(mech), MechY(mech), MechZ(mech), maptext[2]);
	sprintf(mybuff[3],
			"  300  /             \\  60     Terrain: %14s   %.150s",
			GetTerrainName(mech_map, MechX(mech), MechY(mech)), maptext[3]);
	sprintf(mybuff[4],
			"      /               \\                                  %.150s",
			maptext[4]);
	sprintf(mybuff[5],
			"     /                 \\                                 %.150s",
			maptext[5]);
	sprintf(mybuff[6],
			"270 (                   )  90  Speed:           %6.1f   %.150s",
			MechSpeed(mech), maptext[6]);
	sprintf(mybuff[7],
			"     \\                 /       Vertical Speed:  %6.1f   %.150s",
			MechVerticalSpeed(mech), maptext[7]);
	sprintf(mybuff[8],
			"      \\               /        Heading:           %4d   %.150s",
			MechFacing(mech), maptext[8]);
	sprintf(mybuff[9],
			"  240  \\             /  120                              %.150s",
			maptext[9]);
	sprintf(mybuff[10],
			"        \\___________/                                    %.150s",
			maptext[10]);
	sprintf(mybuff[11], "                      ");
	sprintf(mybuff[12], "             180");

	navigate_sketch_mechs(mech, mech_map, x, y, mybuff);
	for(i = 0; i < NAVIGATE_LINES; i++)
		notify(player, mybuff[i]);
}

/* INDENT OFF */

/* 
   0
   ___________                                     /``\][/""\][/""\
   /           \          HEX Location: 254, 122    \`1/``\""/``\""/
   300  /             \  60     Terrain: Light Forest     /``\``/""\`3/""\
   /               \        Elevation:  0             \`2/``\"1/``\""/
   /                 \                                 /""\``|**\`3/""\
   270 (                   )  90  Speed: 0.0                \"4/``\"4/``\""/
   \                 /       Vertical Speed: 0.0       /""\`3/""\`3/""\
   \               /        Heading: 0                \"4/``\"4/``\""/
   240  \             /  120                              /""\`3/""\`3/""\
   \____*______/                                    \"4/][\"4/][\"4/
   180
   */

/* INDENT ON */

char GetLRSMechChar(MECH * mech, MECH * other)
{
	char c = 'u';

	if(mech == other)
		return '*';
	if(IsDS(other))
		c = 'd';
	switch (MechMove(other)) {
	case MOVE_FLY:
		c = 'a';
	case MOVE_BIPED:
		c = 'b';
		break;
	case MOVE_QUAD:
		c = 'q';
		break;
	case MOVE_TRACK:
		c = 't';
		break;
	case MOVE_WHEEL:
		c = 'w';
		break;
	case MOVE_HOVER:
		c = 'h';
		break;
	case MOVE_VTOL:
		c = 'v';
		break;
	case MOVE_HULL:
		c = 'n';
		break;
	case MOVE_SUB:
		c = 's';
		break;
	case MOVE_FOIL:
		c = 'f';
		break;
	}
	if(!MechSeemsFriend(mech, other))
		c = toupper(c);
	return c;
}

static inline char TerrainColorChar(char terrain, int elev)
{
	switch (terrain) {
	case HIGHWATER:
		return custom_color_str[DWATER_IDX];
	case WATER:
		if(elev < 2 || elev == '0' || elev == '1' || elev == '~')
			return custom_color_str[SWATER_IDX];
		return custom_color_str[DWATER_IDX];
	case BUILDING:
		return custom_color_str[BUILDING_IDX];
	case ROAD:
		return custom_color_str[ROAD_IDX];
	case ROUGH:
		return custom_color_str[ROUGH_IDX];
	case MOUNTAINS:
		return custom_color_str[MOUNTAIN_IDX];
	case FIRE:
		return custom_color_str[FIRE_IDX];
	case ICE:
		return custom_color_str[ICE_IDX];
	case WALL:
		return custom_color_str[WALL_IDX];
	case SNOW:
		return custom_color_str[SNOW_IDX];
	case SMOKE:
		return custom_color_str[SMOKE_IDX];
	case LIGHT_FOREST:
		return custom_color_str[LWOOD_IDX];
	case HEAVY_FOREST:
		return custom_color_str[HWOOD_IDX];
	case UNKNOWN_TERRAIN:
		return custom_color_str[UNKNOWN_IDX];
	}
	return '\0';
}

static char *add_color(char newc, char *prevc, char c)
{
	static char buf[10];		/* won't be filled with more than 7 characters */
	buf[0] = '\0';

	if(newc == *prevc) {
		buf[0] = c;
		buf[1] = '\0';
		return buf;
	}

	if(!newc || ((isupper(*prevc)) && !isupper(newc)) ||
	   (newc == 'H' && *prevc))
		strcpy(buf, "%cn");
	else if(isupper(newc) && !isupper(*prevc))
		strcpy(buf, "%ch");

	if(!newc)
		sprintf(buf + strlen(buf), "%c", c);
	else
		sprintf(buf + strlen(buf), "%%c%c%c", tolower(newc), c);
	*prevc = newc;
	return buf;
}

static char *GetLRSMech(MECH * mech, MECH * other, int docolor, char *prevc)
{
	static char buf[2];			/* Won't be filled with more than 1 character */
	char c = GetLRSMechChar(mech, other);
	char newc;

	if(!docolor) {
		sprintf(buf, "%c", c);
		return buf;
	}

	if(mech == other)
		newc = custom_color_str[SELF_IDX];
	else if(!MechSeemsFriend(mech, other))
		newc = custom_color_str[ENEMY_IDX];
	else
		newc = custom_color_str[FRIEND_IDX];

	return add_color(newc, prevc, c);

}

static char *LRSTerrain(MAP * map, int x, int y, int docolor, char *prevc)
{
	static char buf[2];			/* Won't be filled with more than 1 character */

	char c = GetTerrain(map, x, y);
	char newc;

	if(!c || !docolor || c == ' ') {
		buf[0] = c;
		buf[1] = '\0';
		return buf;
	} else
		newc = TerrainColorChar(c, GetElev(map, x, y));

	return add_color(newc, prevc, c);
}

static char *LRSElevation(MAP * map, int x, int y, int docolor, char *prevc)
{
	static char buf[2];			/* Won't be filled with more than 1 character */

	int e = GetElev(map, x, y);
	char c = (e || docolor) ? '0' + e : ' ';
	char newc;

	if(!docolor) {
		buf[0] = c;
		buf[1] = '\0';
		return buf;
	} else
		newc = TerrainColorChar(GetTerrain(map, x, y), e);

	return add_color(newc, prevc, c);
}

#define LRS_TERRAINMODE		1
#define LRS_ELEVMODE		2
#define LRS_MECHMODE		4
#define LRS_LOSMODE		8
#define LRS_COLORMODE		16
#define LRS_ELEVCOLORMODE	32

static char *get_lrshexstr(MECH * mech, MAP * map, int x, int y,
						   char *prevc, int mode, MECH ** mechs, int lm,
						   hexlosmap_info * losmap)
{
	int losflag = MAPLOSHEX_SEE | MAPLOSHEX_SEEN;

	if(mode & LRS_MECHMODE) {
		while (mechs[lm] && MechY(mechs[lm]) < y)
			lm++;
		while (mechs[lm] && MechY(mechs[lm]) == y && MechX(mechs[lm]) < x)
			lm++;
		if(mechs[lm] && MechY(mechs[lm]) == y && MechX(mechs[lm]) == x)
			return GetLRSMech(mech, mechs[lm], mode & LRS_COLORMODE, prevc);
	}

	if(losmap)
		losflag = LOSMap_GetFlag(losmap, x, y);

	/* If the losmap doesn't contain this hex, we return X in bold red
	 * in both terrain and elevation mode.
	 */
	if(!(losflag & MAPLOSHEX_SEEN))
		return add_color('R', prevc, 'X');

	if(((mode & LRS_TERRAINMODE) && !(losflag & MAPLOSHEX_SEETERRAIN)) ||
	   ((mode & LRS_ELEVMODE) && !(losflag & MAPLOSHEX_SEEELEV)))
		return add_color(TerrainColorChar(UNKNOWN_TERRAIN, 0), prevc, '?');

	if(mode & LRS_ELEVMODE)
		return LRSElevation(map, x, y, mode & LRS_ELEVCOLORMODE, prevc);
	if(mode & LRS_TERRAINMODE)
		return LRSTerrain(map, x, y, mode & LRS_COLORMODE, prevc);

	SendError(tprintf("Unknown LRS mode, mech #%d mode 0x%x.",
					  mech->mynum, mode));
	return add_color('R', prevc, 'Y');

}

static void show_lrs_map(dbref player, MECH * mech, MAP * map, int x,
						 int y, int displayHeight, int mode)
{
	int loop, b_width, e_width, b_height, e_height, i;
	MECH *oMech;

	/* topbuff and botbuff must be capable of holding enough
	 * characters to colorize all hexes in the most inefficient
	 * way. This means 15 characters per 2 hexes, or 8 per
	 * hex. topbuff and botbuff both hold half the hexes on the row,
	 * so that ends up 4 * LRS_DISPLAY_WIDTH (plus some padding thrown
	 * in for good measure.)
	 *
	 * midbuff is only used for the lables, and only needs a few
	 * characters more than the display width.
	 */
	char topbuff[4 * LRS_DISPLAY_WIDTH + 30] = "    ";
	char botbuff[4 * LRS_DISPLAY_WIDTH + 30] = "    ";
	char midbuff[8 + LRS_DISPLAY_WIDTH] = "    ";
	char trash1[5];				/* temp var to hold the max-three-digit number of map Y */
	short oddcol = 0;
	MECH *mechs[MAX_MECHS_PER_MAP];
	int last_mech = 0;
	char prevct = 0, prevcb = 0;
	hexlosmap_info *losmap = NULL;

	/* x and y hold the viewing center of the map */
	b_width = x - LRS_DISPLAY_WIDTH / 2;
	b_width = MAX(b_width, 0);
	e_width = b_width + LRS_DISPLAY_WIDTH;
	if(e_width >= map->map_width) {
		e_width = map->map_width - 1;
		b_width = e_width - LRS_DISPLAY_WIDTH;
		b_width = MAX(b_width, 0);
	}

	if(b_width % 2)
		oddcol = 1;

	b_height = y - displayHeight / 2;
	b_height = MAX(b_height, 0);
	e_height = b_height + displayHeight;
	if(e_height > map->map_height) {
		e_height = map->map_height;
		b_height = e_height - displayHeight;
		b_height = MAX(b_height, 0);
	}

	/* Display the top labels */
	for(i = b_width; i <= e_width; i++) {
		sprintf(trash1, "%3d", i);
		sprintf(topbuff + strlen(topbuff), "%c", trash1[0]);
		sprintf(midbuff + strlen(midbuff), "%c", trash1[1]);
		sprintf(botbuff + strlen(botbuff), "%c", trash1[2]);
	}
	notify(player, topbuff);
	notify(player, midbuff);
	notify(player, botbuff);

	if(mode & LRS_MECHMODE) {
		for(i = 0; i < map->first_free; i++) {
			if((oMech = getMech(map->mechsOnMap[i]))) {
				if((mech == oMech) ||
				   (MechY(oMech) >= b_height && MechY(oMech) <= e_height &&
					MechX(oMech) >= b_width && MechX(oMech) <= e_width &&
					InLineOfSight(mech, oMech, MechX(oMech), MechY(oMech),
								  FlMechRange(map, mech, oMech))))
					mechs[last_mech++] = oMech;
			}
		}
		for(i = 0; i < (last_mech - 1); i++)	/* Bubble-sort the list 
												 *  to y/x order */
			for(loop = (i + 1); loop < last_mech; loop++) {
				if(MechY(mechs[i]) > MechY(mechs[loop])) {
					oMech = mechs[i];
					mechs[i] = mechs[loop];
					mechs[loop] = oMech;
				} else if(MechY(mechs[i]) == MechY(mechs[loop]) &&
						  MechX(mechs[i]) > MechX(mechs[loop])) {
					oMech = mechs[i];
					mechs[i] = mechs[loop];
					mechs[loop] = oMech;
				}
			}
		mechs[last_mech] = NULL;
		last_mech = 0;
	}

	if(mode & LRS_LOSMODE)
		losmap = CalculateLOSMap(map, mech, b_width, b_height,
								 e_width - b_width, e_height - b_height);

	for(loop = b_height; loop < e_height; loop++) {
		sprintf(topbuff, "%3d ", loop);
		strcpy(botbuff, "    ");
		if(mode & LRS_MECHMODE)
			while (mechs[last_mech] && MechY(mechs[last_mech]) < loop)
				last_mech++;

		for(i = b_width; i < e_width; i += 2) {
			sprintf(topbuff + strlen(topbuff), oddcol ? "%s " : " %s",
					get_lrshexstr(mech, map, i + !oddcol, loop, &prevct,
								  mode, mechs, last_mech, losmap));

			sprintf(botbuff + strlen(botbuff), oddcol ? " %s" : "%s ",
					get_lrshexstr(mech, map, i + oddcol, loop, &prevcb,
								  mode, mechs, last_mech, losmap));
		}
		if(i == e_width && !oddcol) {
			sprintf(botbuff + strlen(botbuff), "%s",
					get_lrshexstr(mech, map, i, loop, &prevcb, mode,
								  mechs, last_mech, losmap));
		} else if(i == e_width) {
			sprintf(topbuff + strlen(topbuff), "%s",
					get_lrshexstr(mech, map, i, loop, &prevct, mode,
								  mechs, last_mech, losmap));
			strcat(botbuff, " ");
		}

		if(mode & (LRS_COLORMODE | LRS_ELEVCOLORMODE)) {
			if(prevct) {
				strcat(topbuff, "%cn");
				prevct = 0;
			}
			if(prevcb) {
				strcat(botbuff, "%cn");
				prevcb = 0;
			}
		}
		sprintf(botbuff + strlen(botbuff), " %-3d", loop);
		notify(player, topbuff);
		notify(player, botbuff);
	}
}

void mech_lrsmap(dbref player, void *data, char *buffer)
{
	MECH *mech = (MECH *) data;
	MAP *map;
	int argc, mode = 0;
	short x, y;
	char *args[5], *str;
	int displayHeight = LRS_DISPLAY_HEIGHT;

	cch(MECH_USUAL);

	if(Ansimap(player))
		mode |= LRS_COLORMODE;

	map = getMap(mech->mapindex);

	argc = mech_parseattributes(buffer, args, 4);
	DOCHECK(!MechLRSRange(mech), "Your system seems to be inoperational.");
	if(!parse_tacargs(player, mech, &args[1], argc - 1,
					  MechLRSRange(mech), &x, &y))
		return;
	switch (args[0][0]) {
	case 'M':
	case 'm':
		mode |= LRS_MECHMODE | LRS_TERRAINMODE;
		break;
	case 'E':
	case 'e':
		mode |= LRS_ELEVMODE;
		break;
	case 'C':
	case 'c':
		mode |= LRS_ELEVMODE | LRS_ELEVCOLORMODE;
		break;
	case 'T':
	case 't':
		mode |= LRS_TERRAINMODE;
		break;
	case 'L':
	case 'l':
		mode |= LRS_LOSMODE | LRS_TERRAINMODE;
		break;
	case 'H':
	case 'h':
		mode |= LRS_LOSMODE | LRS_ELEVMODE;
		break;
	case 'S':
	case 's':
		mode |= LRS_LOSMODE | LRS_MECHMODE | LRS_TERRAINMODE;
		break;
	default:
		notify_printf(player, "Unknown LRS sensor type '%s'!", args[0]);
		return;
	}

	if(MapIsDark(map) || (MechType(mech) == CLASS_MW &&
						  mudconf.btech_mw_losmap))
		mode |= LRS_LOSMODE;

	str = silly_atr_get(player, A_LRSHEIGHT);
	if(*str) {
		displayHeight = atoi(str);
		if(displayHeight < 10 || displayHeight > 40) {
			notify(player,
				   "Illegal LRSHeight attribute.  Must be between 10 and 40");
			displayHeight = LRS_DISPLAY_HEIGHT;
		}
	}

	displayHeight = MIN(displayHeight, 2 * MechLRSRange(mech));
	displayHeight = MIN(displayHeight, map->map_height);

	if(!(displayHeight % 2))
		displayHeight++;

	set_colorscheme(player);

	show_lrs_map(player, mech, map, x, y, displayHeight, mode);
}

static inline int is_oddcol(int col)
{
	/*
	 * The only real trick here is to handle negative
	 * numbers correctly.
	 */
	return (unsigned) col & 1;
}

static inline int tac_dispcols(int hexcols)
{
	return hexcols * 3 + 1;
}

static inline int tac_hex_offset(int x, int y, int dispcols, int oddcol1)
{
	int oddcolx = is_oddcol(x + oddcol1);

	return (y * 2 + 1 - oddcolx) * dispcols + x * 3 + 1;
}

static inline void sketch_tac_row(char *pos, int left_offset,
								  char const *src, int len)
{
	memset(pos, ' ', left_offset);
	memcpy(pos + left_offset, src, len);
	pos[left_offset + len] = '\0';
}

static void sketch_tac_map(char *buf, MAP * map, MECH * mech, int sx,
						   int sy, int wx, int wy, int dispcols,
						   int top_offset, int left_offset, int docolour,
						   int dohexlos)
{
#if 0
	static char const hexrow[2][76] = {
		"\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/",
		"/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\"
	};
#else
	static char const hexrow[2][310] = {
		"\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/]["
			"\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/]["
			"\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/]["
			"\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/]["
			"\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/",
		"/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\]["
			"/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\]["
			"/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\]["
			"/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\]["
			"/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\][/][\\"
	};
#endif
	int x, y;
	int oddcol1 = is_oddcol(sx);	/* One iff first hex col is odd */
	char *pos;
	int mapcols = tac_dispcols(wx);
	hexlosmap_info *losmap = NULL;

	/*
	 * First create a blank hex map.
	 */
	pos = buf;
	for(y = 0; y < top_offset; y++) {
		memset(pos, ' ', dispcols - 1);
		pos[dispcols - 1] = '\0';
		pos += dispcols;
	}
	for(y = 0; y < wy; y++) {
		sketch_tac_row(pos, left_offset, hexrow[oddcol1], mapcols);
		pos += dispcols;
		sketch_tac_row(pos, left_offset, hexrow[!oddcol1], mapcols);
		pos += dispcols;
	}
	sketch_tac_row(pos, left_offset, hexrow[oddcol1], mapcols);

	/*
	 * Now draw the terrain and elevation. 
	 */
	pos = buf + top_offset * dispcols + left_offset;
	wx = MIN(wx, map->map_width - sx);
	wy = MIN(wy, map->map_height - sy);

	if(dohexlos)
		losmap = CalculateLOSMap(map, mech, MAX(0, sx), MAX(0, sy), wx, wy);

	for(y = MAX(0, -sy); y < wy; y++) {
		for(x = MAX(0, -sx); x < wx; x++) {
			int terr, elev, losflag = MAPLOSHEX_SEE | MAPLOSHEX_SEEN;
			char *base;
			char topchar, botchar;

			if(losmap)
				losflag = LOSMap_GetFlag(losmap, sx + x, sy + y);

			if(!(losflag & MAPLOSHEX_SEEN)) {
				terr = 'X';
				elev = 40;		/* 'X' */
			} else {

				if(losflag & MAPLOSHEX_SEETERRAIN)
					terr = GetTerrain(map, sx + x, sy + y);
				else
					terr = UNKNOWN_TERRAIN;

				if(losflag & MAPLOSHEX_SEEELEV)
					elev = GetElev(map, sx + x, sy + y);
				else
					elev = 15;	/* Ugly hack: '0' + 15 == '?' */
			}
			base = pos + tac_hex_offset(x, y, dispcols, oddcol1);

			switch (terr) {
			case WATER:
				/*
				 * Colour hack:  Draw deep water with '\242'
				 * if using colour so colourize_tac_map()
				 * knows to use dark blue rather than light
				 * blue
				 */
				if(docolour && elev >= 2) {
					topchar = '\242';
					botchar = '\242';
				} else {
					topchar = '~';
					botchar = '~';
				}
				break;

			case HIGHWATER:
				topchar = '~';
				botchar = '+';
				break;

			case BRIDGE:
				topchar = '#';
				botchar = '+';
				break;

			case ' ':			/* GRASSLAND */
				topchar = ' ';
				botchar = '_';
				break;

			case UNKNOWN_TERRAIN:
				topchar = '?';
				botchar = '?';
				break;

			default:
				topchar = terr;
				botchar = terr;
				break;
			}

			base[0] = topchar;
			base[1] = topchar;
			base[dispcols + 0] = botchar;
			if(elev > 0) {
				botchar = '0' + elev;
			}
			base[dispcols + 1] = botchar;
		}
	}
}

/*
 * Draw one of the seven hexes that a Dropship takes up on a tac map.
 */
static void sketch_tac_ds(char *base, int dispcols, char terr)
{
	/*
	 * Becareful not to overlay a 'mech id or terrain elevation.
	 */
	if(!isalpha(base[0]) && base[0] != '*') {
		base[0] = terr;
		base[1] = terr;
	}
	base[dispcols + 0] = terr;
	if(!isdigit((unsigned char) base[dispcols + 1])) {
		base[dispcols + 1] = terr;
	}
}

extern int dirs[6][2];

static void sketch_tac_ownmech(char *buf, MAP * map, MECH * mech, int sx,
							   int sy, int wx, int wy, int dispcols,
							   int top_offset, int left_offset)
{

	int oddcol1 = is_oddcol(sx);
	char *pos = buf + top_offset * dispcols + left_offset;
	char *base;
	int x = MechX(mech) - sx;
	int y = MechY(mech) - sy;

	if(x < 0 || x >= wx || y < 0 || y >= wy) {
		return;
	}
	base = pos + tac_hex_offset(x, y, dispcols, oddcol1);
	base[0] = '*';
	base[0] = '*';
}

static void sketch_tac_mechs(char *buf, MAP * map, MECH * player_mech,
							 int sx, int sy, int wx, int wy, int dispcols,
							 int top_offset, int left_offset, int docolour,
							 int labels)
{
	int i;
	char *pos = buf + top_offset * dispcols + left_offset;
	int oddcol1 = is_oddcol(sx);

	/*
	 * Draw all the 'mechs on the map.
	 */
	for(i = 0; i < map->first_free; i++) {
		int x, y;
		char *base;
		MECH *mech;

		if(map->mechsOnMap[i] == -1) {
			continue;
		}

		mech = getMech(map->mechsOnMap[i]);
		if(mech == NULL) {
			continue;
		}

		/*
		 * Check to see if the 'mech is on the tac map and 
		 * that its in LOS of the player's 'mech.
		 */
		x = MechX(mech) - sx;
		y = MechY(mech) - sy;
		if(!IsDS(mech) && (x < 0 || x >= wx || y < 0 || y >= wy)) {
			continue;
		}

		if(IsDS(mech) && (x < -1 || x > wx || y < -1 || y > wy)) {
			continue;
		}

		if(mech != player_mech &&
		   !InLineOfSight(player_mech, mech, MechX(mech), MechY(mech),
						  FlMechRange(map, player_mech, mech))) {
			continue;
		}

		base = pos + tac_hex_offset(x, y, dispcols, oddcol1);
		if(!(MechSpecials2(mech) & CARRIER_TECH) && IsDS(mech) &&
		   ((MechZ(mech) >= ORBIT_Z && mech != player_mech) || Landed(mech)
			|| !Started(mech))) {
			int ts = DSBearMod(mech);
			int dir;

			/*
			 * Dropships are a special case.  They take up
			 * seven hexes on a tac map.  First draw the
			 * center hex and then the six surronding hexes.
			 */

			for(dir = 0; dir < 6; dir++) {
				int tx = x + dirs[dir][0];
				int ty = y + dirs[dir][1];

				if((tx + oddcol1) % 2 == 0 && dirs[dir][0] != 0) {
					ty--;
				}
				if(tx < 0 || tx >= wx || ty < 0 || ty >= wy) {
					continue;
				}
				base = pos + tac_hex_offset(tx, ty, dispcols, oddcol1);
				if(Find_DS_Bay_Number(mech, (dir - ts + 6) % 6)
				   >= 0) {
					sketch_tac_ds(base, dispcols, '@');
				} else {
					sketch_tac_ds(base, dispcols, '=');
				}
			}
			if(x < 0 || x >= wx || y < 0 || y >= wy)
				continue;

			base = pos + tac_hex_offset(x, y, dispcols, oddcol1);
			if(docolour) {
				/*
				 * Colour hack: 'X' would be confused with
				 * any enemy con by colourize_tac_map()
				 */
				sketch_tac_ds(base, dispcols, '$');
			} else {
				sketch_tac_ds(base, dispcols, 'X');
			}

			if(isalpha(base[0]))
				continue;

			if(mech == player_mech) {
				base[0] = '*';
				base[1] = '*';
			} else {
				char *id = MechIDS(mech, MechSeemsFriend(player_mech, mech));
				base[0] = id[0];
				base[1] = id[1];
			}

		} else if(mech == player_mech) {
			if(isalpha(base[0]))
				continue;
			base[0] = '*';
			base[1] = '*';
		} else {
			char *id = MechIDS(mech, MechSeemsFriend(player_mech, mech));
			base[0] = id[0];
			base[1] = id[1];
		}
	}
}

static void sketch_tac_cliffs(char *buf, MAP * map, int sx, int sy, int wx,
							  int wy, int dispcols, int top_offset,
							  int left_offset, int cliff_size)
{
	char *pos = buf + top_offset * dispcols + left_offset;
	int y, x;
	int oddcol1 = is_oddcol(sx);

	wx = MIN(wx, map->map_width - sx);
	wy = MIN(wy, map->map_height - sy);
	for(y = MAX(0, -sy); y < wy; y++) {
		int ty = sy + y;

		for(x = MAX(0, -sx); x < wx; x++) {
			int tx = sx + x;
			int oddcolx = is_oddcol(tx);
			int elev = Elevation(map, tx, ty);
			char *base = pos + tac_hex_offset(x, y, dispcols,
											  oddcol1);
			char c;

			/*
			 * Copy the elevation up to the top of the hex 
			 * so we can draw a bottom hex edge on every hex.
			 */
			c = base[dispcols + 1];
			if(base[0] == '*') {
				base[0] = '*';
				base[1] = '*';
			} else if(isdigit((unsigned char) c)) {
				base[1] = c;
			}

			/*
			 * For each hex on the map check to see if each
			 * of it's 240, 180, and 120 hex sides is a cliff. 
			 * Don't check for cliffs between hexes that are on
			 * the tac map and those that are off of it.
			 */

			if(x != 0 && (y < wy - 1 || oddcolx)
			   && abs(Elevation(map, tx - 1, ty + 1 - oddcolx)
					  - elev) >= cliff_size) {

				base[dispcols - 1] = '|';
			}
			if(y < wy - 1 && abs(Elevation(map, tx, ty + 1) - elev)
			   >= cliff_size) {
				base[dispcols] = ',';
				base[dispcols + 1] = ',';
			} else {
				base[dispcols] = '_';
				base[dispcols + 1] = '_';
			}
			if(x < wx - 1 && (y < wy - 1 || oddcolx)
			   && abs(Elevation(map, tx + 1, ty + 1 - oddcolx)
					  - elev) >= cliff_size) {
				base[dispcols + 2] = '!';
			}
		}
	}
}
static void sketch_tac_dslz(char *buf, MAP * map, MECH * mech, int sx,
							int sy, int wx, int wy, int dispcols,
							int top_offset, int left_offset, int cliff_size,
							int docolour)
{
	char *pos = buf + top_offset * dispcols + left_offset;
	int y, x;
	int oddcol1 = is_oddcol(sx);

	wx = MIN(wx, map->map_width - sx);
	wy = MIN(wy, map->map_height - sy);
	for(y = MAX(0, -sy); y < wy; y++) {
		int ty = sy + y;

		for(x = MAX(0, -sx); x < wx; x++) {
			int tx = sx + x;
			char *base = pos + tac_hex_offset(x, y, dispcols, oddcol1);

			if(ImproperLZ(mech, tx, ty))
				base[dispcols] = docolour ? '\241' : 'X';
			else
				base[dispcols] = docolour ? '\240' : 'O';
		}
	}
}

/*
 * Colourize a sketch tac map.  Uses dynmaically allocated buffers
 * which are overwritten on each call.
 */
static char **colourize_tac_map(char const *sketch, int dispcols,
								int disprows)
{
	static char *buf = NULL;
	static int buf_len = 5000;
	static char **lines = NULL;
	static int lines_len = 100;
	int pos = 0;
	int line = 0;
	unsigned char cur_colour = '\0';
	const char *line_start;
	char const *src = sketch;

	if(buf == NULL) {
		Create(buf, char, buf_len);
	}
	if(lines == NULL) {
		Create(lines, char *, lines_len);
	}

	line_start = (char *) src;
	lines[0] = buf;
	while (lines > 0) {
		unsigned char new_colour;
		unsigned char c = *src++;

		if(c == '\0') {
			/*
			 * End of line.
			 */
			if(cur_colour != '\0') {
				buf[pos++] = '%';
				buf[pos++] = 'c';
				buf[pos++] = 'n';
			}
			buf[pos++] = '\0';
			line++;
			if(line >= disprows) {
				break;			/* Done */
			}
			if(line + 1 >= lines_len) {
				lines_len *= 2;
				ReCreate(lines, char *, lines_len);
			}
			line_start += dispcols;
			src = line_start;
			lines[line] = buf + pos;
			continue;
		}

		switch (c) {
		case (unsigned char) '\242':	/* Colour Hack: Deep Water */
			c = '~';
			new_colour = custom_color_str[DWATER_IDX];
			break;

		case (unsigned char) '\241':	/* Colour Hack: improper LZ */
			c = 'X';
			new_colour = custom_color_str[BADLZ_IDX];
			break;
		case (unsigned char) '\240':	/* Colour Hack: proper LZ */
			c = 'O';
			new_colour = custom_color_str[GOODLZ_IDX];
			break;
		case '?':
			c = '?';
			new_colour = custom_color_str[UNKNOWN_IDX];
			break;

		case '$':				/* Colour Hack: Drop Ship */
			c = 'X';
			new_colour = custom_color_str[DS_IDX];
			break;

		case '!':				/* Cliff hex edge */
			c = '/';
			new_colour = custom_color_str[CLIFF_IDX];
			break;

		case '|':				/* Cliff hex edge */
			c = '\\';
			new_colour = custom_color_str[CLIFF_IDX];
			break;

		case ',':				/* Cliff hex edge */
			c = '_';
			new_colour = custom_color_str[CLIFF_IDX];
			break;
		case '*':				/* mech itself. */
			new_colour = custom_color_str[SELF_IDX];
			break;

		default:
			if(islower(c)) {	/* Friendly con */
				new_colour = custom_color_str[FRIEND_IDX];
			} else if(isupper(c)) {	/* Enemy con */
				new_colour = custom_color_str[ENEMY_IDX];
			} else if(isdigit(c)) {	/* Elevation */
				new_colour = cur_colour;
			} else {
				new_colour = TerrainColorChar(c, 0);
			}
			break;
		}

		if(isupper(new_colour) != isupper(cur_colour)) {
			if(isupper(new_colour)) {
				buf[pos++] = '%';
				buf[pos++] = 'c';
				buf[pos++] = 'h';
			} else {
				buf[pos++] = '%';
				buf[pos++] = 'c';
				buf[pos++] = 'n';
				cur_colour = '\0';
			}
		}
		if(tolower(new_colour) != tolower(cur_colour)) {
			buf[pos++] = '%';
			buf[pos++] = 'c';
			if(new_colour == '\0') {
				buf[pos++] = 'n';
			} else if(new_colour == 'H') {
				buf[pos++] = 'n';
				buf[pos++] = '%';
				buf[pos++] = 'c';
				buf[pos++] = tolower(new_colour);
			} else {
				buf[pos++] = tolower(new_colour);
			}
			cur_colour = new_colour;
		}
		buf[pos++] = c;
		if(pos + 11 > buf_len) {
			/*
			 * If we somehow run out of room then we don't
			 * bother to reallocate 'buf' and potentially have
			 * a bunch of invalid pointers in 'lines' to fix up.
			 * We just restart from scratch with a bigger 'buf'.
			 */
			buf_len *= 2;
			free(buf);
			buf = NULL;
			return colourize_tac_map(sketch, dispcols, disprows);
		}
	}
	lines[line] = NULL;
	return lines;
}

/*
 * Draw a tac map for the TACTICAL and NAVIGATE commands.
 *
 * This used to be "one MOFO of a function" but has been simplified
 * in a number of ways.  One is that it used to statically allocated
 * buffers which limit the map drawn to MAP_DISPLAY_WIDTH hexes across
 * and 24 hexes down in size.  The return value should no longer be
 * freed with KillText().
 *
 * player   = dbref of player wanting map (mostly irrelevant)
 * mech     = mech player's in (or NULL, if on map) 
 * map      = map obj itself
 * cx       = middle of the map (x)
 * cy       = middle of the map (y)
 * wx       = width in x
 * wy       = width in y
 * labels   = bit array
 *    1 = the 'top numbers'
 *    2 = the 'side numbers'
 *    4 = navigate mode
 *    8 = show mech cliffs
 *   16 = show tank cliffs
 *   32 = show DS LZ's
 *
 * If navigate mode, wx and wy should be equal and odd.  Navigate maps
 * cannot have top or side labels.
 *
 */

char **MakeMapText(dbref player, MECH * mech, MAP * map, int cx, int cy,
				   int wx, int wy, int labels, int dohexlos)
{
	int docolour = Ansimap(player);
	int dispcols;
	int disprows;
	int mapcols;
	int left_offset = 0;
	int top_offset = 0;
	int navigate = 0;
	int sx, sy;
	int i;
	char *base;
	int oddcol1;
	enum {
		MAX_WIDTH = 40,
		MAX_HEIGHT = 24,
		TOP_LABEL = 3,
		LEFT_LABEL = 4,
		RIGHT_LABEL = 3
	};
	static char sketch_buf[((LEFT_LABEL + 1 + MAX_WIDTH * 3 + RIGHT_LABEL +
							 1) * (TOP_LABEL + 1 + MAX_HEIGHT * 2) + 2) * 5];
	static char *lines[(TOP_LABEL + 1 + MAX_HEIGHT * 2 + 1) * 5];

	if(labels & 4) {
		navigate = 1;
		labels = 0;
	}

	/*
	 * Figure out the extent of the tac map to draw.  
	 */
	wx = MIN(MAX_WIDTH, wx);
	wy = MIN(MAX_HEIGHT, wy);

	sx = cx - wx / 2;
	sy = cy - wy / 2;
	if(!navigate) {
		/*
		 * Only allow navigate maps to include off map hexes.
		 */
		sx = MAX(0, MIN(sx, map->map_width - wx));
		sy = MAX(0, MIN(sy, map->map_height - wy));
		wx = MIN(wx, map->map_width);
		wy = MIN(wy, map->map_height);
	}

	mapcols = tac_dispcols(wx);
	dispcols = mapcols + 1;
	disprows = wy * 2 + 1;
	oddcol1 = is_oddcol(sx);

	if(navigate) {
		if(oddcol1) {
			/*
			 * Insert blank line at the top where we can put
			 * a "__" to make the navigate map look pretty.
			 */
			top_offset = 1;
			disprows++;
		}
	} else {
		/*
		 * Allow room for the labels.
		 */
		if(labels & 1) {
			left_offset = LEFT_LABEL;
			dispcols += LEFT_LABEL + RIGHT_LABEL;
		}
		if(labels & 2) {
			top_offset = TOP_LABEL;
			disprows += TOP_LABEL;
		}
	}

	/*
	 * Create a sketch tac map including terrain and elevation.
	 */
	sketch_tac_map(sketch_buf, map, mech, sx, sy, wx, wy, dispcols,
				   top_offset, left_offset, docolour, dohexlos);

	/*
	 * Draw the top and side labels.
	 */
	if(labels & 1) {
		int x;

		for(x = 0; x < wx; x++) {
			char scratch[4];
			int label = sx + x;

			if(label < 0 || label > 999) {
				continue;
			}
			sprintf(scratch, "%3d", label);
			base = sketch_buf + left_offset + 1 + x * 3;
			base[0] = scratch[0];
			base[1 * dispcols] = scratch[1];
			base[2 * dispcols] = scratch[2];
		}
	}

	if(labels & 2) {
		int y;

		for(y = 0; y < wy; y++) {
			int label = sy + y;

			base = sketch_buf + (top_offset + 1 + y * 2)
				* dispcols;
			if(label < 0 || label > 999) {
				continue;
			}

			sprintf(base, "%3d", label);
			base[3] = ' ';
			sprintf(base + (dispcols - RIGHT_LABEL - 1), "%3d", label);
		}
	}

	if(labels & 8) {
		if(mech != NULL) {
			sketch_tac_ownmech(sketch_buf, map, mech, sx, sy, wx, wy,
							   dispcols, top_offset, left_offset);
		}
		sketch_tac_cliffs(sketch_buf, map, sx, sy, wx, wy, dispcols,
						  top_offset, left_offset, 3);
	} else if(labels & 16) {
		if(mech != NULL) {
			sketch_tac_ownmech(sketch_buf, map, mech, sx, sy, wx, wy,
							   dispcols, top_offset, left_offset);
		}
		sketch_tac_cliffs(sketch_buf, map, sx, sy, wx, wy, dispcols,
						  top_offset, left_offset, 2);
	} else if(labels & 32) {
		if(mech != NULL) {
			sketch_tac_ownmech(sketch_buf, map, mech, sx, sy, wx, wy,
							   dispcols, top_offset, left_offset);
		}
		sketch_tac_dslz(sketch_buf, map, mech, sx, sy, wx, wy, dispcols,
						top_offset, left_offset, 2, docolour);
	} else if(mech != NULL) {
		sketch_tac_mechs(sketch_buf, map, mech, sx, sy, wx, wy, dispcols,
						 top_offset, left_offset, docolour, labels);
	}

	if(navigate) {
		int n = wx / 2;			/* Hexagon radius */

		/*
		 * Navigate hack: erase characters from the sketch map
		 * to turn it into a pretty hexagonal shaped map.
		 */
		if(oddcol1) {
			/*
			 * Don't need the last line in this case. 
			 */
			disprows--;
		}

		for(i = 0; i < n; i++) {
			int len;

			base = sketch_buf + (i + 1) * dispcols + left_offset;
			len = (n - i - 1) * 3 + 1;
			memset(base, ' ', len);
			base[len] = '_';
			base[len + 1] = '_';
			base[mapcols - len - 2] = '_';
			base[mapcols - len - 1] = '_';
			base[mapcols - len] = '\0';

			base = sketch_buf + (disprows - i - 1) * dispcols + left_offset;
			len = (n - i) * 3;
			memset(base, ' ', len);
			base[mapcols - len] = '\0';
		}

		memset(sketch_buf + left_offset, ' ', n * 3 + 1);
		sketch_buf[left_offset + n * 3 + 1] = '_';
		sketch_buf[left_offset + n * 3 + 2] = '_';
		sketch_buf[left_offset + n * 3 + 3] = '\0';
	}

	if(docolour) {
		/*
		 * If using colour then colourize the sketch map and
		 * return the result.
		 */
		return colourize_tac_map(sketch_buf, dispcols, disprows);
	}

	/*
	 * If not using colour, the sketch map can be used as is.
	 */
	for(i = 0; i < disprows; i++) {
		lines[i] = sketch_buf + dispcols * i;
	}
	lines[i] = NULL;
	return lines;
}

/* Draws the map for the player when they use the 
 * TACTICAL [C | T | L] [<BEARING> <RANGE> | <TARGET-ID>]
 * command inside a unit */
void mech_tacmap(dbref player, void *data, char *buffer)
{
	MECH *mech = (MECH *) data;
	int argc, i;
	short x, y;
	int mapx, mapy;
	char *args_vec[4];
	char **args = args_vec;
	MAP *mech_map;
	int displayHeight = MAP_DISPLAY_HEIGHT, displayWidth = MAP_DISPLAY_WIDTH;
	char *str;
	char **maptext;
	int flags = 3, dohexlos = 0;

	/* Basic checks for pilot and mech */
	cch(MECH_USUAL);

	/* Get the map info */
	mech_map = getMap(mech->mapindex);
	mapx = MechX(mech);
	mapy = MechY(mech);

	/* Various checks for conditions and system of mech */
	argc = mech_parseattributes(buffer, args, 4);
	DOCHECK(!MechTacRange(mech), "Your system seems to be inoperational.");

	if(MapIsDark(mech_map) || (MechType(mech) == CLASS_MW &&
							   mudconf.btech_mw_losmap))
		dohexlos = 1;

	/* Check to see which type of tactical to display 
	 * if they specified a particular one */
	if(argc > 0 && isalpha((unsigned char) args[0][0])
	   && args[0][1] == '\0') {

		switch (tolower((unsigned char) args[0][0])) {
		case 'c':
			flags |= 8;			/* Show cliffs */
			break;

		case 't':
			flags |= 16;		/* Show tank cliffs */
			break;

		case 'l':
			dohexlos = 1;
			break;

		case 'b':
			flags |= 32;
			break;

		default:
			notify(player, "Invalid tactical map flag.");
			return;
		}

		args++;
		argc--;
	}

	DOCHECK(dohexlos
			&& (flags & (8 | 16 | 32)), "You can't see that much here!");

	if(!parse_tacargs(player, mech, args, argc, MechTacRange(mech), &x, &y))
		return;

	/* Get the Tacsize attribute from
	 * the player, if doesn't exist set the height and width to
	 * default params. If it does exist, check the values and
	 * make sure they are legit. */
	str = silly_atr_get(player, A_TACSIZE);
	if(!*str) {
		displayHeight = MAP_DISPLAY_HEIGHT;
		displayWidth = MAP_DISPLAY_WIDTH;
	} else if(sscanf(str, "%d %d", &displayHeight, &displayWidth) != 2 ||
			  displayHeight > 24 || displayHeight < 5 || displayWidth > 40 ||
			  displayWidth < 5) {

		notify(player,
			   "Illegal Tacsize attribute. Must be in format "
			   "'Height Width' . Height : 5-24 Width : 5-40");
		displayHeight = MAP_DISPLAY_HEIGHT;
		displayWidth = MAP_DISPLAY_WIDTH;
	}

	/* Everything worked but lets check the mech's tac range
	 * and the map size */
	displayHeight = (displayHeight <= 2 * MechTacRange(mech)
					 ? displayHeight : 2 * MechTacRange(mech));
	displayWidth = (displayWidth <= 2 * MechTacRange(mech)
					? displayWidth : 2 * MechTacRange(mech));

	displayHeight = (displayHeight <= mech_map->map_height)
		? displayHeight : mech_map->map_height;
	displayWidth = (displayWidth <= mech_map->map_width)
		? displayWidth : mech_map->map_width;

	set_colorscheme(player);

	/* Get the data to draw the map */
	maptext =
		MakeMapText(player, mech, mech_map, x, y, displayWidth,
					displayHeight, flags, dohexlos);

	/* Draw the map for the player */
	for(i = 0; maptext[i]; i++)
		notify(player, maptext[i]);
}

/* XXX Fix 'enterbase <dir>' */
static void mech_enter_event(MUXEVENT * e)
{
	MECH *mech = (MECH *) e->data, *tmpm = NULL;
	mapobj *mapo;
	MAP *map = getMap(mech->mapindex), *newmap;
	int target = (int) e->data2;
	int x, y;

	if(!(mapo = find_entrance_by_xy(map, MechX(mech), MechY(mech))))
		return;
	if(!Started(mech) || Uncon(mech) || Jumping(mech) ||
	   (MechType(mech) == CLASS_MECH && (Fallen(mech) || Standing(mech)))
	   || OODing(mech) || (fabs(MechSpeed(mech)) * 5 >= MMaxSpeed(mech) &&
						   fabs(MMaxSpeed(mech)) >= MP1)
	   || (MechType(mech) == CLASS_VTOL && AeroFuel(mech) <= 0))
		return;
	if(!(newmap = getMap(mapo->obj)))
		return;
	if(!find_entrance(newmap, target, &x, &y))
		return;

	if(!can_pass_lock(mech->mynum, newmap->mynum, A_LENTER) &&
	   (BuildIsSafe(newmap) || newmap->cf >= (newmap->cfmax / 2))) {
		char *msg = silly_atr_get(newmap->mynum, A_FAIL);
		if(!msg || !*msg)
			msg = "The hangar is locked.";
		mech_notify(mech, MECHALL, msg);
		return;
	}

	StopBSuitSwarmers(FindObjectsData(mech->mapindex), mech, 1);
	mech_printf(mech, MECHALL, "You enter %s.", structure_name(mapo));
	MechLOSBroadcast(mech, tprintf("has entered %s at %d,%d.",
								   structure_name(mapo), MechX(mech),
								   MechY(mech)));
	MarkForLOSUpdate(mech);
	if(MechType(mech) == CLASS_MW && !In_Character(mapo->obj)) {
		enter_mw_bay(mech, mapo->obj);
		return;
	}
	if(MechCarrying(mech) > 0)
		tmpm = getMech(MechCarrying(mech));
	mech_Rsetmapindex(GOD, (void *) mech, tprintf("%d", (int) mapo->obj));
	mech_Rsetxy(GOD, (void *) mech, tprintf("%d %d", x, y));
	MechLOSBroadcast(mech, tprintf("has entered %s at %d,%d.",
								   structure_name(mapo), MechX(mech),
								   MechY(mech)));
	loud_teleport(mech->mynum, mapo->obj);
	if(tmpm) {
		mech_Rsetmapindex(GOD, (void *) tmpm, tprintf("%d", (int) mapo->obj));
		mech_Rsetxy(GOD, (void *) tmpm, tprintf("%d %d", x, y));
		loud_teleport(tmpm->mynum, mapo->obj);
	}
	auto_cal_mapindex(mech);
}

void mech_enterbase(dbref player, void *data, char *buffer)
{
	MECH *mech = (MECH *) data;
	MAP *map, *newmap;
	int x, y;
	mapobj *mapo;
	char target, *tmpc;
	char *args[2];
	int argc;

	char fail_mesg[SBUF_SIZE];

	argc = mech_parseattributes(buffer, args, 2);
	DOCHECK(argc > 1, "Invalid arguments to command!");
	tmpc = args[0];
	if(argc > 0 && *tmpc && !(*(tmpc + 1)))
		target = tolower(*tmpc);
	else
		target = 0;
	cch(MECH_USUAL);
	map = getMap(mech->mapindex);
	/* For now, no dir checks */
	DOCHECK(Jumping(mech), "While in mid-jump? No way.");
	DOCHECK(MechType(mech) == CLASS_MECH && (Fallen(mech) ||
											 Standing(mech)),
			"Crawl inside? I think not. Stand first.");
	DOCHECK(OODing(mech), "While in mid-flight? No way.");
	DOCHECK(MechType(mech) == CLASS_VTOL &&
			AeroFuel(mech) <= 0, "You lack fuel to maneuver in!");
	DOCHECK(FlyingT(mech) &&
			!Landed(mech),
			"You need to land before you can enter the hangar.");
	DOCHECK(IsDS(mech),
			"Heh, you're trying to be funny, right, a DropShip entering hangar?");
	DOCHECK(fabs(MechSpeed(mech)) * 5 >= MMaxSpeed(mech) &&
			fabs(MMaxSpeed(mech)) >= MP1,
			"You are moving too fast to enter the hangar!");
	DOCHECK(!(mapo =
			  find_entrance_by_xy(map, MechX(mech), MechY(mech))),
			"You see nothing to enter here!");
	/* Wow, *gasp*, we got something to enter */
	if(!(newmap = FindObjectsData(mapo->obj))) {
		mech_notify(mech, MECHALL,
					"You sense wrongness in fabric of space..");
		SendError(tprintf
				  ("Error: No map existing for mapindex #%d (@ %d,%d of #%d)",
				   (int) mapo->obj, mapo->x, mapo->y, mech->mapindex));
		return;
	}
	if(!find_entrance(newmap, target, &x, &y)) {
		mech_notify(mech, MECHALL,
					"You sense wrongness in fabric of space..");
		SendError(tprintf
				  ("Error: No entrance existing for mapindex #%d (@ %d,%d of #%d)",
				   (int) mapo->obj, mapo->x, mapo->y, mech->mapindex));
		return;
	}

	if(!can_pass_lock(mech->mynum, newmap->mynum, A_LENTER) &&
	   (BuildIsSafe(newmap) || newmap->cf >= (newmap->cfmax / 2))) {

		/* Trigger FAIL & AFAIL */
		memset(fail_mesg, 0, sizeof(fail_mesg));
		snprintf(fail_mesg, LBUF_SIZE, "The hangar is locked.");

		did_it(player, newmap->mynum, A_FAIL, fail_mesg, 0, NULL, A_AFAIL,
			   (char **) NULL, 0);

		return;
	}

	DOCHECK(EnteringHangar(mech), "You are already entering the hangar!");
	/* XXX Check for other mechs in the hex possibly doing this as well (ick) */
	HexLOSBroadcast(map, MechX(mech), MechY(mech),
					"The doors at $h start to open..");
	MECHEVENT(mech, EVENT_ENTER_HANGAR, mech_enter_event, 18, (int) target);
}