--- deliantra/server/common/object.C	2006/12/26 08:17:58	1.86
+++ deliantra/server/common/object.C	2007/01/21 21:28:27	1.120
@@ -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
@@ -192,7 +194,6 @@
  * Improvements made with merge:  Better checking on potion, and also
  * check weight
  */
-
 bool object::can_merge_slow (object *ob1, object *ob2)
 {
   /* A couple quicksanity checks */
@@ -279,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)
@@ -393,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;
 }
@@ -409,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;
 
@@ -492,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)
@@ -524,7 +523,7 @@
         }
     }
 
-  update_ob_speed (dst);
+  dst->set_speed (dst->speed);
 }
 
 object *
@@ -540,12 +539,12 @@
  * to the closest player being on the other side, this function can
  * be called to update the face variable, _and_ how it looks on the map.
  */
-
 void
 update_turn_face (object *op)
 {
-  if (!QUERY_FLAG (op, FLAG_IS_TURNABLE) || op->arch == NULL)
+  if (!QUERY_FLAG (op, FLAG_IS_TURNABLE) || !op->arch)
     return;
+
   SET_ANIMATION (op, op->direction);
   update_object (op, UP_OBJ_FACE);
 }
@@ -556,92 +555,20 @@
  * This function needs to be called whenever the speed of an object changes.
  */
 void
-update_ob_speed (object *op)
+object::set_speed (float speed)
 {
-  extern int arch_init;
-
-  /* No reason putting the archetypes objects on the speed list,
-   * since they never really need to be updated.
-   */
-  if (QUERY_FLAG (op, FLAG_FREED) && op->speed)
+  if (flag [FLAG_FREED] && speed)
     {
-      LOG (llevError, "Object %s is freed but has speed.\n", &op->name);
-      op->speed = 0;
-    }
-
-  if (arch_init)
-    return;
-
-  if (FABS (op->speed) > MIN_ACTIVE_SPEED)
-    {
-      /* If already on active list, don't do anything */
-      if (op->active_next || op->active_prev || op == active_objects)
-        return;
-
-      /* process_events() expects us to insert the object at the beginning
-       * of the list. */
-      op->active_next = active_objects;
-
-      if (op->active_next != NULL)
-        op->active_next->active_prev = op;
-
-      active_objects = op;
-    }
-  else
-    {
-      /* If not on the active list, nothing needs to be done */
-      if (!op->active_next && !op->active_prev && op != active_objects)
-        return;
-
-      if (op->active_prev == NULL)
-        {
-          active_objects = op->active_next;
-
-          if (op->active_next != NULL)
-            op->active_next->active_prev = NULL;
-        }
-      else
-        {
-          op->active_prev->active_next = op->active_next;
-
-          if (op->active_next)
-            op->active_next->active_prev = op->active_prev;
-        }
-
-      op->active_next = NULL;
-      op->active_prev = NULL;
+      LOG (llevError, "Object %s is freed but has speed.\n", &name);
+      speed = 0;
     }
-}
 
-/* This function removes object 'op' from the list of active
- * objects.
- * This should only be used for style maps or other such 
- * reference maps where you don't want an object that isn't
- * in play chewing up cpu time getting processed.
- * The reverse of this is to call update_ob_speed, which
- * will do the right thing based on the speed of the object.
- */
-void
-remove_from_active_list (object *op)
-{
-  /* If not on the active list, nothing needs to be done */
-  if (!op->active_next && !op->active_prev && op != active_objects)
-    return;
+  this->speed = speed;
 
-  if (op->active_prev == NULL)
-    {
-      active_objects = op->active_next;
-      if (op->active_next != NULL)
-        op->active_next->active_prev = NULL;
-    }
+  if (has_active_speed ())
+    activate ();
   else
-    {
-      op->active_prev->active_next = op->active_next;
-      if (op->active_next)
-        op->active_next->active_prev = op->active_prev;
-    }
-  op->active_next = NULL;
-  op->active_prev = NULL;
+    deactivate ();
 }
 
 /*
@@ -699,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)
     {
@@ -718,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
@@ -735,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);
@@ -748,109 +672,86 @@
 
 object::~object ()
 {
+  if (index)
+    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;
+  assert (index);//D
+  objects.erase (this);
+  refcnt_dec ();
+}
 
-  /* Remove this object from the list of used objects */
-  if (prev) prev->next = next;
-  if (next) next->prev = prev;
+void
+object::activate ()
+{
+  /* If already on active list, don't do anything */
+  if (active)
+    return;
 
-  prev = 0;
-  next = 0;
+  if (has_active_speed ())
+    actives.insert (this);
 }
 
-object *object::create ()
+void
+object::activate_recursive ()
 {
-  object *op = new object;
-  op->link ();
-  return op;
+  activate ();
+
+  for (object *op = inv; op; op = op->below)
+    op->activate_recursive ();
 }
 
-/*
- * free_object() frees everything allocated by an object, removes
- * it from the list of used objects, and puts it on the list of
- * free objects.  The IS_FREED() flag is set in the object.
- * The object must have been removed by remove_ob() first for
- * this function to succeed.
- *
- * If destroy_inventory is set, free inventory as well. Else drop items in
- * inventory to the ground.
+/* This function removes object 'op' from the list of active
+ * objects.
+ * This should only be used for style maps or other such 
+ * reference maps where you don't want an object that isn't
+ * in play chewing up cpu time getting processed.
+ * The reverse of this is to call update_ob_speed, which
+ * will do the right thing based on the speed of the object.
  */
 void
-object::do_destroy ()
+object::deactivate ()
 {
-  attachable::do_destroy ();
-
-  if (flag [FLAG_IS_LINKED])
-    remove_button_link (this);
-
-  if (flag [FLAG_FRIENDLY])
-    remove_friendly_object (this);
-
-  if (!flag [FLAG_REMOVED])
-    remove ();
-
-  if (flag [FLAG_FREED])
+  /* If not on the active list, nothing needs to be done */
+  if (!active)
     return;
 
-  flag [FLAG_FREED] = 1;
-
-  // hack to ensure that freed objects still have a valid map
-  {
-    static maptile *freed_map; // freed objects are moved here to avoid crashes
-
-    if (!freed_map)
-      {
-        freed_map = new maptile;
-
-        freed_map->name   = "/internal/freed_objects_map";
-        freed_map->width  = 3;
-        freed_map->height = 3;
-
-        freed_map->allocate ();
-      }
-
-    map = freed_map;
-    x = 1;
-    y = 1;
-  }
-
-  more = 0;
-  head = 0;
-  inv  = 0;
-
-  // clear those pointers that likely might have circular references to us
-  owner       = 0;
-  enemy       = 0;
-  attacked_by = 0;
+  actives.erase (this);
+}
 
-  // only relevant for players(?), but make sure of it anyways
-  contr       = 0;
+void
+object::deactivate_recursive ()
+{
+  for (object *op = inv; op; op = op->below)
+    op->deactivate_recursive ();
 
-  /* Remove object from the active list */
-  speed = 0;
-  update_ob_speed (this);
+  deactivate ();
+}
 
-  unlink ();
+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);
+    }
 }
 
 /*
@@ -860,6 +761,11 @@
 void
 object::destroy_inv (bool drop_to_ground)
 {
+  // need to check first, because the checks below might segfault
+  // as we might be on an invalid mapspace and crossfire code
+  // is too buggy to ensure that the inventory is empty.
+  // corollary: if you create arrows etc. with stuff in tis inventory,
+  // cf will crash below with off-map x and y
   if (!inv)
     return;
 
@@ -867,7 +773,10 @@
    * if some form of movement is allowed, let objects
    * drop on that space.
    */
-  if (!drop_to_ground || !map || map->in_memory != MAP_IN_MEMORY || GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL)
+  if (!drop_to_ground
+      || !map
+      || map->in_memory != MAP_IN_MEMORY
+      || ms ().move_block == MOVE_ALL)
     {
       while (inv)
         {
@@ -885,34 +794,86 @@
               || 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
-            {
-              op->remove ();
-              op->x = x;
-              op->y = y;
-              insert_ob_in_map (op, map, 0, 0);     /* Insert in same map as the envir */
-            }
+            map->insert (op, x, y);
         }
     }
 }
 
+object *object::create ()
+{
+  object *op = new object;
+  op->link ();
+  return op;
+}
+
 void
-object::destroy (bool destroy_inventory)
+object::do_destroy ()
 {
-  if (destroyed ())
-    return;
+  attachable::do_destroy ();
+
+  if (flag [FLAG_IS_LINKED])
+    remove_button_link (this);
+
+  if (flag [FLAG_FRIENDLY])
+    remove_friendly_object (this);
+
+  if (!flag [FLAG_REMOVED])
+    remove ();
+
+  destroy_inv (true);
+
+  deactivate ();
+  unlink ();
+
+  flag [FLAG_FREED] = 1;
+
+  // hack to ensure that freed objects still have a valid map
+  {
+    static maptile *freed_map; // freed objects are moved here to avoid crashes
+
+    if (!freed_map)
+      {
+        freed_map = new maptile;
+
+        freed_map->name   = "/internal/freed_objects_map";
+        freed_map->width  = 3;
+        freed_map->height = 3;
+
+        freed_map->alloc ();
+        freed_map->in_memory = MAP_IN_MEMORY;
+      }
+
+    map = freed_map;
+    x = 1;
+    y = 1;
+  }
+
+  head = 0;
 
   if (more)
     {
-      //TODO: non-head objects must not have inventory
-      more->destroy (destroy_inventory);
+      more->destroy ();
       more = 0;
     }
 
+  // clear those pointers that likely might have circular references to us
+  owner       = 0;
+  enemy       = 0;
+  attacked_by = 0;
+}
+
+void
+object::destroy (bool destroy_inventory)
+{
+  if (destroyed ())
+    return;
+
   if (destroy_inventory)
-    destroy_inv (true);
+    destroy_inv (false);
 
   attachable::destroy ();
 }
@@ -943,7 +904,7 @@
  *   Beware: This function is called from the editor as well!
  */
 void
-object::remove ()
+object::remove_slow ()
 {
   object *tmp, *last = 0;
   object *otmp;
@@ -975,12 +936,12 @@
       if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
         otmp->update_stats ();
 
-      if (above != NULL)
+      if (above)
         above->below = below;
       else
         env->inv = below;
 
-      if (below != NULL)
+      if (below)
         below->above = above;
 
       /* we set up values so that it could be inserted into
@@ -994,15 +955,20 @@
     }
   else if (map)
     {
-      /* Re did the following section of code - it looks like it had
-       * lots of logic for things we no longer care about
-       */
+      if (type == PLAYER)
+        {
+          --map->players;
+          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)
@@ -1014,17 +980,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;
@@ -1035,7 +993,7 @@
 
       int check_walk_off = !flag [FLAG_NO_APPLY];
 
-      for (tmp = GET_MAP_OB (map, x, y); 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.
@@ -1057,7 +1015,7 @@
                 tmp->contr->ns->floorbox_update ();
             }
 
-          /* See if player moving off should effect something */
+          /* See if object moving off should effect something */
           if (check_walk_off
               && ((move_type & tmp->move_off)
                   && (move_type & ~tmp->move_off & ~tmp->move_block) == 0))
@@ -1069,16 +1027,17 @@
             }
 
           /* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */
-
+          //TODO: why is this horrible hacka fix? get rid of this code=bug! (schmorp)
           if (tmp->above == tmp)
             tmp->above = 0;
 
           last = tmp;
         }
 
-      /* last == NULL of there are no objects on this space */
+      /* 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);
 
@@ -1125,18 +1084,13 @@
 }
 
 /*
- * 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)
 {
-  object *tmp;
-
-  if (op->head)
-    op = op->head;
-
-  for (tmp = op; tmp; tmp = tmp->more)
+  for (object *tmp = op->head_ (); tmp; tmp = tmp->more)
     {
       tmp->x = x + tmp->arch->clone.x;
       tmp->y = y + tmp->arch->clone.y;
@@ -1169,7 +1123,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))
     {
@@ -1177,7 +1130,12 @@
       return NULL;
     }
 
-  if (m == 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);
       LOG (llevError, "Trying to insert in null-map!\n%s\n", dump);
@@ -1200,36 +1158,9 @@
       return op;
     }
 
-  if (!QUERY_FLAG (op, FLAG_REMOVED))
+  if (object *more = op->more)
     {
-      char *dump = dump_object (op);
-      LOG (llevError, "Trying to insert (map) inserted object.\n%s\n", dump);
-      free (dump);
-      return op;
-    }
-
-  if (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");
@@ -1244,14 +1175,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 != NULL; tmp = tmp->above)
+    for (tmp = ms.bot; tmp; tmp = tmp->above)
       if (object::can_merge (op, tmp))
         {
           op->nrof += tmp->nrof;
@@ -1278,17 +1211,19 @@
       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 = NULL;
+          object *last = 0;
 
           /*
            * If there are multiple objects on this space, we do some trickier handling.
@@ -1302,8 +1237,7 @@
            * when lots of spells are cast in one area.  Currently, it is presumed
            * that flying non pickable objects are spell objects.
            */
-
-          while (top != NULL)
+          for (top = ms.bot; top; top = top->above)
             {
               if (QUERY_FLAG (top, FLAG_IS_FLOOR) || QUERY_FLAG (top, FLAG_OVERLAY_FLOOR))
                 floor = top;
@@ -1316,7 +1250,6 @@
                 }
 
               last = top;
-              top = top->above;
             }
 
           /* Don't want top to be NULL, so set it to the last valid object */
@@ -1333,12 +1266,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
@@ -1350,7 +1285,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;
@@ -1361,13 +1296,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 = NULL;
-          op->ms ().bot = op;
+          op->below = 0;
+          ms.bot = op;
         }
       else
         {                       /* get inserted into the stack above top */
@@ -1380,18 +1315,24 @@
           top->above = op;
         }
 
-      if (op->above == NULL)
-        op->ms ().top = op;
+      if (!op->above)
+        ms.top = op;
     }                           /* else not INS_BELOW_ORIGINATOR */
 
   if (op->type == PLAYER)
-    op->contr->do_los = 1;
+    {
+      op->contr->do_los = 1;
+      ++op->map->players;
+      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 +1342,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 +1390,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 ();
 
@@ -1460,6 +1401,12 @@
   insert_ob_in_map (tmp1, op->map, op, 0);
 }
 
+object *
+object::insert_at (object *where, object *originator, int flags)
+{
+  where->map->insert (this, where->x, where->y, originator, flags);
+}
+
 /*
  * get_split_ob(ob,nr) splits up ob into two parts.  The part which
  * is returned contains nr objects, and the remaining parts contains
@@ -1467,7 +1414,6 @@
  * On failure, NULL is returned, and the reason put into the
  * global static errmsg array.
  */
-
 object *
 get_split_ob (object *orig_ob, uint32 nr)
 {
@@ -1741,7 +1687,6 @@
  * object being inserted.  insert_ob_in_map may not put new objects
  * on top.
  */
-
 int
 check_move_on (object *op, object *originator)
 {
@@ -1778,7 +1723,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,
@@ -1806,7 +1751,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)) ||
@@ -1846,13 +1791,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;
 
@@ -1873,7 +1818,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;
 
@@ -2198,28 +2143,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)
 {
@@ -2608,24 +2534,55 @@
     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));
 
   if (map)
-    p += snprintf (p, 256, "(on %s@%d+%d)", map->path, x, y);
+    p += snprintf (p, 256, "(on %s@%d+%d)", &map->path, x, y);
 
   return info;
 }
@@ -2633,7 +2590,14 @@
 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);
 }