--- deliantra/server/common/object.C	2010/04/10 04:54:09	1.321
+++ deliantra/server/common/object.C	2010/04/12 05:22:37	1.324
@@ -39,6 +39,12 @@
 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] = {
@@ -268,11 +274,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
@@ -331,14 +337,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)
@@ -685,7 +691,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);
@@ -761,12 +767,12 @@
     {
 #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))
+      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
@@ -797,7 +803,7 @@
 
 object::object ()
 {
-  SET_FLAG (this, FLAG_REMOVED);
+  this->set_flag (FLAG_REMOVED);
 
   //expmul = 1.0; declared const for the time being
   face     = blank_face;
@@ -811,16 +817,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 ()
@@ -828,6 +834,8 @@
   if (!index)
     return;
 
+  ++destroy_count;
+
   objects.erase (this);
   refcnt_dec ();
 }
@@ -962,13 +970,66 @@
     }
 }
 
-object *object::create ()
+void
+object::freelist_free (int count)
+{
+  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 = new object;
+  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 ()
@@ -1151,8 +1212,8 @@
               // 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 */
@@ -1348,11 +1409,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)
     {
@@ -1397,10 +1458,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;
@@ -1428,7 +1489,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,
@@ -1756,7 +1817,7 @@
 int
 check_move_on (object *op, object *originator)
 {
-  if (QUERY_FLAG (op, FLAG_NO_APPLY))
+  if (op->flag [FLAG_NO_APPLY])
     return 0;
 
   object *tmp;
@@ -1803,7 +1864,7 @@
        * 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))
@@ -1944,7 +2005,7 @@
 {
   for (object *tmp = op->inv; tmp; tmp = tmp->below)
     {
-      SET_FLAG (tmp, flag);
+      tmp->set_flag (flag);
       flag_inv (tmp, flag);
     }
 }
@@ -1957,7 +2018,7 @@
 {
   for (object *tmp = op->inv; tmp; tmp = tmp->below)
     {
-      CLEAR_FLAG (tmp, flag);
+      tmp->clr_flag (flag);
       unflag_inv (tmp, flag);
     }
 }
@@ -2327,9 +2388,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->is_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));
 }
 
 /*