--- deliantra/server/common/object.C	2006/12/18 02:35:00	1.68
+++ deliantra/server/common/object.C	2006/12/26 20:04:09	1.93
@@ -143,7 +143,7 @@
    */
 
   /* For each field in wants, */
-  for (wants_field = wants->key_values; wants_field != NULL; wants_field = wants_field->next)
+  for (wants_field = wants->key_values; wants_field; wants_field = wants_field->next)
     {
       key_value *has_field;
 
@@ -223,8 +223,7 @@
   if (QUERY_FLAG (ob2, FLAG_IDENTIFIED))
     SET_FLAG (ob2, FLAG_BEEN_APPLIED);
 
-
-  if ((ob1->flags ^ ob2->flags).reset (FLAG_INV_LOCKED).reset (FLAG_CLIENT_SENT).any ()
+  if ((ob1->flag ^ ob2->flag).reset (FLAG_INV_LOCKED).reset (FLAG_CLIENT_SENT).any ()
       || ob1->arch         != ob2->arch
       || ob1->name         != ob2->name
       || ob1->title        != ob2->title
@@ -355,21 +354,6 @@
 }
 
 /*
- * Eneq(@csd.uu.se): Since we can have items buried in a character we need
- * a better check.  We basically keeping traversing up until we can't
- * or find a player.
- */
-
-object *
-is_player_inv (object *op)
-{
-  for (; op != NULL && op->type != PLAYER; op = op->env)
-    if (op->env == op)
-      op->env = NULL;
-  return op;
-}
-
-/*
  * Used by: Crossedit: dump. Server DM commands: dumpbelow, dump.
  *      Some error messages.
  * The result of the dump is stored in the static global errmsg array.
@@ -382,7 +366,7 @@
     return strdup ("[NULLOBJ]");
 
   object_freezer freezer;
-  save_object (freezer, op, 3);
+  save_object (freezer, op, 1);
   return freezer.as_string ();
 }
 
@@ -485,48 +469,6 @@
   op->key_values = 0;
 }
 
-void object::clear ()
-{
-  attachable_base::clear ();
-
-  free_key_values (this);
-
-  owner = 0;
-  name = 0;
-  name_pl = 0;
-  title = 0;
-  race = 0;
-  slaying = 0;
-  skill = 0;
-  msg = 0;
-  lore = 0;
-  custom_name = 0;
-  materialname = 0;
-  contr = 0;
-  below = 0;
-  above = 0;
-  inv = 0;
-  container = 0;
-  env = 0;
-  more = 0;
-  head = 0;
-  map = 0;
-  active_next = 0;
-  active_prev = 0;
-
-  memset (static_cast<object_pod *>(this), 0, sizeof (object_pod));
-
-  SET_FLAG (this, FLAG_REMOVED);
-
-  /* What is not cleared is next, prev, and count */
-
-  expmul = 1.0;
-  face = blank_face;
-
-  if (settings.casting_time)
-    casting_time = -1;
-}
-
 /*
  * copy_to first frees everything allocated by the dst object,
  * and then copies the contents of itself into the second
@@ -542,10 +484,6 @@
   bool is_removed = QUERY_FLAG (dst, FLAG_REMOVED);
 
   *(object_copy *)dst = *this;
-  *(object_pod  *)dst = *this;
-
-  if (self || cb)
-    INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
 
   if (is_freed)
     SET_FLAG (dst, FLAG_FREED);
@@ -586,7 +524,7 @@
         }
     }
 
-  update_ob_speed (dst);
+  dst->set_speed (dst->speed);
 }
 
 object *
@@ -618,65 +556,62 @@
  * 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);
-#ifdef MANY_CORES
-      abort ();
-#else
-      op->speed = 0;
-#endif
+      LOG (llevError, "Object %s is freed but has speed.\n", &name);
+      speed = 0;
     }
 
+  this->speed = speed;
+
   if (arch_init)
     return;
 
-  if (FABS (op->speed) > MIN_ACTIVE_SPEED)
+  if (FABS (speed) > MIN_ACTIVE_SPEED)
     {
       /* If already on active list, don't do anything */
-      if (op->active_next || op->active_prev || op == active_objects)
+      if (active_next || active_prev || this == active_objects)
         return;
 
       /* process_events() expects us to insert the object at the beginning
        * of the list. */
-      op->active_next = active_objects;
+      active_next = active_objects;
 
-      if (op->active_next != NULL)
-        op->active_next->active_prev = op;
+      if (active_next)
+        active_next->active_prev = this;
 
-      active_objects = op;
+      active_objects = this;
     }
   else
     {
       /* If not on the active list, nothing needs to be done */
-      if (!op->active_next && !op->active_prev && op != active_objects)
+      if (!active_next && !active_prev && this != active_objects)
         return;
 
-      if (op->active_prev == NULL)
+      if (!active_prev)
         {
-          active_objects = op->active_next;
+          active_objects = active_next;
 
-          if (op->active_next != NULL)
-            op->active_next->active_prev = NULL;
+          if (active_next)
+            active_next->active_prev = 0;
         }
       else
         {
-          op->active_prev->active_next = op->active_next;
+          active_prev->active_next = active_next;
 
-          if (op->active_next)
-            op->active_next->active_prev = op->active_prev;
+          if (active_next)
+            active_next->active_prev = active_prev;
         }
 
-      op->active_next = NULL;
-      op->active_prev = NULL;
+      active_next = 0;
+      active_prev = 0;
     }
 }
 
@@ -712,7 +647,7 @@
 }
 
 /*
- * update_object() updates the array which represents the map.
+ * update_object() updates the the map.
  * It takes into account invisible objects (and represent squares covered
  * by invisible objects by whatever is below them (unless it's another
  * invisible object, etc...)
@@ -721,10 +656,6 @@
  * updating that window, though, since update_object() is called _often_)
  *
  * action is a hint of what the caller believes need to be done.
- * For example, if the only thing that has changed is the face (due to
- * an animation), we don't need to call update_position until that actually
- * comes into view of a player.  OTOH, many other things, like addition/removal
- * of walls or living creatures may need us to update the flags now.
  * current action are:
  * UP_OBJ_INSERT: op was inserted
  * UP_OBJ_REMOVE: op was removed
@@ -732,11 +663,9 @@
  *  as that is easier than trying to look at what may have changed.
  * UP_OBJ_FACE: only the objects face has changed.
  */
-
 void
 update_object (object *op, int action)
 {
-  int update_now = 0, flags;
   MoveType move_on, move_off, move_block, move_slow;
 
   if (op == NULL)
@@ -746,7 +675,7 @@
       return;
     }
 
-  if (op->env != NULL)
+  if (op->env)
     {
       /* Animation is currently handled by client, so nothing
        * to do in this case.
@@ -761,7 +690,7 @@
     return;
 
   /* make sure the object is within map boundaries */
-  if (op->x < 0 || op->x >= MAP_WIDTH (op->map) || op->y < 0 || op->y >= MAP_HEIGHT (op->map))
+  if (op->x < 0 || op->x >= op->map->width || op->y < 0 || op->y >= op->map->height)
     {
       LOG (llevError, "update_object() called for object out of map!\n");
 #ifdef MANY_CORES
@@ -770,83 +699,47 @@
       return;
     }
 
-  flags = GET_MAP_FLAGS (op->map, op->x, op->y);
-  SET_MAP_FLAGS (op->map, op->x, op->y, flags | P_NEED_UPDATE);
-  move_slow = GET_MAP_MOVE_SLOW (op->map, op->x, op->y);
-  move_on = GET_MAP_MOVE_ON (op->map, op->x, op->y);
-  move_block = GET_MAP_MOVE_BLOCK (op->map, op->x, op->y);
-  move_off = GET_MAP_MOVE_OFF (op->map, op->x, op->y);
-
-  if (action == UP_OBJ_INSERT)
-    {
-      if (QUERY_FLAG (op, FLAG_BLOCKSVIEW) && !(flags & P_BLOCKSVIEW))
-        update_now = 1;
-
-      if (QUERY_FLAG (op, FLAG_NO_MAGIC) && !(flags & P_NO_MAGIC))
-        update_now = 1;
-
-      if (QUERY_FLAG (op, FLAG_DAMNED) && !(flags & P_NO_CLERIC))
-        update_now = 1;
-
-      if (QUERY_FLAG (op, FLAG_ALIVE) && !(flags & P_IS_ALIVE))
-        update_now = 1;
-
-      if (op->type == SAFE_GROUND && !(flags & P_SAFE))
-        update_now = 1;
-
-      if ((move_on | op->move_on) != move_on)
-        update_now = 1;
-
-      if ((move_off | op->move_off) != move_off)
-        update_now = 1;
-
-      /* This isn't perfect, but I don't expect a lot of objects to
-       * to have move_allow right now.    
-       */
-      if (((move_block | op->move_block) & ~op->move_allow) != move_block)
-        update_now = 1;
+  mapspace &m = op->ms ();
 
-      if ((move_slow | op->move_slow) != move_slow)
-        update_now = 1;
-    }
-
-  /* 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.
-   */
+  if (m.flags_ & P_NEED_UPDATE)
+    /* nop */;
+  else if (action == UP_OBJ_INSERT)
+    {
+      // this is likely overkill, TODO: revisit (schmorp)
+      if ((QUERY_FLAG (op, FLAG_BLOCKSVIEW)  && !(m.flags_ & P_BLOCKSVIEW))
+          || (QUERY_FLAG (op, FLAG_NO_MAGIC) && !(m.flags_ & P_NO_MAGIC))
+          || (op->type == PLAYER             && !(m.flags_ & P_PLAYER))
+          || (op->type == SAFE_GROUND        && !(m.flags_ & P_SAFE))
+          || (QUERY_FLAG (op, FLAG_ALIVE)    && !(m.flags_ & P_IS_ALIVE))
+          || (QUERY_FLAG (op, FLAG_DAMNED)   && !(m.flags_ & P_NO_CLERIC))
+          || (m.move_on   | op->move_on  ) != m.move_on
+          || (m.move_off  | op->move_off ) != m.move_off
+          || (m.move_slow | op->move_slow) != m.move_slow
+          /* This isn't perfect, but I don't expect a lot of objects to
+           * to have move_allow right now.    
+           */
+          || ((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;
+    }
+    /* 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)
-    update_now = 1;
+    m.flags_ = P_NEED_UPDATE;
   else if (action == UP_OBJ_FACE)
     /* Nothing to do for that case */ ;
   else
     LOG (llevError, "update_object called with invalid action: %d\n", action);
 
-  if (update_now)
-    {
-      SET_MAP_FLAGS (op->map, op->x, op->y, flags | P_NO_ERROR | P_NEED_UPDATE);
-      update_position (op->map, op->x, op->y);
-    }
-
-  if (op->more != NULL)
+  if (op->more)
     update_object (op->more, action);
 }
 
-object::vector object::mortals;
 object::vector object::objects; // not yet used
 object *object::first;
 
-void object::free_mortals ()
-{
-  for (AUTODECL (i, mortals.begin ()); i != mortals.end ();)
-    if ((*i)->refcnt)
-      ++i; // further delay freeing
-    else
-      {
-        delete *i;
-        mortals.erase (i);
-      }
-}
-
 object::object ()
 {
   SET_FLAG (this, FLAG_REMOVED);
@@ -887,6 +780,46 @@
   next = 0;
 }
 
+/*
+ * Remove and free all objects in the inventory of the given object.
+ * object.c ?
+ */
+void
+object::destroy_inv (bool drop_to_ground)
+{
+  /* Only if the space blocks everything do we not process -
+   * if some form of movement is allowed, let objects
+   * drop on that space.
+   */
+  if (!drop_to_ground
+      || !map
+      || map->in_memory != MAP_IN_MEMORY
+      || map->at (x, y).move_block == MOVE_ALL)
+    {
+      while (inv)
+        {
+          inv->destroy_inv (drop_to_ground);
+          inv->destroy ();
+        }
+    }
+  else
+    {                       /* Put objects in inventory onto this space */
+      while (inv)
+        {
+          object *op = inv;
+
+          if (op->flag [FLAG_STARTEQUIP]
+              || op->flag [FLAG_NO_DROP]
+              || op->type == RUNE
+              || op->type == TRAP
+              || op->flag [FLAG_IS_A_TEMPLATE])
+            op->destroy ();
+          else
+            map->insert (op, x, y);
+        }
+    }
+}
+
 object *object::create ()
 {
   object *op = new object;
@@ -894,76 +827,29 @@
   return op;
 }
 
-/*
- * 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.
- */
-void object::destroy (bool destroy_inventory)
+void
+object::do_destroy ()
 {
-  if (QUERY_FLAG (this, FLAG_FREED))
-    return;
+  if (flag [FLAG_IS_LINKED])
+    remove_button_link (this);
 
-  if (QUERY_FLAG (this, FLAG_FRIENDLY))
+  if (flag [FLAG_FRIENDLY])
     remove_friendly_object (this);
 
-  if (!QUERY_FLAG (this, FLAG_REMOVED))
+  if (!flag [FLAG_REMOVED])
     remove ();
 
-  SET_FLAG (this, FLAG_FREED);
-
-  if (more)
-    {
-      more->destroy (destroy_inventory);
-      more = 0;
-    }
-
-  if (inv)
-    {
-      /* Only if the space blocks everything do we not process -
-       * if some form of movement is allowed, let objects
-       * drop on that space.
-       */
-      if (destroy_inventory || !map || map->in_memory != MAP_IN_MEMORY || GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL)
-        {
-          object *op = inv;
-
-          while (op)
-            {
-              object *tmp = op->below;
-              op->destroy (destroy_inventory);
-              op = tmp;
-            }
-        }
-      else
-        {                       /* Put objects in inventory onto this space */
-          object *op = inv;
+  if (flag [FLAG_FREED])
+    return;
 
-          while (op)
-            {
-              object *tmp = op->below;
+  set_speed (0);
 
-              op->remove ();
+  flag [FLAG_FREED] = 1;
 
-              if (QUERY_FLAG (op, FLAG_STARTEQUIP)
-                  || QUERY_FLAG (op, FLAG_NO_DROP) || op->type == RUNE || op->type == TRAP || QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))
-                op->destroy ();
-              else
-                {
-                  op->x = x;
-                  op->y = y;
-                  insert_ob_in_map (op, map, 0, 0);     /* Insert in same map as the envir */
-                }
+  attachable::do_destroy ();
 
-              op = tmp;
-            }
-        }
-    }
+  destroy_inv (true);
+  unlink ();
 
   // hack to ensure that freed objects still have a valid map
   {
@@ -985,6 +871,14 @@
     y = 1;
   }
 
+  head = 0;
+
+  if (more)
+    {
+      more->destroy ();
+      more = 0;
+    }
+
   // clear those pointers that likely might have circular references to us
   owner       = 0;
   enemy       = 0;
@@ -992,14 +886,18 @@
 
   // only relevant for players(?), but make sure of it anyways
   contr       = 0;
+}
 
-  /* Remove object from the active list */
-  speed = 0;
-  update_ob_speed (this);
+void
+object::destroy (bool destroy_inventory)
+{
+  if (destroyed ())
+    return;
 
-  unlink ();
+  if (destroy_inventory)
+    destroy_inv (false);
 
-  mortals.push_back (this);
+  attachable::destroy ();
 }
 
 /*
@@ -1033,12 +931,11 @@
   object *tmp, *last = 0;
   object *otmp;
 
-  int check_walk_off;
-
   if (QUERY_FLAG (this, FLAG_REMOVED))
     return;
 
   SET_FLAG (this, FLAG_REMOVED);
+  INVOKE_OBJECT (REMOVE, this);
 
   if (more)
     more->remove ();
@@ -1058,8 +955,8 @@
        * made to players inventory.  If set, avoiding the call
        * to save cpu time.
        */
-      if ((otmp = is_player_inv (env)) != NULL && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
-        fix_player (otmp);
+      if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
+        otmp->update_stats ();
 
       if (above != NULL)
         above->below = below;
@@ -1088,7 +985,7 @@
       if (above)
         above->below = below;
       else
-        SET_MAP_TOP (map, x, y, below);       /* we were top, set new top */
+        map->at (x, y).top = below;       /* we were top, set new top */
 
       /* Relink the object below us, if there is one */
       if (below)
@@ -1110,7 +1007,7 @@
               free (dump);
             }
 
-          SET_MAP_OB (map, x, y, above);      /* goes on above it. */
+          map->at (x, y).bot = above;      /* goes on above it. */
         }
 
       above = 0;
@@ -1119,9 +1016,9 @@
       if (map->in_memory == MAP_SAVING)
         return;
 
-      check_walk_off = !QUERY_FLAG (this, FLAG_NO_APPLY);
+      int check_walk_off = !flag [FLAG_NO_APPLY];
 
-      for (tmp = GET_MAP_OB (map, x, y); tmp; tmp = tmp->above)
+      for (tmp = map->at (x, y).bot; tmp; tmp = tmp->above)
         {
           /* No point updating the players look faces if he is the object
            * being removed.
@@ -1135,11 +1032,12 @@
                */
               if (tmp->container == this)
                 {
-                  CLEAR_FLAG (this, FLAG_APPLIED);
+                  flag [FLAG_APPLIED] = 0;
                   tmp->container = 0;
                 }
 
-              tmp->contr->socket->update_look = 1;
+              if (tmp->contr->ns)
+                tmp->contr->ns->floorbox_update ();
             }
 
           /* See if player moving off should effect something */
@@ -1163,19 +1061,11 @@
 
       /* last == NULL of there are no objects on this space */
       if (!last)
-        {
-          /* set P_NEED_UPDATE, otherwise update_position will complain.  In theory,
-           * we could preserve the flags (GET_MAP_FLAGS), but update_position figures
-           * those out anyways, and if there are any flags set right now, they won't
-           * be correct anyways.
-           */
-          SET_MAP_FLAGS (map, x, y, P_NEED_UPDATE);
-          update_position (map, x, y);
-        }
+        map->at (x, y).flags_ = P_NEED_UPDATE;
       else
         update_object (last, UP_OBJ_REMOVE);
 
-      if (QUERY_FLAG (this, FLAG_BLOCKSVIEW) || glow_radius)
+      if (flag [FLAG_BLOCKSVIEW] || glow_radius)
         update_all_los (map, x, y);
     }
 }
@@ -1194,10 +1084,11 @@
   if (!op->nrof)
     return 0;
 
-  if (top == NULL)
-    for (top = op; top != NULL && top->above != NULL; top = top->above);
+  if (top)
+    for (top = op; top && top->above; top = top->above)
+      ;
 
-  for (; top != NULL; top = top->below)
+  for (; top; top = top->below)
     {
       if (top == op)
         continue;
@@ -1223,12 +1114,7 @@
 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;
@@ -1257,7 +1143,6 @@
  *   NULL if 'op' was destroyed
  *   just 'op' otherwise
  */
-
 object *
 insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
 {
@@ -1301,7 +1186,7 @@
       return op;
     }
 
-  if (op->more != NULL)
+  if (op->more)
     {
       /* The part may be on a different map. */
 
@@ -1327,7 +1212,7 @@
           if (!op->head)
             LOG (llevError, "BUG: insert_ob_in_map(): inserting op->more killed op\n");
 
-          return NULL;
+          return 0;
         }
     }
 
@@ -1371,7 +1256,7 @@
       if (op->below)
         op->below->above = op;
       else
-        SET_MAP_OB (op->map, op->x, op->y, op);
+        op->ms ().bot = op;
 
       /* since *below* originator, no need to update top */
       originator->below = op;
@@ -1427,7 +1312,7 @@
            * stacking is a bit odd.
            */
           if (!(flag & INS_ON_TOP) &&
-              (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_BLOCKSVIEW) && (op->face && !op->face->visibility))
+              (get_map_flags (op->map, 0, op->x, op->y, 0, 0) & P_BLOCKSVIEW) && (op->face && !op->face->visibility))
             {
               for (last = top; last != floor; last = last->below)
                 if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT))
@@ -1460,7 +1345,7 @@
             op->above->below = op;
 
           op->below = NULL;
-          SET_MAP_OB (op->map, op->x, op->y, op);
+          op->ms ().bot = op;
         }
       else
         {                       /* get inserted into the stack above top */
@@ -1474,7 +1359,7 @@
         }
 
       if (op->above == NULL)
-        SET_MAP_TOP (op->map, op->x, op->y, op);
+        op->ms ().top = op;
     }                           /* else not INS_BELOW_ORIGINATOR */
 
   if (op->type == PLAYER)
@@ -1484,9 +1369,9 @@
    * it, so save a few ticks and start from there.
    */
   if (!(flag & INS_MAP_LOAD))
-    for (tmp = floor ? floor : GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
-      if (tmp->type == PLAYER)
-        tmp->contr->socket->update_look = 1;
+    if (object *pl = op->ms ().player ())
+      if (pl->contr->ns)
+        pl->contr->ns->floorbox_update ();
 
   /* If this object glows, it may affect lighting conditions that are
    * visible to others on this map.  But update_all_los is really
@@ -1497,14 +1382,16 @@
    * or just updating the P_NEED_UPDATE for spaces within this area
    * of effect may be sufficient.
    */
-  if (MAP_DARKNESS (op->map) && (op->glow_radius != 0))
+  if (op->map->darkness && (op->glow_radius != 0))
     update_all_los (op->map, op->x, op->y);
 
   /* updates flags (blocked, alive, no magic, etc) for this map space */
   update_object (op, UP_OBJ_INSERT);
 
+  INVOKE_OBJECT (INSERT, op);
+
   /* Don't know if moving this to the end will break anything.  However,
-   * we want to have update_look set above before calling this.
+   * we want to have floorbox_update called before calling this.
    *
    * check_move_on() must be after this because code called from
    * check_move_on() depends on correct map flags (so functions like
@@ -1516,30 +1403,27 @@
   if (!(flag & INS_NO_WALK_ON) && !op->head)
     {
       if (check_move_on (op, originator))
-        return NULL;
+        return 0;
 
       /* If we are a multi part object, lets work our way through the check
        * walk on's.
        */
       for (tmp = op->more; tmp != NULL; tmp = tmp->more)
         if (check_move_on (tmp, originator))
-          return NULL;
+          return 0;
     }
 
   return op;
 }
 
 /* this function inserts an object in the map, but if it
- *  finds an object of its own type, it'll remove that one first. 
- *  op is the object to insert it under:  supplies x and the map.
+ * finds an object of its own type, it'll remove that one first. 
+ * op is the object to insert it under: supplies x and the map.
  */
 void
 replace_insert_ob_in_map (const char *arch_string, object *op)
 {
-  object *
-    tmp;
-  object *
-    tmp1;
+  object *tmp, *tmp1;
 
   /* first search for itself and remove any old instances */
 
@@ -1554,6 +1438,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
@@ -1561,7 +1451,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)
 {
@@ -1607,7 +1496,6 @@
 decrease_ob_nr (object *op, uint32 i)
 {
   object *tmp;
-  player *pl;
 
   if (i == 0)                   /* objects with op->nrof require this check */
     return op;
@@ -1617,12 +1505,12 @@
 
   if (QUERY_FLAG (op, FLAG_REMOVED))
     op->nrof -= i;
-  else if (op->env != NULL)
+  else if (op->env)
     {
       /* is this object in the players inventory, or sub container
        * therein?
        */
-      tmp = is_player_inv (op->env);
+      tmp = op->in_player ();
       /* nope.  Is this a container the player has opened?
        * If so, set tmp to that player.
        * IMO, searching through all the players will mostly
@@ -1630,33 +1518,26 @@
        * and then searching the map for a player.
        */
       if (!tmp)
-        {
-          for (pl = first_player; pl; pl = pl->next)
-            if (pl->ob->container == op->env)
+        for_all_players (pl)
+          if (pl->ob->container == op->env)
+            {
+              tmp = pl->ob;
               break;
-          if (pl)
-            tmp = pl->ob;
-          else
-            tmp = NULL;
-        }
+            }
 
       if (i < op->nrof)
         {
           sub_weight (op->env, op->weight * i);
           op->nrof -= i;
           if (tmp)
-            {
-              esrv_send_item (tmp, op);
-            }
+            esrv_send_item (tmp, op);
         }
       else
         {
           op->remove ();
           op->nrof = 0;
           if (tmp)
-            {
-              esrv_del_item (tmp->contr, op->count);
-            }
+            esrv_del_item (tmp->contr, op->count);
         }
     }
   else
@@ -1672,7 +1553,7 @@
         }
 
       /* Since we just removed op, op->above is null */
-      for (tmp = above; tmp != NULL; tmp = tmp->above)
+      for (tmp = above; tmp; tmp = tmp->above)
         if (tmp->type == PLAYER)
           {
             if (op->nrof)
@@ -1687,7 +1568,7 @@
   else
     {
       op->destroy ();
-      return NULL;
+      return 0;
     }
 }
 
@@ -1785,15 +1666,15 @@
   else
     add_weight (this, (op->weight + op->carrying));
 
-  otmp = is_player_inv (this);
+  otmp = this->in_player ();
   if (otmp && otmp->contr)
     if (!QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER))
-      fix_player (otmp);
+      otmp->update_stats ();
 
-  op->map = NULL;
+  op->map = 0;
   op->env = this;
-  op->above = NULL;
-  op->below = NULL;
+  op->above = 0;
+  op->below = 0;
   op->x = 0, op->y = 0;
 
   /* reset the light list and los of the players on the map */
@@ -1802,7 +1683,7 @@
 #ifdef DEBUG_LIGHTS
       LOG (llevDebug, " insert_ob_in_ob(): got %s to insert in map/op\n", op->name);
 #endif /* DEBUG_LIGHTS */
-      if (MAP_DARKNESS (map))
+      if (map->darkness)
         update_all_los (map, x, y);
     }
 
@@ -1818,6 +1699,8 @@
       inv = op;
     }
 
+  INVOKE_OBJECT (INSERT, this);
+
   return op;
 }
 
@@ -1841,7 +1724,6 @@
  * object being inserted.  insert_ob_in_map may not put new objects
  * on top.
  */
-
 int
 check_move_on (object *op, object *originator)
 {
@@ -1878,7 +1760,7 @@
    * Hence, we first go to the top: 
    */
 
-  for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL && tmp->above != NULL; tmp = tmp->above)
+  for (tmp = GET_MAP_OB (op->map, op->x, op->y); 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,
@@ -1943,21 +1825,19 @@
  * a matching archetype at the given map and coordinates.
  * The first matching object is returned, or NULL if none.
  */
-
 object *
 present_arch (const archetype *at, maptile *m, int x, int y)
 {
-  object *
-    tmp;
-
   if (m == NULL || out_of_map (m, x, y))
     {
       LOG (llevError, "Present_arch called outside map.\n");
       return NULL;
     }
-  for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
+
+  for (object *tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
     if (tmp->arch == at)
       return tmp;
+
   return NULL;
 }
 
@@ -1966,21 +1846,19 @@
  * a matching type variable at the given map and coordinates.
  * The first matching object is returned, or NULL if none.
  */
-
 object *
 present (unsigned char type, maptile *m, int x, int y)
 {
-  object *
-    tmp;
-
   if (out_of_map (m, x, y))
     {
       LOG (llevError, "Present called outside map.\n");
       return NULL;
     }
-  for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
+
+  for (object *tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
     if (tmp->type == type)
       return tmp;
+
   return NULL;
 }
 
@@ -1989,16 +1867,13 @@
  * a matching type variable in the inventory of the given object.
  * The first matching object is returned, or NULL if none.
  */
-
 object *
 present_in_ob (unsigned char type, const object *op)
 {
-  object *
-    tmp;
-
-  for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
+  for (object *tmp = op->inv; tmp != NULL; tmp = tmp->below)
     if (tmp->type == type)
       return tmp;
+
   return NULL;
 }
 
@@ -2016,19 +1891,14 @@
  * spell code can use one object type (force), but change it's name
  * to be unique.
  */
-
 object *
 present_in_ob_by_name (int type, const char *str, const object *op)
 {
-  object *
-    tmp;
+  for (object *tmp = op->inv; tmp; tmp = tmp->below)
+    if ((type == -1 || tmp->type == type) && (!strcmp (str, tmp->name)))
+      return tmp;
 
-  for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
-    {
-      if ((type == -1 || tmp->type == type) && (!strcmp (str, tmp->name)))
-        return tmp;
-    }
-  return NULL;
+  return 0;
 }
 
 /*
@@ -2036,16 +1906,13 @@
  * a matching archetype in the inventory of the given object.
  * The first matching object is returned, or NULL if none.
  */
-
 object *
 present_arch_in_ob (const archetype *at, const object *op)
 {
-  object *
-    tmp;
-
-  for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
+  for (object *tmp = op->inv; tmp != NULL; tmp = tmp->below)
     if (tmp->arch == at)
       return tmp;
+
   return NULL;
 }
 
@@ -2055,26 +1922,22 @@
 void
 flag_inv (object *op, int flag)
 {
-  object *
-    tmp;
-
   if (op->inv)
-    for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
+    for (object *tmp = op->inv; tmp != NULL; tmp = tmp->below)
       {
         SET_FLAG (tmp, flag);
         flag_inv (tmp, flag);
       }
-}                               /*
-                                 * desactivate recursively a flag on an object inventory
-                                 */
+}
+
+/*
+ * deactivate recursively a flag on an object inventory
+ */
 void
 unflag_inv (object *op, int flag)
 {
-  object *
-    tmp;
-
   if (op->inv)
-    for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
+    for (object *tmp = op->inv; tmp != NULL; tmp = tmp->below)
       {
         CLEAR_FLAG (tmp, flag);
         unflag_inv (tmp, flag);
@@ -2087,7 +1950,6 @@
  * If checksums are used, a player will get set_cheat called for
  * him/her-self and all object carried by a call to this function.
  */
-
 void
 set_cheat (object *op)
 {
@@ -2116,21 +1978,17 @@
  * the archetype because that isn't correct if the monster has been 
  * customized, changed states, etc.
  */
-
 int
 find_free_spot (const object *ob, maptile *m, int x, int y, int start, int stop)
 {
-  int
-    i,
-    index = 0, flag;
-  static int
-    altern[SIZEOFFREE];
+  int index = 0, flag;
+  int altern[SIZEOFFREE];
 
-  for (i = start; i < stop; i++)
+  for (int i = start; i < stop; i++)
     {
       flag = ob_blocked (ob, m, x + freearr_x[i], y + freearr_y[i]);
       if (!flag)
-        altern[index++] = i;
+        altern [index++] = i;
 
       /* Basically, if we find a wall on a space, we cut down the search size.
        * In this way, we won't return spaces that are on another side of a wall.
@@ -2140,11 +1998,13 @@
        * to only the spaces immediately surrounding the target area, and
        * won't look 2 spaces south of the target space.
        */
-      else if ((flag & AB_NO_PASS) && maxfree[i] < stop)
+      else if ((flag & P_NO_PASS) && maxfree[i] < stop)
         stop = maxfree[i];
     }
+
   if (!index)
     return -1;
+
   return altern[RANDOM () % index];
 }
 
@@ -2154,43 +2014,29 @@
  * But it will return the first available spot, not a random choice.
  * Changed 0.93.2: Have it return -1 if there is no free spot available.
  */
-
 int
 find_first_free_spot (const object *ob, maptile *m, int x, int y)
 {
-  int
-    i;
+  for (int i = 0; i < SIZEOFFREE; i++)
+    if (!ob_blocked (ob, m, x + freearr_x[i], y + freearr_y[i]))
+      return i;
 
-  for (i = 0; i < SIZEOFFREE; i++)
-    {
-      if (!ob_blocked (ob, m, x + freearr_x[i], y + freearr_y[i]))
-        return i;
-    }
   return -1;
 }
 
 /*
  * The function permute(arr, begin, end) randomly reorders the array
  * arr[begin..end-1].
+ * now uses a fisher-yates shuffle, old permute was broken
  */
 static void
 permute (int *arr, int begin, int end)
 {
-  int
-    i,
-    j,
-    tmp,
-    len;
-
-  len = end - begin;
-  for (i = begin; i < end; i++)
-    {
-      j = begin + RANDOM () % len;
-
-      tmp = arr[i];
-      arr[i] = arr[j];
-      arr[j] = tmp;
-    }
+  arr += begin;
+  end -= begin;
+
+  while (--end)
+    swap (arr [end], arr [RANDOM () % (end + 1)]);
 }
 
 /* new function to make monster searching more efficient, and effective! 
@@ -2203,13 +2049,10 @@
 void
 get_search_arr (int *search_arr)
 {
-  int
-    i;
+  int i;
 
   for (i = 0; i < SIZEOFFREE; i++)
-    {
-      search_arr[i] = i;
-    }
+    search_arr[i] = i;
 
   permute (search_arr, 1, SIZEOFFREE1 + 1);
   permute (search_arr, SIZEOFFREE1 + 1, SIZEOFFREE2 + 1);
@@ -2228,19 +2071,14 @@
  * because we have to know what movement the thing looking to move
  * there is capable of.
  */
-
 int
 find_dir (maptile *m, int x, int y, object *exclude)
 {
-  int
-    i,
-    max = SIZEOFFREE, mflags;
+  int i, max = SIZEOFFREE, mflags;
 
   sint16 nx, ny;
-  object *
-    tmp;
-  maptile *
-    mp;
+  object *tmp;
+  maptile *mp;
 
   MoveType blocked, move_type;
 
@@ -2262,34 +2100,30 @@
       ny = y + freearr_y[i];
 
       mflags = get_map_flags (m, &mp, nx, ny, &nx, &ny);
+
       if (mflags & P_OUT_OF_MAP)
-        {
-          max = maxfree[i];
-        }
+        max = maxfree[i];
       else
         {
-          blocked = GET_MAP_MOVE_BLOCK (mp, nx, ny);
+          mapspace &ms = mp->at (nx, ny);
+
+          blocked = ms.move_block;
 
           if ((move_type & blocked) == move_type)
-            {
-              max = maxfree[i];
-            }
+            max = maxfree[i];
           else if (mflags & P_IS_ALIVE)
             {
-              for (tmp = GET_MAP_OB (mp, nx, ny); tmp != NULL; tmp = tmp->above)
-                {
-                  if ((QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER) && (tmp != exclude || (tmp->head && tmp->head != exclude)))
-                    {
-                      break;
-                    }
-                }
+              for (tmp = ms.bot; tmp; tmp = tmp->above)
+                if ((tmp->flag [FLAG_MONSTER] || tmp->type == PLAYER)
+                    && (tmp != exclude || (tmp->head && tmp->head != exclude)))
+                  break;
+
               if (tmp)
-                {
-                  return freedir[i];
-                }
+                return freedir[i];
             }
         }
     }
+
   return 0;
 }
 
@@ -2297,15 +2131,10 @@
  * distance(object 1, object 2) will return the square of the
  * distance between the two given objects.
  */
-
 int
 distance (const object *ob1, const object *ob2)
 {
-  int
-    i;
-
-  i = (ob1->x - ob2->x) * (ob1->x - ob2->x) + (ob1->y - ob2->y) * (ob1->y - ob2->y);
-  return i;
+  return (ob1->x - ob2->x) * (ob1->x - ob2->x) + (ob1->y - ob2->y) * (ob1->y - ob2->y);
 }
 
 /*
@@ -2313,12 +2142,10 @@
  * an object which has subtracted the x and y coordinates of another
  * object, needs to travel toward it.
  */
-
 int
 find_dir_2 (int x, int y)
 {
-  int
-    q;
+  int q;
 
   if (y)
     q = x * 100 / y;
@@ -2363,8 +2190,10 @@
 {
   while (d < 1)
     d += 8;
+
   while (d > 8)
     d -= 8;
+
   return d;
 }
 
@@ -2376,12 +2205,12 @@
 int
 dirdiff (int dir1, int dir2)
 {
-  int
-    d;
+  int d;
 
   d = abs (dir1 - dir2);
   if (d > 4)
     d = 8 - d;
+
   return d;
 }
 
@@ -2394,9 +2223,7 @@
  * Moved from spell_util.c to object.c with the other related direction
  * functions.
  */
-
-int
-  reduction_dir[SIZEOFFREE][3] = {
+int reduction_dir[SIZEOFFREE][3] = {
   {0, 0, 0},                    /* 0 */
   {0, 0, 0},                    /* 1 */
   {0, 0, 0},                    /* 2 */
@@ -2454,14 +2281,11 @@
  * can see a direct way to get it
  * Modified to be map tile aware -.MSW
  */
-
-
 int
 can_see_monsterP (maptile *m, int x, int y, int dir)
 {
   sint16 dx, dy;
-  int
-    mflags;
+  int mflags;
 
   if (dir < 0)
     return 0;                   /* exit condition:  invalid direction */
@@ -2484,11 +2308,11 @@
   /* yes, can see. */
   if (dir < 9)
     return 1;
-  return can_see_monsterP (m, x, y, reduction_dir[dir][0]) |
-    can_see_monsterP (m, x, y, reduction_dir[dir][1]) | can_see_monsterP (m, x, y, reduction_dir[dir][2]);
-}
-
 
+  return can_see_monsterP (m, x, y, reduction_dir[dir][0])
+         | can_see_monsterP (m, x, y, reduction_dir[dir][1])
+         | can_see_monsterP (m, x, y, reduction_dir[dir][2]);
+}
 
 /*
  * can_pick(picker, item): finds out if an object is possible to be
@@ -2509,7 +2333,6 @@
      !QUERY_FLAG (item, FLAG_ALIVE) && !item->invisible && (who->type == PLAYER || item->weight < who->weight / 3));
 }
 
-
 /*
  * create clone from object to another
  */
@@ -2538,9 +2361,7 @@
           tmp->head = 0;
         }
       else
-        {
-          tmp->head = dst;
-        }
+        tmp->head = dst;
 
       tmp->more = 0;
 
@@ -2562,7 +2383,6 @@
 /* but it was simple to make and allows reusing the load_object function.    */
 /* Remember not to use load_object_str in a time-critical situation.         */
 /* Also remember that multiparts objects are not supported for now.          */
-
 object *
 load_object_str (const char *obstr)
 {
@@ -2602,13 +2422,11 @@
 object *
 find_obj_by_type_subtype (const object *who, int type, int subtype)
 {
-  object *tmp;
-
-  for (tmp = who->inv; tmp; tmp = tmp->below)
+  for (object *tmp = who->inv; tmp; tmp = tmp->below)
     if (tmp->type == type && tmp->subtype == subtype)
       return tmp;
 
-  return NULL;
+  return 0;
 }
 
 /* If ob has a field named key, return the link from the list,
@@ -2620,13 +2438,11 @@
 key_value *
 get_ob_key_link (const object *ob, const char *key)
 {
-  key_value *link;
-
-  for (link = ob->key_values; link != NULL; link = link->next)
+  for (key_value *link = ob->key_values; link; link = link->next)
     if (link->key == key)
       return link;
 
-  return NULL;
+  return 0;
 }
 
 /* 
@@ -2676,8 +2492,7 @@
 int
 set_ob_key_value_s (object *op, const shstr & canonical_key, const char *value, int add_key)
 {
-  key_value *
-    field = NULL, *last = NULL;
+  key_value *field = NULL, *last = NULL;
 
   for (field = op->key_values; field != NULL; field = field->next)
     {
@@ -2715,9 +2530,8 @@
   /* No field, we'll have to add it. */
 
   if (!add_key)
-    {
-      return FALSE;
-    }
+    return FALSE;
+
   /* There isn't any good reason to store a null
    * value in the key/value list.  If the archetype has
    * this key, then we should also have it, so shouldn't