--- deliantra/server/common/object.C	2008/12/23 00:39:48	1.265
+++ deliantra/server/common/object.C	2011/02/25 07:23:38	1.341
@@ -1,22 +1,23 @@
 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  * 
- * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
- * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
- * Copyright (©) 1992,2007 Frank Tore Johansen
+ * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+ * Copyright (©) 2001 Mark Wedel & Crossfire Development Team
+ * Copyright (©) 1992 Frank Tore Johansen
  * 
- * Deliantra 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 3 of the License, or
- * (at your option) any later version.
+ * Deliantra is free software: you can redistribute it and/or modify it under
+ * the terms of the Affero GNU General Public License as published by the
+ * Free Software Foundation, either version 3 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, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the Affero GNU General Public License
+ * and the GNU General Public License along with this program. If not, see
+ * <http://www.gnu.org/licenses/>.
  * 
  * The authors can be reached via e-mail to <support@deliantra.net>
  */
@@ -27,17 +28,25 @@
 #include <sys/uio.h>
 #include <object.h>
 #include <sproto.h>
-#include <loader.h>
 
 #include <bitset>
 
 UUID UUID::cur;
 static uint64_t seq_next_save;
 static const uint64 UUID_GAP = 1<<19;
+uint32_t mapspace::smellcount = 10000;
 
 objectvec objects;
 activevec actives;
 
+freelist_item *object::freelist;
+uint32_t object::object_count;
+uint32_t object::free_count;
+uint32_t object::create_count;
+uint32_t object::destroy_count;
+
+//+GPL
+
 short freearr_x[SIZEOFFREE] = {
    0,
    0,  1,  1,  1,  0, -1, -1, -1,
@@ -50,12 +59,6 @@
   -2, -2, -2, -1,  0,  1,  2,  2,  2,  2,  2,  1,  0, -1, -2, -2,
   -3, -3, -3, -3, -2, -1,  0,  1,  2,  3,  3,  3,  3,  3,  3,  3,  2,  1,  0, -1, -2, -3, -3, -3
 };
-int maxfree[SIZEOFFREE] = {
-   0,
-   9, 10, 13, 14, 17, 18, 21, 22,
-  25, 26, 27, 30, 31, 32, 33, 36, 37, 39, 39, 42, 43, 44, 45, 48,
-  49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49
-};
 int freedir[SIZEOFFREE] = {
    0,
    1,  2,  3,  4,  5,  6,  7,  8,
@@ -63,6 +66,32 @@
    1,  2,  2,  2,  2,  2,  3,  4,  4,  4,  4,  4,  5,  6,  6,  6,  6,  6,  7,  8,  8,  8,  8,  8
 };
 
+static int maxfree[SIZEOFFREE] = {
+   0,
+   9, 10, 13, 14, 17, 18, 21, 22,
+  25, 26, 27, 30, 31, 32, 33, 36, 37, 39, 39, 42, 43, 44, 45, 48,
+  49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49
+};
+
+const char *wall_suffix[16] = {
+  "0", 
+  "1_3", 
+  "1_4", 
+  "2_1_2", 
+  "1_2", 
+  "2_2_4", 
+  "2_2_1", 
+  "3_1", 
+  "1_1", 
+  "2_2_3", 
+  "2_2_2", 
+  "3_3", 
+  "2_1_1", 
+  "3_4", 
+  "3_2", 
+  "4" 
+};
+
 static void
 write_uuid (uval64 skip, bool sync)
 {
@@ -74,7 +103,7 @@
 }
 
 static void
-read_uuid (void)
+read_uuid ()
 {
   char filename[MAX_BUF];
 
@@ -98,7 +127,7 @@
       _exit (1);
     }
 
-  UUID::BUF buf;
+  char buf [UUID::MAX_LEN];
   buf[0] = 0;
   fgets (buf, sizeof (buf), fp);
 
@@ -137,6 +166,71 @@
   read_uuid ();
 }
 
+bool
+UUID::parse (const char *s)
+{
+  if (*s++ != '<' || *s++ != '1' || *s++ != '.')
+    return false;
+
+  seq = 0;
+
+  while (*s != '>')
+    {
+      if (*s < '0')
+        return false;
+
+      // this gives nice branchless code with gcc
+      assert ('0' < 'a' && '0' == 48 && 'a' == 97);
+      int digit = (*s + (*s & 0x40 ? 9 : 0)) & 15;
+
+      seq = (seq << 4) | digit;
+
+      ++s;
+    }
+
+  return true;
+}
+
+char *
+UUID::append (char *buf) const
+{
+  *buf++ = '<';
+  *buf++ = '1';
+  *buf++ = '.';
+
+  uint64_t seq = this->seq;
+  const int bits = 64;
+  char nz = 0;
+  static const char tohex [] = "0123456789abcdef";
+
+  // assert (len >= 3 + bits / 4 + 1 + 1);
+  for (int i = bits / 4; --i; )
+    {
+      uint8_t digit = seq >> (bits - 4);
+
+      *buf = tohex [digit];
+      nz |= digit;
+      buf += nz ? 1 : 0;
+      seq <<= 4;
+    }
+
+  // last digit is special - always emit
+  uint8_t digit = seq >> (bits - 4);
+  *buf++ = tohex [digit];
+
+  *buf++ = '>';
+
+  return buf;
+}
+
+char *
+UUID::c_str () const
+{
+  static char buf [MAX_LEN];
+  *append (buf) = 0;
+  return buf;
+}
+
 /* Returns TRUE if every key_values in wants has a partner with the same value in has. */
 static bool
 compare_ob_value_lists_one (const object *wants, const object *has)
@@ -180,12 +274,12 @@
  */
 bool object::can_merge_slow (object *ob1, object *ob2)
 {
-  /* A couple quicksanity checks */
+  /* A couple quick sanity checks */
   if (ob1 == ob2
       || ob1->type  != ob2->type
-      || ob1->speed != ob2->speed
       || ob1->value != ob2->value
-      || ob1->name  != ob2->name)
+      || ob1->name  != ob2->name
+      || fabs (ob1->speed - ob2->speed) >= MIN_ACTIVE_SPEED)
     return 0;
 
   /* Do not merge objects if nrof would overflow, assume nrof
@@ -199,11 +293,11 @@
    * are not equal - just if it has been identified, the been_applied
    * flags lose any meaning.
    */
-  if (QUERY_FLAG (ob1, FLAG_IDENTIFIED))
-    SET_FLAG (ob1, FLAG_BEEN_APPLIED);
+  if (ob1->flag [FLAG_IDENTIFIED])
+    ob1->set_flag (FLAG_BEEN_APPLIED);
 
-  if (QUERY_FLAG (ob2, FLAG_IDENTIFIED))
-    SET_FLAG (ob2, FLAG_BEEN_APPLIED);
+  if (ob2->flag [FLAG_IDENTIFIED])
+    ob2->set_flag (FLAG_BEEN_APPLIED);
 
   if (ob1->arch->archname  != ob2->arch->archname
       || ob1->name         != ob2->name
@@ -216,9 +310,9 @@
       || ob1->skill        != ob2->skill
       || ob1->value        != ob2->value
       || ob1->animation_id != ob2->animation_id
-      || (ob1->face != ob2->face && !ob1->animation_id) // face and animation are dependent on each other
+      || (ob1->face != ob2->face && !ob1->animation_id) // face and animation are dependend on each other
       || ob1->client_type  != ob2->client_type
-      || ob1->materialname != ob2->materialname
+      || ob1->material     != ob2->material
       || ob1->lore         != ob2->lore
       || ob1->subtype      != ob2->subtype
       || ob1->move_type    != ob2->move_type
@@ -227,7 +321,7 @@
       || ob1->move_on      != ob2->move_on
       || ob1->move_off     != ob2->move_off
       || ob1->move_slow    != ob2->move_slow
-      || ob1->move_slow_penalty != ob2->move_slow_penalty
+      || fabs (ob1->move_slow_penalty - ob2->move_slow_penalty) >= (1.f / 1024.f)
       || memcmp (&ob1->resist, &ob2->resist, sizeof (ob1->resist))
       || memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats)))
     return 0;
@@ -262,14 +356,14 @@
    * it is possible for most any character to have more than one of
    * some items equipped, and we don't want those to merge.
    */
-  if (QUERY_FLAG (ob1, FLAG_APPLIED) || QUERY_FLAG (ob2, FLAG_APPLIED))
+  if (ob1->flag [FLAG_APPLIED] || ob2->flag [FLAG_APPLIED])
     return 0;
 
   /* Note sure why the following is the case - either the object has to
    * be animated or have a very low speed.  Is this an attempted monster
    * check?
    */
-  if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && ob1->has_active_speed ())
+  if (!ob1->flag [FLAG_ANIMATE] && ob1->has_active_speed ())
     return 0;
 
   switch (ob1->type)
@@ -325,17 +419,17 @@
       if (env)
         {
           // the player inventory itself is always visible
-          if (env->type == PLAYER)
+          if (env->is_player ())
             return env;
 
           // else a player could have our env open
-          object *envest = env->outer_env ();
+          object *envest = env->outer_env_or_self ();
 
           // the player itself is always on a map, so we will find him here
           // even if our inv is in a player.
           if (envest->is_on_map ())
             if (object *pl = envest->ms ().player ())
-              if (pl->container == env)
+              if (pl->container_ () == env)
                 return pl;
         }
       else
@@ -343,8 +437,8 @@
           // maybe there is a player standing on the same mapspace
           // this will catch the case where "this" is a player
           if (object *pl = ms ().player ())
-            if ((!pl->container && pl->contr->ns && !pl->contr->ns->update_look)
-                || this == pl->container)
+            if ((pl->contr->ns && !pl->container_ () && !pl->contr->ns->update_look)
+                || pl->container_ () == this)
               return pl;
         }
     }
@@ -353,37 +447,35 @@
 }
 
 // adjust weight per container type ("of holding")
-static sint32
-weight_adjust_for (object *op, sint32 weight)
+static uint32
+weight_adjust_for (object *op, uint32 weight)
 {
   return op->type == CONTAINER
-         ? lerp (weight, 0, 100, 0, 100 - op->stats.Str)
+         ? weight - weight * op->stats.Str / 100
          : weight;
 }
 
 /*
- * adjust_weight(object, weight) adds the specified weight to an object,
+ * subtracts, then adds, the specified weight to an object,
  * and also updates how much the environment(s) is/are carrying.
  */
 static void
-adjust_weight (object *op, sint32 weight)
+adjust_weight (object *op, sint32 sub, sint32 add)
 {
   while (op)
     {
-      // adjust by actual difference to account for rounding errors
-      // i.e. (w2 - w1) / f != w2 / f - w1 / f and the latter is correct
-      weight = weight_adjust_for (op, op->carrying)
-             - weight_adjust_for (op, op->carrying - weight);
+      sint32 ocarrying = op->carrying;
 
-      if (!weight)
-        return;
-
-      op->carrying += weight;
+      op->carrying -= weight_adjust_for (op, sub);
+      op->carrying += weight_adjust_for (op, add);
 
       if (object *pl = op->visible_to ())
         if (pl != op) // player is handled lazily
           esrv_update_item (UPD_WEIGHT, pl, op);
 
+      sub = ocarrying;
+      add = op->carrying;
+
       op = op->env;
     }
 }
@@ -400,16 +492,17 @@
 
   for (object *op = inv; op; op = op->below)
     {
-      if (op->inv)
-        op->update_weight ();
+      op->update_weight ();
 
-      sum += op->total_weight ();
+      sum += weight_adjust_for (this, op->total_weight ());
     }
 
-  sum = weight_adjust_for (this, sum);
-
   if (sum != carrying)
     {
+      if (carrying != sum && carrying)//D
+        LOG (llevDebug, "updating carrying got %ld, expected %ld (%s)\n",
+             (long long)sum, (long long)carrying, debug_desc ());
+
       carrying = sum;
 
       if (object *pl = visible_to ())
@@ -432,27 +525,10 @@
   return freezer.as_string ();
 }
 
-/*
- * get_nearest_part(multi-object, object 2) returns the part of the
- * multi-object 1 which is closest to the second object.
- * If it's not a multi-object, it is returned.
- */
-object *
-get_nearest_part (object *op, const object *pl)
+char *
+object::as_string ()
 {
-  object *tmp, *closest;
-  int last_dist, i;
-
-  if (!op->more)
-    return op;
-
-  for (last_dist = distance (op, pl), closest = op, tmp = op->more;
-       tmp;
-       tmp = tmp->more)
-    if ((i = distance (tmp, pl)) < last_dist)
-      closest = tmp, last_dist = i;
-
-  return closest;
+  return dump_object (this);
 }
 
 /*
@@ -470,6 +546,21 @@
 }
 
 /*
+ * Returns the object which has the uuid equal to the argument.
+ * MOAR VERRRY slow.
+ */
+
+object *
+find_object_uuid (UUID i)
+{
+  for_all_objects (op)
+   if (op->uuid == i)
+     return op;
+
+  return 0;
+}
+
+/*
  * Returns the first object which has a name equal to the argument.
  * Used only by the patch command, but not all that useful.
  * Enables features like "patch <name-of-other-player> food 999"
@@ -509,72 +600,6 @@
   this->owner = owner;
 }
 
-int
-object::slottype () const
-{
-  if (type == SKILL)
-    {
-      if (IS_COMBAT_SKILL (subtype)) return slot_combat;
-      if (IS_RANGED_SKILL (subtype)) return slot_ranged;
-    }
-  else
-    {
-      if (slot [body_combat].info) return slot_combat;
-      if (slot [body_range ].info) return slot_ranged;
-    }
-  
-  return slot_none;
-}
-
-bool
-object::change_weapon (object *ob)
-{
-  if (current_weapon == ob)
-    return true;
-
-  if (chosen_skill)
-    chosen_skill->flag [FLAG_APPLIED] = false;
-
-  current_weapon = ob;
-  chosen_skill = !ob || ob->type == SKILL ? ob : find_skill_by_name (this, ob->skill);
-
-  if (chosen_skill)
-    chosen_skill->flag [FLAG_APPLIED] = true;
-
-  update_stats ();
-
-  if (ob)
-    {
-      // now check wether any body locations became invalid, in which case
-      // we cannot apply the weapon at the moment.
-      for (int i = 0; i < NUM_BODY_LOCATIONS; ++i)
-        if (slot[i].used < 0)
-          {
-            current_weapon = chosen_skill = 0;
-            update_stats ();
-
-            new_draw_info_format (NDI_UNIQUE, 0, this,
-                                  "You try to balance all your items at once, "
-                                  "but the %s is just too much for your body. "
-                                  "[You need to unapply some items first.]", &ob->name);
-            return false;
-          }
-
-      //new_draw_info_format (NDI_UNIQUE, 0, this, "You switch to your %s.", &ob->name);
-    }
-  else
-    ;//new_draw_info_format (NDI_UNIQUE, 0, this, "You unwield your weapons.");
-
-  if (ob && !ob->flag [FLAG_APPLIED] && ob->type != SPELL)
-    {
-      LOG (llevError | logBacktrace, "%s changed to unapplied weapon %s",
-           &name, ob->debug_desc ());
-      return false;
-    }
-
-  return true;
-}
-
 /* Zero the key_values on op, decrementing the shared-string
  * refcounts and freeing the links. 
  */
@@ -635,9 +660,6 @@
         }
     }
 
-  if (speed < 0)
-    dst->speed_left -= rndm ();
-
   dst->activate ();
 }
 
@@ -647,7 +669,12 @@
   if (!uuid.seq) // HACK
     uuid = UUID::gen ();
 
-  speed_left = -0.1f;
+  // TODO: unclean state changes, should not be done in copy_to AND instantiate
+  if (flag [FLAG_RANDOM_SPEED] && speed)
+    speed_left = - speed - rndm (); // TODO animation
+  else
+    speed_left = -1.;
+
   /* copy the body_info to the body_used - this is only really
    * need for monsters, but doesn't hurt to do it for everything.
    * by doing so, when a monster is created, it has good starting
@@ -665,6 +692,11 @@
 {
   object *neu = create ();
   copy_to (neu);
+
+  // TODO: unclean state changes, should not be done in clone AND instantiate
+  if (neu->flag [FLAG_RANDOM_SPEED] && neu->speed)
+    neu->speed_left = - neu->speed - rndm (); // TODO animation
+
   neu->map = map; // not copied by copy_to
   return neu;
 }
@@ -677,7 +709,7 @@
 void
 update_turn_face (object *op)
 {
-  if (!QUERY_FLAG (op, FLAG_IS_TURNABLE) || !op->arch)
+  if (!op->flag [FLAG_IS_TURNABLE] || !op->arch)
     return;
 
   SET_ANIMATION (op, op->direction);
@@ -692,12 +724,6 @@
 void
 object::set_speed (float speed)
 {
-  if (flag [FLAG_FREED] && speed)
-    {
-      LOG (llevError, "Object %s is freed but has speed.\n", &name);
-      speed = 0;
-    }
-
   this->speed = speed;
 
   if (has_active_speed ())
@@ -757,13 +783,14 @@
     /* nop */;
   else if (action == UP_OBJ_INSERT)
     {
+#if 0
       // 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))
+      if ((op->flag [FLAG_BLOCKSVIEW]  && !(m.flags_ & P_BLOCKSVIEW))
+          || (op->flag [FLAG_NO_MAGIC] && !(m.flags_ & P_NO_MAGIC))
+          || (op->is_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))
+          || (op->flag [FLAG_ALIVE]    && !(m.flags_ & P_IS_ALIVE))
+          || (op->flag [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
@@ -771,8 +798,11 @@
            * 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.invalidate ();
+#else
+      // the above is not strong enough a test to skip updating. los maybe? TODO (schmorp)
+      m.invalidate ();
+#endif
     }
     /* if the object is being removed, we can't make intelligent
      * decisions, because remove_ob can't really pass the object
@@ -791,10 +821,11 @@
 
 object::object ()
 {
-  SET_FLAG (this, FLAG_REMOVED);
+  this->set_flag (FLAG_REMOVED);
 
-  expmul = 1.0;
-  face = blank_face;
+  //expmul = 1.0; declared const for the time being
+  face     = blank_face;
+  material = MATERIAL_NULL;
 }
 
 object::~object ()
@@ -804,16 +835,16 @@
   free_key_values (this);
 }
 
-static int object_count;
-
 void object::link ()
 {
   assert (!index);//D
   uuid = UUID::gen ();
-  count = ++object_count;
 
   refcnt_inc ();
   objects.insert (this);
+
+  ++create_count;
+
 }
 
 void object::unlink ()
@@ -821,6 +852,8 @@
   if (!index)
     return;
 
+  ++destroy_count;
+
   objects.erase (this);
   refcnt_dec ();
 }
@@ -832,11 +865,13 @@
   if (active)
     return;
 
-  if (has_active_speed () && flag [FLAG_FREED]) LOG (llevError | logBacktrace, "BUG: tried to activate freed object %s\n", debug_desc ());//D
-  if (has_active_speed () && flag [FLAG_DEBUG]) LOG (llevError | logBacktrace, "BUG: tried to activate DEBUG object %s\n", debug_desc ());//D temp
-
   if (has_active_speed ())
-    actives.insert (this);
+    {
+      if (flag [FLAG_FREED])
+        LOG (llevError | logBacktrace, "BUG: tried to activate freed object %s\n", debug_desc ());//D
+
+      actives.insert (this);
+    }
 }
 
 void
@@ -932,25 +967,97 @@
     }
 }
 
-object *object::create ()
+/*
+ * Remove and free all objects in the inventory of the given object.
+ * Unlike destroy_inv, this assumes the *this is destroyed as well
+ * well, so we can (and have to!) take shortcuts.
+ */
+void
+object::destroy_inv_fast ()
+{
+  while (object *op = inv)
+    {
+      // remove from object the fast way
+      op->flag [FLAG_REMOVED] = true;
+      op->env = 0;
+      if ((inv = inv->below))
+        inv->above = 0;
+
+      // then destroy
+      op->destroy ();
+    }
+}
+
+void
+object::freelist_free (int count)
 {
-  object *op = new object;
+  while (count-- && freelist)
+    {
+      freelist_item *next = freelist->next;
+      // count is being "destroyed"
+
+      sfree ((char *)freelist, sizeof (object));
+
+      freelist = next;
+      --free_count;
+    }
+}
+
+object *
+object::create ()
+{
+  object *op;
+
+  if (freelist)
+    {
+      freelist_item li = *freelist;
+      memset (freelist, 0, sizeof (object));
+
+      op = new (freelist) object;
+      op->count = li.count;
+
+      freelist = li.next;
+      --free_count;
+    }
+  else
+    {
+      void *ni = salloc0<char> (sizeof (object));
+
+      op = new(ni) object;
+
+      op->count = ++object_count;
+    }
+
   op->link ();
+
   return op;
 }
 
+void
+object::do_delete ()
+{
+  uint32_t count = this->count;
+
+  this->~object ();
+
+  freelist_item *li = (freelist_item *)this;
+  li->next  = freelist;
+  li->count = count;
+
+  freelist = li;
+  ++free_count;
+}
+
 static struct freed_map : maptile
 {
   freed_map ()
+  : maptile (3, 3)
   {
     path     = "<freed objects map>";
     name     = "/internal/freed_objects_map";
-    width    = 3;
-    height   = 3;
     no_drop  = 1;
     no_reset = 1;
 
-    alloc ();
     in_memory = MAP_ACTIVE;
   }
 
@@ -964,7 +1071,7 @@
 object::do_destroy ()
 {
   if (flag [FLAG_IS_LINKED])
-    remove_button_link (this);
+    remove_link ();
 
   if (flag [FLAG_FRIENDLY])
     remove_friendly_object (this);
@@ -1011,7 +1118,7 @@
       return;
     }
 
-  destroy_inv (false);
+  destroy_inv_fast ();
 
   if (is_head ())
     if (sound_destroy)
@@ -1032,9 +1139,6 @@
 void
 object::do_remove ()
 {
-  object *tmp, *last = 0;
-  object *otmp;
-
   if (flag [FLAG_REMOVED])
     return;
 
@@ -1056,7 +1160,7 @@
         esrv_del_item (pl->contr, count);
       flag [FLAG_REMOVED] = true; // hack around the issue of visible_to checking flag_removed
 
-      adjust_weight (env, -total_weight ());
+      adjust_weight (env, total_weight (), 0);
 
       object *pl = in_player ();
 
@@ -1076,18 +1180,27 @@
       below = 0;
       env   = 0;
 
-      /* NO_FIX_PLAYER is set when a great many changes are being
-       * made to players inventory.  If set, avoiding the call
-       * to save cpu time.
-       */
-      if (pl)
-        if (pl->contr && !QUERY_FLAG (pl, FLAG_NO_FIX_PLAYER))
-          {
-            pl->update_stats ();
+      if (pl && pl->is_player ())
+        {
+          if (expect_false (pl->contr->combat_ob == this))
+            {
+              pl->apply (pl->contr->combat_ob, AP_UNAPPLY | AP_IGNORE_CURSE);
+              pl->contr->combat_ob = 0;
+              if (pl->contr->ranged_ob) pl->apply (pl->contr->ranged_ob);
+            }
 
-            if (affects_los () && pl->is_on_map () && pl->map->darkness)
-              update_all_los (pl->map, pl->x, pl->y);
-          }
+          if (expect_false (pl->contr->ranged_ob == this))
+            {
+              pl->apply (pl->contr->ranged_ob, AP_UNAPPLY | AP_IGNORE_CURSE);
+              pl->contr->ranged_ob = 0;
+              if (pl->contr->combat_ob) pl->apply (pl->contr->combat_ob);
+            }
+
+          pl->contr->queue_stats_update ();
+
+          if (expect_false (glow_radius) && pl->is_on_map ())
+            update_all_los (pl->map, pl->x, pl->y);
+        }
     }
   else if (map)
     {
@@ -1096,8 +1209,11 @@
 
       if (object *pl = ms.player ())
         {
-          if (type == PLAYER) // this == pl(!)
+          if (is_player ())
             {
+              if (!flag [FLAG_WIZPASS])
+                ms.smell = ++mapspace::smellcount; // remember the smell of the player
+
               // leaving a spot always closes any open container on the ground
               if (container && !container->env)
                 // this causes spurious floorbox updates, but it ensures
@@ -1107,13 +1223,13 @@
               --map->players;
               map->touch ();
             }
-          else if (pl->container == this)
+          else if (pl->container_ () == this)
             {
               // removing a container should close it
               close_container ();
             }
-
-          esrv_del_item (pl->contr, count);
+          else
+            esrv_del_item (pl->contr, count);
         }
 
       /* link the object above us */
@@ -1133,7 +1249,7 @@
 
       if (object *pl = ms.player ())
         {
-          if (pl->container == this)
+          if (pl->container_ () == this)
             /* If a container that the player is currently using somehow gets
              * removed (most likely destroyed), update the player view
              * appropriately.
@@ -1147,27 +1263,22 @@
             pl->contr->ns->floorbox_update ();
         }
 
-      for (tmp = ms.bot; tmp; tmp = tmp->above)
-        {
-          /* No point updating the players look faces if he is the object
-           * being removed.
-           */
-
-          /* 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))
-            {
-              move_apply (tmp, this, 0);
+      if (check_walk_off)
+        for (object *above, *tmp = ms.bot; tmp; tmp = above)
+          {
+            above = tmp->above;
 
-              if (destroyed ())
-                LOG (llevError, "BUG: remove_ob(): name %s, destroyed leaving object\n", tmp->debug_desc ());
-            }
+            /* No point updating the players look faces if he is the object
+             * being removed.
+             */
 
-          last = tmp;
-        }
+            /* See if object moving off should effect something */
+            if ((move_type & tmp->move_off)
+                && (move_type & ~tmp->move_off & ~tmp->move_block) == 0)
+              move_apply (tmp, this, 0);
+          }
 
-      if (map->darkness && affects_los ())
+      if (affects_los ())
         update_all_los (map, x, y);
     }
 }
@@ -1219,7 +1330,7 @@
 
   for (archetype *at = (archetype *)arch->more; at; at = (archetype *)at->more)
     {
-      object *op = arch_to_object (at);
+      object *op = at->instance ();
 
       op->name    = name;
       op->name_pl = name_pl;
@@ -1267,7 +1378,7 @@
  *
  * Return value:
  *   new object if 'op' was merged with other object
- *   NULL if 'op' was destroyed
+ *   NULL if there was an error (destroyed, blocked etc.)
  *   just 'op' otherwise
  */
 object *
@@ -1284,7 +1395,8 @@
    * of areas of callers (eg, anything that uses find_free_spot would now
    * need extra work
    */
-  if (!xy_normalise (m, op->x, op->y))
+  maptile *newmap = m;
+  if (!xy_normalise (newmap, op->x, op->y))
     {
       op->head_ ()->destroy ();// remove head_ once all tail object destroyers found
       return 0;
@@ -1294,9 +1406,10 @@
     if (!insert_ob_in_map (more, m, originator, flag))
       return 0;
 
-  CLEAR_FLAG (op, FLAG_REMOVED);
+  op->flag [FLAG_REMOVED] = false;
+  op->env = 0;
+  op->map = newmap;
 
-  op->map = m;
   mapspace &ms = op->ms ();
 
   /* this has to be done after we translate the coordinates.
@@ -1312,11 +1425,11 @@
           tmp->destroy ();
         }
 
-  CLEAR_FLAG (op, FLAG_APPLIED);        /* hack for fixing F_APPLIED in items of dead people */
-  CLEAR_FLAG (op, FLAG_INV_LOCKED);
+  op->clr_flag (FLAG_APPLIED);        /* hack for fixing F_APPLIED in items of dead people */
+  op->clr_flag (FLAG_INV_LOCKED);
 
-  if (!QUERY_FLAG (op, FLAG_ALIVE))
-    CLEAR_FLAG (op, FLAG_NO_STEAL);
+  if (!op->flag [FLAG_ALIVE])
+    op->clr_flag (FLAG_NO_STEAL);
 
   if (flag & INS_BELOW_ORIGINATOR)
     {
@@ -1327,8 +1440,11 @@
         }
 
       if (!originator->is_on_map ())
-        LOG (llevDebug | logBacktrace, "insert_ob_in_map(%s) called with INS_BELOW_ORIGINATOR when originator '%s' not on map",
-             op->debug_desc (), originator->debug_desc ());
+        {
+          LOG (llevError, "insert_ob_in_map(%s) called with INS_BELOW_ORIGINATOR when originator '%s' not on map",
+               op->debug_desc (), originator->debug_desc ());
+          abort ();
+        }
 
       op->above = originator;
       op->below = originator->below;
@@ -1358,10 +1474,10 @@
            */
           for (object *tmp = ms.bot; tmp; tmp = tmp->above)
             {
-              if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) || QUERY_FLAG (tmp, FLAG_OVERLAY_FLOOR))
+              if (tmp->flag [FLAG_IS_FLOOR] || tmp->flag [FLAG_OVERLAY_FLOOR])
                 floor = tmp;
 
-              if (QUERY_FLAG (tmp, FLAG_NO_PICK) && (tmp->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !QUERY_FLAG (tmp, FLAG_IS_FLOOR))
+              if (tmp->flag [FLAG_NO_PICK] && (tmp->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !tmp->flag [FLAG_IS_FLOOR])
                 {
                   /* We insert above top, so we want this object below this */
                   top = tmp->below;
@@ -1389,7 +1505,7 @@
               object *last;
 
               for (last = top; last != floor; last = last->below)
-                if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT))
+                if (last->flag [FLAG_BLOCKSVIEW] && (last->type != EXIT))
                   break;
 
               /* Check to see if we found the object that blocks view,
@@ -1424,7 +1540,7 @@
         }
     }
 
-  if (op->type == PLAYER)
+  if (op->is_player ())
     {
       op->contr->do_los = 1;
       ++op->map->players;
@@ -1449,7 +1565,7 @@
    * or just updating the P_UPTODATE for spaces within this area
    * of effect may be sufficient.
    */
-  if (op->affects_los () && op->map->darkness)
+  if (op->affects_los ())
     {
       op->ms ().invalidate ();
       update_all_los (op->map, op->x, op->y);
@@ -1470,16 +1586,16 @@
    */
 
   /* if this is not the head or flag has been passed, don't check walk on status */
-  if (!(flag & INS_NO_WALK_ON) && op->head_ () == op)
+  if (!(flag & INS_NO_WALK_ON) && op->is_head ())
     {
-      if (check_move_on (op, originator))
+      if (check_move_on (op, originator, flag))
         return 0;
 
-      /* If we are a multi part object, lets work our way through the check
+      /* If we are a multi part object, let's work our way through the check
        * walk on's.
        */
       for (object *tmp = op->more; tmp; tmp = tmp->more)
-        if (check_move_on (tmp, originator))
+        if (check_move_on (tmp, originator, flag))
           return 0;
     }
 
@@ -1491,15 +1607,15 @@
  * 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)
+replace_insert_ob_in_map (shstr_tmp archname, object *op)
 {
   /* first search for itself and remove any old instances */
 
   for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
-    if (!strcmp (tmp->arch->archname, arch_string))       /* same archetype */
+    if (tmp->arch->archname == archname)       /* same archetype */
       tmp->destroy ();
 
-  object *tmp = arch_to_object (archetype::find (arch_string));
+  object *tmp = archetype::find (archname)->instance ();
 
   tmp->x = op->x;
   tmp->y = op->y;
@@ -1516,6 +1632,28 @@
     return where->map->insert (this, where->x, where->y, originator, flags);
 }
 
+// check whether we can put this into the map, respect max_volume, max_items
+bool
+object::can_drop_at (maptile *m, int x, int y, object *originator)
+{
+  mapspace &ms = m->at (x, y);
+
+  int items = ms.items ();
+
+  if (!items // testing !items ensures we can drop at least one item
+      || (items < m->max_items
+          && ms.volume () < m->max_volume))
+    return true;
+
+  if (originator && originator->is_player ())
+    originator->contr->failmsgf (
+       "No matter how hard you try, you just cannot put the %s here H<Try to remove some items from the floor first.>",
+       query_name ()
+    );
+
+  return false;
+}
+
 /*
  * decrease(object, number) decreases a specified number from
  * the amount of an object. If the amount reaches 0, the object
@@ -1533,12 +1671,15 @@
 
   if (nrof > nr)
     {
+      sint64 oweight = total_weight ();
+
       nrof -= nr;
-      adjust_weight (env, -weight * max (1, nr)); // carrying == 0
 
       if (object *pl = visible_to ())
         esrv_update_item (UPD_NROF, pl, this);
 
+      adjust_weight (env, oweight, total_weight ());
+
       return true;
     }
   else
@@ -1622,13 +1763,17 @@
       if (object::can_merge (tmp, op))
         {
           /* return the original object and remove inserted object
-             (client needs the original object) */
+             (client prefers the original object) */
+
+          // carring must be 0 for mergable objects
+          sint64 oweight = tmp->weight * tmp->nrof;
+
           tmp->nrof += op->nrof;
 
           if (object *pl = tmp->visible_to ())
             esrv_update_item (UPD_NROF, pl, tmp);
 
-          adjust_weight (this, op->total_weight ());
+          adjust_weight (this, oweight, tmp->weight * tmp->nrof);
 
           op->destroy ();
           op = tmp;
@@ -1654,18 +1799,18 @@
   if (object *pl = op->visible_to ())
     esrv_send_item (pl, op);
 
-  adjust_weight (this, op->total_weight ());
+  adjust_weight (this, 0, op->total_weight ());
 
 inserted:
   /* reset the light list and los of the players on the map */
-  if (op->glow_radius && is_on_map () && map->darkness)
+  if (op->glow_radius && is_on_map ())
     {
       update_stats ();
       update_all_los (map, x, y);
     }
-  else if (type == PLAYER && !flag [FLAG_NO_FIX_PLAYER])
+  else if (is_player ())
     // if this is a player's inventory, update stats
-    update_stats ();
+    contr->queue_stats_update ();
 
   INVOKE_OBJECT (INSERT, this);
 
@@ -1693,20 +1838,22 @@
  * on top.
  */
 int
-check_move_on (object *op, object *originator)
+check_move_on (object *op, object *originator, int flags)
 {
+  if (op->flag [FLAG_NO_APPLY])
+    return 0;
+
   object *tmp;
   maptile *m = op->map;
   int x = op->x, y = op->y;
 
-  MoveType move_on, move_slow, move_block;
+  mapspace &ms = m->at (x, y);
 
-  if (QUERY_FLAG (op, FLAG_NO_APPLY))
-    return 0;
+  ms.update ();
 
-  move_on = GET_MAP_MOVE_ON (op->map, op->x, op->y);
-  move_slow = GET_MAP_MOVE_SLOW (op->map, op->x, op->y);
-  move_block = GET_MAP_MOVE_BLOCK (op->map, op->x, op->y);
+  MoveType move_on    = ms.move_on;
+  MoveType move_slow  = ms.move_slow;
+  MoveType move_block = ms.move_block;
 
   /* if nothing on this space will slow op down or be applied,
    * no need to do checking below.    have to make sure move_type
@@ -1727,19 +1874,10 @@
   /* The objects have to be checked from top to bottom.
    * Hence, we first go to the top: 
    */
-
-  for (tmp = op->ms ().bot; tmp && tmp->above; tmp = tmp->above)
+  for (object *next, *tmp = ms.top; tmp; tmp = next)
     {
-      /* Trim the search when we find the first other spell effect 
-       * this helps performance so that if a space has 50 spell objects,
-       * we don't need to check all of them.
-       */
-      if ((tmp->move_type & MOVE_FLY_LOW) && QUERY_FLAG (tmp, FLAG_NO_PICK))
-        break;
-    }
+      next = tmp->below;
 
-  for (; tmp; tmp = tmp->below)
-    {
       if (tmp == op)
         continue;               /* Can't apply yourself */
 
@@ -1749,18 +1887,16 @@
        * space doesn't slow down swimming (for example), if you can't actually
        * swim on that space, can't use it to avoid the penalty.
        */
-      if (!QUERY_FLAG (op, FLAG_WIZPASS))
+      if (!op->flag [FLAG_WIZPASS])
         {
           if ((!op->move_type && tmp->move_slow & MOVE_WALK) ||
               ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0))
             {
+              float diff = tmp->move_slow_penalty * fabs (op->speed);
 
-              float
-                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)) ||
-                    (QUERY_FLAG (tmp, FLAG_IS_WOODED) && find_skill_by_number (op, SK_WOODSMAN)))
+              if (op->is_player ())
+                if ((tmp->flag [FLAG_IS_HILLY ] && find_skill_by_number (op, SK_CLIMBING)) ||
+                    (tmp->flag [FLAG_IS_WOODED] && find_skill_by_number (op, SK_WOODSMAN)))
                   diff /= 4.0;
 
               op->speed_left -= diff;
@@ -1771,6 +1907,11 @@
       if ((!op->move_type && tmp->move_on & MOVE_WALK) ||
           ((op->move_type & tmp->move_on) && (op->move_type & ~tmp->move_on & ~tmp->move_block) == 0))
         {
+          if ((flags & INS_NO_AUTO_EXIT)
+              && (tmp->type == EXIT || tmp->type == TELEPORTER
+                  || tmp->type == HOLE || tmp->type == TRAPDOOR)) //TODO: temporary, fix exits instead
+            continue;
+
           move_apply (tmp, op, originator);
 
           if (op->destroyed ())
@@ -1892,7 +2033,7 @@
 {
   for (object *tmp = op->inv; tmp; tmp = tmp->below)
     {
-      SET_FLAG (tmp, flag);
+      tmp->set_flag (flag);
       flag_inv (tmp, flag);
     }
 }
@@ -1905,7 +2046,7 @@
 {
   for (object *tmp = op->inv; tmp; tmp = tmp->below)
     {
-      CLEAR_FLAG (tmp, flag);
+      tmp->clr_flag (flag);
       unflag_inv (tmp, flag);
     }
 }
@@ -2054,13 +2195,8 @@
 int
 find_dir (maptile *m, int x, int y, object *exclude)
 {
-  int i, max = SIZEOFFREE, mflags;
-
-  sint16 nx, ny;
-  object *tmp;
-  maptile *mp;
-
-  MoveType blocked, move_type;
+  int max = SIZEOFFREE, mflags;
+  MoveType move_type;
 
   if (exclude && exclude->head_ () != exclude)
     {
@@ -2073,33 +2209,25 @@
       move_type = MOVE_ALL;
     }
 
-  for (i = 1; i < max; i++)
+  for (int i = 1; i < max; i++)
     {
-      mp = m;
-      nx = x + freearr_x[i];
-      ny = y + freearr_y[i];
+      mapxy pos (m, x, y);
+      pos.move (i);
 
-      mflags = get_map_flags (m, &mp, nx, ny, &nx, &ny);
-
-      if (mflags & P_OUT_OF_MAP)
+      if (!pos.normalise ())
         max = maxfree[i];
       else
         {
-          mapspace &ms = mp->at (nx, ny);
+          mapspace &ms = *pos;
 
-          blocked = ms.move_block;
-
-          if ((move_type & blocked) == move_type)
-            max = maxfree[i];
-          else if (mflags & P_IS_ALIVE)
+          if ((move_type & ms.move_block) == move_type)
+            max = maxfree [i];
+          else if (ms.flags () & P_IS_ALIVE)
             {
-              for (tmp = ms.bot; tmp; tmp = tmp->above)
-                if ((tmp->flag [FLAG_MONSTER] || tmp->type == PLAYER)
+              for (object *tmp = ms.bot; tmp; tmp = tmp->above)
+                if ((tmp->flag [FLAG_MONSTER] || tmp->is_player ())
                     && (tmp != exclude || (tmp->head_ () != tmp && tmp->head_ () != exclude)))
-                  break;
-
-              if (tmp)
-                return freedir[i];
+                  return freedir [i];
             }
         }
     }
@@ -2118,45 +2246,84 @@
 }
 
 /*
- * find_dir_2(delta-x,delta-y) will return a direction in which
- * an object which has subtracted the x and y coordinates of another
- * object, needs to travel toward it.
+ * find_dir_2(delta-x,delta-y) will return a direction value
+ * for running into direct [dx, dy].
+ * (the opposite of crossfire's find_dir_2!)
  */
 int
 find_dir_2 (int x, int y)
 {
+#if 1 // new algorithm
+  // this works by putting x, y into 16 sectors, which
+  // are not equal sized, but are a better approximation
+  // then the old algorithm, and then using a mapping
+  // table to map it into a direction value.
+  // basically, it maps these comparisons to each bit
+  // bit #3: x < 0
+  // bit #2: y < 0
+  // bit #1: x > y
+  // bit #0: x > 2y
+
+  static const uint8 dir[16] = {
+     4,  5,  4,  3,
+     2,  1,  2,  3,
+     6,  5,  6,  7,
+     8,  1,  8,  7,
+  };
+  int sector = 0;
+
+  // this is a bit ugly, but more likely to result in branchless code
+  sector |= x < 0 ? 8 : 0;
+  x      =  x < 0 ? -x : x; // abs
+
+  sector |= y < 0 ? 4 : 0;
+  y      =  y < 0 ? -y : y; // abs
+
+  if (x > y)
+    {
+      sector |= 2;
+
+      if (x > y * 2)
+        sector |= 1;
+    }
+  else
+    {
+      if (y > x * 2)
+        sector |= 1;
+      else if (!y)
+        return 0; // x == 0 here
+    }
+
+  return dir [sector];
+#else // old algorithm
   int q;
 
   if (y)
-    q = x * 100 / y;
+    q = 128 * x / y;
   else if (x)
-    q = -300 * x;
+    q = -512 * x; // to make it > 309
   else
     return 0;
 
   if (y > 0)
     {
-      if (q < -242)
-        return 3;
-      if (q < -41)
-        return 2;
-      if (q < 41)
-        return 1;
-      if (q < 242)
-        return 8;
-      return 7;
-    }
+      if (q < -309) return 7;
+      if (q <  -52) return 6;
+      if (q <   52) return 5;
+      if (q <  309) return 4;
 
-  if (q < -242)
-    return 7;
-  if (q < -41)
-    return 6;
-  if (q < 41)
-    return 5;
-  if (q < 242)
-    return 4;
+      return 3;
+    }
+  else
+    {
+      if (q < -309) return 3;
+      if (q <  -52) return 2;
+      if (q <   52) return 1;
+      if (q <  309) return 8;
 
-  return 3;
+      return 7;
+    }
+#endif
 }
 
 /*
@@ -2166,13 +2333,9 @@
 int
 dirdiff (int dir1, int dir2)
 {
-  int d;
+  int d = abs (dir1 - dir2);
 
-  d = abs (dir1 - dir2);
-  if (d > 4)
-    d = 8 - d;
-
-  return d;
+  return d > 4 ? 8 - d : d;
 }
 
 /* peterm:
@@ -2184,7 +2347,7 @@
  * Moved from spell_util.c to object.c with the other related direction
  * functions.
  */
-int reduction_dir[SIZEOFFREE][3] = {
+static const int reduction_dir[SIZEOFFREE][3] = {
   {0, 0, 0},                    /* 0 */
   {0, 0, 0},                    /* 1 */
   {0, 0, 0},                    /* 2 */
@@ -2288,9 +2451,9 @@
 int
 can_pick (const object *who, const object *item)
 {
-  return                        /*QUERY_FLAG(who,FLAG_WIZ)|| */
-    (item->weight > 0 && !QUERY_FLAG (item, FLAG_NO_PICK) &&
-     !QUERY_FLAG (item, FLAG_ALIVE) && !item->invisible && (who->type == PLAYER || item->weight < who->weight / 3));
+  return                        /*who->flag [FLAG_WIZ]|| */
+    (item->weight > 0 && !item->flag [FLAG_NO_PICK] &&
+     !item->flag [FLAG_ALIVE] && !item->invisible && (who->is_player () || item->weight < who->weight / 3));
 }
 
 /*
@@ -2332,18 +2495,18 @@
   return 0;
 }
 
-const shstr &
-object::kv_get (const shstr &key) const
+shstr_tmp
+object::kv_get (shstr_tmp key) const
 {
   for (key_value *kv = key_values; kv; kv = kv->next)
     if (kv->key == key)
       return kv->value;
 
-  return shstr_null;
+  return shstr ();
 }
 
 void
-object::kv_set (const shstr &key, const shstr &value)
+object::kv_set (shstr_tmp key, shstr_tmp value)
 {
   for (key_value *kv = key_values; kv; kv = kv->next)
     if (kv->key == key)
@@ -2362,7 +2525,7 @@
 }
 
 void
-object::kv_del (const shstr &key)
+object::kv_del (shstr_tmp key)
 {
   for (key_value **kvp = &key_values; *kvp; kvp = &(*kvp)->next)
     if ((*kvp)->key == key)
@@ -2465,15 +2628,6 @@
              : region::default_region ();
 }
 
-const materialtype_t *
-object::dominant_material () const
-{
-  if (materialtype_t *mt = name_to_material (materialname))
-    return mt;
-
-  return name_to_material (shstr_unknown);
-}
-
 void
 object::open_container (object *new_container)
 {
@@ -2503,7 +2657,7 @@
       // client needs item update to make it work, client bug requires this to be separate
       esrv_update_item (UPD_FLAGS, this, old_container);
 
-      new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", query_name (old_container));
+      new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", old_container->query_name ());
       play_sound (sound_find ("chest_close"));
     }
 
@@ -2517,13 +2671,13 @@
       // insert the "Close Container" object.
       if (archetype *closer = new_container->other_arch)
         {
-          object *closer = arch_to_object (new_container->other_arch);
+          object *closer = new_container->other_arch->instance ();
           closer->flag [FLAG_NO_MAP_SAVE] = 1;
           new_container->insert (closer);
         }
 #endif
 
-      new_draw_info_format (NDI_UNIQUE, 0, this, "You open %s.", query_name (new_container));
+      new_draw_info_format (NDI_UNIQUE, 0, this, "You open %s.", new_container->query_name ());
 
       // make sure the container is available, client bug requires this to be separate
       esrv_send_item (this, new_container);
@@ -2541,7 +2695,7 @@
 }
 
 object *
-object::force_find (const shstr name)
+object::force_find (shstr_tmp name)
 {
   /* cycle through his inventory to look for the MARK we want to 
    * place 
@@ -2553,41 +2707,51 @@
   return 0;
 }
 
+//-GPL
+
+void
+object::force_set_timer (int duration)
+{
+  this->duration   = 1;
+  this->speed_left = -1.f;
+
+  this->set_speed (duration ? 1.f / duration : 0.f);
+}
+
 object *
-object::force_add (const shstr name, int duration)
+object::force_add (shstr_tmp name, int duration)
 {
   if (object *force = force_find (name))
     force->destroy ();
 
   object *force = get_archetype (FORCE_NAME);
 
-  force->slaying    = name;
-  force->stats.food = 1;
-  force->speed_left = -1.f;
-
-  force->set_speed (duration ? 1.f / duration : 0.f);
-  force->flag [FLAG_IS_USED_UP] = true;
-  force->flag [FLAG_APPLIED]    = true;
+  force->slaying = name;
+  force->force_set_timer (duration);
+  force->flag [FLAG_APPLIED] = true;
 
   return insert (force);
 }
 
 void
-object::play_sound (faceidx sound)
+object::play_sound (faceidx sound) const
 {
   if (!sound)
     return;
 
-  if (flag [FLAG_REMOVED])
-    return;
-
-  if (env)
-    {
-      if (object *pl = in_player ())
-        pl->contr->play_sound (sound);
-    }
-  else
+  if (is_on_map ())
     map->play_sound (sound, x, y);
+  else if (object *pl = in_player ())
+    pl->contr->play_sound (sound);
+}
+
+void
+object::say_msg (const char *msg) const
+{
+  if (is_on_map ())
+    map->say_msg (msg, x, y);
+  else if (object *pl = in_player ())
+    pl->contr->play_sound (sound);
 }
 
 void
@@ -2598,20 +2762,24 @@
   // could use the map instead, but that's less reliable for our
   // goal, which is to make invisibility a bit harder to exploit
 
+  // currently only works sensibly for players
+  if (!is_player ())
+    return;
+
   // find old force, or create new one
   object *force = force_find (shstr_noise_force);
 
   if (force)
-    force->speed = 1.f / 4; // patch old speed up
+    force->speed_left = -1.f; // patch old speed up
   else
     {
-      force = get_archetype (shstr_noise_force);
+      force = archetype::get (shstr_noise_force);
 
-      force->slaying    = name;
+      force->slaying    = shstr_noise_force;
       force->stats.food = 1;
       force->speed_left = -1.f;
 
-      force->set_speed (1.f / 4);
+      force->set_speed (1.f / 4.f);
       force->flag [FLAG_IS_USED_UP] = true;
       force->flag [FLAG_APPLIED]    = true;
 
@@ -2619,3 +2787,44 @@
     }
 }
 
+void object::change_move_type (MoveType mt)
+{
+  if (move_type == mt)
+    return;
+
+  if (is_on_map ())
+    {
+      // we are on the map, so handle move_on/off effects
+      remove ();
+      move_type = mt;
+      map->insert (this, x, y, this);
+    }
+  else
+    move_type = mt;
+}
+
+/* object should be a player.
+ * we return the object the player has marked with the 'mark' command
+ * below. If no match is found (or object has changed), we return
+ * NULL. We leave it up to the calling function to print messages if
+ * nothing is found.
+ */
+object *
+object::mark () const
+{
+  if (contr && contr->mark && contr->mark->env == this)
+    return contr->mark;
+  else
+    return 0;
+}
+
+// put marked object first in the inventory
+// this is used by identify-like spells so players can influence
+// the order a bit.
+void
+object::splay_marked ()
+{
+  if (object *marked = mark ())
+    splay (marked);
+}
+