[ViewVC] Diff of: cvs/deliantra/server/common/utils.C

Comparing deliantra/server/common/utils.C (file contents):
Revision 1.12 by root, Tue Sep 12 20:55:40 2006 UTC vs.
Revision 1.43 by root, Fri Jan 19 22:24:10 2007 UTC

…		…
1
2	/*	1	/*
3	* static char *rcsid_utils_c =
4	* "$Id: utils.C,v 1.12 2006/09/12 20:55:40 root Exp $";
5	*/
6
7	/*
8	CrossFire, A Multiplayer game for X-windows	2	* CrossFire, A Multiplayer game for X-windows
9		3	*
		4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
10	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (C) 2002 Mark Wedel & Crossfire Development Team
11	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (C) 1992 Frank Tore Johansen
12		7	*
13	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
14	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
15	the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation; either version 2 of the License, or
16	(at your option) any later version.	11	* (at your option) any later version.
17		12	*
18	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,
19	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
20	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21	GNU General Public License for more details.	16	* GNU General Public License for more details.
22		17	*
23	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
24	along with this program; if not, write to the Free Software	19	* along with this program; if not, write to the Free Software
25	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26		21	*
27	The authors can be reached via e-mail at crossfire-devel@real-time.com	22	* The authors can be reached via e-mail at <crossfire@schmorp.de>
28	*/	23	*/
29		24
30	/*	25	/*
31	* General convenience functions for crossfire.	26	* General convenience functions for crossfire.
32	*/	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>
33		35
34	#include <global.h>	36	#include <global.h>
35	#include <funcpoint.h>	37	#include <funcpoint.h>
36	#include <material.h>	38	#include <material.h>
37		39
38	#include <glib.h>	40	#include <glib.h>
		41
		42	rand_gen rndm;
		43
		44	void
		45	tausworthe_random_generator::seed (uint32_t seed)
		46	{
		47	state [0] = max ( 2U, seed * 69069U);
		48	state [1] = max ( 8U, state [0] * 69069U);
		49	state [2] = max ( 16U, state [1] * 69069U);
		50	state [3] = max (128U, state [2] * 69069U);
		51
		52	for (int i = 11; --i; )
		53	operator ()();
		54	}
		55
		56	uint32_t
		57	tausworthe_random_generator::next ()
		58	{
		59	state [0] = ((state [0] & 0xFFFFFFFEU) << 18U) ^ (((state [0] << 6U) ^ state [0]) >> 13U);
		60	state [1] = ((state [1] & 0xFFFFFFF8U) << 2U) ^ (((state [1] << 2U) ^ state [1]) >> 27U);
		61	state [2] = ((state [2] & 0xFFFFFFF0U) << 7U) ^ (((state [2] << 13U) ^ state [2]) >> 21U);
		62	state [3] = ((state [3] & 0xFFFFFF80U) << 13U) ^ (((state [3] << 3U) ^ state [3]) >> 12U);
		63
		64	return state [0] ^ state [1] ^ state [2] ^ state [3];
		65	}
		66
		67	uint32_t
		68	tausworthe_random_generator::get_range (uint32_t r_max)
		69	{
		70	return next () % r_max;
		71	}
		72
		73	// return a number within (min .. max)
		74	int
		75	tausworthe_random_generator::get_range (int r_min, int r_max)
		76	{
		77	return r_min + (*this) (max (r_max - r_min + 1, 1));
		78	}
39		79
40	/*	80	/*
41	* The random functions here take luck into account when rolling random	81	* The random functions here take luck into account when rolling random
42	* 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
43	* difference becomes in the random numbers. IE, the effect is lessened	83	* difference becomes in the random numbers. IE, the effect is lessened
50	* Roll a random number between min and max. Uses op to determine luck,	90	* Roll a random number between min and max. Uses op to determine luck,
51	* and if goodbad is non-zero, luck increases the roll, if zero, it decreases.	91	* and if goodbad is non-zero, luck increases the roll, if zero, it decreases.
52	* Generally, op should be the player/caster/hitter requesting the roll,	92	* Generally, op should be the player/caster/hitter requesting the roll,
53	* not the recipient (ie, the poor slob getting hit). [garbled 20010916]	93	* not the recipient (ie, the poor slob getting hit). [garbled 20010916]
54	*/	94	*/
55
56	int	95	int
57	random_roll (int min, int max, const object *op, int goodbad)	96	random_roll (int r_min, int r_max, const object *op, int goodbad)
58	{	97	{
		98	int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */
		99
		100	if (r_max < 1 \|\| r_max < r_min)
		101	{
		102	LOG (llevError, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
		103	return r_min;
		104	}
		105
		106	if (op->type == PLAYER)
		107	{
		108	int luck = op->stats.luck;
		109
		110	if (rndm (base) < min (10, abs (luck)))
		111	{
		112	//TODO: take luck into account
		113	}
		114	}
		115
		116	return rndm (r_min, r_max);
		117	}
		118
		119	/*
		120	* This is a 64 bit version of random_roll above. This is needed
		121	* for exp loss calculations for players changing religions.
		122	*/
		123
		124	sint64
		125	random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
		126	{
59	int omin, diff, luck, base, ran;	127	sint64 omin, diff, luck, ran;
		128	int base;
60		129
61	omin = min;	130	omin = min;
62	diff = max - min + 1;	131	diff = max - min + 1;
63	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */	132	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
64		133
65	if (max < 1 \|\| diff < 1)	134	if (max < 1 \|\| diff < 1)
66	{	135	{
67	LOG (llevError, "Calling random_roll with min=%d max=%d\n", min, max);
68	return (min); /* avoids a float exception */
69	}
70
71	ran = RANDOM ();
72
73	if (op->type != PLAYER)
74	return ((ran % diff) + min);
75
76	luck = op->stats.luck;
77	if (RANDOM () % base < MIN (10, abs (luck)))
78	{
79	/* we have a winner */
80	((luck > 0) ? (luck = 1) : (luck = -1));
81	diff -= luck;
82	if (diff < 1)
83	return (omin); /check again /
84	((goodbad) ? (min += luck) : (diff));
85
86	return (MAX (omin, MIN (max, (ran % diff) + min)));
87	}
88	return ((ran % diff) + min);
89	}
90
91	/*
92	* This is a 64 bit version of random_roll above. This is needed
93	* for exp loss calculations for players changing religions.
94	*/
95
96	sint64
97	random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
98	{
99	sint64 omin, diff, luck, ran;
100	int base;
101
102	omin = min;
103	diff = max - min + 1;
104	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
105
106	if (max < 1 \|\| diff < 1)
107	{
108	#ifndef WIN32
109	LOG (llevError, "Calling random_roll with min=%lld max=%lld\n", min, max);
110	#else
111	LOG (llevError, "Calling random_roll with min=%I64d max=%I64d\n", min, max);	136	LOG (llevError, "Calling random_roll with min=%" PRId64 " max=%" PRId64 "\n", min, max);
112	#endif
113	return (min); /* avoids a float exception */	137	return (min); /* avoids a float exception */
114	}	138	}
115		139
116	/* Don't know of a portable call to get 64 bit random values.	140	/* Don't know of a portable call to get 64 bit random values.
117	* So make a call to get two 32 bit random numbers, and just to	141	* So make a call to get two 32 bit random numbers, and just to
…		…
184	}	208	}
185	}	209	}
186	return (total);	210	return (total);
187	}	211	}
188		212
189	/*
190	* Another convenience function. Returns a number between min and max.
191	* It is suggested one use these functions rather than RANDOM()%, as it
192	* would appear that a number of off-by-one-errors exist due to improper
193	* use of %. This should also prevent SIGFPE.
194	*/
195
196	int
197	rndm (int min, int max)
198	{
199	int diff;
200
201	diff = max - min + 1;
202	if (max < 1 \|\| diff < 1)
203	return (min);
204
205	return (RANDOM () % diff + min);
206	}
207
208	/* decay and destroy persihable items in a map */	213	/* decay and destroy perishable items in a map */
209
210	void	214	void
211	decay_objects (mapstruct *m)	215	maptile::decay_objects ()
212	{	216	{
213	int x, y, destroy;	217	if (!spaces)
214	object op, otmp;
215
216	if (m->unique)
217	return;	218	return;
218		219
219	for (x = 0; x < MAP_WIDTH (m); x++)	220	for (mapspace *ms = spaces + size (); ms-- > spaces; )
220	for (y = 0; y < MAP_HEIGHT (m); y++)	221	for (object above, op = ms->bot; op; op = above)
221	for (op = get_map_ob (m, x, y); op; op = otmp)
222	{	222	{
		223	above = op->above;
		224
223	destroy = 0;	225	bool destroy = 0;
224	otmp = op->above;	226
		227	// do not decay anything above unique floor tiles (yet :)
225	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))	228	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
226	break;	229	break;
		230
227	if (QUERY_FLAG (op, FLAG_IS_FLOOR) \|\|	231	if (QUERY_FLAG (op, FLAG_IS_FLOOR)
228	QUERY_FLAG (op, FLAG_OBJ_ORIGINAL) \|\|	232	\|\| QUERY_FLAG (op, FLAG_OBJ_ORIGINAL)
229	QUERY_FLAG (op, FLAG_OBJ_SAVE_ON_OVL) \|\|	233	\|\| QUERY_FLAG (op, FLAG_OBJ_SAVE_ON_OVL)
230	QUERY_FLAG (op, FLAG_UNIQUE) \|\| QUERY_FLAG (op, FLAG_OVERLAY_FLOOR) \|\| QUERY_FLAG (op, FLAG_UNPAID) \|\| IS_LIVE (op))	234	\|\| QUERY_FLAG (op, FLAG_UNIQUE)
231	continue;	235	\|\| QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)
232	/* otherwise, we decay and destroy */	236	\|\| QUERY_FLAG (op, FLAG_UNPAID)
233	if (IS_WEAPON (op))	237	\|\| op->is_alive ())
		238	; // do not decay
		239	else if (op->is_weapon ())
234	{	240	{
235	op->stats.dam--;	241	op->stats.dam--;
236	if (op->stats.dam < 0)	242	if (op->stats.dam < 0)
237	destroy = 1;	243	destroy = 1;
238	}	244	}
239	else if (IS_ARMOR (op))	245	else if (op->is_armor ())
240	{	246	{
241	op->stats.ac--;	247	op->stats.ac--;
242	if (op->stats.ac < 0)	248	if (op->stats.ac < 0)
243	destroy = 1;	249	destroy = 1;
244	}	250	}
245	else if (op->type == FOOD)	251	else if (op->type == FOOD)
246	{	252	{
247	op->stats.food -= rndm (5, 20);	253	op->stats.food -= rndm (5, 20);
248	if (op->stats.food < 0)	254	if (op->stats.food < 0)
249	destroy = 1;	255	destroy = 1;
250	}	256	}
251	else	257	else
252	{	258	{
253	if (op->material & M_PAPER \|\| op->material & M_LEATHER \|\|	259	int mat = op->material;
254	op->material & M_WOOD \|\| op->material & M_ORGANIC \|\| op->material & M_CLOTH \|\| op->material & M_LIQUID)	260
		261	if (mat & M_PAPER
		262	\|\| mat & M_LEATHER
		263	\|\| mat & M_WOOD
		264	\|\| mat & M_ORGANIC
		265	\|\| mat & M_CLOTH
		266	\|\| mat & M_LIQUID
		267	\|\| (mat & M_IRON && rndm (1, 5) == 1)
		268	\|\| (mat & M_GLASS && rndm (1, 2) == 1)
		269	\|\| ((mat & M_STONE \|\| mat & M_ADAMANT) && rndm (1, 10) == 1)
		270	\|\| ((mat & M_SOFT_METAL \|\| mat & M_BONE) && rndm (1, 3) == 1)
		271	\|\| (mat & M_ICE && temp > 32))
255	destroy = 1;	272	destroy = 1;
256	if (op->material & M_IRON && rndm (1, 5) == 1)
257	destroy = 1;
258	if (op->material & M_GLASS && rndm (1, 2) == 1)
259	destroy = 1;
260	if ((op->material & M_STONE \|\| op->material & M_ADAMANT) && rndm (1, 10) == 1)
261	destroy = 1;
262	if ((op->material & M_SOFT_METAL \|\| op->material & M_BONE) && rndm (1, 3) == 1)
263	destroy = 1;
264	if (op->material & M_ICE && MAP_TEMP (m) > 32)
265	destroy = 1;
266	}	273	}
		274
267	/* adjust overall chance below */	275	/* adjust overall chance below */
268	if (destroy && rndm (0, 1))	276	if (destroy && rndm (0, 1))
269	{	277	op->destroy ();
270	remove_ob (op);
271	free_object (op);
272	}
273	}	278	}
274	}	279	}
275		280
276	/* convert materialname to materialtype_t */	281	/* convert materialname to materialtype_t */
277		282
278	materialtype_t *	283	materialtype_t *
…		…
306	return;	311	return;
307		312
308	if (change->materialname != NULL && strcmp (op->materialname, change->materialname))	313	if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
309	return;	314	return;
310		315
311	if (!IS_ARMOR (op))	316	if (!op->is_armor ())
312	return;	317	return;
313		318
314	mt = name_to_material (op->materialname);	319	mt = name_to_material (op->materialname);
315	if (!mt)	320	if (!mt)
316	{	321	{
…		…
362	{	367	{
363	if (op->material & mt->material && rndm (1, 100) <= mt->chance &&	368	if (op->material & mt->material && rndm (1, 100) <= mt->chance &&
364	difficulty >= mt->difficulty && (op->magic >= mt->magic \|\| mt->magic == 0))	369	difficulty >= mt->difficulty && (op->magic >= mt->magic \|\| mt->magic == 0))
365	{	370	{
366	lmt = mt;	371	lmt = mt;
367	if (!(IS_WEAPON (op) \|\| IS_ARMOR (op)))	372	if (!(op->is_weapon () \|\| op->is_armor ()))
368	break;	373	break;
369	}	374	}
370	}	375	}
371	#endif	376	#endif
372	}	377	}
…		…
380	#ifndef NEW_MATERIAL_CODE	385	#ifndef NEW_MATERIAL_CODE
381	op->materialname = lmt->name;	386	op->materialname = lmt->name;
382	return;	387	return;
383	#else	388	#else
384		389
385	if (op->stats.dam && IS_WEAPON (op))	390	if (op->stats.dam && op->is_weapon ())
386	{	391	{
387	op->stats.dam += lmt->damage;	392	op->stats.dam += lmt->damage;
388	if (op->stats.dam < 1)	393	if (op->stats.dam < 1)
389	op->stats.dam = 1;	394	op->stats.dam = 1;
390	}	395	}
391	if (op->stats.sp && op->type == BOW)	396	if (op->stats.sp && op->type == BOW)
392	op->stats.sp += lmt->sp;	397	op->stats.sp += lmt->sp;
393	if (op->stats.wc && IS_WEAPON (op))	398	if (op->stats.wc && op->is_weapon ())
394	op->stats.wc += lmt->wc;	399	op->stats.wc += lmt->wc;
395	if (IS_ARMOR (op))	400	if (op->is_armor ())
396	{	401	{
397	if (op->stats.ac)	402	if (op->stats.ac)
398	op->stats.ac += lmt->ac;	403	op->stats.ac += lmt->ac;
399	for (j = 0; j < NROFATTACKS; j++)	404	for (j = 0; j < NROFATTACKS; j++)
400	if (op->resist[j] != 0)	405	if (op->resist[j] != 0)
…		…
406	op->resist[j] = -100;	411	op->resist[j] = -100;
407	}	412	}
408	}	413	}
409	op->materialname = add_string (lmt->name);	414	op->materialname = add_string (lmt->name);
410	/* dont make it unstackable if it doesn't need to be */	415	/* dont make it unstackable if it doesn't need to be */
411	if (IS_WEAPON (op) \|\| IS_ARMOR (op))	416	if (op->is_weapon () \|\| op->is_armor ())
412	{	417	{
413	op->weight = (op->weight * lmt->weight) / 100;	418	op->weight = (op->weight * lmt->weight) / 100;
414	op->value = (op->value * lmt->value) / 100;	419	op->value = (op->value * lmt->value) / 100;
415	}	420	}
416	#endif	421	#endif
…		…
549	strcpy (input, tmp);	554	strcpy (input, tmp);
550		555
551	return;	556	return;
552	}	557	}
553		558
		559	/////////////////////////////////////////////////////////////////////////////
		560
		561	void
		562	fork_abort (const char *msg)
		563	{
		564	if (!fork ())
		565	{
		566	signal (SIGABRT, SIG_DFL);
		567	abort ();
		568	}
		569
		570	LOG (llevError, "fork abort: %s\n", msg);
		571	}
		572
554	void *alloc (int s) throw (std::bad_alloc)	573	void *salloc_ (int n) throw (std::bad_alloc)
555	{	574	{
		575	void *ptr = g_slice_alloc (n);
		576
		577	if (!ptr)
		578	throw std::bad_alloc ();
		579
		580	return ptr;
		581	}
		582
		583	void salloc_ (int n, void src) throw (std::bad_alloc)
		584	{
		585	void *ptr = salloc_ (n);
		586
556	if (s)	587	if (src)
557	return g_slice_alloc (s);	588	memcpy (ptr, src, n);
558	else	589	else
		590	memset (ptr, 0, n);
		591
559	return 0;	592	return ptr;
560	}
561
562	void dealloc (void *p, int s) throw ()
563	{
564	if (s)
565	g_slice_free1 (s, p);
566	}	593	}
567		594
568	void assign (char dst, const char src, int maxlen)	595	void assign (char dst, const char src, int maxlen)
569	{	596	{
570	if (!src)	597	if (!src)
…		…
587	}	614	}
588	else	615	else
589	memcpy (dst, src, len + 1);	616	memcpy (dst, src, len + 1);
590	}	617	}
591		618
		619	tstamp now ()
		620	{
		621	struct timeval tv;
		622
		623	gettimeofday (&tv, 0);
		624	return tstamp (tv.tv_sec) + tstamp (tv.tv_usec) * tstamp (1e-6);
		625	}
		626
		627	int
		628	similar_direction (int a, int b)
		629	{
		630	if (!a \|\| !b)
		631	return 0;
		632
		633	int diff = (b - a) & 7;
		634	return diff <= 1 \|\| diff >= 7;
		635	}
		636

Diff Legend

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

Comparing deliantra/server/common/utils.C (file contents): Revision 1.12 by root, Tue Sep 12 20:55:40 2006 UTC vs. Revision 1.43 by root, Fri Jan 19 22:24:10 2007 UTC

Diff Legend

Comparing deliantra/server/common/utils.C (file contents):
Revision 1.12 by root, Tue Sep 12 20:55:40 2006 UTC vs.
Revision 1.43 by root, Fri Jan 19 22:24:10 2007 UTC