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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.14 by root, Fri Sep 8 17:14:07 2006 UTC vs.
Revision 1.32 by root, Mon Dec 25 11:25:49 2006 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").
…		…
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	archetype::archetype ()	390	archetype::archetype ()
425	{	391	{
426	clear_object (&clone); /* to initial state other also */
427	CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */	392	CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_to */
428	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */	393	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
429	}	394	}
430		395
431	archetype::~archetype ()	396	archetype::~archetype ()
432	{	397	{
433	}	398	}
…		…
437	* of archetype-structures.	402	* of archetype-structures.
438	*/	403	*/
439	void	404	void
440	first_arch_pass (object_thawer & fp)	405	first_arch_pass (object_thawer & fp)
441	{	406	{
442	archetype at, head = NULL, *last_more = NULL;	407	archetype head = 0, last_more = 0;
443		408
		409	archetype *at = new archetype;
444	at->clone.arch = first_archetype = at = new archetype;	410	at->clone.arch = first_archetype = at;
445		411
446	while (int i = load_object (fp, &at->clone, 0))	412	while (int i = load_object (fp, &at->clone, 0))
447	{	413	{
448	at->clone.speed_left = (float) (-0.1);	414	at->clone.speed_left = (float) (-0.1);
449	/* copy the body_info to the body_used - this is only really	415	/* copy the body_info to the body_used - this is only really
…		…
454	*/	420	*/
455	memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));	421	memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));
456		422
457	switch (i)	423	switch (i)
458	{	424	{
459	case LL_NORMAL: /* A new archetype, just link it with the previous */	425	case LL_NORMAL: /* A new archetype, just link it with the previous */
460	if (last_more != NULL)	426	if (last_more != NULL)
461	last_more->next = at;	427	last_more->next = at;
462	if (head != NULL)	428	if (head != NULL)
463	head->next = at;	429	head->next = at;
464	head = last_more = at;	430	head = last_more = at;
465	#if 0	431	#if 0
466	if (!op->type)	432	if (!op->type)
467	LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);	433	LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);
468	#endif	434	#endif
469	at->tail_x = 0;	435	at->tail_x = 0;
470	at->tail_y = 0;	436	at->tail_y = 0;
471	break;	437	break;
472		438
473	case LL_MORE: /* Another part of the previous archetype, link it correctly */	439	case LL_MORE: /* Another part of the previous archetype, link it correctly */
474		440
475	at->head = head;	441	at->head = head;
476	at->clone.head = &head->clone;	442	at->clone.head = &head->clone;
477	if (last_more != NULL)	443	if (last_more != NULL)
478	{	444	{
479	last_more->more = at;	445	last_more->more = at;
480	last_more->clone.more = &at->clone;	446	last_more->clone.more = &at->clone;
481	}	447	}
482	last_more = at;	448	last_more = at;
483		449
484	/* If this multipart image is still composed of individual small	450	/* If this multipart image is still composed of individual small
485	* images, don't set the tail_.. values. We can't use them anyways,	451	* 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	452	* 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.	453	* easier as just looking at the head, we know what to do.
488	*/	454	*/
489	if (at->clone.face != head->clone.face)	455	if (at->clone.face != head->clone.face)
490	{	456	{
491	head->tail_x = 0;	457	head->tail_x = 0;
492	head->tail_y = 0;	458	head->tail_y = 0;
493	}	459	}
494	else	460	else
495	{	461	{
496	if (at->clone.x > head->tail_x)	462	if (at->clone.x > head->tail_x)
497	head->tail_x = at->clone.x;	463	head->tail_x = at->clone.x;
498	if (at->clone.y > head->tail_y)	464	if (at->clone.y > head->tail_y)
499	head->tail_y = at->clone.y;	465	head->tail_y = at->clone.y;
500	}	466	}
501	break;	467	break;
502		468
503	}	469	}
504		470
505	at = new archetype;	471	at = new archetype;
		472
506	at->clone.arch = at;	473	at->clone.arch = at;
507	}	474	}
508		475
509	delete at;	476	delete at;
510	}	477	}
…		…
534	cp--;	501	cp--;
535	}	502	}
536	}	503	}
537	if (!strcmp ("Object", variable))	504	if (!strcmp ("Object", variable))
538	{	505	{
539	if ((at = find_archetype (argument)) == NULL)	506	if ((at = archetype::find (argument)) == NULL)
540	LOG (llevError, "Warning: failed to find arch %s\n", argument);	507	LOG (llevError, "Warning: failed to find arch %s\n", argument);
541	}	508	}
542	else if (!strcmp ("other_arch", variable))	509	else if (!strcmp ("other_arch", variable))
543	{	510	{
544	if (at != NULL && at->clone.other_arch == NULL)	511	if (at != NULL && at->clone.other_arch == NULL)
545	{	512	{
546	if ((other = find_archetype (argument)) == NULL)	513	if ((other = archetype::find (argument)) == NULL)
547	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);	514	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
548	else if (at != NULL)	515	else if (at != NULL)
549	at->clone.other_arch = other;	516	at->clone.other_arch = other;
550	}	517	}
551	}	518	}
552	else if (!strcmp ("randomitems", variable))	519	else if (!strcmp ("randomitems", variable))
553	{	520	{
554	if (at != NULL)	521	if (at != NULL)
555	{	522	{
556	treasurelist *
557	tl = find_treasurelist (argument);	523	treasurelist *tl = find_treasurelist (argument);
		524
558	if (tl == NULL)	525	if (tl == NULL)
559	LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);	526	LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
560	else	527	else
561	at->clone.randomitems = tl;	528	at->clone.randomitems = tl;
562	}	529	}
…		…
566		533
567	#ifdef DEBUG	534	#ifdef DEBUG
568	void	535	void
569	check_generators (void)	536	check_generators (void)
570	{	537	{
571	archetype *	538	archetype *at;
572	at;	539
573	for (at = first_archetype; at != NULL; at = at->next)	540	for (at = first_archetype; at != NULL; at = at->next)
574	if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)	541	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);	542	LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
576	}	543	}
577	#endif	544	#endif
…		…
584	*/	551	*/
585		552
586	void	553	void
587	load_archetypes (void)	554	load_archetypes (void)
588	{	555	{
589	char
590	filename[MAX_BUF];	556	char filename[MAX_BUF];
591	#if TIME_ARCH_LOAD
592	struct timeval
593	tv1,
594	tv2;
595	#endif
596		557
597	sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);	558	sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
598	LOG (llevDebug, "Reading archetypes from %s:\n", filename);	559	LOG (llevDebug, "Reading archetypes from %s:\n", filename);
599		560
600	{	561	{
…		…
628		589
629	/*	590	/*
630	* Creates and returns a new object which is a copy of the given archetype.	591	* Creates and returns a new object which is a copy of the given archetype.
631	* This function returns NULL on failure.	592	* This function returns NULL on failure.
632	*/	593	*/
633
634	object *	594	object *
635	arch_to_object (archetype * at)	595	arch_to_object (archetype *at)
636	{	596	{
637	object *	597	object *op;
638	op;	598
639	if (at == NULL)	599	if (at == NULL)
640	{	600	{
641	if (warn_archetypes)	601	if (warn_archetypes)
642	LOG (llevError, "Couldn't find archetype.\n");	602	LOG (llevError, "Couldn't find archetype.\n");
		603
643	return NULL;	604	return NULL;
644	}	605	}
645	op = get_object ();	606
646	copy_object (&at->clone, op);	607	op = at->clone.clone ();
		608	op->arch = at;
647	op->instantiate ();	609	op->instantiate ();
648	op->arch = at;
649	return op;	610	return op;
650	}	611	}
651		612
652	/*	613	/*
653	* Creates an object. This function is called by get_archetype()	614	* Creates an object. This function is called by get_archetype()
654	* if it fails to find the appropriate archetype.	615	* if it fails to find the appropriate archetype.
655	* Thus get_archetype() will be guaranteed to always return	616	* Thus get_archetype() will be guaranteed to always return
656	* an object, and never NULL.	617	* an object, and never NULL.
657	*/	618	*/
658
659	object *	619	object *
660	create_singularity (const char *name)	620	create_singularity (const char *name)
661	{	621	{
662	object *op;	622	object *op;
663	char buf[MAX_BUF];	623	char buf[MAX_BUF];
		624
664	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);	625	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
665	op = get_object ();	626	op = object::create ();
666	op->name = op->name_pl = buf;	627	op->name = op->name_pl = buf;
667	SET_FLAG (op, FLAG_NO_PICK);	628	SET_FLAG (op, FLAG_NO_PICK);
668	return op;	629	return op;
669	}	630	}
670		631
…		…
674	*/	635	*/
675		636
676	object *	637	object *
677	get_archetype (const char *name)	638	get_archetype (const char *name)
678	{	639	{
679	archetype *at;	640	archetype *at = archetype::find (name);
680	at = find_archetype (name);	641
681	if (at == NULL)	642	if (!at)
682	return create_singularity (name);	643	return create_singularity (name);
		644
683	return arch_to_object (at);	645	return arch_to_object (at);
684	}	646	}
685		647
686	/*	648	/*
687	* Hash-function used by the arch-hashtable.	649	* Hash-function used by the arch-hashtable.
…		…
717	* Finds, using the hashtable, which archetype matches the given name.	679	* Finds, using the hashtable, which archetype matches the given name.
718	* returns a pointer to the found archetype, otherwise NULL.	680	* returns a pointer to the found archetype, otherwise NULL.
719	*/	681	*/
720		682
721	archetype *	683	archetype *
722	find_archetype (const char *name)	684	archetype::find (const char *name)
723	{	685	{
724	#if USE_UNORDERED_MAP
725	name = shstr::find (name);
726
727	if (!name)	686	if (!name)
728	return 0;	687	return 0;
729		688
730	HT::const_iterator i = ht.find ((size_t)name);	689	#if USE_UNORDERED_MAP
		690	AUTODECL (i, ht.find ((size_t) name));
731		691
732	if (i == ht.end ())	692	if (i == ht.end ())
733	return 0;	693	return 0;
734	else	694	else
735	return i->second;	695	return i->second;
736	#endif	696	#endif
737		697
738	archetype *at;	698	archetype *at;
739	unsigned long index;	699	unsigned long index;
740		700
741	if (name == NULL)
742	return (archetype *) NULL;
743
744	index = hasharch (name, ARCHTABLE);	701	index = hasharch (name, ARCHTABLE);
745	arch_search++;	702	arch_search++;
746	for (;;)	703	for (;;)
747	{	704	{
748	at = arch_table[index];	705	at = arch_table[index];
		706
749	if (at == NULL)	707	if (at == NULL)
750	{	708	{
751	if (warn_archetypes)	709	if (warn_archetypes)
752	LOG (llevError, "Couldn't find archetype %s\n", name);	710	LOG (llevError, "Couldn't find archetype %s\n", name);
		711
753	return NULL;	712	return NULL;
754	}	713	}
		714
755	arch_cmp++;	715	arch_cmp++;
		716
756	if (!strcmp ((const char *) at->name, name))	717	if (!strcmp ((const char *) at->name, name))
757	return at;	718	return at;
		719
758	if (++index >= ARCHTABLE)	720	if (++index >= ARCHTABLE)
759	index = 0;	721	index = 0;
760	}	722	}
761	}	723	}
762		724
763	/*	725	/*
764	* Adds an archetype to the hashtable.	726	* Adds an archetype to the hashtable.
765	*/	727	*/
766		728	void
767	static void	729	archetype::hash_add ()
768	add_arch (archetype *at)
769	{	730	{
770	#if USE_UNORDERED_MAP	731	#if USE_UNORDERED_MAP
771	ht.insert (std::make_pair ((size_t)(const char *)at->name, at));	732	ht.insert (std::make_pair ((size_t) (const char *) name, this));
772	#endif	733	#else
773		734
774	int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;	735	int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
775		736
776	for (;;)	737	for (;;)
777	{	738	{
778	if (arch_table[index] == NULL)	739	if (!arch_table[index])
779	{	740	{
780	arch_table[index] = at;	741	arch_table[index] = this;
781	return;	742	break;
782	}	743	}
783		744
784	if (++index == ARCHTABLE)	745	if (++index == ARCHTABLE)
785	index = 0;	746	index = 0;
786		747
787	if (index == org_index)	748	if (index == org_index)
788	fatal (ARCHTABLE_TOO_SMALL);	749	fatal (ARCHTABLE_TOO_SMALL);
789	}	750	}
		751	#endif
		752	}
		753
		754	void
		755	archetype::hash_del ()
		756	{
		757	#if USE_UNORDERED_MAP
		758	# error remove this from HT
		759	#else
		760
		761	int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
		762
		763	for (;;)
		764	{
		765	if (arch_table[index] == this)
		766	{
		767	arch_table[index] = 0;
		768	break;
		769	}
		770
		771	if (++index == ARCHTABLE)
		772	index = 0;
		773
		774	if (index == org_index)
		775	break;
		776	}
		777	#endif
790	}	778	}
791		779
792	/*	780	/*
793	* Returns the first archetype using the given type.	781	* Returns the first archetype using the given type.
794	* Used in treasure-generation.	782	* Used in treasure-generation.
795	*/	783	*/
796		784
797	archetype *	785	archetype *
798	type_to_archetype (int type)	786	type_to_archetype (int type)
799	{	787	{
800	archetype *	788	archetype *at;
801	at;
802		789
803	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)	790	for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
804	if (at->clone.type == type)	791	if (at->clone.type == type)
805	return at;	792	return at;
		793
806	return NULL;	794	return 0;
807	}	795	}
808		796
809	/*	797	/*
810	* Returns a new object copied from the first archetype matching	798	* Returns a new object copied from the first archetype matching
811	* the given type.	799	* the given type.
…		…
813	*/	801	*/
814		802
815	object *	803	object *
816	clone_arch (int type)	804	clone_arch (int type)
817	{	805	{
818	archetype *	806	archetype *at;
819	at;
820	object *
821	op = get_object ();
822		807
823	if ((at = type_to_archetype (type)) == NULL)	808	if ((at = type_to_archetype (type)) == NULL)
824	{	809	{
825	LOG (llevError, "Can't clone archetype %d\n", type);	810	LOG (llevError, "Can't clone archetype %d\n", type);
826	free_object (op);
827	return NULL;	811	return 0;
828	}	812	}
829	copy_object (&at->clone, op);	813
		814	object *op = at->clone.clone ();
830	op->instantiate ();	815	op->instantiate ();
831	return op;	816	return op;
832	}	817	}
833		818
834	/*	819	/*
835	* member: make instance from class	820	* member: make instance from class
836	*/	821	*/
837		822
838	object *	823	object *
839	object_create_arch (archetype * at)	824	object_create_arch (archetype *at)
840	{	825	{
841	object *	826	object op, prev = 0, *head = 0;
842	op, *
843	prev = NULL, *head = NULL;
844		827
845	while (at)	828	while (at)
846	{	829	{
847	op = arch_to_object (at);	830	op = arch_to_object (at);
848	op->x = at->clone.x;	831	op->x = at->clone.x;
849	op->y = at->clone.y;	832	op->y = at->clone.y;
		833
850	if (head)	834	if (head)
851	op->head = head, prev->more = op;	835	op->head = head, prev->more = op;
		836
852	if (!head)	837	if (!head)
853	head = op;	838	head = op;
		839
854	prev = op;	840	prev = op;
855	at = at->more;	841	at = at->more;
856	}	842	}
		843
857	return (head);	844	return (head);
858	}	845	}
859		846
860	/* end of arch.c */

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.14 by root, Fri Sep 8 17:14:07 2006 UTC vs. Revision 1.32 by root, Mon Dec 25 11:25:49 2006 UTC

Diff Legend

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.14 by root, Fri Sep 8 17:14:07 2006 UTC vs.
Revision 1.32 by root, Mon Dec 25 11:25:49 2006 UTC