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.12 by root, Mon Sep 4 17:16:19 2006 UTC vs.
Revision 1.35 by root, Wed Jan 3 20:32:13 2007 UTC

1/*
2 * static char *rcsid_arch_c =
3 * "$Id: arch.C,v 1.12 2006/09/04 17:16:19 root Exp $";
4 */
5
6/* 1/*
7 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
8 3
9 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
21 16
22 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 20
26 The authors can be reached via e-mail at crossfire-devel@real-time.com 21 The authors can be reached via e-mail at <crossfire@schmorp.de>
27*/ 22*/
28 23
29#include <cassert> 24#include <cassert>
30 25
31#include <tr1/unordered_map>
32
33#include <global.h> 26#include <global.h>
34#include <arch.h>
35#include <funcpoint.h> 27#include <funcpoint.h>
36#include <loader.h> 28#include <loader.h>
37 29
38/* IF set, does a little timing on the archetype load. */ 30#define USE_UNORDERED_MAP 0
39#define TIME_ARCH_LOAD 0
40 31
41static void add_arch (archetype * at); 32#if USE_UNORDERED_MAP
33# include <tr1/functional>
34# include <tr1/unordered_map>
35#endif
42 36
43static archetype *arch_table[ARCHTABLE];
44int arch_cmp = 0; /* How many strcmp's */ 37int arch_cmp = 0; /* How many strcmp's */
45int arch_search = 0; /* How many searches */ 38int arch_search = 0; /* How many searches */
46int arch_init; /* True if doing arch initialization */ 39int arch_init; /* True if doing arch initialization */
47 40
48/* The naming of these functions is really poor - they are all 41/* The naming of these functions is really poor - they are all
… …
53 * MSW 2003-04-29 46 * MSW 2003-04-29
54 */ 47 */
55 48
56#if USE_UNORDERED_MAP 49#if USE_UNORDERED_MAP
57// the hashtable 50// the hashtable
58typedef std::tr1::unordered_map<size_t, archetype *> HT; 51typedef std::tr1::unordered_map
52 <
53 std::size_t,
54 arch_ptr,
55 std::tr1::hash<size_t>,
56 std::equal_to<size_t>,
57 slice_allocator< std::pair<const std::size_t, archetype *> >
58 true,
59 > HT;
59 60
60static HT ht; 61static HT ht;
62#else
63static arch_ptr arch_table[ARCHTABLE];
61#endif 64#endif
62 65
63/** 66/**
64 * GROS - This function retrieves an archetype given the name that appears 67 * GROS - This function retrieves an archetype given the name that appears
65 * during the game (for example, "writing pen" instead of "stylus"). 68 * during the game (for example, "writing pen" instead of "stylus").
… …
115 * If type is -1, ew don't match on type. 118 * If type is -1, ew don't match on type.
116 */ 119 */
117object * 120object *
118get_archetype_by_skill_name (const char *skill, int type) 121get_archetype_by_skill_name (const char *skill, int type)
119{ 122{
120 archetype * 123 archetype *at;
121 at;
122 124
123 if (skill == NULL) 125 if (skill)
124 return NULL;
125
126 for (at = first_archetype; at != NULL; at = at->next) 126 for (at = first_archetype; at; at = at->next)
127 {
128 if (((type == -1) || (type == at->clone.type)) && (!strcmp (at->clone.skill, skill))) 127 if (((type == -1) || (type == at->clone.type)) && (!strcmp (at->clone.skill, skill)))
129 return arch_to_object (at); 128 return arch_to_object (at);
130 } 129
131 return NULL; 130 return 0;
132} 131}
133 132
134/* similiar to above - this returns the first archetype 133/* similiar to above - this returns the first archetype
135 * that matches both the type and subtype. type and subtype 134 * that matches both the type and subtype. type and subtype
136 * can be -1 to say ignore, but in this case, the match it does 135 * can be -1 to say ignore, but in this case, the match it does
… …
165 * but it otherwise had a big memory leak. 164 * but it otherwise had a big memory leak.
166 */ 165 */
167object * 166object *
168get_archetype_by_object_name (const char *name) 167get_archetype_by_object_name (const char *name)
169{ 168{
170 archetype * 169 archetype *at;
171 at;
172 char
173 tmpname[MAX_BUF]; 170 char tmpname[MAX_BUF];
174 int 171 int i;
175 i;
176 172
177 strncpy (tmpname, name, MAX_BUF - 1); 173 assign (tmpname, name);
178 tmpname[MAX_BUF - 1] = 0; 174
179 for (i = strlen (tmpname); i > 0; i--) 175 for (i = strlen (tmpname); i > 0; i--)
180 { 176 {
181 tmpname[i] = 0; 177 tmpname[i] = 0;
182 at = find_archetype_by_object_name (tmpname); 178 at = find_archetype_by_object_name (tmpname);
179
183 if (at != NULL) 180 if (at)
184 {
185 return arch_to_object (at); 181 return arch_to_object (at);
186 }
187 } 182 }
183
188 return create_singularity (name); 184 return create_singularity (name);
189} 185}
190 186
191 /* This is a subset of the parse_id command. Basically, name can be 187 /* 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. 188 * a string seperated lists of things to match, with certain keywords.
… …
204 * If count is 1, make a quick check on the name. 200 * 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. 201 * IF count is >1, we need to make plural name. Return if match.
206 * Last, make a check on the full name. 202 * Last, make a check on the full name.
207 */ 203 */
208int 204int
209item_matched_string (object * pl, object * op, const char *name) 205item_matched_string (object *pl, object *op, const char *name)
210{ 206{
211 char *
212 cp,
213 local_name[MAX_BUF]; 207 char *cp, local_name[MAX_BUF];
214 int 208 int count, retval = 0;
215 count, 209
216 retval = 0;
217 strcpy (local_name, name); /* strtok is destructive to name */ 210 strcpy (local_name, name); /* strtok is destructive to name */
218 211
219 for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ",")) 212 for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
220 { 213 {
221 while (cp[0] == ' ') 214 while (cp[0] == ' ')
… …
272 retval = 15; 265 retval = 15;
273 else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp))) 266 else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))
274 retval = 14; 267 retval = 14;
275 else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp))) 268 else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))
276 retval = 14; 269 retval = 14;
277
278 /* Do substring checks, so things like 'Str+1' will match. 270 /* Do substring checks, so things like 'Str+1' will match.
279 * retval of these should perhaps be lower - they are lower 271 * retval of these should perhaps be lower - they are lower
280 * then the specific strcasecmp aboves, but still higher than 272 * then the specific strcasecmp aboves, but still higher than
281 * some other match criteria. 273 * some other match criteria.
282 */ 274 */
… …
284 retval = 12; 276 retval = 12;
285 else if (strstr (query_base_name (op, 0), cp)) 277 else if (strstr (query_base_name (op, 0), cp))
286 retval = 12; 278 retval = 12;
287 else if (strstr (query_short_name (op), cp)) 279 else if (strstr (query_short_name (op), cp))
288 retval = 12; 280 retval = 12;
289
290 /* Check against plural/non plural based on count. */ 281 /* Check against plural/non plural based on count. */
291 else if (count > 1 && !strcasecmp (cp, op->name_pl)) 282 else if (count > 1 && !strcasecmp (cp, op->name_pl))
292 {
293 retval = 6; 283 retval = 6;
294 }
295 else if (count == 1 && !strcasecmp (op->name, cp)) 284 else if (count == 1 && !strcasecmp (op->name, cp))
296 {
297 retval = 6; 285 retval = 6;
298 }
299 /* base name matched - not bad */ 286 /* base name matched - not bad */
300 else if (strcasecmp (cp, op->name) == 0 && !count) 287 else if (strcasecmp (cp, op->name) == 0 && !count)
301 retval = 4; 288 retval = 4;
302 /* Check for partial custom name, but give a real low priority */ 289 /* Check for partial custom name, but give a real low priority */
303 else if (op->custom_name && strstr (op->custom_name, cp)) 290 else if (op->custom_name && strstr (op->custom_name, cp))
… …
305 292
306 if (retval) 293 if (retval)
307 { 294 {
308 if (pl->type == PLAYER) 295 if (pl->type == PLAYER)
309 pl->contr->count = count; 296 pl->contr->count = count;
297
310 return retval; 298 return retval;
311 } 299 }
312 } 300 }
301
313 return 0; 302 return 0;
314} 303}
315 304
316/* 305/*
317 * Initialises the internal linked list of archetypes (read from file). 306 * Initialises the internal linked list of archetypes (read from file).
… …
322void 311void
323init_archetypes (void) 312init_archetypes (void)
324{ /* called from add_player() and edit() */ 313{ /* called from add_player() and edit() */
325 if (first_archetype != NULL) /* Only do this once */ 314 if (first_archetype != NULL) /* Only do this once */
326 return; 315 return;
316
327 arch_init = 1; 317 arch_init = 1;
328 load_archetypes (); 318 load_archetypes ();
329 arch_init = 0; 319 arch_init = 0;
330 empty_archetype = find_archetype ("empty_archetype"); 320 empty_archetype = archetype::find ("empty_archetype");
321
331/* init_blocksview();*/ 322/* init_blocksview();*/
332} 323}
333 324
334/* 325/*
335 * Stores debug-information about how efficient the hashtable 326 * Stores debug-information about how efficient the hashtable
336 * used for archetypes has been in the static errmsg array. 327 * used for archetypes has been in the static errmsg array.
337 */ 328 */
338 329
339void 330void
340arch_info (object * op) 331arch_info (object *op)
341{ 332{
342 sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp); 333 sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp);
343 new_draw_info (NDI_BLACK, 0, op, errmsg); 334 new_draw_info (NDI_BLACK, 0, op, errmsg);
344} 335}
345 336
… …
363 archetype *at; 354 archetype *at;
364 355
365 LOG (llevDebug, " Setting up archetable...\n"); 356 LOG (llevDebug, " Setting up archetable...\n");
366 357
367 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more) 358 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
368 add_arch (at); 359 at->hash_add ();
369 360
370 LOG (llevDebug, "done\n"); 361 LOG (llevDebug, "done\n");
371} 362}
372 363
373/*
374 * Dumps an archetype to debug-level output.
375 */
376
377void
378dump_arch (archetype * at)
379{
380 dump_object (&at->clone);
381}
382
383/*
384 * Dumps _all_ archetypes to debug-level output.
385 * If you run crossfire with debug, and enter DM-mode, you can trigger
386 * this with the O key.
387 */
388
389void
390dump_all_archetypes (void)
391{
392 archetype *
393 at;
394 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
395 {
396 dump_arch (at);
397 fprintf (logfile, "%s\n", errmsg);
398 }
399}
400
401void 364void
402free_all_archs (void) 365free_all_archs (void)
403{ 366{
404 archetype * 367 archetype *at, *next;
405 at, *
406 next;
407 int
408 i = 0, f = 0; 368 int i = 0, f = 0;
409 369
410 for (at = first_archetype; at != NULL; at = next) 370 for (at = first_archetype; at != NULL; at = next)
411 { 371 {
412 if (at->more) 372 if (at->more)
413 next = at->more; 373 next = at->more;
414 else 374 else
415 next = at->next; 375 next = at->next;
416 376
417 delete 377 delete
418 at; 378 at;
379
419 i++; 380 i++;
420 } 381 }
382
421 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f); 383 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
422} 384}
423 385
424/* 386archetype::archetype ()
425 * Allocates, initialises and returns the pointer to an archetype structure.
426 */
427// TODO: should become constructor
428archetype *
429get_archetype_struct (void)
430{ 387{
431 archetype *
432 arch;
433
434 arch = new archetype;
435
436 clear_object (&arch->clone); /* to initial state other also */
437 CLEAR_FLAG (&arch->clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */ 388 CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_to */
438 SET_FLAG (&arch->clone, FLAG_REMOVED); /* doesn't copy these flags... */ 389 SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
390}
439 391
440 return arch; 392archetype::~archetype ()
393{
441} 394}
442 395
443/* 396/*
444 * Reads/parses the archetype-file, and copies into a linked list 397 * Reads/parses the archetype-file, and copies into a linked list
445 * of archetype-structures. 398 * of archetype-structures.
446 */ 399 */
447void 400void
448first_arch_pass (object_thawer & fp) 401first_arch_pass (object_thawer & fp)
449{ 402{
450 object * 403 archetype *head = 0, *last_more = 0;
451 op;
452 archetype *
453 at, *
454 head = NULL, *last_more = NULL;
455 int
456 i;
457 404
458 op = get_object (); 405 archetype *at = new archetype;
459 op->arch = first_archetype = at = get_archetype_struct (); 406 at->clone.arch = first_archetype = at;
460 407
461 while ((i = load_object (fp, op, 0))) 408 while (int i = load_object (fp, &at->clone, 0))
462 { 409 {
463 copy_object (op, &at->clone);
464 at->clone.speed_left = (float) (-0.1); 410 at->clone.speed_left = (float) (-0.1);
465 /* copy the body_info to the body_used - this is only really 411 /* copy the body_info to the body_used - this is only really
466 * need for monsters, but doesn't hurt to do it for everything. 412 * need for monsters, but doesn't hurt to do it for everything.
467 * by doing so, when a monster is created, it has good starting 413 * by doing so, when a monster is created, it has good starting
468 * values for the body_used info, so when items are created 414 * values for the body_used info, so when items are created
469 * for it, they can be properly equipped. 415 * for it, they can be properly equipped.
470 */ 416 */
471 memcpy (&at->clone.body_used, &op->body_info, sizeof (op->body_info)); 417 memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));
472 418
473 switch (i) 419 switch (i)
474 { 420 {
475 case LL_NORMAL: /* A new archetype, just link it with the previous */ 421 case LL_NORMAL: /* A new archetype, just link it with the previous */
476 if (last_more != NULL) 422 if (last_more != NULL)
477 last_more->next = at; 423 last_more->next = at;
478 if (head != NULL) 424 if (head != NULL)
479 head->next = at; 425 head->next = at;
480 head = last_more = at; 426 head = last_more = at;
481#if 0 427#if 0
482 if (!op->type) 428 if (!op->type)
483 LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name); 429 LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);
484#endif 430#endif
485 at->tail_x = 0; 431 at->tail_x = 0;
486 at->tail_y = 0; 432 at->tail_y = 0;
487 break; 433 break;
488 434
489 case LL_MORE: /* Another part of the previous archetype, link it correctly */ 435 case LL_MORE: /* Another part of the previous archetype, link it correctly */
490 436
491 at->head = head; 437 at->head = head;
492 at->clone.head = &head->clone; 438 at->clone.head = &head->clone;
493 if (last_more != NULL) 439 if (last_more != NULL)
494 { 440 {
495 last_more->more = at; 441 last_more->more = at;
496 last_more->clone.more = &at->clone; 442 last_more->clone.more = &at->clone;
497 } 443 }
498 last_more = at; 444 last_more = at;
499 445
500 /* If this multipart image is still composed of individual small 446 /* If this multipart image is still composed of individual small
501 * images, don't set the tail_.. values. We can't use them anyways, 447 * images, don't set the tail_.. values. We can't use them anyways,
502 * and setting these to zero makes the map sending to the client much 448 * and setting these to zero makes the map sending to the client much
503 * easier as just looking at the head, we know what to do. 449 * easier as just looking at the head, we know what to do.
504 */ 450 */
505 if (at->clone.face != head->clone.face) 451 if (at->clone.face != head->clone.face)
506 { 452 {
507 head->tail_x = 0; 453 head->tail_x = 0;
508 head->tail_y = 0; 454 head->tail_y = 0;
509 } 455 }
510 else 456 else
511 { 457 {
512 if (at->clone.x > head->tail_x) 458 if (at->clone.x > head->tail_x)
513 head->tail_x = at->clone.x; 459 head->tail_x = at->clone.x;
514 if (at->clone.y > head->tail_y) 460 if (at->clone.y > head->tail_y)
515 head->tail_y = at->clone.y; 461 head->tail_y = at->clone.y;
516 } 462 }
517 break; 463 break;
518 464
519 } 465 }
520 466
521 at = get_archetype_struct (); 467 at = new archetype;
522 clear_object (op); 468
523 op->arch = at; 469 at->clone.arch = at;
524 } 470 }
525 471
526 delete 472 delete at;
527 at;
528 free_object (op);
529} 473}
530 474
531/* 475/*
532 * Reads the archetype file once more, and links all pointers between 476 * Reads the archetype file once more, and links all pointers between
533 * archetypes. 477 * archetypes.
534 */ 478 */
535 479
536void 480void
537second_arch_pass (object_thawer & thawer) 481second_arch_pass (object_thawer & thawer)
538{ 482{
539 char
540 buf[MAX_BUF], *
541 variable = buf, *argument, *cp; 483 char buf[MAX_BUF], *variable = buf, *argument, *cp;
542 archetype *
543 at = NULL, *other; 484 archetype *at = NULL, *other;
544 485
545 while (fgets (buf, MAX_BUF, thawer) != NULL) 486 while (fgets (buf, MAX_BUF, thawer) != NULL)
546 { 487 {
547 if (*buf == '#') 488 if (*buf == '#')
548 continue; 489 continue;
… …
556 cp--; 497 cp--;
557 } 498 }
558 } 499 }
559 if (!strcmp ("Object", variable)) 500 if (!strcmp ("Object", variable))
560 { 501 {
561 if ((at = find_archetype (argument)) == NULL) 502 if ((at = archetype::find (argument)) == NULL)
562 LOG (llevError, "Warning: failed to find arch %s\n", argument); 503 LOG (llevError, "Warning: failed to find arch %s\n", argument);
563 } 504 }
564 else if (!strcmp ("other_arch", variable)) 505 else if (!strcmp ("other_arch", variable))
565 { 506 {
566 if (at != NULL && at->clone.other_arch == NULL) 507 if (at != NULL && at->clone.other_arch == NULL)
567 { 508 {
568 if ((other = find_archetype (argument)) == NULL) 509 if ((other = archetype::find (argument)) == NULL)
569 LOG (llevError, "Warning: failed to find other_arch %s\n", argument); 510 LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
570 else if (at != NULL) 511 else if (at != NULL)
571 at->clone.other_arch = other; 512 at->clone.other_arch = other;
572 } 513 }
573 } 514 }
574 else if (!strcmp ("randomitems", variable)) 515 else if (!strcmp ("randomitems", variable))
575 { 516 {
576 if (at != NULL) 517 if (at != NULL)
577 { 518 {
578 treasurelist *
579 tl = find_treasurelist (argument); 519 treasurelist *tl = find_treasurelist (argument);
520
580 if (tl == NULL) 521 if (tl == NULL)
581 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument); 522 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
582 else 523 else
583 at->clone.randomitems = tl; 524 at->clone.randomitems = tl;
584 } 525 }
… …
588 529
589#ifdef DEBUG 530#ifdef DEBUG
590void 531void
591check_generators (void) 532check_generators (void)
592{ 533{
593 archetype * 534 archetype *at;
594 at; 535
595 for (at = first_archetype; at != NULL; at = at->next) 536 for (at = first_archetype; at != NULL; at = at->next)
596 if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL) 537 if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)
597 LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name); 538 LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
598} 539}
599#endif 540#endif
… …
606 */ 547 */
607 548
608void 549void
609load_archetypes (void) 550load_archetypes (void)
610{ 551{
611 char
612 filename[MAX_BUF]; 552 char filename[MAX_BUF];
613 int
614 comp;
615#if TIME_ARCH_LOAD
616 struct timeval
617 tv1,
618 tv2;
619#endif
620 553
621 sprintf (filename, "%s/%s", settings.datadir, settings.archetypes); 554 sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
622 LOG (llevDebug, "Reading archetypes from %s:\n", filename); 555 LOG (llevDebug, "Reading archetypes from %s:\n", filename);
623 556
624 { 557 {
… …
638 object_thawer 571 object_thawer
639 thawer (filename); 572 thawer (filename);
640 573
641 LOG (llevDebug, " loading treasure...\n"); 574 LOG (llevDebug, " loading treasure...\n");
642 load_treasures (); 575 load_treasures ();
576 LOG (llevDebug, " done\n");
643 LOG (llevDebug, " done\n arch-pass 2...\n"); 577 LOG (llevDebug, " arch-pass 2...\n");
644 second_arch_pass (thawer); 578 second_arch_pass (thawer);
645 LOG (llevDebug, " done\n"); 579 LOG (llevDebug, " done\n");
646#ifdef DEBUG 580#ifdef DEBUG
647 check_generators (); 581 check_generators ();
648#endif 582#endif
… …
652 586
653/* 587/*
654 * Creates and returns a new object which is a copy of the given archetype. 588 * Creates and returns a new object which is a copy of the given archetype.
655 * This function returns NULL on failure. 589 * This function returns NULL on failure.
656 */ 590 */
657
658object * 591object *
659arch_to_object (archetype * at) 592arch_to_object (archetype *at)
660{ 593{
661 object * 594 object *op;
662 op; 595
663 if (at == NULL) 596 if (at == NULL)
664 { 597 {
665 if (warn_archetypes) 598 if (warn_archetypes)
666 LOG (llevError, "Couldn't find archetype.\n"); 599 LOG (llevError, "Couldn't find archetype.\n");
600
667 return NULL; 601 return NULL;
668 } 602 }
669 op = get_object (); 603
670 copy_object (&at->clone, op); 604 op = at->clone.clone ();
605 op->arch = at;
671 op->instantiate (); 606 op->instantiate ();
672 op->arch = at;
673 return op; 607 return op;
674} 608}
675 609
676/* 610/*
677 * Creates an object. This function is called by get_archetype() 611 * Creates an object. This function is called by get_archetype()
678 * if it fails to find the appropriate archetype. 612 * if it fails to find the appropriate archetype.
679 * Thus get_archetype() will be guaranteed to always return 613 * Thus get_archetype() will be guaranteed to always return
680 * an object, and never NULL. 614 * an object, and never NULL.
681 */ 615 */
682
683object * 616object *
684create_singularity (const char *name) 617create_singularity (const char *name)
685{ 618{
686 object * 619 object *op;
687 op;
688 char
689 buf[MAX_BUF]; 620 char buf[MAX_BUF];
621
690 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name); 622 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
691 op = get_object (); 623 op = object::create ();
692 op->name = op->name_pl = buf; 624 op->name = op->name_pl = buf;
693 SET_FLAG (op, FLAG_NO_PICK); 625 SET_FLAG (op, FLAG_NO_PICK);
694 return op; 626 return op;
695} 627}
696 628
697/* 629/*
698 * Finds which archetype matches the given name, and returns a new 630 * Finds which archetype matches the given name, and returns a new
699 * object containing a copy of the archetype. 631 * object containing a copy of the archetype.
700 */ 632 */
701
702object * 633object *
703get_archetype (const char *name) 634get_archetype (const char *name)
704{ 635{
705 archetype * 636 archetype *at = archetype::find (name);
706 at; 637
707 at = find_archetype (name); 638 if (!at)
708 if (at == NULL)
709 return create_singularity (name); 639 return create_singularity (name);
640
710 return arch_to_object (at); 641 return arch_to_object (at);
711} 642}
712 643
713/* 644/*
714 * Hash-function used by the arch-hashtable. 645 * Hash-function used by the arch-hashtable.
715 */ 646 */
716 647
717unsigned long 648unsigned long
718hasharch (const char *str, int tablesize) 649hasharch (const char *str, int tablesize)
719{ 650{
720 unsigned long 651 unsigned long hash = 0;
721 hash = 0;
722 unsigned int 652 unsigned int i = 0;
723 i = 0;
724 const char * 653 const char *p;
725 p;
726 654
727 /* use the one-at-a-time hash function, which supposedly is 655 /* use the one-at-a-time hash function, which supposedly is
728 * better than the djb2-like one used by perl5.005, but 656 * better than the djb2-like one used by perl5.005, but
729 * certainly is better then the bug used here before. 657 * certainly is better then the bug used here before.
730 * see http://burtleburtle.net/bob/hash/doobs.html 658 * see http://burtleburtle.net/bob/hash/doobs.html
… …
747 * Finds, using the hashtable, which archetype matches the given name. 675 * Finds, using the hashtable, which archetype matches the given name.
748 * returns a pointer to the found archetype, otherwise NULL. 676 * returns a pointer to the found archetype, otherwise NULL.
749 */ 677 */
750 678
751archetype * 679archetype *
752find_archetype (const char *name) 680archetype::find (const char *name)
753{ 681{
754#if USE_UNORDERED_MAP
755 name = shstr::find (name);
756
757 if (!name) 682 if (!name)
758 return 0; 683 return 0;
759 684
760 HT::const_iterator i = ht.find ((size_t)name); 685#if USE_UNORDERED_MAP
686 AUTODECL (i, ht.find ((size_t) name));
761 687
762 if (i == ht.end ()) 688 if (i == ht.end ())
763 return 0; 689 return 0;
764 else 690 else
765 return i->second; 691 return i->second;
766#endif 692#endif
767 693
768 archetype *at; 694 archetype *at;
769 unsigned long index; 695 unsigned long index;
770 696
771 if (name == NULL)
772 return (archetype *) NULL;
773
774 index = hasharch (name, ARCHTABLE); 697 index = hasharch (name, ARCHTABLE);
775 arch_search++; 698 arch_search++;
776 for (;;) 699 for (;;)
777 { 700 {
778 at = arch_table[index]; 701 at = arch_table[index];
702
779 if (at == NULL) 703 if (at == NULL)
780 { 704 {
781 if (warn_archetypes) 705 if (warn_archetypes)
782 LOG (llevError, "Couldn't find archetype %s\n", name); 706 LOG (llevError, "Couldn't find archetype %s\n", name);
707
783 return NULL; 708 return NULL;
784 } 709 }
710
785 arch_cmp++; 711 arch_cmp++;
712
786 if (!strcmp ((const char *) at->name, name)) 713 if (!strcmp ((const char *) at->name, name))
787 return at; 714 return at;
715
788 if (++index >= ARCHTABLE) 716 if (++index >= ARCHTABLE)
789 index = 0; 717 index = 0;
790 } 718 }
791} 719}
792 720
793/* 721/*
794 * Adds an archetype to the hashtable. 722 * Adds an archetype to the hashtable.
795 */ 723 */
796 724void
797static void 725archetype::hash_add ()
798add_arch (archetype *at)
799{ 726{
800#if USE_UNORDERED_MAP 727#if USE_UNORDERED_MAP
801 ht.insert (std::make_pair ((size_t)(const char *)at->name, at)); 728 ht.insert (std::make_pair ((size_t) (const char *) name, this));
802#endif 729#else
803 730
804 int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index; 731 int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
805 732
806 for (;;) 733 for (;;)
807 { 734 {
808 if (arch_table[index] == NULL) 735 if (!arch_table[index])
809 { 736 {
810 arch_table[index] = at; 737 arch_table[index] = this;
811 return; 738 break;
812 } 739 }
813 740
814 if (++index == ARCHTABLE) 741 if (++index == ARCHTABLE)
815 index = 0; 742 index = 0;
816 743
817 if (index == org_index) 744 if (index == org_index)
818 fatal (ARCHTABLE_TOO_SMALL); 745 fatal (ARCHTABLE_TOO_SMALL);
819 } 746 }
747#endif
748}
749
750void
751archetype::hash_del ()
752{
753#if USE_UNORDERED_MAP
754# error remove this from HT
755#else
756
757 int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
758
759 for (;;)
760 {
761 if (arch_table[index] == this)
762 {
763 arch_table[index] = 0;
764 break;
765 }
766
767 if (++index == ARCHTABLE)
768 index = 0;
769
770 if (index == org_index)
771 break;
772 }
773#endif
820} 774}
821 775
822/* 776/*
823 * Returns the first archetype using the given type. 777 * Returns the first archetype using the given type.
824 * Used in treasure-generation. 778 * Used in treasure-generation.
825 */ 779 */
826 780
827archetype * 781archetype *
828type_to_archetype (int type) 782type_to_archetype (int type)
829{ 783{
830 archetype * 784 archetype *at;
831 at;
832 785
833 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more) 786 for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
834 if (at->clone.type == type) 787 if (at->clone.type == type)
835 return at; 788 return at;
789
836 return NULL; 790 return 0;
837} 791}
838 792
839/* 793/*
840 * Returns a new object copied from the first archetype matching 794 * Returns a new object copied from the first archetype matching
841 * the given type. 795 * the given type.
… …
843 */ 797 */
844 798
845object * 799object *
846clone_arch (int type) 800clone_arch (int type)
847{ 801{
848 archetype * 802 archetype *at;
849 at;
850 object *
851 op = get_object ();
852 803
853 if ((at = type_to_archetype (type)) == NULL) 804 if ((at = type_to_archetype (type)) == NULL)
854 { 805 {
855 LOG (llevError, "Can't clone archetype %d\n", type); 806 LOG (llevError, "Can't clone archetype %d\n", type);
856 free_object (op);
857 return NULL; 807 return 0;
858 } 808 }
859 copy_object (&at->clone, op); 809
810 object *op = at->clone.clone ();
860 op->instantiate (); 811 op->instantiate ();
861 return op; 812 return op;
862} 813}
863 814
864/* 815/*
865 * member: make instance from class 816 * member: make instance from class
866 */ 817 */
867 818
868object * 819object *
869object_create_arch (archetype * at) 820object_create_arch (archetype *at)
870{ 821{
871 object * 822 object *op, *prev = 0, *head = 0;
872 op, *
873 prev = NULL, *head = NULL;
874 823
875 while (at) 824 while (at)
876 { 825 {
877 op = arch_to_object (at); 826 op = arch_to_object (at);
878 op->x = at->clone.x; 827 op->x = at->clone.x;
879 op->y = at->clone.y; 828 op->y = at->clone.y;
829
880 if (head) 830 if (head)
881 op->head = head, prev->more = op; 831 op->head = head, prev->more = op;
832
882 if (!head) 833 if (!head)
883 head = op; 834 head = op;
835
884 prev = op; 836 prev = op;
885 at = at->more; 837 at = at->more;
886 } 838 }
839
887 return (head); 840 return (head);
888} 841}
889 842
890/*** end of arch.c ***/

Diff Legend

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