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