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.266 by root, Tue Dec 23 01:13:15 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.invalidate ();
778 } 776 }
779 /* if the object is being removed, we can't make intelligent 777 /* if the object is being removed, we can't make intelligent
780 * decisions, because remove_ob can't really pass the object 778 * decisions, because remove_ob can't really pass the object
781 * that is being removed. 779 * that is being removed.
782 */ 780 */
783 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE) 781 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE)
784 m.flags_ = 0; 782 m.invalidate ();
785 else if (action == UP_OBJ_FACE) 783 else if (action == UP_OBJ_FACE)
786 /* Nothing to do for that case */ ; 784 /* Nothing to do for that case */ ;
787 else 785 else
788 LOG (llevError, "update_object called with invalid action: %d\n", action); 786 LOG (llevError, "update_object called with invalid action: %d\n", action);
789 787
… …
831object::activate () 829object::activate ()
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;
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
836 837
837 if (has_active_speed ()) 838 if (has_active_speed ())
838 actives.insert (this); 839 actives.insert (this);
839} 840}
840 841
… …
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])
… …
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 1060
1062 *(above ? &above->below : &env->inv) = below; 1061 object *pl = in_player ();
1063
1064 if (below)
1065 below->above = above;
1066 1062
1067 /* we set up values so that it could be inserted into 1063 /* we set up values so that it could be inserted into
1068 * the map, but we don't actually do that - it is up 1064 * the map, but we don't actually do that - it is up
1069 * to the caller to decide what we want to do. 1065 * to the caller to decide what we want to do.
1070 */ 1066 */
1071 map = env->map; 1067 map = env->map;
1072 x = env->x; 1068 x = env->x;
1073 y = env->y; 1069 y = env->y;
1070
1071 // make sure cmov optimisation is applicable
1072 *(above ? &above->below : &env->inv) = below;
1073 *(below ? &below->above : &above ) = above; // &above is just a dummy
1074
1074 above = 0; 1075 above = 0;
1075 below = 0; 1076 below = 0;
1076 env = 0; 1077 env = 0;
1077 1078
1078 /* NO_FIX_PLAYER is set when a great many changes are being 1079 /* NO_FIX_PLAYER is set when a great many changes are being
1079 * made to players inventory. If set, avoiding the call 1080 * made to players inventory. If set, avoiding the call
1080 * to save cpu time. 1081 * to save cpu time.
1081 */ 1082 */
1083 if (pl)
1082 if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER)) 1084 if (pl->contr && !QUERY_FLAG (pl, FLAG_NO_FIX_PLAYER))
1085 {
1083 otmp->update_stats (); 1086 pl->update_stats ();
1087
1088 if (affects_los () && pl->is_on_map () && pl->map->darkness)
1089 update_all_los (pl->map, pl->x, pl->y);
1090 }
1084 } 1091 }
1085 else if (map) 1092 else if (map)
1086 { 1093 {
1087 map->dirty = true; 1094 map->dirty = true;
1088 mapspace &ms = this->ms (); 1095 mapspace &ms = this->ms ();
… …
1108 1115
1109 esrv_del_item (pl->contr, count); 1116 esrv_del_item (pl->contr, count);
1110 } 1117 }
1111 1118
1112 /* link the object above us */ 1119 /* link the object above us */
1113 if (above) 1120 // re-link, make sure compiler can easily use cmove
1114 above->below = below; 1121 *(above ? &above->below : &ms.top) = below;
1115 else 1122 *(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 1123
1133 above = 0; 1124 above = 0;
1134 below = 0; 1125 below = 0;
1126
1127 ms.invalidate ();
1135 1128
1136 if (map->in_memory == MAP_SAVING) 1129 if (map->in_memory == MAP_SAVING)
1137 return; 1130 return;
1138 1131
1139 int check_walk_off = !flag [FLAG_NO_APPLY]; 1132 int check_walk_off = !flag [FLAG_NO_APPLY];
… …
1172 } 1165 }
1173 1166
1174 last = tmp; 1167 last = tmp;
1175 } 1168 }
1176 1169
1177 /* last == NULL if there are no objects on this space */ 1170 if (map->darkness && affects_los ())
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)
1185 update_all_los (map, x, y); 1171 update_all_los (map, x, y);
1186 } 1172 }
1187} 1173}
1188 1174
1189/* 1175/*
… …
1213 esrv_update_item (UPD_NROF, pl, top); 1199 esrv_update_item (UPD_NROF, pl, top);
1214 1200
1215 op->weight = 0; // cancel the addition above 1201 op->weight = 0; // cancel the addition above
1216 op->carrying = 0; // must be 0 already 1202 op->carrying = 0; // must be 0 already
1217 1203
1218 op->destroy (1); 1204 op->destroy ();
1219 1205
1220 return top; 1206 return top;
1221 } 1207 }
1222 1208
1223 return 0; 1209 return 0;
… …
1251 * job preparing multi-part monsters. 1237 * job preparing multi-part monsters.
1252 */ 1238 */
1253object * 1239object *
1254insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y) 1240insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y)
1255{ 1241{
1242 op->remove ();
1243
1256 for (object *tmp = op->head_ (); tmp; tmp = tmp->more) 1244 for (object *tmp = op->head_ (); tmp; tmp = tmp->more)
1257 { 1245 {
1258 tmp->x = x + tmp->arch->x; 1246 tmp->x = x + tmp->arch->x;
1259 tmp->y = y + tmp->arch->y; 1247 tmp->y = y + tmp->arch->y;
1260 } 1248 }
… …
1283 * just 'op' otherwise 1271 * just 'op' otherwise
1284 */ 1272 */
1285object * 1273object *
1286insert_ob_in_map (object *op, maptile *m, object *originator, int flag) 1274insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
1287{ 1275{
1288 assert (!op->flag [FLAG_FREED]);
1289
1290 op->remove (); 1276 op->remove ();
1277
1278 if (m == &freed_map)//D TODO: remove soon
1279 {//D
1280 LOG (llevError | logBacktrace, "tries to insret object on freed objects map: %s", op->debug_desc ());//D
1281 }//D
1291 1282
1292 /* Ideally, the caller figures this out. However, it complicates a lot 1283 /* 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 1284 * of areas of callers (eg, anything that uses find_free_spot would now
1294 * need extra work 1285 * need extra work
1295 */ 1286 */
1296 if (!xy_normalise (m, op->x, op->y)) 1287 if (!xy_normalise (m, op->x, op->y))
1297 { 1288 {
1298 op->head_ ()->destroy (1);// remove head_ once all tail object destroyers found 1289 op->head_ ()->destroy ();// remove head_ once all tail object destroyers found
1299 return 0; 1290 return 0;
1300 } 1291 }
1301 1292
1302 if (object *more = op->more) 1293 if (object *more = op->more)
1303 if (!insert_ob_in_map (more, m, originator, flag)) 1294 if (!insert_ob_in_map (more, m, originator, flag))
… …
1312 */ 1303 */
1313 if (op->nrof && !(flag & INS_NO_MERGE)) 1304 if (op->nrof && !(flag & INS_NO_MERGE))
1314 for (object *tmp = ms.bot; tmp; tmp = tmp->above) 1305 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1315 if (object::can_merge (op, tmp)) 1306 if (object::can_merge (op, tmp))
1316 { 1307 {
1317 // TODO: we atcually want to update tmp, not op, 1308 // TODO: we actually want to update tmp, not op,
1318 // but some caller surely breaks when we return tmp 1309 // but some caller surely breaks when we return tmp
1319 // from here :/ 1310 // from here :/
1320 op->nrof += tmp->nrof; 1311 op->nrof += tmp->nrof;
1321 tmp->destroy (1); 1312 tmp->destroy ();
1322 } 1313 }
1323 1314
1324 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */ 1315 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */
1325 CLEAR_FLAG (op, FLAG_INV_LOCKED); 1316 CLEAR_FLAG (op, FLAG_INV_LOCKED);
1326 1317
… …
1333 { 1324 {
1334 LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n"); 1325 LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n");
1335 abort (); 1326 abort ();
1336 } 1327 }
1337 1328
1329 if (!originator->is_on_map ())
1330 LOG (llevDebug | logBacktrace, "insert_ob_in_map(%s) called with INS_BELOW_ORIGINATOR when originator '%s' not on map",
1331 op->debug_desc (), originator->debug_desc ());
1332
1338 op->above = originator; 1333 op->above = originator;
1339 op->below = originator->below; 1334 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; 1335 originator->below = op;
1336
1337 *(op->below ? &op->below->above : &ms.bot) = op;
1348 } 1338 }
1349 else 1339 else
1350 { 1340 {
1351 object *top, *floor = NULL; 1341 object *floor = 0;
1352 1342 object *top = ms.top;
1353 top = ms.bot;
1354 1343
1355 /* If there are other objects, then */ 1344 /* If there are other objects, then */
1356 if (top) 1345 if (top)
1357 { 1346 {
1358 object *last = 0;
1359
1360 /* 1347 /*
1361 * If there are multiple objects on this space, we do some trickier handling. 1348 * If there are multiple objects on this space, we do some trickier handling.
1362 * We've already dealt with merging if appropriate. 1349 * We've already dealt with merging if appropriate.
1363 * Generally, we want to put the new object on top. But if 1350 * Generally, we want to put the new object on top. But if
1364 * flag contains INS_ABOVE_FLOOR_ONLY, once we find the last 1351 * 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 1354 * 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 1355 * 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 1356 * when lots of spells are cast in one area. Currently, it is presumed
1370 * that flying non pickable objects are spell objects. 1357 * that flying non pickable objects are spell objects.
1371 */ 1358 */
1372 for (top = ms.bot; top; top = top->above) 1359 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1373 { 1360 {
1374 if (QUERY_FLAG (top, FLAG_IS_FLOOR) || QUERY_FLAG (top, FLAG_OVERLAY_FLOOR)) 1361 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) || QUERY_FLAG (tmp, FLAG_OVERLAY_FLOOR))
1375 floor = top; 1362 floor = tmp;
1376 1363
1377 if (QUERY_FLAG (top, FLAG_NO_PICK) && (top->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !QUERY_FLAG (top, FLAG_IS_FLOOR)) 1364 if (QUERY_FLAG (tmp, FLAG_NO_PICK) && (tmp->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1378 { 1365 {
1379 /* We insert above top, so we want this object below this */ 1366 /* We insert above top, so we want this object below this */
1380 top = top->below; 1367 top = tmp->below;
1381 break; 1368 break;
1382 } 1369 }
1383 1370
1384 last = top; 1371 top = tmp;
1385 } 1372 }
1386
1387 /* Don't want top to be NULL, so set it to the last valid object */
1388 top = last;
1389 1373
1390 /* We let update_position deal with figuring out what the space 1374 /* We let update_position deal with figuring out what the space
1391 * looks like instead of lots of conditions here. 1375 * looks like instead of lots of conditions here.
1392 * makes things faster, and effectively the same result. 1376 * makes things faster, and effectively the same result.
1393 */ 1377 */
… …
1400 */ 1384 */
1401 if (!(flag & INS_ON_TOP) 1385 if (!(flag & INS_ON_TOP)
1402 && ms.flags () & P_BLOCKSVIEW 1386 && ms.flags () & P_BLOCKSVIEW
1403 && (op->face && !faces [op->face].visibility)) 1387 && (op->face && !faces [op->face].visibility))
1404 { 1388 {
1389 object *last;
1390
1405 for (last = top; last != floor; last = last->below) 1391 for (last = top; last != floor; last = last->below)
1406 if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT)) 1392 if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT))
1407 break; 1393 break;
1408 1394
1409 /* Check to see if we found the object that blocks view, 1395 /* Check to see if we found the object that blocks view,
… …
1417 } /* If objects on this space */ 1403 } /* If objects on this space */
1418 1404
1419 if (flag & INS_ABOVE_FLOOR_ONLY) 1405 if (flag & INS_ABOVE_FLOOR_ONLY)
1420 top = floor; 1406 top = floor;
1421 1407
1422 /* Top is the object that our object (op) is going to get inserted above. 1408 // insert object above top, or bottom-most if top = 0
1423 */
1424
1425 /* First object on this space */
1426 if (!top) 1409 if (!top)
1427 { 1410 {
1411 op->below = 0;
1428 op->above = ms.bot; 1412 op->above = ms.bot;
1429
1430 if (op->above)
1431 op->above->below = op;
1432
1433 op->below = 0;
1434 ms.bot = op; 1413 ms.bot = op;
1414
1415 *(op->above ? &op->above->below : &ms.top) = op;
1435 } 1416 }
1436 else 1417 else
1437 { /* get inserted into the stack above top */ 1418 {
1438 op->above = top->above; 1419 op->above = top->above;
1439
1440 if (op->above)
1441 op->above->below = op; 1420 top->above = op;
1442 1421
1443 op->below = top; 1422 op->below = top;
1444 top->above = op; 1423 *(op->above ? &op->above->below : &ms.top) = op;
1445 } 1424 }
1446 1425 }
1447 if (!op->above)
1448 ms.top = op;
1449 } /* else not INS_BELOW_ORIGINATOR */
1450 1426
1451 if (op->type == PLAYER) 1427 if (op->type == PLAYER)
1452 { 1428 {
1453 op->contr->do_los = 1; 1429 op->contr->do_los = 1;
1454 ++op->map->players; 1430 ++op->map->players;
… …
1471 * be far away from this change and not affected in any way - 1447 * be far away from this change and not affected in any way -
1472 * this should get redone to only look for players within range, 1448 * this should get redone to only look for players within range,
1473 * or just updating the P_UPTODATE for spaces within this area 1449 * or just updating the P_UPTODATE for spaces within this area
1474 * of effect may be sufficient. 1450 * of effect may be sufficient.
1475 */ 1451 */
1476 if (op->map->darkness && (op->glow_radius != 0)) 1452 if (op->affects_los () && op->map->darkness)
1453 {
1454 op->ms ().invalidate ();
1477 update_all_los (op->map, op->x, op->y); 1455 update_all_los (op->map, op->x, op->y);
1456 }
1478 1457
1479 /* updates flags (blocked, alive, no magic, etc) for this map space */ 1458 /* updates flags (blocked, alive, no magic, etc) for this map space */
1480 update_object (op, UP_OBJ_INSERT); 1459 update_object (op, UP_OBJ_INSERT);
1481 1460
1482 INVOKE_OBJECT (INSERT, op); 1461 INVOKE_OBJECT (INSERT, op);
… …
1516{ 1495{
1517 /* first search for itself and remove any old instances */ 1496 /* first search for itself and remove any old instances */
1518 1497
1519 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above) 1498 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
1520 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */ 1499 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */
1521 tmp->destroy (1); 1500 tmp->destroy ();
1522 1501
1523 object *tmp = arch_to_object (archetype::find (arch_string)); 1502 object *tmp = arch_to_object (archetype::find (arch_string));
1524 1503
1525 tmp->x = op->x; 1504 tmp->x = op->x;
1526 tmp->y = op->y; 1505 tmp->y = op->y;
… …
1550 if (!nr) 1529 if (!nr)
1551 return true; 1530 return true;
1552 1531
1553 nr = min (nr, nrof); 1532 nr = min (nr, nrof);
1554 1533
1534 if (nrof > nr)
1535 {
1555 nrof -= nr; 1536 nrof -= nr;
1556
1557 if (nrof)
1558 {
1559 adjust_weight (env, -weight * nr); // carrying == 0 1537 adjust_weight (env, -weight * max (1, nr)); // carrying == 0
1560 1538
1561 if (object *pl = visible_to ()) 1539 if (object *pl = visible_to ())
1562 esrv_update_item (UPD_NROF, pl, this); 1540 esrv_update_item (UPD_NROF, pl, this);
1563 1541
1564 return true; 1542 return true;
1565 } 1543 }
1566 else 1544 else
1567 { 1545 {
1568 destroy (1); 1546 destroy ();
1569 return false; 1547 return false;
1570 } 1548 }
1571} 1549}
1572 1550
1573/* 1551/*
… …
1650 if (object *pl = tmp->visible_to ()) 1628 if (object *pl = tmp->visible_to ())
1651 esrv_update_item (UPD_NROF, pl, tmp); 1629 esrv_update_item (UPD_NROF, pl, tmp);
1652 1630
1653 adjust_weight (this, op->total_weight ()); 1631 adjust_weight (this, op->total_weight ());
1654 1632
1655 op->destroy (1); 1633 op->destroy ();
1656 op = tmp; 1634 op = tmp;
1657 goto inserted; 1635 goto inserted;
1658 } 1636 }
1659 1637
1660 op->owner = 0; // it's his/hers now. period. 1638 op->owner = 0; // it's his/hers now. period.
… …
1678 1656
1679 adjust_weight (this, op->total_weight ()); 1657 adjust_weight (this, op->total_weight ());
1680 1658
1681inserted: 1659inserted:
1682 /* reset the light list and los of the players on the map */ 1660 /* reset the light list and los of the players on the map */
1683 if (op->glow_radius && map && map->darkness) 1661 if (op->glow_radius && is_on_map () && map->darkness)
1662 {
1663 update_stats ();
1684 update_all_los (map, x, y); 1664 update_all_los (map, x, y);
1685 1665 }
1666 else if (type == PLAYER && !flag [FLAG_NO_FIX_PLAYER])
1686 // if this is a player's inventory, update stats 1667 // if this is a player's inventory, update stats
1687 if (type == PLAYER && !flag [FLAG_NO_FIX_PLAYER])
1688 update_stats (); 1668 update_stats ();
1689 1669
1690 INVOKE_OBJECT (INSERT, this); 1670 INVOKE_OBJECT (INSERT, this);
1691 1671
1692 return op; 1672 return op;
… …
1994 * head of the object should correspond for the entire object. 1974 * head of the object should correspond for the entire object.
1995 */ 1975 */
1996 if (OB_TYPE_MOVE_BLOCK (ob, ms.move_block)) 1976 if (OB_TYPE_MOVE_BLOCK (ob, ms.move_block))
1997 continue; 1977 continue;
1998 1978
1999 if (ob->blocked (m, pos.x, pos.y)) 1979 if (ob->blocked (pos.m, pos.x, pos.y))
2000 continue; 1980 continue;
2001 1981
2002 altern [index++] = i; 1982 altern [index++] = i;
2003 } 1983 }
2004 1984
… …
2449{ 2429{
2450 char flagdesc[512]; 2430 char flagdesc[512];
2451 char info2[256 * 4]; 2431 char info2[256 * 4];
2452 char *p = info; 2432 char *p = info;
2453 2433
2454 p += snprintf (p, 512, "{cnt:%d,uuid:%s,name:\"%s\"%s%s,flags:[%s],type:%d}", 2434 p += snprintf (p, 512, "{cnt:%d,uuid:%s,name:\"%s\"%s%s%s,flags:[%s],type:%d}",
2455 count, 2435 count,
2456 uuid.c_str (), 2436 uuid.c_str (),
2457 &name, 2437 &name,
2458 title ? "\",title:\"" : "", 2438 title ? ",title:\"" : "",
2459 title ? (const char *)title : "", 2439 title ? (const char *)title : "",
2440 title ? "\"" : "",
2460 flag_desc (flagdesc, 512), type); 2441 flag_desc (flagdesc, 512), type);
2461 2442
2462 if (!flag[FLAG_REMOVED] && env) 2443 if (!flag[FLAG_REMOVED] && env)
2463 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2)); 2444 p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
2464 2445
… …
2570 return splay (tmp); 2551 return splay (tmp);
2571 2552
2572 return 0; 2553 return 0;
2573} 2554}
2574 2555
2575void 2556object *
2576object::force_add (const shstr name, int duration) 2557object::force_add (const shstr name, int duration)
2577{ 2558{
2578 if (object *force = force_find (name)) 2559 if (object *force = force_find (name))
2579 force->destroy (); 2560 force->destroy ();
2580 2561
… …
2586 2567
2587 force->set_speed (duration ? 1.f / duration : 0.f); 2568 force->set_speed (duration ? 1.f / duration : 0.f);
2588 force->flag [FLAG_IS_USED_UP] = true; 2569 force->flag [FLAG_IS_USED_UP] = true;
2589 force->flag [FLAG_APPLIED] = true; 2570 force->flag [FLAG_APPLIED] = true;
2590 2571
2591 insert (force); 2572 return insert (force);
2592} 2573}
2593 2574
2594void 2575void
2595object::play_sound (faceidx sound) 2576object::play_sound (faceidx sound)
2596{ 2577{
… …
2607 } 2588 }
2608 else 2589 else
2609 map->play_sound (sound, x, y); 2590 map->play_sound (sound, x, y);
2610} 2591}
2611 2592
2593void
2594object::make_noise ()
2595{
2596 // we do not model noise in the map, so instead put
2597 // a temporary light into the noise source
2598 // could use the map instead, but that's less reliable for our
2599 // goal, which is to make invisibility a bit harder to exploit
2600
2601 // currently only works sensibly for players
2602 if (!is_player ())
2603 return;
2604
2605 // find old force, or create new one
2606 object *force = force_find (shstr_noise_force);
2607
2608 if (force)
2609 force->speed = 1.f / 4; // patch old speed up
2610 else
2611 force_add (shstr_noise_force, 4);
2612}
2613

Diff Legend

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