ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/utils.C
(Generate patch)

Comparing deliantra/server/common/utils.C (file contents):
Revision 1.39 by pippijn, Mon Jan 15 21:06:18 2007 UTC vs.
Revision 1.49 by root, Sat Apr 21 22:57:15 2007 UTC

… …
37#include <funcpoint.h> 37#include <funcpoint.h>
38#include <material.h> 38#include <material.h>
39 39
40#include <glib.h> 40#include <glib.h>
41 41
42rand_gen rndm;
43
44void
45tausworthe_random_generator::seed (uint32_t seed)
46{
47 state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U;
48 state [1] = state [0] * 69069U; if (state [0] < 8U) state [0] += 8U;
49 state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] += 16U;
50 state [3] = state [2] * 69069U; if (state [0] < 128) state [0] += 128U;
51
52 for (int i = 11; --i; )
53 operator ()();
54}
55
56uint32_t
57tausworthe_random_generator::next ()
58{
59 state [0] = ((state [0] & 0xFFFFFFFEU) << 18U) ^ (((state [0] << 6U) ^ state [0]) >> 13U);
60 state [1] = ((state [1] & 0xFFFFFFF8U) << 2U) ^ (((state [1] << 2U) ^ state [1]) >> 27U);
61 state [2] = ((state [2] & 0xFFFFFFF0U) << 7U) ^ (((state [2] << 13U) ^ state [2]) >> 21U);
62 state [3] = ((state [3] & 0xFFFFFF80U) << 13U) ^ (((state [3] << 3U) ^ state [3]) >> 12U);
63
64 return state [0] ^ state [1] ^ state [2] ^ state [3];
65}
66
67uint32_t
68tausworthe_random_generator::get_range (uint32_t r_max)
69{
70 return (next () * (uint64_t)r_max) >> 32U;
71}
72
73// return a number within (min .. max)
74int
75tausworthe_random_generator::get_range (int r_min, int r_max)
76{
77 return r_min + get_range (max (r_max - r_min + 1, 1));
78}
79
42/* 80/*
43 * The random functions here take luck into account when rolling random 81 * The random functions here take luck into account when rolling random
44 * dice or numbers. This function has less of an impact the larger the 82 * dice or numbers. This function has less of an impact the larger the
45 * difference becomes in the random numbers. IE, the effect is lessened 83 * difference becomes in the random numbers. IE, the effect is lessened
46 * on a 1-1000 roll, vs a 1-6 roll. This can be used by crafty programmers, 84 * on a 1-1000 roll, vs a 1-6 roll. This can be used by crafty programmers,
… …
52 * Roll a random number between min and max. Uses op to determine luck, 90 * Roll a random number between min and max. Uses op to determine luck,
53 * and if goodbad is non-zero, luck increases the roll, if zero, it decreases. 91 * and if goodbad is non-zero, luck increases the roll, if zero, it decreases.
54 * Generally, op should be the player/caster/hitter requesting the roll, 92 * Generally, op should be the player/caster/hitter requesting the roll,
55 * not the recipient (ie, the poor slob getting hit). [garbled 20010916] 93 * not the recipient (ie, the poor slob getting hit). [garbled 20010916]
56 */ 94 */
57
58int 95int
59random_roll (int min, int max, const object *op, int goodbad) 96random_roll (int r_min, int r_max, const object *op, int goodbad)
60{ 97{
98 int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */
99
100 if (r_max < 1 || r_max < r_min)
101 {
102 LOG (llevError, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
103 return r_min;
104 }
105
106 if (op->type == PLAYER)
107 {
108 int luck = op->stats.luck;
109
110 if (rndm (base) < min (10, abs (luck)))
111 {
112 //TODO: take luck into account
113 }
114 }
115
116 return rndm (r_min, r_max);
117}
118
119/*
120 * This is a 64 bit version of random_roll above. This is needed
121 * for exp loss calculations for players changing religions.
122 */
123sint64
124random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
125{
61 int omin, diff, luck, base, ran; 126 sint64 omin, diff, luck, ran;
127 int base;
62 128
63 omin = min; 129 omin = min;
64 diff = max - min + 1; 130 diff = max - min + 1;
65 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */ 131 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
66 132
67 if (max < 1 || diff < 1) 133 if (max < 1 || diff < 1)
68 { 134 {
69 LOG (llevError, "Calling random_roll with min=%d max=%d\n", min, max); 135 LOG (llevError, "Calling random_roll with min=%" PRId64 " max=%" PRId64 "\n", min, max);
70 return (min); /* avoids a float exception */ 136 return (min); /* avoids a float exception */
71 } 137 }
72 138
73 ran = RANDOM (); 139 /*
140 * Make a call to get two 32 bit unsigned random numbers, and just to
141 * a little bitshifting.
142 */
143 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);
74 144
75 if (op->type != PLAYER) 145 if (op->type != PLAYER)
76 return ((ran % diff) + min); 146 return ((ran % diff) + min);
77 147
78 luck = op->stats.luck; 148 luck = op->stats.luck;
79 if (RANDOM () % base < MIN (10, abs (luck))) 149 if (rndm (base) < MIN (10, abs (luck)))
80 { 150 {
81 /* we have a winner */ 151 /* we have a winner */
82 ((luck > 0) ? (luck = 1) : (luck = -1)); 152 ((luck > 0) ? (luck = 1) : (luck = -1));
83 diff -= luck; 153 diff -= luck;
84 if (diff < 1) 154 if (diff < 1)
85 return (omin); /*check again */ 155 return (omin); /*check again */
86 ((goodbad) ? (min += luck) : (diff)); 156 ((goodbad) ? (min += luck) : (diff));
87 157
88 return (MAX (omin, MIN (max, (ran % diff) + min))); 158 return (MAX (omin, MIN (max, (ran % diff) + min)));
89 } 159 }
90 return ((ran % diff) + min);
91}
92 160
93/*
94 * This is a 64 bit version of random_roll above. This is needed
95 * for exp loss calculations for players changing religions.
96 */
97
98sint64
99random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
100{
101 sint64 omin, diff, luck, ran;
102 int base;
103
104 omin = min;
105 diff = max - min + 1;
106 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
107
108 if (max < 1 || diff < 1)
109 {
110 LOG (llevError, "Calling random_roll with min=%" PRId64 " max=%" PRId64 "\n", min, max);
111 return (min); /* avoids a float exception */
112 }
113
114 /* Don't know of a portable call to get 64 bit random values.
115 * So make a call to get two 32 bit random numbers, and just to
116 * a little byteshifting. Do make sure the first one is only
117 * 32 bit, so we don't get skewed results
118 */
119 ran = (RANDOM () & 0xffffffff) | ((sint64) RANDOM () << 32);
120
121 if (op->type != PLAYER)
122 return ((ran % diff) + min);
123
124 luck = op->stats.luck;
125 if (RANDOM () % base < MIN (10, abs (luck)))
126 {
127 /* we have a winner */
128 ((luck > 0) ? (luck = 1) : (luck = -1));
129 diff -= luck;
130 if (diff < 1)
131 return (omin); /*check again */
132 ((goodbad) ? (min += luck) : (diff));
133
134 return (MAX (omin, MIN (max, (ran % diff) + min)));
135 }
136 return ((ran % diff) + min); 161 return ((ran % diff) + min);
137} 162}
138 163
139/* 164/*
140 * Roll a number of dice (2d3, 4d6). Uses op to determine luck, 165 * Roll a number of dice (2d3, 4d6). Uses op to determine luck,
… …
145 */ 170 */
146 171
147int 172int
148die_roll (int num, int size, const object *op, int goodbad) 173die_roll (int num, int size, const object *op, int goodbad)
149{ 174{
150 int min, diff, luck, total, i, gotlucky, base, ran; 175 int min, diff, luck, total, i, gotlucky, base;
151 176
152 diff = size; 177 diff = size;
153 min = 1; 178 min = 1;
154 luck = total = gotlucky = 0; 179 luck = total = gotlucky = 0;
155 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */ 180 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
… …
162 if (op->type == PLAYER) 187 if (op->type == PLAYER)
163 luck = op->stats.luck; 188 luck = op->stats.luck;
164 189
165 for (i = 0; i < num; i++) 190 for (i = 0; i < num; i++)
166 { 191 {
167 if (RANDOM () % base < MIN (10, abs (luck)) && !gotlucky) 192 if (rndm (base) < MIN (10, abs (luck)) && !gotlucky)
168 { 193 {
169 /* we have a winner */ 194 /* we have a winner */
170 gotlucky++; 195 gotlucky++;
171 ((luck > 0) ? (luck = 1) : (luck = -1)); 196 ((luck > 0) ? (luck = 1) : (luck = -1));
172 diff -= luck; 197 diff -= luck;
173 if (diff < 1) 198 if (diff < 1)
174 return (num); /*check again */ 199 return (num); /*check again */
175 ((goodbad) ? (min += luck) : (diff)); 200 ((goodbad) ? (min += luck) : (diff));
176 ran = RANDOM ();
177 total += MAX (1, MIN (size, (ran % diff) + min)); 201 total += MAX (1, MIN (size, rndm (diff) + min));
178 } 202 }
179 else 203 else
180 {
181 total += RANDOM () % size + 1; 204 total += rndm (size) + 1;
182 }
183 } 205 }
206
184 return (total); 207 return total;
185}
186
187/*
188 * Another convenience function. Returns a number between min and max.
189 * It is suggested one use these functions rather than RANDOM()%, as it
190 * would appear that a number of off-by-one-errors exist due to improper
191 * use of %. This should also prevent SIGFPE.
192 */
193
194int
195rndm (int min, int max)
196{
197 int diff;
198
199 diff = max - min + 1;
200 if (max < 1 || diff < 1)
201 return (min);
202
203 return (RANDOM () % diff + min);
204} 208}
205 209
206/* decay and destroy perishable items in a map */ 210/* decay and destroy perishable items in a map */
207void 211void
208maptile::decay_objects () 212maptile::decay_objects ()
… …
247 if (op->stats.food < 0) 251 if (op->stats.food < 0)
248 destroy = 1; 252 destroy = 1;
249 } 253 }
250 else 254 else
251 { 255 {
252 int mat = op->material; 256 int mat = op->materials;
253 257
254 if (mat & M_PAPER 258 if (mat & M_PAPER
255 || mat & M_LEATHER 259 || mat & M_LEATHER
256 || mat & M_WOOD 260 || mat & M_WOOD
257 || mat & M_ORGANIC 261 || mat & M_ORGANIC
… …
272} 276}
273 277
274/* convert materialname to materialtype_t */ 278/* convert materialname to materialtype_t */
275 279
276materialtype_t * 280materialtype_t *
277name_to_material (const char *name) 281name_to_material (const shstr &name)
278{ 282{
279 materialtype_t *mt, *nmt; 283 for (materialtype_t *mt = materialt; mt && mt->next; mt = mt->next)
280 284 if (name == mt->name)
281 mt = NULL;
282 for (nmt = materialt; nmt != NULL && nmt->next != NULL; nmt = nmt->next)
283 {
284 if (strcmp (name, nmt->name) == 0)
285 {
286 mt = nmt;
287 break;
288 }
289 }
290 return mt; 285 return mt;
286
287 return materialt;
291} 288}
292 289
293/* when doing transmutation of objects, we have to recheck the resistances, 290/* when doing transmutation of objects, we have to recheck the resistances,
294 * as some that did not apply previously, may apply now. 291 * as some that did not apply previously, may apply now.
295 */ 292 */
… …
344 341
345 if (nmt == NULL) 342 if (nmt == NULL)
346 { 343 {
347 lmt = NULL; 344 lmt = NULL;
348#ifndef NEW_MATERIAL_CODE 345#ifndef NEW_MATERIAL_CODE
349 for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next) 346 for (mt = materialt; mt && mt->next; mt = mt->next)
350 { 347 {
351 if (op->material & mt->material) 348 if (op->materials & mt->material)
352 { 349 {
353 lmt = mt; 350 lmt = mt;
354 break; 351 break;
355 } 352 }
356 } 353 }
357 354
358#else 355#else
359 for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next) 356 for (mt = materialt; mt && mt->next; mt = mt->next)
360 { 357 {
361 if (op->material & mt->material && rndm (1, 100) <= mt->chance && 358 if (op->materials & mt->material && rndm (1, 100) <= mt->chance &&
362 difficulty >= mt->difficulty && (op->magic >= mt->magic || mt->magic == 0)) 359 difficulty >= mt->difficulty && (op->magic >= mt->magic || mt->magic == 0))
363 { 360 {
364 lmt = mt; 361 lmt = mt;
365 if (!(op->is_weapon () || op->is_armor ())) 362 if (!(op->is_weapon () || op->is_armor ()))
366 break; 363 break;
… …
384 { 381 {
385 op->stats.dam += lmt->damage; 382 op->stats.dam += lmt->damage;
386 if (op->stats.dam < 1) 383 if (op->stats.dam < 1)
387 op->stats.dam = 1; 384 op->stats.dam = 1;
388 } 385 }
386
389 if (op->stats.sp && op->type == BOW) 387 if (op->stats.sp && op->type == BOW)
390 op->stats.sp += lmt->sp; 388 op->stats.sp += lmt->sp;
391 if (op->stats.wc && op->is_weapon ()) 389 if (op->stats.wc && op->is_weapon ())
392 op->stats.wc += lmt->wc; 390 op->stats.wc += lmt->wc;
393 if (op->is_armor ()) 391 if (op->is_armor ())
… …
402 op->resist[j] = 100; 400 op->resist[j] = 100;
403 if (op->resist[j] < -100) 401 if (op->resist[j] < -100)
404 op->resist[j] = -100; 402 op->resist[j] = -100;
405 } 403 }
406 } 404 }
407 op->materialname = add_string (lmt->name); 405 op->materialname = lmt->name;
408 /* dont make it unstackable if it doesn't need to be */ 406 /* dont make it unstackable if it doesn't need to be */
409 if (op->is_weapon () || op->is_armor ()) 407 if (op->is_weapon () || op->is_armor ())
410 { 408 {
411 op->weight = (op->weight * lmt->weight) / 100; 409 op->weight = (op->weight * lmt->weight) / 100;
412 op->value = (op->value * lmt->value) / 100; 410 op->value = (op->value * lmt->value) / 100;
… …
563 LOG (llevError, "fork abort: %s\n", msg); 561 LOG (llevError, "fork abort: %s\n", msg);
564} 562}
565 563
566void *salloc_ (int n) throw (std::bad_alloc) 564void *salloc_ (int n) throw (std::bad_alloc)
567{ 565{
566#ifdef PREFER_MALLOC
567 void *ptr = malloc (n);
568#else
568 void *ptr = g_slice_alloc (n); 569 void *ptr = g_slice_alloc (n);
570#endif
569 571
570 if (!ptr) 572 if (!ptr)
571 throw std::bad_alloc (); 573 throw std::bad_alloc ();
572 574
573 return ptr; 575 return ptr;
… …
625 627
626 int diff = (b - a) & 7; 628 int diff = (b - a) & 7;
627 return diff <= 1 || diff >= 7; 629 return diff <= 1 || diff >= 7;
628} 630}
629 631
632/* crc32 0xdebb20e3 table and supplementary functions. */
633extern const uint32_t crc_32_tab[256] =
634{
635 0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
636 0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
637 0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
638 0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
639 0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
640 0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
641 0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
642 0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
643 0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
644 0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
645 0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
646 0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
647 0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
648 0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
649 0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
650 0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
651 0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
652 0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
653 0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
654 0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
655 0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
656 0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
657 0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
658 0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
659 0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
660 0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
661 0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
662 0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
663 0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
664 0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
665 0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
666 0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
667 0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
668 0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
669 0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
670 0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
671 0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
672 0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
673 0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
674 0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
675 0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
676 0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
677 0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
678 0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
679 0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
680 0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
681 0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
682 0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
683 0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
684 0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
685 0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
686 0x2d02ef8dL
687};
688
689

Diff Legend

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