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