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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.16 by root, Sun Sep 10 16:00:23 2006 UTC vs.
Revision 1.33 by root, Sun Dec 31 17:17:22 2006 UTC

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

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.16 by root, Sun Sep 10 16:00:23 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.16 by root, Sun Sep 10 16:00:23 2006 UTC vs.
Revision 1.33 by root, Sun Dec 31 17:17:22 2006 UTC