[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.24 by root, Sat Sep 16 22:24:12 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>	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	archetype::archetype ()	417	archetype::archetype ()
425	{	418	{
426	clear_object (&clone); /* to initial state other also */	419	clear_object (&clone); /* to initial state other also */
427	CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */	420	CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */
428	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */	421	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
429	}	422	}
430		423
431	archetype::~archetype ()	424	archetype::~archetype ()
432	{	425	{
433	}	426	}
…		…
454	*/	447	*/
455	memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));	448	memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));
456		449
457	switch (i)	450	switch (i)
458	{	451	{
459	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 */
460	if (last_more != NULL)	453	if (last_more != NULL)
461	last_more->next = at;	454	last_more->next = at;
462	if (head != NULL)	455	if (head != NULL)
463	head->next = at;	456	head->next = at;
464	head = last_more = at;	457	head = last_more = at;
465	#if 0	458	#if 0
466	if (!op->type)	459	if (!op->type)
467	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);
468	#endif	461	#endif
469	at->tail_x = 0;	462	at->tail_x = 0;
470	at->tail_y = 0;	463	at->tail_y = 0;
471	break;	464	break;
472		465
473	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 */
474		467
475	at->head = head;	468	at->head = head;
476	at->clone.head = &head->clone;	469	at->clone.head = &head->clone;
477	if (last_more != NULL)	470	if (last_more != NULL)
478	{	471	{
479	last_more->more = at;	472	last_more->more = at;
480	last_more->clone.more = &at->clone;	473	last_more->clone.more = &at->clone;
481	}	474	}
482	last_more = at;	475	last_more = at;
483		476
484	/* If this multipart image is still composed of individual small	477	/* If this multipart image is still composed of individual small
485	* 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,
486	* 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
487	* 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.
488	*/	481	*/
489	if (at->clone.face != head->clone.face)	482	if (at->clone.face != head->clone.face)
490	{	483	{
491	head->tail_x = 0;	484	head->tail_x = 0;
492	head->tail_y = 0;	485	head->tail_y = 0;
493	}	486	}
494	else	487	else
495	{	488	{
496	if (at->clone.x > head->tail_x)	489	if (at->clone.x > head->tail_x)
497	head->tail_x = at->clone.x;	490	head->tail_x = at->clone.x;
498	if (at->clone.y > head->tail_y)	491	if (at->clone.y > head->tail_y)
499	head->tail_y = at->clone.y;	492	head->tail_y = at->clone.y;
500	}	493	}
501	break;	494	break;
502		495
503	}	496	}
504		497
505	at = new archetype;	498	at = new archetype;
		499
506	at->clone.arch = at;	500	at->clone.arch = at;
507	}	501	}
508		502
509	delete at;	503	delete at;
510	}	504	}
…		…
534	cp--;	528	cp--;
535	}	529	}
536	}	530	}
537	if (!strcmp ("Object", variable))	531	if (!strcmp ("Object", variable))
538	{	532	{
539	if ((at = find_archetype (argument)) == NULL)	533	if ((at = archetype::find (argument)) == NULL)
540	LOG (llevError, "Warning: failed to find arch %s\n", argument);	534	LOG (llevError, "Warning: failed to find arch %s\n", argument);
541	}	535	}
542	else if (!strcmp ("other_arch", variable))	536	else if (!strcmp ("other_arch", variable))
543	{	537	{
544	if (at != NULL && at->clone.other_arch == NULL)	538	if (at != NULL && at->clone.other_arch == NULL)
545	{	539	{
546	if ((other = find_archetype (argument)) == NULL)	540	if ((other = archetype::find (argument)) == NULL)
547	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);	541	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
548	else if (at != NULL)	542	else if (at != NULL)
549	at->clone.other_arch = other;	543	at->clone.other_arch = other;
550	}	544	}
551	}	545	}
552	else if (!strcmp ("randomitems", variable))	546	else if (!strcmp ("randomitems", variable))
553	{	547	{
554	if (at != NULL)	548	if (at != NULL)
555	{	549	{
556	treasurelist *
557	tl = find_treasurelist (argument);	550	treasurelist *tl = find_treasurelist (argument);
		551
558	if (tl == NULL)	552	if (tl == NULL)
559	LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);	553	LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
560	else	554	else
561	at->clone.randomitems = tl;	555	at->clone.randomitems = tl;
562	}	556	}
…		…
566		560
567	#ifdef DEBUG	561	#ifdef DEBUG
568	void	562	void
569	check_generators (void)	563	check_generators (void)
570	{	564	{
571	archetype *	565	archetype *at;
572	at;	566
573	for (at = first_archetype; at != NULL; at = at->next)	567	for (at = first_archetype; at != NULL; at = at->next)
574	if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)	568	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);	569	LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
576	}	570	}
577	#endif	571	#endif
…		…
584	*/	578	*/
585		579
586	void	580	void
587	load_archetypes (void)	581	load_archetypes (void)
588	{	582	{
589	char
590	filename[MAX_BUF];	583	char filename[MAX_BUF];
		584
591	#if TIME_ARCH_LOAD	585	#if TIME_ARCH_LOAD
592	struct timeval	586	struct timeval
593	tv1,	587	tv1,
594	tv2;	588	tv2;
595	#endif	589	#endif
…		…
630	* Creates and returns a new object which is a copy of the given archetype.	624	* Creates and returns a new object which is a copy of the given archetype.
631	* This function returns NULL on failure.	625	* This function returns NULL on failure.
632	*/	626	*/
633		627
634	object *	628	object *
635	arch_to_object (archetype * at)	629	arch_to_object (archetype *at)
636	{	630	{
637	object *	631	object *op;
638	op;	632
639	if (at == NULL)	633	if (at == NULL)
640	{	634	{
641	if (warn_archetypes)	635	if (warn_archetypes)
642	LOG (llevError, "Couldn't find archetype.\n");	636	LOG (llevError, "Couldn't find archetype.\n");
		637
643	return NULL;	638	return NULL;
644	}	639	}
		640
645	op = get_object ();	641	op = get_object ();
646	copy_object (&at->clone, op);	642	copy_object (&at->clone, op);
		643	op->arch = at;
647	op->instantiate ();	644	op->instantiate ();
648	op->arch = at;
649	return op;	645	return op;
650	}	646	}
651		647
652	/*	648	/*
653	* Creates an object. This function is called by get_archetype()	649	* Creates an object. This function is called by get_archetype()
…		…
659	object *	655	object *
660	create_singularity (const char *name)	656	create_singularity (const char *name)
661	{	657	{
662	object *op;	658	object *op;
663	char buf[MAX_BUF];	659	char buf[MAX_BUF];
		660
664	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);	661	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
665	op = get_object ();	662	op = get_object ();
666	op->name = op->name_pl = buf;	663	op->name = op->name_pl = buf;
667	SET_FLAG (op, FLAG_NO_PICK);	664	SET_FLAG (op, FLAG_NO_PICK);
668	return op;	665	return op;
…		…
674	*/	671	*/
675		672
676	object *	673	object *
677	get_archetype (const char *name)	674	get_archetype (const char *name)
678	{	675	{
679	archetype *at;	676	archetype *at = archetype::find (name);
680	at = find_archetype (name);	677
681	if (at == NULL)	678	if (!at)
682	return create_singularity (name);	679	return create_singularity (name);
		680
683	return arch_to_object (at);	681	return arch_to_object (at);
684	}	682	}
685		683
686	/*	684	/*
687	* Hash-function used by the arch-hashtable.	685	* Hash-function used by the arch-hashtable.
…		…
717	* Finds, using the hashtable, which archetype matches the given name.	715	* Finds, using the hashtable, which archetype matches the given name.
718	* returns a pointer to the found archetype, otherwise NULL.	716	* returns a pointer to the found archetype, otherwise NULL.
719	*/	717	*/
720		718
721	archetype *	719	archetype *
722	find_archetype (const char *name)	720	archetype::find (const char *name)
723	{	721	{
724	#if USE_UNORDERED_MAP
725	name = shstr::find (name);
726
727	if (!name)	722	if (!name)
728	return 0;	723	return 0;
729		724
730	HT::const_iterator i = ht.find ((size_t)name);	725	#if USE_UNORDERED_MAP
		726	AUTODECL (i, ht.find ((size_t) name));
731		727
732	if (i == ht.end ())	728	if (i == ht.end ())
733	return 0;	729	return 0;
734	else	730	else
735	return i->second;	731	return i->second;
736	#endif	732	#endif
737		733
738	archetype *at;	734	archetype *at;
739	unsigned long index;	735	unsigned long index;
740		736
741	if (name == NULL)
742	return (archetype *) NULL;
743
744	index = hasharch (name, ARCHTABLE);	737	index = hasharch (name, ARCHTABLE);
745	arch_search++;	738	arch_search++;
746	for (;;)	739	for (;;)
747	{	740	{
748	at = arch_table[index];	741	at = arch_table[index];
		742
749	if (at == NULL)	743	if (at == NULL)
750	{	744	{
751	if (warn_archetypes)	745	if (warn_archetypes)
752	LOG (llevError, "Couldn't find archetype %s\n", name);	746	LOG (llevError, "Couldn't find archetype %s\n", name);
		747
753	return NULL;	748	return NULL;
754	}	749	}
		750
755	arch_cmp++;	751	arch_cmp++;
		752
756	if (!strcmp ((const char *) at->name, name))	753	if (!strcmp ((const char *) at->name, name))
757	return at;	754	return at;
		755
758	if (++index >= ARCHTABLE)	756	if (++index >= ARCHTABLE)
759	index = 0;	757	index = 0;
760	}	758	}
761	}	759	}
762		760
…		…
766		764
767	static void	765	static void
768	add_arch (archetype *at)	766	add_arch (archetype *at)
769	{	767	{
770	#if USE_UNORDERED_MAP	768	#if USE_UNORDERED_MAP
771	ht.insert (std::make_pair ((size_t)(const char *)at->name, at));	769	ht.insert (std::make_pair ((size_t) (const char *) at->name, at));
772	#endif	770	#endif
773		771
774	int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;	772	int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;
775		773
776	for (;;)	774	for (;;)
…		…
795	*/	793	*/
796		794
797	archetype *	795	archetype *
798	type_to_archetype (int type)	796	type_to_archetype (int type)
799	{	797	{
800	archetype *	798	archetype *at;
801	at;
802		799
803	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)	800	for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
804	if (at->clone.type == type)	801	if (at->clone.type == type)
805	return at;	802	return at;
		803
806	return NULL;	804	return 0;
807	}	805	}
808		806
809	/*	807	/*
810	* Returns a new object copied from the first archetype matching	808	* Returns a new object copied from the first archetype matching
811	* the given type.	809	* the given type.
…		…
813	*/	811	*/
814		812
815	object *	813	object *
816	clone_arch (int type)	814	clone_arch (int type)
817	{	815	{
818	archetype *	816	archetype *at;
819	at;
820	object *
821	op = get_object ();	817	object *op = get_object ();
822		818
823	if ((at = type_to_archetype (type)) == NULL)	819	if ((at = type_to_archetype (type)) == NULL)
824	{	820	{
825	LOG (llevError, "Can't clone archetype %d\n", type);	821	LOG (llevError, "Can't clone archetype %d\n", type);
826	free_object (op);	822	free_object (op);
827	return NULL;	823	return NULL;
828	}	824	}
		825
829	copy_object (&at->clone, op);	826	copy_object (&at->clone, op);
830	op->instantiate ();	827	op->instantiate ();
831	return op;	828	return op;
832	}	829	}
833		830
834	/*	831	/*
835	* member: make instance from class	832	* member: make instance from class
836	*/	833	*/
837		834
838	object *	835	object *
839	object_create_arch (archetype * at)	836	object_create_arch (archetype *at)
840	{	837	{
841	object *	838	object op, prev = 0, *head = 0;
842	op, *
843	prev = NULL, *head = NULL;
844		839
845	while (at)	840	while (at)
846	{	841	{
847	op = arch_to_object (at);	842	op = arch_to_object (at);
848	op->x = at->clone.x;	843	op->x = at->clone.x;
849	op->y = at->clone.y;	844	op->y = at->clone.y;
		845
850	if (head)	846	if (head)
851	op->head = head, prev->more = op;	847	op->head = head, prev->more = op;
		848
852	if (!head)	849	if (!head)
853	head = op;	850	head = op;
		851
854	prev = op;	852	prev = op;
855	at = at->more;	853	at = at->more;
856	}	854	}
		855
857	return (head);	856	return (head);
858	}	857	}
859		858
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.24 by root, Sat Sep 16 22:24:12 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.24 by root, Sat Sep 16 22:24:12 2006 UTC