ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/map.C
(Generate patch)

Comparing deliantra/server/common/map.C (file contents):
Revision 1.164 by root, Fri Oct 16 01:19:12 2009 UTC vs.
Revision 1.177 by root, Wed Nov 11 23:27:56 2009 UTC

… …
26 26
27#include "global.h" 27#include "global.h"
28#include "loader.h" 28#include "loader.h"
29#include "path.h" 29#include "path.h"
30 30
31//+GPL
32
31sint8 maptile::outdoor_darkness; 33sint8 maptile::outdoor_darkness;
32 34
33/* This rolls up wall, blocks_magic, blocks_view, etc, all into 35/* This rolls up wall, blocks_magic, blocks_view, etc, all into
34 * one function that just returns a P_.. value (see map.h) 36 * one function that just returns a P_.. value (see map.h)
35 * it will also do map translation for tiled maps, returning 37 * it will also do map translation for tiled maps, returning
… …
80 { 82 {
81 LOG (llevError, "blocked_link: Passed map, x, y coordinates outside of map\n"); 83 LOG (llevError, "blocked_link: Passed map, x, y coordinates outside of map\n");
82 return 1; 84 return 1;
83 } 85 }
84 86
85 /* Save some cycles - instead of calling get_map_flags(), just get the value
86 * directly.
87 */
88 mapspace &ms = m->at (sx, sy); 87 mapspace &ms = m->at (sx, sy);
89 88
90 int mflags = ms.flags (); 89 int mflags = ms.flags ();
91 int blocked = ms.move_block; 90 int blocked = ms.move_block;
92 91
… …
114 * true. If we get through the entire stack, that must mean 113 * true. If we get through the entire stack, that must mean
115 * ob is blocking it, so return 0. 114 * ob is blocking it, so return 0.
116 */ 115 */
117 for (object *tmp = ms.bot; tmp; tmp = tmp->above) 116 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
118 { 117 {
119 bool block = OB_MOVE_BLOCK (ob, tmp); 118 if (OB_MOVE_BLOCK (ob, tmp))
120
121 /* This must be before the checks below. Code for inventory checkers. */
122 if (block && tmp->type == CHECK_INV)
123 { 119 {
124 bool have = check_inv_recursive (ob, tmp); 120 if (INVOKE_OBJECT (BLOCKED_MOVE, tmp, ob))
125 121 if (RESULT_INT (0))
126 /* If last_sp is set, the player/monster needs an object, 122 return 1;
127 * so we check for it. If they don't have it, they can't
128 * pass through this space.
129 */ 123 else
130 if (tmp->last_sp) 124 continue;
125
126 if (tmp->type == CHECK_INV)
131 { 127 {
132 if (!have) 128 bool have = check_inv_recursive (ob, tmp);
129
130 // last_sp set means we block if we don't have.
131 if (logical_xor (have, tmp->last_sp))
132 return 1;
133 }
134 else if (tmp->type == T_MATCH)
135 {
136 // T_MATCH allows "entrance" iff the match is true
137 // == blocks if the match fails
138
139 // we could have used an INVOKE_OBJECT, but decided against it, as we
140 // assume that T_MATCH is relatively common.
141 if (!match (tmp->slaying, ob, tmp, ob))
133 return 1; 142 return 1;
134 } 143 }
135 else 144 else
136 { 145 return 1; // unconditional block
137 /* In this case, the player must not have the object - 146
138 * if they do, they can't pass through.
139 */
140 if (have)
141 return 1;
142 }
143 }
144 else if (block && tmp->type == T_MATCH)
145 {
146 //TODO
147 }
148 else 147 } else {
149 { 148 // space does not block the ob, directly, but
150 /* Broke apart a big nasty if into several here to make 149 // anything alive that is not a door still
151 * this more readable. first check - if the space blocks 150 // blocks anything but wizards.
152 * movement, can't move here.
153 * second - if a monster, can't move there, unless it is a
154 * dm.
155 */
156 if (block)
157 return 1;
158 151
159 if (tmp->flag [FLAG_ALIVE] 152 if (tmp->flag [FLAG_ALIVE]
160 && tmp->head_ () != ob 153 && tmp->head_ () != ob
161 && tmp != ob 154 && tmp != ob
162 && tmp->type != DOOR 155 && tmp->type != DOOR
163 && !tmp->flag [FLAG_WIZ]) 156 && !tmp->flag [FLAG_WIZPASS])
164 return 1; 157 return 1;
165 } 158 }
166 } 159 }
167 160
168 return 0; 161 return 0;
… …
224 } 217 }
225 218
226 return 0; 219 return 0;
227} 220}
228 221
229/* When the map is loaded, load_object does not actually insert objects 222//-GPL
230 * into inventory, but just links them. What this does is go through
231 * and insert them properly.
232 * The object 'container' is the object that contains the inventory.
233 * This is needed so that we can update the containers weight.
234 */
235void
236fix_container (object *container)
237{
238 object *tmp = container->inv, *next;
239
240 container->inv = 0;
241 while (tmp)
242 {
243 next = tmp->below;
244 if (tmp->inv)
245 fix_container (tmp);
246
247 insert_ob_in_ob (tmp, container);
248 tmp = next;
249 }
250
251 // go through and calculate what all the containers are carrying.
252 //TODO: remove
253 container->update_weight ();
254}
255 223
256void 224void
257maptile::set_object_flag (int flag, int value) 225maptile::set_object_flag (int flag, int value)
258{ 226{
259 if (!spaces) 227 if (!spaces)
… …
274 242
275 for (mapspace *ms = spaces + size (); ms-- > spaces; ) 243 for (mapspace *ms = spaces + size (); ms-- > spaces; )
276 for (object *tmp = ms->bot; tmp; tmp = tmp->above) 244 for (object *tmp = ms->bot; tmp; tmp = tmp->above)
277 INVOKE_OBJECT (RESET, tmp); 245 INVOKE_OBJECT (RESET, tmp);
278} 246}
247
248void
249maptile::post_load ()
250{
251#if 0
252 if (!spaces)
253 return;
254
255 for (mapspace *ms = spaces + size (); ms-- > spaces; )
256 for (object *tmp = ms->bot; tmp; tmp = tmp->above)
257 ; // nop
258#endif
259}
260
261//+GPL
279 262
280/* link_multipart_objects go through all the objects on the map looking 263/* link_multipart_objects go through all the objects on the map looking
281 * for objects whose arch says they are multipart yet according to the 264 * for objects whose arch says they are multipart yet according to the
282 * info we have, they only have the head (as would be expected when 265 * info we have, they only have the head (as would be expected when
283 * they are saved). 266 * they are saved).
… …
310 else 293 else
311 op = op->above; 294 op = op->above;
312 } 295 }
313 } 296 }
314} 297}
298
299//-GPL
315 300
316/* 301/*
317 * Loads (ands parses) the objects into a given map from the specified 302 * Loads (ands parses) the objects into a given map from the specified
318 * file pointer. 303 * file pointer.
319 */ 304 */
… …
449 * map archetype. Mimic that behaviour. 434 * map archetype. Mimic that behaviour.
450 */ 435 */
451 width = 16; 436 width = 16;
452 height = 16; 437 height = 16;
453 timeout = 300; 438 timeout = 300;
454 max_nrof = 1000; // 1000 items of anything 439 max_items = MAX_ITEM_PER_ACTION;
455 max_volume = 2000000; // 2m³ 440 max_volume = 2000000; // 2m³
456} 441}
457 442
458maptile::maptile (int w, int h) 443maptile::maptile (int w, int h)
459{ 444{
… …
480 if (spaces) 465 if (spaces)
481 return; 466 return;
482 467
483 spaces = salloc0<mapspace> (size ()); 468 spaces = salloc0<mapspace> (size ());
484} 469}
470
471//+GPL
485 472
486/* Takes a string from a map definition and outputs a pointer to the array of shopitems 473/* Takes a string from a map definition and outputs a pointer to the array of shopitems
487 * corresponding to that string. Memory is allocated for this, it must be freed 474 * corresponding to that string. Memory is allocated for this, it must be freed
488 * at a later date. 475 * at a later date.
489 * Called by parse_map_headers below. 476 * Called by parse_map_headers below.
… …
592 } 579 }
593 580
594 return buf; 581 return buf;
595} 582}
596 583
584//-GPL
585
597/* This loads the header information of the map. The header 586/* This loads the header information of the map. The header
598 * contains things like difficulty, size, timeout, etc. 587 * contains things like difficulty, size, timeout, etc.
599 * this used to be stored in the map object, but with the 588 * this used to be stored in the map object, but with the
600 * addition of tiling, fields beyond that easily named in an 589 * addition of tiling, fields beyond that easily named in an
601 * object structure were needed, so it just made sense to 590 * object structure were needed, so it just made sense to
… …
692 } 681 }
693 682
694 abort (); 683 abort ();
695} 684}
696 685
686//+GPL
687
697/****************************************************************************** 688/******************************************************************************
698 * This is the start of unique map handling code 689 * This is the start of unique map handling code
699 *****************************************************************************/ 690 *****************************************************************************/
700 691
701/* This goes through the maptile and removed any unique items on the map. */ 692/* This goes through the maptile and removed any unique items on the map. */
… …
718 op = above; 709 op = above;
719 } 710 }
720 } 711 }
721} 712}
722 713
714//-GPL
715
723bool 716bool
724maptile::_save_header (object_freezer &freezer) 717maptile::_save_header (object_freezer &freezer)
725{ 718{
726#define MAP_OUT(k) freezer.put (KW_ ## k, k) 719#define MAP_OUT(k) freezer.put (KW(k), k)
727#define MAP_OUT2(k,v) freezer.put (KW_ ## k, v) 720#define MAP_OUT2(k,v) freezer.put (KW(k), v)
728 721
729 MAP_OUT2 (arch, "map"); 722 MAP_OUT2 (arch, CS(map));
730 723
731 if (name) MAP_OUT (name); 724 if (name) MAP_OUT (name);
732 MAP_OUT (swap_time); 725 MAP_OUT (swap_time);
733 MAP_OUT (reset_time); 726 MAP_OUT (reset_time);
734 MAP_OUT (reset_timeout); 727 MAP_OUT (reset_timeout);
… …
748 MAP_OUT (width); 741 MAP_OUT (width);
749 MAP_OUT (height); 742 MAP_OUT (height);
750 MAP_OUT (enter_x); 743 MAP_OUT (enter_x);
751 MAP_OUT (enter_y); 744 MAP_OUT (enter_y);
752 745
753 if (msg) freezer.put (KW_msg , KW_endmsg , msg); 746 if (msg) freezer.put (KW(msg) , KW(endmsg) , msg);
754 if (maplore) freezer.put (KW_maplore, KW_endmaplore, maplore); 747 if (maplore) freezer.put (KW(maplore), KW(endmaplore), maplore);
755 748
756 MAP_OUT (outdoor); 749 MAP_OUT (outdoor);
757 MAP_OUT (temp); 750 MAP_OUT (temp);
758 MAP_OUT (pressure); 751 MAP_OUT (pressure);
759 MAP_OUT (humid); 752 MAP_OUT (humid);
… …
768 if (tile_path [1]) MAP_OUT2 (tile_path_2, tile_path [1]); 761 if (tile_path [1]) MAP_OUT2 (tile_path_2, tile_path [1]);
769 if (tile_path [2]) MAP_OUT2 (tile_path_3, tile_path [2]); 762 if (tile_path [2]) MAP_OUT2 (tile_path_3, tile_path [2]);
770 if (tile_path [3]) MAP_OUT2 (tile_path_4, tile_path [3]); 763 if (tile_path [3]) MAP_OUT2 (tile_path_4, tile_path [3]);
771 764
772 freezer.put (this); 765 freezer.put (this);
773 freezer.put (KW_end); 766 freezer.put (KW(end));
774 767
775 return true; 768 return true;
776} 769}
777 770
778bool 771bool
… …
783 if (!_save_header (freezer)) 776 if (!_save_header (freezer))
784 return false; 777 return false;
785 778
786 return freezer.save (path); 779 return freezer.save (path);
787} 780}
781
782//+GPL
788 783
789/* 784/*
790 * Remove and free all objects in the given map. 785 * Remove and free all objects in the given map.
791 */ 786 */
792void 787void
… …
1018 */ 1013 */
1019void 1014void
1020mapspace::update_ () 1015mapspace::update_ ()
1021{ 1016{
1022 object *last = 0; 1017 object *last = 0;
1023 uint8 flags = P_UPTODATE, anywhere = 0; 1018 uint8 flags = P_UPTODATE;
1024 sint8 light = 0; 1019 sint8 light = 0;
1025 MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0; 1020 MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0;
1021 uint64_t volume = 0;
1022 uint32_t items = 0;
1023 object *anywhere = 0;
1024 uint8_t middle_visibility = 0;
1026 1025
1027 //object *middle = 0; 1026 //object *middle = 0;
1028 //object *top = 0; 1027 //object *top = 0;
1029 //object *floor = 0; 1028 //object *floor = 0;
1030 // this seems to generate better code than using locals, above 1029 // this seems to generate better code than using locals, above
1031 object *&top = faces_obj[0] = 0; 1030 object *&top = faces_obj[0] = 0;
1032 object *&middle = faces_obj[1] = 0; 1031 object *&middle = faces_obj[1] = 0;
1033 object *&floor = faces_obj[2] = 0; 1032 object *&floor = faces_obj[2] = 0;
1033
1034 object::flags_t allflags; // all flags of all objects or'ed together
1034 1035
1035 for (object *tmp = bot; tmp; last = tmp, tmp = tmp->above) 1036 for (object *tmp = bot; tmp; last = tmp, tmp = tmp->above)
1036 { 1037 {
1037 // Lights are additive, up to MAX_LIGHT_RADIUS, see los.C) 1038 // Lights are additive, up to MAX_LIGHT_RADIUS, see los.C)
1038 light += tmp->glow_radius; 1039 light += tmp->glow_radius;
… …
1043 * 3 times each time the player moves, because many of the 1044 * 3 times each time the player moves, because many of the
1044 * functions the move_player calls eventualy call this. 1045 * functions the move_player calls eventualy call this.
1045 * 1046 *
1046 * Always put the player down for drawing. 1047 * Always put the player down for drawing.
1047 */ 1048 */
1048 if (!tmp->invisible) 1049 if (expect_true (!tmp->invisible))
1049 { 1050 {
1050 if ((tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER))) 1051 if (expect_false (tmp->type == PLAYER || tmp->flag [FLAG_MONSTER]))
1051 top = tmp; 1052 top = tmp;
1052 else if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1053 else if (expect_false (tmp->flag [FLAG_IS_FLOOR]))
1053 { 1054 {
1054 /* If we got a floor, that means middle and top were below it, 1055 /* If we got a floor, that means middle and top were below it,
1055 * so should not be visible, so we clear them. 1056 * so should not be visible, so we clear them.
1056 */ 1057 */
1057 middle = 0; 1058 middle = 0;
1058 top = 0; 1059 top = 0;
1059 floor = tmp; 1060 floor = tmp;
1061 volume = 0;
1062 items = 0;
1060 } 1063 }
1061 /* Flag anywhere have high priority */ 1064 else
1062 else if (QUERY_FLAG (tmp, FLAG_SEE_ANYWHERE))
1063 { 1065 {
1066 if (expect_true (!tmp->flag [FLAG_NO_PICK]))
1067 {
1068 ++items;
1069 volume += tmp->volume ();
1070 }
1071
1072 /* Flag anywhere have high priority */
1073 if (expect_false (tmp->flag [FLAG_SEE_ANYWHERE]))
1074 anywhere = tmp;
1075
1076 /* Find the highest visible face around. If equal
1077 * visibilities, we still want the one nearer to the
1078 * top
1079 */
1080 if (expect_false (::faces [tmp->face].visibility >= middle_visibility))
1081 {
1082 middle_visibility = ::faces [tmp->face].visibility;
1064 middle = tmp; 1083 middle = tmp;
1065 anywhere = 1; 1084 }
1066 } 1085 }
1067
1068 /* Find the highest visible face around. If equal
1069 * visibilities, we still want the one nearer to the
1070 * top
1071 */
1072 else if (!middle || (::faces [tmp->face].visibility > ::faces [middle->face].visibility && !anywhere))
1073 middle = tmp;
1074 }
1075
1076 if (tmp == tmp->above)
1077 {
1078 LOG (llevError, "Error in structure of map\n");
1079 exit (-1);
1080 } 1086 }
1081 1087
1082 move_slow |= tmp->move_slow; 1088 move_slow |= tmp->move_slow;
1083 move_block |= tmp->move_block; 1089 move_block |= tmp->move_block;
1084 move_on |= tmp->move_on; 1090 move_on |= tmp->move_on;
1085 move_off |= tmp->move_off; 1091 move_off |= tmp->move_off;
1086 move_allow |= tmp->move_allow; 1092 move_allow |= tmp->move_allow;
1087 1093
1088 if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW)) flags |= P_BLOCKSVIEW; 1094 allflags |= tmp->flag;
1089 if (QUERY_FLAG (tmp, FLAG_NO_MAGIC)) flags |= P_NO_MAGIC; 1095
1090 if (tmp->type == PLAYER) flags |= P_PLAYER; 1096 if (tmp->type == PLAYER) flags |= P_PLAYER;
1091 if (tmp->type == SAFE_GROUND) flags |= P_SAFE; 1097 if (tmp->type == SAFE_GROUND) flags |= P_SAFE;
1092 if (QUERY_FLAG (tmp, FLAG_ALIVE)) flags |= P_IS_ALIVE;
1093 if (QUERY_FLAG (tmp, FLAG_DAMNED)) flags |= P_NO_CLERIC;
1094 } 1098 }
1099
1100 // FLAG_SEE_ANYWHERE takes precedence
1101 if (anywhere)
1102 middle = anywhere;
1103
1104 // ORing all flags together and checking them here is much faster
1105 if (allflags [FLAG_BLOCKSVIEW]) flags |= P_BLOCKSVIEW;
1106 if (allflags [FLAG_NO_MAGIC] ) flags |= P_NO_MAGIC;
1107 if (allflags [FLAG_ALIVE] ) flags |= P_IS_ALIVE;
1108 if (allflags [FLAG_DAMNED] ) flags |= P_NO_CLERIC;
1095 1109
1096 this->light = min (light, MAX_LIGHT_RADIUS); 1110 this->light = min (light, MAX_LIGHT_RADIUS);
1097 this->flags_ = flags; 1111 this->flags_ = flags;
1098 this->move_block = move_block & ~move_allow; 1112 this->move_block = move_block & ~move_allow;
1099 this->move_on = move_on; 1113 this->move_on = move_on;
1100 this->move_off = move_off; 1114 this->move_off = move_off;
1101 this->move_slow = move_slow; 1115 this->move_slow = move_slow;
1116 this->volume_ = (volume + 1023) / 1024;
1117 this->items_ = upos_min (items, 65535); // assume nrof <= 2**31
1102 1118
1103 /* At this point, we have a floor face (if there is a floor), 1119 /* At this point, we have a floor face (if there is a floor),
1104 * and the floor is set - we are not going to touch it at 1120 * and the floor is set - we are not going to touch it at
1105 * this point. 1121 * this point.
1106 * middle contains the highest visibility face. 1122 * middle contains the highest visibility face.
… …
1172 faces_obj [1] = middle; 1188 faces_obj [1] = middle;
1173 faces_obj [2] = floor; 1189 faces_obj [2] = floor;
1174#endif 1190#endif
1175} 1191}
1176 1192
1177uint64
1178mapspace::volume () const
1179{
1180 uint64 vol = 0;
1181
1182 for (object *op = top; op && !op->flag [FLAG_NO_PICK]; op = op->below)
1183 vol += op->volume ();
1184
1185 return vol;
1186}
1187
1188maptile * 1193maptile *
1189maptile::tile_available (int dir, bool load) 1194maptile::tile_available (int dir, bool load)
1190{ 1195{
1191 if (tile_path[dir]) 1196 if (tile_path[dir])
1192 { 1197 {
… …
1531 int dx, dy; 1536 int dx, dy;
1532 1537
1533 return adjacent_map (op1->map, op2->map, &dx, &dy); 1538 return adjacent_map (op1->map, op2->map, &dx, &dy);
1534} 1539}
1535 1540
1541//-GPL
1542
1536object * 1543object *
1537maptile::insert (object *op, int x, int y, object *originator, int flags) 1544maptile::insert (object *op, int x, int y, object *originator, int flags)
1538{ 1545{
1539 return insert_ob_in_map_at (op, this, originator, flags, x, y); 1546 return insert_ob_in_map_at (op, this, originator, flags, x, y);
1540} 1547}
… …
1551 if (default_region) 1558 if (default_region)
1552 return default_region; 1559 return default_region;
1553 1560
1554 return ::region::default_region (); 1561 return ::region::default_region ();
1555} 1562}
1563
1564//+GPL
1556 1565
1557/* picks a random object from a style map. 1566/* picks a random object from a style map.
1558 */ 1567 */
1559object * 1568object *
1560maptile::pick_random_object (rand_gen &gen) const 1569maptile::pick_random_object (rand_gen &gen) const
… …
1573 if (pick && pick->is_head ()) 1582 if (pick && pick->is_head ())
1574 return pick->head_ (); 1583 return pick->head_ ();
1575 } 1584 }
1576 1585
1577 // instead of crashing in the unlikely(?) case, try to return *something* 1586 // instead of crashing in the unlikely(?) case, try to return *something*
1578 return archetype::find ("bug"); 1587 return archetype::find (shstr_bug);
1579} 1588}
1589
1590//-GPL
1580 1591
1581void 1592void
1582maptile::play_sound (faceidx sound, int x, int y) const 1593maptile::play_sound (faceidx sound, int x, int y) const
1583{ 1594{
1584 if (!sound) 1595 if (!sound)

Diff Legend

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