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.171 by root, Sun Nov 8 16:13:45 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;
… …
230 * into inventory, but just links them. What this does is go through 223 * into inventory, but just links them. What this does is go through
231 * and insert them properly. 224 * and insert them properly.
232 * The object 'container' is the object that contains the inventory. 225 * The object 'container' is the object that contains the inventory.
233 * This is needed so that we can update the containers weight. 226 * This is needed so that we can update the containers weight.
234 */ 227 */
235void 228static void
236fix_container (object *container) 229fix_container (object *container)
237{ 230{
238 object *tmp = container->inv, *next; 231 object *tmp = container->inv, *next;
239 232
240 container->inv = 0; 233 container->inv = 0;
… …
251 // go through and calculate what all the containers are carrying. 244 // go through and calculate what all the containers are carrying.
252 //TODO: remove 245 //TODO: remove
253 container->update_weight (); 246 container->update_weight ();
254} 247}
255 248
249//-GPL
250
256void 251void
257maptile::set_object_flag (int flag, int value) 252maptile::set_object_flag (int flag, int value)
258{ 253{
259 if (!spaces) 254 if (!spaces)
260 return; 255 return;
… …
274 269
275 for (mapspace *ms = spaces + size (); ms-- > spaces; ) 270 for (mapspace *ms = spaces + size (); ms-- > spaces; )
276 for (object *tmp = ms->bot; tmp; tmp = tmp->above) 271 for (object *tmp = ms->bot; tmp; tmp = tmp->above)
277 INVOKE_OBJECT (RESET, tmp); 272 INVOKE_OBJECT (RESET, tmp);
278} 273}
274
275//+GPL
279 276
280/* link_multipart_objects go through all the objects on the map looking 277/* 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 278 * 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 279 * info we have, they only have the head (as would be expected when
283 * they are saved). 280 * they are saved).
… …
310 else 307 else
311 op = op->above; 308 op = op->above;
312 } 309 }
313 } 310 }
314} 311}
312
313//-GPL
315 314
316/* 315/*
317 * Loads (ands parses) the objects into a given map from the specified 316 * Loads (ands parses) the objects into a given map from the specified
318 * file pointer. 317 * file pointer.
319 */ 318 */
… …
450 */ 449 */
451 width = 16; 450 width = 16;
452 height = 16; 451 height = 16;
453 timeout = 300; 452 timeout = 300;
454 max_nrof = 1000; // 1000 items of anything 453 max_nrof = 1000; // 1000 items of anything
454 max_items = 25;
455 max_volume = 2000000; // 2m³ 455 max_volume = 2000000; // 2m³
456} 456}
457 457
458maptile::maptile (int w, int h) 458maptile::maptile (int w, int h)
459{ 459{
… …
480 if (spaces) 480 if (spaces)
481 return; 481 return;
482 482
483 spaces = salloc0<mapspace> (size ()); 483 spaces = salloc0<mapspace> (size ());
484} 484}
485
486//+GPL
485 487
486/* Takes a string from a map definition and outputs a pointer to the array of shopitems 488/* 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 489 * corresponding to that string. Memory is allocated for this, it must be freed
488 * at a later date. 490 * at a later date.
489 * Called by parse_map_headers below. 491 * Called by parse_map_headers below.
… …
592 } 594 }
593 595
594 return buf; 596 return buf;
595} 597}
596 598
599//-GPL
600
597/* This loads the header information of the map. The header 601/* This loads the header information of the map. The header
598 * contains things like difficulty, size, timeout, etc. 602 * contains things like difficulty, size, timeout, etc.
599 * this used to be stored in the map object, but with the 603 * this used to be stored in the map object, but with the
600 * addition of tiling, fields beyond that easily named in an 604 * addition of tiling, fields beyond that easily named in an
601 * object structure were needed, so it just made sense to 605 * object structure were needed, so it just made sense to
… …
692 } 696 }
693 697
694 abort (); 698 abort ();
695} 699}
696 700
701//+GPL
702
697/****************************************************************************** 703/******************************************************************************
698 * This is the start of unique map handling code 704 * This is the start of unique map handling code
699 *****************************************************************************/ 705 *****************************************************************************/
700 706
701/* This goes through the maptile and removed any unique items on the map. */ 707/* This goes through the maptile and removed any unique items on the map. */
… …
717 723
718 op = above; 724 op = above;
719 } 725 }
720 } 726 }
721} 727}
728
729//-GPL
722 730
723bool 731bool
724maptile::_save_header (object_freezer &freezer) 732maptile::_save_header (object_freezer &freezer)
725{ 733{
726#define MAP_OUT(k) freezer.put (KW_ ## k, k) 734#define MAP_OUT(k) freezer.put (KW_ ## k, k)
… …
783 if (!_save_header (freezer)) 791 if (!_save_header (freezer))
784 return false; 792 return false;
785 793
786 return freezer.save (path); 794 return freezer.save (path);
787} 795}
796
797//+GPL
788 798
789/* 799/*
790 * Remove and free all objects in the given map. 800 * Remove and free all objects in the given map.
791 */ 801 */
792void 802void
… …
1018 */ 1028 */
1019void 1029void
1020mapspace::update_ () 1030mapspace::update_ ()
1021{ 1031{
1022 object *last = 0; 1032 object *last = 0;
1023 uint8 flags = P_UPTODATE, anywhere = 0; 1033 uint8 flags = P_UPTODATE;
1024 sint8 light = 0; 1034 sint8 light = 0;
1025 MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0; 1035 MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0;
1036 uint64_t volume = 0;
1037 uint32_t nrof = 0;
1038 object *anywhere = 0;
1026 1039
1027 //object *middle = 0; 1040 //object *middle = 0;
1028 //object *top = 0; 1041 //object *top = 0;
1029 //object *floor = 0; 1042 //object *floor = 0;
1030 // this seems to generate better code than using locals, above 1043 // this seems to generate better code than using locals, above
1031 object *&top = faces_obj[0] = 0; 1044 object *&top = faces_obj[0] = 0;
1032 object *&middle = faces_obj[1] = 0; 1045 object *&middle = faces_obj[1] = 0;
1033 object *&floor = faces_obj[2] = 0; 1046 object *&floor = faces_obj[2] = 0;
1047
1048 object::flags_t allflags; // all flags of all objects or'ed together
1034 1049
1035 for (object *tmp = bot; tmp; last = tmp, tmp = tmp->above) 1050 for (object *tmp = bot; tmp; last = tmp, tmp = tmp->above)
1036 { 1051 {
1037 // Lights are additive, up to MAX_LIGHT_RADIUS, see los.C) 1052 // Lights are additive, up to MAX_LIGHT_RADIUS, see los.C)
1038 light += tmp->glow_radius; 1053 light += tmp->glow_radius;
… …
1043 * 3 times each time the player moves, because many of the 1058 * 3 times each time the player moves, because many of the
1044 * functions the move_player calls eventualy call this. 1059 * functions the move_player calls eventualy call this.
1045 * 1060 *
1046 * Always put the player down for drawing. 1061 * Always put the player down for drawing.
1047 */ 1062 */
1048 if (!tmp->invisible) 1063 if (expect_true (!tmp->invisible))
1049 { 1064 {
1050 if ((tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER))) 1065 if (tmp->type == PLAYER || tmp->flag [FLAG_MONSTER])
1051 top = tmp; 1066 top = tmp;
1052 else if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1067 else
1053 { 1068 {
1069 if (expect_false (tmp->flag [FLAG_IS_FLOOR]))
1070 {
1054 /* If we got a floor, that means middle and top were below it, 1071 /* If we got a floor, that means middle and top were below it,
1055 * so should not be visible, so we clear them. 1072 * so should not be visible, so we clear them.
1056 */ 1073 */
1057 middle = 0; 1074 middle = 0;
1058 top = 0; 1075 top = 0;
1059 floor = tmp; 1076 floor = tmp;
1077 volume = 0;
1078 nrof = 0;
1079 }
1080 else
1081 {
1082 if (expect_true (!tmp->flag [FLAG_NO_PICK]))
1083 {
1084 ++nrof;
1085 volume += tmp->volume ();
1086 }
1087
1088 /* Flag anywhere have high priority */
1089 if (expect_false (tmp->flag [FLAG_SEE_ANYWHERE]))
1090 anywhere = tmp;
1091 /* Find the highest visible face around. If equal
1092 * visibilities, we still want the one nearer to the
1093 * top
1094 */
1095 else if (!middle || (::faces [tmp->face].visibility > ::faces [middle->face].visibility))
1096 middle = tmp;
1097 }
1060 } 1098 }
1061 /* Flag anywhere have high priority */
1062 else if (QUERY_FLAG (tmp, FLAG_SEE_ANYWHERE))
1063 {
1064 middle = tmp;
1065 anywhere = 1;
1066 }
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 } 1099 }
1081 1100
1082 move_slow |= tmp->move_slow; 1101 move_slow |= tmp->move_slow;
1083 move_block |= tmp->move_block; 1102 move_block |= tmp->move_block;
1084 move_on |= tmp->move_on; 1103 move_on |= tmp->move_on;
1085 move_off |= tmp->move_off; 1104 move_off |= tmp->move_off;
1086 move_allow |= tmp->move_allow; 1105 move_allow |= tmp->move_allow;
1087 1106
1088 if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW)) flags |= P_BLOCKSVIEW; 1107 allflags |= tmp->flag;
1089 if (QUERY_FLAG (tmp, FLAG_NO_MAGIC)) flags |= P_NO_MAGIC; 1108
1090 if (tmp->type == PLAYER) flags |= P_PLAYER; 1109 if (tmp->type == PLAYER) flags |= P_PLAYER;
1091 if (tmp->type == SAFE_GROUND) flags |= P_SAFE; 1110 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 } 1111 }
1112
1113 // FLAG_SEE_ANYWHERE takes precedence
1114 if (anywhere)
1115 middle = anywhere;
1116
1117 // ORing all flags together and checking them here is much faster
1118 if (allflags [FLAG_BLOCKSVIEW]) flags |= P_BLOCKSVIEW;
1119 if (allflags [FLAG_NO_MAGIC] ) flags |= P_NO_MAGIC;
1120 if (allflags [FLAG_ALIVE] ) flags |= P_IS_ALIVE;
1121 if (allflags [FLAG_DAMNED] ) flags |= P_NO_CLERIC;
1095 1122
1096 this->light = min (light, MAX_LIGHT_RADIUS); 1123 this->light = min (light, MAX_LIGHT_RADIUS);
1097 this->flags_ = flags; 1124 this->flags_ = flags;
1098 this->move_block = move_block & ~move_allow; 1125 this->move_block = move_block & ~move_allow;
1099 this->move_on = move_on; 1126 this->move_on = move_on;
1100 this->move_off = move_off; 1127 this->move_off = move_off;
1101 this->move_slow = move_slow; 1128 this->move_slow = move_slow;
1129 this->volume_ = volume / 1024;
1130 this->nrof_ = upos_min (nrof, 65535); // assume nrof <= 2**31
1102 1131
1103 /* At this point, we have a floor face (if there is a floor), 1132 /* 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 1133 * and the floor is set - we are not going to touch it at
1105 * this point. 1134 * this point.
1106 * middle contains the highest visibility face. 1135 * middle contains the highest visibility face.
… …
1172 faces_obj [1] = middle; 1201 faces_obj [1] = middle;
1173 faces_obj [2] = floor; 1202 faces_obj [2] = floor;
1174#endif 1203#endif
1175} 1204}
1176 1205
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 * 1206maptile *
1189maptile::tile_available (int dir, bool load) 1207maptile::tile_available (int dir, bool load)
1190{ 1208{
1191 if (tile_path[dir]) 1209 if (tile_path[dir])
1192 { 1210 {
… …
1531 int dx, dy; 1549 int dx, dy;
1532 1550
1533 return adjacent_map (op1->map, op2->map, &dx, &dy); 1551 return adjacent_map (op1->map, op2->map, &dx, &dy);
1534} 1552}
1535 1553
1554//-GPL
1555
1536object * 1556object *
1537maptile::insert (object *op, int x, int y, object *originator, int flags) 1557maptile::insert (object *op, int x, int y, object *originator, int flags)
1538{ 1558{
1539 return insert_ob_in_map_at (op, this, originator, flags, x, y); 1559 return insert_ob_in_map_at (op, this, originator, flags, x, y);
1540} 1560}
… …
1551 if (default_region) 1571 if (default_region)
1552 return default_region; 1572 return default_region;
1553 1573
1554 return ::region::default_region (); 1574 return ::region::default_region ();
1555} 1575}
1576
1577//+GPL
1556 1578
1557/* picks a random object from a style map. 1579/* picks a random object from a style map.
1558 */ 1580 */
1559object * 1581object *
1560maptile::pick_random_object (rand_gen &gen) const 1582maptile::pick_random_object (rand_gen &gen) const
… …
1573 if (pick && pick->is_head ()) 1595 if (pick && pick->is_head ())
1574 return pick->head_ (); 1596 return pick->head_ ();
1575 } 1597 }
1576 1598
1577 // instead of crashing in the unlikely(?) case, try to return *something* 1599 // instead of crashing in the unlikely(?) case, try to return *something*
1578 return archetype::find ("bug"); 1600 return archetype::find (shstr_bug);
1579} 1601}
1602
1603//-GPL
1580 1604
1581void 1605void
1582maptile::play_sound (faceidx sound, int x, int y) const 1606maptile::play_sound (faceidx sound, int x, int y) const
1583{ 1607{
1584 if (!sound) 1608 if (!sound)

Diff Legend

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