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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.3 by root, Sat Aug 26 23:36:28 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.3 2006/08/26 23:36:28 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)) &&
128	(subtype == -1 \|\| subtype == at->clone.subtype))
129	return at;
130	}	148	{
		149	if (((type == -1) \|\| (type == at->clone.type)) && (subtype == -1 \|\| subtype == at->clone.subtype))
		150	return at;
		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
164	/* GROS - find_best_weapon_used_match and item_matched_string moved there */
165	object find_best_weapon_used_match(object pl, const char *params)
166	{
167	object tmp, best=NULL;
168	int match_val=0,tmpmatch;
169
170	for (tmp=pl->inv; tmp; tmp=tmp->below) {
171	if (tmp->invisible) continue;
172	if ((tmpmatch=item_matched_string(pl, tmp, params))>match_val)
173	{
174	if ((QUERY_FLAG(tmp, FLAG_APPLIED))&&(tmp->type==WEAPON))
175	{
176	match_val=tmpmatch;
177	best=tmp;
178	};
179	}
180	}
181	return best;
182	}
183		187
184	/* 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
185	* a string seperated lists of things to match, with certain keywords.	189	* a string seperated lists of things to match, with certain keywords.
186	* pl is the player (only needed to set count properly)	190	* pl is the player (only needed to set count properly)
187	* op is the item we are trying to match. Calling function takes care	191	* op is the item we are trying to match. Calling function takes care
…		…
196	* player object.)	200	* player object.)
197	* If count is 1, make a quick check on the name.	201	* If count is 1, make a quick check on the name.
198	* 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.
199	* Last, make a check on the full name.	203	* Last, make a check on the full name.
200	*/	204	*/
		205	int
201	int item_matched_string(object pl, object op, const char *name)	206	item_matched_string (object pl, object op, const char *name)
202	{	207	{
203	char *cp, local_name[MAX_BUF];	208	char *cp, local_name[MAX_BUF];
204	int count,retval=0;	209	int count, retval = 0;
		210
205	strcpy(local_name, name); /* strtok is destructive to name */	211	strcpy (local_name, name); /* strtok is destructive to name */
206		212
207	for (cp=strtok(local_name,","); cp; cp=strtok(NULL,",")) {	213	for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
208	while (cp[0]==' ') ++cp; /* get rid of spaces */	214	{
		215	while (cp[0] == ' ')
		216	++cp; /* get rid of spaces */
209		217
210	/* LOG(llevDebug,"Trying to match %s\n", cp);*/	218	/* LOG(llevDebug,"Trying to match %s\n", cp); */
211	/* All is a very generic match - low match value */	219	/* All is a very generic match - low match value */
212	if (!strcmp(cp,"all")) return 1;	220	if (!strcmp (cp, "all"))
		221	return 1;
213		222
214	/* unpaid is a little more specific */	223	/* unpaid is a little more specific */
215	if (!strcmp(cp,"unpaid") && QUERY_FLAG(op,FLAG_UNPAID)) return 2;	224	if (!strcmp (cp, "unpaid") && QUERY_FLAG (op, FLAG_UNPAID))
216	if (!strcmp(cp,"cursed") && QUERY_FLAG(op,FLAG_KNOWN_CURSED) &&
217	(QUERY_FLAG(op,FLAG_CURSED) \|\|QUERY_FLAG(op,FLAG_DAMNED)))
218	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;
219		228
220	if (!strcmp(cp,"unlocked") && !QUERY_FLAG(op, FLAG_INV_LOCKED))	229	if (!strcmp (cp, "unlocked") && !QUERY_FLAG (op, FLAG_INV_LOCKED))
221	return 2;	230	return 2;
222		231
223	/* Allow for things like '100 arrows' */	232	/* Allow for things like '100 arrows' */
224	if ((count=atoi(cp))!=0) {	233	if ((count = atoi (cp)) != 0)
		234	{
225	cp=strchr(cp, ' ');	235	cp = strchr (cp, ' ');
226	while (cp && cp[0]==' ') ++cp; /* get rid of spaces */	236	while (cp && cp[0] == ' ')
227	}	237	++cp; /* get rid of spaces */
228	else {	238	}
		239	else
		240	{
229	if (pl->type==PLAYER)	241	if (pl->type == PLAYER)
230	count=pl->contr->count;	242	count = pl->contr->count;
231	else	243	else
232	count = 0;	244	count = 0;
233	}	245	}
234		246
235	if (!cp \|\| cp[0]=='\0' \|\| count<0) return 0;	247	if (!cp \|\| cp[0] == '\0' \|\| count < 0)
		248	return 0;
236		249
237		250
238	/* The code here should go from highest retval to lowest. That	251	/* The code here should go from highest retval to lowest. That
239	* 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
240	* 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
241	* 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
242	* match first, and work downward.	255	* match first, and work downward.
243	*/	256	*/
244	if (!strcasecmp(cp,query_name(op))) retval=20;	257	if (!strcasecmp (cp, query_name (op)))
		258	retval = 20;
245	else if (!strcasecmp(cp,query_short_name(op))) retval=18;	259	else if (!strcasecmp (cp, query_short_name (op)))
246	else if (!strcasecmp(cp,query_base_name(op,0))) retval=16;	260	retval = 18;
247	else if (!strcasecmp(cp,query_base_name(op,1))) retval=16;
248	else if (op->custom_name && !strcasecmp(cp,op->custom_name)) retval=15;
249	else if (!strncasecmp(cp,query_base_name(op,0),	261	else if (!strcasecmp (cp, query_base_name (op, 0)))
250	strlen(cp))) retval=14;	262	retval = 16;
251	else if (!strncasecmp(cp,query_base_name(op,1),	263	else if (!strcasecmp (cp, query_base_name (op, 1)))
252	strlen(cp))) retval=14;	264	retval = 16;
253		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;
254	/* Do substring checks, so things like 'Str+1' will match.	271	/* Do substring checks, so things like 'Str+1' will match.
255	* retval of these should perhaps be lower - they are lower	272	* retval of these should perhaps be lower - they are lower
256	* then the specific strcasecmp aboves, but still higher than	273	* then the specific strcasecmp aboves, but still higher than
257	* some other match criteria.	274	* some other match criteria.
258	*/	275	*/
259	else if (strstr(query_base_name(op,1), cp)) retval = 12;	276	else if (strstr (query_base_name (op, 1), cp))
		277	retval = 12;
260	else if (strstr(query_base_name(op,0), cp)) retval = 12;	278	else if (strstr (query_base_name (op, 0), cp))
		279	retval = 12;
261	else if (strstr(query_short_name(op), cp)) retval = 12;	280	else if (strstr (query_short_name (op), cp))
262		281	retval = 12;
263	/* Check against plural/non plural based on count. */	282	/* Check against plural/non plural based on count. */
264	else if (count>1 && !strcasecmp(cp,op->name_pl)) {	283	else if (count > 1 && !strcasecmp (cp, op->name_pl))
265	retval=6;	284	retval = 6;
266	}
267	else if (count==1 && !strcasecmp(op->name,cp)) {	285	else if (count == 1 && !strcasecmp (op->name, cp))
268	retval=6;	286	retval = 6;
269	}
270	/* base name matched - not bad */	287	/* base name matched - not bad */
271	else if (strcasecmp(cp,op->name)==0 && !count) retval=4;	288	else if (strcasecmp (cp, op->name) == 0 && !count)
		289	retval = 4;
272	/* Check for partial custom name, but give a real low priority */	290	/* Check for partial custom name, but give a real low priority */
273	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;
274		293
275	if (retval) {	294	if (retval)
		295	{
276	if (pl->type == PLAYER)	296	if (pl->type == PLAYER)
277	pl->contr->count=count;	297	pl->contr->count = count;
		298
278	return retval;	299	return retval;
279	}	300	}
280	}	301	}
		302
281	return 0;	303	return 0;
282	}	304	}
283		305
284	/*	306	/*
285	* Initialises the internal linked list of archetypes (read from file).	307	* Initialises the internal linked list of archetypes (read from file).
286	* Then the global "empty_archetype" pointer is initialised.	308	* Then the global "empty_archetype" pointer is initialised.
287	* Then the blocksview[] array is initialised.	309	* Then the blocksview[] array is initialised.
288	*/	310	*/
289		311
290	void init_archetypes(void) { /* called from add_player() and edit() */	312	void
		313	init_archetypes (void)
		314	{ /* called from add_player() and edit() */
291	if(first_archetype!=NULL) /* Only do this once */	315	if (first_archetype != NULL) /* Only do this once */
292	return;	316	return;
		317
293	arch_init = 1;	318	arch_init = 1;
294	load_archetypes();	319	load_archetypes ();
295	arch_init = 0;	320	arch_init = 0;
296	empty_archetype=find_archetype("empty_archetype");	321	empty_archetype = archetype::find ("empty_archetype");
		322
297	/* init_blocksview();*/	323	/* init_blocksview();*/
298	}	324	}
299		325
300	/*	326	/*
301	* Stores debug-information about how efficient the hashtable	327	* Stores debug-information about how efficient the hashtable
302	* used for archetypes has been in the static errmsg array.	328	* used for archetypes has been in the static errmsg array.
303	*/	329	*/
304		330
		331	void
305	void arch_info(object *op) {	332	arch_info (object *op)
		333	{
306	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);
307	new_draw_info(NDI_BLACK, 0, op,errmsg);	335	new_draw_info (NDI_BLACK, 0, op, errmsg);
308	}	336	}
309		337
310	/*	338	/*
311	* Initialise the hashtable used by the archetypes.	339	* Initialise the hashtable used by the archetypes.
312	*/	340	*/
313		341
		342	void
314	void clear_archetable(void) {	343	clear_archetable (void)
		344	{
315	memset((void ) arch_table,0,ARCHTABLEsizeof(archetype *));	345	memset ((void ) arch_table, 0, ARCHTABLE sizeof (archetype *));
316	}	346	}
317		347
318	/*	348	/*
319	* 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_...
320	*/	350	*/
321		351
		352	void
322	void init_archetable(void) {	353	init_archetable (void)
		354	{
323	archetype *at;	355	archetype *at;
		356
324	LOG(llevDebug," Setting up archetable...\n");	357	LOG (llevDebug, " Setting up archetable...\n");
		358
325	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)
326	add_arch(at);	360	at->hash_add ();
		361
327	LOG(llevDebug,"done\n");	362	LOG (llevDebug, "done\n");
328	}	363	}
329		364
330	/*	365	void
331	* Dumps an archetype to debug-level output.
332	*/
333
334	void dump_arch(archetype *at) {
335	dump_object(&at->clone);
336	}
337
338	/*
339	* Dumps _all_ archetypes to debug-level output.
340	* If you run crossfire with debug, and enter DM-mode, you can trigger
341	* this with the O key.
342	*/
343
344	void dump_all_archetypes(void) {
345	archetype *at;
346	for(at=first_archetype;at!=NULL;at=(at->more==NULL)?at->next:at->more) {
347	dump_arch(at);
348	fprintf(logfile, "%s\n", errmsg);
349	}
350	}
351
352	void free_all_archs(void)	366	free_all_archs (void)
353	{	367	{
354	archetype at, next;	368	archetype at, next;
355	int i=0,f=0;	369	int i = 0, f = 0;
356		370
357	for (at=first_archetype; at!=NULL; at=next) {	371	for (at = first_archetype; at != NULL; at = next)
358	if (at->more) next=at->more;
359	else next=at->next;
360	if (at->name) free_string(at->name);
361	if (at->clone.name) free_string(at->clone.name);
362	if (at->clone.name_pl) free_string(at->clone.name_pl);
363	if (at->clone.title) free_string(at->clone.title);
364	if (at->clone.race) free_string(at->clone.race);
365	if (at->clone.slaying) free_string(at->clone.slaying);
366	if (at->clone.msg) free_string(at->clone.msg);
367	free(at);
368	i++;
369	}	372	{
		373	if (at->more)
		374	next = at->more;
		375	else
		376	next = at->next;
		377
		378	delete
		379	at;
		380
		381	i++;
		382	}
		383
370	LOG(llevDebug,"Freed %d archetypes, %d faces\n", i, f);	384	LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
371	}	385	}
372		386
373	/*	387	archetype::archetype ()
374	* Allocates, initialises and returns the pointer to an archetype structure.	388	{
375	*/
376
377	archetype *get_archetype_struct(void) {
378	archetype *arch;
379
380	arch=(archetype *)CALLOC(1,sizeof(archetype));
381	if(arch==NULL)
382	fatal(OUT_OF_MEMORY);
383	arch->next=NULL;
384	arch->name=NULL;
385	arch->clone.other_arch=NULL;
386	arch->clone.name=NULL;
387	arch->clone.name_pl=NULL;
388	arch->clone.title=NULL;
389	arch->clone.race=NULL;
390	arch->clone.slaying=NULL;
391	arch->clone.msg=NULL;
392	clear_object(&arch->clone); /* to initial state other also */
393	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 */
394	SET_FLAG((&arch->clone), FLAG_REMOVED); /* doesn't copy these flags... */	390	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
395	arch->head=NULL;	391	}
396	arch->more=NULL;	392
397	return arch;	393	archetype::~archetype ()
		394	{
398	}	395	}
399		396
400	/*	397	/*
401	* Reads/parses the archetype-file, and copies into a linked list	398	* Reads/parses the archetype-file, and copies into a linked list
402	* of archetype-structures.	399	* of archetype-structures.
403	*/	400	*/
404	void first_arch_pass(FILE *fp) {	401	void
405	object *op;	402	first_arch_pass (object_thawer & fp)
406	archetype at,head=NULL,*last_more=NULL;	403	{
407	int i,first=2;	404	archetype head = 0, last_more = 0;
408		405
409	op=get_object();	406	archetype *at = new archetype;
410	op->arch=first_archetype=at=get_archetype_struct();	407	at->clone.arch = first_archetype = at;
411		408
412	while((i=load_object(fp,op,first,0))) {	409	while (int i = load_object (fp, &at->clone, 0))
413	first=0;	410	{
414	copy_object(op,&at->clone);
415	at->clone.speed_left= (float) (-0.1);	411	at->clone.speed_left = (float) (-0.1);
416	/* 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
417	* 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.
418	* 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
419	* values for the body_used info, so when items are created	415	* values for the body_used info, so when items are created
420	* for it, they can be properly equipped.	416	* for it, they can be properly equipped.
421	*/	417	*/
422	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));
423		419
424	switch(i) {	420	switch (i)
		421	{
425	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 */
426	if(last_more!=NULL)	423	if (last_more != NULL)
427	last_more->next=at;	424	last_more->next = at;
428	if(head!=NULL)	425	if (head != NULL)
429	head->next=at;	426	head->next = at;
430	head=last_more=at;	427	head = last_more = at;
431	#if 0	428	#if 0
432	if(!op->type)	429	if (!op->type)
433	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);
434	#endif	431	#endif
435	at->tail_x = 0;	432	at->tail_x = 0;
436	at->tail_y = 0;	433	at->tail_y = 0;
437	break;	434	break;
438		435
439	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 */
440		437
441	at->head=head;	438	at->head = head;
442	at->clone.head = &head->clone;	439	at->clone.head = &head->clone;
443	if(last_more!=NULL) {	440	if (last_more != NULL)
444	last_more->more=at;	441	{
		442	last_more->more = at;
445	last_more->clone.more = &at->clone;	443	last_more->clone.more = &at->clone;
446	}	444	}
447	last_more=at;	445	last_more = at;
448		446
449	/* If this multipart image is still composed of individual small	447	/* If this multipart image is still composed of individual small
450	* 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,
451	* 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
452	* 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.
453	*/	451	*/
454	if (at->clone.face != head->clone.face) {	452	if (at->clone.face != head->clone.face)
455	head->tail_x = 0;	453	{
456	head->tail_y = 0;	454	head->tail_x = 0;
457	} else {	455	head->tail_y = 0;
458	if (at->clone.x > head->tail_x) head->tail_x = at->clone.x;	456	}
459	if (at->clone.y > head->tail_y) head->tail_y = at->clone.y;	457	else
460	}	458	{
461	break;	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	}
		464	break;
462		465
463	}	466	}
464		467
465	at=get_archetype_struct();	468	at = new archetype;
466	clear_object(op);	469
467	op->arch=at;	470	at->clone.arch = at;
468	}	471	}
469	free(at);	472
470	free_object(op);	473	delete at;
471	}	474	}
472		475
473	/*	476	/*
474	* Reads the archetype file once more, and links all pointers between	477	* Reads the archetype file once more, and links all pointers between
475	* archetypes.	478	* archetypes.
476	*/	479	*/
477		480
478	void second_arch_pass(FILE *fp) {	481	void
		482	second_arch_pass (object_thawer & thawer)
		483	{
479	char buf[MAX_BUF],variable=buf,argument,*cp;	484	char buf[MAX_BUF], variable = buf, argument, *cp;
480	archetype at=NULL,other;	485	archetype at = NULL, other;
481		486
482	while(fgets(buf,MAX_BUF,fp)!=NULL) {	487	while (fgets (buf, MAX_BUF, thawer) != NULL)
		488	{
483	if(*buf=='#')	489	if (*buf == '#')
484	continue;	490	continue;
485	if((argument=strchr(buf,' '))!=NULL) {	491	if ((argument = strchr (buf, ' ')) != NULL)
		492	{
486	*argument='\0',argument++;	493	*argument = '\0', argument++;
487	cp = argument + strlen(argument)-1;	494	cp = argument + strlen (argument) - 1;
488	while (isspace(*cp)) {	495	while (isspace (*cp))
489	*cp='\0';	496	{
490	cp--;	497	*cp = '\0';
491	}	498	cp--;
492	}	499	}
		500	}
493	if(!strcmp("Object",variable)) {	501	if (!strcmp ("Object", variable))
		502	{
494	if((at=find_archetype(argument))==NULL)	503	if ((at = archetype::find (argument)) == NULL)
495	LOG(llevError,"Warning: failed to find arch %s\n",argument);	504	LOG (llevError, "Warning: failed to find arch %s\n", argument);
		505	}
496	} else if(!strcmp("other_arch",variable)) {	506	else if (!strcmp ("other_arch", variable))
		507	{
497	if(at!=NULL&&at->clone.other_arch==NULL) {	508	if (at != NULL && at->clone.other_arch == NULL)
		509	{
498	if((other=find_archetype(argument))==NULL)	510	if ((other = archetype::find (argument)) == NULL)
499	LOG(llevError,"Warning: failed to find other_arch %s\n",argument);	511	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
500	else if(at!=NULL)	512	else if (at != NULL)
501	at->clone.other_arch=other;	513	at->clone.other_arch = other;
		514	}
502	}	515	}
503	} else if(!strcmp("randomitems",variable)) {	516	else if (!strcmp ("randomitems", variable))
		517	{
504	if(at!=NULL) {	518	if (at != NULL)
		519	{
505	treasurelist *tl=find_treasurelist(argument);	520	treasurelist *tl = find_treasurelist (argument);
		521
506	if(tl==NULL)	522	if (tl == NULL)
507	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);
508	else	524	else
509	at->clone.randomitems=tl;	525	at->clone.randomitems = tl;
		526	}
510	}	527	}
511	}
512	}	528	}
513	}	529	}
514		530
515	#ifdef DEBUG	531	#ifdef DEBUG
		532	void
516	void check_generators(void) {	533	check_generators (void)
		534	{
517	archetype *at;	535	archetype *at;
		536
518	for(at=first_archetype;at!=NULL;at=at->next)	537	for (at = first_archetype; at != NULL; at = at->next)
519	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)
520	LOG(llevError,"Warning: %s is generator but lacks other_arch.\n",	539	LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
521	at->name);
522	}	540	}
523	#endif	541	#endif
524		542
525	/*	543	/*
526	* First initialises the archtype hash-table (init_archetable()).	544	* First initialises the archtype hash-table (init_archetable()).
527	* Reads and parses the archetype file (with the first and second-pass	545	* Reads and parses the archetype file (with the first and second-pass
528	* functions).	546	* functions).
529	* Then initialises treasures by calling load_treasures().	547	* Then initialises treasures by calling load_treasures().
530	*/	548	*/
531		549
		550	void
532	void load_archetypes(void) {	551	load_archetypes (void)
533	FILE *fp;	552	{
534	char filename[MAX_BUF];	553	char filename[MAX_BUF];
535	int comp;	554
536	#if TIME_ARCH_LOAD	555	sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
537	struct timeval tv1,tv2;	556	LOG (llevDebug, "Reading archetypes from %s:\n", filename);
		557
		558	{
		559	object_thawer
		560	thawer (filename);
		561
		562	clear_archetable ();
		563	LOG (llevDebug, " arch-pass 1...\n");
		564	first_arch_pass (thawer);
		565	LOG (llevDebug, " done\n");
		566	}
		567
		568	init_archetable ();
		569	warn_archetypes = 1;
		570
		571	{
		572	object_thawer
		573	thawer (filename);
		574
		575	LOG (llevDebug, " loading treasure...\n");
		576	load_treasures ();
		577	LOG (llevDebug, " done\n");
		578	LOG (llevDebug, " arch-pass 2...\n");
		579	second_arch_pass (thawer);
		580	LOG (llevDebug, " done\n");
		581	#ifdef DEBUG
		582	check_generators ();
538	#endif	583	#endif
539
540	sprintf(filename,"%s/%s",settings.datadir,settings.archetypes);
541	LOG(llevDebug,"Reading archetypes from %s...\n",filename);
542	if((fp=open_and_uncompress(filename,0,&comp))==NULL) {
543	LOG(llevError," Can't open archetype file.\n");
544	return;
545	}	584	}
546	clear_archetable();
547	LOG(llevDebug," arch-pass 1...\n");
548	#if TIME_ARCH_LOAD
549	GETTIMEOFDAY(&tv1);
550	#endif
551	first_arch_pass(fp);
552	#if TIME_ARCH_LOAD
553	{ int sec, usec;
554	GETTIMEOFDAY(&tv2);
555	sec = tv2.tv_sec - tv1.tv_sec;
556	usec = tv2.tv_usec - tv1.tv_usec;
557	if (usec<0) { usec +=1000000; sec--;}
558	LOG(llevDebug,"Load took %d.%06d seconds\n", sec, usec);
559	}
560	#endif
561
562	LOG(llevDebug," done\n");	585	LOG (llevDebug, " done\n");
563	init_archetable();
564	warn_archetypes=1;
565
566	/* do a close and reopen instead of a rewind - necessary in case the
567	* file has been compressed.
568	*/
569	close_and_delete(fp, comp);
570	fp=open_and_uncompress(filename,0,&comp);
571
572	LOG(llevDebug," loading treasure...\n");
573	load_treasures();
574	LOG(llevDebug," done\n arch-pass 2...\n");
575	second_arch_pass(fp);
576	LOG(llevDebug," done\n");
577	#ifdef DEBUG
578	check_generators();
579	#endif
580	close_and_delete(fp, comp);
581	LOG(llevDebug," done\n");
582	}	586	}
583		587
584	/*	588	/*
585	* 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.
586	* This function returns NULL on failure.	590	* This function returns NULL on failure.
587	*/	591	*/
588		592	object *
589	object arch_to_object(archetype at) {	593	arch_to_object (archetype *at)
		594	{
590	object *op;	595	object *op;
		596
591	if(at==NULL) {	597	if (at == NULL)
		598	{
592	if(warn_archetypes)	599	if (warn_archetypes)
593	LOG(llevError,"Couldn't find archetype.\n");	600	LOG (llevError, "Couldn't find archetype.\n");
		601
594	return NULL;	602	return NULL;
595	}	603	}
596	op=get_object();	604
597	copy_object(&at->clone,op);	605	op = at->clone.clone ();
		606	op->arch = at;
598	op->instantiate ();	607	op->instantiate ();
599	op->arch=at;
600	return op;	608	return op;
601	}	609	}
602		610
603	/*	611	/*
604	* Creates an object. This function is called by get_archetype()	612	* Creates an object. This function is called by get_archetype()
605	* if it fails to find the appropriate archetype.	613	* if it fails to find the appropriate archetype.
606	* Thus get_archetype() will be guaranteed to always return	614	* Thus get_archetype() will be guaranteed to always return
607	* an object, and never NULL.	615	* an object, and never NULL.
608	*/	616	*/
609		617	object *
610	object create_singularity(const char name) {	618	create_singularity (const char *name)
		619	{
611	object *op;	620	object *op;
612	char buf[MAX_BUF];	621	char buf[MAX_BUF];
		622
613	sprintf(buf,"%s (%s)",ARCH_SINGULARITY,name);	623	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
614	op = get_object();	624	op = object::create ();
615	op->name = add_string(buf);	625	op->name = op->name_pl = buf;
616	op->name_pl = add_string(buf);
617	SET_FLAG(op,FLAG_NO_PICK);	626	SET_FLAG (op, FLAG_NO_PICK);
618	return op;	627	return op;
619	}	628	}
620		629
621	/*	630	/*
622	* Finds which archetype matches the given name, and returns a new	631	* Finds which archetype matches the given name, and returns a new
623	* object containing a copy of the archetype.	632	* object containing a copy of the archetype.
624	*/	633	*/
625		634	object *
626	object get_archetype(const char name) {	635	get_archetype (const char *name)
627	archetype *at;	636	{
628	at = find_archetype(name);	637	archetype *at = archetype::find (name);
629	if (at == NULL)	638
		639	if (!at)
630	return create_singularity(name);	640	return create_singularity (name);
		641
631	return arch_to_object(at);	642	return arch_to_object (at);
632	}	643	}
633		644
634	/*	645	/*
635	* Hash-function used by the arch-hashtable.	646	* Hash-function used by the arch-hashtable.
636	*/	647	*/
637		648
638	unsigned long	649	unsigned long
639	hasharch(const char *str, int tablesize) {	650	hasharch (const char *str, int tablesize)
		651	{
640	unsigned long hash = 0;	652	unsigned long hash = 0;
641	int i = 0;	653	unsigned int i = 0;
642	const char *p;	654	const char *p;
643		655
644	/* use the one-at-a-time hash function, which supposedly is	656	/* use the one-at-a-time hash function, which supposedly is
645	* better than the djb2-like one used by perl5.005, but	657	* better than the djb2-like one used by perl5.005, but
646	* certainly is better then the bug used here before.	658	* certainly is better then the bug used here before.
647	* see http://burtleburtle.net/bob/hash/doobs.html	659	* see http://burtleburtle.net/bob/hash/doobs.html
648	*/	660	*/
649	for (p = str; i < MAXSTRING && *p; p++, i++) {	661	for (p = str; i < MAXSTRING && *p; p++, i++)
		662	{
650	hash += *p;	663	hash += *p;
651	hash += hash << 10;	664	hash += hash << 10;
652	hash ^= hash >> 6;	665	hash ^= hash >> 6;
653	}	666	}
		667
654	hash += hash << 3;	668	hash += hash << 3;
655	hash ^= hash >> 11;	669	hash ^= hash >> 11;
656	hash += hash << 15;	670	hash += hash << 15;
		671
657	return hash % tablesize;	672	return hash % tablesize;
658	}	673	}
659		674
660	/*	675	/*
661	* Finds, using the hashtable, which archetype matches the given name.	676	* Finds, using the hashtable, which archetype matches the given name.
662	* returns a pointer to the found archetype, otherwise NULL.	677	* returns a pointer to the found archetype, otherwise NULL.
663	*/	678	*/
664		679
		680	archetype *
665	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
666	archetype *at;	695	archetype *at;
667	unsigned long index;	696	unsigned long index;
668		697
669	if (name == NULL)
670	return (archetype *) NULL;
671
672	index=hasharch(name, ARCHTABLE);	698	index = hasharch (name, ARCHTABLE);
673	arch_search++;	699	arch_search++;
674	for(;;) {	700	for (;;)
		701	{
675	at = arch_table[index];	702	at = arch_table[index];
		703
676	if (at==NULL) {	704	if (at == NULL)
		705	{
677	if(warn_archetypes)	706	if (warn_archetypes)
678	LOG(llevError,"Couldn't find archetype %s\n",name);	707	LOG (llevError, "Couldn't find archetype %s\n", name);
		708
679	return NULL;	709	return NULL;
680	}	710	}
		711
681	arch_cmp++;	712	arch_cmp++;
		713
682	if (!strcmp(at->name,name))	714	if (!strcmp ((const char *) at->name, name))
683	return at;	715	return at;
		716
684	if(++index>=ARCHTABLE)	717	if (++index >= ARCHTABLE)
685	index=0;	718	index = 0;
686	}	719	}
687	}	720	}
688		721
689	/*	722	/*
690	* Adds an archetype to the hashtable.	723	* Adds an archetype to the hashtable.
691	*/	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
692		731
693	static void add_arch(archetype *at) {
694	int index=hasharch(at->name, ARCHTABLE),org_index=index;	732	int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
		733
695	for(;;) {	734	for (;;)
		735	{
696	if(arch_table[index]==NULL) {	736	if (!arch_table[index])
		737	{
697	arch_table[index]=at;	738	arch_table[index] = this;
698	return;	739	break;
699	}	740	}
		741
700	if(++index==ARCHTABLE)	742	if (++index == ARCHTABLE)
701	index=0;	743	index = 0;
		744
702	if(index==org_index)	745	if (index == org_index)
703	fatal(ARCHTABLE_TOO_SMALL);	746	fatal (ARCHTABLE_TOO_SMALL);
704	}	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
705	}	775	}
706		776
707	/*	777	/*
708	* Returns the first archetype using the given type.	778	* Returns the first archetype using the given type.
709	* Used in treasure-generation.	779	* Used in treasure-generation.
710	*/	780	*/
711		781
		782	archetype *
712	archetype *type_to_archetype(int type) {	783	type_to_archetype (int type)
		784	{
713	archetype *at;	785	archetype *at;
714		786
715	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)
716	if(at->clone.type==type)	788	if (at->clone.type == type)
717	return at;	789	return at;
		790
718	return NULL;	791	return 0;
719	}	792	}
720		793
721	/*	794	/*
722	* Returns a new object copied from the first archetype matching	795	* Returns a new object copied from the first archetype matching
723	* the given type.	796	* the given type.
724	* Used in treasure-generation.	797	* Used in treasure-generation.
725	*/	798	*/
726		799
		800	object *
727	object *clone_arch(int type) {	801	clone_arch (int type)
		802	{
728	archetype *at;	803	archetype *at;
729	object *op=get_object();
730		804
731	if((at=type_to_archetype(type))==NULL) {	805	if ((at = type_to_archetype (type)) == NULL)
		806	{
732	LOG(llevError,"Can't clone archetype %d\n",type);	807	LOG (llevError, "Can't clone archetype %d\n", type);
733	free_object(op);
734	return NULL;	808	return 0;
735	}	809	}
736	copy_object(&at->clone,op);	810
		811	object *op = at->clone.clone ();
737	op->instantiate ();	812	op->instantiate ();
738	return op;	813	return op;
739	}	814	}
740		815
741	/*	816	/*
742	* member: make instance from class	817	* member: make instance from class
743	*/	818	*/
744		819
		820	object *
745	object object_create_arch (archetype at)	821	object_create_arch (archetype *at)
746	{	822	{
747	object op, prev = NULL, *head = NULL;	823	object op, prev = 0, *head = 0;
748		824
749	while (at) {	825	while (at)
		826	{
750	op = arch_to_object (at);	827	op = arch_to_object (at);
751	op->x = at->clone.x;	828	op->x = at->clone.x;
752	op->y = at->clone.y;	829	op->y = at->clone.y;
		830
753	if (head)	831	if (head)
754	op->head = head, prev->more = op;	832	op->head = head, prev->more = op;
		833
755	if (!head)	834	if (!head)
756	head = op;	835	head = op;
		836
757	prev = op;	837	prev = op;
758	at = at->more;	838	at = at->more;
759	}	839	}
		840
760	return (head);	841	return (head);
761	}	842	}
762		843
763	/* end of arch.c */

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.3 by root, Sat Aug 26 23:36:28 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.3 by root, Sat Aug 26 23:36:28 2006 UTC vs.
Revision 1.36 by pippijn, Sat Jan 6 14:42:28 2007 UTC