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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.54 by root, Tue Apr 17 18:59:05 2007 UTC vs.
Revision 1.65 by root, Thu Jun 7 18:55:24 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
…		…
157	}	157	}
158		158
159	return create_singularity (name);	159	return create_singularity (name);
160	}	160	}
161		161
162	/* This is a subset of the parse_id command. Basically, name can be	162	/* This is a subset of the parse_id command. Basically, name can be
163	* a string seperated lists of things to match, with certain keywords.	163	* a string seperated lists of things to match, with certain keywords.
164	* pl is the player (only needed to set count properly)	164	* pl is the player (only needed to set count properly)
165	* op is the item we are trying to match. Calling function takes care	165	* op is the item we are trying to match. Calling function takes care
166	* of what action might need to be done and if it is valid	166	* of what action might need to be done and if it is valid
167	* (pickup, drop, etc.) Return NONZERO if we have a match. A higher	167	* (pickup, drop, etc.) Return NONZERO if we have a match. A higher
168	* value means a better match. 0 means no match.	168	* value means a better match. 0 means no match.
169	*	169	*
170	* Brief outline of the procedure:	170	* Brief outline of the procedure:
171	* We take apart the name variable into the individual components.	171	* We take apart the name variable into the individual components.
172	* cases for 'all' and unpaid are pretty obvious.	172	* cases for 'all' and unpaid are pretty obvious.
173	* Next, we check for a count (either specified in name, or in the	173	* Next, we check for a count (either specified in name, or in the
174	* player object.)	174	* player object.)
175	* If count is 1, make a quick check on the name.	175	* If count is 1, make a quick check on the name.
176	* IF count is >1, we need to make plural name. Return if match.	176	* IF count is >1, we need to make plural name. Return if match.
177	* Last, make a check on the full name.	177	* Last, make a check on the full name.
178	*/	178	*/
179	int	179	int
180	item_matched_string (object pl, object op, const char *name)	180	item_matched_string (object pl, object op, const char *name)
181	{	181	{
182	char *cp, local_name[MAX_BUF];	182	char *cp, local_name[MAX_BUF];
183	int count, retval = 0;	183	int count, retval = 0;
…		…
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);
		299	}
		300
		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;
319	}	346	}
320		347
321	archetype *	348	archetype *
322	archetype::read (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	loading_arch = true; // hack to tell parse_kv et al. to behave	353	loading_arch = true; // hack to tell parse_kv et al. to behave
327		354
328	typedef std::pair<archetype , object > part;
329	std::vector<part> parts;	355	std::vector<archetype *> parts;
330		356
331	coroapi::cede_to_tick_every (100);	357	coroapi::cede_to_tick_every (10);
332		358
333	for (;;)	359	for (;;)
334	{	360	{
335	object *op = object::create ();	361	// the archetype might have been referenced earlier
		362	// so try to find an existing stub archetype first
336	archetype *at = get (f.get_str ());	363	archetype *at = find (f.get_str ());
337	f.get (op->name);	364
		365	if (!at \|\| !at->stub)
		366	at = new archetype (f.get_str ());
		367
338	f.next ();	368	f.next ();
339		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
340	if (!op->parse_kv (f))	387	if (!at->parse_kv (f))
341	goto fail;	388	goto fail;
342		389
343	parts.push_back (std::make_pair (at, op));	390	at->post_load_check ();
		391
		392	parts.push_back (at);
344		393
345	if (f.kw != KW_more)	394	if (f.kw != KW_more)
346	break;	395	break;
347		396
348	f.next ();	397	f.next ();
…		…
352	f.parse_error ("more object");	401	f.parse_error ("more object");
353	goto fail;	402	goto fail;
354	}	403	}
355	}	404	}
356		405
		406	loading_arch = false;
		407
357	{	408	{
		409	auto (at, parts.begin ());
		410
358	archetype *head = parts.front ().first;	411	archetype *new_head = parts.front ();
		412	archetype *old_head = find (new_head->archname);
359		413
360	// check that all archetypes belong to the same object or are heads	414	if (old_head && !old_head->is_head ())
361	for (auto (p, parts.begin ()); p != parts.end (); ++p)
362	{	415	{
363	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	}
364		420
365	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)
366	{	428	{
367	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",
368	goto fail;	430	&new_part->archname, &((archetype *)old_part->head_ ())->archname);
369	}
370
371	if (at->next && at != head)
372	{
373	LOG (llevError, "%s: unable to overwrite foreign head archetype with non-head archetype\n", &at->name);
374	goto fail;	431	goto fail;
375	}	432	}
376	}	433	}
377		434
378	// sever chain of existing head object	435	// deactivate existing archetype
379	for (archetype more, at = head; at; at = more)	436	for (archetype at = old_head; at; at = (archetype )at->more)
380	{	437	at->unlink ();
381	more = at->more;
382		438
383	at->head = 0;
384	at->more = 0;
385	}
386
387	// replace/update head
388	overwrite (head, parts.front ().second);
389	head->tail_x = 0;
390	head->tail_y = 0;
391
392	// link into list of heads, if not already there
393	if (!head->linked)
394	{
395	head->linked = true;
396	head->next = first_archetype;
397	first_archetype = head;
398	}
399
400	// reassemble new chain	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
401	archetype *prev = head;	443	archetype *less = new_head;
402	for (auto (p, parts.begin () + 1); p != parts.end (); ++p)	444	for (auto (p, parts.begin () + 1); p != parts.end (); ++p)
403	{	445	{
404	archetype *at = p->first;	446	archetype at = p;
405	overwrite (at, p->second);
406		447
407	if (at->clone.x > head->tail_x) head->tail_x = at->clone.x;	448	if (at->x < new_head->min_x) new_head->min_x = at->x;
408	if (at->clone.y > head->tail_y) head->tail_y = at->clone.y;	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;
409		452
410	at->head = head;	453	at->head = new_head;
411	at->clone.head = &head->clone;
412	prev->more = at;	454	less->more = at;
413	prev->clone.more = &at->clone;
414
415	prev = at;	455	less = at;
416	}	456	}
417		457
418	loading_arch = false;	458	// now activate it
		459	for (auto (p, parts.begin ()); p != parts.end (); ++p)
		460	{
		461	archetype at = p;
		462	at->stub = false;
		463	at->link ();
		464	}
		465
419	return head;	466	return new_head;
420	}	467	}
421		468
422	fail:	469	fail:
423	for (auto (p, parts.begin ()); p != parts.end (); ++p)	470	for (auto (p, parts.begin ()); p != parts.end (); ++p)
424	p->second->destroy (true);	471	(*p)->destroy (true);
425		472
426	loading_arch = false;	473	loading_arch = false;
427	return 0;	474	return 0;
428	}	475	}
429		476
…		…
451	{	498	{
452	LOG (llevError, "Couldn't find archetype.\n");	499	LOG (llevError, "Couldn't find archetype.\n");
453	return 0;	500	return 0;
454	}	501	}
455		502
456	object *op = at->clone.clone ();	503	object *op = at->clone ();
457	op->arch = at;	504	op->arch = at;
458	op->instantiate ();	505	op->instantiate ();
459		506
460	return op;	507	return op;
461	}	508	}
…		…
467	* an object, and never NULL.	514	* an object, and never NULL.
468	*/	515	*/
469	object *	516	object *
470	create_singularity (const char *name)	517	create_singularity (const char *name)
471	{	518	{
472	object *op;	519	LOG (llevError \| logBacktrace, "FATAL: creating singularity for '%s'.\n", name);
		520
		521	if (!strcmp (name, "bug"))
		522	abort ();
		523
473	char buf[MAX_BUF];	524	char buf[MAX_BUF];
474
475	sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);	525	sprintf (buf, "bug, please report (%s)", ARCH_SINGULARITY, name);
476	op = object::create ();	526
		527	object *op = get_archetype ("bug");
477	op->name = op->name_pl = buf;	528	op->name = op->name_pl = buf;
478	SET_FLAG (op, FLAG_NO_PICK);	529
479	return op;	530	return op;
480	}	531	}
481		532
482	/*	533	/*
483	* Finds which archetype matches the given name, and returns a new	534	* Finds which archetype matches the given name, and returns a new
…		…
493		544
494	return arch_to_object (at);	545	return arch_to_object (at);
495	}	546	}
496		547
497	/*	548	/*
498	* Finds, using the hashtable, which archetype matches the given name.
499	* returns a pointer to the found archetype, otherwise NULL.
500	*/
501	archetype *
502	archetype::find (const char *name)
503	{
504	if (!name)
505	return 0;
506
507	auto (i, ht.find (name));
508
509	if (i == ht.end ())
510	return 0;
511	else
512	return i->second;
513	}
514
515	archetype *
516	archetype::get (const char *name)
517	{
518	archetype *at = find (name);
519
520	if (!at)
521	{
522	archetypes.push_back (at = new archetype);
523	at->name = name;
524	at->hash_add ();
525	}
526
527	return at;
528	}
529
530	/*
531	* Adds an archetype to the hashtable.
532	*/
533	void
534	archetype::hash_add ()
535	{
536	ht.insert (std::make_pair (name, this));
537	}
538
539	void
540	archetype::hash_del ()
541	{
542	ht.erase (name);
543	}
544
545	/*
546	* Returns the first archetype using the given type.	549	* Returns the first archetype using the given type.
547	* Used in treasure-generation.	550	* Used in treasure-generation.
548	*/	551	*/
549	archetype *	552	archetype *
550	type_to_archetype (int type)	553	type_to_archetype (int type)
551	{	554	{
552	for (archetype *at = first_archetype; at; at = at->more == 0 ? at->next : at->more)	555	for_all_archetypes (at)
553	if (at->clone.type == type)	556	if (at->type == type && at->head_ () != at)
554	return at;	557	return at;
555		558
556	return 0;	559	return 0;
557	}	560	}
558		561
…		…
570	{	573	{
571	LOG (llevError, "Can't clone archetype %d\n", type);	574	LOG (llevError, "Can't clone archetype %d\n", type);
572	return 0;	575	return 0;
573	}	576	}
574		577
575	object *op = at->clone.clone ();	578	object *op = at->clone ();
576	op->instantiate ();	579	op->instantiate ();
577	return op;	580	return op;
578	}	581	}
579		582
580	/*	583	/*
581	* member: make instance from class	584	* member: make instance from class
582	*/	585	*/
583
584	object *	586	object *
585	object_create_arch (archetype *at)	587	object_create_arch (archetype *at)
586	{	588	{
587	object op, prev = 0, *head = 0;	589	object op, prev = 0, *head = 0;
588		590
589	while (at)	591	while (at)
590	{	592	{
591	op = arch_to_object (at);	593	op = arch_to_object (at);
		594
592	op->x = at->clone.x;	595	op->x = at->x;
593	op->y = at->clone.y;	596	op->y = at->y;
594		597
595	if (head)	598	if (head)
596	op->head = head, prev->more = op;	599	op->head = head, prev->more = op;
597		600
598	if (!head)	601	if (!head)
599	head = op;	602	head = op;
600		603
601	prev = op;	604	prev = op;
602	at = at->more;	605	at = (archetype *)at->more;
603	}	606	}
604		607
605	return (head);	608	return head;
606	}	609	}
607		610

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.54 by root, Tue Apr 17 18:59:05 2007 UTC vs. Revision 1.65 by root, Thu Jun 7 18:55:24 2007 UTC

Diff Legend

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.54 by root, Tue Apr 17 18:59:05 2007 UTC vs.
Revision 1.65 by root, Thu Jun 7 18:55:24 2007 UTC