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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.10 by root, Sun Sep 3 00:18:39 2006 UTC vs.
Revision 1.36 by pippijn, Sat Jan 6 14:42:28 2007 UTC

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

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.10 by root, Sun Sep 3 00:18:39 2006 UTC vs. Revision 1.36 by pippijn, Sat Jan 6 14:42:28 2007 UTC

Diff Legend

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.10 by root, Sun Sep 3 00:18:39 2006 UTC vs.
Revision 1.36 by pippijn, Sat Jan 6 14:42:28 2007 UTC