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

Comparing deliantra/server/common/utils.C (file contents):
Revision 1.57 by root, Mon May 28 21:21:40 2007 UTC vs.
Revision 1.78 by root, Fri May 16 17:09:38 2008 UTC

…		…
1	/*	1	/*
2	* This file is part of Crossfire TRT, the Multiplayer Online Role Playing Game.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team	4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*	7	*
8	* Crossfire TRT is free software; you can redistribute it and/or modify it	8	* Deliantra is free software: you can redistribute it and/or modify
9	* under the terms of the GNU General Public License as published by the Free	9	* it under the terms of the GNU General Public License as published by
10	* Software Foundation; either version 2 of the License, or (at your option)	10	* the Free Software Foundation, either version 3 of the License, or
11	* 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, but	13	* This program is distributed in the hope that it will be useful,
14	* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* 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 along	18	* You should have received a copy of the GNU General Public License
19	* with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	* Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21	*	20	*
22	* The authors can be reached via e-mail to <crossfire@schmorp.de>	21	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/	22	*/
24		23
25	/*	24	/*
26	* General convenience functions for crossfire.	25	* General convenience functions for crossfire.
27	*/	26	*/
32	#include <sys/time.h>	31	#include <sys/time.h>
33	#include <time.h>	32	#include <time.h>
34	#include <signal.h>	33	#include <signal.h>
35		34
36	#include <global.h>	35	#include <global.h>
37	#include <funcpoint.h>
38	#include <material.h>	36	#include <material.h>
39		37
40	#include <glib.h>	38	#include <glib.h>
41		39
42	rand_gen rndm;	40	refcnt_base::refcnt_t refcnt_dummy;
		41	ssize_t slice_alloc;
		42	rand_gen rndm, rmg_rndm;
43		43
44	void	44	void
45	tausworthe_random_generator::seed (uint32_t seed)	45	tausworthe_random_generator::seed (uint32_t seed)
46	{	46	{
47	state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U;	47	state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U;
48	state [1] = state [0] * 69069U; if (state [0] < 8U) state [0] += 8U;	48	state [1] = state [0] * 69069U; if (state [0] < 8U) state [0] += 8U;
49	state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] += 16U;	49	state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] += 16U;
50	state [3] = state [2] * 69069U; if (state [0] < 128) state [0] += 128U;	50	state [3] = state [2] * 69069U; if (state [0] < 128U) state [0] += 128U;
51		51
52	for (int i = 11; --i; )	52	for (int i = 11; --i; )
53	operator ()();	53	operator ()();
54	}	54	}
55		55
…		…
93	* not the recipient (ie, the poor slob getting hit). [garbled 20010916]	93	* not the recipient (ie, the poor slob getting hit). [garbled 20010916]
94	*/	94	*/
95	int	95	int
96	random_roll (int r_min, int r_max, const object *op, int goodbad)	96	random_roll (int r_min, int r_max, const object *op, int goodbad)
97	{	97	{
		98	r_max = max (r_min, r_max);
		99
98	int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */	100	int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */
99
100	if (r_max < r_min)
101	{
102	LOG (llevError \| logBacktrace, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
103	return r_min;
104	}
105		101
106	if (op->type == PLAYER)	102	if (op->type == PLAYER)
107	{	103	{
108	int luck = op->stats.luck;	104	int luck = op->stats.luck;
109		105
…		…
119	/*	115	/*
120	* This is a 64 bit version of random_roll above. This is needed	116	* This is a 64 bit version of random_roll above. This is needed
121	* for exp loss calculations for players changing religions.	117	* for exp loss calculations for players changing religions.
122	*/	118	*/
123	sint64	119	sint64
124	random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)	120	random_roll64 (sint64 r_min, sint64 r_max, const object *op, int goodbad)
125	{	121	{
126	sint64 omin = min;	122	sint64 omin = r_min;
127	sint64 diff = max - min + 1;	123	sint64 range = max (0, r_max - r_min + 1);
128	int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */	124	int base = range > 2 ? 20 : 50; /* d2 and d3 are corner cases */
129
130	if (diff < 0)
131	{
132	LOG (llevError \| logBacktrace, "Calling random_roll64 with min=%" PRId64 " max=%" PRId64 "\n", min, max);
133	return (min); /* avoids a float exception */
134	}
135		125
136	/*	126	/*
137	* Make a call to get two 32 bit unsigned random numbers, and just to	127	* Make a call to get two 32 bit unsigned random numbers, and just to
138	* a little bitshifting.	128	* a little bitshifting.
139	*/	129	*/
140	sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);	130	sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);
141		131
142	if (op->type != PLAYER)	132	if (op->type != PLAYER)
143	return ((ran % diff) + min);	133	return ((ran % range) + r_min);
144		134
145	int luck = op->stats.luck;	135	int luck = op->stats.luck;
146		136
147	if (rndm (base) < MIN (10, abs (luck)))	137	if (rndm (base) < min (10, abs (luck)))
148	{	138	{
149	/* we have a winner */	139	/* we have a winner */
150	((luck > 0) ? (luck = 1) : (luck = -1));	140	((luck > 0) ? (luck = 1) : (luck = -1));
151	diff -= luck;	141	range -= luck;
152	if (diff < 1)	142	if (range < 1)
153	return (omin); /check again /	143	return (omin); /check again /
154		144
155	((goodbad) ? (min += luck) : (diff));	145	((goodbad) ? (r_min += luck) : (range));
156		146
157	return (MAX (omin, MIN (max, (ran % diff) + min)));	147	return (max (omin, min (r_max, (ran % range) + r_min)));
158	}	148	}
159		149
160	return ran % diff + min;	150	return ran % range + r_min;
161	}	151	}
162		152
163	/*	153	/*
164	* Roll a number of dice (2d3, 4d6). Uses op to determine luck,	154	* Roll a number of dice (2d3, 4d6). Uses op to determine luck,
165	* If goodbad is non-zero, luck increases the roll, if zero, it decreases.	155	* If goodbad is non-zero, luck increases the roll, if zero, it decreases.
…		…
204	}	194	}
205		195
206	return total;	196	return total;
207	}	197	}
208		198
209	/* decay and destroy perishable items in a map */
210	void
211	maptile::decay_objects ()
212	{
213	if (!spaces)
214	return;
215
216	for (mapspace *ms = spaces + size (); ms-- > spaces; )
217	for (object above, op = ms->bot; op; op = above)
218	{
219	above = op->above;
220
221	bool destroy = 0;
222
223	// do not decay anything above unique floor tiles (yet :)
224	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
225	break;
226
227	if (QUERY_FLAG (op, FLAG_IS_FLOOR)
228	\|\| QUERY_FLAG (op, FLAG_OBJ_ORIGINAL)
229	\|\| QUERY_FLAG (op, FLAG_OBJ_SAVE_ON_OVL)
230	\|\| QUERY_FLAG (op, FLAG_UNIQUE)
231	\|\| QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)
232	\|\| QUERY_FLAG (op, FLAG_UNPAID)
233	\|\| op->is_alive ())
234	; // do not decay
235	else if (op->is_weapon ())
236	{
237	op->stats.dam--;
238	if (op->stats.dam < 0)
239	destroy = 1;
240	}
241	else if (op->is_armor ())
242	{
243	op->stats.ac--;
244	if (op->stats.ac < 0)
245	destroy = 1;
246	}
247	else if (op->type == FOOD)
248	{
249	op->stats.food -= rndm (5, 20);
250	if (op->stats.food < 0)
251	destroy = 1;
252	}
253	else
254	{
255	int mat = op->materials;
256
257	if (mat & M_PAPER
258	\|\| mat & M_LEATHER
259	\|\| mat & M_WOOD
260	\|\| mat & M_ORGANIC
261	\|\| mat & M_CLOTH
262	\|\| mat & M_LIQUID
263	\|\| (mat & M_IRON && rndm (1, 5) == 1)
264	\|\| (mat & M_GLASS && rndm (1, 2) == 1)
265	\|\| ((mat & M_STONE \|\| mat & M_ADAMANT) && rndm (1, 10) == 1)
266	\|\| ((mat & M_SOFT_METAL \|\| mat & M_BONE) && rndm (1, 3) == 1)
267	\|\| (mat & M_ICE && temp > 32))
268	destroy = 1;
269	}
270
271	/* adjust overall chance below */
272	if (destroy && rndm (0, 1))
273	op->destroy ();
274	}
275	}
276
277	/* convert materialname to materialtype_t */	199	/* convert materialname to materialtype_t */
278		200
279	materialtype_t *	201	materialtype_t *
280	name_to_material (const shstr &name)	202	name_to_material (const shstr &name)
281	{	203	{
282	for (materialtype_t *mt = materialt; mt && mt->next; mt = mt->next)	204	for (materialtype_t *mt = materialt; mt && mt->next; mt = mt->next)
283	if (name == mt->name)	205	if (name == mt->name)
284	return mt;	206	return mt;
285		207
286	return materialt;	208	return 0;
287	}	209	}
288		210
289	/* when doing transmutation of objects, we have to recheck the resistances,	211	/* when doing transmutation of objects, we have to recheck the resistances,
290	* as some that did not apply previously, may apply now.	212	* as some that did not apply previously, may apply now.
291	*/	213	*/
292
293	void	214	void
294	transmute_materialname (object op, const object change)	215	transmute_materialname (object op, const object change)
295	{	216	{
296	materialtype_t *mt;	217	materialtype_t *mt;
297	int j;	218	int j;
…		…
306	return;	227	return;
307		228
308	mt = name_to_material (op->materialname);	229	mt = name_to_material (op->materialname);
309	if (!mt)	230	if (!mt)
310	{	231	{
311	LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->name, &op->name, &op->materialname);	232	LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->archname, &op->name, &op->materialname);
312	return;	233	return;
313	}	234	}
314		235
315	for (j = 0; j < NROFATTACKS; j++)	236	for (j = 0; j < NROFATTACKS; j++)
316	if (op->resist[j] == 0 && change->resist[j] != 0)	237	if (op->resist[j] == 0 && change->resist[j] != 0)
…		…
327	void	248	void
328	set_materialname (object op, int difficulty, materialtype_t nmt)	249	set_materialname (object op, int difficulty, materialtype_t nmt)
329	{	250	{
330	materialtype_t mt, lmt;	251	materialtype_t mt, lmt;
331		252
332	#ifdef NEW_MATERIAL_CODE
333	int j;
334	#endif
335
336	if (op->materialname != NULL)	253	if (op->materialname != NULL)
337	return;	254	return;
338		255
339
340
341	if (nmt == NULL)	256	if (nmt == NULL)
342	{	257	{
343	lmt = NULL;	258	lmt = NULL;
344	#ifndef NEW_MATERIAL_CODE	259
345	for (mt = materialt; mt && mt->next; mt = mt->next)	260	for (mt = materialt; mt && mt->next; mt = mt->next)
346	{	261	if (op->materials & mt->material && rndm (1, 100) <= mt->chance &&
347	if (op->materials & mt->material)	262	difficulty >= mt->difficulty && (op->magic >= mt->magic \|\| mt->magic == 0))
348	{	263	{
349	lmt = mt;	264	lmt = mt;
		265	if (!(op->is_weapon () \|\| op->is_armor ()))
350	break;	266	break;
351	}	267	}
352	}
353
354	#else
355	for (mt = materialt; mt && mt->next; mt = mt->next)
356	{
357	if (op->materials & mt->material && rndm (1, 100) <= mt->chance &&
358	difficulty >= mt->difficulty && (op->magic >= mt->magic \|\| mt->magic == 0))
359	{
360	lmt = mt;
361	if (!(op->is_weapon () \|\| op->is_armor ()))
362	break;
363	}
364	}
365	#endif
366	}	268	}
367	else	269	else
368	{
369	lmt = nmt;	270	lmt = nmt;
370	}
371		271
372	if (lmt != NULL)	272	if (lmt != NULL)
373	{	273	{
374	#ifndef NEW_MATERIAL_CODE
375	op->materialname = lmt->name;
376	return;
377	#else
378
379	if (op->stats.dam && op->is_weapon ())	274	if (op->stats.dam && op->is_weapon ())
380	{	275	{
381	op->stats.dam += lmt->damage;	276	op->stats.dam += lmt->damage;
382	if (op->stats.dam < 1)	277	if (op->stats.dam < 1)
383	op->stats.dam = 1;	278	op->stats.dam = 1;
…		…
389	op->stats.wc += lmt->wc;	284	op->stats.wc += lmt->wc;
390	if (op->is_armor ())	285	if (op->is_armor ())
391	{	286	{
392	if (op->stats.ac)	287	if (op->stats.ac)
393	op->stats.ac += lmt->ac;	288	op->stats.ac += lmt->ac;
		289
394	for (j = 0; j < NROFATTACKS; j++)	290	for (int j = 0; j < NROFATTACKS; j++)
395	if (op->resist[j] != 0)	291	if (op->resist[j] != 0)
396	{	292	{
397	op->resist[j] += lmt->mod[j];	293	op->resist[j] += lmt->mod[j];
398	if (op->resist[j] > 100)	294	if (op->resist[j] > 100)
399	op->resist[j] = 100;	295	op->resist[j] = 100;
400	if (op->resist[j] < -100)	296	if (op->resist[j] < -100)
401	op->resist[j] = -100;	297	op->resist[j] = -100;
402	}	298	}
403	}	299	}
		300
404	op->materialname = lmt->name;	301	op->materialname = lmt->name;
405	/* dont make it unstackable if it doesn't need to be */	302	/* dont make it unstackable if it doesn't need to be */
406	if (op->is_weapon () \|\| op->is_armor ())	303	if (op->is_weapon () \|\| op->is_armor ())
407	{	304	{
408	op->weight = (op->weight * lmt->weight) / 100;	305	op->weight = (op->weight * lmt->weight) / 100;
409	op->value = (op->value * lmt->value) / 100;	306	op->value = (op->value * lmt->value) / 100;
410	}	307	}
411	#endif
412	}	308	}
413	}	309	}
414		310
415	/*	311	/*
416	* Strip out the media tags from a String.	312	* Strip out the media tags from a String.
…		…
511	* a 'list' for the purposes here, is a string of items, seperated by commas, except	407	* a 'list' for the purposes here, is a string of items, seperated by commas, except
512	* for the last entry, which has an 'and' before it, and a full stop (period) after it.	408	* for the last entry, which has an 'and' before it, and a full stop (period) after it.
513	* This function will also strip all trailing non alphanumeric characters.	409	* This function will also strip all trailing non alphanumeric characters.
514	* It does not insert an oxford comma.	410	* It does not insert an oxford comma.
515	*/	411	*/
516
517	void	412	void
518	make_list_like (char *input)	413	make_list_like (char *input)
519	{	414	{
520	char *p, tmp[MAX_BUF];	415	char *p, tmp[MAX_BUF];
521	int i;	416	int i;
…		…
563	LOG (llevError, "fork abort: %s\n", msg);	458	LOG (llevError, "fork abort: %s\n", msg);
564	}	459	}
565		460
566	void *salloc_ (int n) throw (std::bad_alloc)	461	void *salloc_ (int n) throw (std::bad_alloc)
567	{	462	{
568	#ifdef PREFER_MALLOC
569	void *ptr = malloc (n);
570	#else
571	void *ptr = g_slice_alloc (n);	463	void *ptr = g_slice_alloc (n);
572	#endif
573		464
574	if (!ptr)	465	if (!ptr)
575	throw std::bad_alloc ();	466	throw std::bad_alloc ();
576		467
		468	slice_alloc += n;
577	return ptr;	469	return ptr;
578	}	470	}
579		471
580	void salloc_ (int n, void src) throw (std::bad_alloc)	472	void salloc_ (int n, void src) throw (std::bad_alloc)
581	{	473	{
…		…
587	memset (ptr, 0, n);	479	memset (ptr, 0, n);
588		480
589	return ptr;	481	return ptr;
590	}	482	}
591		483
		484	/******************************************************************************/
		485
		486	#if DEBUG_SALLOC
		487
		488	#define MAGIC 0xa1b2c35543deadLL
		489
		490	void *g_slice_alloc (unsigned long size)
		491	{
		492	unsigned long p = (unsigned long ) (g_slice_alloc)(size + sizeof (unsigned long));
		493	*p++ = size ^ MAGIC;
		494	//fprintf (stderr, "g_slice_alloc %ld %p\n", size, p);//D
		495	return (void *)p;
		496	}
		497
		498	void *g_slice_alloc0 (unsigned long size)
		499	{
		500	return memset (g_slice_alloc (size), 0, size);
		501	}
		502
		503	void g_slice_free1 (unsigned long size, void *ptr)
		504	{
		505	//fprintf (stderr, "g_slice_free %ld %p\n", size, ptr);//D
		506	if (expect_true (ptr))
		507	{
		508	unsigned long p = (unsigned long )ptr;
		509	unsigned long s = *--p ^ MAGIC;
		510
		511	if (size != (unsigned long)(*p ^ MAGIC))
		512	{
		513	LOG (logBacktrace \| llevError, "slice free size (%lx) doesn't match alloc size (%lx)\n", size, s);
		514	abort ();
		515	}
		516
		517	*p = MAGIC;
		518
		519	(g_slice_free1)(s + sizeof (unsigned long), p);
		520	}
		521	}
		522
		523	#endif
		524
		525	/******************************************************************************/
		526
592	void assign (char dst, const char src, int maxlen)	527	void assign (char dst, const char src, int maxlen)
593	{	528	{
594	if (!src)	529	if (!src)
595	src = "";	530	src = "";
596		531
…		…
611	}	546	}
612	else	547	else
613	memcpy (dst, src, len + 1);	548	memcpy (dst, src, len + 1);
614	}	549	}
615		550
616	const std::string	551	const char *
617	format (const char *format, ...)	552	format (const char *format, ...)
618	{	553	{
619	int len;	554	static dynbuf_text buf;
620		555
621	{	556	buf.clear ();
622	char buf[128];
623		557
624	va_list ap;	558	va_list ap;
625	va_start (ap, format);	559	va_start (ap, format);
626	len = vsnprintf (buf, sizeof (buf), format, ap);	560	buf.vprintf (format, ap);
627	va_end (ap);	561	va_end (ap);
628		562
629	assert (len >= 0); // shield againstz broken vsnprintf's
630
631	// was our static buffer short enough?
632	if (len < sizeof (buf))
633	return std::string (buf, len);
634	}
635
636	{
637	// longer, try harder
638	char *buf = salloc<char> (len + 1);
639
640	va_list ap;
641	va_start (ap, format);
642	vsnprintf (buf, len + 1, format, ap);
643	va_end (ap);
644
645	const std::string s (buf, len);
646	sfree<char> (buf, len + 1);
647
648	return buf;	563	return buf;
649	}
650	}	564	}
651		565
652	tstamp now ()	566	tstamp now ()
653	{	567	{
654	struct timeval tv;	568	struct timeval tv;
…		…
722	0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,	636	0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
723	0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,	637	0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
724	0x2d02ef8dL	638	0x2d02ef8dL
725	};	639	};
726		640
		641	void thread::start (void (start_routine)(void ), void arg)
		642	{
		643	pthread_attr_t attr;
727		644
		645	pthread_attr_init (&attr);
		646	pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
		647	pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN < sizeof (long) * 4096
		648	? sizeof (long) * 4096 : PTHREAD_STACK_MIN);
		649	#ifdef PTHREAD_SCOPE_PROCESS
		650	pthread_attr_setscope (&attr, PTHREAD_SCOPE_PROCESS);
		651	#endif
		652
		653	sigset_t fullsigset, oldsigset;
		654	sigfillset (&fullsigset);
		655
		656	pthread_sigmask (SIG_SETMASK, &fullsigset, &oldsigset);
		657
		658	if (pthread_create (&id, &attr, start_routine, arg))
		659	cleanup ("unable to create a new thread");
		660
		661	pthread_sigmask (SIG_SETMASK, &oldsigset, 0);
		662	}
		663

Diff Legend

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

Comparing deliantra/server/common/utils.C (file contents): Revision 1.57 by root, Mon May 28 21:21:40 2007 UTC vs. Revision 1.78 by root, Fri May 16 17:09:38 2008 UTC

Diff Legend

Comparing deliantra/server/common/utils.C (file contents):
Revision 1.57 by root, Mon May 28 21:21:40 2007 UTC vs.
Revision 1.78 by root, Fri May 16 17:09:38 2008 UTC