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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.14 by root, Fri Sep 8 17:14:07 2006 UTC vs.
Revision 1.21 by root, Thu Sep 14 22:33:58 2006 UTC

…		…
1	/*
2	* static char *rcsid_arch_c =
3	* "$Id: arch.C,v 1.14 2006/09/08 17:14:07 root Exp $";
4	*/
5
6	/*	1	/*
7	CrossFire, A Multiplayer game for X-windows	2	CrossFire, A Multiplayer game for X-windows
8		3
9	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	4	Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10	Copyright (C) 1992 Frank Tore Johansen	5	Copyright (C) 1992 Frank Tore Johansen
21		16
22	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU General Public License
23	along with this program; if not, write to the Free Software	18	along with this program; if not, write to the Free Software
24	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25		20
26	The authors can be reached via e-mail at crossfire-devel@real-time.com	21	The authors can be reached via e-mail at <crossfire@schmorp.de>
27	*/	22	*/
28		23
29	#include <cassert>	24	#include <cassert>
30		25
31	#include <tr1/unordered_map>	26	#include <tr1/unordered_map>
…		…
36	#include <loader.h>	31	#include <loader.h>
37		32
38	/* IF set, does a little timing on the archetype load. */	33	/* IF set, does a little timing on the archetype load. */
39	#define TIME_ARCH_LOAD 0	34	#define TIME_ARCH_LOAD 0
40		35
41	static void add_arch (archetype * at);	36	static void add_arch (archetype *at);
42		37
43	static archetype *arch_table[ARCHTABLE];	38	static archetype *arch_table[ARCHTABLE];
44	int arch_cmp = 0; /* How many strcmp's */	39	int arch_cmp = 0; /* How many strcmp's */
45	int arch_search = 0; /* How many searches */	40	int arch_search = 0; /* How many searches */
46	int arch_init; /* True if doing arch initialization */	41	int arch_init; /* True if doing arch initialization */
…		…
53	* MSW 2003-04-29	48	* MSW 2003-04-29
54	*/	49	*/
55		50
56	#if USE_UNORDERED_MAP	51	#if USE_UNORDERED_MAP
57	// the hashtable	52	// the hashtable
58	typedef std::tr1::unordered_map<size_t, archetype *> HT;	53	typedef std::tr1::unordered_map
		54	<
		55	std::size_t,
		56	archetype *,
		57	std::hash<size_t>,
		58	std::equal_to<size_t>,
		59	slice_allocator< std::pair<const std::size_t, archetype *> >
		60	true,
		61	> HT;
59		62
60	static HT ht;	63	static HT ht;
61	#endif	64	#endif
62		65
63	/**	66	/**
…		…
165	* but it otherwise had a big memory leak.	168	* but it otherwise had a big memory leak.
166	*/	169	*/
167	object *	170	object *
168	get_archetype_by_object_name (const char *name)	171	get_archetype_by_object_name (const char *name)
169	{	172	{
170	archetype *	173	archetype *at;
171	at;
172	char
173	tmpname[MAX_BUF];	174	char tmpname[MAX_BUF];
174	int	175	int i;
175	i;
176		176
177	strncpy (tmpname, name, MAX_BUF - 1);	177	assign (tmpname, name);
178	tmpname[MAX_BUF - 1] = 0;	178
179	for (i = strlen (tmpname); i > 0; i--)	179	for (i = strlen (tmpname); i > 0; i--)
180	{	180	{
181	tmpname[i] = 0;	181	tmpname[i] = 0;
182	at = find_archetype_by_object_name (tmpname);	182	at = find_archetype_by_object_name (tmpname);
		183
183	if (at != NULL)	184	if (at != NULL)
184	{
185	return arch_to_object (at);	185	return arch_to_object (at);
186	}
187	}	186	}
		187
188	return create_singularity (name);	188	return create_singularity (name);
189	}	189	}
190		190
191	/* This is a subset of the parse_id command. Basically, name can be	191	/* This is a subset of the parse_id command. Basically, name can be
192	* a string seperated lists of things to match, with certain keywords.	192	* a string seperated lists of things to match, with certain keywords.
…		…
204	* If count is 1, make a quick check on the name.	204	* If count is 1, make a quick check on the name.
205	* IF count is >1, we need to make plural name. Return if match.	205	* IF count is >1, we need to make plural name. Return if match.
206	* Last, make a check on the full name.	206	* Last, make a check on the full name.
207	*/	207	*/
208	int	208	int
209	item_matched_string (object * pl, object * op, const char *name)	209	item_matched_string (object pl, object op, const char *name)
210	{	210	{
211	char *	211	char *
212	cp,	212	cp,
213	local_name[MAX_BUF];	213	local_name[MAX_BUF];
214	int	214	int
215	count,	215	count,
216	retval = 0;	216	retval = 0;
		217
217	strcpy (local_name, name); /* strtok is destructive to name */	218	strcpy (local_name, name); /* strtok is destructive to name */
218		219
219	for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))	220	for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
220	{	221	{
221	while (cp[0] == ' ')	222	while (cp[0] == ' ')
…		…
322	void	323	void
323	init_archetypes (void)	324	init_archetypes (void)
324	{ /* called from add_player() and edit() */	325	{ /* called from add_player() and edit() */
325	if (first_archetype != NULL) /* Only do this once */	326	if (first_archetype != NULL) /* Only do this once */
326	return;	327	return;
		328
327	arch_init = 1;	329	arch_init = 1;
328	load_archetypes ();	330	load_archetypes ();
329	arch_init = 0;	331	arch_init = 0;
330	empty_archetype = find_archetype ("empty_archetype");	332	empty_archetype = archetype::find ("empty_archetype");
		333
331	/* init_blocksview();*/	334	/* init_blocksview();*/
332	}	335	}
333		336
334	/*	337	/*
335	* Stores debug-information about how efficient the hashtable	338	* Stores debug-information about how efficient the hashtable
336	* used for archetypes has been in the static errmsg array.	339	* used for archetypes has been in the static errmsg array.
337	*/	340	*/
338		341
339	void	342	void
340	arch_info (object * op)	343	arch_info (object *op)
341	{	344	{
342	sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp);	345	sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp);
343	new_draw_info (NDI_BLACK, 0, op, errmsg);	346	new_draw_info (NDI_BLACK, 0, op, errmsg);
344	}	347	}
345		348
…		…
358	*/	361	*/
359		362
360	void	363	void
361	init_archetable (void)	364	init_archetable (void)
362	{	365	{
363	archetype *at;	366	archetype *
		367	at;
364		368
365	LOG (llevDebug, " Setting up archetable...\n");	369	LOG (llevDebug, " Setting up archetable...\n");
366		370
367	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)	371	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
368	add_arch (at);	372	add_arch (at);
…		…
373	/*	377	/*
374	* Dumps an archetype to debug-level output.	378	* Dumps an archetype to debug-level output.
375	*/	379	*/
376		380
377	void	381	void
378	dump_arch (archetype * at)	382	dump_arch (archetype *at)
379	{	383	{
380	dump_object (&at->clone);	384	dump_object (&at->clone);
381	}	385	}
382		386
383	/*	387	/*
…		…
389	void	393	void
390	dump_all_archetypes (void)	394	dump_all_archetypes (void)
391	{	395	{
392	archetype *	396	archetype *
393	at;	397	at;
		398
394	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)	399	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
395	{	400	{
396	dump_arch (at);	401	dump_arch (at);
397	fprintf (logfile, "%s\n", errmsg);	402	fprintf (logfile, "%s\n", errmsg);
398	}	403	}
…		…
414	else	419	else
415	next = at->next;	420	next = at->next;
416		421
417	delete	422	delete
418	at;	423	at;
		424
419	i++;	425	i++;
420	}	426	}
421	LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);	427	LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
422	}	428	}
423		429
424	archetype::archetype ()	430	archetype::archetype ()
425	{	431	{
426	clear_object (&clone); /* to initial state other also */	432	clear_object (&clone); /* to initial state other also */
427	CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */	433	CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */
428	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */	434	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
429	}	435	}
430		436
431	archetype::~archetype ()	437	archetype::~archetype ()
432	{	438	{
433	}	439	}
…		…
437	* of archetype-structures.	443	* of archetype-structures.
438	*/	444	*/
439	void	445	void
440	first_arch_pass (object_thawer & fp)	446	first_arch_pass (object_thawer & fp)
441	{	447	{
		448	archetype *
		449	at, *
442	archetype at, head = NULL, *last_more = NULL;	450	head = NULL, *last_more = NULL;
443		451
444	at->clone.arch = first_archetype = at = new archetype;	452	at->clone.arch = first_archetype = at = new archetype;
445		453
446	while (int i = load_object (fp, &at->clone, 0))	454	while (int i = load_object (fp, &at->clone, 0))
447	{	455	{
…		…
454	*/	462	*/
455	memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));	463	memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));
456		464
457	switch (i)	465	switch (i)
458	{	466	{
459	case LL_NORMAL: /* A new archetype, just link it with the previous */	467	case LL_NORMAL: /* A new archetype, just link it with the previous */
460	if (last_more != NULL)	468	if (last_more != NULL)
461	last_more->next = at;	469	last_more->next = at;
462	if (head != NULL)	470	if (head != NULL)
463	head->next = at;	471	head->next = at;
464	head = last_more = at;	472	head = last_more = at;
465	#if 0	473	#if 0
466	if (!op->type)	474	if (!op->type)
467	LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);	475	LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);
468	#endif	476	#endif
469	at->tail_x = 0;	477	at->tail_x = 0;
470	at->tail_y = 0;	478	at->tail_y = 0;
471	break;	479	break;
472		480
473	case LL_MORE: /* Another part of the previous archetype, link it correctly */	481	case LL_MORE: /* Another part of the previous archetype, link it correctly */
474		482
475	at->head = head;	483	at->head = head;
476	at->clone.head = &head->clone;	484	at->clone.head = &head->clone;
477	if (last_more != NULL)	485	if (last_more != NULL)
478	{	486	{
479	last_more->more = at;	487	last_more->more = at;
480	last_more->clone.more = &at->clone;	488	last_more->clone.more = &at->clone;
481	}	489	}
482	last_more = at;	490	last_more = at;
483		491
484	/* If this multipart image is still composed of individual small	492	/* If this multipart image is still composed of individual small
485	* images, don't set the tail_.. values. We can't use them anyways,	493	* images, don't set the tail_.. values. We can't use them anyways,
486	* and setting these to zero makes the map sending to the client much	494	* and setting these to zero makes the map sending to the client much
487	* easier as just looking at the head, we know what to do.	495	* easier as just looking at the head, we know what to do.
488	*/	496	*/
489	if (at->clone.face != head->clone.face)	497	if (at->clone.face != head->clone.face)
490	{	498	{
491	head->tail_x = 0;	499	head->tail_x = 0;
492	head->tail_y = 0;	500	head->tail_y = 0;
493	}	501	}
494	else	502	else
495	{	503	{
496	if (at->clone.x > head->tail_x)	504	if (at->clone.x > head->tail_x)
497	head->tail_x = at->clone.x;	505	head->tail_x = at->clone.x;
498	if (at->clone.y > head->tail_y)	506	if (at->clone.y > head->tail_y)
499	head->tail_y = at->clone.y;	507	head->tail_y = at->clone.y;
500	}	508	}
501	break;	509	break;
502		510
503	}	511	}
504		512
505	at = new archetype;	513	at = new archetype;
		514
506	at->clone.arch = at;	515	at->clone.arch = at;
507	}	516	}
508		517
509	delete at;	518	delete at;
510	}	519	}
…		…
515	*/	524	*/
516		525
517	void	526	void
518	second_arch_pass (object_thawer & thawer)	527	second_arch_pass (object_thawer & thawer)
519	{	528	{
		529	char
		530	buf[MAX_BUF], *
520	char buf[MAX_BUF], variable = buf, argument, *cp;	531	variable = buf, argument, cp;
		532	archetype *
521	archetype at = NULL, other;	533	at = NULL, *other;
522		534
523	while (fgets (buf, MAX_BUF, thawer) != NULL)	535	while (fgets (buf, MAX_BUF, thawer) != NULL)
524	{	536	{
525	if (*buf == '#')	537	if (*buf == '#')
526	continue;	538	continue;
…		…
534	cp--;	546	cp--;
535	}	547	}
536	}	548	}
537	if (!strcmp ("Object", variable))	549	if (!strcmp ("Object", variable))
538	{	550	{
539	if ((at = find_archetype (argument)) == NULL)	551	if ((at = archetype::find (argument)) == NULL)
540	LOG (llevError, "Warning: failed to find arch %s\n", argument);	552	LOG (llevError, "Warning: failed to find arch %s\n", argument);
541	}	553	}
542	else if (!strcmp ("other_arch", variable))	554	else if (!strcmp ("other_arch", variable))
543	{	555	{
544	if (at != NULL && at->clone.other_arch == NULL)	556	if (at != NULL && at->clone.other_arch == NULL)
545	{	557	{
546	if ((other = find_archetype (argument)) == NULL)	558	if ((other = archetype::find (argument)) == NULL)
547	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);	559	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
548	else if (at != NULL)	560	else if (at != NULL)
549	at->clone.other_arch = other;	561	at->clone.other_arch = other;
550	}	562	}
551	}	563	}
…		…
553	{	565	{
554	if (at != NULL)	566	if (at != NULL)
555	{	567	{
556	treasurelist *	568	treasurelist *
557	tl = find_treasurelist (argument);	569	tl = find_treasurelist (argument);
		570
558	if (tl == NULL)	571	if (tl == NULL)
559	LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);	572	LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
560	else	573	else
561	at->clone.randomitems = tl;	574	at->clone.randomitems = tl;
562	}	575	}
…		…
568	void	581	void
569	check_generators (void)	582	check_generators (void)
570	{	583	{
571	archetype *	584	archetype *
572	at;	585	at;
		586
573	for (at = first_archetype; at != NULL; at = at->next)	587	for (at = first_archetype; at != NULL; at = at->next)
574	if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)	588	if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)
575	LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);	589	LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
576	}	590	}
577	#endif	591	#endif
…		…
586	void	600	void
587	load_archetypes (void)	601	load_archetypes (void)
588	{	602	{
589	char	603	char
590	filename[MAX_BUF];	604	filename[MAX_BUF];
		605
591	#if TIME_ARCH_LOAD	606	#if TIME_ARCH_LOAD
592	struct timeval	607	struct timeval
593	tv1,	608	tv1,
594	tv2;	609	tv2;
595	#endif	610	#endif
…		…
630	* Creates and returns a new object which is a copy of the given archetype.	645	* Creates and returns a new object which is a copy of the given archetype.
631	* This function returns NULL on failure.	646	* This function returns NULL on failure.
632	*/	647	*/
633		648
634	object *	649	object *
635	arch_to_object (archetype * at)	650	arch_to_object (archetype *at)
636	{	651	{
637	object *	652	object *
638	op;	653	op;
		654
639	if (at == NULL)	655	if (at == NULL)
640	{	656	{
641	if (warn_archetypes)	657	if (warn_archetypes)
642	LOG (llevError, "Couldn't find archetype.\n");	658	LOG (llevError, "Couldn't find archetype.\n");
		659
643	return NULL;	660	return NULL;
644	}	661	}
		662
645	op = get_object ();	663	op = get_object ();
646	copy_object (&at->clone, op);	664	copy_object (&at->clone, op);
		665	op->arch = at;
647	op->instantiate ();	666	op->instantiate ();
648	op->arch = at;
649	return op;	667	return op;
650	}	668	}
651		669
652	/*	670	/*
653	* Creates an object. This function is called by get_archetype()	671	* Creates an object. This function is called by get_archetype()
…		…
657	*/	675	*/
658		676
659	object *	677	object *
660	create_singularity (const char *name)	678	create_singularity (const char *name)
661	{	679	{
662	object *op;	680	object * op;
663	char buf[MAX_BUF];	681	char buf[MAX_BUF];
		682
664	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);	683	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
665	op = get_object ();	684	op = get_object ();
666	op->name = op->name_pl = buf;	685	op->name = op->name_pl = buf;
667	SET_FLAG (op, FLAG_NO_PICK);	686	SET_FLAG (op, FLAG_NO_PICK);
668	return op;	687	return op;
…		…
674	*/	693	*/
675		694
676	object *	695	object *
677	get_archetype (const char *name)	696	get_archetype (const char *name)
678	{	697	{
679	archetype *at;	698	archetype *at = archetype::find (name);
680	at = find_archetype (name);	699
681	if (at == NULL)	700	if (!at)
682	return create_singularity (name);	701	return create_singularity (name);
		702
683	return arch_to_object (at);	703	return arch_to_object (at);
684	}	704	}
685		705
686	/*	706	/*
687	* Hash-function used by the arch-hashtable.	707	* Hash-function used by the arch-hashtable.
…		…
717	* Finds, using the hashtable, which archetype matches the given name.	737	* Finds, using the hashtable, which archetype matches the given name.
718	* returns a pointer to the found archetype, otherwise NULL.	738	* returns a pointer to the found archetype, otherwise NULL.
719	*/	739	*/
720		740
721	archetype *	741	archetype *
722	find_archetype (const char *name)	742	archetype::find (const char *name)
723	{	743	{
724	#if USE_UNORDERED_MAP
725	name = shstr::find (name);
726
727	if (!name)	744	if (!name)
728	return 0;	745	return 0;
729		746
730	HT::const_iterator i = ht.find ((size_t)name);	747	#if USE_UNORDERED_MAP
		748	AUTODECL (i, ht.find ((size_t) name));
731		749
732	if (i == ht.end ())	750	if (i == ht.end ())
733	return 0;	751	return 0;
734	else	752	else
735	return i->second;	753	return i->second;
736	#endif	754	#endif
737		755
738	archetype *at;	756	archetype *at;
739	unsigned long index;	757	unsigned long index;
740		758
741	if (name == NULL)
742	return (archetype *) NULL;
743
744	index = hasharch (name, ARCHTABLE);	759	index = hasharch (name, ARCHTABLE);
745	arch_search++;	760	arch_search++;
746	for (;;)	761	for (;;)
747	{	762	{
748	at = arch_table[index];	763	at = arch_table[index];
		764
749	if (at == NULL)	765	if (at == NULL)
750	{	766	{
751	if (warn_archetypes)	767	if (warn_archetypes)
752	LOG (llevError, "Couldn't find archetype %s\n", name);	768	LOG (llevError, "Couldn't find archetype %s\n", name);
		769
753	return NULL;	770	return NULL;
754	}	771	}
		772
755	arch_cmp++;	773	arch_cmp++;
		774
756	if (!strcmp ((const char *) at->name, name))	775	if (!strcmp ((const char *) at->name, name))
757	return at;	776	return at;
		777
758	if (++index >= ARCHTABLE)	778	if (++index >= ARCHTABLE)
759	index = 0;	779	index = 0;
760	}	780	}
761	}	781	}
762		782
…		…
766		786
767	static void	787	static void
768	add_arch (archetype *at)	788	add_arch (archetype *at)
769	{	789	{
770	#if USE_UNORDERED_MAP	790	#if USE_UNORDERED_MAP
771	ht.insert (std::make_pair ((size_t)(const char *)at->name, at));	791	ht.insert (std::make_pair ((size_t) (const char *) at->name, at));
772	#endif	792	#endif
773		793
774	int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;	794	int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;
775		795
776	for (;;)	796	for (;;)
…		…
795	*/	815	*/
796		816
797	archetype *	817	archetype *
798	type_to_archetype (int type)	818	type_to_archetype (int type)
799	{	819	{
800	archetype *	820	archetype *at;
801	at;
802		821
803	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)	822	for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
804	if (at->clone.type == type)	823	if (at->clone.type == type)
805	return at;	824	return at;
		825
806	return NULL;	826	return 0;
807	}	827	}
808		828
809	/*	829	/*
810	* Returns a new object copied from the first archetype matching	830	* Returns a new object copied from the first archetype matching
811	* the given type.	831	* the given type.
…		…
813	*/	833	*/
814		834
815	object *	835	object *
816	clone_arch (int type)	836	clone_arch (int type)
817	{	837	{
818	archetype *	838	archetype *at;
819	at;
820	object *
821	op = get_object ();	839	object *op = get_object ();
822		840
823	if ((at = type_to_archetype (type)) == NULL)	841	if ((at = type_to_archetype (type)) == NULL)
824	{	842	{
825	LOG (llevError, "Can't clone archetype %d\n", type);	843	LOG (llevError, "Can't clone archetype %d\n", type);
826	free_object (op);	844	free_object (op);
827	return NULL;	845	return NULL;
828	}	846	}
		847
829	copy_object (&at->clone, op);	848	copy_object (&at->clone, op);
830	op->instantiate ();	849	op->instantiate ();
831	return op;	850	return op;
832	}	851	}
833		852
834	/*	853	/*
835	* member: make instance from class	854	* member: make instance from class
836	*/	855	*/
837		856
838	object *	857	object *
839	object_create_arch (archetype * at)	858	object_create_arch (archetype *at)
840	{	859	{
841	object *	860	object op, prev = 0, *head = 0;
842	op, *
843	prev = NULL, *head = NULL;
844		861
845	while (at)	862	while (at)
846	{	863	{
847	op = arch_to_object (at);	864	op = arch_to_object (at);
848	op->x = at->clone.x;	865	op->x = at->clone.x;
849	op->y = at->clone.y;	866	op->y = at->clone.y;
		867
850	if (head)	868	if (head)
851	op->head = head, prev->more = op;	869	op->head = head, prev->more = op;
		870
852	if (!head)	871	if (!head)
853	head = op;	872	head = op;
		873
854	prev = op;	874	prev = op;
855	at = at->more;	875	at = at->more;
856	}	876	}
		877
857	return (head);	878	return (head);
858	}	879	}
859		880
860	/* end of arch.c */

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.14 by root, Fri Sep 8 17:14:07 2006 UTC vs. Revision 1.21 by root, Thu Sep 14 22:33:58 2006 UTC

Diff Legend

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.14 by root, Fri Sep 8 17:14:07 2006 UTC vs.
Revision 1.21 by root, Thu Sep 14 22:33:58 2006 UTC