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.27 by root, Mon Sep 11 12:08:45 2006 UTC vs.
Revision 1.42 by root, Thu Sep 14 01:19:47 2006 UTC

1
2/*
3 * static char *rcsid_object_c =
4 * "$Id: object.C,v 1.27 2006/09/11 12:08:45 root Exp $";
5 */
6 1
7/* 2/*
8 CrossFire, A Multiplayer game for X-windows 3 CrossFire, A Multiplayer game for X-windows
9 4
10 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 5 Copyright (C) 2001 Mark Wedel & Crossfire Development Team
… …
29 24
30/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects. 25/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects.
31 sub/add_weight will transcend the environment updating the carrying 26 sub/add_weight will transcend the environment updating the carrying
32 variable. */ 27 variable. */
33#include <global.h> 28#include <global.h>
34#ifndef WIN32 /* ---win32 exclude headers */
35# include <stdio.h> 29#include <stdio.h>
36# include <sys/types.h> 30#include <sys/types.h>
37# include <sys/uio.h> 31#include <sys/uio.h>
38#endif /* win32 */
39#include <object.h> 32#include <object.h>
40#include <funcpoint.h> 33#include <funcpoint.h>
41#include <skills.h>
42#include <loader.h> 34#include <loader.h>
35
43int nrofallocobjects = 0; 36int nrofallocobjects = 0;
37static UUID uuid;
38const uint64 UUID_SKIP = 1<<19;
44 39
45object *objects; /* Pointer to the list of used objects */ 40object *objects; /* Pointer to the list of used objects */
46object *active_objects; /* List of active objects that need to be processed */ 41object *active_objects; /* List of active objects that need to be processed */
47 42
48short 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, 43short 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,
… …
56}; 51};
57int freedir[SIZEOFFREE] = { 52int freedir[SIZEOFFREE] = {
58 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, 53 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,
59 1, 2, 2, 2, 2, 2, 3, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 7, 8, 8, 8, 8, 8 54 1, 2, 2, 2, 2, 2, 3, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 7, 8, 8, 8, 8, 8
60}; 55};
56
57static void
58write_uuid (void)
59{
60 char filename1[MAX_BUF], filename2[MAX_BUF];
61
62 sprintf (filename1, "%s/uuid", settings.localdir);
63 sprintf (filename2, "%s/uuid~", settings.localdir);
64
65 FILE *fp;
66
67 if (!(fp = fopen (filename2, "w")))
68 {
69 LOG (llevError, "ERROR: cannot open %s for writing, unable to write UUID!\n", filename2);
70 return;
71 }
72
73 fprintf (fp, "<1,%llx>\n", (unsigned long long)uuid.seq + UUID_SKIP * 2);
74 fclose (fp);
75 rename (filename2, filename1);
76}
77
78static void
79read_uuid (void)
80{
81 char filename[MAX_BUF];
82
83 sprintf (filename, "%s/uuid", settings.localdir);
84
85 FILE *fp;
86
87 if (!(fp = fopen (filename, "r")))
88 {
89 if (errno == ENOENT)
90 {
91 LOG (llevInfo, "RESET uid to 1\n");
92 uuid.seq = 0;
93 write_uuid ();
94 return;
95 }
96
97 LOG (llevError, "FATAL: cannot open %s for reading!\n", filename);
98 _exit (1);
99 }
100
101 int version;
102 unsigned long long uid;
103 if (2 != fscanf (fp, "<%d,%llx>\n", &version, &uid) || version != 1)
104 {
105 LOG (llevError, "FATAL: error reading uid from %s!\n", filename);
106 _exit (1);
107 }
108
109 uuid.seq = uid;
110 write_uuid ();
111 LOG (llevDebug, "read UID: %lld\n", uid);
112 fclose (fp);
113}
114
115UUID
116gen_uuid ()
117{
118 UUID uid;
119
120 uid.seq = ++uuid.seq;
121
122 if (!(uuid.seq & (UUID_SKIP - 1)))
123 write_uuid ();
124
125 return uid;
126}
127
128void
129init_uuid ()
130{
131 read_uuid ();
132}
61 133
62/* Returns TRUE if every key_values in wants has a partner with the same value in has. */ 134/* Returns TRUE if every key_values in wants has a partner with the same value in has. */
63static int 135static int
64compare_ob_value_lists_one (const object *wants, const object *has) 136compare_ob_value_lists_one (const object *wants, const object *has)
65{ 137{
… …
214 if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && FABS ((ob1)->speed) > MIN_ACTIVE_SPEED) 286 if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && FABS ((ob1)->speed) > MIN_ACTIVE_SPEED)
215 return 0; 287 return 0;
216 288
217 switch (ob1->type) 289 switch (ob1->type)
218 { 290 {
219 case SCROLL: 291 case SCROLL:
220 if (ob1->level != ob2->level) 292 if (ob1->level != ob2->level)
221 return 0; 293 return 0;
222 break; 294 break;
223 } 295 }
224 296
225 if (ob1->key_values != NULL || ob2->key_values != NULL) 297 if (ob1->key_values != NULL || ob2->key_values != NULL)
226 { 298 {
227 /* At least one of these has key_values. */ 299 /* At least one of these has key_values. */
… …
249/* 321/*
250 * sum_weight() is a recursive function which calculates the weight 322 * sum_weight() is a recursive function which calculates the weight
251 * an object is carrying. It goes through in figures out how much 323 * an object is carrying. It goes through in figures out how much
252 * containers are carrying, and sums it up. 324 * containers are carrying, and sums it up.
253 */ 325 */
254signed long 326long
255sum_weight (object *op) 327sum_weight (object *op)
256{ 328{
257 signed long sum; 329 long sum;
258 object *inv; 330 object *inv;
259 331
260 for (sum = 0, inv = op->inv; inv != NULL; inv = inv->below) 332 for (sum = 0, inv = op->inv; inv != NULL; inv = inv->below)
261 { 333 {
262 if (inv->inv) 334 if (inv->inv)
263 sum_weight (inv); 335 sum_weight (inv);
264 sum += inv->carrying + inv->weight * (inv->nrof ? inv->nrof : 1); 336 sum += inv->carrying + inv->weight * (inv->nrof ? inv->nrof : 1);
265 } 337 }
338
266 if (op->type == CONTAINER && op->stats.Str) 339 if (op->type == CONTAINER && op->stats.Str)
267 sum = (sum * (100 - op->stats.Str)) / 100; 340 sum = (sum * (100 - op->stats.Str)) / 100;
341
268 if (op->carrying != sum) 342 if (op->carrying != sum)
269 op->carrying = sum; 343 op->carrying = sum;
344
270 return sum; 345 return sum;
271} 346}
272 347
273/** 348/**
274 * Return the outermost environment object for a given object. 349 * Return the outermost environment object for a given object.
… …
423 */ 498 */
424 499
425object * 500object *
426find_object_name (const char *str) 501find_object_name (const char *str)
427{ 502{
428 const char *name = shstr::find (str); 503 shstr_cmp str_ (str);
429 object *op; 504 object *op;
430 505
431 for (op = objects; op != NULL; op = op->next) 506 for (op = objects; op != NULL; op = op->next)
432 if (&op->name == name) 507 if (op->name == str_)
433 break; 508 break;
434 509
435 return op; 510 return op;
436} 511}
437 512
… …
449 * Changed 2004-02-12 - if the player is setting at the play again 524 * Changed 2004-02-12 - if the player is setting at the play again
450 * prompt, he is removed, and we don't want to treat him as an owner of 525 * prompt, he is removed, and we don't want to treat him as an owner of
451 * anything, so check removed flag. I don't expect that this should break 526 * anything, so check removed flag. I don't expect that this should break
452 * anything - once an object is removed, it is basically dead anyways. 527 * anything - once an object is removed, it is basically dead anyways.
453 */ 528 */
454
455object * 529object *
456get_owner (object *op) 530object::get_owner ()
457{ 531{
458 if (op->owner == NULL) 532 if (!owner
459 return NULL; 533 || QUERY_FLAG (owner, FLAG_FREED)
534 || QUERY_FLAG (owner, FLAG_REMOVED))
535 owner = 0;
460 536
461 if (!QUERY_FLAG (op->owner, FLAG_FREED) && !QUERY_FLAG (op->owner, FLAG_REMOVED) && op->owner->count == op->ownercount)
462 return op->owner; 537 return owner;
463
464 op->owner = NULL;
465 op->ownercount = 0;
466 return NULL;
467}
468
469void
470clear_owner (object *op)
471{
472 if (!op)
473 return;
474
475 if (op->owner && op->ownercount == op->owner->count)
476 op->owner->refcount--;
477
478 op->owner = NULL;
479 op->ownercount = 0;
480} 538}
481 539
482/* 540/*
483 * Sets the owner and sets the skill and exp pointers to owner's current 541 * Sets the owner and sets the skill and exp pointers to owner's current
484 * skill and experience objects. 542 * skill and experience objects.
485 */ 543 */
486void 544void
487set_owner (object *op, object *owner) 545object::set_owner (object *owner)
488{ 546{
489 if (owner == NULL || op == NULL) 547 if (!owner)
490 return; 548 return;
491 549
492 /* next line added to allow objects which own objects */ 550 /* next line added to allow objects which own objects */
493 /* Add a check for ownercounts in here, as I got into an endless loop 551 /* Add a check for ownercounts in here, as I got into an endless loop
494 * with the fireball owning a poison cloud which then owned the 552 * with the fireball owning a poison cloud which then owned the
495 * fireball. I believe that was caused by one of the objects getting 553 * fireball. I believe that was caused by one of the objects getting
496 * freed and then another object replacing it. Since the ownercounts 554 * freed and then another object replacing it. Since the ownercounts
497 * didn't match, this check is valid and I believe that cause is valid. 555 * didn't match, this check is valid and I believe that cause is valid.
498 */ 556 */
499 while (owner->owner && owner != owner->owner && owner->ownercount == owner->owner->count) 557 while (owner->owner)
500 owner = owner->owner; 558 owner = owner->owner;
501 559
502 /* IF the owner still has an owner, we did not resolve to a final owner.
503 * so lets not add to that.
504 */
505 if (owner->owner)
506 return;
507
508 op->owner = owner; 560 this->owner = owner;
509
510 op->ownercount = owner->count;
511 owner->refcount++;
512}
513
514/* Set the owner to clone's current owner and set the skill and experience
515 * objects to clone's objects (typically those objects that where the owner's
516 * current skill and experience objects at the time when clone's owner was
517 * set - not the owner's current skill and experience objects).
518 *
519 * Use this function if player created an object (e.g. fire bullet, swarm
520 * spell), and this object creates further objects whose kills should be
521 * accounted for the player's original skill, even if player has changed
522 * skills meanwhile.
523 */
524void
525copy_owner (object *op, object *clone)
526{
527 object *owner = get_owner (clone);
528
529 if (owner == NULL)
530 {
531 /* players don't have owners - they own themselves. Update
532 * as appropriate.
533 */
534 if (clone->type == PLAYER)
535 owner = clone;
536 else
537 return;
538 }
539
540 set_owner (op, owner);
541} 561}
542 562
543/* Zero the key_values on op, decrementing the shared-string 563/* Zero the key_values on op, decrementing the shared-string
544 * refcounts and freeing the links. 564 * refcounts and freeing the links.
545 */ 565 */
… …
561{ 581{
562 attachable_base::clear (); 582 attachable_base::clear ();
563 583
564 free_key_values (this); 584 free_key_values (this);
565 585
566 clear_owner (this); 586 owner = 0;
567
568 name = 0; 587 name = 0;
569 name_pl = 0; 588 name_pl = 0;
570 title = 0; 589 title = 0;
571 race = 0; 590 race = 0;
572 slaying = 0; 591 slaying = 0;
573 skill = 0; 592 skill = 0;
574 msg = 0; 593 msg = 0;
575 lore = 0; 594 lore = 0;
576 custom_name = 0; 595 custom_name = 0;
577 materialname = 0; 596 materialname = 0;
597 contr = 0;
598 below = 0;
599 above = 0;
600 inv = 0;
601 container = 0;
602 env = 0;
603 more = 0;
604 head = 0;
605 map = 0;
606 active_next = 0;
607 active_prev = 0;
578 608
579 memset (static_cast < object_pod * >(this), 0, sizeof (object_pod)); 609 memset (static_cast<object_pod *>(this), 0, sizeof (object_pod));
580 610
581 SET_FLAG (this, FLAG_REMOVED); 611 SET_FLAG (this, FLAG_REMOVED);
612
613 /* What is not cleared is next, prev, and count */
614
615 expmul = 1.0;
616 face = blank_face;
617 attacked_by_count = -1;
618
619 if (settings.casting_time)
620 casting_time = -1;
582} 621}
583 622
584void object::clone (object *destination) 623void object::clone (object *destination)
585{ 624{
586 *(object_copy *) destination = *this; 625 *(object_copy *)destination = *this;
587 *(object_pod *) destination = *this; 626 *(object_pod *)destination = *this;
588 627
589 if (self || cb) 628 if (self || cb)
590 INVOKE_OBJECT (CLONE, this, ARG_OBJECT (destination)); 629 INVOKE_OBJECT (CLONE, this, ARG_OBJECT (destination));
591}
592
593/*
594 * clear_object() frees everything allocated by an object, and also
595 * clears all variables and flags to default settings.
596 */
597
598void
599clear_object (object *op)
600{
601 op->clear ();
602
603 op->contr = NULL;
604 op->below = NULL;
605 op->above = NULL;
606 op->inv = NULL;
607 op->container = NULL;
608 op->env = NULL;
609 op->more = NULL;
610 op->head = NULL;
611 op->map = NULL;
612 op->refcount = 0;
613 op->active_next = NULL;
614 op->active_prev = NULL;
615 /* What is not cleared is next, prev, and count */
616
617 op->expmul = 1.0;
618 op->face = blank_face;
619 op->attacked_by_count = -1;
620
621 if (settings.casting_time)
622 op->casting_time = -1;
623} 630}
624 631
625/* 632/*
626 * copy object first frees everything allocated by the second object, 633 * copy object first frees everything allocated by the second object,
627 * and then copies the contends of the first object into the second 634 * and then copies the contends of the first object into the second
628 * object, allocating what needs to be allocated. Basically, any 635 * object, allocating what needs to be allocated. Basically, any
629 * data that is malloc'd needs to be re-malloc/copied. Otherwise, 636 * data that is malloc'd needs to be re-malloc/copied. Otherwise,
630 * if the first object is freed, the pointers in the new object 637 * if the first object is freed, the pointers in the new object
631 * will point at garbage. 638 * will point at garbage.
632 */ 639 */
633
634void 640void
635copy_object (object *op2, object *op) 641copy_object (object *op2, object *op)
636{ 642{
637 bool is_freed = QUERY_FLAG (op, FLAG_FREED); 643 bool is_freed = QUERY_FLAG (op, FLAG_FREED);
638 bool is_removed = QUERY_FLAG (op, FLAG_REMOVED); 644 bool is_removed = QUERY_FLAG (op, FLAG_REMOVED);
… …
698/* 704/*
699 * Updates the speed of an object. If the speed changes from 0 to another 705 * Updates the speed of an object. If the speed changes from 0 to another
700 * value, or vice versa, then add/remove the object from the active list. 706 * value, or vice versa, then add/remove the object from the active list.
701 * This function needs to be called whenever the speed of an object changes. 707 * This function needs to be called whenever the speed of an object changes.
702 */ 708 */
703
704void 709void
705update_ob_speed (object *op) 710update_ob_speed (object *op)
706{ 711{
707 extern int arch_init; 712 extern int arch_init;
708 713
… …
717 abort (); 722 abort ();
718#else 723#else
719 op->speed = 0; 724 op->speed = 0;
720#endif 725#endif
721 } 726 }
727
722 if (arch_init) 728 if (arch_init)
723 {
724 return; 729 return;
725 } 730
726 if (FABS (op->speed) > MIN_ACTIVE_SPEED) 731 if (FABS (op->speed) > MIN_ACTIVE_SPEED)
727 { 732 {
728 /* If already on active list, don't do anything */ 733 /* If already on active list, don't do anything */
729 if (op->active_next || op->active_prev || op == active_objects) 734 if (op->active_next || op->active_prev || op == active_objects)
730 return; 735 return;
731 736
732 /* process_events() expects us to insert the object at the beginning 737 /* process_events() expects us to insert the object at the beginning
733 * of the list. */ 738 * of the list. */
734 op->active_next = active_objects; 739 op->active_next = active_objects;
740
735 if (op->active_next != NULL) 741 if (op->active_next != NULL)
736 op->active_next->active_prev = op; 742 op->active_next->active_prev = op;
743
737 active_objects = op; 744 active_objects = op;
738 } 745 }
739 else 746 else
740 { 747 {
741 /* If not on the active list, nothing needs to be done */ 748 /* If not on the active list, nothing needs to be done */
… …
743 return; 750 return;
744 751
745 if (op->active_prev == NULL) 752 if (op->active_prev == NULL)
746 { 753 {
747 active_objects = op->active_next; 754 active_objects = op->active_next;
755
748 if (op->active_next != NULL) 756 if (op->active_next != NULL)
749 op->active_next->active_prev = NULL; 757 op->active_next->active_prev = NULL;
750 } 758 }
751 else 759 else
752 { 760 {
753 op->active_prev->active_next = op->active_next; 761 op->active_prev->active_next = op->active_next;
762
754 if (op->active_next) 763 if (op->active_next)
755 op->active_next->active_prev = op->active_prev; 764 op->active_next->active_prev = op->active_prev;
756 } 765 }
766
757 op->active_next = NULL; 767 op->active_next = NULL;
758 op->active_prev = NULL; 768 op->active_prev = NULL;
759 } 769 }
760} 770}
761 771
… …
893 * that is being removed. 903 * that is being removed.
894 */ 904 */
895 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE) 905 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE)
896 update_now = 1; 906 update_now = 1;
897 else if (action == UP_OBJ_FACE) 907 else if (action == UP_OBJ_FACE)
898 /* Nothing to do for that case */; 908 /* Nothing to do for that case */ ;
899 else 909 else
900 LOG (llevError, "update_object called with invalid action: %d\n", action); 910 LOG (llevError, "update_object called with invalid action: %d\n", action);
901 911
902 if (update_now) 912 if (update_now)
903 { 913 {
… …
908 if (op->more != NULL) 918 if (op->more != NULL)
909 update_object (op->more, action); 919 update_object (op->more, action);
910} 920}
911 921
912static unordered_vector<object *> mortals; 922static unordered_vector<object *> mortals;
913static std::vector<object *> freed;
914 923
915void object::free_mortals () 924void object::free_mortals ()
916{ 925{
917 for (unordered_vector<object *>::iterator i = mortals.begin (); i != mortals.end (); ) 926 for (unordered_vector<object *>::iterator i = mortals.begin (); i != mortals.end ();)
918 if (!(*i)->refcount) 927 if ((*i)->refcnt)
928 ++i; // further delay freeing
929 else
919 { 930 {
920 freed.push_back (*i); 931 delete *i;
921 mortals.erase (i); 932 mortals.erase (i);
922 } 933 }
923 else 934
924 ++i; 935 static int lastmortals = 0;//D
936
937 if (mortals.size() != lastmortals)//D
938 {
939 lastmortals = mortals.size ();//D
940 LOG (llevDebug, "%d objects in mortal queue\n", lastmortals);//D
941 }
925} 942}
926 943
927object::object () 944object::object ()
928{ 945{
929 SET_FLAG (this, FLAG_REMOVED); 946 SET_FLAG (this, FLAG_REMOVED);
… …
939} 956}
940 957
941void object::link () 958void object::link ()
942{ 959{
943 count = ++ob_count; 960 count = ++ob_count;
961 uuid = gen_uuid ();
944 962
945 prev = 0; 963 prev = 0;
946 next = objects; 964 next = objects;
947 965
948 if (objects) 966 if (objects)
… …
951 objects = this; 969 objects = this;
952} 970}
953 971
954void object::unlink () 972void object::unlink ()
955{ 973{
956 count = 0; 974 //count = 0;//D
957 975 if (!prev && !next) return;//D
958 /* Remove this object from the list of used objects */
959 if (prev)
960 {
961 prev->next = next;
962 prev = 0;
963 }
964
965 if (next)
966 {
967 next->prev = prev;
968 next = 0;
969 }
970 976
971 if (this == objects) 977 if (this == objects)
972 objects = next; 978 objects = next;
979
980 /* Remove this object from the list of used objects */
981 if (prev) prev->next = next;
982 if (next) next->prev = prev;
983
984 prev = 0;
985 next = 0;
973} 986}
974 987
975object *object::create () 988object *object::create ()
976{ 989{
977 object *op;
978
979 if (freed.empty ())
980 op = new object; 990 object *op = new object;
981 else
982 {
983 // highly annoying, but the only way to get it stable right now
984 op = freed.back (); freed.pop_back ();
985 op->~object ();
986 new ((void *)op) object;
987 }
988
989 op->link (); 991 op->link ();
990 return op; 992 return op;
991} 993}
992 994
993/* 995/*
… …
1000 * If free_inventory is set, free inventory as well. Else drop items in 1002 * If free_inventory is set, free inventory as well. Else drop items in
1001 * inventory to the ground. 1003 * inventory to the ground.
1002 */ 1004 */
1003void object::free (bool free_inventory) 1005void object::free (bool free_inventory)
1004{ 1006{
1007 if (QUERY_FLAG (this, FLAG_FREED))
1008 return;
1009
1010 if (QUERY_FLAG (this, FLAG_FRIENDLY))
1011 remove_friendly_object (this);
1012
1005 if (!QUERY_FLAG (this, FLAG_REMOVED)) 1013 if (!QUERY_FLAG (this, FLAG_REMOVED))
1006 { 1014 remove_ob (this);
1007 LOG (llevDebug, "Free object called with non removed object\n");
1008 dump_object (this);
1009#ifdef MANY_CORES
1010 abort ();
1011#endif
1012 }
1013 1015
1014 if (QUERY_FLAG (this, FLAG_FRIENDLY))
1015 {
1016 LOG (llevMonster, "Warning: tried to free friendly object.\n");
1017 remove_friendly_object (this);
1018 }
1019
1020 if (QUERY_FLAG (this, FLAG_FREED)) 1016 SET_FLAG (this, FLAG_FREED);
1021 {
1022 dump_object (this);
1023 LOG (llevError, "Trying to free freed object.\n%s\n", errmsg);
1024 return;
1025 }
1026 1017
1027 if (more) 1018 if (more)
1028 { 1019 {
1029 more->free (free_inventory); 1020 more->free (free_inventory);
1030 more = 0; 1021 more = 0;
… …
1034 { 1025 {
1035 /* Only if the space blocks everything do we not process - 1026 /* Only if the space blocks everything do we not process -
1036 * if some form of movement is allowed, let objects 1027 * if some form of movement is allowed, let objects
1037 * drop on that space. 1028 * drop on that space.
1038 */ 1029 */
1039 if (free_inventory || !map || map->in_memory != MAP_IN_MEMORY || (GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL)) 1030 if (free_inventory || !map || map->in_memory != MAP_IN_MEMORY || GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL)
1040 { 1031 {
1041 object * 1032 object *op = inv;
1042 op = inv;
1043 1033
1044 while (op) 1034 while (op)
1045 { 1035 {
1046 object *
1047 tmp = op->below; 1036 object *tmp = op->below;
1048
1049 remove_ob (op);
1050 op->free (free_inventory); 1037 op->free (free_inventory);
1051 op = tmp; 1038 op = tmp;
1052 } 1039 }
1053 } 1040 }
1054 else 1041 else
1055 { /* Put objects in inventory onto this space */ 1042 { /* Put objects in inventory onto this space */
1056 object * 1043 object *op = inv;
1057 op = inv;
1058 1044
1059 while (op) 1045 while (op)
1060 { 1046 {
1061 object *
1062 tmp = op->below; 1047 object *tmp = op->below;
1063 1048
1064 remove_ob (op); 1049 remove_ob (op);
1065 1050
1066 if (QUERY_FLAG (op, FLAG_STARTEQUIP) 1051 if (QUERY_FLAG (op, FLAG_STARTEQUIP)
1067 || QUERY_FLAG (op, FLAG_NO_DROP) || op->type == RUNE || op->type == TRAP || QUERY_FLAG (op, FLAG_IS_A_TEMPLATE)) 1052 || QUERY_FLAG (op, FLAG_NO_DROP) || op->type == RUNE || op->type == TRAP || QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))
… …
1076 op = tmp; 1061 op = tmp;
1077 } 1062 }
1078 } 1063 }
1079 } 1064 }
1080 1065
1081 clear_owner (this); 1066 owner = 0;
1082 1067
1083 /* Remove object from the active list */ 1068 /* Remove object from the active list */
1084 speed = 0; 1069 speed = 0;
1085 update_ob_speed (this); 1070 update_ob_speed (this);
1086 1071
1087 unlink (); 1072 unlink ();
1088
1089 SET_FLAG (this, FLAG_FREED);
1090 1073
1091 mortals.push_back (this); 1074 mortals.push_back (this);
1092} 1075}
1093 1076
1094/* 1077/*
… …
1120 */ 1103 */
1121 1104
1122void 1105void
1123remove_ob (object *op) 1106remove_ob (object *op)
1124{ 1107{
1125 object *tmp, *last = NULL;
1126 object *otmp; 1108 object *
1109 tmp, *
1110 last = NULL;
1111 object *
1112 otmp;
1127 1113
1128 tag_t tag; 1114 tag_t
1115 tag;
1116 int
1129 int check_walk_off; 1117 check_walk_off;
1130 mapstruct *m; 1118 mapstruct *
1119 m;
1131 1120
1132 sint16 x, y; 1121 sint16
1122 x,
1123 y;
1133 1124
1134 if (QUERY_FLAG (op, FLAG_REMOVED)) 1125 if (QUERY_FLAG (op, FLAG_REMOVED))
1135 { 1126 return;
1136 dump_object (op);
1137 LOG (llevError, "Trying to remove removed object.\n%s\n", errmsg);
1138 1127
1139 /* Changed it to always dump core in this case. As has been learned 1128 SET_FLAG (op, FLAG_REMOVED);
1140 * in the past, trying to recover from errors almost always
1141 * make things worse, and this is a real error here - something
1142 * that should not happen.
1143 * Yes, if this was a mission critical app, trying to do something
1144 * to recover may make sense, but that is because failure of the app
1145 * may have other disastrous problems. Cf runs out of a script
1146 * so is easily enough restarted without any real problems.
1147 * MSW 2001-07-01
1148 */
1149 abort ();
1150 }
1151 1129
1152 if (op->more != NULL) 1130 if (op->more != NULL)
1153 remove_ob (op->more); 1131 remove_ob (op->more);
1154
1155 SET_FLAG (op, FLAG_REMOVED);
1156 1132
1157 /* 1133 /*
1158 * In this case, the object to be removed is in someones 1134 * In this case, the object to be removed is in someones
1159 * inventory. 1135 * inventory.
1160 */ 1136 */
… …
1186 */ 1162 */
1187 op->x = op->env->x, op->y = op->env->y; 1163 op->x = op->env->x, op->y = op->env->y;
1188 op->map = op->env->map; 1164 op->map = op->env->map;
1189 op->above = NULL, op->below = NULL; 1165 op->above = NULL, op->below = NULL;
1190 op->env = NULL; 1166 op->env = NULL;
1191 return; 1167 }
1168 else if (op->map)
1192 } 1169 {
1193
1194 /* If we get here, we are removing it from a map */
1195 if (op->map == NULL)
1196 return;
1197
1198 x = op->x; 1170 x = op->x;
1199 y = op->y; 1171 y = op->y;
1200 m = get_map_from_coord (op->map, &x, &y); 1172 m = get_map_from_coord (op->map, &x, &y);
1201 1173
1202 if (!m) 1174 if (!m)
1203 { 1175 {
1204 LOG (llevError, "remove_ob called when object was on map but appears to not be within valid coordinates? %s (%d,%d)\n", 1176 LOG (llevError, "remove_ob called when object was on map but appears to not be within valid coordinates? %s (%d,%d)\n",
1205 op->map->path, op->x, op->y); 1177 op->map->path, op->x, op->y);
1206 /* in old days, we used to set x and y to 0 and continue. 1178 /* in old days, we used to set x and y to 0 and continue.
1207 * it seems if we get into this case, something is probablye 1179 * it seems if we get into this case, something is probablye
1208 * screwed up and should be fixed. 1180 * screwed up and should be fixed.
1181 */
1182 abort ();
1183 }
1184
1185 if (op->map != m)
1186 LOG (llevDebug, "remove_ob: Object not really on map it claimed to be on? %s != %s, %d,%d != %d,%d\n",
1187 op->map->path, m->path, op->x, op->y, x, y);
1188
1189 /* Re did the following section of code - it looks like it had
1190 * lots of logic for things we no longer care about
1209 */ 1191 */
1210 abort ();
1211 }
1212 if (op->map != m)
1213 {
1214 LOG (llevDebug, "remove_ob: Object not really on map it claimed to be on? %s != %s, %d,%d != %d,%d\n",
1215 op->map->path, m->path, op->x, op->y, x, y);
1216 }
1217 1192
1218 /* Re did the following section of code - it looks like it had
1219 * lots of logic for things we no longer care about
1220 */
1221
1222 /* link the object above us */ 1193 /* link the object above us */
1223 if (op->above) 1194 if (op->above)
1224 op->above->below = op->below; 1195 op->above->below = op->below;
1225 else 1196 else
1226 SET_MAP_TOP (m, x, y, op->below); /* we were top, set new top */ 1197 SET_MAP_TOP (m, x, y, op->below); /* we were top, set new top */
1227 1198
1228 /* Relink the object below us, if there is one */ 1199 /* Relink the object below us, if there is one */
1229 if (op->below) 1200 if (op->below)
1230 op->below->above = op->above; 1201 op->below->above = op->above;
1231 else 1202 else
1232 { 1203 {
1233 /* Nothing below, which means we need to relink map object for this space 1204 /* Nothing below, which means we need to relink map object for this space
1234 * use translated coordinates in case some oddness with map tiling is 1205 * use translated coordinates in case some oddness with map tiling is
1235 * evident 1206 * evident
1236 */
1237 if (GET_MAP_OB (m, x, y) != op)
1238 {
1239 dump_object (op);
1240 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",
1241 errmsg);
1242 dump_object (GET_MAP_OB (m, x, y));
1243 LOG (llevError, "%s\n", errmsg);
1244 }
1245
1246 SET_MAP_OB (m, x, y, op->above); /* goes on above it. */
1247 }
1248
1249 op->above = NULL;
1250 op->below = NULL;
1251
1252 if (op->map->in_memory == MAP_SAVING)
1253 return;
1254
1255 tag = op->count;
1256 check_walk_off = !QUERY_FLAG (op, FLAG_NO_APPLY);
1257
1258 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
1259 {
1260 /* No point updating the players look faces if he is the object
1261 * being removed.
1262 */
1263
1264 if (tmp->type == PLAYER && tmp != op)
1265 {
1266 /* If a container that the player is currently using somehow gets
1267 * removed (most likely destroyed), update the player view
1268 * appropriately.
1269 */ 1207 */
1270 if (tmp->container == op) 1208 if (GET_MAP_OB (m, x, y) != op)
1271 { 1209 {
1272 CLEAR_FLAG (op, FLAG_APPLIED); 1210 dump_object (op);
1273 tmp->container = NULL; 1211 LOG (llevError,
1212 "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);
1213 dump_object (GET_MAP_OB (m, x, y));
1214 LOG (llevError, "%s\n", errmsg);
1274 } 1215 }
1275 1216
1276 tmp->contr->socket.update_look = 1; 1217 SET_MAP_OB (m, x, y, op->above); /* goes on above it. */
1277 }
1278 /* See if player moving off should effect something */
1279 if (check_walk_off && ((op->move_type & tmp->move_off) && (op->move_type & ~tmp->move_off & ~tmp->move_block) == 0))
1280 { 1218 }
1281 move_apply (tmp, op, NULL);
1282 1219
1283 if (was_destroyed (op, tag)) 1220 op->above = 0;
1221 op->below = 0;
1222
1223 if (op->map->in_memory == MAP_SAVING)
1224 return;
1225
1226 tag = op->count;
1227 check_walk_off = !QUERY_FLAG (op, FLAG_NO_APPLY);
1228
1229 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
1230 {
1231 /* No point updating the players look faces if he is the object
1232 * being removed.
1233 */
1234
1235 if (tmp->type == PLAYER && tmp != op)
1284 { 1236 {
1285 LOG (llevError, "BUG: remove_ob(): name %s, archname %s destroyed " "leaving object\n", &tmp->name, &tmp->arch->name); 1237 /* If a container that the player is currently using somehow gets
1238 * removed (most likely destroyed), update the player view
1239 * appropriately.
1240 */
1241 if (tmp->container == op)
1242 {
1243 CLEAR_FLAG (op, FLAG_APPLIED);
1244 tmp->container = NULL;
1245 }
1246
1247 tmp->contr->socket.update_look = 1;
1286 } 1248 }
1249
1250 /* See if player moving off should effect something */
1251 if (check_walk_off && ((op->move_type & tmp->move_off) && (op->move_type & ~tmp->move_off & ~tmp->move_block) == 0))
1252 {
1253 move_apply (tmp, op, NULL);
1254
1255 if (was_destroyed (op, tag))
1256 {
1257 LOG (llevError, "BUG: remove_ob(): name %s, archname %s destroyed " "leaving object\n", &tmp->name, &tmp->arch->name);
1258 }
1287 } 1259 }
1288 1260
1289 /* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */ 1261 /* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */
1290 1262
1291 if (tmp->above == tmp) 1263 if (tmp->above == tmp)
1292 tmp->above = NULL; 1264 tmp->above = NULL;
1293 1265
1294 last = tmp; 1266 last = tmp;
1295 } 1267 }
1296 1268
1297 /* last == NULL of there are no objects on this space */ 1269 /* last == NULL of there are no objects on this space */
1298 if (last == NULL) 1270 if (last == NULL)
1299 { 1271 {
1300 /* set P_NEED_UPDATE, otherwise update_position will complain. In theory, 1272 /* set P_NEED_UPDATE, otherwise update_position will complain. In theory,
1301 * we could preserve the flags (GET_MAP_FLAGS), but update_position figures 1273 * we could preserve the flags (GET_MAP_FLAGS), but update_position figures
1302 * those out anyways, and if there are any flags set right now, they won't 1274 * those out anyways, and if there are any flags set right now, they won't
1303 * be correct anyways. 1275 * be correct anyways.
1304 */ 1276 */
1305 SET_MAP_FLAGS (op->map, op->x, op->y, P_NEED_UPDATE); 1277 SET_MAP_FLAGS (op->map, op->x, op->y, P_NEED_UPDATE);
1306 update_position (op->map, op->x, op->y); 1278 update_position (op->map, op->x, op->y);
1307 } 1279 }
1308 else 1280 else
1309 update_object (last, UP_OBJ_REMOVE); 1281 update_object (last, UP_OBJ_REMOVE);
1310 1282
1311 if (QUERY_FLAG (op, FLAG_BLOCKSVIEW) || (op->glow_radius != 0)) 1283 if (QUERY_FLAG (op, FLAG_BLOCKSVIEW) || (op->glow_radius != 0))
1312 update_all_los (op->map, op->x, op->y); 1284 update_all_los (op->map, op->x, op->y);
1285 }
1313} 1286}
1314 1287
1315/* 1288/*
1316 * merge_ob(op,top): 1289 * merge_ob(op,top):
1317 * 1290 *
1318 * This function goes through all objects below and including top, and 1291 * This function goes through all objects below and including top, and
1319 * merges op to the first matching object. 1292 * merges op to the first matching object.
1320 * If top is NULL, it is calculated. 1293 * If top is NULL, it is calculated.
1321 * Returns pointer to object if it succeded in the merge, otherwise NULL 1294 * Returns pointer to object if it succeded in the merge, otherwise NULL
1322 */ 1295 */
1323
1324object * 1296object *
1325merge_ob (object *op, object *top) 1297merge_ob (object *op, object *top)
1326{ 1298{
1327 if (!op->nrof) 1299 if (!op->nrof)
1328 return 0; 1300 return 0;
1301
1329 if (top == NULL) 1302 if (top == NULL)
1330 for (top = op; top != NULL && top->above != NULL; top = top->above); 1303 for (top = op; top != NULL && top->above != NULL; top = top->above);
1304
1331 for (; top != NULL; top = top->below) 1305 for (; top != NULL; top = top->below)
1332 { 1306 {
1333 if (top == op) 1307 if (top == op)
1334 continue; 1308 continue;
1335 if (CAN_MERGE (op, top)) 1309 if (CAN_MERGE (op, top))
… …
1341 remove_ob (op); 1315 remove_ob (op);
1342 free_object (op); 1316 free_object (op);
1343 return top; 1317 return top;
1344 } 1318 }
1345 } 1319 }
1320
1346 return NULL; 1321 return NULL;
1347} 1322}
1348 1323
1349/* 1324/*
1350 * same as insert_ob_in_map except it handle separate coordinates and do a clean 1325 * same as insert_ob_in_map except it handle separate coordinates and do a clean
1351 * job preparing multi-part monsters 1326 * job preparing multi-part monsters
1352 */ 1327 */
1353object * 1328object *
1354insert_ob_in_map_at (object *op, mapstruct *m, object *originator, int flag, int x, int y) 1329insert_ob_in_map_at (object *op, mapstruct *m, object *originator, int flag, int x, int y)
1355{ 1330{
1356 object * 1331 object *tmp;
1357 tmp;
1358 1332
1359 if (op->head) 1333 if (op->head)
1360 op = op->head; 1334 op = op->head;
1335
1361 for (tmp = op; tmp; tmp = tmp->more) 1336 for (tmp = op; tmp; tmp = tmp->more)
1362 { 1337 {
1363 tmp->x = x + tmp->arch->clone.x; 1338 tmp->x = x + tmp->arch->clone.x;
1364 tmp->y = y + tmp->arch->clone.y; 1339 tmp->y = y + tmp->arch->clone.y;
1365 } 1340 }
1341
1366 return insert_ob_in_map (op, m, originator, flag); 1342 return insert_ob_in_map (op, m, originator, flag);
1367} 1343}
1368 1344
1369/* 1345/*
1370 * insert_ob_in_map (op, map, originator, flag): 1346 * insert_ob_in_map (op, map, originator, flag):
… …
1661 * op is the object to insert it under: supplies x and the map. 1637 * op is the object to insert it under: supplies x and the map.
1662 */ 1638 */
1663void 1639void
1664replace_insert_ob_in_map (const char *arch_string, object *op) 1640replace_insert_ob_in_map (const char *arch_string, object *op)
1665{ 1641{
1666 object *tmp; 1642 object *
1643 tmp;
1667 object *tmp1; 1644 object *
1645 tmp1;
1668 1646
1669 /* first search for itself and remove any old instances */ 1647 /* first search for itself and remove any old instances */
1670 1648
1671 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 1649 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
1672 { 1650 {
… …
1703 if (orig_ob->nrof < nr) 1681 if (orig_ob->nrof < nr)
1704 { 1682 {
1705 sprintf (errmsg, "There are only %d %ss.", orig_ob->nrof ? orig_ob->nrof : 1, &orig_ob->name); 1683 sprintf (errmsg, "There are only %d %ss.", orig_ob->nrof ? orig_ob->nrof : 1, &orig_ob->name);
1706 return NULL; 1684 return NULL;
1707 } 1685 }
1686
1708 newob = object_create_clone (orig_ob); 1687 newob = object_create_clone (orig_ob);
1688
1709 if ((orig_ob->nrof -= nr) < 1) 1689 if ((orig_ob->nrof -= nr) < 1)
1710 { 1690 {
1711 if (!is_removed) 1691 if (!is_removed)
1712 remove_ob (orig_ob); 1692 remove_ob (orig_ob);
1713 free_object2 (orig_ob, 1); 1693 free_object2 (orig_ob, 1);
… …
1721 strcpy (errmsg, "Tried to split object whose map is not in memory."); 1701 strcpy (errmsg, "Tried to split object whose map is not in memory.");
1722 LOG (llevDebug, "Error, Tried to split object whose map is not in memory.\n"); 1702 LOG (llevDebug, "Error, Tried to split object whose map is not in memory.\n");
1723 return NULL; 1703 return NULL;
1724 } 1704 }
1725 } 1705 }
1706
1726 newob->nrof = nr; 1707 newob->nrof = nr;
1727 1708
1728 return newob; 1709 return newob;
1729} 1710}
1730 1711
… …
1737 */ 1718 */
1738 1719
1739object * 1720object *
1740decrease_ob_nr (object *op, uint32 i) 1721decrease_ob_nr (object *op, uint32 i)
1741{ 1722{
1742 object * 1723 object *tmp;
1743 tmp;
1744 player * 1724 player *pl;
1745 pl;
1746 1725
1747 if (i == 0) /* objects with op->nrof require this check */ 1726 if (i == 0) /* objects with op->nrof require this check */
1748 return op; 1727 return op;
1749 1728
1750 if (i > op->nrof) 1729 if (i > op->nrof)
1751 i = op->nrof; 1730 i = op->nrof;
1752 1731
1753 if (QUERY_FLAG (op, FLAG_REMOVED)) 1732 if (QUERY_FLAG (op, FLAG_REMOVED))
1754 {
1755 op->nrof -= i; 1733 op->nrof -= i;
1756 }
1757 else if (op->env != NULL) 1734 else if (op->env != NULL)
1758 { 1735 {
1759 /* is this object in the players inventory, or sub container 1736 /* is this object in the players inventory, or sub container
1760 * therein? 1737 * therein?
1761 */ 1738 */
… …
1796 } 1773 }
1797 } 1774 }
1798 } 1775 }
1799 else 1776 else
1800 { 1777 {
1801 object *
1802 above = op->above; 1778 object *above = op->above;
1803 1779
1804 if (i < op->nrof) 1780 if (i < op->nrof)
1805 {
1806 op->nrof -= i; 1781 op->nrof -= i;
1807 }
1808 else 1782 else
1809 { 1783 {
1810 remove_ob (op); 1784 remove_ob (op);
1811 op->nrof = 0; 1785 op->nrof = 0;
1812 } 1786 }
1787
1813 /* Since we just removed op, op->above is null */ 1788 /* Since we just removed op, op->above is null */
1814 for (tmp = above; tmp != NULL; tmp = tmp->above) 1789 for (tmp = above; tmp != NULL; tmp = tmp->above)
1815 if (tmp->type == PLAYER) 1790 if (tmp->type == PLAYER)
1816 { 1791 {
1817 if (op->nrof) 1792 if (op->nrof)
… …
1820 esrv_del_item (tmp->contr, op->count); 1795 esrv_del_item (tmp->contr, op->count);
1821 } 1796 }
1822 } 1797 }
1823 1798
1824 if (op->nrof) 1799 if (op->nrof)
1825 {
1826 return op; 1800 return op;
1827 }
1828 else 1801 else
1829 { 1802 {
1830 free_object (op); 1803 free_object (op);
1831 return NULL; 1804 return NULL;
1832 } 1805 }
… …
1841add_weight (object *op, signed long weight) 1814add_weight (object *op, signed long weight)
1842{ 1815{
1843 while (op != NULL) 1816 while (op != NULL)
1844 { 1817 {
1845 if (op->type == CONTAINER) 1818 if (op->type == CONTAINER)
1846 {
1847 weight = (signed long) (weight * (100 - op->stats.Str) / 100); 1819 weight = (signed long) (weight * (100 - op->stats.Str) / 100);
1848 } 1820
1849 op->carrying += weight; 1821 op->carrying += weight;
1850 op = op->env; 1822 op = op->env;
1851 } 1823 }
1852} 1824}
1853 1825
… …
1876 { 1848 {
1877 dump_object (op); 1849 dump_object (op);
1878 LOG (llevError, "Trying to insert (ob) inserted object.\n%s\n", errmsg); 1850 LOG (llevError, "Trying to insert (ob) inserted object.\n%s\n", errmsg);
1879 return op; 1851 return op;
1880 } 1852 }
1853
1881 if (where == NULL) 1854 if (where == NULL)
1882 { 1855 {
1883 dump_object (op); 1856 dump_object (op);
1884 LOG (llevError, "Trying to put object in NULL.\n%s\n", errmsg); 1857 LOG (llevError, "Trying to put object in NULL.\n%s\n", errmsg);
1885 return op; 1858 return op;
1886 } 1859 }
1860
1887 if (where->head) 1861 if (where->head)
1888 { 1862 {
1889 LOG (llevDebug, "Warning: Tried to insert object wrong part of multipart object.\n"); 1863 LOG (llevDebug, "Warning: Tried to insert object wrong part of multipart object.\n");
1890 where = where->head; 1864 where = where->head;
1891 } 1865 }
1866
1892 if (op->more) 1867 if (op->more)
1893 { 1868 {
1894 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count); 1869 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count);
1895 return op; 1870 return op;
1896 } 1871 }
1872
1897 CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL); 1873 CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL);
1898 CLEAR_FLAG (op, FLAG_REMOVED); 1874 CLEAR_FLAG (op, FLAG_REMOVED);
1899 if (op->nrof) 1875 if (op->nrof)
1900 { 1876 {
1901 for (tmp = where->inv; tmp != NULL; tmp = tmp->below) 1877 for (tmp = where->inv; tmp != NULL; tmp = tmp->below)
… …
1986 */ 1962 */
1987 1963
1988int 1964int
1989check_move_on (object *op, object *originator) 1965check_move_on (object *op, object *originator)
1990{ 1966{
1991 object *tmp; 1967 object *
1992 tag_t tag; 1968 tmp;
1993 mapstruct *m = op->map; 1969 tag_t
1970 tag;
1971 mapstruct *
1972 m = op->map;
1973 int
1994 int x = op->x, y = op->y; 1974 x = op->x, y = op->y;
1995 1975
1996 MoveType move_on, move_slow, move_block; 1976 MoveType
1977 move_on,
1978 move_slow,
1979 move_block;
1997 1980
1998 if (QUERY_FLAG (op, FLAG_NO_APPLY)) 1981 if (QUERY_FLAG (op, FLAG_NO_APPLY))
1999 return 0; 1982 return 0;
2000 1983
2001 tag = op->count; 1984 tag = op->count;
… …
2049 { 2032 {
2050 if ((!op->move_type && tmp->move_slow & MOVE_WALK) || 2033 if ((!op->move_type && tmp->move_slow & MOVE_WALK) ||
2051 ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0)) 2034 ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0))
2052 { 2035 {
2053 2036
2037 float
2054 float diff = tmp->move_slow_penalty * FABS (op->speed); 2038 diff = tmp->move_slow_penalty * FABS (op->speed);
2055 2039
2056 if (op->type == PLAYER) 2040 if (op->type == PLAYER)
2057 if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) || 2041 if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) ||
2058 (QUERY_FLAG (tmp, FLAG_IS_WOODED) && find_skill_by_number (op, SK_WOODSMAN))) 2042 (QUERY_FLAG (tmp, FLAG_IS_WOODED) && find_skill_by_number (op, SK_WOODSMAN)))
2059 diff /= 4.0; 2043 diff /= 4.0;
… …
2378find_dir (mapstruct *m, int x, int y, object *exclude) 2362find_dir (mapstruct *m, int x, int y, object *exclude)
2379{ 2363{
2380 int 2364 int
2381 i, 2365 i,
2382 max = SIZEOFFREE, mflags; 2366 max = SIZEOFFREE, mflags;
2383 sint16 2367
2384 nx, 2368 sint16 nx, ny;
2385 ny;
2386 object * 2369 object *
2387 tmp; 2370 tmp;
2388 mapstruct * 2371 mapstruct *
2389 mp; 2372 mp;
2390 MoveType 2373
2391 blocked, 2374 MoveType blocked, move_type;
2392 move_type;
2393 2375
2394 if (exclude && exclude->head) 2376 if (exclude && exclude->head)
2395 { 2377 {
2396 exclude = exclude->head; 2378 exclude = exclude->head;
2397 move_type = exclude->move_type; 2379 move_type = exclude->move_type;
… …
2604 2586
2605 2587
2606int 2588int
2607can_see_monsterP (mapstruct *m, int x, int y, int dir) 2589can_see_monsterP (mapstruct *m, int x, int y, int dir)
2608{ 2590{
2609 sint16 2591 sint16 dx, dy;
2610 dx,
2611 dy;
2612 int 2592 int
2613 mflags; 2593 mflags;
2614 2594
2615 if (dir < 0) 2595 if (dir < 0)
2616 return 0; /* exit condition: invalid direction */ 2596 return 0; /* exit condition: invalid direction */
… …
2741 2721
2742 if (tempfile == NULL) 2722 if (tempfile == NULL)
2743 { 2723 {
2744 LOG (llevError, "Error - Unable to access load object temp file\n"); 2724 LOG (llevError, "Error - Unable to access load object temp file\n");
2745 return NULL; 2725 return NULL;
2746 }; 2726 }
2727
2747 fprintf (tempfile, obstr); 2728 fprintf (tempfile, obstr);
2748 fclose (tempfile); 2729 fclose (tempfile);
2749 2730
2750 op = get_object (); 2731 op = get_object ();
2751 2732
2752 object_thawer 2733 object_thawer thawer (filename);
2753 thawer (filename);
2754 2734
2755 if (thawer) 2735 if (thawer)
2756 load_object (thawer, op, 0); 2736 load_object (thawer, op, 0);
2757 2737
2758 LOG (llevDebug, " load str completed, object=%s\n", &op->name); 2738 LOG (llevDebug, " load str completed, object=%s\n", &op->name);
… …
2809 * The returned string is shared. 2789 * The returned string is shared.
2810 */ 2790 */
2811const char * 2791const char *
2812get_ob_key_value (const object *op, const char *const key) 2792get_ob_key_value (const object *op, const char *const key)
2813{ 2793{
2814 key_value * 2794 key_value *link;
2815 link; 2795 shstr_cmp canonical_key (key);
2816 const char *
2817 canonical_key;
2818 2796
2819 canonical_key = shstr::find (key);
2820
2821 if (canonical_key == NULL) 2797 if (!canonical_key)
2822 { 2798 {
2823 /* 1. There being a field named key on any object 2799 /* 1. There being a field named key on any object
2824 * implies there'd be a shared string to find. 2800 * implies there'd be a shared string to find.
2825 * 2. Since there isn't, no object has this field. 2801 * 2. Since there isn't, no object has this field.
2826 * 3. Therefore, *this* object doesn't have this field. 2802 * 3. Therefore, *this* object doesn't have this field.
2827 */ 2803 */
2828 return NULL; 2804 return 0;
2829 } 2805 }
2830 2806
2831 /* This is copied from get_ob_key_link() above - 2807 /* This is copied from get_ob_key_link() above -
2832 * only 4 lines, and saves the function call overhead. 2808 * only 4 lines, and saves the function call overhead.
2833 */ 2809 */
2834 for (link = op->key_values; link != NULL; link = link->next) 2810 for (link = op->key_values; link; link = link->next)
2835 {
2836 if (link->key == canonical_key) 2811 if (link->key == canonical_key)
2837 {
2838 return link->value; 2812 return link->value;
2839 } 2813
2840 }
2841 return NULL; 2814 return 0;
2842} 2815}
2843 2816
2844 2817
2845/* 2818/*
2846 * Updates the canonical_key in op to value. 2819 * Updates the canonical_key in op to value.
… …
2882 if (last) 2855 if (last)
2883 last->next = field->next; 2856 last->next = field->next;
2884 else 2857 else
2885 op->key_values = field->next; 2858 op->key_values = field->next;
2886 2859
2887 delete
2888 field; 2860 delete field;
2889 } 2861 }
2890 } 2862 }
2891 return TRUE; 2863 return TRUE;
2892 } 2864 }
2893 /* IF we get here, key doesn't exist */ 2865 /* IF we get here, key doesn't exist */
… …
2928 * Returns TRUE on success. 2900 * Returns TRUE on success.
2929 */ 2901 */
2930int 2902int
2931set_ob_key_value (object *op, const char *key, const char *value, int add_key) 2903set_ob_key_value (object *op, const char *key, const char *value, int add_key)
2932{ 2904{
2933 shstr
2934 key_ (key); 2905 shstr key_ (key);
2935 2906
2936 return set_ob_key_value_s (op, key_, value, add_key); 2907 return set_ob_key_value_s (op, key_, value, add_key);
2937} 2908}
2909
2910object::depth_iterator::depth_iterator (object *container)
2911: iterator_base (container)
2912{
2913 while (item->inv)
2914 item = item->inv;
2915}
2916
2917void
2918object::depth_iterator::next ()
2919{
2920 if (item->below)
2921 {
2922 item = item->below;
2923
2924 while (item->inv)
2925 item = item->inv;
2926 }
2927 else
2928 item = item->env;
2929}
2930
2931// return a suitable string describing an objetc in enough detail to find it
2932const char *
2933object::debug_desc (char *info) const
2934{
2935 char info2[256 * 3];
2936 char *p = info;
2937
2938 p += snprintf (p, 256, "%d=\"%s%s%s\"",
2939 count,
2940 &name,
2941 title ? " " : "",
2942 title ? (const char *)title : "");
2943
2944 if (env)
2945 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
2946
2947 if (map)
2948 p += snprintf (p, 256, "(on %s@%d+%d)", map->path, x, y);
2949
2950 return info;
2951}
2952
2953const char *
2954object::debug_desc () const
2955{
2956 static char info[256 * 3];
2957 return debug_desc (info);
2958}
2959

Diff Legend

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