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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.28 by root, Mon Sep 11 12:10:21 2006 UTC vs.
Revision 1.46 by root, Thu Sep 14 21:16:11 2006 UTC

1
1/* 2/*
2 CrossFire, A Multiplayer game for X-windows 3 CrossFire, A Multiplayer game for X-windows
3 4
4 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 5 Copyright (C) 2001 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 Copyright (C) 1992 Frank Tore Johansen
… …
28#include <stdio.h> 29#include <stdio.h>
29#include <sys/types.h> 30#include <sys/types.h>
30#include <sys/uio.h> 31#include <sys/uio.h>
31#include <object.h> 32#include <object.h>
32#include <funcpoint.h> 33#include <funcpoint.h>
33#include <skills.h>
34#include <loader.h> 34#include <loader.h>
35 35
36int nrofallocobjects = 0; 36int nrofallocobjects = 0;
37static UUID uuid;
38const uint64 UUID_SKIP = 1<<19;
37 39
38object *objects; /* Pointer to the list of used objects */
39object *active_objects; /* List of active objects that need to be processed */ 40object *active_objects; /* List of active objects that need to be processed */
40 41
41short freearr_x[SIZEOFFREE] = { 0, 0, 1, 1, 1, 0, -1, -1, -1, 0, 1, 2, 2, 2, 2, 2, 1, 0, -1, -2, -2, -2, -2, -2, -1, 42short freearr_x[SIZEOFFREE] = { 0, 0, 1, 1, 1, 0, -1, -1, -1, 0, 1, 2, 2, 2, 2, 2, 1, 0, -1, -2, -2, -2, -2, -2, -1,
42 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3, -3, -3, -3, -3, -2, -1 43 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3, -3, -3, -3, -3, -2, -1
43}; 44};
… …
49}; 50};
50int freedir[SIZEOFFREE] = { 51int freedir[SIZEOFFREE] = {
51 0, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 2, 2, 3, 4, 4, 4, 5, 6, 6, 6, 7, 8, 8, 8, 52 0, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 2, 2, 3, 4, 4, 4, 5, 6, 6, 6, 7, 8, 8, 8,
52 1, 2, 2, 2, 2, 2, 3, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 7, 8, 8, 8, 8, 8 53 1, 2, 2, 2, 2, 2, 3, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 7, 8, 8, 8, 8, 8
53}; 54};
55
56static void
57write_uuid (void)
58{
59 char filename1[MAX_BUF], filename2[MAX_BUF];
60
61 sprintf (filename1, "%s/uuid", settings.localdir);
62 sprintf (filename2, "%s/uuid~", settings.localdir);
63
64 FILE *fp;
65
66 if (!(fp = fopen (filename2, "w")))
67 {
68 LOG (llevError, "ERROR: cannot open %s for writing, unable to write UUID!\n", filename2);
69 return;
70 }
71
72 fprintf (fp, "<1,%llx>\n", (unsigned long long)uuid.seq + UUID_SKIP * 2);
73 fclose (fp);
74 rename (filename2, filename1);
75}
76
77static void
78read_uuid (void)
79{
80 char filename[MAX_BUF];
81
82 sprintf (filename, "%s/uuid", settings.localdir);
83
84 FILE *fp;
85
86 if (!(fp = fopen (filename, "r")))
87 {
88 if (errno == ENOENT)
89 {
90 LOG (llevInfo, "RESET uid to 1\n");
91 uuid.seq = 0;
92 write_uuid ();
93 return;
94 }
95
96 LOG (llevError, "FATAL: cannot open %s for reading!\n", filename);
97 _exit (1);
98 }
99
100 int version;
101 unsigned long long uid;
102 if (2 != fscanf (fp, "<%d,%llx>\n", &version, &uid) || version != 1)
103 {
104 LOG (llevError, "FATAL: error reading uid from %s!\n", filename);
105 _exit (1);
106 }
107
108 uuid.seq = uid;
109 write_uuid ();
110 LOG (llevDebug, "read UID: %lld\n", uid);
111 fclose (fp);
112}
113
114UUID
115gen_uuid ()
116{
117 UUID uid;
118
119 uid.seq = ++uuid.seq;
120
121 if (!(uuid.seq & (UUID_SKIP - 1)))
122 write_uuid ();
123
124 return uid;
125}
126
127void
128init_uuid ()
129{
130 read_uuid ();
131}
54 132
55/* Returns TRUE if every key_values in wants has a partner with the same value in has. */ 133/* Returns TRUE if every key_values in wants has a partner with the same value in has. */
56static int 134static int
57compare_ob_value_lists_one (const object *wants, const object *has) 135compare_ob_value_lists_one (const object *wants, const object *has)
58{ 136{
… …
207 if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && FABS ((ob1)->speed) > MIN_ACTIVE_SPEED) 285 if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && FABS ((ob1)->speed) > MIN_ACTIVE_SPEED)
208 return 0; 286 return 0;
209 287
210 switch (ob1->type) 288 switch (ob1->type)
211 { 289 {
212 case SCROLL: 290 case SCROLL:
213 if (ob1->level != ob2->level) 291 if (ob1->level != ob2->level)
214 return 0; 292 return 0;
215 break; 293 break;
216 } 294 }
217 295
218 if (ob1->key_values != NULL || ob2->key_values != NULL) 296 if (ob1->key_values != NULL || ob2->key_values != NULL)
219 { 297 {
220 /* At least one of these has key_values. */ 298 /* At least one of these has key_values. */
… …
254 { 332 {
255 if (inv->inv) 333 if (inv->inv)
256 sum_weight (inv); 334 sum_weight (inv);
257 sum += inv->carrying + inv->weight * (inv->nrof ? inv->nrof : 1); 335 sum += inv->carrying + inv->weight * (inv->nrof ? inv->nrof : 1);
258 } 336 }
337
259 if (op->type == CONTAINER && op->stats.Str) 338 if (op->type == CONTAINER && op->stats.Str)
260 sum = (sum * (100 - op->stats.Str)) / 100; 339 sum = (sum * (100 - op->stats.Str)) / 100;
340
261 if (op->carrying != sum) 341 if (op->carrying != sum)
262 op->carrying = sum; 342 op->carrying = sum;
343
263 return sum; 344 return sum;
264} 345}
265 346
266/** 347/**
267 * Return the outermost environment object for a given object. 348 * Return the outermost environment object for a given object.
… …
365void 446void
366dump_all_objects (void) 447dump_all_objects (void)
367{ 448{
368 object *op; 449 object *op;
369 450
370 for (op = objects; op != NULL; op = op->next) 451 for (op = object::first; op != NULL; op = op->next)
371 { 452 {
372 dump_object (op); 453 dump_object (op);
373 fprintf (logfile, "Object %d\n:%s\n", op->count, errmsg); 454 fprintf (logfile, "Object %d\n:%s\n", op->count, errmsg);
374 } 455 }
375} 456}
… …
401object * 482object *
402find_object (tag_t i) 483find_object (tag_t i)
403{ 484{
404 object *op; 485 object *op;
405 486
406 for (op = objects; op != NULL; op = op->next) 487 for (op = object::first; op != NULL; op = op->next)
407 if (op->count == i) 488 if (op->count == i)
408 break; 489 break;
409 return op; 490 return op;
410} 491}
411 492
… …
416 */ 497 */
417 498
418object * 499object *
419find_object_name (const char *str) 500find_object_name (const char *str)
420{ 501{
421 const char *name = shstr::find (str); 502 shstr_cmp str_ (str);
422 object *op; 503 object *op;
423 504
424 for (op = objects; op != NULL; op = op->next) 505 for (op = object::first; op != NULL; op = op->next)
425 if (&op->name == name) 506 if (op->name == str_)
426 break; 507 break;
427 508
428 return op; 509 return op;
429} 510}
430 511
… …
433{ 514{
434 LOG (llevDebug, "%d allocated objects\n", nrofallocobjects); 515 LOG (llevDebug, "%d allocated objects\n", nrofallocobjects);
435} 516}
436 517
437/* 518/*
438 * Returns the object which this object marks as being the owner.
439 * A id-scheme is used to avoid pointing to objects which have been
440 * freed and are now reused. If this is detected, the owner is
441 * set to NULL, and NULL is returned.
442 * Changed 2004-02-12 - if the player is setting at the play again
443 * prompt, he is removed, and we don't want to treat him as an owner of
444 * anything, so check removed flag. I don't expect that this should break
445 * anything - once an object is removed, it is basically dead anyways.
446 */
447
448object *
449get_owner (object *op)
450{
451 if (op->owner == NULL)
452 return NULL;
453
454 if (!QUERY_FLAG (op->owner, FLAG_FREED) && !QUERY_FLAG (op->owner, FLAG_REMOVED) && op->owner->count == op->ownercount)
455 return op->owner;
456
457 op->owner = NULL;
458 op->ownercount = 0;
459 return NULL;
460}
461
462void
463clear_owner (object *op)
464{
465 if (!op)
466 return;
467
468 if (op->owner && op->ownercount == op->owner->count)
469 op->owner->refcount--;
470
471 op->owner = NULL;
472 op->ownercount = 0;
473}
474
475/*
476 * Sets the owner and sets the skill and exp pointers to owner's current 519 * Sets the owner and sets the skill and exp pointers to owner's current
477 * skill and experience objects. 520 * skill and experience objects.
478 */ 521 */
479void 522void
480set_owner (object *op, object *owner) 523object::set_owner (object *owner)
481{ 524{
482 if (owner == NULL || op == NULL) 525 if (!owner)
483 return; 526 return;
484 527
485 /* next line added to allow objects which own objects */ 528 /* next line added to allow objects which own objects */
486 /* Add a check for ownercounts in here, as I got into an endless loop 529 /* Add a check for ownercounts in here, as I got into an endless loop
487 * with the fireball owning a poison cloud which then owned the 530 * with the fireball owning a poison cloud which then owned the
488 * fireball. I believe that was caused by one of the objects getting 531 * fireball. I believe that was caused by one of the objects getting
489 * freed and then another object replacing it. Since the ownercounts 532 * freed and then another object replacing it. Since the ownercounts
490 * didn't match, this check is valid and I believe that cause is valid. 533 * didn't match, this check is valid and I believe that cause is valid.
491 */ 534 */
492 while (owner->owner && owner != owner->owner && owner->ownercount == owner->owner->count) 535 while (owner->owner)
493 owner = owner->owner; 536 owner = owner->owner;
494 537
495 /* IF the owner still has an owner, we did not resolve to a final owner.
496 * so lets not add to that.
497 */
498 if (owner->owner)
499 return;
500
501 op->owner = owner; 538 this->owner = owner;
502
503 op->ownercount = owner->count;
504 owner->refcount++;
505}
506
507/* Set the owner to clone's current owner and set the skill and experience
508 * objects to clone's objects (typically those objects that where the owner's
509 * current skill and experience objects at the time when clone's owner was
510 * set - not the owner's current skill and experience objects).
511 *
512 * Use this function if player created an object (e.g. fire bullet, swarm
513 * spell), and this object creates further objects whose kills should be
514 * accounted for the player's original skill, even if player has changed
515 * skills meanwhile.
516 */
517void
518copy_owner (object *op, object *clone)
519{
520 object *owner = get_owner (clone);
521
522 if (owner == NULL)
523 {
524 /* players don't have owners - they own themselves. Update
525 * as appropriate.
526 */
527 if (clone->type == PLAYER)
528 owner = clone;
529 else
530 return;
531 }
532
533 set_owner (op, owner);
534} 539}
535 540
536/* Zero the key_values on op, decrementing the shared-string 541/* Zero the key_values on op, decrementing the shared-string
537 * refcounts and freeing the links. 542 * refcounts and freeing the links.
538 */ 543 */
… …
554{ 559{
555 attachable_base::clear (); 560 attachable_base::clear ();
556 561
557 free_key_values (this); 562 free_key_values (this);
558 563
559 clear_owner (this); 564 owner = 0;
560
561 name = 0; 565 name = 0;
562 name_pl = 0; 566 name_pl = 0;
563 title = 0; 567 title = 0;
564 race = 0; 568 race = 0;
565 slaying = 0; 569 slaying = 0;
566 skill = 0; 570 skill = 0;
567 msg = 0; 571 msg = 0;
568 lore = 0; 572 lore = 0;
569 custom_name = 0; 573 custom_name = 0;
570 materialname = 0; 574 materialname = 0;
575 contr = 0;
576 below = 0;
577 above = 0;
578 inv = 0;
579 container = 0;
580 env = 0;
581 more = 0;
582 head = 0;
583 map = 0;
584 active_next = 0;
585 active_prev = 0;
571 586
572 memset (static_cast < object_pod * >(this), 0, sizeof (object_pod)); 587 memset (static_cast<object_pod *>(this), 0, sizeof (object_pod));
573 588
574 SET_FLAG (this, FLAG_REMOVED); 589 SET_FLAG (this, FLAG_REMOVED);
590
591 /* What is not cleared is next, prev, and count */
592
593 expmul = 1.0;
594 face = blank_face;
595
596 if (settings.casting_time)
597 casting_time = -1;
575} 598}
576 599
577void object::clone (object *destination) 600void object::clone (object *destination)
578{ 601{
579 *(object_copy *) destination = *this; 602 *(object_copy *)destination = *this;
580 *(object_pod *) destination = *this; 603 *(object_pod *)destination = *this;
581 604
582 if (self || cb) 605 if (self || cb)
583 INVOKE_OBJECT (CLONE, this, ARG_OBJECT (destination)); 606 INVOKE_OBJECT (CLONE, this, ARG_OBJECT (destination));
584}
585
586/*
587 * clear_object() frees everything allocated by an object, and also
588 * clears all variables and flags to default settings.
589 */
590
591void
592clear_object (object *op)
593{
594 op->clear ();
595
596 op->contr = NULL;
597 op->below = NULL;
598 op->above = NULL;
599 op->inv = NULL;
600 op->container = NULL;
601 op->env = NULL;
602 op->more = NULL;
603 op->head = NULL;
604 op->map = NULL;
605 op->refcount = 0;
606 op->active_next = NULL;
607 op->active_prev = NULL;
608 /* What is not cleared is next, prev, and count */
609
610 op->expmul = 1.0;
611 op->face = blank_face;
612 op->attacked_by_count = -1;
613
614 if (settings.casting_time)
615 op->casting_time = -1;
616} 607}
617 608
618/* 609/*
619 * copy object first frees everything allocated by the second object, 610 * copy object first frees everything allocated by the second object,
620 * and then copies the contends of the first object into the second 611 * and then copies the contends of the first object into the second
621 * object, allocating what needs to be allocated. Basically, any 612 * object, allocating what needs to be allocated. Basically, any
622 * data that is malloc'd needs to be re-malloc/copied. Otherwise, 613 * data that is malloc'd needs to be re-malloc/copied. Otherwise,
623 * if the first object is freed, the pointers in the new object 614 * if the first object is freed, the pointers in the new object
624 * will point at garbage. 615 * will point at garbage.
625 */ 616 */
626
627void 617void
628copy_object (object *op2, object *op) 618copy_object (object *op2, object *op)
629{ 619{
630 bool is_freed = QUERY_FLAG (op, FLAG_FREED); 620 bool is_freed = QUERY_FLAG (op, FLAG_FREED);
631 bool is_removed = QUERY_FLAG (op, FLAG_REMOVED); 621 bool is_removed = QUERY_FLAG (op, FLAG_REMOVED);
… …
691/* 681/*
692 * Updates the speed of an object. If the speed changes from 0 to another 682 * Updates the speed of an object. If the speed changes from 0 to another
693 * value, or vice versa, then add/remove the object from the active list. 683 * value, or vice versa, then add/remove the object from the active list.
694 * This function needs to be called whenever the speed of an object changes. 684 * This function needs to be called whenever the speed of an object changes.
695 */ 685 */
696
697void 686void
698update_ob_speed (object *op) 687update_ob_speed (object *op)
699{ 688{
700 extern int arch_init; 689 extern int arch_init;
701 690
… …
710 abort (); 699 abort ();
711#else 700#else
712 op->speed = 0; 701 op->speed = 0;
713#endif 702#endif
714 } 703 }
704
715 if (arch_init) 705 if (arch_init)
716 {
717 return; 706 return;
718 } 707
719 if (FABS (op->speed) > MIN_ACTIVE_SPEED) 708 if (FABS (op->speed) > MIN_ACTIVE_SPEED)
720 { 709 {
721 /* If already on active list, don't do anything */ 710 /* If already on active list, don't do anything */
722 if (op->active_next || op->active_prev || op == active_objects) 711 if (op->active_next || op->active_prev || op == active_objects)
723 return; 712 return;
724 713
725 /* process_events() expects us to insert the object at the beginning 714 /* process_events() expects us to insert the object at the beginning
726 * of the list. */ 715 * of the list. */
727 op->active_next = active_objects; 716 op->active_next = active_objects;
717
728 if (op->active_next != NULL) 718 if (op->active_next != NULL)
729 op->active_next->active_prev = op; 719 op->active_next->active_prev = op;
720
730 active_objects = op; 721 active_objects = op;
731 } 722 }
732 else 723 else
733 { 724 {
734 /* If not on the active list, nothing needs to be done */ 725 /* If not on the active list, nothing needs to be done */
… …
736 return; 727 return;
737 728
738 if (op->active_prev == NULL) 729 if (op->active_prev == NULL)
739 { 730 {
740 active_objects = op->active_next; 731 active_objects = op->active_next;
732
741 if (op->active_next != NULL) 733 if (op->active_next != NULL)
742 op->active_next->active_prev = NULL; 734 op->active_next->active_prev = NULL;
743 } 735 }
744 else 736 else
745 { 737 {
746 op->active_prev->active_next = op->active_next; 738 op->active_prev->active_next = op->active_next;
739
747 if (op->active_next) 740 if (op->active_next)
748 op->active_next->active_prev = op->active_prev; 741 op->active_next->active_prev = op->active_prev;
749 } 742 }
743
750 op->active_next = NULL; 744 op->active_next = NULL;
751 op->active_prev = NULL; 745 op->active_prev = NULL;
752 } 746 }
753} 747}
754 748
… …
886 * that is being removed. 880 * that is being removed.
887 */ 881 */
888 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE) 882 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE)
889 update_now = 1; 883 update_now = 1;
890 else if (action == UP_OBJ_FACE) 884 else if (action == UP_OBJ_FACE)
891 /* Nothing to do for that case */; 885 /* Nothing to do for that case */ ;
892 else 886 else
893 LOG (llevError, "update_object called with invalid action: %d\n", action); 887 LOG (llevError, "update_object called with invalid action: %d\n", action);
894 888
895 if (update_now) 889 if (update_now)
896 { 890 {
… …
900 894
901 if (op->more != NULL) 895 if (op->more != NULL)
902 update_object (op->more, action); 896 update_object (op->more, action);
903} 897}
904 898
905static unordered_vector<object *> mortals; 899object::vector object::mortals;
906static std::vector<object *> freed; 900object::vector object::objects; // not yet used
901object *object::first;
907 902
908void object::free_mortals () 903void object::free_mortals ()
909{ 904{
910 for (unordered_vector<object *>::iterator i = mortals.begin (); i != mortals.end (); ) 905 for (AUTODECL (i, mortals.begin ()); i != mortals.end ();)
911 if (!(*i)->refcount) 906 if ((*i)->refcnt)
907 ++i; // further delay freeing
908 else
912 { 909 {
913 freed.push_back (*i); 910 delete *i;
914 mortals.erase (i); 911 mortals.erase (i);
915 } 912 }
916 else 913
917 ++i; 914 static int lastmortals = 0;//D
915
916 if (mortals.size() != lastmortals)//D
917 {
918 lastmortals = mortals.size ();//D
919 LOG (llevDebug, "%d objects in mortal queue\n", lastmortals);//D
920 }
918} 921}
919 922
920object::object () 923object::object ()
921{ 924{
922 SET_FLAG (this, FLAG_REMOVED); 925 SET_FLAG (this, FLAG_REMOVED);
923 926
924 expmul = 1.0; 927 expmul = 1.0;
925 face = blank_face; 928 face = blank_face;
926 attacked_by_count = -1;
927} 929}
928 930
929object::~object () 931object::~object ()
930{ 932{
931 free_key_values (this); 933 free_key_values (this);
932} 934}
933 935
934void object::link () 936void object::link ()
935{ 937{
936 count = ++ob_count; 938 count = ++ob_count;
939 uuid = gen_uuid ();
937 940
938 prev = 0; 941 prev = 0;
939 next = objects; 942 next = object::first;
940 943
941 if (objects) 944 if (object::first)
942 objects->prev = this; 945 object::first->prev = this;
943 946
944 objects = this; 947 object::first = this;
945} 948}
946 949
947void object::unlink () 950void object::unlink ()
948{ 951{
949 count = 0; 952 //count = 0;//D
953 if (!prev && !next) return;//D
954
955 if (this == object::first)
956 object::first = next;
950 957
951 /* Remove this object from the list of used objects */ 958 /* Remove this object from the list of used objects */
952 if (prev)
953 {
954 prev->next = next; 959 if (prev) prev->next = next;
960 if (next) next->prev = prev;
961
955 prev = 0; 962 prev = 0;
956 }
957
958 if (next)
959 {
960 next->prev = prev;
961 next = 0; 963 next = 0;
962 }
963
964 if (this == objects)
965 objects = next;
966} 964}
967 965
968object *object::create () 966object *object::create ()
969{ 967{
970 object *op;
971
972 if (freed.empty ())
973 op = new object; 968 object *op = new object;
974 else
975 {
976 // highly annoying, but the only way to get it stable right now
977 op = freed.back (); freed.pop_back ();
978 op->~object ();
979 new ((void *)op) object;
980 }
981
982 op->link (); 969 op->link ();
983 return op; 970 return op;
984} 971}
985 972
986/* 973/*
… …
993 * If free_inventory is set, free inventory as well. Else drop items in 980 * If free_inventory is set, free inventory as well. Else drop items in
994 * inventory to the ground. 981 * inventory to the ground.
995 */ 982 */
996void object::free (bool free_inventory) 983void object::free (bool free_inventory)
997{ 984{
985 if (QUERY_FLAG (this, FLAG_FREED))
986 return;
987
988 if (QUERY_FLAG (this, FLAG_FRIENDLY))
989 remove_friendly_object (this);
990
998 if (!QUERY_FLAG (this, FLAG_REMOVED)) 991 if (!QUERY_FLAG (this, FLAG_REMOVED))
999 { 992 remove_ob (this);
1000 LOG (llevDebug, "Free object called with non removed object\n");
1001 dump_object (this);
1002#ifdef MANY_CORES
1003 abort ();
1004#endif
1005 }
1006 993
1007 if (QUERY_FLAG (this, FLAG_FRIENDLY))
1008 {
1009 LOG (llevMonster, "Warning: tried to free friendly object.\n");
1010 remove_friendly_object (this);
1011 }
1012
1013 if (QUERY_FLAG (this, FLAG_FREED)) 994 SET_FLAG (this, FLAG_FREED);
1014 {
1015 dump_object (this);
1016 LOG (llevError, "Trying to free freed object.\n%s\n", errmsg);
1017 return;
1018 }
1019 995
1020 if (more) 996 if (more)
1021 { 997 {
1022 more->free (free_inventory); 998 more->free (free_inventory);
1023 more = 0; 999 more = 0;
… …
1027 { 1003 {
1028 /* Only if the space blocks everything do we not process - 1004 /* Only if the space blocks everything do we not process -
1029 * if some form of movement is allowed, let objects 1005 * if some form of movement is allowed, let objects
1030 * drop on that space. 1006 * drop on that space.
1031 */ 1007 */
1032 if (free_inventory || !map || map->in_memory != MAP_IN_MEMORY || (GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL)) 1008 if (free_inventory || !map || map->in_memory != MAP_IN_MEMORY || GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL)
1033 { 1009 {
1034 object * 1010 object *op = inv;
1035 op = inv;
1036 1011
1037 while (op) 1012 while (op)
1038 { 1013 {
1039 object *
1040 tmp = op->below; 1014 object *tmp = op->below;
1041
1042 remove_ob (op);
1043 op->free (free_inventory); 1015 op->free (free_inventory);
1044 op = tmp; 1016 op = tmp;
1045 } 1017 }
1046 } 1018 }
1047 else 1019 else
1048 { /* Put objects in inventory onto this space */ 1020 { /* Put objects in inventory onto this space */
1049 object * 1021 object *op = inv;
1050 op = inv;
1051 1022
1052 while (op) 1023 while (op)
1053 { 1024 {
1054 object *
1055 tmp = op->below; 1025 object *tmp = op->below;
1056 1026
1057 remove_ob (op); 1027 remove_ob (op);
1058 1028
1059 if (QUERY_FLAG (op, FLAG_STARTEQUIP) 1029 if (QUERY_FLAG (op, FLAG_STARTEQUIP)
1060 || QUERY_FLAG (op, FLAG_NO_DROP) || op->type == RUNE || op->type == TRAP || QUERY_FLAG (op, FLAG_IS_A_TEMPLATE)) 1030 || QUERY_FLAG (op, FLAG_NO_DROP) || op->type == RUNE || op->type == TRAP || QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))
… …
1069 op = tmp; 1039 op = tmp;
1070 } 1040 }
1071 } 1041 }
1072 } 1042 }
1073 1043
1074 clear_owner (this); 1044 // clear those pointers that likely might have circular references to us
1045 owner = 0;
1046 enemy = 0;
1047 attacked_by = 0;
1075 1048
1076 /* Remove object from the active list */ 1049 /* Remove object from the active list */
1077 speed = 0; 1050 speed = 0;
1078 update_ob_speed (this); 1051 update_ob_speed (this);
1079 1052
1080 unlink (); 1053 unlink ();
1081 1054
1082 SET_FLAG (this, FLAG_FREED);
1083
1084 mortals.push_back (this); 1055 mortals.push_back (this);
1085} 1056}
1086 1057
1087/* 1058/*
1088 * sub_weight() recursively (outwards) subtracts a number from the 1059 * sub_weight() recursively (outwards) subtracts a number from the
… …
1093sub_weight (object *op, signed long weight) 1064sub_weight (object *op, signed long weight)
1094{ 1065{
1095 while (op != NULL) 1066 while (op != NULL)
1096 { 1067 {
1097 if (op->type == CONTAINER) 1068 if (op->type == CONTAINER)
1098 {
1099 weight = (signed long) (weight * (100 - op->stats.Str) / 100); 1069 weight = (signed long) (weight * (100 - op->stats.Str) / 100);
1100 } 1070
1101 op->carrying -= weight; 1071 op->carrying -= weight;
1102 op = op->env; 1072 op = op->env;
1103 } 1073 }
1104} 1074}
1105 1075
… …
1113 */ 1083 */
1114 1084
1115void 1085void
1116remove_ob (object *op) 1086remove_ob (object *op)
1117{ 1087{
1118 object *tmp, *last = NULL; 1088 object *tmp, *last = 0;
1119 object *otmp; 1089 object *otmp;
1120 1090
1121 tag_t tag; 1091 tag_t tag;
1122 int check_walk_off; 1092 int check_walk_off;
1123 mapstruct *m; 1093 mapstruct *m;
1124 1094
1125 sint16 x, y; 1095 sint16 x, y;
1126 1096
1127 if (QUERY_FLAG (op, FLAG_REMOVED)) 1097 if (QUERY_FLAG (op, FLAG_REMOVED))
1128 { 1098 return;
1129 dump_object (op);
1130 LOG (llevError, "Trying to remove removed object.\n%s\n", errmsg);
1131 1099
1132 /* Changed it to always dump core in this case. As has been learned 1100 SET_FLAG (op, FLAG_REMOVED);
1133 * in the past, trying to recover from errors almost always
1134 * make things worse, and this is a real error here - something
1135 * that should not happen.
1136 * Yes, if this was a mission critical app, trying to do something
1137 * to recover may make sense, but that is because failure of the app
1138 * may have other disastrous problems. Cf runs out of a script
1139 * so is easily enough restarted without any real problems.
1140 * MSW 2001-07-01
1141 */
1142 abort ();
1143 }
1144 1101
1145 if (op->more != NULL) 1102 if (op->more != NULL)
1146 remove_ob (op->more); 1103 remove_ob (op->more);
1147
1148 SET_FLAG (op, FLAG_REMOVED);
1149 1104
1150 /* 1105 /*
1151 * In this case, the object to be removed is in someones 1106 * In this case, the object to be removed is in someones
1152 * inventory. 1107 * inventory.
1153 */ 1108 */
… …
1179 */ 1134 */
1180 op->x = op->env->x, op->y = op->env->y; 1135 op->x = op->env->x, op->y = op->env->y;
1181 op->map = op->env->map; 1136 op->map = op->env->map;
1182 op->above = NULL, op->below = NULL; 1137 op->above = NULL, op->below = NULL;
1183 op->env = NULL; 1138 op->env = NULL;
1184 return; 1139 }
1140 else if (op->map)
1185 } 1141 {
1186
1187 /* If we get here, we are removing it from a map */
1188 if (op->map == NULL)
1189 return;
1190
1191 x = op->x; 1142 x = op->x;
1192 y = op->y; 1143 y = op->y;
1193 m = get_map_from_coord (op->map, &x, &y); 1144 m = get_map_from_coord (op->map, &x, &y);
1194 1145
1195 if (!m) 1146 if (!m)
1196 { 1147 {
1197 LOG (llevError, "remove_ob called when object was on map but appears to not be within valid coordinates? %s (%d,%d)\n", 1148 LOG (llevError, "remove_ob called when object was on map but appears to not be within valid coordinates? %s (%d,%d)\n",
1198 op->map->path, op->x, op->y); 1149 op->map->path, op->x, op->y);
1199 /* in old days, we used to set x and y to 0 and continue. 1150 /* in old days, we used to set x and y to 0 and continue.
1200 * it seems if we get into this case, something is probablye 1151 * it seems if we get into this case, something is probablye
1201 * screwed up and should be fixed. 1152 * screwed up and should be fixed.
1153 */
1154 abort ();
1155 }
1156
1157 if (op->map != m)
1158 LOG (llevDebug, "remove_ob: Object not really on map it claimed to be on? %s != %s, %d,%d != %d,%d\n",
1159 op->map->path, m->path, op->x, op->y, x, y);
1160
1161 /* Re did the following section of code - it looks like it had
1162 * lots of logic for things we no longer care about
1202 */ 1163 */
1203 abort ();
1204 }
1205 if (op->map != m)
1206 {
1207 LOG (llevDebug, "remove_ob: Object not really on map it claimed to be on? %s != %s, %d,%d != %d,%d\n",
1208 op->map->path, m->path, op->x, op->y, x, y);
1209 }
1210 1164
1211 /* Re did the following section of code - it looks like it had
1212 * lots of logic for things we no longer care about
1213 */
1214
1215 /* link the object above us */ 1165 /* link the object above us */
1216 if (op->above) 1166 if (op->above)
1217 op->above->below = op->below; 1167 op->above->below = op->below;
1218 else 1168 else
1219 SET_MAP_TOP (m, x, y, op->below); /* we were top, set new top */ 1169 SET_MAP_TOP (m, x, y, op->below); /* we were top, set new top */
1220 1170
1221 /* Relink the object below us, if there is one */ 1171 /* Relink the object below us, if there is one */
1222 if (op->below) 1172 if (op->below)
1223 op->below->above = op->above; 1173 op->below->above = op->above;
1224 else 1174 else
1225 { 1175 {
1226 /* Nothing below, which means we need to relink map object for this space 1176 /* Nothing below, which means we need to relink map object for this space
1227 * use translated coordinates in case some oddness with map tiling is 1177 * use translated coordinates in case some oddness with map tiling is
1228 * evident 1178 * evident
1229 */
1230 if (GET_MAP_OB (m, x, y) != op)
1231 {
1232 dump_object (op);
1233 LOG (llevError, "remove_ob: GET_MAP_OB does not return object to be removed even though it appears to be on the bottom?\n%s\n",
1234 errmsg);
1235 dump_object (GET_MAP_OB (m, x, y));
1236 LOG (llevError, "%s\n", errmsg);
1237 }
1238
1239 SET_MAP_OB (m, x, y, op->above); /* goes on above it. */
1240 }
1241
1242 op->above = NULL;
1243 op->below = NULL;
1244
1245 if (op->map->in_memory == MAP_SAVING)
1246 return;
1247
1248 tag = op->count;
1249 check_walk_off = !QUERY_FLAG (op, FLAG_NO_APPLY);
1250
1251 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
1252 {
1253 /* No point updating the players look faces if he is the object
1254 * being removed.
1255 */
1256
1257 if (tmp->type == PLAYER && tmp != op)
1258 {
1259 /* If a container that the player is currently using somehow gets
1260 * removed (most likely destroyed), update the player view
1261 * appropriately.
1262 */ 1179 */
1263 if (tmp->container == op) 1180 if (GET_MAP_OB (m, x, y) != op)
1264 { 1181 {
1265 CLEAR_FLAG (op, FLAG_APPLIED); 1182 dump_object (op);
1266 tmp->container = NULL; 1183 LOG (llevError,
1184 "remove_ob: GET_MAP_OB does not return object to be removed even though it appears to be on the bottom?\n%s\n", errmsg);
1185 dump_object (GET_MAP_OB (m, x, y));
1186 LOG (llevError, "%s\n", errmsg);
1267 } 1187 }
1268 1188
1269 tmp->contr->socket.update_look = 1; 1189 SET_MAP_OB (m, x, y, op->above); /* goes on above it. */
1270 }
1271 /* See if player moving off should effect something */
1272 if (check_walk_off && ((op->move_type & tmp->move_off) && (op->move_type & ~tmp->move_off & ~tmp->move_block) == 0))
1273 { 1190 }
1274 move_apply (tmp, op, NULL);
1275 1191
1276 if (was_destroyed (op, tag)) 1192 op->above = 0;
1193 op->below = 0;
1194
1195 if (op->map->in_memory == MAP_SAVING)
1196 return;
1197
1198 tag = op->count;
1199 check_walk_off = !QUERY_FLAG (op, FLAG_NO_APPLY);
1200
1201 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
1202 {
1203 /* No point updating the players look faces if he is the object
1204 * being removed.
1205 */
1206
1207 if (tmp->type == PLAYER && tmp != op)
1277 { 1208 {
1278 LOG (llevError, "BUG: remove_ob(): name %s, archname %s destroyed " "leaving object\n", &tmp->name, &tmp->arch->name); 1209 /* If a container that the player is currently using somehow gets
1210 * removed (most likely destroyed), update the player view
1211 * appropriately.
1212 */
1213 if (tmp->container == op)
1214 {
1215 CLEAR_FLAG (op, FLAG_APPLIED);
1216 tmp->container = NULL;
1217 }
1218
1219 tmp->contr->socket.update_look = 1;
1279 } 1220 }
1221
1222 /* See if player moving off should effect something */
1223 if (check_walk_off && ((op->move_type & tmp->move_off) && (op->move_type & ~tmp->move_off & ~tmp->move_block) == 0))
1224 {
1225 move_apply (tmp, op, NULL);
1226
1227 if (was_destroyed (op, tag))
1228 {
1229 LOG (llevError, "BUG: remove_ob(): name %s, archname %s destroyed " "leaving object\n", &tmp->name, &tmp->arch->name);
1230 }
1280 } 1231 }
1281 1232
1282 /* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */ 1233 /* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */
1283 1234
1284 if (tmp->above == tmp) 1235 if (tmp->above == tmp)
1285 tmp->above = NULL; 1236 tmp->above = NULL;
1286 1237
1287 last = tmp; 1238 last = tmp;
1288 } 1239 }
1289 1240
1290 /* last == NULL of there are no objects on this space */ 1241 /* last == NULL of there are no objects on this space */
1291 if (last == NULL) 1242 if (last == NULL)
1292 { 1243 {
1293 /* set P_NEED_UPDATE, otherwise update_position will complain. In theory, 1244 /* set P_NEED_UPDATE, otherwise update_position will complain. In theory,
1294 * we could preserve the flags (GET_MAP_FLAGS), but update_position figures 1245 * we could preserve the flags (GET_MAP_FLAGS), but update_position figures
1295 * those out anyways, and if there are any flags set right now, they won't 1246 * those out anyways, and if there are any flags set right now, they won't
1296 * be correct anyways. 1247 * be correct anyways.
1297 */ 1248 */
1298 SET_MAP_FLAGS (op->map, op->x, op->y, P_NEED_UPDATE); 1249 SET_MAP_FLAGS (op->map, op->x, op->y, P_NEED_UPDATE);
1299 update_position (op->map, op->x, op->y); 1250 update_position (op->map, op->x, op->y);
1300 } 1251 }
1301 else 1252 else
1302 update_object (last, UP_OBJ_REMOVE); 1253 update_object (last, UP_OBJ_REMOVE);
1303 1254
1304 if (QUERY_FLAG (op, FLAG_BLOCKSVIEW) || (op->glow_radius != 0)) 1255 if (QUERY_FLAG (op, FLAG_BLOCKSVIEW) || (op->glow_radius != 0))
1305 update_all_los (op->map, op->x, op->y); 1256 update_all_los (op->map, op->x, op->y);
1257 }
1306} 1258}
1307 1259
1308/* 1260/*
1309 * merge_ob(op,top): 1261 * merge_ob(op,top):
1310 * 1262 *
1311 * This function goes through all objects below and including top, and 1263 * This function goes through all objects below and including top, and
1312 * merges op to the first matching object. 1264 * merges op to the first matching object.
1313 * If top is NULL, it is calculated. 1265 * If top is NULL, it is calculated.
1314 * Returns pointer to object if it succeded in the merge, otherwise NULL 1266 * Returns pointer to object if it succeded in the merge, otherwise NULL
1315 */ 1267 */
1316
1317object * 1268object *
1318merge_ob (object *op, object *top) 1269merge_ob (object *op, object *top)
1319{ 1270{
1320 if (!op->nrof) 1271 if (!op->nrof)
1321 return 0; 1272 return 0;
1273
1322 if (top == NULL) 1274 if (top == NULL)
1323 for (top = op; top != NULL && top->above != NULL; top = top->above); 1275 for (top = op; top != NULL && top->above != NULL; top = top->above);
1276
1324 for (; top != NULL; top = top->below) 1277 for (; top != NULL; top = top->below)
1325 { 1278 {
1326 if (top == op) 1279 if (top == op)
1327 continue; 1280 continue;
1328 if (CAN_MERGE (op, top)) 1281 if (CAN_MERGE (op, top))
… …
1334 remove_ob (op); 1287 remove_ob (op);
1335 free_object (op); 1288 free_object (op);
1336 return top; 1289 return top;
1337 } 1290 }
1338 } 1291 }
1292
1339 return NULL; 1293 return 0;
1340} 1294}
1341 1295
1342/* 1296/*
1343 * same as insert_ob_in_map except it handle separate coordinates and do a clean 1297 * same as insert_ob_in_map except it handle separate coordinates and do a clean
1344 * job preparing multi-part monsters 1298 * job preparing multi-part monsters
1345 */ 1299 */
1346object * 1300object *
1347insert_ob_in_map_at (object *op, mapstruct *m, object *originator, int flag, int x, int y) 1301insert_ob_in_map_at (object *op, mapstruct *m, object *originator, int flag, int x, int y)
1348{ 1302{
1349 object * 1303 object *tmp;
1350 tmp;
1351 1304
1352 if (op->head) 1305 if (op->head)
1353 op = op->head; 1306 op = op->head;
1307
1354 for (tmp = op; tmp; tmp = tmp->more) 1308 for (tmp = op; tmp; tmp = tmp->more)
1355 { 1309 {
1356 tmp->x = x + tmp->arch->clone.x; 1310 tmp->x = x + tmp->arch->clone.x;
1357 tmp->y = y + tmp->arch->clone.y; 1311 tmp->y = y + tmp->arch->clone.y;
1358 } 1312 }
1313
1359 return insert_ob_in_map (op, m, originator, flag); 1314 return insert_ob_in_map (op, m, originator, flag);
1360} 1315}
1361 1316
1362/* 1317/*
1363 * insert_ob_in_map (op, map, originator, flag): 1318 * insert_ob_in_map (op, map, originator, flag):
… …
1654 * op is the object to insert it under: supplies x and the map. 1609 * op is the object to insert it under: supplies x and the map.
1655 */ 1610 */
1656void 1611void
1657replace_insert_ob_in_map (const char *arch_string, object *op) 1612replace_insert_ob_in_map (const char *arch_string, object *op)
1658{ 1613{
1659 object *tmp; 1614 object *
1615 tmp;
1660 object *tmp1; 1616 object *
1617 tmp1;
1661 1618
1662 /* first search for itself and remove any old instances */ 1619 /* first search for itself and remove any old instances */
1663 1620
1664 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 1621 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
1665 { 1622 {
… …
1668 remove_ob (tmp); 1625 remove_ob (tmp);
1669 free_object (tmp); 1626 free_object (tmp);
1670 } 1627 }
1671 } 1628 }
1672 1629
1673 tmp1 = arch_to_object (find_archetype (arch_string)); 1630 tmp1 = arch_to_object (archetype::find (arch_string));
1674 1631
1675 tmp1->x = op->x; 1632 tmp1->x = op->x;
1676 tmp1->y = op->y; 1633 tmp1->y = op->y;
1677 insert_ob_in_map (tmp1, op->map, op, 0); 1634 insert_ob_in_map (tmp1, op->map, op, 0);
1678} 1635}
… …
1696 if (orig_ob->nrof < nr) 1653 if (orig_ob->nrof < nr)
1697 { 1654 {
1698 sprintf (errmsg, "There are only %d %ss.", orig_ob->nrof ? orig_ob->nrof : 1, &orig_ob->name); 1655 sprintf (errmsg, "There are only %d %ss.", orig_ob->nrof ? orig_ob->nrof : 1, &orig_ob->name);
1699 return NULL; 1656 return NULL;
1700 } 1657 }
1658
1701 newob = object_create_clone (orig_ob); 1659 newob = object_create_clone (orig_ob);
1660
1702 if ((orig_ob->nrof -= nr) < 1) 1661 if ((orig_ob->nrof -= nr) < 1)
1703 { 1662 {
1704 if (!is_removed) 1663 if (!is_removed)
1705 remove_ob (orig_ob); 1664 remove_ob (orig_ob);
1706 free_object2 (orig_ob, 1); 1665 free_object2 (orig_ob, 1);
… …
1714 strcpy (errmsg, "Tried to split object whose map is not in memory."); 1673 strcpy (errmsg, "Tried to split object whose map is not in memory.");
1715 LOG (llevDebug, "Error, Tried to split object whose map is not in memory.\n"); 1674 LOG (llevDebug, "Error, Tried to split object whose map is not in memory.\n");
1716 return NULL; 1675 return NULL;
1717 } 1676 }
1718 } 1677 }
1678
1719 newob->nrof = nr; 1679 newob->nrof = nr;
1720 1680
1721 return newob; 1681 return newob;
1722} 1682}
1723 1683
… …
1730 */ 1690 */
1731 1691
1732object * 1692object *
1733decrease_ob_nr (object *op, uint32 i) 1693decrease_ob_nr (object *op, uint32 i)
1734{ 1694{
1735 object * 1695 object *tmp;
1736 tmp;
1737 player * 1696 player *pl;
1738 pl;
1739 1697
1740 if (i == 0) /* objects with op->nrof require this check */ 1698 if (i == 0) /* objects with op->nrof require this check */
1741 return op; 1699 return op;
1742 1700
1743 if (i > op->nrof) 1701 if (i > op->nrof)
1744 i = op->nrof; 1702 i = op->nrof;
1745 1703
1746 if (QUERY_FLAG (op, FLAG_REMOVED)) 1704 if (QUERY_FLAG (op, FLAG_REMOVED))
1747 {
1748 op->nrof -= i; 1705 op->nrof -= i;
1749 }
1750 else if (op->env != NULL) 1706 else if (op->env != NULL)
1751 { 1707 {
1752 /* is this object in the players inventory, or sub container 1708 /* is this object in the players inventory, or sub container
1753 * therein? 1709 * therein?
1754 */ 1710 */
… …
1789 } 1745 }
1790 } 1746 }
1791 } 1747 }
1792 else 1748 else
1793 { 1749 {
1794 object *
1795 above = op->above; 1750 object *above = op->above;
1796 1751
1797 if (i < op->nrof) 1752 if (i < op->nrof)
1798 {
1799 op->nrof -= i; 1753 op->nrof -= i;
1800 }
1801 else 1754 else
1802 { 1755 {
1803 remove_ob (op); 1756 remove_ob (op);
1804 op->nrof = 0; 1757 op->nrof = 0;
1805 } 1758 }
1759
1806 /* Since we just removed op, op->above is null */ 1760 /* Since we just removed op, op->above is null */
1807 for (tmp = above; tmp != NULL; tmp = tmp->above) 1761 for (tmp = above; tmp != NULL; tmp = tmp->above)
1808 if (tmp->type == PLAYER) 1762 if (tmp->type == PLAYER)
1809 { 1763 {
1810 if (op->nrof) 1764 if (op->nrof)
… …
1813 esrv_del_item (tmp->contr, op->count); 1767 esrv_del_item (tmp->contr, op->count);
1814 } 1768 }
1815 } 1769 }
1816 1770
1817 if (op->nrof) 1771 if (op->nrof)
1818 {
1819 return op; 1772 return op;
1820 }
1821 else 1773 else
1822 { 1774 {
1823 free_object (op); 1775 free_object (op);
1824 return NULL; 1776 return NULL;
1825 } 1777 }
… …
1834add_weight (object *op, signed long weight) 1786add_weight (object *op, signed long weight)
1835{ 1787{
1836 while (op != NULL) 1788 while (op != NULL)
1837 { 1789 {
1838 if (op->type == CONTAINER) 1790 if (op->type == CONTAINER)
1839 {
1840 weight = (signed long) (weight * (100 - op->stats.Str) / 100); 1791 weight = (signed long) (weight * (100 - op->stats.Str) / 100);
1841 } 1792
1842 op->carrying += weight; 1793 op->carrying += weight;
1843 op = op->env; 1794 op = op->env;
1844 } 1795 }
1845} 1796}
1846 1797
… …
1869 { 1820 {
1870 dump_object (op); 1821 dump_object (op);
1871 LOG (llevError, "Trying to insert (ob) inserted object.\n%s\n", errmsg); 1822 LOG (llevError, "Trying to insert (ob) inserted object.\n%s\n", errmsg);
1872 return op; 1823 return op;
1873 } 1824 }
1825
1874 if (where == NULL) 1826 if (where == NULL)
1875 { 1827 {
1876 dump_object (op); 1828 dump_object (op);
1877 LOG (llevError, "Trying to put object in NULL.\n%s\n", errmsg); 1829 LOG (llevError, "Trying to put object in NULL.\n%s\n", errmsg);
1878 return op; 1830 return op;
1879 } 1831 }
1832
1880 if (where->head) 1833 if (where->head)
1881 { 1834 {
1882 LOG (llevDebug, "Warning: Tried to insert object wrong part of multipart object.\n"); 1835 LOG (llevDebug, "Warning: Tried to insert object wrong part of multipart object.\n");
1883 where = where->head; 1836 where = where->head;
1884 } 1837 }
1838
1885 if (op->more) 1839 if (op->more)
1886 { 1840 {
1887 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count); 1841 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count);
1888 return op; 1842 return op;
1889 } 1843 }
1844
1890 CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL); 1845 CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL);
1891 CLEAR_FLAG (op, FLAG_REMOVED); 1846 CLEAR_FLAG (op, FLAG_REMOVED);
1892 if (op->nrof) 1847 if (op->nrof)
1893 { 1848 {
1894 for (tmp = where->inv; tmp != NULL; tmp = tmp->below) 1849 for (tmp = where->inv; tmp != NULL; tmp = tmp->below)
… …
1979 */ 1934 */
1980 1935
1981int 1936int
1982check_move_on (object *op, object *originator) 1937check_move_on (object *op, object *originator)
1983{ 1938{
1984 object *tmp; 1939 object *
1985 tag_t tag; 1940 tmp;
1986 mapstruct *m = op->map; 1941 tag_t
1942 tag;
1943 mapstruct *
1944 m = op->map;
1945 int
1987 int x = op->x, y = op->y; 1946 x = op->x, y = op->y;
1988 1947
1989 MoveType move_on, move_slow, move_block; 1948 MoveType
1949 move_on,
1950 move_slow,
1951 move_block;
1990 1952
1991 if (QUERY_FLAG (op, FLAG_NO_APPLY)) 1953 if (QUERY_FLAG (op, FLAG_NO_APPLY))
1992 return 0; 1954 return 0;
1993 1955
1994 tag = op->count; 1956 tag = op->count;
… …
2042 { 2004 {
2043 if ((!op->move_type && tmp->move_slow & MOVE_WALK) || 2005 if ((!op->move_type && tmp->move_slow & MOVE_WALK) ||
2044 ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0)) 2006 ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0))
2045 { 2007 {
2046 2008
2009 float
2047 float diff = tmp->move_slow_penalty * FABS (op->speed); 2010 diff = tmp->move_slow_penalty * FABS (op->speed);
2048 2011
2049 if (op->type == PLAYER) 2012 if (op->type == PLAYER)
2050 if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) || 2013 if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) ||
2051 (QUERY_FLAG (tmp, FLAG_IS_WOODED) && find_skill_by_number (op, SK_WOODSMAN))) 2014 (QUERY_FLAG (tmp, FLAG_IS_WOODED) && find_skill_by_number (op, SK_WOODSMAN)))
2052 diff /= 4.0; 2015 diff /= 4.0;
… …
2371find_dir (mapstruct *m, int x, int y, object *exclude) 2334find_dir (mapstruct *m, int x, int y, object *exclude)
2372{ 2335{
2373 int 2336 int
2374 i, 2337 i,
2375 max = SIZEOFFREE, mflags; 2338 max = SIZEOFFREE, mflags;
2376 sint16 2339
2377 nx, 2340 sint16 nx, ny;
2378 ny;
2379 object * 2341 object *
2380 tmp; 2342 tmp;
2381 mapstruct * 2343 mapstruct *
2382 mp; 2344 mp;
2383 MoveType 2345
2384 blocked, 2346 MoveType blocked, move_type;
2385 move_type;
2386 2347
2387 if (exclude && exclude->head) 2348 if (exclude && exclude->head)
2388 { 2349 {
2389 exclude = exclude->head; 2350 exclude = exclude->head;
2390 move_type = exclude->move_type; 2351 move_type = exclude->move_type;
… …
2597 2558
2598 2559
2599int 2560int
2600can_see_monsterP (mapstruct *m, int x, int y, int dir) 2561can_see_monsterP (mapstruct *m, int x, int y, int dir)
2601{ 2562{
2602 sint16 2563 sint16 dx, dy;
2603 dx,
2604 dy;
2605 int 2564 int
2606 mflags; 2565 mflags;
2607 2566
2608 if (dir < 0) 2567 if (dir < 0)
2609 return 0; /* exit condition: invalid direction */ 2568 return 0; /* exit condition: invalid direction */
… …
2734 2693
2735 if (tempfile == NULL) 2694 if (tempfile == NULL)
2736 { 2695 {
2737 LOG (llevError, "Error - Unable to access load object temp file\n"); 2696 LOG (llevError, "Error - Unable to access load object temp file\n");
2738 return NULL; 2697 return NULL;
2739 }; 2698 }
2699
2740 fprintf (tempfile, obstr); 2700 fprintf (tempfile, obstr);
2741 fclose (tempfile); 2701 fclose (tempfile);
2742 2702
2743 op = get_object (); 2703 op = get_object ();
2744 2704
2745 object_thawer 2705 object_thawer thawer (filename);
2746 thawer (filename);
2747 2706
2748 if (thawer) 2707 if (thawer)
2749 load_object (thawer, op, 0); 2708 load_object (thawer, op, 0);
2750 2709
2751 LOG (llevDebug, " load str completed, object=%s\n", &op->name); 2710 LOG (llevDebug, " load str completed, object=%s\n", &op->name);
… …
2802 * The returned string is shared. 2761 * The returned string is shared.
2803 */ 2762 */
2804const char * 2763const char *
2805get_ob_key_value (const object *op, const char *const key) 2764get_ob_key_value (const object *op, const char *const key)
2806{ 2765{
2807 key_value * 2766 key_value *link;
2808 link; 2767 shstr_cmp canonical_key (key);
2809 const char *
2810 canonical_key;
2811 2768
2812 canonical_key = shstr::find (key);
2813
2814 if (canonical_key == NULL) 2769 if (!canonical_key)
2815 { 2770 {
2816 /* 1. There being a field named key on any object 2771 /* 1. There being a field named key on any object
2817 * implies there'd be a shared string to find. 2772 * implies there'd be a shared string to find.
2818 * 2. Since there isn't, no object has this field. 2773 * 2. Since there isn't, no object has this field.
2819 * 3. Therefore, *this* object doesn't have this field. 2774 * 3. Therefore, *this* object doesn't have this field.
2820 */ 2775 */
2821 return NULL; 2776 return 0;
2822 } 2777 }
2823 2778
2824 /* This is copied from get_ob_key_link() above - 2779 /* This is copied from get_ob_key_link() above -
2825 * only 4 lines, and saves the function call overhead. 2780 * only 4 lines, and saves the function call overhead.
2826 */ 2781 */
2827 for (link = op->key_values; link != NULL; link = link->next) 2782 for (link = op->key_values; link; link = link->next)
2828 {
2829 if (link->key == canonical_key) 2783 if (link->key == canonical_key)
2830 {
2831 return link->value; 2784 return link->value;
2832 } 2785
2833 }
2834 return NULL; 2786 return 0;
2835} 2787}
2836 2788
2837 2789
2838/* 2790/*
2839 * Updates the canonical_key in op to value. 2791 * Updates the canonical_key in op to value.
… …
2875 if (last) 2827 if (last)
2876 last->next = field->next; 2828 last->next = field->next;
2877 else 2829 else
2878 op->key_values = field->next; 2830 op->key_values = field->next;
2879 2831
2880 delete
2881 field; 2832 delete field;
2882 } 2833 }
2883 } 2834 }
2884 return TRUE; 2835 return TRUE;
2885 } 2836 }
2886 /* IF we get here, key doesn't exist */ 2837 /* IF we get here, key doesn't exist */
… …
2921 * Returns TRUE on success. 2872 * Returns TRUE on success.
2922 */ 2873 */
2923int 2874int
2924set_ob_key_value (object *op, const char *key, const char *value, int add_key) 2875set_ob_key_value (object *op, const char *key, const char *value, int add_key)
2925{ 2876{
2926 shstr
2927 key_ (key); 2877 shstr key_ (key);
2928 2878
2929 return set_ob_key_value_s (op, key_, value, add_key); 2879 return set_ob_key_value_s (op, key_, value, add_key);
2930} 2880}
2881
2882object::depth_iterator::depth_iterator (object *container)
2883: iterator_base (container)
2884{
2885 while (item->inv)
2886 item = item->inv;
2887}
2888
2889void
2890object::depth_iterator::next ()
2891{
2892 if (item->below)
2893 {
2894 item = item->below;
2895
2896 while (item->inv)
2897 item = item->inv;
2898 }
2899 else
2900 item = item->env;
2901}
2902
2903// return a suitable string describing an objetc in enough detail to find it
2904const char *
2905object::debug_desc (char *info) const
2906{
2907 char info2[256 * 3];
2908 char *p = info;
2909
2910 p += snprintf (p, 256, "%d=\"%s%s%s\"",
2911 count,
2912 &name,
2913 title ? " " : "",
2914 title ? (const char *)title : "");
2915
2916 if (env)
2917 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
2918
2919 if (map)
2920 p += snprintf (p, 256, "(on %s@%d+%d)", map->path, x, y);
2921
2922 return info;
2923}
2924
2925const char *
2926object::debug_desc () const
2927{
2928 static char info[256 * 3];
2929 return debug_desc (info);
2930}
2931

Diff Legend

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