ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/include/util.h
(Generate patch)

Comparing deliantra/server/include/util.h (file contents):
Revision 1.24 by root, Mon Dec 25 11:25:49 2006 UTC vs.
Revision 1.35 by root, Fri Jan 19 22:47:57 2007 UTC

… …
6#else 6#else
7# define is_constant(c) 0 7# define is_constant(c) 0
8#endif 8#endif
9 9
10#include <cstddef> 10#include <cstddef>
11#include <cmath>
12#include <new>
13#include <vector>
11 14
12#include <glib.h> 15#include <glib.h>
16
17#include <shstr.h>
18#include <traits.h>
13 19
14// use a gcc extension for auto declarations until ISO C++ sanctifies them 20// use a gcc extension for auto declarations until ISO C++ sanctifies them
15#define AUTODECL(var,expr) typeof(expr) var = (expr) 21#define AUTODECL(var,expr) typeof(expr) var = (expr)
22
23// very ugly macro that basicaly declares and initialises a variable
24// that is in scope for the next statement only
25// works only for stuff that can be assigned 0 and converts to false
26// (note: works great for pointers)
27// most ugly macro I ever wrote
28#define declvar(type, name, value) if (type name = 0) { } else if (((name) = (value)), 1)
29
30// in range including end
31#define IN_RANGE_INC(val,beg,end) \
32 ((unsigned int)(val) - (unsigned int)(beg) <= (unsigned int)(end) - (unsigned int)(beg))
33
34// in range excluding end
35#define IN_RANGE_EXC(val,beg,end) \
36 ((unsigned int)(val) - (unsigned int)(beg) < (unsigned int)(end) - (unsigned int)(beg))
37
38void fork_abort (const char *msg);
39
40// rationale for using (U) not (T) is to reduce signed/unsigned issues,
41// as a is often a constant while b is the variable. it is still a bug, though.
42template<typename T, typename U> static inline T min (T a, U b) { return (U)a < b ? (U)a : b; }
43template<typename T, typename U> static inline T max (T a, U b) { return (U)a > b ? (U)a : b; }
44template<typename T, typename U, typename V> static inline T clamp (T v, U a, V b) { return v < (T)a ? (T)a : v >(T)b ? (T)b : v; }
45
46template<typename T, typename U> static inline void swap (T& a, U& b) { T t=a; a=(T)b; b=(U)t; }
47
48// this is much faster than crossfires original algorithm
49// on modern cpus
50inline int
51isqrt (int n)
52{
53 return (int)sqrtf ((float)n);
54}
55
56// this is only twice as fast as naive sqrtf (dx*dy+dy*dy)
57#if 0
58// and has a max. error of 6 in the range -100..+100.
59#else
60// and has a max. error of 9 in the range -100..+100.
61#endif
62inline int
63idistance (int dx, int dy)
64{
65 unsigned int dx_ = abs (dx);
66 unsigned int dy_ = abs (dy);
67
68#if 0
69 return dx_ > dy_
70 ? (dx_ * 61685 + dy_ * 26870) >> 16
71 : (dy_ * 61685 + dx_ * 26870) >> 16;
72#else
73 return dx_ + dy_ - min (dx_, dy_) * 5 / 8;
74#endif
75}
76
77/*
78 * absdir(int): Returns a number between 1 and 8, which represent
79 * the "absolute" direction of a number (it actually takes care of
80 * "overflow" in previous calculations of a direction).
81 */
82inline int
83absdir (int d)
84{
85 return ((d - 1) & 7) + 1;
86}
16 87
17// makes dynamically allocated objects zero-initialised 88// makes dynamically allocated objects zero-initialised
18struct zero_initialised 89struct zero_initialised
19{ 90{
20 void *operator new (size_t s, void *p) 91 void *operator new (size_t s, void *p)
… …
119 void destroy (pointer p) 190 void destroy (pointer p)
120 { 191 {
121 p->~Tp (); 192 p->~Tp ();
122 } 193 }
123}; 194};
195
196// P. L'Ecuyer, “Maximally Equidistributed Combined Tausworthe Generators”, Mathematics of Computation, 65, 213 (1996), 203–213.
197// http://www.iro.umontreal.ca/~lecuyer/myftp/papers/tausme.ps
198// http://www.iro.umontreal.ca/~lecuyer/myftp/papers/tausme2.ps
199struct tausworthe_random_generator
200{
201 // generator
202 uint32_t state [4];
203
204 void operator =(const tausworthe_random_generator &src)
205 {
206 state [0] = src.state [0];
207 state [1] = src.state [1];
208 state [2] = src.state [2];
209 state [3] = src.state [3];
210 }
211
212 void seed (uint32_t seed);
213 uint32_t next ();
214
215 // uniform distribution
216 uint32_t operator ()(uint32_t r_max)
217 {
218 return is_constant (r_max)
219 ? this->next () % r_max
220 : get_range (r_max);
221 }
222
223 // return a number within (min .. max)
224 int operator () (int r_min, int r_max)
225 {
226 return is_constant (r_min) && is_constant (r_max)
227 ? r_min + (*this) (max (r_max - r_min + 1, 1))
228 : get_range (r_min, r_max);
229 }
230
231 double operator ()()
232 {
233 return this->next () / (double)0xFFFFFFFFU;
234 }
235
236protected:
237 uint32_t get_range (uint32_t r_max);
238 int get_range (int r_min, int r_max);
239};
240
241typedef tausworthe_random_generator rand_gen;
242
243extern rand_gen rndm;
124 244
125template<class T> 245template<class T>
126struct refptr 246struct refptr
127{ 247{
128 T *p; 248 T *p;
… …
191 { 311 {
192 return !strcmp (a, b); 312 return !strcmp (a, b);
193 } 313 }
194}; 314};
195 315
196#include <vector>
197
198template<class obj> 316template<class T>
199struct unordered_vector : std::vector<obj, slice_allocator<obj> > 317struct unordered_vector : std::vector<T, slice_allocator<T> >
200{ 318{
201 typedef typename unordered_vector::iterator iterator; 319 typedef typename unordered_vector::iterator iterator;
202 320
203 void erase (unsigned int pos) 321 void erase (unsigned int pos)
204 { 322 {
… …
212 { 330 {
213 erase ((unsigned int )(i - this->begin ())); 331 erase ((unsigned int )(i - this->begin ()));
214 } 332 }
215}; 333};
216 334
217template<typename T, typename U> static inline T min (T a, U b) { return a < (T)b ? a : (T)b; } 335template<class T, int T::* index>
218template<typename T, typename U> static inline T max (T a, U b) { return a > (T)b ? a : (T)b; } 336struct object_vector : std::vector<T *, slice_allocator<T *> >
219template<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; } 337{
338 void insert (T *obj)
339 {
340 assert (!(obj->*index));
341 push_back (obj);
342 obj->*index = this->size ();
343 }
220 344
221template<typename T, typename U> static inline void swap (T& a, U& b) { T t=a; a=(T)b; b=(U)t; } 345 void insert (T &obj)
346 {
347 insert (&obj);
348 }
349
350 void erase (T *obj)
351 {
352 assert (obj->*index);
353 int pos = obj->*index;
354 obj->*index = 0;
355
356 if (pos < this->size ())
357 {
358 (*this)[pos - 1] = (*this)[this->size () - 1];
359 (*this)[pos - 1]->*index = pos;
360 }
361
362 this->pop_back ();
363 }
364
365 void erase (T &obj)
366 {
367 errase (&obj);
368 }
369};
222 370
223// basically does what strncpy should do, but appends "..." to strings exceeding length 371// basically does what strncpy should do, but appends "..." to strings exceeding length
224void assign (char *dst, const char *src, int maxlen); 372void assign (char *dst, const char *src, int maxlen);
225 373
226// type-safe version of assign 374// type-safe version of assign
… …
233typedef double tstamp; 381typedef double tstamp;
234 382
235// return current time as timestampe 383// return current time as timestampe
236tstamp now (); 384tstamp now ();
237 385
386int similar_direction (int a, int b);
387
238#endif 388#endif
239 389

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines