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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.12 by root, Mon Sep 4 17:16:19 2006 UTC vs.
Revision 1.22 by root, Thu Sep 14 22:35:53 2006 UTC

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

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.12 by root, Mon Sep 4 17:16:19 2006 UTC vs. Revision 1.22 by root, Thu Sep 14 22:35:53 2006 UTC

Diff Legend

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.12 by root, Mon Sep 4 17:16:19 2006 UTC vs.
Revision 1.22 by root, Thu Sep 14 22:35:53 2006 UTC