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.345 by root, Sun May 1 16:58:15 2011 UTC vs.
Revision 1.367 by root, Sun Nov 18 15:19:48 2018 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 (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
4 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 5 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2001 Mark Wedel & Crossfire Development Team 6 * Copyright (©) 2001 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992 Frank Tore Johansen 7 * Copyright (©) 1992 Frank Tore Johansen
7 * 8 *
8 * Deliantra is free software: you can redistribute it and/or modify it under 9 * 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 10 * 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 11 * Free Software Foundation, either version 3 of the License, or (at your
11 * option) any later version. 12 * option) any later version.
12 * 13 *
13 * This program is distributed in the hope that it will be useful, 14 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details. 17 * GNU General Public License for more details.
17 * 18 *
18 * You should have received a copy of the Affero GNU General Public License 19 * You should have received a copy of the Affero GNU General Public License
19 * and the GNU General Public License along with this program. If not, see 20 * and the GNU General Public License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>. 21 * <http://www.gnu.org/licenses/>.
21 * 22 *
22 * The authors can be reached via e-mail to <support@deliantra.net> 23 * The authors can be reached via e-mail to <support@deliantra.net>
23 */ 24 */
24 25
25#include <global.h> 26#include <global.h>
26#include <stdio.h> 27#include <stdio.h>
… …
45uint32_t object::create_count; 46uint32_t object::create_count;
46uint32_t object::destroy_count; 47uint32_t object::destroy_count;
47 48
48//+GPL 49//+GPL
49 50
50short freearr_x[SIZEOFFREE] = { 51int freearr_x[SIZEOFFREE] = {
51 0, 52 0,
52 0, 1, 1, 1, 0, -1, -1, -1, 53 0, 1, 1, 1, 0, -1, -1, -1,
53 0, 1, 2, 2, 2, 2, 2, 1, 0, -1, -2, -2, -2, -2, -2, -1, 54 0, 1, 2, 2, 2, 2, 2, 1, 0, -1, -2, -2, -2, -2, -2, -1,
54 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3, -3, -3, -3, -3, -2, -1 55 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3, -3, -3, -3, -3, -2, -1
55}; 56};
56short freearr_y[SIZEOFFREE] = { 57int freearr_y[SIZEOFFREE] = {
57 0, 58 0,
58 -1, -1, 0, 1, 1, 1, 0, -1, 59 -1, -1, 0, 1, 1, 1, 0, -1,
59 -2, -2, -2, -1, 0, 1, 2, 2, 2, 2, 2, 1, 0, -1, -2, -2, 60 -2, -2, -2, -1, 0, 1, 2, 2, 2, 2, 2, 1, 0, -1, -2, -2,
60 -3, -3, -3, -3, -2, -1, 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3 61 -3, -3, -3, -3, -2, -1, 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3
61}; 62};
… …
72 25, 26, 27, 30, 31, 32, 33, 36, 37, 39, 39, 42, 43, 44, 45, 48, 73 25, 26, 27, 30, 31, 32, 33, 36, 37, 39, 39, 42, 43, 44, 45, 48,
73 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49 74 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49
74}; 75};
75 76
76const char *wall_suffix[16] = { 77const char *wall_suffix[16] = {
77 "0", 78 "0",
78 "1_3", 79 "1_3",
79 "1_4", 80 "1_4",
80 "2_1_2", 81 "2_1_2",
81 "1_2", 82 "1_2",
82 "2_2_4", 83 "2_2_4",
83 "2_2_1", 84 "2_2_1",
84 "3_1", 85 "3_1",
85 "1_1", 86 "1_1",
86 "2_2_3", 87 "2_2_3",
87 "2_2_2", 88 "2_2_2",
88 "3_3", 89 "3_3",
89 "2_1_1", 90 "2_1_1",
90 "3_4", 91 "3_4",
91 "3_2", 92 "3_2",
92 "4" 93 "4"
93}; 94};
94 95
95static void 96static void
96write_uuid (uval64 skip, bool sync) 97write_uuid (uval64 skip, bool sync)
97{ 98{
… …
235static bool 236static bool
236compare_ob_value_lists_one (const object *wants, const object *has) 237compare_ob_value_lists_one (const object *wants, const object *has)
237{ 238{
238 /* n-squared behaviour (see kv.get), but I'm hoping both 239 /* n-squared behaviour (see kv.get), but I'm hoping both
239 * objects with lists are rare, and lists stay short. If not, use a 240 * objects with lists are rare, and lists stay short. If not, use a
240 * different structure or at least keep the lists sorted... 241 * different structure or at least keep the lists sorted...
241 */ 242 */
242 243
243 /* For each field in wants, */ 244 /* For each field in wants, */
244 for (key_value *kv = wants->kv.first; kv; kv = kv->next) 245 for (key_value *kv = wants->kv.first; kv; kv = kv->next)
245 if (has->kv.get (kv->key) != kv->value) 246 if (has->kv.get (kv->key) != kv->value)
… …
351 /* inventory ok - still need to check rest of this object to see 352 /* inventory ok - still need to check rest of this object to see
352 * if it is valid. 353 * if it is valid.
353 */ 354 */
354 } 355 }
355 356
356 /* Don't merge objects that are applied. With the new 'body' code, 357 /* Don't merge objects that are applied. With the new 'body' code,
357 * it is possible for most any character to have more than one of 358 * it is possible for most any character to have more than one of
358 * some items equipped, and we don't want those to merge. 359 * some items equipped, and we don't want those to merge.
359 */ 360 */
360 if (ob1->flag [FLAG_APPLIED] || ob2->flag [FLAG_APPLIED]) 361 if (ob1->flag [FLAG_APPLIED] || ob2->flag [FLAG_APPLIED])
361 return 0; 362 return 0;
362 363
363 /* Note sure why the following is the case - either the object has to 364 /* Not sure why the following is the case - either the object has to
364 * be animated or have a very low speed. Is this an attempted monster 365 * be animated or have a very low speed. Is this an attempted monster
365 * check? 366 * check?
366 */ 367 */
367 if (!ob1->flag [FLAG_ANIMATE] && ob1->has_active_speed ()) 368 if (!ob1->flag [FLAG_ANIMATE] && ob1->has_active_speed ())
368 return 0; 369 return 0;
369 370
… …
446 447
447 return 0; 448 return 0;
448} 449}
449 450
450// adjust weight per container type ("of holding") 451// adjust weight per container type ("of holding")
451static uint32 452static weight_t
452weight_adjust_for (object *op, uint32 weight) 453weight_adjust_for (object *op, weight_t weight)
453{ 454{
454 return op->type == CONTAINER 455 if (op->type == CONTAINER)
455 ? weight - weight * op->stats.Str / 100 456 weight -= weight * op->stats.Str / 100;
456 : weight; 457
458 return weight;
457} 459}
458 460
459/* 461/*
460 * subtracts, then adds, the specified weight to an object, 462 * subtracts, then adds, the specified weight to an object,
461 * and also updates how much the environment(s) is/are carrying. 463 * and also updates how much the environment(s) is/are carrying.
462 */ 464 */
463static void 465static void
464adjust_weight (object *op, sint32 sub, sint32 add) 466adjust_weight (object *op, weight_t sub, weight_t add)
465{ 467{
466 while (op) 468 while (op)
467 { 469 {
468 sint32 ocarrying = op->carrying; 470 weight_t carrying = (weight_t)op->carrying
471 - weight_adjust_for (op, sub)
472 + weight_adjust_for (op, add);
469 473
470 op->carrying -= weight_adjust_for (op, sub); 474 sub = op->carrying;
471 op->carrying += weight_adjust_for (op, add); 475 op->carrying = carrying;
476 add = op->carrying;
472 477
473 if (object *pl = op->visible_to ()) 478 if (object *pl = op->visible_to ())
474 if (pl != op) // player is handled lazily 479 if (pl != op) // player is handled lazily
475 esrv_update_item (UPD_WEIGHT, pl, op); 480 esrv_update_item (UPD_WEIGHT, pl, op);
476 481
477 sub = ocarrying;
478 add = op->carrying;
479
480 op = op->env; 482 op = op->env;
481 } 483 }
482} 484}
483 485
484/* 486/*
… …
487 * containers are carrying, and sums it up. 489 * containers are carrying, and sums it up.
488 */ 490 */
489void 491void
490object::update_weight () 492object::update_weight ()
491{ 493{
492 sint32 sum = 0; 494 weight_t sum = 0;
493 495
494 for (object *op = inv; op; op = op->below) 496 for (object *op = inv; op; op = op->below)
495 { 497 {
496 op->update_weight (); 498 op->update_weight ();
497 499
… …
635 speed_left = -1.; 637 speed_left = -1.;
636 638
637 /* copy the body_info to the body_used - this is only really 639 /* copy the body_info to the body_used - this is only really
638 * need for monsters, but doesn't hurt to do it for everything. 640 * need for monsters, but doesn't hurt to do it for everything.
639 * by doing so, when a monster is created, it has good starting 641 * by doing so, when a monster is created, it has good starting
640 * values for the body_used info, so when items are created 642 * values for the body_used info, so when items are created
641 * for it, they can be properly equipped. 643 * for it, they can be properly equipped.
642 */ 644 */
643 for (int i = NUM_BODY_LOCATIONS; i--; ) 645 for (int i = 0; i < NUM_BODY_LOCATIONS; ++i)
644 slot[i].used = slot[i].info; 646 slot[i].used = slot[i].info;
645 647
646 attachable::instantiate (); 648 attachable::instantiate ();
647} 649}
648 650
… …
658 660
659 neu->map = map; // not copied by copy_to 661 neu->map = map; // not copied by copy_to
660 return neu; 662 return neu;
661} 663}
662 664
665// update the anhimation frame of an object, but only if it has an animation
666// assigned and the frame number if within the animation.
667void object::update_anim_frame (int frame)
668{
669 if (ecb_expect_false (!has_anim () || frame >= anim_frames ()))
670 return;
671
672 set_anim_frame (frame);
673 update_object (this, UP_OBJ_FACE);
674}
675
663/* 676/*
664 * If an object with the IS_TURNABLE() flag needs to be turned due 677 * If an object with the IS_TURNABLE() flag needs to be turned due
665 * to the closest player being on the other side, this function can 678 * to the closest player being on the other side, this function can
666 * be called to update the face variable, _and_ how it looks on the map. 679 * be called to update the face variable, _and_ how it looks on the map.
667 */ 680 */
… …
669update_turn_face (object *op) 682update_turn_face (object *op)
670{ 683{
671 if (!op->flag [FLAG_IS_TURNABLE] || !op->arch) 684 if (!op->flag [FLAG_IS_TURNABLE] || !op->arch)
672 return; 685 return;
673 686
674 SET_ANIMATION (op, op->direction); 687 op->update_anim_frame (op->direction);
675 update_object (op, UP_OBJ_FACE);
676} 688}
677 689
678/* 690/*
679 * Updates the speed of an object. If the speed changes from 0 to another 691 * Updates the speed of an object. If the speed changes from 0 to another
680 * value, or vice versa, then add/remove the object from the active list. 692 * value, or vice versa, then add/remove the object from the active list.
… …
690 else 702 else
691 deactivate (); 703 deactivate ();
692} 704}
693 705
694/* 706/*
695 * update_object() updates the the map. 707 * update_object() updates the map.
696 * It takes into account invisible objects (and represent squares covered 708 * It takes into account invisible objects (and represent squares covered
697 * by invisible objects by whatever is below them (unless it's another 709 * by invisible objects by whatever is below them (unless it's another
698 * invisible object, etc...) 710 * invisible object, etc...)
699 * If the object being updated is beneath a player, the look-window 711 * If the object being updated is beneath a player, the look-window
700 * of that player is updated (this might be a suboptimal way of 712 * of that player is updated (this might be a suboptimal way of
… …
737 } 749 }
738 750
739 mapspace &m = op->ms (); 751 mapspace &m = op->ms ();
740 752
741 if (!(m.flags_ & P_UPTODATE)) 753 if (!(m.flags_ & P_UPTODATE))
742 /* nop */; 754 m.update_up (); // nothing to do except copy up
743 else if (action == UP_OBJ_INSERT) 755 else if (action == UP_OBJ_INSERT)
744 { 756 {
745#if 0 757#if 0
746 // this is likely overkill, TODO: revisit (schmorp) 758 // this is likely overkill, TODO: revisit (schmorp)
747 if ((op->flag [FLAG_BLOCKSVIEW] && !(m.flags_ & P_BLOCKSVIEW)) 759 if ((op->flag [FLAG_BLOCKSVIEW] && !(m.flags_ & P_BLOCKSVIEW))
… …
752 || (op->flag [FLAG_DAMNED] && !(m.flags_ & P_NO_CLERIC)) 764 || (op->flag [FLAG_DAMNED] && !(m.flags_ & P_NO_CLERIC))
753 || (m.move_on | op->move_on ) != m.move_on 765 || (m.move_on | op->move_on ) != m.move_on
754 || (m.move_off | op->move_off ) != m.move_off 766 || (m.move_off | op->move_off ) != m.move_off
755 || (m.move_slow | op->move_slow) != m.move_slow 767 || (m.move_slow | op->move_slow) != m.move_slow
756 /* This isn't perfect, but I don't expect a lot of objects to 768 /* This isn't perfect, but I don't expect a lot of objects to
757 * have move_allow right now. 769 * have move_allow right now.
758 */ 770 */
759 || ((m.move_block | op->move_block) & ~op->move_allow) != m.move_block 771 || ((m.move_block | op->move_block) & ~op->move_allow) != m.move_block
760 m.invalidate (); 772 m.invalidate ();
761#else 773#else
762 // the above is not strong enough a test to skip updating. los maybe? TODO (schmorp) 774 // the above is not strong enough a test to skip updating. los maybe? TODO (schmorp)
… …
768 * that is being removed. 780 * that is being removed.
769 */ 781 */
770 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE) 782 else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE)
771 m.invalidate (); 783 m.invalidate ();
772 else if (action == UP_OBJ_FACE) 784 else if (action == UP_OBJ_FACE)
773 /* Nothing to do for that case */ ; 785 m.update_up (); // nothing to do for that case, except copy up
774 else 786 else
775 LOG (llevError, "update_object called with invalid action: %d\n", action); 787 LOG (llevError, "update_object called with invalid action: %d\n", action);
776 788
777 if (op->more) 789 if (op->more)
778 update_object (op->more, action); 790 update_object (op->more, action);
… …
842 op->activate_recursive (); 854 op->activate_recursive ();
843} 855}
844 856
845/* This function removes object 'op' from the list of active 857/* This function removes object 'op' from the list of active
846 * objects. 858 * objects.
847 * This should only be used for style maps or other such 859 * This should only be used for style maps or other such
848 * reference maps where you don't want an object that isn't 860 * reference maps where you don't want an object that isn't
849 * in play chewing up cpu time getting processed. 861 * in play chewing up cpu time getting processed.
850 * The reverse of this is to call update_ob_speed, which 862 * The reverse of this is to call update_ob_speed, which
851 * will do the right thing based on the speed of the object. 863 * will do the right thing based on the speed of the object.
852 */ 864 */
… …
898 * if some form of movement is allowed, let objects 910 * if some form of movement is allowed, let objects
899 * drop on that space. 911 * drop on that space.
900 */ 912 */
901 if (!drop_to_ground 913 if (!drop_to_ground
902 || !map 914 || !map
903 || map->in_memory != MAP_ACTIVE 915 || !map->linkable ()
904 || map->no_drop 916 || map->no_drop
905 || ms ().move_block == MOVE_ALL) 917 || ms ().move_block == MOVE_ALL)
906 { 918 {
907 while (inv) 919 while (inv)
908 inv->destroy (); 920 inv->destroy ();
… …
1005 1017
1006 freelist = li; 1018 freelist = li;
1007 ++free_count; 1019 ++free_count;
1008} 1020}
1009 1021
1010static struct freed_map : maptile
1011{
1012 freed_map ()
1013 : maptile (3, 3)
1014 {
1015 path = "<freed objects map>";
1016 name = "/internal/freed_objects_map";
1017 no_drop = 1;
1018 no_reset = 1;
1019
1020 in_memory = MAP_ACTIVE;
1021 }
1022
1023 ~freed_map ()
1024 {
1025 destroy ();
1026 }
1027} freed_map; // freed objects are moved here to avoid crashes
1028
1029void 1022void
1030object::do_destroy () 1023object::do_destroy ()
1031{ 1024{
1032 if (flag [FLAG_IS_LINKED]) 1025 if (flag [FLAG_IS_LINKED])
1033 remove_link (); 1026 remove_link ();
… …
1106 flag [FLAG_REMOVED] = true; 1099 flag [FLAG_REMOVED] = true;
1107 1100
1108 if (more) 1101 if (more)
1109 more->remove (); 1102 more->remove ();
1110 1103
1111 /* 1104 /*
1112 * In this case, the object to be removed is in someones 1105 * In this case, the object to be removed is in someones
1113 * inventory. 1106 * inventory.
1114 */ 1107 */
1115 if (env) 1108 if (env)
1116 { 1109 {
… …
1198 1191
1199 above = 0; 1192 above = 0;
1200 below = 0; 1193 below = 0;
1201 1194
1202 ms.invalidate (); 1195 ms.invalidate ();
1203
1204 if (map->in_memory == MAP_SAVING)
1205 return;
1206 1196
1207 int check_walk_off = !flag [FLAG_NO_APPLY]; 1197 int check_walk_off = !flag [FLAG_NO_APPLY];
1208 1198
1209 if (object *pl = ms.player ()) 1199 if (object *pl = ms.player ())
1210 { 1200 {
… …
1424 * We've already dealt with merging if appropriate. 1414 * We've already dealt with merging if appropriate.
1425 * Generally, we want to put the new object on top. But if 1415 * Generally, we want to put the new object on top. But if
1426 * flag contains INS_ABOVE_FLOOR_ONLY, once we find the last 1416 * flag contains INS_ABOVE_FLOOR_ONLY, once we find the last
1427 * floor, we want to insert above that and no further. 1417 * floor, we want to insert above that and no further.
1428 * Also, if there are spell objects on this space, we stop processing 1418 * Also, if there are spell objects on this space, we stop processing
1429 * once we get to them. This reduces the need to traverse over all of 1419 * once we get to them. This reduces the need to traverse over all of
1430 * them when adding another one - this saves quite a bit of cpu time 1420 * them when adding another one - this saves quite a bit of cpu time
1431 * when lots of spells are cast in one area. Currently, it is presumed 1421 * when lots of spells are cast in one area. Currently, it is presumed
1432 * that flying non pickable objects are spell objects. 1422 * that flying non pickable objects are spell objects.
1433 */ 1423 */
1434 for (object *tmp = ms.bot; tmp; tmp = tmp->above) 1424 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
… …
1560 1550
1561 return op; 1551 return op;
1562} 1552}
1563 1553
1564/* this function inserts an object in the map, but if it 1554/* this function inserts an object in the map, but if it
1565 * finds an object of its own type, it'll remove that one first. 1555 * finds an object of its own type, it'll remove that one first.
1566 * op is the object to insert it under: supplies x and the map. 1556 * op is the object to insert it under: supplies x and the map.
1567 */ 1557 */
1568void 1558void
1569replace_insert_ob_in_map (shstr_tmp archname, object *op) 1559replace_insert_ob_in_map (shstr_tmp archname, object *op)
1570{ 1560{
… …
1602 if (!items // testing !items ensures we can drop at least one item 1592 if (!items // testing !items ensures we can drop at least one item
1603 || (items < m->max_items 1593 || (items < m->max_items
1604 && ms.volume () < m->max_volume)) 1594 && ms.volume () < m->max_volume))
1605 return true; 1595 return true;
1606 1596
1607 if (originator && originator->is_player ()) 1597 if (originator)
1608 originator->contr->failmsgf ( 1598 originator->failmsgf (
1609 "No matter how hard you try, you just cannot put the %s here H<Try to remove some items from the floor first.>", 1599 "No matter how hard you try, you just cannot put the %s here! H<Try to remove some items from the floor first.>",
1610 query_name () 1600 query_name ()
1611 ); 1601 );
1612 1602
1613 return false; 1603 return false;
1614} 1604}
… …
1628 1618
1629 nr = min (nr, nrof); 1619 nr = min (nr, nrof);
1630 1620
1631 if (nrof > nr) 1621 if (nrof > nr)
1632 { 1622 {
1633 sint64 oweight = total_weight (); 1623 weight_t oweight = total_weight ();
1634 1624
1635 nrof -= nr; 1625 nrof -= nr;
1636 1626
1637 if (object *pl = visible_to ()) 1627 if (object *pl = visible_to ())
1638 esrv_update_item (UPD_NROF, pl, this); 1628 esrv_update_item (UPD_NROF, pl, this);
… …
1699/* 1689/*
1700 * env->insert (op) 1690 * env->insert (op)
1701 * This function inserts the object op in the linked list 1691 * This function inserts the object op in the linked list
1702 * inside the object environment. 1692 * inside the object environment.
1703 * 1693 *
1704 * The function returns now pointer to inserted item, and return value can 1694 * The function returns now pointer to inserted item, and return value can
1705 * be != op, if items are merged. -Tero 1695 * be != op, if items are merged. -Tero
1706 */ 1696 */
1707object * 1697object *
1708object::insert (object *op) 1698object::insert (object *op)
1709{ 1699{
… …
1722 if (object::can_merge (tmp, op)) 1712 if (object::can_merge (tmp, op))
1723 { 1713 {
1724 /* return the original object and remove inserted object 1714 /* return the original object and remove inserted object
1725 (client prefers the original object) */ 1715 (client prefers the original object) */
1726 1716
1727 // carring must be 0 for mergable objects 1717 // carrying must be 0 for mergable objects
1728 sint64 oweight = tmp->weight * tmp->nrof; 1718 weight_t oweight = weight_t (tmp->weight) * tmp->nrof;
1729 1719
1730 tmp->nrof += op->nrof; 1720 tmp->nrof += op->nrof;
1731 1721
1732 if (object *pl = tmp->visible_to ()) 1722 if (object *pl = tmp->visible_to ())
1733 esrv_update_item (UPD_NROF, pl, tmp); 1723 esrv_update_item (UPD_NROF, pl, tmp);
1734 1724
1735 adjust_weight (this, oweight, tmp->weight * tmp->nrof); 1725 adjust_weight (this, oweight, weight_t (tmp->weight) * tmp->nrof);
1736 1726
1737 op->destroy (); 1727 op->destroy ();
1738 op = tmp; 1728 op = tmp;
1739 goto inserted; 1729 goto inserted;
1740 } 1730 }
… …
1829 */ 1819 */
1830 if ((op->move_type & ~move_on & ~move_block) != 0 && (op->move_type & ~move_slow & ~move_block) != 0) 1820 if ((op->move_type & ~move_on & ~move_block) != 0 && (op->move_type & ~move_slow & ~move_block) != 0)
1831 return 0; 1821 return 0;
1832 1822
1833 /* The objects have to be checked from top to bottom. 1823 /* The objects have to be checked from top to bottom.
1834 * Hence, we first go to the top: 1824 * Hence, we first go to the top:
1835 */ 1825 */
1836 for (object *next, *tmp = ms.top; tmp; tmp = next) 1826 for (object *next, *tmp = ms.top; tmp; tmp = next)
1837 { 1827 {
1838 next = tmp->below; 1828 next = tmp->below;
1839 1829
… …
2023 * inform the caller. However, insert_ob_in_map will update as 2013 * inform the caller. However, insert_ob_in_map will update as
2024 * necessary, so the caller shouldn't need to do any special work. 2014 * necessary, so the caller shouldn't need to do any special work.
2025 * Note - updated to take an object instead of archetype - this is necessary 2015 * Note - updated to take an object instead of archetype - this is necessary
2026 * because arch_blocked (now ob_blocked) needs to know the movement type 2016 * because arch_blocked (now ob_blocked) needs to know the movement type
2027 * to know if the space in question will block the object. We can't use 2017 * to know if the space in question will block the object. We can't use
2028 * the archetype because that isn't correct if the monster has been 2018 * the archetype because that isn't correct if the monster has been
2029 * customized, changed states, etc. 2019 * customized, changed states, etc.
2030 */ 2020 */
2031int 2021int
2032find_free_spot (const object *ob, maptile *m, int x, int y, int start, int stop) 2022find_free_spot (const object *ob, maptile *m, int x, int y, int start, int stop)
2033{ 2023{
2034 int altern[SIZEOFFREE]; 2024 int altern[SIZEOFFREE];
2035 int index = 0, flag; 2025 int index = 0;
2036 2026
2037 for (int i = start; i < stop; i++) 2027 for (int i = start; i < stop; i++)
2038 { 2028 {
2039 mapxy pos (m, x, y); pos.move (i); 2029 mapxy pos (m, x, y); pos.move (i);
2040 2030
… …
2056 continue; 2046 continue;
2057 } 2047 }
2058 2048
2059 /* Basically, if we find a wall on a space, we cut down the search size. 2049 /* Basically, if we find a wall on a space, we cut down the search size.
2060 * In this way, we won't return spaces that are on another side of a wall. 2050 * In this way, we won't return spaces that are on another side of a wall.
2061 * This mostly work, but it cuts down the search size in all directions - 2051 * This mostly work, but it cuts down the search size in all directions -
2062 * if the space being examined only has a wall to the north and empty 2052 * if the space being examined only has a wall to the north and empty
2063 * spaces in all the other directions, this will reduce the search space 2053 * spaces in all the other directions, this will reduce the search space
2064 * to only the spaces immediately surrounding the target area, and 2054 * to only the spaces immediately surrounding the target area, and
2065 * won't look 2 spaces south of the target space. 2055 * won't look 2 spaces south of the target space.
2066 */ 2056 */
… …
2096 */ 2086 */
2097int 2087int
2098find_first_free_spot (const object *ob, maptile *m, int x, int y) 2088find_first_free_spot (const object *ob, maptile *m, int x, int y)
2099{ 2089{
2100 for (int i = 0; i < SIZEOFFREE; i++) 2090 for (int i = 0; i < SIZEOFFREE; i++)
2101 if (!ob->blocked (m, x + freearr_x[i], y + freearr_y[i])) 2091 if (!ob->blocked (m, x + DIRX (i), y + DIRY (i)))
2102 return i; 2092 return i;
2103 2093
2104 return -1; 2094 return -1;
2105} 2095}
2106 2096
… …
2117 2107
2118 while (--end) 2108 while (--end)
2119 swap (arr [end], arr [rndm (end + 1)]); 2109 swap (arr [end], arr [rndm (end + 1)]);
2120} 2110}
2121 2111
2122/* new function to make monster searching more efficient, and effective! 2112/* new function to make monster searching more efficient, and effective!
2123 * This basically returns a randomized array (in the passed pointer) of 2113 * This basically returns a randomized array (in the passed pointer) of
2124 * the spaces to find monsters. In this way, it won't always look for 2114 * the spaces to find monsters. In this way, it won't always look for
2125 * monsters to the north first. However, the size of the array passed 2115 * monsters to the north first. However, the size of the array passed
2126 * covers all the spaces, so within that size, all the spaces within 2116 * covers all the spaces, so within that size, all the spaces within
2127 * the 3x3 area will be searched, just not in a predictable order. 2117 * the 3x3 area will be searched, just not in a predictable order.
… …
2152 * there is capable of. 2142 * there is capable of.
2153 */ 2143 */
2154int 2144int
2155find_dir (maptile *m, int x, int y, object *exclude) 2145find_dir (maptile *m, int x, int y, object *exclude)
2156{ 2146{
2157 int max = SIZEOFFREE, mflags; 2147 int max = SIZEOFFREE;
2158 MoveType move_type; 2148 MoveType move_type;
2159 2149
2160 if (exclude && exclude->head_ () != exclude) 2150 if (exclude && exclude->head_ () != exclude)
2161 { 2151 {
2162 exclude = exclude->head; 2152 exclude = exclude->head;
… …
2371 int mflags; 2361 int mflags;
2372 2362
2373 if (dir < 0) 2363 if (dir < 0)
2374 return 0; /* exit condition: invalid direction */ 2364 return 0; /* exit condition: invalid direction */
2375 2365
2376 dx = x + freearr_x[dir]; 2366 dx = x + DIRX (dir);
2377 dy = y + freearr_y[dir]; 2367 dy = y + DIRY (dir);
2378 2368
2379 mflags = get_map_flags (m, &m, dx, dy, &dx, &dy); 2369 mflags = get_map_flags (m, &m, dx, dy, &dx, &dy);
2380 2370
2381 /* This functional arguably was incorrect before - it was 2371 /* This functional arguably was incorrect before - it was
2382 * checking for P_WALL - that was basically seeing if 2372 * checking for P_WALL - that was basically seeing if
… …
2413 return /*who->flag [FLAG_WIZ]|| */ 2403 return /*who->flag [FLAG_WIZ]|| */
2414 (item->weight > 0 && !item->flag [FLAG_NO_PICK] && 2404 (item->weight > 0 && !item->flag [FLAG_NO_PICK] &&
2415 !item->flag [FLAG_ALIVE] && !item->invisible && (who->is_player () || item->weight < who->weight / 3)); 2405 !item->flag [FLAG_ALIVE] && !item->invisible && (who->is_player () || item->weight < who->weight / 3));
2416} 2406}
2417 2407
2408//-GPL
2409
2418/* 2410/*
2419 * create clone from object to another 2411 * create clone from object to another
2420 */ 2412 */
2421object * 2413object *
2422object::deep_clone () 2414object::deep_clone ()
… …
2453 2445
2454 return 0; 2446 return 0;
2455} 2447}
2456 2448
2457/* Zero the key_values on op, decrementing the shared-string 2449/* Zero the key_values on op, decrementing the shared-string
2458 * refcounts and freeing the links. 2450 * refcounts and freeing the links.
2459 */ 2451 */
2460void 2452void
2461key_values::clear () 2453key_values::clear ()
2462{ 2454{
2463 for (key_value *kvp = first; kvp; ) 2455 for (key_value *kvp = first; kvp; )
… …
2634object::region () const 2626object::region () const
2635{ 2627{
2636 return map ? map->region (x, y) 2628 return map ? map->region (x, y)
2637 : region::default_region (); 2629 : region::default_region ();
2638} 2630}
2631
2632//+GPL
2639 2633
2640void 2634void
2641object::open_container (object *new_container) 2635object::open_container (object *new_container)
2642{ 2636{
2643 if (container == new_container) 2637 if (container == new_container)
… …
2701 } 2695 }
2702// else if (!old_container->env && contr && contr->ns) 2696// else if (!old_container->env && contr && contr->ns)
2703// contr->ns->floorbox_reset (); 2697// contr->ns->floorbox_reset ();
2704} 2698}
2705 2699
2700//-GPL
2701
2702// prefetch some flat area around the player
2703static void
2704prefetch_surrounding_area (object *op, maptile *map, int range)
2705{
2706 for (maprect *rect = map->split_to_tiles (mapwalk_buf,
2707 op->x - range , op->y - range ,
2708 op->x + range + 1, op->y + range + 1);
2709 rect->m;
2710 ++rect)
2711 {
2712 rect->m->touch ();
2713 rect->m->activate ();
2714 }
2715}
2716
2717// prefetch a generous area around the player, also up and down
2718void
2719object::prefetch_surrounding_maps ()
2720{
2721 prefetch_surrounding_area (this, map, 40);
2722
2723 if (maptile *m = map->tile_available (TILE_DOWN))
2724 prefetch_surrounding_area (this, m, 20);
2725
2726 if (maptile *m = map->tile_available (TILE_UP))
2727 prefetch_surrounding_area (this, m, 20);
2728}
2729
2730//+GPL
2731
2706object * 2732object *
2707object::force_find (shstr_tmp name) 2733object::force_find (shstr_tmp name)
2708{ 2734{
2709 /* cycle through his inventory to look for the MARK we want to 2735 /* cycle through his inventory to look for the MARK we want to
2710 * place 2736 * place
2711 */ 2737 */
2712 for (object *tmp = inv; tmp; tmp = tmp->below) 2738 for (object *tmp = inv; tmp; tmp = tmp->below)
2713 if (tmp->type == FORCE && tmp->slaying == name) 2739 if (tmp->type == FORCE && tmp->slaying == name)
2714 return splay (tmp); 2740 return splay (tmp);
2715 2741
2716 return 0; 2742 return 0;
2717} 2743}
2718
2719//-GPL
2720 2744
2721void 2745void
2722object::force_set_timer (int duration) 2746object::force_set_timer (int duration)
2723{ 2747{
2724 this->duration = 1; 2748 this->duration = 1;

Diff Legend

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