--- deliantra/server/common/object.C	2006/12/30 10:16:10	1.96
+++ deliantra/server/common/object.C	2007/01/29 21:04:32	1.127
@@ -1,25 +1,26 @@
 /*
-    CrossFire, A Multiplayer game for X-windows
-
-    Copyright (C) 2001 Mark Wedel & Crossfire Development Team
-    Copyright (C) 1992 Frank Tore Johansen
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    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@schmorp.de>
-*/
+ * CrossFire, A Multiplayer game for X-windows
+ * 
+ * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
+ * Copyright (C) 2001 Mark Wedel & Crossfire Development Team
+ * Copyright (C) 1992 Frank Tore Johansen
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * 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@schmorp.de>
+ */
 
 /* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects.
    sub/add_weight will transcend the environment updating the carrying
@@ -38,7 +39,8 @@
 static UUID uuid;
 const uint64 UUID_SKIP = 1<<19;
 
-object *active_objects;         /* List of active objects that need to be processed */
+objectvec objects;
+activevec actives;
 
 short freearr_x[SIZEOFFREE] = { 0, 0, 1, 1, 1, 0, -1, -1, -1, 0, 1, 2, 2, 2, 2, 2, 1, 0, -1, -2, -2, -2, -2, -2, -1,
   0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3, -3, -3, -3, -3, -2, -1
@@ -278,7 +280,7 @@
    * be animated or have a very low speed.  Is this an attempted monster
    * check?
    */
-  if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && FABS ((ob1)->speed) > MIN_ACTIVE_SPEED)
+  if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && ob1->has_active_speed ())
     return 0;
 
   switch (ob1->type)
@@ -392,13 +394,12 @@
 /*
  * Returns the object which has the count-variable equal to the argument.
  */
-
 object *
 find_object (tag_t i)
 {
-  for (object *op = object::first; op; op = op->next)
-    if (op->count == i)
-      return op;
+  for_all_objects (op)
+   if (op->count == i)
+     return op;
 
   return 0;
 }
@@ -408,14 +409,13 @@
  * Used only by the patch command, but not all that useful.
  * Enables features like "patch <name-of-other-player> food 999"
  */
-
 object *
 find_object_name (const char *str)
 {
   shstr_cmp str_ (str);
   object *op;
 
-  for (op = object::first; op != NULL; op = op->next)
+  for_all_objects (op)
     if (op->name == str_)
       break;
 
@@ -491,7 +491,7 @@
     SET_FLAG (dst, FLAG_REMOVED);
 
   if (speed < 0)
-    dst->speed_left = speed_left - RANDOM () % 200 / 100.0;
+    dst->speed_left = speed_left - rndm ();
 
   /* Copy over key_values, if any. */
   if (key_values)
@@ -565,45 +565,10 @@
 
   this->speed = speed;
 
-  if (FABS (speed) > MIN_ACTIVE_SPEED)
-    {
-      /* If already on active list, don't do anything */
-      if (active_next || active_prev || this == active_objects)
-        return;
-
-      /* process_events() expects us to insert the object at the beginning
-       * of the list. */
-      active_next = active_objects;
-
-      if (active_next)
-        active_next->active_prev = this;
-
-      active_objects = this;
-    }
+  if (has_active_speed ())
+    activate ();
   else
-    {
-      /* If not on the active list, nothing needs to be done */
-      if (!active_next && !active_prev && this != active_objects)
-        return;
-
-      if (!active_prev)
-        {
-          active_objects = active_next;
-
-          if (active_next)
-            active_next->active_prev = 0;
-        }
-      else
-        {
-          active_prev->active_next = active_next;
-
-          if (active_next)
-            active_next->active_prev = active_prev;
-        }
-
-      active_next = 0;
-      active_prev = 0;
-    }
+    deactivate ();
 }
 
 /*
@@ -661,7 +626,7 @@
 
   mapspace &m = op->ms ();
 
-  if (m.flags_ & P_NEED_UPDATE)
+  if (!(m.flags_ & P_UPTODATE))
     /* nop */;
   else if (action == UP_OBJ_INSERT)
     {
@@ -680,14 +645,14 @@
            */
           || ((m.move_block | op->move_block) & ~op->move_allow) != m.move_block
           || 1) // the above is not strong enough a test to skip updating. los maybe? TODO (Schmorp)
-        m.flags_ = P_NEED_UPDATE;
+        m.flags_ = 0;
     }
     /* if the object is being removed, we can't make intelligent
      * decisions, because remove_ob can't really pass the object
      * that is being removed.
      */
   else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE)
-    m.flags_ = P_NEED_UPDATE;
+    m.flags_ = 0;
   else if (action == UP_OBJ_FACE)
     /* Nothing to do for that case */ ;
   else
@@ -697,9 +662,6 @@
     update_object (op->more, action);
 }
 
-object::vector object::objects; // not yet used
-object *object::first;
-
 object::object ()
 {
   SET_FLAG (this, FLAG_REMOVED);
@@ -710,45 +672,50 @@
 
 object::~object ()
 {
+  unlink ();
+
   free_key_values (this);
 }
 
+static int object_count;
+
 void object::link ()
 {
-  count = ++ob_count;
+  assert (!index);//D
   uuid = gen_uuid ();
+  count = ++object_count;
 
-  prev = 0;
-  next = object::first;
-
-  if (object::first)
-    object::first->prev = this;
-
-  object::first = this;
+  refcnt_inc ();
+  objects.insert (this);
 }
 
 void object::unlink ()
 {
-  if (this == object::first)
-    object::first = next;
+  if (!index)
+    return;
 
-  /* Remove this object from the list of used objects */
-  if (prev) prev->next = next;
-  if (next) next->prev = prev;
+  objects.erase (this);
+  refcnt_dec ();
+}
 
-  prev = 0;
-  next = 0;
+void
+object::activate ()
+{
+  /* If already on active list, don't do anything */
+  if (active)
+    return;
+
+  if (has_active_speed ())
+    actives.insert (this);
 }
 
 void
-object::activate (bool recursive)
+object::activate_recursive ()
 {
-  // uh, hack
-  set_speed (speed);
+  activate ();
 
-  if (recursive)
-    for (object *op = inv; op; op = op->above)
-      op->activate (1);
+  for (object *op = inv; op; op = op->below)
+    op->activate_recursive ();
 }
 
 /* This function removes object 'op' from the list of active
@@ -760,31 +727,32 @@
  * will do the right thing based on the speed of the object.
  */
 void
-object::deactivate (bool recursive)
+object::deactivate ()
 {
   /* If not on the active list, nothing needs to be done */
-  if (!active_next && !active_prev && this != active_objects)
+  if (!active)
     return;
 
-  if (active_prev == 0)
-    {
-      active_objects = active_next;
-      if (active_next)
-        active_next->active_prev = 0;
-    }
-  else
-    {
-      active_prev->active_next = active_next;
-      if (active_next)
-        active_next->active_prev = active_prev;
-    }
+  actives.erase (this);
+}
+
+void
+object::deactivate_recursive ()
+{
+  for (object *op = inv; op; op = op->below)
+    op->deactivate_recursive ();
 
-  active_next = 0;
-  active_prev = 0;
+  deactivate ();
+}
 
-  if (recursive)
-    for (object *op = inv; op; op = op->above)
-      op->deactivate (1);
+void
+object::set_flag_inv (int flag, int value)
+{
+  for (object *op = inv; op; op = op->below)
+    {
+      op->flag [flag] = value;
+      op->set_flag_inv (flag, value);
+    }
 }
 
 /*
@@ -809,6 +777,7 @@
   if (!drop_to_ground
       || !map
       || map->in_memory != MAP_IN_MEMORY
+      || map->nodrop
       || ms ().move_block == MOVE_ALL)
     {
       while (inv)
@@ -827,7 +796,8 @@
               || op->flag [FLAG_NO_DROP]
               || op->type == RUNE
               || op->type == TRAP
-              || op->flag [FLAG_IS_A_TEMPLATE])
+              || op->flag [FLAG_IS_A_TEMPLATE]
+              || op->flag [FLAG_DESTROY_ON_DEATH])
             op->destroy ();
           else
             map->insert (op, x, y);
@@ -845,27 +815,32 @@
 void
 object::do_destroy ()
 {
+  attachable::do_destroy ();
+
   if (flag [FLAG_IS_LINKED])
     remove_button_link (this);
 
   if (flag [FLAG_FRIENDLY])
-    remove_friendly_object (this);
+    {
+      remove_friendly_object (this);
+
+      if (type == GOLEM
+          && owner
+          && owner->type == PLAYER
+          && owner->contr->ranges[range_golem] == this)
+        owner->contr->ranges[range_golem] = 0;
+    }
 
   if (!flag [FLAG_REMOVED])
     remove ();
 
-  if (flag [FLAG_FREED])
-    return;
+  destroy_inv (true);
 
-  set_speed (0);
+  deactivate ();
+  unlink ();
 
   flag [FLAG_FREED] = 1;
 
-  attachable::do_destroy ();
-
-  destroy_inv (true);
-  unlink ();
-
   // hack to ensure that freed objects still have a valid map
   {
     static maptile *freed_map; // freed objects are moved here to avoid crashes
@@ -879,6 +854,7 @@
         freed_map->height = 3;
 
         freed_map->alloc ();
+        freed_map->in_memory = MAP_IN_MEMORY;
       }
 
     map = freed_map;
@@ -898,9 +874,6 @@
   owner       = 0;
   enemy       = 0;
   attacked_by = 0;
-
-  // only relevant for players(?), but make sure of it anyways
-  contr       = 0;
 }
 
 void
@@ -938,10 +911,9 @@
  *   object will have no environment.  If the object previously had an
  *   environment, the x and y coordinates will be updated to
  *   the previous environment.
- *   Beware: This function is called from the editor as well!
  */
 void
-object::remove ()
+object::remove_slow ()
 {
   object *tmp, *last = 0;
   object *otmp;
@@ -995,15 +967,17 @@
       if (type == PLAYER)
         {
           --map->players;
-          map->last_access = runtime;
+          map->touch ();
         }
 
+      map->dirty = true;
+      mapspace &ms = this->ms ();
 
       /* link the object above us */
       if (above)
         above->below = below;
       else
-        map->at (x, y).top = below;       /* we were top, set new top */
+        ms.top = below;       /* we were top, set new top */
 
       /* Relink the object below us, if there is one */
       if (below)
@@ -1015,17 +989,9 @@
            * evident
            */
           if (GET_MAP_OB (map, x, y) != this)
-            {
-              char *dump = dump_object (this);
-              LOG (llevError,
-                   "remove_ob: GET_MAP_OB does not return object to be removed even though it appears to be on the bottom?\n%s\n", dump);
-              free (dump);
-              dump = dump_object (GET_MAP_OB (map, x, y));
-              LOG (llevError, "%s\n", dump);
-              free (dump);
-            }
+            LOG (llevError, "remove_ob: GET_MAP_OB does not return object to be removed even though it appears to be on the bottom? %s\n", debug_desc ());
 
-          map->at (x, y).bot = above;      /* goes on above it. */
+          ms.bot = above;      /* goes on above it. */
         }
 
       above = 0;
@@ -1036,7 +1002,7 @@
 
       int check_walk_off = !flag [FLAG_NO_APPLY];
 
-      for (tmp = map->at (x, y).bot; tmp; tmp = tmp->above)
+      for (tmp = ms.bot; tmp; tmp = tmp->above)
         {
           /* No point updating the players look faces if he is the object
            * being removed.
@@ -1080,7 +1046,7 @@
       /* last == NULL if there are no objects on this space */
       //TODO: this makes little sense, why only update the topmost object?
       if (!last)
-        map->at (x, y).flags_ = P_NEED_UPDATE;
+        map->at (x, y).flags_ = 0;
       else
         update_object (last, UP_OBJ_REMOVE);
 
@@ -1127,8 +1093,8 @@
 }
 
 /*
- * same as insert_ob_in_map except it handle separate coordinates and do a clean
- * job preparing multi-part monsters
+ * same as insert_ob_in_map except it handles separate coordinates and does a clean
+ * job preparing multi-part monsters.
  */
 object *
 insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y)
@@ -1166,7 +1132,6 @@
 insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
 {
   object *tmp, *top, *floor = NULL;
-  sint16 x, y;
 
   if (QUERY_FLAG (op, FLAG_FREED))
     {
@@ -1174,6 +1139,11 @@
       return NULL;
     }
 
+  if (!QUERY_FLAG (op, FLAG_REMOVED))
+    LOG (llevError, "Trying to insert already inserted object %s\n", op->debug_desc ());
+
+  op->remove ();
+
   if (!m)
     {
       char *dump = dump_object (op);
@@ -1197,36 +1167,9 @@
       return op;
     }
 
-  if (!QUERY_FLAG (op, FLAG_REMOVED))
-    {
-      char *dump = dump_object (op);
-      LOG (llevError, "Trying to insert (map) inserted object.\n%s\n", dump);
-      free (dump);
-      return op;
-    }
-
-  if (op->more)
+  if (object *more = op->more)
     {
-      /* The part may be on a different map. */
-
-      object *more = op->more;
-
-      /* We really need the caller to normalize coordinates - if
-       * we set the map, that doesn't work if the location is within
-       * a map and this is straddling an edge.  So only if coordinate
-       * is clear wrong do we normalize it.
-       */
-      if (OUT_OF_REAL_MAP (more->map, more->x, more->y))
-        more->map = get_map_from_coord (m, &more->x, &more->y);
-      else if (!more->map)
-        {
-          /* For backwards compatibility - when not dealing with tiled maps,
-           * more->map should always point to the parent.
-           */
-          more->map = m;
-        }
-
-      if (insert_ob_in_map (more, more->map, originator, flag) == NULL)
+      if (!insert_ob_in_map (more, m, originator, flag))
         {
           if (!op->head)
             LOG (llevError, "BUG: insert_ob_in_map(): inserting op->more killed op\n");
@@ -1241,14 +1184,16 @@
    * of areas of callers (eg, anything that uses find_free_spot would now
    * need extra work
    */
-  op->map = get_map_from_coord (m, &op->x, &op->y);
-  x = op->x;
-  y = op->y;
+  if (!xy_normalise (m, op->x, op->y))
+    return 0;
+
+  op->map = m;
+  mapspace &ms = op->ms ();
 
   /* this has to be done after we translate the coordinates.
    */
   if (op->nrof && !(flag & INS_NO_MERGE))
-    for (tmp = GET_MAP_OB (op->map, x, y); tmp; tmp = tmp->above)
+    for (tmp = ms.bot; tmp; tmp = tmp->above)
       if (object::can_merge (op, tmp))
         {
           op->nrof += tmp->nrof;
@@ -1275,15 +1220,17 @@
       if (op->below)
         op->below->above = op;
       else
-        op->ms ().bot = op;
+        ms.bot = op;
 
       /* since *below* originator, no need to update top */
       originator->below = op;
     }
   else
     {
+      top = ms.bot;
+
       /* If there are other objects, then */
-      if ((!(flag & INS_MAP_LOAD)) && ((top = GET_MAP_OB (op->map, op->x, op->y)) != NULL))
+      if ((!(flag & INS_MAP_LOAD)) && top)
         {
           object *last = 0;
 
@@ -1299,7 +1246,7 @@
            * when lots of spells are cast in one area.  Currently, it is presumed
            * that flying non pickable objects are spell objects.
            */
-          while (top)
+          for (top = ms.bot; top; top = top->above)
             {
               if (QUERY_FLAG (top, FLAG_IS_FLOOR) || QUERY_FLAG (top, FLAG_OVERLAY_FLOOR))
                 floor = top;
@@ -1312,7 +1259,6 @@
                 }
 
               last = top;
-              top = top->above;
             }
 
           /* Don't want top to be NULL, so set it to the last valid object */
@@ -1329,12 +1275,14 @@
            * Need to find the object that in fact blocks view, otherwise
            * stacking is a bit odd.
            */
-          if (!(flag & INS_ON_TOP) &&
-              (get_map_flags (op->map, 0, op->x, op->y, 0, 0) & P_BLOCKSVIEW) && (op->face && !op->face->visibility))
+          if (!(flag & INS_ON_TOP)
+              && ms.flags () & P_BLOCKSVIEW
+              && (op->face && !op->face->visibility))
             {
               for (last = top; last != floor; last = last->below)
                 if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT))
                   break;
+
               /* Check to see if we found the object that blocks view,
                * and make sure we have a below pointer for it so that
                * we can get inserted below this one, which requires we
@@ -1346,7 +1294,7 @@
         }                       /* If objects on this space */
 
       if (flag & INS_MAP_LOAD)
-        top = GET_MAP_TOP (op->map, op->x, op->y);
+        top = ms.top;
 
       if (flag & INS_ABOVE_FLOOR_ONLY)
         top = floor;
@@ -1357,13 +1305,13 @@
       /* First object on this space */
       if (!top)
         {
-          op->above = GET_MAP_OB (op->map, op->x, op->y);
+          op->above = ms.bot;
 
           if (op->above)
             op->above->below = op;
 
           op->below = 0;
-          op->ms ().bot = op;
+          ms.bot = op;
         }
       else
         {                       /* get inserted into the stack above top */
@@ -1377,21 +1325,23 @@
         }
 
       if (!op->above)
-        op->ms ().top = op;
+        ms.top = op;
     }                           /* else not INS_BELOW_ORIGINATOR */
 
   if (op->type == PLAYER)
     {
       op->contr->do_los = 1;
       ++op->map->players;
-      op->map->last_access = runtime;
+      op->map->touch ();
     }
 
+  op->map->dirty = true;
+
   /* If we have a floor, we know the player, if any, will be above
    * it, so save a few ticks and start from there.
    */
   if (!(flag & INS_MAP_LOAD))
-    if (object *pl = op->ms ().player ())
+    if (object *pl = ms.player ())
       if (pl->contr->ns)
         pl->contr->ns->floorbox_update ();
 
@@ -1401,7 +1351,7 @@
    * on the map will get recalculated.  The players could very well
    * be far away from this change and not affected in any way -
    * this should get redone to only look for players within range,
-   * or just updating the P_NEED_UPDATE for spaces within this area
+   * or just updating the P_UPTODATE for spaces within this area
    * of effect may be sufficient.
    */
   if (op->map->darkness && (op->glow_radius != 0))
@@ -1449,7 +1399,7 @@
 
   /* first search for itself and remove any old instances */
 
-  for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
+  for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
     if (!strcmp (tmp->arch->name, arch_string))       /* same archetype */
       tmp->destroy ();
 
@@ -1782,7 +1732,7 @@
    * Hence, we first go to the top: 
    */
 
-  for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp && tmp->above; tmp = tmp->above)
+  for (tmp = op->ms ().bot; tmp && tmp->above; tmp = tmp->above)
     {
       /* Trim the search when we find the first other spell effect 
        * this helps performance so that if a space has 50 spell objects,
@@ -1810,7 +1760,7 @@
             {
 
               float
-                diff = tmp->move_slow_penalty * FABS (op->speed);
+                diff = tmp->move_slow_penalty * fabs (op->speed);
 
               if (op->type == PLAYER)
                 if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) ||
@@ -1850,13 +1800,13 @@
 object *
 present_arch (const archetype *at, maptile *m, int x, int y)
 {
-  if (m == NULL || out_of_map (m, x, y))
+  if (!m || out_of_map (m, x, y))
     {
       LOG (llevError, "Present_arch called outside map.\n");
       return NULL;
     }
 
-  for (object *tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
+  for (object *tmp = m->at (x, y).bot; tmp; tmp = tmp->above)
     if (tmp->arch == at)
       return tmp;
 
@@ -1877,7 +1827,7 @@
       return NULL;
     }
 
-  for (object *tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
+  for (object *tmp = m->at (x, y).bot; tmp; tmp = tmp->above)
     if (tmp->type == type)
       return tmp;
 
@@ -2027,7 +1977,7 @@
   if (!index)
     return -1;
 
-  return altern[RANDOM () % index];
+  return altern [rndm (index)];
 }
 
 /*
@@ -2058,7 +2008,7 @@
   end -= begin;
 
   while (--end)
-    swap (arr [end], arr [RANDOM () % (end + 1)]);
+    swap (arr [end], arr [rndm (end + 1)]);
 }
 
 /* new function to make monster searching more efficient, and effective! 
@@ -2202,28 +2152,9 @@
 }
 
 /*
- * absdir(int): Returns a number between 1 and 8, which represent
- * the "absolute" direction of a number (it actually takes care of
- * "overflow" in previous calculations of a direction).
- */
-
-int
-absdir (int d)
-{
-  while (d < 1)
-    d += 8;
-
-  while (d > 8)
-    d -= 8;
-
-  return d;
-}
-
-/*
  * dirdiff(dir1, dir2) returns how many 45-degrees differences there is
  * between two directions (which are expected to be absolute (see absdir())
  */
-
 int
 dirdiff (int dir1, int dir2)
 {
@@ -2612,18 +2543,49 @@
     item = item->env;
 }
 
-// return a suitable string describing an objetc in enough detail to find it
+
+const char *
+object::flag_desc (char *desc, int len) const
+{
+  char *p = desc;
+  bool first = true;
+
+  *p = 0;
+
+  for (int i = 0; i < NUM_FLAGS; i++)
+    {
+      if (len <= 10) // magic constant!
+        {
+          snprintf (p, len, ",...");
+          break;
+        }
+
+      if (flag [i])
+        {
+          int cnt = snprintf (p, len, "%s%d", first ? "" : ",", i);
+          len -= cnt;
+          p += cnt;
+          first = false;
+        }
+    }
+
+  return desc;
+}
+
+// return a suitable string describing an object in enough detail to find it
 const char *
 object::debug_desc (char *info) const
 {
-  char info2[256 * 3];
+  char flagdesc[512];
+  char info2[256 * 4];
   char *p = info;
 
-  p += snprintf (p, 256, "%d=\"%s%s%s\"",
-                 count,
+  p += snprintf (p, 512, "{cnt:%d,uuid:<1.%" PRIx64 ">,name:\"%s\"%s%s,flags:[%s],type:%d}",
+                 count, uuid.seq,
                  &name,
-                 title ? " " : "",
-                 title ? (const char *)title : "");
+                 title ? "\",title:\"" : "",
+                 title ? (const char *)title : "",
+                 flag_desc (flagdesc, 512), type);
 
   if (env)
     p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
@@ -2637,7 +2599,21 @@
 const char *
 object::debug_desc () const
 {
-  static char info[256 * 3];
+  static char info[256 * 4];
   return debug_desc (info);
 }
 
+const char *
+object::debug_desc2 () const
+{
+  static char info[256 * 4];
+  return debug_desc (info);
+}
+
+struct region *
+object::region () const
+{
+  return map ? map->region (x, y)
+             : region::default_region ();
+}
+