/** * This is the terrain handler method documentation. For a more general * introduction to the terrain handler, please see the help for terrains. * * @author Sin * @author Turrican * @author others... * * @change 9 Nov 1997, Sin * added support for inherit statements to * get_room_size(), this fixes a bug in the terrain handler in * regards to the placement of set_room_size() functions. Added * a limit of 4 inherits, so infinite loops aren't a problem. * @change 25 Nov 1997, Sin * changed the calculate_exits() call so that it * starts at the border of the current room instead of starting * at the center of the current room. This makes sense because * it already knows the room size for the current room. :) * @change 29 Nov 1997, Sin * changed query_room_size() to cache results * temporarily and to check the map handler before trying to * parse on its own. * @change 13 Nov 2002, Shiannar * Began adding functionality to remove the Discworldisms from * the handler, culminating in a backward compatable but * (theoretically) greatly improved version. * @see help::terrains */ /* * Ok. Terrains will now be stored in classes, all held in a big array. * Due to the messiness of such an approach, it will be cleaned up * periodically, most likely every 9 1/2 minutes. Each terrain will be * linked to any terrains it needs to link to, which will keep overall * class size to a minimum (hopefully). Each terrain can have "landmarks" * listed, each of which has a maximum visible distance, reduced by half * at night, and a set of locations. The set of locations is for landmarks * that are larger than one room. The landmark consists of a name, a * short, and a long (added as an add_item to the room in question). * And thus concludes the improvements I plan to do at the moment, more * will probably follow. */ #include <dirs.h> #include <terrain.h> #undef DEBUG_ROOM_SIZE #undef DEBUG_CALC_EXITS #define BACKUP_TIME_OUT 1000000 inherit OBJECT_OBJ; /*class landmark { string name; string short; string long; int *where; }*/ //Landmarks: ([ name : ({ short, long, ({ where }) }) ]) class a_terrain { object *rooms; mapping fixed_locations; mixed *floating_locations; mapping cloned_locations; mapping landmarks; string *links; } mapping terrains = ([ ]); //string terrain_name; //mapping fixed_locations; //mixed *floating_locations; //private nosave int in_map; //private nosave mapping size_cache, cloned_locations, float_cache; private nosave mapping std_types = ([ "north" : "path", "south" : "path", "east" : "path", "west" : "path", "northeast" : "hidden", "southwest" : "hidden", "southeast" : "hidden", "northwest" : "hidden", "up" : "stair", "down" : "stair" ]); /** @ignore yes */ void setup() { // size_cache = ([ ]); // cloned_locations = ([ ]); // float_cache = ([ ]); set_name("map"); set_short("terrain map"); add_adjective("terrain"); // set_long("This is a large map showing a large expanse of forest, desert, " // "mountain or ocean. A few locations of interest are marked on " // "it, with most of the gaps between them blank or marked " // "\"Here bee Draggons\" and the like, suggesting that the map-" // "maker didn't know what was there either.\n" ); set_long("This is the terrain handler. It used to have a description " "mentioning dragons and mountains and map makers and stuff, but who " "really cares? I mean, will anyone ever actually \"look\" at a " "terrain handler?\n"); add_adjective("terrain"); } /* setup() */ void save_me() { } void create_terrain(string terrain) { if(!sizeof(terrains)) terrains = ([ ]); terrains += ([ terrain : new(class a_terrain, rooms : ({ }), fixed_locations : ([ ]), floating_locations : ({ }), cloned_locations : ([ ]), landmarks : ([ ]), links : ({ }) ) ]); } /** * This method checks wether there is a cloned location which matches the * given coordinates. * @param terrain the terrain to look in * @param co_ords the coordinates to find the room for * @return the room with the given coordinates, or 0 if * it is not found * @see member_fixed_locations() * @see member_floating_locations() */ object member_cloned_locations(string terrain, int *co_ords) { mapping tmp; if(!terrains[terrain]) return 0; if ((tmp = terrains[terrain]->cloned_locations) && (tmp = tmp[co_ords[0]]) && (tmp = tmp[co_ords[1]])) { return tmp[co_ords[2]]; } return 0; } /* member_cloned_locations() */ /** * This method checks wether there is a fixed location which matches the * given coordinates. * @param terrain the terrain to search in * @param co_ords the coordinates to find the room for * @return the file name of the room with the given coordinates, or 0 if * it is not found * @see member_cloned_locations() * @see member_floating_locations() */ string member_fixed_locations(string terrain, int *co_ords) { int *loc_co_ords; string location; if(!terrains[terrain]) return 0; foreach (location, loc_co_ords in terrains[terrain]->fixed_locations) { if ((co_ords[0] == loc_co_ords[0]) && (co_ords[1] == loc_co_ords[1]) && (co_ords[2] == loc_co_ords[2])) { return location; } } return 0; } /* member_fixed_locations() */ /** @ignore yes */ private int between(int limit1, int val, int limit2) { if (limit1 < limit2) { return ((limit1 <= val) && (val <= limit2)); } else { return ((limit2 <= val) && (val <= limit1)); } } /** * This method checks wether there are floating locations which match the * given coordinates. * @param terrain the terrain to search in * @param co_ords the coordinates to find the rooms for * @return an array with the file names of the rooms and the levels, or * the empty array if none are found * @see member_cloned_locations() * @see member_fixed_locations() */ mixed *member_floating_locations(string terrain, int *co_ords) { int *data; mixed *right_locations, *location; if(!terrains[terrain]) return ({ }); right_locations = ({ }); foreach (location in terrains[terrain]->floating_locations) { data = location[1]; if (sizeof(data) == 6) { /* element is ({ file, ({ 6 coords bounding box }), priority }) */ if (between(data[0], co_ords[0], data[3]) && between(data[1], co_ords[1], data[4]) && between(data[2], co_ords[2], data[5])) { right_locations += ({ location[0], location[2] }); } } else { /* element is ({ file, ({ 3 coords of location }), priority }) */ if ((co_ords[0] == data[0]) && (co_ords[1] == data[1]) && (co_ords[2] == data[2])) { right_locations += ({ location[0], location[2] }); } } } return right_locations; } /* member_floating_locations() */ /** * This method searches the top level floating location for the given * coordinates. * @param terrain the terrain to search in * @param co_ords the coordinates to find the top level for * @return the top level room with the given coordinates, * or 0 if none was found * @see member_floating_locations() */ mixed top_floating_location(string terrain, int *co_ords) { int i, highest_level; mixed highest_location; mixed *right_locations; right_locations = member_floating_locations(terrain, co_ords); if (!sizeof(right_locations)) return 0; highest_level = right_locations[1]; highest_location = right_locations[0]; for (i = 0; i < sizeof(right_locations); i += 2) { if (right_locations[i + 1] > highest_level) { highest_level = right_locations[i + 1]; highest_location = right_locations[i]; } } if (highest_location == "nothing") return 0; return highest_location; } /* top_floating_location() */ private void init_data(string word) { // terrain_name = word; // fixed_locations = ([ ]); // floating_locations = ({ }); TCRE("shiannar", "init_data in "+file_name(TO)+" is currently empty, " "and has just been called!"); } /* init_data() */ /** * This method loads the data file for a given terrain. * @param word the terrain to load the data for * @return 1 if the terrain exists, 0 if it didn't */ int get_data_file(string word) { TCRE("shiannar", "get_data_file (outdated) in "+file_name(TO)+ " was just called with "+word+", from "+PO); return 1; // if (terrain_name != word) { if (file_size(RESTORE_PATH + word + ".o") > 0) { unguarded((: restore_object, RESTORE_PATH + word :)); } else { init_data(word); return 0; } // } return 1; } /* get_data_file() */ private void save_data_file(string word) { int number, last; string line, *lines; TCRE("shiannar", "save_data_file (outdated) in "+file_name(TO)+ " was just called with "+word+", from "+PO); return; if (file_size(RESTORE_PATH + word +".o") > 0) { unguarded((: rename, RESTORE_PATH + word +".o", RESTORE_PATH +"backups/"+ word +"."+ time() :)); lines = unguarded((: get_dir, RESTORE_PATH +"backups/"+ word +".*" :)); if (sizeof(lines) > 3) { last = time() - BACKUP_TIME_OUT; foreach(line in lines) { sscanf(line, word +".%d", number); if (number < last) unguarded((: rm, RESTORE_PATH +"backups/"+ line :)); } } } unguarded((: save_object, RESTORE_PATH + word :)); } /* save_data_file() */ /** * This method returns the cloned_locations mapping for a given terrain. * @param word the terrain name * @return the cloned_locations mapping; keys are the file names, values are * the coordinates for the files. There are also keys on x coordinates to * facilitate faster coordinate lookups. * @see query_fixed_locations() * @see query_floating_locations() */ mapping query_cloned_locations(string terrain) { if(!terrains[terrain]) return ([ ]); return terrains[terrain]; } /* query_cloned_locations() */ /** * This method returns the fixed_locations mapping for the given terrain. * @param word the terrain name * @return the fixed_locations mapping; keys are the file names, values are * the coordinates for the files * @see query_cloned_locations() * @see query_floating_locations() */ mapping query_fixed_locations(string word) { // get_data_file(word); if(!terrains[word]) return ([ ]); return terrains[word]->fixed_locations; } /* query_fixed_locations() */ /** * This method returns the floating_locations array for the given terrain. * @param word the terrain name * @return the floating_locations array; this is an array of arrays where each * array consists of the file name, an array of 6 coordinates forming a * bounding box or normal coordinates for the location and the level of the * floating location * @see query_cloned_locations() * @see query_fixed_locations() */ mixed *query_floating_locations(string word) { // get_data_file(word); if(!terrains[word]) return ({ }); return terrains[word]->floating_locations; } /* query_floating_locations() */ /** * This method returns the coordinates for a given terrain and fixed location * filename. * @param terrain the terrain name * @param file the file name of the location * @return the coordinates */ int *query_co_ord(string terrain, string file) { // get_data_file(terrain); if(!terrains[terrain]) return ({ }); return terrains[terrain]->fixed_locations[file]; } /* query_co_ord() */ /** * This method returns the connecting room for the given coordinates and * direction. * @param terrain the terrain name * @param co_ords the coordinates * @param direc the direction to find the room for * @return the file name of the connecting room or 0 if none was found * @see query_connected() */ string query_connection(string terrain, int *co_ords, string direc) { mapping connection_info, tmp; string connections; // if (!float_cache[terrain] || // !(connection_info = float_cache[terrain][co_ords[0]])) { if (file_size(RESTORE_PATH + terrain) != -2) { return 0; } if (file_size(RESTORE_PATH + terrain +"/"+ co_ords[0]) == -1) { return 0; } connections = unguarded((: read_file, RESTORE_PATH + terrain +"/"+ co_ords[0] :)); connection_info = restore_variable(connections); /* if (!mappingp(float_cache[terrain])) { float_cache[terrain] = ([ co_ords[0] : connection_info ]); } else { float_cache[terrain][co_ords[0]] = connection_info; }*/ // } if ((tmp = connection_info[co_ords[1]]) && (tmp = tmp[co_ords[2]])) { return tmp[direc]; } return 0; } /* query_connection() */ /** * This method returns wether the given coordinates is connected to another * room in the terrain handler system. * @param terrain the terrain name * @param co_ords the coordinates * @return 1 if it is found, 0 otherwise * @see query_connection() */ int query_connected(string terrain, int *co_ords) { mapping connection_info, tmp; string connections; // if (!float_cache[terrain] || // !(connection_info = float_cache[terrain][co_ords[0]])) { if (file_size(RESTORE_PATH + terrain) != -2) { return 0; } if (file_size(RESTORE_PATH + terrain +"/"+ co_ords[0]) == -1) { return 0; } connections = unguarded((: read_file, RESTORE_PATH + terrain +"/"+ co_ords[0] :)); connection_info = restore_variable(connections); /* if (!mappingp(float_cache[terrain])) { float_cache[terrain] = ([ co_ords[0] : connection_info ]); } else { float_cache[terrain][co_ords[0]] = connection_info; } }*/ if ((tmp = connection_info[co_ords[1]]) && tmp[co_ords[2]]) { return 1; } return 0; } /* query_connected() */ /** * This method adds a landmark to a terrain. To refer to the landmark * in a room, use $name$, eg "$calarien$". * @param terrain the terrain name * @param name the name of the landmark, eg "calarien" * @param short the short desc of the landmark, eg "the grand city of Calarien" * @param long the long desc of the landmark * @param coords the int array of the coords of the landmark * @see remove_landmark() * @see modify_landmark() */ int add_landmark(string terrain, string name, string short, mixed long, int *coords) { if(!terrains[terrain]) create_terrain(terrain); if(!terrains[terrain]->landmarks) terrains[terrain]->landmarks = ([ ]); if(terrains[terrain]->landmarks[name]) return 0; terrains[terrain]->landmarks += ([ terrain : ({ name, short, long, coords }) ]); return 1; } /** * This method removes a landmark from a terrain. * @param terrain the terrain name * @param name the name of the landmark, eg "calarien" * @return int success * @see add_landmark() * @see modify_landmark() */ int remove_landmark(string terrain, string name) { if(!terrains[terrain]) return 0; if(!terrains[terrain]->landmarks) return 0; return map_delete(terrains[terrain]->landmarks, name); } /** * This method modifies a landmark. Equivalent to removing and re-adding * a landmark. * @param terrain the terrain to modify the landmark of * @param name the landmark name * @param short the short of the landmark * @param long the long of the landmark * @param coords the int array of the coords of the landmark * @return int success */ int modify_landmark(string terrain, string name, string short, mixed long, int *coords) { remove_landmark(terrain, name); return add_landmark(terrain, name, short, long, coords); } /** * This method adds a new fixed location for a terrain. * @param terrain the terrain name * @param file the file name * @param co_ords the coordinates for the location * @return 1 if it succeeds, 0 if it fails (wrong coordinates or location * already present) * @see add_floating_location() * @see modify_fixed_location() */ int add_fixed_location(string terrain, string file, int *co_ords) { // get_data_file(terrain); if(!terrains[terrain]) create_terrain(terrain); if (terrains[terrain]->fixed_locations[file]) { return 0; } if (sizeof(co_ords) != 3) { return 0; } terrains[terrain]->fixed_locations[file] = co_ords; // save_data_file(terrain_name); save_me(); return 1; } /* add_fixed_location() */ private int add_connection(string terrain, int *co_ords, string direc, string file) { mapping connection_info, tmp; string connections; if (!query_connection(terrain, co_ords, direc)) { if (file_size(RESTORE_PATH + terrain) != -2) { unguarded((: mkdir, RESTORE_PATH + terrain :)); } if (file_size(RESTORE_PATH + terrain +"/"+ co_ords[0]) == -1) { connection_info = ([ co_ords[1] : ([ co_ords[2] : ([ direc : file ]) ]) ]); unguarded((: write_file, RESTORE_PATH + terrain + "/" + co_ords[0], save_variable(connection_info), 1 :)); } else { connections = unguarded((: read_file, RESTORE_PATH + terrain +"/"+ co_ords[0] :)); connection_info = restore_variable(connections); if ((tmp = connection_info[co_ords[1]])) { if ((tmp = tmp[co_ords[2]])) { tmp[direc] = file; } else { connection_info[co_ords[1]][co_ords[2]] = ([ direc : file ]); } } else { connection_info[co_ords[1]] = ([ co_ords[2] : ([ direc : file ]) ]); } unguarded((: write_file, RESTORE_PATH + terrain + "/" + co_ords[0], save_variable(connection_info), 1 :)); } /* if (!mappingp(float_cache[terrain])) { float_cache[terrain] = ([ co_ords[0] : connection_info ]); } else { float_cache[terrain][co_ords[0]] = connection_info; }*/ } } /* add_connection() */ /** * This method adds a new floating location for a terrain. * @param terrain the terrain name * @param file the file name * @param co_ords the coordinates for the location (either a single coordinate * or 2 forming a bounding rectangle) * @param level the level of this location * @return 1 if it succeeds, 0 if it fails (wrong coordinates or location * already present) * @see add_fixed_location() */ int add_floating_location(string terrain, string file, int *co_ords, int level) { // get_data_file(terrain); if(!terrains[terrain]) create_terrain(terrain); if ((sizeof(co_ords) != 6) && (sizeof(co_ords) != 3)) { return 0; } if (member_array(({ file, co_ords, level }), terrains[terrain]->floating_locations) != -1) { return 0; } terrains[terrain]->floating_locations += ({ ({ file, co_ords, level }) }); // save_data_file(terrain_name); save_me(); return 1; } /* add_floating_location() */ private void add_cloned_location(string terrain, string file, int *co_ords) { mapping tmp, location_m; if(!terrains[terrain]) return; if (!(location_m = terrains[terrain]->cloned_locations[terrain])) { terrains[terrain]->cloned_locations[terrain] = ([ file : co_ords, co_ords[0] : ([ co_ords[1] : ([ co_ords[2] : file ]) ]) ]); } else { location_m[file] = co_ords; if ((tmp = location_m[co_ords[0]])) { if ((tmp = tmp[co_ords[1]])) { tmp[co_ords[2]] = file; } else { location_m[co_ords[0]][co_ords[1]] = ([ co_ords[2] : file ]); } } else { location_m[co_ords[0]] = ([ co_ords[1] : ([ co_ords[2] : file ]) ]); } } } /* add_cloned_location() */ /** * This method modifies an existing fixed location for a terrain. * @param terrain the terrain name * @param file the file name * @param co_ords the coordinates for the location * @return 1 if it succeeds, 0 if it fails (wrong coordinates or location * not found) * @see add_fixed_location() */ int modify_fixed_location(string terrain, string file, int *co_ords) { // get_data_file(terrain); if (!terrains[terrain]->fixed_locations[file]) { return 0; } if (sizeof(co_ords) != 3) { return 0; } terrains[terrain]->fixed_locations[file] = co_ords; // save_data_file(terrain_name); return 1; } /* modify_fixed_location() */ /** * This method deletes a cloned location for a terrain from the cache. * It is meant to be called when a cloned location is destructed. * @param terrain the terrain name * @param file the file name * @return 1 if it succeeds, 0 if it fails (location not present) * @see delete_fixed_location() * @see delete_floating_location() */ int delete_cloned_location(string terrain, string file) { int *co_ords; mapping tmp, location_m; if (!((location_m = terrains[terrain]->cloned_locations) && (co_ords = location_m[file]))) { return 0; } map_delete(location_m, file); tmp = location_m[co_ords[0]][co_ords[1]]; map_delete(tmp, co_ords[2]); if (!sizeof(tmp)) { tmp = location_m[co_ords[0]]; map_delete(tmp, co_ords[1]); if (!sizeof(tmp)) { map_delete(location_m, co_ords[0]); if (!sizeof(location_m)) { map_delete(terrains[terrain]->cloned_locations, terrain); } } } return 1; } /* delete_cloned_location() */ /** * This method deletes a fixed location for a terrain. * @param terrain the terrain name * @param file the file name * @return 1 if it succeeds, 0 if it fails (location not present) * @see delete_cloned_location() * @see delete_floating_location() */ int delete_fixed_location(string terrain, string file) { // get_data_file(terrain); if (!terrains[terrain]->fixed_locations[file]) { return 0; } map_delete(terrains[terrain]->fixed_locations, file); // save_data_file(terrain_name); return 1; } /* delete_fixed_location() */ /** * This method deletes a floating location for a terrain. * @param terrain the terrain name * @param file the file name * @param co_ords the coordinates for the location (either a single coordinate * or 2 forming a bounding rectangle) * @return 1 if it succeeds, 0 if it fails (location not present) * @see delete_cloned_location() * @see delete_fixed_location() */ int delete_floating_location(string terrain, string file, int *co_ords) { int i, j, flag_d, flag_m, *data; // get_data_file(terrain); for (i = 0; i < sizeof(terrains[terrain]->floating_locations); i++) { if (terrains[terrain]->floating_locations[i][0] == file) { data = terrains[terrain]->floating_locations[i][1]; if (sizeof(data) != sizeof(co_ords)) { continue; } flag_m = 0; for (j = 0; j < sizeof(data); j++) { if (data[j] != co_ords[j]) { flag_m = 1; break; } if (!flag_m) { terrains[terrain]->floating_locations = delete(terrains[terrain]->floating_locations, i, 1); flag_d = 1; } } } } // save_data_file(terrain_name); return flag_d; } /* delete_floating_location() */ /** * This method clears the cloned locations cache for a given terrain. * @param terrain the terrain name * @see clear_connections() */ void clear_cloned_locations(string terrain) { map_delete(terrains[terrain]->cloned_locations, terrain); } /* clear_cloned_locations() */ /** * This method clears all connections for a given terrain. This needs to * be done when a terrain was modified. * @param terrain the terrain name * @see clear_cloned_locations() */ void clear_connections(string terrain) { string line, *lines; if (file_size(RESTORE_PATH + terrain) != -2) { return; } lines = unguarded((: get_dir, RESTORE_PATH + terrain +"/*" :)) - ({ ".", ".." }); foreach(line in lines) { unguarded((: rm, RESTORE_PATH + terrain +"/"+ line :)); } } /* clear_connections() */ private int right_co_ords(int *new_co_ords, int *co_ords, int delta, int *vector) { int i; for (i = 0; i < 3; i++) { if (new_co_ords[i] + delta * vector[i] != co_ords[i]) { return 0; } } return 1; } /* right_co_ords() */ /** * This method returns the room size for a given room. It uses a cache * to speed things up. * @param file the file name of the room * @param level the recursion level * @return the size of the room */ int get_room_size(string file, int level) { int i, number, roomsize, *mapsize; string bname, parent, *lines; bname = base_name(file); /* if (size_cache[bname]) { #ifdef DEBUG_ROOM_SIZE TP(sprintf("GRS says (cached) %s is %d\n", file, size_cache[bname])); #endif return size_cache[bname]; }*/ /* if (find_object(file)) { size_cache += ([ bname : file->query_room_size() ]); #ifdef DEBUG_ROOM_SIZE TP(sprintf("GRS says (loaded) %s is %d\n", file, size_cache[bname])); #endif return size_cache[bname]; }*/ /* if (!in_map) { in_map = 1; mapsize = MAP_H->query_room_size(bname); in_map = 0; } else { #ifdef DEBUG_ROOM_SIZE TP("GRS says recursion!\n"); #endif mapsize = 0; }*/ /* if (mapsize) { size_cache += ([ bname : mapsize[0] ]); #ifdef DEBUG_ROOM_SIZE TP(sprintf("GRS says (map) %s is %d\n", file, size_cache[bname])); #endif return mapsize[0]; }*/ /* May I please throw up violently? - Turrican */ file = bname + ".c"; if (file_size(file) < 0) { return 10; } lines = explode(read_file(file), "\n"); roomsize = 10; for (i = 0; i < sizeof(lines); i++) { if (level < 4 && sscanf(lines[i], "%*sinherit%*s\"%s\"%*s;", parent) == 4) { if (parent[<2..] != ".c") { parent += ".c"; } roomsize = get_room_size(parent, level + 1); } else if (sscanf(lines[i], "%*sset_room_size(%*s%d%*s", number) == 4) { roomsize = number; break; } } //size_cache += ([ bname : roomsize ]); #ifdef DEBUG_ROOM_SIZE //TP(sprintf("GRS says (parsed) %s is %d\n", file, size_cache[bname])); #endif return roomsize; } /* get_room_size() */ private void add_exit(object place, string direc, string dest) { string type; type = (string)place->query_exit_type(direc, dest); if (!type) { type = std_types[direc]; } else { if (type == "none") { return; } } place->add_exit(direc, dest, type); } /* add_exit() */ private void calculate_exits(object place, int *co_ords) { int i, j, k, connected, delta, *new_co_ords; string actual, *exit_dirs; // connected = query_connected(terrain_name, co_ords); exit_dirs = (string *)place->query_direc(); for (i = 0; i < 20; i += 2) { if (member_array(STD_ORDERS[i], exit_dirs) != -1) { continue; } // actual = query_connection(terrain_name, co_ords, STD_ORDERS[i]); if (actual) { #ifdef DEBUG_CALC_EXITS TP(sprintf("actual room %s found\n", actual)); #endif add_exit(place, STD_ORDERS[i], actual); continue; } if (connected) { #ifdef DEBUG_CALC_EXITS TP("connected, but no actual room\n"); #endif continue; } new_co_ords = copy(co_ords); for (k = 0; k < 3; k++) { new_co_ords[k] -= place->query_room_size() * STD_ORDERS[i+1][k]; } reset_eval_cost(); for (j = 0; j < 100; j++) { for (k = 0; k < 3; k++) { new_co_ords[k] -= 5 * STD_ORDERS[i+1][k]; } /* if ((actual = member_fixed_locations(new_co_ords)) || (actual = member_cloned_locations(new_co_ords)) || (actual = top_floating_location(new_co_ords))) { delta = (int)place->query_room_size() + get_room_size(actual, 0); if (!right_co_ords(new_co_ords, co_ords, delta, STD_ORDERS[i+1])) { continue; } #ifdef DEBUG_CALC_EXITS TP(sprintf("adding connection for %s\n", actual)); #endif add_connection(terrain_name, co_ords, STD_ORDERS[i], base_name(actual)); add_exit(place, STD_ORDERS[i], actual); break; }*/ } } } /* calculate_exits() */ /** * This method is the main entry point for the terrain handler. It loads * the room that is associated with the given terrain and coordinates. * @param terrain the terrain name * @param co_ords the coordinates to look up * @return the room that was found or loaded * @see setup_location() */ object find_location(string terrain, int *co_ords) { string dest_name; object destination; if (!terrains[terrain] || (sizeof(co_ords) != 3)) { return 0; } reset_eval_cost(); if ((dest_name = member_fixed_locations(terrain,co_ords))) { if (!(destination = find_object(dest_name))) { destination = load_object(dest_name); } return destination; } if (destination = member_cloned_locations(terrain,co_ords)) { if ((destination = find_object(dest_name))) { return destination; } else { delete_cloned_location(terrain, dest_name); } } if (dest_name = top_floating_location(terrain,co_ords)) { destination = clone_object(dest_name); destination->set_co_ord(co_ords); destination->set_terrain(terrain); calculate_exits(destination, co_ords); add_cloned_location(terrain, file_name(destination), co_ords); return destination; } return 0; } /* find_location() */ /** * This method is called when a normal room is loaded which is part of * a terrain. The terrain handler needs to know about this to be able * to calculate the exits into the floating portion of the terrain. * It also sets the coordinates of the room to the values as saved in the * terrain. * @param place the room object which is a fixed location in the terrain * @param terrain the terrain name * @see find_location() */ void setup_location(object place, string terrain) { int *co_ords; get_data_file(terrain); if (!terrains[terrain]->fixed_locations[base_name(place)]) { return; } co_ords = terrains[terrain]->fixed_locations[base_name(place)]; place->set_co_ord(co_ords); calculate_exits(place, co_ords); } /* setup_location() */ /** @ignore yes */ mixed *stats() { return ::stats() + ({ ({ "terrain mapping", terrains }), }); }