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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.15 by root, Sun Sep 10 13:20:12 2006 UTC vs.
Revision 1.35 by root, Wed Jan 3 20:32:13 2007 UTC

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

Diff Legend

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.15 by root, Sun Sep 10 13:20:12 2006 UTC vs.
Revision 1.35 by root, Wed Jan 3 20:32:13 2007 UTC