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.20 by root, Mon Dec 11 21:32:16 2006 UTC vs.
Revision 1.41 by root, Thu Jan 18 22:19:59 2007 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * CrossFire, A Multiplayer game for X-windows
3 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (C) 2002 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (C) 1992 Frank Tore Johansen
6 7 *
7 This program is free software; you can redistribute it and/or modify 8 * This program is free software; you can redistribute it and/or modify
8 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
9 the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version. 11 * (at your option) any later version.
11 12 *
12 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,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details. 16 * GNU General Public License for more details.
16 17 *
17 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
18 along with this program; if not, write to the Free Software 19 * along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 21 *
21 The authors can be reached via e-mail at <crossfire@schmorp.de> 22 * The authors can be reached via e-mail at <crossfire@schmorp.de>
22*/ 23 */
23 24
24/* 25/*
25 * General convenience functions for crossfire. 26 * General convenience functions for crossfire.
26 */ 27 */
28
29#include <cstdlib>
30#include <sys/types.h>
31#include <unistd.h>
32#include <sys/time.h>
33#include <time.h>
34#include <signal.h>
27 35
28#include <global.h> 36#include <global.h>
29#include <funcpoint.h> 37#include <funcpoint.h>
30#include <material.h> 38#include <material.h>
31 39
32#include <glib.h> 40#include <glib.h>
41
42rand_gen rndm (time (0));
43
44tausworthe_random_generator::tausworthe_random_generator (uint32_t seed)
45{
46 state [0] = max ( 2, seed * 69069U);
47 state [1] = max ( 8, state [0] * 69069U);
48 state [2] = max ( 16, state [1] * 69069U);
49 state [3] = max (128, state [2] * 69069U);
50
51 for (int i = 11; --i; )
52 operator ()();
53}
54
55uint32_t
56tausworthe_random_generator::next ()
57{
58 state [0] = ((state [0] & 0xFFFFFFFEU) << 18U) ^ (((state [0] << 6U) ^ state [0]) >> 13U);
59 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 [3] = ((state [3] & 0xFFFFFF80U) << 13U) ^ (((state [3] << 3U) ^ state [3]) >> 12U);
62
63 return state [0] ^ state [1] ^ state [2] ^ state [3];
64}
33 65
34/* 66/*
35 * The random functions here take luck into account when rolling random 67 * The random functions here take luck into account when rolling random
36 * dice or numbers. This function has less of an impact the larger the 68 * dice or numbers. This function has less of an impact the larger the
37 * difference becomes in the random numbers. IE, the effect is lessened 69 * difference becomes in the random numbers. IE, the effect is lessened
… …
44 * Roll a random number between min and max. Uses op to determine luck, 76 * Roll a random number between min and max. Uses op to determine luck,
45 * and if goodbad is non-zero, luck increases the roll, if zero, it decreases. 77 * and if goodbad is non-zero, luck increases the roll, if zero, it decreases.
46 * Generally, op should be the player/caster/hitter requesting the roll, 78 * Generally, op should be the player/caster/hitter requesting the roll,
47 * not the recipient (ie, the poor slob getting hit). [garbled 20010916] 79 * not the recipient (ie, the poor slob getting hit). [garbled 20010916]
48 */ 80 */
49
50int 81int
51random_roll (int min, int max, const object *op, int goodbad) 82random_roll (int r_min, int r_max, const object *op, int goodbad)
52{ 83{
53 int omin, diff, luck, base, ran; 84 int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */
54 85
55 omin = min; 86 if (r_max < 1 || r_max < r_min)
56 diff = max - min + 1;
57 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
58
59 if (max < 1 || diff < 1)
60 { 87 {
61 LOG (llevError, "Calling random_roll with min=%d max=%d\n", min, max); 88 LOG (llevError, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
62 return (min); /* avoids a float exception */ 89 return r_min;
63 } 90 }
64 91
65 ran = RANDOM ();
66
67 if (op->type != PLAYER) 92 if (op->type == PLAYER)
68 return ((ran % diff) + min); 93 {
69
70 luck = op->stats.luck; 94 int luck = op->stats.luck;
71 if (RANDOM () % base < MIN (10, abs (luck))) 95
96 if (rndm (base) < min (10, abs (luck)))
97 {
98 //TODO: take luck into account
99 }
72 { 100 }
73 /* we have a winner */
74 ((luck > 0) ? (luck = 1) : (luck = -1));
75 diff -= luck;
76 if (diff < 1)
77 return (omin); /*check again */
78 ((goodbad) ? (min += luck) : (diff));
79 101
80 return (MAX (omin, MIN (max, (ran % diff) + min))); 102 return rndm (r_min, r_max);
81 }
82 return ((ran % diff) + min);
83} 103}
84 104
85/* 105/*
86 * This is a 64 bit version of random_roll above. This is needed 106 * This is a 64 bit version of random_roll above. This is needed
87 * for exp loss calculations for players changing religions. 107 * for exp loss calculations for players changing religions.
… …
174 } 194 }
175 } 195 }
176 return (total); 196 return (total);
177} 197}
178 198
179/*
180 * Another convenience function. Returns a number between min and max.
181 * It is suggested one use these functions rather than RANDOM()%, as it
182 * would appear that a number of off-by-one-errors exist due to improper
183 * use of %. This should also prevent SIGFPE.
184 */
185
186int
187rndm (int min, int max)
188{
189 int diff;
190
191 diff = max - min + 1;
192 if (max < 1 || diff < 1)
193 return (min);
194
195 return (RANDOM () % diff + min);
196}
197
198/* decay and destroy persihable items in a map */ 199/* decay and destroy perishable items in a map */
199
200void 200void
201decay_objects (maptile *m) 201maptile::decay_objects ()
202{ 202{
203 int x, y, destroy; 203 if (!spaces)
204 object *op, *otmp;
205
206 if (m->unique)
207 return; 204 return;
208 205
209 for (x = 0; x < MAP_WIDTH (m); x++) 206 for (mapspace *ms = spaces + size (); ms-- > spaces; )
210 for (y = 0; y < MAP_HEIGHT (m); y++) 207 for (object *above, *op = ms->bot; op; op = above)
211 for (op = get_map_ob (m, x, y); op; op = otmp)
212 { 208 {
209 above = op->above;
210
213 destroy = 0; 211 bool destroy = 0;
214 otmp = op->above; 212
213 // do not decay anything above unique floor tiles (yet :)
215 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE)) 214 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
216 break; 215 break;
216
217 if (QUERY_FLAG (op, FLAG_IS_FLOOR) || 217 if (QUERY_FLAG (op, FLAG_IS_FLOOR)
218 QUERY_FLAG (op, FLAG_OBJ_ORIGINAL) || 218 || QUERY_FLAG (op, FLAG_OBJ_ORIGINAL)
219 QUERY_FLAG (op, FLAG_OBJ_SAVE_ON_OVL) || 219 || QUERY_FLAG (op, FLAG_OBJ_SAVE_ON_OVL)
220 QUERY_FLAG (op, FLAG_UNIQUE) || QUERY_FLAG (op, FLAG_OVERLAY_FLOOR) || QUERY_FLAG (op, FLAG_UNPAID) || IS_LIVE (op)) 220 || QUERY_FLAG (op, FLAG_UNIQUE)
221 continue; 221 || QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)
222 /* otherwise, we decay and destroy */ 222 || QUERY_FLAG (op, FLAG_UNPAID)
223 if (IS_WEAPON (op)) 223 || op->is_alive ())
224 ; // do not decay
225 else if (op->is_weapon ())
224 { 226 {
225 op->stats.dam--; 227 op->stats.dam--;
226 if (op->stats.dam < 0) 228 if (op->stats.dam < 0)
227 destroy = 1; 229 destroy = 1;
228 } 230 }
229 else if (IS_ARMOR (op)) 231 else if (op->is_armor ())
230 { 232 {
231 op->stats.ac--; 233 op->stats.ac--;
232 if (op->stats.ac < 0) 234 if (op->stats.ac < 0)
233 destroy = 1; 235 destroy = 1;
234 } 236 }
235 else if (op->type == FOOD) 237 else if (op->type == FOOD)
236 { 238 {
237 op->stats.food -= rndm (5, 20); 239 op->stats.food -= rndm (5, 20);
238 if (op->stats.food < 0) 240 if (op->stats.food < 0)
239 destroy = 1; 241 destroy = 1;
240 } 242 }
241 else 243 else
242 { 244 {
243 if (op->material & M_PAPER || op->material & M_LEATHER || 245 int mat = op->material;
244 op->material & M_WOOD || op->material & M_ORGANIC || op->material & M_CLOTH || op->material & M_LIQUID) 246
247 if (mat & M_PAPER
248 || mat & M_LEATHER
249 || mat & M_WOOD
250 || mat & M_ORGANIC
251 || mat & M_CLOTH
252 || mat & M_LIQUID
253 || (mat & M_IRON && rndm (1, 5) == 1)
254 || (mat & M_GLASS && rndm (1, 2) == 1)
255 || ((mat & M_STONE || mat & M_ADAMANT) && rndm (1, 10) == 1)
256 || ((mat & M_SOFT_METAL || mat & M_BONE) && rndm (1, 3) == 1)
257 || (mat & M_ICE && temp > 32))
245 destroy = 1; 258 destroy = 1;
246 if (op->material & M_IRON && rndm (1, 5) == 1)
247 destroy = 1;
248 if (op->material & M_GLASS && rndm (1, 2) == 1)
249 destroy = 1;
250 if ((op->material & M_STONE || op->material & M_ADAMANT) && rndm (1, 10) == 1)
251 destroy = 1;
252 if ((op->material & M_SOFT_METAL || op->material & M_BONE) && rndm (1, 3) == 1)
253 destroy = 1;
254 if (op->material & M_ICE && MAP_TEMP (m) > 32)
255 destroy = 1;
256 } 259 }
260
257 /* adjust overall chance below */ 261 /* adjust overall chance below */
258 if (destroy && rndm (0, 1)) 262 if (destroy && rndm (0, 1))
259 { 263 op->destroy ();
260 remove_ob (op);
261 free_object (op);
262 }
263 } 264 }
264} 265}
265 266
266/* convert materialname to materialtype_t */ 267/* convert materialname to materialtype_t */
267 268
268materialtype_t * 269materialtype_t *
… …
296 return; 297 return;
297 298
298 if (change->materialname != NULL && strcmp (op->materialname, change->materialname)) 299 if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
299 return; 300 return;
300 301
301 if (!IS_ARMOR (op)) 302 if (!op->is_armor ())
302 return; 303 return;
303 304
304 mt = name_to_material (op->materialname); 305 mt = name_to_material (op->materialname);
305 if (!mt) 306 if (!mt)
306 { 307 {
… …
352 { 353 {
353 if (op->material & mt->material && rndm (1, 100) <= mt->chance && 354 if (op->material & mt->material && rndm (1, 100) <= mt->chance &&
354 difficulty >= mt->difficulty && (op->magic >= mt->magic || mt->magic == 0)) 355 difficulty >= mt->difficulty && (op->magic >= mt->magic || mt->magic == 0))
355 { 356 {
356 lmt = mt; 357 lmt = mt;
357 if (!(IS_WEAPON (op) || IS_ARMOR (op))) 358 if (!(op->is_weapon () || op->is_armor ()))
358 break; 359 break;
359 } 360 }
360 } 361 }
361#endif 362#endif
362 } 363 }
… …
370#ifndef NEW_MATERIAL_CODE 371#ifndef NEW_MATERIAL_CODE
371 op->materialname = lmt->name; 372 op->materialname = lmt->name;
372 return; 373 return;
373#else 374#else
374 375
375 if (op->stats.dam && IS_WEAPON (op)) 376 if (op->stats.dam && op->is_weapon ())
376 { 377 {
377 op->stats.dam += lmt->damage; 378 op->stats.dam += lmt->damage;
378 if (op->stats.dam < 1) 379 if (op->stats.dam < 1)
379 op->stats.dam = 1; 380 op->stats.dam = 1;
380 } 381 }
381 if (op->stats.sp && op->type == BOW) 382 if (op->stats.sp && op->type == BOW)
382 op->stats.sp += lmt->sp; 383 op->stats.sp += lmt->sp;
383 if (op->stats.wc && IS_WEAPON (op)) 384 if (op->stats.wc && op->is_weapon ())
384 op->stats.wc += lmt->wc; 385 op->stats.wc += lmt->wc;
385 if (IS_ARMOR (op)) 386 if (op->is_armor ())
386 { 387 {
387 if (op->stats.ac) 388 if (op->stats.ac)
388 op->stats.ac += lmt->ac; 389 op->stats.ac += lmt->ac;
389 for (j = 0; j < NROFATTACKS; j++) 390 for (j = 0; j < NROFATTACKS; j++)
390 if (op->resist[j] != 0) 391 if (op->resist[j] != 0)
… …
396 op->resist[j] = -100; 397 op->resist[j] = -100;
397 } 398 }
398 } 399 }
399 op->materialname = add_string (lmt->name); 400 op->materialname = add_string (lmt->name);
400 /* dont make it unstackable if it doesn't need to be */ 401 /* dont make it unstackable if it doesn't need to be */
401 if (IS_WEAPON (op) || IS_ARMOR (op)) 402 if (op->is_weapon () || op->is_armor ())
402 { 403 {
403 op->weight = (op->weight * lmt->weight) / 100; 404 op->weight = (op->weight * lmt->weight) / 100;
404 op->value = (op->value * lmt->value) / 100; 405 op->value = (op->value * lmt->value) / 100;
405 } 406 }
406#endif 407#endif
… …
541 return; 542 return;
542} 543}
543 544
544///////////////////////////////////////////////////////////////////////////// 545/////////////////////////////////////////////////////////////////////////////
545 546
546#if 0 547void
547refcounted *refcounted::rc_first; 548fork_abort (const char *msg)
548
549refcounted::refcounted ()
550{ 549{
551 refcnt = 0; 550 if (!fork ())
552 rc_next = rc_first; 551 {
553 rc_first = this; 552 signal (SIGABRT, SIG_DFL);
554} 553 abort ();
554 }
555 555
556refcounted::~refcounted () 556 LOG (llevError, "fork abort: %s\n", msg);
557{
558 assert (!rc_next);
559 assert (!refcnt);
560} 557}
561#endif
562 558
563void *alloc (int s) throw (std::bad_alloc) 559void *salloc_ (int n) throw (std::bad_alloc)
564{ 560{
565 void *p = g_slice_alloc (s); 561 void *ptr = g_slice_alloc (n);
566 562
567 if (!p) 563 if (!ptr)
568 throw std::bad_alloc (); 564 throw std::bad_alloc ();
569 565
570 return p; 566 return ptr;
567}
568
569void *salloc_ (int n, void *src) throw (std::bad_alloc)
570{
571 void *ptr = salloc_ (n);
572
573 if (src)
574 memcpy (ptr, src, n);
575 else
576 memset (ptr, 0, n);
577
578 return ptr;
571} 579}
572 580
573void assign (char *dst, const char *src, int maxlen) 581void assign (char *dst, const char *src, int maxlen)
574{ 582{
575 if (!src) 583 if (!src)
… …
592 } 600 }
593 else 601 else
594 memcpy (dst, src, len + 1); 602 memcpy (dst, src, len + 1);
595} 603}
596 604
605tstamp now ()
606{
607 struct timeval tv;
597 608
609 gettimeofday (&tv, 0);
610 return tstamp (tv.tv_sec) + tstamp (tv.tv_usec) * tstamp (1e-6);
611}
612
613int
614similar_direction (int a, int b)
615{
616 if (!a || !b)
617 return 0;
618
619 int diff = (b - a) & 7;
620 return diff <= 1 || diff >= 7;
621}
622

Diff Legend

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