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.309 by root, Sun Nov 29 17:41:07 2009 UTC vs.
Revision 1.323 by root, Sun Apr 11 23:56:09 2010 UTC

1/* 1/*
2 * This file is part of Deliantra, the Roguelike Realtime MMORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2001 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992 Frank Tore Johansen
7 * 7 *
8 * Deliantra is free software: you can redistribute it and/or modify it under 8 * Deliantra is free software: you can redistribute it and/or modify it under
9 * the terms of the Affero GNU General Public License as published by the 9 * the terms of the Affero GNU General Public License as published by the
10 * Free Software Foundation, either version 3 of the License, or (at your 10 * Free Software Foundation, either version 3 of the License, or (at your
11 * option) any later version. 11 * option) any later version.
… …
26#include <stdio.h> 26#include <stdio.h>
27#include <sys/types.h> 27#include <sys/types.h>
28#include <sys/uio.h> 28#include <sys/uio.h>
29#include <object.h> 29#include <object.h>
30#include <sproto.h> 30#include <sproto.h>
31#include <loader.h>
32 31
33#include <bitset> 32#include <bitset>
34 33
35UUID UUID::cur; 34UUID UUID::cur;
36static uint64_t seq_next_save; 35static uint64_t seq_next_save;
… …
248 * Improvements made with merge: Better checking on potion, and also 247 * Improvements made with merge: Better checking on potion, and also
249 * check weight 248 * check weight
250 */ 249 */
251bool object::can_merge_slow (object *ob1, object *ob2) 250bool object::can_merge_slow (object *ob1, object *ob2)
252{ 251{
253 /* A couple quicksanity checks */ 252 /* A couple quick sanity checks */
254 if (ob1 == ob2 253 if (ob1 == ob2
255 || ob1->type != ob2->type 254 || ob1->type != ob2->type
256 || fabs (ob1->speed - ob2->speed) >= MIN_ACTIVE_SPEED
257 || ob1->value != ob2->value 255 || ob1->value != ob2->value
258 || ob1->name != ob2->name) 256 || ob1->name != ob2->name
257 || fabs (ob1->speed - ob2->speed) >= MIN_ACTIVE_SPEED)
259 return 0; 258 return 0;
260 259
261 /* Do not merge objects if nrof would overflow, assume nrof 260 /* Do not merge objects if nrof would overflow, assume nrof
262 * is always 0 .. 2**31-1 */ 261 * is always 0 .. 2**31-1 */
263 if (ob1->nrof > 0x7fffffff - ob2->nrof) 262 if (ob1->nrof > 0x7fffffff - ob2->nrof)
… …
267 * This is to the comparison of the flags below will be OK. We 266 * This is to the comparison of the flags below will be OK. We
268 * just can't ignore the been applied or identified flags, as they 267 * just can't ignore the been applied or identified flags, as they
269 * are not equal - just if it has been identified, the been_applied 268 * are not equal - just if it has been identified, the been_applied
270 * flags lose any meaning. 269 * flags lose any meaning.
271 */ 270 */
272 if (QUERY_FLAG (ob1, FLAG_IDENTIFIED)) 271 if (ob1->flag [FLAG_IDENTIFIED])
273 SET_FLAG (ob1, FLAG_BEEN_APPLIED); 272 ob1->set_flag (FLAG_BEEN_APPLIED);
274 273
275 if (QUERY_FLAG (ob2, FLAG_IDENTIFIED)) 274 if (ob2->flag [FLAG_IDENTIFIED])
276 SET_FLAG (ob2, FLAG_BEEN_APPLIED); 275 ob2->set_flag (FLAG_BEEN_APPLIED);
277 276
278 if (ob1->arch->archname != ob2->arch->archname 277 if (ob1->arch->archname != ob2->arch->archname
279 || ob1->name != ob2->name 278 || ob1->name != ob2->name
280 || ob1->title != ob2->title 279 || ob1->title != ob2->title
281 || ob1->msg != ob2->msg 280 || ob1->msg != ob2->msg
… …
284 || ob1->magic != ob2->magic 283 || ob1->magic != ob2->magic
285 || ob1->slaying != ob2->slaying 284 || ob1->slaying != ob2->slaying
286 || ob1->skill != ob2->skill 285 || ob1->skill != ob2->skill
287 || ob1->value != ob2->value 286 || ob1->value != ob2->value
288 || ob1->animation_id != ob2->animation_id 287 || ob1->animation_id != ob2->animation_id
289 || (ob1->face != ob2->face && !ob1->animation_id) // face and animation are dependent on each other 288 || (ob1->face != ob2->face && !ob1->animation_id) // face and animation are dependend on each other
290 || ob1->client_type != ob2->client_type 289 || ob1->client_type != ob2->client_type
291 || ob1->material != ob2->material 290 || ob1->material != ob2->material
292 || ob1->lore != ob2->lore 291 || ob1->lore != ob2->lore
293 || ob1->subtype != ob2->subtype 292 || ob1->subtype != ob2->subtype
294 || ob1->move_type != ob2->move_type 293 || ob1->move_type != ob2->move_type
… …
330 329
331 /* Don't merge objects that are applied. With the new 'body' code, 330 /* Don't merge objects that are applied. With the new 'body' code,
332 * it is possible for most any character to have more than one of 331 * it is possible for most any character to have more than one of
333 * some items equipped, and we don't want those to merge. 332 * some items equipped, and we don't want those to merge.
334 */ 333 */
335 if (QUERY_FLAG (ob1, FLAG_APPLIED) || QUERY_FLAG (ob2, FLAG_APPLIED)) 334 if (ob1->flag [FLAG_APPLIED] || ob2->flag [FLAG_APPLIED])
336 return 0; 335 return 0;
337 336
338 /* Note sure why the following is the case - either the object has to 337 /* Note sure why the following is the case - either the object has to
339 * be animated or have a very low speed. Is this an attempted monster 338 * be animated or have a very low speed. Is this an attempted monster
340 * check? 339 * check?
341 */ 340 */
342 if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && ob1->has_active_speed ()) 341 if (!ob1->flag [FLAG_ANIMATE] && ob1->has_active_speed ())
343 return 0; 342 return 0;
344 343
345 switch (ob1->type) 344 switch (ob1->type)
346 { 345 {
347 case SCROLL: 346 case SCROLL:
… …
521 520
522 return 0; 521 return 0;
523} 522}
524 523
525/* 524/*
525 * Returns the object which has the uuid equal to the argument.
526 * MOAR VERRRY slow.
527 */
528
529object *
530find_object_uuid (UUID i)
531{
532 for_all_objects (op)
533 if (op->uuid == i)
534 return op;
535
536 return 0;
537}
538
539/*
526 * Returns the first object which has a name equal to the argument. 540 * Returns the first object which has a name equal to the argument.
527 * Used only by the patch command, but not all that useful. 541 * Used only by the patch command, but not all that useful.
528 * Enables features like "patch <name-of-other-player> food 999" 542 * Enables features like "patch <name-of-other-player> food 999"
529 */ 543 */
530object * 544object *
… …
558 LOG (llevError | logBacktrace, "tried to set owner of %s to %s\n", debug_desc (), owner->debug_desc ()); 572 LOG (llevError | logBacktrace, "tried to set owner of %s to %s\n", debug_desc (), owner->debug_desc ());
559 return; 573 return;
560 } 574 }
561 575
562 this->owner = owner; 576 this->owner = owner;
563}
564
565int
566object::slottype () const
567{
568 if (type == SKILL)
569 {
570 if (IS_COMBAT_SKILL (subtype)) return slot_combat;
571 if (IS_RANGED_SKILL (subtype)) return slot_ranged;
572 }
573 else
574 {
575 if (slot [body_combat].info) return slot_combat;
576 if (slot [body_range ].info) return slot_ranged;
577 }
578
579 return slot_none;
580}
581
582bool
583object::change_weapon (object *ob)
584{
585 if (current_weapon == ob)
586 return true;
587
588 if (chosen_skill)
589 chosen_skill->flag [FLAG_APPLIED] = false;
590
591 current_weapon = ob;
592 chosen_skill = !ob || ob->type == SKILL ? ob : find_skill_by_name (this, ob->skill);
593
594 if (chosen_skill)
595 chosen_skill->flag [FLAG_APPLIED] = true;
596
597 update_stats ();
598
599 if (ob)
600 {
601 // now check wether any body locations became invalid, in which case
602 // we cannot apply the weapon at the moment.
603 for (int i = 0; i < NUM_BODY_LOCATIONS; ++i)
604 if (slot[i].used < 0)
605 {
606 current_weapon = chosen_skill = 0;
607 update_stats ();
608
609 new_draw_info_format (NDI_UNIQUE, 0, this,
610 "You try to balance all your items at once, "
611 "but the %s is just too much for your body. "
612 "[You need to unapply some items first - use the 'body' command to see "
613 "how many items you cna wera on a specific body part.]", &ob->name);
614 return false;
615 }
616
617 //new_draw_info_format (NDI_UNIQUE, 0, this, "You switch to your %s.", &ob->name);
618 }
619 else
620 ;//new_draw_info_format (NDI_UNIQUE, 0, this, "You unwield your weapons.");
621
622 if (ob && !ob->flag [FLAG_APPLIED] && ob->type != SPELL)
623 {
624 LOG (llevError | logBacktrace, "%s changed to unapplied weapon %s",
625 &name, ob->debug_desc ());
626 return false;
627 }
628
629 return true;
630} 577}
631 578
632/* Zero the key_values on op, decrementing the shared-string 579/* Zero the key_values on op, decrementing the shared-string
633 * refcounts and freeing the links. 580 * refcounts and freeing the links.
634 */ 581 */
… …
736 * be called to update the face variable, _and_ how it looks on the map. 683 * be called to update the face variable, _and_ how it looks on the map.
737 */ 684 */
738void 685void
739update_turn_face (object *op) 686update_turn_face (object *op)
740{ 687{
741 if (!QUERY_FLAG (op, FLAG_IS_TURNABLE) || !op->arch) 688 if (!op->flag [FLAG_IS_TURNABLE] || !op->arch)
742 return; 689 return;
743 690
744 SET_ANIMATION (op, op->direction); 691 SET_ANIMATION (op, op->direction);
745 update_object (op, UP_OBJ_FACE); 692 update_object (op, UP_OBJ_FACE);
746} 693}
… …
812 /* nop */; 759 /* nop */;
813 else if (action == UP_OBJ_INSERT) 760 else if (action == UP_OBJ_INSERT)
814 { 761 {
815#if 0 762#if 0
816 // this is likely overkill, TODO: revisit (schmorp) 763 // this is likely overkill, TODO: revisit (schmorp)
817 if ((QUERY_FLAG (op, FLAG_BLOCKSVIEW) && !(m.flags_ & P_BLOCKSVIEW)) 764 if ((op->flag [FLAG_BLOCKSVIEW] && !(m.flags_ & P_BLOCKSVIEW))
818 || (QUERY_FLAG (op, FLAG_NO_MAGIC) && !(m.flags_ & P_NO_MAGIC)) 765 || (op->flag [FLAG_NO_MAGIC] && !(m.flags_ & P_NO_MAGIC))
819 || (op->is_player () && !(m.flags_ & P_PLAYER)) 766 || (op->is_player () && !(m.flags_ & P_PLAYER))
820 || (op->type == SAFE_GROUND && !(m.flags_ & P_SAFE)) 767 || (op->type == SAFE_GROUND && !(m.flags_ & P_SAFE))
821 || (QUERY_FLAG (op, FLAG_ALIVE) && !(m.flags_ & P_IS_ALIVE)) 768 || (op->flag [FLAG_ALIVE] && !(m.flags_ & P_IS_ALIVE))
822 || (QUERY_FLAG (op, FLAG_DAMNED) && !(m.flags_ & P_NO_CLERIC)) 769 || (op->flag [FLAG_DAMNED] && !(m.flags_ & P_NO_CLERIC))
823 || (m.move_on | op->move_on ) != m.move_on 770 || (m.move_on | op->move_on ) != m.move_on
824 || (m.move_off | op->move_off ) != m.move_off 771 || (m.move_off | op->move_off ) != m.move_off
825 || (m.move_slow | op->move_slow) != m.move_slow 772 || (m.move_slow | op->move_slow) != m.move_slow
826 /* This isn't perfect, but I don't expect a lot of objects to 773 /* This isn't perfect, but I don't expect a lot of objects to
827 * have move_allow right now. 774 * have move_allow right now.
… …
848 update_object (op->more, action); 795 update_object (op->more, action);
849} 796}
850 797
851object::object () 798object::object ()
852{ 799{
853 SET_FLAG (this, FLAG_REMOVED); 800 this->set_flag (FLAG_REMOVED);
854 801
855 //expmul = 1.0; declared const for the time being 802 //expmul = 1.0; declared const for the time being
856 face = blank_face; 803 face = blank_face;
857 material = MATERIAL_NULL; 804 material = MATERIAL_NULL;
858} 805}
… …
992 map->insert (op, x, y); 939 map->insert (op, x, y);
993 } 940 }
994 } 941 }
995} 942}
996 943
944/*
945 * Remove and free all objects in the inventory of the given object.
946 * Unlike destroy_inv, this assumes the *this is destroyed as well
947 * well, so we can (and have to!) take shortcuts.
948 */
949void
950object::destroy_inv_fast ()
951{
952 while (object *op = inv)
953 {
954 // remove from object the fast way
955 op->flag [FLAG_REMOVED] = true;
956 op->env = 0;
957 if ((inv = inv->below))
958 inv->above = 0;
959
960 // then destroy
961 op->destroy ();
962 }
963}
964
997object *object::create () 965object *object::create ()
998{ 966{
999 object *op = new object; 967 object *op = new object;
1000 op->link (); 968 op->link ();
1001 return op; 969 return op;
… …
1071 LOG (llevError | logBacktrace, "tried to destroy the tail of an object"); 1039 LOG (llevError | logBacktrace, "tried to destroy the tail of an object");
1072 head->destroy (); 1040 head->destroy ();
1073 return; 1041 return;
1074 } 1042 }
1075 1043
1076 destroy_inv (false); 1044 destroy_inv_fast ();
1077 1045
1078 if (is_head ()) 1046 if (is_head ())
1079 if (sound_destroy) 1047 if (sound_destroy)
1080 play_sound (sound_destroy); 1048 play_sound (sound_destroy);
1081 else if (flag [FLAG_MONSTER]) 1049 else if (flag [FLAG_MONSTER])
… …
1135 below = 0; 1103 below = 0;
1136 env = 0; 1104 env = 0;
1137 1105
1138 if (pl && pl->is_player ()) 1106 if (pl && pl->is_player ())
1139 { 1107 {
1108 if (expect_false (pl->contr->combat_ob == this))
1109 {
1110 pl->apply (pl->contr->combat_ob, AP_UNAPPLY);
1111 pl->contr->combat_ob = 0;
1112 if (pl->contr->ranged_ob) pl->apply (pl->contr->ranged_ob);
1113 }
1114
1115 if (expect_false (pl->contr->ranged_ob == this))
1116 {
1117 pl->apply (pl->contr->ranged_ob, AP_UNAPPLY);
1118 pl->contr->ranged_ob = 0;
1119 if (pl->contr->combat_ob) pl->apply (pl->contr->combat_ob);
1120 }
1121
1140 pl->contr->queue_stats_update (); 1122 pl->contr->queue_stats_update ();
1141 1123
1142 if (glow_radius && pl->is_on_map ()) 1124 if (expect_false (glow_radius) && pl->is_on_map ())
1143 update_all_los (pl->map, pl->x, pl->y); 1125 update_all_los (pl->map, pl->x, pl->y);
1144 } 1126 }
1145 } 1127 }
1146 else if (map) 1128 else if (map)
1147 { 1129 {
… …
1167 else if (pl->container_ () == this) 1149 else if (pl->container_ () == this)
1168 { 1150 {
1169 // removing a container should close it 1151 // removing a container should close it
1170 close_container (); 1152 close_container ();
1171 } 1153 }
1172 1154 else
1173 esrv_del_item (pl->contr, count); 1155 esrv_del_item (pl->contr, count);
1174 } 1156 }
1175 1157
1176 /* link the object above us */ 1158 /* link the object above us */
1177 // re-link, make sure compiler can easily use cmove 1159 // re-link, make sure compiler can easily use cmove
1178 *(above ? &above->below : &ms.top) = below; 1160 *(above ? &above->below : &ms.top) = below;
… …
1317 * Passing 0 for flag gives proper default values, so flag really only needs 1299 * Passing 0 for flag gives proper default values, so flag really only needs
1318 * to be set if special handling is needed. 1300 * to be set if special handling is needed.
1319 * 1301 *
1320 * Return value: 1302 * Return value:
1321 * new object if 'op' was merged with other object 1303 * new object if 'op' was merged with other object
1322 * NULL if 'op' was destroyed 1304 * NULL if there was an error (destroyed, blocked etc.)
1323 * just 'op' otherwise 1305 * just 'op' otherwise
1324 */ 1306 */
1325object * 1307object *
1326insert_ob_in_map (object *op, maptile *m, object *originator, int flag) 1308insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
1327{ 1309{
… …
1364 // from here :/ 1346 // from here :/
1365 op->nrof += tmp->nrof; 1347 op->nrof += tmp->nrof;
1366 tmp->destroy (); 1348 tmp->destroy ();
1367 } 1349 }
1368 1350
1369 CLEAR_FLAG (op, FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */ 1351 op->clr_flag (FLAG_APPLIED); /* hack for fixing F_APPLIED in items of dead people */
1370 CLEAR_FLAG (op, FLAG_INV_LOCKED); 1352 op->clr_flag (FLAG_INV_LOCKED);
1371 1353
1372 if (!QUERY_FLAG (op, FLAG_ALIVE)) 1354 if (!op->flag [FLAG_ALIVE])
1373 CLEAR_FLAG (op, FLAG_NO_STEAL); 1355 op->clr_flag (FLAG_NO_STEAL);
1374 1356
1375 if (flag & INS_BELOW_ORIGINATOR) 1357 if (flag & INS_BELOW_ORIGINATOR)
1376 { 1358 {
1377 if (originator->map != op->map || originator->x != op->x || originator->y != op->y) 1359 if (originator->map != op->map || originator->x != op->x || originator->y != op->y)
1378 { 1360 {
… …
1413 * when lots of spells are cast in one area. Currently, it is presumed 1395 * when lots of spells are cast in one area. Currently, it is presumed
1414 * that flying non pickable objects are spell objects. 1396 * that flying non pickable objects are spell objects.
1415 */ 1397 */
1416 for (object *tmp = ms.bot; tmp; tmp = tmp->above) 1398 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
1417 { 1399 {
1418 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) || QUERY_FLAG (tmp, FLAG_OVERLAY_FLOOR)) 1400 if (tmp->flag [FLAG_IS_FLOOR] || tmp->flag [FLAG_OVERLAY_FLOOR])
1419 floor = tmp; 1401 floor = tmp;
1420 1402
1421 if (QUERY_FLAG (tmp, FLAG_NO_PICK) && (tmp->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1403 if (tmp->flag [FLAG_NO_PICK] && (tmp->move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) && !tmp->flag [FLAG_IS_FLOOR])
1422 { 1404 {
1423 /* We insert above top, so we want this object below this */ 1405 /* We insert above top, so we want this object below this */
1424 top = tmp->below; 1406 top = tmp->below;
1425 break; 1407 break;
1426 } 1408 }
… …
1444 && (op->face && !faces [op->face].visibility)) 1426 && (op->face && !faces [op->face].visibility))
1445 { 1427 {
1446 object *last; 1428 object *last;
1447 1429
1448 for (last = top; last != floor; last = last->below) 1430 for (last = top; last != floor; last = last->below)
1449 if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT)) 1431 if (last->flag [FLAG_BLOCKSVIEW] && (last->type != EXIT))
1450 break; 1432 break;
1451 1433
1452 /* Check to see if we found the object that blocks view, 1434 /* Check to see if we found the object that blocks view,
1453 * and make sure we have a below pointer for it so that 1435 * and make sure we have a below pointer for it so that
1454 * we can get inserted below this one, which requires we 1436 * we can get inserted below this one, which requires we
… …
1585 || (items < m->max_items 1567 || (items < m->max_items
1586 && ms.volume () < m->max_volume)) 1568 && ms.volume () < m->max_volume))
1587 return true; 1569 return true;
1588 1570
1589 if (originator && originator->is_player ()) 1571 if (originator && originator->is_player ())
1590 originator->contr->failmsg (format ( 1572 originator->contr->failmsgf (
1591 "No matter how hard you try, you just cannot put the %s here H<Try to remove some items from the floor first.>", 1573 "No matter how hard you try, you just cannot put the %s here H<Try to remove some items from the floor first.>",
1592 query_name () 1574 query_name ()
1593 )); 1575 );
1594 1576
1595 return false; 1577 return false;
1596} 1578}
1597 1579
1598/* 1580/*
… …
1772 * on top. 1754 * on top.
1773 */ 1755 */
1774int 1756int
1775check_move_on (object *op, object *originator) 1757check_move_on (object *op, object *originator)
1776{ 1758{
1777 if (QUERY_FLAG (op, FLAG_NO_APPLY)) 1759 if (op->flag [FLAG_NO_APPLY])
1778 return 0; 1760 return 0;
1779 1761
1780 object *tmp; 1762 object *tmp;
1781 maptile *m = op->map; 1763 maptile *m = op->map;
1782 int x = op->x, y = op->y; 1764 int x = op->x, y = op->y;
… …
1819 * Second check makes sure that the movement types not being slowed 1801 * Second check makes sure that the movement types not being slowed
1820 * (~slow_move) is not blocked on this space - just because the 1802 * (~slow_move) is not blocked on this space - just because the
1821 * space doesn't slow down swimming (for example), if you can't actually 1803 * space doesn't slow down swimming (for example), if you can't actually
1822 * swim on that space, can't use it to avoid the penalty. 1804 * swim on that space, can't use it to avoid the penalty.
1823 */ 1805 */
1824 if (!QUERY_FLAG (op, FLAG_WIZPASS)) 1806 if (!op->flag [FLAG_WIZPASS])
1825 { 1807 {
1826 if ((!op->move_type && tmp->move_slow & MOVE_WALK) || 1808 if ((!op->move_type && tmp->move_slow & MOVE_WALK) ||
1827 ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0)) 1809 ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0))
1828 { 1810 {
1829 float diff = tmp->move_slow_penalty * fabs (op->speed); 1811 float diff = tmp->move_slow_penalty * fabs (op->speed);
… …
1960void 1942void
1961flag_inv (object *op, int flag) 1943flag_inv (object *op, int flag)
1962{ 1944{
1963 for (object *tmp = op->inv; tmp; tmp = tmp->below) 1945 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1964 { 1946 {
1965 SET_FLAG (tmp, flag); 1947 tmp->set_flag (flag);
1966 flag_inv (tmp, flag); 1948 flag_inv (tmp, flag);
1967 } 1949 }
1968} 1950}
1969 1951
1970/* 1952/*
… …
1973void 1955void
1974unflag_inv (object *op, int flag) 1956unflag_inv (object *op, int flag)
1975{ 1957{
1976 for (object *tmp = op->inv; tmp; tmp = tmp->below) 1958 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1977 { 1959 {
1978 CLEAR_FLAG (tmp, flag); 1960 tmp->clr_flag (flag);
1979 unflag_inv (tmp, flag); 1961 unflag_inv (tmp, flag);
1980 } 1962 }
1981} 1963}
1982 1964
1983/* 1965/*
… …
2343 * Add a check so we can't pick up invisible objects (0.93.8) 2325 * Add a check so we can't pick up invisible objects (0.93.8)
2344 */ 2326 */
2345int 2327int
2346can_pick (const object *who, const object *item) 2328can_pick (const object *who, const object *item)
2347{ 2329{
2348 return /*QUERY_FLAG(who,FLAG_WIZ)|| */ 2330 return /*who->flag [FLAG_WIZ]|| */
2349 (item->weight > 0 && !QUERY_FLAG (item, FLAG_NO_PICK) && 2331 (item->weight > 0 && !item->flag [FLAG_NO_PICK] &&
2350 !QUERY_FLAG (item, FLAG_ALIVE) && !item->invisible && (who->is_player () || item->weight < who->weight / 3)); 2332 !item->flag [FLAG_ALIVE] && !item->invisible && (who->is_player () || item->weight < who->weight / 3));
2351} 2333}
2352 2334
2353/* 2335/*
2354 * create clone from object to another 2336 * create clone from object to another
2355 */ 2337 */
… …
2679 2661
2680 insert (force); 2662 insert (force);
2681 } 2663 }
2682} 2664}
2683 2665
2666void object::change_move_type (MoveType mt)
2667{
2668 if (move_type == mt)
2669 return;
2670
2671 if (is_on_map ())
2672 {
2673 // we are on the map, so handle move_on/off effects
2674 remove ();
2675 move_type = mt;
2676 map->insert (this, x, y, this);
2677 }
2678 else
2679 move_type = mt;
2680}
2681

Diff Legend

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