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.245 by root, Sun May 18 19:53:07 2008 UTC vs.
Revision 1.268 by root, Fri Dec 26 13:33:22 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.invalidate ();
783 } 776 }
784 /* if the object is being removed, we can't make intelligent 777 /* if the object is being removed, we can't make intelligent
785 * decisions, because remove_ob can't really pass the object 778 * decisions, because remove_ob can't really pass the object
786 * that is being removed. 779 * that is being removed.
787 */ 780 */
788 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE) 781 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE)
789 m.flags_ = 0; 782 m.invalidate ();
790 else if (action == UP_OBJ_FACE) 783 else if (action == UP_OBJ_FACE)
791 /* Nothing to do for that case */ ; 784 /* Nothing to do for that case */ ;
792 else 785 else
793 LOG (llevError, "update_object called with invalid action: %d\n", action); 786 LOG (llevError, "update_object called with invalid action: %d\n", action);
794 787
… …
836object::activate () 829object::activate ()
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;
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
841 837
842 if (has_active_speed ()) 838 if (has_active_speed ())
843 actives.insert (this); 839 actives.insert (this);
844} 840}
845 841
… …
913 || map->in_memory != MAP_ACTIVE 909 || map->in_memory != MAP_ACTIVE
914 || map->no_drop 910 || map->no_drop
915 || ms ().move_block == MOVE_ALL) 911 || ms ().move_block == MOVE_ALL)
916 { 912 {
917 while (inv) 913 while (inv)
918 {
919 inv->destroy_inv (false);
920 inv->destroy (); 914 inv->destroy ();
921 }
922 } 915 }
923 else 916 else
924 { /* Put objects in inventory onto this space */ 917 { /* Put objects in inventory onto this space */
925 while (inv) 918 while (inv)
926 { 919 {
… …
930 || op->flag [FLAG_NO_DROP] 923 || op->flag [FLAG_NO_DROP]
931 || op->type == RUNE 924 || op->type == RUNE
932 || op->type == TRAP 925 || op->type == TRAP
933 || op->flag [FLAG_IS_A_TEMPLATE] 926 || op->flag [FLAG_IS_A_TEMPLATE]
934 || op->flag [FLAG_DESTROY_ON_DEATH]) 927 || op->flag [FLAG_DESTROY_ON_DEATH])
935 op->destroy (true); 928 op->destroy ();
936 else 929 else
937 map->insert (op, x, y); 930 map->insert (op, x, y);
938 } 931 }
939 } 932 }
940} 933}
… …
1004 attacked_by = 0; 997 attacked_by = 0;
1005 current_weapon = 0; 998 current_weapon = 0;
1006} 999}
1007 1000
1008void 1001void
1009object::destroy (bool destroy_inventory) 1002object::destroy ()
1010{ 1003{
1011 if (destroyed ()) 1004 if (destroyed ())
1012 return; 1005 return;
1013 1006
1014 if (!is_head () && !head->destroyed ()) 1007 if (!is_head () && !head->destroyed ())
1015 { 1008 {
1016 LOG (llevError | logBacktrace, "tried to destroy the tail of an object"); 1009 LOG (llevError | logBacktrace, "tried to destroy the tail of an object");
1017 head->destroy (destroy_inventory); 1010 head->destroy ();
1018 return; 1011 return;
1019 } 1012 }
1020 1013
1021 destroy_inv (!destroy_inventory); 1014 destroy_inv (false);
1022 1015
1023 if (is_head ()) 1016 if (is_head ())
1024 if (sound_destroy) 1017 if (sound_destroy)
1025 play_sound (sound_destroy); 1018 play_sound (sound_destroy);
1026 else if (flag [FLAG_MONSTER]) 1019 else if (flag [FLAG_MONSTER])
… …
1062 if (object *pl = visible_to ()) 1055 if (object *pl = visible_to ())
1063 esrv_del_item (pl->contr, count); 1056 esrv_del_item (pl->contr, count);
1064 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
1065 1058
1066 adjust_weight (env, -total_weight ()); 1059 adjust_weight (env, -total_weight ());
1060
1061 object *pl = in_player ();
1067 1062
1068 /* we set up values so that it could be inserted into 1063 /* we set up values so that it could be inserted into
1069 * 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
1070 * to the caller to decide what we want to do. 1065 * to the caller to decide what we want to do.
1071 */ 1066 */
… …
1083 1078
1084 /* 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
1085 * made to players inventory. If set, avoiding the call 1080 * made to players inventory. If set, avoiding the call
1086 * to save cpu time. 1081 * to save cpu time.
1087 */ 1082 */
1088 if ((otmp = in_player ()) && otmp->contr && !QUERY_FLAG (otmp, FLAG_NO_FIX_PLAYER)) 1083 if (pl)
1084 if (pl->is_player () && (glow_radius || !QUERY_FLAG (pl, FLAG_NO_FIX_PLAYER)))
1085 {
1089 otmp->update_stats (); 1086 pl->update_stats ();
1087
1088 if (glow_radius && pl->is_on_map () && pl->map->darklevel () > 0)
1089 update_all_los (pl->map, pl->x, pl->y);
1090 }
1090 } 1091 }
1091 else if (map) 1092 else if (map)
1092 { 1093 {
1093 map->dirty = true; 1094 map->dirty = true;
1094 mapspace &ms = this->ms (); 1095 mapspace &ms = this->ms ();
… …
1121 *(below ? &below->above : &ms.bot) = above; 1122 *(below ? &below->above : &ms.bot) = above;
1122 1123
1123 above = 0; 1124 above = 0;
1124 below = 0; 1125 below = 0;
1125 1126
1127 ms.invalidate ();
1128
1126 if (map->in_memory == MAP_SAVING) 1129 if (map->in_memory == MAP_SAVING)
1127 return; 1130 return;
1128 1131
1129 int check_walk_off = !flag [FLAG_NO_APPLY]; 1132 int check_walk_off = !flag [FLAG_NO_APPLY];
1130 1133
… …
1162 } 1165 }
1163 1166
1164 last = tmp; 1167 last = tmp;
1165 } 1168 }
1166 1169
1167 /* last == NULL if there are no objects on this space */ 1170 if (affect_los () && map->darklevel () > 0)
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
1174 if (flag [FLAG_BLOCKSVIEW] || glow_radius)
1175 update_all_los (map, x, y); 1171 update_all_los (map, x, y);
1176 } 1172 }
1177} 1173}
1178 1174
1179/* 1175/*
… …
1203 esrv_update_item (UPD_NROF, pl, top); 1199 esrv_update_item (UPD_NROF, pl, top);
1204 1200
1205 op->weight = 0; // cancel the addition above 1201 op->weight = 0; // cancel the addition above
1206 op->carrying = 0; // must be 0 already 1202 op->carrying = 0; // must be 0 already
1207 1203
1208 op->destroy (1); 1204 op->destroy ();
1209 1205
1210 return top; 1206 return top;
1211 } 1207 }
1212 1208
1213 return 0; 1209 return 0;
… …
1275 * just 'op' otherwise 1271 * just 'op' otherwise
1276 */ 1272 */
1277object * 1273object *
1278insert_ob_in_map (object *op, maptile *m, object *originator, int flag) 1274insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
1279{ 1275{
1280 if (op->is_on_map ())
1281 {
1282 LOG (llevError, "insert_ob_in_map called for object already on map");
1283 abort ();
1284 }
1285
1286 if (op->env)
1287 {
1288 LOG (llevError, "insert_ob_in_map called for object in an inventory (proceeding)");
1289 op->remove (); 1276 op->remove ();
1290 }
1291 1277
1292 if (op->face && !face_info (op->face))//D TODO: remove soon 1278 if (m == &freed_map)//D TODO: remove soon
1293 {//D 1279 {//D
1294 LOG (llevError | logBacktrace, "op->face out of bounds: %s", op->debug_desc ());//D 1280 LOG (llevError | logBacktrace, "tries to insret object on freed objects map: %s", op->debug_desc ());//D
1295 op->face = 1;//D
1296 }//D 1281 }//D
1297 1282
1298 /* Ideally, the caller figures this out. However, it complicates a lot 1283 /* Ideally, the caller figures this out. However, it complicates a lot
1299 * 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
1300 * need extra work 1285 * need extra work
1301 */ 1286 */
1302 if (!xy_normalise (m, op->x, op->y)) 1287 if (!xy_normalise (m, op->x, op->y))
1303 { 1288 {
1304 op->head_ ()->destroy (1);// remove head_ once all tail object destroyers found 1289 op->head_ ()->destroy ();// remove head_ once all tail object destroyers found
1305 return 0; 1290 return 0;
1306 } 1291 }
1307 1292
1308 if (object *more = op->more) 1293 if (object *more = op->more)
1309 if (!insert_ob_in_map (more, m, originator, flag)) 1294 if (!insert_ob_in_map (more, m, originator, flag))
… …
1322 { 1307 {
1323 // TODO: we actually want to update tmp, not op, 1308 // TODO: we actually want to update tmp, not op,
1324 // but some caller surely breaks when we return tmp 1309 // but some caller surely breaks when we return tmp
1325 // from here :/ 1310 // from here :/
1326 op->nrof += tmp->nrof; 1311 op->nrof += tmp->nrof;
1327 tmp->destroy (1); 1312 tmp->destroy ();
1328 } 1313 }
1329 1314
1330 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 */
1331 CLEAR_FLAG (op, FLAG_INV_LOCKED); 1316 CLEAR_FLAG (op, FLAG_INV_LOCKED);
1332 1317
… …
1462 * 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 -
1463 * this should get redone to only look for players within range, 1448 * this should get redone to only look for players within range,
1464 * or just updating the P_UPTODATE for spaces within this area 1449 * or just updating the P_UPTODATE for spaces within this area
1465 * of effect may be sufficient. 1450 * of effect may be sufficient.
1466 */ 1451 */
1467 if (op->map->darkness && (op->glow_radius != 0)) 1452 if (op->affects_los () && op->map->darklevel () > 0)
1453 {
1454 op->ms ().invalidate ();
1468 update_all_los (op->map, op->x, op->y); 1455 update_all_los (op->map, op->x, op->y);
1456 }
1469 1457
1470 /* updates flags (blocked, alive, no magic, etc) for this map space */ 1458 /* updates flags (blocked, alive, no magic, etc) for this map space */
1471 update_object (op, UP_OBJ_INSERT); 1459 update_object (op, UP_OBJ_INSERT);
1472 1460
1473 INVOKE_OBJECT (INSERT, op); 1461 INVOKE_OBJECT (INSERT, op);
… …
1507{ 1495{
1508 /* first search for itself and remove any old instances */ 1496 /* first search for itself and remove any old instances */
1509 1497
1510 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above) 1498 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
1511 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */ 1499 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */
1512 tmp->destroy (1); 1500 tmp->destroy ();
1513 1501
1514 object *tmp = arch_to_object (archetype::find (arch_string)); 1502 object *tmp = arch_to_object (archetype::find (arch_string));
1515 1503
1516 tmp->x = op->x; 1504 tmp->x = op->x;
1517 tmp->y = op->y; 1505 tmp->y = op->y;
… …
1541 if (!nr) 1529 if (!nr)
1542 return true; 1530 return true;
1543 1531
1544 nr = min (nr, nrof); 1532 nr = min (nr, nrof);
1545 1533
1534 if (nrof > nr)
1535 {
1546 nrof -= nr; 1536 nrof -= nr;
1547
1548 if (nrof)
1549 {
1550 adjust_weight (env, -weight * nr); // carrying == 0 1537 adjust_weight (env, -weight * max (1, nr)); // carrying == 0
1551 1538
1552 if (object *pl = visible_to ()) 1539 if (object *pl = visible_to ())
1553 esrv_update_item (UPD_NROF, pl, this); 1540 esrv_update_item (UPD_NROF, pl, this);
1554 1541
1555 return true; 1542 return true;
1556 } 1543 }
1557 else 1544 else
1558 { 1545 {
1559 destroy (1); 1546 destroy ();
1560 return false; 1547 return false;
1561 } 1548 }
1562} 1549}
1563 1550
1564/* 1551/*
… …
1641 if (object *pl = tmp->visible_to ()) 1628 if (object *pl = tmp->visible_to ())
1642 esrv_update_item (UPD_NROF, pl, tmp); 1629 esrv_update_item (UPD_NROF, pl, tmp);
1643 1630
1644 adjust_weight (this, op->total_weight ()); 1631 adjust_weight (this, op->total_weight ());
1645 1632
1646 op->destroy (1); 1633 op->destroy ();
1647 op = tmp; 1634 op = tmp;
1648 goto inserted; 1635 goto inserted;
1649 } 1636 }
1650 1637
1651 op->owner = 0; // it's his/hers now. period. 1638 op->owner = 0; // it's his/hers now. period.
… …
1669 1656
1670 adjust_weight (this, op->total_weight ()); 1657 adjust_weight (this, op->total_weight ());
1671 1658
1672inserted: 1659inserted:
1673 /* 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 */
1674 if (op->glow_radius && map && map->darkness) 1661 if (op->glow_radius && is_on_map () && map->darklevel () > 0)
1662 {
1663 update_stats ();
1675 update_all_los (map, x, y); 1664 update_all_los (map, x, y);
1676 1665 }
1666 else if (type == PLAYER && !flag [FLAG_NO_FIX_PLAYER])
1677 // if this is a player's inventory, update stats 1667 // if this is a player's inventory, update stats
1678 if (type == PLAYER && !flag [FLAG_NO_FIX_PLAYER])
1679 update_stats (); 1668 update_stats ();
1680 1669
1681 INVOKE_OBJECT (INSERT, this); 1670 INVOKE_OBJECT (INSERT, this);
1682 1671
1683 return op; 1672 return op;
… …
1985 * head of the object should correspond for the entire object. 1974 * head of the object should correspond for the entire object.
1986 */ 1975 */
1987 if (OB_TYPE_MOVE_BLOCK (ob, ms.move_block)) 1976 if (OB_TYPE_MOVE_BLOCK (ob, ms.move_block))
1988 continue; 1977 continue;
1989 1978
1990 if (ob->blocked (m, pos.x, pos.y)) 1979 if (ob->blocked (pos.m, pos.x, pos.y))
1991 continue; 1980 continue;
1992 1981
1993 altern [index++] = i; 1982 altern [index++] = i;
1994 } 1983 }
1995 1984
… …
2562 return splay (tmp); 2551 return splay (tmp);
2563 2552
2564 return 0; 2553 return 0;
2565} 2554}
2566 2555
2567void 2556object *
2568object::force_add (const shstr name, int duration) 2557object::force_add (const shstr name, int duration)
2569{ 2558{
2570 if (object *force = force_find (name)) 2559 if (object *force = force_find (name))
2571 force->destroy (); 2560 force->destroy ();
2572 2561
… …
2578 2567
2579 force->set_speed (duration ? 1.f / duration : 0.f); 2568 force->set_speed (duration ? 1.f / duration : 0.f);
2580 force->flag [FLAG_IS_USED_UP] = true; 2569 force->flag [FLAG_IS_USED_UP] = true;
2581 force->flag [FLAG_APPLIED] = true; 2570 force->flag [FLAG_APPLIED] = true;
2582 2571
2583 insert (force); 2572 return insert (force);
2584} 2573}
2585 2574
2586void 2575void
2587object::play_sound (faceidx sound) 2576object::play_sound (faceidx sound)
2588{ 2577{
… …
2599 } 2588 }
2600 else 2589 else
2601 map->play_sound (sound, x, y); 2590 map->play_sound (sound, x, y);
2602} 2591}
2603 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