--- deliantra/server/include/util.h	2006/09/12 18:15:34	1.9
+++ deliantra/server/include/util.h	2007/01/18 22:20:00	1.33
@@ -7,25 +7,221 @@
 # define is_constant(c) 0
 #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))
+
+void fork_abort (const char *msg);
+
+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; }
+
+template<typename T, typename U> static inline void swap (T& a, U& b) { T t=a; a=(T)b; b=(U)t; }
+
+// 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
 {
-  void *operator new (size_t s, void *);
-  void *operator new (size_t s);
-  void *operator new [] (size_t s);
-  void operator delete (void *p, size_t s);
-  void operator delete [] (void *p, size_t s);
+  void *operator new (size_t s, void *p)
+  {
+    memset (p, 0, s);
+    return p;
+  }
+
+  void *operator new (size_t s)
+  {
+    return g_slice_alloc0 (s);
+  }
+
+  void *operator new[] (size_t s)
+  {
+    return g_slice_alloc0 (s);
+  }
+
+  void operator delete (void *p, size_t s)
+  {
+    g_slice_free1 (s, p);
+  }
+
+  void operator delete[] (void *p, size_t s)
+  {
+    g_slice_free1 (s, p);
+  }
+};
+
+void *salloc_ (int n)            throw (std::bad_alloc);
+void *salloc_ (int n, void *src) throw (std::bad_alloc);
+
+// strictly the same as g_slice_alloc, but never returns 0
+template<typename T>
+inline T *salloc (int n = 1)     throw (std::bad_alloc) { return (T *)salloc_ (n * sizeof (T));              }
+
+// also copies src into the new area, like "memdup"
+// if src is 0, clears the memory
+template<typename T>
+inline T *salloc (int n, T *src) throw (std::bad_alloc) { return (T *)salloc_ (n * sizeof (T), (void *)src); }
+
+// clears the memory
+template<typename T>
+inline T *salloc0(int n = 1)     throw (std::bad_alloc) { return (T *)salloc_ (n * sizeof (T), 0);           }
+
+// for symmetry
+template<typename T>
+inline void sfree (T *ptr, int n = 1) throw ()
+{
+  g_slice_free1 (n * sizeof (T), (void *)ptr);
+}
+
+// a STL-compatible allocator that uses g_slice
+// boy, this is verbose
+template<typename Tp>
+struct slice_allocator
+{
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef Tp *pointer;
+  typedef const Tp *const_pointer;
+  typedef Tp &reference;
+  typedef const Tp &const_reference;
+  typedef Tp value_type;
+
+  template <class U> 
+  struct rebind
+  {
+    typedef slice_allocator<U> other;
+  };
+
+  slice_allocator () throw () { }
+  slice_allocator (const slice_allocator &o) throw () { }
+  template<typename Tp2>
+  slice_allocator (const slice_allocator<Tp2> &) throw () { }
+
+  ~slice_allocator () { }
+
+  pointer address (reference x) const { return &x; }
+  const_pointer address (const_reference x) const { return &x; }
+
+  pointer allocate (size_type n, const_pointer = 0)
+  {
+    return salloc<Tp> (n);
+  }
+
+  void deallocate (pointer p, size_type n)
+  {
+    sfree<Tp> (p, n);
+  }
+
+  size_type max_size ()const throw ()
+  {
+    return size_t (-1) / sizeof (Tp);
+  }
+
+  void construct (pointer p, const Tp &val)
+  {
+    ::new (p) Tp (val);
+  }
+
+  void destroy (pointer p)
+  {
+    p->~Tp ();
+  }
 };
 
-struct refcounted
-{
-  mutable int refcnt;
-  refcounted () : refcnt (0) { }
-  void refcnt_inc () { ++refcnt; }
-  void refcnt_dec () { --refcnt;
-  if (refcnt < 0)abort();}//D
+// P. L'Ecuyer, “Maximally Equidistributed Combined Tausworthe Generators”, Mathematics of Computation, 65, 213 (1996), 203–213.
+// http://www.iro.umontreal.ca/~lecuyer/myftp/papers/tausme.ps
+// http://www.iro.umontreal.ca/~lecuyer/myftp/papers/tausme2.ps
+struct tausworthe_random_generator
+{
+  uint32_t state [4];
+
+  tausworthe_random_generator (uint32_t seed);
+  uint32_t next ();
+
+  uint32_t operator ()(uint32_t r_max)
+  {
+    return next () % r_max;
+  }
+
+  // return a number within (min .. max)
+  int operator () (int r_min, int r_max)
+  {
+    return r_min + (*this) (max (r_max - r_min + 1, 1));
+  }
+
+  double operator ()()
+  {
+    return next () / (double)0xFFFFFFFFU;
+  }
 };
 
+typedef tausworthe_random_generator rand_gen;
+
+extern rand_gen rndm;
+
 template<class T>
 struct refptr
 {
@@ -57,6 +253,12 @@
   operator T *() const { return p; }
 };
 
+typedef refptr<maptile>   maptile_ptr;
+typedef refptr<object>    object_ptr;
+typedef refptr<archetype> arch_ptr;
+typedef refptr<client>    client_ptr;
+typedef refptr<player>    player_ptr;
+
 struct str_hash
 {
   std::size_t operator ()(const char *s) const
@@ -91,12 +293,10 @@
   }
 };
 
-#include <vector>
-
-template<class obj>
-struct unordered_vector : std::vector<obj>
+template<class T>
+struct unordered_vector : std::vector<T, slice_allocator<T> >
 {
-  typedef typename std::vector<obj>::iterator iterator;
+  typedef typename unordered_vector::iterator iterator;
 
   void erase (unsigned int pos)
   {
@@ -112,20 +312,58 @@
   }
 };
 
-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; }
+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 ();
+  }
 
-template<typename T, typename U> static inline void swap (T& a, U& b) { T t=a; a=(T)b; b=(U)t; }
+  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;
+      }
 
-// basically does what strncpy should do
+    this->pop_back ();
+  }
+
+  void erase (T &obj)
+  {
+    errase (&obj);
+  }
+};
+
+// basically does what strncpy should do, but appends "..." to strings exceeding length
+void assign (char *dst, const char *src, int maxlen);
+
+// type-safe version of assign
 template<int N>
 inline void assign (char (&dst)[N], const char *src)
 {
-  // should be optimised at some point, maybe should also add "..."
-  // when buffer is too small.
-  snprintf (dst, N, "%s", src);
+  assign ((char *)&dst, src, N);
 }
 
+typedef double tstamp;
+
+// return current time as timestampe
+tstamp now ();
+
+int similar_direction (int a, int b);
+
 #endif