Split env.tile_* fields into a separate global
authorAidan Holm <aidanholm@gmail.com>
Tue, 20 Oct 2020 13:43:10 +0000 (21:43 +0800)
committerAidan Holm <aidanholm@gmail.com>
Thu, 22 Oct 2020 12:12:51 +0000 (20:12 +0800)
Currently a lot of widely used objects are grouped together into the
env global. While env thankfully doesn't have any behaviour itself,
this has the unpleasant effect of obscuring the actual dependencies
between objects: everything depends on env because everything is in env,
and since it's already widely used, it can easily accrete more stuff,
causing a snowballing effect.

This commit breaks a subset of tile drawing related fields into their
own separate global "tile env" object. The presence of this global isn't
great, but it's much better than lumping everything together: env.h is
included 119 times, while the newly-added tile-env.h is now included
only 23 times: around a sixth of the users. This not only clarifies the
dependencies involved, but will also aid compilation time: if this file
needs to be changed, recompilation will be six times faster.

Of course, ideally none of the functions involved need to pass around
data in global mutable state. With smaller globals with a smaller number
of users, analyzing the structure of data transfer is now tractable,
and hopefully this "tile env" global can be pulled apart and refactored
further.

25 files changed:
crawl-ref/source/abyss.cc
crawl-ref/source/describe.cc
crawl-ref/source/dungeon.cc
crawl-ref/source/env.h
crawl-ref/source/fake-main.hpp
crawl-ref/source/files.cc
crawl-ref/source/invent.cc
crawl-ref/source/l-dgntil.cc
crawl-ref/source/main.cc
crawl-ref/source/mapdef.cc
crawl-ref/source/menu.cc
crawl-ref/source/mon-cast.cc
crawl-ref/source/mon-util.cc
crawl-ref/source/player.cc
crawl-ref/source/spl-goditem.cc
crawl-ref/source/tags.cc
crawl-ref/source/terrain.cc
crawl-ref/source/tile-env.h [new file with mode: 0644]
crawl-ref/source/tilepick.cc
crawl-ref/source/tilereg-dgn.cc
crawl-ref/source/tilereg-inv.cc
crawl-ref/source/tilereg-mon.cc
crawl-ref/source/tileview.cc
crawl-ref/source/view.cc
crawl-ref/source/wiz-dgn.cc

index 7752a15..7acd218 100644 (file)
@@ -24,6 +24,7 @@
 #include "delay.h"
 #include "dgn-overview.h"
 #include "dgn-proclayouts.h"
+#include "tile-env.h"
 #include "files.h"
 #include "god-companions.h" // hep stuff
 #include "god-passive.h" // passive_t::slow_abyss
@@ -724,9 +725,9 @@ static void _abyss_wipe_square_at(coord_def p, bool saveMonsters=false)
     env.pgrid(p)        = terrain_property_t{};
     env.grid_colours(p) = 0;
 #ifdef USE_TILE
-    env.tile_bk_fg(p)   = 0;
-    env.tile_bk_bg(p)   = 0;
-    env.tile_bk_cloud(p)= 0;
+    tile_env.bk_fg(p)   = 0;
+    tile_env.bk_bg(p)   = 0;
+    tile_env.bk_cloud(p)= 0;
 #endif
     tile_clear_flavour(p);
     tile_init_flavour(p);
@@ -1965,13 +1966,13 @@ static void _corrupt_square_flavor(const corrupt_env &cenv, const coord_def &c)
     {
         tileidx_t idx = tile_dngn_coloured(TILE_WALL_ABYSS,
                                            cenv.rock_colour);
-        env.tile_flv(c).wall = idx + random2(tile_dngn_count(idx));
+        tile_env.flv(c).wall = idx + random2(tile_dngn_count(idx));
     }
     else if (feat == DNGN_FLOOR)
     {
         tileidx_t idx = tile_dngn_coloured(TILE_FLOOR_NERVES,
                                            floor);
-        env.tile_flv(c).floor = idx + random2(tile_dngn_count(idx));
+        tile_env.flv(c).floor = idx + random2(tile_dngn_count(idx));
     }
     else if (feat == DNGN_STONE_WALL)
     {
@@ -1979,13 +1980,13 @@ static void _corrupt_square_flavor(const corrupt_env &cenv, const coord_def &c)
         // in _is_grid_corruptible
         tileidx_t idx = tile_dngn_coloured(TILE_DNGN_STONE_WALL,
                                            cenv.rock_colour);
-        env.tile_flv(c).wall = idx + random2(tile_dngn_count(idx));
+        tile_env.flv(c).wall = idx + random2(tile_dngn_count(idx));
     }
     else if (feat == DNGN_METAL_WALL)
     {
         tileidx_t idx = tile_dngn_coloured(TILE_DNGN_METAL_WALL,
                                            cenv.rock_colour);
-        env.tile_flv(c).wall = idx + random2(tile_dngn_count(idx));
+        tile_env.flv(c).wall = idx + random2(tile_dngn_count(idx));
     }
     else if (feat == DNGN_TREE)
     {
@@ -1995,7 +1996,7 @@ static void _corrupt_square_flavor(const corrupt_env &cenv, const coord_def &c)
         if (idx == TILE_DNGN_TREE)
             idx = tile_dngn_coloured(TILE_DNGN_TREE, DARKGREY);
         env.grid_colours(c) = DARKGREY;
-        env.tile_flv(c).wall = idx + random2(tile_dngn_count(idx));
+        tile_env.flv(c).wall = idx + random2(tile_dngn_count(idx));
     }
 }
 
index 988005c..5f5d2f1 100644 (file)
@@ -33,6 +33,7 @@
 #include "directn.h"
 #include "english.h"
 #include "env.h"
+#include "tile-env.h"
 #include "evoke.h"
 #include "fight.h"
 #include "ghost.h"
@@ -2420,7 +2421,7 @@ void describe_feature_wide(const coord_def& pos)
         f.body = trimmed_string(inf.body.str());
 #ifdef USE_TILE
         tileidx_t tile = tileidx_feature(pos);
-        apply_variations(env.tile_flv(pos), &tile, pos);
+        apply_variations(tile_env.flv(pos), &tile, pos);
         f.tile = tile_def(tile);
 #endif
         f.quote = trimmed_string(inf.quote);
index 8f4e2eb..cd79e51 100644 (file)
@@ -34,6 +34,7 @@
 #include "dgn-overview.h"
 #include "dgn-shoals.h"
 #include "end.h"
+#include "tile-env.h"
 #include "files.h"
 #include "flood-find.h"
 #include "ghost.h"
@@ -705,8 +706,8 @@ void dgn_set_grid_colour_at(const coord_def &c, int colour)
 static void _set_grd(const coord_def &c, dungeon_feature_type feat)
 {
     // It might be good to clear some pgrid flags as well.
-    env.tile_flv(c).feat    = 0;
-    env.tile_flv(c).special = 0;
+    tile_env.flv(c).feat    = 0;
+    tile_env.flv(c).special = 0;
     env.grid_colours(c) = 0;
     env.grid(c) = feat;
 }
@@ -1153,10 +1154,10 @@ dgn_register_place(const vault_placement &place, bool register_vault)
         tileidx_t rock;
         if (tile_dngn_index(place.map.rock_tile.c_str(), &rock))
         {
-            env.tile_default.wall_idx =
+            tile_env.default_flavour.wall_idx =
                 store_tilename_get_index(place.map.rock_tile);
 
-            env.tile_default.wall = rock;
+            tile_env.default_flavour.wall = rock;
         }
     }
 
@@ -1165,10 +1166,10 @@ dgn_register_place(const vault_placement &place, bool register_vault)
         tileidx_t floor;
         if (tile_dngn_index(place.map.floor_tile.c_str(), &floor))
         {
-            env.tile_default.floor_idx =
+            tile_env.default_flavour.floor_idx =
                 store_tilename_get_index(place.map.floor_tile);
 
-            env.tile_default.floor = floor;
+            tile_env.default_flavour.floor = floor;
         }
     }
 
@@ -1357,7 +1358,7 @@ void dgn_reset_level(bool enable_random_maps)
     // Clear custom tile settings from vaults
     tile_init_default_flavour();
     tile_clear_flavour();
-    env.tile_names.clear();
+    tile_env.names.clear();
 
     update_portal_entrances();
 }
@@ -5300,7 +5301,7 @@ void dgn_replace_area(const coord_def& p1, const coord_def& p2,
                 env.map_knowledge(*ri).set_feature(feature, 0,
                                                    get_trap_type(*ri));
 #ifdef USE_TILE
-                env.tile_bk_bg(*ri) = feature;
+                tile_env.bk_bg(*ri) = feature;
 #endif
             }
         }
index a379b0f..6d00ba1 100644 (file)
@@ -58,22 +58,6 @@ struct crawl_environment
 
     vector<coord_def>                        travel_trail;
 
-    // indexed by grid coords
-#ifdef USE_TILE // TODO: separate out this stuff from crawl_environment
-    FixedArray<tile_fg_store, GXM, GYM> tile_bk_fg;
-    FixedArray<tileidx_t, GXM, GYM> tile_bk_bg;
-    FixedArray<tileidx_t, GXM, GYM> tile_bk_cloud;
-#endif
-    FixedArray<tile_flavour, GXM, GYM> tile_flv;
-    // indexed by (show-1) coords
-#ifdef USE_TILE // TODO: separate out this stuff from crawl_environment
-    FixedArray<tileidx_t, ENV_SHOW_DIAMETER, ENV_SHOW_DIAMETER> tile_fg;
-    FixedArray<tileidx_t, ENV_SHOW_DIAMETER, ENV_SHOW_DIAMETER> tile_bg;
-    FixedArray<tileidx_t, ENV_SHOW_DIAMETER, ENV_SHOW_DIAMETER> tile_cloud;
-#endif
-    tile_flavour tile_default;
-    vector<string> tile_names;
-
     map<coord_def, cloud_struct> cloud;
 
     map<coord_def, shop_struct> shop; // shop list
index 07c6d78..f16902a 100644 (file)
@@ -10,6 +10,7 @@
 #include "externs.h"
 #include "directn.h"
 #include "env.h"
+#include "tile-env.h"
 #include "colour.h"
 #include "dungeon.h"
 #include "mon-abil.h"
@@ -30,6 +31,7 @@
 CLua clua(true);
 CLua dlua(false);      // Lua interpreter for the dungeon builder.
 crawl_environment env; // Requires dlua.
+crawl_tile_environment tile_env; // Requires dlua.
 player you;
 game_state crawl_state;
 
index 87cef84..5e608d4 100644 (file)
@@ -48,6 +48,7 @@
 #include "directn.h"
 #include "dungeon.h"
 #include "end.h"
+#include "tile-env.h"
 #include "errors.h"
 #include "player-save-info.h"
 #include "fineff.h"
@@ -1602,7 +1603,7 @@ bool generate_level(const level_id &l)
     env.turns_on_level = -1;
     tile_init_default_flavour();
     tile_clear_flavour();
-    env.tile_names.clear();
+    tile_env.names.clear();
     _clear_env_map();
 
     // finally -- everything is set up, call the builder.
index 6a5a3e1..0725c01 100644 (file)
@@ -19,6 +19,7 @@
 #include "command.h"
 #include "describe.h"
 #include "env.h"
+#include "tile-env.h"
 #include "god-item.h"
 #include "god-passive.h"
 #include "initfile.h"
@@ -579,9 +580,9 @@ bool get_tiles_for_item(const item_def &item, vector<tile_def>& tileset, bool sh
         {
             ch = tileidx_feature(c);
             if (ch == TILE_FLOOR_NORMAL)
-                ch = env.tile_flv(c).floor;
+                ch = tile_env.flv(c).floor;
             else if (ch == TILE_WALL_NORMAL)
-                ch = env.tile_flv(c).wall;
+                ch = tile_env.flv(c).wall;
 
             tileset.emplace_back(ch);
         }
index e569eac..4236a22 100644 (file)
@@ -7,6 +7,7 @@
 
 #include "cluautil.h"
 #include "env.h"
+#include "tile-env.h"
 #include "mapdef.h"
 #include "stringutil.h"
 #include "rltiles/tiledef-dngn.h"
@@ -63,8 +64,8 @@ LUAFN(dgn_change_rock_tile)
         luaL_argerror(ls, 1, error.c_str());
         return 0;
     }
-    env.tile_default.wall     = rock;
-    env.tile_default.wall_idx =
+    tile_env.default_flavour.wall     = rock;
+    tile_env.default_flavour.wall_idx =
         store_tilename_get_index(tilename);
 
     PLUARET(string, tilename.c_str());
@@ -83,8 +84,8 @@ LUAFN(dgn_change_floor_tile)
         luaL_argerror(ls, 1, error.c_str());
         return 0;
     }
-    env.tile_default.floor     = floor;
-    env.tile_default.floor_idx =
+    tile_env.default_flavour.floor     = floor;
+    tile_env.default_flavour.floor_idx =
         store_tilename_get_index(tilename);
 
     PLUARET(string, tilename.c_str());
@@ -111,8 +112,8 @@ LUAFN(dgn_tile_feat_changed)
 
     if (lua_isnil(ls, 3))
     {
-        env.tile_flv(c).feat     = 0;
-        env.tile_flv(c).feat_idx = 0;
+        tile_env.flv(c).feat     = 0;
+        tile_env.flv(c).feat_idx = 0;
         return 0;
     }
 
@@ -127,8 +128,8 @@ LUAFN(dgn_tile_feat_changed)
         luaL_argerror(ls, 1, error.c_str());
         return 0;
     }
-    env.tile_flv(c).feat     = feat;
-    env.tile_flv(c).feat_idx =
+    tile_env.flv(c).feat     = feat;
+    tile_env.flv(c).feat_idx =
         store_tilename_get_index(tilename);
 
     return 0;
@@ -140,8 +141,8 @@ LUAFN(dgn_tile_floor_changed)
 
     if (lua_isnil(ls, 3))
     {
-        env.tile_flv(c).floor     = 0;
-        env.tile_flv(c).floor_idx = 0;
+        tile_env.flv(c).floor     = 0;
+        tile_env.flv(c).floor_idx = 0;
         return 0;
     }
 
@@ -156,8 +157,8 @@ LUAFN(dgn_tile_floor_changed)
         luaL_argerror(ls, 1, error.c_str());
         return 0;
     }
-    env.tile_flv(c).floor     = floor;
-    env.tile_flv(c).floor_idx =
+    tile_env.flv(c).floor     = floor;
+    tile_env.flv(c).floor_idx =
         store_tilename_get_index(tilename);
 
     return 0;
index bd5712e..cbae556 100644 (file)
@@ -64,6 +64,7 @@
 #include "dungeon.h"
 #include "end.h"
 #include "env.h"
+#include "tile-env.h"
 #include "errors.h"
 #include "evoke.h"
 #include "fight.h"
@@ -164,6 +165,7 @@ CLua clua(true);
 CLua dlua(false);      // Lua interpreter for the dungeon builder.
 #endif
 crawl_environment env; // Requires dlua.
+crawl_tile_environment tile_env;
 
 player you;
 
index f83cca8..340f067 100644 (file)
@@ -24,6 +24,7 @@
 #include "dgn-height.h"
 #include "dungeon.h"
 #include "end.h"
+#include "tile-env.h"
 #include "english.h"
 #include "files.h"
 #include "initfile.h"
@@ -189,15 +190,15 @@ int store_tilename_get_index(const string& tilename)
 
     // Increase index by 1 to distinguish between first entry and none.
     unsigned int i;
-    for (i = 0; i < env.tile_names.size(); ++i)
-        if (tilename == env.tile_names[i])
+    for (i = 0; i < tile_env.names.size(); ++i)
+        if (tilename == tile_env.names[i])
             return i+1;
 
 #ifdef DEBUG_TILE_NAMES
     mprf("adding %s on index %d (%d)", tilename.c_str(), i, i+1);
 #endif
     // If not found, add tile name to vector.
-    env.tile_names.push_back(tilename);
+    tile_env.names.push_back(tilename);
     return i+1;
 }
 
@@ -631,7 +632,7 @@ void map_lines::apply_grid_overlay(const coord_def &c, bool is_layout)
             string name = (*overlay)(x, y).floortile;
             if (!name.empty() && name != "none")
             {
-                env.tile_flv(gc).floor_idx =
+                tile_env.flv(gc).floor_idx =
                     store_tilename_get_index(name);
 
                 tileidx_t floor;
@@ -639,14 +640,14 @@ void map_lines::apply_grid_overlay(const coord_def &c, bool is_layout)
                 if (colour)
                     floor = tile_dngn_coloured(floor, colour);
                 int offset = random2(tile_dngn_count(floor));
-                env.tile_flv(gc).floor = floor + offset;
+                tile_env.flv(gc).floor = floor + offset;
                 has_floor = true;
             }
 
             name = (*overlay)(x, y).rocktile;
             if (!name.empty() && name != "none")
             {
-                env.tile_flv(gc).wall_idx =
+                tile_env.flv(gc).wall_idx =
                     store_tilename_get_index(name);
 
                 tileidx_t rock;
@@ -654,14 +655,14 @@ void map_lines::apply_grid_overlay(const coord_def &c, bool is_layout)
                 if (colour)
                     rock = tile_dngn_coloured(rock, colour);
                 int offset = random2(tile_dngn_count(rock));
-                env.tile_flv(gc).wall = rock + offset;
+                tile_env.flv(gc).wall = rock + offset;
                 has_rock = true;
             }
 
             name = (*overlay)(x, y).tile;
             if (!name.empty() && name != "none")
             {
-                env.tile_flv(gc).feat_idx =
+                tile_env.flv(gc).feat_idx =
                     store_tilename_get_index(name);
 
                 tileidx_t feat;
@@ -677,14 +678,14 @@ void map_lines::apply_grid_overlay(const coord_def &c, bool is_layout)
                     offset = random2(tile_dngn_count(feat));
 
                 if (!has_floor && env.grid(gc) == DNGN_FLOOR)
-                    env.tile_flv(gc).floor = feat + offset;
+                    tile_env.flv(gc).floor = feat + offset;
                 else if (!has_rock && env.grid(gc) == DNGN_ROCK_WALL)
-                    env.tile_flv(gc).wall = feat + offset;
+                    tile_env.flv(gc).wall = feat + offset;
                 else
                 {
                     if ((*overlay)(x, y).no_random)
                         offset = 0;
-                    env.tile_flv(gc).feat = feat + offset;
+                    tile_env.flv(gc).feat = feat + offset;
                 }
             }
         }
index 804a947..63a5745 100644 (file)
@@ -15,6 +15,7 @@
 #include "command.h"
 #include "coord.h"
 #include "env.h"
+#include "tile-env.h"
 #include "hints.h"
 #include "invent.h"
 #include "libutil.h"
@@ -1536,9 +1537,9 @@ bool MonsterMenuEntry::get_tiles(vector<tile_def>& tileset) const
     {
         ch = tileidx_feature(c);
         if (ch == TILE_FLOOR_NORMAL)
-            ch = env.tile_flv(c).floor;
+            ch = tile_env.flv(c).floor;
         else if (ch == TILE_WALL_NORMAL)
-            ch = env.tile_flv(c).wall;
+            ch = tile_env.flv(c).wall;
     }
 
     tileset.emplace_back(ch);
index 3bc4f75..1b4ba78 100644 (file)
@@ -26,6 +26,7 @@
 #include "directn.h"
 #include "english.h"
 #include "env.h"
+#include "tile-env.h"
 #include "evoke.h"
 #include "exclude.h"
 #include "fight.h"
@@ -2439,7 +2440,7 @@ static bool _seal_doors_and_stairs(const monster* warden,
                     {
                         env.map_knowledge(dc).set_feature(DNGN_CLOSED_DOOR);
 #ifdef USE_TILE
-                        env.tile_bk_bg(dc) = TILE_DNGN_CLOSED_DOOR;
+                        tile_env.bk_bg(dc) = TILE_DNGN_CLOSED_DOOR;
 #endif
                     }
                 }
index 0e92403..70db9e3 100644 (file)
@@ -26,6 +26,7 @@
 #include "dungeon.h"
 #include "english.h"
 #include "env.h"
+#include "tile-env.h"
 #include "errors.h"
 #include "fight.h"
 #include "files.h"
@@ -1126,7 +1127,7 @@ void discover_mimic(const coord_def& pos)
 
 #ifdef USE_TILE
     tileidx_t tile = tileidx_feature(pos);
-    apply_variations(env.tile_flv(pos), &tile, pos);
+    apply_variations(tile_env.flv(pos), &tile, pos);
 #endif
 
     if (you.see_cell(pos))
index 894f9d8..1829a93 100644 (file)
@@ -32,6 +32,7 @@
 #include "directn.h"
 #include "english.h"
 #include "env.h"
+#include "tile-env.h"
 #include "errors.h"
 #include "exercise.h"
 #include "files.h"
@@ -7874,7 +7875,7 @@ void player_open_door(coord_def doorpos)
         {
             env.map_knowledge(dc).set_feature(env.grid(dc));
 #ifdef USE_TILE
-            env.tile_bk_bg(dc) = tileidx_feature_base(env.grid(dc));
+            tile_env.bk_bg(dc) = tileidx_feature_base(env.grid(dc));
 #endif
         }
 
@@ -8045,7 +8046,7 @@ void player_close_door(coord_def doorpos)
         {
             env.map_knowledge(dc).set_feature(env.grid(dc));
 #ifdef USE_TILE
-            env.tile_bk_bg(dc) = tileidx_feature_base(env.grid(dc));
+            tile_env.bk_bg(dc) = tileidx_feature_base(env.grid(dc));
 #endif
         }
 
index f137fe1..d26de69 100644 (file)
@@ -14,6 +14,7 @@
 #include "directn.h"
 #include "english.h"
 #include "env.h"
+#include "tile-env.h"
 #include "fight.h"
 #include "god-conduct.h"
 #include "god-passive.h"
@@ -911,16 +912,16 @@ static bool _do_imprison(int pow, const coord_def& where, bool zin)
 
                 // Make the walls silver.
                 env.grid_colours(*ai) = WHITE;
-                env.tile_flv(*ai).feat_idx =
+                tile_env.flv(*ai).feat_idx =
                         store_tilename_get_index("dngn_silver_wall");
-                env.tile_flv(*ai).feat = TILE_DNGN_SILVER_WALL;
+                tile_env.flv(*ai).feat = TILE_DNGN_SILVER_WALL;
                 if (env.map_knowledge(*ai).seen())
                 {
                     env.map_knowledge(*ai).set_feature(DNGN_METAL_WALL);
                     env.map_knowledge(*ai).clear_item();
 #ifdef USE_TILE
-                    env.tile_bk_bg(*ai) = TILE_DNGN_SILVER_WALL;
-                    env.tile_bk_fg(*ai) = 0;
+                    tile_env.bk_bg(*ai) = TILE_DNGN_SILVER_WALL;
+                    tile_env.bk_fg(*ai) = 0;
 #endif
                 }
             }
index 31ff097..c195abd 100644 (file)
@@ -45,6 +45,7 @@
 #include "dgn-overview.h"
 #include "dungeon.h"
 #include "end.h"
+#include "tile-env.h"
 #include "errors.h"
 #include "ghost.h"
 #include "god-abil.h" // just for the Ru sac penalty key
@@ -5953,8 +5954,8 @@ void _tag_construct_level_tiles(writer &th)
     // how many Y?
     marshallShort(th, GYM);
 
-    marshallShort(th, env.tile_names.size());
-    for (const string &name : env.tile_names)
+    marshallShort(th, tile_env.names.size());
+    for (const string &name : tile_env.names)
     {
         marshallString(th, name);
 #ifdef DEBUG_TILE_NAMES
@@ -5963,24 +5964,24 @@ void _tag_construct_level_tiles(writer &th)
     }
 
     // flavour
-    marshallShort(th, env.tile_default.wall_idx);
-    marshallShort(th, env.tile_default.floor_idx);
+    marshallShort(th, tile_env.default_flavour.wall_idx);
+    marshallShort(th, tile_env.default_flavour.floor_idx);
 
-    marshallShort(th, env.tile_default.wall);
-    marshallShort(th, env.tile_default.floor);
-    marshallShort(th, env.tile_default.special);
+    marshallShort(th, tile_env.default_flavour.wall);
+    marshallShort(th, tile_env.default_flavour.floor);
+    marshallShort(th, tile_env.default_flavour.special);
 
     for (int count_x = 0; count_x < GXM; count_x++)
         for (int count_y = 0; count_y < GYM; count_y++)
         {
-            marshallShort(th, env.tile_flv[count_x][count_y].wall_idx);
-            marshallShort(th, env.tile_flv[count_x][count_y].floor_idx);
-            marshallShort(th, env.tile_flv[count_x][count_y].feat_idx);
-
-            marshallShort(th, env.tile_flv[count_x][count_y].wall);
-            marshallShort(th, env.tile_flv[count_x][count_y].floor);
-            marshallShort(th, env.tile_flv[count_x][count_y].feat);
-            marshallShort(th, env.tile_flv[count_x][count_y].special);
+            marshallShort(th, tile_env.flv[count_x][count_y].wall_idx);
+            marshallShort(th, tile_env.flv[count_x][count_y].floor_idx);
+            marshallShort(th, tile_env.flv[count_x][count_y].feat_idx);
+
+            marshallShort(th, tile_env.flv[count_x][count_y].wall);
+            marshallShort(th, tile_env.flv[count_x][count_y].floor);
+            marshallShort(th, tile_env.flv[count_x][count_y].feat);
+            marshallShort(th, tile_env.flv[count_x][count_y].special);
         }
 
     marshallInt(th, TILE_WALL_MAX);
@@ -6952,13 +6953,13 @@ static void _debug_count_tiles()
     for (int i = 0; i < GXM; i++)
         for (int j = 0; j < GYM; j++)
         {
-            t = env.tile_bk_bg[i][j];
+            t = tile_env.bk_bg[i][j];
             if (!found.count(t))
                 cnt++, found[t] = true;
-            t = env.tile_bk_fg[i][j];
+            t = tile_env.bk_fg[i][j];
             if (!found.count(t))
                 cnt++, found[t] = true;
-            t = env.tile_bk_cloud[i][j];
+            t = tile_env.bk_cloud[i][j];
             if (!found.count(t))
                 cnt++, found[t] = true;
         }
@@ -6975,38 +6976,38 @@ void _tag_read_level_tiles(reader &th)
     // how many Y?
     const int gy = unmarshallShort(th);
 
-    env.tile_names.clear();
+    tile_env.names.clear();
     unsigned int num_tilenames = unmarshallShort(th);
     for (unsigned int i = 0; i < num_tilenames; ++i)
     {
 #ifdef DEBUG_TILE_NAMES
         string temp = unmarshallString(th);
         mprf("Reading tile_names[%d] = %s", i, temp.c_str());
-        env.tile_names.push_back(temp);
+        tile_env.names.push_back(temp);
 #else
-        env.tile_names.push_back(unmarshallString(th));
+        tile_env.names.push_back(unmarshallString(th));
 #endif
     }
 
     // flavour
-    env.tile_default.wall_idx  = unmarshallShort(th);
-    env.tile_default.floor_idx = unmarshallShort(th);
-    env.tile_default.wall      = unmarshallShort(th);
-    env.tile_default.floor     = unmarshallShort(th);
-    env.tile_default.special   = unmarshallShort(th);
+    tile_env.default_flavour.wall_idx  = unmarshallShort(th);
+    tile_env.default_flavour.floor_idx = unmarshallShort(th);
+    tile_env.default_flavour.wall      = unmarshallShort(th);
+    tile_env.default_flavour.floor     = unmarshallShort(th);
+    tile_env.default_flavour.special   = unmarshallShort(th);
 
     for (int x = 0; x < gx; x++)
         for (int y = 0; y < gy; y++)
         {
-            env.tile_flv[x][y].wall_idx  = unmarshallShort(th);
-            env.tile_flv[x][y].floor_idx = unmarshallShort(th);
-            env.tile_flv[x][y].feat_idx  = unmarshallShort(th);
+            tile_env.flv[x][y].wall_idx  = unmarshallShort(th);
+            tile_env.flv[x][y].floor_idx = unmarshallShort(th);
+            tile_env.flv[x][y].feat_idx  = unmarshallShort(th);
 
             // These get overwritten by _regenerate_tile_flavour
-            env.tile_flv[x][y].wall    = unmarshallShort(th);
-            env.tile_flv[x][y].floor   = unmarshallShort(th);
-            env.tile_flv[x][y].feat    = unmarshallShort(th);
-            env.tile_flv[x][y].special = unmarshallShort(th);
+            tile_env.flv[x][y].wall    = unmarshallShort(th);
+            tile_env.flv[x][y].floor   = unmarshallShort(th);
+            tile_env.flv[x][y].feat    = unmarshallShort(th);
+            tile_env.flv[x][y].special = unmarshallShort(th);
         }
 
     _debug_count_tiles();
@@ -7019,15 +7020,15 @@ void _tag_read_level_tiles(reader &th)
 
 static tileidx_t _get_tile_from_vector(const unsigned int idx)
 {
-    if (idx <= 0 || idx > env.tile_names.size())
+    if (idx <= 0 || idx > tile_env.names.size())
     {
 #ifdef DEBUG_TILE_NAMES
         mprf("Index out of bounds: idx = %d - 1, size(tile_names) = %d",
-            idx, env.tile_names.size());
+            idx, tile_env.names.size());
 #endif
         return 0;
     }
-    string tilename = env.tile_names[idx - 1];
+    string tilename = tile_env.names[idx - 1];
 
     tileidx_t tile;
     if (!tile_dngn_index(tilename.c_str(), &tile))
@@ -7050,16 +7051,16 @@ static void _regenerate_tile_flavour()
 {
     /* Remember the wall_idx and floor_idx; tile_init_default_flavour
        sets them to 0 */
-    tileidx_t default_wall_idx = env.tile_default.wall_idx;
-    tileidx_t default_floor_idx = env.tile_default.floor_idx;
+    tileidx_t default_wall_idx = tile_env.default_flavour.wall_idx;
+    tileidx_t default_floor_idx = tile_env.default_flavour.floor_idx;
     tile_init_default_flavour();
     if (default_wall_idx)
     {
         tileidx_t new_wall = _get_tile_from_vector(default_wall_idx);
         if (new_wall)
         {
-            env.tile_default.wall_idx = default_wall_idx;
-            env.tile_default.wall = new_wall;
+            tile_env.default_flavour.wall_idx = default_wall_idx;
+            tile_env.default_flavour.wall = new_wall;
         }
     }
     if (default_floor_idx)
@@ -7067,15 +7068,15 @@ static void _regenerate_tile_flavour()
         tileidx_t new_floor = _get_tile_from_vector(default_floor_idx);
         if (new_floor)
         {
-            env.tile_default.floor_idx = default_floor_idx;
-            env.tile_default.floor = new_floor;
+            tile_env.default_flavour.floor_idx = default_floor_idx;
+            tile_env.default_flavour.floor = new_floor;
         }
     }
 
     for (rectangle_iterator ri(coord_def(0, 0), coord_def(GXM-1, GYM-1));
          ri; ++ri)
     {
-        tile_flavour &flv = env.tile_flv(*ri);
+        tile_flavour &flv = tile_env.flv(*ri);
         flv.wall = 0;
         flv.floor = 0;
         flv.feat = 0;
index 45b4e04..5393ff1 100644 (file)
@@ -22,6 +22,7 @@
 #include "directn.h"
 #include "dungeon.h"
 #include "env.h"
+#include "tile-env.h"
 #include "fight.h"
 #include "feature.h"
 #include "fprop.h"
@@ -1103,11 +1104,11 @@ void dgn_move_entities_at(coord_def src, coord_def dst,
     env.pgrid(dst) = env.pgrid(src);
     env.grid_colours(dst) = env.grid_colours(src);
 #ifdef USE_TILE
-    env.tile_bk_fg(dst) = env.tile_bk_fg(src);
-    env.tile_bk_bg(dst) = env.tile_bk_bg(src);
-    env.tile_bk_cloud(dst) = env.tile_bk_cloud(src);
+    tile_env.bk_fg(dst) = tile_env.bk_fg(src);
+    tile_env.bk_bg(dst) = tile_env.bk_bg(src);
+    tile_env.bk_cloud(dst) = tile_env.bk_cloud(src);
 #endif
-    env.tile_flv(dst) = env.tile_flv(src);
+    tile_env.flv(dst) = tile_env.flv(src);
 
     // Move vault masks.
     env.level_map_mask(dst) = env.level_map_mask(src);
@@ -1258,8 +1259,8 @@ void dungeon_terrain_changed(const coord_def &pos,
 
         env.grid(pos) = nfeat;
         // Reset feature tile
-        env.tile_flv(pos).feat = 0;
-        env.tile_flv(pos).feat_idx = 0;
+        tile_env.flv(pos).feat = 0;
+        tile_env.flv(pos).feat_idx = 0;
 
         if (is_notable_terrain(nfeat) && you.see_cell(pos))
             seen_notable_thing(nfeat, pos);
diff --git a/crawl-ref/source/tile-env.h b/crawl-ref/source/tile-env.h
new file mode 100644 (file)
index 0000000..2f15748
--- /dev/null
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <vector>
+#include <string>
+
+#include "defines.h"
+#include "externs.h"
+#include "fixedarray.h"
+#include "rltiles/tiledef_defines.h"
+
+struct crawl_tile_environment
+{
+    // indexed by grid coords
+#ifdef USE_TILE // TODO: separate out this stuff from crawl_environment
+    FixedArray<tile_fg_store, GXM, GYM> bk_fg;
+    FixedArray<tileidx_t, GXM, GYM> bk_bg;
+    FixedArray<tileidx_t, GXM, GYM> bk_cloud;
+#endif
+    FixedArray<tile_flavour, GXM, GYM> flv;
+    // indexed by (show-1) coords
+#ifdef USE_TILE // TODO: separate out this stuff from crawl_environment
+    FixedArray<tileidx_t, ENV_SHOW_DIAMETER, ENV_SHOW_DIAMETER> fg;
+    FixedArray<tileidx_t, ENV_SHOW_DIAMETER, ENV_SHOW_DIAMETER> bg;
+    FixedArray<tileidx_t, ENV_SHOW_DIAMETER, ENV_SHOW_DIAMETER> cloud;
+#endif
+    tile_flavour default_flavour;
+    std::vector<std::string> names;
+};
+
+#ifdef DEBUG_GLOBALS
+#define tile_env (*real_tile_env)
+#endif
+extern struct crawl_tile_environment tile_env;
index ed4d578..b00a534 100644 (file)
@@ -11,6 +11,7 @@
 #include "describe.h"
 #include "debug.h"
 #include "env.h"
+#include "tile-env.h"
 #include "files.h"
 #include "item-name.h"
 #include "item-prop.h"
@@ -523,7 +524,7 @@ tileidx_t tileidx_feature(const coord_def &gc)
 {
     dungeon_feature_type feat = env.map_knowledge(gc).feat();
 
-    tileidx_t override = env.tile_flv(gc).feat;
+    tileidx_t override = tile_env.flv(gc).feat;
     bool can_override = !feat_is_door(feat)
                         && feat != DNGN_FLOOR
                         && feat != DNGN_UNSEEN
@@ -568,13 +569,13 @@ tileidx_t tileidx_feature(const coord_def &gc)
         }
         if (colour >= ETC_FIRST)
         {
-            tileidx_t idx = (feat == DNGN_FLOOR) ? env.tile_flv(gc).floor :
-                (feat == DNGN_ROCK_WALL) ? env.tile_flv(gc).wall
+            tileidx_t idx = (feat == DNGN_FLOOR) ? tile_env.flv(gc).floor :
+                (feat == DNGN_ROCK_WALL) ? tile_env.flv(gc).wall
                 : tileidx_feature_base(feat);
 
 #ifdef USE_TILE
             if (feat == DNGN_STONE_WALL)
-                apply_variations(env.tile_flv(gc), &idx, gc);
+                apply_variations(tile_env.flv(gc), &idx, gc);
 #endif
 
             tileidx_t base = tile_dngn_basetile(idx);
@@ -933,9 +934,9 @@ tileidx_t tileidx_out_of_bounds(int branch)
 void tileidx_out_of_los(tileidx_t *fg, tileidx_t *bg, tileidx_t *cloud, const coord_def& gc)
 {
     // Player memory.
-    tileidx_t mem_fg = env.tile_bk_fg(gc);
-    tileidx_t mem_bg = env.tile_bk_bg(gc);
-    tileidx_t mem_cloud = env.tile_bk_cloud(gc);
+    tileidx_t mem_fg = tile_env.bk_fg(gc);
+    tileidx_t mem_bg = tile_env.bk_bg(gc);
+    tileidx_t mem_cloud = tile_env.bk_cloud(gc);
 
     // Detected info is just stored in map_knowledge and doesn't get
     // written to what the player remembers. We'll feather that in here.
@@ -1589,7 +1590,7 @@ static void _add_tentacle_overlay(const coord_def pos,
         case main_dir::west: flag = TILE_FLAG_TENTACLE_SE; break;
         default: die("invalid direction");
     }
-    env.tile_bg(next_showpos) |= flag;
+    tile_env.bg(next_showpos) |= flag;
 
     switch (type)
     {
@@ -1601,7 +1602,7 @@ static void _add_tentacle_overlay(const coord_def pos,
         case tentacle_type::spectral_kraken: flag = TILE_FLAG_TENTACLE_SPECTRAL_KRAKEN; break;
         default: flag = TILE_FLAG_TENTACLE_KRAKEN;
     }
-    env.tile_bg(next_showpos) |= flag;
+    tile_env.bg(next_showpos) |= flag;
 }
 
 static void _handle_tentacle_overlay(const coord_def pos,
index ce087c3..36c5ea5 100644 (file)
@@ -14,6 +14,7 @@
 #include "directn.h"
 #include "dgn-height.h"
 #include "env.h"
+#include "tile-env.h"
 #include "invent.h"
 #include "item-prop.h"
 #include "items.h"
@@ -951,7 +952,7 @@ bool DungeonRegion::update_tip_text(string &tip)
                 tip += make_stringf("HEIGHT(%d)\n", dgn_height_at(gc));
 
             tip += "\n";
-            tip += tile_debug_string(env.tile_fg(ep), env.tile_bg(ep), ' ');
+            tip += tile_debug_string(tile_env.fg(ep), tile_env.bg(ep), ' ');
         }
         else
         {
@@ -961,7 +962,7 @@ bool DungeonRegion::update_tip_text(string &tip)
             tip += "\n";
         }
 
-        tip += tile_debug_string(env.tile_bk_fg(gc), env.tile_bk_bg(gc), 'B');
+        tip += tile_debug_string(tile_env.bk_fg(gc), tile_env.bk_bg(gc), 'B');
 
         if (!m_vbuf.empty())
         {
@@ -975,16 +976,16 @@ bool DungeonRegion::update_tip_text(string &tip)
                             "\n     wall:  %d (%s) (%d)"
                             "\n     feat:  %d (%s) (%d)"
                             "\n  special:  %d",
-                            env.tile_flv(gc).floor,
-                            tile_dngn_name(env.tile_flv(gc).floor),
-                            env.tile_flv(gc).floor_idx,
-                            env.tile_flv(gc).wall,
-                            tile_dngn_name(env.tile_flv(gc).wall),
-                            env.tile_flv(gc).wall_idx,
-                            env.tile_flv(gc).feat,
-                            tile_dngn_name(env.tile_flv(gc).feat),
-                            env.tile_flv(gc).feat_idx,
-                            env.tile_flv(gc).special);
+                            tile_env.flv(gc).floor,
+                            tile_dngn_name(tile_env.flv(gc).floor),
+                            tile_env.flv(gc).floor_idx,
+                            tile_env.flv(gc).wall,
+                            tile_dngn_name(tile_env.flv(gc).wall),
+                            tile_env.flv(gc).wall_idx,
+                            tile_env.flv(gc).feat,
+                            tile_dngn_name(tile_env.flv(gc).feat),
+                            tile_env.flv(gc).feat_idx,
+                            tile_env.flv(gc).special);
 
         ret = true;
     }
index 1ffbb79..8d66035 100644 (file)
@@ -7,6 +7,7 @@
 #include "cio.h"
 #include "describe.h"
 #include "env.h"
+#include "tile-env.h"
 #include "invent.h"
 #include "item-name.h"
 #include "item-prop.h"
@@ -50,8 +51,8 @@ void InventoryRegion::pack_buffers()
                 if (i > (unsigned int) mx * my * (m_grid_page+1) && item.tile)
                     break;
 
-                int num_floor = tile_dngn_count(env.tile_default.floor);
-                tileidx_t t = env.tile_default.floor + i % num_floor;
+                int num_floor = tile_dngn_count(tile_env.default_flavour.floor);
+                tileidx_t t = tile_env.default_flavour.floor + i % num_floor;
                 m_buf.add_dngn_tile(t, x, y);
             }
             else
index 245b636..b8e879b 100644 (file)
@@ -9,6 +9,7 @@
 #include "cio.h"
 #include "directn.h"
 #include "env.h"
+#include "tile-env.h"
 #include "libutil.h"
 #include "monster.h"
 #include "output.h"
@@ -155,7 +156,7 @@ const monster_info* MonsterRegion::get_monster(unsigned int idx) const
 void MonsterRegion::pack_buffers()
 {
     update();
-    const int num_floor = tile_dngn_count(env.tile_default.floor);
+    const int num_floor = tile_dngn_count(tile_env.default_flavour.floor);
 
     unsigned int i = 0;
     for (int y = 0; y < my; y++)
@@ -174,9 +175,9 @@ void MonsterRegion::pack_buffers()
                 if (crawl_view.in_los_bounds_g(gc))
                 {
                     packed_cell cell;
-                    cell.fg = env.tile_fg(ep);
-                    cell.bg = env.tile_bg(ep);
-                    cell.flv = env.tile_flv(gc);
+                    cell.fg = tile_env.fg(ep);
+                    cell.bg = tile_env.bg(ep);
+                    cell.flv = tile_env.flv(gc);
                     tile_apply_properties(gc, cell);
 
                     m_buf.add(cell, x, y);
@@ -188,7 +189,7 @@ void MonsterRegion::pack_buffers()
             }
 
             // Fill the rest of the space with out of sight floor tiles.
-            int tileidx = env.tile_default.floor + i % num_floor;
+            int tileidx = tile_env.default_flavour.floor + i % num_floor;
             m_buf.add_dngn_tile(tileidx, x, y);
             m_buf.add_icons_tile(TILEI_MESH, x, y);
         }
index 1b3d042..b714bd7 100644 (file)
@@ -12,6 +12,7 @@
 #include "domino-data.h"
 #include "dungeon.h"
 #include "env.h"
+#include "tile-env.h"
 #include "fprop.h"
 #include "items.h"
 #include "kills.h"
@@ -43,9 +44,9 @@ void tile_new_level(bool first_time, bool init_unseen)
         for (unsigned int x = 0; x < GXM; x++)
             for (unsigned int y = 0; y < GYM; y++)
             {
-                env.tile_bk_fg[x][y] = 0;
-                env.tile_bk_bg[x][y] = TILE_DNGN_UNSEEN;
-                env.tile_bk_cloud[x][y] = 0;
+                tile_env.bk_fg[x][y] = 0;
+                tile_env.bk_bg[x][y] = TILE_DNGN_UNSEEN;
+                tile_env.bk_cloud[x][y] = 0;
             }
     }
 
@@ -55,15 +56,15 @@ void tile_new_level(bool first_time, bool init_unseen)
     for (unsigned int x = 0; x < GXM; x++)
         for (unsigned int y = 0; y < GYM; y++)
         {
-            unsigned int tile = env.tile_bk_bg[x][y];
+            unsigned int tile = tile_env.bk_bg[x][y];
             if ((tile & TILE_FLAG_NEW_STAIR)
                 && !is_unknown_stair(coord_def(x,y)))
             {
-                env.tile_bk_bg[x][y] &= ~TILE_FLAG_NEW_STAIR;
+                tile_env.bk_bg[x][y] &= ~TILE_FLAG_NEW_STAIR;
             }
             else if ((tile & TILE_FLAG_NEW_TRANSPORTER)
                      && !is_unknown_transporter(coord_def(x,y)))
-                env.tile_bk_bg[x][y] &= ~TILE_FLAG_NEW_TRANSPORTER;
+                tile_env.bk_bg[x][y] &= ~TILE_FLAG_NEW_TRANSPORTER;
         }
 
     tiles.clear_minimap();
@@ -78,7 +79,7 @@ void tile_new_level(bool first_time, bool init_unseen)
 
 void tile_init_default_flavour()
 {
-    tile_default_flv(you.where_are_you, env.tile_default);
+    tile_default_flv(you.where_are_you, tile_env.default_flavour);
 }
 
 void tile_default_flv(branch_type br, tile_flavour &flv)
@@ -296,13 +297,13 @@ void tile_default_flv(branch_type br, tile_flavour &flv)
 
 void tile_clear_flavour(const coord_def &p)
 {
-    env.tile_flv(p).floor     = 0;
-    env.tile_flv(p).wall      = 0;
-    env.tile_flv(p).feat      = 0;
-    env.tile_flv(p).floor_idx = 0;
-    env.tile_flv(p).wall_idx  = 0;
-    env.tile_flv(p).feat_idx  = 0;
-    env.tile_flv(p).special   = 0;
+    tile_env.flv(p).floor     = 0;
+    tile_env.flv(p).wall      = 0;
+    tile_env.flv(p).feat      = 0;
+    tile_env.flv(p).floor_idx = 0;
+    tile_env.flv(p).wall_idx  = 0;
+    tile_env.flv(p).feat_idx  = 0;
+    tile_env.flv(p).special   = 0;
 }
 
 void tile_clear_flavour()
@@ -488,57 +489,57 @@ void tile_init_flavour(const coord_def &gc, const int domino)
     int rand1 = hash_with_seed(INT_MAX, seed, 0);
     int rand2 = hash_with_seed(INT_MAX, seed, 1);
 
-    if (!env.tile_flv(gc).floor)
+    if (!tile_env.flv(gc).floor)
     {
-        tileidx_t floor_base = env.tile_default.floor;
+        tileidx_t floor_base = tile_env.default_flavour.floor;
         int colour = env.grid_colours(gc);
         if (colour)
             floor_base = tile_dngn_coloured(floor_base, colour);
-        env.tile_flv(gc).floor = pick_dngn_tile(floor_base, rand1, domino);
+        tile_env.flv(gc).floor = pick_dngn_tile(floor_base, rand1, domino);
     }
-    else if (env.tile_flv(gc).floor != TILE_HALO_GRASS
-             && env.tile_flv(gc).floor != TILE_HALO_GRASS2
-             && env.tile_flv(gc).floor != TILE_HALO_VAULT
-             && env.tile_flv(gc).floor != TILE_HALO_DIRT)
+    else if (tile_env.flv(gc).floor != TILE_HALO_GRASS
+             && tile_env.flv(gc).floor != TILE_HALO_GRASS2
+             && tile_env.flv(gc).floor != TILE_HALO_VAULT
+             && tile_env.flv(gc).floor != TILE_HALO_DIRT)
     {
-        env.tile_flv(gc).floor = pick_dngn_tile(env.tile_flv(gc).floor, rand1);
+        tile_env.flv(gc).floor = pick_dngn_tile(tile_env.flv(gc).floor, rand1);
     }
 
-    if (!env.tile_flv(gc).wall)
+    if (!tile_env.flv(gc).wall)
     {
         if ((player_in_branch(BRANCH_DUNGEON) || player_in_branch(BRANCH_DEPTHS))
-            && env.tile_default.wall == TILE_WALL_NORMAL)
+            && tile_env.default_flavour.wall == TILE_WALL_NORMAL)
         {
             vector<tileidx_t> tile_candidates;
             if (player_in_branch(BRANCH_DEPTHS))
                 _get_depths_wall_tiles_by_depth(you.depth, tile_candidates);
             else
                 _get_dungeon_wall_tiles_by_depth(you.depth, tile_candidates);
-            env.tile_flv(gc).wall = _pick_dngn_tile_multi(tile_candidates, rand2);
+            tile_env.flv(gc).wall = _pick_dngn_tile_multi(tile_candidates, rand2);
         }
         else
         {
-            tileidx_t wall_base = env.tile_default.wall;
+            tileidx_t wall_base = tile_env.default_flavour.wall;
             int colour = env.grid_colours(gc);
             if (colour)
                 wall_base = tile_dngn_coloured(wall_base, colour);
-            env.tile_flv(gc).wall = pick_dngn_tile(wall_base, rand2);
+            tile_env.flv(gc).wall = pick_dngn_tile(wall_base, rand2);
         }
     }
     else
-        env.tile_flv(gc).wall = pick_dngn_tile(env.tile_flv(gc).wall, rand2);
+        tile_env.flv(gc).wall = pick_dngn_tile(tile_env.flv(gc).wall, rand2);
 
     if (feat_is_stone_stair(env.grid(gc)) && player_in_branch(BRANCH_SHOALS))
     {
         const bool up = feat_stair_direction(env.grid(gc)) == CMD_GO_UPSTAIRS;
-        env.tile_flv(gc).feat = up ? TILE_DNGN_SHOALS_STAIRS_UP
+        tile_env.flv(gc).feat = up ? TILE_DNGN_SHOALS_STAIRS_UP
                                    : TILE_DNGN_SHOALS_STAIRS_DOWN;
     }
 
     if (feat_is_escape_hatch(env.grid(gc)) && player_in_branch(BRANCH_TOMB))
     {
         const bool up = feat_stair_direction(env.grid(gc)) == CMD_GO_UPSTAIRS;
-        env.tile_flv(gc).feat = up ? TILE_DNGN_ONE_WAY_STAIRS_UP
+        tile_env.flv(gc).feat = up ? TILE_DNGN_ONE_WAY_STAIRS_UP
                                    : TILE_DNGN_ONE_WAY_STAIRS_DOWN;
     }
 
@@ -569,13 +570,13 @@ void tile_init_flavour(const coord_def &gc, const int domino)
             // NOTE: This requires that closed gates and open gates
             // are positioned in the tile set relative to their
             // door counterpart.
-            env.tile_flv(gc).special = target - TILE_DNGN_CLOSED_DOOR;
+            tile_env.flv(gc).special = target - TILE_DNGN_CLOSED_DOOR;
         }
         else
-            env.tile_flv(gc).special = 0;
+            tile_env.flv(gc).special = 0;
     }
-    else if (!env.tile_flv(gc).special)
-        env.tile_flv(gc).special = hash_with_seed(256, seed, 10);
+    else if (!tile_env.flv(gc).special)
+        tile_env.flv(gc).special = hash_with_seed(256, seed, 10);
 }
 
 enum SpecialIdx
@@ -648,130 +649,130 @@ void tile_floor_halo(dungeon_feature_type target, tileidx_t tile)
             if (l_nrm && r_nrm || u_nrm && d_nrm)
             {
                 // Not much to do here...
-                env.tile_flv[x][y].floor = tile + SPECIAL_FULL;
+                tile_env.flv[x][y].floor = tile + SPECIAL_FULL;
             }
             else if (l_nrm)
             {
                 if (u_nrm)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_NW;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_NW;
                 else if (d_nrm)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_SW;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_SW;
                 else if (u_spc && d_spc)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_W;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_W;
                 else if (u_spc && r_spc)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_SW;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_SW;
                 else if (d_spc && r_spc)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_NW;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_NW;
                 else if (u_spc)
                 {
-                    env.tile_flv[x][y].floor = tile + (coinflip() ?
+                    tile_env.flv[x][y].floor = tile + (coinflip() ?
                         SPECIAL_W : SPECIAL_SW);
                 }
                 else if (d_spc)
                 {
-                    env.tile_flv[x][y].floor = tile + (coinflip() ?
+                    tile_env.flv[x][y].floor = tile + (coinflip() ?
                         SPECIAL_W : SPECIAL_NW);
                 }
                 else
-                    env.tile_flv[x][y].floor = tile + _jitter(SPECIAL_W);
+                    tile_env.flv[x][y].floor = tile + _jitter(SPECIAL_W);
             }
             else if (r_nrm)
             {
                 if (u_nrm)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_NE;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_NE;
                 else if (d_nrm)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_SE;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_SE;
                 else if (u_spc && d_spc)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_E;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_E;
                 else if (u_spc && l_spc)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_SE;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_SE;
                 else if (d_spc && l_spc)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_NE;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_NE;
                 else if (u_spc)
-                    env.tile_flv[x][y].floor = tile + (coinflip() ?
+                    tile_env.flv[x][y].floor = tile + (coinflip() ?
                         SPECIAL_E : SPECIAL_SE);
                 else if (d_spc)
-                    env.tile_flv[x][y].floor = tile + (coinflip() ?
+                    tile_env.flv[x][y].floor = tile + (coinflip() ?
                         SPECIAL_E : SPECIAL_NE);
                 else
-                    env.tile_flv[x][y].floor = tile + _jitter(SPECIAL_E);
+                    tile_env.flv[x][y].floor = tile + _jitter(SPECIAL_E);
             }
             else if (u_nrm)
             {
                 if (r_spc && l_spc)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_N;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_N;
                 else if (r_spc && d_spc)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_NW;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_NW;
                 else if (l_spc && d_spc)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_NE;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_NE;
                 else if (r_spc)
                 {
-                    env.tile_flv[x][y].floor = tile + (coinflip() ?
+                    tile_env.flv[x][y].floor = tile + (coinflip() ?
                         SPECIAL_N : SPECIAL_NW);
                 }
                 else if (l_spc)
                 {
-                    env.tile_flv[x][y].floor = tile + (coinflip() ?
+                    tile_env.flv[x][y].floor = tile + (coinflip() ?
                         SPECIAL_N : SPECIAL_NE);
                 }
                 else
-                    env.tile_flv[x][y].floor = tile + _jitter(SPECIAL_N);
+                    tile_env.flv[x][y].floor = tile + _jitter(SPECIAL_N);
             }
             else if (d_nrm)
             {
                 if (r_spc && l_spc)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_S;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_S;
                 else if (r_spc && u_spc)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_SW;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_SW;
                 else if (l_spc && u_spc)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_SE;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_SE;
                 else if (r_spc)
                 {
-                    env.tile_flv[x][y].floor = tile + (coinflip() ?
+                    tile_env.flv[x][y].floor = tile + (coinflip() ?
                         SPECIAL_S : SPECIAL_SW);
                 }
                 else if (l_spc)
                 {
-                    env.tile_flv[x][y].floor = tile + (coinflip() ?
+                    tile_env.flv[x][y].floor = tile + (coinflip() ?
                         SPECIAL_S : SPECIAL_SE);
                 }
                 else
-                    env.tile_flv[x][y].floor = tile + _jitter(SPECIAL_S);
+                    tile_env.flv[x][y].floor = tile + _jitter(SPECIAL_S);
             }
             else if (u_spc && d_spc)
             {
                 // We know this value is already initialised and
                 // is necessarily in bounds.
-                tileidx_t t = env.tile_flv[x][y-1].floor - tile;
+                tileidx_t t = tile_env.flv[x][y-1].floor - tile;
                 if (t == SPECIAL_NE || t == SPECIAL_E)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_E;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_E;
                 else if (t == SPECIAL_NW || t == SPECIAL_W)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_W;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_W;
                 else
-                    env.tile_flv[x][y].floor = tile + SPECIAL_FULL;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_FULL;
             }
             else if (r_spc && l_spc)
             {
                 // We know this value is already initialised and
                 // is necessarily in bounds.
-                tileidx_t t = env.tile_flv[x-1][y].floor - tile;
+                tileidx_t t = tile_env.flv[x-1][y].floor - tile;
                 if (t == SPECIAL_NW || t == SPECIAL_N)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_N;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_N;
                 else if (t == SPECIAL_SW || t == SPECIAL_S)
-                    env.tile_flv[x][y].floor = tile + SPECIAL_S;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_S;
                 else
-                    env.tile_flv[x][y].floor = tile + SPECIAL_FULL;
+                    tile_env.flv[x][y].floor = tile + SPECIAL_FULL;
             }
             else if (u_spc && l_spc)
-                env.tile_flv[x][y].floor = tile + SPECIAL_SE;
+                tile_env.flv[x][y].floor = tile + SPECIAL_SE;
             else if (u_spc && r_spc)
-                env.tile_flv[x][y].floor = tile + SPECIAL_SW;
+                tile_env.flv[x][y].floor = tile + SPECIAL_SW;
             else if (d_spc && l_spc)
-                env.tile_flv[x][y].floor = tile + SPECIAL_NE;
+                tile_env.flv[x][y].floor = tile + SPECIAL_NE;
             else if (d_spc && r_spc)
-                env.tile_flv[x][y].floor = tile + SPECIAL_NW;
+                tile_env.flv[x][y].floor = tile + SPECIAL_NW;
             else
-                env.tile_flv[x][y].floor = tile + SPECIAL_FULL;
+                tile_env.flv[x][y].floor = tile + SPECIAL_FULL;
         }
     }
 
@@ -795,7 +796,7 @@ void tile_floor_halo(dungeon_feature_type target, tileidx_t tile)
     for (int y = 0; y < GYM - 1; ++y)
         for (int x = 0; x < GXM - 1; ++x)
         {
-            int this_spc = env.tile_flv[x][y].floor - tile;
+            int this_spc = tile_env.flv[x][y].floor - tile;
             if (this_spc < 0 || this_spc > 8)
                 continue;
 
@@ -806,30 +807,30 @@ void tile_floor_halo(dungeon_feature_type target, tileidx_t tile)
             }
 
             // TODO: these conditions are guaranteed?
-            int right_spc = x < GXM - 1 ? env.tile_flv[x+1][y].floor - tile
+            int right_spc = x < GXM - 1 ? tile_env.flv[x+1][y].floor - tile
                                         : int{SPECIAL_FULL};
-            int down_spc  = y < GYM - 1 ? env.tile_flv[x][y+1].floor - tile
+            int down_spc  = y < GYM - 1 ? tile_env.flv[x][y+1].floor - tile
                                         : int{SPECIAL_FULL};
 
             if (this_spc == SPECIAL_N && right_spc == SPECIAL_S)
             {
-                env.tile_flv[x][y].floor = tile + SPECIAL_NE;
-                env.tile_flv[x+1][y].floor = tile + SPECIAL_SW;
+                tile_env.flv[x][y].floor = tile + SPECIAL_NE;
+                tile_env.flv[x+1][y].floor = tile + SPECIAL_SW;
             }
             else if (this_spc == SPECIAL_S && right_spc == SPECIAL_N)
             {
-                env.tile_flv[x][y].floor = tile + SPECIAL_SE;
-                env.tile_flv[x+1][y].floor = tile + SPECIAL_NW;
+                tile_env.flv[x][y].floor = tile + SPECIAL_SE;
+                tile_env.flv[x+1][y].floor = tile + SPECIAL_NW;
             }
             else if (this_spc == SPECIAL_E && down_spc == SPECIAL_W)
             {
-                env.tile_flv[x][y].floor = tile + SPECIAL_SE;
-                env.tile_flv[x][y+1].floor = tile + SPECIAL_NW;
+                tile_env.flv[x][y].floor = tile + SPECIAL_SE;
+                tile_env.flv[x][y+1].floor = tile + SPECIAL_NW;
             }
             else if (this_spc == SPECIAL_W && down_spc == SPECIAL_E)
             {
-                env.tile_flv[x][y].floor = tile + SPECIAL_NE;
-                env.tile_flv[x][y+1].floor = tile + SPECIAL_SW;
+                tile_env.flv[x][y].floor = tile + SPECIAL_NE;
+                tile_env.flv[x][y+1].floor = tile + SPECIAL_SW;
             }
         }
 }
@@ -880,8 +881,8 @@ static tileidx_t _get_floor_bg(const coord_def& gc)
 
 void tile_draw_floor()
 {
-    for (int cy = 0; cy < env.tile_fg.height(); cy++)
-        for (int cx = 0; cx < env.tile_fg.width(); cx++)
+    for (int cy = 0; cy < tile_env.fg.height(); cy++)
+        for (int cx = 0; cx < tile_env.fg.width(); cx++)
         {
             const coord_def ep(cx, cy);
             const coord_def gc = show2grid(ep);
@@ -889,24 +890,24 @@ void tile_draw_floor()
             tileidx_t bg = _get_floor_bg(gc);
 
             // init tiles
-            env.tile_bg(ep) = bg;
-            env.tile_fg(ep) = 0;
-            env.tile_cloud(ep) = 0;
+            tile_env.bg(ep) = bg;
+            tile_env.fg(ep) = 0;
+            tile_env.cloud(ep) = 0;
         }
 }
 
 void tile_clear_map(const coord_def& gc)
 {
-    env.tile_bk_fg(gc) = 0;
-    env.tile_bk_cloud(gc) = 0;
+    tile_env.bk_fg(gc) = 0;
+    tile_env.bk_cloud(gc) = 0;
     tiles.update_minimap(gc);
 }
 
 void tile_forget_map(const coord_def &gc)
 {
-    env.tile_bk_fg(gc) = 0;
-    env.tile_bk_bg(gc) = 0;
-    env.tile_bk_cloud(gc) = 0;
+    tile_env.bk_fg(gc) = 0;
+    tile_env.bk_bg(gc) = 0;
+    tile_env.bk_cloud(gc) = 0;
     // This may have changed the explore horizon, so update adjacent minimap
     // squares as well.
     for (adjacent_iterator ai(gc, false); ai; ++ai)
@@ -923,20 +924,20 @@ static void _tile_place_item(const coord_def &gc, const item_info &item,
     if (you.see_cell(gc))
     {
         const coord_def ep = crawl_view.grid2show(gc);
-        if (env.tile_fg(ep))
+        if (tile_env.fg(ep))
             return;
 
-        env.tile_fg(ep) = t;
+        tile_env.fg(ep) = t;
 
         if (item_needs_autopickup(item))
-            env.tile_bg(ep) |= TILE_FLAG_CURSOR3;
+            tile_env.bg(ep) |= TILE_FLAG_CURSOR3;
     }
     else
     {
-        env.tile_bk_fg(gc) = t;
+        tile_env.bk_fg(gc) = t;
 
         if (item_needs_autopickup(item))
-            env.tile_bk_bg(gc) |= TILE_FLAG_CURSOR3;
+            tile_env.bk_bg(gc) |= TILE_FLAG_CURSOR3;
     }
 }
 
@@ -945,17 +946,17 @@ static void _tile_place_item_marker(const coord_def &gc, const item_def &item)
     if (you.see_cell(gc))
     {
         const coord_def ep = crawl_view.grid2show(gc);
-        env.tile_fg(ep) |= TILE_FLAG_S_UNDER;
+        tile_env.fg(ep) |= TILE_FLAG_S_UNDER;
 
         if (item_needs_autopickup(item))
-            env.tile_bg(ep) |= TILE_FLAG_CURSOR3;
+            tile_env.bg(ep) |= TILE_FLAG_CURSOR3;
     }
     else
     {
-        env.tile_bk_fg(gc) = ((tileidx_t) env.tile_bk_fg(gc)) | TILE_FLAG_S_UNDER;
+        tile_env.bk_fg(gc) = ((tileidx_t) tile_env.bk_fg(gc)) | TILE_FLAG_S_UNDER;
 
         if (item_needs_autopickup(item))
-            env.tile_bk_bg(gc) |= TILE_FLAG_CURSOR3;
+            tile_env.bk_bg(gc) |= TILE_FLAG_CURSOR3;
     }
 }
 
@@ -975,9 +976,9 @@ static void _tile_place_invisible_monster(const coord_def &gc)
     if (cell.feat() != DNGN_SHALLOW_WATER || cell.cloud() != CLOUD_NONE)
     {
         if (you.see_cell(gc))
-            env.tile_fg(ep) = TILE_UNSEEN_MONSTER;
+            tile_env.fg(ep) = TILE_UNSEEN_MONSTER;
         else
-            env.tile_bk_fg(gc) = TILE_UNSEEN_MONSTER;
+            tile_env.bk_fg(gc) = TILE_UNSEEN_MONSTER;
     }
 
     if (env.map_knowledge(gc).item())
@@ -1003,9 +1004,9 @@ static void _tile_place_monster(const coord_def &gc, const monster_info& mon)
             if (item_needs_autopickup(*env.map_knowledge(gc).item()))
             {
                 if (you.see_cell(gc))
-                    env.tile_bg(ep) |= TILE_FLAG_CURSOR3;
+                    tile_env.bg(ep) |= TILE_FLAG_CURSOR3;
                 else
-                    env.tile_bk_bg(gc) |= TILE_FLAG_CURSOR3;
+                    tile_env.bk_bg(gc) |= TILE_FLAG_CURSOR3;
             }
         }
     }
@@ -1017,10 +1018,10 @@ static void _tile_place_monster(const coord_def &gc, const monster_info& mon)
 
     if (!you.see_cell(gc))
     {
-        env.tile_bk_fg(gc) = t;
+        tile_env.bk_fg(gc) = t;
         return;
     }
-    env.tile_fg(ep) = t;
+    tile_env.fg(ep) = t;
 
     // Add name tags.
     if (!mons_class_gives_xp(mon.type))
@@ -1049,14 +1050,14 @@ static void _tile_place_monster(const coord_def &gc, const monster_info& mon)
 void tile_reset_fg(const coord_def &gc)
 {
     // remove autopickup cursor, it will be added back if necessary
-    env.tile_bk_bg(gc) &= ~TILE_FLAG_CURSOR3;
+    tile_env.bk_bg(gc) &= ~TILE_FLAG_CURSOR3;
     tile_draw_map_cell(gc, true);
     tiles.update_minimap(gc);
 }
 
 void tile_reset_feat(const coord_def &gc)
 {
-    env.tile_bk_bg(gc) = tileidx_feature(gc);
+    tile_env.bk_bg(gc) = tileidx_feature(gc);
 }
 
 static void _tile_place_cloud(const coord_def &gc, const cloud_info &cl)
@@ -1064,21 +1065,21 @@ static void _tile_place_cloud(const coord_def &gc, const cloud_info &cl)
     if (you.see_cell(gc))
     {
         const coord_def ep = grid2show(gc);
-        env.tile_cloud(ep) = tileidx_cloud(cl);
+        tile_env.cloud(ep) = tileidx_cloud(cl);
     }
     else
-        env.tile_bk_cloud(gc) = tileidx_cloud(cl);
+        tile_env.bk_cloud(gc) = tileidx_cloud(cl);
 }
 
 void tile_draw_map_cell(const coord_def& gc, bool foreground_only)
 {
     if (!foreground_only)
-        env.tile_bk_bg(gc) = _get_floor_bg(gc);
+        tile_env.bk_bg(gc) = _get_floor_bg(gc);
 
     if (you.see_cell(gc))
     {
-        env.tile_fg(grid2show(gc)) = 0;
-        env.tile_cloud(grid2show(gc)) = 0;
+        tile_env.fg(grid2show(gc)) = 0;
+        tile_env.cloud(grid2show(gc)) = 0;
     }
 
     const map_cell& cell = env.map_knowledge(gc);
@@ -1095,18 +1096,18 @@ void tile_draw_map_cell(const coord_def& gc, bool foreground_only)
             _tile_place_item(gc, *cell.item(), (cell.flags & MAP_MORE_ITEMS) != 0);
     }
     else
-        env.tile_bk_fg(gc) = 0;
+        tile_env.bk_fg(gc) = 0;
 
     // Always place clouds now they have their own layer
     if (cell.cloud() != CLOUD_NONE)
         _tile_place_cloud(gc, *cell.cloudinfo());
     else
-        env.tile_bk_cloud(gc) = 0;
+        tile_env.bk_cloud(gc) = 0;
 }
 
 void tile_wizmap_terrain(const coord_def &gc)
 {
-    env.tile_bk_bg(gc) = tileidx_feature(gc);
+    tile_env.bk_bg(gc) = tileidx_feature(gc);
 }
 
 static bool _is_torch(tileidx_t basetile)
@@ -1395,7 +1396,7 @@ void tile_apply_properties(const coord_def &gc, packed_cell &cell)
     if (!map_bounds(gc))
         return;
 
-    apply_variations(env.tile_flv(gc), &cell.bg, gc);
+    apply_variations(tile_env.flv(gc), &cell.bg, gc);
 
     const map_cell& mc = env.map_knowledge(gc);
 
@@ -1472,7 +1473,7 @@ void tile_apply_properties(const coord_def &gc, packed_cell &cell)
         }
     }
 
-    cell.flv = env.tile_flv(gc);
+    cell.flv = tile_env.flv(gc);
 
     if (env.level_state & LSTATE_SLIMY_WALL)
     {
index 4cf3c13..cd4d2ee 100644 (file)
@@ -27,6 +27,7 @@
 #include "directn.h"
 #include "english.h"
 #include "env.h"
+#include "tile-env.h"
 #include "exclude.h"
 #include "feature.h"
 #include "files.h"
@@ -1049,9 +1050,9 @@ static update_flags player_view_update_at(const coord_def &gc)
 
     // We remove any references to mcache when
     // writing to the background.
-    env.tile_bk_fg(gc) = env.tile_fg(ep);
-    env.tile_bk_bg(gc) = env.tile_bg(ep);
-    env.tile_bk_cloud(gc) = env.tile_cloud(ep);
+    tile_env.bk_fg(gc) = tile_env.fg(ep);
+    tile_env.bk_bg(gc) = tile_env.bg(ep);
+    tile_env.bk_cloud(gc) = tile_env.cloud(ep);
 #endif
 
     return ret;
@@ -1110,7 +1111,7 @@ static void _draw_outside_los(screen_cell_t *cell, const coord_def &gc,
 #ifdef USE_TILE
     // this is just for out-of-los rays, but I don't see a more efficient way..
     if (in_bounds(gc))
-        cell->tile.bg = env.tile_bg(ep);
+        cell->tile.bg = tile_env.bg(ep);
 
     tileidx_out_of_los(&cell->tile.fg, &cell->tile.bg, &cell->tile.cloud, gc);
 #else
@@ -1140,11 +1141,11 @@ static void _draw_player(screen_cell_t *cell,
 #endif
 
 #ifdef USE_TILE
-    cell->tile.fg = env.tile_fg(ep) = tileidx_player();
-    cell->tile.bg = env.tile_bg(ep);
-    cell->tile.cloud = env.tile_cloud(ep);
+    cell->tile.fg = tile_env.fg(ep) = tileidx_player();
+    cell->tile.bg = tile_env.bg(ep);
+    cell->tile.cloud = tile_env.cloud(ep);
     if (anim_updates)
-        tile_apply_animations(cell->tile.bg, &env.tile_flv(gc));
+        tile_apply_animations(cell->tile.bg, &tile_env.flv(gc));
 #else
     UNUSED(ep, anim_updates);
 #endif
@@ -1161,11 +1162,11 @@ static void _draw_los(screen_cell_t *cell,
 #endif
 
 #ifdef USE_TILE
-    cell->tile.fg = env.tile_fg(ep);
-    cell->tile.bg = env.tile_bg(ep);
-    cell->tile.cloud = env.tile_cloud(ep);
+    cell->tile.fg = tile_env.fg(ep);
+    cell->tile.bg = tile_env.bg(ep);
+    cell->tile.cloud = tile_env.cloud(ep);
     if (anim_updates)
-        tile_apply_animations(cell->tile.bg, &env.tile_flv(gc));
+        tile_apply_animations(cell->tile.bg, &tile_env.flv(gc));
 #else
     UNUSED(ep, anim_updates);
 #endif
index 538f412..78cb5eb 100644 (file)
@@ -15,6 +15,7 @@
 #include "describe.h"
 #include "dgn-overview.h"
 #include "dungeon.h"
+#include "tile-env.h"
 #include "files.h"
 #include "libutil.h"
 #include "maps.h"
@@ -246,8 +247,8 @@ bool wizard_create_feature(const coord_def& pos)
     if (feat_is_trap(feat))
         return debug_make_trap(pos);
 
-    env.tile_flv(pos).feat = 0;
-    env.tile_flv(pos).special = 0;
+    tile_env.flv(pos).feat = 0;
+    tile_env.flv(pos).special = 0;
     env.grid_colours(pos) = 0;
     const dungeon_feature_type old_feat = env.grid(pos);
     dungeon_terrain_changed(pos, feat, false, false, false, true);