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.244 by root, Sun May 18 17:52:53 2008 UTC vs.
Revision 1.256 by root, Sun Aug 31 05:47:14 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 // some objects are unmergable
192 if (!ob1->nrof || !ob2->nrof)
193 return 0;
194
195 /* Do not merge objects if nrof would overflow. First part checks 191 /* Do not merge objects if nrof would overflow, assume nrof
196 * for unsigned overflow (2c), second part checks whether the result 192 * is always 0 .. 2**31-1 */
197 * would fit into a 32 bit signed int, which is often used to hold 193 if (ob1->nrof > 0x7fffffff - ob2->nrof)
198 * nrof values.
199 */
200 if (~ob1->nrof < ob2->nrof || ob1->nrof + ob2->nrof > (1UL << 31))
201 return 0; 194 return 0;
202 195
203 /* If the objects have been identified, set the BEEN_APPLIED flag. 196 /* If the objects have been identified, set the BEEN_APPLIED flag.
204 * 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
205 * 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
… …
239 || memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats))) 232 || memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats)))
240 return 0; 233 return 0;
241 234
242 if ((ob1->flag ^ ob2->flag) 235 if ((ob1->flag ^ ob2->flag)
243 .reset (FLAG_INV_LOCKED) 236 .reset (FLAG_INV_LOCKED)
244 .reset (FLAG_CLIENT_SENT)
245 .reset (FLAG_REMOVED) 237 .reset (FLAG_REMOVED)
246 .any ()) 238 .any ())
247 return 0; 239 return 0;
248 240
249 /* This is really a spellbook check - we should in general 241 /* This is really a spellbook check - we should in general
… …
349 else 341 else
350 { 342 {
351 // maybe there is a player standing on the same mapspace 343 // maybe there is a player standing on the same mapspace
352 // this will catch the case where "this" is a player 344 // this will catch the case where "this" is a player
353 if (object *pl = ms ().player ()) 345 if (object *pl = ms ().player ())
346 if ((!pl->container && pl->contr->ns && !pl->contr->ns->update_look)
354 if (!pl->container || this == pl->container) 347 || this == pl->container)
355 return pl; 348 return pl;
356 } 349 }
357 } 350 }
358 351
359 return 0; 352 return 0;
… …
643 } 636 }
644 637
645 if (speed < 0) 638 if (speed < 0)
646 dst->speed_left -= rndm (); 639 dst->speed_left -= rndm ();
647 640
648 dst->set_speed (dst->speed); 641 dst->activate ();
649} 642}
650 643
651void 644void
652object::instantiate () 645object::instantiate ()
653{ 646{
… …
773 || (QUERY_FLAG (op, FLAG_DAMNED) && !(m.flags_ & P_NO_CLERIC)) 766 || (QUERY_FLAG (op, FLAG_DAMNED) && !(m.flags_ & P_NO_CLERIC))
774 || (m.move_on | op->move_on ) != m.move_on 767 || (m.move_on | op->move_on ) != m.move_on
775 || (m.move_off | op->move_off ) != m.move_off 768 || (m.move_off | op->move_off ) != m.move_off
776 || (m.move_slow | op->move_slow) != m.move_slow 769 || (m.move_slow | op->move_slow) != m.move_slow
777 /* 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
778 * to have move_allow right now. 771 * have move_allow right now.
779 */ 772 */
780 || ((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
781 || 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)
782 m.flags_ = 0; 775 m.flags_ = 0;
783 } 776 }
… …
837{ 830{
838 /* If already on active list, don't do anything */ 831 /* If already on active list, don't do anything */
839 if (active) 832 if (active)
840 return; 833 return;
841 834
835 if (has_active_speed () && flag [FLAG_FREED ]) LOG (llevError | logBacktrace, "BUG: tried to activate freed object %s\n", debug_desc ());//D
836
842 if (has_active_speed ()) 837 if (has_active_speed ())
843 actives.insert (this); 838 actives.insert (this);
844} 839}
845 840
846void 841void
… …
913 || map->in_memory != MAP_ACTIVE 908 || map->in_memory != MAP_ACTIVE
914 || map->no_drop 909 || map->no_drop
915 || ms ().move_block == MOVE_ALL) 910 || ms ().move_block == MOVE_ALL)
916 { 911 {
917 while (inv) 912 while (inv)
918 {
919 inv->destroy_inv (false);
920 inv->destroy (); 913 inv->destroy (true);
921 }
922 } 914 }
923 else 915 else
924 { /* Put objects in inventory onto this space */ 916 { /* Put objects in inventory onto this space */
925 while (inv) 917 while (inv)
926 { 918 {
… …
1121 *(below ? &below->above : &ms.bot) = above; 1113 *(below ? &below->above : &ms.bot) = above;
1122 1114
1123 above = 0; 1115 above = 0;
1124 below = 0; 1116 below = 0;
1125 1117
1118 ms.flags_ = 0;
1119
1126 if (map->in_memory == MAP_SAVING) 1120 if (map->in_memory == MAP_SAVING)
1127 return; 1121 return;
1128 1122
1129 int check_walk_off = !flag [FLAG_NO_APPLY]; 1123 int check_walk_off = !flag [FLAG_NO_APPLY];
1130 1124
… …
1161 LOG (llevError, "BUG: remove_ob(): name %s, destroyed leaving object\n", tmp->debug_desc ()); 1155 LOG (llevError, "BUG: remove_ob(): name %s, destroyed leaving object\n", tmp->debug_desc ());
1162 } 1156 }
1163 1157
1164 last = tmp; 1158 last = tmp;
1165 } 1159 }
1166
1167 /* last == NULL if there are no objects on this space */
1168 //TODO: this makes little sense, why only update the topmost object?
1169 if (!last)
1170 map->at (x, y).flags_ = 0;
1171 else
1172 update_object (last, UP_OBJ_REMOVE);
1173 1160
1174 if (flag [FLAG_BLOCKSVIEW] || glow_radius) 1161 if (flag [FLAG_BLOCKSVIEW] || glow_radius)
1175 update_all_los (map, x, y); 1162 update_all_los (map, x, y);
1176 } 1163 }
1177} 1164}
… …
1286 if (op->env) 1273 if (op->env)
1287 { 1274 {
1288 LOG (llevError, "insert_ob_in_map called for object in an inventory (proceeding)"); 1275 LOG (llevError, "insert_ob_in_map called for object in an inventory (proceeding)");
1289 op->remove (); 1276 op->remove ();
1290 } 1277 }
1278
1279 if (op->face && !face_info (op->face))//D TODO: remove soon
1280 {//D
1281 LOG (llevError | logBacktrace, "op->face out of bounds: %s", op->debug_desc ());//D
1282 op->face = 1;//D
1283 }//D
1291 1284
1292 /* Ideally, the caller figures this out. However, it complicates a lot 1285 /* 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 1286 * of areas of callers (eg, anything that uses find_free_spot would now
1294 * need extra work 1287 * need extra work
1295 */ 1288 */
… …
1535 if (!nr) 1528 if (!nr)
1536 return true; 1529 return true;
1537 1530
1538 nr = min (nr, nrof); 1531 nr = min (nr, nrof);
1539 1532
1533 if (nrof > nr)
1534 {
1540 nrof -= nr; 1535 nrof -= nr;
1541
1542 if (nrof)
1543 {
1544 adjust_weight (env, -weight * nr); // carrying == 0 1536 adjust_weight (env, -weight * max (1, nr)); // carrying == 0
1545 1537
1546 if (object *pl = visible_to ()) 1538 if (object *pl = visible_to ())
1547 esrv_update_item (UPD_NROF, pl, this); 1539 esrv_update_item (UPD_NROF, pl, this);
1548 1540
1549 return true; 1541 return true;
1550 } 1542 }
1551 else 1543 else
1552 { 1544 {
1553 destroy (1); 1545 destroy ();
1554 return false; 1546 return false;
1555 } 1547 }
1556} 1548}
1557 1549
1558/* 1550/*

Diff Legend

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