[ViewVC] Diff of: cvs/deliantra/server/common/map.C

Comparing deliantra/server/common/map.C (file contents):
Revision 1.29 by root, Sun Sep 10 16:00:23 2006 UTC vs.
Revision 1.33 by root, Sun Oct 8 16:51:50 2006 UTC

-/*
- * static char *rcsid_map_c =
- *   "$Id: map.C,v 1.29 2006/09/10 16:00:23 root Exp $";
- */
 /*
     CrossFire, A Multiplayer game for X-windows
     Copyright (C) 2001-2003 Mark Wedel & Crossfire Development Team
     Copyright (C) 1992 Frank Tore Johansen
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-    The authors can be reached via e-mail at crossfire-devel@real-time.com
+    The authors can be reached via e-mail at <crossfire@schmorp.de>
 */
 #include <global.h>
 #include <funcpoint.h>
 #endif /* win32 */
 #include "path.h"
-extern int nrofallocobjects, nroffreeobjects;
 /*
- * Returns the mapstruct which has a name matching the given argument.
+ * Returns the maptile which has a name matching the given argument.
  * return NULL if no match is found.
  */
-mapstruct *
+maptile *
 has_been_loaded (const char *name)
 {
-  mapstruct *map;
+  maptile *map;
   if (!name || !*name)
     return 0;
   for (map = first_map; map; map = map->next)
     if (!strcmp (name, map->path))
  * Dumping these at llevError doesn't seem right, but is
  * necessary to make sure the information is in fact logged.
  */
 void
-dump_map (const mapstruct *m)
+dump_map (const maptile *m)
 {
   LOG (llevError, "Map %s status: %d.\n", m->path, m->in_memory);
   LOG (llevError, "Size: %dx%d Start: %d,%d\n", MAP_WIDTH (m), MAP_HEIGHT (m), MAP_ENTER_X (m), MAP_ENTER_Y (m));
   if (m->msg != NULL)
  */
 void
 dump_all_maps (void)
 {
-  mapstruct *m;
+  maptile *m;
   for (m = first_map; m != NULL; m = m->next)
     {
       dump_map (m);
     }
  * is needed.  The case of not passing values is if we're just
  * checking for the existence of something on those spaces, but
  * don't expect to insert/remove anything from those spaces.
  */
 int
-get_map_flags (mapstruct *oldmap, mapstruct **newmap, sint16 x, sint16 y, sint16 * nx, sint16 * ny)
+get_map_flags (maptile *oldmap, maptile **newmap, sint16 x, sint16 y, sint16 * nx, sint16 * ny)
 {
   sint16 newx, newy;
   int retval = 0;
-  mapstruct *mp;
+  maptile *mp;
   if (out_of_map (oldmap, x, y))
     return P_OUT_OF_MAP;
   newx = x;
   newy = y;
   retval |= mp->spaces[newx + mp->width * newy].flags;
   return retval;
 }
 /*
  * Returns true if the given coordinate is blocked except by the
  * object passed is not blocking.  This is used with
  * multipart monsters - if we want to see if a 2x2 monster
  * can move 1 space to the left, we don't want its own area
  * monster.
  * m, x, y are the target map/coordinates - needed for map tiling.
  * the coordinates & map passed in should have been updated for tiling
  * by the caller.
  */
 int
-blocked_link (object *ob, mapstruct *m, int sx, int sy)
+blocked_link (object *ob, maptile *m, int sx, int sy)
 {
   object *tmp;
   int mflags, blocked;
   /* Make sure the coordinates are valid - they should be, as caller should
  * code, we need to have actual object to check its move_type
  * against the move_block values.
  */
 int
-ob_blocked (const object *ob, mapstruct *m, sint16 x, sint16 y)
+ob_blocked (const object *ob, maptile *m, sint16 x, sint16 y)
 {
   archetype *tmp;
   int flag;
-  mapstruct *m1;
+  maptile *m1;
   sint16 sx, sy;
   if (ob == NULL)
     {
       flag = get_map_flags (m, &m1, x, y, &sx, &sy);
  * they are saved).  We do have to look for the old maps that did save
  * the more sections and not re-add sections for them.
  */
 static void
-link_multipart_objects (mapstruct *m)
+link_multipart_objects (maptile *m)
 {
   int x, y;
   object *tmp, *op, *last, *above;
   archetype *at;
  * Loads (ands parses) the objects into a given map from the specified
  * file pointer.
  * mapflags is the same as we get with load_original_map
  */
 void
-load_objects (mapstruct *m, object_thawer & fp, int mapflags)
+load_objects (maptile *m, object_thawer & fp, int mapflags)
 {
   int i, j;
   int unique;
   object *op, *prev = NULL, *last_more = NULL, *otmp;
  * Modified by MSW 2001-07-01 to do in a single pass - reduces code,
  * and we only save the head of multi part objects - this is needed
  * in order to do map tiling properly.
  */
 void
-save_objects (mapstruct *m, object_freezer & fp, object_freezer & fp2, int flag)
+save_objects (maptile *m, object_freezer & fp, object_freezer & fp2, int flag)
 {
   int i, j = 0, unique = 0;
   object *op;
   /* first pass - save one-part objects */
           }                     /* for this space */
       }                         /* for this j */
 }
 /*
- * Allocates, initialises, and returns a pointer to a mapstruct.
+ * Allocates, initialises, and returns a pointer to a maptile.
  * Modified to no longer take a path option which was not being
  * used anyways.  MSW 2001-07-01
  */
-mapstruct *
+maptile *
 get_linked_map (void)
 {
-  mapstruct *map = new mapstruct;
+  maptile *map = new maptile;
-  mapstruct *mp;
+  maptile *mp;
   for (mp = first_map; mp != NULL && mp->next != NULL; mp = mp->next);
   if (mp == NULL)
     first_map = map;
   else
   MAP_WORLDPARTY (map) = -1;
   return map;
 }
 /*
- * Allocates the arrays contained in a mapstruct.
+ * Allocates the arrays contained in a maptile.
  * This basically allocates the dynamic array of spaces for the
  * map.
  */
 void
-allocate_map (mapstruct *m)
+allocate_map (maptile *m)
 {
   m->in_memory = MAP_IN_MEMORY;
   /* Log this condition and free the storage.  We could I suppose
    * realloc, but if the caller is presuming the data will be intact,
    * that is their poor assumption.
 }
 /* Create and returns a map of the specific size.  Used
  * in random map code and the editor.
  */
-mapstruct *
+maptile *
 get_empty_map (int sizex, int sizey)
 {
-  mapstruct *m = get_linked_map ();
+  maptile *m = get_linked_map ();
   m->width = sizex;
   m->height = sizey;
   m->in_memory = MAP_SWAPPED;
   allocate_map (m);
 }
 /* opposite of parse string, this puts the string that was originally fed in to
  * the map (or something equivilent) into output_string. */
 static void
-print_shop_string (mapstruct *m, char *output_string)
+print_shop_string (maptile *m, char *output_string)
 {
   int i;
   char tmp[MAX_BUF];
   strcpy (output_string, "");
  * MSW 2001-07-01
  * return 0 on success, 1 on failure.
  */
 static int
-load_map_header (object_thawer & fp, mapstruct *m)
+load_map_header (object_thawer & fp, maptile *m)
 {
   char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key = NULL, *value, *end;
   int msgpos = 0;
   int maplorepos = 0;
 }
 /*
  * Opens the file "filename" and reads information about the map
  * from the given file, and stores it in a newly allocated
- * mapstruct.  A pointer to this structure is returned, or NULL on failure.
+ * maptile.  A pointer to this structure is returned, or NULL on failure.
  * flags correspond to those in map.h.  Main ones used are
  * MAP_PLAYER_UNIQUE, in which case we don't do any name changes, and
  * MAP_BLOCK, in which case we block on this load.  This happens in all
  *   cases, no matter if this flag is set or not.
  * MAP_STYLE: style map - don't add active objects, don't add to server
  *                managed map list.
  */
-mapstruct *
+maptile *
 load_original_map (const char *filename, int flags)
 {
-  mapstruct *m;
+  maptile *m;
   char pathname[MAX_BUF];
   if (flags & MAP_PLAYER_UNIQUE)
     strcpy (pathname, filename);
   else if (flags & MAP_OVERLAY)
  * Loads a map, which has been loaded earlier, from file.
  * Return the map object we load into (this can change from the passed
  * option if we can't find the original map)
  */
-static mapstruct *
+static maptile *
-load_temporary_map (mapstruct *m)
+load_temporary_map (maptile *m)
 {
   char buf[MAX_BUF];
   if (!m->tmpname)
     {
  * Loads a map, which has been loaded earlier, from file.
  * Return the map object we load into (this can change from the passed
  * option if we can't find the original map)
  */
-mapstruct *
+maptile *
-load_overlay_map (const char *filename, mapstruct *m)
+load_overlay_map (const char *filename, maptile *m)
 {
   char pathname[MAX_BUF];
   strcpy (pathname, create_overlay_pathname (filename));
  * This is the start of unique map handling code
  *****************************************************************************/
 /* This goes through map 'm' and removed any unique items on the map. */
 static void
-delete_unique_items (mapstruct *m)
+delete_unique_items (maptile *m)
 {
   int i, j, unique;
   object *op, *next;
   for (i = 0; i < MAP_WIDTH (m); i++)
 /*
  * Loads unique objects from file(s) into the map which is in memory
  * m is the map to load unique items into.
  */
 static void
-load_unique_objects (mapstruct *m)
+load_unique_objects (maptile *m)
 {
   int count;
   char firstname[MAX_BUF];
   for (count = 0; count < 10; count++)
 /*
  * Saves a map to file.  If flag is set, it is saved into the same
  * file it was (originally) loaded from.  Otherwise a temporary
  * filename will be genarated, and the file will be stored there.
- * The temporary filename will be stored in the mapstructure.
+ * The temporary filename will be stored in the maptileure.
  * If the map is unique, we also save to the filename in the map
  * (this should have been updated when first loaded)
  */
 int
-new_save_map (mapstruct *m, int flag)
+new_save_map (maptile *m, int flag)
 {
   char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF];
   int i;
   if (flag && !*m->path)
 /*
  * Remove and free all objects in the given map.
  */
 void
-free_all_objects (mapstruct *m)
+free_all_objects (maptile *m)
 {
   int i, j;
   object *op;
   for (i = 0; i < MAP_WIDTH (m); i++)
           }
       }
 }
 /*
- * Frees everything allocated by the given mapstructure.
+ * Frees everything allocated by the given maptileure.
  * don't free tmpname - our caller is left to do that
  */
 void
-free_map (mapstruct *m, int flag)
+free_map (maptile *m, int flag)
 {
   int i;
   if (!m->in_memory)
     {
     }
   m->in_memory = MAP_SWAPPED;
 }
 /*
- * function: vanish mapstruct
+ * function: vanish maptile
- * m       : pointer to mapstruct, if NULL no action
+ * m       : pointer to maptile, if NULL no action
  * this deletes all the data on the map (freeing pointers)
  * and then removes this map from the global linked list of maps.
  */
 void
-delete_map (mapstruct *m)
+delete_map (maptile *m)
 {
-  mapstruct *tmp, *last;
+  maptile *tmp, *last;
   int i;
   if (!m)
     return;
  *   dont do any more name translation on it.
  *
  * Returns a pointer to the given map.
  */
-mapstruct *
+maptile *
 ready_map_name (const char *name, int flags)
 {
-  mapstruct *m;
+  maptile *m;
   if (!name)
     return (NULL);
   /* Have we been at this level before? */
  * have a difficulty set than using this function - human calculation
  * is much better than this functions guesswork.
  */
 int
-calculate_difficulty (mapstruct *m)
+calculate_difficulty (maptile *m)
 {
   object *op;
   archetype *at;
   int x, y, i;
   long monster_cnt = 0;
   return 1;
 }
 void
-clean_tmp_map (mapstruct *m)
+clean_tmp_map (maptile *m)
 {
   if (m->tmpname == NULL)
     return;
   INVOKE_MAP (CLEAN, m);
   (void) unlink (m->tmpname);
  * to maps than los.
  * postive values make it darker, negative make it brighter
  */
 int
-change_map_light (mapstruct *m, int change)
+change_map_light (maptile *m, int change)
 {
   int new_level = m->darkness + change;
   /* Nothing to do */
   if (!change || (new_level <= 0 && m->darkness == 0) || (new_level >= MAX_DARKNESS && m->darkness >= MAX_DARKNESS))
  * on the map (what it looks like, whether it blocks magic,
  * has a living creatures, prevents people from passing
  * through, etc)
  */
 void
-update_position (mapstruct *m, int x, int y)
+update_position (maptile *m, int x, int y)
 {
   object *tmp, *last = NULL;
   uint8 flags = 0, oldflags, light = 0, anywhere = 0;
   New_Face *top, *floor, *middle;
   object *top_obj, *floor_obj, *middle_obj;
   SET_MAP_LIGHT (m, x, y, light);
 }
 void
-set_map_reset_time (mapstruct *map)
+set_map_reset_time (maptile *map)
 {
   int timeout;
   timeout = MAP_RESET_TIMEOUT (map);
   if (timeout <= 0)
  * maps tile_map values if it tiles back to this one.  It returns
  * the value of orig_map->tile_map[tile_num].  It really only does this
  * so that it is easier for calling functions to verify success.
  */
-static mapstruct *
+static maptile *
-load_and_link_tiled_map (mapstruct *orig_map, int tile_num)
+load_and_link_tiled_map (maptile *orig_map, int tile_num)
 {
   int dest_tile = (tile_num + 2) % 4;
   char *path = path_combine_and_normalize (orig_map->path, orig_map->tile_path[tile_num]);
   orig_map->tile_map[tile_num] = ready_map_name (path, 0);
  * tiled maps.
  *
  *
  */
 int
-out_of_map (mapstruct *m, int x, int y)
+out_of_map (maptile *m, int x, int y)
 {
   /* If we get passed a null map, this is obviously the
    * case.  This generally shouldn't happen, but if the
    * map loads fail below, it could happen.
  * the map as that the coordinates are really on, and
  * updates x and y to be the localized coordinates.
  * Using this is more efficient of calling out_of_map
  * and then figuring out what the real map is
  */
-mapstruct *
+maptile *
-get_map_from_coord (mapstruct *m, sint16 * x, sint16 * y)
+get_map_from_coord (maptile *m, sint16 * x, sint16 * y)
 {
   if (*x < 0)
     {
       if (!m->tile_path[3])
 /**
  * Return whether map2 is adjacent to map1. If so, store the distance from
  * map1 to map2 in dx/dy.
  */
 static int
-adjacent_map (const mapstruct *map1, const mapstruct *map2, int *dx, int *dy)
+adjacent_map (const maptile *map1, const maptile *map2, int *dx, int *dy)
 {
   if (!map1 || !map2)
     return 0;
   if (map1 == map2)
  * for something in the future.  Also, since no object is pasted, the best
  * field of the rv_vector is set to NULL.
  */
 void
-get_rangevector_from_mapcoord (const mapstruct *m, int x, int y, const object *op2, rv_vector * retval, int flags)
+get_rangevector_from_mapcoord (const maptile *m, int x, int y, const object *op2, rv_vector * retval, int flags)
 {
   if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y))
     {
       /* be conservative and fill in _some_ data */
       retval->distance = 100000;

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing deliantra/server/common/map.C (file contents): Revision 1.29 by root, Sun Sep 10 16:00:23 2006 UTC vs. Revision 1.33 by root, Sun Oct 8 16:51:50 2006 UTC

Diff Legend

Comparing deliantra/server/common/map.C (file contents):
Revision 1.29 by root, Sun Sep 10 16:00:23 2006 UTC vs.
Revision 1.33 by root, Sun Oct 8 16:51:50 2006 UTC