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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.9 by root, Wed Aug 30 11:02:15 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.9 2006/08/30 11:02:15 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	if (at->name) free_string(at->name);	376
341	if (at->clone.name) free_string(at->clone.name);	377	delete
342	if (at->clone.name_pl) free_string(at->clone.name_pl);
343	if (at->clone.title) free_string(at->clone.title);
344	if (at->clone.race) free_string(at->clone.race);
345	if (at->clone.slaying) free_string(at->clone.slaying);
346	if (at->clone.msg) free_string(at->clone.msg);
347	free(at);	378	at;
		379
348	i++;	380	i++;
349	}	381	}
		382
350	LOG(llevDebug,"Freed %d archetypes, %d faces\n", i, f);	383	LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
351	}	384	}
352		385
353	/*	386	archetype::archetype ()
354	* Allocates, initialises and returns the pointer to an archetype structure.	387	{
355	*/
356
357	archetype *get_archetype_struct(void) {
358	archetype *arch;
359
360	arch=(archetype *)CALLOC(1,sizeof(archetype));
361	if(arch==NULL)
362	fatal(OUT_OF_MEMORY);
363	arch->next=NULL;
364	arch->name=NULL;
365	arch->clone.other_arch=NULL;
366	arch->clone.name=NULL;
367	arch->clone.name_pl=NULL;
368	arch->clone.title=NULL;
369	arch->clone.race=NULL;
370	arch->clone.slaying=NULL;
371	arch->clone.msg=NULL;
372	clear_object(&arch->clone); /* to initial state other also */
373	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 */
374	SET_FLAG((&arch->clone), FLAG_REMOVED); /* doesn't copy these flags... */	389	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
375	arch->head=NULL;	390	}
376	arch->more=NULL;	391
377	return arch;	392	archetype::~archetype ()
		393	{
378	}	394	}
379		395
380	/*	396	/*
381	* Reads/parses the archetype-file, and copies into a linked list	397	* Reads/parses the archetype-file, and copies into a linked list
382	* of archetype-structures.	398	* of archetype-structures.
383	*/	399	*/
		400	void
384	void first_arch_pass(object_thawer &fp) {	401	first_arch_pass (object_thawer & fp)
385	object *op;	402	{
386	archetype at,head=NULL,*last_more=NULL;	403	archetype head = 0, last_more = 0;
387	int i,first=2;
388		404
389	op=get_object();	405	archetype *at = new archetype;
390	op->arch=first_archetype=at=get_archetype_struct();	406	at->clone.arch = first_archetype = at;
391		407
392	while((i=load_object(fp,op,first,0))) {	408	while (int i = load_object (fp, &at->clone, 0))
393	first=0;	409	{
394	copy_object(op,&at->clone);
395	at->clone.speed_left= (float) (-0.1);	410	at->clone.speed_left = (float) (-0.1);
396	/* 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
397	* 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.
398	* 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
399	* values for the body_used info, so when items are created	414	* values for the body_used info, so when items are created
400	* for it, they can be properly equipped.	415	* for it, they can be properly equipped.
401	*/	416	*/
402	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));
403		418
404	switch(i) {	419	switch (i)
		420	{
405	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 */
406	if(last_more!=NULL)	422	if (last_more != NULL)
407	last_more->next=at;	423	last_more->next = at;
408	if(head!=NULL)	424	if (head != NULL)
409	head->next=at;	425	head->next = at;
410	head=last_more=at;	426	head = last_more = at;
411	#if 0	427	#if 0
412	if(!op->type)	428	if (!op->type)
413	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);
414	#endif	430	#endif
415	at->tail_x = 0;	431	at->tail_x = 0;
416	at->tail_y = 0;	432	at->tail_y = 0;
417	break;	433	break;
418		434
419	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 */
420		436
421	at->head=head;	437	at->head = head;
422	at->clone.head = &head->clone;	438	at->clone.head = &head->clone;
423	if(last_more!=NULL) {	439	if (last_more != NULL)
		440	{
424	last_more->more=at;	441	last_more->more = at;
425	last_more->clone.more = &at->clone;	442	last_more->clone.more = &at->clone;
426	}	443	}
427	last_more=at;	444	last_more = at;
428		445
429	/* If this multipart image is still composed of individual small	446	/* If this multipart image is still composed of individual small
430	* 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,
431	* 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
432	* 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.
433	*/	450	*/
434	if (at->clone.face != head->clone.face) {	451	if (at->clone.face != head->clone.face)
		452	{
435	head->tail_x = 0;	453	head->tail_x = 0;
436	head->tail_y = 0;	454	head->tail_y = 0;
437	} else {
438	if (at->clone.x > head->tail_x) head->tail_x = at->clone.x;
439	if (at->clone.y > head->tail_y) head->tail_y = at->clone.y;
440	}	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	}
441	break;	463	break;
442		464
443	}	465	}
444		466
445	at=get_archetype_struct();	467	at = new archetype;
446	clear_object(op);	468
447	op->arch=at;	469	at->clone.arch = at;
448	}	470	}
449	free(at);	471
450	free_object(op);	472	delete at;
451	}	473	}
452		474
453	/*	475	/*
454	* Reads the archetype file once more, and links all pointers between	476	* Reads the archetype file once more, and links all pointers between
455	* archetypes.	477	* archetypes.
456	*/	478	*/
457		479
		480	void
458	void second_arch_pass(object_thawer &thawer) {	481	second_arch_pass (object_thawer & thawer)
		482	{
459	char buf[MAX_BUF],variable=buf,argument,*cp;	483	char buf[MAX_BUF], variable = buf, argument, *cp;
460	archetype at=NULL,other;	484	archetype at = NULL, other;
461		485
462	while(fgets(buf,MAX_BUF,thawer)!=NULL) {	486	while (fgets (buf, MAX_BUF, thawer) != NULL)
		487	{
463	if(*buf=='#')	488	if (*buf == '#')
464	continue;	489	continue;
465	if((argument=strchr(buf,' '))!=NULL) {	490	if ((argument = strchr (buf, ' ')) != NULL)
		491	{
466	*argument='\0',argument++;	492	*argument = '\0', argument++;
467	cp = argument + strlen(argument)-1;	493	cp = argument + strlen (argument) - 1;
468	while (isspace(*cp)) {	494	while (isspace (*cp))
		495	{
469	*cp='\0';	496	*cp = '\0';
470	cp--;	497	cp--;
471	}	498	}
472	}	499	}
473	if(!strcmp("Object",variable)) {	500	if (!strcmp ("Object", variable))
		501	{
474	if((at=find_archetype(argument))==NULL)	502	if ((at = archetype::find (argument)) == NULL)
475	LOG(llevError,"Warning: failed to find arch %s\n",argument);	503	LOG (llevError, "Warning: failed to find arch %s\n", argument);
		504	}
476	} else if(!strcmp("other_arch",variable)) {	505	else if (!strcmp ("other_arch", variable))
		506	{
477	if(at!=NULL&&at->clone.other_arch==NULL) {	507	if (at != NULL && at->clone.other_arch == NULL)
		508	{
478	if((other=find_archetype(argument))==NULL)	509	if ((other = archetype::find (argument)) == NULL)
479	LOG(llevError,"Warning: failed to find other_arch %s\n",argument);	510	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
480	else if(at!=NULL)	511	else if (at != NULL)
481	at->clone.other_arch=other;	512	at->clone.other_arch = other;
		513	}
482	}	514	}
483	} else if(!strcmp("randomitems",variable)) {	515	else if (!strcmp ("randomitems", variable))
		516	{
484	if(at!=NULL) {	517	if (at != NULL)
		518	{
485	treasurelist *tl=find_treasurelist(argument);	519	treasurelist *tl = find_treasurelist (argument);
		520
486	if(tl==NULL)	521	if (tl == NULL)
487	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);
488	else	523	else
489	at->clone.randomitems=tl;	524	at->clone.randomitems = tl;
		525	}
490	}	526	}
491	}
492	}	527	}
493	}	528	}
494		529
495	#ifdef DEBUG	530	#ifdef DEBUG
		531	void
496	void check_generators(void) {	532	check_generators (void)
		533	{
497	archetype *at;	534	archetype *at;
		535
498	for(at=first_archetype;at!=NULL;at=at->next)	536	for (at = first_archetype; at != NULL; at = at->next)
499	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)
500	LOG(llevError,"Warning: %s is generator but lacks other_arch.\n",	538	LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
501	at->name);
502	}	539	}
503	#endif	540	#endif
504		541
505	/*	542	/*
506	* First initialises the archtype hash-table (init_archetable()).	543	* First initialises the archtype hash-table (init_archetable()).
…		…
511		548
512	void	549	void
513	load_archetypes (void)	550	load_archetypes (void)
514	{	551	{
515	char filename[MAX_BUF];	552	char filename[MAX_BUF];
516	int comp;
517	#if TIME_ARCH_LOAD
518	struct timeval tv1, tv2;
519	#endif
520		553
521	sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);	554	sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
522	LOG (llevDebug, "Reading archetypes from %s:\n", filename);	555	LOG (llevDebug, "Reading archetypes from %s:\n", filename);
523		556
524	{	557	{
		558	object_thawer
525	object_thawer thawer (filename);	559	thawer (filename);
526		560
527	clear_archetable ();	561	clear_archetable ();
528	LOG (llevDebug, " arch-pass 1...\n");	562	LOG (llevDebug, " arch-pass 1...\n");
529	first_arch_pass (thawer);	563	first_arch_pass (thawer);
530	LOG (llevDebug, " done\n");	564	LOG (llevDebug, " done\n");
531
532	init_archetable ();
533	warn_archetypes = 1;
534	}	565	}
535		566
		567	init_archetable ();
		568	warn_archetypes = 1;
		569
536	{	570	{
		571	object_thawer
537	object_thawer thawer (filename);	572	thawer (filename);
538		573
539	LOG (llevDebug, " loading treasure...\n");	574	LOG (llevDebug, " loading treasure...\n");
540	load_treasures ();	575	load_treasures ();
		576	LOG (llevDebug, " done\n");
541	LOG (llevDebug, " done\n arch-pass 2...\n");	577	LOG (llevDebug, " arch-pass 2...\n");
542	second_arch_pass (thawer);	578	second_arch_pass (thawer);
543	LOG (llevDebug, " done\n");	579	LOG (llevDebug, " done\n");
544	#ifdef DEBUG	580	#ifdef DEBUG
545	check_generators ();	581	check_generators ();
546	#endif	582	#endif
…		…
550		586
551	/*	587	/*
552	* 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.
553	* This function returns NULL on failure.	589	* This function returns NULL on failure.
554	*/	590	*/
555		591	object *
556	object arch_to_object(archetype at) {	592	arch_to_object (archetype *at)
		593	{
557	object *op;	594	object *op;
		595
558	if(at==NULL) {	596	if (at == NULL)
		597	{
559	if(warn_archetypes)	598	if (warn_archetypes)
560	LOG(llevError,"Couldn't find archetype.\n");	599	LOG (llevError, "Couldn't find archetype.\n");
		600
561	return NULL;	601	return NULL;
562	}	602	}
563	op=get_object();	603
564	copy_object(&at->clone,op);	604	op = at->clone.clone ();
		605	op->arch = at;
565	op->instantiate ();	606	op->instantiate ();
566	op->arch=at;
567	return op;	607	return op;
568	}	608	}
569		609
570	/*	610	/*
571	* Creates an object. This function is called by get_archetype()	611	* Creates an object. This function is called by get_archetype()
572	* if it fails to find the appropriate archetype.	612	* if it fails to find the appropriate archetype.
573	* Thus get_archetype() will be guaranteed to always return	613	* Thus get_archetype() will be guaranteed to always return
574	* an object, and never NULL.	614	* an object, and never NULL.
575	*/	615	*/
576		616	object *
577	object create_singularity(const char name) {	617	create_singularity (const char *name)
		618	{
578	object *op;	619	object *op;
579	char buf[MAX_BUF];	620	char buf[MAX_BUF];
		621
580	sprintf(buf,"%s (%s)",ARCH_SINGULARITY,name);	622	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
581	op = get_object();	623	op = object::create ();
582	op->name = add_string(buf);	624	op->name = op->name_pl = buf;
583	op->name_pl = add_string(buf);
584	SET_FLAG(op,FLAG_NO_PICK);	625	SET_FLAG (op, FLAG_NO_PICK);
585	return op;	626	return op;
586	}	627	}
587		628
588	/*	629	/*
589	* Finds which archetype matches the given name, and returns a new	630	* Finds which archetype matches the given name, and returns a new
590	* object containing a copy of the archetype.	631	* object containing a copy of the archetype.
591	*/	632	*/
592		633	object *
593	object get_archetype(const char name) {	634	get_archetype (const char *name)
594	archetype *at;	635	{
595	at = find_archetype(name);	636	archetype *at = archetype::find (name);
596	if (at == NULL)	637
		638	if (!at)
597	return create_singularity(name);	639	return create_singularity (name);
		640
598	return arch_to_object(at);	641	return arch_to_object (at);
599	}	642	}
600		643
601	/*	644	/*
602	* Hash-function used by the arch-hashtable.	645	* Hash-function used by the arch-hashtable.
603	*/	646	*/
604		647
605	unsigned long	648	unsigned long
606	hasharch(const char *str, int tablesize) {	649	hasharch (const char *str, int tablesize)
		650	{
607	unsigned long hash = 0;	651	unsigned long hash = 0;
608	int i = 0;	652	unsigned int i = 0;
609	const char *p;	653	const char *p;
610		654
611	/* use the one-at-a-time hash function, which supposedly is	655	/* use the one-at-a-time hash function, which supposedly is
612	* better than the djb2-like one used by perl5.005, but	656	* better than the djb2-like one used by perl5.005, but
613	* certainly is better then the bug used here before.	657	* certainly is better then the bug used here before.
614	* see http://burtleburtle.net/bob/hash/doobs.html	658	* see http://burtleburtle.net/bob/hash/doobs.html
615	*/	659	*/
616	for (p = str; i < MAXSTRING && *p; p++, i++) {	660	for (p = str; i < MAXSTRING && *p; p++, i++)
		661	{
617	hash += *p;	662	hash += *p;
618	hash += hash << 10;	663	hash += hash << 10;
619	hash ^= hash >> 6;	664	hash ^= hash >> 6;
620	}	665	}
		666
621	hash += hash << 3;	667	hash += hash << 3;
622	hash ^= hash >> 11;	668	hash ^= hash >> 11;
623	hash += hash << 15;	669	hash += hash << 15;
		670
624	return hash % tablesize;	671	return hash % tablesize;
625	}	672	}
626		673
627	/*	674	/*
628	* Finds, using the hashtable, which archetype matches the given name.	675	* Finds, using the hashtable, which archetype matches the given name.
629	* returns a pointer to the found archetype, otherwise NULL.	676	* returns a pointer to the found archetype, otherwise NULL.
630	*/	677	*/
631		678
		679	archetype *
632	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
633	archetype *at;	694	archetype *at;
634	unsigned long index;	695	unsigned long index;
635		696
636	if (name == NULL)
637	return (archetype *) NULL;
638
639	index=hasharch(name, ARCHTABLE);	697	index = hasharch (name, ARCHTABLE);
640	arch_search++;	698	arch_search++;
641	for(;;) {	699	for (;;)
		700	{
642	at = arch_table[index];	701	at = arch_table[index];
		702
643	if (at==NULL) {	703	if (at == NULL)
		704	{
644	if(warn_archetypes)	705	if (warn_archetypes)
645	LOG(llevError,"Couldn't find archetype %s\n",name);	706	LOG (llevError, "Couldn't find archetype %s\n", name);
		707
646	return NULL;	708	return NULL;
647	}	709	}
		710
648	arch_cmp++;	711	arch_cmp++;
		712
649	if (!strcmp(at->name,name))	713	if (!strcmp ((const char *) at->name, name))
650	return at;	714	return at;
		715
651	if(++index>=ARCHTABLE)	716	if (++index >= ARCHTABLE)
652	index=0;	717	index = 0;
653	}	718	}
654	}	719	}
655		720
656	/*	721	/*
657	* Adds an archetype to the hashtable.	722	* Adds an archetype to the hashtable.
658	*/	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
659		730
660	static void add_arch(archetype *at) {
661	int index=hasharch(at->name, ARCHTABLE),org_index=index;	731	int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
		732
662	for(;;) {	733	for (;;)
		734	{
663	if(arch_table[index]==NULL) {	735	if (!arch_table[index])
		736	{
664	arch_table[index]=at;	737	arch_table[index] = this;
665	return;	738	break;
666	}	739	}
		740
667	if(++index==ARCHTABLE)	741	if (++index == ARCHTABLE)
668	index=0;	742	index = 0;
		743
669	if(index==org_index)	744	if (index == org_index)
670	fatal(ARCHTABLE_TOO_SMALL);	745	fatal (ARCHTABLE_TOO_SMALL);
671	}	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
672	}	774	}
673		775
674	/*	776	/*
675	* Returns the first archetype using the given type.	777	* Returns the first archetype using the given type.
676	* Used in treasure-generation.	778	* Used in treasure-generation.
677	*/	779	*/
678		780
		781	archetype *
679	archetype *type_to_archetype(int type) {	782	type_to_archetype (int type)
		783	{
680	archetype *at;	784	archetype *at;
681		785
682	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)
683	if(at->clone.type==type)	787	if (at->clone.type == type)
684	return at;	788	return at;
		789
685	return NULL;	790	return 0;
686	}	791	}
687		792
688	/*	793	/*
689	* Returns a new object copied from the first archetype matching	794	* Returns a new object copied from the first archetype matching
690	* the given type.	795	* the given type.
691	* Used in treasure-generation.	796	* Used in treasure-generation.
692	*/	797	*/
693		798
		799	object *
694	object *clone_arch(int type) {	800	clone_arch (int type)
		801	{
695	archetype *at;	802	archetype *at;
696	object *op=get_object();
697		803
698	if((at=type_to_archetype(type))==NULL) {	804	if ((at = type_to_archetype (type)) == NULL)
		805	{
699	LOG(llevError,"Can't clone archetype %d\n",type);	806	LOG (llevError, "Can't clone archetype %d\n", type);
700	free_object(op);
701	return NULL;	807	return 0;
702	}	808	}
703	copy_object(&at->clone,op);	809
		810	object *op = at->clone.clone ();
704	op->instantiate ();	811	op->instantiate ();
705	return op;	812	return op;
706	}	813	}
707		814
708	/*	815	/*
709	* member: make instance from class	816	* member: make instance from class
710	*/	817	*/
711		818
		819	object *
712	object object_create_arch (archetype at)	820	object_create_arch (archetype *at)
713	{	821	{
714	object op, prev = NULL, *head = NULL;	822	object op, prev = 0, *head = 0;
715		823
716	while (at) {	824	while (at)
		825	{
717	op = arch_to_object (at);	826	op = arch_to_object (at);
718	op->x = at->clone.x;	827	op->x = at->clone.x;
719	op->y = at->clone.y;	828	op->y = at->clone.y;
		829
720	if (head)	830	if (head)
721	op->head = head, prev->more = op;	831	op->head = head, prev->more = op;
		832
722	if (!head)	833	if (!head)
723	head = op;	834	head = op;
		835
724	prev = op;	836	prev = op;
725	at = at->more;	837	at = at->more;
726	}	838	}
		839
727	return (head);	840	return (head);
728	}	841	}
729		842
730	/* end of arch.c */

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.9 by root, Wed Aug 30 11:02:15 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.9 by root, Wed Aug 30 11:02:15 2006 UTC vs.
Revision 1.35 by root, Wed Jan 3 20:32:13 2007 UTC