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

Comparing deliantra/server/common/utils.C (file contents):
Revision 1.9 by root, Sun Sep 10 16:00:23 2006 UTC vs.
Revision 1.41 by root, Thu Jan 18 22:19:59 2007 UTC

…		…
1
2	/*	1	/*
3	* static char *rcsid_utils_c =
4	* "$Id: utils.C,v 1.9 2006/09/10 16:00:23 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 (time (0));
		43
		44	tausworthe_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
		55	uint32_t
		56	tausworthe_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	}
39		65
40	/*	66	/*
41	* The random functions here take luck into account when rolling random	67	* 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	68	* 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	69	* 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,	76	* 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.	77	* 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,	78	* Generally, op should be the player/caster/hitter requesting the roll,
53	* not the recipient (ie, the poor slob getting hit). [garbled 20010916]	79	* not the recipient (ie, the poor slob getting hit). [garbled 20010916]
54	*/	80	*/
55
56	int	81	int
57	random_roll (int min, int max, const object *op, int goodbad)	82	random_roll (int r_min, int r_max, const object *op, int goodbad)
58	{	83	{
		84	int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */
		85
		86	if (r_max < 1 \|\| r_max < r_min)
		87	{
		88	LOG (llevError, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
		89	return r_min;
		90	}
		91
		92	if (op->type == PLAYER)
		93	{
		94	int luck = op->stats.luck;
		95
		96	if (rndm (base) < min (10, abs (luck)))
		97	{
		98	//TODO: take luck into account
		99	}
		100	}
		101
		102	return rndm (r_min, r_max);
		103	}
		104
		105	/*
		106	* This is a 64 bit version of random_roll above. This is needed
		107	* for exp loss calculations for players changing religions.
		108	*/
		109
		110	sint64
		111	random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
		112	{
59	int omin, diff, luck, base, ran;	113	sint64 omin, diff, luck, ran;
		114	int base;
60		115
61	omin = min;	116	omin = min;
62	diff = max - min + 1;	117	diff = max - min + 1;
63	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */	118	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
64		119
65	if (max < 1 \|\| diff < 1)	120	if (max < 1 \|\| diff < 1)
66	{	121	{
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);	122	LOG (llevError, "Calling random_roll with min=%" PRId64 " max=%" PRId64 "\n", min, max);
112	#endif
113	return (min); /* avoids a float exception */	123	return (min); /* avoids a float exception */
114	}	124	}
115		125
116	/* Don't know of a portable call to get 64 bit random values.	126	/* 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	127	* So make a call to get two 32 bit random numbers, and just to
…		…
184	}	194	}
185	}	195	}
186	return (total);	196	return (total);
187	}	197	}
188		198
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 */	199	/* decay and destroy perishable items in a map */
209
210	void	200	void
211	decay_objects (mapstruct *m)	201	maptile::decay_objects ()
212	{	202	{
213	int x, y, destroy;	203	if (!spaces)
214	object op, otmp;
215
216	if (m->unique)
217	return;	204	return;
218		205
219	for (x = 0; x < MAP_WIDTH (m); x++)	206	for (mapspace *ms = spaces + size (); ms-- > spaces; )
220	for (y = 0; y < MAP_HEIGHT (m); y++)	207	for (object above, op = ms->bot; op; op = above)
221	for (op = get_map_ob (m, x, y); op; op = otmp)
222	{	208	{
		209	above = op->above;
		210
223	destroy = 0;	211	bool destroy = 0;
224	otmp = op->above;	212
		213	// do not decay anything above unique floor tiles (yet :)
225	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))
226	break;	215	break;
		216
227	if (QUERY_FLAG (op, FLAG_IS_FLOOR) \|\|	217	if (QUERY_FLAG (op, FLAG_IS_FLOOR)
228	QUERY_FLAG (op, FLAG_OBJ_ORIGINAL) \|\|	218	\|\| QUERY_FLAG (op, FLAG_OBJ_ORIGINAL)
229	QUERY_FLAG (op, FLAG_OBJ_SAVE_ON_OVL) \|\|	219	\|\| 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))	220	\|\| QUERY_FLAG (op, FLAG_UNIQUE)
231	continue;	221	\|\| QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)
232	/* otherwise, we decay and destroy */	222	\|\| QUERY_FLAG (op, FLAG_UNPAID)
233	if (IS_WEAPON (op))	223	\|\| op->is_alive ())
		224	; // do not decay
		225	else if (op->is_weapon ())
234	{	226	{
235	op->stats.dam--;	227	op->stats.dam--;
236	if (op->stats.dam < 0)	228	if (op->stats.dam < 0)
237	destroy = 1;	229	destroy = 1;
238	}	230	}
239	else if (IS_ARMOR (op))	231	else if (op->is_armor ())
240	{	232	{
241	op->stats.ac--;	233	op->stats.ac--;
242	if (op->stats.ac < 0)	234	if (op->stats.ac < 0)
243	destroy = 1;	235	destroy = 1;
244	}	236	}
245	else if (op->type == FOOD)	237	else if (op->type == FOOD)
246	{	238	{
247	op->stats.food -= rndm (5, 20);	239	op->stats.food -= rndm (5, 20);
248	if (op->stats.food < 0)	240	if (op->stats.food < 0)
249	destroy = 1;	241	destroy = 1;
250	}	242	}
251	else	243	else
252	{	244	{
253	if (op->material & M_PAPER \|\| op->material & M_LEATHER \|\|	245	int mat = op->material;
254	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))
255	destroy = 1;	258	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	}	259	}
		260
267	/* adjust overall chance below */	261	/* adjust overall chance below */
268	if (destroy && rndm (0, 1))	262	if (destroy && rndm (0, 1))
269	{	263	op->destroy ();
270	remove_ob (op);
271	free_object (op);
272	}
273	}	264	}
274	}	265	}
275		266
276	/* convert materialname to materialtype_t */	267	/* convert materialname to materialtype_t */
277		268
278	materialtype_t *	269	materialtype_t *
…		…
306	return;	297	return;
307		298
308	if (change->materialname != NULL && strcmp (op->materialname, change->materialname))	299	if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
309	return;	300	return;
310		301
311	if (!IS_ARMOR (op))	302	if (!op->is_armor ())
312	return;	303	return;
313		304
314	mt = name_to_material (op->materialname);	305	mt = name_to_material (op->materialname);
315	if (!mt)	306	if (!mt)
316	{	307	{
…		…
362	{	353	{
363	if (op->material & mt->material && rndm (1, 100) <= mt->chance &&	354	if (op->material & mt->material && rndm (1, 100) <= mt->chance &&
364	difficulty >= mt->difficulty && (op->magic >= mt->magic \|\| mt->magic == 0))	355	difficulty >= mt->difficulty && (op->magic >= mt->magic \|\| mt->magic == 0))
365	{	356	{
366	lmt = mt;	357	lmt = mt;
367	if (!(IS_WEAPON (op) \|\| IS_ARMOR (op)))	358	if (!(op->is_weapon () \|\| op->is_armor ()))
368	break;	359	break;
369	}	360	}
370	}	361	}
371	#endif	362	#endif
372	}	363	}
…		…
380	#ifndef NEW_MATERIAL_CODE	371	#ifndef NEW_MATERIAL_CODE
381	op->materialname = lmt->name;	372	op->materialname = lmt->name;
382	return;	373	return;
383	#else	374	#else
384		375
385	if (op->stats.dam && IS_WEAPON (op))	376	if (op->stats.dam && op->is_weapon ())
386	{	377	{
387	op->stats.dam += lmt->damage;	378	op->stats.dam += lmt->damage;
388	if (op->stats.dam < 1)	379	if (op->stats.dam < 1)
389	op->stats.dam = 1;	380	op->stats.dam = 1;
390	}	381	}
391	if (op->stats.sp && op->type == BOW)	382	if (op->stats.sp && op->type == BOW)
392	op->stats.sp += lmt->sp;	383	op->stats.sp += lmt->sp;
393	if (op->stats.wc && IS_WEAPON (op))	384	if (op->stats.wc && op->is_weapon ())
394	op->stats.wc += lmt->wc;	385	op->stats.wc += lmt->wc;
395	if (IS_ARMOR (op))	386	if (op->is_armor ())
396	{	387	{
397	if (op->stats.ac)	388	if (op->stats.ac)
398	op->stats.ac += lmt->ac;	389	op->stats.ac += lmt->ac;
399	for (j = 0; j < NROFATTACKS; j++)	390	for (j = 0; j < NROFATTACKS; j++)
400	if (op->resist[j] != 0)	391	if (op->resist[j] != 0)
…		…
406	op->resist[j] = -100;	397	op->resist[j] = -100;
407	}	398	}
408	}	399	}
409	op->materialname = add_string (lmt->name);	400	op->materialname = add_string (lmt->name);
410	/* dont make it unstackable if it doesn't need to be */	401	/* dont make it unstackable if it doesn't need to be */
411	if (IS_WEAPON (op) \|\| IS_ARMOR (op))	402	if (op->is_weapon () \|\| op->is_armor ())
412	{	403	{
413	op->weight = (op->weight * lmt->weight) / 100;	404	op->weight = (op->weight * lmt->weight) / 100;
414	op->value = (op->value * lmt->value) / 100;	405	op->value = (op->value * lmt->value) / 100;
415	}	406	}
416	#endif	407	#endif
…		…
531		522
532	strncpy (tmp, input, MAX_BUF - 5);	523	strncpy (tmp, input, MAX_BUF - 5);
533	/trim all trailing commas, spaces etc. /	524	/trim all trailing commas, spaces etc. /
534	for (i = strlen (tmp); !isalnum (tmp[i]) && i >= 0; i--)	525	for (i = strlen (tmp); !isalnum (tmp[i]) && i >= 0; i--)
535	tmp[i] = '\0';	526	tmp[i] = '\0';
		527
536	strcat (tmp, ".");	528	strcat (tmp, ".");
537		529
538	p = strrchr (tmp, ',');	530	p = strrchr (tmp, ',');
539	if (p)	531	if (p)
540	{	532	{
…		…
544	strcat (input, " and");	536	strcat (input, " and");
545	strcat (input, p);	537	strcat (input, p);
546	}	538	}
547	else	539	else
548	strcpy (input, tmp);	540	strcpy (input, tmp);
		541
549	return;	542	return;
550	}	543	}
551		544
		545	/////////////////////////////////////////////////////////////////////////////
		546
552	void *	547	void
553	zero_initialised::operator	548	fork_abort (const char *msg)
554	new (size_t s)
555	{	549	{
556	//return calloc (1, s);	550	if (!fork ())
557	return g_slice_alloc0 (s);	551	{
558	}	552	signal (SIGABRT, SIG_DFL);
		553	abort ();
		554	}
559		555
560	void *	556	LOG (llevError, "fork abort: %s\n", msg);
561	zero_initialised::operator
562	new[] (size_t s)
563	{
564	//return calloc (1, s);
565	return g_slice_alloc0 (s);
566	}	557	}
567		558
568	void	559	void *salloc_ (int n) throw (std::bad_alloc)
569	zero_initialised::operator
570	delete (void *p, size_t s)
571	{	560	{
572	//free (p); return;	561	void *ptr = g_slice_alloc (n);
573	g_slice_free1 (s, p);
574	}
575		562
576	void	563	if (!ptr)
577	zero_initialised::operator	564	throw std::bad_alloc ();
578	delete[] (void *p, size_t s)	565
579	{	566	return ptr;
580	//free (p); return;
581	g_slice_free1 (s, p);
582	}	567	}
		568
		569	void 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;
		579	}
		580
		581	void assign (char dst, const char src, int maxlen)
		582	{
		583	if (!src)
		584	src = "";
		585
		586	int len = strlen (src);
		587
		588	if (len >= maxlen - 1)
		589	{
		590	if (maxlen <= 4)
		591	{
		592	memset (dst, '.', maxlen - 1);
		593	dst [maxlen - 1] = 0;
		594	}
		595	else
		596	{
		597	memcpy (dst, src, maxlen - 4);
		598	memcpy (dst + maxlen - 4, "...", 4);
		599	}
		600	}
		601	else
		602	memcpy (dst, src, len + 1);
		603	}
		604
		605	tstamp now ()
		606	{
		607	struct timeval tv;
		608
		609	gettimeofday (&tv, 0);
		610	return tstamp (tv.tv_sec) + tstamp (tv.tv_usec) * tstamp (1e-6);
		611	}
		612
		613	int
		614	similar_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

Comparing deliantra/server/common/utils.C (file contents): Revision 1.9 by root, Sun Sep 10 16:00:23 2006 UTC vs. Revision 1.41 by root, Thu Jan 18 22:19:59 2007 UTC

Diff Legend

Comparing deliantra/server/common/utils.C (file contents):
Revision 1.9 by root, Sun Sep 10 16:00:23 2006 UTC vs.
Revision 1.41 by root, Thu Jan 18 22:19:59 2007 UTC