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

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

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.50 by root, Mon Apr 16 13:02:28 2007 UTC vs. Revision 1.64 by root, Tue Jun 5 13:05:02 2007 UTC

Diff Legend

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.50 by root, Mon Apr 16 13:02:28 2007 UTC vs.
Revision 1.64 by root, Tue Jun 5 13:05:02 2007 UTC