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.13 by pippijn, Thu Sep 7 09:37:11 2006 UTC vs.
Revision 1.25 by root, Tue Nov 7 16:30:54 2006 UTC

1/*
2 * static char *rcsid_arch_c =
3 * "$Id: arch.C,v 1.13 2006/09/07 09:37:11 pippijn 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> 26#include <tr1/unordered_map>
… …
36#include <loader.h> 31#include <loader.h>
37 32
38/* IF set, does a little timing on the archetype load. */ 33/* IF set, does a little timing on the archetype load. */
39#define TIME_ARCH_LOAD 0 34#define TIME_ARCH_LOAD 0
40 35
41static void add_arch (archetype * at); 36static void add_arch (archetype *at);
42 37
43static archetype *arch_table[ARCHTABLE]; 38static archetype *arch_table[ARCHTABLE];
44int arch_cmp = 0; /* How many strcmp's */ 39int arch_cmp = 0; /* How many strcmp's */
45int arch_search = 0; /* How many searches */ 40int arch_search = 0; /* How many searches */
46int arch_init; /* True if doing arch initialization */ 41int arch_init; /* True if doing arch initialization */
… …
53 * MSW 2003-04-29 48 * MSW 2003-04-29
54 */ 49 */
55 50
56#if USE_UNORDERED_MAP 51#if USE_UNORDERED_MAP
57// the hashtable 52// the hashtable
58typedef std::tr1::unordered_map<size_t, archetype *> HT; 53typedef std::tr1::unordered_map
54 <
55 std::size_t,
56 archetype *,
57 std::hash<size_t>,
58 std::equal_to<size_t>,
59 slice_allocator< std::pair<const std::size_t, archetype *> >
60 true,
61 > HT;
59 62
60static HT ht; 63static HT ht;
61#endif 64#endif
62 65
63/** 66/**
… …
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
… …
368 add_arch (at); 363 add_arch (at);
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 }
421 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f); 386 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
422} 387}
423 388
424/* 389archetype::archetype ()
425 * Allocates, initialises and returns the pointer to an archetype structure.
426 */
427// TODO: should become constructor
428archetype *
429get_archetype_struct (void)
430{ 390{
431 archetype *
432 arch;
433
434 arch = new archetype;
435
436 clear_object (&arch->clone); /* to initial state other also */ 391 clear_object (&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_object() */
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 *
451 op;
452 archetype *
453 at, *
454 head = NULL, *last_more = NULL; 407 archetype *at, *head = NULL, *last_more = NULL;
455 int
456 i;
457 408
458 op = get_object ();
459 op->arch = first_archetype = at = get_archetype_struct (); 409 at->clone.arch = first_archetype = at = new archetype;
460 410
461 while ((i = load_object (fp, op, 0))) 411 while (int i = load_object (fp, &at->clone, 0))
462 { 412 {
463 copy_object (op, &at->clone);
464 at->clone.speed_left = (float) (-0.1); 413 at->clone.speed_left = (float) (-0.1);
465 /* copy the body_info to the body_used - this is only really 414 /* 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. 415 * 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 416 * by doing so, when a monster is created, it has good starting
468 * values for the body_used info, so when items are created 417 * values for the body_used info, so when items are created
469 * for it, they can be properly equipped. 418 * for it, they can be properly equipped.
470 */ 419 */
471 memcpy (&at->clone.body_used, &op->body_info, sizeof (op->body_info)); 420 memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));
472 421
473 switch (i) 422 switch (i)
474 { 423 {
475 case LL_NORMAL: /* A new archetype, just link it with the previous */ 424 case LL_NORMAL: /* A new archetype, just link it with the previous */
476 if (last_more != NULL) 425 if (last_more != NULL)
477 last_more->next = at; 426 last_more->next = at;
478 if (head != NULL) 427 if (head != NULL)
479 head->next = at; 428 head->next = at;
480 head = last_more = at; 429 head = last_more = at;
481#if 0 430#if 0
482 if (!op->type) 431 if (!op->type)
483 LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name); 432 LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);
484#endif 433#endif
485 at->tail_x = 0; 434 at->tail_x = 0;
486 at->tail_y = 0; 435 at->tail_y = 0;
487 break; 436 break;
488 437
489 case LL_MORE: /* Another part of the previous archetype, link it correctly */ 438 case LL_MORE: /* Another part of the previous archetype, link it correctly */
490 439
491 at->head = head; 440 at->head = head;
492 at->clone.head = &head->clone; 441 at->clone.head = &head->clone;
493 if (last_more != NULL) 442 if (last_more != NULL)
494 { 443 {
495 last_more->more = at; 444 last_more->more = at;
496 last_more->clone.more = &at->clone; 445 last_more->clone.more = &at->clone;
497 } 446 }
498 last_more = at; 447 last_more = at;
499 448
500 /* If this multipart image is still composed of individual small 449 /* If this multipart image is still composed of individual small
501 * images, don't set the tail_.. values. We can't use them anyways, 450 * 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 451 * 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. 452 * easier as just looking at the head, we know what to do.
504 */ 453 */
505 if (at->clone.face != head->clone.face) 454 if (at->clone.face != head->clone.face)
506 { 455 {
507 head->tail_x = 0; 456 head->tail_x = 0;
508 head->tail_y = 0; 457 head->tail_y = 0;
509 } 458 }
510 else 459 else
511 { 460 {
512 if (at->clone.x > head->tail_x) 461 if (at->clone.x > head->tail_x)
513 head->tail_x = at->clone.x; 462 head->tail_x = at->clone.x;
514 if (at->clone.y > head->tail_y) 463 if (at->clone.y > head->tail_y)
515 head->tail_y = at->clone.y; 464 head->tail_y = at->clone.y;
516 } 465 }
517 break; 466 break;
518 467
519 } 468 }
520 469
521 at = get_archetype_struct (); 470 at = new archetype;
522 clear_object (op); 471
523 op->arch = at; 472 at->clone.arch = at;
524 } 473 }
525 474
526 delete 475 delete at;
527 at;
528 free_object (op);
529} 476}
530 477
531/* 478/*
532 * Reads the archetype file once more, and links all pointers between 479 * Reads the archetype file once more, and links all pointers between
533 * archetypes. 480 * archetypes.
534 */ 481 */
535 482
536void 483void
537second_arch_pass (object_thawer & thawer) 484second_arch_pass (object_thawer & thawer)
538{ 485{
539 char
540 buf[MAX_BUF], *
541 variable = buf, *argument, *cp; 486 char buf[MAX_BUF], *variable = buf, *argument, *cp;
542 archetype *
543 at = NULL, *other; 487 archetype *at = NULL, *other;
544 488
545 while (fgets (buf, MAX_BUF, thawer) != NULL) 489 while (fgets (buf, MAX_BUF, thawer) != NULL)
546 { 490 {
547 if (*buf == '#') 491 if (*buf == '#')
548 continue; 492 continue;
… …
556 cp--; 500 cp--;
557 } 501 }
558 } 502 }
559 if (!strcmp ("Object", variable)) 503 if (!strcmp ("Object", variable))
560 { 504 {
561 if ((at = find_archetype (argument)) == NULL) 505 if ((at = archetype::find (argument)) == NULL)
562 LOG (llevError, "Warning: failed to find arch %s\n", argument); 506 LOG (llevError, "Warning: failed to find arch %s\n", argument);
563 } 507 }
564 else if (!strcmp ("other_arch", variable)) 508 else if (!strcmp ("other_arch", variable))
565 { 509 {
566 if (at != NULL && at->clone.other_arch == NULL) 510 if (at != NULL && at->clone.other_arch == NULL)
567 { 511 {
568 if ((other = find_archetype (argument)) == NULL) 512 if ((other = archetype::find (argument)) == NULL)
569 LOG (llevError, "Warning: failed to find other_arch %s\n", argument); 513 LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
570 else if (at != NULL) 514 else if (at != NULL)
571 at->clone.other_arch = other; 515 at->clone.other_arch = other;
572 } 516 }
573 } 517 }
574 else if (!strcmp ("randomitems", variable)) 518 else if (!strcmp ("randomitems", variable))
575 { 519 {
576 if (at != NULL) 520 if (at != NULL)
577 { 521 {
578 treasurelist *
579 tl = find_treasurelist (argument); 522 treasurelist *tl = find_treasurelist (argument);
523
580 if (tl == NULL) 524 if (tl == NULL)
581 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument); 525 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
582 else 526 else
583 at->clone.randomitems = tl; 527 at->clone.randomitems = tl;
584 } 528 }
… …
588 532
589#ifdef DEBUG 533#ifdef DEBUG
590void 534void
591check_generators (void) 535check_generators (void)
592{ 536{
593 archetype * 537 archetype *at;
594 at; 538
595 for (at = first_archetype; at != NULL; at = at->next) 539 for (at = first_archetype; at != NULL; at = at->next)
596 if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL) 540 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); 541 LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
598} 542}
599#endif 543#endif
… …
606 */ 550 */
607 551
608void 552void
609load_archetypes (void) 553load_archetypes (void)
610{ 554{
611 char
612 filename[MAX_BUF]; 555 char filename[MAX_BUF];
556
613#if TIME_ARCH_LOAD 557#if TIME_ARCH_LOAD
614 struct timeval 558 struct timeval
615 tv1, 559 tv1,
616 tv2; 560 tv2;
617#endif 561#endif
… …
652 * Creates and returns a new object which is a copy of the given archetype. 596 * Creates and returns a new object which is a copy of the given archetype.
653 * This function returns NULL on failure. 597 * This function returns NULL on failure.
654 */ 598 */
655 599
656object * 600object *
657arch_to_object (archetype * at) 601arch_to_object (archetype *at)
658{ 602{
659 object * 603 object *op;
660 op; 604
661 if (at == NULL) 605 if (at == NULL)
662 { 606 {
663 if (warn_archetypes) 607 if (warn_archetypes)
664 LOG (llevError, "Couldn't find archetype.\n"); 608 LOG (llevError, "Couldn't find archetype.\n");
609
665 return NULL; 610 return NULL;
666 } 611 }
612
667 op = get_object (); 613 op = get_object ();
668 copy_object (&at->clone, op); 614 copy_object (&at->clone, op);
615 op->arch = at;
669 op->instantiate (); 616 op->instantiate ();
670 op->arch = at;
671 return op; 617 return op;
672} 618}
673 619
674/* 620/*
675 * Creates an object. This function is called by get_archetype() 621 * Creates an object. This function is called by get_archetype()
… …
679 */ 625 */
680 626
681object * 627object *
682create_singularity (const char *name) 628create_singularity (const char *name)
683{ 629{
684 object * 630 object *op;
685 op;
686 char
687 buf[MAX_BUF]; 631 char buf[MAX_BUF];
632
688 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name); 633 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
689 op = get_object (); 634 op = get_object ();
690 op->name = op->name_pl = buf; 635 op->name = op->name_pl = buf;
691 SET_FLAG (op, FLAG_NO_PICK); 636 SET_FLAG (op, FLAG_NO_PICK);
692 return op; 637 return op;
… …
698 */ 643 */
699 644
700object * 645object *
701get_archetype (const char *name) 646get_archetype (const char *name)
702{ 647{
703 archetype * 648 archetype *at = archetype::find (name);
704 at; 649
705 at = find_archetype (name); 650 if (!at)
706 if (at == NULL)
707 return create_singularity (name); 651 return create_singularity (name);
652
708 return arch_to_object (at); 653 return arch_to_object (at);
709} 654}
710 655
711/* 656/*
712 * Hash-function used by the arch-hashtable. 657 * Hash-function used by the arch-hashtable.
713 */ 658 */
714 659
715unsigned long 660unsigned long
716hasharch (const char *str, int tablesize) 661hasharch (const char *str, int tablesize)
717{ 662{
718 unsigned long 663 unsigned long hash = 0;
719 hash = 0;
720 unsigned int 664 unsigned int i = 0;
721 i = 0;
722 const char * 665 const char *p;
723 p;
724 666
725 /* use the one-at-a-time hash function, which supposedly is 667 /* use the one-at-a-time hash function, which supposedly is
726 * better than the djb2-like one used by perl5.005, but 668 * better than the djb2-like one used by perl5.005, but
727 * certainly is better then the bug used here before. 669 * certainly is better then the bug used here before.
728 * see http://burtleburtle.net/bob/hash/doobs.html 670 * see http://burtleburtle.net/bob/hash/doobs.html
… …
745 * Finds, using the hashtable, which archetype matches the given name. 687 * Finds, using the hashtable, which archetype matches the given name.
746 * returns a pointer to the found archetype, otherwise NULL. 688 * returns a pointer to the found archetype, otherwise NULL.
747 */ 689 */
748 690
749archetype * 691archetype *
750find_archetype (const char *name) 692archetype::find (const char *name)
751{ 693{
752#if USE_UNORDERED_MAP
753 name = shstr::find (name);
754
755 if (!name) 694 if (!name)
756 return 0; 695 return 0;
757 696
758 HT::const_iterator i = ht.find ((size_t)name); 697#if USE_UNORDERED_MAP
698 AUTODECL (i, ht.find ((size_t) name));
759 699
760 if (i == ht.end ()) 700 if (i == ht.end ())
761 return 0; 701 return 0;
762 else 702 else
763 return i->second; 703 return i->second;
764#endif 704#endif
765 705
766 archetype *at; 706 archetype *at;
767 unsigned long index; 707 unsigned long index;
768 708
769 if (name == NULL)
770 return (archetype *) NULL;
771
772 index = hasharch (name, ARCHTABLE); 709 index = hasharch (name, ARCHTABLE);
773 arch_search++; 710 arch_search++;
774 for (;;) 711 for (;;)
775 { 712 {
776 at = arch_table[index]; 713 at = arch_table[index];
714
777 if (at == NULL) 715 if (at == NULL)
778 { 716 {
779 if (warn_archetypes) 717 if (warn_archetypes)
780 LOG (llevError, "Couldn't find archetype %s\n", name); 718 LOG (llevError, "Couldn't find archetype %s\n", name);
719
781 return NULL; 720 return NULL;
782 } 721 }
722
783 arch_cmp++; 723 arch_cmp++;
724
784 if (!strcmp ((const char *) at->name, name)) 725 if (!strcmp ((const char *) at->name, name))
785 return at; 726 return at;
727
786 if (++index >= ARCHTABLE) 728 if (++index >= ARCHTABLE)
787 index = 0; 729 index = 0;
788 } 730 }
789} 731}
790 732
… …
794 736
795static void 737static void
796add_arch (archetype *at) 738add_arch (archetype *at)
797{ 739{
798#if USE_UNORDERED_MAP 740#if USE_UNORDERED_MAP
799 ht.insert (std::make_pair ((size_t)(const char *)at->name, at)); 741 ht.insert (std::make_pair ((size_t) (const char *) at->name, at));
800#endif 742#endif
801 743
802 int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index; 744 int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;
803 745
804 for (;;) 746 for (;;)
… …
823 */ 765 */
824 766
825archetype * 767archetype *
826type_to_archetype (int type) 768type_to_archetype (int type)
827{ 769{
828 archetype * 770 archetype *at;
829 at;
830 771
831 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more) 772 for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
832 if (at->clone.type == type) 773 if (at->clone.type == type)
833 return at; 774 return at;
775
834 return NULL; 776 return 0;
835} 777}
836 778
837/* 779/*
838 * Returns a new object copied from the first archetype matching 780 * Returns a new object copied from the first archetype matching
839 * the given type. 781 * the given type.
… …
841 */ 783 */
842 784
843object * 785object *
844clone_arch (int type) 786clone_arch (int type)
845{ 787{
846 archetype * 788 archetype *at;
847 at;
848 object *
849 op = get_object (); 789 object *op = get_object ();
850 790
851 if ((at = type_to_archetype (type)) == NULL) 791 if ((at = type_to_archetype (type)) == NULL)
852 { 792 {
853 LOG (llevError, "Can't clone archetype %d\n", type); 793 LOG (llevError, "Can't clone archetype %d\n", type);
854 free_object (op); 794 free_object (op);
855 return NULL; 795 return NULL;
856 } 796 }
797
857 copy_object (&at->clone, op); 798 copy_object (&at->clone, op);
858 op->instantiate (); 799 op->instantiate ();
859 return op; 800 return op;
860} 801}
861 802
862/* 803/*
863 * member: make instance from class 804 * member: make instance from class
864 */ 805 */
865 806
866object * 807object *
867object_create_arch (archetype * at) 808object_create_arch (archetype *at)
868{ 809{
869 object * 810 object *op, *prev = 0, *head = 0;
870 op, *
871 prev = NULL, *head = NULL;
872 811
873 while (at) 812 while (at)
874 { 813 {
875 op = arch_to_object (at); 814 op = arch_to_object (at);
876 op->x = at->clone.x; 815 op->x = at->clone.x;
877 op->y = at->clone.y; 816 op->y = at->clone.y;
817
878 if (head) 818 if (head)
879 op->head = head, prev->more = op; 819 op->head = head, prev->more = op;
820
880 if (!head) 821 if (!head)
881 head = op; 822 head = op;
823
882 prev = op; 824 prev = op;
883 at = at->more; 825 at = at->more;
884 } 826 }
827
885 return (head); 828 return (head);
886} 829}
887 830
888/*** end of arch.c ***/

Diff Legend

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