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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.11 by root, Sun Sep 3 22:45:55 2006 UTC vs.
Revision 1.27 by root, Sat Dec 9 14:01:12 2006 UTC

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

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.11 by root, Sun Sep 3 22:45:55 2006 UTC vs. Revision 1.27 by root, Sat Dec 9 14:01:12 2006 UTC

Diff Legend

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.11 by root, Sun Sep 3 22:45:55 2006 UTC vs.
Revision 1.27 by root, Sat Dec 9 14:01:12 2006 UTC