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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.46 by root, Mon Apr 16 06:23:39 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 (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	if (!strcmp (&archname, "Gaea")) fprintf (stderr, "oI\n");//D
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 (!at)
		340	{
		341	at = new archetype (name);
		342	at->link ();
		343	}
		344
		345	return at;
325	}	346	}
326		347
327	archetype *	348	archetype *
328	archetype::read (object_thawer &f)	349	archetype::read (object_thawer &f)
329	{	350	{
330	assert (f.kw == KW_object);	351	assert (f.kw == KW_object);
331		352
332	archetype *head = get (f.get_str ());	353	loading_arch = true; // hack to tell parse_kv et al. to behave
333	unlink (head);
334	object *op = object::create ();
335		354
336	if (!op->parse_kv (f))	355	std::vector<archetype *> parts;
337	{	356
338	op->destroy (true);	357	coroapi::cede_to_tick_every (10);
339	// leak head	358
340	return 0;	359	for (;;)
341	}	360	{
		361	// the archetype might have been referenced earlier
		362	// so try to find an existing stub archetype first
		363	archetype *at = find (f.get_str ());
342		364
343	overwrite (head, op);	365	if (!at \|\| !at->stub)
344	op->destroy ();	366	at = new archetype (f.get_str ());
345		367
346	for (archetype *prev = head; f.kw == KW_more; )
347	{
348	f.next ();	368	f.next ();
349	assert (f.kw == KW_object);
350		369
351	archetype *more = get (f.get_str ());	370	#if 0
352	unlink (more);	371	// implementing it here in the server does neither allow multiple inheritence
353	object *op = object::create ();	372	// nor does it cleanly "just override". it would allow use in map files, though,
354		373	// and other resource files dynamically laoded (as opposed to being preprocessed).
355	if (!op->parse_kv (f))	374	// not that any of this is relevant as of yet...
		375	if (f.kw == KW_inherit)
356	{	376	{
357	op->destroy (true);	377	if (archetype *at = find (f.get_str ()))
358	// leak head more*	378	*op = at->clone;
359	return 0;	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 ();
360	}	384	}
		385	#endif
361		386
362	overwrite (more, op);	387	if (!at->parse_kv (f))
363	op->destroy ();	388	goto fail;
364		389
365	if (more->clone.x > head->tail_x) head->tail_x = more->clone.x;	390	at->post_load_check ();
366	if (more->clone.y > head->tail_y) head->tail_y = more->clone.y;
367		391
368	more->head = head;	392	parts.push_back (at);
369	more->clone.head = &head->clone;
370	prev->more = more;
371	prev->clone.more = &more->clone;
372		393
373	prev = more;	394	if (f.kw != KW_more)
374	}	395	break;
375		396
376	if (!head->next)	397	f.next ();
377	{
378	head->next = first_archetype;
379	first_archetype = head;
380	}
381		398
382	return head;	399	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	{	400	{
396	case KW_object:	401	f.parse_error ("more object");
397	loading_arch = true;	402	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	}	403	}
		404	}
414		405
415	f.next ();	406	loading_arch = false;
		407
		408	{
		409	auto (at, parts.begin ());
		410
		411	archetype *new_head = parts.front ();
		412	archetype *old_head = find (new_head->archname);
		413
		414	if (old_head && !old_head->is_head ())
		415	{
		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;
416	}	419	}
417	}
418		420
		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)
		428	{
		429	LOG (llevError, "%s: unable to overwrite archetype '%s' with archetype of different object, skipping.\n",
		430	&new_part->archname, &((archetype *)old_part->head_ ())->archname);
		431	goto fail;
		432	}
		433	}
		434
		435	// deactivate existing archetype
		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)
		445	{
		446	archetype at = p;
		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
		453	at->head = new_head;
		454	less->more = at;
		455	less = at;
		456	}
		457
		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
		466	return new_head;
		467	}
		468
		469	fail:
		470	for (auto (p, parts.begin ()); p != parts.end (); ++p)
		471	(*p)->destroy (true);
		472
		473	loading_arch = false;
		474	return 0;
		475	}
		476
419	/*	477	/*
420	* First initialises the archtype hash-table (init_archetable()).	478	* Initialize global archtype pointers:
421	* Reads and parses the archetype file (with the first and second-pass
422	* functions).
423	* Then initialises treasures by calling load_treasures().
424	*/	479	*/
425	void	480	void
426	load_archetypes (void)	481	init_archetype_pointers ()
427	{	482	{
428	char filename[MAX_BUF];	483	ring_arch = archetype::find ("ring");
429		484	amulet_arch = archetype::find ("amulet");
430	sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);	485	staff_arch = archetype::find ("staff");
431	LOG (llevDebug, "Reading archetypes from %s:\n", filename);	486	crown_arch = archetype::find ("crown");
432		487	empty_archetype = archetype::find ("empty_archetype");
433	object_thawer f (filename);
434
435	f.next ();
436
437	if (!load_archetypes (f))
438	cleanup ("unable to load archetypes");
439
440	warn_archetypes = 1;
441	}	488	}
442		489
443	/*	490	/*
444	* 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.
445	* This function returns NULL on failure.	492	* This function returns NULL on failure.
…		…
447	object *	494	object *
448	arch_to_object (archetype *at)	495	arch_to_object (archetype *at)
449	{	496	{
450	if (!at)	497	if (!at)
451	{	498	{
452	if (warn_archetypes)
453	LOG (llevError, "Couldn't find archetype.\n");	499	LOG (llevError, "Couldn't find archetype.\n");
454
455	return NULL;	500	return 0;
456	}	501	}
457		502
458	object *op = at->clone.clone ();	503	object *op = at->clone ();
459	op->arch = at;	504	op->arch = at;
460	op->instantiate ();	505	op->instantiate ();
		506
461	return op;	507	return op;
462	}	508	}
463		509
464	/*	510	/*
465	* Creates an object. This function is called by get_archetype()	511	* Creates an object. This function is called by get_archetype()
…		…
494		540
495	return arch_to_object (at);	541	return arch_to_object (at);
496	}	542	}
497		543
498	/*	544	/*
499	* Hash-function used by the arch-hashtable.
500	*/
501
502	unsigned long
503	hasharch (const char *str, int tablesize)
504	{
505	unsigned long hash = 0;
506	unsigned int i = 0;
507	const char *p;
508
509	/* use the one-at-a-time hash function, which supposedly is
510	* better than the djb2-like one used by perl5.005, but
511	* certainly is better then the bug used here before.
512	* see http://burtleburtle.net/bob/hash/doobs.html
513	*/
514	for (p = str; i < MAXSTRING && *p; p++, i++)
515	{
516	hash += *p;
517	hash += hash << 10;
518	hash ^= hash >> 6;
519	}
520
521	hash += hash << 3;
522	hash ^= hash >> 11;
523	hash += hash << 15;
524
525	return hash % tablesize;
526	}
527
528	/*
529	* Finds, using the hashtable, which archetype matches the given name.
530	* returns a pointer to the found archetype, otherwise NULL.
531	*/
532	archetype *
533	archetype::find (const char *name)
534	{
535	if (!name)
536	return 0;
537
538	AUTODECL (i, ht.find (name));
539
540	if (i == ht.end ())
541	return 0;
542	else
543	return i->second;
544	}
545
546	archetype *
547	archetype::get (const char *name)
548	{
549	archetype *at = find (name);
550
551	if (!at)
552	{
553	archetypes.push_back (at = new archetype);
554	at->name = name;
555	at->hash_add ();
556	}
557
558	return at;
559	}
560
561	/*
562	* Adds an archetype to the hashtable.
563	*/
564	void
565	archetype::hash_add ()
566	{
567	ht.insert (std::make_pair (name, this));
568	}
569
570	void
571	archetype::hash_del ()
572	{
573	ht.erase (name);
574	}
575
576	/*
577	* Returns the first archetype using the given type.	545	* Returns the first archetype using the given type.
578	* Used in treasure-generation.	546	* Used in treasure-generation.
579	*/	547	*/
580	archetype *	548	archetype *
581	type_to_archetype (int type)	549	type_to_archetype (int type)
582	{	550	{
583	for (archetype *at = first_archetype; at; at = at->more == 0 ? at->next : at->more)	551	for_all_archetypes (at)
584	if (at->clone.type == type)	552	if (at->type == type && at->head_ () != at)
585	return at;	553	return at;
586		554
587	return 0;	555	return 0;
588	}	556	}
589		557
…		…
601	{	569	{
602	LOG (llevError, "Can't clone archetype %d\n", type);	570	LOG (llevError, "Can't clone archetype %d\n", type);
603	return 0;	571	return 0;
604	}	572	}
605		573
606	object *op = at->clone.clone ();	574	object *op = at->clone ();
607	op->instantiate ();	575	op->instantiate ();
608	return op;	576	return op;
609	}	577	}
610		578
611	/*	579	/*
612	* member: make instance from class	580	* member: make instance from class
613	*/	581	*/
614
615	object *	582	object *
616	object_create_arch (archetype *at)	583	object_create_arch (archetype *at)
617	{	584	{
618	object op, prev = 0, *head = 0;	585	object op, prev = 0, *head = 0;
619		586
620	while (at)	587	while (at)
621	{	588	{
622	op = arch_to_object (at);	589	op = arch_to_object (at);
		590
623	op->x = at->clone.x;	591	op->x = at->x;
624	op->y = at->clone.y;	592	op->y = at->y;
625		593
626	if (head)	594	if (head)
627	op->head = head, prev->more = op;	595	op->head = head, prev->more = op;
628		596
629	if (!head)	597	if (!head)
630	head = op;	598	head = op;
631		599
632	prev = op;	600	prev = op;
633	at = at->more;	601	at = (archetype *)at->more;
634	}	602	}
635		603
636	return (head);	604	return head;
637	}	605	}
638		606

Diff Legend

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

Comparing deliantra/server/common/arch.C (file contents): Revision 1.46 by root, Mon Apr 16 06:23:39 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.46 by root, Mon Apr 16 06:23:39 2007 UTC vs.
Revision 1.64 by root, Tue Jun 5 13:05:02 2007 UTC