[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.37 by pippijn, Mon Jan 15 21:06:18 2007 UTC

…		…
1	/*	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	/*
7	CrossFire, A Multiplayer game for X-windows	2	* CrossFire, A Multiplayer game for X-windows
8		3	*
		4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
9	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (C) 1992 Frank Tore Johansen
11		7	*
12	This program is free software; you can redistribute it and/or modify	8	* This program is free software; you can redistribute it and/or modify
13	it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
14	the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation; either version 2 of the License, or
15	(at your option) any later version.	11	* (at your option) any later version.
16		12	*
17	This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
18	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
19	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20	GNU General Public License for more details.	16	* GNU General Public License for more details.
21		17	*
22	You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
23	along with this program; if not, write to the Free Software	19	* along with this program; if not, write to the Free Software
24	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25		21	*
26	The authors can be reached via e-mail at crossfire-devel@real-time.com	22	* The authors can be reached via e-mail at <crossfire@schmorp.de>
27	*/	23	*/
28		24
29	#include <cassert>	25	#include <cassert>
30		26
31	#include <tr1/unordered_map>
32
33	#include <global.h>	27	#include <global.h>
34	#include <arch.h>
35	#include <funcpoint.h>	28	#include <funcpoint.h>
36	#include <loader.h>	29	#include <loader.h>
37		30
38	/* IF set, does a little timing on the archetype load. */	31	#define USE_UNORDERED_MAP 0
39	#define TIME_ARCH_LOAD 0
40		32
41	static void add_arch (archetype * at);	33	#if USE_UNORDERED_MAP
		34	# include <tr1/functional>
		35	# include <tr1/unordered_map>
		36	#endif
42		37
43	static archetype *arch_table[ARCHTABLE];
44	int arch_cmp = 0; /* How many strcmp's */	38	int arch_cmp = 0; /* How many strcmp's */
45	int arch_search = 0; /* How many searches */	39	int arch_search = 0; /* How many searches */
46	int arch_init; /* True if doing arch initialization */	40	int arch_init; /* True if doing arch initialization */
47		41
48	/* The naming of these functions is really poor - they are all	42	/* The naming of these functions is really poor - they are all
53	* MSW 2003-04-29	47	* MSW 2003-04-29
54	*/	48	*/
55		49
56	#if USE_UNORDERED_MAP	50	#if USE_UNORDERED_MAP
57	// the hashtable	51	// the hashtable
58	typedef std::tr1::unordered_map<size_t, archetype *> HT;	52	typedef std::tr1::unordered_map
		53	<
		54	std::size_t,
		55	arch_ptr,
		56	std::tr1::hash<size_t>,
		57	std::equal_to<size_t>,
		58	slice_allocator< std::pair<const std::size_t, archetype *> >
		59	true,
		60	> HT;
59		61
60	static HT ht;	62	static HT ht;
		63	#else
		64	static arch_ptr arch_table[ARCHTABLE];
61	#endif	65	#endif
62		66
63	/**	67	/**
64	* GROS - This function retrieves an archetype given the name that appears	68	* GROS - This function retrieves an archetype given the name that appears
65	* during the game (for example, "writing pen" instead of "stylus").	69	* during the game (for example, "writing pen" instead of "stylus").
…		…
115	* If type is -1, ew don't match on type.	119	* If type is -1, ew don't match on type.
116	*/	120	*/
117	object *	121	object *
118	get_archetype_by_skill_name (const char *skill, int type)	122	get_archetype_by_skill_name (const char *skill, int type)
119	{	123	{
120	archetype *	124	archetype *at;
121	at;
122		125
123	if (skill == NULL)	126	if (skill)
124	return NULL;
125
126	for (at = first_archetype; at != NULL; at = at->next)	127	for (at = first_archetype; at; at = at->next)
127	{
128	if (((type == -1) \|\| (type == at->clone.type)) && (!strcmp (at->clone.skill, skill)))	128	if (((type == -1) \|\| (type == at->clone.type)) && (!strcmp (at->clone.skill, skill)))
129	return arch_to_object (at);	129	return arch_to_object (at);
130	}	130
131	return NULL;	131	return 0;
132	}	132	}
133		133
134	/* similiar to above - this returns the first archetype	134	/* similiar to above - this returns the first archetype
135	* that matches both the type and subtype. type and subtype	135	* 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	136	* can be -1 to say ignore, but in this case, the match it does
…		…
165	* but it otherwise had a big memory leak.	165	* but it otherwise had a big memory leak.
166	*/	166	*/
167	object *	167	object *
168	get_archetype_by_object_name (const char *name)	168	get_archetype_by_object_name (const char *name)
169	{	169	{
170	archetype *	170	archetype *at;
171	at;
172	char
173	tmpname[MAX_BUF];	171	char tmpname[MAX_BUF];
174	int	172	int i;
175	i;
176		173
177	strncpy (tmpname, name, MAX_BUF - 1);	174	assign (tmpname, name);
178	tmpname[MAX_BUF - 1] = 0;	175
179	for (i = strlen (tmpname); i > 0; i--)	176	for (i = strlen (tmpname); i > 0; i--)
180	{	177	{
181	tmpname[i] = 0;	178	tmpname[i] = 0;
182	at = find_archetype_by_object_name (tmpname);	179	at = find_archetype_by_object_name (tmpname);
		180
183	if (at != NULL)	181	if (at)
184	{
185	return arch_to_object (at);	182	return arch_to_object (at);
186	}
187	}	183	}
		184
188	return create_singularity (name);	185	return create_singularity (name);
189	}	186	}
190		187
191	/* This is a subset of the parse_id command. Basically, name can be	188	/* 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.	189	* a string seperated lists of things to match, with certain keywords.
…		…
204	* If count is 1, make a quick check on the name.	201	* 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.	202	* IF count is >1, we need to make plural name. Return if match.
206	* Last, make a check on the full name.	203	* Last, make a check on the full name.
207	*/	204	*/
208	int	205	int
209	item_matched_string (object * pl, object * op, const char *name)	206	item_matched_string (object pl, object op, const char *name)
210	{	207	{
211	char *
212	cp,
213	local_name[MAX_BUF];	208	char *cp, local_name[MAX_BUF];
214	int	209	int count, retval = 0;
215	count,	210
216	retval = 0;
217	strcpy (local_name, name); /* strtok is destructive to name */	211	strcpy (local_name, name); /* strtok is destructive to name */
218		212
219	for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))	213	for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
220	{	214	{
221	while (cp[0] == ' ')	215	while (cp[0] == ' ')
…		…
272	retval = 15;	266	retval = 15;
273	else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))	267	else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))
274	retval = 14;	268	retval = 14;
275	else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))	269	else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))
276	retval = 14;	270	retval = 14;
277
278	/* Do substring checks, so things like 'Str+1' will match.	271	/* Do substring checks, so things like 'Str+1' will match.
279	* retval of these should perhaps be lower - they are lower	272	* retval of these should perhaps be lower - they are lower
280	* then the specific strcasecmp aboves, but still higher than	273	* then the specific strcasecmp aboves, but still higher than
281	* some other match criteria.	274	* some other match criteria.
282	*/	275	*/
…		…
284	retval = 12;	277	retval = 12;
285	else if (strstr (query_base_name (op, 0), cp))	278	else if (strstr (query_base_name (op, 0), cp))
286	retval = 12;	279	retval = 12;
287	else if (strstr (query_short_name (op), cp))	280	else if (strstr (query_short_name (op), cp))
288	retval = 12;	281	retval = 12;
289
290	/* Check against plural/non plural based on count. */	282	/* Check against plural/non plural based on count. */
291	else if (count > 1 && !strcasecmp (cp, op->name_pl))	283	else if (count > 1 && !strcasecmp (cp, op->name_pl))
292	{
293	retval = 6;	284	retval = 6;
294	}
295	else if (count == 1 && !strcasecmp (op->name, cp))	285	else if (count == 1 && !strcasecmp (op->name, cp))
296	{
297	retval = 6;	286	retval = 6;
298	}
299	/* base name matched - not bad */	287	/* base name matched - not bad */
300	else if (strcasecmp (cp, op->name) == 0 && !count)	288	else if (strcasecmp (cp, op->name) == 0 && !count)
301	retval = 4;	289	retval = 4;
302	/* Check for partial custom name, but give a real low priority */	290	/* Check for partial custom name, but give a real low priority */
303	else if (op->custom_name && strstr (op->custom_name, cp))	291	else if (op->custom_name && strstr (op->custom_name, cp))
…		…
305		293
306	if (retval)	294	if (retval)
307	{	295	{
308	if (pl->type == PLAYER)	296	if (pl->type == PLAYER)
309	pl->contr->count = count;	297	pl->contr->count = count;
		298
310	return retval;	299	return retval;
311	}	300	}
312	}	301	}
		302
313	return 0;	303	return 0;
314	}	304	}
315		305
316	/*	306	/*
317	* Initialises the internal linked list of archetypes (read from file).	307	* Initialises the internal linked list of archetypes (read from file).
…		…
322	void	312	void
323	init_archetypes (void)	313	init_archetypes (void)
324	{ /* called from add_player() and edit() */	314	{ /* called from add_player() and edit() */
325	if (first_archetype != NULL) /* Only do this once */	315	if (first_archetype != NULL) /* Only do this once */
326	return;	316	return;
		317
327	arch_init = 1;	318	arch_init = 1;
328	load_archetypes ();	319	load_archetypes ();
329	arch_init = 0;	320	arch_init = 0;
330	empty_archetype = find_archetype ("empty_archetype");	321	empty_archetype = archetype::find ("empty_archetype");
		322
331	/* init_blocksview();*/	323	/* init_blocksview();*/
332	}	324	}
333		325
334	/*	326	/*
335	* Stores debug-information about how efficient the hashtable	327	* Stores debug-information about how efficient the hashtable
336	* used for archetypes has been in the static errmsg array.	328	* used for archetypes has been in the static errmsg array.
337	*/	329	*/
338		330
339	void	331	void
340	arch_info (object * op)	332	arch_info (object *op)
341	{	333	{
342	sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp);	334	sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp);
343	new_draw_info (NDI_BLACK, 0, op, errmsg);	335	new_draw_info (NDI_BLACK, 0, op, errmsg);
344	}	336	}
345		337
…		…
363	archetype *at;	355	archetype *at;
364		356
365	LOG (llevDebug, " Setting up archetable...\n");	357	LOG (llevDebug, " Setting up archetable...\n");
366		358
367	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)	359	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
368	add_arch (at);	360	at->hash_add ();
369		361
370	LOG (llevDebug, "done\n");	362	LOG (llevDebug, "done\n");
371	}	363	}
372		364
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	365	void
402	free_all_archs (void)	366	free_all_archs (void)
403	{	367	{
404	archetype *	368	archetype at, next;
405	at, *
406	next;
407	int
408	i = 0, f = 0;	369	int i = 0, f = 0;
409		370
410	for (at = first_archetype; at != NULL; at = next)	371	for (at = first_archetype; at != NULL; at = next)
411	{	372	{
412	if (at->more)	373	if (at->more)
413	next = at->more;	374	next = at->more;
414	else	375	else
415	next = at->next;	376	next = at->next;
416		377
417	delete	378	delete
418	at;	379	at;
		380
419	i++;	381	i++;
420	}	382	}
		383
421	LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);	384	LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
422	}	385	}
423		386
424	archetype::archetype ()	387	archetype::archetype ()
425	{	388	{
426	clear_object (&clone); /* to initial state other also */
427	CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */	389	CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_to */
428	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */	390	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
429	}	391	}
430		392
431	archetype::~archetype ()	393	archetype::~archetype ()
432	{	394	{
433	}	395	}
…		…
437	* of archetype-structures.	399	* of archetype-structures.
438	*/	400	*/
439	void	401	void
440	first_arch_pass (object_thawer & fp)	402	first_arch_pass (object_thawer & fp)
441	{	403	{
442	archetype at, head = NULL, *last_more = NULL;	404	archetype head = 0, last_more = 0;
443		405
		406	archetype *at = new archetype;
444	at->clone.arch = first_archetype = at = new archetype;	407	at->clone.arch = first_archetype = at;
445		408
446	while (int i = load_object (fp, &at->clone, 0))	409	while (int i = load_object (fp, &at->clone, 0))
447	{	410	{
448	at->clone.speed_left = (float) (-0.1);	411	at->clone.speed_left = (float) (-0.1);
449	/* copy the body_info to the body_used - this is only really	412	/* copy the body_info to the body_used - this is only really
…		…
454	*/	417	*/
455	memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));	418	memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));
456		419
457	switch (i)	420	switch (i)
458	{	421	{
459	case LL_NORMAL: /* A new archetype, just link it with the previous */	422	case LL_NORMAL: /* A new archetype, just link it with the previous */
460	if (last_more != NULL)	423	if (last_more != NULL)
461	last_more->next = at;	424	last_more->next = at;
462	if (head != NULL)	425	if (head != NULL)
463	head->next = at;	426	head->next = at;
464	head = last_more = at;	427	head = last_more = at;
465	#if 0	428	#if 0
466	if (!op->type)	429	if (!op->type)
467	LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);	430	LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);
468	#endif	431	#endif
469	at->tail_x = 0;	432	at->tail_x = 0;
470	at->tail_y = 0;	433	at->tail_y = 0;
471	break;	434	break;
472		435
473	case LL_MORE: /* Another part of the previous archetype, link it correctly */	436	case LL_MORE: /* Another part of the previous archetype, link it correctly */
474		437
475	at->head = head;	438	at->head = head;
476	at->clone.head = &head->clone;	439	at->clone.head = &head->clone;
477	if (last_more != NULL)	440	if (last_more != NULL)
478	{	441	{
479	last_more->more = at;	442	last_more->more = at;
480	last_more->clone.more = &at->clone;	443	last_more->clone.more = &at->clone;
481	}	444	}
482	last_more = at;	445	last_more = at;
483		446
484	/* If this multipart image is still composed of individual small	447	/* If this multipart image is still composed of individual small
485	* images, don't set the tail_.. values. We can't use them anyways,	448	* 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	449	* 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.	450	* easier as just looking at the head, we know what to do.
488	*/	451	*/
489	if (at->clone.face != head->clone.face)	452	if (at->clone.face != head->clone.face)
490	{	453	{
491	head->tail_x = 0;	454	head->tail_x = 0;
492	head->tail_y = 0;	455	head->tail_y = 0;
493	}	456	}
494	else	457	else
495	{	458	{
496	if (at->clone.x > head->tail_x)	459	if (at->clone.x > head->tail_x)
497	head->tail_x = at->clone.x;	460	head->tail_x = at->clone.x;
498	if (at->clone.y > head->tail_y)	461	if (at->clone.y > head->tail_y)
499	head->tail_y = at->clone.y;	462	head->tail_y = at->clone.y;
500	}	463	}
501	break;	464	break;
502		465
503	}	466	}
504		467
505	at = new archetype;	468	at = new archetype;
		469
506	at->clone.arch = at;	470	at->clone.arch = at;
507	}	471	}
508		472
509	delete at;	473	delete at;
510	}	474	}
…		…
534	cp--;	498	cp--;
535	}	499	}
536	}	500	}
537	if (!strcmp ("Object", variable))	501	if (!strcmp ("Object", variable))
538	{	502	{
539	if ((at = find_archetype (argument)) == NULL)	503	if ((at = archetype::find (argument)) == NULL)
540	LOG (llevError, "Warning: failed to find arch %s\n", argument);	504	LOG (llevError, "Warning: failed to find arch %s\n", argument);
541	}	505	}
542	else if (!strcmp ("other_arch", variable))	506	else if (!strcmp ("other_arch", variable))
543	{	507	{
544	if (at != NULL && at->clone.other_arch == NULL)	508	if (at != NULL && at->clone.other_arch == NULL)
545	{	509	{
546	if ((other = find_archetype (argument)) == NULL)	510	if ((other = archetype::find (argument)) == NULL)
547	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);	511	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
548	else if (at != NULL)	512	else if (at != NULL)
549	at->clone.other_arch = other;	513	at->clone.other_arch = other;
550	}	514	}
551	}	515	}
552	else if (!strcmp ("randomitems", variable))	516	else if (!strcmp ("randomitems", variable))
553	{	517	{
554	if (at != NULL)	518	if (at != NULL)
555	{	519	{
556	treasurelist *
557	tl = find_treasurelist (argument);	520	treasurelist *tl = find_treasurelist (argument);
		521
558	if (tl == NULL)	522	if (tl == NULL)
559	LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);	523	LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
560	else	524	else
561	at->clone.randomitems = tl;	525	at->clone.randomitems = tl;
562	}	526	}
…		…
566		530
567	#ifdef DEBUG	531	#ifdef DEBUG
568	void	532	void
569	check_generators (void)	533	check_generators (void)
570	{	534	{
571	archetype *	535	archetype *at;
572	at;	536
573	for (at = first_archetype; at != NULL; at = at->next)	537	for (at = first_archetype; at != NULL; at = at->next)
574	if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)	538	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);	539	LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
576	}	540	}
577	#endif	541	#endif
…		…
584	*/	548	*/
585		549
586	void	550	void
587	load_archetypes (void)	551	load_archetypes (void)
588	{	552	{
589	char
590	filename[MAX_BUF];	553	char filename[MAX_BUF];
591	#if TIME_ARCH_LOAD
592	struct timeval
593	tv1,
594	tv2;
595	#endif
596		554
597	sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);	555	sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
598	LOG (llevDebug, "Reading archetypes from %s:\n", filename);	556	LOG (llevDebug, "Reading archetypes from %s:\n", filename);
599		557
600	{	558	{
…		…
614	object_thawer	572	object_thawer
615	thawer (filename);	573	thawer (filename);
616		574
617	LOG (llevDebug, " loading treasure...\n");	575	LOG (llevDebug, " loading treasure...\n");
618	load_treasures ();	576	load_treasures ();
		577	LOG (llevDebug, " done\n");
619	LOG (llevDebug, " done\n arch-pass 2...\n");	578	LOG (llevDebug, " arch-pass 2...\n");
620	second_arch_pass (thawer);	579	second_arch_pass (thawer);
621	LOG (llevDebug, " done\n");	580	LOG (llevDebug, " done\n");
622	#ifdef DEBUG	581	#ifdef DEBUG
623	check_generators ();	582	check_generators ();
624	#endif	583	#endif
…		…
628		587
629	/*	588	/*
630	* Creates and returns a new object which is a copy of the given archetype.	589	* Creates and returns a new object which is a copy of the given archetype.
631	* This function returns NULL on failure.	590	* This function returns NULL on failure.
632	*/	591	*/
633
634	object *	592	object *
635	arch_to_object (archetype * at)	593	arch_to_object (archetype *at)
636	{	594	{
637	object *	595	object *op;
638	op;	596
639	if (at == NULL)	597	if (at == NULL)
640	{	598	{
641	if (warn_archetypes)	599	if (warn_archetypes)
642	LOG (llevError, "Couldn't find archetype.\n");	600	LOG (llevError, "Couldn't find archetype.\n");
		601
643	return NULL;	602	return NULL;
644	}	603	}
645	op = get_object ();	604
646	copy_object (&at->clone, op);	605	op = at->clone.clone ();
		606	op->arch = at;
647	op->instantiate ();	607	op->instantiate ();
648	op->arch = at;
649	return op;	608	return op;
650	}	609	}
651		610
652	/*	611	/*
653	* Creates an object. This function is called by get_archetype()	612	* Creates an object. This function is called by get_archetype()
654	* if it fails to find the appropriate archetype.	613	* if it fails to find the appropriate archetype.
655	* Thus get_archetype() will be guaranteed to always return	614	* Thus get_archetype() will be guaranteed to always return
656	* an object, and never NULL.	615	* an object, and never NULL.
657	*/	616	*/
658
659	object *	617	object *
660	create_singularity (const char *name)	618	create_singularity (const char *name)
661	{	619	{
662	object *op;	620	object *op;
663	char buf[MAX_BUF];	621	char buf[MAX_BUF];
		622
664	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);	623	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
665	op = get_object ();	624	op = object::create ();
666	op->name = op->name_pl = buf;	625	op->name = op->name_pl = buf;
667	SET_FLAG (op, FLAG_NO_PICK);	626	SET_FLAG (op, FLAG_NO_PICK);
668	return op;	627	return op;
669	}	628	}
670		629
671	/*	630	/*
672	* Finds which archetype matches the given name, and returns a new	631	* Finds which archetype matches the given name, and returns a new
673	* object containing a copy of the archetype.	632	* object containing a copy of the archetype.
674	*/	633	*/
675
676	object *	634	object *
677	get_archetype (const char *name)	635	get_archetype (const char *name)
678	{	636	{
679	archetype *at;	637	archetype *at = archetype::find (name);
680	at = find_archetype (name);	638
681	if (at == NULL)	639	if (!at)
682	return create_singularity (name);	640	return create_singularity (name);
		641
683	return arch_to_object (at);	642	return arch_to_object (at);
684	}	643	}
685		644
686	/*	645	/*
687	* Hash-function used by the arch-hashtable.	646	* Hash-function used by the arch-hashtable.
…		…
717	* Finds, using the hashtable, which archetype matches the given name.	676	* Finds, using the hashtable, which archetype matches the given name.
718	* returns a pointer to the found archetype, otherwise NULL.	677	* returns a pointer to the found archetype, otherwise NULL.
719	*/	678	*/
720		679
721	archetype *	680	archetype *
722	find_archetype (const char *name)	681	archetype::find (const char *name)
723	{	682	{
724	#if USE_UNORDERED_MAP
725	name = shstr::find (name);
726
727	if (!name)	683	if (!name)
728	return 0;	684	return 0;
729		685
730	HT::const_iterator i = ht.find ((size_t)name);	686	#if USE_UNORDERED_MAP
		687	AUTODECL (i, ht.find ((size_t) name));
731		688
732	if (i == ht.end ())	689	if (i == ht.end ())
733	return 0;	690	return 0;
734	else	691	else
735	return i->second;	692	return i->second;
736	#endif	693	#endif
737		694
738	archetype *at;	695	archetype *at;
739	unsigned long index;	696	unsigned long index;
740		697
741	if (name == NULL)
742	return (archetype *) NULL;
743
744	index = hasharch (name, ARCHTABLE);	698	index = hasharch (name, ARCHTABLE);
745	arch_search++;	699	arch_search++;
746	for (;;)	700	for (;;)
747	{	701	{
748	at = arch_table[index];	702	at = arch_table[index];
		703
749	if (at == NULL)	704	if (at == NULL)
750	{	705	{
751	if (warn_archetypes)	706	if (warn_archetypes)
752	LOG (llevError, "Couldn't find archetype %s\n", name);	707	LOG (llevError, "Couldn't find archetype %s\n", name);
		708
753	return NULL;	709	return NULL;
754	}	710	}
		711
755	arch_cmp++;	712	arch_cmp++;
		713
756	if (!strcmp ((const char *) at->name, name))	714	if (!strcmp ((const char *) at->name, name))
757	return at;	715	return at;
		716
758	if (++index >= ARCHTABLE)	717	if (++index >= ARCHTABLE)
759	index = 0;	718	index = 0;
760	}	719	}
761	}	720	}
762		721
763	/*	722	/*
764	* Adds an archetype to the hashtable.	723	* Adds an archetype to the hashtable.
765	*/	724	*/
766		725	void
767	static void	726	archetype::hash_add ()
768	add_arch (archetype *at)
769	{	727	{
770	#if USE_UNORDERED_MAP	728	#if USE_UNORDERED_MAP
771	ht.insert (std::make_pair ((size_t)(const char *)at->name, at));	729	ht.insert (std::make_pair ((size_t) (const char *) name, this));
772	#endif	730	#else
773		731
774	int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;	732	int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
775		733
776	for (;;)	734	for (;;)
777	{	735	{
778	if (arch_table[index] == NULL)	736	if (!arch_table[index])
779	{	737	{
780	arch_table[index] = at;	738	arch_table[index] = this;
781	return;	739	break;
782	}	740	}
783		741
784	if (++index == ARCHTABLE)	742	if (++index == ARCHTABLE)
785	index = 0;	743	index = 0;
786		744
787	if (index == org_index)	745	if (index == org_index)
788	fatal (ARCHTABLE_TOO_SMALL);	746	fatal (ARCHTABLE_TOO_SMALL);
789	}	747	}
		748	#endif
		749	}
		750
		751	void
		752	archetype::hash_del ()
		753	{
		754	#if USE_UNORDERED_MAP
		755	# error remove this from HT
		756	#else
		757
		758	int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
		759
		760	for (;;)
		761	{
		762	if (arch_table[index] == this)
		763	{
		764	arch_table[index] = 0;
		765	break;
		766	}
		767
		768	if (++index == ARCHTABLE)
		769	index = 0;
		770
		771	if (index == org_index)
		772	break;
		773	}
		774	#endif
790	}	775	}
791		776
792	/*	777	/*
793	* Returns the first archetype using the given type.	778	* Returns the first archetype using the given type.
794	* Used in treasure-generation.	779	* Used in treasure-generation.
795	*/	780	*/
796		781
797	archetype *	782	archetype *
798	type_to_archetype (int type)	783	type_to_archetype (int type)
799	{	784	{
800	archetype *	785	archetype *at;
801	at;
802		786
803	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)	787	for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
804	if (at->clone.type == type)	788	if (at->clone.type == type)
805	return at;	789	return at;
		790
806	return NULL;	791	return 0;
807	}	792	}
808		793
809	/*	794	/*
810	* Returns a new object copied from the first archetype matching	795	* Returns a new object copied from the first archetype matching
811	* the given type.	796	* the given type.
…		…
813	*/	798	*/
814		799
815	object *	800	object *
816	clone_arch (int type)	801	clone_arch (int type)
817	{	802	{
818	archetype *	803	archetype *at;
819	at;
820	object *
821	op = get_object ();
822		804
823	if ((at = type_to_archetype (type)) == NULL)	805	if ((at = type_to_archetype (type)) == NULL)
824	{	806	{
825	LOG (llevError, "Can't clone archetype %d\n", type);	807	LOG (llevError, "Can't clone archetype %d\n", type);
826	free_object (op);
827	return NULL;	808	return 0;
828	}	809	}
829	copy_object (&at->clone, op);	810
		811	object *op = at->clone.clone ();
830	op->instantiate ();	812	op->instantiate ();
831	return op;	813	return op;
832	}	814	}
833		815
834	/*	816	/*
835	* member: make instance from class	817	* member: make instance from class
836	*/	818	*/
837		819
838	object *	820	object *
839	object_create_arch (archetype * at)	821	object_create_arch (archetype *at)
840	{	822	{
841	object *	823	object op, prev = 0, *head = 0;
842	op, *
843	prev = NULL, *head = NULL;
844		824
845	while (at)	825	while (at)
846	{	826	{
847	op = arch_to_object (at);	827	op = arch_to_object (at);
848	op->x = at->clone.x;	828	op->x = at->clone.x;
849	op->y = at->clone.y;	829	op->y = at->clone.y;
		830
850	if (head)	831	if (head)
851	op->head = head, prev->more = op;	832	op->head = head, prev->more = op;
		833
852	if (!head)	834	if (!head)
853	head = op;	835	head = op;
		836
854	prev = op;	837	prev = op;
855	at = at->more;	838	at = at->more;
856	}	839	}
		840
857	return (head);	841	return (head);
858	}	842	}
859		843
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.37 by pippijn, Mon Jan 15 21:06:18 2007 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.37 by pippijn, Mon Jan 15 21:06:18 2007 UTC