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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.13 by pippijn, Thu Sep 7 09:37:11 2006 UTC vs.
Revision 1.36 by pippijn, Sat Jan 6 14:42:28 2007 UTC

…		…
1	/*
2	* static char *rcsid_arch_c =
3	* "$Id: arch.C,v 1.13 2006/09/07 09:37:11 pippijn Exp $";
4	*/
5
6	/*	1	/*
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
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	*/
28		24
29	#include <cassert>	25	#include <cassert>
30		26
31	#include <tr1/unordered_map>
32
33	#include <global.h>	27	#include <global.h>
34	#include <arch.h>
35	#include <funcpoint.h>	28	#include <funcpoint.h>
36	#include <loader.h>	29	#include <loader.h>
37		30
38	/* IF set, does a little timing on the archetype load. */	31	#define USE_UNORDERED_MAP 0
39	#define TIME_ARCH_LOAD 0
40		32
41	static void add_arch (archetype * at);	33	#if USE_UNORDERED_MAP
		34	# include <tr1/functional>
		35	# include <tr1/unordered_map>
		36	#endif
42		37
43	static archetype *arch_table[ARCHTABLE];
44	int arch_cmp = 0; /* How many strcmp's */	38	int arch_cmp = 0; /* How many strcmp's */
45	int arch_search = 0; /* How many searches */	39	int arch_search = 0; /* How many searches */
46	int arch_init; /* True if doing arch initialization */	40	int arch_init; /* True if doing arch initialization */
47		41
48	/* The naming of these functions is really poor - they are all	42	/* The naming of these functions is really poor - they are all
…		…
53	* MSW 2003-04-29	47	* MSW 2003-04-29
54	*/	48	*/
55		49
56	#if USE_UNORDERED_MAP	50	#if USE_UNORDERED_MAP
57	// the hashtable	51	// the hashtable
58	typedef std::tr1::unordered_map<size_t, archetype *> HT;	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;
59		61
60	static HT ht;	62	static HT ht;
		63	#else
		64	static arch_ptr arch_table[ARCHTABLE];
61	#endif	65	#endif
62		66
63	/**	67	/**
64	* GROS - This function retrieves an archetype given the name that appears	68	* GROS - This function retrieves an archetype given the name that appears
65	* during the game (for example, "writing pen" instead of "stylus").	69	* during the game (for example, "writing pen" instead of "stylus").
…		…
115	* If type is -1, ew don't match on type.	119	* If type is -1, ew don't match on type.
116	*/	120	*/
117	object *	121	object *
118	get_archetype_by_skill_name (const char *skill, int type)	122	get_archetype_by_skill_name (const char *skill, int type)
119	{	123	{
120	archetype *	124	archetype *at;
121	at;
122		125
123	if (skill == NULL)	126	if (skill)
124	return NULL;
125
126	for (at = first_archetype; at != NULL; at = at->next)	127	for (at = first_archetype; at; at = at->next)
127	{
128	if (((type == -1) \|\| (type == at->clone.type)) && (!strcmp (at->clone.skill, skill)))	128	if (((type == -1) \|\| (type == at->clone.type)) && (!strcmp (at->clone.skill, skill)))
129	return arch_to_object (at);	129	return arch_to_object (at);
130	}	130
131	return NULL;	131	return 0;
132	}	132	}
133		133
134	/* similiar to above - this returns the first archetype	134	/* similiar to above - this returns the first archetype
135	* that matches both the type and subtype. type and subtype	135	* that matches both the type and subtype. type and subtype
136	* 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
…		…
165	* but it otherwise had a big memory leak.	165	* but it otherwise had a big memory leak.
166	*/	166	*/
167	object *	167	object *
168	get_archetype_by_object_name (const char *name)	168	get_archetype_by_object_name (const char *name)
169	{	169	{
170	archetype *	170	archetype *at;
171	at;
172	char
173	tmpname[MAX_BUF];	171	char tmpname[MAX_BUF];
174	int	172	int i;
175	i;
176		173
177	strncpy (tmpname, name, MAX_BUF - 1);	174	assign (tmpname, name);
178	tmpname[MAX_BUF - 1] = 0;	175
179	for (i = strlen (tmpname); i > 0; i--)	176	for (i = strlen (tmpname); i > 0; i--)
180	{	177	{
181	tmpname[i] = 0;	178	tmpname[i] = 0;
182	at = find_archetype_by_object_name (tmpname);	179	at = find_archetype_by_object_name (tmpname);
		180
183	if (at != NULL)	181	if (at)
184	{
185	return arch_to_object (at);	182	return arch_to_object (at);
186	}
187	}	183	}
		184
188	return create_singularity (name);	185	return create_singularity (name);
189	}	186	}
190		187
191	/* 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
192	* a string seperated lists of things to match, with certain keywords.	189	* a string seperated lists of things to match, with certain keywords.
…		…
204	* If count is 1, make a quick check on the name.	201	* If count is 1, make a quick check on the name.
205	* 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.
206	* Last, make a check on the full name.	203	* Last, make a check on the full name.
207	*/	204	*/
208	int	205	int
209	item_matched_string (object * pl, object * op, const char *name)	206	item_matched_string (object pl, object op, const char *name)
210	{	207	{
211	char *
212	cp,
213	local_name[MAX_BUF];	208	char *cp, local_name[MAX_BUF];
214	int	209	int count, retval = 0;
215	count,	210
216	retval = 0;
217	strcpy (local_name, name); /* strtok is destructive to name */	211	strcpy (local_name, name); /* strtok is destructive to name */
218		212
219	for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))	213	for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
220	{	214	{
221	while (cp[0] == ' ')	215	while (cp[0] == ' ')
…		…
272	retval = 15;	266	retval = 15;
273	else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))	267	else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))
274	retval = 14;	268	retval = 14;
275	else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))	269	else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))
276	retval = 14;	270	retval = 14;
277
278	/* Do substring checks, so things like 'Str+1' will match.	271	/* Do substring checks, so things like 'Str+1' will match.
279	* retval of these should perhaps be lower - they are lower	272	* retval of these should perhaps be lower - they are lower
280	* then the specific strcasecmp aboves, but still higher than	273	* then the specific strcasecmp aboves, but still higher than
281	* some other match criteria.	274	* some other match criteria.
282	*/	275	*/
…		…
284	retval = 12;	277	retval = 12;
285	else if (strstr (query_base_name (op, 0), cp))	278	else if (strstr (query_base_name (op, 0), cp))
286	retval = 12;	279	retval = 12;
287	else if (strstr (query_short_name (op), cp))	280	else if (strstr (query_short_name (op), cp))
288	retval = 12;	281	retval = 12;
289
290	/* Check against plural/non plural based on count. */	282	/* Check against plural/non plural based on count. */
291	else if (count > 1 && !strcasecmp (cp, op->name_pl))	283	else if (count > 1 && !strcasecmp (cp, op->name_pl))
292	{
293	retval = 6;	284	retval = 6;
294	}
295	else if (count == 1 && !strcasecmp (op->name, cp))	285	else if (count == 1 && !strcasecmp (op->name, cp))
296	{
297	retval = 6;	286	retval = 6;
298	}
299	/* base name matched - not bad */	287	/* base name matched - not bad */
300	else if (strcasecmp (cp, op->name) == 0 && !count)	288	else if (strcasecmp (cp, op->name) == 0 && !count)
301	retval = 4;	289	retval = 4;
302	/* Check for partial custom name, but give a real low priority */	290	/* Check for partial custom name, but give a real low priority */
303	else if (op->custom_name && strstr (op->custom_name, cp))	291	else if (op->custom_name && strstr (op->custom_name, cp))
…		…
305		293
306	if (retval)	294	if (retval)
307	{	295	{
308	if (pl->type == PLAYER)	296	if (pl->type == PLAYER)
309	pl->contr->count = count;	297	pl->contr->count = count;
		298
310	return retval;	299	return retval;
311	}	300	}
312	}	301	}
		302
313	return 0;	303	return 0;
314	}	304	}
315		305
316	/*	306	/*
317	* Initialises the internal linked list of archetypes (read from file).	307	* Initialises the internal linked list of archetypes (read from file).
…		…
322	void	312	void
323	init_archetypes (void)	313	init_archetypes (void)
324	{ /* called from add_player() and edit() */	314	{ /* called from add_player() and edit() */
325	if (first_archetype != NULL) /* Only do this once */	315	if (first_archetype != NULL) /* Only do this once */
326	return;	316	return;
		317
327	arch_init = 1;	318	arch_init = 1;
328	load_archetypes ();	319	load_archetypes ();
329	arch_init = 0;	320	arch_init = 0;
330	empty_archetype = find_archetype ("empty_archetype");	321	empty_archetype = archetype::find ("empty_archetype");
		322
331	/* init_blocksview();*/	323	/* init_blocksview();*/
332	}	324	}
333		325
334	/*	326	/*
335	* Stores debug-information about how efficient the hashtable	327	* Stores debug-information about how efficient the hashtable
336	* used for archetypes has been in the static errmsg array.	328	* used for archetypes has been in the static errmsg array.
337	*/	329	*/
338		330
339	void	331	void
340	arch_info (object * op)	332	arch_info (object *op)
341	{	333	{
342	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);
343	new_draw_info (NDI_BLACK, 0, op, errmsg);	335	new_draw_info (NDI_BLACK, 0, op, errmsg);
344	}	336	}
345		337
…		…
363	archetype *at;	355	archetype *at;
364		356
365	LOG (llevDebug, " Setting up archetable...\n");	357	LOG (llevDebug, " Setting up archetable...\n");
366		358
367	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)
368	add_arch (at);	360	at->hash_add ();
369		361
370	LOG (llevDebug, "done\n");	362	LOG (llevDebug, "done\n");
371	}	363	}
372		364
373	/*
374	* Dumps an archetype to debug-level output.
375	*/
376
377	void
378	dump_arch (archetype * at)
379	{
380	dump_object (&at->clone);
381	}
382
383	/*
384	* Dumps _all_ archetypes to debug-level output.
385	* If you run crossfire with debug, and enter DM-mode, you can trigger
386	* this with the O key.
387	*/
388
389	void
390	dump_all_archetypes (void)
391	{
392	archetype *
393	at;
394	for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
395	{
396	dump_arch (at);
397	fprintf (logfile, "%s\n", errmsg);
398	}
399	}
400
401	void	365	void
402	free_all_archs (void)	366	free_all_archs (void)
403	{	367	{
404	archetype *	368	archetype at, next;
405	at, *
406	next;
407	int
408	i = 0, f = 0;	369	int i = 0, f = 0;
409		370
410	for (at = first_archetype; at != NULL; at = next)	371	for (at = first_archetype; at != NULL; at = next)
411	{	372	{
412	if (at->more)	373	if (at->more)
413	next = at->more;	374	next = at->more;
414	else	375	else
415	next = at->next;	376	next = at->next;
416		377
417	delete	378	delete
418	at;	379	at;
		380
419	i++;	381	i++;
420	}	382	}
		383
421	LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);	384	LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
422	}	385	}
423		386
424	/*	387	archetype::archetype ()
425	* Allocates, initialises and returns the pointer to an archetype structure.
426	*/
427	// TODO: should become constructor
428	archetype *
429	get_archetype_struct (void)
430	{	388	{
431	archetype *
432	arch;
433
434	arch = new archetype;
435
436	clear_object (&arch->clone); /* to initial state other also */
437	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 */
438	SET_FLAG (&arch->clone, FLAG_REMOVED); /* doesn't copy these flags... */	390	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
		391	}
439		392
440	return arch;	393	archetype::~archetype ()
		394	{
441	}	395	}
442		396
443	/*	397	/*
444	* Reads/parses the archetype-file, and copies into a linked list	398	* Reads/parses the archetype-file, and copies into a linked list
445	* of archetype-structures.	399	* of archetype-structures.
446	*/	400	*/
447	void	401	void
448	first_arch_pass (object_thawer & fp)	402	first_arch_pass (object_thawer & fp)
449	{	403	{
450	object *	404	archetype head = 0, last_more = 0;
451	op;
452	archetype *
453	at, *
454	head = NULL, *last_more = NULL;
455	int
456	i;
457		405
458	op = get_object ();	406	archetype *at = new archetype;
459	op->arch = first_archetype = at = get_archetype_struct ();	407	at->clone.arch = first_archetype = at;
460		408
461	while ((i = load_object (fp, op, 0)))	409	while (int i = load_object (fp, &at->clone, 0))
462	{	410	{
463	copy_object (op, &at->clone);
464	at->clone.speed_left = (float) (-0.1);	411	at->clone.speed_left = (float) (-0.1);
465	/* 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
466	* 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.
467	* 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
468	* values for the body_used info, so when items are created	415	* values for the body_used info, so when items are created
469	* for it, they can be properly equipped.	416	* for it, they can be properly equipped.
470	*/	417	*/
471	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));
472		419
473	switch (i)	420	switch (i)
474	{	421	{
475	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 */
476	if (last_more != NULL)	423	if (last_more != NULL)
477	last_more->next = at;	424	last_more->next = at;
478	if (head != NULL)	425	if (head != NULL)
479	head->next = at;	426	head->next = at;
480	head = last_more = at;	427	head = last_more = at;
481	#if 0	428	#if 0
482	if (!op->type)	429	if (!op->type)
483	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);
484	#endif	431	#endif
485	at->tail_x = 0;	432	at->tail_x = 0;
486	at->tail_y = 0;	433	at->tail_y = 0;
487	break;	434	break;
488		435
489	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 */
490		437
491	at->head = head;	438	at->head = head;
492	at->clone.head = &head->clone;	439	at->clone.head = &head->clone;
493	if (last_more != NULL)	440	if (last_more != NULL)
494	{	441	{
495	last_more->more = at;	442	last_more->more = at;
496	last_more->clone.more = &at->clone;	443	last_more->clone.more = &at->clone;
497	}	444	}
498	last_more = at;	445	last_more = at;
499		446
500	/* If this multipart image is still composed of individual small	447	/* If this multipart image is still composed of individual small
501	* 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,
502	* 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
503	* 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.
504	*/	451	*/
505	if (at->clone.face != head->clone.face)	452	if (at->clone.face != head->clone.face)
506	{	453	{
507	head->tail_x = 0;	454	head->tail_x = 0;
508	head->tail_y = 0;	455	head->tail_y = 0;
509	}	456	}
510	else	457	else
511	{	458	{
512	if (at->clone.x > head->tail_x)	459	if (at->clone.x > head->tail_x)
513	head->tail_x = at->clone.x;	460	head->tail_x = at->clone.x;
514	if (at->clone.y > head->tail_y)	461	if (at->clone.y > head->tail_y)
515	head->tail_y = at->clone.y;	462	head->tail_y = at->clone.y;
516	}	463	}
517	break;	464	break;
518		465
519	}	466	}
520		467
521	at = get_archetype_struct ();	468	at = new archetype;
522	clear_object (op);	469
523	op->arch = at;	470	at->clone.arch = at;
524	}	471	}
525		472
526	delete	473	delete at;
527	at;
528	free_object (op);
529	}	474	}
530		475
531	/*	476	/*
532	* Reads the archetype file once more, and links all pointers between	477	* Reads the archetype file once more, and links all pointers between
533	* archetypes.	478	* archetypes.
534	*/	479	*/
535		480
536	void	481	void
537	second_arch_pass (object_thawer & thawer)	482	second_arch_pass (object_thawer & thawer)
538	{	483	{
539	char
540	buf[MAX_BUF], *
541	variable = buf, argument, cp;	484	char buf[MAX_BUF], variable = buf, argument, *cp;
542	archetype *
543	at = NULL, *other;	485	archetype at = NULL, other;
544		486
545	while (fgets (buf, MAX_BUF, thawer) != NULL)	487	while (fgets (buf, MAX_BUF, thawer) != NULL)
546	{	488	{
547	if (*buf == '#')	489	if (*buf == '#')
548	continue;	490	continue;
…		…
556	cp--;	498	cp--;
557	}	499	}
558	}	500	}
559	if (!strcmp ("Object", variable))	501	if (!strcmp ("Object", variable))
560	{	502	{
561	if ((at = find_archetype (argument)) == NULL)	503	if ((at = archetype::find (argument)) == NULL)
562	LOG (llevError, "Warning: failed to find arch %s\n", argument);	504	LOG (llevError, "Warning: failed to find arch %s\n", argument);
563	}	505	}
564	else if (!strcmp ("other_arch", variable))	506	else if (!strcmp ("other_arch", variable))
565	{	507	{
566	if (at != NULL && at->clone.other_arch == NULL)	508	if (at != NULL && at->clone.other_arch == NULL)
567	{	509	{
568	if ((other = find_archetype (argument)) == NULL)	510	if ((other = archetype::find (argument)) == NULL)
569	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);	511	LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
570	else if (at != NULL)	512	else if (at != NULL)
571	at->clone.other_arch = other;	513	at->clone.other_arch = other;
572	}	514	}
573	}	515	}
574	else if (!strcmp ("randomitems", variable))	516	else if (!strcmp ("randomitems", variable))
575	{	517	{
576	if (at != NULL)	518	if (at != NULL)
577	{	519	{
578	treasurelist *
579	tl = find_treasurelist (argument);	520	treasurelist *tl = find_treasurelist (argument);
		521
580	if (tl == NULL)	522	if (tl == NULL)
581	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);
582	else	524	else
583	at->clone.randomitems = tl;	525	at->clone.randomitems = tl;
584	}	526	}
…		…
588		530
589	#ifdef DEBUG	531	#ifdef DEBUG
590	void	532	void
591	check_generators (void)	533	check_generators (void)
592	{	534	{
593	archetype *	535	archetype *at;
594	at;	536
595	for (at = first_archetype; at != NULL; at = at->next)	537	for (at = first_archetype; at != NULL; at = at->next)
596	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)
597	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);
598	}	540	}
599	#endif	541	#endif
…		…
606	*/	548	*/
607		549
608	void	550	void
609	load_archetypes (void)	551	load_archetypes (void)
610	{	552	{
611	char
612	filename[MAX_BUF];	553	char filename[MAX_BUF];
613	#if TIME_ARCH_LOAD
614	struct timeval
615	tv1,
616	tv2;
617	#endif
618		554
619	sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);	555	sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
620	LOG (llevDebug, "Reading archetypes from %s:\n", filename);	556	LOG (llevDebug, "Reading archetypes from %s:\n", filename);
621		557
622	{	558	{
…		…
636	object_thawer	572	object_thawer
637	thawer (filename);	573	thawer (filename);
638		574
639	LOG (llevDebug, " loading treasure...\n");	575	LOG (llevDebug, " loading treasure...\n");
640	load_treasures ();	576	load_treasures ();
		577	LOG (llevDebug, " done\n");
641	LOG (llevDebug, " done\n arch-pass 2...\n");	578	LOG (llevDebug, " arch-pass 2...\n");
642	second_arch_pass (thawer);	579	second_arch_pass (thawer);
643	LOG (llevDebug, " done\n");	580	LOG (llevDebug, " done\n");
644	#ifdef DEBUG	581	#ifdef DEBUG
645	check_generators ();	582	check_generators ();
646	#endif	583	#endif
…		…
650		587
651	/*	588	/*
652	* 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.
653	* This function returns NULL on failure.	590	* This function returns NULL on failure.
654	*/	591	*/
655
656	object *	592	object *
657	arch_to_object (archetype * at)	593	arch_to_object (archetype *at)
658	{	594	{
659	object *	595	object *op;
660	op;	596
661	if (at == NULL)	597	if (at == NULL)
662	{	598	{
663	if (warn_archetypes)	599	if (warn_archetypes)
664	LOG (llevError, "Couldn't find archetype.\n");	600	LOG (llevError, "Couldn't find archetype.\n");
		601
665	return NULL;	602	return NULL;
666	}	603	}
667	op = get_object ();	604
668	copy_object (&at->clone, op);	605	op = at->clone.clone ();
		606	op->arch = at;
669	op->instantiate ();	607	op->instantiate ();
670	op->arch = at;
671	return op;	608	return op;
672	}	609	}
673		610
674	/*	611	/*
675	* Creates an object. This function is called by get_archetype()	612	* Creates an object. This function is called by get_archetype()
676	* if it fails to find the appropriate archetype.	613	* if it fails to find the appropriate archetype.
677	* Thus get_archetype() will be guaranteed to always return	614	* Thus get_archetype() will be guaranteed to always return
678	* an object, and never NULL.	615	* an object, and never NULL.
679	*/	616	*/
680
681	object *	617	object *
682	create_singularity (const char *name)	618	create_singularity (const char *name)
683	{	619	{
684	object *	620	object *op;
685	op;
686	char
687	buf[MAX_BUF];	621	char buf[MAX_BUF];
		622
688	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);	623	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
689	op = get_object ();	624	op = object::create ();
690	op->name = op->name_pl = buf;	625	op->name = op->name_pl = buf;
691	SET_FLAG (op, FLAG_NO_PICK);	626	SET_FLAG (op, FLAG_NO_PICK);
692	return op;	627	return op;
693	}	628	}
694		629
695	/*	630	/*
696	* Finds which archetype matches the given name, and returns a new	631	* Finds which archetype matches the given name, and returns a new
697	* object containing a copy of the archetype.	632	* object containing a copy of the archetype.
698	*/	633	*/
699
700	object *	634	object *
701	get_archetype (const char *name)	635	get_archetype (const char *name)
702	{	636	{
703	archetype *	637	archetype *at = archetype::find (name);
704	at;	638
705	at = find_archetype (name);	639	if (!at)
706	if (at == NULL)
707	return create_singularity (name);	640	return create_singularity (name);
		641
708	return arch_to_object (at);	642	return arch_to_object (at);
709	}	643	}
710		644
711	/*	645	/*
712	* Hash-function used by the arch-hashtable.	646	* Hash-function used by the arch-hashtable.
713	*/	647	*/
714		648
715	unsigned long	649	unsigned long
716	hasharch (const char *str, int tablesize)	650	hasharch (const char *str, int tablesize)
717	{	651	{
718	unsigned long	652	unsigned long hash = 0;
719	hash = 0;
720	unsigned int	653	unsigned int i = 0;
721	i = 0;
722	const char *	654	const char *p;
723	p;
724		655
725	/* use the one-at-a-time hash function, which supposedly is	656	/* use the one-at-a-time hash function, which supposedly is
726	* better than the djb2-like one used by perl5.005, but	657	* better than the djb2-like one used by perl5.005, but
727	* certainly is better then the bug used here before.	658	* certainly is better then the bug used here before.
728	* see http://burtleburtle.net/bob/hash/doobs.html	659	* see http://burtleburtle.net/bob/hash/doobs.html
…		…
745	* Finds, using the hashtable, which archetype matches the given name.	676	* Finds, using the hashtable, which archetype matches the given name.
746	* returns a pointer to the found archetype, otherwise NULL.	677	* returns a pointer to the found archetype, otherwise NULL.
747	*/	678	*/
748		679
749	archetype *	680	archetype *
750	find_archetype (const char *name)	681	archetype::find (const char *name)
751	{	682	{
752	#if USE_UNORDERED_MAP
753	name = shstr::find (name);
754
755	if (!name)	683	if (!name)
756	return 0;	684	return 0;
757		685
758	HT::const_iterator i = ht.find ((size_t)name);	686	#if USE_UNORDERED_MAP
		687	AUTODECL (i, ht.find ((size_t) name));
759		688
760	if (i == ht.end ())	689	if (i == ht.end ())
761	return 0;	690	return 0;
762	else	691	else
763	return i->second;	692	return i->second;
764	#endif	693	#endif
765		694
766	archetype *at;	695	archetype *at;
767	unsigned long index;	696	unsigned long index;
768		697
769	if (name == NULL)
770	return (archetype *) NULL;
771
772	index = hasharch (name, ARCHTABLE);	698	index = hasharch (name, ARCHTABLE);
773	arch_search++;	699	arch_search++;
774	for (;;)	700	for (;;)
775	{	701	{
776	at = arch_table[index];	702	at = arch_table[index];
		703
777	if (at == NULL)	704	if (at == NULL)
778	{	705	{
779	if (warn_archetypes)	706	if (warn_archetypes)
780	LOG (llevError, "Couldn't find archetype %s\n", name);	707	LOG (llevError, "Couldn't find archetype %s\n", name);
		708
781	return NULL;	709	return NULL;
782	}	710	}
		711
783	arch_cmp++;	712	arch_cmp++;
		713
784	if (!strcmp ((const char *) at->name, name))	714	if (!strcmp ((const char *) at->name, name))
785	return at;	715	return at;
		716
786	if (++index >= ARCHTABLE)	717	if (++index >= ARCHTABLE)
787	index = 0;	718	index = 0;
788	}	719	}
789	}	720	}
790		721
791	/*	722	/*
792	* Adds an archetype to the hashtable.	723	* Adds an archetype to the hashtable.
793	*/	724	*/
794		725	void
795	static void	726	archetype::hash_add ()
796	add_arch (archetype *at)
797	{	727	{
798	#if USE_UNORDERED_MAP	728	#if USE_UNORDERED_MAP
799	ht.insert (std::make_pair ((size_t)(const char *)at->name, at));	729	ht.insert (std::make_pair ((size_t) (const char *) name, this));
800	#endif	730	#else
801		731
802	int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;	732	int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
803		733
804	for (;;)	734	for (;;)
805	{	735	{
806	if (arch_table[index] == NULL)	736	if (!arch_table[index])
807	{	737	{
808	arch_table[index] = at;	738	arch_table[index] = this;
809	return;	739	break;
810	}	740	}
811		741
812	if (++index == ARCHTABLE)	742	if (++index == ARCHTABLE)
813	index = 0;	743	index = 0;
814		744
815	if (index == org_index)	745	if (index == org_index)
816	fatal (ARCHTABLE_TOO_SMALL);	746	fatal (ARCHTABLE_TOO_SMALL);
817	}	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
818	}	775	}
819		776
820	/*	777	/*
821	* Returns the first archetype using the given type.	778	* Returns the first archetype using the given type.
822	* Used in treasure-generation.	779	* Used in treasure-generation.
823	*/	780	*/
824		781
825	archetype *	782	archetype *
826	type_to_archetype (int type)	783	type_to_archetype (int type)
827	{	784	{
828	archetype *	785	archetype *at;
829	at;
830		786
831	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)
832	if (at->clone.type == type)	788	if (at->clone.type == type)
833	return at;	789	return at;
		790
834	return NULL;	791	return 0;
835	}	792	}
836		793
837	/*	794	/*
838	* Returns a new object copied from the first archetype matching	795	* Returns a new object copied from the first archetype matching
839	* the given type.	796	* the given type.
…		…
841	*/	798	*/
842		799
843	object *	800	object *
844	clone_arch (int type)	801	clone_arch (int type)
845	{	802	{
846	archetype *	803	archetype *at;
847	at;
848	object *
849	op = get_object ();
850		804
851	if ((at = type_to_archetype (type)) == NULL)	805	if ((at = type_to_archetype (type)) == NULL)
852	{	806	{
853	LOG (llevError, "Can't clone archetype %d\n", type);	807	LOG (llevError, "Can't clone archetype %d\n", type);
854	free_object (op);
855	return NULL;	808	return 0;
856	}	809	}
857	copy_object (&at->clone, op);	810
		811	object *op = at->clone.clone ();
858	op->instantiate ();	812	op->instantiate ();
859	return op;	813	return op;
860	}	814	}
861		815
862	/*	816	/*
863	* member: make instance from class	817	* member: make instance from class
864	*/	818	*/
865		819
866	object *	820	object *
867	object_create_arch (archetype * at)	821	object_create_arch (archetype *at)
868	{	822	{
869	object *	823	object op, prev = 0, *head = 0;
870	op, *
871	prev = NULL, *head = NULL;
872		824
873	while (at)	825	while (at)
874	{	826	{
875	op = arch_to_object (at);	827	op = arch_to_object (at);
876	op->x = at->clone.x;	828	op->x = at->clone.x;
877	op->y = at->clone.y;	829	op->y = at->clone.y;
		830
878	if (head)	831	if (head)
879	op->head = head, prev->more = op;	832	op->head = head, prev->more = op;
		833
880	if (!head)	834	if (!head)
881	head = op;	835	head = op;
		836
882	prev = op;	837	prev = op;
883	at = at->more;	838	at = at->more;
884	}	839	}
		840
885	return (head);	841	return (head);
886	}	842	}
887		843
888	/* end of arch.c */

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.13 by pippijn, Thu Sep 7 09:37:11 2006 UTC vs. Revision 1.36 by pippijn, Sat Jan 6 14:42:28 2007 UTC

Diff Legend

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.13 by pippijn, Thu Sep 7 09:37:11 2006 UTC vs.
Revision 1.36 by pippijn, Sat Jan 6 14:42:28 2007 UTC