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.25 by root, Mon Sep 11 01:16:20 2006 UTC vs.
Revision 1.31 by root, Mon Sep 11 23:33:27 2006 UTC

1
2/*
3 * static char *rcsid_object_c =
4 * "$Id: object.C,v 1.25 2006/09/11 01:16:20 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> 34#include <skills.h>
42#include <loader.h> 35#include <loader.h>
36
43int nrofallocobjects = 0; 37int nrofallocobjects = 0;
44 38
45object *objects; /* Pointer to the list of used objects */ 39object *objects; /* Pointer to the list of used objects */
46object *active_objects; /* List of active objects that need to be processed */ 40object *active_objects; /* List of active objects that need to be processed */
47 41
… …
214 if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && FABS ((ob1)->speed) > MIN_ACTIVE_SPEED) 208 if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && FABS ((ob1)->speed) > MIN_ACTIVE_SPEED)
215 return 0; 209 return 0;
216 210
217 switch (ob1->type) 211 switch (ob1->type)
218 { 212 {
219 case SCROLL: 213 case SCROLL:
220 if (ob1->level != ob2->level) 214 if (ob1->level != ob2->level)
221 return 0; 215 return 0;
222 break; 216 break;
223 } 217 }
224 218
225 if (ob1->key_values != NULL || ob2->key_values != NULL) 219 if (ob1->key_values != NULL || ob2->key_values != NULL)
226 { 220 {
227 /* At least one of these has key_values. */ 221 /* At least one of these has key_values. */
… …
249/* 243/*
250 * sum_weight() is a recursive function which calculates the weight 244 * sum_weight() is a recursive function which calculates the weight
251 * an object is carrying. It goes through in figures out how much 245 * an object is carrying. It goes through in figures out how much
252 * containers are carrying, and sums it up. 246 * containers are carrying, and sums it up.
253 */ 247 */
254signed long 248long
255sum_weight (object *op) 249sum_weight (object *op)
256{ 250{
257 signed long sum; 251 long sum;
258 object *inv; 252 object *inv;
259 253
260 for (sum = 0, inv = op->inv; inv != NULL; inv = inv->below) 254 for (sum = 0, inv = op->inv; inv != NULL; inv = inv->below)
261 { 255 {
262 if (inv->inv) 256 if (inv->inv)
… …
449 * Changed 2004-02-12 - if the player is setting at the play again 443 * 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 444 * 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 445 * 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. 446 * anything - once an object is removed, it is basically dead anyways.
453 */ 447 */
454
455object * 448object *
456get_owner (object *op) 449object::get_owner ()
457{ 450{
458 if (op->owner == NULL) 451 if (!owner
459 return NULL; 452 || QUERY_FLAG (owner, FLAG_FREED)
453 || QUERY_FLAG (owner, FLAG_REMOVED))
454 owner = 0;
460 455
461 if (!QUERY_FLAG (op->owner, FLAG_FREED) && !QUERY_FLAG (op->owner, FLAG_REMOVED) && op->owner->count == op->ownercount)
462 return op->owner; 456 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} 457}
481 458
482/* 459/*
483 * Sets the owner and sets the skill and exp pointers to owner's current 460 * Sets the owner and sets the skill and exp pointers to owner's current
484 * skill and experience objects. 461 * skill and experience objects.
485 */ 462 */
486void 463void
487set_owner (object *op, object *owner) 464object::set_owner (object *owner)
488{ 465{
489 if (owner == NULL || op == NULL) 466 if (!owner)
490 return; 467 return;
491 468
492 /* next line added to allow objects which own objects */ 469 /* next line added to allow objects which own objects */
493 /* Add a check for ownercounts in here, as I got into an endless loop 470 /* 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 471 * with the fireball owning a poison cloud which then owned the
495 * fireball. I believe that was caused by one of the objects getting 472 * fireball. I believe that was caused by one of the objects getting
496 * freed and then another object replacing it. Since the ownercounts 473 * 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. 474 * didn't match, this check is valid and I believe that cause is valid.
498 */ 475 */
499 while (owner->owner && owner != owner->owner && owner->ownercount == owner->owner->count) 476 while (owner->owner)
500 owner = owner->owner; 477 owner = owner->owner;
501 478
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; 479 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} 480}
542 481
543/* Zero the key_values on op, decrementing the shared-string 482/* Zero the key_values on op, decrementing the shared-string
544 * refcounts and freeing the links. 483 * refcounts and freeing the links.
545 */ 484 */
… …
561{ 500{
562 attachable_base::clear (); 501 attachable_base::clear ();
563 502
564 free_key_values (this); 503 free_key_values (this);
565 504
566 clear_owner (this); 505 owner = 0;
567
568 name = 0; 506 name = 0;
569 name_pl = 0; 507 name_pl = 0;
570 title = 0; 508 title = 0;
571 race = 0; 509 race = 0;
572 slaying = 0; 510 slaying = 0;
573 skill = 0; 511 skill = 0;
574 msg = 0; 512 msg = 0;
575 lore = 0; 513 lore = 0;
576 custom_name = 0; 514 custom_name = 0;
577 materialname = 0; 515 materialname = 0;
516 contr = 0;
517 below = 0;
518 above = 0;
519 inv = 0;
520 container = 0;
521 env = 0;
522 more = 0;
523 head = 0;
524 map = 0;
525 active_next = 0;
526 active_prev = 0;
578 527
579 memset (static_cast < object_pod * >(this), 0, sizeof (object_pod)); 528 memset (static_cast<object_pod *>(this), 0, sizeof (object_pod));
580 529
581 SET_FLAG (this, FLAG_REMOVED); 530 SET_FLAG (this, FLAG_REMOVED);
531
532 /* What is not cleared is next, prev, and count */
533
534 expmul = 1.0;
535 face = blank_face;
536 attacked_by_count = -1;
537
538 if (settings.casting_time)
539 casting_time = -1;
582} 540}
583 541
584void object::clone (object *destination) 542void object::clone (object *destination)
585{ 543{
586 *(object_copy *) destination = *this; 544 *(object_copy *)destination = *this;
587 *(object_pod *) destination = *this; 545 *(object_pod *)destination = *this;
588 546
589 if (self || cb) 547 if (self || cb)
590 INVOKE_OBJECT (CLONE, this, ARG_OBJECT (destination)); 548 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} 549}
624 550
625/* 551/*
626 * copy object first frees everything allocated by the second object, 552 * copy object first frees everything allocated by the second object,
627 * and then copies the contends of the first object into the second 553 * and then copies the contends of the first object into the second
628 * object, allocating what needs to be allocated. Basically, any 554 * object, allocating what needs to be allocated. Basically, any
629 * data that is malloc'd needs to be re-malloc/copied. Otherwise, 555 * 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 556 * if the first object is freed, the pointers in the new object
631 * will point at garbage. 557 * will point at garbage.
632 */ 558 */
633
634void 559void
635copy_object (object *op2, object *op) 560copy_object (object *op2, object *op)
636{ 561{
637 bool is_freed = QUERY_FLAG (op, FLAG_FREED); 562 bool is_freed = QUERY_FLAG (op, FLAG_FREED);
638 bool is_removed = QUERY_FLAG (op, FLAG_REMOVED); 563 bool is_removed = QUERY_FLAG (op, FLAG_REMOVED);
… …
698/* 623/*
699 * Updates the speed of an object. If the speed changes from 0 to another 624 * 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. 625 * 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. 626 * This function needs to be called whenever the speed of an object changes.
702 */ 627 */
703
704void 628void
705update_ob_speed (object *op) 629update_ob_speed (object *op)
706{ 630{
707 extern int arch_init; 631 extern int arch_init;
708 632
… …
717 abort (); 641 abort ();
718#else 642#else
719 op->speed = 0; 643 op->speed = 0;
720#endif 644#endif
721 } 645 }
646
722 if (arch_init) 647 if (arch_init)
723 {
724 return; 648 return;
725 } 649
726 if (FABS (op->speed) > MIN_ACTIVE_SPEED) 650 if (FABS (op->speed) > MIN_ACTIVE_SPEED)
727 { 651 {
728 /* If already on active list, don't do anything */ 652 /* If already on active list, don't do anything */
729 if (op->active_next || op->active_prev || op == active_objects) 653 if (op->active_next || op->active_prev || op == active_objects)
730 return; 654 return;
731 655
732 /* process_events() expects us to insert the object at the beginning 656 /* process_events() expects us to insert the object at the beginning
733 * of the list. */ 657 * of the list. */
734 op->active_next = active_objects; 658 op->active_next = active_objects;
659
735 if (op->active_next != NULL) 660 if (op->active_next != NULL)
736 op->active_next->active_prev = op; 661 op->active_next->active_prev = op;
662
737 active_objects = op; 663 active_objects = op;
738 } 664 }
739 else 665 else
740 { 666 {
741 /* If not on the active list, nothing needs to be done */ 667 /* If not on the active list, nothing needs to be done */
… …
743 return; 669 return;
744 670
745 if (op->active_prev == NULL) 671 if (op->active_prev == NULL)
746 { 672 {
747 active_objects = op->active_next; 673 active_objects = op->active_next;
674
748 if (op->active_next != NULL) 675 if (op->active_next != NULL)
749 op->active_next->active_prev = NULL; 676 op->active_next->active_prev = NULL;
750 } 677 }
751 else 678 else
752 { 679 {
753 op->active_prev->active_next = op->active_next; 680 op->active_prev->active_next = op->active_next;
681
754 if (op->active_next) 682 if (op->active_next)
755 op->active_next->active_prev = op->active_prev; 683 op->active_next->active_prev = op->active_prev;
756 } 684 }
685
757 op->active_next = NULL; 686 op->active_next = NULL;
758 op->active_prev = NULL; 687 op->active_prev = NULL;
759 } 688 }
760} 689}
761 690
… …
891 /* if the object is being removed, we can't make intelligent 820 /* if the object is being removed, we can't make intelligent
892 * decisions, because remove_ob can't really pass the object 821 * decisions, because remove_ob can't really pass the object
893 * that is being removed. 822 * that is being removed.
894 */ 823 */
895 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE) 824 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE)
896 {
897 update_now = 1; 825 update_now = 1;
898 }
899 else if (action == UP_OBJ_FACE) 826 else if (action == UP_OBJ_FACE)
900 {
901 /* Nothing to do for that case */ 827 /* Nothing to do for that case */ ;
902 }
903 else 828 else
904 {
905 LOG (llevError, "update_object called with invalid action: %d\n", action); 829 LOG (llevError, "update_object called with invalid action: %d\n", action);
906 }
907 830
908 if (update_now) 831 if (update_now)
909 { 832 {
910 SET_MAP_FLAGS (op->map, op->x, op->y, flags | P_NO_ERROR | P_NEED_UPDATE); 833 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); 834 update_position (op->map, op->x, op->y);
… …
918static unordered_vector<object *> mortals; 841static unordered_vector<object *> mortals;
919static std::vector<object *> freed; 842static std::vector<object *> freed;
920 843
921void object::free_mortals () 844void object::free_mortals ()
922{ 845{
923 for (unordered_vector<object *>::iterator i = mortals.begin (); i != mortals.end (); ) 846 for (unordered_vector<object *>::iterator i = mortals.begin (); i != mortals.end ();)
924 if (!(*i)->refcount) 847 if ((*i)->refcnt)
848 ++i; // further delay freeing
849 else
925 { 850 {
926 freed.push_back (*i); 851 freed.push_back (*i);//D
852 //delete *i;
927 mortals.erase (i); 853 mortals.erase (i);
928 } 854 }
929 else 855
930 ++i; 856 if (mortals.size())//D
857 LOG (llevDebug, "%d objects in mortal queue\n", mortals.size());//D
931} 858}
932 859
933object::object () 860object::object ()
934{ 861{
935 SET_FLAG (this, FLAG_REMOVED); 862 SET_FLAG (this, FLAG_REMOVED);
… …
978 objects = next; 905 objects = next;
979} 906}
980 907
981object *object::create () 908object *object::create ()
982{ 909{
983 object *op; 910 object *
911 op;
984 912
985 if (freed.empty ()) 913 if (freed.empty ())
986 op = new object; 914 op = new object;
987 else 915 else
988 { 916 {
989 // highly annoying, but the only way to get it stable right now 917 // highly annoying, but the only way to get it stable right now
990 op = freed.back (); freed.pop_back (); 918 op = freed.back ();
919 freed.pop_back ();
991 op->~object (); 920 op->~object ();
992 new ((void *)op) object; 921 new ((void *) op) object;
993 } 922 }
994 923
995 op->link (); 924 op->link ();
996 return op; 925 return op;
997} 926}
… …
1006 * If free_inventory is set, free inventory as well. Else drop items in 935 * If free_inventory is set, free inventory as well. Else drop items in
1007 * inventory to the ground. 936 * inventory to the ground.
1008 */ 937 */
1009void object::free (bool free_inventory) 938void object::free (bool free_inventory)
1010{ 939{
940 if (QUERY_FLAG (this, FLAG_FREED))
941 return;
942
1011 if (!QUERY_FLAG (this, FLAG_REMOVED)) 943 if (!QUERY_FLAG (this, FLAG_REMOVED))
1012 { 944 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 945
1020 if (QUERY_FLAG (this, FLAG_FRIENDLY)) 946 if (QUERY_FLAG (this, FLAG_FRIENDLY))
1021 {
1022 LOG (llevMonster, "Warning: tried to free friendly object.\n");
1023 remove_friendly_object (this); 947 remove_friendly_object (this);
1024 }
1025 948
1026 if (QUERY_FLAG (this, FLAG_FREED)) 949 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 950
1033 if (more) 951 if (more)
1034 { 952 {
1035 more->free (free_inventory); 953 more->free (free_inventory);
1036 more = 0; 954 more = 0;
… …
1042 * if some form of movement is allowed, let objects 960 * if some form of movement is allowed, let objects
1043 * drop on that space. 961 * drop on that space.
1044 */ 962 */
1045 if (free_inventory || !map || map->in_memory != MAP_IN_MEMORY || (GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL)) 963 if (free_inventory || !map || map->in_memory != MAP_IN_MEMORY || (GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL))
1046 { 964 {
1047 object * 965 object *op = inv;
1048 op = inv;
1049 966
1050 while (op) 967 while (op)
1051 { 968 {
1052 object *
1053 tmp = op->below; 969 object *tmp = op->below;
1054
1055 remove_ob (op);
1056 op->free (free_inventory); 970 op->free (free_inventory);
1057 op = tmp; 971 op = tmp;
1058 } 972 }
1059 } 973 }
1060 else 974 else
1061 { /* Put objects in inventory onto this space */ 975 { /* Put objects in inventory onto this space */
1062 object * 976 object *op = inv;
1063 op = inv;
1064 977
1065 while (op) 978 while (op)
1066 { 979 {
1067 object *
1068 tmp = op->below; 980 object *tmp = op->below;
1069 981
1070 remove_ob (op); 982 remove_ob (op);
1071 983
1072 if (QUERY_FLAG (op, FLAG_STARTEQUIP) 984 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)) 985 || QUERY_FLAG (op, FLAG_NO_DROP) || op->type == RUNE || op->type == TRAP || QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))
… …
1082 op = tmp; 994 op = tmp;
1083 } 995 }
1084 } 996 }
1085 } 997 }
1086 998
1087 clear_owner (this); 999 owner = 0;
1088 1000
1089 /* Remove object from the active list */ 1001 /* Remove object from the active list */
1090 speed = 0; 1002 speed = 0;
1091 update_ob_speed (this); 1003 update_ob_speed (this);
1092 1004
1093 unlink (); 1005 unlink ();
1094
1095 SET_FLAG (this, FLAG_FREED);
1096 1006
1097 mortals.push_back (this); 1007 mortals.push_back (this);
1098} 1008}
1099 1009
1100/* 1010/*
… …
1131 object * 1041 object *
1132 tmp, * 1042 tmp, *
1133 last = NULL; 1043 last = NULL;
1134 object * 1044 object *
1135 otmp; 1045 otmp;
1046
1136 tag_t 1047 tag_t
1137 tag; 1048 tag;
1138 int 1049 int
1139 check_walk_off; 1050 check_walk_off;
1140 mapstruct * 1051 mapstruct *
1141 m; 1052 m;
1053
1142 sint16 1054 sint16
1143 x, 1055 x,
1144 y; 1056 y;
1145 1057
1146
1147 if (QUERY_FLAG (op, FLAG_REMOVED)) 1058 if (QUERY_FLAG (op, FLAG_REMOVED))
1148 { 1059 return;
1149 dump_object (op);
1150 LOG (llevError, "Trying to remove removed object.\n%s\n", errmsg);
1151 1060
1152 /* Changed it to always dump core in this case. As has been learned 1061 SET_FLAG (op, FLAG_REMOVED);
1153 * in the past, trying to recover from errors almost always 1062
1154 * make things worse, and this is a real error here - something
1155 * that should not happen.
1156 * Yes, if this was a mission critical app, trying to do something
1157 * to recover may make sense, but that is because failure of the app
1158 * may have other disastrous problems. Cf runs out of a script
1159 * so is easily enough restarted without any real problems.
1160 * MSW 2001-07-01
1161 */
1162 abort ();
1163 }
1164 if (op->more != NULL) 1063 if (op->more != NULL)
1165 remove_ob (op->more); 1064 remove_ob (op->more);
1166
1167 SET_FLAG (op, FLAG_REMOVED);
1168 1065
1169 /* 1066 /*
1170 * In this case, the object to be removed is in someones 1067 * In this case, the object to be removed is in someones
1171 * inventory. 1068 * inventory.
1172 */ 1069 */
… …
1198 */ 1095 */
1199 op->x = op->env->x, op->y = op->env->y; 1096 op->x = op->env->x, op->y = op->env->y;
1200 op->map = op->env->map; 1097 op->map = op->env->map;
1201 op->above = NULL, op->below = NULL; 1098 op->above = NULL, op->below = NULL;
1202 op->env = NULL; 1099 op->env = NULL;
1203 return; 1100 }
1101 else if (op->map)
1204 } 1102 {
1205
1206 /* If we get here, we are removing it from a map */
1207 if (op->map == NULL)
1208 return;
1209
1210 x = op->x; 1103 x = op->x;
1211 y = op->y; 1104 y = op->y;
1212 m = get_map_from_coord (op->map, &x, &y); 1105 m = get_map_from_coord (op->map, &x, &y);
1213 1106
1214 if (!m) 1107 if (!m)
1215 { 1108 {
1216 LOG (llevError, "remove_ob called when object was on map but appears to not be within valid coordinates? %s (%d,%d)\n", 1109 LOG (llevError, "remove_ob called when object was on map but appears to not be within valid coordinates? %s (%d,%d)\n",
1217 op->map->path, op->x, op->y); 1110 op->map->path, op->x, op->y);
1218 /* in old days, we used to set x and y to 0 and continue. 1111 /* in old days, we used to set x and y to 0 and continue.
1219 * it seems if we get into this case, something is probablye 1112 * it seems if we get into this case, something is probablye
1220 * screwed up and should be fixed. 1113 * screwed up and should be fixed.
1114 */
1115 abort ();
1116 }
1117
1118 if (op->map != m)
1119 LOG (llevDebug, "remove_ob: Object not really on map it claimed to be on? %s != %s, %d,%d != %d,%d\n",
1120 op->map->path, m->path, op->x, op->y, x, y);
1121
1122 /* Re did the following section of code - it looks like it had
1123 * lots of logic for things we no longer care about
1221 */ 1124 */
1222 abort ();
1223 }
1224 if (op->map != m)
1225 {
1226 LOG (llevDebug, "remove_ob: Object not really on map it claimed to be on? %s != %s, %d,%d != %d,%d\n",
1227 op->map->path, m->path, op->x, op->y, x, y);
1228 }
1229 1125
1230 /* Re did the following section of code - it looks like it had
1231 * lots of logic for things we no longer care about
1232 */
1233
1234 /* link the object above us */ 1126 /* link the object above us */
1235 if (op->above) 1127 if (op->above)
1236 op->above->below = op->below; 1128 op->above->below = op->below;
1237 else 1129 else
1238 SET_MAP_TOP (m, x, y, op->below); /* we were top, set new top */ 1130 SET_MAP_TOP (m, x, y, op->below); /* we were top, set new top */
1239 1131
1240 /* Relink the object below us, if there is one */ 1132 /* Relink the object below us, if there is one */
1241 if (op->below) 1133 if (op->below)
1242 {
1243 op->below->above = op->above; 1134 op->below->above = op->above;
1244 }
1245 else 1135 else
1246 { 1136 {
1247 /* Nothing below, which means we need to relink map object for this space 1137 /* Nothing below, which means we need to relink map object for this space
1248 * use translated coordinates in case some oddness with map tiling is 1138 * use translated coordinates in case some oddness with map tiling is
1249 * evident 1139 * evident
1250 */
1251 if (GET_MAP_OB (m, x, y) != op)
1252 {
1253 dump_object (op);
1254 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",
1255 errmsg);
1256 dump_object (GET_MAP_OB (m, x, y));
1257 LOG (llevError, "%s\n", errmsg);
1258 }
1259 SET_MAP_OB (m, x, y, op->above); /* goes on above it. */
1260 }
1261 op->above = NULL;
1262 op->below = NULL;
1263
1264 if (op->map->in_memory == MAP_SAVING)
1265 return;
1266
1267 tag = op->count;
1268 check_walk_off = !QUERY_FLAG (op, FLAG_NO_APPLY);
1269 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
1270 {
1271 /* No point updating the players look faces if he is the object
1272 * being removed.
1273 */
1274
1275 if (tmp->type == PLAYER && tmp != op)
1276 {
1277 /* If a container that the player is currently using somehow gets
1278 * removed (most likely destroyed), update the player view
1279 * appropriately.
1280 */ 1140 */
1281 if (tmp->container == op) 1141 if (GET_MAP_OB (m, x, y) != op)
1282 { 1142 {
1283 CLEAR_FLAG (op, FLAG_APPLIED); 1143 dump_object (op);
1284 tmp->container = NULL; 1144 LOG (llevError,
1145 "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);
1146 dump_object (GET_MAP_OB (m, x, y));
1147 LOG (llevError, "%s\n", errmsg);
1285 } 1148 }
1286 tmp->contr->socket.update_look = 1; 1149
1287 } 1150 SET_MAP_OB (m, x, y, op->above); /* goes on above it. */
1288 /* See if player moving off should effect something */
1289 if (check_walk_off && ((op->move_type & tmp->move_off) && (op->move_type & ~tmp->move_off & ~tmp->move_block) == 0))
1290 { 1151 }
1291 1152
1292 move_apply (tmp, op, NULL); 1153 op->above = 0;
1293 if (was_destroyed (op, tag)) 1154 op->below = 0;
1155
1156 if (op->map->in_memory == MAP_SAVING)
1157 return;
1158
1159 tag = op->count;
1160 check_walk_off = !QUERY_FLAG (op, FLAG_NO_APPLY);
1161
1162 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
1163 {
1164 /* No point updating the players look faces if he is the object
1165 * being removed.
1166 */
1167
1168 if (tmp->type == PLAYER && tmp != op)
1294 { 1169 {
1295 LOG (llevError, "BUG: remove_ob(): name %s, archname %s destroyed " "leaving object\n", &tmp->name, &tmp->arch->name); 1170 /* If a container that the player is currently using somehow gets
1171 * removed (most likely destroyed), update the player view
1172 * appropriately.
1173 */
1174 if (tmp->container == op)
1175 {
1176 CLEAR_FLAG (op, FLAG_APPLIED);
1177 tmp->container = NULL;
1178 }
1179
1180 tmp->contr->socket.update_look = 1;
1296 } 1181 }
1182
1183 /* See if player moving off should effect something */
1184 if (check_walk_off && ((op->move_type & tmp->move_off) && (op->move_type & ~tmp->move_off & ~tmp->move_block) == 0))
1185 {
1186 move_apply (tmp, op, NULL);
1187
1188 if (was_destroyed (op, tag))
1189 {
1190 LOG (llevError, "BUG: remove_ob(): name %s, archname %s destroyed " "leaving object\n", &tmp->name, &tmp->arch->name);
1191 }
1297 } 1192 }
1298 1193
1299 /* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */ 1194 /* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */
1300 1195
1301 if (tmp->above == tmp) 1196 if (tmp->above == tmp)
1302 tmp->above = NULL; 1197 tmp->above = NULL;
1198
1303 last = tmp; 1199 last = tmp;
1304 } 1200 }
1201
1305 /* last == NULL of there are no objects on this space */ 1202 /* last == NULL of there are no objects on this space */
1306 if (last == NULL) 1203 if (last == NULL)
1307 { 1204 {
1308 /* set P_NEED_UPDATE, otherwise update_position will complain. In theory, 1205 /* set P_NEED_UPDATE, otherwise update_position will complain. In theory,
1309 * we could preserve the flags (GET_MAP_FLAGS), but update_position figures 1206 * we could preserve the flags (GET_MAP_FLAGS), but update_position figures
1310 * those out anyways, and if there are any flags set right now, they won't 1207 * those out anyways, and if there are any flags set right now, they won't
1311 * be correct anyways. 1208 * be correct anyways.
1312 */ 1209 */
1313 SET_MAP_FLAGS (op->map, op->x, op->y, P_NEED_UPDATE); 1210 SET_MAP_FLAGS (op->map, op->x, op->y, P_NEED_UPDATE);
1314 update_position (op->map, op->x, op->y); 1211 update_position (op->map, op->x, op->y);
1315 } 1212 }
1316 else 1213 else
1317 update_object (last, UP_OBJ_REMOVE); 1214 update_object (last, UP_OBJ_REMOVE);
1318 1215
1319 if (QUERY_FLAG (op, FLAG_BLOCKSVIEW) || (op->glow_radius != 0)) 1216 if (QUERY_FLAG (op, FLAG_BLOCKSVIEW) || (op->glow_radius != 0))
1320 update_all_los (op->map, op->x, op->y); 1217 update_all_los (op->map, op->x, op->y);
1321 1218 }
1322} 1219}
1323 1220
1324/* 1221/*
1325 * merge_ob(op,top): 1222 * merge_ob(op,top):
1326 * 1223 *
… …
1333object * 1230object *
1334merge_ob (object *op, object *top) 1231merge_ob (object *op, object *top)
1335{ 1232{
1336 if (!op->nrof) 1233 if (!op->nrof)
1337 return 0; 1234 return 0;
1235
1338 if (top == NULL) 1236 if (top == NULL)
1339 for (top = op; top != NULL && top->above != NULL; top = top->above); 1237 for (top = op; top != NULL && top->above != NULL; top = top->above);
1238
1340 for (; top != NULL; top = top->below) 1239 for (; top != NULL; top = top->below)
1341 { 1240 {
1342 if (top == op) 1241 if (top == op)
1343 continue; 1242 continue;
1344 if (CAN_MERGE (op, top)) 1243 if (CAN_MERGE (op, top))
… …
1350 remove_ob (op); 1249 remove_ob (op);
1351 free_object (op); 1250 free_object (op);
1352 return top; 1251 return top;
1353 } 1252 }
1354 } 1253 }
1254
1355 return NULL; 1255 return NULL;
1356} 1256}
1357 1257
1358/* 1258/*
1359 * same as insert_ob_in_map except it handle separate coordinates and do a clean 1259 * same as insert_ob_in_map except it handle separate coordinates and do a clean
1360 * job preparing multi-part monsters 1260 * job preparing multi-part monsters
1361 */ 1261 */
1362object * 1262object *
1363insert_ob_in_map_at (object *op, mapstruct *m, object *originator, int flag, int x, int y) 1263insert_ob_in_map_at (object *op, mapstruct *m, object *originator, int flag, int x, int y)
1364{ 1264{
1365 object * 1265 object *tmp;
1366 tmp;
1367 1266
1368 if (op->head) 1267 if (op->head)
1369 op = op->head; 1268 op = op->head;
1269
1370 for (tmp = op; tmp; tmp = tmp->more) 1270 for (tmp = op; tmp; tmp = tmp->more)
1371 { 1271 {
1372 tmp->x = x + tmp->arch->clone.x; 1272 tmp->x = x + tmp->arch->clone.x;
1373 tmp->y = y + tmp->arch->clone.y; 1273 tmp->y = y + tmp->arch->clone.y;
1374 } 1274 }
1275
1375 return insert_ob_in_map (op, m, originator, flag); 1276 return insert_ob_in_map (op, m, originator, flag);
1376} 1277}
1377 1278
1378/* 1279/*
1379 * insert_ob_in_map (op, map, originator, flag): 1280 * insert_ob_in_map (op, map, originator, flag):
… …
1438 1339
1439 if (op->more != NULL) 1340 if (op->more != NULL)
1440 { 1341 {
1441 /* The part may be on a different map. */ 1342 /* The part may be on a different map. */
1442 1343
1443 object *
1444 more = op->more; 1344 object *more = op->more;
1445 1345
1446 /* We really need the caller to normalize coordinates - if 1346 /* We really need the caller to normalize coordinates - if
1447 * we set the map, that doesn't work if the location is within 1347 * we set the map, that doesn't work if the location is within
1448 * a map and this is straddling an edge. So only if coordinate 1348 * a map and this is straddling an edge. So only if coordinate
1449 * is clear wrong do we normalize it. 1349 * is clear wrong do we normalize it.
1450 */ 1350 */
1451 if (OUT_OF_REAL_MAP (more->map, more->x, more->y)) 1351 if (OUT_OF_REAL_MAP (more->map, more->x, more->y))
1452 {
1453 more->map = get_map_from_coord (m, &more->x, &more->y); 1352 more->map = get_map_from_coord (m, &more->x, &more->y);
1454 }
1455 else if (!more->map) 1353 else if (!more->map)
1456 { 1354 {
1457 /* For backwards compatibility - when not dealing with tiled maps, 1355 /* For backwards compatibility - when not dealing with tiled maps,
1458 * more->map should always point to the parent. 1356 * more->map should always point to the parent.
1459 */ 1357 */
… …
1462 1360
1463 if (insert_ob_in_map (more, more->map, originator, flag) == NULL) 1361 if (insert_ob_in_map (more, more->map, originator, flag) == NULL)
1464 { 1362 {
1465 if (!op->head) 1363 if (!op->head)
1466 LOG (llevError, "BUG: insert_ob_in_map(): inserting op->more killed op\n"); 1364 LOG (llevError, "BUG: insert_ob_in_map(): inserting op->more killed op\n");
1365
1467 return NULL; 1366 return NULL;
1468 } 1367 }
1469 } 1368 }
1470 1369
1471 CLEAR_FLAG (op, FLAG_REMOVED); 1370 CLEAR_FLAG (op, FLAG_REMOVED);
… …
1536 1435
1537 while (top != NULL) 1436 while (top != NULL)
1538 { 1437 {
1539 if (QUERY_FLAG (top, FLAG_IS_FLOOR) || QUERY_FLAG (top, FLAG_OVERLAY_FLOOR)) 1438 if (QUERY_FLAG (top, FLAG_IS_FLOOR) || QUERY_FLAG (top, FLAG_OVERLAY_FLOOR))
1540 floor = top; 1439 floor = top;
1440
1541 if (QUERY_FLAG (top, FLAG_NO_PICK) && (top->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !QUERY_FLAG (top, FLAG_IS_FLOOR)) 1441 if (QUERY_FLAG (top, FLAG_NO_PICK) && (top->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !QUERY_FLAG (top, FLAG_IS_FLOOR))
1542 { 1442 {
1543 /* We insert above top, so we want this object below this */ 1443 /* We insert above top, so we want this object below this */
1544 top = top->below; 1444 top = top->below;
1545 break; 1445 break;
1546 } 1446 }
1447
1547 last = top; 1448 last = top;
1548 top = top->above; 1449 top = top->above;
1549 } 1450 }
1451
1550 /* Don't want top to be NULL, so set it to the last valid object */ 1452 /* Don't want top to be NULL, so set it to the last valid object */
1551 top = last; 1453 top = last;
1552 1454
1553 /* We let update_position deal with figuring out what the space 1455 /* We let update_position deal with figuring out what the space
1554 * looks like instead of lots of conditions here. 1456 * looks like instead of lots of conditions here.
… …
1633 * of effect may be sufficient. 1535 * of effect may be sufficient.
1634 */ 1536 */
1635 if (MAP_DARKNESS (op->map) && (op->glow_radius != 0)) 1537 if (MAP_DARKNESS (op->map) && (op->glow_radius != 0))
1636 update_all_los (op->map, op->x, op->y); 1538 update_all_los (op->map, op->x, op->y);
1637 1539
1638
1639 /* updates flags (blocked, alive, no magic, etc) for this map space */ 1540 /* updates flags (blocked, alive, no magic, etc) for this map space */
1640 update_object (op, UP_OBJ_INSERT); 1541 update_object (op, UP_OBJ_INSERT);
1641
1642 1542
1643 /* Don't know if moving this to the end will break anything. However, 1543 /* Don't know if moving this to the end will break anything. However,
1644 * we want to have update_look set above before calling this. 1544 * we want to have update_look set above before calling this.
1645 * 1545 *
1646 * check_move_on() must be after this because code called from 1546 * check_move_on() must be after this because code called from
… …
1671 * op is the object to insert it under: supplies x and the map. 1571 * op is the object to insert it under: supplies x and the map.
1672 */ 1572 */
1673void 1573void
1674replace_insert_ob_in_map (const char *arch_string, object *op) 1574replace_insert_ob_in_map (const char *arch_string, object *op)
1675{ 1575{
1676 object *tmp; 1576 object *
1577 tmp;
1677 object *tmp1; 1578 object *
1579 tmp1;
1678 1580
1679 /* first search for itself and remove any old instances */ 1581 /* first search for itself and remove any old instances */
1680 1582
1681 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 1583 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
1682 { 1584 {
… …
1713 if (orig_ob->nrof < nr) 1615 if (orig_ob->nrof < nr)
1714 { 1616 {
1715 sprintf (errmsg, "There are only %d %ss.", orig_ob->nrof ? orig_ob->nrof : 1, &orig_ob->name); 1617 sprintf (errmsg, "There are only %d %ss.", orig_ob->nrof ? orig_ob->nrof : 1, &orig_ob->name);
1716 return NULL; 1618 return NULL;
1717 } 1619 }
1620
1718 newob = object_create_clone (orig_ob); 1621 newob = object_create_clone (orig_ob);
1622
1719 if ((orig_ob->nrof -= nr) < 1) 1623 if ((orig_ob->nrof -= nr) < 1)
1720 { 1624 {
1721 if (!is_removed) 1625 if (!is_removed)
1722 remove_ob (orig_ob); 1626 remove_ob (orig_ob);
1723 free_object2 (orig_ob, 1); 1627 free_object2 (orig_ob, 1);
… …
1731 strcpy (errmsg, "Tried to split object whose map is not in memory."); 1635 strcpy (errmsg, "Tried to split object whose map is not in memory.");
1732 LOG (llevDebug, "Error, Tried to split object whose map is not in memory.\n"); 1636 LOG (llevDebug, "Error, Tried to split object whose map is not in memory.\n");
1733 return NULL; 1637 return NULL;
1734 } 1638 }
1735 } 1639 }
1640
1736 newob->nrof = nr; 1641 newob->nrof = nr;
1737 1642
1738 return newob; 1643 return newob;
1739} 1644}
1740 1645
… …
1747 */ 1652 */
1748 1653
1749object * 1654object *
1750decrease_ob_nr (object *op, uint32 i) 1655decrease_ob_nr (object *op, uint32 i)
1751{ 1656{
1752 object * 1657 object *tmp;
1753 tmp;
1754 player * 1658 player *pl;
1755 pl;
1756 1659
1757 if (i == 0) /* objects with op->nrof require this check */ 1660 if (i == 0) /* objects with op->nrof require this check */
1758 return op; 1661 return op;
1759 1662
1760 if (i > op->nrof) 1663 if (i > op->nrof)
1761 i = op->nrof; 1664 i = op->nrof;
1762 1665
1763 if (QUERY_FLAG (op, FLAG_REMOVED)) 1666 if (QUERY_FLAG (op, FLAG_REMOVED))
1764 {
1765 op->nrof -= i; 1667 op->nrof -= i;
1766 }
1767 else if (op->env != NULL) 1668 else if (op->env != NULL)
1768 { 1669 {
1769 /* is this object in the players inventory, or sub container 1670 /* is this object in the players inventory, or sub container
1770 * therein? 1671 * therein?
1771 */ 1672 */
… …
1806 } 1707 }
1807 } 1708 }
1808 } 1709 }
1809 else 1710 else
1810 { 1711 {
1811 object *
1812 above = op->above; 1712 object *above = op->above;
1813 1713
1814 if (i < op->nrof) 1714 if (i < op->nrof)
1815 {
1816 op->nrof -= i; 1715 op->nrof -= i;
1817 }
1818 else 1716 else
1819 { 1717 {
1820 remove_ob (op); 1718 remove_ob (op);
1821 op->nrof = 0; 1719 op->nrof = 0;
1822 } 1720 }
1721
1823 /* Since we just removed op, op->above is null */ 1722 /* Since we just removed op, op->above is null */
1824 for (tmp = above; tmp != NULL; tmp = tmp->above) 1723 for (tmp = above; tmp != NULL; tmp = tmp->above)
1825 if (tmp->type == PLAYER) 1724 if (tmp->type == PLAYER)
1826 { 1725 {
1827 if (op->nrof) 1726 if (op->nrof)
… …
1830 esrv_del_item (tmp->contr, op->count); 1729 esrv_del_item (tmp->contr, op->count);
1831 } 1730 }
1832 } 1731 }
1833 1732
1834 if (op->nrof) 1733 if (op->nrof)
1835 {
1836 return op; 1734 return op;
1837 }
1838 else 1735 else
1839 { 1736 {
1840 free_object (op); 1737 free_object (op);
1841 return NULL; 1738 return NULL;
1842 } 1739 }
… …
1851add_weight (object *op, signed long weight) 1748add_weight (object *op, signed long weight)
1852{ 1749{
1853 while (op != NULL) 1750 while (op != NULL)
1854 { 1751 {
1855 if (op->type == CONTAINER) 1752 if (op->type == CONTAINER)
1856 {
1857 weight = (signed long) (weight * (100 - op->stats.Str) / 100); 1753 weight = (signed long) (weight * (100 - op->stats.Str) / 100);
1858 } 1754
1859 op->carrying += weight; 1755 op->carrying += weight;
1860 op = op->env; 1756 op = op->env;
1861 } 1757 }
1862} 1758}
1863 1759
… …
1886 { 1782 {
1887 dump_object (op); 1783 dump_object (op);
1888 LOG (llevError, "Trying to insert (ob) inserted object.\n%s\n", errmsg); 1784 LOG (llevError, "Trying to insert (ob) inserted object.\n%s\n", errmsg);
1889 return op; 1785 return op;
1890 } 1786 }
1787
1891 if (where == NULL) 1788 if (where == NULL)
1892 { 1789 {
1893 dump_object (op); 1790 dump_object (op);
1894 LOG (llevError, "Trying to put object in NULL.\n%s\n", errmsg); 1791 LOG (llevError, "Trying to put object in NULL.\n%s\n", errmsg);
1895 return op; 1792 return op;
1896 } 1793 }
1794
1897 if (where->head) 1795 if (where->head)
1898 { 1796 {
1899 LOG (llevDebug, "Warning: Tried to insert object wrong part of multipart object.\n"); 1797 LOG (llevDebug, "Warning: Tried to insert object wrong part of multipart object.\n");
1900 where = where->head; 1798 where = where->head;
1901 } 1799 }
1800
1902 if (op->more) 1801 if (op->more)
1903 { 1802 {
1904 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count); 1803 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count);
1905 return op; 1804 return op;
1906 } 1805 }
1806
1907 CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL); 1807 CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL);
1908 CLEAR_FLAG (op, FLAG_REMOVED); 1808 CLEAR_FLAG (op, FLAG_REMOVED);
1909 if (op->nrof) 1809 if (op->nrof)
1910 { 1810 {
1911 for (tmp = where->inv; tmp != NULL; tmp = tmp->below) 1811 for (tmp = where->inv; tmp != NULL; tmp = tmp->below)
… …
2004 tag; 1904 tag;
2005 mapstruct * 1905 mapstruct *
2006 m = op->map; 1906 m = op->map;
2007 int 1907 int
2008 x = op->x, y = op->y; 1908 x = op->x, y = op->y;
1909
2009 MoveType 1910 MoveType
2010 move_on, 1911 move_on,
2011 move_slow, 1912 move_slow,
2012 move_block; 1913 move_block;
2013 1914
… …
2047 * we don't need to check all of them. 1948 * we don't need to check all of them.
2048 */ 1949 */
2049 if ((tmp->move_type & MOVE_FLY_LOW) && QUERY_FLAG (tmp, FLAG_NO_PICK)) 1950 if ((tmp->move_type & MOVE_FLY_LOW) && QUERY_FLAG (tmp, FLAG_NO_PICK))
2050 break; 1951 break;
2051 } 1952 }
1953
2052 for (; tmp != NULL; tmp = tmp->below) 1954 for (; tmp; tmp = tmp->below)
2053 { 1955 {
2054 if (tmp == op) 1956 if (tmp == op)
2055 continue; /* Can't apply yourself */ 1957 continue; /* Can't apply yourself */
2056 1958
2057 /* Check to see if one of the movement types should be slowed down. 1959 /* Check to see if one of the movement types should be slowed down.
… …
2065 if ((!op->move_type && tmp->move_slow & MOVE_WALK) || 1967 if ((!op->move_type && tmp->move_slow & MOVE_WALK) ||
2066 ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0)) 1968 ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0))
2067 { 1969 {
2068 1970
2069 float 1971 float
2070 diff;
2071
2072 diff = tmp->move_slow_penalty * FABS (op->speed); 1972 diff = tmp->move_slow_penalty * FABS (op->speed);
1973
2073 if (op->type == PLAYER) 1974 if (op->type == PLAYER)
2074 {
2075 if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) || 1975 if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) ||
2076 (QUERY_FLAG (tmp, FLAG_IS_WOODED) && find_skill_by_number (op, SK_WOODSMAN))) 1976 (QUERY_FLAG (tmp, FLAG_IS_WOODED) && find_skill_by_number (op, SK_WOODSMAN)))
2077 {
2078 diff /= 4.0; 1977 diff /= 4.0;
2079 } 1978
2080 }
2081 op->speed_left -= diff; 1979 op->speed_left -= diff;
2082 } 1980 }
2083 } 1981 }
2084 1982
2085 /* Basically same logic as above, except now for actual apply. */ 1983 /* Basically same logic as above, except now for actual apply. */
2086 if ((!op->move_type && tmp->move_on & MOVE_WALK) || 1984 if ((!op->move_type && tmp->move_on & MOVE_WALK) ||
2087 ((op->move_type & tmp->move_on) && (op->move_type & ~tmp->move_on & ~tmp->move_block) == 0)) 1985 ((op->move_type & tmp->move_on) && (op->move_type & ~tmp->move_on & ~tmp->move_block) == 0))
2088 { 1986 {
2089
2090 move_apply (tmp, op, originator); 1987 move_apply (tmp, op, originator);
1988
2091 if (was_destroyed (op, tag)) 1989 if (was_destroyed (op, tag))
2092 return 1; 1990 return 1;
2093 1991
2094 /* what the person/creature stepped onto has moved the object 1992 /* what the person/creature stepped onto has moved the object
2095 * someplace new. Don't process any further - if we did, 1993 * someplace new. Don't process any further - if we did,
… …
2097 */ 1995 */
2098 if (op->map != m || op->x != x || op->y != y) 1996 if (op->map != m || op->x != x || op->y != y)
2099 return 0; 1997 return 0;
2100 } 1998 }
2101 } 1999 }
2000
2102 return 0; 2001 return 0;
2103} 2002}
2104 2003
2105/* 2004/*
2106 * present_arch(arch, map, x, y) searches for any objects with 2005 * present_arch(arch, map, x, y) searches for any objects with
… …
2397find_dir (mapstruct *m, int x, int y, object *exclude) 2296find_dir (mapstruct *m, int x, int y, object *exclude)
2398{ 2297{
2399 int 2298 int
2400 i, 2299 i,
2401 max = SIZEOFFREE, mflags; 2300 max = SIZEOFFREE, mflags;
2402 sint16 2301
2403 nx, 2302 sint16 nx, ny;
2404 ny;
2405 object * 2303 object *
2406 tmp; 2304 tmp;
2407 mapstruct * 2305 mapstruct *
2408 mp; 2306 mp;
2409 MoveType 2307
2410 blocked, 2308 MoveType blocked, move_type;
2411 move_type;
2412 2309
2413 if (exclude && exclude->head) 2310 if (exclude && exclude->head)
2414 { 2311 {
2415 exclude = exclude->head; 2312 exclude = exclude->head;
2416 move_type = exclude->move_type; 2313 move_type = exclude->move_type;
… …
2623 2520
2624 2521
2625int 2522int
2626can_see_monsterP (mapstruct *m, int x, int y, int dir) 2523can_see_monsterP (mapstruct *m, int x, int y, int dir)
2627{ 2524{
2628 sint16 2525 sint16 dx, dy;
2629 dx,
2630 dy;
2631 int 2526 int
2632 mflags; 2527 mflags;
2633 2528
2634 if (dir < 0) 2529 if (dir < 0)
2635 return 0; /* exit condition: invalid direction */ 2530 return 0; /* exit condition: invalid direction */
… …
2766 fprintf (tempfile, obstr); 2661 fprintf (tempfile, obstr);
2767 fclose (tempfile); 2662 fclose (tempfile);
2768 2663
2769 op = get_object (); 2664 op = get_object ();
2770 2665
2771 object_thawer 2666 object_thawer thawer (filename);
2772 thawer (filename);
2773 2667
2774 if (thawer) 2668 if (thawer)
2775 load_object (thawer, op, 0); 2669 load_object (thawer, op, 0);
2776 2670
2777 LOG (llevDebug, " load str completed, object=%s\n", &op->name); 2671 LOG (llevDebug, " load str completed, object=%s\n", &op->name);
… …
2901 if (last) 2795 if (last)
2902 last->next = field->next; 2796 last->next = field->next;
2903 else 2797 else
2904 op->key_values = field->next; 2798 op->key_values = field->next;
2905 2799
2906 delete
2907 field; 2800 delete field;
2908 } 2801 }
2909 } 2802 }
2910 return TRUE; 2803 return TRUE;
2911 } 2804 }
2912 /* IF we get here, key doesn't exist */ 2805 /* IF we get here, key doesn't exist */
… …
2947 * Returns TRUE on success. 2840 * Returns TRUE on success.
2948 */ 2841 */
2949int 2842int
2950set_ob_key_value (object *op, const char *key, const char *value, int add_key) 2843set_ob_key_value (object *op, const char *key, const char *value, int add_key)
2951{ 2844{
2952 shstr
2953 key_ (key); 2845 shstr key_ (key);
2954 2846
2955 return set_ob_key_value_s (op, key_, value, add_key); 2847 return set_ob_key_value_s (op, key_, value, add_key);
2956} 2848}
2849
2850void
2851object::deep_iterator::next ()
2852{
2853 if (item->inv)
2854 item = item->inv;
2855 else if (item->below)
2856 item = item->below;
2857 else
2858 item = item->env->below;
2859}

Diff Legend

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