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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.13 by pippijn, Thu Sep 7 09:37:11 2006 UTC vs.
Revision 1.28 by root, Tue Dec 12 20:53:02 2006 UTC

…		…
1	/*
2	* static char *rcsid_arch_c =
3	* "$Id: arch.C,v 1.13 2006/09/07 09:37:11 pippijn 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").
…		…
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
…		…
363	archetype *at;	358	archetype *at;
364		359
365	LOG (llevDebug, " Setting up archetable...\n");	360	LOG (llevDebug, " Setting up archetable...\n");
366		361
367	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)	362	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
368	add_arch (at);	363	at->hash_add ();
369		364
370	LOG (llevDebug, "done\n");	365	LOG (llevDebug, "done\n");
371	}	366	}
372		367
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	368	void
402	free_all_archs (void)	369	free_all_archs (void)
403	{	370	{
404	archetype *	371	archetype at, next;
405	at, *
406	next;
407	int
408	i = 0, f = 0;	372	int i = 0, f = 0;
409		373
410	for (at = first_archetype; at != NULL; at = next)	374	for (at = first_archetype; at != NULL; at = next)
411	{	375	{
412	if (at->more)	376	if (at->more)
413	next = at->more;	377	next = at->more;
414	else	378	else
415	next = at->next;	379	next = at->next;
416		380
417	delete	381	delete
418	at;	382	at;
		383
419	i++;	384	i++;
420	}	385	}
		386
421	LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);	387	LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
422	}	388	}
423		389
424	/*	390	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	{	391	{
431	archetype *
432	arch;
433
434	arch = new archetype;
435
436	clear_object (&arch->clone); /* to initial state other also */	392	clear_object (&clone); /* to initial state other also */
437	CLEAR_FLAG (&arch->clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */	393	CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */
438	SET_FLAG (&arch->clone, FLAG_REMOVED); /* doesn't copy these flags... */	394	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
		395	}
439		396
440	return arch;	397	archetype::~archetype ()
		398	{
441	}	399	}
442		400
443	/*	401	/*
444	* Reads/parses the archetype-file, and copies into a linked list	402	* Reads/parses the archetype-file, and copies into a linked list
445	* of archetype-structures.	403	* of archetype-structures.
446	*/	404	*/
447	void	405	void
448	first_arch_pass (object_thawer & fp)	406	first_arch_pass (object_thawer & fp)
449	{	407	{
450	object *	408	archetype head = 0, last_more = 0;
451	op;
452	archetype *
453	at, *
454	head = NULL, *last_more = NULL;
455	int
456	i;
457		409
458	op = get_object ();	410	archetype *at = new archetype;
459	op->arch = first_archetype = at = get_archetype_struct ();	411	at->clone.arch = first_archetype = at;
460		412
461	while ((i = load_object (fp, op, 0)))	413	while (int i = load_object (fp, &at->clone, 0))
462	{	414	{
463	copy_object (op, &at->clone);
464	at->clone.speed_left = (float) (-0.1);	415	at->clone.speed_left = (float) (-0.1);
465	/* copy the body_info to the body_used - this is only really	416	/* copy the body_info to the body_used - this is only really
466	* need for monsters, but doesn't hurt to do it for everything.	417	* 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	418	* by doing so, when a monster is created, it has good starting
468	* values for the body_used info, so when items are created	419	* values for the body_used info, so when items are created
469	* for it, they can be properly equipped.	420	* for it, they can be properly equipped.
470	*/	421	*/
471	memcpy (&at->clone.body_used, &op->body_info, sizeof (op->body_info));	422	memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));
472		423
473	switch (i)	424	switch (i)
474	{	425	{
475	case LL_NORMAL: /* A new archetype, just link it with the previous */	426	case LL_NORMAL: /* A new archetype, just link it with the previous */
476	if (last_more != NULL)	427	if (last_more != NULL)
477	last_more->next = at;	428	last_more->next = at;
478	if (head != NULL)	429	if (head != NULL)
479	head->next = at;	430	head->next = at;
480	head = last_more = at;	431	head = last_more = at;
481	#if 0	432	#if 0
482	if (!op->type)	433	if (!op->type)
483	LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);	434	LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);
484	#endif	435	#endif
485	at->tail_x = 0;	436	at->tail_x = 0;
486	at->tail_y = 0;	437	at->tail_y = 0;
487	break;	438	break;
488		439
489	case LL_MORE: /* Another part of the previous archetype, link it correctly */	440	case LL_MORE: /* Another part of the previous archetype, link it correctly */
490		441
491	at->head = head;	442	at->head = head;
492	at->clone.head = &head->clone;	443	at->clone.head = &head->clone;
493	if (last_more != NULL)	444	if (last_more != NULL)
494	{	445	{
495	last_more->more = at;	446	last_more->more = at;
496	last_more->clone.more = &at->clone;	447	last_more->clone.more = &at->clone;
497	}	448	}
498	last_more = at;	449	last_more = at;
499		450
500	/* If this multipart image is still composed of individual small	451	/* If this multipart image is still composed of individual small
501	* images, don't set the tail_.. values. We can't use them anyways,	452	* 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	453	* 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.	454	* easier as just looking at the head, we know what to do.
504	*/	455	*/
505	if (at->clone.face != head->clone.face)	456	if (at->clone.face != head->clone.face)
506	{	457	{
507	head->tail_x = 0;	458	head->tail_x = 0;
508	head->tail_y = 0;	459	head->tail_y = 0;
509	}	460	}
510	else	461	else
511	{	462	{
512	if (at->clone.x > head->tail_x)	463	if (at->clone.x > head->tail_x)
513	head->tail_x = at->clone.x;	464	head->tail_x = at->clone.x;
514	if (at->clone.y > head->tail_y)	465	if (at->clone.y > head->tail_y)
515	head->tail_y = at->clone.y;	466	head->tail_y = at->clone.y;
516	}	467	}
517	break;	468	break;
518		469
519	}	470	}
520		471
521	at = get_archetype_struct ();	472	at = new archetype;
522	clear_object (op);	473
523	op->arch = at;	474	at->clone.arch = at;
524	}	475	}
525		476
526	delete	477	delete at;
527	at;
528	free_object (op);
529	}	478	}
530		479
531	/*	480	/*
532	* Reads the archetype file once more, and links all pointers between	481	* Reads the archetype file once more, and links all pointers between
533	* archetypes.	482	* archetypes.
534	*/	483	*/
535		484
536	void	485	void
537	second_arch_pass (object_thawer & thawer)	486	second_arch_pass (object_thawer & thawer)
538	{	487	{
539	char
540	buf[MAX_BUF], *
541	variable = buf, argument, cp;	488	char buf[MAX_BUF], variable = buf, argument, *cp;
542	archetype *
543	at = NULL, *other;	489	archetype at = NULL, other;
544		490
545	while (fgets (buf, MAX_BUF, thawer) != NULL)	491	while (fgets (buf, MAX_BUF, thawer) != NULL)
546	{	492	{
547	if (*buf == '#')	493	if (*buf == '#')
548	continue;	494	continue;
…		…
556	cp--;	502	cp--;
557	}	503	}
558	}	504	}
559	if (!strcmp ("Object", variable))	505	if (!strcmp ("Object", variable))
560	{	506	{
561	if ((at = find_archetype (argument)) == NULL)	507	if ((at = archetype::find (argument)) == NULL)
562	LOG (llevError, "Warning: failed to find arch %s\n", argument);	508	LOG (llevError, "Warning: failed to find arch %s\n", argument);
563	}	509	}
564	else if (!strcmp ("other_arch", variable))	510	else if (!strcmp ("other_arch", variable))
565	{	511	{
566	if (at != NULL && at->clone.other_arch == NULL)	512	if (at != NULL && at->clone.other_arch == NULL)
567	{	513	{
568	if ((other = find_archetype (argument)) == NULL)	514	if ((other = archetype::find (argument)) == NULL)
569	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);	515	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
570	else if (at != NULL)	516	else if (at != NULL)
571	at->clone.other_arch = other;	517	at->clone.other_arch = other;
572	}	518	}
573	}	519	}
574	else if (!strcmp ("randomitems", variable))	520	else if (!strcmp ("randomitems", variable))
575	{	521	{
576	if (at != NULL)	522	if (at != NULL)
577	{	523	{
578	treasurelist *
579	tl = find_treasurelist (argument);	524	treasurelist *tl = find_treasurelist (argument);
		525
580	if (tl == NULL)	526	if (tl == NULL)
581	LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);	527	LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
582	else	528	else
583	at->clone.randomitems = tl;	529	at->clone.randomitems = tl;
584	}	530	}
…		…
588		534
589	#ifdef DEBUG	535	#ifdef DEBUG
590	void	536	void
591	check_generators (void)	537	check_generators (void)
592	{	538	{
593	archetype *	539	archetype *at;
594	at;	540
595	for (at = first_archetype; at != NULL; at = at->next)	541	for (at = first_archetype; at != NULL; at = at->next)
596	if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)	542	if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)
597	LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);	543	LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
598	}	544	}
599	#endif	545	#endif
…		…
606	*/	552	*/
607		553
608	void	554	void
609	load_archetypes (void)	555	load_archetypes (void)
610	{	556	{
611	char
612	filename[MAX_BUF];	557	char filename[MAX_BUF];
613	#if TIME_ARCH_LOAD
614	struct timeval
615	tv1,
616	tv2;
617	#endif
618		558
619	sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);	559	sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
620	LOG (llevDebug, "Reading archetypes from %s:\n", filename);	560	LOG (llevDebug, "Reading archetypes from %s:\n", filename);
621		561
622	{	562	{
…		…
652	* Creates and returns a new object which is a copy of the given archetype.	592	* Creates and returns a new object which is a copy of the given archetype.
653	* This function returns NULL on failure.	593	* This function returns NULL on failure.
654	*/	594	*/
655		595
656	object *	596	object *
657	arch_to_object (archetype * at)	597	arch_to_object (archetype *at)
658	{	598	{
659	object *	599	object *op;
660	op;	600
661	if (at == NULL)	601	if (at == NULL)
662	{	602	{
663	if (warn_archetypes)	603	if (warn_archetypes)
664	LOG (llevError, "Couldn't find archetype.\n");	604	LOG (llevError, "Couldn't find archetype.\n");
		605
665	return NULL;	606	return NULL;
666	}	607	}
		608
667	op = get_object ();	609	op = get_object ();
668	copy_object (&at->clone, op);	610	copy_object (&at->clone, op);
		611	op->arch = at;
669	op->instantiate ();	612	op->instantiate ();
670	op->arch = at;
671	return op;	613	return op;
672	}	614	}
673		615
674	/*	616	/*
675	* Creates an object. This function is called by get_archetype()	617	* Creates an object. This function is called by get_archetype()
…		…
679	*/	621	*/
680		622
681	object *	623	object *
682	create_singularity (const char *name)	624	create_singularity (const char *name)
683	{	625	{
684	object *	626	object *op;
685	op;
686	char
687	buf[MAX_BUF];	627	char buf[MAX_BUF];
		628
688	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);	629	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
689	op = get_object ();	630	op = get_object ();
690	op->name = op->name_pl = buf;	631	op->name = op->name_pl = buf;
691	SET_FLAG (op, FLAG_NO_PICK);	632	SET_FLAG (op, FLAG_NO_PICK);
692	return op;	633	return op;
…		…
698	*/	639	*/
699		640
700	object *	641	object *
701	get_archetype (const char *name)	642	get_archetype (const char *name)
702	{	643	{
703	archetype *	644	archetype *at = archetype::find (name);
704	at;	645
705	at = find_archetype (name);	646	if (!at)
706	if (at == NULL)
707	return create_singularity (name);	647	return create_singularity (name);
		648
708	return arch_to_object (at);	649	return arch_to_object (at);
709	}	650	}
710		651
711	/*	652	/*
712	* Hash-function used by the arch-hashtable.	653	* Hash-function used by the arch-hashtable.
713	*/	654	*/
714		655
715	unsigned long	656	unsigned long
716	hasharch (const char *str, int tablesize)	657	hasharch (const char *str, int tablesize)
717	{	658	{
718	unsigned long	659	unsigned long hash = 0;
719	hash = 0;
720	unsigned int	660	unsigned int i = 0;
721	i = 0;
722	const char *	661	const char *p;
723	p;
724		662
725	/* use the one-at-a-time hash function, which supposedly is	663	/* use the one-at-a-time hash function, which supposedly is
726	* better than the djb2-like one used by perl5.005, but	664	* better than the djb2-like one used by perl5.005, but
727	* certainly is better then the bug used here before.	665	* certainly is better then the bug used here before.
728	* see http://burtleburtle.net/bob/hash/doobs.html	666	* see http://burtleburtle.net/bob/hash/doobs.html
…		…
745	* Finds, using the hashtable, which archetype matches the given name.	683	* Finds, using the hashtable, which archetype matches the given name.
746	* returns a pointer to the found archetype, otherwise NULL.	684	* returns a pointer to the found archetype, otherwise NULL.
747	*/	685	*/
748		686
749	archetype *	687	archetype *
750	find_archetype (const char *name)	688	archetype::find (const char *name)
751	{	689	{
752	#if USE_UNORDERED_MAP
753	name = shstr::find (name);
754
755	if (!name)	690	if (!name)
756	return 0;	691	return 0;
757		692
758	HT::const_iterator i = ht.find ((size_t)name);	693	#if USE_UNORDERED_MAP
		694	AUTODECL (i, ht.find ((size_t) name));
759		695
760	if (i == ht.end ())	696	if (i == ht.end ())
761	return 0;	697	return 0;
762	else	698	else
763	return i->second;	699	return i->second;
764	#endif	700	#endif
765		701
766	archetype *at;	702	archetype *at;
767	unsigned long index;	703	unsigned long index;
768		704
769	if (name == NULL)
770	return (archetype *) NULL;
771
772	index = hasharch (name, ARCHTABLE);	705	index = hasharch (name, ARCHTABLE);
773	arch_search++;	706	arch_search++;
774	for (;;)	707	for (;;)
775	{	708	{
776	at = arch_table[index];	709	at = arch_table[index];
		710
777	if (at == NULL)	711	if (at == NULL)
778	{	712	{
779	if (warn_archetypes)	713	if (warn_archetypes)
780	LOG (llevError, "Couldn't find archetype %s\n", name);	714	LOG (llevError, "Couldn't find archetype %s\n", name);
		715
781	return NULL;	716	return NULL;
782	}	717	}
		718
783	arch_cmp++;	719	arch_cmp++;
		720
784	if (!strcmp ((const char *) at->name, name))	721	if (!strcmp ((const char *) at->name, name))
785	return at;	722	return at;
		723
786	if (++index >= ARCHTABLE)	724	if (++index >= ARCHTABLE)
787	index = 0;	725	index = 0;
788	}	726	}
789	}	727	}
790		728
791	/*	729	/*
792	* Adds an archetype to the hashtable.	730	* Adds an archetype to the hashtable.
793	*/	731	*/
794		732	void
795	static void	733	archetype::hash_add ()
796	add_arch (archetype *at)
797	{	734	{
798	#if USE_UNORDERED_MAP	735	#if USE_UNORDERED_MAP
799	ht.insert (std::make_pair ((size_t)(const char *)at->name, at));	736	ht.insert (std::make_pair ((size_t) (const char *) name, this));
800	#endif	737	#else
801		738
802	int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;	739	int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
803		740
804	for (;;)	741	for (;;)
805	{	742	{
806	if (arch_table[index] == NULL)	743	if (!arch_table[index])
807	{	744	{
808	arch_table[index] = at;	745	arch_table[index] = this;
809	return;	746	break;
810	}	747	}
811		748
812	if (++index == ARCHTABLE)	749	if (++index == ARCHTABLE)
813	index = 0;	750	index = 0;
814		751
815	if (index == org_index)	752	if (index == org_index)
816	fatal (ARCHTABLE_TOO_SMALL);	753	fatal (ARCHTABLE_TOO_SMALL);
817	}	754	}
		755	#endif
		756	}
		757
		758	void
		759	archetype::hash_del ()
		760	{
		761	#if USE_UNORDERED_MAP
		762	# error remove this from HT
		763	#else
		764
		765	int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
		766
		767	for (;;)
		768	{
		769	if (arch_table[index] == this)
		770	{
		771	arch_table[index] = 0;
		772	break;
		773	}
		774
		775	if (++index == ARCHTABLE)
		776	index = 0;
		777
		778	if (index == org_index)
		779	break;
		780	}
		781	#endif
818	}	782	}
819		783
820	/*	784	/*
821	* Returns the first archetype using the given type.	785	* Returns the first archetype using the given type.
822	* Used in treasure-generation.	786	* Used in treasure-generation.
823	*/	787	*/
824		788
825	archetype *	789	archetype *
826	type_to_archetype (int type)	790	type_to_archetype (int type)
827	{	791	{
828	archetype *	792	archetype *at;
829	at;
830		793
831	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)	794	for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
832	if (at->clone.type == type)	795	if (at->clone.type == type)
833	return at;	796	return at;
		797
834	return NULL;	798	return 0;
835	}	799	}
836		800
837	/*	801	/*
838	* Returns a new object copied from the first archetype matching	802	* Returns a new object copied from the first archetype matching
839	* the given type.	803	* the given type.
…		…
841	*/	805	*/
842		806
843	object *	807	object *
844	clone_arch (int type)	808	clone_arch (int type)
845	{	809	{
846	archetype *	810	archetype *at;
847	at;
848	object *
849	op = get_object ();	811	object *op = get_object ();
850		812
851	if ((at = type_to_archetype (type)) == NULL)	813	if ((at = type_to_archetype (type)) == NULL)
852	{	814	{
853	LOG (llevError, "Can't clone archetype %d\n", type);	815	LOG (llevError, "Can't clone archetype %d\n", type);
854	free_object (op);	816	op->destroy (0);
855	return NULL;	817	return NULL;
856	}	818	}
		819
857	copy_object (&at->clone, op);	820	copy_object (&at->clone, op);
858	op->instantiate ();	821	op->instantiate ();
859	return op;	822	return op;
860	}	823	}
861		824
862	/*	825	/*
863	* member: make instance from class	826	* member: make instance from class
864	*/	827	*/
865		828
866	object *	829	object *
867	object_create_arch (archetype * at)	830	object_create_arch (archetype *at)
868	{	831	{
869	object *	832	object op, prev = 0, *head = 0;
870	op, *
871	prev = NULL, *head = NULL;
872		833
873	while (at)	834	while (at)
874	{	835	{
875	op = arch_to_object (at);	836	op = arch_to_object (at);
876	op->x = at->clone.x;	837	op->x = at->clone.x;
877	op->y = at->clone.y;	838	op->y = at->clone.y;
		839
878	if (head)	840	if (head)
879	op->head = head, prev->more = op;	841	op->head = head, prev->more = op;
		842
880	if (!head)	843	if (!head)
881	head = op;	844	head = op;
		845
882	prev = op;	846	prev = op;
883	at = at->more;	847	at = at->more;
884	}	848	}
		849
885	return (head);	850	return (head);
886	}	851	}
887		852
888	/* end of arch.c */

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.13 by pippijn, Thu Sep 7 09:37:11 2006 UTC vs. Revision 1.28 by root, Tue Dec 12 20:53:02 2006 UTC

Diff Legend

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.13 by pippijn, Thu Sep 7 09:37:11 2006 UTC vs.
Revision 1.28 by root, Tue Dec 12 20:53:02 2006 UTC