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

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

Diff Legend

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

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