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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.17 by root, Tue Sep 12 19:20:06 2006 UTC vs.
Revision 1.34 by pippijn, Wed Jan 3 00:10:04 2007 UTC

…		…
16		16
17	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
18	along with this program; if not, write to the Free Software	18	along with this program; if not, write to the Free Software
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20		20
21	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>
22	*/	22	*/
23		23
24	#include <cassert>	24	#include <cassert>
25		25
26	#include <tr1/unordered_map>
27
28	#include <global.h>	26	#include <global.h>
29	#include <arch.h>
30	#include <funcpoint.h>	27	#include <funcpoint.h>
31	#include <loader.h>	28	#include <loader.h>
32		29
33	/* IF set, does a little timing on the archetype load. */	30	#define USE_UNORDERED_MAP 0
34	#define TIME_ARCH_LOAD 0
35		31
36	static void add_arch (archetype *at);	32	#if USE_UNORDERED_MAP
		33	# include <tr1/functional>
		34	# include <tr1/unordered_map>
		35	#endif
37		36
38	static archetype *arch_table[ARCHTABLE];
39	int arch_cmp = 0; /* How many strcmp's */	37	int arch_cmp = 0; /* How many strcmp's */
40	int arch_search = 0; /* How many searches */	38	int arch_search = 0; /* How many searches */
41	int arch_init; /* True if doing arch initialization */	39	int arch_init; /* True if doing arch initialization */
42		40
43	/* The naming of these functions is really poor - they are all	41	/* The naming of these functions is really poor - they are all
…		…
48	* MSW 2003-04-29	46	* MSW 2003-04-29
49	*/	47	*/
50		48
51	#if USE_UNORDERED_MAP	49	#if USE_UNORDERED_MAP
52	// the hashtable	50	// the hashtable
53	typedef
54	std::tr1::unordered_map <	51	typedef std::tr1::unordered_map
55	size_t, archetype *>	52	<
		53	std::size_t,
		54	arch_ptr,
		55	std::tr1::hash<size_t>,
		56	std::equal_to<size_t>,
		57	slice_allocator< std::pair<const std::size_t, archetype *> >
		58	true,
56	HT;	59	> HT;
57		60
58	static	61	static HT ht;
59	HT	62	#else
60	ht;	63	static arch_ptr arch_table[ARCHTABLE];
61	#endif	64	#endif
62		65
63	/**	66	/**
64	* GROS - This function retrieves an archetype given the name that appears	67	* GROS - This function retrieves an archetype given the name that appears
65	* during the game (for example, "writing pen" instead of "stylus").	68	* during the game (for example, "writing pen" instead of "stylus").
…		…
72	* - the archetype found or null if nothing was found.	75	* - the archetype found or null if nothing was found.
73	*/	76	*/
74	archetype *	77	archetype *
75	find_archetype_by_object_name (const char *name)	78	find_archetype_by_object_name (const char *name)
76	{	79	{
77	archetype *	80	archetype *at;
78	at;
79		81
80	if (name == NULL)	82	if (name == NULL)
81	return (archetype *) NULL;	83	return (archetype *) NULL;
82		84
83	for (at = first_archetype; at != NULL; at = at->next)	85	for (at = first_archetype; at != NULL; at = at->next)
…		…
94	* except that it considers only items of the given type.	96	* except that it considers only items of the given type.
95	*/	97	*/
96	archetype *	98	archetype *
97	find_archetype_by_object_type_name (int type, const char *name)	99	find_archetype_by_object_type_name (int type, const char *name)
98	{	100	{
99	archetype *	101	archetype *at;
100	at;
101		102
102	if (name == NULL)	103	if (name == NULL)
103	return NULL;	104	return NULL;
104		105
105	for (at = first_archetype; at != NULL; at = at->next)	106	for (at = first_archetype; at != NULL; at = at->next)
…		…
179	{	180	{
180	tmpname[i] = 0;	181	tmpname[i] = 0;
181	at = find_archetype_by_object_name (tmpname);	182	at = find_archetype_by_object_name (tmpname);
182		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	}
188		187
189	return create_singularity (name);	188	return create_singularity (name);
190	}	189	}
191		190
…		…
207	* Last, make a check on the full name.	206	* Last, make a check on the full name.
208	*/	207	*/
209	int	208	int
210	item_matched_string (object pl, object op, const char *name)	209	item_matched_string (object pl, object op, const char *name)
211	{	210	{
212	char *
213	cp,
214	local_name[MAX_BUF];	211	char *cp, local_name[MAX_BUF];
215	int	212	int count, retval = 0;
216	count,
217	retval = 0;
218		213
219	strcpy (local_name, name); /* strtok is destructive to name */	214	strcpy (local_name, name); /* strtok is destructive to name */
220		215
221	for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))	216	for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
222	{	217	{
…		…
274	retval = 15;	269	retval = 15;
275	else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))	270	else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))
276	retval = 14;	271	retval = 14;
277	else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))	272	else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))
278	retval = 14;	273	retval = 14;
279
280	/* Do substring checks, so things like 'Str+1' will match.	274	/* Do substring checks, so things like 'Str+1' will match.
281	* retval of these should perhaps be lower - they are lower	275	* retval of these should perhaps be lower - they are lower
282	* then the specific strcasecmp aboves, but still higher than	276	* then the specific strcasecmp aboves, but still higher than
283	* some other match criteria.	277	* some other match criteria.
284	*/	278	*/
…		…
286	retval = 12;	280	retval = 12;
287	else if (strstr (query_base_name (op, 0), cp))	281	else if (strstr (query_base_name (op, 0), cp))
288	retval = 12;	282	retval = 12;
289	else if (strstr (query_short_name (op), cp))	283	else if (strstr (query_short_name (op), cp))
290	retval = 12;	284	retval = 12;
291
292	/* Check against plural/non plural based on count. */	285	/* Check against plural/non plural based on count. */
293	else if (count > 1 && !strcasecmp (cp, op->name_pl))	286	else if (count > 1 && !strcasecmp (cp, op->name_pl))
294	{
295	retval = 6;	287	retval = 6;
296	}
297	else if (count == 1 && !strcasecmp (op->name, cp))	288	else if (count == 1 && !strcasecmp (op->name, cp))
298	{
299	retval = 6;	289	retval = 6;
300	}
301	/* base name matched - not bad */	290	/* base name matched - not bad */
302	else if (strcasecmp (cp, op->name) == 0 && !count)	291	else if (strcasecmp (cp, op->name) == 0 && !count)
303	retval = 4;	292	retval = 4;
304	/* Check for partial custom name, but give a real low priority */	293	/* Check for partial custom name, but give a real low priority */
305	else if (op->custom_name && strstr (op->custom_name, cp))	294	else if (op->custom_name && strstr (op->custom_name, cp))
…		…
307		296
308	if (retval)	297	if (retval)
309	{	298	{
310	if (pl->type == PLAYER)	299	if (pl->type == PLAYER)
311	pl->contr->count = count;	300	pl->contr->count = count;
		301
312	return retval;	302	return retval;
313	}	303	}
314	}	304	}
		305
315	return 0;	306	return 0;
316	}	307	}
317		308
318	/*	309	/*
319	* Initialises the internal linked list of archetypes (read from file).	310	* Initialises the internal linked list of archetypes (read from file).
…		…
324	void	315	void
325	init_archetypes (void)	316	init_archetypes (void)
326	{ /* called from add_player() and edit() */	317	{ /* called from add_player() and edit() */
327	if (first_archetype != NULL) /* Only do this once */	318	if (first_archetype != NULL) /* Only do this once */
328	return;	319	return;
		320
329	arch_init = 1;	321	arch_init = 1;
330	load_archetypes ();	322	load_archetypes ();
331	arch_init = 0;	323	arch_init = 0;
332	empty_archetype = find_archetype ("empty_archetype");	324	empty_archetype = archetype::find ("empty_archetype");
333		325
334	/* init_blocksview();*/	326	/* init_blocksview();*/
335	}	327	}
336		328
337	/*	329	/*
…		…
361	*/	353	*/
362		354
363	void	355	void
364	init_archetable (void)	356	init_archetable (void)
365	{	357	{
366	archetype *	358	archetype *at;
367	at;
368		359
369	LOG (llevDebug, " Setting up archetable...\n");	360	LOG (llevDebug, " Setting up archetable...\n");
370		361
371	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)	362	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
372	add_arch (at);	363	at->hash_add ();
373		364
374	LOG (llevDebug, "done\n");	365	LOG (llevDebug, "done\n");
375	}	366	}
376		367
377	/*
378	* Dumps an archetype to debug-level output.
379	*/
380
381	void
382	dump_arch (archetype *at)
383	{
384	dump_object (&at->clone);
385	}
386
387	/*
388	* Dumps _all_ archetypes to debug-level output.
389	* If you run crossfire with debug, and enter DM-mode, you can trigger
390	* this with the O key.
391	*/
392
393	void
394	dump_all_archetypes (void)
395	{
396	archetype *
397	at;
398
399	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
400	{
401	dump_arch (at);
402	fprintf (logfile, "%s\n", errmsg);
403	}
404	}
405
406	void	368	void
407	free_all_archs (void)	369	free_all_archs (void)
408	{	370	{
409	archetype *	371	archetype at, next;
410	at, *
411	next;
412	int
413	i = 0, f = 0;	372	int i = 0, f = 0;
414		373
415	for (at = first_archetype; at != NULL; at = next)	374	for (at = first_archetype; at != NULL; at = next)
416	{	375	{
417	if (at->more)	376	if (at->more)
418	next = at->more;	377	next = at->more;
…		…
422	delete	381	delete
423	at;	382	at;
424		383
425	i++;	384	i++;
426	}	385	}
		386
427	LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);	387	LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
428	}	388	}
429		389
430	archetype::archetype ()	390	archetype::archetype ()
431	{	391	{
432	clear_object (&clone); /* to initial state other also */
433	CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */	392	CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_to */
434	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */	393	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
435	}	394	}
436		395
437	archetype::~archetype ()	396	archetype::~archetype ()
438	{	397	{
…		…
443	* of archetype-structures.	402	* of archetype-structures.
444	*/	403	*/
445	void	404	void
446	first_arch_pass (object_thawer & fp)	405	first_arch_pass (object_thawer & fp)
447	{	406	{
448	archetype *	407	archetype head = 0, last_more = 0;
449	at, *
450	head = NULL, *last_more = NULL;
451		408
		409	archetype *at = new archetype;
452	at->clone.arch = first_archetype = at = new archetype;	410	at->clone.arch = first_archetype = at;
453		411
454	while (int i = load_object (fp, &at->clone, 0))	412	while (int i = load_object (fp, &at->clone, 0))
455	{	413	{
456	at->clone.speed_left = (float) (-0.1);	414	at->clone.speed_left = (float) (-0.1);
457	/* copy the body_info to the body_used - this is only really	415	/* copy the body_info to the body_used - this is only really
…		…
524	*/	482	*/
525		483
526	void	484	void
527	second_arch_pass (object_thawer & thawer)	485	second_arch_pass (object_thawer & thawer)
528	{	486	{
529	char
530	buf[MAX_BUF], *
531	variable = buf, argument, cp;	487	char buf[MAX_BUF], variable = buf, argument, *cp;
532	archetype *
533	at = NULL, *other;	488	archetype at = NULL, other;
534		489
535	while (fgets (buf, MAX_BUF, thawer) != NULL)	490	while (fgets (buf, MAX_BUF, thawer) != NULL)
536	{	491	{
537	if (*buf == '#')	492	if (*buf == '#')
538	continue;	493	continue;
…		…
546	cp--;	501	cp--;
547	}	502	}
548	}	503	}
549	if (!strcmp ("Object", variable))	504	if (!strcmp ("Object", variable))
550	{	505	{
551	if ((at = find_archetype (argument)) == NULL)	506	if ((at = archetype::find (argument)) == NULL)
552	LOG (llevError, "Warning: failed to find arch %s\n", argument);	507	LOG (llevError, "Warning: failed to find arch %s\n", argument);
553	}	508	}
554	else if (!strcmp ("other_arch", variable))	509	else if (!strcmp ("other_arch", variable))
555	{	510	{
556	if (at != NULL && at->clone.other_arch == NULL)	511	if (at != NULL && at->clone.other_arch == NULL)
557	{	512	{
558	if ((other = find_archetype (argument)) == NULL)	513	if ((other = archetype::find (argument)) == NULL)
559	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);	514	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
560	else if (at != NULL)	515	else if (at != NULL)
561	at->clone.other_arch = other;	516	at->clone.other_arch = other;
562	}	517	}
563	}	518	}
564	else if (!strcmp ("randomitems", variable))	519	else if (!strcmp ("randomitems", variable))
565	{	520	{
566	if (at != NULL)	521	if (at != NULL)
567	{	522	{
568	treasurelist *
569	tl = find_treasurelist (argument);	523	treasurelist *tl = find_treasurelist (argument);
570		524
571	if (tl == NULL)	525	if (tl == NULL)
572	LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);	526	LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
573	else	527	else
574	at->clone.randomitems = tl;	528	at->clone.randomitems = tl;
…		…
579		533
580	#ifdef DEBUG	534	#ifdef DEBUG
581	void	535	void
582	check_generators (void)	536	check_generators (void)
583	{	537	{
584	archetype *	538	archetype *at;
585	at;
586		539
587	for (at = first_archetype; at != NULL; at = at->next)	540	for (at = first_archetype; at != NULL; at = at->next)
588	if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)	541	if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)
589	LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);	542	LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
590	}	543	}
…		…
598	*/	551	*/
599		552
600	void	553	void
601	load_archetypes (void)	554	load_archetypes (void)
602	{	555	{
603	char
604	filename[MAX_BUF];	556	char filename[MAX_BUF];
605
606	#if TIME_ARCH_LOAD
607	struct timeval
608	tv1,
609	tv2;
610	#endif
611		557
612	sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);	558	sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
613	LOG (llevDebug, "Reading archetypes from %s:\n", filename);	559	LOG (llevDebug, "Reading archetypes from %s:\n", filename);
614		560
615	{	561	{
…		…
629	object_thawer	575	object_thawer
630	thawer (filename);	576	thawer (filename);
631		577
632	LOG (llevDebug, " loading treasure...\n");	578	LOG (llevDebug, " loading treasure...\n");
633	load_treasures ();	579	load_treasures ();
		580	LOG (llevDebug, " done\n");
634	LOG (llevDebug, " done\n arch-pass 2...\n");	581	LOG (llevDebug, " arch-pass 2...\n");
635	second_arch_pass (thawer);	582	second_arch_pass (thawer);
636	LOG (llevDebug, " done\n");	583	LOG (llevDebug, " done\n");
637	#ifdef DEBUG	584	#ifdef DEBUG
638	check_generators ();	585	check_generators ();
639	#endif	586	#endif
…		…
643		590
644	/*	591	/*
645	* Creates and returns a new object which is a copy of the given archetype.	592	* Creates and returns a new object which is a copy of the given archetype.
646	* This function returns NULL on failure.	593	* This function returns NULL on failure.
647	*/	594	*/
648
649	object *	595	object *
650	arch_to_object (archetype *at)	596	arch_to_object (archetype *at)
651	{	597	{
652	object *	598	object *op;
653	op;
654		599
655	if (at == NULL)	600	if (at == NULL)
656	{	601	{
657	if (warn_archetypes)	602	if (warn_archetypes)
658	LOG (llevError, "Couldn't find archetype.\n");	603	LOG (llevError, "Couldn't find archetype.\n");
659		604
660	return NULL;	605	return NULL;
661	}	606	}
662		607
663	op = get_object ();	608	op = at->clone.clone ();
664	copy_object (&at->clone, op);
665	op->arch = at;	609	op->arch = at;
666	op->instantiate ();	610	op->instantiate ();
667	return op;	611	return op;
668	}	612	}
669		613
…		…
671	* Creates an object. This function is called by get_archetype()	615	* Creates an object. This function is called by get_archetype()
672	* if it fails to find the appropriate archetype.	616	* if it fails to find the appropriate archetype.
673	* Thus get_archetype() will be guaranteed to always return	617	* Thus get_archetype() will be guaranteed to always return
674	* an object, and never NULL.	618	* an object, and never NULL.
675	*/	619	*/
676
677	object *	620	object *
678	create_singularity (const char *name)	621	create_singularity (const char *name)
679	{	622	{
680	object *	623	object *op;
681	op;
682	char
683	buf[MAX_BUF];	624	char buf[MAX_BUF];
684		625
685	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);	626	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
686	op = get_object ();	627	op = object::create ();
687	op->name = op->name_pl = buf;	628	op->name = op->name_pl = buf;
688	SET_FLAG (op, FLAG_NO_PICK);	629	SET_FLAG (op, FLAG_NO_PICK);
689	return op;	630	return op;
690	}	631	}
691		632
692	/*	633	/*
693	* Finds which archetype matches the given name, and returns a new	634	* Finds which archetype matches the given name, and returns a new
694	* object containing a copy of the archetype.	635	* object containing a copy of the archetype.
695	*/	636	*/
696
697	object *	637	object *
698	get_archetype (const char *name)	638	get_archetype (const char *name)
699	{	639	{
700	archetype *	640	archetype *at = archetype::find (name);
701	at;
702		641
703	at = find_archetype (name);	642	if (!at)
704	if (at == NULL)
705	return create_singularity (name);	643	return create_singularity (name);
706		644
707	return arch_to_object (at);	645	return arch_to_object (at);
708	}	646	}
709		647
…		…
712	*/	650	*/
713		651
714	unsigned long	652	unsigned long
715	hasharch (const char *str, int tablesize)	653	hasharch (const char *str, int tablesize)
716	{	654	{
717	unsigned long	655	unsigned long hash = 0;
718	hash = 0;
719	unsigned int	656	unsigned int i = 0;
720	i = 0;
721	const char *	657	const char *p;
722	p;
723		658
724	/* use the one-at-a-time hash function, which supposedly is	659	/* use the one-at-a-time hash function, which supposedly is
725	* better than the djb2-like one used by perl5.005, but	660	* better than the djb2-like one used by perl5.005, but
726	* certainly is better then the bug used here before.	661	* certainly is better then the bug used here before.
727	* see http://burtleburtle.net/bob/hash/doobs.html	662	* see http://burtleburtle.net/bob/hash/doobs.html
…		…
744	* Finds, using the hashtable, which archetype matches the given name.	679	* Finds, using the hashtable, which archetype matches the given name.
745	* returns a pointer to the found archetype, otherwise NULL.	680	* returns a pointer to the found archetype, otherwise NULL.
746	*/	681	*/
747		682
748	archetype *	683	archetype *
749	find_archetype (const char *name)	684	archetype::find (const char *name)
750	{	685	{
751	#if USE_UNORDERED_MAP
752	name = shstr::find (name);
753
754	if (!name)	686	if (!name)
755	return 0;	687	return 0;
756		688
757	HT::const_iterator i = ht.find ((size_t) name);	689	#if USE_UNORDERED_MAP
		690	AUTODECL (i, ht.find ((size_t) name));
758		691
759	if (i == ht.end ())	692	if (i == ht.end ())
760	return 0;	693	return 0;
761	else	694	else
762	return i->second;	695	return i->second;
763	#endif	696	#endif
764		697
765	archetype *	698	archetype *at;
766	at;
767	unsigned long	699	unsigned long index;
768	index;
769
770	if (name == NULL)
771	return (archetype *) NULL;
772		700
773	index = hasharch (name, ARCHTABLE);	701	index = hasharch (name, ARCHTABLE);
774	arch_search++;	702	arch_search++;
775	for (;;)	703	for (;;)
776	{	704	{
777	at = arch_table[index];	705	at = arch_table[index];
		706
778	if (at == NULL)	707	if (at == NULL)
779	{	708	{
780	if (warn_archetypes)	709	if (warn_archetypes)
781	LOG (llevError, "Couldn't find archetype %s\n", name);	710	LOG (llevError, "Couldn't find archetype %s\n", name);
		711
782	return NULL;	712	return NULL;
783	}	713	}
		714
784	arch_cmp++;	715	arch_cmp++;
		716
785	if (!strcmp ((const char *) at->name, name))	717	if (!strcmp ((const char *) at->name, name))
786	return at;	718	return at;
		719
787	if (++index >= ARCHTABLE)	720	if (++index >= ARCHTABLE)
788	index = 0;	721	index = 0;
789	}	722	}
790	}	723	}
791		724
792	/*	725	/*
793	* Adds an archetype to the hashtable.	726	* Adds an archetype to the hashtable.
794	*/	727	*/
795		728	void
796	static void	729	archetype::hash_add ()
797	add_arch (archetype *at)
798	{	730	{
799	#if USE_UNORDERED_MAP	731	#if USE_UNORDERED_MAP
800	ht.insert (std::make_pair ((size_t) (const char *) at->name, at));	732	ht.insert (std::make_pair ((size_t) (const char *) name, this));
801	#endif	733	#else
802		734
803	int
804	index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;	735	int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
805		736
806	for (;;)	737	for (;;)
807	{	738	{
808	if (arch_table[index] == NULL)	739	if (!arch_table[index])
809	{	740	{
810	arch_table[index] = at;	741	arch_table[index] = this;
811	return;	742	break;
812	}	743	}
813		744
814	if (++index == ARCHTABLE)	745	if (++index == ARCHTABLE)
815	index = 0;	746	index = 0;
816		747
817	if (index == org_index)	748	if (index == org_index)
818	fatal (ARCHTABLE_TOO_SMALL);	749	fatal (ARCHTABLE_TOO_SMALL);
819	}	750	}
		751	#endif
		752	}
		753
		754	void
		755	archetype::hash_del ()
		756	{
		757	#if USE_UNORDERED_MAP
		758	# error remove this from HT
		759	#else
		760
		761	int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
		762
		763	for (;;)
		764	{
		765	if (arch_table[index] == this)
		766	{
		767	arch_table[index] = 0;
		768	break;
		769	}
		770
		771	if (++index == ARCHTABLE)
		772	index = 0;
		773
		774	if (index == org_index)
		775	break;
		776	}
		777	#endif
820	}	778	}
821		779
822	/*	780	/*
823	* Returns the first archetype using the given type.	781	* Returns the first archetype using the given type.
824	* Used in treasure-generation.	782	* Used in treasure-generation.
825	*/	783	*/
826		784
827	archetype *	785	archetype *
828	type_to_archetype (int type)	786	type_to_archetype (int type)
829	{	787	{
830	archetype *	788	archetype *at;
831	at;
832		789
833	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)	790	for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
834	if (at->clone.type == type)	791	if (at->clone.type == type)
835	return at;	792	return at;
		793
836	return NULL;	794	return 0;
837	}	795	}
838		796
839	/*	797	/*
840	* Returns a new object copied from the first archetype matching	798	* Returns a new object copied from the first archetype matching
841	* the given type.	799	* the given type.
…		…
843	*/	801	*/
844		802
845	object *	803	object *
846	clone_arch (int type)	804	clone_arch (int type)
847	{	805	{
848	archetype *	806	archetype *at;
849	at;
850	object *
851	op = get_object ();
852		807
853	if ((at = type_to_archetype (type)) == NULL)	808	if ((at = type_to_archetype (type)) == NULL)
854	{	809	{
855	LOG (llevError, "Can't clone archetype %d\n", type);	810	LOG (llevError, "Can't clone archetype %d\n", type);
856	free_object (op);
857	return NULL;	811	return 0;
858	}	812	}
859	copy_object (&at->clone, op);	813
		814	object *op = at->clone.clone ();
860	op->instantiate ();	815	op->instantiate ();
861	return op;	816	return op;
862	}	817	}
863		818
864	/*	819	/*
…		…
866	*/	821	*/
867		822
868	object *	823	object *
869	object_create_arch (archetype *at)	824	object_create_arch (archetype *at)
870	{	825	{
871	object *	826	object op, prev = 0, *head = 0;
872	op, *
873	prev = NULL, *head = NULL;
874		827
875	while (at)	828	while (at)
876	{	829	{
877	op = arch_to_object (at);	830	op = arch_to_object (at);
878	op->x = at->clone.x;	831	op->x = at->clone.x;
879	op->y = at->clone.y;	832	op->y = at->clone.y;
		833
880	if (head)	834	if (head)
881	op->head = head, prev->more = op;	835	op->head = head, prev->more = op;
		836
882	if (!head)	837	if (!head)
883	head = op;	838	head = op;
		839
884	prev = op;	840	prev = op;
885	at = at->more;	841	at = at->more;
886	}	842	}
		843
887	return (head);	844	return (head);
888	}	845	}
889		846
890	/* end of arch.c */

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.17 by root, Tue Sep 12 19:20:06 2006 UTC vs. Revision 1.34 by pippijn, Wed Jan 3 00:10:04 2007 UTC

Diff Legend

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.17 by root, Tue Sep 12 19:20:06 2006 UTC vs.
Revision 1.34 by pippijn, Wed Jan 3 00:10:04 2007 UTC