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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.11 by root, Sun Sep 3 22:45:55 2006 UTC vs.
Revision 1.35 by root, Wed Jan 3 20:32:13 2007 UTC

…		…
1	/*
2	* static char *rcsid_arch_c =
3	* "$Id: arch.C,v 1.11 2006/09/03 22:45:55 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
		24	#include <cassert>
		25
29	#include <global.h>	26	#include <global.h>
30	#include <arch.h>
31	#include <funcpoint.h>	27	#include <funcpoint.h>
32	#include <loader.h>	28	#include <loader.h>
33		29
34	#include <cassert>	30	#define USE_UNORDERED_MAP 0
35		31
36	/* IF set, does a little timing on the archetype load. */	32	#if USE_UNORDERED_MAP
37	#define TIME_ARCH_LOAD 0	33	# include <tr1/functional>
		34	# include <tr1/unordered_map>
		35	#endif
38		36
39	static void add_arch(archetype *at);
40
41	static archetype *arch_table[ARCHTABLE];
42	int arch_cmp=0; /* How many strcmp's */	37	int arch_cmp = 0; /* How many strcmp's */
43	int arch_search=0; /* How many searches */	38	int arch_search = 0; /* How many searches */
44	int arch_init; /* True if doing arch initialization */	39	int arch_init; /* True if doing arch initialization */
45		40
46	/* The naming of these functions is really poor - they are all	41	/* The naming of these functions is really poor - they are all
47	* pretty much named '.._arch_...', but they may more may not	42	* pretty much named '.._arch_...', but they may more may not
48	* return archetypes. Some make the arch_to_object call, and thus	43	* return archetypes. Some make the arch_to_object call, and thus
49	* return an object. Perhaps those should be called 'archob' functions	44	* return an object. Perhaps those should be called 'archob' functions
50	* to denote they return an object derived from the archetype.	45	* to denote they return an object derived from the archetype.
51	* MSW 2003-04-29	46	* MSW 2003-04-29
52	*/	47	*/
		48
		49	#if USE_UNORDERED_MAP
		50	// the hashtable
		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;
		60
		61	static HT ht;
		62	#else
		63	static arch_ptr arch_table[ARCHTABLE];
		64	#endif
53		65
54	/**	66	/**
55	* GROS - This function retrieves an archetype given the name that appears	67	* GROS - This function retrieves an archetype given the name that appears
56	* during the game (for example, "writing pen" instead of "stylus").	68	* during the game (for example, "writing pen" instead of "stylus").
57	* It does not use the hashtable system, but browse the whole archlist each time.	69	* It does not use the hashtable system, but browse the whole archlist each time.
…		…
60	* Params:	72	* Params:
61	* - name: the name we're searching for (ex: "writing pen");	73	* - name: the name we're searching for (ex: "writing pen");
62	* Return value:	74	* Return value:
63	* - the archetype found or null if nothing was found.	75	* - the archetype found or null if nothing was found.
64	*/	76	*/
		77	archetype *
65	archetype find_archetype_by_object_name(const char name) {	78	find_archetype_by_object_name (const char *name)
		79	{
66	archetype *at;	80	archetype *at;
67		81
68	if (name == NULL)	82	if (name == NULL)
69	return (archetype *) NULL;	83	return (archetype *) NULL;
70		84
71	for(at = first_archetype;at!=NULL;at=at->next) {	85	for (at = first_archetype; at != NULL; at = at->next)
		86	{
72	if (!strcmp(at->clone.name, name))	87	if (!strcmp (at->clone.name, name))
73	return at;	88	return at;
74	}	89	}
75	return NULL;	90	return NULL;
76	}	91	}
77		92
78	/**	93	/**
79	* This function retrieves an archetype by type and name that appears during	94	* This function retrieves an archetype by type and name that appears during
80	* the game. It is basically the same as find_archetype_by_object_name()	95	* the game. It is basically the same as find_archetype_by_object_name()
81	* except that it considers only items of the given type.	96	* except that it considers only items of the given type.
82	*/	97	*/
		98	archetype *
83	archetype find_archetype_by_object_type_name(int type, const char name) {	99	find_archetype_by_object_type_name (int type, const char *name)
		100	{
84	archetype *at;	101	archetype *at;
85		102
86	if (name == NULL)	103	if (name == NULL)
87	return NULL;
88
89	for (at = first_archetype; at != NULL; at = at->next) {
90	if (at->clone.type == type && strcmp(at->clone.name, name) == 0)
91	return at;
92	}
93
94	return NULL;	104	return NULL;
		105
		106	for (at = first_archetype; at != NULL; at = at->next)
		107	{
		108	if (at->clone.type == type && strcmp (at->clone.name, name) == 0)
		109	return at;
		110	}
		111
		112	return NULL;
95	}	113	}
96		114
97	/* This is a lot like the above function. Instead, we are trying to match	115	/* This is a lot like the above function. Instead, we are trying to match
98	* the arch->skill values. type is the type of object to match	116	* the arch->skill values. type is the type of object to match
99	* against (eg, to only match against skills or only skill objects for example).	117	* against (eg, to only match against skills or only skill objects for example).
100	* If type is -1, ew don't match on type.	118	* If type is -1, ew don't match on type.
101	*/	119	*/
		120	object *
102	object get_archetype_by_skill_name(const char skill, int type) {	121	get_archetype_by_skill_name (const char *skill, int type)
		122	{
103	archetype *at;	123	archetype *at;
104		124
105	if (skill == NULL)	125	if (skill)
106	return NULL;
107
108	for(at = first_archetype;at!=NULL;at=at->next) {	126	for (at = first_archetype; at; at = at->next)
109	if ( ((type == -1) \|\| (type == at->clone.type)) &&	127	if (((type == -1) \|\| (type == at->clone.type)) && (!strcmp (at->clone.skill, skill)))
110	(!strcmp(at->clone.skill, skill)))
111	return arch_to_object(at);	128	return arch_to_object (at);
112	}	129
113	return NULL;	130	return 0;
114	}	131	}
115		132
116	/* similiar to above - this returns the first archetype	133	/* similiar to above - this returns the first archetype
117	* that matches both the type and subtype. type and subtype	134	* that matches both the type and subtype. type and subtype
118	* can be -1 to say ignore, but in this case, the match it does	135	* can be -1 to say ignore, but in this case, the match it does
119	* may not be very useful. This function is most useful when	136	* may not be very useful. This function is most useful when
120	* subtypes are known to be unique for a particular type	137	* subtypes are known to be unique for a particular type
121	* (eg, skills)	138	* (eg, skills)
122	*/	139	*/
		140	archetype *
123	archetype *get_archetype_by_type_subtype(int type, int subtype) {	141	get_archetype_by_type_subtype (int type, int subtype)
		142	{
124	archetype *at;	143	archetype *
		144	at;
125		145
126	for(at = first_archetype;at!=NULL;at=at->next) {	146	for (at = first_archetype; at != NULL; at = at->next)
127	if ( ((type == -1) \|\| (type == at->clone.type)) &&	147	{
128	(subtype == -1 \|\| subtype == at->clone.subtype))	148	if (((type == -1) \|\| (type == at->clone.type)) && (subtype == -1 \|\| subtype == at->clone.subtype))
129	return at;	149	return at;
130	}	150	}
131	return NULL;	151	return NULL;
132	}	152	}
133		153
134	/**	154	/**
135	* GROS - this returns a new object given the name that appears during the game	155	* GROS - this returns a new object given the name that appears during the game
136	* (for example, "writing pen" instead of "stylus").	156	* (for example, "writing pen" instead of "stylus").
…		…
141	* Note by MSW - it appears that it takes the full name and keeps	161	* Note by MSW - it appears that it takes the full name and keeps
142	* shortening it until it finds a match. I re-wrote this so that it	162	* shortening it until it finds a match. I re-wrote this so that it
143	* doesn't malloc it each time - not that this function is used much,	163	* doesn't malloc it each time - not that this function is used much,
144	* but it otherwise had a big memory leak.	164	* but it otherwise had a big memory leak.
145	*/	165	*/
		166	object *
146	object get_archetype_by_object_name(const char name) {	167	get_archetype_by_object_name (const char *name)
		168	{
147	archetype *at;	169	archetype *at;
148	char tmpname[MAX_BUF];	170	char tmpname[MAX_BUF];
149	int i;	171	int i;
150		172
151	strncpy(tmpname,name,MAX_BUF-1);	173	assign (tmpname, name);
152	tmpname[MAX_BUF-1] = 0;	174
153	for(i=strlen(tmpname); i>0; i--) {	175	for (i = strlen (tmpname); i > 0; i--)
		176	{
154	tmpname[i] = 0;	177	tmpname[i] = 0;
155	at = find_archetype_by_object_name(tmpname);	178	at = find_archetype_by_object_name (tmpname);
156	if (at !=NULL)	179
157	{	180	if (at)
158	return arch_to_object(at);	181	return arch_to_object (at);
159	}
160	}	182	}
		183
161	return create_singularity(name);	184	return create_singularity (name);
162	}	185	}
163		186
164	/* This is a subset of the parse_id command. Basically, name can be	187	/* This is a subset of the parse_id command. Basically, name can be
165	* a string seperated lists of things to match, with certain keywords.	188	* a string seperated lists of things to match, with certain keywords.
166	* pl is the player (only needed to set count properly)	189	* pl is the player (only needed to set count properly)
…		…
176	* player object.)	199	* player object.)
177	* If count is 1, make a quick check on the name.	200	* If count is 1, make a quick check on the name.
178	* IF count is >1, we need to make plural name. Return if match.	201	* IF count is >1, we need to make plural name. Return if match.
179	* Last, make a check on the full name.	202	* Last, make a check on the full name.
180	*/	203	*/
		204	int
181	int item_matched_string(object pl, object op, const char *name)	205	item_matched_string (object pl, object op, const char *name)
182	{	206	{
183	char *cp, local_name[MAX_BUF];	207	char *cp, local_name[MAX_BUF];
184	int count,retval=0;	208	int count, retval = 0;
		209
185	strcpy(local_name, name); /* strtok is destructive to name */	210	strcpy (local_name, name); /* strtok is destructive to name */
186		211
187	for (cp=strtok(local_name,","); cp; cp=strtok(NULL,",")) {	212	for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
188	while (cp[0]==' ') ++cp; /* get rid of spaces */	213	{
		214	while (cp[0] == ' ')
		215	++cp; /* get rid of spaces */
189		216
190	/* LOG(llevDebug,"Trying to match %s\n", cp);*/	217	/* LOG(llevDebug,"Trying to match %s\n", cp); */
191	/* All is a very generic match - low match value */	218	/* All is a very generic match - low match value */
192	if (!strcmp(cp,"all")) return 1;	219	if (!strcmp (cp, "all"))
		220	return 1;
193		221
194	/* unpaid is a little more specific */	222	/* unpaid is a little more specific */
195	if (!strcmp(cp,"unpaid") && QUERY_FLAG(op,FLAG_UNPAID)) return 2;	223	if (!strcmp (cp, "unpaid") && QUERY_FLAG (op, FLAG_UNPAID))
196	if (!strcmp(cp,"cursed") && QUERY_FLAG(op,FLAG_KNOWN_CURSED) &&
197	(QUERY_FLAG(op,FLAG_CURSED) \|\|QUERY_FLAG(op,FLAG_DAMNED)))
198	return 2;	224	return 2;
		225	if (!strcmp (cp, "cursed") && QUERY_FLAG (op, FLAG_KNOWN_CURSED) && (QUERY_FLAG (op, FLAG_CURSED) \|\| QUERY_FLAG (op, FLAG_DAMNED)))
		226	return 2;
199		227
200	if (!strcmp(cp,"unlocked") && !QUERY_FLAG(op, FLAG_INV_LOCKED))	228	if (!strcmp (cp, "unlocked") && !QUERY_FLAG (op, FLAG_INV_LOCKED))
201	return 2;	229	return 2;
202		230
203	/* Allow for things like '100 arrows' */	231	/* Allow for things like '100 arrows' */
204	if ((count=atoi(cp))!=0) {	232	if ((count = atoi (cp)) != 0)
		233	{
205	cp=strchr(cp, ' ');	234	cp = strchr (cp, ' ');
206	while (cp && cp[0]==' ') ++cp; /* get rid of spaces */	235	while (cp && cp[0] == ' ')
		236	++cp; /* get rid of spaces */
		237	}
		238	else
207	}	239	{
208	else {
209	if (pl->type==PLAYER)	240	if (pl->type == PLAYER)
210	count=pl->contr->count;	241	count = pl->contr->count;
211	else	242	else
212	count = 0;	243	count = 0;
213	}	244	}
214		245
215	if (!cp \|\| cp[0]=='\0' \|\| count<0) return 0;	246	if (!cp \|\| cp[0] == '\0' \|\| count < 0)
		247	return 0;
216		248
217		249
218	/* The code here should go from highest retval to lowest. That	250	/* The code here should go from highest retval to lowest. That
219	* is because of the 'else' handling - we don't want to match on	251	* is because of the 'else' handling - we don't want to match on
220	* something and set a low retval, even though it may match a higher retcal	252	* something and set a low retval, even though it may match a higher retcal
221	* later. So keep it in descending order here, so we try for the best	253	* later. So keep it in descending order here, so we try for the best
222	* match first, and work downward.	254	* match first, and work downward.
223	*/	255	*/
224	if (!strcasecmp(cp,query_name(op))) retval=20;	256	if (!strcasecmp (cp, query_name (op)))
		257	retval = 20;
225	else if (!strcasecmp(cp,query_short_name(op))) retval=18;	258	else if (!strcasecmp (cp, query_short_name (op)))
226	else if (!strcasecmp(cp,query_base_name(op,0))) retval=16;	259	retval = 18;
227	else if (!strcasecmp(cp,query_base_name(op,1))) retval=16;
228	else if (op->custom_name && !strcasecmp(cp,op->custom_name)) retval=15;
229	else if (!strncasecmp(cp,query_base_name(op,0),	260	else if (!strcasecmp (cp, query_base_name (op, 0)))
230	strlen(cp))) retval=14;	261	retval = 16;
231	else if (!strncasecmp(cp,query_base_name(op,1),	262	else if (!strcasecmp (cp, query_base_name (op, 1)))
232	strlen(cp))) retval=14;	263	retval = 16;
233		264	else if (op->custom_name && !strcasecmp (cp, op->custom_name))
		265	retval = 15;
		266	else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))
		267	retval = 14;
		268	else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))
		269	retval = 14;
234	/* Do substring checks, so things like 'Str+1' will match.	270	/* Do substring checks, so things like 'Str+1' will match.
235	* retval of these should perhaps be lower - they are lower	271	* retval of these should perhaps be lower - they are lower
236	* then the specific strcasecmp aboves, but still higher than	272	* then the specific strcasecmp aboves, but still higher than
237	* some other match criteria.	273	* some other match criteria.
238	*/	274	*/
239	else if (strstr(query_base_name(op,1), cp)) retval = 12;	275	else if (strstr (query_base_name (op, 1), cp))
		276	retval = 12;
240	else if (strstr(query_base_name(op,0), cp)) retval = 12;	277	else if (strstr (query_base_name (op, 0), cp))
		278	retval = 12;
241	else if (strstr(query_short_name(op), cp)) retval = 12;	279	else if (strstr (query_short_name (op), cp))
242		280	retval = 12;
243	/* Check against plural/non plural based on count. */	281	/* Check against plural/non plural based on count. */
244	else if (count>1 && !strcasecmp(cp,op->name_pl)) {	282	else if (count > 1 && !strcasecmp (cp, op->name_pl))
245	retval=6;	283	retval = 6;
246	}
247	else if (count==1 && !strcasecmp(op->name,cp)) {	284	else if (count == 1 && !strcasecmp (op->name, cp))
248	retval=6;	285	retval = 6;
249	}
250	/* base name matched - not bad */	286	/* base name matched - not bad */
251	else if (strcasecmp(cp,op->name)==0 && !count) retval=4;	287	else if (strcasecmp (cp, op->name) == 0 && !count)
		288	retval = 4;
252	/* Check for partial custom name, but give a real low priority */	289	/* Check for partial custom name, but give a real low priority */
253	else if (op->custom_name && strstr(op->custom_name, cp)) retval = 3;	290	else if (op->custom_name && strstr (op->custom_name, cp))
		291	retval = 3;
254		292
255	if (retval) {	293	if (retval)
		294	{
256	if (pl->type == PLAYER)	295	if (pl->type == PLAYER)
257	pl->contr->count=count;	296	pl->contr->count = count;
		297
258	return retval;	298	return retval;
259	}	299	}
260	}	300	}
		301
261	return 0;	302	return 0;
262	}	303	}
263		304
264	/*	305	/*
265	* Initialises the internal linked list of archetypes (read from file).	306	* Initialises the internal linked list of archetypes (read from file).
266	* Then the global "empty_archetype" pointer is initialised.	307	* Then the global "empty_archetype" pointer is initialised.
267	* Then the blocksview[] array is initialised.	308	* Then the blocksview[] array is initialised.
268	*/	309	*/
269		310
270	void init_archetypes(void) { /* called from add_player() and edit() */	311	void
		312	init_archetypes (void)
		313	{ /* called from add_player() and edit() */
271	if(first_archetype!=NULL) /* Only do this once */	314	if (first_archetype != NULL) /* Only do this once */
272	return;	315	return;
		316
273	arch_init = 1;	317	arch_init = 1;
274	load_archetypes();	318	load_archetypes ();
275	arch_init = 0;	319	arch_init = 0;
276	empty_archetype=find_archetype("empty_archetype");	320	empty_archetype = archetype::find ("empty_archetype");
		321
277	/* init_blocksview();*/	322	/* init_blocksview();*/
278	}	323	}
279		324
280	/*	325	/*
281	* Stores debug-information about how efficient the hashtable	326	* Stores debug-information about how efficient the hashtable
282	* used for archetypes has been in the static errmsg array.	327	* used for archetypes has been in the static errmsg array.
283	*/	328	*/
284		329
		330	void
285	void arch_info(object *op) {	331	arch_info (object *op)
		332	{
286	sprintf(errmsg,"%d searches and %d strcmp()'s",arch_search,arch_cmp);	333	sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp);
287	new_draw_info(NDI_BLACK, 0, op,errmsg);	334	new_draw_info (NDI_BLACK, 0, op, errmsg);
288	}	335	}
289		336
290	/*	337	/*
291	* Initialise the hashtable used by the archetypes.	338	* Initialise the hashtable used by the archetypes.
292	*/	339	*/
293		340
		341	void
294	void clear_archetable(void) {	342	clear_archetable (void)
		343	{
295	memset((void ) arch_table,0,ARCHTABLEsizeof(archetype *));	344	memset ((void ) arch_table, 0, ARCHTABLE sizeof (archetype *));
296	}	345	}
297		346
298	/*	347	/*
299	* An alternative way to init the hashtable which is slower, but _works_...	348	* An alternative way to init the hashtable which is slower, but _works_...
300	*/	349	*/
301		350
		351	void
302	void init_archetable(void) {	352	init_archetable (void)
		353	{
303	archetype *at;	354	archetype *at;
		355
304	LOG(llevDebug," Setting up archetable...\n");	356	LOG (llevDebug, " Setting up archetable...\n");
		357
305	for(at=first_archetype;at!=NULL;at=(at->more==NULL)?at->next:at->more)	358	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
306	add_arch(at);	359	at->hash_add ();
		360
307	LOG(llevDebug,"done\n");	361	LOG (llevDebug, "done\n");
308	}	362	}
309		363
310	/*	364	void
311	* Dumps an archetype to debug-level output.
312	*/
313
314	void dump_arch(archetype *at) {
315	dump_object(&at->clone);
316	}
317
318	/*
319	* Dumps _all_ archetypes to debug-level output.
320	* If you run crossfire with debug, and enter DM-mode, you can trigger
321	* this with the O key.
322	*/
323
324	void dump_all_archetypes(void) {
325	archetype *at;
326	for(at=first_archetype;at!=NULL;at=(at->more==NULL)?at->next:at->more) {
327	dump_arch(at);
328	fprintf(logfile, "%s\n", errmsg);
329	}
330	}
331
332	void free_all_archs(void)	365	free_all_archs (void)
333	{	366	{
334	archetype at, next;	367	archetype at, next;
335	int i=0,f=0;	368	int i = 0, f = 0;
336		369
337	for (at=first_archetype; at!=NULL; at=next) {	370	for (at = first_archetype; at != NULL; at = next)
338	if (at->more) next=at->more;	371	{
		372	if (at->more)
		373	next = at->more;
		374	else
339	else next=at->next;	375	next = at->next;
340		376
341	delete at;	377	delete
		378	at;
		379
342	i++;	380	i++;
343	}	381	}
		382
344	LOG(llevDebug,"Freed %d archetypes, %d faces\n", i, f);	383	LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
345	}	384	}
346		385
347	/*	386	archetype::archetype ()
348	* Allocates, initialises and returns the pointer to an archetype structure.	387	{
349	*/
350	// TODO: should become constructor
351	archetype *get_archetype_struct(void) {
352	archetype *arch;
353
354	arch = new archetype;
355
356	clear_object (&arch->clone); /* to initial state other also */
357	CLEAR_FLAG (&arch->clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */	388	CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_to */
358	SET_FLAG (&arch->clone, FLAG_REMOVED); /* doesn't copy these flags... */	389	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
		390	}
359		391
360	return arch;	392	archetype::~archetype ()
		393	{
361	}	394	}
362		395
363	/*	396	/*
364	* Reads/parses the archetype-file, and copies into a linked list	397	* Reads/parses the archetype-file, and copies into a linked list
365	* of archetype-structures.	398	* of archetype-structures.
366	*/	399	*/
		400	void
367	void first_arch_pass(object_thawer &fp) {	401	first_arch_pass (object_thawer & fp)
368	object *op;	402	{
369	archetype at,head=NULL,*last_more=NULL;	403	archetype head = 0, last_more = 0;
370	int i;
371		404
372	op=get_object();	405	archetype *at = new archetype;
373	op->arch=first_archetype=at=get_archetype_struct();	406	at->clone.arch = first_archetype = at;
374		407
375	while((i=load_object(fp,op,0))) {	408	while (int i = load_object (fp, &at->clone, 0))
376	copy_object(op,&at->clone);	409	{
377	at->clone.speed_left= (float) (-0.1);	410	at->clone.speed_left = (float) (-0.1);
378	/* copy the body_info to the body_used - this is only really	411	/* copy the body_info to the body_used - this is only really
379	* need for monsters, but doesn't hurt to do it for everything.	412	* need for monsters, but doesn't hurt to do it for everything.
380	* by doing so, when a monster is created, it has good starting	413	* by doing so, when a monster is created, it has good starting
381	* values for the body_used info, so when items are created	414	* values for the body_used info, so when items are created
382	* for it, they can be properly equipped.	415	* for it, they can be properly equipped.
383	*/	416	*/
384	memcpy(&at->clone.body_used, &op->body_info, sizeof(op->body_info));	417	memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));
385		418
386	switch(i) {	419	switch (i)
		420	{
387	case LL_NORMAL: /* A new archetype, just link it with the previous */	421	case LL_NORMAL: /* A new archetype, just link it with the previous */
388	if(last_more!=NULL)	422	if (last_more != NULL)
389	last_more->next=at;	423	last_more->next = at;
390	if(head!=NULL)	424	if (head != NULL)
391	head->next=at;	425	head->next = at;
392	head=last_more=at;	426	head = last_more = at;
393	#if 0	427	#if 0
394	if(!op->type)	428	if (!op->type)
395	LOG(llevDebug," WARNING: Archetype %s has no type info!\n", op->arch->name);	429	LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);
396	#endif	430	#endif
397	at->tail_x = 0;	431	at->tail_x = 0;
398	at->tail_y = 0;	432	at->tail_y = 0;
399	break;	433	break;
400		434
401	case LL_MORE: /* Another part of the previous archetype, link it correctly */	435	case LL_MORE: /* Another part of the previous archetype, link it correctly */
402		436
403	at->head=head;	437	at->head = head;
404	at->clone.head = &head->clone;	438	at->clone.head = &head->clone;
405	if(last_more!=NULL) {	439	if (last_more != NULL)
		440	{
406	last_more->more=at;	441	last_more->more = at;
407	last_more->clone.more = &at->clone;	442	last_more->clone.more = &at->clone;
408	}	443	}
409	last_more=at;	444	last_more = at;
410		445
411	/* If this multipart image is still composed of individual small	446	/* If this multipart image is still composed of individual small
412	* images, don't set the tail_.. values. We can't use them anyways,	447	* images, don't set the tail_.. values. We can't use them anyways,
413	* and setting these to zero makes the map sending to the client much	448	* and setting these to zero makes the map sending to the client much
414	* easier as just looking at the head, we know what to do.	449	* easier as just looking at the head, we know what to do.
415	*/	450	*/
416	if (at->clone.face != head->clone.face) {	451	if (at->clone.face != head->clone.face)
		452	{
417	head->tail_x = 0;	453	head->tail_x = 0;
418	head->tail_y = 0;	454	head->tail_y = 0;
419	} else {
420	if (at->clone.x > head->tail_x) head->tail_x = at->clone.x;
421	if (at->clone.y > head->tail_y) head->tail_y = at->clone.y;
422	}	455	}
		456	else
		457	{
		458	if (at->clone.x > head->tail_x)
		459	head->tail_x = at->clone.x;
		460	if (at->clone.y > head->tail_y)
		461	head->tail_y = at->clone.y;
		462	}
423	break;	463	break;
424		464
425	}	465	}
426		466
427	at=get_archetype_struct();	467	at = new archetype;
428	clear_object(op);
429	op->arch=at;
430	}
431		468
		469	at->clone.arch = at;
		470	}
		471
432	delete at;	472	delete at;
433	free_object(op);
434	}	473	}
435		474
436	/*	475	/*
437	* Reads the archetype file once more, and links all pointers between	476	* Reads the archetype file once more, and links all pointers between
438	* archetypes.	477	* archetypes.
439	*/	478	*/
440		479
		480	void
441	void second_arch_pass(object_thawer &thawer) {	481	second_arch_pass (object_thawer & thawer)
		482	{
442	char buf[MAX_BUF],variable=buf,argument,*cp;	483	char buf[MAX_BUF], variable = buf, argument, *cp;
443	archetype at=NULL,other;	484	archetype at = NULL, other;
444		485
445	while(fgets(buf,MAX_BUF,thawer)!=NULL) {	486	while (fgets (buf, MAX_BUF, thawer) != NULL)
		487	{
446	if(*buf=='#')	488	if (*buf == '#')
447	continue;	489	continue;
448	if((argument=strchr(buf,' '))!=NULL) {	490	if ((argument = strchr (buf, ' ')) != NULL)
		491	{
449	*argument='\0',argument++;	492	*argument = '\0', argument++;
450	cp = argument + strlen(argument)-1;	493	cp = argument + strlen (argument) - 1;
451	while (isspace(*cp)) {	494	while (isspace (*cp))
		495	{
452	*cp='\0';	496	*cp = '\0';
453	cp--;	497	cp--;
454	}	498	}
455	}	499	}
456	if(!strcmp("Object",variable)) {	500	if (!strcmp ("Object", variable))
		501	{
457	if((at=find_archetype(argument))==NULL)	502	if ((at = archetype::find (argument)) == NULL)
458	LOG(llevError,"Warning: failed to find arch %s\n",argument);	503	LOG (llevError, "Warning: failed to find arch %s\n", argument);
		504	}
459	} else if(!strcmp("other_arch",variable)) {	505	else if (!strcmp ("other_arch", variable))
		506	{
460	if(at!=NULL&&at->clone.other_arch==NULL) {	507	if (at != NULL && at->clone.other_arch == NULL)
		508	{
461	if((other=find_archetype(argument))==NULL)	509	if ((other = archetype::find (argument)) == NULL)
462	LOG(llevError,"Warning: failed to find other_arch %s\n",argument);	510	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
463	else if(at!=NULL)	511	else if (at != NULL)
464	at->clone.other_arch=other;	512	at->clone.other_arch = other;
		513	}
465	}	514	}
466	} else if(!strcmp("randomitems",variable)) {	515	else if (!strcmp ("randomitems", variable))
		516	{
467	if(at!=NULL) {	517	if (at != NULL)
		518	{
468	treasurelist *tl=find_treasurelist(argument);	519	treasurelist *tl = find_treasurelist (argument);
		520
469	if(tl==NULL)	521	if (tl == NULL)
470	LOG(llevError,"Failed to link treasure to arch (%s): %s\n", &at->name, argument);	522	LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
471	else	523	else
472	at->clone.randomitems=tl;	524	at->clone.randomitems = tl;
		525	}
473	}	526	}
474	}
475	}	527	}
476	}	528	}
477		529
478	#ifdef DEBUG	530	#ifdef DEBUG
		531	void
479	void check_generators(void) {	532	check_generators (void)
		533	{
480	archetype *at;	534	archetype *at;
		535
481	for(at=first_archetype;at!=NULL;at=at->next)	536	for (at = first_archetype; at != NULL; at = at->next)
482	if(QUERY_FLAG(&at->clone,FLAG_GENERATOR)&&at->clone.other_arch==NULL)	537	if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)
483	LOG(llevError,"Warning: %s is generator but lacks other_arch.\n", &at->name);	538	LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
484	}	539	}
485	#endif	540	#endif
486		541
487	/*	542	/*
488	* First initialises the archtype hash-table (init_archetable()).	543	* First initialises the archtype hash-table (init_archetable()).
…		…
493		548
494	void	549	void
495	load_archetypes (void)	550	load_archetypes (void)
496	{	551	{
497	char filename[MAX_BUF];	552	char filename[MAX_BUF];
498	int comp;
499	#if TIME_ARCH_LOAD
500	struct timeval tv1, tv2;
501	#endif
502		553
503	sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);	554	sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
504	LOG (llevDebug, "Reading archetypes from %s:\n", filename);	555	LOG (llevDebug, "Reading archetypes from %s:\n", filename);
505		556
506	{	557	{
		558	object_thawer
507	object_thawer thawer (filename);	559	thawer (filename);
508		560
509	clear_archetable ();	561	clear_archetable ();
510	LOG (llevDebug, " arch-pass 1...\n");	562	LOG (llevDebug, " arch-pass 1...\n");
511	first_arch_pass (thawer);	563	first_arch_pass (thawer);
512	LOG (llevDebug, " done\n");	564	LOG (llevDebug, " done\n");
513
514	init_archetable ();
515	warn_archetypes = 1;
516	}	565	}
517		566
		567	init_archetable ();
		568	warn_archetypes = 1;
		569
518	{	570	{
		571	object_thawer
519	object_thawer thawer (filename);	572	thawer (filename);
520		573
521	LOG (llevDebug, " loading treasure...\n");	574	LOG (llevDebug, " loading treasure...\n");
522	load_treasures ();	575	load_treasures ();
		576	LOG (llevDebug, " done\n");
523	LOG (llevDebug, " done\n arch-pass 2...\n");	577	LOG (llevDebug, " arch-pass 2...\n");
524	second_arch_pass (thawer);	578	second_arch_pass (thawer);
525	LOG (llevDebug, " done\n");	579	LOG (llevDebug, " done\n");
526	#ifdef DEBUG	580	#ifdef DEBUG
527	check_generators ();	581	check_generators ();
528	#endif	582	#endif
…		…
532		586
533	/*	587	/*
534	* Creates and returns a new object which is a copy of the given archetype.	588	* Creates and returns a new object which is a copy of the given archetype.
535	* This function returns NULL on failure.	589	* This function returns NULL on failure.
536	*/	590	*/
537		591	object *
538	object arch_to_object(archetype at) {	592	arch_to_object (archetype *at)
		593	{
539	object *op;	594	object *op;
		595
540	if(at==NULL) {	596	if (at == NULL)
		597	{
541	if(warn_archetypes)	598	if (warn_archetypes)
542	LOG(llevError,"Couldn't find archetype.\n");	599	LOG (llevError, "Couldn't find archetype.\n");
		600
543	return NULL;	601	return NULL;
544	}	602	}
545	op=get_object();	603
546	copy_object(&at->clone,op);	604	op = at->clone.clone ();
		605	op->arch = at;
547	op->instantiate ();	606	op->instantiate ();
548	op->arch=at;
549	return op;	607	return op;
550	}	608	}
551		609
552	/*	610	/*
553	* Creates an object. This function is called by get_archetype()	611	* Creates an object. This function is called by get_archetype()
554	* if it fails to find the appropriate archetype.	612	* if it fails to find the appropriate archetype.
555	* Thus get_archetype() will be guaranteed to always return	613	* Thus get_archetype() will be guaranteed to always return
556	* an object, and never NULL.	614	* an object, and never NULL.
557	*/	615	*/
558		616	object *
559	object create_singularity(const char name) {	617	create_singularity (const char *name)
		618	{
560	object *op;	619	object *op;
561	char buf[MAX_BUF];	620	char buf[MAX_BUF];
		621
562	sprintf(buf,"%s (%s)",ARCH_SINGULARITY,name);	622	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
563	op = get_object();	623	op = object::create ();
564	op->name = op->name_pl = buf;	624	op->name = op->name_pl = buf;
565	SET_FLAG(op,FLAG_NO_PICK);	625	SET_FLAG (op, FLAG_NO_PICK);
566	return op;	626	return op;
567	}	627	}
568		628
569	/*	629	/*
570	* Finds which archetype matches the given name, and returns a new	630	* Finds which archetype matches the given name, and returns a new
571	* object containing a copy of the archetype.	631	* object containing a copy of the archetype.
572	*/	632	*/
573		633	object *
574	object get_archetype(const char name) {	634	get_archetype (const char *name)
575	archetype *at;	635	{
576	at = find_archetype(name);	636	archetype *at = archetype::find (name);
577	if (at == NULL)	637
		638	if (!at)
578	return create_singularity(name);	639	return create_singularity (name);
		640
579	return arch_to_object(at);	641	return arch_to_object (at);
580	}	642	}
581		643
582	/*	644	/*
583	* Hash-function used by the arch-hashtable.	645	* Hash-function used by the arch-hashtable.
584	*/	646	*/
585		647
586	unsigned long	648	unsigned long
587	hasharch(const char *str, int tablesize)	649	hasharch (const char *str, int tablesize)
588	{	650	{
589	unsigned long hash = 0;	651	unsigned long hash = 0;
590	unsigned int i = 0;	652	unsigned int i = 0;
591	const char *p;	653	const char *p;
592		654
…		…
597	*/	659	*/
598	for (p = str; i < MAXSTRING && *p; p++, i++)	660	for (p = str; i < MAXSTRING && *p; p++, i++)
599	{	661	{
600	hash += *p;	662	hash += *p;
601	hash += hash << 10;	663	hash += hash << 10;
602	hash ^= hash >> 6;	664	hash ^= hash >> 6;
603	}	665	}
604		666
605	hash += hash << 3;	667	hash += hash << 3;
606	hash ^= hash >> 11;	668	hash ^= hash >> 11;
607	hash += hash << 15;	669	hash += hash << 15;
608		670
609	return hash % tablesize;	671	return hash % tablesize;
610	}	672	}
…		…
612	/*	674	/*
613	* Finds, using the hashtable, which archetype matches the given name.	675	* Finds, using the hashtable, which archetype matches the given name.
614	* returns a pointer to the found archetype, otherwise NULL.	676	* returns a pointer to the found archetype, otherwise NULL.
615	*/	677	*/
616		678
		679	archetype *
617	archetype find_archetype(const char name) {	680	archetype::find (const char *name)
		681	{
		682	if (!name)
		683	return 0;
		684
		685	#if USE_UNORDERED_MAP
		686	AUTODECL (i, ht.find ((size_t) name));
		687
		688	if (i == ht.end ())
		689	return 0;
		690	else
		691	return i->second;
		692	#endif
		693
618	archetype *at;	694	archetype *at;
619	unsigned long index;	695	unsigned long index;
620		696
621	if (name == NULL)
622	return (archetype *) NULL;
623
624	index=hasharch(name, ARCHTABLE);	697	index = hasharch (name, ARCHTABLE);
625	arch_search++;	698	arch_search++;
626	for(;;) {	699	for (;;)
		700	{
627	at = arch_table[index];	701	at = arch_table[index];
		702
628	if (at==NULL) {	703	if (at == NULL)
		704	{
629	if(warn_archetypes)	705	if (warn_archetypes)
630	LOG(llevError,"Couldn't find archetype %s\n",name);	706	LOG (llevError, "Couldn't find archetype %s\n", name);
		707
631	return NULL;	708	return NULL;
632	}	709	}
		710
633	arch_cmp++;	711	arch_cmp++;
		712
634	if (!strcmp((const char *)at->name,name))	713	if (!strcmp ((const char *) at->name, name))
635	return at;	714	return at;
		715
636	if(++index>=ARCHTABLE)	716	if (++index >= ARCHTABLE)
637	index=0;	717	index = 0;
638	}	718	}
639	}	719	}
640		720
641	/*	721	/*
642	* Adds an archetype to the hashtable.	722	* Adds an archetype to the hashtable.
643	*/	723	*/
		724	void
		725	archetype::hash_add ()
		726	{
		727	#if USE_UNORDERED_MAP
		728	ht.insert (std::make_pair ((size_t) (const char *) name, this));
		729	#else
644		730
645	static void add_arch(archetype *at) {
646	int index=hasharch((const char *)at->name, ARCHTABLE),org_index=index;	731	int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
		732
647	for(;;) {	733	for (;;)
		734	{
648	if(arch_table[index]==NULL) {	735	if (!arch_table[index])
		736	{
649	arch_table[index]=at;	737	arch_table[index] = this;
650	return;	738	break;
651	}	739	}
		740
652	if(++index==ARCHTABLE)	741	if (++index == ARCHTABLE)
653	index=0;	742	index = 0;
		743
654	if(index==org_index)	744	if (index == org_index)
655	fatal(ARCHTABLE_TOO_SMALL);	745	fatal (ARCHTABLE_TOO_SMALL);
656	}	746	}
		747	#endif
		748	}
		749
		750	void
		751	archetype::hash_del ()
		752	{
		753	#if USE_UNORDERED_MAP
		754	# error remove this from HT
		755	#else
		756
		757	int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
		758
		759	for (;;)
		760	{
		761	if (arch_table[index] == this)
		762	{
		763	arch_table[index] = 0;
		764	break;
		765	}
		766
		767	if (++index == ARCHTABLE)
		768	index = 0;
		769
		770	if (index == org_index)
		771	break;
		772	}
		773	#endif
657	}	774	}
658		775
659	/*	776	/*
660	* Returns the first archetype using the given type.	777	* Returns the first archetype using the given type.
661	* Used in treasure-generation.	778	* Used in treasure-generation.
662	*/	779	*/
663		780
		781	archetype *
664	archetype *type_to_archetype(int type) {	782	type_to_archetype (int type)
		783	{
665	archetype *at;	784	archetype *at;
666		785
667	for(at=first_archetype;at!=NULL;at=(at->more==NULL)?at->next:at->more)	786	for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
668	if(at->clone.type==type)	787	if (at->clone.type == type)
669	return at;	788	return at;
		789
670	return NULL;	790	return 0;
671	}	791	}
672		792
673	/*	793	/*
674	* Returns a new object copied from the first archetype matching	794	* Returns a new object copied from the first archetype matching
675	* the given type.	795	* the given type.
676	* Used in treasure-generation.	796	* Used in treasure-generation.
677	*/	797	*/
678		798
		799	object *
679	object *clone_arch(int type) {	800	clone_arch (int type)
		801	{
680	archetype *at;	802	archetype *at;
681	object *op=get_object();
682		803
683	if((at=type_to_archetype(type))==NULL) {	804	if ((at = type_to_archetype (type)) == NULL)
		805	{
684	LOG(llevError,"Can't clone archetype %d\n",type);	806	LOG (llevError, "Can't clone archetype %d\n", type);
685	free_object(op);
686	return NULL;	807	return 0;
687	}	808	}
688	copy_object(&at->clone,op);	809
		810	object *op = at->clone.clone ();
689	op->instantiate ();	811	op->instantiate ();
690	return op;	812	return op;
691	}	813	}
692		814
693	/*	815	/*
694	* member: make instance from class	816	* member: make instance from class
695	*/	817	*/
696		818
		819	object *
697	object object_create_arch (archetype at)	820	object_create_arch (archetype *at)
698	{	821	{
699	object op, prev = NULL, *head = NULL;	822	object op, prev = 0, *head = 0;
700		823
701	while (at) {	824	while (at)
		825	{
702	op = arch_to_object (at);	826	op = arch_to_object (at);
703	op->x = at->clone.x;	827	op->x = at->clone.x;
704	op->y = at->clone.y;	828	op->y = at->clone.y;
		829
705	if (head)	830	if (head)
706	op->head = head, prev->more = op;	831	op->head = head, prev->more = op;
		832
707	if (!head)	833	if (!head)
708	head = op;	834	head = op;
		835
709	prev = op;	836	prev = op;
710	at = at->more;	837	at = at->more;
711	}	838	}
		839
712	return (head);	840	return (head);
713	}	841	}
714		842
715	/* end of arch.c */

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.11 by root, Sun Sep 3 22:45:55 2006 UTC vs. Revision 1.35 by root, Wed Jan 3 20:32:13 2007 UTC

Diff Legend

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.11 by root, Sun Sep 3 22:45:55 2006 UTC vs.
Revision 1.35 by root, Wed Jan 3 20:32:13 2007 UTC