[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.93 by root, Wed Nov 4 00:02:48 2009 UTC

1
2	/*	1	/*
3	* static char *rcsid_utils_c =	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
4	* "$Id: utils.C,v 1.9 2006/09/10 16:00:23 root Exp $";	3	*
		4	* Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
		5	*
		6	* Deliantra is free software: you can redistribute it and/or modify it under
		7	* the terms of the Affero GNU General Public License as published by the
		8	* Free Software Foundation, either version 3 of the License, or (at your
		9	* option) any later version.
		10	*
		11	* This program is distributed in the hope that it will be useful,
		12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		14	* GNU General Public License for more details.
		15	*
		16	* You should have received a copy of the Affero GNU General Public License
		17	* and the GNU General Public License along with this program. If not, see
		18	* <http://www.gnu.org/licenses/>.
		19	*
		20	* The authors can be reached via e-mail to <support@deliantra.net>
5	*/	21	*/
6		22
7	/*	23	/*
8	CrossFire, A Multiplayer game for X-windows
9
10	Copyright (C) 2002 Mark Wedel & Crossfire Development Team
11	Copyright (C) 1992 Frank Tore Johansen
12
13	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
15	the Free Software Foundation; either version 2 of the License, or
16	(at your option) any later version.
17
18	This program is distributed in the hope that it will be useful,
19	but WITHOUT ANY WARRANTY; without even the implied warranty of
20	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21	GNU General Public License for more details.
22
23	You should have received a copy of the GNU General Public License
24	along with this program; if not, write to the Free Software
25	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26
27	The authors can be reached via e-mail at crossfire-devel@real-time.com
28	*/
29
30	/*
31	* General convenience functions for crossfire.	24	* General convenience functions for deliantra.
32	*/	25	*/
33		26
		27	#include <cstdlib>
		28	#include <sys/types.h>
		29	#include <unistd.h>
		30	#include <sys/time.h>
		31	#include <time.h>
		32	#include <signal.h>
		33
34	#include <global.h>	34	#include <global.h>
35	#include <funcpoint.h>
36	#include <material.h>	35	#include <material.h>
		36	#include <object.h>
		37
		38	#include <sys/time.h>
		39	#include <sys/resource.h>
37		40
38	#include <glib.h>	41	#include <glib.h>
39		42
40	/*	43	refcnt_base::refcnt_t refcnt_dummy;
41	* The random functions here take luck into account when rolling random	44	ssize_t slice_alloc;
42	* dice or numbers. This function has less of an impact the larger the	45	rand_gen rndm, rmg_rndm;
43	* difference becomes in the random numbers. IE, the effect is lessened	46
44	* on a 1-1000 roll, vs a 1-6 roll. This can be used by crafty programmers,	47	void
45	* to specifically disable luck in certain rolls, simply by making the	48	tausworthe_random_generator::seed (uint32_t seed)
46	* numbers larger (ie, 1d1000 > 500 vs 1d6 > 3)	49	{
		50	state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U;
		51	state [1] = state [0] * 69069U; if (state [0] < 8U) state [0] += 8U;
		52	state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] += 16U;
		53	state [3] = state [2] * 69069U; if (state [0] < 128U) state [0] += 128U;
		54
		55	for (int i = 11; --i; )
		56	next ();
		57	}
		58
		59	uint32_t
		60	tausworthe_random_generator::next ()
		61	{
		62	state [0] = ((state [0] & 0xFFFFFFFEU) << 18U) ^ (((state [0] << 6U) ^ state [0]) >> 13U);
		63	state [1] = ((state [1] & 0xFFFFFFF8U) << 2U) ^ (((state [1] << 2U) ^ state [1]) >> 27U);
		64	state [2] = ((state [2] & 0xFFFFFFF0U) << 7U) ^ (((state [2] << 13U) ^ state [2]) >> 21U);
		65	state [3] = ((state [3] & 0xFFFFFF80U) << 13U) ^ (((state [3] << 3U) ^ state [3]) >> 12U);
		66
		67	return state [0] ^ state [1] ^ state [2] ^ state [3];
		68	}
		69
		70	template<class generator>
		71	uint32_t
		72	random_number_generator<generator>::get_range (uint32_t num)
		73	{
		74	return (this->next () * (uint64_t)num) >> 32U;
		75	}
		76
		77	// return a number within (min .. max)
		78	template<class generator>
		79	int
		80	random_number_generator<generator>::get_range (int r_min, int r_max)
		81	{
		82	return r_min + get_range (max (r_max - r_min + 1, 0));
		83	}
		84
		85	template struct random_number_generator<tausworthe_random_generator>;
		86	template struct random_number_generator<xorshift_random_generator>;
		87
		88	/******************************************************************************/
		89
		90	/* Checks a player-provided string which will become the msg property of
		91	* an object for dangerous input.
47	*/	92	*/
		93	bool
		94	msg_is_safe (const char *msg)
		95	{
		96	bool safe = true;
48		97
49	/*	98	/* Trying to cheat by getting data into the object */
50	* Roll a random number between min and max. Uses op to determine luck,	99	if (!strncmp (msg, "endmsg", sizeof ("endmsg") - 1)
51	* and if goodbad is non-zero, luck increases the roll, if zero, it decreases.	100	\|\| strstr (msg, "\nendmsg"))
52	* Generally, op should be the player/caster/hitter requesting the roll,	101	safe = false;
53	* not the recipient (ie, the poor slob getting hit). [garbled 20010916]	102
54	*/	103	/* Trying to make the object talk, and potentially access arbitrary code */
		104	if (object::msg_has_dialogue (msg))
		105	safe = false;
		106
		107	return safe;
		108	}
		109
		110	/////////////////////////////////////////////////////////////////////////////
		111
		112	void
		113	fork_abort (const char *msg)
		114	{
		115	if (!fork ())
		116	{
		117	signal (SIGINT , SIG_IGN);
		118	signal (SIGTERM, SIG_IGN);
		119	signal (SIGABRT, SIG_IGN);
		120
		121	signal (SIGSEGV, SIG_DFL);
		122	signal (SIGBUS , SIG_DFL);
		123	signal (SIGILL , SIG_DFL);
		124	signal (SIGTRAP, SIG_DFL);
		125
		126	// try to put corefiles into a subdirectory, if existing, to allow
		127	// an administrator to reduce the I/O load.
		128	chdir ("cores");
		129
		130	// try to detach us from as many external dependencies as possible
		131	// as coredumping can take time by closing all fd's.
		132	{
		133	struct rlimit lim;
		134
		135	if (getrlimit (RLIMIT_NOFILE, &lim))
		136	lim.rlim_cur = 1024;
		137
		138	for (int i = 0; i < lim.rlim_cur; ++i)
		139	close (i);
		140	}
		141
		142	{
		143	sigset_t empty;
		144	sigemptyset (&empty);
		145	sigprocmask (SIG_SETMASK, &empty, 0);
		146	}
		147
		148	// try to coredump with SIGTRAP
		149	kill (getpid (), SIGTRAP);
		150	abort ();
		151	}
		152
		153	LOG (llevError, "fork abort: %s\n", msg);
		154	}
		155
		156	void *salloc_ (int n) throw (std::bad_alloc)
		157	{
		158	void *ptr = g_slice_alloc (n);
		159
		160	if (!ptr)
		161	throw std::bad_alloc ();
		162
		163	slice_alloc += n;
		164	return ptr;
		165	}
		166
		167	void salloc_ (int n, void src) throw (std::bad_alloc)
		168	{
		169	void *ptr = salloc_ (n);
		170
		171	if (src)
		172	memcpy (ptr, src, n);
		173	else
		174	memset (ptr, 0, n);
		175
		176	return ptr;
		177	}
		178
		179	/******************************************************************************/
		180
		181	#if DEBUG_SALLOC
		182
		183	#define MAGIC 0xa1b2c35543deadLL
		184
		185	void *g_slice_alloc (unsigned long size)
		186	{
		187	unsigned long p = (unsigned long ) (g_slice_alloc)(size + sizeof (unsigned long));
		188	*p++ = size ^ MAGIC;
		189	//fprintf (stderr, "g_slice_alloc %ld %p\n", size, p);//D
		190	return (void *)p;
		191	}
		192
		193	void *g_slice_alloc0 (unsigned long size)
		194	{
		195	return memset (g_slice_alloc (size), 0, size);
		196	}
		197
		198	void g_slice_free1 (unsigned long size, void *ptr)
		199	{
		200	//fprintf (stderr, "g_slice_free %ld %p\n", size, ptr);//D
		201	if (expect_true (ptr))
		202	{
		203	unsigned long p = (unsigned long )ptr;
		204	unsigned long s = *--p ^ MAGIC;
		205
		206	if (size != (unsigned long)(*p ^ MAGIC))
		207	{
		208	LOG (logBacktrace \| llevError, "slice free size (%lx) doesn't match alloc size (%lx)\n", size, s);
		209	abort ();
		210	}
		211
		212	*p = MAGIC;
		213
		214	(g_slice_free1)(s + sizeof (unsigned long), p);
		215	}
		216	}
		217
		218	#endif
		219
		220	/******************************************************************************/
55		221
56	int	222	int
57	random_roll (int min, int max, const object *op, int goodbad)	223	assign (char dst, const char src, int maxsize)
58	{	224	{
59	int omin, diff, luck, base, ran;	225	if (!src)
		226	src = "";
60		227
61	omin = min;	228	int len = strlen (src);
62	diff = max - min + 1;
63	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
64		229
65	if (max < 1 \|\| diff < 1)	230	if (len >= maxsize)
66	{	231	{
67	LOG (llevError, "Calling random_roll with min=%d max=%d\n", min, max);	232	if (maxsize <= 4)
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);
112	#endif
113	return (min); /* avoids a float exception */
114	}
115
116	/* 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
118	* a little byteshifting. Do make sure the first one is only
119	* 32 bit, so we don't get skewed results
120	*/
121	ran = (RANDOM () & 0xffffffff) \| ((sint64) RANDOM () << 32);
122
123	if (op->type != PLAYER)
124	return ((ran % diff) + min);
125
126	luck = op->stats.luck;
127	if (RANDOM () % base < MIN (10, abs (luck)))
128	{
129	/* we have a winner */
130	((luck > 0) ? (luck = 1) : (luck = -1));
131	diff -= luck;
132	if (diff < 1)
133	return (omin); /check again /
134	((goodbad) ? (min += luck) : (diff));
135
136	return (MAX (omin, MIN (max, (ran % diff) + min)));
137	}
138	return ((ran % diff) + min);
139	}
140
141	/*
142	* Roll a number of dice (2d3, 4d6). Uses op to determine luck,
143	* If goodbad is non-zero, luck increases the roll, if zero, it decreases.
144	* Generally, op should be the player/caster/hitter requesting the roll,
145	* not the recipient (ie, the poor slob getting hit).
146	* The args are num D size (ie 4d6) [garbled 20010916]
147	*/
148
149	int
150	die_roll (int num, int size, const object *op, int goodbad)
151	{
152	int min, diff, luck, total, i, gotlucky, base, ran;
153
154	diff = size;
155	min = 1;
156	luck = total = gotlucky = 0;
157	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
158	if (size < 2 \|\| diff < 1)
159	{
160	LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size);
161	return (num); /* avoids a float exception */
162	}
163
164	if (op->type == PLAYER)
165	luck = op->stats.luck;
166
167	for (i = 0; i < num; i++)
168	{
169	if (RANDOM () % base < MIN (10, abs (luck)) && !gotlucky)
170	{	233	{
171	/* we have a winner */	234	memset (dst, '.', maxsize - 2);
172	gotlucky++;	235	dst [maxsize - 1] = 0;
173	((luck > 0) ? (luck = 1) : (luck = -1));
174	diff -= luck;
175	if (diff < 1)
176	return (num); /check again /
177	((goodbad) ? (min += luck) : (diff));
178	ran = RANDOM ();
179	total += MAX (1, MIN (size, (ran % diff) + min));
180	}	236	}
181	else	237	else
182	{	238	{
183	total += RANDOM () % size + 1;	239	memcpy (dst, src, maxsize - 4);
		240	memcpy (dst + maxsize - 4, "...", 4);
184	}	241	}
185	}
186	return (total);
187	}
188		242
189	/*	243	len = maxsize;
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 */
209
210	void
211	decay_objects (mapstruct *m)
212	{
213	int x, y, destroy;
214	object op, otmp;
215
216	if (m->unique)
217	return;
218
219	for (x = 0; x < MAP_WIDTH (m); x++)
220	for (y = 0; y < MAP_HEIGHT (m); y++)
221	for (op = get_map_ob (m, x, y); op; op = otmp)
222	{
223	destroy = 0;
224	otmp = op->above;
225	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
226	break;
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) \|\| QUERY_FLAG (op, FLAG_OVERLAY_FLOOR) \|\| QUERY_FLAG (op, FLAG_UNPAID) \|\| IS_LIVE (op))
231	continue;
232	/* otherwise, we decay and destroy */
233	if (IS_WEAPON (op))
234	{
235	op->stats.dam--;
236	if (op->stats.dam < 0)
237	destroy = 1;
238	}
239	else if (IS_ARMOR (op))
240	{
241	op->stats.ac--;
242	if (op->stats.ac < 0)
243	destroy = 1;
244	}
245	else if (op->type == FOOD)
246	{
247	op->stats.food -= rndm (5, 20);
248	if (op->stats.food < 0)
249	destroy = 1;
250	}
251	else
252	{
253	if (op->material & M_PAPER \|\| op->material & M_LEATHER \|\|
254	op->material & M_WOOD \|\| op->material & M_ORGANIC \|\| op->material & M_CLOTH \|\| op->material & M_LIQUID)
255	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	}
267	/* adjust overall chance below */
268	if (destroy && rndm (0, 1))
269	{
270	remove_ob (op);
271	free_object (op);
272	}
273	}
274	}
275
276	/* convert materialname to materialtype_t */
277
278	materialtype_t *
279	name_to_material (const char *name)
280	{
281	materialtype_t mt, nmt;
282
283	mt = NULL;
284	for (nmt = materialt; nmt != NULL && nmt->next != NULL; nmt = nmt->next)
285	{
286	if (strcmp (name, nmt->name) == 0)
287	{
288	mt = nmt;
289	break;
290	}
291	}
292	return mt;
293	}
294
295	/* when doing transmutation of objects, we have to recheck the resistances,
296	* as some that did not apply previously, may apply now.
297	*/
298
299	void
300	transmute_materialname (object op, const object change)
301	{
302	materialtype_t *mt;
303	int j;
304
305	if (op->materialname == NULL)
306	return;
307
308	if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
309	return;
310
311	if (!IS_ARMOR (op))
312	return;
313
314	mt = name_to_material (op->materialname);
315	if (!mt)
316	{
317	LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->name, &op->name, &op->materialname);
318	return;
319	}
320
321	for (j = 0; j < NROFATTACKS; j++)
322	if (op->resist[j] == 0 && change->resist[j] != 0)
323	{
324	op->resist[j] += mt->mod[j];
325	if (op->resist[j] > 100)
326	op->resist[j] = 100;
327	if (op->resist[j] < -100)
328	op->resist[j] = -100;
329	}
330	}
331
332	/* set the materialname and type for an item */
333	void
334	set_materialname (object op, int difficulty, materialtype_t nmt)
335	{
336	materialtype_t mt, lmt;
337
338	#ifdef NEW_MATERIAL_CODE
339	int j;
340	#endif
341
342	if (op->materialname != NULL)
343	return;
344
345
346
347	if (nmt == NULL)
348	{
349	lmt = NULL;
350	#ifndef NEW_MATERIAL_CODE
351	for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next)
352	{
353	if (op->material & mt->material)
354	{
355	lmt = mt;
356	break;
357	}
358	}
359
360	#else
361	for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next)
362	{
363	if (op->material & mt->material && rndm (1, 100) <= mt->chance &&
364	difficulty >= mt->difficulty && (op->magic >= mt->magic \|\| mt->magic == 0))
365	{
366	lmt = mt;
367	if (!(IS_WEAPON (op) \|\| IS_ARMOR (op)))
368	break;
369	}
370	}
371	#endif
372	}	244	}
373	else	245	else
374	{	246	memcpy (dst, src, ++len);
375	lmt = nmt;
376	}
377		247
378	if (lmt != NULL)	248	return len;
379	{	249	}
380	#ifndef NEW_MATERIAL_CODE	250
381	op->materialname = lmt->name;	251	char *
		252	vformat (const char *format, va_list ap)
		253	{
		254	static dynbuf_text buf; buf.clear ();
		255	buf.vprintf (format, ap);
		256	return buf;
		257	}
		258
		259	char *
		260	format (const char *format, ...)
		261	{
		262	va_list ap;
		263	va_start (ap, format);
		264	char *buf = vformat (format, ap);
		265	va_end (ap);
		266
		267	return buf;
		268	}
		269
		270	tstamp now ()
		271	{
		272	struct timeval tv;
		273
		274	gettimeofday (&tv, 0);
		275	return tstamp (tv.tv_sec) + tstamp (tv.tv_usec) * tstamp (1e-6);
		276	}
		277
		278	int
		279	similar_direction (int a, int b)
		280	{
		281	if (!a \|\| !b)
382	return;	282	return 0;
383	#else
384		283
385	if (op->stats.dam && IS_WEAPON (op))	284	int diff = (b - a) & 7;
386	{	285	return diff <= 1 \|\| diff >= 7;
387	op->stats.dam += lmt->damage;	286	}
388	if (op->stats.dam < 1)	287
389	op->stats.dam = 1;	288	/* crc32 0xdebb20e3 table and supplementary functions. */
390	}	289	extern const uint32_t crc_32_tab[256] =
391	if (op->stats.sp && op->type == BOW)	290	{
392	op->stats.sp += lmt->sp;	291	0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
393	if (op->stats.wc && IS_WEAPON (op))	292	0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
394	op->stats.wc += lmt->wc;	293	0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
395	if (IS_ARMOR (op))	294	0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
396	{	295	0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
397	if (op->stats.ac)	296	0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
398	op->stats.ac += lmt->ac;	297	0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
399	for (j = 0; j < NROFATTACKS; j++)	298	0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
400	if (op->resist[j] != 0)	299	0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
401	{	300	0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
402	op->resist[j] += lmt->mod[j];	301	0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
403	if (op->resist[j] > 100)	302	0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
404	op->resist[j] = 100;	303	0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
405	if (op->resist[j] < -100)	304	0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
406	op->resist[j] = -100;	305	0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
407	}	306	0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
408	}	307	0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
409	op->materialname = add_string (lmt->name);	308	0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
410	/* dont make it unstackable if it doesn't need to be */	309	0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
411	if (IS_WEAPON (op) \|\| IS_ARMOR (op))	310	0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
412	{	311	0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
413	op->weight = (op->weight * lmt->weight) / 100;	312	0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
414	op->value = (op->value * lmt->value) / 100;	313	0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
415	}	314	0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
		315	0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
		316	0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
		317	0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
		318	0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
		319	0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
		320	0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
		321	0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
		322	0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
		323	0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
		324	0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
		325	0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
		326	0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
		327	0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
		328	0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
		329	0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
		330	0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
		331	0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
		332	0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
		333	0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
		334	0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
		335	0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
		336	0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
		337	0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
		338	0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
		339	0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
		340	0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
		341	0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
		342	0x2d02ef8dL
		343	};
		344
		345	void thread::start (void (start_routine)(void ), void arg)
		346	{
		347	pthread_attr_t attr;
		348
		349	pthread_attr_init (&attr);
		350	pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
		351	pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN < sizeof (long) * 4096
		352	? sizeof (long) * 4096 : PTHREAD_STACK_MIN);
		353	#ifdef PTHREAD_SCOPE_PROCESS
		354	pthread_attr_setscope (&attr, PTHREAD_SCOPE_PROCESS);
416	#endif	355	#endif
417	}
418	}
419		356
420	/*	357	sigset_t fullsigset, oldsigset;
421	* Strip out the media tags from a String.	358	sigfillset (&fullsigset);
422	* Warning the input string will contain the result string
423	*/
424	void
425	strip_media_tag (char *message)
426	{
427	int in_tag = 0;
428	char *dest;
429	char *src;
430		359
431	src = dest = message;	360	pthread_sigmask (SIG_SETMASK, &fullsigset, &oldsigset);
432	while (*src != '\0')
433	{
434	if (*src == '[')
435	{
436	in_tag = 1;
437	}
438	else if (in_tag && (*src == ']'))
439	in_tag = 0;
440	else if (!in_tag)
441	{
442	dest = src;
443	dest++;
444	}
445	src++;
446	}
447	*dest = '\0';
448	}
449		361
450	const char *	362	if (pthread_create (&id, &attr, start_routine, arg))
451	strrstr (const char haystack, const char needle)	363	cleanup ("unable to create a new thread");
452	{
453	const char *lastneedle;
454		364
455	lastneedle = NULL;	365	pthread_sigmask (SIG_SETMASK, &oldsigset, 0);
456	while ((haystack = strstr (haystack, needle)) != NULL)
457	{
458	lastneedle = haystack;
459	haystack++;
460	}
461	return lastneedle;
462
463	}	366	}
464		367
465	#define EOL_SIZE (sizeof("\n")-1)
466	void
467	strip_endline (char *buf)
468	{
469	if (strlen (buf) < sizeof ("\n"))
470	{
471	return;
472	}
473	if (!strcmp (buf + strlen (buf) - EOL_SIZE, "\n"))
474	buf[strlen (buf) - EOL_SIZE] = '\0';
475	}
476
477	/**
478	* Replace in string src all occurrences of key by replacement. The resulting
479	* string is put into result; at most resultsize characters (including the
480	* terminating null character) will be written to result.
481	*/
482	void
483	replace (const char src, const char key, const char replacement, char result, size_t resultsize)
484	{
485	size_t resultlen;
486	size_t keylen;
487
488	/* special case to prevent infinite loop if key==replacement=="" */
489	if (strcmp (key, replacement) == 0)
490	{
491	snprintf (result, resultsize, "%s", src);
492	return;
493	}
494
495	keylen = strlen (key);
496
497	resultlen = 0;
498	while (*src != '\0' && resultlen + 1 < resultsize)
499	{
500	if (strncmp (src, key, keylen) == 0)
501	{
502	snprintf (result + resultlen, resultsize - resultlen, "%s", replacement);
503	resultlen += strlen (result + resultlen);
504	src += keylen;
505	}
506	else
507	{
508	result[resultlen++] = *src++;
509	}
510	}
511	result[resultlen] = '\0';
512	}
513
514	/**
515	* Taking a string as an argument, mutate it into a string that looks like a list.
516	* a 'list' for the purposes here, is a string of items, seperated by commas, except
517	* for the last entry, which has an 'and' before it, and a full stop (period) after it.
518	* This function will also strip all trailing non alphanumeric characters.
519	* It does not insert an oxford comma.
520	*/
521
522	void
523	make_list_like (char *input)
524	{
525	char *p, tmp[MAX_BUF];
526	int i;
527
528	if (!input \|\| strlen (input) > MAX_BUF - 5)
529	return;
530	/* bad stuff would happen if we continued here, the -5 is to make space for ' and ' */
531
532	strncpy (tmp, input, MAX_BUF - 5);
533	/trim all trailing commas, spaces etc. /
534	for (i = strlen (tmp); !isalnum (tmp[i]) && i >= 0; i--)
535	tmp[i] = '\0';
536	strcat (tmp, ".");
537
538	p = strrchr (tmp, ',');
539	if (p)
540	{
541	*p = '\0';
542	strcpy (input, tmp);
543	p++;
544	strcat (input, " and");
545	strcat (input, p);
546	}
547	else
548	strcpy (input, tmp);
549	return;
550	}
551
552	void *
553	zero_initialised::operator
554	new (size_t s)
555	{
556	//return calloc (1, s);
557	return g_slice_alloc0 (s);
558	}
559
560	void *
561	zero_initialised::operator
562	new[] (size_t s)
563	{
564	//return calloc (1, s);
565	return g_slice_alloc0 (s);
566	}
567
568	void
569	zero_initialised::operator
570	delete (void *p, size_t s)
571	{
572	//free (p); return;
573	g_slice_free1 (s, p);
574	}
575
576	void
577	zero_initialised::operator
578	delete[] (void *p, size_t s)
579	{
580	//free (p); return;
581	g_slice_free1 (s, p);
582	}

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.93 by root, Wed Nov 4 00:02:48 2009 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.93 by root, Wed Nov 4 00:02:48 2009 UTC