src/hcode/btech/p.map.h File Reference

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

Go to the source code of this file.

Functions
void	debug_fixmap (dbref player, void *data, char *buffer)
void	map_view (dbref player, void *data, char *buffer)
void	map_addhex (dbref player, void *data, char *buffer)
void	map_mapemit (dbref player, void *data, char *buffer)
int	water_distance (MAP *map, int x, int y, int dir, int max)
int	map_load (MAP *map, char *mapname)
void	map_loadmap (dbref player, void *data, char *buffer)
void	map_savemap (dbref player, void *data, char *buffer)
void	map_setmapsize (dbref player, void *data, char *buffer)
void	map_clearmechs (dbref player, void *data, char *buffer)
void	map_update (dbref obj, void *data)
void	initialize_map_empty (MAP *new, dbref key)
void	newfreemap (dbref key, void **data, int selector)
int	map_sizefun (void *data, int flag)
void	map_listmechs (dbref player, void *data, char *buffer)
void	clear_hex (MECH *mech, int x, int y, int meant)
void	map_pathfind (dbref player, void *data, char *buffer)
void	UpdateMechsTerrain (MAP *map, int x, int y, int t)

---

Function Documentation

void clear_hex	(	MECH *	mech,
		int	x,
		int	y,
		int	meant
	)

Definition at line 658 of file map.c.

References getMap(), GetTerrain, GRASSLAND, HEAVY_FOREST, LIGHT_FOREST, MECH::mapindex, mech_printf(), MECHALL, MechLOSBroadcast(), Number, ROUGH, SetTerrain, and tprintf().

Referenced by possibly_clear().

{
        MAP *map;

        if(!(map = getMap(mech->mapindex)))
                return;
        switch (GetTerrain(map, x, y)) {
        case HEAVY_FOREST:
                SetTerrain(map, x, y, LIGHT_FOREST);
                break;
        case LIGHT_FOREST:
                if(Number(1, 2) == 1)
                        SetTerrain(map, x, y, ROUGH);
                else
                        SetTerrain(map, x, y, GRASSLAND);
                break;
        default:
                return;
        }
        if(meant) {
                MechLOSBroadcast(mech, tprintf("'s shot clears %d,%d!", x, y));
                mech_printf(mech, MECHALL, "You clear %d,%d.", x, y);
        } else {
                MechLOSBroadcast(mech, tprintf("'s stray shot clears %d,%d!", x, y));
                mech_printf(mech, MECHALL, "You accidentally clear the %d,%d!", x, y);
        }
}

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

Definition at line 36 of file map.c.

References Contents, DOLIST, MAP::first_free, getMech(), GTYPE_MECH, Hardcode, IsMech, MECH::mapindex, MECH::mapnumber, MAP::mechsOnMap, MAP::mynum, notify_printf(), and WhichSpecial().

Referenced by load_update1().

{
        MAP *m = (MAP *) data;
        int i, k;
        MECH *mek;

        if(!m)
                return;
        notify_printf(player, "Checking %d entries..", m->first_free);
        DOLIST(k, Contents(m->mynum)) {
                if(Hardcode(k)) {
                        if(WhichSpecial(k) == GTYPE_MECH) {
                                MECH *mek;

                                /* Check if it's on the map */
                                for(i = 0; i < m->first_free; i++)
                                        if(m->mechsOnMap[i] == k)
                                                break;
                                if(i != m->first_free)
                                        continue;
                                mek = getMech(k);
                                mek->mapindex = -1;     /* Eep. */
                                mek->mapnumber = 0;
                        }
                }
        }
        for(i = 0; i < m->first_free; i++)
                if((k = m->mechsOnMap[i]) >= 0) {
                        if(!IsMech(k)) {
                                notify_printf(player,
                                                          "Error: #%d isn't mech yet is in mapindex. Fixing..",
                                                          k);
                                m->mechsOnMap[i] = -1;
                        } else if(!(mek = getMech(k))) {
                                notify_printf(player,
                                                          "Error: #%d has no mech data. Removing..", k);
                                m->mechsOnMap[i] = -1;
                        } else if(mek->mapindex != m->mynum) {
                                notify_printf(player,
                                                          "Error: #%d isn't really here! Removing..", k);
                                m->mechsOnMap[i] = -1;
                        } else if(mek->mapnumber != i) {
                                notify_printf(player,
                                                          "Error: #%d has invalid mapnumber (mn:%d <-> real:%d)..",
                                                          k, mek->mapnumber, i);
                        }
                }
        notify(player, "Done.");
}

void initialize_map_empty	(	MAP *	new,
		dbref	key
	)

Definition at line 549 of file map.c.

References Create, DEFAULT_MAP_HEIGHT, DEFAULT_MAP_WIDTH, MAP::map, MAP::map_height, MAP::map_width, and SetMap.

Referenced by load_update1(), and newfreemap().

{
        int i, j;

        new->mynum = key;
        new->map_width = DEFAULT_MAP_WIDTH;
        new->map_height = DEFAULT_MAP_HEIGHT;
        Create(new->map, unsigned char *, new->map_height);

        for(i = 0; i < new->map_height; i++)
                Create(new->map[i], unsigned char, new->map_width);

        for(i = 0; i < new->map_height; i++)
                for(j = 0; j < new->map_width; j++)
                        SetMap(new, j, i, ' ', 0);
}

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

Definition at line 153 of file map.c.

References args, CheckData(), DOCHECK, MAX_ELEV, mech_parseattributes(), notify, SetElevation, SetTerrain, x, and y.

{
        MAP *map;
        int x, y, argc;
        char *args[4], elev;

        map = (MAP *) data;
        if(!CheckData(player, map))
                return;
        argc = mech_parseattributes(buffer, args, 4);
        DOCHECK(argc != 4, "Invalid number of arguments!");
        x = atoi(args[0]);
        y = atoi(args[1]);
        elev = abs(atoi(args[3]));
        DOCHECK(!((x >= 0) && (x < map->map_width) && (y >= 0) &&
                          (y < map->map_height)), "X,Y out of range!");
        if(args[2][0] == '.')
                SetTerrain(map, x, y, ' ');
        else
                SetTerrain(map, x, y, args[2][0]);
        SetElevation(map, x, y, (elev <= MAX_ELEV) ? elev : MAX_ELEV);
        notify(player, "Hex set!");
}

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

Definition at line 492 of file map.c.

References CheckData(), MAP::mynum, and ShutDownMap().

Referenced by fun_btloadmap(), and map_loadmap().

{
        MAP *map;

        map = (MAP *) data;
        if(CheckData(player, map))
                ShutDownMap(player, map->mynum);
}

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

Definition at line 605 of file map.c.

References args, CheckData(), DOCHECK, MAP::first_free, getMech(), list_mapobjs(), listmatch(), MAX_MECHS_PER_MAP, mech_parseattributes(), MechIDS(), MAP::mechsOnMap, notify, and notify_printf().

{
        MAP *map;
        MECH *tempMech;
        int i;
        int count = 0;
        char valid[50];
        char *ID;
        char *args[2];
        char *cmds[] = { "MECHS", "OBJS", NULL };
        enum {
                MECHS, OBJS
        };

        map = (MAP *) data;

        if(!CheckData(player, map))
                return;
        DOCHECK(mech_parseattributes(buffer, args, 1) == 0,
                        "Supply target type too!");
        switch (listmatch(cmds, args[0])) {
        case MECHS:
                notify(player, "--- Mechs on Map ---");
                for(i = 0; i < map->first_free; i++) {
                        if(map->mechsOnMap[i] != -1) {
                                tempMech = getMech(map->mechsOnMap[i]);
                                ID = MechIDS(tempMech, 0);
                                if(tempMech)
                                        strcpy(valid, "Valid Data");
                                else
                                        strcpy(valid, "Invalid Object Data!  Remove this Mech!");
                                notify_printf(player, "Mech DB Number: %d : [%s]\t%s",
                                                          map->mechsOnMap[i], ID, valid);
                                count++;
                        }
                }
                notify_printf(player, "%d Mechs On Map", count);
                notify_printf(player, "%d positions open", MAX_MECHS_PER_MAP - count);
                if(count != map->first_free)
                        notify_printf(player,
                                                  "%d is first free slot, according to db.",
                                                  map->first_free);
                return;
                break;
        case OBJS:
                list_mapobjs(player, map);
                return;
                break;
        }
        notify_printf(player, "Invalid argument (%s)!", args[0]);
        return;
}

int map_load	(	MAP *	map,
		char *	mapname
	)

Definition at line 244 of file map.c.

References Create, DEFAULT_MAP_HEIGHT, DEFAULT_MAP_WIDTH, del_mapobjs(), FIRE, MAP::flags, GetTerrainName_base(), GRASSLAND, LIGHT_FOREST, MAP::map, MAP::map_height, MAP_NAME_SIZE, MAP_PATH, MAPFLAG_FIRES, MAPX, MAPY, my_open_file(), MAP::mynum, SendError, SetMap, SMOKE, TFIRE, and tprintf().

Referenced by fun_btloadmap(), and map_loadmap().

{
        char openfile[50];
        char terr, elev;
        int i1, i2, i3;
        FILE *fp;
        char row[MAPX * 2 + 3];
        int i, j = 0, height, width, filemode;

        if(strlen(mapname) >= MAP_NAME_SIZE)
                mapname[MAP_NAME_SIZE] = 0;
        sprintf(openfile, "%s/%s", MAP_PATH, mapname);
        fp = my_open_file(openfile, "r", &filemode);
        if(!fp) {
                return -1;
        }
        del_mapobjs(map);                       /* Just in case */
        if(map->map) {
                for(i = 0; i < map->map_height; i++)
                        free((char *) (map->map[i]));
                free((char *) (map->map));
        }
        if(fscanf(fp, "%d %d\n", &height, &width) != 2 || height < 1 ||
           height > MAPY || width < 1 || width > MAPX) {
                SendError(tprintf("Map #%d: Invalid height and/or width",
                                                  map->mynum));
                width = DEFAULT_MAP_WIDTH;
                height = DEFAULT_MAP_HEIGHT;
        }
        Create(map->map, unsigned char *, height);

        for(i = 0; i < height; i++)
                Create(map->map[i], unsigned char, width);

        for(i = 0; i < height; i++) {
                if(feof(fp)
                   || fgets(row, 2 * MAPX + 2, fp) == NULL ||
                   strlen(row) < (2 * width)) {
                        break;
                }
                for(j = 0; j < width; j++) {
                        terr = row[2 * j];
                        elev = row[2 * j + 1] - '0';
                        switch (terr) {
                        case FIRE:
                                map->flags |= MAPFLAG_FIRES;
                                break;
                        case TFIRE:
                        case SMOKE:
                        case '.':
                                terr = GRASSLAND;
                                break;
                        case '\'':
                                terr = LIGHT_FOREST;
                                break;
                        }
                        if(!strcmp(GetTerrainName_base(terr), "Unknown")) {
                                SendError(tprintf
                                                  ("Map #%d: Invalid terrain at %d,%d: '%c'",
                                                   map->mynum, j, i, terr));
                                terr = GRASSLAND;
                        }
                        SetMap(map, j, i, terr, elev);
                }
        }
        if(i != height) {
                SendError(tprintf("Error: EOF reached prematurely. "
                                                  "(x%d != %d || y%d != %d)", j, width, i, height));
                my_close_file(fp, &filemode);
                return -2;
        }
        map->grav = 100;
        map->temp = 20;
        if(!feof(fp)) {
                if(fscanf(fp, "%d: %d %d\n", &i1, &i2, &i3) == 3) {
                        map->flags = i1;
                        map->grav = i2;
                        map->temp = i3;
                }
        }
        map->map_height = height;
        map->map_width = width;
        if(!MapNoBridgify(map))
                make_bridges(map);
        sprintf(map->mapname, mapname);
        my_close_file(fp, &filemode);
        return 0;
}

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

Definition at line 333 of file map.c.

References args, CheckData(), DOCHECK, map_clearmechs(), map_load(), mech_parseattributes(), notify, and notify_printf().

Referenced by load_update1().

{
        MAP *map;
        char *args[1];

        map = (MAP *) data;

        if(!CheckData(player, map))
                return;

        DOCHECK(mech_parseattributes(buffer, args, 1) != 1,
                        "Invalid number of arguments!");
        notify_printf(player, "Loading %s", args[0]);
        switch (map_load(map, args[0])) {
        case -1:
                notify(player, "Map not found.");
                return;
        case -2:
                notify(player, "Map invalid.");
                return;
        case 0:
                notify(player, "Map loaded.");
                break;
        default:
                notify(player, "Unknown error while loading map!");
                return;
        }

        if(player != 1) {
                notify(player, "Clearing Mechs off Newly Loaded Map");
                map_clearmechs(player, data, "");
        }
}

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

Definition at line 177 of file map.c.

References CheckData(), DOCHECK, MapBroadcast(), and notify.

{
        MAP *map;

        map = (MAP *) data;
        if(!CheckData(player, map))
                return;
        while (*buffer == ' ')
                buffer++;
        DOCHECK(!buffer || !*buffer, "What do you want to @mapemit?");
        MapBroadcast(map, buffer);
        notify(player, "Message sent!");
}

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

Definition at line 690 of file map.c.

References args, BOUNDED(), DOCHECK, mech_parseattributes(), readval, spath_map, and time().

{
        MAP *map = (MAP *) data;
        char *args[6];
        int argc;
        int x1, y1, x2, y2;
        time_t start_t;
        int errper = -1;

        if(!map)
                return;
        argc = mech_parseattributes(buffer, args, 6);
        DOCHECK((argc < 4 || argc > 5), "Invalid arguments!");
        readval(x1, args[0]);
        readval(y1, args[1]);
        readval(x2, args[2]);
        readval(y2, args[3]);
        if(argc > 4) {
                readval(errper, args[4]);
                errper = BOUNDED(0, errper, 1000);
        }
        spath_map = map;
        start_t = time(NULL);
}

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

Definition at line 369 of file map.c.

References args, CheckData(), DOCHECK, find_mapobj(), FIRE, MAP::flags, GetElevation, GetRTerrain, GetTerrain, MAP::map_height, MAP_NAME_SIZE, MAP_PATH, MAP::map_width, MAPFLAG_FIRES, MAPX, mech_parseattributes(), my_open_file(), notify_printf(), SendEvent, SetTerrain, SMOKE, TFIRE, tprintf(), and TYPE_FIRE.

{
        MAP *map;
        char *args[1];
        FILE *fp;
        char openfile[50];
        int i, j;
        char row[MAPX * 2 + 1];
        char terrain;
        int filemode;

        map = (MAP *) data;

        if(!CheckData(player, map))
                return;

        DOCHECK(mech_parseattributes(buffer, args, 1) != 1,
                        "Invalid number of arguments!");
        if(strlen(args[0]) >= MAP_NAME_SIZE)
                args[MAP_NAME_SIZE] = 0;
        notify_printf(player, "Saving %s", args[0]);
        sprintf(openfile, "%s/", MAP_PATH);
        strcat(openfile, args[0]);
        DOCHECK(!(fp =
                          my_open_file(openfile, "w", &filemode)),
                        "Unable to open the map file!");
        fprintf(fp, "%d %d\n", map->map_height, map->map_width);
        for(i = 0; i < map->map_height; i++) {
                mapobj *mo;

                row[0] = 0;
                for(j = 0; j < map->map_width; j++) {
                        terrain = GetTerrain(map, j, i);
                        switch (terrain) {
                        case ' ':
                                terrain = '.';
                                break;
                        case FIRE:
                                /* check if we're burnin', if so, alter terrain type */
                                if((mo = find_mapobj(map, j, i, TYPE_FIRE)))
                                        terrain = TFIRE;
                                else if(!(map->flags & MAPFLAG_FIRES)) {
                                        SetTerrain(map, j, i, ' ');
                                        SendEvent(tprintf
                                                          ("[lost?] fire event noticed on map #%d (%s) at %d,%d",
                                                           map->mynum, map->mapname, j, i));
                                        terrain = '.';
                                }
                                break;
                        case SMOKE:
                                terrain = GetRTerrain(map, j, i);
                                if(terrain == ' ')
                                        terrain = '.';
                                if(terrain == SMOKE) {
                                        SetTerrain(map, j, i, ' ');
                                        SendEvent(tprintf
                                                          ("[lost?] smoke event noticed on map #%d (%s) at %d,%d",
                                                           map->mynum, map->mapname, j, i));
                                        terrain = '.';
                                }
                                break;
                        }
                        row[j * 2] = terrain;
                        row[j * 2 + 1] = GetElevation(map, j, i) + '0';
                }
                row[j * 2] = 0;
                fprintf(fp, "%s\n", row);
        }
        if((i = (map->flags & ~(MAPFLAG_MAPO))))
                fprintf(fp, "%d: %d %d\n", i, map->grav, map->temp);
        notify(player, "Saving complete!");
        my_close_file(fp, &filemode);
}

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

Definition at line 443 of file map.c.

References args, CheckData(), Create, del_mapobjs(), DOCHECK, GetElevation, GetTerrain, MAP::map, MAP::map_height, MAP::map_width, MAP::mapobj, MAPX, MAPY, mech_parseattributes(), notify, SendError, SetMapB, TYPE_BITS, x, and y.

{
        MAP *oldmap;
        unsigned char **map;
        int x, y, i, j, failed = 0, argc, x1, y1;
        char *args[4];

        oldmap = (MAP *) data;
        if(!CheckData(player, oldmap))
                return;
        DOCHECK(oldmap->mapobj[TYPE_BITS], "Invalid map for size change, sorry.");
        DOCHECK((argc =
                         mech_parseattributes(buffer, args, 4)) != 2,
                        "Invalid number of arguments (X/Y expected)");
        x = atoi(args[0]);
        y = atoi(args[1]);
        DOCHECK(!((x >= 0) && (x <= MAPX) && (y >= 0) &&
                          (y <= MAPY)), "X,Y out of range!");
        /* allocate new map space */
        Create(map, unsigned char *, y);
        for(i = 0; i < y; i++)
                Create(map[i], unsigned char, x);

        if(failed)
                SendError("Memory allocation failed in setmapsize!");
        else {
                /* Initialize the hexes in the new map to blank */
                for(i = 0; i < y; i++)
                        for(j = 0; j < x; j++)
                                SetMapB(map, j, i, ' ', 0);
                /* Copy old map into new map */
                x1 = (oldmap->map_width < x) ? oldmap->map_width : x;
                y1 = (oldmap->map_height < y) ? oldmap->map_height : y;
                for(i = 0; i < y1; i++)
                        for(j = 0; j < x1; j++)
                                SetMapB(map, j, i, GetTerrain(oldmap, j, i),
                                                GetElevation(oldmap, j, i));
                /* Now free the old map */
                for(i = oldmap->map_height - 1; i >= 0; i--)
                        free((char *) (oldmap->map[i]));
                del_mapobjs(oldmap);
                /* set new map size and pointer to new map space */
                oldmap->map_height = y;
                oldmap->map_width = x;
                oldmap->map = map;
                notify(player, "Size set.");
        }
}

int map_sizefun	(	void *	data,
		int	flag
	)

Definition at line 592 of file map.c.

References MAP::map.

{
        MAP *map = (MAP *) data;
        int size = 0;

        if(!map)
                return 0;
        size = sizeof(*map);
        if(map->map)
                size += sizeof(*map->map);
        return size;
}

void map_update	(	dbref	obj,
		void *	data
	)

Definition at line 503 of file map.c.

References A_MAPVIS, BOUNDED(), MAP::cloudbase, MAP::first_free, getMech(), LBUF_SIZE, MAP::maplight, MAP::mapvis, MAP::maxvis, mech_notify(), MECHALL, MAP::mechsOnMap, muxevent_tick, sensor_light_availability_check(), silly_atr_get(), update_LOSinfo(), MAP::winddir, and MAP::windspeed.

{
        MAP *map = ((MAP *) data);
        MECH *mech;
        char *tmps, changemsg[LBUF_SIZE] = "";
        int ma, ml, wind, wspeed, cloudbase = 200;
        int oldl, oldv, i, j;
        AUTO *au;

        /* Changed from % 25 to % 60. %60 never hit when muxevent_tick came here and was odd.
           % 25 should hit when its odd or even (25 75 125... when odd 50 100 150... when even */

        if(!(muxevent_tick % 25)) {
                oldl = map->maplight;
                oldv = map->mapvis;
                if(!(tmps = silly_atr_get(obj, A_MAPVIS)) ||
                   sscanf(tmps, "%d %d %d %d %d %[^\n]", &ma, &ml, &wind,
                                  &wspeed, &cloudbase, changemsg) < 4) {
                        ma = 30;
                        ml = 2;
                        wind = 0;
                        wspeed = 0;
                        cloudbase = 200;
                }
                map->winddir = wind;
                map->windspeed = wspeed;
                map->mapvis = BOUNDED(0, ma, 60);
                map->maxvis = BOUNDED(24, ma * 3, 60);
                map->maplight = BOUNDED(0, ml, 2);
                map->cloudbase = cloudbase;
                if(ml != oldl || ma != oldv)
                        for(i = 0; i < map->first_free; i++) {
                                if((j = map->mechsOnMap[i]) < 0)
                                        continue;
                                if(!(mech = getMech(j)))
                                        continue;
                                if(ml != oldl)
                                        sensor_light_availability_check(mech);
                                if(strlen(changemsg) > 5)
                                        mech_notify(mech, MECHALL, changemsg);
                        }
        }
        update_LOSinfo(obj, map);
        /* Fire/Smoke are event-driven -> nothing related to them done here */
}

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

Definition at line 92 of file map.c.

References A_TACSIZE, args, BOUNDED(), MakeMapText(), MAP_DISPLAY_HEIGHT, MAP_DISPLAY_WIDTH, MAP::map_height, MAP::map_width, mech_parseattributes(), notify, silly_atr_get(), x, and y.

{
        MAP *mech_map = (MAP *) data;
        int argc, i;
        int x, y;
        char *args[2];
        int displayHeight = MAP_DISPLAY_HEIGHT, displayWidth = MAP_DISPLAY_WIDTH;
        char *str;
        char **maptext;

        /* Check if its a valid map */
        if(!mech_map)
                return;

        /* Make sure the proper number of arguments '<X> <Y>' were passed */
        argc = mech_parseattributes(buffer, args, 2);
        switch (argc) {
        case 2:
                x = BOUNDED(0, atoi(args[0]), mech_map->map_width - 1);
                y = BOUNDED(0, atoi(args[1]), mech_map->map_height - 1);
                break;
        default:
                notify(player, "Invalid number of parameters!");
                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 < 5 ||
                          displayWidth > 40) {

                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 map size */
        displayHeight = (displayHeight <= mech_map->map_height)
                ? displayHeight : mech_map->map_height;
        displayWidth = (displayWidth <= mech_map->map_width)
                ? displayWidth : mech_map->map_width;

        /* Get the map data */
        maptext = MakeMapText(player, NULL, mech_map, x, y, displayWidth,
                                                  displayHeight, 3, 0);

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

void newfreemap	(	dbref	key,
		void **	data,
		int	selector
	)

Definition at line 567 of file map.c.

References del_mapobjs(), initialize_map_empty(), NUM_MAPOBJTYPES, SPECIAL_ALLOC, and SPECIAL_FREE.

{
        MAP *new = *data;
        int i;

        switch (selector) {
        case SPECIAL_ALLOC:
                initialize_map_empty(new, key);
                /* allocate default map space */
                for(i = 0; i < NUM_MAPOBJTYPES; i++)
                        new->mapobj[i] = NULL;
                sprintf(new->mapname, "%s", "Default Map");
                break;
        case SPECIAL_FREE:
                del_mapobjs(new);
                if(new->map) {
                        for(i = new->map_height - 1; i >= 0; i--)
                                if(new->map[i])
                                        free((char *) (new->map[i]));
                        free((char *) (new->map));
                }
                break;
        }
}

void UpdateMechsTerrain	(	MAP *	map,
		int	x,
		int	y,
		int	t
	)

Definition at line 717 of file map.c.

References FindObjectsData(), MAP::first_free, MarkForLOSUpdate(), MAP::mechsOnMap, MechTerrain, MechX, and MechY.

{
        MECH *mech;
        int i;

        for(i = 0; i < map->first_free; i++) {
                if(!(mech = FindObjectsData(map->mechsOnMap[i])))
                        continue;
                if(MechX(mech) != x || MechY(mech) != y)
                        continue;
                if(MechTerrain(mech) != t) {
                        MechTerrain(mech) = t;
                        MarkForLOSUpdate(mech);
                }
        }
}

int water_distance	(	MAP *	map,
		int	x,
		int	y,
		int	dir,
		int	max
	)

Definition at line 195 of file map.c.

References BOUNDED(), BRIDGE, dirs, GetTerrain, ICE, MAP::map_height, MAP::map_width, ROAD, and WATER.

Referenced by eligible_bridge_hex().

{
        int i;
        int x2, y2;

        for(i = 1; i < max; i++) {
                x = x + dirs[dir][0];
                y = y + dirs[dir][1];
                if(!x && dirs[dir][0])
                        y--;
                x2 = BOUNDED(0, x, map->map_width - 1);
                y2 = BOUNDED(0, y, map->map_height - 1);
                if(x != x2 || y != y2)
                        return max;
                if(GetTerrain(map, x, y) == WATER || GetTerrain(map, x, y) == ICE)
                        return i;
                if(GetTerrain(map, x, y) != BRIDGE && GetTerrain(map, x, y) != ROAD)
                        return max;
        }
        return max;
}

---