--- deliantra/server/common/utils.C	2007/01/18 19:32:37	1.40
+++ deliantra/server/common/utils.C	2007/01/25 03:54:44	1.44
@@ -39,14 +39,15 @@
 
 #include <glib.h>
 
-rand_gen rndm (time (0));
+rand_gen rndm;
 
-tausworthe_random_generator::tausworthe_random_generator (uint32_t seed)
+void
+tausworthe_random_generator::seed (uint32_t seed)
 {
-  state [0] = max (  2, seed      * 69069U);
-  state [1] = max (  8, state [0] * 69069U);
-  state [2] = max ( 16, state [1] * 69069U);
-  state [3] = max (128, state [2] * 69069U);
+  state [0] = max (  2U, seed      * 69069U);
+  state [1] = max (  8U, state [0] * 69069U);
+  state [2] = max ( 16U, state [1] * 69069U);
+  state [3] = max (128U, state [2] * 69069U);
 
   for (int i = 11; --i; )
     operator ()();
@@ -63,6 +64,19 @@
   return state [0] ^ state [1] ^ state [2] ^ state [3];
 }
 
+uint32_t
+tausworthe_random_generator::get_range (uint32_t r_max)
+{
+  return next () % r_max;
+}
+
+// return a number within (min .. max)
+int 
+tausworthe_random_generator::get_range (int r_min, int r_max)
+{
+  return r_min + (*this) (max (r_max - r_min + 1, 1));
+}
+
 /*
  * The random functions here take luck into account when rolling random
  * dice or numbers.  This function has less of an impact the larger the
@@ -79,38 +93,27 @@
  * not the recipient (ie, the poor slob getting hit). [garbled 20010916]
  */
 int
-random_roll (int min, int max, const object *op, int goodbad)
+random_roll (int r_min, int r_max, const object *op, int goodbad)
 {
-  int omin, diff, luck, base, ran;
+  int base = r_max - r_min > 1 ? 20 : 50;     /* d2 and d3 are corner cases */
 
-  omin = min;
-  diff = max - min + 1;
-  ((diff > 2) ? (base = 20) : (base = 50));     /* d2 and d3 are corner cases */
-
-  if (max < 1 || diff < 1)
+  if (r_max < 1 || r_max < r_min)
     {
-      LOG (llevError, "Calling random_roll with min=%d max=%d\n", min, max);
-      return (min);             /* avoids a float exception */
+      LOG (llevError, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
+      return r_min;
     }
 
-  ran = RANDOM ();
-
-  if (op->type != PLAYER)
-    return ((ran % diff) + min);
-
-  luck = op->stats.luck;
-  if (RANDOM () % base < MIN (10, abs (luck)))
+  if (op->type == PLAYER)
     {
-      /* we have a winner */
-      ((luck > 0) ? (luck = 1) : (luck = -1));
-      diff -= luck;
-      if (diff < 1)
-        return (omin);          /*check again */
-      ((goodbad) ? (min += luck) : (diff));
+      int luck = op->stats.luck;
 
-      return (MAX (omin, MIN (max, (ran % diff) + min)));
+      if (rndm (base) < min (10, abs (luck)))
+        {
+          //TODO: take luck into account
+        }
     }
-  return ((ran % diff) + min);
+
+  return rndm (r_min, r_max);
 }
 
 /*
@@ -569,7 +572,11 @@
 
 void *salloc_ (int n) throw (std::bad_alloc)
 {
+#ifdef PREFER_MALLOC
+  void *ptr = malloc (n);
+#else
   void *ptr = g_slice_alloc (n);
+#endif
 
   if (!ptr)
     throw std::bad_alloc ();