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

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

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.2 by root, Sat Aug 26 08:44:04 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.2 by root, Sat Aug 26 08:44:04 2006 UTC vs.
Revision 1.37 by pippijn, Mon Jan 15 21:06:18 2007 UTC