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.74 by root, Fri Apr 11 21:09:52 2008 UTC vs.
Revision 1.80 by root, Wed Sep 10 18:18:10 2008 UTC

… …
31#include <sys/time.h> 31#include <sys/time.h>
32#include <time.h> 32#include <time.h>
33#include <signal.h> 33#include <signal.h>
34 34
35#include <global.h> 35#include <global.h>
36#include <funcpoint.h>
37#include <material.h> 36#include <material.h>
37
38#include <sys/time.h>
39#include <sys/resource.h>
38 40
39#include <glib.h> 41#include <glib.h>
40 42
41refcnt_base::refcnt_t refcnt_dummy; 43refcnt_base::refcnt_t refcnt_dummy;
42ssize_t slice_alloc; 44ssize_t slice_alloc;
43rand_gen rndm; 45rand_gen rndm, rmg_rndm;
44 46
45void 47void
46tausworthe_random_generator::seed (uint32_t seed) 48tausworthe_random_generator::seed (uint32_t seed)
47{ 49{
48 state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U; 50 state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U;
… …
94 * not the recipient (ie, the poor slob getting hit). [garbled 20010916] 96 * not the recipient (ie, the poor slob getting hit). [garbled 20010916]
95 */ 97 */
96int 98int
97random_roll (int r_min, int r_max, const object *op, int goodbad) 99random_roll (int r_min, int r_max, const object *op, int goodbad)
98{ 100{
101 r_max = max (r_min, r_max);
102
99 int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */ 103 int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */
100
101 if (r_max < r_min)
102 {
103 LOG (llevError | logBacktrace, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
104 return r_min;
105 }
106 104
107 if (op->type == PLAYER) 105 if (op->type == PLAYER)
108 { 106 {
109 int luck = op->stats.luck; 107 int luck = op->stats.luck;
110 108
… …
120/* 118/*
121 * This is a 64 bit version of random_roll above. This is needed 119 * This is a 64 bit version of random_roll above. This is needed
122 * for exp loss calculations for players changing religions. 120 * for exp loss calculations for players changing religions.
123 */ 121 */
124sint64 122sint64
125random_roll64 (sint64 min, sint64 max, const object *op, int goodbad) 123random_roll64 (sint64 r_min, sint64 r_max, const object *op, int goodbad)
126{ 124{
127 sint64 omin = min; 125 sint64 omin = r_min;
128 sint64 diff = max - min + 1; 126 sint64 range = max (0, r_max - r_min + 1);
129 int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */ 127 int base = range > 2 ? 20 : 50; /* d2 and d3 are corner cases */
130
131 if (diff < 0)
132 {
133 LOG (llevError | logBacktrace, "Calling random_roll64 with min=%" PRId64 " max=%" PRId64 "\n", min, max);
134 return (min); /* avoids a float exception */
135 }
136 128
137 /* 129 /*
138 * Make a call to get two 32 bit unsigned random numbers, and just to 130 * Make a call to get two 32 bit unsigned random numbers, and just to
139 * a little bitshifting. 131 * a little bitshifting.
140 */ 132 */
141 sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31); 133 sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);
142 134
143 if (op->type != PLAYER) 135 if (op->type != PLAYER)
144 return ((ran % diff) + min); 136 return ((ran % range) + r_min);
145 137
146 int luck = op->stats.luck; 138 int luck = op->stats.luck;
147 139
148 if (rndm (base) < MIN (10, abs (luck))) 140 if (rndm (base) < min (10, abs (luck)))
149 { 141 {
150 /* we have a winner */ 142 /* we have a winner */
151 ((luck > 0) ? (luck = 1) : (luck = -1)); 143 ((luck > 0) ? (luck = 1) : (luck = -1));
152 diff -= luck; 144 range -= luck;
153 if (diff < 1) 145 if (range < 1)
154 return (omin); /*check again */ 146 return (omin); /*check again */
155 147
156 ((goodbad) ? (min += luck) : (diff)); 148 ((goodbad) ? (r_min += luck) : (range));
157 149
158 return (MAX (omin, MIN (max, (ran % diff) + min))); 150 return (max (omin, min (r_max, (ran % range) + r_min)));
159 } 151 }
160 152
161 return ran % diff + min; 153 return ran % range + r_min;
162} 154}
163 155
164/* 156/*
165 * Roll a number of dice (2d3, 4d6). Uses op to determine luck, 157 * Roll a number of dice (2d3, 4d6). Uses op to determine luck,
166 * If goodbad is non-zero, luck increases the roll, if zero, it decreases. 158 * If goodbad is non-zero, luck increases the roll, if zero, it decreases.
… …
457void 449void
458fork_abort (const char *msg) 450fork_abort (const char *msg)
459{ 451{
460 if (!fork ()) 452 if (!fork ())
461 { 453 {
454 signal (SIGINT , SIG_IGN);
455 signal (SIGTERM, SIG_IGN);
462 signal (SIGABRT, SIG_DFL); 456 signal (SIGABRT, SIG_IGN);
457
463 // try to put corefiles into a subdirectory, if existing, to allow 458 // try to put corefiles into a subdirectory, if existing, to allow
464 // an administrator to reduce the I/O load. 459 // an administrator to reduce the I/O load.
465 chdir ("cores"); 460 chdir ("cores");
461
462 // try to detach us from as many external dependencies as possible
463 // as coredumping can take time by closing all fd's.
464 {
465 struct rlimit lim;
466
467 if (getrlimit (RLIMIT_NOFILE, &lim))
468 lim.rlim_cur = 1024;
469
470 for (int i = 0; i < lim.rlim_cur; ++i)
471 close (i);
472 }
473
466 abort (); 474 abort ();
467 } 475 }
468 476
469 LOG (llevError, "fork abort: %s\n", msg); 477 LOG (llevError, "fork abort: %s\n", msg);
470} 478}
… …
649 0x2d02ef8dL 657 0x2d02ef8dL
650}; 658};
651 659
652void thread::start (void *(*start_routine)(void *), void *arg) 660void thread::start (void *(*start_routine)(void *), void *arg)
653{ 661{
662 pthread_attr_t attr;
663
664 pthread_attr_init (&attr);
665 pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
666 pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN < sizeof (long) * 4096
667 ? sizeof (long) * 4096 : PTHREAD_STACK_MIN);
668#ifdef PTHREAD_SCOPE_PROCESS
669 pthread_attr_setscope (&attr, PTHREAD_SCOPE_PROCESS);
670#endif
671
654 sigset_t fullsigset, oldsigset; 672 sigset_t fullsigset, oldsigset;
655 sigfillset (&fullsigset); 673 sigfillset (&fullsigset);
656 674
657 pthread_sigmask (SIG_SETMASK, &fullsigset, &oldsigset); 675 pthread_sigmask (SIG_SETMASK, &fullsigset, &oldsigset);
658 676
659 if (pthread_create (&id, 0, start_routine, arg)) 677 if (pthread_create (&id, &attr, start_routine, arg))
660 cleanup ("unable to create a new thread"); 678 cleanup ("unable to create a new thread");
661 679
662 pthread_sigmask (SIG_SETMASK, &oldsigset, 0); 680 pthread_sigmask (SIG_SETMASK, &oldsigset, 0);
663} 681}
682

Diff Legend

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