1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
#pragma once
#include <set>
#include <memory> // unique_ptr
#include <vector>
#include "cloud.h"
#include "coord.h"
#include "fprop.h"
#include "map-cell.h"
#include "mapmark.h"
#include "monster.h"
#include "shopping.h"
#include "trap-def.h"
using std::vector;
typedef FixedArray<short, GXM, GYM> grid_heightmap;
typedef set<string> string_set;
struct vault_placement;
typedef vector<unique_ptr<vault_placement>> vault_placement_refv;
typedef FixedArray< map_cell, GXM, GYM > MapKnowledge;
struct crawl_environment
{
colour_t rock_colour;
colour_t floor_colour;
FixedVector< item_def, MAX_ITEMS > item; // item list
FixedVector< monster, MAX_MONSTERS+2 > mons; // monster list, plus anon
// Highest index into mons that might currently contain a real monster.
// This is incremented by 1 whenever get_free_monster() is called and
// reduced to the current highest index whenever clear_monster_flags() is
// called each turn.
//
// This is used only as a small optimisation for monster_iterator and is
// completely safe if it's an overestimate - just not an underestimate.
int max_mon_index;
feature_grid grid; // terrain grid
FixedArray<terrain_property_t, GXM, GYM> pgrid; // terrain properties
FixedArray< unsigned short, GXM, GYM > mgrid; // monster grid
FixedArray< int, GXM, GYM > igrid; // item grid
FixedArray< unsigned short, GXM, GYM > grid_colours; // colour overrides
map_mask level_map_mask;
map_mask level_map_ids;
string_set level_uniq_maps;
string_set level_uniq_map_tags;
string_set level_layout_types;
// copied from branch_uniq_map_tags, copied back again after level gen
// (if level is vetoed we need to reset to the original)
string_set branch_uniq_map_tags;
string level_build_method;
vault_placement_refv level_vaults;
unique_ptr<grid_heightmap> heightmap;
map_bitmask map_seen;
// Player-remembered terrain and LOS
MapKnowledge map_knowledge;
// Forgotten map knowledge (X^F)
unique_ptr<MapKnowledge> map_forgotten;
set<coord_def> visible;
vector<coord_def> travel_trail;
map<coord_def, cloud_struct> cloud;
map<coord_def, shop_struct> shop; // shop list
map<coord_def, trap_def> trap; // trap list
FixedVector< monster_type, MAX_MONS_ALLOC > mons_alloc;
map_markers markers;
// Place to associate arbitrary data with a particular level.
// Sort of like player::attribute
CrawlHashTable properties;
// Time when level was saved (hence we write out you.elapsed_time
// (but load it back to env.elapsed_time); used during level load
int elapsed_time;
// Which point did the player leave the level from?
coord_def old_player_pos;
// Number of turns the player has spent on this level.
int turns_on_level;
// Index into the delayed actions array.
unsigned int dactions_done;
coord_def sanctuary_pos;
coord_def orb_pos;
int sanctuary_time;
int forest_awoken_until;
bool forest_is_hostile;
int density;
int absdepth0;
// Remaining fields not marshalled:
// Volatile level flags, not saved.
uint32_t level_state;
// Mapping mid->mindex until the transition is finished.
map<mid_t, unsigned short> mid_cache;
// Copies of monsters cached so they can be looked up during a final_effect
// that will be processed after their death. Used mainly to assign proper
// blame for dead exploders. (Cleared every time final_effects is)
vector<monster> final_effect_monster_cache;
// A stack that accumulates subvaults being placed. A failure may pop a
// part of the stack before retrying.
vector<string> new_subvault_names, new_subvault_tags;
// A set of the unique subvaults being placed. These are considered used
// for the purposes of placing additional subvaults.
string_set new_used_subvault_names;
// A set of uniq_, luniq_ or buniq_ map tags being placed.
string_set new_used_subvault_tags;
// Vault currently being placed, for crash dump purposes.
string placing_vault;
};
#ifdef DEBUG_GLOBALS
#define env (*real_env)
#endif
extern struct crawl_environment env;
/**
* Range proxy to iterate over only "real" env.mons slots, skipping anon slots.
*
* Use as the range expression in a for loop:
* for (auto &mons : menv_real)
*/
static const struct menv_range_proxy
{
menv_range_proxy() {}
monster *begin() const { return &env.mons[0]; }
monster *end() const { return &env.mons[MAX_MONSTERS]; }
} menv_real;
/**
* Look up a property of a coordinate in the player's map_knowledge grid.
*
* @tparam T The type of the property being queried.
* @tparam F A callable type taking const map_cell& and returning T.
*
* @param default_value The value to return if pos is out of bounds.
* @param pos The position to query.
* @param f A function that will be passed a map_cell& representing what the
* player knows about the map at the given position. Will only be called
* if pos is in-bounds.
*
* @return Either the default value, or the result of f(env.map_knowledge(pos)).
*/
template<typename T, typename F>
T query_map_knowledge(T default_value, const coord_def& pos, F f)
{
if (!map_bounds(pos))
return default_value;
return f(env.map_knowledge(pos));
}
|
