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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.7 by root, Tue Aug 29 08:01:35 2006 UTC vs.
Revision 1.26 by root, Fri Nov 17 19:40:53 2006 UTC

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

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.7 by root, Tue Aug 29 08:01:35 2006 UTC vs. Revision 1.26 by root, Fri Nov 17 19:40:53 2006 UTC

Diff Legend

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.7 by root, Tue Aug 29 08:01:35 2006 UTC vs.
Revision 1.26 by root, Fri Nov 17 19:40:53 2006 UTC