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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.47 by root, Mon Apr 16 10:14:25 2007 UTC vs.
Revision 1.63 by root, Mon Jun 4 13:04:00 2007 UTC

…		…
1	/*	1	/*
2	* CrossFire, A Multiplayer game for X-windows	2	* This file is part of Crossfire TRT, the Multiplayer Online Role Playing Game.
3	*	3	*
4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team	4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5	* Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*	7	*
8	* This program is free software; you can redistribute it and/or modify	8	* Crossfire TRT is free software; you can redistribute it and/or modify it
9	* it under the terms of the GNU General Public License as published by	9	* under the terms of the GNU General Public License as published by the Free
10	* the Free Software Foundation; either version 2 of the License, or	10	* Software Foundation; either version 2 of the License, or (at your option)
11	* (at your option) any later version.	11	* any later version.
12	*	12	*
13	* 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, but
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16	* GNU General Public License for more details.	16	* for more details.
17	*	17	*
18	* 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 along
19	* along with this program; if not, write to the Free Software	19	* with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21	*	21	*
22	* The authors can be reached via e-mail at <crossfire@schmorp.de>	22	* The authors can be reached via e-mail to <crossfire@schmorp.de>
23	*/	23	*/
24		24
25	#include <cassert>	25	#include <cassert>
26		26
27	#include <global.h>	27	#include <global.h>
50	str_equal,	50	str_equal,
51	slice_allocator< std::pair<const char *const, arch_ptr> >	51	slice_allocator< std::pair<const char *const, arch_ptr> >
52	> HT;	52	> HT;
53		53
54	static HT ht (5000);	54	static HT ht (5000);
55	static std::vector<archetype *> archetypes;	55	archvec archetypes;
56		56
57	/**	57	/**
58	* GROS - This function retrieves an archetype given the name that appears	58	* GROS - This function retrieves an archetype given the name that appears
59	* during the game (for example, "writing pen" instead of "stylus").	59	* during the game (for example, "writing pen" instead of "stylus").
60	* It does not use the hashtable system, but browse the whole archlist each time.	60	* It does not use the hashtable system, but browse the whole archlist each time.
…		…
68	archetype *	68	archetype *
69	find_archetype_by_object_name (const char *name)	69	find_archetype_by_object_name (const char *name)
70	{	70	{
71	shstr_cmp name_cmp (name);	71	shstr_cmp name_cmp (name);
72		72
73	for (archetype *at = first_archetype; at; at = at->next)	73	for_all_archetypes (at)
74	if (at->clone.name == name_cmp)	74	if (at->archname == name_cmp)
75	return at;	75	return at;
76		76
77	return 0;	77	return 0;
78	}	78	}
79		79
…		…
85	archetype *	85	archetype *
86	find_archetype_by_object_type_name (int type, const char *name)	86	find_archetype_by_object_type_name (int type, const char *name)
87	{	87	{
88	shstr_cmp name_cmp (name);	88	shstr_cmp name_cmp (name);
89		89
90	for (archetype *at = first_archetype; at; at = at->next)	90	for_all_archetypes (at)
91	if (at->clone.name == name_cmp && at->clone.type == type)	91	if (at->archname == name_cmp && at->type == type)
92	return at;	92	return at;
93		93
94	return 0;	94	return 0;
95	}	95	}
96		96
…		…
102	object *	102	object *
103	get_archetype_by_skill_name (const char *skill, int type)	103	get_archetype_by_skill_name (const char *skill, int type)
104	{	104	{
105	shstr_cmp skill_cmp (skill);	105	shstr_cmp skill_cmp (skill);
106		106
107	for (archetype *at = first_archetype; at; at = at->next)	107	for_all_archetypes (at)
108	if (at->clone.skill == skill_cmp && (type == -1 \|\| type == at->clone.type))	108	if (at->skill == skill_cmp && (type == -1 \|\| type == at->type))
109	return arch_to_object (at);	109	return arch_to_object (at);
110		110
111	return 0;	111	return 0;
112	}	112	}
113		113
…		…
119	* (eg, skills)	119	* (eg, skills)
120	*/	120	*/
121	archetype *	121	archetype *
122	get_archetype_by_type_subtype (int type, int subtype)	122	get_archetype_by_type_subtype (int type, int subtype)
123	{	123	{
124	for (archetype *at = first_archetype; at; at = at->next)	124	for_all_archetypes (at)
125	if ((type == -1 \|\| type == at->clone.type) && (subtype == -1 \|\| subtype == at->clone.subtype))	125	if ((type == -1 \|\| type == at->type) && (subtype == -1 \|\| subtype == at->subtype))
126	return at;	126	return at;
127		127
128	return 0;	128	return 0;
129	}	129	}
130		130
…		…
275	}	275	}
276		276
277	return 0;	277	return 0;
278	}	278	}
279		279
		280	archetype::archetype (const char *name)
		281	{
		282	stub = true;
		283	arch = this;
		284	this->archname = this->name = this->name_pl = name;
		285	}
		286
		287	archetype::~archetype ()
		288	{
		289	unlink ();
		290	}
		291
280	void	292	void
281	init_archetypes (void)	293	archetype::link ()
282	{	294	{
283	load_archetypes ();	295	ht.insert (std::make_pair (archname, this));
284		296
285	empty_archetype = archetype::find ("empty_archetype");	297	if (!archetypes.contains (this))
		298	archetypes.insert (this);
286	}	299	}
287		300
288	archetype::archetype ()
289	{
290	clone.arch = this;
291
292	CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_to */
293	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
294	}
295
296	archetype::~archetype ()
297	{
298	//TODO: nuke ->more's
299	}
300
301	static void
302	unlink (archetype *at)
303	{
304	if (at->head)
305	at = at->head;
306
307	// destroy this archetype's link, making singletons out of its parts
308	while (at)
309	{
310	archetype *more = at->more;
311	at->clone.destroy_inv ();
312	at->head = at->more = 0;
313	at = more;
314	}
315	}
316
317	// dire hack, need to rationalise
318	void	301	void
319	overwrite (archetype at, object op)	302	archetype::unlink ()
320	{	303	{
321	at->clone = *op;	304	ht.erase (archname);
322		305
323	at->clone.arch = at;	306	if (archetypes.contains (this))
324	//TODO: inv et al.	307	archetypes.erase (this);
		308	}
		309
		310	/*
		311	* Finds, using the hashtable, which archetype matches the given name.
		312	* returns a pointer to the found archetype, otherwise NULL.
		313	*/
		314	archetype *
		315	archetype::find (const char *name)
		316	{
		317	if (!name)
		318	return 0;
		319
		320	auto (i, ht.find (name));
		321
		322	if (i == ht.end ())
		323	return 0;
		324	else
		325	return i->second;
		326	}
		327
		328	archetype *
		329	archetype::get (const char *name)
		330	{
		331	if (!name)
		332	{
		333	LOG (llevError, "null archetype requested\n");
		334	name = "(null)";
		335	}
		336
		337	archetype *at = find (name);
		338
		339	if (loading_arch && at && !at->stub)
		340	{
		341	at->unlink ();
		342	at = 0;
		343	}
		344
		345	if (!at \|\| (!at->stub && loading_arch))
		346	{
		347	at = new archetype (name);
		348	at->link ();
		349	}
		350
		351	return at;
325	}	352	}
326		353
327	archetype *	354	archetype *
328	archetype::read (object_thawer &f)	355	archetype::read (object_thawer &f)
329	{	356	{
330	assert (f.kw == KW_object);	357	assert (f.kw == KW_object);
331		358
332	archetype *head = get (f.get_str ());	359	loading_arch = true; // hack to tell parse_kv et al. to behave
333	unlink (head);
334	object *op = object::create ();
335		360
336	if (!op->parse_kv (f))	361	std::vector<archetype *> parts;
337	{	362
338	op->destroy (true);	363	coroapi::cede_to_tick_every (10);
339	// leak head	364
340	return 0;	365	for (;;)
341	}	366	{
		367	// the archetype might have been referenced earlier
		368	// so try to find an existing stub archetype first
		369	archetype *at = find (f.get_str ());
342		370
343	overwrite (head, op);	371	if (!at \|\| !at->stub)
344	op->destroy ();	372	at = new archetype (f.get_str ());
345		373
346	for (archetype *prev = head; f.kw == KW_more; )
347	{
348	f.next ();	374	f.next ();
349	assert (f.kw == KW_object);
350		375
351	archetype *more = get (f.get_str ());	376	#if 0
352	unlink (more);	377	// implementing it here in the server does neither allow multiple inheritence
353	object *op = object::create ();	378	// nor does it cleanly "just override". it would allow use in map files, though,
354		379	// and other resource files dynamically laoded (as opposed to being preprocessed).
355	if (!op->parse_kv (f))	380	// not that any of this is relevant as of yet...
		381	if (f.kw == KW_inherit)
356	{	382	{
357	op->destroy (true);	383	if (archetype *at = find (f.get_str ()))
358	// leak head more*	384	*op = at->clone;
359	return 0;	385	else
		386	LOG (llevError, "archetype '%s' tries to inherit from non-existent archetype '%s'.\n",
		387	&at->archname, f.get_str ());
		388
		389	f.next ();
360	}	390	}
		391	#endif
361		392
362	overwrite (more, op);	393	if (!at->parse_kv (f))
363	op->destroy ();	394	goto fail;
364		395
365	if (more->clone.x > head->tail_x) head->tail_x = more->clone.x;	396	at->post_load_check ();
366	if (more->clone.y > head->tail_y) head->tail_y = more->clone.y;
367		397
368	more->head = head;	398	parts.push_back (at);
369	more->clone.head = &head->clone;
370	prev->more = more;
371	prev->clone.more = &more->clone;
372		399
373	prev = more;	400	if (f.kw != KW_more)
374	}	401	break;
375		402
376	if (!head->next)	403	f.next ();
377	{
378	head->next = first_archetype;
379	first_archetype = head;
380	}
381		404
382	return head;	405	if (f.kw != KW_object)
383	}
384
385	/*
386	* Reads/parses the archetype-file, and copies into a linked list
387	* of archetype-structures.
388	*/
389	static bool
390	load_archetypes (object_thawer &f)
391	{
392	for (;;)
393	{
394	switch (f.kw)
395	{	406	{
396	case KW_object:	407	f.parse_error ("more object");
397	loading_arch = true;	408	goto fail;
398	if (!archetype::read (f))
399	{
400	loading_arch = false;
401	return false;
402	}
403
404	loading_arch = false;
405	continue;
406
407	case KW_EOF:
408	return true;
409
410	default:
411	if (!f.parse_error ("archetypes file"))
412	return false;
413	}	409	}
		410	}
414		411
415	f.next ();	412	loading_arch = false;
		413
		414	{
		415	auto (at, parts.begin ());
		416
		417	archetype *new_head = parts.front ();
		418	archetype *old_head = find (new_head->archname);
		419
		420	for (auto (at, parts.begin ()); at != parts.end (); ++at)
		421	fprintf (stderr, "%d: %s\n", at - parts.begin(), &(*at)->archname);//D
		422
		423	// check that all archetypes belong to the same old object or are new
		424	for (auto (at, parts.begin ()); at != parts.end (); ++at)
		425	{
		426	archetype new_part = at;
		427	archetype *old_part = find (new_part->archname);
		428
		429	if (old_part && old_part->head_ () != old_head)
		430	{
		431	fprintf (stderr, "nhn %s\n", &new_head->archname);//D
		432	fprintf (stderr, "old_head %p,%p new_head %p,%p ph %p\n", old_head, old_part, new_head, new_part, old_part->head_());
		433	LOG (llevError, "%s: unable to overwrite archetype '%s' with archetype of different object, skipping.\n",
		434	&new_part->archname, &((archetype *)old_part->head_ ())->archname);
		435	goto fail;
		436	}
416	}	437	}
417	}
418		438
		439	fprintf (stderr, "oh %p %s\n", old_head, &new_head->archname);//D
		440
		441	// deactivate existing archetype
		442	for (archetype at = old_head; at; at = (archetype )at->more)
		443	at->unlink ();
		444
		445	// reassemble new chain
		446	new_head->min_x = new_head->max_x = new_head->x;
		447	new_head->min_y = new_head->max_y = new_head->y;
		448
		449	archetype *less = new_head;
		450	archetype *head = 0;
		451	for (auto (p, parts.begin () + 1); p != parts.end (); ++p)
		452	{
		453	archetype at = p;
		454
		455	if (at->x < new_head->min_x) new_head->min_x = at->x;
		456	if (at->y < new_head->min_y) new_head->min_y = at->y;
		457	if (at->x > new_head->max_x) new_head->max_x = at->x;
		458	if (at->y > new_head->max_y) new_head->max_y = at->y;
		459
		460	at->head = head; head = new_head;
		461	less->more = at; less = at;
		462	}
		463
		464	// now activate it
		465	for (auto (p, parts.begin ()); p != parts.end (); ++p)
		466	{
		467	archetype at = p;
		468	at->stub = false;
		469	at->link ();
		470	}
		471
		472	return new_head;
		473	}
		474
		475	fail:
		476	for (auto (p, parts.begin ()); p != parts.end (); ++p)
		477	(*p)->destroy (true);
		478
		479	loading_arch = false;
		480	return 0;
		481	}
		482
419	/*	483	/*
420	* First initialises the archtype hash-table (init_archetable()).	484	* Initialize global archtype pointers:
421	* Reads and parses the archetype file (with the first and second-pass
422	* functions).
423	*/	485	*/
424	void	486	void
425	load_archetypes (void)	487	init_archetype_pointers ()
426	{	488	{
427	char filename[MAX_BUF];	489	ring_arch = archetype::find ("ring");
428		490	amulet_arch = archetype::find ("amulet");
429	sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);	491	staff_arch = archetype::find ("staff");
430	LOG (llevDebug, "Reading archetypes from %s:\n", filename);	492	crown_arch = archetype::find ("crown");
431		493	empty_archetype = archetype::find ("empty_archetype");
432	object_thawer f (filename);
433
434	f.next ();
435
436	if (!load_archetypes (f))
437	cleanup ("unable to load archetypes");
438
439	warn_archetypes = 1;
440
441	load_treasures ();
442	}	494	}
443		495
444	/*	496	/*
445	* Creates and returns a new object which is a copy of the given archetype.	497	* Creates and returns a new object which is a copy of the given archetype.
446	* This function returns NULL on failure.	498	* This function returns NULL on failure.
…		…
448	object *	500	object *
449	arch_to_object (archetype *at)	501	arch_to_object (archetype *at)
450	{	502	{
451	if (!at)	503	if (!at)
452	{	504	{
453	if (warn_archetypes)
454	LOG (llevError, "Couldn't find archetype.\n");	505	LOG (llevError, "Couldn't find archetype.\n");
455
456	return NULL;	506	return 0;
457	}	507	}
458		508
459	object *op = at->clone.clone ();	509	object *op = at->clone ();
460	op->arch = at;	510	op->arch = at;
461	op->instantiate ();	511	op->instantiate ();
		512
462	return op;	513	return op;
463	}	514	}
464		515
465	/*	516	/*
466	* Creates an object. This function is called by get_archetype()	517	* Creates an object. This function is called by get_archetype()
…		…
495		546
496	return arch_to_object (at);	547	return arch_to_object (at);
497	}	548	}
498		549
499	/*	550	/*
500	* Hash-function used by the arch-hashtable.
501	*/
502
503	unsigned long
504	hasharch (const char *str, int tablesize)
505	{
506	unsigned long hash = 0;
507	unsigned int i = 0;
508	const char *p;
509
510	/* use the one-at-a-time hash function, which supposedly is
511	* better than the djb2-like one used by perl5.005, but
512	* certainly is better then the bug used here before.
513	* see http://burtleburtle.net/bob/hash/doobs.html
514	*/
515	for (p = str; i < MAXSTRING && *p; p++, i++)
516	{
517	hash += *p;
518	hash += hash << 10;
519	hash ^= hash >> 6;
520	}
521
522	hash += hash << 3;
523	hash ^= hash >> 11;
524	hash += hash << 15;
525
526	return hash % tablesize;
527	}
528
529	/*
530	* Finds, using the hashtable, which archetype matches the given name.
531	* returns a pointer to the found archetype, otherwise NULL.
532	*/
533	archetype *
534	archetype::find (const char *name)
535	{
536	if (!name)
537	return 0;
538
539	AUTODECL (i, ht.find (name));
540
541	if (i == ht.end ())
542	return 0;
543	else
544	return i->second;
545	}
546
547	archetype *
548	archetype::get (const char *name)
549	{
550	archetype *at = find (name);
551
552	if (!at)
553	{
554	archetypes.push_back (at = new archetype);
555	at->name = name;
556	at->hash_add ();
557	}
558
559	return at;
560	}
561
562	/*
563	* Adds an archetype to the hashtable.
564	*/
565	void
566	archetype::hash_add ()
567	{
568	ht.insert (std::make_pair (name, this));
569	}
570
571	void
572	archetype::hash_del ()
573	{
574	ht.erase (name);
575	}
576
577	/*
578	* Returns the first archetype using the given type.	551	* Returns the first archetype using the given type.
579	* Used in treasure-generation.	552	* Used in treasure-generation.
580	*/	553	*/
581	archetype *	554	archetype *
582	type_to_archetype (int type)	555	type_to_archetype (int type)
583	{	556	{
584	for (archetype *at = first_archetype; at; at = at->more == 0 ? at->next : at->more)	557	for_all_archetypes (at)
585	if (at->clone.type == type)	558	if (at->type == type && at->head_ () != at)
586	return at;	559	return at;
587		560
588	return 0;	561	return 0;
589	}	562	}
590		563
…		…
602	{	575	{
603	LOG (llevError, "Can't clone archetype %d\n", type);	576	LOG (llevError, "Can't clone archetype %d\n", type);
604	return 0;	577	return 0;
605	}	578	}
606		579
607	object *op = at->clone.clone ();	580	object *op = at->clone ();
608	op->instantiate ();	581	op->instantiate ();
609	return op;	582	return op;
610	}	583	}
611		584
612	/*	585	/*
613	* member: make instance from class	586	* member: make instance from class
614	*/	587	*/
615
616	object *	588	object *
617	object_create_arch (archetype *at)	589	object_create_arch (archetype *at)
618	{	590	{
619	object op, prev = 0, *head = 0;	591	object op, prev = 0, *head = 0;
620		592
621	while (at)	593	while (at)
622	{	594	{
623	op = arch_to_object (at);	595	op = arch_to_object (at);
		596
624	op->x = at->clone.x;	597	op->x = at->x;
625	op->y = at->clone.y;	598	op->y = at->y;
626		599
627	if (head)	600	if (head)
628	op->head = head, prev->more = op;	601	op->head = head, prev->more = op;
629		602
630	if (!head)	603	if (!head)
631	head = op;	604	head = op;
632		605
633	prev = op;	606	prev = op;
634	at = at->more;	607	at = (archetype *)at->more;
635	}	608	}
636		609
637	return (head);	610	return head;
638	}	611	}
639		612

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.47 by root, Mon Apr 16 10:14:25 2007 UTC vs. Revision 1.63 by root, Mon Jun 4 13:04:00 2007 UTC

Diff Legend

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.47 by root, Mon Apr 16 10:14:25 2007 UTC vs.
Revision 1.63 by root, Mon Jun 4 13:04:00 2007 UTC