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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.10 by root, Sun Sep 3 00:18:39 2006 UTC vs.
Revision 1.37 by pippijn, Mon Jan 15 21:06:18 2007 UTC

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

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.10 by root, Sun Sep 3 00:18:39 2006 UTC vs. Revision 1.37 by pippijn, Mon Jan 15 21:06:18 2007 UTC

Diff Legend

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.10 by root, Sun Sep 3 00:18:39 2006 UTC vs.
Revision 1.37 by pippijn, Mon Jan 15 21:06:18 2007 UTC