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

Diff Legend

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