[ViewVC] Diff of: cvs/cf.schmorp.de/server/common/arch.C

Comparing cf.schmorp.de/server/common/arch.C (file contents):
Revision 1.14 by root, Fri Sep 8 17:14:07 2006 UTC vs.
Revision 1.35 by root, Wed Jan 3 20:32:13 2007 UTC

…		…
1	/*
2	* static char *rcsid_arch_c =
3	* "$Id: arch.C,v 1.14 2006/09/08 17:14:07 root Exp $";
4	*/
5
6	/*	1	/*
7	CrossFire, A Multiplayer game for X-windows	2	CrossFire, A Multiplayer game for X-windows
8		3
9	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	4	Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10	Copyright (C) 1992 Frank Tore Johansen	5	Copyright (C) 1992 Frank Tore Johansen
21		16
22	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
23	along with this program; if not, write to the Free Software	18	along with this program; if not, write to the Free Software
24	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25		20
26	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>
27	*/	22	*/
28		23
29	#include <cassert>	24	#include <cassert>
30		25
31	#include <tr1/unordered_map>
32
33	#include <global.h>	26	#include <global.h>
34	#include <arch.h>
35	#include <funcpoint.h>	27	#include <funcpoint.h>
36	#include <loader.h>	28	#include <loader.h>
37		29
38	/* IF set, does a little timing on the archetype load. */	30	#define USE_UNORDERED_MAP 0
39	#define TIME_ARCH_LOAD 0
40		31
41	static void add_arch (archetype * at);	32	#if USE_UNORDERED_MAP
		33	# include <tr1/functional>
		34	# include <tr1/unordered_map>
		35	#endif
42		36
43	static archetype *arch_table[ARCHTABLE];
44	int arch_cmp = 0; /* How many strcmp's */	37	int arch_cmp = 0; /* How many strcmp's */
45	int arch_search = 0; /* How many searches */	38	int arch_search = 0; /* How many searches */
46	int arch_init; /* True if doing arch initialization */	39	int arch_init; /* True if doing arch initialization */
47		40
48	/* The naming of these functions is really poor - they are all	41	/* The naming of these functions is really poor - they are all
…		…
53	* MSW 2003-04-29	46	* MSW 2003-04-29
54	*/	47	*/
55		48
56	#if USE_UNORDERED_MAP	49	#if USE_UNORDERED_MAP
57	// the hashtable	50	// the hashtable
58	typedef std::tr1::unordered_map<size_t, archetype *> HT;	51	typedef std::tr1::unordered_map
		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,
		59	> HT;
59		60
60	static HT ht;	61	static HT ht;
		62	#else
		63	static arch_ptr arch_table[ARCHTABLE];
61	#endif	64	#endif
62		65
63	/**	66	/**
64	* GROS - This function retrieves an archetype given the name that appears	67	* GROS - This function retrieves an archetype given the name that appears
65	* during the game (for example, "writing pen" instead of "stylus").	68	* during the game (for example, "writing pen" instead of "stylus").
…		…
115	* If type is -1, ew don't match on type.	118	* If type is -1, ew don't match on type.
116	*/	119	*/
117	object *	120	object *
118	get_archetype_by_skill_name (const char *skill, int type)	121	get_archetype_by_skill_name (const char *skill, int type)
119	{	122	{
120	archetype *	123	archetype *at;
121	at;
122		124
123	if (skill == NULL)	125	if (skill)
124	return NULL;
125
126	for (at = first_archetype; at != NULL; at = at->next)	126	for (at = first_archetype; at; at = at->next)
127	{
128	if (((type == -1) \|\| (type == at->clone.type)) && (!strcmp (at->clone.skill, skill)))	127	if (((type == -1) \|\| (type == at->clone.type)) && (!strcmp (at->clone.skill, skill)))
129	return arch_to_object (at);	128	return arch_to_object (at);
130	}	129
131	return NULL;	130	return 0;
132	}	131	}
133		132
134	/* similiar to above - this returns the first archetype	133	/* similiar to above - this returns the first archetype
135	* that matches both the type and subtype. type and subtype	134	* that matches both the type and subtype. type and subtype
136	* can be -1 to say ignore, but in this case, the match it does	135	* can be -1 to say ignore, but in this case, the match it does
…		…
165	* but it otherwise had a big memory leak.	164	* but it otherwise had a big memory leak.
166	*/	165	*/
167	object *	166	object *
168	get_archetype_by_object_name (const char *name)	167	get_archetype_by_object_name (const char *name)
169	{	168	{
170	archetype *	169	archetype *at;
171	at;
172	char
173	tmpname[MAX_BUF];	170	char tmpname[MAX_BUF];
174	int	171	int i;
175	i;
176		172
177	strncpy (tmpname, name, MAX_BUF - 1);	173	assign (tmpname, name);
178	tmpname[MAX_BUF - 1] = 0;	174
179	for (i = strlen (tmpname); i > 0; i--)	175	for (i = strlen (tmpname); i > 0; i--)
180	{	176	{
181	tmpname[i] = 0;	177	tmpname[i] = 0;
182	at = find_archetype_by_object_name (tmpname);	178	at = find_archetype_by_object_name (tmpname);
		179
183	if (at != NULL)	180	if (at)
184	{
185	return arch_to_object (at);	181	return arch_to_object (at);
186	}
187	}	182	}
		183
188	return create_singularity (name);	184	return create_singularity (name);
189	}	185	}
190		186
191	/* This is a subset of the parse_id command. Basically, name can be	187	/* This is a subset of the parse_id command. Basically, name can be
192	* a string seperated lists of things to match, with certain keywords.	188	* a string seperated lists of things to match, with certain keywords.
…		…
204	* If count is 1, make a quick check on the name.	200	* If count is 1, make a quick check on the name.
205	* IF count is >1, we need to make plural name. Return if match.	201	* IF count is >1, we need to make plural name. Return if match.
206	* Last, make a check on the full name.	202	* Last, make a check on the full name.
207	*/	203	*/
208	int	204	int
209	item_matched_string (object * pl, object * op, const char *name)	205	item_matched_string (object pl, object op, const char *name)
210	{	206	{
211	char *
212	cp,
213	local_name[MAX_BUF];	207	char *cp, local_name[MAX_BUF];
214	int	208	int count, retval = 0;
215	count,	209
216	retval = 0;
217	strcpy (local_name, name); /* strtok is destructive to name */	210	strcpy (local_name, name); /* strtok is destructive to name */
218		211
219	for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))	212	for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
220	{	213	{
221	while (cp[0] == ' ')	214	while (cp[0] == ' ')
…		…
272	retval = 15;	265	retval = 15;
273	else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))	266	else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))
274	retval = 14;	267	retval = 14;
275	else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))	268	else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))
276	retval = 14;	269	retval = 14;
277
278	/* Do substring checks, so things like 'Str+1' will match.	270	/* Do substring checks, so things like 'Str+1' will match.
279	* retval of these should perhaps be lower - they are lower	271	* retval of these should perhaps be lower - they are lower
280	* then the specific strcasecmp aboves, but still higher than	272	* then the specific strcasecmp aboves, but still higher than
281	* some other match criteria.	273	* some other match criteria.
282	*/	274	*/
…		…
284	retval = 12;	276	retval = 12;
285	else if (strstr (query_base_name (op, 0), cp))	277	else if (strstr (query_base_name (op, 0), cp))
286	retval = 12;	278	retval = 12;
287	else if (strstr (query_short_name (op), cp))	279	else if (strstr (query_short_name (op), cp))
288	retval = 12;	280	retval = 12;
289
290	/* Check against plural/non plural based on count. */	281	/* Check against plural/non plural based on count. */
291	else if (count > 1 && !strcasecmp (cp, op->name_pl))	282	else if (count > 1 && !strcasecmp (cp, op->name_pl))
292	{
293	retval = 6;	283	retval = 6;
294	}
295	else if (count == 1 && !strcasecmp (op->name, cp))	284	else if (count == 1 && !strcasecmp (op->name, cp))
296	{
297	retval = 6;	285	retval = 6;
298	}
299	/* base name matched - not bad */	286	/* base name matched - not bad */
300	else if (strcasecmp (cp, op->name) == 0 && !count)	287	else if (strcasecmp (cp, op->name) == 0 && !count)
301	retval = 4;	288	retval = 4;
302	/* Check for partial custom name, but give a real low priority */	289	/* Check for partial custom name, but give a real low priority */
303	else if (op->custom_name && strstr (op->custom_name, cp))	290	else if (op->custom_name && strstr (op->custom_name, cp))
…		…
305		292
306	if (retval)	293	if (retval)
307	{	294	{
308	if (pl->type == PLAYER)	295	if (pl->type == PLAYER)
309	pl->contr->count = count;	296	pl->contr->count = count;
		297
310	return retval;	298	return retval;
311	}	299	}
312	}	300	}
		301
313	return 0;	302	return 0;
314	}	303	}
315		304
316	/*	305	/*
317	* Initialises the internal linked list of archetypes (read from file).	306	* Initialises the internal linked list of archetypes (read from file).
…		…
322	void	311	void
323	init_archetypes (void)	312	init_archetypes (void)
324	{ /* called from add_player() and edit() */	313	{ /* called from add_player() and edit() */
325	if (first_archetype != NULL) /* Only do this once */	314	if (first_archetype != NULL) /* Only do this once */
326	return;	315	return;
		316
327	arch_init = 1;	317	arch_init = 1;
328	load_archetypes ();	318	load_archetypes ();
329	arch_init = 0;	319	arch_init = 0;
330	empty_archetype = find_archetype ("empty_archetype");	320	empty_archetype = archetype::find ("empty_archetype");
		321
331	/* init_blocksview();*/	322	/* init_blocksview();*/
332	}	323	}
333		324
334	/*	325	/*
335	* Stores debug-information about how efficient the hashtable	326	* Stores debug-information about how efficient the hashtable
336	* used for archetypes has been in the static errmsg array.	327	* used for archetypes has been in the static errmsg array.
337	*/	328	*/
338		329
339	void	330	void
340	arch_info (object * op)	331	arch_info (object *op)
341	{	332	{
342	sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp);	333	sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp);
343	new_draw_info (NDI_BLACK, 0, op, errmsg);	334	new_draw_info (NDI_BLACK, 0, op, errmsg);
344	}	335	}
345		336
…		…
363	archetype *at;	354	archetype *at;
364		355
365	LOG (llevDebug, " Setting up archetable...\n");	356	LOG (llevDebug, " Setting up archetable...\n");
366		357
367	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)	358	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
368	add_arch (at);	359	at->hash_add ();
369		360
370	LOG (llevDebug, "done\n");	361	LOG (llevDebug, "done\n");
371	}	362	}
372		363
373	/*
374	* Dumps an archetype to debug-level output.
375	*/
376
377	void
378	dump_arch (archetype * at)
379	{
380	dump_object (&at->clone);
381	}
382
383	/*
384	* Dumps _all_ archetypes to debug-level output.
385	* If you run crossfire with debug, and enter DM-mode, you can trigger
386	* this with the O key.
387	*/
388
389	void
390	dump_all_archetypes (void)
391	{
392	archetype *
393	at;
394	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
395	{
396	dump_arch (at);
397	fprintf (logfile, "%s\n", errmsg);
398	}
399	}
400
401	void	364	void
402	free_all_archs (void)	365	free_all_archs (void)
403	{	366	{
404	archetype *	367	archetype at, next;
405	at, *
406	next;
407	int
408	i = 0, f = 0;	368	int i = 0, f = 0;
409		369
410	for (at = first_archetype; at != NULL; at = next)	370	for (at = first_archetype; at != NULL; at = next)
411	{	371	{
412	if (at->more)	372	if (at->more)
413	next = at->more;	373	next = at->more;
414	else	374	else
415	next = at->next;	375	next = at->next;
416		376
417	delete	377	delete
418	at;	378	at;
		379
419	i++;	380	i++;
420	}	381	}
		382
421	LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);	383	LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
422	}	384	}
423		385
424	archetype::archetype ()	386	archetype::archetype ()
425	{	387	{
426	clear_object (&clone); /* to initial state other also */
427	CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */	388	CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_to */
428	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */	389	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
429	}	390	}
430		391
431	archetype::~archetype ()	392	archetype::~archetype ()
432	{	393	{
433	}	394	}
…		…
437	* of archetype-structures.	398	* of archetype-structures.
438	*/	399	*/
439	void	400	void
440	first_arch_pass (object_thawer & fp)	401	first_arch_pass (object_thawer & fp)
441	{	402	{
442	archetype at, head = NULL, *last_more = NULL;	403	archetype head = 0, last_more = 0;
443		404
		405	archetype *at = new archetype;
444	at->clone.arch = first_archetype = at = new archetype;	406	at->clone.arch = first_archetype = at;
445		407
446	while (int i = load_object (fp, &at->clone, 0))	408	while (int i = load_object (fp, &at->clone, 0))
447	{	409	{
448	at->clone.speed_left = (float) (-0.1);	410	at->clone.speed_left = (float) (-0.1);
449	/* copy the body_info to the body_used - this is only really	411	/* copy the body_info to the body_used - this is only really
…		…
454	*/	416	*/
455	memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));	417	memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));
456		418
457	switch (i)	419	switch (i)
458	{	420	{
459	case LL_NORMAL: /* A new archetype, just link it with the previous */	421	case LL_NORMAL: /* A new archetype, just link it with the previous */
460	if (last_more != NULL)	422	if (last_more != NULL)
461	last_more->next = at;	423	last_more->next = at;
462	if (head != NULL)	424	if (head != NULL)
463	head->next = at;	425	head->next = at;
464	head = last_more = at;	426	head = last_more = at;
465	#if 0	427	#if 0
466	if (!op->type)	428	if (!op->type)
467	LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);	429	LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);
468	#endif	430	#endif
469	at->tail_x = 0;	431	at->tail_x = 0;
470	at->tail_y = 0;	432	at->tail_y = 0;
471	break;	433	break;
472		434
473	case LL_MORE: /* Another part of the previous archetype, link it correctly */	435	case LL_MORE: /* Another part of the previous archetype, link it correctly */
474		436
475	at->head = head;	437	at->head = head;
476	at->clone.head = &head->clone;	438	at->clone.head = &head->clone;
477	if (last_more != NULL)	439	if (last_more != NULL)
478	{	440	{
479	last_more->more = at;	441	last_more->more = at;
480	last_more->clone.more = &at->clone;	442	last_more->clone.more = &at->clone;
481	}	443	}
482	last_more = at;	444	last_more = at;
483		445
484	/* If this multipart image is still composed of individual small	446	/* If this multipart image is still composed of individual small
485	* images, don't set the tail_.. values. We can't use them anyways,	447	* images, don't set the tail_.. values. We can't use them anyways,
486	* and setting these to zero makes the map sending to the client much	448	* and setting these to zero makes the map sending to the client much
487	* easier as just looking at the head, we know what to do.	449	* easier as just looking at the head, we know what to do.
488	*/	450	*/
489	if (at->clone.face != head->clone.face)	451	if (at->clone.face != head->clone.face)
490	{	452	{
491	head->tail_x = 0;	453	head->tail_x = 0;
492	head->tail_y = 0;	454	head->tail_y = 0;
493	}	455	}
494	else	456	else
495	{	457	{
496	if (at->clone.x > head->tail_x)	458	if (at->clone.x > head->tail_x)
497	head->tail_x = at->clone.x;	459	head->tail_x = at->clone.x;
498	if (at->clone.y > head->tail_y)	460	if (at->clone.y > head->tail_y)
499	head->tail_y = at->clone.y;	461	head->tail_y = at->clone.y;
500	}	462	}
501	break;	463	break;
502		464
503	}	465	}
504		466
505	at = new archetype;	467	at = new archetype;
		468
506	at->clone.arch = at;	469	at->clone.arch = at;
507	}	470	}
508		471
509	delete at;	472	delete at;
510	}	473	}
…		…
534	cp--;	497	cp--;
535	}	498	}
536	}	499	}
537	if (!strcmp ("Object", variable))	500	if (!strcmp ("Object", variable))
538	{	501	{
539	if ((at = find_archetype (argument)) == NULL)	502	if ((at = archetype::find (argument)) == NULL)
540	LOG (llevError, "Warning: failed to find arch %s\n", argument);	503	LOG (llevError, "Warning: failed to find arch %s\n", argument);
541	}	504	}
542	else if (!strcmp ("other_arch", variable))	505	else if (!strcmp ("other_arch", variable))
543	{	506	{
544	if (at != NULL && at->clone.other_arch == NULL)	507	if (at != NULL && at->clone.other_arch == NULL)
545	{	508	{
546	if ((other = find_archetype (argument)) == NULL)	509	if ((other = archetype::find (argument)) == NULL)
547	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);	510	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
548	else if (at != NULL)	511	else if (at != NULL)
549	at->clone.other_arch = other;	512	at->clone.other_arch = other;
550	}	513	}
551	}	514	}
552	else if (!strcmp ("randomitems", variable))	515	else if (!strcmp ("randomitems", variable))
553	{	516	{
554	if (at != NULL)	517	if (at != NULL)
555	{	518	{
556	treasurelist *
557	tl = find_treasurelist (argument);	519	treasurelist *tl = find_treasurelist (argument);
		520
558	if (tl == NULL)	521	if (tl == NULL)
559	LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);	522	LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
560	else	523	else
561	at->clone.randomitems = tl;	524	at->clone.randomitems = tl;
562	}	525	}
…		…
566		529
567	#ifdef DEBUG	530	#ifdef DEBUG
568	void	531	void
569	check_generators (void)	532	check_generators (void)
570	{	533	{
571	archetype *	534	archetype *at;
572	at;	535
573	for (at = first_archetype; at != NULL; at = at->next)	536	for (at = first_archetype; at != NULL; at = at->next)
574	if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)	537	if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)
575	LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);	538	LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
576	}	539	}
577	#endif	540	#endif
…		…
584	*/	547	*/
585		548
586	void	549	void
587	load_archetypes (void)	550	load_archetypes (void)
588	{	551	{
589	char
590	filename[MAX_BUF];	552	char filename[MAX_BUF];
591	#if TIME_ARCH_LOAD
592	struct timeval
593	tv1,
594	tv2;
595	#endif
596		553
597	sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);	554	sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
598	LOG (llevDebug, "Reading archetypes from %s:\n", filename);	555	LOG (llevDebug, "Reading archetypes from %s:\n", filename);
599		556
600	{	557	{
…		…
614	object_thawer	571	object_thawer
615	thawer (filename);	572	thawer (filename);
616		573
617	LOG (llevDebug, " loading treasure...\n");	574	LOG (llevDebug, " loading treasure...\n");
618	load_treasures ();	575	load_treasures ();
		576	LOG (llevDebug, " done\n");
619	LOG (llevDebug, " done\n arch-pass 2...\n");	577	LOG (llevDebug, " arch-pass 2...\n");
620	second_arch_pass (thawer);	578	second_arch_pass (thawer);
621	LOG (llevDebug, " done\n");	579	LOG (llevDebug, " done\n");
622	#ifdef DEBUG	580	#ifdef DEBUG
623	check_generators ();	581	check_generators ();
624	#endif	582	#endif
…		…
628		586
629	/*	587	/*
630	* Creates and returns a new object which is a copy of the given archetype.	588	* Creates and returns a new object which is a copy of the given archetype.
631	* This function returns NULL on failure.	589	* This function returns NULL on failure.
632	*/	590	*/
633
634	object *	591	object *
635	arch_to_object (archetype * at)	592	arch_to_object (archetype *at)
636	{	593	{
637	object *	594	object *op;
638	op;	595
639	if (at == NULL)	596	if (at == NULL)
640	{	597	{
641	if (warn_archetypes)	598	if (warn_archetypes)
642	LOG (llevError, "Couldn't find archetype.\n");	599	LOG (llevError, "Couldn't find archetype.\n");
		600
643	return NULL;	601	return NULL;
644	}	602	}
645	op = get_object ();	603
646	copy_object (&at->clone, op);	604	op = at->clone.clone ();
		605	op->arch = at;
647	op->instantiate ();	606	op->instantiate ();
648	op->arch = at;
649	return op;	607	return op;
650	}	608	}
651		609
652	/*	610	/*
653	* Creates an object. This function is called by get_archetype()	611	* Creates an object. This function is called by get_archetype()
654	* if it fails to find the appropriate archetype.	612	* if it fails to find the appropriate archetype.
655	* Thus get_archetype() will be guaranteed to always return	613	* Thus get_archetype() will be guaranteed to always return
656	* an object, and never NULL.	614	* an object, and never NULL.
657	*/	615	*/
658
659	object *	616	object *
660	create_singularity (const char *name)	617	create_singularity (const char *name)
661	{	618	{
662	object *op;	619	object *op;
663	char buf[MAX_BUF];	620	char buf[MAX_BUF];
		621
664	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);	622	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
665	op = get_object ();	623	op = object::create ();
666	op->name = op->name_pl = buf;	624	op->name = op->name_pl = buf;
667	SET_FLAG (op, FLAG_NO_PICK);	625	SET_FLAG (op, FLAG_NO_PICK);
668	return op;	626	return op;
669	}	627	}
670		628
671	/*	629	/*
672	* Finds which archetype matches the given name, and returns a new	630	* Finds which archetype matches the given name, and returns a new
673	* object containing a copy of the archetype.	631	* object containing a copy of the archetype.
674	*/	632	*/
675
676	object *	633	object *
677	get_archetype (const char *name)	634	get_archetype (const char *name)
678	{	635	{
679	archetype *at;	636	archetype *at = archetype::find (name);
680	at = find_archetype (name);	637
681	if (at == NULL)	638	if (!at)
682	return create_singularity (name);	639	return create_singularity (name);
		640
683	return arch_to_object (at);	641	return arch_to_object (at);
684	}	642	}
685		643
686	/*	644	/*
687	* Hash-function used by the arch-hashtable.	645	* Hash-function used by the arch-hashtable.
…		…
717	* Finds, using the hashtable, which archetype matches the given name.	675	* Finds, using the hashtable, which archetype matches the given name.
718	* returns a pointer to the found archetype, otherwise NULL.	676	* returns a pointer to the found archetype, otherwise NULL.
719	*/	677	*/
720		678
721	archetype *	679	archetype *
722	find_archetype (const char *name)	680	archetype::find (const char *name)
723	{	681	{
724	#if USE_UNORDERED_MAP
725	name = shstr::find (name);
726
727	if (!name)	682	if (!name)
728	return 0;	683	return 0;
729		684
730	HT::const_iterator i = ht.find ((size_t)name);	685	#if USE_UNORDERED_MAP
		686	AUTODECL (i, ht.find ((size_t) name));
731		687
732	if (i == ht.end ())	688	if (i == ht.end ())
733	return 0;	689	return 0;
734	else	690	else
735	return i->second;	691	return i->second;
736	#endif	692	#endif
737		693
738	archetype *at;	694	archetype *at;
739	unsigned long index;	695	unsigned long index;
740		696
741	if (name == NULL)
742	return (archetype *) NULL;
743
744	index = hasharch (name, ARCHTABLE);	697	index = hasharch (name, ARCHTABLE);
745	arch_search++;	698	arch_search++;
746	for (;;)	699	for (;;)
747	{	700	{
748	at = arch_table[index];	701	at = arch_table[index];
		702
749	if (at == NULL)	703	if (at == NULL)
750	{	704	{
751	if (warn_archetypes)	705	if (warn_archetypes)
752	LOG (llevError, "Couldn't find archetype %s\n", name);	706	LOG (llevError, "Couldn't find archetype %s\n", name);
		707
753	return NULL;	708	return NULL;
754	}	709	}
		710
755	arch_cmp++;	711	arch_cmp++;
		712
756	if (!strcmp ((const char *) at->name, name))	713	if (!strcmp ((const char *) at->name, name))
757	return at;	714	return at;
		715
758	if (++index >= ARCHTABLE)	716	if (++index >= ARCHTABLE)
759	index = 0;	717	index = 0;
760	}	718	}
761	}	719	}
762		720
763	/*	721	/*
764	* Adds an archetype to the hashtable.	722	* Adds an archetype to the hashtable.
765	*/	723	*/
766		724	void
767	static void	725	archetype::hash_add ()
768	add_arch (archetype *at)
769	{	726	{
770	#if USE_UNORDERED_MAP	727	#if USE_UNORDERED_MAP
771	ht.insert (std::make_pair ((size_t)(const char *)at->name, at));	728	ht.insert (std::make_pair ((size_t) (const char *) name, this));
772	#endif	729	#else
773		730
774	int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;	731	int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
775		732
776	for (;;)	733	for (;;)
777	{	734	{
778	if (arch_table[index] == NULL)	735	if (!arch_table[index])
779	{	736	{
780	arch_table[index] = at;	737	arch_table[index] = this;
781	return;	738	break;
782	}	739	}
783		740
784	if (++index == ARCHTABLE)	741	if (++index == ARCHTABLE)
785	index = 0;	742	index = 0;
786		743
787	if (index == org_index)	744	if (index == org_index)
788	fatal (ARCHTABLE_TOO_SMALL);	745	fatal (ARCHTABLE_TOO_SMALL);
789	}	746	}
		747	#endif
		748	}
		749
		750	void
		751	archetype::hash_del ()
		752	{
		753	#if USE_UNORDERED_MAP
		754	# error remove this from HT
		755	#else
		756
		757	int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
		758
		759	for (;;)
		760	{
		761	if (arch_table[index] == this)
		762	{
		763	arch_table[index] = 0;
		764	break;
		765	}
		766
		767	if (++index == ARCHTABLE)
		768	index = 0;
		769
		770	if (index == org_index)
		771	break;
		772	}
		773	#endif
790	}	774	}
791		775
792	/*	776	/*
793	* Returns the first archetype using the given type.	777	* Returns the first archetype using the given type.
794	* Used in treasure-generation.	778	* Used in treasure-generation.
795	*/	779	*/
796		780
797	archetype *	781	archetype *
798	type_to_archetype (int type)	782	type_to_archetype (int type)
799	{	783	{
800	archetype *	784	archetype *at;
801	at;
802		785
803	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)	786	for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
804	if (at->clone.type == type)	787	if (at->clone.type == type)
805	return at;	788	return at;
		789
806	return NULL;	790	return 0;
807	}	791	}
808		792
809	/*	793	/*
810	* Returns a new object copied from the first archetype matching	794	* Returns a new object copied from the first archetype matching
811	* the given type.	795	* the given type.
…		…
813	*/	797	*/
814		798
815	object *	799	object *
816	clone_arch (int type)	800	clone_arch (int type)
817	{	801	{
818	archetype *	802	archetype *at;
819	at;
820	object *
821	op = get_object ();
822		803
823	if ((at = type_to_archetype (type)) == NULL)	804	if ((at = type_to_archetype (type)) == NULL)
824	{	805	{
825	LOG (llevError, "Can't clone archetype %d\n", type);	806	LOG (llevError, "Can't clone archetype %d\n", type);
826	free_object (op);
827	return NULL;	807	return 0;
828	}	808	}
829	copy_object (&at->clone, op);	809
		810	object *op = at->clone.clone ();
830	op->instantiate ();	811	op->instantiate ();
831	return op;	812	return op;
832	}	813	}
833		814
834	/*	815	/*
835	* member: make instance from class	816	* member: make instance from class
836	*/	817	*/
837		818
838	object *	819	object *
839	object_create_arch (archetype * at)	820	object_create_arch (archetype *at)
840	{	821	{
841	object *	822	object op, prev = 0, *head = 0;
842	op, *
843	prev = NULL, *head = NULL;
844		823
845	while (at)	824	while (at)
846	{	825	{
847	op = arch_to_object (at);	826	op = arch_to_object (at);
848	op->x = at->clone.x;	827	op->x = at->clone.x;
849	op->y = at->clone.y;	828	op->y = at->clone.y;
		829
850	if (head)	830	if (head)
851	op->head = head, prev->more = op;	831	op->head = head, prev->more = op;
		832
852	if (!head)	833	if (!head)
853	head = op;	834	head = op;
		835
854	prev = op;	836	prev = op;
855	at = at->more;	837	at = at->more;
856	}	838	}
		839
857	return (head);	840	return (head);
858	}	841	}
859		842
860	/* end of arch.c */

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing cf.schmorp.de/server/common/arch.C (file contents): Revision 1.14 by root, Fri Sep 8 17:14:07 2006 UTC vs. Revision 1.35 by root, Wed Jan 3 20:32:13 2007 UTC

Diff Legend

Comparing cf.schmorp.de/server/common/arch.C (file contents):
Revision 1.14 by root, Fri Sep 8 17:14:07 2006 UTC vs.
Revision 1.35 by root, Wed Jan 3 20:32:13 2007 UTC