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