--- deliantra/server/common/object.C	2010/04/11 00:34:05	1.322
+++ deliantra/server/common/object.C	2010/04/22 03:49:13	1.332
@@ -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] = {
@@ -441,8 +447,8 @@
     {
       // 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);
+      weight = weight_adjust_for (op, op->carrying + weight)
+             - weight_adjust_for (op, op->carrying);
 
       if (!weight)
         return;
@@ -479,6 +485,10 @@
 
   if (sum != carrying)
     {
+      if (carrying != sum)//D
+        LOG (llevDebug, "updating weight got %ld, expected %ld (%s)\n",
+             (long long)sum, (long long)carrying, debug_desc ());
+
       carrying = sum;
 
       if (object *pl = visible_to ())
@@ -811,16 +821,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 +838,8 @@
   if (!index)
     return;
 
+  ++destroy_count;
+
   objects.erase (this);
   refcnt_dec ();
 }
@@ -962,25 +974,76 @@
     }
 }
 
-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 ()
+  : 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;
   }
 
@@ -1151,8 +1214,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 */
@@ -2157,45 +2220,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
 }
 
 /*
@@ -2205,13 +2307,9 @@
 int
 dirdiff (int dir1, int dir2)
 {
-  int d;
-
-  d = abs (dir1 - dir2);
-  if (d > 4)
-    d = 8 - d;
+  int d = abs (dir1 - dir2);
 
-  return d;
+  return d > 4 ? 8 - d : d;
 }
 
 /* peterm:
@@ -2679,3 +2777,18 @@
     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;
+}
+