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.41 by root, Thu Jan 18 22:19:59 2007 UTC vs.
Revision 1.51 by root, Mon Apr 23 18:09:57 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 (time (0)); 42rand_gen rndm;
43 43
44void
44tausworthe_random_generator::tausworthe_random_generator (uint32_t seed) 45tausworthe_random_generator::seed (uint32_t seed)
45{ 46{
46 state [0] = max ( 2, seed * 69069U); 47 state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U;
47 state [1] = max ( 8, state [0] * 69069U); 48 state [1] = state [0] * 69069U; if (state [0] < 8U) state [0] += 8U;
48 state [2] = max ( 16, state [1] * 69069U); 49 state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] += 16U;
49 state [3] = max (128, state [2] * 69069U); 50 state [3] = state [2] * 69069U; if (state [0] < 128) state [0] += 128U;
50 51
51 for (int i = 11; --i; ) 52 for (int i = 11; --i; )
52 operator ()(); 53 operator ()();
53} 54}
54 55
… …
59 state [1] = ((state [1] & 0xFFFFFFF8U) << 2U) ^ (((state [1] << 2U) ^ state [1]) >> 27U); 60 state [1] = ((state [1] & 0xFFFFFFF8U) << 2U) ^ (((state [1] << 2U) ^ state [1]) >> 27U);
60 state [2] = ((state [2] & 0xFFFFFFF0U) << 7U) ^ (((state [2] << 13U) ^ state [2]) >> 21U); 61 state [2] = ((state [2] & 0xFFFFFFF0U) << 7U) ^ (((state [2] << 13U) ^ state [2]) >> 21U);
61 state [3] = ((state [3] & 0xFFFFFF80U) << 13U) ^ (((state [3] << 3U) ^ state [3]) >> 12U); 62 state [3] = ((state [3] & 0xFFFFFF80U) << 13U) ^ (((state [3] << 3U) ^ state [3]) >> 12U);
62 63
63 return state [0] ^ state [1] ^ state [2] ^ state [3]; 64 return state [0] ^ state [1] ^ state [2] ^ state [3];
65}
66
67uint32_t
68tausworthe_random_generator::get_range (uint32_t num)
69{
70 return (next () * (uint64_t)num) >> 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, 0));
64} 78}
65 79
66/* 80/*
67 * The random functions here take luck into account when rolling random 81 * The random functions here take luck into account when rolling random
68 * 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
… …
104 118
105/* 119/*
106 * This is a 64 bit version of random_roll above. This is needed 120 * This is a 64 bit version of random_roll above. This is needed
107 * for exp loss calculations for players changing religions. 121 * for exp loss calculations for players changing religions.
108 */ 122 */
109
110sint64 123sint64
111random_roll64 (sint64 min, sint64 max, const object *op, int goodbad) 124random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
112{ 125{
113 sint64 omin, diff, luck, ran; 126 sint64 omin, diff, luck, ran;
114 int base; 127 int base;
… …
121 { 134 {
122 LOG (llevError, "Calling random_roll with min=%" PRId64 " max=%" PRId64 "\n", min, max); 135 LOG (llevError, "Calling random_roll with min=%" PRId64 " max=%" PRId64 "\n", min, max);
123 return (min); /* avoids a float exception */ 136 return (min); /* avoids a float exception */
124 } 137 }
125 138
126 /* Don't know of a portable call to get 64 bit random values. 139 /*
127 * So make a call to get two 32 bit random numbers, and just to 140 * Make a call to get two 32 bit unsigned random numbers, and just to
128 * a little byteshifting. Do make sure the first one is only 141 * a little bitshifting.
129 * 32 bit, so we don't get skewed results
130 */ 142 */
131 ran = (RANDOM () & 0xffffffff) | ((sint64) RANDOM () << 32); 143 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);
132 144
133 if (op->type != PLAYER) 145 if (op->type != PLAYER)
134 return ((ran % diff) + min); 146 return ((ran % diff) + min);
135 147
136 luck = op->stats.luck; 148 luck = op->stats.luck;
137 if (RANDOM () % base < MIN (10, abs (luck))) 149 if (rndm (base) < MIN (10, abs (luck)))
138 { 150 {
139 /* we have a winner */ 151 /* we have a winner */
140 ((luck > 0) ? (luck = 1) : (luck = -1)); 152 ((luck > 0) ? (luck = 1) : (luck = -1));
141 diff -= luck; 153 diff -= luck;
142 if (diff < 1) 154 if (diff < 1)
143 return (omin); /*check again */ 155 return (omin); /*check again */
144 ((goodbad) ? (min += luck) : (diff)); 156 ((goodbad) ? (min += luck) : (diff));
145 157
146 return (MAX (omin, MIN (max, (ran % diff) + min))); 158 return (MAX (omin, MIN (max, (ran % diff) + min)));
147 } 159 }
160
148 return ((ran % diff) + min); 161 return ((ran % diff) + min);
149} 162}
150 163
151/* 164/*
152 * 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,
… …
157 */ 170 */
158 171
159int 172int
160die_roll (int num, int size, const object *op, int goodbad) 173die_roll (int num, int size, const object *op, int goodbad)
161{ 174{
162 int min, diff, luck, total, i, gotlucky, base, ran; 175 int min, diff, luck, total, i, gotlucky, base;
163 176
164 diff = size; 177 diff = size;
165 min = 1; 178 min = 1;
166 luck = total = gotlucky = 0; 179 luck = total = gotlucky = 0;
167 ((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 */
… …
174 if (op->type == PLAYER) 187 if (op->type == PLAYER)
175 luck = op->stats.luck; 188 luck = op->stats.luck;
176 189
177 for (i = 0; i < num; i++) 190 for (i = 0; i < num; i++)
178 { 191 {
179 if (RANDOM () % base < MIN (10, abs (luck)) && !gotlucky) 192 if (rndm (base) < MIN (10, abs (luck)) && !gotlucky)
180 { 193 {
181 /* we have a winner */ 194 /* we have a winner */
182 gotlucky++; 195 gotlucky++;
183 ((luck > 0) ? (luck = 1) : (luck = -1)); 196 ((luck > 0) ? (luck = 1) : (luck = -1));
184 diff -= luck; 197 diff -= luck;
185 if (diff < 1) 198 if (diff < 1)
186 return (num); /*check again */ 199 return (num); /*check again */
187 ((goodbad) ? (min += luck) : (diff)); 200 ((goodbad) ? (min += luck) : (diff));
188 ran = RANDOM ();
189 total += MAX (1, MIN (size, (ran % diff) + min)); 201 total += MAX (1, MIN (size, rndm (diff) + min));
190 } 202 }
191 else 203 else
192 {
193 total += RANDOM () % size + 1; 204 total += rndm (size) + 1;
194 }
195 } 205 }
206
196 return (total); 207 return total;
197} 208}
198 209
199/* decay and destroy perishable items in a map */ 210/* decay and destroy perishable items in a map */
200void 211void
201maptile::decay_objects () 212maptile::decay_objects ()
… …
240 if (op->stats.food < 0) 251 if (op->stats.food < 0)
241 destroy = 1; 252 destroy = 1;
242 } 253 }
243 else 254 else
244 { 255 {
245 int mat = op->material; 256 int mat = op->materials;
246 257
247 if (mat & M_PAPER 258 if (mat & M_PAPER
248 || mat & M_LEATHER 259 || mat & M_LEATHER
249 || mat & M_WOOD 260 || mat & M_WOOD
250 || mat & M_ORGANIC 261 || mat & M_ORGANIC
… …
265} 276}
266 277
267/* convert materialname to materialtype_t */ 278/* convert materialname to materialtype_t */
268 279
269materialtype_t * 280materialtype_t *
270name_to_material (const char *name) 281name_to_material (const shstr &name)
271{ 282{
272 materialtype_t *mt, *nmt; 283 for (materialtype_t *mt = materialt; mt && mt->next; mt = mt->next)
273 284 if (name == mt->name)
274 mt = NULL;
275 for (nmt = materialt; nmt != NULL && nmt->next != NULL; nmt = nmt->next)
276 {
277 if (strcmp (name, nmt->name) == 0)
278 {
279 mt = nmt;
280 break;
281 }
282 }
283 return mt; 285 return mt;
286
287 return materialt;
284} 288}
285 289
286/* when doing transmutation of objects, we have to recheck the resistances, 290/* when doing transmutation of objects, we have to recheck the resistances,
287 * as some that did not apply previously, may apply now. 291 * as some that did not apply previously, may apply now.
288 */ 292 */
… …
337 341
338 if (nmt == NULL) 342 if (nmt == NULL)
339 { 343 {
340 lmt = NULL; 344 lmt = NULL;
341#ifndef NEW_MATERIAL_CODE 345#ifndef NEW_MATERIAL_CODE
342 for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next) 346 for (mt = materialt; mt && mt->next; mt = mt->next)
343 { 347 {
344 if (op->material & mt->material) 348 if (op->materials & mt->material)
345 { 349 {
346 lmt = mt; 350 lmt = mt;
347 break; 351 break;
348 } 352 }
349 } 353 }
350 354
351#else 355#else
352 for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next) 356 for (mt = materialt; mt && mt->next; mt = mt->next)
353 { 357 {
354 if (op->material & mt->material && rndm (1, 100) <= mt->chance && 358 if (op->materials & mt->material && rndm (1, 100) <= mt->chance &&
355 difficulty >= mt->difficulty && (op->magic >= mt->magic || mt->magic == 0)) 359 difficulty >= mt->difficulty && (op->magic >= mt->magic || mt->magic == 0))
356 { 360 {
357 lmt = mt; 361 lmt = mt;
358 if (!(op->is_weapon () || op->is_armor ())) 362 if (!(op->is_weapon () || op->is_armor ()))
359 break; 363 break;
… …
377 { 381 {
378 op->stats.dam += lmt->damage; 382 op->stats.dam += lmt->damage;
379 if (op->stats.dam < 1) 383 if (op->stats.dam < 1)
380 op->stats.dam = 1; 384 op->stats.dam = 1;
381 } 385 }
386
382 if (op->stats.sp && op->type == BOW) 387 if (op->stats.sp && op->type == BOW)
383 op->stats.sp += lmt->sp; 388 op->stats.sp += lmt->sp;
384 if (op->stats.wc && op->is_weapon ()) 389 if (op->stats.wc && op->is_weapon ())
385 op->stats.wc += lmt->wc; 390 op->stats.wc += lmt->wc;
386 if (op->is_armor ()) 391 if (op->is_armor ())
… …
395 op->resist[j] = 100; 400 op->resist[j] = 100;
396 if (op->resist[j] < -100) 401 if (op->resist[j] < -100)
397 op->resist[j] = -100; 402 op->resist[j] = -100;
398 } 403 }
399 } 404 }
400 op->materialname = add_string (lmt->name); 405 op->materialname = lmt->name;
401 /* dont make it unstackable if it doesn't need to be */ 406 /* dont make it unstackable if it doesn't need to be */
402 if (op->is_weapon () || op->is_armor ()) 407 if (op->is_weapon () || op->is_armor ())
403 { 408 {
404 op->weight = (op->weight * lmt->weight) / 100; 409 op->weight = (op->weight * lmt->weight) / 100;
405 op->value = (op->value * lmt->value) / 100; 410 op->value = (op->value * lmt->value) / 100;
… …
556 LOG (llevError, "fork abort: %s\n", msg); 561 LOG (llevError, "fork abort: %s\n", msg);
557} 562}
558 563
559void *salloc_ (int n) throw (std::bad_alloc) 564void *salloc_ (int n) throw (std::bad_alloc)
560{ 565{
566#ifdef PREFER_MALLOC
567 void *ptr = malloc (n);
568#else
561 void *ptr = g_slice_alloc (n); 569 void *ptr = g_slice_alloc (n);
570#endif
562 571
563 if (!ptr) 572 if (!ptr)
564 throw std::bad_alloc (); 573 throw std::bad_alloc ();
565 574
566 return ptr; 575 return ptr;
… …
600 } 609 }
601 else 610 else
602 memcpy (dst, src, len + 1); 611 memcpy (dst, src, len + 1);
603} 612}
604 613
614const std::string
615format (const char *format, ...)
616{
617 int len;
618
619 {
620 char buf[128];
621
622 va_list ap;
623 va_start (ap, format);
624 len = vsnprintf (buf, sizeof (buf), format, ap);
625 va_end (ap);
626
627 assert (len >= 0); // shield againstz broken vsnprintf's
628
629 // was our static buffer short enough?
630 if (len < sizeof (buf))
631 return std::string (buf, len);
632 }
633
634 {
635 // longer, try harder
636 char *buf = salloc<char> (len + 1);
637
638 va_list ap;
639 va_start (ap, format);
640 vsnprintf (buf, len + 1, format, ap);
641 va_end (ap);
642
643 const std::string s (buf, len);
644 sfree<char> (buf, len + 1);
645
646 return buf;
647 }
648}
649
605tstamp now () 650tstamp now ()
606{ 651{
607 struct timeval tv; 652 struct timeval tv;
608 653
609 gettimeofday (&tv, 0); 654 gettimeofday (&tv, 0);
… …
618 663
619 int diff = (b - a) & 7; 664 int diff = (b - a) & 7;
620 return diff <= 1 || diff >= 7; 665 return diff <= 1 || diff >= 7;
621} 666}
622 667
668/* crc32 0xdebb20e3 table and supplementary functions. */
669extern const uint32_t crc_32_tab[256] =
670{
671 0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
672 0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
673 0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
674 0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
675 0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
676 0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
677 0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
678 0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
679 0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
680 0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
681 0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
682 0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
683 0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
684 0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
685 0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
686 0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
687 0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
688 0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
689 0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
690 0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
691 0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
692 0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
693 0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
694 0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
695 0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
696 0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
697 0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
698 0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
699 0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
700 0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
701 0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
702 0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
703 0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
704 0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
705 0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
706 0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
707 0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
708 0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
709 0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
710 0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
711 0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
712 0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
713 0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
714 0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
715 0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
716 0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
717 0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
718 0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
719 0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
720 0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
721 0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
722 0x2d02ef8dL
723};
724
725

Diff Legend

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