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.43 by root, Fri Jan 19 22:24:10 2007 UTC vs.
Revision 1.53 by root, Fri Apr 27 19:53:57 2007 UTC

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

Diff Legend

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