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

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

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.19 by root, Thu Sep 14 18:13:01 2006 UTC vs. Revision 1.33 by root, Sun Dec 31 17:17:22 2006 UTC

Diff Legend

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.19 by root, Thu Sep 14 18:13:01 2006 UTC vs.
Revision 1.33 by root, Sun Dec 31 17:17:22 2006 UTC