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

Comparing deliantra/server/common/utils.C (file contents):
Revision 1.5 by pippijn, Thu Sep 7 09:37:12 2006 UTC vs.
Revision 1.41 by root, Thu Jan 18 22:19:59 2007 UTC

…		…
1	/*	1	/*
2	* static char *rcsid_utils_c =
3	* "$Id: utils.C,v 1.5 2006/09/07 09:37:12 pippijn Exp $";
4	*/
5
6	/*
7	CrossFire, A Multiplayer game for X-windows	2	* CrossFire, A Multiplayer game for X-windows
8		3	*
		4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
9	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (C) 1992 Frank Tore Johansen
11		7	*
12	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
13	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
14	the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation; either version 2 of the License, or
15	(at your option) any later version.	11	* (at your option) any later version.
16		12	*
17	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,
18	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
19	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20	GNU General Public License for more details.	16	* GNU General Public License for more details.
21		17	*
22	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
23	along with this program; if not, write to the Free Software	19	* along with this program; if not, write to the Free Software
24	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25		21	*
26	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>
27	*/	23	*/
28		24
29	/*	25	/*
30	* General convenience functions for crossfire.	26	* General convenience functions for crossfire.
31	*/	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>
32		35
33	#include <global.h>	36	#include <global.h>
34	#include <funcpoint.h>	37	#include <funcpoint.h>
35	#include <material.h>	38	#include <material.h>
36		39
37	#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	}
38		65
39	/*	66	/*
40	* The random functions here take luck into account when rolling random	67	* The random functions here take luck into account when rolling random
41	* 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
42	* difference becomes in the random numbers. IE, the effect is lessened	69	* difference becomes in the random numbers. IE, the effect is lessened
49	* 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,
50	* 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.
51	* Generally, op should be the player/caster/hitter requesting the roll,	78	* Generally, op should be the player/caster/hitter requesting the roll,
52	* not the recipient (ie, the poor slob getting hit). [garbled 20010916]	79	* not the recipient (ie, the poor slob getting hit). [garbled 20010916]
53	*/	80	*/
54		81	int
55	int 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)
56	int omin, diff, luck, base, ran;	83	{
		84	int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */
57		85
58	omin = min;	86	if (r_max < 1 \|\| r_max < r_min)
59	diff = max - min + 1;	87	{
60	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
61
62	if (max < 1 \|\| diff < 1) {
63	LOG(llevError, "Calling random_roll with min=%d max=%d\n", min, max);	88	LOG (llevError, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
64	return(min); /* avoids a float exception */	89	return r_min;
65	}	90	}
66		91
67	ran = RANDOM();
68
69	if (op->type != PLAYER)	92	if (op->type == PLAYER)
70	return((ran%diff)+min);	93	{
71
72	luck = op->stats.luck;	94	int luck = op->stats.luck;
73	if (RANDOM()%base < MIN(10, abs(luck))) {
74	/* we have a winner */
75	((luck > 0) ? (luck = 1) : (luck = -1));
76	diff -= luck;
77	if (diff < 1)
78	return(omin); /check again/
79	((goodbad) ? (min += luck) : (diff));
80		95
81	return(MAX(omin, MIN(max, (ran%diff)+min)));	96	if (rndm (base) < min (10, abs (luck)))
		97	{
		98	//TODO: take luck into account
		99	}
82	}	100	}
83	return((ran%diff)+min);	101
		102	return rndm (r_min, r_max);
84	}	103	}
85		104
86	/*	105	/*
87	* This is a 64 bit version of random_roll above. This is needed	106	* This is a 64 bit version of random_roll above. This is needed
88	* for exp loss calculations for players changing religions.	107	* for exp loss calculations for players changing religions.
89	*/	108	*/
90		109
		110	sint64
91	sint64 random_roll64(sint64 min, sint64 max, const object *op, int goodbad) {	111	random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
		112	{
92	sint64 omin, diff, luck, ran;	113	sint64 omin, diff, luck, ran;
93	int base;	114	int base;
94		115
95	omin = min;	116	omin = min;
96	diff = max - min + 1;	117	diff = max - min + 1;
97	((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 */
98		119
99	if (max < 1 \|\| diff < 1) {	120	if (max < 1 \|\| diff < 1)
100	#ifndef WIN32	121	{
101	LOG(llevError, "Calling random_roll with min=%lld max=%lld\n", min, max);
102	#else
103	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);
104	#endif
105	return(min); /* avoids a float exception */	123	return (min); /* avoids a float exception */
106	}	124	}
107		125
108	/* 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.
109	* 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
110	* a little byteshifting. Do make sure the first one is only	128	* a little byteshifting. Do make sure the first one is only
111	* 32 bit, so we don't get skewed results	129	* 32 bit, so we don't get skewed results
112	*/	130	*/
113	ran = (RANDOM() & 0xffffffff) \| ((sint64)RANDOM() << 32);	131	ran = (RANDOM () & 0xffffffff) \| ((sint64) RANDOM () << 32);
114		132
115	if (op->type != PLAYER)	133	if (op->type != PLAYER)
116	return((ran%diff)+min);	134	return ((ran % diff) + min);
117		135
118	luck = op->stats.luck;	136	luck = op->stats.luck;
119	if (RANDOM()%base < MIN(10, abs(luck))) {	137	if (RANDOM () % base < MIN (10, abs (luck)))
		138	{
120	/* we have a winner */	139	/* we have a winner */
121	((luck > 0) ? (luck = 1) : (luck = -1));	140	((luck > 0) ? (luck = 1) : (luck = -1));
122	diff -= luck;	141	diff -= luck;
123	if (diff < 1)	142	if (diff < 1)
124	return(omin); /check again/	143	return (omin); /check again /
125	((goodbad) ? (min += luck) : (diff));	144	((goodbad) ? (min += luck) : (diff));
126		145
127	return(MAX(omin, MIN(max, (ran%diff)+min)));	146	return (MAX (omin, MIN (max, (ran % diff) + min)));
128	}	147	}
129	return((ran%diff)+min);	148	return ((ran % diff) + min);
130	}	149	}
131		150
132	/*	151	/*
133	* Roll a number of dice (2d3, 4d6). Uses op to determine luck,	152	* Roll a number of dice (2d3, 4d6). Uses op to determine luck,
134	* If goodbad is non-zero, luck increases the roll, if zero, it decreases.	153	* If goodbad is non-zero, luck increases the roll, if zero, it decreases.
135	* Generally, op should be the player/caster/hitter requesting the roll,	154	* Generally, op should be the player/caster/hitter requesting the roll,
136	* not the recipient (ie, the poor slob getting hit).	155	* not the recipient (ie, the poor slob getting hit).
137	* The args are num D size (ie 4d6) [garbled 20010916]	156	* The args are num D size (ie 4d6) [garbled 20010916]
138	*/	157	*/
139		158
		159	int
140	int die_roll(int num, int size, const object *op, int goodbad) {	160	die_roll (int num, int size, const object *op, int goodbad)
		161	{
141	int min, diff, luck, total, i, gotlucky, base, ran;	162	int min, diff, luck, total, i, gotlucky, base, ran;
142		163
143	diff = size;	164	diff = size;
144	min = 1;	165	min = 1;
145	luck = total = gotlucky = 0;	166	luck = total = gotlucky = 0;
146	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */	167	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
147	if (size < 2 \|\| diff < 1) {	168	if (size < 2 \|\| diff < 1)
		169	{
148	LOG(llevError, "Calling die_roll with num=%d size=%d\n", num, size);	170	LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size);
149	return(num); /* avoids a float exception */	171	return (num); /* avoids a float exception */
150	}	172	}
151		173
152	if (op->type == PLAYER)	174	if (op->type == PLAYER)
153	luck = op->stats.luck;	175	luck = op->stats.luck;
154		176
155	for (i = 0; i < num; i++) {	177	for (i = 0; i < num; i++)
		178	{
156	if (RANDOM()%base < MIN(10, abs(luck)) && !gotlucky) {	179	if (RANDOM () % base < MIN (10, abs (luck)) && !gotlucky)
		180	{
157	/* we have a winner */	181	/* we have a winner */
158	gotlucky++;	182	gotlucky++;
159	((luck > 0) ? (luck = 1) : (luck = -1));	183	((luck > 0) ? (luck = 1) : (luck = -1));
160	diff -= luck;	184	diff -= luck;
161	if (diff < 1)	185	if (diff < 1)
162	return(num); /check again/	186	return (num); /check again /
163	((goodbad) ? (min += luck) : (diff));	187	((goodbad) ? (min += luck) : (diff));
164	ran = RANDOM();	188	ran = RANDOM ();
165	total += MAX(1, MIN(size, (ran%diff)+min));	189	total += MAX (1, MIN (size, (ran % diff) + min));
		190	}
166	} else {	191	else
		192	{
167	total += RANDOM()%size+1;	193	total += RANDOM () % size + 1;
168	}	194	}
169	}	195	}
170	return(total);	196	return (total);
171	}	197	}
172		198
173	/*
174	* Another convenience function. Returns a number between min and max.
175	* It is suggested one use these functions rather than RANDOM()%, as it
176	* would appear that a number of off-by-one-errors exist due to improper
177	* use of %. This should also prevent SIGFPE.
178	*/
179
180	int rndm(int min, int max)
181	{
182	int diff;
183
184	diff = max - min + 1;
185	if (max < 1 \|\| diff < 1)
186	return(min);
187
188	return(RANDOM()%diff+min);
189	}
190
191	/* decay and destroy persihable items in a map */	199	/* decay and destroy perishable items in a map */
192		200	void
193	void decay_objects(mapstruct *m)	201	maptile::decay_objects ()
194	{	202	{
195	int x, y, destroy;	203	if (!spaces)
196	object op, otmp;
197
198	if (m->unique)
199	return;	204	return;
200		205
201	for (x=0; x < MAP_WIDTH(m); x++)	206	for (mapspace *ms = spaces + size (); ms-- > spaces; )
202	for (y=0; y < MAP_HEIGHT(m); y++)	207	for (object above, op = ms->bot; op; op = above)
203	for (op = get_map_ob(m, x, y); op; op = otmp) {	208	{
		209	above = op->above;
		210
204	destroy = 0;	211	bool destroy = 0;
205	otmp = op->above;	212
		213	// do not decay anything above unique floor tiles (yet :)
206	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))
207	break;	215	break;
		216
208	if (QUERY_FLAG(op, FLAG_IS_FLOOR) \|\|	217	if (QUERY_FLAG (op, FLAG_IS_FLOOR)
209	QUERY_FLAG(op, FLAG_OBJ_ORIGINAL) \|\|	218	\|\| QUERY_FLAG (op, FLAG_OBJ_ORIGINAL)
210	QUERY_FLAG(op, FLAG_OBJ_SAVE_ON_OVL) \|\|	219	\|\| QUERY_FLAG (op, FLAG_OBJ_SAVE_ON_OVL)
211	QUERY_FLAG(op, FLAG_UNIQUE) \|\|	220	\|\| QUERY_FLAG (op, FLAG_UNIQUE)
212	QUERY_FLAG(op, FLAG_OVERLAY_FLOOR) \|\|	221	\|\| QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)
213	QUERY_FLAG(op, FLAG_UNPAID) \|\| IS_LIVE(op))	222	\|\| QUERY_FLAG (op, FLAG_UNPAID)
214	continue;	223	\|\| op->is_alive ())
215	/* otherwise, we decay and destroy */	224	; // do not decay
216	if (IS_WEAPON(op)) {	225	else if (op->is_weapon ())
		226	{
217	op->stats.dam--;	227	op->stats.dam--;
218	if (op->stats.dam < 0)	228	if (op->stats.dam < 0)
219	destroy = 1;	229	destroy = 1;
220	} else if (IS_ARMOR(op)) {
221	op->stats.ac--;
222	if (op->stats.ac < 0)
223	destroy = 1;
224	} else if (op->type == FOOD) {
225	op->stats.food -= rndm(5,20);
226	if (op->stats.food < 0)
227	destroy = 1;
228	} else {
229	if (op->material & M_PAPER \|\| op->material & M_LEATHER \|\|
230	op->material & M_WOOD \|\| op->material & M_ORGANIC \|\|
231	op->material & M_CLOTH \|\| op->material & M_LIQUID)
232	destroy = 1;
233	if (op->material & M_IRON && rndm(1,5) == 1)
234	destroy = 1;
235	if (op->material & M_GLASS && rndm(1,2) == 1)
236	destroy = 1;
237	if ((op->material & M_STONE \|\| op->material & M_ADAMANT) &&
238	rndm(1,10) == 1)
239	destroy = 1;
240	if ((op->material & M_SOFT_METAL \|\| op->material & M_BONE) &&
241	rndm(1,3) == 1)
242	destroy = 1;
243	if (op->material & M_ICE && MAP_TEMP(m) > 32)
244	destroy = 1;
245	}
246	/* adjust overall chance below */
247	if (destroy && rndm(0, 1)) {
248	remove_ob(op);
249	free_object(op);
250	}
251	}	230	}
		231	else if (op->is_armor ())
		232	{
		233	op->stats.ac--;
		234	if (op->stats.ac < 0)
		235	destroy = 1;
		236	}
		237	else if (op->type == FOOD)
		238	{
		239	op->stats.food -= rndm (5, 20);
		240	if (op->stats.food < 0)
		241	destroy = 1;
		242	}
		243	else
		244	{
		245	int mat = op->material;
		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))
		258	destroy = 1;
		259	}
		260
		261	/* adjust overall chance below */
		262	if (destroy && rndm (0, 1))
		263	op->destroy ();
		264	}
252	}	265	}
253		266
254	/* convert materialname to materialtype_t */	267	/* convert materialname to materialtype_t */
255		268
		269	materialtype_t *
256	materialtype_t name_to_material(const char name)	270	name_to_material (const char *name)
257	{	271	{
258	materialtype_t mt, nmt;	272	materialtype_t mt, nmt;
259		273
260	mt = NULL;	274	mt = NULL;
261	for (nmt = materialt; nmt != NULL && nmt->next != NULL; nmt=nmt->next) {	275	for (nmt = materialt; nmt != NULL && nmt->next != NULL; nmt = nmt->next)
		276	{
262	if (strcmp(name, nmt->name) == 0) {	277	if (strcmp (name, nmt->name) == 0)
		278	{
263	mt = nmt;	279	mt = nmt;
264	break;	280	break;
265	}	281	}
266	}	282	}
267	return mt;	283	return mt;
268	}	284	}
269		285
270	/* when doing transmutation of objects, we have to recheck the resistances,	286	/* when doing transmutation of objects, we have to recheck the resistances,
271	* as some that did not apply previously, may apply now.	287	* as some that did not apply previously, may apply now.
272	*/	288	*/
273		289
		290	void
274	void transmute_materialname(object op, const object change)	291	transmute_materialname (object op, const object change)
275	{	292	{
276	materialtype_t *mt;	293	materialtype_t *mt;
277	int j;	294	int j;
278		295
279	if (op->materialname == NULL)	296	if (op->materialname == NULL)
280	return;	297	return;
281		298
282	if (change->materialname != NULL &&	299	if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
283	strcmp(op->materialname, change->materialname))
284	return;	300	return;
285		301
286	if (!IS_ARMOR(op))	302	if (!op->is_armor ())
287	return;	303	return;
288		304
289	mt = name_to_material(op->materialname);	305	mt = name_to_material (op->materialname);
290	if (!mt) {	306	if (!mt)
		307	{
291	LOG(llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->name, &op->name, &op->materialname);	308	LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->name, &op->name, &op->materialname);
292	return;	309	return;
293	}	310	}
294		311
295	for (j=0; j < NROFATTACKS; j++)	312	for (j = 0; j < NROFATTACKS; j++)
296	if (op->resist[j] == 0 && change->resist[j] != 0) {	313	if (op->resist[j] == 0 && change->resist[j] != 0)
		314	{
297	op->resist[j] += mt->mod[j];	315	op->resist[j] += mt->mod[j];
298	if (op->resist[j] > 100)	316	if (op->resist[j] > 100)
299	op->resist[j] = 100;	317	op->resist[j] = 100;
300	if (op->resist[j] < -100)	318	if (op->resist[j] < -100)
301	op->resist[j] = -100;	319	op->resist[j] = -100;
302	}	320	}
303	}	321	}
304		322
305	/* set the materialname and type for an item */	323	/* set the materialname and type for an item */
		324	void
306	void set_materialname(object op, int difficulty, materialtype_t nmt)	325	set_materialname (object op, int difficulty, materialtype_t nmt)
307	{	326	{
308	materialtype_t mt, lmt;	327	materialtype_t mt, lmt;
		328
309	#ifdef NEW_MATERIAL_CODE	329	#ifdef NEW_MATERIAL_CODE
310	int j;	330	int j;
311	#endif	331	#endif
312		332
313	if (op->materialname != NULL)	333	if (op->materialname != NULL)
314	return;	334	return;
315		335
316		336
317		337
318	if (nmt == NULL) {	338	if (nmt == NULL)
		339	{
319	lmt = NULL;	340	lmt = NULL;
320	#ifndef NEW_MATERIAL_CODE	341	#ifndef NEW_MATERIAL_CODE
321	for (mt = materialt; mt != NULL && mt->next != NULL; mt=mt->next) {	342	for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next)
		343	{
322	if (op->material & mt->material) {	344	if (op->material & mt->material)
		345	{
323	lmt = mt;	346	lmt = mt;
		347	break;
		348	}
		349	}
		350
		351	#else
		352	for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next)
		353	{
		354	if (op->material & mt->material && rndm (1, 100) <= mt->chance &&
		355	difficulty >= mt->difficulty && (op->magic >= mt->magic \|\| mt->magic == 0))
		356	{
		357	lmt = mt;
		358	if (!(op->is_weapon () \|\| op->is_armor ()))
324	break;	359	break;
325	}	360	}
326	}	361	}
		362	#endif
		363	}
		364	else
		365	{
		366	lmt = nmt;
		367	}
327		368
		369	if (lmt != NULL)
		370	{
		371	#ifndef NEW_MATERIAL_CODE
		372	op->materialname = lmt->name;
		373	return;
328	#else	374	#else
329	for (mt = materialt; mt != NULL && mt->next != NULL; mt=mt->next) {	375
330	if (op->material & mt->material && rndm(1, 100) <= mt->chance &&	376	if (op->stats.dam && op->is_weapon ())
331	difficulty >= mt->difficulty &&
332	(op->magic >= mt->magic \|\| mt->magic == 0)) {
333	lmt = mt;
334	if (!(IS_WEAPON(op) \|\| IS_ARMOR(op)))
335	break;
336	}
337	}	377	{
338	#endif
339	} else {
340	lmt = nmt;
341	}
342
343	if (lmt != NULL) {
344	#ifndef NEW_MATERIAL_CODE
345	op->materialname = lmt->name;
346	return;
347	#else
348
349	if (op->stats.dam && IS_WEAPON(op)) {
350	op->stats.dam += lmt->damage;	378	op->stats.dam += lmt->damage;
351	if (op->stats.dam < 1)	379	if (op->stats.dam < 1)
352	op->stats.dam = 1;	380	op->stats.dam = 1;
353	}	381	}
354	if (op->stats.sp && op->type == BOW)	382	if (op->stats.sp && op->type == BOW)
355	op->stats.sp += lmt->sp;	383	op->stats.sp += lmt->sp;
356	if (op->stats.wc && IS_WEAPON(op))	384	if (op->stats.wc && op->is_weapon ())
357	op->stats.wc += lmt->wc;	385	op->stats.wc += lmt->wc;
358	if (IS_ARMOR(op)) {	386	if (op->is_armor ())
		387	{
359	if (op->stats.ac)	388	if (op->stats.ac)
360	op->stats.ac += lmt->ac;	389	op->stats.ac += lmt->ac;
361	for (j=0; j < NROFATTACKS; j++)	390	for (j = 0; j < NROFATTACKS; j++)
362	if (op->resist[j] != 0) {	391	if (op->resist[j] != 0)
		392	{
363	op->resist[j] += lmt->mod[j];	393	op->resist[j] += lmt->mod[j];
364	if (op->resist[j] > 100)	394	if (op->resist[j] > 100)
365	op->resist[j] = 100;	395	op->resist[j] = 100;
366	if (op->resist[j] < -100)	396	if (op->resist[j] < -100)
367	op->resist[j] = -100;	397	op->resist[j] = -100;
368	}	398	}
369	}	399	}
370	op->materialname = add_string(lmt->name);	400	op->materialname = add_string (lmt->name);
371	/* dont make it unstackable if it doesn't need to be */	401	/* dont make it unstackable if it doesn't need to be */
372	if (IS_WEAPON(op) \|\| IS_ARMOR(op)) {	402	if (op->is_weapon () \|\| op->is_armor ())
		403	{
373	op->weight = (op->weight * lmt->weight)/100;	404	op->weight = (op->weight * lmt->weight) / 100;
374	op->value = (op->value * lmt->value)/100;	405	op->value = (op->value * lmt->value) / 100;
375	}	406	}
376	#endif	407	#endif
377	}	408	}
378	}	409	}
379		410
380	/*	411	/*
381	* Strip out the media tags from a String.	412	* Strip out the media tags from a String.
382	* Warning the input string will contain the result string	413	* Warning the input string will contain the result string
383	*/	414	*/
		415	void
384	void strip_media_tag(char *message){	416	strip_media_tag (char *message)
		417	{
385	int in_tag=0;	418	int in_tag = 0;
386	char* dest;	419	char *dest;
387	char* src;	420	char *src;
		421
388	src=dest=message;	422	src = dest = message;
389	while (*src!='\0'){	423	while (*src != '\0')
		424	{
390	if (*src=='['){	425	if (*src == '[')
		426	{
391	in_tag=1;	427	in_tag = 1;
		428	}
392	} else if (in_tag && (*src==']'))	429	else if (in_tag && (*src == ']'))
393	in_tag=0;	430	in_tag = 0;
394	else if (!in_tag){	431	else if (!in_tag)
		432	{
395	dest=src;	433	dest = src;
396	dest++;	434	dest++;
397	}	435	}
398	src++;	436	src++;
399	}	437	}
400	*dest='\0';	438	*dest = '\0';
401	}	439	}
402		440
		441	const char *
403	const char* strrstr(const char* haystack, const char* needle){	442	strrstr (const char haystack, const char needle)
		443	{
404	const char* lastneedle;	444	const char *lastneedle;
		445
405	lastneedle=NULL;	446	lastneedle = NULL;
406	while((haystack=strstr(haystack,needle))!=NULL){	447	while ((haystack = strstr (haystack, needle)) != NULL)
		448	{
407	lastneedle=haystack;	449	lastneedle = haystack;
408	haystack++;	450	haystack++;
409	}	451	}
410	return lastneedle;	452	return lastneedle;
411		453
412	}	454	}
		455
413	#define EOL_SIZE (sizeof("\n")-1)	456	#define EOL_SIZE (sizeof("\n")-1)
		457	void
414	void strip_endline(char* buf){	458	strip_endline (char *buf)
		459	{
415	if (strlen(buf)<sizeof("\n")){	460	if (strlen (buf) < sizeof ("\n"))
		461	{
416	return;	462	return;
417	}	463	}
418	if (!strcmp(buf+strlen(buf)-EOL_SIZE,"\n"))	464	if (!strcmp (buf + strlen (buf) - EOL_SIZE, "\n"))
419	buf[strlen(buf)-EOL_SIZE]='\0';	465	buf[strlen (buf) - EOL_SIZE] = '\0';
420	}	466	}
421		467
422	/**	468	/**
423	* Replace in string src all occurrences of key by replacement. The resulting	469	* Replace in string src all occurrences of key by replacement. The resulting
424	* string is put into result; at most resultsize characters (including the	470	* string is put into result; at most resultsize characters (including the
425	* terminating null character) will be written to result.	471	* terminating null character) will be written to result.
426	*/	472	*/
		473	void
427	void replace(const char src, const char key, const char replacement, char result, size_t resultsize)	474	replace (const char src, const char key, const char replacement, char result, size_t resultsize)
428	{	475	{
429	size_t resultlen;	476	size_t resultlen;
430	size_t keylen;	477	size_t keylen;
431		478
432	/* special case to prevent infinite loop if key==replacement=="" */	479	/* special case to prevent infinite loop if key==replacement=="" */
433	if(strcmp(key, replacement) == 0)	480	if (strcmp (key, replacement) == 0)
434	{	481	{
435	snprintf(result, resultsize, "%s", src);	482	snprintf (result, resultsize, "%s", src);
436	return;	483	return;
437	}	484	}
438		485
439	keylen = strlen(key);	486	keylen = strlen (key);
440		487
441	resultlen = 0;	488	resultlen = 0;
442	while(*src != '\0' && resultlen+1 < resultsize)	489	while (*src != '\0' && resultlen + 1 < resultsize)
443	{	490	{
444	if(strncmp(src, key, keylen) == 0)	491	if (strncmp (src, key, keylen) == 0)
445	{	492	{
446	snprintf(result+resultlen, resultsize-resultlen, "%s", replacement);	493	snprintf (result + resultlen, resultsize - resultlen, "%s", replacement);
447	resultlen += strlen(result+resultlen);	494	resultlen += strlen (result + resultlen);
448	src += keylen;	495	src += keylen;
449	}	496	}
450	else	497	else
451	{
452	result[resultlen++] = *src++;
453	}
454	}	498	{
		499	result[resultlen++] = *src++;
		500	}
		501	}
455	result[resultlen] = '\0';	502	result[resultlen] = '\0';
456	}	503	}
457		504
458	/**	505	/**
459	* Taking a string as an argument, mutate it into a string that looks like a list.	506	* Taking a string as an argument, mutate it into a string that looks like a list.
460	* a 'list' for the purposes here, is a string of items, seperated by commas, except	507	* a 'list' for the purposes here, is a string of items, seperated by commas, except
461	* for the last entry, which has an 'and' before it, and a full stop (period) after it.	508	* for the last entry, which has an 'and' before it, and a full stop (period) after it.
462	* This function will also strip all trailing non alphanumeric characters.	509	* This function will also strip all trailing non alphanumeric characters.
463	* It does not insert an oxford comma.	510	* It does not insert an oxford comma.
464	*/	511	*/
465		512
		513	void
466	void make_list_like(char *input) {	514	make_list_like (char *input)
		515	{
467	char *p, tmp[MAX_BUF];	516	char *p, tmp[MAX_BUF];
468	int i;	517	int i;
		518
469	if (!input \|\| strlen(input) > MAX_BUF-5) return;	519	if (!input \|\| strlen (input) > MAX_BUF - 5)
470	/* bad stuff would happen if we continued here, the -5 is to make space for ' and ' */
471
472	strncpy(tmp, input, MAX_BUF-5);
473	/trim all trailing commas, spaces etc./
474	for (i=strlen(tmp); !isalnum(tmp[i]) && i >= 0; i--)
475	tmp[i]='\0';
476	strcat(tmp, ".");
477
478	p=strrchr(tmp, ',');
479	if (p) {
480	*p='\0';
481	strcpy(input, tmp);
482	p++;
483	strcat(input, " and");
484	strcat(input, p);
485	}
486	else strcpy(input, tmp);
487	return;	520	return;
488	}	521	/* bad stuff would happen if we continued here, the -5 is to make space for ' and ' */
489		522
490	//TODO: overhead due to specifying size twice	523	strncpy (tmp, input, MAX_BUF - 5);
		524	/trim all trailing commas, spaces etc. /
		525	for (i = strlen (tmp); !isalnum (tmp[i]) && i >= 0; i--)
		526	tmp[i] = '\0';
		527
		528	strcat (tmp, ".");
		529
		530	p = strrchr (tmp, ',');
		531	if (p)
		532	{
		533	*p = '\0';
		534	strcpy (input, tmp);
		535	p++;
		536	strcat (input, " and");
		537	strcat (input, p);
		538	}
		539	else
		540	strcpy (input, tmp);
		541
		542	return;
		543	}
		544
		545	/////////////////////////////////////////////////////////////////////////////
		546
491	void *	547	void
492	zero_initialised::operator new (size_t s)	548	fork_abort (const char *msg)
493	{
494	return g_slice_alloc0 (s);
495	}
496
497	void *
498	zero_initialised::operator new [] (size_t s)
499	{
500	return g_slice_alloc0 (s);
501	}
502
503	void
504	zero_initialised::operator delete (void *p, size_t s)
505	{	549	{
506	g_slice_free1 (s, p);	550	if (!fork ())
507	}	551	{
		552	signal (SIGABRT, SIG_DFL);
		553	abort ();
		554	}
508		555
509	void	556	LOG (llevError, "fork abort: %s\n", msg);
510	zero_initialised::operator delete [] (void *p, size_t s)
511	{
512	g_slice_free1 (s, p);
513	}	557	}
514		558
		559	void *salloc_ (int n) throw (std::bad_alloc)
		560	{
		561	void *ptr = g_slice_alloc (n);
		562
		563	if (!ptr)
		564	throw std::bad_alloc ();
		565
		566	return ptr;
		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.5 by pippijn, Thu Sep 7 09:37:12 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.5 by pippijn, Thu Sep 7 09:37:12 2006 UTC vs.
Revision 1.41 by root, Thu Jan 18 22:19:59 2007 UTC