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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.52 by root, Tue Apr 17 10:06:32 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 ()	280	archetype::archetype (const char *name)
281	{	281	{
		282	stub = true;
282	clone.arch = this;	283	arch = this;
283		284	this->archname = this->name = this->name_pl = name;
284	CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_to */
285	SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
286	}	285	}
287		286
288	archetype::~archetype ()	287	archetype::~archetype ()
289	{	288	{
290	//TODO: nuke ->more's	289	unlink ();
291	}	290	}
292		291
293	static void
294	unlink (archetype *at)
295	{
296	if (at->head)
297	at = at->head;
298
299	// destroy this archetype's link, making singletons out of its parts
300	while (at)
301	{
302	archetype *more = at->more;
303	at->clone.destroy_inv ();
304	at->head = at->more = 0;
305	at = more;
306	}
307	}
308
309	// dire hack, need to rationalise
310	void	292	void
311	overwrite (archetype at, object op)	293	archetype::link ()
312	{	294	{
313	at->clone = *op;	295	ht.insert (std::make_pair (archname, this));
314
315	at->clone.arch = at;
316	at->clone.inv = op->inv; op->inv = 0;
317		296
318	op->destroy ();	297	if (!archetypes.contains (this))
		298	archetypes.insert (this);
319	}	299	}
320		300
321	bool	301	void
		302	archetype::unlink ()
		303	{
		304	ht.erase (archname);
		305
		306	if (archetypes.contains (this))
		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;
		352	}
		353
		354	archetype *
322	archetype::load (object_thawer &f)	355	archetype::read (object_thawer &f)
323	{	356	{
324	assert (f.kw == KW_object);	357	assert (f.kw == KW_object);
325		358
326	typedef std::pair<archetype , object > part;	359	loading_arch = true; // hack to tell parse_kv et al. to behave
		360
327	std::vector<part> parts;	361	std::vector<archetype *> parts;
328		362
329	coroapi::cede_to_tick_every (100);	363	coroapi::cede_to_tick_every (10);
330		364
331	for (;;)	365	for (;;)
332	{	366	{
		367	// the archetype might have been referenced earlier
		368	// so try to find an existing stub archetype first
333	archetype *at = get (f.get_str ());	369	archetype *at = find (f.get_str ());
334	object *op = object::create ();
335		370
		371	if (!at \|\| !at->stub)
		372	at = new archetype (f.get_str ());
		373
		374	f.next ();
		375
		376	#if 0
		377	// implementing it here in the server does neither allow multiple inheritence
		378	// nor does it cleanly "just override". it would allow use in map files, though,
		379	// and other resource files dynamically laoded (as opposed to being preprocessed).
		380	// not that any of this is relevant as of yet...
		381	if (f.kw == KW_inherit)
		382	{
		383	if (archetype *at = find (f.get_str ()))
		384	*op = at->clone;
		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 ();
		390	}
		391	#endif
		392
336	if (!op->parse_kv (f))	393	if (!at->parse_kv (f))
337	goto fail;	394	goto fail;
338		395
339	parts.push_back (std::make_pair (at, op));	396	at->post_load_check ();
		397
		398	parts.push_back (at);
340		399
341	if (f.kw != KW_more)	400	if (f.kw != KW_more)
342	break;	401	break;
343		402
344	f.next ();	403	f.next ();
		404
345	assert (f.kw == KW_object);	405	if (f.kw != KW_object)
		406	{
		407	f.parse_error ("more object");
		408	goto fail;
		409	}
346	}	410	}
		411
		412	loading_arch = false;
347		413
348	{	414	{
		415	auto (at, parts.begin ());
		416
349	archetype *head = parts.front ().first;	417	archetype *new_head = parts.front ();
		418	archetype *old_head = find (new_head->archname);
350		419
		420	for (auto (at, parts.begin ()); at != parts.end (); ++at)
		421	fprintf (stderr, "%d: %s\n", at - parts.begin(), &(*at)->archname);//D
		422
351	// check that all archetypes belong to the same object or are heads	423	// check that all archetypes belong to the same old object or are new
352	for (auto (p, parts.begin ()); p != parts.end (); ++p)	424	for (auto (at, parts.begin ()); at != parts.end (); ++at)
353	{	425	{
354	archetype *at = p->first;	426	archetype new_part = at;
		427	archetype *old_part = find (new_part->archname);
355		428
356	if (at->head != head && at->head)	429	if (old_part && old_part->head_ () != old_head)
357	{	430	{
358	LOG (llevError, "%s: unable to overwrite foreign non-head archetype with non-head archetype\n", &at->name);	431	fprintf (stderr, "nhn %s\n", &new_head->archname);//D
359	goto fail;	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_());
360	}	433	LOG (llevError, "%s: unable to overwrite archetype '%s' with archetype of different object, skipping.\n",
361		434	&new_part->archname, &((archetype *)old_part->head_ ())->archname);
362	if (at->next && at != head)
363	{
364	LOG (llevError, "%s: unable to overwrite foreign head archetype with non-head archetype\n", &at->name);
365	goto fail;	435	goto fail;
366	}	436	}
367	}	437	}
368		438
369	// sever chain of existing head object	439	fprintf (stderr, "oh %p %s\n", old_head, &new_head->archname);//D
		440
		441	// deactivate existing archetype
370	for (archetype more, at = head; at; at = more)	442	for (archetype at = old_head; at; at = (archetype )at->more)
371	{	443	at->unlink ();
372	more = at->more;
373
374	at->head = 0;
375	at->more = 0;
376	}
377
378	// replace/update head
379	overwrite (head, parts.front ().second);
380	head->tail_x = 0;
381	head->tail_y = 0;
382
383	// link into list of heads, if not already there
384	if (!head->linked)
385	{
386	head->linked = true;
387	head->next = first_archetype;
388	first_archetype = head;
389	}
390		444
391	// reassemble new chain	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
392	archetype *prev = head;	449	archetype *less = new_head;
		450	archetype *head = 0;
393	for (auto (p, parts.begin () + 1); p != parts.end (); ++p)	451	for (auto (p, parts.begin () + 1); p != parts.end (); ++p)
394	{	452	{
395	archetype *at = p->first;	453	archetype at = p;
396	overwrite (at, p->second);
397		454
398	if (at->clone.x > head->tail_x) head->tail_x = at->clone.x;	455	if (at->x < new_head->min_x) new_head->min_x = at->x;
399	if (at->clone.y > head->tail_y) head->tail_y = at->clone.y;	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;
400		459
401	at->head = head;	460	at->head = head; head = new_head;
402	at->clone.head = &head->clone;	461	less->more = at; less = at;
403	prev->more = at;
404	prev->clone.more = &at->clone;
405
406	prev = at;
407	}	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;
408	}	473	}
409
410	return true;
411		474
412	fail:	475	fail:
413	for (auto (p, parts.begin ()); p != parts.end (); ++p)	476	for (auto (p, parts.begin ()); p != parts.end (); ++p)
414	p->second->destroy (true);	477	(*p)->destroy (true);
415		478
416	return false;
417	}
418
419	/*
420	* Reads/parses the archetype-file, and copies into a linked list
421	* of archetype-structures.
422	*/
423	static bool
424	load_archetypes (object_thawer &f)
425	{
426	for (;;)
427	{
428	switch (f.kw)
429	{
430	case KW_object:
431	loading_arch = true;
432	if (!archetype::load (f))
433	{
434	loading_arch = false;
435	return false;
436	}
437
438	loading_arch = false;	479	loading_arch = false;
439	continue;	480	return 0;
440
441	case KW_EOF:
442	return true;
443
444	default:
445	if (!f.parse_error ("archetypes file"))
446	return false;
447	}
448
449	f.next ();
450	}
451	}	481	}
452		482
453	/*	483	/*
454	* First initialises the archtype hash-table (init_archetable()).	484	* Initialize global archtype pointers:
455	* Reads and parses the archetype file (with the first and second-pass
456	* functions).
457	*/	485	*/
458	bool	486	void
459	load_archetype_file (const char *filename)	487	init_archetype_pointers ()
460	{	488	{
461	object_thawer f (filename);	489	ring_arch = archetype::find ("ring");
462		490	amulet_arch = archetype::find ("amulet");
463	f.next ();	491	staff_arch = archetype::find ("staff");
464		492	crown_arch = archetype::find ("crown");
465	if (!load_archetypes (f))
466	return false;
467
468	warn_archetypes = 1;
469
470	empty_archetype = archetype::find ("empty_archetype");	493	empty_archetype = archetype::find ("empty_archetype");
471	if (!empty_archetype)
472	return false;
473
474	return true;
475	}	494	}
476		495
477	/*	496	/*
478	* 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.
479	* This function returns NULL on failure.	498	* This function returns NULL on failure.
…		…
481	object *	500	object *
482	arch_to_object (archetype *at)	501	arch_to_object (archetype *at)
483	{	502	{
484	if (!at)	503	if (!at)
485	{	504	{
486	if (warn_archetypes)
487	LOG (llevError, "Couldn't find archetype.\n");	505	LOG (llevError, "Couldn't find archetype.\n");
488
489	return NULL;	506	return 0;
490	}	507	}
491		508
492	object *op = at->clone.clone ();	509	object *op = at->clone ();
493	op->arch = at;	510	op->arch = at;
494	op->instantiate ();	511	op->instantiate ();
		512
495	return op;	513	return op;
496	}	514	}
497		515
498	/*	516	/*
499	* Creates an object. This function is called by get_archetype()	517	* Creates an object. This function is called by get_archetype()
…		…
528		546
529	return arch_to_object (at);	547	return arch_to_object (at);
530	}	548	}
531		549
532	/*	550	/*
533	* Finds, using the hashtable, which archetype matches the given name.
534	* returns a pointer to the found archetype, otherwise NULL.
535	*/
536	archetype *
537	archetype::find (const char *name)
538	{
539	if (!name)
540	return 0;
541
542	auto (i, ht.find (name));
543
544	if (i == ht.end ())
545	return 0;
546	else
547	return i->second;
548	}
549
550	archetype *
551	archetype::get (const char *name)
552	{
553	archetype *at = find (name);
554
555	if (!at)
556	{
557	archetypes.push_back (at = new archetype);
558	at->name = name;
559	at->hash_add ();
560	}
561
562	return at;
563	}
564
565	/*
566	* Adds an archetype to the hashtable.
567	*/
568	void
569	archetype::hash_add ()
570	{
571	ht.insert (std::make_pair (name, this));
572	}
573
574	void
575	archetype::hash_del ()
576	{
577	ht.erase (name);
578	}
579
580	/*
581	* Returns the first archetype using the given type.	551	* Returns the first archetype using the given type.
582	* Used in treasure-generation.	552	* Used in treasure-generation.
583	*/	553	*/
584	archetype *	554	archetype *
585	type_to_archetype (int type)	555	type_to_archetype (int type)
586	{	556	{
587	for (archetype *at = first_archetype; at; at = at->more == 0 ? at->next : at->more)	557	for_all_archetypes (at)
588	if (at->clone.type == type)	558	if (at->type == type && at->head_ () != at)
589	return at;	559	return at;
590		560
591	return 0;	561	return 0;
592	}	562	}
593		563
…		…
605	{	575	{
606	LOG (llevError, "Can't clone archetype %d\n", type);	576	LOG (llevError, "Can't clone archetype %d\n", type);
607	return 0;	577	return 0;
608	}	578	}
609		579
610	object *op = at->clone.clone ();	580	object *op = at->clone ();
611	op->instantiate ();	581	op->instantiate ();
612	return op;	582	return op;
613	}	583	}
614		584
615	/*	585	/*
616	* member: make instance from class	586	* member: make instance from class
617	*/	587	*/
618
619	object *	588	object *
620	object_create_arch (archetype *at)	589	object_create_arch (archetype *at)
621	{	590	{
622	object op, prev = 0, *head = 0;	591	object op, prev = 0, *head = 0;
623		592
624	while (at)	593	while (at)
625	{	594	{
626	op = arch_to_object (at);	595	op = arch_to_object (at);
		596
627	op->x = at->clone.x;	597	op->x = at->x;
628	op->y = at->clone.y;	598	op->y = at->y;
629		599
630	if (head)	600	if (head)
631	op->head = head, prev->more = op;	601	op->head = head, prev->more = op;
632		602
633	if (!head)	603	if (!head)
634	head = op;	604	head = op;
635		605
636	prev = op;	606	prev = op;
637	at = at->more;	607	at = (archetype *)at->more;
638	}	608	}
639		609
640	return (head);	610	return head;
641	}	611	}
642		612

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.52 by root, Tue Apr 17 10:06:32 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.52 by root, Tue Apr 17 10:06:32 2007 UTC vs.
Revision 1.63 by root, Mon Jun 4 13:04:00 2007 UTC