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.234 by root, Tue May 6 18:47:52 2008 UTC vs.
Revision 1.262 by elmex, Wed Oct 22 19:51:41 2008 UTC

… …
186 || ob1->speed != ob2->speed 186 || ob1->speed != ob2->speed
187 || ob1->value != ob2->value 187 || ob1->value != ob2->value
188 || ob1->name != ob2->name) 188 || ob1->name != ob2->name)
189 return 0; 189 return 0;
190 190
191 /* Do not merge objects if nrof would overflow. First part checks 191 /* Do not merge objects if nrof would overflow, assume nrof
192 * for unsigned overflow (2c), second part checks whether the result 192 * is always 0 .. 2**31-1 */
193 * would fit into a 32 bit signed int, which is often used to hold 193 if (ob1->nrof > 0x7fffffff - ob2->nrof)
194 * nrof values.
195 */
196 if (~ob1->nrof < ob2->nrof || ob1->nrof + ob2->nrof > (1UL << 31))
197 return 0; 194 return 0;
198 195
199 /* If the objects have been identified, set the BEEN_APPLIED flag. 196 /* If the objects have been identified, set the BEEN_APPLIED flag.
200 * This is to the comparison of the flags below will be OK. We 197 * This is to the comparison of the flags below will be OK. We
201 * just can't ignore the been applied or identified flags, as they 198 * just can't ignore the been applied or identified flags, as they
… …
206 SET_FLAG (ob1, FLAG_BEEN_APPLIED); 203 SET_FLAG (ob1, FLAG_BEEN_APPLIED);
207 204
208 if (QUERY_FLAG (ob2, FLAG_IDENTIFIED)) 205 if (QUERY_FLAG (ob2, FLAG_IDENTIFIED))
209 SET_FLAG (ob2, FLAG_BEEN_APPLIED); 206 SET_FLAG (ob2, FLAG_BEEN_APPLIED);
210 207
211 if (ob1->arch->name != ob2->arch->name 208 if (ob1->arch->archname != ob2->arch->archname
212 || ob1->name != ob2->name 209 || ob1->name != ob2->name
213 || ob1->title != ob2->title 210 || ob1->title != ob2->title
214 || ob1->msg != ob2->msg 211 || ob1->msg != ob2->msg
215 || ob1->weight != ob2->weight 212 || ob1->weight != ob2->weight
216 || ob1->attacktype != ob2->attacktype 213 || ob1->attacktype != ob2->attacktype
217 || ob1->magic != ob2->magic 214 || ob1->magic != ob2->magic
218 || ob1->slaying != ob2->slaying 215 || ob1->slaying != ob2->slaying
219 || ob1->skill != ob2->skill 216 || ob1->skill != ob2->skill
220 || ob1->value != ob2->value 217 || ob1->value != ob2->value
221 || ob1->animation_id != ob2->animation_id 218 || ob1->animation_id != ob2->animation_id
219 || (ob1->face != ob2->face && !ob1->animation_id) // face and animation are dependent on each other
222 || ob1->client_type != ob2->client_type 220 || ob1->client_type != ob2->client_type
223 || ob1->materialname != ob2->materialname 221 || ob1->materialname != ob2->materialname
224 || ob1->lore != ob2->lore 222 || ob1->lore != ob2->lore
225 || ob1->subtype != ob2->subtype 223 || ob1->subtype != ob2->subtype
226 || ob1->move_type != ob2->move_type 224 || ob1->move_type != ob2->move_type
… …
234 || memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats))) 232 || memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats)))
235 return 0; 233 return 0;
236 234
237 if ((ob1->flag ^ ob2->flag) 235 if ((ob1->flag ^ ob2->flag)
238 .reset (FLAG_INV_LOCKED) 236 .reset (FLAG_INV_LOCKED)
239 .reset (FLAG_CLIENT_SENT)
240 .reset (FLAG_REMOVED) 237 .reset (FLAG_REMOVED)
241 .any ()) 238 .any ())
242 return 0; 239 return 0;
243 240
244 /* This is really a spellbook check - we should in general 241 /* This is really a spellbook check - we should in general
… …
344 else 341 else
345 { 342 {
346 // maybe there is a player standing on the same mapspace 343 // maybe there is a player standing on the same mapspace
347 // this will catch the case where "this" is a player 344 // this will catch the case where "this" is a player
348 if (object *pl = ms ().player ()) 345 if (object *pl = ms ().player ())
346 if ((!pl->container && pl->contr->ns && !pl->contr->ns->update_look)
349 if (!pl->container || this == pl->container) 347 || this == pl->container)
350 return pl; 348 return pl;
351 } 349 }
352 } 350 }
353 351
354 return 0; 352 return 0;
… …
478 */ 476 */
479object * 477object *
480find_object_name (const char *str) 478find_object_name (const char *str)
481{ 479{
482 shstr_cmp str_ (str); 480 shstr_cmp str_ (str);
483 object *op;
484 481
482 if (str_)
485 for_all_objects (op) 483 for_all_objects (op)
486 if (op->name == str_) 484 if (op->name == str_)
487 break; 485 return op;
488 486
489 return op; 487 return 0;
490} 488}
491 489
492/* 490/*
493 * Sets the owner and sets the skill and exp pointers to owner's current 491 * Sets the owner and sets the skill and exp pointers to owner's current
494 * skill and experience objects. 492 * skill and experience objects.
… …
638 } 636 }
639 637
640 if (speed < 0) 638 if (speed < 0)
641 dst->speed_left -= rndm (); 639 dst->speed_left -= rndm ();
642 640
643 dst->set_speed (dst->speed); 641 dst->activate ();
644} 642}
645 643
646void 644void
647object::instantiate () 645object::instantiate ()
648{ 646{
… …
768 || (QUERY_FLAG (op, FLAG_DAMNED) && !(m.flags_ & P_NO_CLERIC)) 766 || (QUERY_FLAG (op, FLAG_DAMNED) && !(m.flags_ & P_NO_CLERIC))
769 || (m.move_on | op->move_on ) != m.move_on 767 || (m.move_on | op->move_on ) != m.move_on
770 || (m.move_off | op->move_off ) != m.move_off 768 || (m.move_off | op->move_off ) != m.move_off
771 || (m.move_slow | op->move_slow) != m.move_slow 769 || (m.move_slow | op->move_slow) != m.move_slow
772 /* This isn't perfect, but I don't expect a lot of objects to 770 /* This isn't perfect, but I don't expect a lot of objects to
773 * to have move_allow right now. 771 * have move_allow right now.
774 */ 772 */
775 || ((m.move_block | op->move_block) & ~op->move_allow) != m.move_block 773 || ((m.move_block | op->move_block) & ~op->move_allow) != m.move_block
776 || 1) // the above is not strong enough a test to skip updating. los maybe? TODO (Schmorp) 774 || 1) // the above is not strong enough a test to skip updating. los maybe? TODO (Schmorp)
777 m.flags_ = 0; 775 m.flags_ = 0;
778 } 776 }
… …
832{ 830{
833 /* If already on active list, don't do anything */ 831 /* If already on active list, don't do anything */
834 if (active) 832 if (active)
835 return; 833 return;
836 834
835 if (has_active_speed () && flag [FLAG_FREED]) LOG (llevError | logBacktrace, "BUG: tried to activate freed object %s\n", debug_desc ());//D
836 if (has_active_speed () && flag [FLAG_DEBUG]) LOG (llevError | logBacktrace, "BUG: tried to activate DEBUG object %s\n", debug_desc ());//D temp
837
837 if (has_active_speed ()) 838 if (has_active_speed ())
838 actives.insert (this); 839 actives.insert (this);
839} 840}
840 841
841void 842void
… …
904 * drop on that space. 905 * drop on that space.
905 */ 906 */
906 if (!drop_to_ground 907 if (!drop_to_ground
907 || !map 908 || !map
908 || map->in_memory != MAP_ACTIVE 909 || map->in_memory != MAP_ACTIVE
909 || map->nodrop 910 || map->no_drop
910 || ms ().move_block == MOVE_ALL) 911 || ms ().move_block == MOVE_ALL)
911 { 912 {
912 while (inv) 913 while (inv)
913 {
914 inv->destroy_inv (false);
915 inv->destroy (); 914 inv->destroy ();
916 }
917 } 915 }
918 else 916 else
919 { /* Put objects in inventory onto this space */ 917 { /* Put objects in inventory onto this space */
920 while (inv) 918 while (inv)
921 { 919 {
… …
925 || op->flag [FLAG_NO_DROP] 923 || op->flag [FLAG_NO_DROP]
926 || op->type == RUNE 924 || op->type == RUNE
927 || op->type == TRAP 925 || op->type == TRAP
928 || op->flag [FLAG_IS_A_TEMPLATE] 926 || op->flag [FLAG_IS_A_TEMPLATE]
929 || op->flag [FLAG_DESTROY_ON_DEATH]) 927 || op->flag [FLAG_DESTROY_ON_DEATH])
930 op->destroy (true); 928 op->destroy ();
931 else 929 else
932 map->insert (op, x, y); 930 map->insert (op, x, y);
933 } 931 }
934 } 932 }
935} 933}
… …
943 941
944static struct freed_map : maptile 942static struct freed_map : maptile
945{ 943{
946 freed_map () 944 freed_map ()
947 { 945 {
948 path = "<freed objects map>"; 946 path = "<freed objects map>";
949 name = "/internal/freed_objects_map"; 947 name = "/internal/freed_objects_map";
950 width = 3; 948 width = 3;
951 height = 3; 949 height = 3;
952 nodrop = 1; 950 no_drop = 1;
951 no_reset = 1;
953 952
954 alloc (); 953 alloc ();
955 in_memory = MAP_ACTIVE; 954 in_memory = MAP_ACTIVE;
956 } 955 }
957 956
… …
998 attacked_by = 0; 997 attacked_by = 0;
999 current_weapon = 0; 998 current_weapon = 0;
1000} 999}
1001 1000
1002void 1001void
1003object::destroy (bool destroy_inventory) 1002object::destroy ()
1004{ 1003{
1005 if (destroyed ()) 1004 if (destroyed ())
1006 return; 1005 return;
1007 1006
1008 if (!is_head () && !head->destroyed ()) 1007 if (!is_head () && !head->destroyed ())
1009 { 1008 {
1010 LOG (llevError | logBacktrace, "tried to destroy the tail of an object"); 1009 LOG (llevError | logBacktrace, "tried to destroy the tail of an object");
1011 head->destroy (destroy_inventory); 1010 head->destroy ();
1012 return; 1011 return;
1013 } 1012 }
1014 1013
1015 destroy_inv (!destroy_inventory); 1014 destroy_inv (false);
1016 1015
1017 if (is_head ()) 1016 if (is_head ())
1018 if (sound_destroy) 1017 if (sound_destroy)
1019 play_sound (sound_destroy); 1018 play_sound (sound_destroy);
1020 else if (flag [FLAG_MONSTER]) 1019 else if (flag [FLAG_MONSTER])
… …
1056 if (object *pl = visible_to ()) 1055 if (object *pl = visible_to ())
1057 esrv_del_item (pl->contr, count); 1056 esrv_del_item (pl->contr, count);
1058 flag [FLAG_REMOVED] = true; // hack around the issue of visible_to checking flag_removed 1057 flag [FLAG_REMOVED] = true; // hack around the issue of visible_to checking flag_removed
1059 1058
1060 adjust_weight (env, -total_weight ()); 1059 adjust_weight (env, -total_weight ());
1061
1062 *(above ? &above->below : &env->inv) = below;
1063
1064 if (below)
1065 below->above = above;
1066 1060
1067 /* we set up values so that it could be inserted into 1061 /* we set up values so that it could be inserted into
1068 * the map, but we don't actually do that - it is up 1062 * the map, but we don't actually do that - it is up
1069 * to the caller to decide what we want to do. 1063 * to the caller to decide what we want to do.
1070 */ 1064 */
1071 map = env->map; 1065 map = env->map;
1072 x = env->x; 1066 x = env->x;
1073 y = env->y; 1067 y = env->y;
1068
1069 // make sure cmov optimisation is applicable
1070 *(above ? &above->below : &env->inv) = below;
1071 *(below ? &below->above : &above ) = above; // &above is just a dummy
1072
1074 above = 0; 1073 above = 0;
1075 below = 0; 1074 below = 0;
1076 env = 0; 1075 env = 0;
1077 1076
1078 /* NO_FIX_PLAYER is set when a great many changes are being 1077 /* NO_FIX_PLAYER is set when a great many changes are being
… …
1108 1107
1109 esrv_del_item (pl->contr, count); 1108 esrv_del_item (pl->contr, count);
1110 } 1109 }
1111 1110
1112 /* link the object above us */ 1111 /* link the object above us */
1113 if (above) 1112 // re-link, make sure compiler can easily use cmove
1114 above->below = below; 1113 *(above ? &above->below : &ms.top) = below;
1115 else 1114 *(below ? &below->above : &ms.bot) = above;
1116 ms.top = below; /* we were top, set new top */
1117
1118 /* Relink the object below us, if there is one */
1119 if (below)
1120 below->above = above;
1121 else
1122 {
1123 /* Nothing below, which means we need to relink map object for this space
1124 * use translated coordinates in case some oddness with map tiling is
1125 * evident
1126 */
1127 if (GET_MAP_OB (map, x, y) != this)
1128 LOG (llevError, "remove_ob: GET_MAP_OB does not return object to be removed even though it appears to be on the bottom? %s\n", debug_desc ());
1129
1130 ms.bot = above; /* goes on above it. */
1131 }
1132 1115
1133 above = 0; 1116 above = 0;
1134 below = 0; 1117 below = 0;
1118
1119 ms.flags_ = 0;
1135 1120
1136 if (map->in_memory == MAP_SAVING) 1121 if (map->in_memory == MAP_SAVING)
1137 return; 1122 return;
1138 1123
1139 int check_walk_off = !flag [FLAG_NO_APPLY]; 1124 int check_walk_off = !flag [FLAG_NO_APPLY];
… …
1172 } 1157 }
1173 1158
1174 last = tmp; 1159 last = tmp;
1175 } 1160 }
1176 1161
1177 /* last == NULL if there are no objects on this space */
1178 //TODO: this makes little sense, why only update the topmost object?
1179 if (!last)
1180 map->at (x, y).flags_ = 0;
1181 else
1182 update_object (last, UP_OBJ_REMOVE);
1183
1184 if (flag [FLAG_BLOCKSVIEW] || glow_radius) 1162 if (flag [FLAG_BLOCKSVIEW] || glow_radius)
1185 update_all_los (map, x, y); 1163 update_all_los (map, x, y);
1186 } 1164 }
1187} 1165}
1188 1166
… …
1213 esrv_update_item (UPD_NROF, pl, top); 1191 esrv_update_item (UPD_NROF, pl, top);
1214 1192
1215 op->weight = 0; // cancel the addition above 1193 op->weight = 0; // cancel the addition above
1216 op->carrying = 0; // must be 0 already 1194 op->carrying = 0; // must be 0 already
1217 1195
1218 op->destroy (1); 1196 op->destroy ();
1219 1197
1220 return top; 1198 return top;
1221 } 1199 }
1222 1200
1223 return 0; 1201 return 0;
… …
1251 * job preparing multi-part monsters. 1229 * job preparing multi-part monsters.
1252 */ 1230 */
1253object * 1231object *
1254insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y) 1232insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y)
1255{ 1233{
1234 op->remove ();
1235
1256 for (object *tmp = op->head_ (); tmp; tmp = tmp->more) 1236 for (object *tmp = op->head_ (); tmp; tmp = tmp->more)
1257 { 1237 {
1258 tmp->x = x + tmp->arch->x; 1238 tmp->x = x + tmp->arch->x;
1259 tmp->y = y + tmp->arch->y; 1239 tmp->y = y + tmp->arch->y;
1260 } 1240 }
… …
1283 * just 'op' otherwise 1263 * just 'op' otherwise
1284 */ 1264 */
1285object * 1265object *
1286insert_ob_in_map (object *op, maptile *m, object *originator, int flag) 1266insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
1287{ 1267{
1288 assert (!op->flag [FLAG_FREED]);
1289
1290 op->remove (); 1268 op->remove ();
1269
1270 if (m == &freed_map)//D TODO: remove soon
1271 {//D
1272 LOG (llevError | logBacktrace, "tries to insret object on freed objects map: %s", op->debug_desc ());//D
1273 }//D
1291 1274
1292 /* Ideally, the caller figures this out. However, it complicates a lot 1275 /* Ideally, the caller figures this out. However, it complicates a lot
1293 * of areas of callers (eg, anything that uses find_free_spot would now 1276 * of areas of callers (eg, anything that uses find_free_spot would now
1294 * need extra work 1277 * need extra work
1295 */ 1278 */
1296 if (!xy_normalise (m, op->x, op->y)) 1279 if (!xy_normalise (m, op->x, op->y))
1297 { 1280 {
1298 op->head_ ()->destroy (1);// remove head_ once all tail object destroyers found 1281 op->head_ ()->destroy ();// remove head_ once all tail object destroyers found
1299 return 0; 1282 return 0;
1300 } 1283 }
1301 1284
1302 if (object *more = op->more) 1285 if (object *more = op->more)
1303 if (!insert_ob_in_map (more, m, originator, flag)) 1286 if (!insert_ob_in_map (more, m, originator, flag))
… …
1312 */ 1295 */
1313 if (op->nrof && !(flag & INS_NO_MERGE)) 1296 if (op->nrof && !(flag & INS_NO_MERGE))
1314 for (object *tmp = ms.bot; tmp; tmp = tmp->above) 1297 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1315 if (object::can_merge (op, tmp)) 1298 if (object::can_merge (op, tmp))
1316 { 1299 {
1317 // TODO: we atcually want to update tmp, not op, 1300 // TODO: we actually want to update tmp, not op,
1318 // but some caller surely breaks when we return tmp 1301 // but some caller surely breaks when we return tmp
1319 // from here :/ 1302 // from here :/
1320 op->nrof += tmp->nrof; 1303 op->nrof += tmp->nrof;
1321 tmp->destroy (1); 1304 tmp->destroy ();
1322 } 1305 }
1323 1306
1324 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */ 1307 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */
1325 CLEAR_FLAG (op, FLAG_INV_LOCKED); 1308 CLEAR_FLAG (op, FLAG_INV_LOCKED);
1326 1309
… …
1333 { 1316 {
1334 LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n"); 1317 LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n");
1335 abort (); 1318 abort ();
1336 } 1319 }
1337 1320
1321 if (!originator->is_on_map ())
1322 LOG (llevDebug | logBacktrace, "insert_ob_in_map(%s) called with INS_BELOW_ORIGINATOR when originator '%s' not on map",
1323 op->debug_desc (), originator->debug_desc ());
1324
1338 op->above = originator; 1325 op->above = originator;
1339 op->below = originator->below; 1326 op->below = originator->below;
1340
1341 if (op->below)
1342 op->below->above = op;
1343 else
1344 ms.bot = op;
1345
1346 /* since *below* originator, no need to update top */
1347 originator->below = op; 1327 originator->below = op;
1328
1329 *(op->below ? &op->below->above : &ms.bot) = op;
1348 } 1330 }
1349 else 1331 else
1350 { 1332 {
1351 object *top, *floor = NULL; 1333 object *floor = 0;
1352 1334 object *top = ms.top;
1353 top = ms.bot;
1354 1335
1355 /* If there are other objects, then */ 1336 /* If there are other objects, then */
1356 if (top) 1337 if (top)
1357 { 1338 {
1358 object *last = 0;
1359
1360 /* 1339 /*
1361 * If there are multiple objects on this space, we do some trickier handling. 1340 * If there are multiple objects on this space, we do some trickier handling.
1362 * We've already dealt with merging if appropriate. 1341 * We've already dealt with merging if appropriate.
1363 * Generally, we want to put the new object on top. But if 1342 * Generally, we want to put the new object on top. But if
1364 * flag contains INS_ABOVE_FLOOR_ONLY, once we find the last 1343 * flag contains INS_ABOVE_FLOOR_ONLY, once we find the last
… …
1367 * once we get to them. This reduces the need to traverse over all of 1346 * once we get to them. This reduces the need to traverse over all of
1368 * them when adding another one - this saves quite a bit of cpu time 1347 * them when adding another one - this saves quite a bit of cpu time
1369 * when lots of spells are cast in one area. Currently, it is presumed 1348 * when lots of spells are cast in one area. Currently, it is presumed
1370 * that flying non pickable objects are spell objects. 1349 * that flying non pickable objects are spell objects.
1371 */ 1350 */
1372 for (top = ms.bot; top; top = top->above) 1351 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1373 { 1352 {
1374 if (QUERY_FLAG (top, FLAG_IS_FLOOR) || QUERY_FLAG (top, FLAG_OVERLAY_FLOOR)) 1353 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) || QUERY_FLAG (tmp, FLAG_OVERLAY_FLOOR))
1375 floor = top; 1354 floor = tmp;
1376 1355
1377 if (QUERY_FLAG (top, FLAG_NO_PICK) && (top->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !QUERY_FLAG (top, FLAG_IS_FLOOR)) 1356 if (QUERY_FLAG (tmp, FLAG_NO_PICK) && (tmp->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1378 { 1357 {
1379 /* We insert above top, so we want this object below this */ 1358 /* We insert above top, so we want this object below this */
1380 top = top->below; 1359 top = tmp->below;
1381 break; 1360 break;
1382 } 1361 }
1383 1362
1384 last = top; 1363 top = tmp;
1385 } 1364 }
1386
1387 /* Don't want top to be NULL, so set it to the last valid object */
1388 top = last;
1389 1365
1390 /* We let update_position deal with figuring out what the space 1366 /* We let update_position deal with figuring out what the space
1391 * looks like instead of lots of conditions here. 1367 * looks like instead of lots of conditions here.
1392 * makes things faster, and effectively the same result. 1368 * makes things faster, and effectively the same result.
1393 */ 1369 */
… …
1400 */ 1376 */
1401 if (!(flag & INS_ON_TOP) 1377 if (!(flag & INS_ON_TOP)
1402 && ms.flags () & P_BLOCKSVIEW 1378 && ms.flags () & P_BLOCKSVIEW
1403 && (op->face && !faces [op->face].visibility)) 1379 && (op->face && !faces [op->face].visibility))
1404 { 1380 {
1381 object *last;
1382
1405 for (last = top; last != floor; last = last->below) 1383 for (last = top; last != floor; last = last->below)
1406 if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT)) 1384 if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT))
1407 break; 1385 break;
1408 1386
1409 /* Check to see if we found the object that blocks view, 1387 /* Check to see if we found the object that blocks view,
… …
1417 } /* If objects on this space */ 1395 } /* If objects on this space */
1418 1396
1419 if (flag & INS_ABOVE_FLOOR_ONLY) 1397 if (flag & INS_ABOVE_FLOOR_ONLY)
1420 top = floor; 1398 top = floor;
1421 1399
1422 /* Top is the object that our object (op) is going to get inserted above. 1400 // insert object above top, or bottom-most if top = 0
1423 */
1424
1425 /* First object on this space */
1426 if (!top) 1401 if (!top)
1427 { 1402 {
1403 op->below = 0;
1428 op->above = ms.bot; 1404 op->above = ms.bot;
1429
1430 if (op->above)
1431 op->above->below = op;
1432
1433 op->below = 0;
1434 ms.bot = op; 1405 ms.bot = op;
1406
1407 *(op->above ? &op->above->below : &ms.top) = op;
1435 } 1408 }
1436 else 1409 else
1437 { /* get inserted into the stack above top */ 1410 {
1438 op->above = top->above; 1411 op->above = top->above;
1439
1440 if (op->above)
1441 op->above->below = op; 1412 top->above = op;
1442 1413
1443 op->below = top; 1414 op->below = top;
1444 top->above = op; 1415 *(op->above ? &op->above->below : &ms.top) = op;
1445 } 1416 }
1446 1417 }
1447 if (!op->above)
1448 ms.top = op;
1449 } /* else not INS_BELOW_ORIGINATOR */
1450 1418
1451 if (op->type == PLAYER) 1419 if (op->type == PLAYER)
1452 { 1420 {
1453 op->contr->do_los = 1; 1421 op->contr->do_los = 1;
1454 ++op->map->players; 1422 ++op->map->players;
… …
1516{ 1484{
1517 /* first search for itself and remove any old instances */ 1485 /* first search for itself and remove any old instances */
1518 1486
1519 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above) 1487 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
1520 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */ 1488 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */
1521 tmp->destroy (1); 1489 tmp->destroy ();
1522 1490
1523 object *tmp = arch_to_object (archetype::find (arch_string)); 1491 object *tmp = arch_to_object (archetype::find (arch_string));
1524 1492
1525 tmp->x = op->x; 1493 tmp->x = op->x;
1526 tmp->y = op->y; 1494 tmp->y = op->y;
… …
1550 if (!nr) 1518 if (!nr)
1551 return true; 1519 return true;
1552 1520
1553 nr = min (nr, nrof); 1521 nr = min (nr, nrof);
1554 1522
1523 if (nrof > nr)
1524 {
1555 nrof -= nr; 1525 nrof -= nr;
1556
1557 if (nrof)
1558 {
1559 adjust_weight (env, -weight * nr); // carrying == 0 1526 adjust_weight (env, -weight * max (1, nr)); // carrying == 0
1560 1527
1561 if (object *pl = visible_to ()) 1528 if (object *pl = visible_to ())
1562 esrv_update_item (UPD_NROF, pl, this); 1529 esrv_update_item (UPD_NROF, pl, this);
1563 1530
1564 return true; 1531 return true;
1565 } 1532 }
1566 else 1533 else
1567 { 1534 {
1568 destroy (1); 1535 destroy ();
1569 return false; 1536 return false;
1570 } 1537 }
1571} 1538}
1572 1539
1573/* 1540/*
… …
1650 if (object *pl = tmp->visible_to ()) 1617 if (object *pl = tmp->visible_to ())
1651 esrv_update_item (UPD_NROF, pl, tmp); 1618 esrv_update_item (UPD_NROF, pl, tmp);
1652 1619
1653 adjust_weight (this, op->total_weight ()); 1620 adjust_weight (this, op->total_weight ());
1654 1621
1655 op->destroy (1); 1622 op->destroy ();
1656 op = tmp; 1623 op = tmp;
1657 goto inserted; 1624 goto inserted;
1658 } 1625 }
1659 1626
1660 op->owner = 0; // it's his/hers now. period. 1627 op->owner = 0; // it's his/hers now. period.
… …
1994 * head of the object should correspond for the entire object. 1961 * head of the object should correspond for the entire object.
1995 */ 1962 */
1996 if (OB_TYPE_MOVE_BLOCK (ob, ms.move_block)) 1963 if (OB_TYPE_MOVE_BLOCK (ob, ms.move_block))
1997 continue; 1964 continue;
1998 1965
1999 if (ob->blocked (m, pos.x, pos.y)) 1966 if (ob->blocked (pos.m, pos.x, pos.y))
2000 continue; 1967 continue;
2001 1968
2002 altern [index++] = i; 1969 altern [index++] = i;
2003 } 1970 }
2004 1971
… …
2449{ 2416{
2450 char flagdesc[512]; 2417 char flagdesc[512];
2451 char info2[256 * 4]; 2418 char info2[256 * 4];
2452 char *p = info; 2419 char *p = info;
2453 2420
2454 p += snprintf (p, 512, "{cnt:%d,uuid:%s,name:\"%s\"%s%s,flags:[%s],type:%d}", 2421 p += snprintf (p, 512, "{cnt:%d,uuid:%s,name:\"%s\"%s%s%s,flags:[%s],type:%d}",
2455 count, 2422 count,
2456 uuid.c_str (), 2423 uuid.c_str (),
2457 &name, 2424 &name,
2458 title ? "\",title:\"" : "", 2425 title ? ",title:\"" : "",
2459 title ? (const char *)title : "", 2426 title ? (const char *)title : "",
2427 title ? "\"" : "",
2460 flag_desc (flagdesc, 512), type); 2428 flag_desc (flagdesc, 512), type);
2461 2429
2462 if (!flag[FLAG_REMOVED] && env) 2430 if (!flag[FLAG_REMOVED] && env)
2463 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2)); 2431 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
2464 2432

Diff Legend

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