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