src/hcode/btech/p.mech.maps.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	mech_findcenter (dbref player, void *data, char *buffer)
const char *	GetTerrainName_base (int t)
const char *	GetTerrainName (MAP *map, int x, int y)
void	mech_navigate (dbref player, void *data, char *buffer)
char	GetLRSMechChar (MECH *mech, MECH *tempMech)
void	mech_lrsmap (dbref player, void *data, char *buffer)
char *	TerrainColor (char terrain, int elev)
void	TacMapTerr (MAP *mech_map, int x, int y, char *terr, char *elev, int isdown)
char **	MakeMapText (dbref player, MECH *mech, MAP *mech_map, int x, int y, int xw, int yw, int labels, int dohexlos)
void	mech_tacmap (dbref player, void *data, char *buffer)
void	mech_enterbase (dbref player, void *data, char *buffer)

---

Function Documentation

char GetLRSMechChar	(	MECH *	mech,
		MECH *	tempMech
	)

Definition at line 286 of file mech.maps.c.

References c, IsDS, MechMove, MechSeemsFriend, MOVE_BIPED, MOVE_FLY, MOVE_FOIL, MOVE_HOVER, MOVE_HULL, MOVE_QUAD, MOVE_SUB, MOVE_TRACK, MOVE_VTOL, and MOVE_WHEEL.

Referenced by GetLRSMech().

{
        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;
}

const char* GetTerrainName	(	MAP *	map,
		int	x,
		int	y
	)

Definition at line 124 of file mech.maps.c.

References GetTerrain, and GetTerrainName_base().

Referenced by mech_navigate().

{
        return GetTerrainName_base(GetTerrain(map, x, y));
}

const char* GetTerrainName_base

(

int

t

)

Definition at line 89 of file mech.maps.c.

References BRIDGE, BUILDING, FIRE, GRASSLAND, HEAVY_FOREST, HIGHWATER, ICE, LIGHT_FOREST, MOUNTAINS, ROAD, ROUGH, SMOKE, WALL, and WATER.

Referenced by GetTerrainName(), and map_load().

{
        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";
}

char** MakeMapText	(	dbref	player,
		MECH *	mech,
		MAP *	mech_map,
		int	x,
		int	y,
		int	xw,
		int	yw,
		int	labels,
		int	dohexlos
	)

Definition at line 1302 of file mech.maps.c.

References Ansimap, colourize_tac_map(), is_oddcol(), MAP::map_height, MAP::map_width, MAX, MIN, sketch_tac_cliffs(), sketch_tac_dslz(), sketch_tac_map(), sketch_tac_mechs(), sketch_tac_ownmech(), tac_dispcols(), x, and y.

Referenced by map_view(), mech_navigate(), and mech_tacmap().

{
        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;
}

void mech_enterbase	(	dbref	player,
		void *	data,
		char *	buffer
	)

Definition at line 1675 of file mech.maps.c.

References A_AFAIL, A_FAIL, A_LENTER, AeroFuel, args, BuildIsSafe, can_pass_lock, cch, MAP::cf, MAP::cfmax, CLASS_MECH, CLASS_VTOL, did_it(), DOCHECK, EnteringHangar, EVENT_ENTER_HANGAR, Fallen, find_entrance(), find_entrance_by_xy(), FindObjectsData(), FlyingT, getMap(), HexLOSBroadcast(), IsDS, Jumping, Landed, LBUF_SIZE, MECH::mapindex, mech_enter_event(), mech_notify(), mech_parseattributes(), MECH_USUAL, MECHALL, MECHEVENT, MechSpeed, MechType, MechX, MechY, MMaxSpeed, MP1, MAP::mynum, MECH::mynum, mapobj_struct::obj, OODing, SBUF_SIZE, SendError, Standing, tprintf(), mapobj_struct::x, x, mapobj_struct::y, and y.

Referenced by auto_enter_event().

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

void mech_findcenter	(	dbref	player,
		void *	data,
		char *	buffer
	)

Definition at line 33 of file mech.maps.c.

References cch, FindBearing(), FindHexRange(), MapCoordToRealCoord(), MECH_USUAL, MechFX, MechFY, MechX, MechY, MechZ, notify_printf(), x, and y.

Referenced by turret_findcenter().

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

void mech_lrsmap	(	dbref	player,
		void *	data,
		char *	buffer
	)

Definition at line 630 of file mech.maps.c.

References A_LRSHEIGHT, Ansimap, args, confdata::btech_mw_losmap, cch, CLASS_MW, DOCHECK, getMap(), LRS_COLORMODE, LRS_DISPLAY_HEIGHT, LRS_ELEVCOLORMODE, LRS_ELEVMODE, LRS_TERRAINMODE, MAP::map_height, MECH::mapindex, MapIsDark, mech_parseattributes(), MECH_USUAL, MechLRSRange, MechType, MIN, mudconf, notify, notify_printf(), parse_tacargs(), set_colorscheme(), show_lrs_map(), silly_atr_get(), x, and y.

Referenced by turret_lrsmap().

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

void mech_navigate	(	dbref	player,
		void *	data,
		char *	buffer
	)

Definition at line 200 of file mech.maps.c.

References args, confdata::btech_mw_losmap, cch, CLASS_MW, DOCHECK, getMap(), GetTerrainName(), MakeMapText(), MAP::map_height, MAP::map_width, MECH::mapindex, MapIsDark, MBUF_SIZE, mech_parseattributes(), MECH_USUAL, MechFacing, MechSpeed, MechTacRange, MechType, MechVerticalSpeed, MechX, MechY, MechZ, mudconf, NAVIGATE_LINES, navigate_sketch_mechs(), notify, parse_tacargs(), set_colorscheme(), x, and y.

Referenced by turret_navigate().

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

void mech_tacmap	(	dbref	player,
		void *	data,
		char *	buffer
	)

Definition at line 1508 of file mech.maps.c.

References A_TACSIZE, args, confdata::btech_mw_losmap, cch, CLASS_MW, DOCHECK, getMap(), MakeMapText(), MAP_DISPLAY_HEIGHT, MAP_DISPLAY_WIDTH, MAP::map_height, MAP::map_width, MECH::mapindex, MapIsDark, mech_parseattributes(), MECH_USUAL, MechTacRange, MechType, MechX, MechY, mudconf, notify, parse_tacargs(), set_colorscheme(), silly_atr_get(), x, and y.

Referenced by turret_tacmap().

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

void TacMapTerr	(	MAP *	mech_map,
		int	x,
		int	y,
		char *	terr,
		char *	elev,
		int	isdown
	)

char* TerrainColor	(	char	terrain,
		int	elev
	)

---