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.47 by root, Wed Feb 7 02:04:46 2007 UTC vs.
Revision 1.60 by root, Sun Jul 1 05:00:18 2007 UTC

1/* 1/*
2 * CrossFire, A Multiplayer game for X-windows 2 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3 * 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team 4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5 * Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * This program is free software; you can redistribute it and/or modify 8 * Crossfire TRT is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version. 11 * (at your option) any later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the GNU General Public License 18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 * 20 *
22 * The authors can be reached via e-mail at <crossfire@schmorp.de> 21 * The authors can be reached via e-mail to <crossfire@schmorp.de>
23 */ 22 */
24 23
25/* 24/*
26 * General convenience functions for crossfire. 25 * General convenience functions for crossfire.
27 */ 26 */
… …
42rand_gen rndm; 41rand_gen rndm;
43 42
44void 43void
45tausworthe_random_generator::seed (uint32_t seed) 44tausworthe_random_generator::seed (uint32_t seed)
46{ 45{
47 state [0] = max ( 2U, seed * 69069U); 46 state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U;
48 state [1] = max ( 8U, state [0] * 69069U); 47 state [1] = state [0] * 69069U; if (state [0] < 8U) state [0] += 8U;
49 state [2] = max ( 16U, state [1] * 69069U); 48 state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] += 16U;
50 state [3] = max (128U, state [2] * 69069U); 49 state [3] = state [2] * 69069U; if (state [0] < 128) state [0] += 128U;
51 50
52 for (int i = 11; --i; ) 51 for (int i = 11; --i; )
53 operator ()(); 52 operator ()();
54} 53}
55 54
… …
63 62
64 return state [0] ^ state [1] ^ state [2] ^ state [3]; 63 return state [0] ^ state [1] ^ state [2] ^ state [3];
65} 64}
66 65
67uint32_t 66uint32_t
68tausworthe_random_generator::get_range (uint32_t r_max) 67tausworthe_random_generator::get_range (uint32_t num)
69{ 68{
70 return next () % r_max; 69 return (next () * (uint64_t)num) >> 32U;
71} 70}
72 71
73// return a number within (min .. max) 72// return a number within (min .. max)
74int 73int
75tausworthe_random_generator::get_range (int r_min, int r_max) 74tausworthe_random_generator::get_range (int r_min, int r_max)
76{ 75{
77 return r_min + (*this) (max (r_max - r_min + 1, 1)); 76 return r_min + get_range (max (r_max - r_min + 1, 0));
78} 77}
79 78
80/* 79/*
81 * The random functions here take luck into account when rolling random 80 * 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 81 * dice or numbers. This function has less of an impact the larger the
… …
95int 94int
96random_roll (int r_min, int r_max, const object *op, int goodbad) 95random_roll (int r_min, int r_max, const object *op, int goodbad)
97{ 96{
98 int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */ 97 int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */
99 98
100 if (r_max < 1 || r_max < r_min) 99 if (r_max < r_min)
101 { 100 {
102 LOG (llevError, "Calling random_roll with min=%d max=%d\n", r_min, r_max); 101 LOG (llevError | logBacktrace, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
103 return r_min; 102 return r_min;
104 } 103 }
105 104
106 if (op->type == PLAYER) 105 if (op->type == PLAYER)
107 { 106 {
… …
121 * for exp loss calculations for players changing religions. 120 * for exp loss calculations for players changing religions.
122 */ 121 */
123sint64 122sint64
124random_roll64 (sint64 min, sint64 max, const object *op, int goodbad) 123random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
125{ 124{
126 sint64 omin, diff, luck, ran;
127 int base;
128
129 omin = min; 125 sint64 omin = min;
130 diff = max - min + 1; 126 sint64 diff = max - min + 1;
131 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */ 127 int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */
132 128
133 if (max < 1 || diff < 1) 129 if (diff < 0)
134 { 130 {
135 LOG (llevError, "Calling random_roll with min=%" PRId64 " max=%" PRId64 "\n", min, max); 131 LOG (llevError | logBacktrace, "Calling random_roll64 with min=%" PRId64 " max=%" PRId64 "\n", min, max);
136 return (min); /* avoids a float exception */ 132 return (min); /* avoids a float exception */
137 } 133 }
138 134
139 /* 135 /*
140 * Make a call to get two 32 bit unsigned random numbers, and just to 136 * Make a call to get two 32 bit unsigned random numbers, and just to
141 * a little bitshifting. 137 * a little bitshifting.
142 */ 138 */
143 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31); 139 sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);
144 140
145 if (op->type != PLAYER) 141 if (op->type != PLAYER)
146 return ((ran % diff) + min); 142 return ((ran % diff) + min);
147 143
148 luck = op->stats.luck; 144 int luck = op->stats.luck;
145
149 if (rndm (base) < MIN (10, abs (luck))) 146 if (rndm (base) < MIN (10, abs (luck)))
150 { 147 {
151 /* we have a winner */ 148 /* we have a winner */
152 ((luck > 0) ? (luck = 1) : (luck = -1)); 149 ((luck > 0) ? (luck = 1) : (luck = -1));
153 diff -= luck; 150 diff -= luck;
154 if (diff < 1) 151 if (diff < 1)
155 return (omin); /*check again */ 152 return (omin); /*check again */
153
156 ((goodbad) ? (min += luck) : (diff)); 154 ((goodbad) ? (min += luck) : (diff));
157 155
158 return (MAX (omin, MIN (max, (ran % diff) + min))); 156 return (MAX (omin, MIN (max, (ran % diff) + min)));
159 } 157 }
160 158
161 return ((ran % diff) + min); 159 return ran % diff + min;
162} 160}
163 161
164/* 162/*
165 * Roll a number of dice (2d3, 4d6). Uses op to determine luck, 163 * 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. 164 * If goodbad is non-zero, luck increases the roll, if zero, it decreases.
167 * Generally, op should be the player/caster/hitter requesting the roll, 165 * Generally, op should be the player/caster/hitter requesting the roll,
168 * not the recipient (ie, the poor slob getting hit). 166 * not the recipient (ie, the poor slob getting hit).
169 * The args are num D size (ie 4d6) [garbled 20010916] 167 * The args are num D size (ie 4d6) [garbled 20010916]
170 */ 168 */
171
172int 169int
173die_roll (int num, int size, const object *op, int goodbad) 170die_roll (int num, int size, const object *op, int goodbad)
174{ 171{
175 int min, diff, luck, total, i, gotlucky, base; 172 int min, luck, total, i, gotlucky;
176 173
177 diff = size; 174 int diff = size;
178 min = 1; 175 min = 1;
179 luck = total = gotlucky = 0; 176 luck = total = gotlucky = 0;
180 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */ 177 int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */
178
181 if (size < 2 || diff < 1) 179 if (size < 2 || diff < 1)
182 { 180 {
183 LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size); 181 LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size);
184 return (num); /* avoids a float exception */ 182 return num; /* avoids a float exception */
185 } 183 }
186 184
187 if (op->type == PLAYER) 185 if (op->type == PLAYER)
188 luck = op->stats.luck; 186 luck = op->stats.luck;
189 187
… …
205 } 203 }
206 204
207 return total; 205 return total;
208} 206}
209 207
210/* decay and destroy perishable items in a map */
211void
212maptile::decay_objects ()
213{
214 if (!spaces)
215 return;
216
217 for (mapspace *ms = spaces + size (); ms-- > spaces; )
218 for (object *above, *op = ms->bot; op; op = above)
219 {
220 above = op->above;
221
222 bool destroy = 0;
223
224 // do not decay anything above unique floor tiles (yet :)
225 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
226 break;
227
228 if (QUERY_FLAG (op, FLAG_IS_FLOOR)
229 || QUERY_FLAG (op, FLAG_OBJ_ORIGINAL)
230 || QUERY_FLAG (op, FLAG_OBJ_SAVE_ON_OVL)
231 || QUERY_FLAG (op, FLAG_UNIQUE)
232 || QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)
233 || QUERY_FLAG (op, FLAG_UNPAID)
234 || op->is_alive ())
235 ; // do not decay
236 else if (op->is_weapon ())
237 {
238 op->stats.dam--;
239 if (op->stats.dam < 0)
240 destroy = 1;
241 }
242 else if (op->is_armor ())
243 {
244 op->stats.ac--;
245 if (op->stats.ac < 0)
246 destroy = 1;
247 }
248 else if (op->type == FOOD)
249 {
250 op->stats.food -= rndm (5, 20);
251 if (op->stats.food < 0)
252 destroy = 1;
253 }
254 else
255 {
256 int mat = op->materials;
257
258 if (mat & M_PAPER
259 || mat & M_LEATHER
260 || mat & M_WOOD
261 || mat & M_ORGANIC
262 || mat & M_CLOTH
263 || mat & M_LIQUID
264 || (mat & M_IRON && rndm (1, 5) == 1)
265 || (mat & M_GLASS && rndm (1, 2) == 1)
266 || ((mat & M_STONE || mat & M_ADAMANT) && rndm (1, 10) == 1)
267 || ((mat & M_SOFT_METAL || mat & M_BONE) && rndm (1, 3) == 1)
268 || (mat & M_ICE && temp > 32))
269 destroy = 1;
270 }
271
272 /* adjust overall chance below */
273 if (destroy && rndm (0, 1))
274 op->destroy ();
275 }
276}
277
278/* convert materialname to materialtype_t */ 208/* convert materialname to materialtype_t */
279 209
280materialtype_t * 210materialtype_t *
281name_to_material (const shstr &name) 211name_to_material (const shstr &name)
282{ 212{
… …
307 return; 237 return;
308 238
309 mt = name_to_material (op->materialname); 239 mt = name_to_material (op->materialname);
310 if (!mt) 240 if (!mt)
311 { 241 {
312 LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->name, &op->name, &op->materialname); 242 LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->archname, &op->name, &op->materialname);
313 return; 243 return;
314 } 244 }
315 245
316 for (j = 0; j < NROFATTACKS; j++) 246 for (j = 0; j < NROFATTACKS; j++)
317 if (op->resist[j] == 0 && change->resist[j] != 0) 247 if (op->resist[j] == 0 && change->resist[j] != 0)
… …
553fork_abort (const char *msg) 483fork_abort (const char *msg)
554{ 484{
555 if (!fork ()) 485 if (!fork ())
556 { 486 {
557 signal (SIGABRT, SIG_DFL); 487 signal (SIGABRT, SIG_DFL);
488 // try to put corefiles into a subdirectory, if existing, to allow
489 // an administrator to reduce the I/O load.
490 chdir ("cores");
558 abort (); 491 abort ();
559 } 492 }
560 493
561 LOG (llevError, "fork abort: %s\n", msg); 494 LOG (llevError, "fork abort: %s\n", msg);
562} 495}
… …
609 } 542 }
610 else 543 else
611 memcpy (dst, src, len + 1); 544 memcpy (dst, src, len + 1);
612} 545}
613 546
547const std::string
548format (const char *format, ...)
549{
550 int len;
551
552 {
553 char buf[128];
554
555 va_list ap;
556 va_start (ap, format);
557 len = vsnprintf (buf, sizeof (buf), format, ap);
558 va_end (ap);
559
560 assert (len >= 0); // shield againstz broken vsnprintf's
561
562 // was our static buffer short enough?
563 if (len < sizeof (buf))
564 return std::string (buf, len);
565 }
566
567 {
568 // longer, try harder
569 char *buf = salloc<char> (len + 1);
570
571 va_list ap;
572 va_start (ap, format);
573 vsnprintf (buf, len + 1, format, ap);
574 va_end (ap);
575
576 const std::string s (buf, len);
577 sfree<char> (buf, len + 1);
578
579 return buf;
580 }
581}
582
614tstamp now () 583tstamp now ()
615{ 584{
616 struct timeval tv; 585 struct timeval tv;
617 586
618 gettimeofday (&tv, 0); 587 gettimeofday (&tv, 0);
… …
627 596
628 int diff = (b - a) & 7; 597 int diff = (b - a) & 7;
629 return diff <= 1 || diff >= 7; 598 return diff <= 1 || diff >= 7;
630} 599}
631 600
601/* crc32 0xdebb20e3 table and supplementary functions. */
602extern const uint32_t crc_32_tab[256] =
603{
604 0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
605 0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
606 0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
607 0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
608 0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
609 0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
610 0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
611 0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
612 0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
613 0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
614 0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
615 0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
616 0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
617 0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
618 0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
619 0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
620 0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
621 0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
622 0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
623 0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
624 0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
625 0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
626 0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
627 0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
628 0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
629 0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
630 0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
631 0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
632 0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
633 0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
634 0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
635 0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
636 0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
637 0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
638 0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
639 0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
640 0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
641 0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
642 0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
643 0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
644 0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
645 0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
646 0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
647 0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
648 0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
649 0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
650 0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
651 0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
652 0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
653 0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
654 0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
655 0x2d02ef8dL
656};
657
658

Diff Legend

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