ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/arch.C
(Generate patch)

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.31 by root, Wed Dec 13 03:28:42 2006 UTC vs.
Revision 1.86 by root, Sun Oct 5 14:54:05 2008 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 3 *
4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
6 7 *
7 This program is free software; you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version. 11 * (at your option) any later version.
11 12 *
12 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,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details. 16 * GNU General Public License for more details.
16 17 *
17 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
18 along with this program; if not, write to the Free Software 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 *
20 21 * The authors can be reached via e-mail to <support@deliantra.net>
21 The authors can be reached via e-mail at <crossfire@schmorp.de>
22*/ 22 */
23 23
24#include <cassert> 24#include <cassert>
25 25
26#include <global.h> 26#include <global.h>
27#include <funcpoint.h>
28#include <loader.h> 27#include <loader.h>
29 28
30#define USE_UNORDERED_MAP 0
31
32#if USE_UNORDERED_MAP
33# include <tr1/functional> 29#include <tr1/functional>
34# include <tr1/unordered_map> 30#include <tr1/unordered_map>
35#endif
36 31
37int arch_cmp = 0; /* How many strcmp's */ 32archetype *loading_arch; // ugly flag to object loader etc. to suppress/request special processing
38int arch_search = 0; /* How many searches */ 33arch_ptr archetype::empty;
39int arch_init; /* True if doing arch initialization */
40 34
41/* The naming of these functions is really poor - they are all
42 * pretty much named '.._arch_...', but they may more may not
43 * return archetypes. Some make the arch_to_object call, and thus
44 * return an object. Perhaps those should be called 'archob' functions
45 * to denote they return an object derived from the archetype.
46 * MSW 2003-04-29
47 */
48
49#if USE_UNORDERED_MAP
50// the hashtable 35// the hashtable
51typedef std::tr1::unordered_map 36typedef std::tr1::unordered_map
52 < 37 <
53 std::size_t, 38 const char *,
54 arch_ptr, 39 arch_ptr,
55 std::tr1::hash<size_t>, 40 str_hash,
56 std::equal_to<size_t>, 41 str_equal,
57 slice_allocator< std::pair<const std::size_t, archetype *> > 42 slice_allocator< std::pair<const char *const, arch_ptr> >
58 true,
59 > HT; 43 > HT;
60 44
61static HT ht; 45static HT ht (10000);
62#else 46archvec archetypes;
63static arch_ptr arch_table[ARCHTABLE]; 47static unordered_vector<archetype *> allarch;
64#endif 48static int dirtycnt;
49
50// the vector of other_arch references to be resolved
51static std::vector< std::pair<arch_ptr *, shstr> > postponed_arch_ref;
52// the vector of loaded but not yet committed archetypes
53static std::vector<archetype *> postponed_arch;
65 54
66/** 55/**
67 * GROS - This function retrieves an archetype given the name that appears 56 * GROS - This function retrieves an archetype given the name that appears
68 * during the game (for example, "writing pen" instead of "stylus"). 57 * during the game (for example, "writing pen" instead of "stylus").
69 * It does not use the hashtable system, but browse the whole archlist each time. 58 * It does not use the hashtable system, but browse the whole archlist each time.
75 * - the archetype found or null if nothing was found. 64 * - the archetype found or null if nothing was found.
76 */ 65 */
77archetype * 66archetype *
78find_archetype_by_object_name (const char *name) 67find_archetype_by_object_name (const char *name)
79{ 68{
80 archetype *at; 69 shstr_cmp name_cmp (name);
81 70
82 if (name == NULL) 71 for_all_archetypes (at)
83 return (archetype *) NULL; 72 if (at->name == name_cmp)
84
85 for (at = first_archetype; at != NULL; at = at->next)
86 {
87 if (!strcmp (at->clone.name, name))
88 return at; 73 return at;
89 } 74
90 return NULL; 75 return 0;
91} 76}
92 77
93/** 78/**
94 * This function retrieves an archetype by type and name that appears during 79 * This function retrieves an archetype by type and name that appears during
95 * the game. It is basically the same as find_archetype_by_object_name() 80 * the game. It is basically the same as find_archetype_by_object_name()
96 * except that it considers only items of the given type. 81 * except that it considers only items of the given type.
97 */ 82 */
98archetype * 83archetype *
99find_archetype_by_object_type_name (int type, const char *name) 84find_archetype_by_object_type_name (int type, const char *name)
100{ 85{
101 archetype *at; 86 shstr_cmp name_cmp (name);
102 87
103 if (name == NULL) 88 for_all_archetypes (at)
104 return NULL; 89 if (at->name == name_cmp && at->type == type)
105
106 for (at = first_archetype; at != NULL; at = at->next)
107 {
108 if (at->clone.type == type && strcmp (at->clone.name, name) == 0)
109 return at; 90 return at;
110 }
111 91
112 return NULL; 92 return 0;
113} 93}
114 94
115/* This is a lot like the above function. Instead, we are trying to match 95/* This is a lot like the above function. Instead, we are trying to match
116 * the arch->skill values. type is the type of object to match 96 * the arch->skill values. type is the type of object to match
117 * against (eg, to only match against skills or only skill objects for example). 97 * against (eg, to only match against skills or only skill objects for example).
118 * If type is -1, ew don't match on type. 98 * If type is -1, ew don't match on type.
119 */ 99 */
120object * 100object *
121get_archetype_by_skill_name (const char *skill, int type) 101get_archetype_by_skill_name (const char *skill, int type)
122{ 102{
123 archetype * 103 shstr_cmp skill_cmp (skill);
124 at;
125 104
126 if (skill == NULL) 105 for_all_archetypes (at)
127 return NULL; 106 if (at->skill == skill_cmp && (type == -1 || type == at->type))
107 return at->instance ();
128 108
129 for (at = first_archetype; at != NULL; at = at->next)
130 {
131 if (((type == -1) || (type == at->clone.type)) && (!strcmp (at->clone.skill, skill)))
132 return arch_to_object (at);
133 }
134 return NULL; 109 return 0;
135} 110}
136 111
137/* similiar to above - this returns the first archetype 112/* similiar to above - this returns the first archetype
138 * that matches both the type and subtype. type and subtype 113 * that matches both the type and subtype. type and subtype
139 * can be -1 to say ignore, but in this case, the match it does 114 * can be -1 to say ignore, but in this case, the match it does
142 * (eg, skills) 117 * (eg, skills)
143 */ 118 */
144archetype * 119archetype *
145get_archetype_by_type_subtype (int type, int subtype) 120get_archetype_by_type_subtype (int type, int subtype)
146{ 121{
147 archetype * 122 for_all_archetypes (at)
148 at;
149
150 for (at = first_archetype; at != NULL; at = at->next)
151 {
152 if (((type == -1) || (type == at->clone.type)) && (subtype == -1 || subtype == at->clone.subtype)) 123 if ((type == -1 || type == at->type) && (subtype == -1 || subtype == at->subtype))
153 return at; 124 return at;
154 } 125
155 return NULL; 126 return 0;
156} 127}
157 128
158/** 129/**
159 * GROS - this returns a new object given the name that appears during the game 130 * GROS - this returns a new object given the name that appears during the game
160 * (for example, "writing pen" instead of "stylus"). 131 * (for example, "writing pen" instead of "stylus").
162 * - name: The name we're searching for (ex: "writing pen"); 133 * - name: The name we're searching for (ex: "writing pen");
163 * Return value: 134 * Return value:
164 * - a corresponding object if found; a singularity object if not found. 135 * - a corresponding object if found; a singularity object if not found.
165 * Note by MSW - it appears that it takes the full name and keeps 136 * Note by MSW - it appears that it takes the full name and keeps
166 * shortening it until it finds a match. I re-wrote this so that it 137 * shortening it until it finds a match. I re-wrote this so that it
167 * doesn't malloc it each time - not that this function is used much, 138 * doesn't allocate it each time - not that this function is used much,
168 * but it otherwise had a big memory leak. 139 * but it otherwise had a big memory leak.
169 */ 140 */
170object * 141object *
171get_archetype_by_object_name (const char *name) 142get_archetype_by_object_name (const char *name)
172{ 143{
173 archetype *at;
174 char tmpname[MAX_BUF]; 144 char tmpname[MAX_BUF];
175 int i; 145 int i;
176 146
177 assign (tmpname, name); 147 assign (tmpname, name);
178 148
179 for (i = strlen (tmpname); i > 0; i--) 149 for (i = strlen (tmpname); i > 0; i--)
180 { 150 {
181 tmpname[i] = 0; 151 tmpname[i] = 0;
152
182 at = find_archetype_by_object_name (tmpname); 153 if (archetype *at = find_archetype_by_object_name (tmpname))
183 154 return at->instance ();
184 if (at != NULL)
185 return arch_to_object (at);
186 } 155 }
187 156
188 return create_singularity (name); 157 return create_singularity (name);
189} 158}
190 159
191 /* This is a subset of the parse_id command. Basically, name can be 160/* This is a subset of the parse_id command. Basically, name can be
192 * a string seperated lists of things to match, with certain keywords. 161 * a string seperated lists of things to match, with certain keywords.
193 * pl is the player (only needed to set count properly) 162 * pl is the player (only needed to set count properly)
194 * op is the item we are trying to match. Calling function takes care 163 * op is the item we are trying to match. Calling function takes care
195 * of what action might need to be done and if it is valid 164 * of what action might need to be done and if it is valid
196 * (pickup, drop, etc.) Return NONZERO if we have a match. A higher 165 * (pickup, drop, etc.) Return NONZERO if we have a match. A higher
197 * value means a better match. 0 means no match. 166 * value means a better match. 0 means no match.
198 * 167 *
199 * Brief outline of the procedure: 168 * Brief outline of the procedure:
200 * We take apart the name variable into the individual components. 169 * We take apart the name variable into the individual components.
201 * cases for 'all' and unpaid are pretty obvious. 170 * cases for 'all' and unpaid are pretty obvious.
202 * Next, we check for a count (either specified in name, or in the 171 * Next, we check for a count (either specified in name, or in the
203 * player object.) 172 * player object.)
204 * If count is 1, make a quick check on the name. 173 * If count is 1, make a quick check on the name.
205 * IF count is >1, we need to make plural name. Return if match. 174 * IF count is >1, we need to make plural name. Return if match.
206 * Last, make a check on the full name. 175 * Last, make a check on the full name.
207 */ 176 */
208int 177int
209item_matched_string (object *pl, object *op, const char *name) 178item_matched_string (object *pl, object *op, const char *name)
210{ 179{
211 char *cp, local_name[MAX_BUF]; 180 char *cp, local_name[MAX_BUF];
212 int count, retval = 0; 181 int count, retval = 0;
213 182
214 strcpy (local_name, name); /* strtok is destructive to name */ 183 assign (local_name, name); /* strtok is destructive to name */
215 184
216 for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ",")) 185 for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
217 { 186 {
218 while (cp[0] == ' ') 187 while (cp[0] == ' ')
219 ++cp; /* get rid of spaces */ 188 ++cp; /* get rid of spaces */
304 } 273 }
305 274
306 return 0; 275 return 0;
307} 276}
308 277
278archetype::archetype (const char *name)
279{
280 arch = this;
281 this->archname = this->name = this->name_pl = name;
282}
283
284archetype::~archetype ()
285{
286 unlink ();
287}
288
289void
290archetype::link ()
291{
292 if (!archetypes.contains (this))
293 {
294 archetypes.insert (this);
295 ht.insert (std::make_pair (archname, this));
296 }
297}
298
299void
300archetype::unlink ()
301{
302 if (archetypes.contains (this))
303 {
304 archetypes.erase (this);
305 ht.erase (archname);
306 }
307}
308
309/* 309/*
310 * Initialises the internal linked list of archetypes (read from file). 310 * Finds, using the hashtable, which archetype matches the given name.
311 * Then the global "empty_archetype" pointer is initialised. 311 * returns a pointer to the found archetype, otherwise NULL.
312 * Then the blocksview[] array is initialised.
313 */ 312 */
313archetype *
314archetype::find (const char *name)
315{
316 if (!name)
317 return 0;
318
319 auto (i, ht.find (name));
320
321 if (i == ht.end ())
322 return 0;
323 else
324 return i->second;
325}
326
327archetype *
328archetype::read (object_thawer &f)
329{
330 assert (f.kw == KW_object);
331
332 std::vector<archetype *> parts;
333
334 coroapi::cede_to_tick ();
335
336 for (;;)
337 {
338 archetype *at = new archetype (f.get_str ());
339
340 f.next ();
341
342#if 0
343 // implementing it here in the server does neither allow multiple inheritence
344 // nor does it cleanly "just override". it would allow use in map files, though,
345 // and other resource files dynamically laoded (as opposed to being preprocessed).
346 // not that any of this is relevant as of yet...
347 if (f.kw == KW_inherit)
348 {
349 if (archetype *at = find (f.get_str ()))
350 *op = at->clone;
351 else
352 LOG (llevError, "archetype '%s' tries to inherit from non-existent archetype '%s'.\n",
353 &at->archname, f.get_str ());
354
355 f.next ();
356 }
357#endif
358
359 loading_arch = at; // hack to tell parse_kv et al. to behave
360 bool parse_ok = at->parse_kv (f);
361 loading_arch = 0;
362
363 if (!parse_ok)
364 goto fail;
365
366 loading_arch = at; // hack to tell parse_kv et al. to behave
367 at->post_load_check ();
368 loading_arch = 0;
369
370 parts.push_back (at);
371
372 if (f.kw != KW_more)
373 break;
374
375 f.next ();
376
377 if (f.kw != KW_object)
378 {
379 f.parse_error ("more object");
380 goto fail;
381 }
382 }
383
384 {
385 auto (at, parts.begin ());
386
387 archetype *new_head = parts.front ();
388 archetype *old_head = find (new_head->archname);
389
390 if (old_head && !old_head->is_head ())
391 {
392 LOG (llevError, "%s: unable to overwrite non-head archetype '%s' with head archetype, skipping.\n",
393 &new_head->archname, &old_head->archname);
394 goto fail;
395 }
396
397 // check that all archetypes belong to the same old object or are new
398 for (auto (at, parts.begin ()); at != parts.end (); ++at)
399 {
400 archetype *new_part = *at;
401 archetype *old_part = find (new_part->archname);
402
403 if (old_part && old_part->head_ () != old_head)
404 {
405 LOG (llevError, "%s: unable to overwrite archetype '%s' with archetype of different object, skipping.\n",
406 &new_part->archname, &((archetype *)old_part->head_ ())->archname);
407 goto fail;
408 }
409 }
410
411 // assemble new chain
412 new_head->min_x = new_head->max_x = new_head->x;
413 new_head->min_y = new_head->max_y = new_head->y;
414
415 archetype *less = new_head;
416 for (auto (p, parts.begin () + 1); p != parts.end (); ++p)
417 {
418 archetype *at = *p;
419
420 // some flags get inherited from the head (probably a lot more)
421 // doing it here doesn't feel too cozy, but it allows code
422 // to ignore head checks for these flags, which saves time
423 at->flag [FLAG_ALIVE] = new_head->flag [FLAG_ALIVE];
424 at->flag [FLAG_NO_PICK] = new_head->flag [FLAG_NO_PICK];
425 at->flag [FLAG_MONSTER] = new_head->flag [FLAG_MONSTER];
426 at->flag [FLAG_IS_FLOOR] = new_head->flag [FLAG_IS_FLOOR];
427
428 new_head->min_x = min (new_head->min_x, at->x);
429 new_head->min_y = min (new_head->min_y, at->y);
430 new_head->max_x = max (new_head->max_x, at->x);
431 new_head->max_y = max (new_head->max_y, at->y);
432
433 at->head = new_head;
434 less->more = at;
435 less = at;
436 }
437
438 postponed_arch.insert (postponed_arch.end (), parts.begin (), parts.end ());
439
440 return new_head;
441 }
442
443fail:
444 for (auto (p, parts.begin ()); p != parts.end (); ++p)
445 (*p)->destroy ();
446
447 return 0;
448}
314 449
315void 450void
316init_archetypes (void) 451archetype::postpone_arch_ref (arch_ptr &ref, const_utf8_string other_arch)
317{ /* called from add_player() and edit() */ 452{
318 if (first_archetype != NULL) /* Only do this once */ 453 ref = 0;
319 return; 454 postponed_arch_ref.push_back (std::pair<arch_ptr *, shstr>(&ref, shstr (other_arch)));
320
321 arch_init = 1;
322 load_archetypes ();
323 arch_init = 0;
324 empty_archetype = archetype::find ("empty_archetype");
325
326/* init_blocksview();*/
327} 455}
328
329/*
330 * Stores debug-information about how efficient the hashtable
331 * used for archetypes has been in the static errmsg array.
332 */
333 456
334void 457void
335arch_info (object *op) 458archetype::commit_load ()
336{ 459{
337 sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp); 460 // unlink old archetypes and link in new ones */
338 new_draw_info (NDI_BLACK, 0, op, errmsg); 461 for (auto (p, postponed_arch.begin ()); p != postponed_arch.end (); ++p)
339} 462 {
463 archetype *at = *p;
340 464
341/* 465 if (archetype *old = find (at->archname))
342 * Initialise the hashtable used by the archetypes. 466 old->unlink ();
343 */ 467
468 allarch.push_back (at);
469
470 at->link ();
471 ++dirtycnt;
472 }
473
474 postponed_arch.clear ();
475
476 // now resolve arch references
477 for (auto (p, postponed_arch_ref.begin ()); p != postponed_arch_ref.end (); ++p)
478 {
479 arch_ptr *ap = p->first;
480 archetype *at = find (p->second);
481
482 if (!at)
483 LOG (llevError, "unable to resolve postponed arch reference to '%s'", &p->second);
484
485 *ap = at;
486 }
487
488 postponed_arch_ref.clear ();
489
490 empty = find (shstr_empty_archetype);
491}
344 492
345void 493void
346clear_archetable (void) 494archetype::gc ()
347{ 495{
348 memset ((void *) arch_table, 0, ARCHTABLE * sizeof (archetype *)); 496 int cnt = max (1, min (allarch.size () / 128, dirtycnt));
349} 497 dirtycnt = max (0, dirtycnt - cnt);
350 498
351/* 499 do
352 * An alternative way to init the hashtable which is slower, but _works_...
353 */
354
355void
356init_archetable (void)
357{
358 archetype *at;
359
360 LOG (llevDebug, " Setting up archetable...\n");
361
362 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
363 at->hash_add ();
364
365 LOG (llevDebug, "done\n");
366}
367
368void
369free_all_archs (void)
370{
371 archetype *at, *next;
372 int i = 0, f = 0;
373
374 for (at = first_archetype; at != NULL; at = next)
375 { 500 {
376 if (at->more) 501 static int idx;
377 next = at->more; 502
503 if (idx >= allarch.size ())
504 if (idx)
505 idx = 0;
506 else
507 return;
508
509 archetype *at = allarch [idx];
510
511 if (at->refcnt_cnt () > 1) // all arches have ONE refcount from their object
512 ++idx;
378 else 513 else
379 next = at->next;
380
381 delete
382 at;
383
384 i++;
385 }
386
387 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
388}
389
390archetype::archetype ()
391{
392 clone.clear (); /* to initial state other also */
393 CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_to */
394 SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
395}
396
397archetype::~archetype ()
398{
399}
400
401/*
402 * Reads/parses the archetype-file, and copies into a linked list
403 * of archetype-structures.
404 */
405void
406first_arch_pass (object_thawer & fp)
407{
408 archetype *head = 0, *last_more = 0;
409
410 archetype *at = new archetype;
411 at->clone.arch = first_archetype = at;
412
413 while (int i = load_object (fp, &at->clone, 0))
414 {
415 at->clone.speed_left = (float) (-0.1);
416 /* copy the body_info to the body_used - this is only really
417 * need for monsters, but doesn't hurt to do it for everything.
418 * by doing so, when a monster is created, it has good starting
419 * values for the body_used info, so when items are created
420 * for it, they can be properly equipped.
421 */
422 memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));
423
424 switch (i)
425 { 514 {
426 case LL_NORMAL: /* A new archetype, just link it with the previous */ 515 LOG (llevDebug, "garbage collect arch %s", &at->archname);
427 if (last_more != NULL) 516 assert (at->arch == at); // verify that refcnt == 1 is truly valid
428 last_more->next = at; 517 allarch.erase (idx);
429 if (head != NULL)
430 head->next = at;
431 head = last_more = at;
432#if 0
433 if (!op->type)
434 LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);
435#endif
436 at->tail_x = 0;
437 at->tail_y = 0;
438 break;
439 518
440 case LL_MORE: /* Another part of the previous archetype, link it correctly */ 519 // break chain
441 520 for (object *op = at->head_ (); op; )
442 at->head = head;
443 at->clone.head = &head->clone;
444 if (last_more != NULL)
445 { 521 {
522 object *next = op->more;
523 op->head = 0;
446 last_more->more = at; 524 op->more = 0;
447 last_more->clone.more = &at->clone; 525 op = next;
448 } 526 }
449 last_more = at;
450 527
451 /* If this multipart image is still composed of individual small 528 at->destroy ();
452 * images, don't set the tail_.. values. We can't use them anyways, 529 at->arch = 0;
453 * and setting these to zero makes the map sending to the client much
454 * easier as just looking at the head, we know what to do.
455 */
456 if (at->clone.face != head->clone.face)
457 {
458 head->tail_x = 0;
459 head->tail_y = 0;
460 }
461 else
462 {
463 if (at->clone.x > head->tail_x)
464 head->tail_x = at->clone.x;
465 if (at->clone.y > head->tail_y)
466 head->tail_y = at->clone.y;
467 }
468 break;
469
470 } 530 }
471
472 at = new archetype;
473
474 at->clone.arch = at;
475 }
476
477 delete at;
478}
479
480/*
481 * Reads the archetype file once more, and links all pointers between
482 * archetypes.
483 */
484
485void
486second_arch_pass (object_thawer & thawer)
487{
488 char buf[MAX_BUF], *variable = buf, *argument, *cp;
489 archetype *at = NULL, *other;
490
491 while (fgets (buf, MAX_BUF, thawer) != NULL)
492 { 531 }
493 if (*buf == '#') 532 while (--cnt);
494 continue;
495 if ((argument = strchr (buf, ' ')) != NULL)
496 {
497 *argument = '\0', argument++;
498 cp = argument + strlen (argument) - 1;
499 while (isspace (*cp))
500 {
501 *cp = '\0';
502 cp--;
503 }
504 }
505 if (!strcmp ("Object", variable))
506 {
507 if ((at = archetype::find (argument)) == NULL)
508 LOG (llevError, "Warning: failed to find arch %s\n", argument);
509 }
510 else if (!strcmp ("other_arch", variable))
511 {
512 if (at != NULL && at->clone.other_arch == NULL)
513 {
514 if ((other = archetype::find (argument)) == NULL)
515 LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
516 else if (at != NULL)
517 at->clone.other_arch = other;
518 }
519 }
520 else if (!strcmp ("randomitems", variable))
521 {
522 if (at != NULL)
523 {
524 treasurelist *tl = find_treasurelist (argument);
525
526 if (tl == NULL)
527 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
528 else
529 at->clone.randomitems = tl;
530 }
531 }
532 }
533} 533}
534 534
535#ifdef DEBUG
536void
537check_generators (void)
538{
539 archetype *at;
540
541 for (at = first_archetype; at != NULL; at = at->next)
542 if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)
543 LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
544}
545#endif
546
547/*
548 * First initialises the archtype hash-table (init_archetable()).
549 * Reads and parses the archetype file (with the first and second-pass
550 * functions).
551 * Then initialises treasures by calling load_treasures().
552 */
553
554void
555load_archetypes (void)
556{
557 char filename[MAX_BUF];
558
559 sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
560 LOG (llevDebug, "Reading archetypes from %s:\n", filename);
561
562 {
563 object_thawer
564 thawer (filename);
565
566 clear_archetable ();
567 LOG (llevDebug, " arch-pass 1...\n");
568 first_arch_pass (thawer);
569 LOG (llevDebug, " done\n");
570 }
571
572 init_archetable ();
573 warn_archetypes = 1;
574
575 {
576 object_thawer
577 thawer (filename);
578
579 LOG (llevDebug, " loading treasure...\n");
580 load_treasures ();
581 LOG (llevDebug, " done\n arch-pass 2...\n");
582 second_arch_pass (thawer);
583 LOG (llevDebug, " done\n");
584#ifdef DEBUG
585 check_generators ();
586#endif
587 }
588 LOG (llevDebug, " done\n");
589}
590
591/*
592 * Creates and returns a new object which is a copy of the given archetype.
593 * This function returns NULL on failure.
594 */
595
596object *
597arch_to_object (archetype *at)
598{
599 object *op; 535object *
600 536archetype::instance ()
601 if (at == NULL) 537{
602 { 538 object *op = clone ();
603 if (warn_archetypes)
604 LOG (llevError, "Couldn't find archetype.\n");
605
606 return NULL;
607 }
608
609 op = at->clone.clone ();
610 op->arch = at;
611 op->instantiate (); 539 op->instantiate ();
612 return op; 540 return op;
613} 541}
614 542
615/* 543/*
616 * Creates an object. This function is called by get_archetype() 544 * Creates an object. This function is called by get_archetype()
617 * if it fails to find the appropriate archetype. 545 * if it fails to find the appropriate archetype.
618 * Thus get_archetype() will be guaranteed to always return 546 * Thus get_archetype() will be guaranteed to always return
619 * an object, and never NULL. 547 * an object, and never NULL.
620 */ 548 */
621
622object * 549object *
623create_singularity (const char *name) 550create_singularity (const char *name)
624{ 551{
625 object *op; 552 LOG (llevError | logBacktrace, "FATAL: creating singularity for '%s'.\n", name);
626 char buf[MAX_BUF];
627 553
628 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name); 554 if (!strcmp (name, "bug"))
629 op = object::create (); 555 abort ();
630 op->name = op->name_pl = buf; 556
631 SET_FLAG (op, FLAG_NO_PICK); 557 object *op = archetype::get (shstr_bug);
558 op->name = op->name_pl = format ("bug, please report (missing archetype %s)", name);
559
632 return op; 560 return op;
633} 561}
634 562
635/* 563/*
636 * Finds which archetype matches the given name, and returns a new 564 * Finds which archetype matches the given name, and returns a new
637 * object containing a copy of the archetype. 565 * object containing a copy of the archetype.
638 */ 566 */
639
640object * 567object *
641get_archetype (const char *name) 568get_archetype (const char *name)
642{ 569{
570 return archetype::get (name);
571}
572
573object *
574archetype::get (const char *name)
575{
643 archetype *at = archetype::find (name); 576 archetype *at = find (name);
644 577
645 if (!at) 578 if (!at)
646 return create_singularity (name); 579 return create_singularity (name);
647 580
648 return arch_to_object (at); 581 return at->instance ();
649}
650
651/*
652 * Hash-function used by the arch-hashtable.
653 */
654
655unsigned long
656hasharch (const char *str, int tablesize)
657{
658 unsigned long hash = 0;
659 unsigned int i = 0;
660 const char *p;
661
662 /* use the one-at-a-time hash function, which supposedly is
663 * better than the djb2-like one used by perl5.005, but
664 * certainly is better then the bug used here before.
665 * see http://burtleburtle.net/bob/hash/doobs.html
666 */
667 for (p = str; i < MAXSTRING && *p; p++, i++)
668 {
669 hash += *p;
670 hash += hash << 10;
671 hash ^= hash >> 6;
672 }
673
674 hash += hash << 3;
675 hash ^= hash >> 11;
676 hash += hash << 15;
677
678 return hash % tablesize;
679}
680
681/*
682 * Finds, using the hashtable, which archetype matches the given name.
683 * returns a pointer to the found archetype, otherwise NULL.
684 */
685
686archetype *
687archetype::find (const char *name)
688{
689 if (!name)
690 return 0;
691
692#if USE_UNORDERED_MAP
693 AUTODECL (i, ht.find ((size_t) name));
694
695 if (i == ht.end ())
696 return 0;
697 else
698 return i->second;
699#endif
700
701 archetype *at;
702 unsigned long index;
703
704 index = hasharch (name, ARCHTABLE);
705 arch_search++;
706 for (;;)
707 {
708 at = arch_table[index];
709
710 if (at == NULL)
711 {
712 if (warn_archetypes)
713 LOG (llevError, "Couldn't find archetype %s\n", name);
714
715 return NULL;
716 }
717
718 arch_cmp++;
719
720 if (!strcmp ((const char *) at->name, name))
721 return at;
722
723 if (++index >= ARCHTABLE)
724 index = 0;
725 }
726}
727
728/*
729 * Adds an archetype to the hashtable.
730 */
731void
732archetype::hash_add ()
733{
734#if USE_UNORDERED_MAP
735 ht.insert (std::make_pair ((size_t) (const char *) name, this));
736#else
737
738 int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
739
740 for (;;)
741 {
742 if (!arch_table[index])
743 {
744 arch_table[index] = this;
745 break;
746 }
747
748 if (++index == ARCHTABLE)
749 index = 0;
750
751 if (index == org_index)
752 fatal (ARCHTABLE_TOO_SMALL);
753 }
754#endif
755}
756
757void
758archetype::hash_del ()
759{
760#if USE_UNORDERED_MAP
761# error remove this from HT
762#else
763
764 int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
765
766 for (;;)
767 {
768 if (arch_table[index] == this)
769 {
770 arch_table[index] = 0;
771 break;
772 }
773
774 if (++index == ARCHTABLE)
775 index = 0;
776
777 if (index == org_index)
778 break;
779 }
780#endif
781} 582}
782 583
783/* 584/*
784 * Returns the first archetype using the given type. 585 * Returns the first archetype using the given type.
785 * Used in treasure-generation. 586 * Used in treasure-generation.
786 */ 587 */
787
788archetype * 588archetype *
789type_to_archetype (int type) 589type_to_archetype (int type)
790{ 590{
791 archetype *at; 591 for_all_archetypes (at)
792 592 if (at->type == type && at->head_ () != at)
793 for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
794 if (at->clone.type == type)
795 return at; 593 return at;
796 594
797 return 0; 595 return 0;
798} 596}
799 597
800/* 598/*
801 * Returns a new object copied from the first archetype matching 599 * Returns a new object copied from the first archetype matching
802 * the given type. 600 * the given type.
803 * Used in treasure-generation. 601 * Used in treasure-generation.
804 */ 602 */
805
806object * 603object *
807clone_arch (int type) 604clone_arch (int type)
808{ 605{
809 archetype *at; 606 archetype *at = type_to_archetype (type);
810 607
811 if ((at = type_to_archetype (type)) == NULL) 608 if (!at)
812 { 609 {
813 LOG (llevError, "Can't clone archetype %d\n", type); 610 LOG (llevError, "Can't clone archetype %d\n", type);
814 return 0; 611 return 0;
815 } 612 }
816 613
817 object *op = at->clone.clone (); 614 return at->instance ();
818 op->instantiate ();
819 return op;
820} 615}
821 616
822/* 617/*
823 * member: make instance from class 618 * member: make instance from class
824 */ 619 */
825
826object * 620object *
827object_create_arch (archetype *at) 621object_create_arch (archetype *at)
828{ 622{
829 object *op, *prev = 0, *head = 0; 623 object *op, *prev = 0, *head = 0;
830 624
831 while (at) 625 while (at)
832 { 626 {
833 op = arch_to_object (at); 627 op = at->instance ();
628
834 op->x = at->clone.x; 629 op->x = at->x;
835 op->y = at->clone.y; 630 op->y = at->y;
836 631
837 if (head) 632 if (head)
838 op->head = head, prev->more = op; 633 op->head = head, prev->more = op;
839 634
840 if (!head) 635 if (!head)
841 head = op; 636 head = op;
842 637
843 prev = op; 638 prev = op;
844 at = at->more; 639 at = (archetype *)at->more;
845 } 640 }
846 641
847 return (head); 642 return head;
848} 643}
849 644

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines