[ViewVC] Diff of: cvs/deliantra/server/common/arch.C

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.12 by root, Mon Sep 4 17:16:19 2006 UTC vs.
Revision 1.23 by root, Thu Sep 14 23:13:48 2006 UTC

…		…
1	/*
2	* static char *rcsid_arch_c =
3	* "$Id: arch.C,v 1.12 2006/09/04 17:16:19 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>	26	#include <tr1/unordered_map>
…		…
36	#include <loader.h>	31	#include <loader.h>
37		32
38	/* IF set, does a little timing on the archetype load. */	33	/* IF set, does a little timing on the archetype load. */
39	#define TIME_ARCH_LOAD 0	34	#define TIME_ARCH_LOAD 0
40		35
41	static void add_arch (archetype * at);	36	static void add_arch (archetype *at);
42		37
43	static archetype *arch_table[ARCHTABLE];	38	static archetype *arch_table[ARCHTABLE];
44	int arch_cmp = 0; /* How many strcmp's */	39	int arch_cmp = 0; /* How many strcmp's */
45	int arch_search = 0; /* How many searches */	40	int arch_search = 0; /* How many searches */
46	int arch_init; /* True if doing arch initialization */	41	int arch_init; /* True if doing arch initialization */
…		…
53	* MSW 2003-04-29	48	* MSW 2003-04-29
54	*/	49	*/
55		50
56	#if USE_UNORDERED_MAP	51	#if USE_UNORDERED_MAP
57	// the hashtable	52	// the hashtable
58	typedef std::tr1::unordered_map<size_t, archetype *> HT;	53	typedef std::tr1::unordered_map
		54	<
		55	std::size_t,
		56	archetype *,
		57	std::hash<size_t>,
		58	std::equal_to<size_t>,
		59	slice_allocator< std::pair<const std::size_t, archetype *> >
		60	true,
		61	> HT;
59		62
60	static HT ht;	63	static HT ht;
61	#endif	64	#endif
62		65
63	/**	66	/**
…		…
165	* but it otherwise had a big memory leak.	168	* but it otherwise had a big memory leak.
166	*/	169	*/
167	object *	170	object *
168	get_archetype_by_object_name (const char *name)	171	get_archetype_by_object_name (const char *name)
169	{	172	{
170	archetype *	173	archetype *at;
171	at;
172	char
173	tmpname[MAX_BUF];	174	char tmpname[MAX_BUF];
174	int	175	int i;
175	i;
176		176
177	strncpy (tmpname, name, MAX_BUF - 1);	177	assign (tmpname, name);
178	tmpname[MAX_BUF - 1] = 0;	178
179	for (i = strlen (tmpname); i > 0; i--)	179	for (i = strlen (tmpname); i > 0; i--)
180	{	180	{
181	tmpname[i] = 0;	181	tmpname[i] = 0;
182	at = find_archetype_by_object_name (tmpname);	182	at = find_archetype_by_object_name (tmpname);
		183
183	if (at != NULL)	184	if (at != NULL)
184	{
185	return arch_to_object (at);	185	return arch_to_object (at);
186	}
187	}	186	}
		187
188	return create_singularity (name);	188	return create_singularity (name);
189	}	189	}
190		190
191	/* 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
192	* a string seperated lists of things to match, with certain keywords.	192	* a string seperated lists of things to match, with certain keywords.
…		…
204	* If count is 1, make a quick check on the name.	204	* 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.	205	* IF count is >1, we need to make plural name. Return if match.
206	* Last, make a check on the full name.	206	* Last, make a check on the full name.
207	*/	207	*/
208	int	208	int
209	item_matched_string (object * pl, object * op, const char *name)	209	item_matched_string (object pl, object op, const char *name)
210	{	210	{
211	char *
212	cp,
213	local_name[MAX_BUF];	211	char *cp, local_name[MAX_BUF];
214	int	212	int count, retval = 0;
215	count,	213
216	retval = 0;
217	strcpy (local_name, name); /* strtok is destructive to name */	214	strcpy (local_name, name); /* strtok is destructive to name */
218		215
219	for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))	216	for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
220	{	217	{
221	while (cp[0] == ' ')	218	while (cp[0] == ' ')
…		…
272	retval = 15;	269	retval = 15;
273	else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))	270	else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))
274	retval = 14;	271	retval = 14;
275	else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))	272	else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))
276	retval = 14;	273	retval = 14;
277
278	/* Do substring checks, so things like 'Str+1' will match.	274	/* Do substring checks, so things like 'Str+1' will match.
279	* retval of these should perhaps be lower - they are lower	275	* retval of these should perhaps be lower - they are lower
280	* then the specific strcasecmp aboves, but still higher than	276	* then the specific strcasecmp aboves, but still higher than
281	* some other match criteria.	277	* some other match criteria.
282	*/	278	*/
…		…
284	retval = 12;	280	retval = 12;
285	else if (strstr (query_base_name (op, 0), cp))	281	else if (strstr (query_base_name (op, 0), cp))
286	retval = 12;	282	retval = 12;
287	else if (strstr (query_short_name (op), cp))	283	else if (strstr (query_short_name (op), cp))
288	retval = 12;	284	retval = 12;
289
290	/* Check against plural/non plural based on count. */	285	/* Check against plural/non plural based on count. */
291	else if (count > 1 && !strcasecmp (cp, op->name_pl))	286	else if (count > 1 && !strcasecmp (cp, op->name_pl))
292	{
293	retval = 6;	287	retval = 6;
294	}
295	else if (count == 1 && !strcasecmp (op->name, cp))	288	else if (count == 1 && !strcasecmp (op->name, cp))
296	{
297	retval = 6;	289	retval = 6;
298	}
299	/* base name matched - not bad */	290	/* base name matched - not bad */
300	else if (strcasecmp (cp, op->name) == 0 && !count)	291	else if (strcasecmp (cp, op->name) == 0 && !count)
301	retval = 4;	292	retval = 4;
302	/* Check for partial custom name, but give a real low priority */	293	/* Check for partial custom name, but give a real low priority */
303	else if (op->custom_name && strstr (op->custom_name, cp))	294	else if (op->custom_name && strstr (op->custom_name, cp))
…		…
305		296
306	if (retval)	297	if (retval)
307	{	298	{
308	if (pl->type == PLAYER)	299	if (pl->type == PLAYER)
309	pl->contr->count = count;	300	pl->contr->count = count;
		301
310	return retval;	302	return retval;
311	}	303	}
312	}	304	}
		305
313	return 0;	306	return 0;
314	}	307	}
315		308
316	/*	309	/*
317	* Initialises the internal linked list of archetypes (read from file).	310	* Initialises the internal linked list of archetypes (read from file).
…		…
322	void	315	void
323	init_archetypes (void)	316	init_archetypes (void)
324	{ /* called from add_player() and edit() */	317	{ /* called from add_player() and edit() */
325	if (first_archetype != NULL) /* Only do this once */	318	if (first_archetype != NULL) /* Only do this once */
326	return;	319	return;
		320
327	arch_init = 1;	321	arch_init = 1;
328	load_archetypes ();	322	load_archetypes ();
329	arch_init = 0;	323	arch_init = 0;
330	empty_archetype = find_archetype ("empty_archetype");	324	empty_archetype = archetype::find ("empty_archetype");
		325
331	/* init_blocksview();*/	326	/* init_blocksview();*/
332	}	327	}
333		328
334	/*	329	/*
335	* Stores debug-information about how efficient the hashtable	330	* Stores debug-information about how efficient the hashtable
336	* used for archetypes has been in the static errmsg array.	331	* used for archetypes has been in the static errmsg array.
337	*/	332	*/
338		333
339	void	334	void
340	arch_info (object * op)	335	arch_info (object *op)
341	{	336	{
342	sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp);	337	sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp);
343	new_draw_info (NDI_BLACK, 0, op, errmsg);	338	new_draw_info (NDI_BLACK, 0, op, errmsg);
344	}	339	}
345		340
…		…
373	/*	368	/*
374	* Dumps an archetype to debug-level output.	369	* Dumps an archetype to debug-level output.
375	*/	370	*/
376		371
377	void	372	void
378	dump_arch (archetype * at)	373	dump_arch (archetype *at)
379	{	374	{
380	dump_object (&at->clone);	375	dump_object (&at->clone);
381	}	376	}
382		377
383	/*	378	/*
…		…
387	*/	382	*/
388		383
389	void	384	void
390	dump_all_archetypes (void)	385	dump_all_archetypes (void)
391	{	386	{
392	archetype *	387	archetype *at;
393	at;	388
394	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)	389	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
395	{	390	{
396	dump_arch (at);	391	dump_arch (at);
397	fprintf (logfile, "%s\n", errmsg);	392	fprintf (logfile, "%s\n", errmsg);
398	}	393	}
399	}	394	}
400		395
401	void	396	void
402	free_all_archs (void)	397	free_all_archs (void)
403	{	398	{
404	archetype *	399	archetype at, next;
405	at, *
406	next;
407	int
408	i = 0, f = 0;	400	int i = 0, f = 0;
409		401
410	for (at = first_archetype; at != NULL; at = next)	402	for (at = first_archetype; at != NULL; at = next)
411	{	403	{
412	if (at->more)	404	if (at->more)
413	next = at->more;	405	next = at->more;
414	else	406	else
415	next = at->next;	407	next = at->next;
416		408
417	delete	409	delete
418	at;	410	at;
		411
419	i++;	412	i++;
420	}	413	}
421	LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);	414	LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
422	}	415	}
423		416
424	/*	417	archetype::archetype ()
425	* Allocates, initialises and returns the pointer to an archetype structure.
426	*/
427	// TODO: should become constructor
428	archetype *
429	get_archetype_struct (void)
430	{	418	{
431	archetype *
432	arch;
433
434	arch = new archetype;
435
436	clear_object (&arch->clone); /* to initial state other also */	419	clear_object (&clone); /* to initial state other also */
437	CLEAR_FLAG (&arch->clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */	420	CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */
438	SET_FLAG (&arch->clone, FLAG_REMOVED); /* doesn't copy these flags... */	421	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
		422	}
439		423
440	return arch;	424	archetype::~archetype ()
		425	{
441	}	426	}
442		427
443	/*	428	/*
444	* Reads/parses the archetype-file, and copies into a linked list	429	* Reads/parses the archetype-file, and copies into a linked list
445	* of archetype-structures.	430	* of archetype-structures.
446	*/	431	*/
447	void	432	void
448	first_arch_pass (object_thawer & fp)	433	first_arch_pass (object_thawer & fp)
449	{	434	{
450	object *
451	op;
452	archetype *
453	at, *
454	head = NULL, *last_more = NULL;	435	archetype at, head = NULL, *last_more = NULL;
455	int
456	i;
457		436
458	op = get_object ();
459	op->arch = first_archetype = at = get_archetype_struct ();	437	at->clone.arch = first_archetype = at = new archetype;
460		438
461	while ((i = load_object (fp, op, 0)))	439	while (int i = load_object (fp, &at->clone, 0))
462	{	440	{
463	copy_object (op, &at->clone);
464	at->clone.speed_left = (float) (-0.1);	441	at->clone.speed_left = (float) (-0.1);
465	/* copy the body_info to the body_used - this is only really	442	/* copy the body_info to the body_used - this is only really
466	* need for monsters, but doesn't hurt to do it for everything.	443	* need for monsters, but doesn't hurt to do it for everything.
467	* by doing so, when a monster is created, it has good starting	444	* by doing so, when a monster is created, it has good starting
468	* values for the body_used info, so when items are created	445	* values for the body_used info, so when items are created
469	* for it, they can be properly equipped.	446	* for it, they can be properly equipped.
470	*/	447	*/
471	memcpy (&at->clone.body_used, &op->body_info, sizeof (op->body_info));	448	memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));
472		449
473	switch (i)	450	switch (i)
474	{	451	{
475	case LL_NORMAL: /* A new archetype, just link it with the previous */	452	case LL_NORMAL: /* A new archetype, just link it with the previous */
476	if (last_more != NULL)	453	if (last_more != NULL)
477	last_more->next = at;	454	last_more->next = at;
478	if (head != NULL)	455	if (head != NULL)
479	head->next = at;	456	head->next = at;
480	head = last_more = at;	457	head = last_more = at;
481	#if 0	458	#if 0
482	if (!op->type)	459	if (!op->type)
483	LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);	460	LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);
484	#endif	461	#endif
485	at->tail_x = 0;	462	at->tail_x = 0;
486	at->tail_y = 0;	463	at->tail_y = 0;
487	break;	464	break;
488		465
489	case LL_MORE: /* Another part of the previous archetype, link it correctly */	466	case LL_MORE: /* Another part of the previous archetype, link it correctly */
490		467
491	at->head = head;	468	at->head = head;
492	at->clone.head = &head->clone;	469	at->clone.head = &head->clone;
493	if (last_more != NULL)	470	if (last_more != NULL)
494	{	471	{
495	last_more->more = at;	472	last_more->more = at;
496	last_more->clone.more = &at->clone;	473	last_more->clone.more = &at->clone;
497	}	474	}
498	last_more = at;	475	last_more = at;
499		476
500	/* If this multipart image is still composed of individual small	477	/* If this multipart image is still composed of individual small
501	* images, don't set the tail_.. values. We can't use them anyways,	478	* images, don't set the tail_.. values. We can't use them anyways,
502	* and setting these to zero makes the map sending to the client much	479	* and setting these to zero makes the map sending to the client much
503	* easier as just looking at the head, we know what to do.	480	* easier as just looking at the head, we know what to do.
504	*/	481	*/
505	if (at->clone.face != head->clone.face)	482	if (at->clone.face != head->clone.face)
506	{	483	{
507	head->tail_x = 0;	484	head->tail_x = 0;
508	head->tail_y = 0;	485	head->tail_y = 0;
509	}	486	}
510	else	487	else
511	{	488	{
512	if (at->clone.x > head->tail_x)	489	if (at->clone.x > head->tail_x)
513	head->tail_x = at->clone.x;	490	head->tail_x = at->clone.x;
514	if (at->clone.y > head->tail_y)	491	if (at->clone.y > head->tail_y)
515	head->tail_y = at->clone.y;	492	head->tail_y = at->clone.y;
516	}	493	}
517	break;	494	break;
518		495
519	}	496	}
520		497
521	at = get_archetype_struct ();	498	at = new archetype;
522	clear_object (op);	499
523	op->arch = at;	500	at->clone.arch = at;
524	}	501	}
525		502
526	delete	503	delete at;
527	at;
528	free_object (op);
529	}	504	}
530		505
531	/*	506	/*
532	* Reads the archetype file once more, and links all pointers between	507	* Reads the archetype file once more, and links all pointers between
533	* archetypes.	508	* archetypes.
534	*/	509	*/
535		510
536	void	511	void
537	second_arch_pass (object_thawer & thawer)	512	second_arch_pass (object_thawer & thawer)
538	{	513	{
539	char
540	buf[MAX_BUF], *
541	variable = buf, argument, cp;	514	char buf[MAX_BUF], variable = buf, argument, *cp;
542	archetype *
543	at = NULL, *other;	515	archetype at = NULL, other;
544		516
545	while (fgets (buf, MAX_BUF, thawer) != NULL)	517	while (fgets (buf, MAX_BUF, thawer) != NULL)
546	{	518	{
547	if (*buf == '#')	519	if (*buf == '#')
548	continue;	520	continue;
…		…
556	cp--;	528	cp--;
557	}	529	}
558	}	530	}
559	if (!strcmp ("Object", variable))	531	if (!strcmp ("Object", variable))
560	{	532	{
561	if ((at = find_archetype (argument)) == NULL)	533	if ((at = archetype::find (argument)) == NULL)
562	LOG (llevError, "Warning: failed to find arch %s\n", argument);	534	LOG (llevError, "Warning: failed to find arch %s\n", argument);
563	}	535	}
564	else if (!strcmp ("other_arch", variable))	536	else if (!strcmp ("other_arch", variable))
565	{	537	{
566	if (at != NULL && at->clone.other_arch == NULL)	538	if (at != NULL && at->clone.other_arch == NULL)
567	{	539	{
568	if ((other = find_archetype (argument)) == NULL)	540	if ((other = archetype::find (argument)) == NULL)
569	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);	541	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
570	else if (at != NULL)	542	else if (at != NULL)
571	at->clone.other_arch = other;	543	at->clone.other_arch = other;
572	}	544	}
573	}	545	}
…		…
575	{	547	{
576	if (at != NULL)	548	if (at != NULL)
577	{	549	{
578	treasurelist *	550	treasurelist *
579	tl = find_treasurelist (argument);	551	tl = find_treasurelist (argument);
		552
580	if (tl == NULL)	553	if (tl == NULL)
581	LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);	554	LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
582	else	555	else
583	at->clone.randomitems = tl;	556	at->clone.randomitems = tl;
584	}	557	}
…		…
588		561
589	#ifdef DEBUG	562	#ifdef DEBUG
590	void	563	void
591	check_generators (void)	564	check_generators (void)
592	{	565	{
593	archetype *	566	archetype *at;
594	at;	567
595	for (at = first_archetype; at != NULL; at = at->next)	568	for (at = first_archetype; at != NULL; at = at->next)
596	if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)	569	if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)
597	LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);	570	LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
598	}	571	}
599	#endif	572	#endif
…		…
606	*/	579	*/
607		580
608	void	581	void
609	load_archetypes (void)	582	load_archetypes (void)
610	{	583	{
611	char
612	filename[MAX_BUF];	584	char filename[MAX_BUF];
613	int	585
614	comp;
615	#if TIME_ARCH_LOAD	586	#if TIME_ARCH_LOAD
616	struct timeval	587	struct timeval
617	tv1,	588	tv1,
618	tv2;	589	tv2;
619	#endif	590	#endif
…		…
654	* Creates and returns a new object which is a copy of the given archetype.	625	* Creates and returns a new object which is a copy of the given archetype.
655	* This function returns NULL on failure.	626	* This function returns NULL on failure.
656	*/	627	*/
657		628
658	object *	629	object *
659	arch_to_object (archetype * at)	630	arch_to_object (archetype *at)
660	{	631	{
661	object *	632	object *op;
662	op;	633
663	if (at == NULL)	634	if (at == NULL)
664	{	635	{
665	if (warn_archetypes)	636	if (warn_archetypes)
666	LOG (llevError, "Couldn't find archetype.\n");	637	LOG (llevError, "Couldn't find archetype.\n");
		638
667	return NULL;	639	return NULL;
668	}	640	}
		641
669	op = get_object ();	642	op = get_object ();
670	copy_object (&at->clone, op);	643	copy_object (&at->clone, op);
		644	op->arch = at;
671	op->instantiate ();	645	op->instantiate ();
672	op->arch = at;
673	return op;	646	return op;
674	}	647	}
675		648
676	/*	649	/*
677	* Creates an object. This function is called by get_archetype()	650	* Creates an object. This function is called by get_archetype()
…		…
681	*/	654	*/
682		655
683	object *	656	object *
684	create_singularity (const char *name)	657	create_singularity (const char *name)
685	{	658	{
686	object *	659	object *op;
687	op;
688	char
689	buf[MAX_BUF];	660	char buf[MAX_BUF];
		661
690	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);	662	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
691	op = get_object ();	663	op = get_object ();
692	op->name = op->name_pl = buf;	664	op->name = op->name_pl = buf;
693	SET_FLAG (op, FLAG_NO_PICK);	665	SET_FLAG (op, FLAG_NO_PICK);
694	return op;	666	return op;
…		…
700	*/	672	*/
701		673
702	object *	674	object *
703	get_archetype (const char *name)	675	get_archetype (const char *name)
704	{	676	{
705	archetype *	677	archetype *at = archetype::find (name);
706	at;	678
707	at = find_archetype (name);	679	if (!at)
708	if (at == NULL)
709	return create_singularity (name);	680	return create_singularity (name);
		681
710	return arch_to_object (at);	682	return arch_to_object (at);
711	}	683	}
712		684
713	/*	685	/*
714	* Hash-function used by the arch-hashtable.	686	* Hash-function used by the arch-hashtable.
715	*/	687	*/
716		688
717	unsigned long	689	unsigned long
718	hasharch (const char *str, int tablesize)	690	hasharch (const char *str, int tablesize)
719	{	691	{
720	unsigned long	692	unsigned long hash = 0;
721	hash = 0;
722	unsigned int	693	unsigned int i = 0;
723	i = 0;
724	const char *	694	const char *p;
725	p;
726		695
727	/* use the one-at-a-time hash function, which supposedly is	696	/* use the one-at-a-time hash function, which supposedly is
728	* better than the djb2-like one used by perl5.005, but	697	* better than the djb2-like one used by perl5.005, but
729	* certainly is better then the bug used here before.	698	* certainly is better then the bug used here before.
730	* see http://burtleburtle.net/bob/hash/doobs.html	699	* see http://burtleburtle.net/bob/hash/doobs.html
…		…
747	* Finds, using the hashtable, which archetype matches the given name.	716	* Finds, using the hashtable, which archetype matches the given name.
748	* returns a pointer to the found archetype, otherwise NULL.	717	* returns a pointer to the found archetype, otherwise NULL.
749	*/	718	*/
750		719
751	archetype *	720	archetype *
752	find_archetype (const char *name)	721	archetype::find (const char *name)
753	{	722	{
754	#if USE_UNORDERED_MAP
755	name = shstr::find (name);
756
757	if (!name)	723	if (!name)
758	return 0;	724	return 0;
759		725
760	HT::const_iterator i = ht.find ((size_t)name);	726	#if USE_UNORDERED_MAP
		727	AUTODECL (i, ht.find ((size_t) name));
761		728
762	if (i == ht.end ())	729	if (i == ht.end ())
763	return 0;	730	return 0;
764	else	731	else
765	return i->second;	732	return i->second;
766	#endif	733	#endif
767		734
768	archetype *at;	735	archetype *at;
769	unsigned long index;	736	unsigned long index;
770		737
771	if (name == NULL)
772	return (archetype *) NULL;
773
774	index = hasharch (name, ARCHTABLE);	738	index = hasharch (name, ARCHTABLE);
775	arch_search++;	739	arch_search++;
776	for (;;)	740	for (;;)
777	{	741	{
778	at = arch_table[index];	742	at = arch_table[index];
		743
779	if (at == NULL)	744	if (at == NULL)
780	{	745	{
781	if (warn_archetypes)	746	if (warn_archetypes)
782	LOG (llevError, "Couldn't find archetype %s\n", name);	747	LOG (llevError, "Couldn't find archetype %s\n", name);
		748
783	return NULL;	749	return NULL;
784	}	750	}
		751
785	arch_cmp++;	752	arch_cmp++;
		753
786	if (!strcmp ((const char *) at->name, name))	754	if (!strcmp ((const char *) at->name, name))
787	return at;	755	return at;
		756
788	if (++index >= ARCHTABLE)	757	if (++index >= ARCHTABLE)
789	index = 0;	758	index = 0;
790	}	759	}
791	}	760	}
792		761
…		…
796		765
797	static void	766	static void
798	add_arch (archetype *at)	767	add_arch (archetype *at)
799	{	768	{
800	#if USE_UNORDERED_MAP	769	#if USE_UNORDERED_MAP
801	ht.insert (std::make_pair ((size_t)(const char *)at->name, at));	770	ht.insert (std::make_pair ((size_t) (const char *) at->name, at));
802	#endif	771	#endif
803		772
804	int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;	773	int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;
805		774
806	for (;;)	775	for (;;)
…		…
825	*/	794	*/
826		795
827	archetype *	796	archetype *
828	type_to_archetype (int type)	797	type_to_archetype (int type)
829	{	798	{
830	archetype *	799	archetype *at;
831	at;
832		800
833	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)	801	for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
834	if (at->clone.type == type)	802	if (at->clone.type == type)
835	return at;	803	return at;
		804
836	return NULL;	805	return 0;
837	}	806	}
838		807
839	/*	808	/*
840	* Returns a new object copied from the first archetype matching	809	* Returns a new object copied from the first archetype matching
841	* the given type.	810	* the given type.
…		…
843	*/	812	*/
844		813
845	object *	814	object *
846	clone_arch (int type)	815	clone_arch (int type)
847	{	816	{
848	archetype *	817	archetype *at;
849	at;
850	object *
851	op = get_object ();	818	object *op = get_object ();
852		819
853	if ((at = type_to_archetype (type)) == NULL)	820	if ((at = type_to_archetype (type)) == NULL)
854	{	821	{
855	LOG (llevError, "Can't clone archetype %d\n", type);	822	LOG (llevError, "Can't clone archetype %d\n", type);
856	free_object (op);	823	free_object (op);
857	return NULL;	824	return NULL;
858	}	825	}
		826
859	copy_object (&at->clone, op);	827	copy_object (&at->clone, op);
860	op->instantiate ();	828	op->instantiate ();
861	return op;	829	return op;
862	}	830	}
863		831
864	/*	832	/*
865	* member: make instance from class	833	* member: make instance from class
866	*/	834	*/
867		835
868	object *	836	object *
869	object_create_arch (archetype * at)	837	object_create_arch (archetype *at)
870	{	838	{
871	object *	839	object op, prev = 0, *head = 0;
872	op, *
873	prev = NULL, *head = NULL;
874		840
875	while (at)	841	while (at)
876	{	842	{
877	op = arch_to_object (at);	843	op = arch_to_object (at);
878	op->x = at->clone.x;	844	op->x = at->clone.x;
879	op->y = at->clone.y;	845	op->y = at->clone.y;
		846
880	if (head)	847	if (head)
881	op->head = head, prev->more = op;	848	op->head = head, prev->more = op;
		849
882	if (!head)	850	if (!head)
883	head = op;	851	head = op;
		852
884	prev = op;	853	prev = op;
885	at = at->more;	854	at = at->more;
886	}	855	}
		856
887	return (head);	857	return (head);
888	}	858	}
889		859
890	/* end of arch.c */

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.12 by root, Mon Sep 4 17:16:19 2006 UTC vs. Revision 1.23 by root, Thu Sep 14 23:13:48 2006 UTC

Diff Legend

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.12 by root, Mon Sep 4 17:16:19 2006 UTC vs.
Revision 1.23 by root, Thu Sep 14 23:13:48 2006 UTC