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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.28 by root, Mon Sep 11 12:10:21 2006 UTC vs.
Revision 1.30 by root, Mon Sep 11 20:28:37 2006 UTC

1
1/* 2/*
2 CrossFire, A Multiplayer game for X-windows 3 CrossFire, A Multiplayer game for X-windows
3 4
4 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 5 Copyright (C) 2001 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 Copyright (C) 1992 Frank Tore Johansen
… …
207 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)
208 return 0; 209 return 0;
209 210
210 switch (ob1->type) 211 switch (ob1->type)
211 { 212 {
212 case SCROLL: 213 case SCROLL:
213 if (ob1->level != ob2->level) 214 if (ob1->level != ob2->level)
214 return 0; 215 return 0;
215 break; 216 break;
216 } 217 }
217 218
218 if (ob1->key_values != NULL || ob2->key_values != NULL) 219 if (ob1->key_values != NULL || ob2->key_values != NULL)
219 { 220 {
220 /* At least one of these has key_values. */ 221 /* At least one of these has key_values. */
… …
442 * 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
443 * 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
444 * 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
445 * anything - once an object is removed, it is basically dead anyways. 446 * anything - once an object is removed, it is basically dead anyways.
446 */ 447 */
447
448object * 448object *
449get_owner (object *op) 449object::get_owner ()
450{ 450{
451 if (op->owner == NULL) 451 if (!owner
452 return NULL; 452 || QUERY_FLAG (owner, FLAG_FREED)
453 || QUERY_FLAG (owner, FLAG_REMOVED))
454 owner = 0;
453 455
454 if (!QUERY_FLAG (op->owner, FLAG_FREED) && !QUERY_FLAG (op->owner, FLAG_REMOVED) && op->owner->count == op->ownercount)
455 return op->owner; 456 return owner;
456
457 op->owner = NULL;
458 op->ownercount = 0;
459 return NULL;
460}
461
462void
463clear_owner (object *op)
464{
465 if (!op)
466 return;
467
468 if (op->owner && op->ownercount == op->owner->count)
469 op->owner->refcount--;
470
471 op->owner = NULL;
472 op->ownercount = 0;
473} 457}
474 458
475/* 459/*
476 * 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
477 * skill and experience objects. 461 * skill and experience objects.
478 */ 462 */
479void 463void
480set_owner (object *op, object *owner) 464object::set_owner (object *owner)
481{ 465{
482 if (owner == NULL || op == NULL) 466 if (!owner)
483 return; 467 return;
484 468
485 /* next line added to allow objects which own objects */ 469 /* next line added to allow objects which own objects */
486 /* 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
487 * with the fireball owning a poison cloud which then owned the 471 * with the fireball owning a poison cloud which then owned the
488 * 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
489 * freed and then another object replacing it. Since the ownercounts 473 * freed and then another object replacing it. Since the ownercounts
490 * didn't match, this check is valid and I believe that cause is valid. 474 * didn't match, this check is valid and I believe that cause is valid.
491 */ 475 */
492 while (owner->owner && owner != owner->owner && owner->ownercount == owner->owner->count) 476 while (owner->owner)
493 owner = owner->owner; 477 owner = owner->owner;
494 478
495 /* IF the owner still has an owner, we did not resolve to a final owner.
496 * so lets not add to that.
497 */
498 if (owner->owner)
499 return;
500
501 op->owner = owner; 479 this->owner = owner;
502
503 op->ownercount = owner->count;
504 owner->refcount++;
505}
506
507/* Set the owner to clone's current owner and set the skill and experience
508 * objects to clone's objects (typically those objects that where the owner's
509 * current skill and experience objects at the time when clone's owner was
510 * set - not the owner's current skill and experience objects).
511 *
512 * Use this function if player created an object (e.g. fire bullet, swarm
513 * spell), and this object creates further objects whose kills should be
514 * accounted for the player's original skill, even if player has changed
515 * skills meanwhile.
516 */
517void
518copy_owner (object *op, object *clone)
519{
520 object *owner = get_owner (clone);
521
522 if (owner == NULL)
523 {
524 /* players don't have owners - they own themselves. Update
525 * as appropriate.
526 */
527 if (clone->type == PLAYER)
528 owner = clone;
529 else
530 return;
531 }
532
533 set_owner (op, owner);
534} 480}
535 481
536/* Zero the key_values on op, decrementing the shared-string 482/* Zero the key_values on op, decrementing the shared-string
537 * refcounts and freeing the links. 483 * refcounts and freeing the links.
538 */ 484 */
… …
554{ 500{
555 attachable_base::clear (); 501 attachable_base::clear ();
556 502
557 free_key_values (this); 503 free_key_values (this);
558 504
559 clear_owner (this); 505 owner = 0;
560
561 name = 0; 506 name = 0;
562 name_pl = 0; 507 name_pl = 0;
563 title = 0; 508 title = 0;
564 race = 0; 509 race = 0;
565 slaying = 0; 510 slaying = 0;
566 skill = 0; 511 skill = 0;
567 msg = 0; 512 msg = 0;
568 lore = 0; 513 lore = 0;
569 custom_name = 0; 514 custom_name = 0;
570 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;
571 527
572 memset (static_cast < object_pod * >(this), 0, sizeof (object_pod)); 528 memset (static_cast<object_pod *>(this), 0, sizeof (object_pod));
573 529
574 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;
575} 540}
576 541
577void object::clone (object *destination) 542void object::clone (object *destination)
578{ 543{
579 *(object_copy *) destination = *this; 544 *(object_copy *)destination = *this;
580 *(object_pod *) destination = *this; 545 *(object_pod *)destination = *this;
581 546
582 if (self || cb) 547 if (self || cb)
583 INVOKE_OBJECT (CLONE, this, ARG_OBJECT (destination)); 548 INVOKE_OBJECT (CLONE, this, ARG_OBJECT (destination));
584}
585
586/*
587 * clear_object() frees everything allocated by an object, and also
588 * clears all variables and flags to default settings.
589 */
590
591void
592clear_object (object *op)
593{
594 op->clear ();
595
596 op->contr = NULL;
597 op->below = NULL;
598 op->above = NULL;
599 op->inv = NULL;
600 op->container = NULL;
601 op->env = NULL;
602 op->more = NULL;
603 op->head = NULL;
604 op->map = NULL;
605 op->refcount = 0;
606 op->active_next = NULL;
607 op->active_prev = NULL;
608 /* What is not cleared is next, prev, and count */
609
610 op->expmul = 1.0;
611 op->face = blank_face;
612 op->attacked_by_count = -1;
613
614 if (settings.casting_time)
615 op->casting_time = -1;
616} 549}
617 550
618/* 551/*
619 * copy object first frees everything allocated by the second object, 552 * copy object first frees everything allocated by the second object,
620 * 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
621 * object, allocating what needs to be allocated. Basically, any 554 * object, allocating what needs to be allocated. Basically, any
622 * 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,
623 * 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
624 * will point at garbage. 557 * will point at garbage.
625 */ 558 */
626
627void 559void
628copy_object (object *op2, object *op) 560copy_object (object *op2, object *op)
629{ 561{
630 bool is_freed = QUERY_FLAG (op, FLAG_FREED); 562 bool is_freed = QUERY_FLAG (op, FLAG_FREED);
631 bool is_removed = QUERY_FLAG (op, FLAG_REMOVED); 563 bool is_removed = QUERY_FLAG (op, FLAG_REMOVED);
… …
886 * that is being removed. 818 * that is being removed.
887 */ 819 */
888 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE) 820 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE)
889 update_now = 1; 821 update_now = 1;
890 else if (action == UP_OBJ_FACE) 822 else if (action == UP_OBJ_FACE)
891 /* Nothing to do for that case */; 823 /* Nothing to do for that case */ ;
892 else 824 else
893 LOG (llevError, "update_object called with invalid action: %d\n", action); 825 LOG (llevError, "update_object called with invalid action: %d\n", action);
894 826
895 if (update_now) 827 if (update_now)
896 { 828 {
… …
905static unordered_vector<object *> mortals; 837static unordered_vector<object *> mortals;
906static std::vector<object *> freed; 838static std::vector<object *> freed;
907 839
908void object::free_mortals () 840void object::free_mortals ()
909{ 841{
910 for (unordered_vector<object *>::iterator i = mortals.begin (); i != mortals.end (); ) 842 for (unordered_vector<object *>::iterator i = mortals.begin (); i != mortals.end ();)
911 if (!(*i)->refcount) 843 if ((*i)->refcnt)
844 ++i; // further delay freeing
845 else
912 { 846 {
913 freed.push_back (*i); 847 freed.push_back (*i);//D
848 //delete *i;
914 mortals.erase (i); 849 mortals.erase (i);
915 } 850 }
916 else 851
917 ++i; 852 if (mortals.size())//D
853 LOG (llevDebug, "%d objects in mortal queue\n", mortals.size());//D
918} 854}
919 855
920object::object () 856object::object ()
921{ 857{
922 SET_FLAG (this, FLAG_REMOVED); 858 SET_FLAG (this, FLAG_REMOVED);
… …
965 objects = next; 901 objects = next;
966} 902}
967 903
968object *object::create () 904object *object::create ()
969{ 905{
970 object *op; 906 object *
907 op;
971 908
972 if (freed.empty ()) 909 if (freed.empty ())
973 op = new object; 910 op = new object;
974 else 911 else
975 { 912 {
976 // highly annoying, but the only way to get it stable right now 913 // highly annoying, but the only way to get it stable right now
977 op = freed.back (); freed.pop_back (); 914 op = freed.back ();
915 freed.pop_back ();
978 op->~object (); 916 op->~object ();
979 new ((void *)op) object; 917 new ((void *) op) object;
980 } 918 }
981 919
982 op->link (); 920 op->link ();
983 return op; 921 return op;
984} 922}
… …
993 * If free_inventory is set, free inventory as well. Else drop items in 931 * If free_inventory is set, free inventory as well. Else drop items in
994 * inventory to the ground. 932 * inventory to the ground.
995 */ 933 */
996void object::free (bool free_inventory) 934void object::free (bool free_inventory)
997{ 935{
936 if (QUERY_FLAG (this, FLAG_FREED))
937 return;
938
998 if (!QUERY_FLAG (this, FLAG_REMOVED)) 939 if (!QUERY_FLAG (this, FLAG_REMOVED))
999 { 940 remove_ob (this);
1000 LOG (llevDebug, "Free object called with non removed object\n");
1001 dump_object (this);
1002#ifdef MANY_CORES
1003 abort ();
1004#endif
1005 }
1006 941
1007 if (QUERY_FLAG (this, FLAG_FRIENDLY)) 942 if (QUERY_FLAG (this, FLAG_FRIENDLY))
1008 {
1009 LOG (llevMonster, "Warning: tried to free friendly object.\n");
1010 remove_friendly_object (this); 943 remove_friendly_object (this);
1011 }
1012 944
1013 if (QUERY_FLAG (this, FLAG_FREED)) 945 SET_FLAG (this, FLAG_FREED);
1014 {
1015 dump_object (this);
1016 LOG (llevError, "Trying to free freed object.\n%s\n", errmsg);
1017 return;
1018 }
1019 946
1020 if (more) 947 if (more)
1021 { 948 {
1022 more->free (free_inventory); 949 more->free (free_inventory);
1023 more = 0; 950 more = 0;
… …
1029 * if some form of movement is allowed, let objects 956 * if some form of movement is allowed, let objects
1030 * drop on that space. 957 * drop on that space.
1031 */ 958 */
1032 if (free_inventory || !map || map->in_memory != MAP_IN_MEMORY || (GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL)) 959 if (free_inventory || !map || map->in_memory != MAP_IN_MEMORY || (GET_MAP_MOVE_BLOCK (map, x, y) == MOVE_ALL))
1033 { 960 {
1034 object * 961 object *op = inv;
1035 op = inv;
1036 962
1037 while (op) 963 while (op)
1038 { 964 {
1039 object *
1040 tmp = op->below; 965 object *tmp = op->below;
1041
1042 remove_ob (op);
1043 op->free (free_inventory); 966 op->free (free_inventory);
1044 op = tmp; 967 op = tmp;
1045 } 968 }
1046 } 969 }
1047 else 970 else
1048 { /* Put objects in inventory onto this space */ 971 { /* Put objects in inventory onto this space */
1049 object * 972 object *op = inv;
1050 op = inv;
1051 973
1052 while (op) 974 while (op)
1053 { 975 {
1054 object *
1055 tmp = op->below; 976 object *tmp = op->below;
1056 977
1057 remove_ob (op); 978 remove_ob (op);
1058 979
1059 if (QUERY_FLAG (op, FLAG_STARTEQUIP) 980 if (QUERY_FLAG (op, FLAG_STARTEQUIP)
1060 || QUERY_FLAG (op, FLAG_NO_DROP) || op->type == RUNE || op->type == TRAP || QUERY_FLAG (op, FLAG_IS_A_TEMPLATE)) 981 || QUERY_FLAG (op, FLAG_NO_DROP) || op->type == RUNE || op->type == TRAP || QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))
… …
1069 op = tmp; 990 op = tmp;
1070 } 991 }
1071 } 992 }
1072 } 993 }
1073 994
1074 clear_owner (this); 995 owner = 0;
1075 996
1076 /* Remove object from the active list */ 997 /* Remove object from the active list */
1077 speed = 0; 998 speed = 0;
1078 update_ob_speed (this); 999 update_ob_speed (this);
1079 1000
1080 unlink (); 1001 unlink ();
1081
1082 SET_FLAG (this, FLAG_FREED);
1083 1002
1084 mortals.push_back (this); 1003 mortals.push_back (this);
1085} 1004}
1086 1005
1087/* 1006/*
… …
1113 */ 1032 */
1114 1033
1115void 1034void
1116remove_ob (object *op) 1035remove_ob (object *op)
1117{ 1036{
1118 object *tmp, *last = NULL;
1119 object *otmp; 1037 object *
1038 tmp, *
1039 last = NULL;
1040 object *
1041 otmp;
1120 1042
1121 tag_t tag; 1043 tag_t
1044 tag;
1045 int
1122 int check_walk_off; 1046 check_walk_off;
1123 mapstruct *m; 1047 mapstruct *
1048 m;
1124 1049
1125 sint16 x, y; 1050 sint16
1051 x,
1052 y;
1126 1053
1127 if (QUERY_FLAG (op, FLAG_REMOVED)) 1054 if (QUERY_FLAG (op, FLAG_REMOVED))
1128 { 1055 return;
1129 dump_object (op);
1130 LOG (llevError, "Trying to remove removed object.\n%s\n", errmsg);
1131 1056
1132 /* Changed it to always dump core in this case. As has been learned 1057 SET_FLAG (op, FLAG_REMOVED);
1133 * in the past, trying to recover from errors almost always
1134 * make things worse, and this is a real error here - something
1135 * that should not happen.
1136 * Yes, if this was a mission critical app, trying to do something
1137 * to recover may make sense, but that is because failure of the app
1138 * may have other disastrous problems. Cf runs out of a script
1139 * so is easily enough restarted without any real problems.
1140 * MSW 2001-07-01
1141 */
1142 abort ();
1143 }
1144 1058
1145 if (op->more != NULL) 1059 if (op->more != NULL)
1146 remove_ob (op->more); 1060 remove_ob (op->more);
1147
1148 SET_FLAG (op, FLAG_REMOVED);
1149 1061
1150 /* 1062 /*
1151 * In this case, the object to be removed is in someones 1063 * In this case, the object to be removed is in someones
1152 * inventory. 1064 * inventory.
1153 */ 1065 */
… …
1179 */ 1091 */
1180 op->x = op->env->x, op->y = op->env->y; 1092 op->x = op->env->x, op->y = op->env->y;
1181 op->map = op->env->map; 1093 op->map = op->env->map;
1182 op->above = NULL, op->below = NULL; 1094 op->above = NULL, op->below = NULL;
1183 op->env = NULL; 1095 op->env = NULL;
1184 return; 1096 }
1097 else if (op->map)
1185 } 1098 {
1186
1187 /* If we get here, we are removing it from a map */
1188 if (op->map == NULL)
1189 return;
1190
1191 x = op->x; 1099 x = op->x;
1192 y = op->y; 1100 y = op->y;
1193 m = get_map_from_coord (op->map, &x, &y); 1101 m = get_map_from_coord (op->map, &x, &y);
1194 1102
1195 if (!m) 1103 if (!m)
1196 { 1104 {
1197 LOG (llevError, "remove_ob called when object was on map but appears to not be within valid coordinates? %s (%d,%d)\n", 1105 LOG (llevError, "remove_ob called when object was on map but appears to not be within valid coordinates? %s (%d,%d)\n",
1198 op->map->path, op->x, op->y); 1106 op->map->path, op->x, op->y);
1199 /* in old days, we used to set x and y to 0 and continue. 1107 /* in old days, we used to set x and y to 0 and continue.
1200 * it seems if we get into this case, something is probablye 1108 * it seems if we get into this case, something is probablye
1201 * screwed up and should be fixed. 1109 * screwed up and should be fixed.
1110 */
1111 abort ();
1112 }
1113
1114 if (op->map != m)
1115 LOG (llevDebug, "remove_ob: Object not really on map it claimed to be on? %s != %s, %d,%d != %d,%d\n",
1116 op->map->path, m->path, op->x, op->y, x, y);
1117
1118 /* Re did the following section of code - it looks like it had
1119 * lots of logic for things we no longer care about
1202 */ 1120 */
1203 abort ();
1204 }
1205 if (op->map != m)
1206 {
1207 LOG (llevDebug, "remove_ob: Object not really on map it claimed to be on? %s != %s, %d,%d != %d,%d\n",
1208 op->map->path, m->path, op->x, op->y, x, y);
1209 }
1210 1121
1211 /* Re did the following section of code - it looks like it had
1212 * lots of logic for things we no longer care about
1213 */
1214
1215 /* link the object above us */ 1122 /* link the object above us */
1216 if (op->above) 1123 if (op->above)
1217 op->above->below = op->below; 1124 op->above->below = op->below;
1218 else 1125 else
1219 SET_MAP_TOP (m, x, y, op->below); /* we were top, set new top */ 1126 SET_MAP_TOP (m, x, y, op->below); /* we were top, set new top */
1220 1127
1221 /* Relink the object below us, if there is one */ 1128 /* Relink the object below us, if there is one */
1222 if (op->below) 1129 if (op->below)
1223 op->below->above = op->above; 1130 op->below->above = op->above;
1224 else 1131 else
1225 { 1132 {
1226 /* Nothing below, which means we need to relink map object for this space 1133 /* Nothing below, which means we need to relink map object for this space
1227 * use translated coordinates in case some oddness with map tiling is 1134 * use translated coordinates in case some oddness with map tiling is
1228 * evident 1135 * evident
1229 */
1230 if (GET_MAP_OB (m, x, y) != op)
1231 {
1232 dump_object (op);
1233 LOG (llevError, "remove_ob: GET_MAP_OB does not return object to be removed even though it appears to be on the bottom?\n%s\n",
1234 errmsg);
1235 dump_object (GET_MAP_OB (m, x, y));
1236 LOG (llevError, "%s\n", errmsg);
1237 }
1238
1239 SET_MAP_OB (m, x, y, op->above); /* goes on above it. */
1240 }
1241
1242 op->above = NULL;
1243 op->below = NULL;
1244
1245 if (op->map->in_memory == MAP_SAVING)
1246 return;
1247
1248 tag = op->count;
1249 check_walk_off = !QUERY_FLAG (op, FLAG_NO_APPLY);
1250
1251 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
1252 {
1253 /* No point updating the players look faces if he is the object
1254 * being removed.
1255 */
1256
1257 if (tmp->type == PLAYER && tmp != op)
1258 {
1259 /* If a container that the player is currently using somehow gets
1260 * removed (most likely destroyed), update the player view
1261 * appropriately.
1262 */ 1136 */
1263 if (tmp->container == op) 1137 if (GET_MAP_OB (m, x, y) != op)
1264 { 1138 {
1265 CLEAR_FLAG (op, FLAG_APPLIED); 1139 dump_object (op);
1266 tmp->container = NULL; 1140 LOG (llevError,
1141 "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);
1142 dump_object (GET_MAP_OB (m, x, y));
1143 LOG (llevError, "%s\n", errmsg);
1267 } 1144 }
1268 1145
1269 tmp->contr->socket.update_look = 1; 1146 SET_MAP_OB (m, x, y, op->above); /* goes on above it. */
1270 }
1271 /* See if player moving off should effect something */
1272 if (check_walk_off && ((op->move_type & tmp->move_off) && (op->move_type & ~tmp->move_off & ~tmp->move_block) == 0))
1273 { 1147 }
1274 move_apply (tmp, op, NULL);
1275 1148
1276 if (was_destroyed (op, tag)) 1149 op->above = 0;
1150 op->below = 0;
1151
1152 if (op->map->in_memory == MAP_SAVING)
1153 return;
1154
1155 tag = op->count;
1156 check_walk_off = !QUERY_FLAG (op, FLAG_NO_APPLY);
1157
1158 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
1159 {
1160 /* No point updating the players look faces if he is the object
1161 * being removed.
1162 */
1163
1164 if (tmp->type == PLAYER && tmp != op)
1277 { 1165 {
1278 LOG (llevError, "BUG: remove_ob(): name %s, archname %s destroyed " "leaving object\n", &tmp->name, &tmp->arch->name); 1166 /* If a container that the player is currently using somehow gets
1167 * removed (most likely destroyed), update the player view
1168 * appropriately.
1169 */
1170 if (tmp->container == op)
1171 {
1172 CLEAR_FLAG (op, FLAG_APPLIED);
1173 tmp->container = NULL;
1174 }
1175
1176 tmp->contr->socket.update_look = 1;
1279 } 1177 }
1178
1179 /* See if player moving off should effect something */
1180 if (check_walk_off && ((op->move_type & tmp->move_off) && (op->move_type & ~tmp->move_off & ~tmp->move_block) == 0))
1181 {
1182 move_apply (tmp, op, NULL);
1183
1184 if (was_destroyed (op, tag))
1185 {
1186 LOG (llevError, "BUG: remove_ob(): name %s, archname %s destroyed " "leaving object\n", &tmp->name, &tmp->arch->name);
1187 }
1280 } 1188 }
1281 1189
1282 /* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */ 1190 /* Eneq(@csd.uu.se): Fixed this to skip tmp->above=tmp */
1283 1191
1284 if (tmp->above == tmp) 1192 if (tmp->above == tmp)
1285 tmp->above = NULL; 1193 tmp->above = NULL;
1286 1194
1287 last = tmp; 1195 last = tmp;
1288 } 1196 }
1289 1197
1290 /* last == NULL of there are no objects on this space */ 1198 /* last == NULL of there are no objects on this space */
1291 if (last == NULL) 1199 if (last == NULL)
1292 { 1200 {
1293 /* set P_NEED_UPDATE, otherwise update_position will complain. In theory, 1201 /* set P_NEED_UPDATE, otherwise update_position will complain. In theory,
1294 * we could preserve the flags (GET_MAP_FLAGS), but update_position figures 1202 * we could preserve the flags (GET_MAP_FLAGS), but update_position figures
1295 * those out anyways, and if there are any flags set right now, they won't 1203 * those out anyways, and if there are any flags set right now, they won't
1296 * be correct anyways. 1204 * be correct anyways.
1297 */ 1205 */
1298 SET_MAP_FLAGS (op->map, op->x, op->y, P_NEED_UPDATE); 1206 SET_MAP_FLAGS (op->map, op->x, op->y, P_NEED_UPDATE);
1299 update_position (op->map, op->x, op->y); 1207 update_position (op->map, op->x, op->y);
1300 } 1208 }
1301 else 1209 else
1302 update_object (last, UP_OBJ_REMOVE); 1210 update_object (last, UP_OBJ_REMOVE);
1303 1211
1304 if (QUERY_FLAG (op, FLAG_BLOCKSVIEW) || (op->glow_radius != 0)) 1212 if (QUERY_FLAG (op, FLAG_BLOCKSVIEW) || (op->glow_radius != 0))
1305 update_all_los (op->map, op->x, op->y); 1213 update_all_los (op->map, op->x, op->y);
1214 }
1306} 1215}
1307 1216
1308/* 1217/*
1309 * merge_ob(op,top): 1218 * merge_ob(op,top):
1310 * 1219 *
… …
1317object * 1226object *
1318merge_ob (object *op, object *top) 1227merge_ob (object *op, object *top)
1319{ 1228{
1320 if (!op->nrof) 1229 if (!op->nrof)
1321 return 0; 1230 return 0;
1231
1322 if (top == NULL) 1232 if (top == NULL)
1323 for (top = op; top != NULL && top->above != NULL; top = top->above); 1233 for (top = op; top != NULL && top->above != NULL; top = top->above);
1234
1324 for (; top != NULL; top = top->below) 1235 for (; top != NULL; top = top->below)
1325 { 1236 {
1326 if (top == op) 1237 if (top == op)
1327 continue; 1238 continue;
1328 if (CAN_MERGE (op, top)) 1239 if (CAN_MERGE (op, top))
… …
1334 remove_ob (op); 1245 remove_ob (op);
1335 free_object (op); 1246 free_object (op);
1336 return top; 1247 return top;
1337 } 1248 }
1338 } 1249 }
1250
1339 return NULL; 1251 return NULL;
1340} 1252}
1341 1253
1342/* 1254/*
1343 * same as insert_ob_in_map except it handle separate coordinates and do a clean 1255 * same as insert_ob_in_map except it handle separate coordinates and do a clean
1344 * job preparing multi-part monsters 1256 * job preparing multi-part monsters
1345 */ 1257 */
1346object * 1258object *
1347insert_ob_in_map_at (object *op, mapstruct *m, object *originator, int flag, int x, int y) 1259insert_ob_in_map_at (object *op, mapstruct *m, object *originator, int flag, int x, int y)
1348{ 1260{
1349 object * 1261 object *tmp;
1350 tmp;
1351 1262
1352 if (op->head) 1263 if (op->head)
1353 op = op->head; 1264 op = op->head;
1265
1354 for (tmp = op; tmp; tmp = tmp->more) 1266 for (tmp = op; tmp; tmp = tmp->more)
1355 { 1267 {
1356 tmp->x = x + tmp->arch->clone.x; 1268 tmp->x = x + tmp->arch->clone.x;
1357 tmp->y = y + tmp->arch->clone.y; 1269 tmp->y = y + tmp->arch->clone.y;
1358 } 1270 }
1271
1359 return insert_ob_in_map (op, m, originator, flag); 1272 return insert_ob_in_map (op, m, originator, flag);
1360} 1273}
1361 1274
1362/* 1275/*
1363 * insert_ob_in_map (op, map, originator, flag): 1276 * insert_ob_in_map (op, map, originator, flag):
… …
1654 * op is the object to insert it under: supplies x and the map. 1567 * op is the object to insert it under: supplies x and the map.
1655 */ 1568 */
1656void 1569void
1657replace_insert_ob_in_map (const char *arch_string, object *op) 1570replace_insert_ob_in_map (const char *arch_string, object *op)
1658{ 1571{
1659 object *tmp; 1572 object *
1573 tmp;
1660 object *tmp1; 1574 object *
1575 tmp1;
1661 1576
1662 /* first search for itself and remove any old instances */ 1577 /* first search for itself and remove any old instances */
1663 1578
1664 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 1579 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
1665 { 1580 {
… …
1696 if (orig_ob->nrof < nr) 1611 if (orig_ob->nrof < nr)
1697 { 1612 {
1698 sprintf (errmsg, "There are only %d %ss.", orig_ob->nrof ? orig_ob->nrof : 1, &orig_ob->name); 1613 sprintf (errmsg, "There are only %d %ss.", orig_ob->nrof ? orig_ob->nrof : 1, &orig_ob->name);
1699 return NULL; 1614 return NULL;
1700 } 1615 }
1616
1701 newob = object_create_clone (orig_ob); 1617 newob = object_create_clone (orig_ob);
1618
1702 if ((orig_ob->nrof -= nr) < 1) 1619 if ((orig_ob->nrof -= nr) < 1)
1703 { 1620 {
1704 if (!is_removed) 1621 if (!is_removed)
1705 remove_ob (orig_ob); 1622 remove_ob (orig_ob);
1706 free_object2 (orig_ob, 1); 1623 free_object2 (orig_ob, 1);
… …
1714 strcpy (errmsg, "Tried to split object whose map is not in memory."); 1631 strcpy (errmsg, "Tried to split object whose map is not in memory.");
1715 LOG (llevDebug, "Error, Tried to split object whose map is not in memory.\n"); 1632 LOG (llevDebug, "Error, Tried to split object whose map is not in memory.\n");
1716 return NULL; 1633 return NULL;
1717 } 1634 }
1718 } 1635 }
1636
1719 newob->nrof = nr; 1637 newob->nrof = nr;
1720 1638
1721 return newob; 1639 return newob;
1722} 1640}
1723 1641
… …
1730 */ 1648 */
1731 1649
1732object * 1650object *
1733decrease_ob_nr (object *op, uint32 i) 1651decrease_ob_nr (object *op, uint32 i)
1734{ 1652{
1735 object * 1653 object *tmp;
1736 tmp;
1737 player * 1654 player *pl;
1738 pl;
1739 1655
1740 if (i == 0) /* objects with op->nrof require this check */ 1656 if (i == 0) /* objects with op->nrof require this check */
1741 return op; 1657 return op;
1742 1658
1743 if (i > op->nrof) 1659 if (i > op->nrof)
1744 i = op->nrof; 1660 i = op->nrof;
1745 1661
1746 if (QUERY_FLAG (op, FLAG_REMOVED)) 1662 if (QUERY_FLAG (op, FLAG_REMOVED))
1747 {
1748 op->nrof -= i; 1663 op->nrof -= i;
1749 }
1750 else if (op->env != NULL) 1664 else if (op->env != NULL)
1751 { 1665 {
1752 /* is this object in the players inventory, or sub container 1666 /* is this object in the players inventory, or sub container
1753 * therein? 1667 * therein?
1754 */ 1668 */
… …
1789 } 1703 }
1790 } 1704 }
1791 } 1705 }
1792 else 1706 else
1793 { 1707 {
1794 object *
1795 above = op->above; 1708 object *above = op->above;
1796 1709
1797 if (i < op->nrof) 1710 if (i < op->nrof)
1798 {
1799 op->nrof -= i; 1711 op->nrof -= i;
1800 }
1801 else 1712 else
1802 { 1713 {
1803 remove_ob (op); 1714 remove_ob (op);
1804 op->nrof = 0; 1715 op->nrof = 0;
1805 } 1716 }
1717
1806 /* Since we just removed op, op->above is null */ 1718 /* Since we just removed op, op->above is null */
1807 for (tmp = above; tmp != NULL; tmp = tmp->above) 1719 for (tmp = above; tmp != NULL; tmp = tmp->above)
1808 if (tmp->type == PLAYER) 1720 if (tmp->type == PLAYER)
1809 { 1721 {
1810 if (op->nrof) 1722 if (op->nrof)
… …
1813 esrv_del_item (tmp->contr, op->count); 1725 esrv_del_item (tmp->contr, op->count);
1814 } 1726 }
1815 } 1727 }
1816 1728
1817 if (op->nrof) 1729 if (op->nrof)
1818 {
1819 return op; 1730 return op;
1820 }
1821 else 1731 else
1822 { 1732 {
1823 free_object (op); 1733 free_object (op);
1824 return NULL; 1734 return NULL;
1825 } 1735 }
… …
1834add_weight (object *op, signed long weight) 1744add_weight (object *op, signed long weight)
1835{ 1745{
1836 while (op != NULL) 1746 while (op != NULL)
1837 { 1747 {
1838 if (op->type == CONTAINER) 1748 if (op->type == CONTAINER)
1839 {
1840 weight = (signed long) (weight * (100 - op->stats.Str) / 100); 1749 weight = (signed long) (weight * (100 - op->stats.Str) / 100);
1841 } 1750
1842 op->carrying += weight; 1751 op->carrying += weight;
1843 op = op->env; 1752 op = op->env;
1844 } 1753 }
1845} 1754}
1846 1755
… …
1869 { 1778 {
1870 dump_object (op); 1779 dump_object (op);
1871 LOG (llevError, "Trying to insert (ob) inserted object.\n%s\n", errmsg); 1780 LOG (llevError, "Trying to insert (ob) inserted object.\n%s\n", errmsg);
1872 return op; 1781 return op;
1873 } 1782 }
1783
1874 if (where == NULL) 1784 if (where == NULL)
1875 { 1785 {
1876 dump_object (op); 1786 dump_object (op);
1877 LOG (llevError, "Trying to put object in NULL.\n%s\n", errmsg); 1787 LOG (llevError, "Trying to put object in NULL.\n%s\n", errmsg);
1878 return op; 1788 return op;
1879 } 1789 }
1790
1880 if (where->head) 1791 if (where->head)
1881 { 1792 {
1882 LOG (llevDebug, "Warning: Tried to insert object wrong part of multipart object.\n"); 1793 LOG (llevDebug, "Warning: Tried to insert object wrong part of multipart object.\n");
1883 where = where->head; 1794 where = where->head;
1884 } 1795 }
1796
1885 if (op->more) 1797 if (op->more)
1886 { 1798 {
1887 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count); 1799 LOG (llevError, "Tried to insert multipart object %s (%d)\n", &op->name, op->count);
1888 return op; 1800 return op;
1889 } 1801 }
1802
1890 CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL); 1803 CLEAR_FLAG (op, FLAG_OBJ_ORIGINAL);
1891 CLEAR_FLAG (op, FLAG_REMOVED); 1804 CLEAR_FLAG (op, FLAG_REMOVED);
1892 if (op->nrof) 1805 if (op->nrof)
1893 { 1806 {
1894 for (tmp = where->inv; tmp != NULL; tmp = tmp->below) 1807 for (tmp = where->inv; tmp != NULL; tmp = tmp->below)
… …
1979 */ 1892 */
1980 1893
1981int 1894int
1982check_move_on (object *op, object *originator) 1895check_move_on (object *op, object *originator)
1983{ 1896{
1984 object *tmp; 1897 object *
1985 tag_t tag; 1898 tmp;
1986 mapstruct *m = op->map; 1899 tag_t
1900 tag;
1901 mapstruct *
1902 m = op->map;
1903 int
1987 int x = op->x, y = op->y; 1904 x = op->x, y = op->y;
1988 1905
1989 MoveType move_on, move_slow, move_block; 1906 MoveType
1907 move_on,
1908 move_slow,
1909 move_block;
1990 1910
1991 if (QUERY_FLAG (op, FLAG_NO_APPLY)) 1911 if (QUERY_FLAG (op, FLAG_NO_APPLY))
1992 return 0; 1912 return 0;
1993 1913
1994 tag = op->count; 1914 tag = op->count;
… …
2042 { 1962 {
2043 if ((!op->move_type && tmp->move_slow & MOVE_WALK) || 1963 if ((!op->move_type && tmp->move_slow & MOVE_WALK) ||
2044 ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0)) 1964 ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0))
2045 { 1965 {
2046 1966
1967 float
2047 float diff = tmp->move_slow_penalty * FABS (op->speed); 1968 diff = tmp->move_slow_penalty * FABS (op->speed);
2048 1969
2049 if (op->type == PLAYER) 1970 if (op->type == PLAYER)
2050 if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) || 1971 if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) ||
2051 (QUERY_FLAG (tmp, FLAG_IS_WOODED) && find_skill_by_number (op, SK_WOODSMAN))) 1972 (QUERY_FLAG (tmp, FLAG_IS_WOODED) && find_skill_by_number (op, SK_WOODSMAN)))
2052 diff /= 4.0; 1973 diff /= 4.0;
… …
2371find_dir (mapstruct *m, int x, int y, object *exclude) 2292find_dir (mapstruct *m, int x, int y, object *exclude)
2372{ 2293{
2373 int 2294 int
2374 i, 2295 i,
2375 max = SIZEOFFREE, mflags; 2296 max = SIZEOFFREE, mflags;
2376 sint16 2297
2377 nx, 2298 sint16 nx, ny;
2378 ny;
2379 object * 2299 object *
2380 tmp; 2300 tmp;
2381 mapstruct * 2301 mapstruct *
2382 mp; 2302 mp;
2383 MoveType 2303
2384 blocked, 2304 MoveType blocked, move_type;
2385 move_type;
2386 2305
2387 if (exclude && exclude->head) 2306 if (exclude && exclude->head)
2388 { 2307 {
2389 exclude = exclude->head; 2308 exclude = exclude->head;
2390 move_type = exclude->move_type; 2309 move_type = exclude->move_type;
… …
2597 2516
2598 2517
2599int 2518int
2600can_see_monsterP (mapstruct *m, int x, int y, int dir) 2519can_see_monsterP (mapstruct *m, int x, int y, int dir)
2601{ 2520{
2602 sint16 2521 sint16 dx, dy;
2603 dx,
2604 dy;
2605 int 2522 int
2606 mflags; 2523 mflags;
2607 2524
2608 if (dir < 0) 2525 if (dir < 0)
2609 return 0; /* exit condition: invalid direction */ 2526 return 0; /* exit condition: invalid direction */
… …
2740 fprintf (tempfile, obstr); 2657 fprintf (tempfile, obstr);
2741 fclose (tempfile); 2658 fclose (tempfile);
2742 2659
2743 op = get_object (); 2660 op = get_object ();
2744 2661
2745 object_thawer 2662 object_thawer thawer (filename);
2746 thawer (filename);
2747 2663
2748 if (thawer) 2664 if (thawer)
2749 load_object (thawer, op, 0); 2665 load_object (thawer, op, 0);
2750 2666
2751 LOG (llevDebug, " load str completed, object=%s\n", &op->name); 2667 LOG (llevDebug, " load str completed, object=%s\n", &op->name);
… …
2875 if (last) 2791 if (last)
2876 last->next = field->next; 2792 last->next = field->next;
2877 else 2793 else
2878 op->key_values = field->next; 2794 op->key_values = field->next;
2879 2795
2880 delete
2881 field; 2796 delete field;
2882 } 2797 }
2883 } 2798 }
2884 return TRUE; 2799 return TRUE;
2885 } 2800 }
2886 /* IF we get here, key doesn't exist */ 2801 /* IF we get here, key doesn't exist */
… …
2921 * Returns TRUE on success. 2836 * Returns TRUE on success.
2922 */ 2837 */
2923int 2838int
2924set_ob_key_value (object *op, const char *key, const char *value, int add_key) 2839set_ob_key_value (object *op, const char *key, const char *value, int add_key)
2925{ 2840{
2926 shstr
2927 key_ (key); 2841 shstr key_ (key);
2928 2842
2929 return set_ob_key_value_s (op, key_, value, add_key); 2843 return set_ob_key_value_s (op, key_, value, add_key);
2930} 2844}

Diff Legend

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