[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.37 by pippijn, Mon Jan 15 21:06:18 2007 UTC

…		…
1
2	/*	1	/*
3	* static char *rcsid_arch_c =
4	* "$Id: arch.C,v 1.15 2006/09/10 13:20:12 root Exp $";
5	*/
6
7	/*
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
15	the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation; either version 2 of the License, or
16	(at your option) any later version.	11	* (at your option) any later version.
17		12	*
18	This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
19	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
20	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21	GNU General Public License for more details.	16	* GNU General Public License for more details.
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.37 by pippijn, Mon Jan 15 21:06:18 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.37 by pippijn, Mon Jan 15 21:06:18 2007 UTC