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.26 by root, Mon Sep 11 11:46:52 2006 UTC vs.
Revision 1.34 by root, Tue Sep 12 01:09:53 2006 UTC

1
2/*
3 * static char *rcsid_object_c =
4 * "$Id: object.C,v 1.26 2006/09/11 11:46:52 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;
44 37
45object *objects; /* Pointer to the list of used objects */ 38object *objects; /* Pointer to the list of used objects */
46object *active_objects; /* List of active objects that need to be processed */ 39object *active_objects; /* List of active objects that need to be processed */
47 40
… …
214 if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && FABS ((ob1)->speed) > MIN_ACTIVE_SPEED) 207 if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && FABS ((ob1)->speed) > MIN_ACTIVE_SPEED)
215 return 0; 208 return 0;
216 209
217 switch (ob1->type) 210 switch (ob1->type)
218 { 211 {
219 case SCROLL: 212 case SCROLL:
220 if (ob1->level != ob2->level) 213 if (ob1->level != ob2->level)
221 return 0; 214 return 0;
222 break; 215 break;
223 } 216 }
224 217
225 if (ob1->key_values != NULL || ob2->key_values != NULL) 218 if (ob1->key_values != NULL || ob2->key_values != NULL)
226 { 219 {
227 /* At least one of these has key_values. */ 220 /* At least one of these has key_values. */
… …
249/* 242/*
250 * sum_weight() is a recursive function which calculates the weight 243 * sum_weight() is a recursive function which calculates the weight
251 * an object is carrying. It goes through in figures out how much 244 * an object is carrying. It goes through in figures out how much
252 * containers are carrying, and sums it up. 245 * containers are carrying, and sums it up.
253 */ 246 */
254signed long 247long
255sum_weight (object *op) 248sum_weight (object *op)
256{ 249{
257 signed long sum; 250 long sum;
258 object *inv; 251 object *inv;
259 252
260 for (sum = 0, inv = op->inv; inv != NULL; inv = inv->below) 253 for (sum = 0, inv = op->inv; inv != NULL; inv = inv->below)
261 { 254 {
262 if (inv->inv) 255 if (inv->inv)
… …
449 * Changed 2004-02-12 - if the player is setting at the play again 442 * 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 443 * 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 444 * 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. 445 * anything - once an object is removed, it is basically dead anyways.
453 */ 446 */
454
455object * 447object *
456get_owner (object *op) 448object::get_owner ()
457{ 449{
458 if (op->owner == NULL) 450 if (!owner
459 return NULL; 451 || QUERY_FLAG (owner, FLAG_FREED)
452 || QUERY_FLAG (owner, FLAG_REMOVED))
453 owner = 0;
460 454
461 if (!QUERY_FLAG (op->owner, FLAG_FREED) && !QUERY_FLAG (op->owner, FLAG_REMOVED) && op->owner->count == op->ownercount)
462 return op->owner; 455 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} 456}
481 457
482/* 458/*
483 * Sets the owner and sets the skill and exp pointers to owner's current 459 * Sets the owner and sets the skill and exp pointers to owner's current
484 * skill and experience objects. 460 * skill and experience objects.
485 */ 461 */
486void 462void
487set_owner (object *op, object *owner) 463object::set_owner (object *owner)
488{ 464{
489 if (owner == NULL || op == NULL) 465 if (!owner)
490 return; 466 return;
491 467
492 /* next line added to allow objects which own objects */ 468 /* next line added to allow objects which own objects */
493 /* Add a check for ownercounts in here, as I got into an endless loop 469 /* 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 470 * with the fireball owning a poison cloud which then owned the
495 * fireball. I believe that was caused by one of the objects getting 471 * fireball. I believe that was caused by one of the objects getting
496 * freed and then another object replacing it. Since the ownercounts 472 * 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. 473 * didn't match, this check is valid and I believe that cause is valid.
498 */ 474 */
499 while (owner->owner && owner != owner->owner && owner->ownercount == owner->owner->count) 475 while (owner->owner)
500 owner = owner->owner; 476 owner = owner->owner;
501 477
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; 478 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} 479}
542 480
543/* Zero the key_values on op, decrementing the shared-string 481/* Zero the key_values on op, decrementing the shared-string
544 * refcounts and freeing the links. 482 * refcounts and freeing the links.
545 */ 483 */
… …
561{ 499{
562 attachable_base::clear (); 500 attachable_base::clear ();
563 501
564 free_key_values (this); 502 free_key_values (this);
565 503
566 clear_owner (this); 504 owner = 0;
567
568 name = 0; 505 name = 0;
569 name_pl = 0; 506 name_pl = 0;
570 title = 0; 507 title = 0;
571 race = 0; 508 race = 0;
572 slaying = 0; 509 slaying = 0;
573 skill = 0; 510 skill = 0;
574 msg = 0; 511 msg = 0;
575 lore = 0; 512 lore = 0;
576 custom_name = 0; 513 custom_name = 0;
577 materialname = 0; 514 materialname = 0;
515 contr = 0;
516 below = 0;
517 above = 0;
518 inv = 0;
519 container = 0;
520 env = 0;
521 more = 0;
522 head = 0;
523 map = 0;
524 active_next = 0;
525 active_prev = 0;
578 526
579 memset (static_cast < object_pod * >(this), 0, sizeof (object_pod)); 527 memset (static_cast<object_pod *>(this), 0, sizeof (object_pod));
580 528
581 SET_FLAG (this, FLAG_REMOVED); 529 SET_FLAG (this, FLAG_REMOVED);
530
531 /* What is not cleared is next, prev, and count */
532
533 expmul = 1.0;
534 face = blank_face;
535 attacked_by_count = -1;
536
537 if (settings.casting_time)
538 casting_time = -1;
582} 539}
583 540
584void object::clone (object *destination) 541void object::clone (object *destination)
585{ 542{
586 *(object_copy *) destination = *this; 543 *(object_copy *)destination = *this;
587 *(object_pod *) destination = *this; 544 *(object_pod *)destination = *this;
588 545
589 if (self || cb) 546 if (self || cb)
590 INVOKE_OBJECT (CLONE, this, ARG_OBJECT (destination)); 547 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} 548}
624 549
625/* 550/*
626 * copy object first frees everything allocated by the second object, 551 * copy object first frees everything allocated by the second object,
627 * and then copies the contends of the first object into the second 552 * and then copies the contends of the first object into the second
628 * object, allocating what needs to be allocated. Basically, any 553 * object, allocating what needs to be allocated. Basically, any
629 * data that is malloc'd needs to be re-malloc/copied. Otherwise, 554 * 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 555 * if the first object is freed, the pointers in the new object
631 * will point at garbage. 556 * will point at garbage.
632 */ 557 */
633
634void 558void
635copy_object (object *op2, object *op) 559copy_object (object *op2, object *op)
636{ 560{
637 bool is_freed = QUERY_FLAG (op, FLAG_FREED); 561 bool is_freed = QUERY_FLAG (op, FLAG_FREED);
638 bool is_removed = QUERY_FLAG (op, FLAG_REMOVED); 562 bool is_removed = QUERY_FLAG (op, FLAG_REMOVED);
… …
698/* 622/*
699 * Updates the speed of an object. If the speed changes from 0 to another 623 * 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. 624 * 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. 625 * This function needs to be called whenever the speed of an object changes.
702 */ 626 */
703
704void 627void
705update_ob_speed (object *op) 628update_ob_speed (object *op)
706{ 629{
707 extern int arch_init; 630 extern int arch_init;
708 631
… …
717 abort (); 640 abort ();
718#else 641#else
719 op->speed = 0; 642 op->speed = 0;
720#endif 643#endif
721 } 644 }
645
722 if (arch_init) 646 if (arch_init)
723 {
724 return; 647 return;
725 } 648
726 if (FABS (op->speed) > MIN_ACTIVE_SPEED) 649 if (FABS (op->speed) > MIN_ACTIVE_SPEED)
727 { 650 {
728 /* If already on active list, don't do anything */ 651 /* If already on active list, don't do anything */
729 if (op->active_next || op->active_prev || op == active_objects) 652 if (op->active_next || op->active_prev || op == active_objects)
730 return; 653 return;
731 654
732 /* process_events() expects us to insert the object at the beginning 655 /* process_events() expects us to insert the object at the beginning
733 * of the list. */ 656 * of the list. */
734 op->active_next = active_objects; 657 op->active_next = active_objects;
658
735 if (op->active_next != NULL) 659 if (op->active_next != NULL)
736 op->active_next->active_prev = op; 660 op->active_next->active_prev = op;
661
737 active_objects = op; 662 active_objects = op;
738 } 663 }
739 else 664 else
740 { 665 {
741 /* If not on the active list, nothing needs to be done */ 666 /* If not on the active list, nothing needs to be done */
… …
743 return; 668 return;
744 669
745 if (op->active_prev == NULL) 670 if (op->active_prev == NULL)
746 { 671 {
747 active_objects = op->active_next; 672 active_objects = op->active_next;
673
748 if (op->active_next != NULL) 674 if (op->active_next != NULL)
749 op->active_next->active_prev = NULL; 675 op->active_next->active_prev = NULL;
750 } 676 }
751 else 677 else
752 { 678 {
753 op->active_prev->active_next = op->active_next; 679 op->active_prev->active_next = op->active_next;
680
754 if (op->active_next) 681 if (op->active_next)
755 op->active_next->active_prev = op->active_prev; 682 op->active_next->active_prev = op->active_prev;
756 } 683 }
684
757 op->active_next = NULL; 685 op->active_next = NULL;
758 op->active_prev = NULL; 686 op->active_prev = NULL;
759 } 687 }
760} 688}
761 689
… …
891 /* if the object is being removed, we can't make intelligent 819 /* if the object is being removed, we can't make intelligent
892 * decisions, because remove_ob can't really pass the object 820 * decisions, because remove_ob can't really pass the object
893 * that is being removed. 821 * that is being removed.
894 */ 822 */
895 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE) 823 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE)
896 {
897 update_now = 1; 824 update_now = 1;
898 }
899 else if (action == UP_OBJ_FACE) 825 else if (action == UP_OBJ_FACE)
900 {
901 /* Nothing to do for that case */ 826 /* Nothing to do for that case */ ;
902 }
903 else 827 else
904 {
905 LOG (llevError, "update_object called with invalid action: %d\n", action); 828 LOG (llevError, "update_object called with invalid action: %d\n", action);
906 }
907 829
908 if (update_now) 830 if (update_now)
909 { 831 {
910 SET_MAP_FLAGS (op->map, op->x, op->y, flags | P_NO_ERROR | P_NEED_UPDATE); 832 SET_MAP_FLAGS (op->map, op->x, op->y, flags | P_NO_ERROR | P_NEED_UPDATE);
911 update_position (op->map, op->x, op->y); 833 update_position (op->map, op->x, op->y);
… …
918static unordered_vector<object *> mortals; 840static unordered_vector<object *> mortals;
919static std::vector<object *> freed; 841static std::vector<object *> freed;
920 842
921void object::free_mortals () 843void object::free_mortals ()
922{ 844{
923 for (unordered_vector<object *>::iterator i = mortals.begin (); i != mortals.end (); ) 845 for (unordered_vector<object *>::iterator i = mortals.begin (); i != mortals.end ();)
924 if (!(*i)->refcount) 846 if ((*i)->refcnt)
847 ++i; // further delay freeing
848 else
925 { 849 {
926 freed.push_back (*i); 850 freed.push_back (*i);//D
851 //delete *i;
927 mortals.erase (i); 852 mortals.erase (i);
928 } 853 }
929 else 854
930 ++i; 855 if (mortals.size())//D
856 LOG (llevDebug, "%d objects in mortal queue\n", mortals.size());//D
931} 857}
932 858
933object::object () 859object::object ()
934{ 860{
935 SET_FLAG (this, FLAG_REMOVED); 861 SET_FLAG (this, FLAG_REMOVED);
… …
985 if (freed.empty ()) 911 if (freed.empty ())
986 op = new object; 912 op = new object;
987 else 913 else
988 { 914 {
989 // highly annoying, but the only way to get it stable right now 915 // highly annoying, but the only way to get it stable right now
990 op = freed.back (); freed.pop_back (); 916 op = freed.back ();
917 freed.pop_back ();
991 op->~object (); 918 op->~object ();
992 new ((void *)op) object; 919 new ((void *) op) object;
993 } 920 }
994 921
995 op->link (); 922 op->link ();
996 return op; 923 return op;
997} 924}
… …
1006 * If free_inventory is set, free inventory as well. Else drop items in 933 * If free_inventory is set, free inventory as well. Else drop items in
1007 * inventory to the ground. 934 * inventory to the ground.
1008 */ 935 */
1009void object::free (bool free_inventory) 936void object::free (bool free_inventory)
1010{ 937{
938 if (QUERY_FLAG (this, FLAG_FREED))
939 return;
940
941 if (QUERY_FLAG (this, FLAG_FRIENDLY))
942 remove_friendly_object (this);
943
1011 if (!QUERY_FLAG (this, FLAG_REMOVED)) 944 if (!QUERY_FLAG (this, FLAG_REMOVED))
1012 { 945 remove_ob (this);
1013 LOG (llevDebug, "Free object called with non removed object\n");
1014 dump_object (this);
1015#ifdef MANY_CORES
1016 abort ();
1017#endif
1018 }
1019 946
1020 if (QUERY_FLAG (this, FLAG_FRIENDLY))
1021 {
1022 LOG (llevMonster, "Warning: tried to free friendly object.\n");
1023 remove_friendly_object (this);
1024 }
1025
1026 if (QUERY_FLAG (this, FLAG_FREED)) 947 SET_FLAG (this, FLAG_FREED);
1027 {
1028 dump_object (this);
1029 LOG (llevError, "Trying to free freed object.\n%s\n", errmsg);
1030 return;
1031 }
1032 948
1033 if (more) 949 if (more)
1034 { 950 {
1035 more->free (free_inventory); 951 more->free (free_inventory);
1036 more = 0; 952 more = 0;
… …
1040 { 956 {
1041 /* Only if the space blocks everything do we not process - 957 /* Only if the space blocks everything do we not process -
1042 * if some form of movement is allowed, let objects 958 * if some form of movement is allowed, let objects
1043 * drop on that space. 959 * drop on that space.
1044 */ 960 */
1045 if (free_inventory || !map || map->in_memory != MAP_IN_MEMORY || (GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL)) 961 if (free_inventory || !map || map->in_memory != MAP_IN_MEMORY || GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL)
1046 { 962 {
1047 object * 963 object *op = inv;
1048 op = inv;
1049 964
1050 while (op) 965 while (op)
1051 { 966 {
1052 object *
1053 tmp = op->below; 967 object *tmp = op->below;
1054
1055 remove_ob (op);
1056 op->free (free_inventory); 968 op->free (free_inventory);
1057 op = tmp; 969 op = tmp;
1058 } 970 }
1059 } 971 }
1060 else 972 else
1061 { /* Put objects in inventory onto this space */ 973 { /* Put objects in inventory onto this space */
1062 object * 974 object *op = inv;
1063 op = inv;
1064 975
1065 while (op) 976 while (op)
1066 { 977 {
1067 object *
1068 tmp = op->below; 978 object *tmp = op->below;
1069 979
1070 remove_ob (op); 980 remove_ob (op);
1071 981
1072 if (QUERY_FLAG (op, FLAG_STARTEQUIP) 982 if (QUERY_FLAG (op, FLAG_STARTEQUIP)
1073 || QUERY_FLAG (op, FLAG_NO_DROP) || op->type == RUNE || op->type == TRAP || QUERY_FLAG (op, FLAG_IS_A_TEMPLATE)) 983 || QUERY_FLAG (op, FLAG_NO_DROP) || op->type == RUNE || op->type == TRAP || QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))
… …
1082 op = tmp; 992 op = tmp;
1083 } 993 }
1084 } 994 }
1085 } 995 }
1086 996
1087 clear_owner (this); 997 owner = 0;
1088 998
1089 /* Remove object from the active list */ 999 /* Remove object from the active list */
1090 speed = 0; 1000 speed = 0;
1091 update_ob_speed (this); 1001 update_ob_speed (this);
1092 1002
1093 unlink (); 1003 unlink ();
1094
1095 SET_FLAG (this, FLAG_FREED);
1096 1004
1097 mortals.push_back (this); 1005 mortals.push_back (this);
1098} 1006}
1099 1007
1100/* 1008/*
… …
1126 */ 1034 */
1127 1035
1128void 1036void
1129remove_ob (object *op) 1037remove_ob (object *op)
1130{ 1038{
1131 object *tmp, *last = NULL;
1132 object *otmp; 1039 object *
1040 tmp, *
1041 last = NULL;
1042 object *
1043 otmp;
1133 1044
1134 tag_t tag; 1045 tag_t
1046 tag;
1047 int
1135 int check_walk_off; 1048 check_walk_off;
1136 mapstruct *m; 1049 mapstruct *
1050 m;
1137 1051
1138 sint16 x, y; 1052 sint16
1053 x,
1054 y;
1139 1055
1140 if (QUERY_FLAG (op, FLAG_REMOVED)) 1056 if (QUERY_FLAG (op, FLAG_REMOVED))
1141 { 1057 return;
1142 dump_object (op);
1143 LOG (llevError, "Trying to remove removed object.\n%s\n", errmsg);
1144 1058
1145 /* Changed it to always dump core in this case. As has been learned 1059 SET_FLAG (op, FLAG_REMOVED);
1146 * in the past, trying to recover from errors almost always
1147 * make things worse, and this is a real error here - something
1148 * that should not happen.
1149 * Yes, if this was a mission critical app, trying to do something
1150 * to recover may make sense, but that is because failure of the app
1151 * may have other disastrous problems. Cf runs out of a script
1152 * so is easily enough restarted without any real problems.
1153 * MSW 2001-07-01
1154 */
1155 abort ();
1156 }
1157 1060
1158 if (op->more != NULL) 1061 if (op->more != NULL)
1159 remove_ob (op->more); 1062 remove_ob (op->more);
1160
1161 SET_FLAG (op, FLAG_REMOVED);
1162 1063
1163 /* 1064 /*
1164 * In this case, the object to be removed is in someones 1065 * In this case, the object to be removed is in someones
1165 * inventory. 1066 * inventory.
1166 */ 1067 */
… …
1192 */ 1093 */
1193 op->x = op->env->x, op->y = op->env->y; 1094 op->x = op->env->x, op->y = op->env->y;
1194 op->map = op->env->map; 1095 op->map = op->env->map;
1195 op->above = NULL, op->below = NULL; 1096 op->above = NULL, op->below = NULL;
1196 op->env = NULL; 1097 op->env = NULL;
1197 return; 1098 }
1099 else if (op->map)
1198 } 1100 {
1199
1200 /* If we get here, we are removing it from a map */
1201 if (op->map == NULL)
1202 return;
1203
1204 x = op->x; 1101 x = op->x;
1205 y = op->y; 1102 y = op->y;
1206 m = get_map_from_coord (op->map, &x, &y); 1103 m = get_map_from_coord (op->map, &x, &y);
1207 1104
1208 if (!m) 1105 if (!m)
1209 { 1106 {
1210 LOG (llevError, "remove_ob called when object was on map but appears to not be within valid coordinates? %s (%d,%d)\n", 1107 LOG (llevError, "remove_ob called when object was on map but appears to not be within valid coordinates? %s (%d,%d)\n",
1211 op->map->path, op->x, op->y); 1108 op->map->path, op->x, op->y);
1212 /* in old days, we used to set x and y to 0 and continue. 1109 /* in old days, we used to set x and y to 0 and continue.
1213 * it seems if we get into this case, something is probablye 1110 * it seems if we get into this case, something is probablye
1214 * screwed up and should be fixed. 1111 * screwed up and should be fixed.
1112 */
1113 abort ();
1114 }
1115
1116 if (op->map != m)
1117 LOG (llevDebug, "remove_ob: Object not really on map it claimed to be on? %s != %s, %d,%d != %d,%d\n",
1118 op->map->path, m->path, op->x, op->y, x, y);
1119
1120 /* Re did the following section of code - it looks like it had
1121 * lots of logic for things we no longer care about
1215 */ 1122 */
1216 abort ();
1217 }
1218 if (op->map != m)
1219 {
1220 LOG (llevDebug, "remove_ob: Object not really on map it claimed to be on? %s != %s, %d,%d != %d,%d\n",
1221 op->map->path, m->path, op->x, op->y, x, y);
1222 }
1223 1123
1224 /* Re did the following section of code - it looks like it had
1225 * lots of logic for things we no longer care about
1226 */
1227
1228 /* link the object above us */ 1124 /* link the object above us */
1229 if (op->above) 1125 if (op->above)
1230 op->above->below = op->below; 1126 op->above->below = op->below;
1231 else 1127 else
1232 SET_MAP_TOP (m, x, y, op->below); /* we were top, set new top */ 1128 SET_MAP_TOP (m, x, y, op->below); /* we were top, set new top */
1233 1129
1234 /* Relink the object below us, if there is one */ 1130 /* Relink the object below us, if there is one */
1235 if (op->below) 1131 if (op->below)
1236 op->below->above = op->above; 1132 op->below->above = op->above;
1237 else 1133 else
1238 { 1134 {
1239 /* Nothing below, which means we need to relink map object for this space 1135 /* Nothing below, which means we need to relink map object for this space
1240 * use translated coordinates in case some oddness with map tiling is 1136 * use translated coordinates in case some oddness with map tiling is
1241 * evident 1137 * evident
1242 */
1243 if (GET_MAP_OB (m, x, y) != op)
1244 {
1245 dump_object (op);
1246 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",
1247 errmsg);
1248 dump_object (GET_MAP_OB (m, x, y));
1249 LOG (llevError, "%s\n", errmsg);
1250 }
1251
1252 SET_MAP_OB (m, x, y, op->above); /* goes on above it. */
1253 }
1254
1255 op->above = NULL;
1256 op->below = NULL;
1257
1258 if (op->map->in_memory == MAP_SAVING)
1259 return;
1260
1261 tag = op->count;
1262 check_walk_off = !QUERY_FLAG (op, FLAG_NO_APPLY);
1263
1264 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
1265 {
1266 /* No point updating the players look faces if he is the object
1267 * being removed.
1268 */
1269
1270 if (tmp->type == PLAYER && tmp != op)
1271 {
1272 /* If a container that the player is currently using somehow gets
1273 * removed (most likely destroyed), update the player view
1274 * appropriately.
1275 */ 1138 */
1276 if (tmp->container == op) 1139 if (GET_MAP_OB (m, x, y) != op)
1277 { 1140 {
1278 CLEAR_FLAG (op, FLAG_APPLIED); 1141 dump_object (op);
1279 tmp->container = NULL; 1142 LOG (llevError,
1143 "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);
1144 dump_object (GET_MAP_OB (m, x, y));
1145 LOG (llevError, "%s\n", errmsg);
1280 } 1146 }
1281 1147
1282 tmp->contr->socket.update_look = 1; 1148 SET_MAP_OB (m, x, y, op->above); /* goes on above it. */
1283 }
1284 /* See if player moving off should effect something */
1285 if (check_walk_off && ((op->move_type & tmp->move_off) && (op->move_type & ~tmp->move_off & ~tmp->move_block) == 0))
1286 { 1149 }
1287 move_apply (tmp, op, NULL);
1288 1150
1289 if (was_destroyed (op, tag)) 1151 op->above = 0;
1152 op->below = 0;
1153
1154 if (op->map->in_memory == MAP_SAVING)
1155 return;
1156
1157 tag = op->count;
1158 check_walk_off = !QUERY_FLAG (op, FLAG_NO_APPLY);
1159
1160 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
1161 {
1162 /* No point updating the players look faces if he is the object
1163 * being removed.
1164 */
1165
1166 if (tmp->type == PLAYER && tmp != op)
1290 { 1167 {
1291 LOG (llevError, "BUG: remove_ob(): name %s, archname %s destroyed " "leaving object\n", &tmp->name, &tmp->arch->name); 1168 /* If a container that the player is currently using somehow gets
1169 * removed (most likely destroyed), update the player view
1170 * appropriately.
1171 */
1172 if (tmp->container == op)
1173 {
1174 CLEAR_FLAG (op, FLAG_APPLIED);
1175 tmp->container = NULL;
1176 }
1177
1178 tmp->contr->socket.update_look = 1;
1292 } 1179 }
1180
1181 /* See if player moving off should effect something */
1182 if (check_walk_off && ((op->move_type & tmp->move_off) && (op->move_type & ~tmp->move_off & ~tmp->move_block) == 0))
1183 {
1184 move_apply (tmp, op, NULL);
1185
1186 if (was_destroyed (op, tag))
1187 {
1188 LOG (llevError, "BUG: remove_ob(): name %s, archname %s destroyed " "leaving object\n", &tmp->name, &tmp->arch->name);
1189 }
1293 } 1190 }
1294 1191
1295 /* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */ 1192 /* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */
1296 1193
1297 if (tmp->above == tmp) 1194 if (tmp->above == tmp)
1298 tmp->above = NULL; 1195 tmp->above = NULL;
1299 1196
1300 last = tmp; 1197 last = tmp;
1301 } 1198 }
1302 1199
1303 /* last == NULL of there are no objects on this space */ 1200 /* last == NULL of there are no objects on this space */
1304 if (last == NULL) 1201 if (last == NULL)
1305 { 1202 {
1306 /* set P_NEED_UPDATE, otherwise update_position will complain. In theory, 1203 /* set P_NEED_UPDATE, otherwise update_position will complain. In theory,
1307 * we could preserve the flags (GET_MAP_FLAGS), but update_position figures 1204 * we could preserve the flags (GET_MAP_FLAGS), but update_position figures
1308 * those out anyways, and if there are any flags set right now, they won't 1205 * those out anyways, and if there are any flags set right now, they won't
1309 * be correct anyways. 1206 * be correct anyways.
1310 */ 1207 */
1311 SET_MAP_FLAGS (op->map, op->x, op->y, P_NEED_UPDATE); 1208 SET_MAP_FLAGS (op->map, op->x, op->y, P_NEED_UPDATE);
1312 update_position (op->map, op->x, op->y); 1209 update_position (op->map, op->x, op->y);
1313 } 1210 }
1314 else 1211 else
1315 update_object (last, UP_OBJ_REMOVE); 1212 update_object (last, UP_OBJ_REMOVE);
1316 1213
1317 if (QUERY_FLAG (op, FLAG_BLOCKSVIEW) || (op->glow_radius != 0)) 1214 if (QUERY_FLAG (op, FLAG_BLOCKSVIEW) || (op->glow_radius != 0))
1318 update_all_los (op->map, op->x, op->y); 1215 update_all_los (op->map, op->x, op->y);
1216 }
1319} 1217}
1320 1218
1321/* 1219/*
1322 * merge_ob(op,top): 1220 * merge_ob(op,top):
1323 * 1221 *
… …
1330object * 1228object *
1331merge_ob (object *op, object *top) 1229merge_ob (object *op, object *top)
1332{ 1230{
1333 if (!op->nrof) 1231 if (!op->nrof)
1334 return 0; 1232 return 0;
1233
1335 if (top == NULL) 1234 if (top == NULL)
1336 for (top = op; top != NULL && top->above != NULL; top = top->above); 1235 for (top = op; top != NULL && top->above != NULL; top = top->above);
1236
1337 for (; top != NULL; top = top->below) 1237 for (; top != NULL; top = top->below)
1338 { 1238 {
1339 if (top == op) 1239 if (top == op)
1340 continue; 1240 continue;
1341 if (CAN_MERGE (op, top)) 1241 if (CAN_MERGE (op, top))
… …
1347 remove_ob (op); 1247 remove_ob (op);
1348 free_object (op); 1248 free_object (op);
1349 return top; 1249 return top;
1350 } 1250 }
1351 } 1251 }
1252
1352 return NULL; 1253 return NULL;
1353} 1254}
1354 1255
1355/* 1256/*
1356 * same as insert_ob_in_map except it handle separate coordinates and do a clean 1257 * same as insert_ob_in_map except it handle separate coordinates and do a clean
1357 * job preparing multi-part monsters 1258 * job preparing multi-part monsters
1358 */ 1259 */
1359object * 1260object *
1360insert_ob_in_map_at (object *op, mapstruct *m, object *originator, int flag, int x, int y) 1261insert_ob_in_map_at (object *op, mapstruct *m, object *originator, int flag, int x, int y)
1361{ 1262{
1362 object * 1263 object *tmp;
1363 tmp;
1364 1264
1365 if (op->head) 1265 if (op->head)
1366 op = op->head; 1266 op = op->head;
1267
1367 for (tmp = op; tmp; tmp = tmp->more) 1268 for (tmp = op; tmp; tmp = tmp->more)
1368 { 1269 {
1369 tmp->x = x + tmp->arch->clone.x; 1270 tmp->x = x + tmp->arch->clone.x;
1370 tmp->y = y + tmp->arch->clone.y; 1271 tmp->y = y + tmp->arch->clone.y;
1371 } 1272 }
1273
1372 return insert_ob_in_map (op, m, originator, flag); 1274 return insert_ob_in_map (op, m, originator, flag);
1373} 1275}
1374 1276
1375/* 1277/*
1376 * insert_ob_in_map (op, map, originator, flag): 1278 * insert_ob_in_map (op, map, originator, flag):
… …
1667 * op is the object to insert it under: supplies x and the map. 1569 * op is the object to insert it under: supplies x and the map.
1668 */ 1570 */
1669void 1571void
1670replace_insert_ob_in_map (const char *arch_string, object *op) 1572replace_insert_ob_in_map (const char *arch_string, object *op)
1671{ 1573{
1672 object *tmp; 1574 object *
1575 tmp;
1673 object *tmp1; 1576 object *
1577 tmp1;
1674 1578
1675 /* first search for itself and remove any old instances */ 1579 /* first search for itself and remove any old instances */
1676 1580
1677 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 1581 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
1678 { 1582 {
… …
1709 if (orig_ob->nrof < nr) 1613 if (orig_ob->nrof < nr)
1710 { 1614 {
1711 sprintf (errmsg, "There are only %d %ss.", orig_ob->nrof ? orig_ob->nrof : 1, &orig_ob->name); 1615 sprintf (errmsg, "There are only %d %ss.", orig_ob->nrof ? orig_ob->nrof : 1, &orig_ob->name);
1712 return NULL; 1616 return NULL;
1713 } 1617 }
1618
1714 newob = object_create_clone (orig_ob); 1619 newob = object_create_clone (orig_ob);
1620
1715 if ((orig_ob->nrof -= nr) < 1) 1621 if ((orig_ob->nrof -= nr) < 1)
1716 { 1622 {
1717 if (!is_removed) 1623 if (!is_removed)
1718 remove_ob (orig_ob); 1624 remove_ob (orig_ob);
1719 free_object2 (orig_ob, 1); 1625 free_object2 (orig_ob, 1);
… …
1727 strcpy (errmsg, "Tried to split object whose map is not in memory."); 1633 strcpy (errmsg, "Tried to split object whose map is not in memory.");
1728 LOG (llevDebug, "Error, Tried to split object whose map is not in memory.\n"); 1634 LOG (llevDebug, "Error, Tried to split object whose map is not in memory.\n");
1729 return NULL; 1635 return NULL;
1730 } 1636 }
1731 } 1637 }
1638
1732 newob->nrof = nr; 1639 newob->nrof = nr;
1733 1640
1734 return newob; 1641 return newob;
1735} 1642}
1736 1643
… …
1743 */ 1650 */
1744 1651
1745object * 1652object *
1746decrease_ob_nr (object *op, uint32 i) 1653decrease_ob_nr (object *op, uint32 i)
1747{ 1654{
1748 object * 1655 object *tmp;
1749 tmp;
1750 player * 1656 player *pl;
1751 pl;
1752 1657
1753 if (i == 0) /* objects with op->nrof require this check */ 1658 if (i == 0) /* objects with op->nrof require this check */
1754 return op; 1659 return op;
1755 1660
1756 if (i > op->nrof) 1661 if (i > op->nrof)
1757 i = op->nrof; 1662 i = op->nrof;
1758 1663
1759 if (QUERY_FLAG (op, FLAG_REMOVED)) 1664 if (QUERY_FLAG (op, FLAG_REMOVED))
1760 {
1761 op->nrof -= i; 1665 op->nrof -= i;
1762 }
1763 else if (op->env != NULL) 1666 else if (op->env != NULL)
1764 { 1667 {
1765 /* is this object in the players inventory, or sub container 1668 /* is this object in the players inventory, or sub container
1766 * therein? 1669 * therein?
1767 */ 1670 */
… …
1802 } 1705 }
1803 } 1706 }
1804 } 1707 }
1805 else 1708 else
1806 { 1709 {
1807 object *
1808 above = op->above; 1710 object *above = op->above;
1809 1711
1810 if (i < op->nrof) 1712 if (i < op->nrof)
1811 {
1812 op->nrof -= i; 1713 op->nrof -= i;
1813 }
1814 else 1714 else
1815 { 1715 {
1816 remove_ob (op); 1716 remove_ob (op);
1817 op->nrof = 0; 1717 op->nrof = 0;
1818 } 1718 }
1719
1819 /* Since we just removed op, op->above is null */ 1720 /* Since we just removed op, op->above is null */
1820 for (tmp = above; tmp != NULL; tmp = tmp->above) 1721 for (tmp = above; tmp != NULL; tmp = tmp->above)
1821 if (tmp->type == PLAYER) 1722 if (tmp->type == PLAYER)
1822 { 1723 {
1823 if (op->nrof) 1724 if (op->nrof)
… …
1826 esrv_del_item (tmp->contr, op->count); 1727 esrv_del_item (tmp->contr, op->count);
1827 } 1728 }
1828 } 1729 }
1829 1730
1830 if (op->nrof) 1731 if (op->nrof)
1831 {
1832 return op; 1732 return op;
1833 }
1834 else 1733 else
1835 { 1734 {
1836 free_object (op); 1735 free_object (op);
1837 return NULL; 1736 return NULL;
1838 } 1737 }
… …
1847add_weight (object *op, signed long weight) 1746add_weight (object *op, signed long weight)
1848{ 1747{
1849 while (op != NULL) 1748 while (op != NULL)
1850 { 1749 {
1851 if (op->type == CONTAINER) 1750 if (op->type == CONTAINER)
1852 {
1853 weight = (signed long) (weight * (100 - op->stats.Str) / 100); 1751 weight = (signed long) (weight * (100 - op->stats.Str) / 100);
1854 } 1752
1855 op->carrying += weight; 1753 op->carrying += weight;
1856 op = op->env; 1754 op = op->env;
1857 } 1755 }
1858} 1756}
1859 1757
… …
1882 { 1780 {
1883 dump_object (op); 1781 dump_object (op);
1884 LOG (llevError, "Trying to insert (ob) inserted object.\n%s\n", errmsg); 1782 LOG (llevError, "Trying to insert (ob) inserted object.\n%s\n", errmsg);
1885 return op; 1783 return op;
1886 } 1784 }
1785
1887 if (where == NULL) 1786 if (where == NULL)
1888 { 1787 {
1889 dump_object (op); 1788 dump_object (op);
1890 LOG (llevError, "Trying to put object in NULL.\n%s\n", errmsg); 1789 LOG (llevError, "Trying to put object in NULL.\n%s\n", errmsg);
1891 return op; 1790 return op;
1892 } 1791 }
1792
1893 if (where->head) 1793 if (where->head)
1894 { 1794 {
1895 LOG (llevDebug, "Warning: Tried to insert object wrong part of multipart object.\n"); 1795 LOG (llevDebug, "Warning: Tried to insert object wrong part of multipart object.\n");
1896 where = where->head; 1796 where = where->head;
1897 } 1797 }
1798
1898 if (op->more) 1799 if (op->more)
1899 { 1800 {
1900 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count); 1801 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count);
1901 return op; 1802 return op;
1902 } 1803 }
1804
1903 CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL); 1805 CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL);
1904 CLEAR_FLAG (op, FLAG_REMOVED); 1806 CLEAR_FLAG (op, FLAG_REMOVED);
1905 if (op->nrof) 1807 if (op->nrof)
1906 { 1808 {
1907 for (tmp = where->inv; tmp != NULL; tmp = tmp->below) 1809 for (tmp = where->inv; tmp != NULL; tmp = tmp->below)
… …
1992 */ 1894 */
1993 1895
1994int 1896int
1995check_move_on (object *op, object *originator) 1897check_move_on (object *op, object *originator)
1996{ 1898{
1997 object *tmp; 1899 object *
1998 tag_t tag; 1900 tmp;
1999 mapstruct *m = op->map; 1901 tag_t
1902 tag;
1903 mapstruct *
1904 m = op->map;
1905 int
2000 int x = op->x, y = op->y; 1906 x = op->x, y = op->y;
2001 1907
2002 MoveType move_on, move_slow, move_block; 1908 MoveType
1909 move_on,
1910 move_slow,
1911 move_block;
2003 1912
2004 if (QUERY_FLAG (op, FLAG_NO_APPLY)) 1913 if (QUERY_FLAG (op, FLAG_NO_APPLY))
2005 return 0; 1914 return 0;
2006 1915
2007 tag = op->count; 1916 tag = op->count;
… …
2055 { 1964 {
2056 if ((!op->move_type && tmp->move_slow & MOVE_WALK) || 1965 if ((!op->move_type && tmp->move_slow & MOVE_WALK) ||
2057 ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0)) 1966 ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0))
2058 { 1967 {
2059 1968
1969 float
2060 float diff = tmp->move_slow_penalty * FABS (op->speed); 1970 diff = tmp->move_slow_penalty * FABS (op->speed);
2061 1971
2062 if (op->type == PLAYER) 1972 if (op->type == PLAYER)
2063 if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) || 1973 if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) ||
2064 (QUERY_FLAG (tmp, FLAG_IS_WOODED) && find_skill_by_number (op, SK_WOODSMAN))) 1974 (QUERY_FLAG (tmp, FLAG_IS_WOODED) && find_skill_by_number (op, SK_WOODSMAN)))
2065 diff /= 4.0; 1975 diff /= 4.0;
… …
2384find_dir (mapstruct *m, int x, int y, object *exclude) 2294find_dir (mapstruct *m, int x, int y, object *exclude)
2385{ 2295{
2386 int 2296 int
2387 i, 2297 i,
2388 max = SIZEOFFREE, mflags; 2298 max = SIZEOFFREE, mflags;
2389 sint16 2299
2390 nx, 2300 sint16 nx, ny;
2391 ny;
2392 object * 2301 object *
2393 tmp; 2302 tmp;
2394 mapstruct * 2303 mapstruct *
2395 mp; 2304 mp;
2396 MoveType 2305
2397 blocked, 2306 MoveType blocked, move_type;
2398 move_type;
2399 2307
2400 if (exclude && exclude->head) 2308 if (exclude && exclude->head)
2401 { 2309 {
2402 exclude = exclude->head; 2310 exclude = exclude->head;
2403 move_type = exclude->move_type; 2311 move_type = exclude->move_type;
… …
2610 2518
2611 2519
2612int 2520int
2613can_see_monsterP (mapstruct *m, int x, int y, int dir) 2521can_see_monsterP (mapstruct *m, int x, int y, int dir)
2614{ 2522{
2615 sint16 2523 sint16 dx, dy;
2616 dx,
2617 dy;
2618 int 2524 int
2619 mflags; 2525 mflags;
2620 2526
2621 if (dir < 0) 2527 if (dir < 0)
2622 return 0; /* exit condition: invalid direction */ 2528 return 0; /* exit condition: invalid direction */
… …
2753 fprintf (tempfile, obstr); 2659 fprintf (tempfile, obstr);
2754 fclose (tempfile); 2660 fclose (tempfile);
2755 2661
2756 op = get_object (); 2662 op = get_object ();
2757 2663
2758 object_thawer 2664 object_thawer thawer (filename);
2759 thawer (filename);
2760 2665
2761 if (thawer) 2666 if (thawer)
2762 load_object (thawer, op, 0); 2667 load_object (thawer, op, 0);
2763 2668
2764 LOG (llevDebug, " load str completed, object=%s\n", &op->name); 2669 LOG (llevDebug, " load str completed, object=%s\n", &op->name);
… …
2888 if (last) 2793 if (last)
2889 last->next = field->next; 2794 last->next = field->next;
2890 else 2795 else
2891 op->key_values = field->next; 2796 op->key_values = field->next;
2892 2797
2893 delete
2894 field; 2798 delete field;
2895 } 2799 }
2896 } 2800 }
2897 return TRUE; 2801 return TRUE;
2898 } 2802 }
2899 /* IF we get here, key doesn't exist */ 2803 /* IF we get here, key doesn't exist */
… …
2934 * Returns TRUE on success. 2838 * Returns TRUE on success.
2935 */ 2839 */
2936int 2840int
2937set_ob_key_value (object *op, const char *key, const char *value, int add_key) 2841set_ob_key_value (object *op, const char *key, const char *value, int add_key)
2938{ 2842{
2939 shstr
2940 key_ (key); 2843 shstr key_ (key);
2941 2844
2942 return set_ob_key_value_s (op, key_, value, add_key); 2845 return set_ob_key_value_s (op, key_, value, add_key);
2943} 2846}
2847
2848object::depth_iterator::depth_iterator (object *container)
2849: iterator_base (container)
2850{
2851 while (item->inv)
2852 item = item->inv;
2853}
2854
2855void
2856object::depth_iterator::next ()
2857{
2858 if (item->below)
2859 {
2860 item = item->below;
2861
2862 while (item->inv)
2863 item = item->inv;
2864 }
2865 else
2866 item = item->env;
2867}
2868

Diff Legend

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