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

Comparing deliantra/server/common/utils.C (file contents):
Revision 1.20 by root, Mon Dec 11 21:32:16 2006 UTC vs.
Revision 1.46 by root, Mon Feb 5 01:47:22 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
		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	}
33		79
34	/*	80	/*
35	* The random functions here take luck into account when rolling random	81	* 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	82	* 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	83	* 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,	90	* 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.	91	* 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,	92	* Generally, op should be the player/caster/hitter requesting the roll,
47	* not the recipient (ie, the poor slob getting hit). [garbled 20010916]	93	* not the recipient (ie, the poor slob getting hit). [garbled 20010916]
48	*/	94	*/
49
50	int	95	int
51	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)
52	{	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	sint64
		124	random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
		125	{
53	int omin, diff, luck, base, ran;	126	sint64 omin, diff, luck, ran;
		127	int base;
54		128
55	omin = min;	129	omin = min;
56	diff = max - min + 1;	130	diff = max - min + 1;
57	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */	131	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
58		132
59	if (max < 1 \|\| diff < 1)	133	if (max < 1 \|\| diff < 1)
60	{	134	{
61	LOG (llevError, "Calling random_roll with min=%d max=%d\n", min, max);	135	LOG (llevError, "Calling random_roll with min=%" PRId64 " max=%" PRId64 "\n", min, max);
62	return (min); /* avoids a float exception */	136	return (min); /* avoids a float exception */
63	}	137	}
64		138
65	ran = RANDOM ();	139	/*
		140	* Make a call to get two 32 bit unsigned random numbers, and just to
		141	* a little bitshifting.
		142	*/
		143	ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);
66		144
67	if (op->type != PLAYER)	145	if (op->type != PLAYER)
68	return ((ran % diff) + min);	146	return ((ran % diff) + min);
69		147
70	luck = op->stats.luck;	148	luck = op->stats.luck;
71	if (RANDOM () % base < MIN (10, abs (luck)))	149	if (rndm (base) < MIN (10, abs (luck)))
72	{	150	{
73	/* we have a winner */	151	/* we have a winner */
74	((luck > 0) ? (luck = 1) : (luck = -1));	152	((luck > 0) ? (luck = 1) : (luck = -1));
75	diff -= luck;	153	diff -= luck;
76	if (diff < 1)	154	if (diff < 1)
77	return (omin); /check again /	155	return (omin); /check again /
78	((goodbad) ? (min += luck) : (diff));	156	((goodbad) ? (min += luck) : (diff));
79		157
80	return (MAX (omin, MIN (max, (ran % diff) + min)));	158	return (MAX (omin, MIN (max, (ran % diff) + min)));
81	}	159	}
82	return ((ran % diff) + min);
83	}
84		160
85	/*
86	* This is a 64 bit version of random_roll above. This is needed
87	* for exp loss calculations for players changing religions.
88	*/
89
90	sint64
91	random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
92	{
93	sint64 omin, diff, luck, ran;
94	int base;
95
96	omin = min;
97	diff = max - min + 1;
98	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
99
100	if (max < 1 \|\| diff < 1)
101	{
102	LOG (llevError, "Calling random_roll with min=%" PRId64 " max=%" PRId64 "\n", min, max);
103	return (min); /* avoids a float exception */
104	}
105
106	/* Don't know of a portable call to get 64 bit random values.
107	* So make a call to get two 32 bit random numbers, and just to
108	* a little byteshifting. Do make sure the first one is only
109	* 32 bit, so we don't get skewed results
110	*/
111	ran = (RANDOM () & 0xffffffff) \| ((sint64) RANDOM () << 32);
112
113	if (op->type != PLAYER)
114	return ((ran % diff) + min);
115
116	luck = op->stats.luck;
117	if (RANDOM () % base < MIN (10, abs (luck)))
118	{
119	/* we have a winner */
120	((luck > 0) ? (luck = 1) : (luck = -1));
121	diff -= luck;
122	if (diff < 1)
123	return (omin); /check again /
124	((goodbad) ? (min += luck) : (diff));
125
126	return (MAX (omin, MIN (max, (ran % diff) + min)));
127	}
128	return ((ran % diff) + min);	161	return ((ran % diff) + min);
129	}	162	}
130		163
131	/*	164	/*
132	* Roll a number of dice (2d3, 4d6). Uses op to determine luck,	165	* Roll a number of dice (2d3, 4d6). Uses op to determine luck,
…		…
137	*/	170	*/
138		171
139	int	172	int
140	die_roll (int num, int size, const object *op, int goodbad)	173	die_roll (int num, int size, const object *op, int goodbad)
141	{	174	{
142	int min, diff, luck, total, i, gotlucky, base, ran;	175	int min, diff, luck, total, i, gotlucky, base;
143		176
144	diff = size;	177	diff = size;
145	min = 1;	178	min = 1;
146	luck = total = gotlucky = 0;	179	luck = total = gotlucky = 0;
147	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */	180	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
…		…
154	if (op->type == PLAYER)	187	if (op->type == PLAYER)
155	luck = op->stats.luck;	188	luck = op->stats.luck;
156		189
157	for (i = 0; i < num; i++)	190	for (i = 0; i < num; i++)
158	{	191	{
159	if (RANDOM () % base < MIN (10, abs (luck)) && !gotlucky)	192	if (rndm (base) < MIN (10, abs (luck)) && !gotlucky)
160	{	193	{
161	/* we have a winner */	194	/* we have a winner */
162	gotlucky++;	195	gotlucky++;
163	((luck > 0) ? (luck = 1) : (luck = -1));	196	((luck > 0) ? (luck = 1) : (luck = -1));
164	diff -= luck;	197	diff -= luck;
165	if (diff < 1)	198	if (diff < 1)
166	return (num); /check again /	199	return (num); /check again /
167	((goodbad) ? (min += luck) : (diff));	200	((goodbad) ? (min += luck) : (diff));
168	ran = RANDOM ();
169	total += MAX (1, MIN (size, (ran % diff) + min));	201	total += MAX (1, MIN (size, rndm (diff) + min));
170	}	202	}
171	else	203	else
172	{
173	total += RANDOM () % size + 1;	204	total += rndm (size) + 1;
174	}
175	}	205	}
		206
176	return (total);	207	return total;
177	}	208	}
178		209
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
186	int
187	rndm (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 */	210	/* decay and destroy perishable items in a map */
199
200	void	211	void
201	decay_objects (maptile *m)	212	maptile::decay_objects ()
202	{	213	{
203	int x, y, destroy;	214	if (!spaces)
204	object op, otmp;
205
206	if (m->unique)
207	return;	215	return;
208		216
209	for (x = 0; x < MAP_WIDTH (m); x++)	217	for (mapspace *ms = spaces + size (); ms-- > spaces; )
210	for (y = 0; y < MAP_HEIGHT (m); y++)	218	for (object above, op = ms->bot; op; op = above)
211	for (op = get_map_ob (m, x, y); op; op = otmp)
212	{	219	{
		220	above = op->above;
		221
213	destroy = 0;	222	bool destroy = 0;
214	otmp = op->above;	223
		224	// do not decay anything above unique floor tiles (yet :)
215	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))	225	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
216	break;	226	break;
		227
217	if (QUERY_FLAG (op, FLAG_IS_FLOOR) \|\|	228	if (QUERY_FLAG (op, FLAG_IS_FLOOR)
218	QUERY_FLAG (op, FLAG_OBJ_ORIGINAL) \|\|	229	\|\| QUERY_FLAG (op, FLAG_OBJ_ORIGINAL)
219	QUERY_FLAG (op, FLAG_OBJ_SAVE_ON_OVL) \|\|	230	\|\| 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))	231	\|\| QUERY_FLAG (op, FLAG_UNIQUE)
221	continue;	232	\|\| QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)
222	/* otherwise, we decay and destroy */	233	\|\| QUERY_FLAG (op, FLAG_UNPAID)
223	if (IS_WEAPON (op))	234	\|\| op->is_alive ())
		235	; // do not decay
		236	else if (op->is_weapon ())
224	{	237	{
225	op->stats.dam--;	238	op->stats.dam--;
226	if (op->stats.dam < 0)	239	if (op->stats.dam < 0)
227	destroy = 1;	240	destroy = 1;
228	}	241	}
229	else if (IS_ARMOR (op))	242	else if (op->is_armor ())
230	{	243	{
231	op->stats.ac--;	244	op->stats.ac--;
232	if (op->stats.ac < 0)	245	if (op->stats.ac < 0)
233	destroy = 1;	246	destroy = 1;
234	}	247	}
235	else if (op->type == FOOD)	248	else if (op->type == FOOD)
236	{	249	{
237	op->stats.food -= rndm (5, 20);	250	op->stats.food -= rndm (5, 20);
238	if (op->stats.food < 0)	251	if (op->stats.food < 0)
239	destroy = 1;	252	destroy = 1;
240	}	253	}
241	else	254	else
242	{	255	{
243	if (op->material & M_PAPER \|\| op->material & M_LEATHER \|\|	256	int mat = op->material;
244	op->material & M_WOOD \|\| op->material & M_ORGANIC \|\| op->material & M_CLOTH \|\| op->material & M_LIQUID)	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))
245	destroy = 1;	269	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	}	270	}
		271
257	/* adjust overall chance below */	272	/* adjust overall chance below */
258	if (destroy && rndm (0, 1))	273	if (destroy && rndm (0, 1))
259	{	274	op->destroy ();
260	remove_ob (op);
261	free_object (op);
262	}
263	}	275	}
264	}	276	}
265		277
266	/* convert materialname to materialtype_t */	278	/* convert materialname to materialtype_t */
267		279
268	materialtype_t *	280	materialtype_t *
…		…
296	return;	308	return;
297		309
298	if (change->materialname != NULL && strcmp (op->materialname, change->materialname))	310	if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
299	return;	311	return;
300		312
301	if (!IS_ARMOR (op))	313	if (!op->is_armor ())
302	return;	314	return;
303		315
304	mt = name_to_material (op->materialname);	316	mt = name_to_material (op->materialname);
305	if (!mt)	317	if (!mt)
306	{	318	{
…		…
352	{	364	{
353	if (op->material & mt->material && rndm (1, 100) <= mt->chance &&	365	if (op->material & mt->material && rndm (1, 100) <= mt->chance &&
354	difficulty >= mt->difficulty && (op->magic >= mt->magic \|\| mt->magic == 0))	366	difficulty >= mt->difficulty && (op->magic >= mt->magic \|\| mt->magic == 0))
355	{	367	{
356	lmt = mt;	368	lmt = mt;
357	if (!(IS_WEAPON (op) \|\| IS_ARMOR (op)))	369	if (!(op->is_weapon () \|\| op->is_armor ()))
358	break;	370	break;
359	}	371	}
360	}	372	}
361	#endif	373	#endif
362	}	374	}
…		…
370	#ifndef NEW_MATERIAL_CODE	382	#ifndef NEW_MATERIAL_CODE
371	op->materialname = lmt->name;	383	op->materialname = lmt->name;
372	return;	384	return;
373	#else	385	#else
374		386
375	if (op->stats.dam && IS_WEAPON (op))	387	if (op->stats.dam && op->is_weapon ())
376	{	388	{
377	op->stats.dam += lmt->damage;	389	op->stats.dam += lmt->damage;
378	if (op->stats.dam < 1)	390	if (op->stats.dam < 1)
379	op->stats.dam = 1;	391	op->stats.dam = 1;
380	}	392	}
		393
381	if (op->stats.sp && op->type == BOW)	394	if (op->stats.sp && op->type == BOW)
382	op->stats.sp += lmt->sp;	395	op->stats.sp += lmt->sp;
383	if (op->stats.wc && IS_WEAPON (op))	396	if (op->stats.wc && op->is_weapon ())
384	op->stats.wc += lmt->wc;	397	op->stats.wc += lmt->wc;
385	if (IS_ARMOR (op))	398	if (op->is_armor ())
386	{	399	{
387	if (op->stats.ac)	400	if (op->stats.ac)
388	op->stats.ac += lmt->ac;	401	op->stats.ac += lmt->ac;
389	for (j = 0; j < NROFATTACKS; j++)	402	for (j = 0; j < NROFATTACKS; j++)
390	if (op->resist[j] != 0)	403	if (op->resist[j] != 0)
…		…
394	op->resist[j] = 100;	407	op->resist[j] = 100;
395	if (op->resist[j] < -100)	408	if (op->resist[j] < -100)
396	op->resist[j] = -100;	409	op->resist[j] = -100;
397	}	410	}
398	}	411	}
399	op->materialname = add_string (lmt->name);	412	op->materialname = lmt->name;
400	/* dont make it unstackable if it doesn't need to be */	413	/* dont make it unstackable if it doesn't need to be */
401	if (IS_WEAPON (op) \|\| IS_ARMOR (op))	414	if (op->is_weapon () \|\| op->is_armor ())
402	{	415	{
403	op->weight = (op->weight * lmt->weight) / 100;	416	op->weight = (op->weight * lmt->weight) / 100;
404	op->value = (op->value * lmt->value) / 100;	417	op->value = (op->value * lmt->value) / 100;
405	}	418	}
406	#endif	419	#endif
…		…
541	return;	554	return;
542	}	555	}
543		556
544	/////////////////////////////////////////////////////////////////////////////	557	/////////////////////////////////////////////////////////////////////////////
545		558
546	#if 0	559	void
547	refcounted *refcounted::rc_first;	560	fork_abort (const char *msg)
548
549	refcounted::refcounted ()
550	{	561	{
551	refcnt = 0;	562	if (!fork ())
552	rc_next = rc_first;	563	{
553	rc_first = this;	564	signal (SIGABRT, SIG_DFL);
554	}	565	abort ();
		566	}
555		567
556	refcounted::~refcounted ()	568	LOG (llevError, "fork abort: %s\n", msg);
557	{
558	assert (!rc_next);
559	assert (!refcnt);
560	}	569	}
		570
		571	void *salloc_ (int n) throw (std::bad_alloc)
		572	{
		573	#ifdef PREFER_MALLOC
		574	void *ptr = malloc (n);
		575	#else
		576	void *ptr = g_slice_alloc (n);
561	#endif	577	#endif
562		578
563	void *alloc (int s) throw (std::bad_alloc)
564	{
565	void *p = g_slice_alloc (s);
566
567	if (!p)	579	if (!ptr)
568	throw std::bad_alloc ();	580	throw std::bad_alloc ();
569		581
570	return p;	582	return ptr;
		583	}
		584
		585	void salloc_ (int n, void src) throw (std::bad_alloc)
		586	{
		587	void *ptr = salloc_ (n);
		588
		589	if (src)
		590	memcpy (ptr, src, n);
		591	else
		592	memset (ptr, 0, n);
		593
		594	return ptr;
571	}	595	}
572		596
573	void assign (char dst, const char src, int maxlen)	597	void assign (char dst, const char src, int maxlen)
574	{	598	{
575	if (!src)	599	if (!src)
…		…
592	}	616	}
593	else	617	else
594	memcpy (dst, src, len + 1);	618	memcpy (dst, src, len + 1);
595	}	619	}
596		620
		621	tstamp now ()
		622	{
		623	struct timeval tv;
597		624
		625	gettimeofday (&tv, 0);
		626	return tstamp (tv.tv_sec) + tstamp (tv.tv_usec) * tstamp (1e-6);
		627	}
		628
		629	int
		630	similar_direction (int a, int b)
		631	{
		632	if (!a \|\| !b)
		633	return 0;
		634
		635	int diff = (b - a) & 7;
		636	return diff <= 1 \|\| diff >= 7;
		637	}
		638

Diff Legend

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

Comparing deliantra/server/common/utils.C (file contents): Revision 1.20 by root, Mon Dec 11 21:32:16 2006 UTC vs. Revision 1.46 by root, Mon Feb 5 01:47:22 2007 UTC

Diff Legend

Comparing deliantra/server/common/utils.C (file contents):
Revision 1.20 by root, Mon Dec 11 21:32:16 2006 UTC vs.
Revision 1.46 by root, Mon Feb 5 01:47:22 2007 UTC