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.242 by elmex, Wed May 7 21:00:02 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
… …
908 || map->in_memory != MAP_ACTIVE 909 || map->in_memory != MAP_ACTIVE
909 || map->no_drop 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}
… …
999 attacked_by = 0; 997 attacked_by = 0;
1000 current_weapon = 0; 998 current_weapon = 0;
1001} 999}
1002 1000
1003void 1001void
1004object::destroy (bool destroy_inventory) 1002object::destroy ()
1005{ 1003{
1006 if (destroyed ()) 1004 if (destroyed ())
1007 return; 1005 return;
1008 1006
1009 if (!is_head () && !head->destroyed ()) 1007 if (!is_head () && !head->destroyed ())
1010 { 1008 {
1011 LOG (llevError | logBacktrace, "tried to destroy the tail of an object"); 1009 LOG (llevError | logBacktrace, "tried to destroy the tail of an object");
1012 head->destroy (destroy_inventory); 1010 head->destroy ();
1013 return; 1011 return;
1014 } 1012 }
1015 1013
1016 destroy_inv (!destroy_inventory); 1014 destroy_inv (false);
1017 1015
1018 if (is_head ()) 1016 if (is_head ())
1019 if (sound_destroy) 1017 if (sound_destroy)
1020 play_sound (sound_destroy); 1018 play_sound (sound_destroy);
1021 else if (flag [FLAG_MONSTER]) 1019 else if (flag [FLAG_MONSTER])
… …
1057 if (object *pl = visible_to ()) 1055 if (object *pl = visible_to ())
1058 esrv_del_item (pl->contr, count); 1056 esrv_del_item (pl->contr, count);
1059 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
1060 1058
1061 adjust_weight (env, -total_weight ()); 1059 adjust_weight (env, -total_weight ());
1060
1061 object *pl = in_player ();
1062 1062
1063 /* we set up values so that it could be inserted into 1063 /* we set up values so that it could be inserted into
1064 * 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
1065 * to the caller to decide what we want to do. 1065 * to the caller to decide what we want to do.
1066 */ 1066 */
… …
1078 1078
1079 /* 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
1080 * made to players inventory. If set, avoiding the call 1080 * made to players inventory. If set, avoiding the call
1081 * to save cpu time. 1081 * to save cpu time.
1082 */ 1082 */
1083 if (pl)
1083 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 {
1084 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 }
1085 } 1091 }
1086 else if (map) 1092 else if (map)
1087 { 1093 {
1088 map->dirty = true; 1094 map->dirty = true;
1089 mapspace &ms = this->ms (); 1095 mapspace &ms = this->ms ();
… …
1116 *(below ? &below->above : &ms.bot) = above; 1122 *(below ? &below->above : &ms.bot) = above;
1117 1123
1118 above = 0; 1124 above = 0;
1119 below = 0; 1125 below = 0;
1120 1126
1127 ms.invalidate ();
1128
1121 if (map->in_memory == MAP_SAVING) 1129 if (map->in_memory == MAP_SAVING)
1122 return; 1130 return;
1123 1131
1124 int check_walk_off = !flag [FLAG_NO_APPLY]; 1132 int check_walk_off = !flag [FLAG_NO_APPLY];
1125 1133
… …
1157 } 1165 }
1158 1166
1159 last = tmp; 1167 last = tmp;
1160 } 1168 }
1161 1169
1162 /* last == NULL if there are no objects on this space */ 1170 if (map->darkness && affects_los ())
1163 //TODO: this makes little sense, why only update the topmost object?
1164 if (!last)
1165 map->at (x, y).flags_ = 0;
1166 else
1167 update_object (last, UP_OBJ_REMOVE);
1168
1169 if (flag [FLAG_BLOCKSVIEW] || glow_radius)
1170 update_all_los (map, x, y); 1171 update_all_los (map, x, y);
1171 } 1172 }
1172} 1173}
1173 1174
1174/* 1175/*
… …
1198 esrv_update_item (UPD_NROF, pl, top); 1199 esrv_update_item (UPD_NROF, pl, top);
1199 1200
1200 op->weight = 0; // cancel the addition above 1201 op->weight = 0; // cancel the addition above
1201 op->carrying = 0; // must be 0 already 1202 op->carrying = 0; // must be 0 already
1202 1203
1203 op->destroy (1); 1204 op->destroy ();
1204 1205
1205 return top; 1206 return top;
1206 } 1207 }
1207 1208
1208 return 0; 1209 return 0;
… …
1236 * job preparing multi-part monsters. 1237 * job preparing multi-part monsters.
1237 */ 1238 */
1238object * 1239object *
1239insert_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)
1240{ 1241{
1242 op->remove ();
1243
1241 for (object *tmp = op->head_ (); tmp; tmp = tmp->more) 1244 for (object *tmp = op->head_ (); tmp; tmp = tmp->more)
1242 { 1245 {
1243 tmp->x = x + tmp->arch->x; 1246 tmp->x = x + tmp->arch->x;
1244 tmp->y = y + tmp->arch->y; 1247 tmp->y = y + tmp->arch->y;
1245 } 1248 }
… …
1270object * 1273object *
1271insert_ob_in_map (object *op, maptile *m, object *originator, int flag) 1274insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
1272{ 1275{
1273 op->remove (); 1276 op->remove ();
1274 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
1282
1275 /* Ideally, the caller figures this out. However, it complicates a lot 1283 /* Ideally, the caller figures this out. However, it complicates a lot
1276 * 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
1277 * need extra work 1285 * need extra work
1278 */ 1286 */
1279 if (!xy_normalise (m, op->x, op->y)) 1287 if (!xy_normalise (m, op->x, op->y))
1280 { 1288 {
1281 op->head_ ()->destroy (1);// remove head_ once all tail object destroyers found 1289 op->head_ ()->destroy ();// remove head_ once all tail object destroyers found
1282 return 0; 1290 return 0;
1283 } 1291 }
1284 1292
1285 if (object *more = op->more) 1293 if (object *more = op->more)
1286 if (!insert_ob_in_map (more, m, originator, flag)) 1294 if (!insert_ob_in_map (more, m, originator, flag))
… …
1299 { 1307 {
1300 // TODO: we actually want to update tmp, not op, 1308 // TODO: we actually want to update tmp, not op,
1301 // but some caller surely breaks when we return tmp 1309 // but some caller surely breaks when we return tmp
1302 // from here :/ 1310 // from here :/
1303 op->nrof += tmp->nrof; 1311 op->nrof += tmp->nrof;
1304 tmp->destroy (1); 1312 tmp->destroy ();
1305 } 1313 }
1306 1314
1307 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 */
1308 CLEAR_FLAG (op, FLAG_INV_LOCKED); 1316 CLEAR_FLAG (op, FLAG_INV_LOCKED);
1309 1317
… …
1439 * 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 -
1440 * this should get redone to only look for players within range, 1448 * this should get redone to only look for players within range,
1441 * or just updating the P_UPTODATE for spaces within this area 1449 * or just updating the P_UPTODATE for spaces within this area
1442 * of effect may be sufficient. 1450 * of effect may be sufficient.
1443 */ 1451 */
1444 if (op->map->darkness && (op->glow_radius != 0)) 1452 if (op->affects_los () && op->map->darkness)
1453 {
1454 op->ms ().invalidate ();
1445 update_all_los (op->map, op->x, op->y); 1455 update_all_los (op->map, op->x, op->y);
1456 }
1446 1457
1447 /* updates flags (blocked, alive, no magic, etc) for this map space */ 1458 /* updates flags (blocked, alive, no magic, etc) for this map space */
1448 update_object (op, UP_OBJ_INSERT); 1459 update_object (op, UP_OBJ_INSERT);
1449 1460
1450 INVOKE_OBJECT (INSERT, op); 1461 INVOKE_OBJECT (INSERT, op);
… …
1484{ 1495{
1485 /* first search for itself and remove any old instances */ 1496 /* first search for itself and remove any old instances */
1486 1497
1487 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above) 1498 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
1488 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */ 1499 if (!strcmp (tmp->arch->archname, arch_string)) /* same archetype */
1489 tmp->destroy (1); 1500 tmp->destroy ();
1490 1501
1491 object *tmp = arch_to_object (archetype::find (arch_string)); 1502 object *tmp = arch_to_object (archetype::find (arch_string));
1492 1503
1493 tmp->x = op->x; 1504 tmp->x = op->x;
1494 tmp->y = op->y; 1505 tmp->y = op->y;
… …
1518 if (!nr) 1529 if (!nr)
1519 return true; 1530 return true;
1520 1531
1521 nr = min (nr, nrof); 1532 nr = min (nr, nrof);
1522 1533
1534 if (nrof > nr)
1535 {
1523 nrof -= nr; 1536 nrof -= nr;
1524
1525 if (nrof)
1526 {
1527 adjust_weight (env, -weight * nr); // carrying == 0 1537 adjust_weight (env, -weight * max (1, nr)); // carrying == 0
1528 1538
1529 if (object *pl = visible_to ()) 1539 if (object *pl = visible_to ())
1530 esrv_update_item (UPD_NROF, pl, this); 1540 esrv_update_item (UPD_NROF, pl, this);
1531 1541
1532 return true; 1542 return true;
1533 } 1543 }
1534 else 1544 else
1535 { 1545 {
1536 destroy (1); 1546 destroy ();
1537 return false; 1547 return false;
1538 } 1548 }
1539} 1549}
1540 1550
1541/* 1551/*
… …
1618 if (object *pl = tmp->visible_to ()) 1628 if (object *pl = tmp->visible_to ())
1619 esrv_update_item (UPD_NROF, pl, tmp); 1629 esrv_update_item (UPD_NROF, pl, tmp);
1620 1630
1621 adjust_weight (this, op->total_weight ()); 1631 adjust_weight (this, op->total_weight ());
1622 1632
1623 op->destroy (1); 1633 op->destroy ();
1624 op = tmp; 1634 op = tmp;
1625 goto inserted; 1635 goto inserted;
1626 } 1636 }
1627 1637
1628 op->owner = 0; // it's his/hers now. period. 1638 op->owner = 0; // it's his/hers now. period.
… …
1646 1656
1647 adjust_weight (this, op->total_weight ()); 1657 adjust_weight (this, op->total_weight ());
1648 1658
1649inserted: 1659inserted:
1650 /* 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 */
1651 if (op->glow_radius && map && map->darkness) 1661 if (op->glow_radius && is_on_map () && map->darkness)
1662 {
1663 update_stats ();
1652 update_all_los (map, x, y); 1664 update_all_los (map, x, y);
1653 1665 }
1666 else if (type == PLAYER && !flag [FLAG_NO_FIX_PLAYER])
1654 // if this is a player's inventory, update stats 1667 // if this is a player's inventory, update stats
1655 if (type == PLAYER && !flag [FLAG_NO_FIX_PLAYER])
1656 update_stats (); 1668 update_stats ();
1657 1669
1658 INVOKE_OBJECT (INSERT, this); 1670 INVOKE_OBJECT (INSERT, this);
1659 1671
1660 return op; 1672 return op;
… …
1962 * head of the object should correspond for the entire object. 1974 * head of the object should correspond for the entire object.
1963 */ 1975 */
1964 if (OB_TYPE_MOVE_BLOCK (ob, ms.move_block)) 1976 if (OB_TYPE_MOVE_BLOCK (ob, ms.move_block))
1965 continue; 1977 continue;
1966 1978
1967 if (ob->blocked (m, pos.x, pos.y)) 1979 if (ob->blocked (pos.m, pos.x, pos.y))
1968 continue; 1980 continue;
1969 1981
1970 altern [index++] = i; 1982 altern [index++] = i;
1971 } 1983 }
1972 1984
… …
2539 return splay (tmp); 2551 return splay (tmp);
2540 2552
2541 return 0; 2553 return 0;
2542} 2554}
2543 2555
2544void 2556object *
2545object::force_add (const shstr name, int duration) 2557object::force_add (const shstr name, int duration)
2546{ 2558{
2547 if (object *force = force_find (name)) 2559 if (object *force = force_find (name))
2548 force->destroy (); 2560 force->destroy ();
2549 2561
… …
2555 2567
2556 force->set_speed (duration ? 1.f / duration : 0.f); 2568 force->set_speed (duration ? 1.f / duration : 0.f);
2557 force->flag [FLAG_IS_USED_UP] = true; 2569 force->flag [FLAG_IS_USED_UP] = true;
2558 force->flag [FLAG_APPLIED] = true; 2570 force->flag [FLAG_APPLIED] = true;
2559 2571
2560 insert (force); 2572 return insert (force);
2561} 2573}
2562 2574
2563void 2575void
2564object::play_sound (faceidx sound) 2576object::play_sound (faceidx sound)
2565{ 2577{
… …
2576 } 2588 }
2577 else 2589 else
2578 map->play_sound (sound, x, y); 2590 map->play_sound (sound, x, y);
2579} 2591}
2580 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