--- deliantra/server/include/util.h	2006/12/25 11:25:49	1.24
+++ deliantra/server/include/util.h	2007/01/15 01:50:33	1.30
@@ -8,12 +8,73 @@
 #endif
 
 #include <cstddef>
+#include <cmath>
+#include <new>
+#include <vector>
 
 #include <glib.h>
 
+#include <shstr.h>
+#include <traits.h>
+
 // use a gcc extension for auto declarations until ISO C++ sanctifies them
 #define AUTODECL(var,expr) typeof(expr) var = (expr)
 
+// very ugly macro that basicaly declares and initialises a variable
+// that is in scope for the next statement only
+// works only for stuff that can be assigned 0 and converts to false
+// (note: works great for pointers)
+// most ugly macro I ever wrote
+#define declvar(type, name, value) if (type name = 0) { } else if (((name) = (value)), 1)
+
+// in range including end
+#define IN_RANGE_INC(val,beg,end) \
+  ((unsigned int)(val) - (unsigned int)(beg) <= (unsigned int)(end) - (unsigned int)(beg))
+
+// in range excluding end
+#define IN_RANGE_EXC(val,beg,end) \
+  ((unsigned int)(val) - (unsigned int)(beg) <  (unsigned int)(end) - (unsigned int)(beg))
+
+// this is much faster than crossfires original algorithm
+// on modern cpus
+inline int
+isqrt (int n)
+{
+  return (int)sqrtf ((float)n);
+}
+
+// this is only twice as fast as naive sqrtf (dx*dy+dy*dy)
+#if 0
+// and has a max. error of 6 in the range -100..+100.
+#else
+// and has a max. error of 9 in the range -100..+100.
+#endif
+inline int 
+idistance (int dx, int dy)
+{ 
+  unsigned int dx_ = abs (dx);
+  unsigned int dy_ = abs (dy);
+
+#if 0
+  return dx_ > dy_
+      ? (dx_ * 61685 + dy_ * 26870) >> 16
+      : (dy_ * 61685 + dx_ * 26870) >> 16;
+#else
+  return dx_ + dy_ - min (dx_, dy_) * 5 / 8;
+#endif
+}
+
+/*
+ * absdir(int): Returns a number between 1 and 8, which represent
+ * the "absolute" direction of a number (it actually takes care of
+ * "overflow" in previous calculations of a direction).
+ */
+inline int
+absdir (int d)
+{
+  return ((d - 1) & 7) + 1;
+}
+
 // makes dynamically allocated objects zero-initialised
 struct zero_initialised
 {
@@ -193,10 +254,8 @@
   }
 };
 
-#include <vector>
-
-template<class obj>
-struct unordered_vector : std::vector<obj, slice_allocator<obj> >
+template<class T>
+struct unordered_vector : std::vector<T, slice_allocator<T> >
 {
   typedef typename unordered_vector::iterator iterator;
 
@@ -214,6 +273,42 @@
   }
 };
 
+template<class T, int T::* index>
+struct object_vector : std::vector<T *, slice_allocator<T *> >
+{
+  void insert (T *obj)
+  {
+    assert (!(obj->*index));
+    push_back (obj);
+    obj->*index = this->size ();
+  }
+
+  void insert (T &obj)
+  {
+    insert (&obj);
+  }
+
+  void erase (T *obj)
+  {
+    assert (obj->*index);
+    int pos = obj->*index;
+    obj->*index = 0;
+
+    if (pos < this->size ())
+      {
+        (*this)[pos - 1] = (*this)[this->size () - 1];
+        (*this)[pos - 1]->*index = pos;
+      }
+
+    this->pop_back ();
+  }
+
+  void erase (T &obj)
+  {
+    errase (&obj);
+  }
+};
+
 template<typename T, typename U> static inline T min (T a, U b) { return a < (T)b ? a : (T)b; }
 template<typename T, typename U> static inline T max (T a, U b) { return a > (T)b ? a : (T)b; }
 template<typename T, typename U, typename V> static inline T clamp (T v, U a, V b) { return v < (T)a ? a : v >(T)b ? b : v; }
@@ -235,5 +330,7 @@
 // return current time as timestampe
 tstamp now ();
 
+int similar_direction (int a, int b);
+
 #endif