diff options
39 files changed, 1016 insertions, 921 deletions
diff --git a/crawl-ref/source/acr.cc b/crawl-ref/source/acr.cc index 8b876b1cb5..7ced21d0a1 100644 --- a/crawl-ref/source/acr.cc +++ b/crawl-ref/source/acr.cc @@ -3525,13 +3525,13 @@ static bool _initialise(void) seed_rng(); get_typeid_array().init(ID_UNKNOWN_TYPE); init_char_table(Options.char_set); - init_feature_table(); + init_show_table(); init_monster_symbols(); init_spell_descs(); // This needs to be way up top. {dlb} init_mon_name_cache(); // init_item_name_cache() needs to be redone after init_char_table() - // and init_feature_table() have been called, so that the glyphs will + // and init_show_table() have been called, so that the glyphs will // be set to use with item_names_by_glyph_cache. init_item_name_cache(); @@ -3680,7 +3680,7 @@ static bool _initialise(void) // In case Lua changed the character set. init_char_table(Options.char_set); - init_feature_table(); + init_show_table(); init_monster_symbols(); #endif diff --git a/crawl-ref/source/chardump.cc b/crawl-ref/source/chardump.cc index 335f0e4386..0787629f40 100644 --- a/crawl-ref/source/chardump.cc +++ b/crawl-ref/source/chardump.cc @@ -1261,7 +1261,7 @@ void dump_map(FILE *fp, bool debug) char_table_bk = Options.char_table; init_char_table(CSET_ASCII); - init_feature_table(); + init_show_table(); if (debug) { @@ -1306,7 +1306,7 @@ void dump_map(FILE *fp, bool debug) // Restore char and feature tables Options.char_table = char_table_bk; - init_feature_table(); + init_show_table(); } void dump_map(const char* fname, bool debug) diff --git a/crawl-ref/source/cloud.cc b/crawl-ref/source/cloud.cc index 1916914ed1..04736fc968 100644 --- a/crawl-ref/source/cloud.cc +++ b/crawl-ref/source/cloud.cc @@ -14,6 +14,7 @@ #include "branch.h" #include "cloud.h" +#include "colour.h" #include "coord.h" #include "mapmark.h" #include "ouch.h" @@ -959,6 +960,80 @@ void cloud_struct::set_killer(killer_type _killer) break; } } + +int get_cloud_colour(int cloudno) +{ + int which_colour = LIGHTGREY; + switch (env.cloud[cloudno].type) + { + case CLOUD_FIRE: + case CLOUD_FOREST_FIRE: + if (env.cloud[cloudno].decay <= 20) + which_colour = RED; + else if (env.cloud[cloudno].decay <= 40) + which_colour = LIGHTRED; + else if (one_chance_in(4)) + which_colour = RED; + else if (one_chance_in(4)) + which_colour = LIGHTRED; + else + which_colour = YELLOW; + break; + + case CLOUD_STINK: + which_colour = GREEN; + break; + + case CLOUD_COLD: + if (env.cloud[cloudno].decay <= 20) + which_colour = BLUE; + else if (env.cloud[cloudno].decay <= 40) + which_colour = LIGHTBLUE; + else if (one_chance_in(4)) + which_colour = BLUE; + else if (one_chance_in(4)) + which_colour = LIGHTBLUE; + else + which_colour = WHITE; + break; + + case CLOUD_POISON: + which_colour = (one_chance_in(3) ? LIGHTGREEN : GREEN); + break; + + case CLOUD_BLUE_SMOKE: + which_colour = LIGHTBLUE; + break; + + case CLOUD_PURP_SMOKE: + which_colour = MAGENTA; + break; + + case CLOUD_MIASMA: + case CLOUD_BLACK_SMOKE: + which_colour = DARKGREY; + break; + + case CLOUD_RAIN: + case CLOUD_MIST: + which_colour = ETC_MIST; + break; + + case CLOUD_CHAOS: + which_colour = ETC_RANDOM; + break; + + case CLOUD_MUTAGENIC: + which_colour = ETC_MUTAGENIC; + break; + + default: + which_colour = LIGHTGREY; + break; + } + return (which_colour); +} + ////////////////////////////////////////////////////////////////////////// // Fog machine stuff diff --git a/crawl-ref/source/cloud.h b/crawl-ref/source/cloud.h index f9fa6d6d18..c94bd4af8d 100644 --- a/crawl-ref/source/cloud.h +++ b/crawl-ref/source/cloud.h @@ -63,6 +63,7 @@ int max_cloud_damage(cloud_type cl_type, int power = -1); void in_a_cloud(void); std::string cloud_name(cloud_type type); +int get_cloud_colour(int cloudno); bool is_damaging_cloud(cloud_type type, bool temp = false); bool is_harmless_cloud(cloud_type type); diff --git a/crawl-ref/source/command.cc b/crawl-ref/source/command.cc index d9d94b83ee..0b117625df 100644 --- a/crawl-ref/source/command.cc +++ b/crawl-ref/source/command.cc @@ -2122,7 +2122,7 @@ static void _add_formatted_keyhelp(column_composer &cols) "<lightgrey>/</lightgrey> : wands (e<w>V</w>oke)\n" "<lightcyan>"; - get_item_symbol(DNGN_ITEM_BOOK, &ch, &colour); + get_show_symbol(show_type(SHOW_ITEM_BOOK), &ch, &colour); item_types += static_cast<char>(ch); item_types += "</lightcyan> : books (<w>r</w>ead, <w>M</w>emorise, <w>z</w>ap, <w>Z</w>ap)\n" @@ -2289,12 +2289,12 @@ static void _add_formatted_tutorial_help(column_composer &cols) "<red>\"</red> : amulets (<w>P</w>ut on and <w>R</w>emove)\n" "<darkgrey>/</darkgrey> : wands (e<w>V</w>oke)\n" "<lightcyan>"; - get_item_symbol(DNGN_ITEM_BOOK, &ch, &colour); + get_show_symbol(show_type(SHOW_ITEM_BOOK), &ch, &colour); text << static_cast<char>(ch); text << "</lightcyan> : books (<w>r</w>ead, <w>M</w>emorise and " "<w>z</w>ap)\n" "<brown>"; - get_item_symbol(DNGN_ITEM_STAVE, &ch, &colour); + get_show_symbol(show_type(SHOW_ITEM_STAVE), &ch, &colour); text << static_cast<char>(ch); text << "</brown> : staves, rods (<w>w</w>ield and e<w>v</w>oke)\n" "\n" diff --git a/crawl-ref/source/directn.cc b/crawl-ref/source/directn.cc index b80eeb3199..9a981ded71 100644 --- a/crawl-ref/source/directn.cc +++ b/crawl-ref/source/directn.cc @@ -46,6 +46,7 @@ #include "mon-util.h" #include "player.h" #include "shopping.h" +#include "show.h" #include "state.h" #include "stuff.h" #include "stash.h" @@ -689,10 +690,10 @@ void full_describe_view() std::string desc = ""; #ifndef USE_TILE const coord_def e = c - you.pos() + coord_def(9,9); - unsigned short col = env.show_col(e);; - int object = env.show(e); + show_type object = env.show(e); + unsigned short col = object.colour; unsigned ch; - get_item_symbol( object, &ch, &col ); + get_show_symbol(object, &ch, &col); const std::string colour_str = colour_to_str(col); desc = "(<" + colour_str + ">"; diff --git a/crawl-ref/source/enum.h b/crawl-ref/source/enum.h index c9b4d0e43a..2deffd9793 100644 --- a/crawl-ref/source/enum.h +++ b/crawl-ref/source/enum.h @@ -1146,38 +1146,7 @@ enum dungeon_feature_type DNGN_PERMADRY_FOUNTAIN, DNGN_ABANDONED_SHOP, - NUM_REAL_FEATURES, // 208 - - // Real terrain must all occur before 256 to guarantee it fits - // into the unsigned char used for the grid! - - // These aren't really terrain, but they're passed in and used - // to get their appearance character so I'm putting them here for now. - DNGN_ITEM_ORB = 256, - DNGN_INVIS_EXPOSED = 257, - DNGN_ITEM_WEAPON = 258, - DNGN_ITEM_ARMOUR = 259, - DNGN_ITEM_WAND = 260, - DNGN_ITEM_FOOD = 261, - DNGN_ITEM_UNUSED_1 = 262, - DNGN_ITEM_SCROLL = 263, - DNGN_ITEM_RING = 264, - DNGN_ITEM_POTION = 265, - DNGN_ITEM_MISSILE = 266, - DNGN_ITEM_BOOK = 267, - DNGN_ITEM_UNUSED_2 = 268, - DNGN_ITEM_STAVE = 269, - DNGN_ITEM_MISCELLANY = 270, - DNGN_ITEM_CORPSE = 271, - DNGN_ITEM_GOLD = 272, - DNGN_ITEM_AMULET = 273, - DNGN_ITEM_DETECTED = 274, - - DNGN_CLOUD = 280, - NUM_FEATURES, // for use in lookup table in view.cc - - DNGN_RANDOM, - DNGN_START_OF_MONSTERS = 297 // don't go past here! see view.cc + NUM_FEATURES // 208 }; enum duration_type diff --git a/crawl-ref/source/env.h b/crawl-ref/source/env.h index d4c70f74eb..32ce82e92a 100644 --- a/crawl-ref/source/env.h +++ b/crawl-ref/source/env.h @@ -2,6 +2,7 @@ #define ENV_H #include "monster.h" +#include "show.h" class crawl_exit_hook; @@ -22,16 +23,14 @@ public: FixedArray< map_cell, GXM, GYM > map; // discovered terrain - // Glyphs of squares that are in LOS. - env_show_grid show; + // Objects that are in LOS, used for drawing. + show_def show; + env_show_grid show_los; // Compatibility. TODO: remove. // What would be visible, if all of the translucent wall were // made opaque. env_show_grid no_trans_show; - FixedArray<unsigned short, ENV_SHOW_DIAMETER, ENV_SHOW_DIAMETER> - show_col; // view window colour - #ifdef USE_TILE // indexed by grid coords FixedArray<tile_fg_store, GXM, GYM> tile_bk_fg; diff --git a/crawl-ref/source/exclude.cc b/crawl-ref/source/exclude.cc index f4ed190336..f9deb58f8b 100644 --- a/crawl-ref/source/exclude.cc +++ b/crawl-ref/source/exclude.cc @@ -95,8 +95,8 @@ struct opacity_excl : opacity_func return OPC_CLEAR; else if (!is_terrain_changed(p)) return _feat_opacity(env.grid(p)); - else if (env.map(p).object < NUM_REAL_FEATURES) - return _feat_opacity((dungeon_feature_type) env.map(p).object); + else if (env.map(p).object.cls == SH_FEATURE) + return _feat_opacity(env.map(p).object.feat); else { // If you have seen monsters, items or clouds there, diff --git a/crawl-ref/source/externs.h b/crawl-ref/source/externs.h index c064975b82..e2aab124d6 100644 --- a/crawl-ref/source/externs.h +++ b/crawl-ref/source/externs.h @@ -592,21 +592,6 @@ private: int shot_damage(actor& act); }; -struct map_cell -{ - short object; // The object: monster, item, feature, or cloud. - unsigned short flags; // Flags describing the mappedness of this square. - unsigned short colour; - unsigned long property; // Flags for blood, sanctuary, ... - - map_cell() : object(0), flags(0), colour(0), property(0) { } - void clear() { flags = object = colour = 0; } - - unsigned glyph() const; - bool known() const; - bool seen() const; -}; - class map_marker; class reader; class writer; diff --git a/crawl-ref/source/feature.cc b/crawl-ref/source/feature.cc index 85eab18c94..97dd278c19 100644 --- a/crawl-ref/source/feature.cc +++ b/crawl-ref/source/feature.cc @@ -3,14 +3,25 @@ #include "feature.h" #include "colour.h" -#include "fixvec.h" +#include "debug.h" #include "options.h" +#include "show.h" -static FixedVector<feature_def, NUM_FEATURES> Feature; +typedef std::map<show_type, feature_def> feat_map; +static feat_map Features; + +const feature_def &get_feature_def(show_type object) +{ + return (Features[object]); +} const feature_def &get_feature_def(dungeon_feature_type feat) { - return (Feature[feat]); + ASSERT(feat < NUM_FEATURES); + show_type object; + object.cls = SH_FEATURE; + object.feat = feat; + return (Features[object]); } void apply_feature_overrides() @@ -19,7 +30,7 @@ void apply_feature_overrides() { const feature_override &fov = Options.feature_overrides[i]; const feature_def &ofeat = fov.override; - feature_def &feat = Feature[fov.feat]; + feature_def &feat = Features[fov.object]; if (ofeat.symbol) feat.symbol = ofeat.symbol; @@ -38,355 +49,342 @@ void apply_feature_overrides() } } -void init_feature_table(void) +void _init_feat(feature_def &f, dungeon_feature_type feat) { - for (int i = 0; i < NUM_FEATURES; i++) + switch(feat) { - Feature[i].dchar = NUM_DCHAR_TYPES; - Feature[i].symbol = 0; - Feature[i].colour = BLACK; // means must be set some other way - Feature[i].flags = FFT_NONE; - Feature[i].magic_symbol = 0; // set to symbol if unchanged - Feature[i].map_colour = DARKGREY; - Feature[i].seen_colour = BLACK; // -> no special seen map handling - Feature[i].seen_em_colour = BLACK; - Feature[i].em_colour = BLACK; - Feature[i].minimap = MF_UNSEEN; - - switch (i) - { case DNGN_UNSEEN: default: break; case DNGN_ROCK_WALL: case DNGN_PERMAROCK_WALL: - Feature[i].dchar = DCHAR_WALL; - Feature[i].colour = ETC_ROCK; - Feature[i].magic_symbol = Options.char_table[ DCHAR_WALL_MAGIC ]; - Feature[i].minimap = MF_WALL; + f.dchar = DCHAR_WALL; + f.colour = ETC_ROCK; + f.magic_symbol = Options.char_table[ DCHAR_WALL_MAGIC ]; + f.minimap = MF_WALL; break; case DNGN_STONE_WALL: - Feature[i].dchar = DCHAR_WALL; - Feature[i].colour = ETC_STONE; - Feature[i].magic_symbol = Options.char_table[ DCHAR_WALL_MAGIC ]; - Feature[i].minimap = MF_WALL; + f.dchar = DCHAR_WALL; + f.colour = ETC_STONE; + f.magic_symbol = Options.char_table[ DCHAR_WALL_MAGIC ]; + f.minimap = MF_WALL; break; case DNGN_CLEAR_ROCK_WALL: case DNGN_CLEAR_STONE_WALL: case DNGN_CLEAR_PERMAROCK_WALL: - Feature[i].dchar = DCHAR_WALL; - Feature[i].magic_symbol = Options.char_table[ DCHAR_WALL_MAGIC ]; - Feature[i].colour = LIGHTCYAN; - Feature[i].minimap = MF_WALL; + f.dchar = DCHAR_WALL; + f.magic_symbol = Options.char_table[ DCHAR_WALL_MAGIC ]; + f.colour = LIGHTCYAN; + f.minimap = MF_WALL; break; case DNGN_TREES: - Feature[i].dchar = DCHAR_TREES; - Feature[i].magic_symbol = Options.char_table[ DCHAR_WALL_MAGIC ]; - Feature[i].colour = BLACK; // overridden later - Feature[i].minimap = MF_WALL; + f.dchar = DCHAR_TREES; + f.magic_symbol = Options.char_table[ DCHAR_WALL_MAGIC ]; + f.colour = BLACK; // overridden later + f.minimap = MF_WALL; break; case DNGN_OPEN_SEA: #ifdef USE_TILE - Feature[i].dchar = DCHAR_WAVY; + f.dchar = DCHAR_WAVY; #else - Feature[i].dchar = DCHAR_WALL; + f.dchar = DCHAR_WALL; #endif - Feature[i].colour = BLUE; - Feature[i].minimap = MF_WATER; + f.colour = BLUE; + f.minimap = MF_WATER; break; case DNGN_OPEN_DOOR: - Feature[i].dchar = DCHAR_DOOR_OPEN; - Feature[i].colour = LIGHTGREY; - Feature[i].minimap = MF_DOOR; + f.dchar = DCHAR_DOOR_OPEN; + f.colour = LIGHTGREY; + f.minimap = MF_DOOR; break; case DNGN_CLOSED_DOOR: case DNGN_DETECTED_SECRET_DOOR: - Feature[i].dchar = DCHAR_DOOR_CLOSED; - Feature[i].colour = LIGHTGREY; - Feature[i].minimap = MF_DOOR; + f.dchar = DCHAR_DOOR_CLOSED; + f.colour = LIGHTGREY; + f.minimap = MF_DOOR; break; case DNGN_METAL_WALL: - Feature[i].dchar = DCHAR_WALL; - Feature[i].colour = CYAN; - Feature[i].magic_symbol = Options.char_table[ DCHAR_WALL_MAGIC ]; - Feature[i].minimap = MF_WALL; + f.dchar = DCHAR_WALL; + f.colour = CYAN; + f.magic_symbol = Options.char_table[ DCHAR_WALL_MAGIC ]; + f.minimap = MF_WALL; break; case DNGN_SECRET_DOOR: // Note: get_secret_door_appearance means this probably isn't used. - Feature[i].dchar = DCHAR_WALL; - Feature[i].colour = ETC_ROCK; - Feature[i].magic_symbol = Options.char_table[ DCHAR_WALL_MAGIC ]; - Feature[i].minimap = MF_WALL; + f.dchar = DCHAR_WALL; + f.colour = ETC_ROCK; + f.magic_symbol = Options.char_table[ DCHAR_WALL_MAGIC ]; + f.minimap = MF_WALL; break; case DNGN_GREEN_CRYSTAL_WALL: - Feature[i].dchar = DCHAR_WALL; - Feature[i].colour = GREEN; - Feature[i].magic_symbol = Options.char_table[ DCHAR_WALL_MAGIC ]; - Feature[i].minimap = MF_WALL; + f.dchar = DCHAR_WALL; + f.colour = GREEN; + f.magic_symbol = Options.char_table[ DCHAR_WALL_MAGIC ]; + f.minimap = MF_WALL; break; case DNGN_ORCISH_IDOL: - Feature[i].dchar = DCHAR_STATUE; - Feature[i].colour = BROWN; // same as clay golem, I hope that's okay - Feature[i].minimap = MF_WALL; + f.dchar = DCHAR_STATUE; + f.colour = BROWN; // same as clay golem, I hope that's okay + f.minimap = MF_WALL; break; case DNGN_WAX_WALL: - Feature[i].dchar = DCHAR_WALL; - Feature[i].colour = YELLOW; - Feature[i].magic_symbol = Options.char_table[ DCHAR_WALL_MAGIC ]; - Feature[i].minimap = MF_WALL; + f.dchar = DCHAR_WALL; + f.colour = YELLOW; + f.magic_symbol = Options.char_table[ DCHAR_WALL_MAGIC ]; + f.minimap = MF_WALL; break; case DNGN_GRANITE_STATUE: - Feature[i].dchar = DCHAR_STATUE; - Feature[i].colour = DARKGREY; - Feature[i].minimap = MF_WALL; + f.dchar = DCHAR_STATUE; + f.colour = DARKGREY; + f.minimap = MF_WALL; break; case DNGN_LAVA: - Feature[i].dchar = DCHAR_WAVY; - Feature[i].colour = RED; - Feature[i].minimap = MF_LAVA; + f.dchar = DCHAR_WAVY; + f.colour = RED; + f.minimap = MF_LAVA; break; case DNGN_DEEP_WATER: - Feature[i].dchar = DCHAR_WAVY; - Feature[i].colour = BLUE; - Feature[i].minimap = MF_WATER; + f.dchar = DCHAR_WAVY; + f.colour = BLUE; + f.minimap = MF_WATER; break; case DNGN_SHALLOW_WATER: - Feature[i].dchar = DCHAR_WAVY; - Feature[i].colour = CYAN; - Feature[i].minimap = MF_WATER; + f.dchar = DCHAR_WAVY; + f.colour = CYAN; + f.minimap = MF_WATER; break; case DNGN_FLOOR: - Feature[i].dchar = DCHAR_FLOOR; - Feature[i].colour = ETC_FLOOR; - Feature[i].magic_symbol = Options.char_table[ DCHAR_FLOOR_MAGIC ]; - Feature[i].minimap = MF_FLOOR; + f.dchar = DCHAR_FLOOR; + f.colour = ETC_FLOOR; + f.magic_symbol = Options.char_table[ DCHAR_FLOOR_MAGIC ]; + f.minimap = MF_FLOOR; break; case DNGN_FLOOR_SPECIAL: - Feature[i].dchar = DCHAR_FLOOR; - Feature[i].colour = YELLOW; - Feature[i].magic_symbol = Options.char_table[ DCHAR_FLOOR_MAGIC ]; - Feature[i].minimap = MF_FLOOR; + f.dchar = DCHAR_FLOOR; + f.colour = YELLOW; + f.magic_symbol = Options.char_table[ DCHAR_FLOOR_MAGIC ]; + f.minimap = MF_FLOOR; break; case DNGN_EXIT_HELL: - Feature[i].dchar = DCHAR_ARCH; - Feature[i].colour = LIGHTRED; - Feature[i].map_colour = LIGHTGREY; - Feature[i].seen_colour = LIGHTRED; - Feature[i].minimap = MF_STAIR_UP; + f.dchar = DCHAR_ARCH; + f.colour = LIGHTRED; + f.map_colour = LIGHTGREY; + f.seen_colour = LIGHTRED; + f.minimap = MF_STAIR_UP; break; case DNGN_ENTER_HELL: - Feature[i].dchar = DCHAR_ARCH; - Feature[i].colour = RED; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = LIGHTGREY; - Feature[i].seen_colour = RED; - Feature[i].minimap = MF_STAIR_BRANCH; + f.dchar = DCHAR_ARCH; + f.colour = RED; + f.flags |= FFT_NOTABLE; + f.map_colour = LIGHTGREY; + f.seen_colour = RED; + f.minimap = MF_STAIR_BRANCH; break; case DNGN_TRAP_MECHANICAL: - Feature[i].colour = LIGHTCYAN; - Feature[i].dchar = DCHAR_TRAP; - Feature[i].map_colour = LIGHTCYAN; - Feature[i].minimap = MF_TRAP; + f.colour = LIGHTCYAN; + f.dchar = DCHAR_TRAP; + f.map_colour = LIGHTCYAN; + f.minimap = MF_TRAP; break; case DNGN_TRAP_MAGICAL: - Feature[i].colour = MAGENTA; - Feature[i].dchar = DCHAR_TRAP; - Feature[i].map_colour = MAGENTA; - Feature[i].minimap = MF_TRAP; + f.colour = MAGENTA; + f.dchar = DCHAR_TRAP; + f.map_colour = MAGENTA; + f.minimap = MF_TRAP; break; case DNGN_TRAP_NATURAL: - Feature[i].colour = BROWN; - Feature[i].dchar = DCHAR_TRAP; - Feature[i].map_colour = BROWN; - Feature[i].minimap = MF_TRAP; + f.colour = BROWN; + f.dchar = DCHAR_TRAP; + f.map_colour = BROWN; + f.minimap = MF_TRAP; break; case DNGN_UNDISCOVERED_TRAP: - Feature[i].dchar = DCHAR_FLOOR; - Feature[i].colour = ETC_FLOOR; - Feature[i].magic_symbol = Options.char_table[ DCHAR_FLOOR_MAGIC ]; - Feature[i].minimap = MF_FLOOR; + f.dchar = DCHAR_FLOOR; + f.colour = ETC_FLOOR; + f.magic_symbol = Options.char_table[ DCHAR_FLOOR_MAGIC ]; + f.minimap = MF_FLOOR; break; case DNGN_ENTER_SHOP: - Feature[i].dchar = DCHAR_ARCH; - Feature[i].colour = YELLOW; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = LIGHTGREY; - Feature[i].seen_colour = YELLOW; - Feature[i].minimap = MF_FEATURE; + f.dchar = DCHAR_ARCH; + f.colour = YELLOW; + f.flags |= FFT_NOTABLE; + f.map_colour = LIGHTGREY; + f.seen_colour = YELLOW; + f.minimap = MF_FEATURE; break; case DNGN_ABANDONED_SHOP: - Feature[i].colour = LIGHTGREY; - Feature[i].dchar = DCHAR_ARCH; - Feature[i].map_colour = LIGHTGREY; - Feature[i].minimap = MF_FLOOR; + f.colour = LIGHTGREY; + f.dchar = DCHAR_ARCH; + f.map_colour = LIGHTGREY; + f.minimap = MF_FLOOR; break; case DNGN_ENTER_LABYRINTH: - Feature[i].dchar = DCHAR_ARCH; - Feature[i].colour = CYAN; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = LIGHTGREY; - Feature[i].seen_colour = CYAN; - Feature[i].minimap = MF_STAIR_BRANCH; + f.dchar = DCHAR_ARCH; + f.colour = CYAN; + f.flags |= FFT_NOTABLE; + f.map_colour = LIGHTGREY; + f.seen_colour = CYAN; + f.minimap = MF_STAIR_BRANCH; break; case DNGN_ENTER_PORTAL_VAULT: - Feature[i].flags |= FFT_NOTABLE; + f.flags |= FFT_NOTABLE; // fall through case DNGN_EXIT_PORTAL_VAULT: - Feature[i].dchar = DCHAR_ARCH; - Feature[i].colour = ETC_SHIMMER_BLUE; - Feature[i].map_colour = LIGHTGREY; - Feature[i].seen_colour = ETC_SHIMMER_BLUE; - Feature[i].minimap = MF_STAIR_BRANCH; + f.dchar = DCHAR_ARCH; + f.colour = ETC_SHIMMER_BLUE; + f.map_colour = LIGHTGREY; + f.seen_colour = ETC_SHIMMER_BLUE; + f.minimap = MF_STAIR_BRANCH; break; case DNGN_ESCAPE_HATCH_DOWN: - Feature[i].dchar = DCHAR_STAIRS_DOWN; - Feature[i].colour = BROWN; - Feature[i].map_colour = BROWN; - Feature[i].minimap = MF_STAIR_DOWN; + f.dchar = DCHAR_STAIRS_DOWN; + f.colour = BROWN; + f.map_colour = BROWN; + f.minimap = MF_STAIR_DOWN; break; case DNGN_STONE_STAIRS_DOWN_I: case DNGN_STONE_STAIRS_DOWN_II: case DNGN_STONE_STAIRS_DOWN_III: - Feature[i].dchar = DCHAR_STAIRS_DOWN; - Feature[i].colour = LIGHTGREY; - Feature[i].em_colour = WHITE; - Feature[i].map_colour = RED; - Feature[i].seen_em_colour = WHITE; - Feature[i].minimap = MF_STAIR_DOWN; + f.dchar = DCHAR_STAIRS_DOWN; + f.colour = LIGHTGREY; + f.em_colour = WHITE; + f.map_colour = RED; + f.seen_em_colour = WHITE; + f.minimap = MF_STAIR_DOWN; break; case DNGN_ESCAPE_HATCH_UP: - Feature[i].dchar = DCHAR_STAIRS_UP; - Feature[i].colour = BROWN; - Feature[i].map_colour = BROWN; - Feature[i].minimap = MF_STAIR_UP; + f.dchar = DCHAR_STAIRS_UP; + f.colour = BROWN; + f.map_colour = BROWN; + f.minimap = MF_STAIR_UP; break; case DNGN_STONE_STAIRS_UP_I: case DNGN_STONE_STAIRS_UP_II: case DNGN_STONE_STAIRS_UP_III: - Feature[i].dchar = DCHAR_STAIRS_UP; - Feature[i].colour = LIGHTGREY; - Feature[i].map_colour = GREEN; - Feature[i].em_colour = WHITE; - Feature[i].seen_em_colour = WHITE; - Feature[i].minimap = MF_STAIR_UP; + f.dchar = DCHAR_STAIRS_UP; + f.colour = LIGHTGREY; + f.map_colour = GREEN; + f.em_colour = WHITE; + f.seen_em_colour = WHITE; + f.minimap = MF_STAIR_UP; break; case DNGN_ENTER_DIS: - Feature[i].colour = CYAN; - Feature[i].dchar = DCHAR_ARCH; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = LIGHTGREY; - Feature[i].seen_colour = CYAN; - Feature[i].minimap = MF_STAIR_BRANCH; + f.colour = CYAN; + f.dchar = DCHAR_ARCH; + f.flags |= FFT_NOTABLE; + f.map_colour = LIGHTGREY; + f.seen_colour = CYAN; + f.minimap = MF_STAIR_BRANCH; break; case DNGN_ENTER_GEHENNA: - Feature[i].colour = RED; - Feature[i].dchar = DCHAR_ARCH; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = LIGHTGREY; - Feature[i].seen_colour = RED; - Feature[i].minimap = MF_STAIR_BRANCH; + f.colour = RED; + f.dchar = DCHAR_ARCH; + f.flags |= FFT_NOTABLE; + f.map_colour = LIGHTGREY; + f.seen_colour = RED; + f.minimap = MF_STAIR_BRANCH; break; case DNGN_ENTER_COCYTUS: - Feature[i].colour = LIGHTCYAN; - Feature[i].dchar = DCHAR_ARCH; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = LIGHTGREY; - Feature[i].seen_colour = LIGHTCYAN; - Feature[i].minimap = MF_STAIR_BRANCH; + f.colour = LIGHTCYAN; + f.dchar = DCHAR_ARCH; + f.flags |= FFT_NOTABLE; + f.map_colour = LIGHTGREY; + f.seen_colour = LIGHTCYAN; + f.minimap = MF_STAIR_BRANCH; break; case DNGN_ENTER_TARTARUS: - Feature[i].colour = DARKGREY; - Feature[i].dchar = DCHAR_ARCH; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = LIGHTGREY; - Feature[i].seen_colour = DARKGREY; - Feature[i].minimap = MF_STAIR_BRANCH; + f.colour = DARKGREY; + f.dchar = DCHAR_ARCH; + f.flags |= FFT_NOTABLE; + f.map_colour = LIGHTGREY; + f.seen_colour = DARKGREY; + f.minimap = MF_STAIR_BRANCH; break; case DNGN_ENTER_ABYSS: - Feature[i].colour = ETC_RANDOM; - Feature[i].dchar = DCHAR_ARCH; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = LIGHTGREY; - Feature[i].seen_colour = ETC_RANDOM; - Feature[i].minimap = MF_STAIR_BRANCH; + f.colour = ETC_RANDOM; + f.dchar = DCHAR_ARCH; + f.flags |= FFT_NOTABLE; + f.map_colour = LIGHTGREY; + f.seen_colour = ETC_RANDOM; + f.minimap = MF_STAIR_BRANCH; break; case DNGN_EXIT_ABYSS: - Feature[i].colour = ETC_RANDOM; - Feature[i].dchar = DCHAR_ARCH; - Feature[i].map_colour = ETC_RANDOM; - Feature[i].minimap = MF_STAIR_BRANCH; + f.colour = ETC_RANDOM; + f.dchar = DCHAR_ARCH; + f.map_colour = ETC_RANDOM; + f.minimap = MF_STAIR_BRANCH; break; case DNGN_STONE_ARCH: - Feature[i].colour = LIGHTGREY; - Feature[i].dchar = DCHAR_ARCH; - Feature[i].map_colour = LIGHTGREY; - Feature[i].minimap = MF_FLOOR; + f.colour = LIGHTGREY; + f.dchar = DCHAR_ARCH; + f.map_colour = LIGHTGREY; + f.minimap = MF_FLOOR; break; case DNGN_ENTER_PANDEMONIUM: - Feature[i].colour = LIGHTBLUE; - Feature[i].dchar = DCHAR_ARCH; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = LIGHTGREY; - Feature[i].seen_colour = LIGHTBLUE; - Feature[i].minimap = MF_STAIR_BRANCH; + f.colour = LIGHTBLUE; + f.dchar = DCHAR_ARCH; + f.flags |= FFT_NOTABLE; + f.map_colour = LIGHTGREY; + f.seen_colour = LIGHTBLUE; + f.minimap = MF_STAIR_BRANCH; break; case DNGN_EXIT_PANDEMONIUM: // Note: Has special handling for colouring with mutation. - Feature[i].colour = LIGHTBLUE; - Feature[i].dchar = DCHAR_ARCH; - Feature[i].map_colour = LIGHTGREY; - Feature[i].seen_colour = LIGHTBLUE; - Feature[i].minimap = MF_STAIR_BRANCH; + f.colour = LIGHTBLUE; + f.dchar = DCHAR_ARCH; + f.map_colour = LIGHTGREY; + f.seen_colour = LIGHTBLUE; + f.minimap = MF_STAIR_BRANCH; break; case DNGN_TRANSIT_PANDEMONIUM: - Feature[i].colour = LIGHTGREEN; - Feature[i].dchar = DCHAR_ARCH; - Feature[i].map_colour = LIGHTGREY; - Feature[i].seen_colour = LIGHTGREEN; - Feature[i].minimap = MF_STAIR_BRANCH; + f.colour = LIGHTGREEN; + f.dchar = DCHAR_ARCH; + f.map_colour = LIGHTGREY; + f.seen_colour = LIGHTGREEN; + f.minimap = MF_STAIR_BRANCH; break; case DNGN_ENTER_ORCISH_MINES: @@ -402,21 +400,21 @@ void init_feature_table(void) case DNGN_ENTER_TOMB: case DNGN_ENTER_SWAMP: case DNGN_ENTER_SHOALS: - Feature[i].colour = YELLOW; - Feature[i].dchar = DCHAR_STAIRS_DOWN; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = RED; - Feature[i].seen_colour = YELLOW; - Feature[i].minimap = MF_STAIR_BRANCH; + f.colour = YELLOW; + f.dchar = DCHAR_STAIRS_DOWN; + f.flags |= FFT_NOTABLE; + f.map_colour = RED; + f.seen_colour = YELLOW; + f.minimap = MF_STAIR_BRANCH; break; case DNGN_ENTER_ZOT: - Feature[i].colour = MAGENTA; - Feature[i].dchar = DCHAR_ARCH; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = LIGHTGREY; - Feature[i].seen_colour = MAGENTA; - Feature[i].minimap = MF_STAIR_BRANCH; + f.colour = MAGENTA; + f.dchar = DCHAR_ARCH; + f.flags |= FFT_NOTABLE; + f.map_colour = LIGHTGREY; + f.seen_colour = MAGENTA; + f.minimap = MF_STAIR_BRANCH; break; case DNGN_RETURN_FROM_ORCISH_MINES: @@ -432,308 +430,319 @@ void init_feature_table(void) case DNGN_RETURN_FROM_TOMB: case DNGN_RETURN_FROM_SWAMP: case DNGN_RETURN_FROM_SHOALS: - Feature[i].colour = YELLOW; - Feature[i].dchar = DCHAR_STAIRS_UP; - Feature[i].map_colour = GREEN; - Feature[i].seen_colour = YELLOW; - Feature[i].minimap = MF_STAIR_BRANCH; + f.colour = YELLOW; + f.dchar = DCHAR_STAIRS_UP; + f.map_colour = GREEN; + f.seen_colour = YELLOW; + f.minimap = MF_STAIR_BRANCH; break; case DNGN_RETURN_FROM_ZOT: - Feature[i].colour = MAGENTA; - Feature[i].dchar = DCHAR_ARCH; - Feature[i].map_colour = LIGHTGREY; - Feature[i].seen_colour = MAGENTA; - Feature[i].minimap = MF_STAIR_BRANCH; + f.colour = MAGENTA; + f.dchar = DCHAR_ARCH; + f.map_colour = LIGHTGREY; + f.seen_colour = MAGENTA; + f.minimap = MF_STAIR_BRANCH; break; case DNGN_ALTAR_ZIN: - Feature[i].colour = WHITE; - Feature[i].dchar = DCHAR_ALTAR; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = DARKGREY; - Feature[i].seen_colour = WHITE; - Feature[i].minimap = MF_FEATURE; + f.colour = WHITE; + f.dchar = DCHAR_ALTAR; + f.flags |= FFT_NOTABLE; + f.map_colour = DARKGREY; + f.seen_colour = WHITE; + f.minimap = MF_FEATURE; break; case DNGN_ALTAR_SHINING_ONE: - Feature[i].colour = YELLOW; - Feature[i].dchar = DCHAR_ALTAR; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = DARKGREY; - Feature[i].seen_colour = YELLOW; - Feature[i].minimap = MF_FEATURE; + f.colour = YELLOW; + f.dchar = DCHAR_ALTAR; + f.flags |= FFT_NOTABLE; + f.map_colour = DARKGREY; + f.seen_colour = YELLOW; + f.minimap = MF_FEATURE; break; case DNGN_ALTAR_KIKUBAAQUDGHA: - Feature[i].colour = DARKGREY; - Feature[i].dchar = DCHAR_ALTAR; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = DARKGREY; - Feature[i].seen_colour = DARKGREY; - Feature[i].minimap = MF_FEATURE; + f.colour = DARKGREY; + f.dchar = DCHAR_ALTAR; + f.flags |= FFT_NOTABLE; + f.map_colour = DARKGREY; + f.seen_colour = DARKGREY; + f.minimap = MF_FEATURE; break; case DNGN_ALTAR_YREDELEMNUL: - Feature[i].colour = ETC_UNHOLY; - Feature[i].dchar = DCHAR_ALTAR; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = DARKGREY; - Feature[i].seen_colour = ETC_UNHOLY; - Feature[i].minimap = MF_FEATURE; + f.colour = ETC_UNHOLY; + f.dchar = DCHAR_ALTAR; + f.flags |= FFT_NOTABLE; + f.map_colour = DARKGREY; + f.seen_colour = ETC_UNHOLY; + f.minimap = MF_FEATURE; break; case DNGN_ALTAR_XOM: - Feature[i].colour = ETC_RANDOM; - Feature[i].dchar = DCHAR_ALTAR; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = DARKGREY; - Feature[i].seen_colour = ETC_RANDOM; - Feature[i].minimap = MF_FEATURE; + f.colour = ETC_RANDOM; + f.dchar = DCHAR_ALTAR; + f.flags |= FFT_NOTABLE; + f.map_colour = DARKGREY; + f.seen_colour = ETC_RANDOM; + f.minimap = MF_FEATURE; break; case DNGN_ALTAR_VEHUMET: - Feature[i].colour = ETC_VEHUMET; - Feature[i].dchar = DCHAR_ALTAR; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = DARKGREY; - Feature[i].seen_colour = ETC_VEHUMET; - Feature[i].minimap = MF_FEATURE; + f.colour = ETC_VEHUMET; + f.dchar = DCHAR_ALTAR; + f.flags |= FFT_NOTABLE; + f.map_colour = DARKGREY; + f.seen_colour = ETC_VEHUMET; + f.minimap = MF_FEATURE; break; case DNGN_ALTAR_OKAWARU: - Feature[i].colour = CYAN; - Feature[i].dchar = DCHAR_ALTAR; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = DARKGREY; - Feature[i].seen_colour = CYAN; - Feature[i].minimap = MF_FEATURE; + f.colour = CYAN; + f.dchar = DCHAR_ALTAR; + f.flags |= FFT_NOTABLE; + f.map_colour = DARKGREY; + f.seen_colour = CYAN; + f.minimap = MF_FEATURE; break; case DNGN_ALTAR_MAKHLEB: - Feature[i].colour = ETC_FIRE; - Feature[i].dchar = DCHAR_ALTAR; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = DARKGREY; - Feature[i].seen_colour = ETC_FIRE; - Feature[i].minimap = MF_FEATURE; + f.colour = ETC_FIRE; + f.dchar = DCHAR_ALTAR; + f.flags |= FFT_NOTABLE; + f.map_colour = DARKGREY; + f.seen_colour = ETC_FIRE; + f.minimap = MF_FEATURE; break; case DNGN_ALTAR_SIF_MUNA: - Feature[i].colour = BLUE; - Feature[i].dchar = DCHAR_ALTAR; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = DARKGREY; - Feature[i].seen_colour = BLUE; - Feature[i].minimap = MF_FEATURE; + f.colour = BLUE; + f.dchar = DCHAR_ALTAR; + f.flags |= FFT_NOTABLE; + f.map_colour = DARKGREY; + f.seen_colour = BLUE; + f.minimap = MF_FEATURE; break; case DNGN_ALTAR_TROG: - Feature[i].colour = RED; - Feature[i].dchar = DCHAR_ALTAR; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = DARKGREY; - Feature[i].seen_colour = RED; - Feature[i].minimap = MF_FEATURE; + f.colour = RED; + f.dchar = DCHAR_ALTAR; + f.flags |= FFT_NOTABLE; + f.map_colour = DARKGREY; + f.seen_colour = RED; + f.minimap = MF_FEATURE; break; case DNGN_ALTAR_NEMELEX_XOBEH: - Feature[i].colour = LIGHTMAGENTA; - Feature[i].dchar = DCHAR_ALTAR; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = DARKGREY; - Feature[i].seen_colour = LIGHTMAGENTA; - Feature[i].minimap = MF_FEATURE; + f.colour = LIGHTMAGENTA; + f.dchar = DCHAR_ALTAR; + f.flags |= FFT_NOTABLE; + f.map_colour = DARKGREY; + f.seen_colour = LIGHTMAGENTA; + f.minimap = MF_FEATURE; break; case DNGN_ALTAR_ELYVILON: - Feature[i].colour = LIGHTGREY; - Feature[i].dchar = DCHAR_ALTAR; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = DARKGREY; - Feature[i].seen_colour = LIGHTGREY; - Feature[i].minimap = MF_FEATURE; + f.colour = LIGHTGREY; + f.dchar = DCHAR_ALTAR; + f.flags |= FFT_NOTABLE; + f.map_colour = DARKGREY; + f.seen_colour = LIGHTGREY; + f.minimap = MF_FEATURE; break; case DNGN_ALTAR_LUGONU: - Feature[i].colour = MAGENTA; - Feature[i].dchar = DCHAR_ALTAR; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = DARKGREY; - Feature[i].seen_colour = MAGENTA; - Feature[i].minimap = MF_FEATURE; + f.colour = MAGENTA; + f.dchar = DCHAR_ALTAR; + f.flags |= FFT_NOTABLE; + f.map_colour = DARKGREY; + f.seen_colour = MAGENTA; + f.minimap = MF_FEATURE; break; case DNGN_ALTAR_BEOGH: - Feature[i].colour = ETC_BEOGH; - Feature[i].dchar = DCHAR_ALTAR; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = DARKGREY; - Feature[i].seen_colour = ETC_BEOGH; - Feature[i].minimap = MF_FEATURE; + f.colour = ETC_BEOGH; + f.dchar = DCHAR_ALTAR; + f.flags |= FFT_NOTABLE; + f.map_colour = DARKGREY; + f.seen_colour = ETC_BEOGH; + f.minimap = MF_FEATURE; break; case DNGN_ALTAR_JIYVA: - Feature[i].colour = ETC_SLIME; - Feature[i].dchar = DCHAR_ALTAR; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = DARKGREY; - Feature[i].seen_colour = ETC_SLIME; - Feature[i].minimap = MF_FEATURE; + f.colour = ETC_SLIME; + f.dchar = DCHAR_ALTAR; + f.flags |= FFT_NOTABLE; + f.map_colour = DARKGREY; + f.seen_colour = ETC_SLIME; + f.minimap = MF_FEATURE; break; case DNGN_ALTAR_FEAWN: - Feature[i].colour = GREEN; - Feature[i].dchar = DCHAR_ALTAR; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = DARKGREY; - Feature[i].seen_colour = GREEN; - Feature[i].minimap = MF_FEATURE; + f.colour = GREEN; + f.dchar = DCHAR_ALTAR; + f.flags |= FFT_NOTABLE; + f.map_colour = DARKGREY; + f.seen_colour = GREEN; + f.minimap = MF_FEATURE; break; case DNGN_ALTAR_CHEIBRIADOS: - Feature[i].colour = LIGHTCYAN; - Feature[i].dchar = DCHAR_ALTAR; - Feature[i].flags |= FFT_NOTABLE; - Feature[i].map_colour = DARKGREY; - Feature[i].seen_colour = LIGHTCYAN; - Feature[i].minimap = MF_FEATURE; + f.colour = LIGHTCYAN; + f.dchar = DCHAR_ALTAR; + f.flags |= FFT_NOTABLE; + f.map_colour = DARKGREY; + f.seen_colour = LIGHTCYAN; + f.minimap = MF_FEATURE; break; case DNGN_FOUNTAIN_BLUE: - Feature[i].colour = BLUE; - Feature[i].dchar = DCHAR_FOUNTAIN; - Feature[i].minimap = MF_FEATURE; + f.colour = BLUE; + f.dchar = DCHAR_FOUNTAIN; + f.minimap = MF_FEATURE; break; case DNGN_FOUNTAIN_SPARKLING: - Feature[i].colour = LIGHTBLUE; - Feature[i].dchar = DCHAR_FOUNTAIN; - Feature[i].minimap = MF_FEATURE; + f.colour = LIGHTBLUE; + f.dchar = DCHAR_FOUNTAIN; + f.minimap = MF_FEATURE; break; case DNGN_FOUNTAIN_BLOOD: - Feature[i].colour = RED; - Feature[i].dchar = DCHAR_FOUNTAIN; - Feature[i].minimap = MF_FEATURE; + f.colour = RED; + f.dchar = DCHAR_FOUNTAIN; + f.minimap = MF_FEATURE; break; case DNGN_DRY_FOUNTAIN_BLUE: case DNGN_DRY_FOUNTAIN_SPARKLING: case DNGN_DRY_FOUNTAIN_BLOOD: case DNGN_PERMADRY_FOUNTAIN: - Feature[i].colour = LIGHTGREY; - Feature[i].dchar = DCHAR_FOUNTAIN; - Feature[i].minimap = MF_FEATURE; + f.colour = LIGHTGREY; + f.dchar = DCHAR_FOUNTAIN; + f.minimap = MF_FEATURE; break; + } - case DNGN_INVIS_EXPOSED: - Feature[i].dchar = DCHAR_INVIS_EXPOSED; - Feature[i].minimap = MF_MONS_HOSTILE; - break; + if (feat == DNGN_ENTER_ORCISH_MINES || feat == DNGN_ENTER_SLIME_PITS + || feat == DNGN_ENTER_LABYRINTH) + { + f.flags |= FFT_EXAMINE_HINT; + } +} - case DNGN_ITEM_DETECTED: - Feature[i].dchar = DCHAR_ITEM_DETECTED; - Feature[i].minimap = MF_ITEM; +void _init_item(feature_def &f, show_item_type item) +{ + f.minimap = MF_ITEM; + switch (item) + { + case SHOW_ITEM_DETECTED: + f.dchar = DCHAR_ITEM_DETECTED; break; - case DNGN_ITEM_ORB: - Feature[i].dchar = DCHAR_ITEM_ORB; - Feature[i].minimap = MF_ITEM; + case SHOW_ITEM_ORB: + f.dchar = DCHAR_ITEM_ORB; break; - case DNGN_ITEM_WEAPON: - Feature[i].dchar = DCHAR_ITEM_WEAPON; - Feature[i].minimap = MF_ITEM; + case SHOW_ITEM_WEAPON: + f.dchar = DCHAR_ITEM_WEAPON; break; - case DNGN_ITEM_ARMOUR: - Feature[i].dchar = DCHAR_ITEM_ARMOUR; - Feature[i].minimap = MF_ITEM; + case SHOW_ITEM_ARMOUR: + f.dchar = DCHAR_ITEM_ARMOUR; break; - case DNGN_ITEM_WAND: - Feature[i].dchar = DCHAR_ITEM_WAND; - Feature[i].minimap = MF_ITEM; + case SHOW_ITEM_WAND: + f.dchar = DCHAR_ITEM_WAND; break; - case DNGN_ITEM_FOOD: - Feature[i].dchar = DCHAR_ITEM_FOOD; - Feature[i].minimap = MF_ITEM; + case SHOW_ITEM_FOOD: + f.dchar = DCHAR_ITEM_FOOD; break; - case DNGN_ITEM_SCROLL: - Feature[i].dchar = DCHAR_ITEM_SCROLL; - Feature[i].minimap = MF_ITEM; + case SHOW_ITEM_SCROLL: + f.dchar = DCHAR_ITEM_SCROLL; break; - case DNGN_ITEM_RING: - Feature[i].dchar = DCHAR_ITEM_RING; - Feature[i].minimap = MF_ITEM; + case SHOW_ITEM_RING: + f.dchar = DCHAR_ITEM_RING; break; - case DNGN_ITEM_POTION: - Feature[i].dchar = DCHAR_ITEM_POTION; - Feature[i].minimap = MF_ITEM; + case SHOW_ITEM_POTION: + f.dchar = DCHAR_ITEM_POTION; break; - case DNGN_ITEM_MISSILE: - Feature[i].dchar = DCHAR_ITEM_MISSILE; - Feature[i].minimap = MF_ITEM; + case SHOW_ITEM_MISSILE: + f.dchar = DCHAR_ITEM_MISSILE; break; - case DNGN_ITEM_BOOK: - Feature[i].dchar = DCHAR_ITEM_BOOK; - Feature[i].minimap = MF_ITEM; + case SHOW_ITEM_BOOK: + f.dchar = DCHAR_ITEM_BOOK; break; - case DNGN_ITEM_STAVE: - Feature[i].dchar = DCHAR_ITEM_STAVE; - Feature[i].minimap = MF_ITEM; + case SHOW_ITEM_STAVE: + f.dchar = DCHAR_ITEM_STAVE; break; - case DNGN_ITEM_MISCELLANY: - Feature[i].dchar = DCHAR_ITEM_MISCELLANY; - Feature[i].minimap = MF_ITEM; + case SHOW_ITEM_MISCELLANY: + f.dchar = DCHAR_ITEM_MISCELLANY; break; - case DNGN_ITEM_CORPSE: - Feature[i].dchar = DCHAR_ITEM_CORPSE; - Feature[i].minimap = MF_ITEM; + case SHOW_ITEM_CORPSE: + f.dchar = DCHAR_ITEM_CORPSE; break; - case DNGN_ITEM_GOLD: - Feature[i].dchar = DCHAR_ITEM_GOLD; - Feature[i].minimap = MF_ITEM; + case SHOW_ITEM_GOLD: + f.dchar = DCHAR_ITEM_GOLD; break; - case DNGN_ITEM_AMULET: - Feature[i].dchar = DCHAR_ITEM_AMULET; - Feature[i].minimap = MF_ITEM; + case SHOW_ITEM_AMULET: + f.dchar = DCHAR_ITEM_AMULET; break; + } +} - case DNGN_CLOUD: - Feature[i].dchar = DCHAR_CLOUD; - Feature[i].minimap = MF_SKIP; - break; - } +void init_show_table(void) +{ + show_type obj; + for (int i = 0; i < NUM_FEATURES; i++) + { + obj.cls = SH_FEATURE; + obj.feat = static_cast<dungeon_feature_type>(i); - if (i == DNGN_ENTER_ORCISH_MINES || i == DNGN_ENTER_SLIME_PITS - || i == DNGN_ENTER_LABYRINTH) - { - Feature[i].flags |= FFT_EXAMINE_HINT; - } + _init_feat(Features[obj], obj.feat); + } + + obj.cls = SH_INVIS_EXPOSED; + Features[obj].dchar = DCHAR_INVIS_EXPOSED; + Features[obj].minimap = MF_MONS_HOSTILE; - if (Feature[i].dchar != NUM_DCHAR_TYPES) - Feature[i].symbol = Options.char_table[ Feature[i].dchar ]; + for (int i = 0; i < NUM_SHOW_ITEMS; i++) + { + obj.cls = SH_ITEM; + obj.item = static_cast<show_item_type>(i); + + _init_item(Features[obj], obj.item); } - apply_feature_overrides(); + obj.cls = SH_CLOUD; + Features[obj].dchar = DCHAR_CLOUD; + Features[obj].minimap = MF_SKIP; - for (int i = 0; i < NUM_FEATURES; ++i) + for (feat_map::iterator i = Features.begin(); i != Features.end(); ++i) { - feature_def &f(Feature[i]); + feature_def &f = i->second; + if (f.dchar != NUM_DCHAR_TYPES) + f.symbol = Options.char_table[f.dchar]; + } + apply_feature_overrides(); + + for (feat_map::iterator i = Features.begin(); i != Features.end(); ++i) + { + feature_def &f = i->second; if (!f.magic_symbol) f.magic_symbol = f.symbol; diff --git a/crawl-ref/source/feature.h b/crawl-ref/source/feature.h index f9a7115693..feda02a1a3 100644 --- a/crawl-ref/source/feature.h +++ b/crawl-ref/source/feature.h @@ -1,6 +1,8 @@ #ifndef FEATURE_H #define FEATURE_H +#include "show.h" + struct feature_def { dungeon_char_type dchar; @@ -14,17 +16,31 @@ struct feature_def unsigned flags; map_feature minimap; // mini-map categorization + feature_def() : + dchar(NUM_DCHAR_TYPES), + symbol(0), + magic_symbol(0), + colour(BLACK), + map_colour(DARKGREY), + seen_colour(BLACK), + em_colour(BLACK), + seen_em_colour(BLACK), + flags(FFT_NONE), + minimap(MF_UNSEEN) + {} + bool is_notable() const { return (flags & FFT_NOTABLE); } }; struct feature_override { - dungeon_feature_type feat; - feature_def override; + show_type object; + feature_def override; }; +const feature_def &get_feature_def(show_type object); const feature_def &get_feature_def(dungeon_feature_type feat); -void init_feature_table(); +void init_show_table(); #endif diff --git a/crawl-ref/source/files.cc b/crawl-ref/source/files.cc index 4dbcefceb9..e989cac4a2 100644 --- a/crawl-ref/source/files.cc +++ b/crawl-ref/source/files.cc @@ -1224,7 +1224,7 @@ bool load( dungeon_feature_type stair_taken, load_mode_type load_mode, // Clear the show grid, to prevent us noticing things // which were within the old LOS by new coordinates. - env.show.init(0); + env.show_los.init(0); // Try to open level savefile. #ifdef DEBUG_LEVEL_LOAD diff --git a/crawl-ref/source/initfile.cc b/crawl-ref/source/initfile.cc index 63416e0fc6..dc9c95b21a 100644 --- a/crawl-ref/source/initfile.cc +++ b/crawl-ref/source/initfile.cc @@ -1091,8 +1091,11 @@ void game_options::add_feature_override(const std::string &text) for (int i = 0, size = feats.size(); i < size; ++i) { + if (feats[i] >= NUM_FEATURES) + continue; // TODO: handle other object types. feature_override fov; - fov.feat = feats[i]; + fov.object.cls = SH_FEATURE; + fov.object.feat = feats[i]; fov.override.symbol = read_symbol(iprops[0]); fov.override.magic_symbol = read_symbol(iprops[1]); diff --git a/crawl-ref/source/l_debug.cc b/crawl-ref/source/l_debug.cc index d8cb466bae..a8fb968535 100644 --- a/crawl-ref/source/l_debug.cc +++ b/crawl-ref/source/l_debug.cc @@ -44,7 +44,7 @@ LUAFN(debug_flush_map_memory) LUAFN(debug_generate_level) { no_messages mx; - env.show.init(0); + env.show_los.init(0); env.map.init(map_cell()); #ifdef USE_TILE tile_init_default_flavour(); diff --git a/crawl-ref/source/l_dgngrd.cc b/crawl-ref/source/l_dgngrd.cc index 39f33d76f5..e500326136 100644 --- a/crawl-ref/source/l_dgngrd.cc +++ b/crawl-ref/source/l_dgngrd.cc @@ -64,7 +64,7 @@ const char *dngn_feature_names[] = dungeon_feature_type dungeon_feature_by_name(const std::string &name) { - COMPILE_CHECK(ARRAYSZ(dngn_feature_names) == NUM_REAL_FEATURES, c1); + COMPILE_CHECK(ARRAYSZ(dngn_feature_names) == NUM_FEATURES, c1); if (name.empty()) return (DNGN_UNSEEN); @@ -79,7 +79,7 @@ std::vector<std::string> dungeon_feature_matches(const std::string &name) { std::vector<std::string> matches; - COMPILE_CHECK(ARRAYSZ(dngn_feature_names) == NUM_REAL_FEATURES, c1); + COMPILE_CHECK(ARRAYSZ(dngn_feature_names) == NUM_FEATURES, c1); if (name.empty()) return (matches); diff --git a/crawl-ref/source/libgui.cc b/crawl-ref/source/libgui.cc index 721572327c..e00eb851e1 100644 --- a/crawl-ref/source/libgui.cc +++ b/crawl-ref/source/libgui.cc @@ -35,11 +35,11 @@ int tile_idx_unseen_terrain(int x, int y, int what) { const coord_def gc(x,y); - unsigned int feature = grd(gc); + dungeon_feature_type feature = grd(gc); unsigned int grid_symbol; unsigned short grid_color; - get_item_symbol(feature, &grid_symbol, &grid_color); + get_show_symbol(show_type(feature), &grid_symbol, &grid_color); unsigned int t = tileidx_feature(feature, gc.x, gc.y); if (t == TILE_ERROR || what == ' ') diff --git a/crawl-ref/source/los.cc b/crawl-ref/source/los.cc index 408d5e9ff0..6c0eb0936a 100644 --- a/crawl-ref/source/los.cc +++ b/crawl-ref/source/los.cc @@ -696,7 +696,7 @@ dungeon_feature_type ray_blocker(const coord_def& source, if (!find_ray(source, target, ray, opc_default)) { ASSERT (false); - return (NUM_REAL_FEATURES); + return (NUM_FEATURES); } ray.advance(); @@ -709,7 +709,7 @@ dungeon_feature_type ray_blocker(const coord_def& source, ray.advance(); } ASSERT (false); - return (NUM_REAL_FEATURES); + return (NUM_FEATURES); } // Returns a straight ray from source to target. @@ -1001,7 +1001,7 @@ void calc_show_los() { if (!crawl_state.arena && !crawl_state.arena_suspended) { - losight(env.show, you.pos()); + losight(env.show_los, you.pos()); // What would be visible, if all of the translucent walls were // made opaque. @@ -1010,7 +1010,7 @@ void calc_show_los() } else { - losight_permissive(env.show, crawl_view.glosc()); + losight_permissive(env.show_los, crawl_view.glosc()); } } @@ -1036,7 +1036,7 @@ bool see_cell(const coord_def &p) { return (((crawl_state.arena || crawl_state.arena_suspended) && crawl_view.in_grid_los(p)) - || see_cell(env.show, you.pos(), p)); + || see_cell(env.show_los, you.pos(), p)); } // Answers the question: "Would a cell be within character's line of sight, diff --git a/crawl-ref/source/makefile.obj b/crawl-ref/source/makefile.obj index b47df8f2a3..fff4ef0229 100644 --- a/crawl-ref/source/makefile.obj +++ b/crawl-ref/source/makefile.obj @@ -116,6 +116,7 @@ religion.o \ rng.o \ sha256.o \ shopping.o \ +show.o \ skills.o \ skills2.o \ species.o \ diff --git a/crawl-ref/source/mon-behv.cc b/crawl-ref/source/mon-behv.cc index f7be683b9b..4335854400 100644 --- a/crawl-ref/source/mon-behv.cc +++ b/crawl-ref/source/mon-behv.cc @@ -40,21 +40,18 @@ static void _check_lava_water_in_sight() // XXX: remove explicit coordinate translation. const coord_def ep = *ri - you.pos() + coord_def(ENV_SHOW_OFFSET, ENV_SHOW_OFFSET); - if (env.show(ep)) + const dungeon_feature_type feat = grd(*ri); + if (feat == DNGN_LAVA) { - const dungeon_feature_type feat = grd(*ri); - if (feat == DNGN_LAVA) - { - you.lava_in_sight = 1; - if (you.water_in_sight > 0) - break; - } - else if (feat == DNGN_DEEP_WATER) - { - you.water_in_sight = 1; - if (you.lava_in_sight > 0) - break; - } + you.lava_in_sight = 1; + if (you.water_in_sight > 0) + break; + } + else if (feat == DNGN_DEEP_WATER) + { + you.water_in_sight = 1; + if (you.lava_in_sight > 0) + break; } } } diff --git a/crawl-ref/source/mon-util.cc b/crawl-ref/source/mon-util.cc index 35ebd6a443..0cf2f20930 100644 --- a/crawl-ref/source/mon-util.cc +++ b/crawl-ref/source/mon-util.cc @@ -3226,7 +3226,7 @@ std::string do_mon_str_replacements(const std::string &in_msg, if (see_cell(monster->pos())) { dungeon_feature_type feat = grd(monster->pos()); - if (feat < DNGN_MINMOVE || feat >= NUM_REAL_FEATURES) + if (feat < DNGN_MINMOVE || feat >= NUM_FEATURES) msg = replace_all(msg, "@surface@", "buggy surface"); else if (feat == DNGN_LAVA) msg = replace_all(msg, "@surface@", "lava"); diff --git a/crawl-ref/source/overmap.cc b/crawl-ref/source/overmap.cc index 7c33da7f73..55cbbd2f05 100644 --- a/crawl-ref/source/overmap.cc +++ b/crawl-ref/source/overmap.cc @@ -64,8 +64,7 @@ static void _seen_staircase(dungeon_feature_type which_staircase, static void _seen_other_thing(dungeon_feature_type which_thing, const coord_def& pos); -void seen_notable_thing( dungeon_feature_type which_thing, - const coord_def& pos ) +void seen_notable_thing(dungeon_feature_type which_thing, const coord_def& pos) { // Tell the world first. dungeon_events.fire_position_event(DET_PLAYER_IN_LOS, pos); diff --git a/crawl-ref/source/show.cc b/crawl-ref/source/show.cc new file mode 100644 index 0000000000..3a5e8908c4 --- /dev/null +++ b/crawl-ref/source/show.cc @@ -0,0 +1,224 @@ +#include "AppHdr.h" + +#include "show.h" + +#include "cloud.h" +#include "coordit.h" +#include "directn.h" +#include "feature.h" +#include "mon-util.h" +#include "monster.h" +#include "options.h" +#include "state.h" +#include "terrain.h" +#include "view.h" + +void get_show_symbol(show_type object, unsigned *ch, + unsigned short *colour) +{ + if (object.cls < SH_MONSTER) + { + *ch = get_feature_def(object).symbol; + + // Don't clobber with BLACK, because the colour should be already set. + if (get_feature_def(object).colour != BLACK) + *colour = get_feature_def(object).colour; + } + *colour = real_colour(*colour); +} + +show_type::show_type(const monsters* m) + : cls(SH_MONSTER), mons(m->type) {} + +show_type::show_type(dungeon_feature_type f) + : cls(SH_FEATURE), feat(f) {} + +static show_item_type _item_to_show_code(const item_def &item); + +show_type::show_type(const item_def &it) + : cls(SH_ITEM), item(_item_to_show_code(it)) {} + +show_type::show_type(show_item_type t) + : cls(SH_ITEM), item(t) {} + +bool show_type::operator < (const show_type &other) const +{ + if (cls < other.cls) + return (false); + else if (cls > other.cls) + return (true); + switch (cls) + { + case SH_FEATURE: + return (feat < other.feat); + case SH_ITEM: + return (item < other.item); + case SH_MONSTER: + return (mons < other.mons); + default: + return (false); + } +} + +void show_def::_set_backup(const coord_def &ep) +{ + backup(ep) = grid(ep); +} + +void show_def::_update_feat_at(const coord_def &gp, const coord_def &ep) +{ + grid(ep).cls = SH_FEATURE; + grid(ep).feat = grid_appearance(gp); + grid(ep).colour = 0; +} + +static show_item_type _item_to_show_code(const item_def &item) +{ + switch (item.base_type) + { + case OBJ_ORBS: return (SHOW_ITEM_ORB); + case OBJ_WEAPONS: return (SHOW_ITEM_WEAPON); + case OBJ_MISSILES: return (SHOW_ITEM_MISSILE); + case OBJ_ARMOUR: return (SHOW_ITEM_ARMOUR); + case OBJ_WANDS: return (SHOW_ITEM_WAND); + case OBJ_FOOD: return (SHOW_ITEM_FOOD); + case OBJ_SCROLLS: return (SHOW_ITEM_SCROLL); + case OBJ_JEWELLERY: + return (jewellery_is_amulet(item)? SHOW_ITEM_AMULET : SHOW_ITEM_RING); + case OBJ_POTIONS: return (SHOW_ITEM_POTION); + case OBJ_BOOKS: return (SHOW_ITEM_BOOK); + case OBJ_STAVES: return (SHOW_ITEM_STAVE); + case OBJ_MISCELLANY: return (SHOW_ITEM_MISCELLANY); + case OBJ_CORPSES: return (SHOW_ITEM_CORPSE); + case OBJ_GOLD: return (SHOW_ITEM_GOLD); + default: return (SHOW_ITEM_ORB); // bad item character + } +} + +void show_def::_update_item_at(const coord_def &gp, const coord_def &ep) +{ + const item_def &eitem = mitm[igrd(gp)]; + unsigned short &ecol = grid(ep).colour; + + const dungeon_feature_type feat = grd(gp); + if (Options.feature_item_brand && is_critical_feature(feat)) + ecol |= COLFLAG_FEATURE_ITEM; + else if (Options.trap_item_brand && feat_is_trap(feat)) + ecol |= COLFLAG_TRAP_ITEM; + else + { + const unsigned short gcol = env.grid_colours(gp); + ecol = (feat == DNGN_SHALLOW_WATER) ? + (gcol != BLACK ? gcol : CYAN) : eitem.colour; + if (eitem.link != NON_ITEM && !crawl_state.arena) + ecol |= COLFLAG_ITEM_HEAP; + grid(ep).cls = SH_ITEM; + grid(ep).item = _item_to_show_code(eitem); + } + +#ifdef USE_TILE + int idx = igrd(gp); + if (feat_is_stair(feat)) + tile_place_item_marker(ep.x, ep.y, idx); + else + tile_place_item(ep.x, ep.y, idx); +#endif +} + +void show_def::_update_cloud(int cloudno) +{ + const coord_def e = grid2show(env.cloud[cloudno].pos); + int which_colour = get_cloud_colour(cloudno); + _set_backup(e); + grid(e).cls = SH_CLOUD; + grid(e).colour = which_colour; + +#ifdef USE_TILE + tile_place_cloud(e.x, e.y, env.cloud[cloudno].type, + env.cloud[cloudno].decay); +#endif +} + +bool show_def::update_monster(const monsters* mons) +{ + const coord_def e = grid2show(mons->pos()); + + if (!mons->visible_to(&you)) + { + // ripple effect? + if (grd(mons->pos()) == DNGN_SHALLOW_WATER + && !mons_flies(mons) + && env.cgrid(mons->pos()) == EMPTY_CLOUD) + { + _set_backup(e); + grid(e).cls = SH_INVIS_EXPOSED; + + // Translates between colours used for shallow and deep water, + // if not using the normal LIGHTCYAN / BLUE. The ripple uses + // the deep water colour. + unsigned short base_colour = env.grid_colours(mons->pos()); + + static const unsigned short ripple_table[] = + {BLUE, // BLACK => BLUE (default) + BLUE, // BLUE => BLUE + GREEN, // GREEN => GREEN + CYAN, // CYAN => CYAN + RED, // RED => RED + MAGENTA, // MAGENTA => MAGENTA + BROWN, // BROWN => BROWN + DARKGREY, // LIGHTGREY => DARKGREY + DARKGREY, // DARKGREY => DARKGREY + BLUE, // LIGHTBLUE => BLUE + GREEN, // LIGHTGREEN => GREEN + BLUE, // LIGHTCYAN => BLUE + RED, // LIGHTRED => RED + MAGENTA, // LIGHTMAGENTA => MAGENTA + BROWN, // YELLOW => BROWN + LIGHTGREY}; // WHITE => LIGHTGREY + + grid(e).colour = ripple_table[base_colour & 0x0f]; + } + return (false); + } + + // Mimics are always left on map. + if (!mons_is_mimic(mons->type)) + _set_backup(e); + + grid(e).cls = SH_MONSTER; + grid(e).mons = mons->type; + grid(e).colour = get_mons_colour(mons); + + return (true); +} + +void show_def::update_at(const coord_def &gp, const coord_def &ep) +{ + grid(ep).cls = SH_NOTHING; + + // The sequence is grid, items, clouds, monsters. + _update_feat_at(gp, ep); + + if (igrd(gp) != NON_ITEM) + _update_item_at(gp, ep); + + const int cloud = env.cgrid(gp); + if (cloud != EMPTY_CLOUD && env.cloud[cloud].type != CLOUD_NONE + && env.cloud[cloud].pos == gp) + { + _update_cloud(cloud); + } + + const monsters *mons = monster_at(gp); + if (mons && mons->alive()) + update_monster(mons); +} + +void show_def::init() +{ + grid.init(show_type()); + backup.init(show_type()); + + for (radius_iterator ri(you.pos(), LOS_RADIUS); ri; ++ri) + update_at(*ri, grid2show(*ri)); +} diff --git a/crawl-ref/source/show.h b/crawl-ref/source/show.h new file mode 100644 index 0000000000..ea19d4485f --- /dev/null +++ b/crawl-ref/source/show.h @@ -0,0 +1,98 @@ +#ifndef SHOW_H +#define SHOW_H + +#include "fixary.h" + +enum show_item_type +{ + SHOW_ITEM_ORB, + SHOW_ITEM_WEAPON, + SHOW_ITEM_ARMOUR, + SHOW_ITEM_WAND, + SHOW_ITEM_FOOD, + SHOW_ITEM_SCROLL, + SHOW_ITEM_RING, + SHOW_ITEM_POTION, + SHOW_ITEM_MISSILE, + SHOW_ITEM_BOOK, + SHOW_ITEM_STAVE, + SHOW_ITEM_MISCELLANY, + SHOW_ITEM_CORPSE, + SHOW_ITEM_GOLD, + SHOW_ITEM_AMULET, + SHOW_ITEM_DETECTED, + NUM_SHOW_ITEMS +}; + +enum show_class +{ + SH_NOTHING, + SH_FEATURE, + SH_ITEM, + SH_CLOUD, + SH_INVIS_EXPOSED, + SH_MONSTER, + NUM_SHOW_CLASSES +}; + +struct show_type +{ + show_class cls; + union + { + dungeon_feature_type feat; + show_item_type item; + monster_type mons; + }; + unsigned short colour; + + show_type() : cls(SH_NOTHING), colour(0) {} + show_type(dungeon_feature_type f); + show_type(const item_def &item); + show_type(show_item_type itemtype); + show_type(const monsters* mons); + + operator bool() const { return (cls != SH_NOTHING); } + + bool operator < (const show_type &other) const; +}; + +struct map_cell +{ + show_type object; // The object: monster, item, feature, or cloud. + unsigned short flags; // Flags describing the mappedness of this square. + unsigned short colour; + unsigned long property; // Flags for blood, sanctuary, ... + + map_cell() : object(), flags(0), colour(0), property(0) { } + void clear() { flags = colour = 0; object = show_type(); } + + unsigned glyph() const; + bool known() const; + bool seen() const; +}; + +// Replaces get_item_symbol. +void get_show_symbol(show_type object, unsigned *ch, unsigned short *colour); + +class monsters; +class show_def +{ + FixedArray<show_type, ENV_SHOW_DIAMETER, ENV_SHOW_DIAMETER> grid; + FixedArray<show_type, ENV_SHOW_DIAMETER, ENV_SHOW_DIAMETER> backup; + + void _update_feat_at(const coord_def &gp, const coord_def &ep); + void _update_item_at(const coord_def &gp, const coord_def &ep); + void _update_cloud(int cloudno); + void _set_backup(const coord_def &e); + +public: + show_type operator()(const coord_def &ep) const { return grid(ep); } + show_type get_backup(const coord_def &ep) const { return backup(ep); } + + void init(); + bool update_monster(const monsters *monster); + void update_at(const coord_def &gp, const coord_def &ep); +}; + +#endif diff --git a/crawl-ref/source/spells2.cc b/crawl-ref/source/spells2.cc index 660c5de06f..8d857c3f10 100644 --- a/crawl-ref/source/spells2.cc +++ b/crawl-ref/source/spells2.cc @@ -68,7 +68,7 @@ int detect_traps(int pow) { traps_found++; trap.reveal(); - set_envmap_obj(trap.pos, grd(trap.pos)); + set_envmap_obj(trap.pos, show_type(grd(trap.pos))); set_terrain_mapped(trap.pos); } } @@ -95,7 +95,7 @@ int detect_items(int pow) { items_found++; - set_envmap_obj(*ri, DNGN_ITEM_DETECTED); + set_envmap_obj(*ri, show_type(SHOW_ITEM_DETECTED)); set_envmap_detected_item(*ri); #ifdef USE_TILE // Don't replace previously seen items with an unseen one. @@ -170,7 +170,7 @@ static bool _mark_detected_creature(coord_def where, const monsters *mon, where = place; } - set_envmap_obj(where, mon->type + DNGN_START_OF_MONSTERS); + set_envmap_obj(where, show_type(mon)); set_envmap_detected_mons(where); #ifdef USE_TILE diff --git a/crawl-ref/source/stuff.cc b/crawl-ref/source/stuff.cc index ba3fd80765..3fefb11e7b 100644 --- a/crawl-ref/source/stuff.cc +++ b/crawl-ref/source/stuff.cc @@ -861,7 +861,7 @@ bool is_trap_square(dungeon_feature_type grid) // applied to new games. void zap_los_monsters() { - losight(env.show, you.pos()); + losight(env.show_los, you.pos()); for (rectangle_iterator ri(crawl_view.vlos1, crawl_view.vlos2); ri; ++ri ) { diff --git a/crawl-ref/source/tags.cc b/crawl-ref/source/tags.cc index 9300e7329b..a05a0bd18a 100644 --- a/crawl-ref/source/tags.cc +++ b/crawl-ref/source/tags.cc @@ -1708,7 +1708,7 @@ static void tag_construct_level(writer &th) for (int count_y = 0; count_y < GYM; count_y++) { marshallByte(th, grd[count_x][count_y]); - marshallShort(th, env.map[count_x][count_y].object); + marshallShowtype(th, env.map[count_x][count_y].object); marshallShort(th, env.map[count_x][count_y].colour); marshallShort(th, env.map[count_x][count_y].flags); marshallLong(th, env.map[count_x][count_y].property); @@ -1810,6 +1810,22 @@ void unmarshallItem(reader &th, item_def &item) item.props.read(th); } +void marshallShowtype(writer &th, const show_type &obj) +{ + marshallByte(th, obj.cls); + marshallShort(th, obj.feat); // union + marshallShort(th, obj.colour); +} + +show_type unmarshallShowtype(reader &th) +{ + show_type obj; + obj.cls = static_cast<show_class>(unmarshallByte(th)); + obj.feat = static_cast<dungeon_feature_type>(unmarshallShort(th)); + obj.colour = unmarshallShort(th); + return (obj); +} + static void tag_construct_level_items(writer &th) { // how many traps? @@ -2073,7 +2089,7 @@ static void tag_read_level( reader &th, char minorVersion ) static_cast<dungeon_feature_type>( static_cast<unsigned char>(unmarshallByte(th)) ); - env.map[i][j].object = unmarshallShort(th); + env.map[i][j].object = unmarshallShowtype(th); env.map[i][j].colour = unmarshallShort(th); env.map[i][j].flags = unmarshallShort(th); env.map[i][j].property = unmarshallLong(th); diff --git a/crawl-ref/source/tags.h b/crawl-ref/source/tags.h index 3bb38318fd..ce2ec65a68 100644 --- a/crawl-ref/source/tags.h +++ b/crawl-ref/source/tags.h @@ -11,6 +11,8 @@ #include <stdint.h> #include "externs.h" +struct show_type; + enum tag_type // used during save/load process to identify data blocks { TAG_NO_TAG = 0, // should NEVER be read in! @@ -92,6 +94,7 @@ void marshallString (writer &, const std::string &, int maxSize = 0); void marshallString4 (writer &, const std::string &); void marshallCoord (writer &, const coord_def &); void marshallItem (writer &, const item_def &); +void marshallShowtype (writer &, const show_type &); /* *********************************************************************** * reader API @@ -124,6 +127,7 @@ std::string unmarshallString (reader &, int maxSize = 1000); void unmarshallString4 (reader &, std::string&); void unmarshallCoord (reader &, coord_def &c); void unmarshallItem (reader &, item_def &item); +show_type unmarshallShowtype (reader &); /* *********************************************************************** * Tag interface diff --git a/crawl-ref/source/terrain.cc b/crawl-ref/source/terrain.cc index a3b1e48ff3..47b66af04a 100644 --- a/crawl-ref/source/terrain.cc +++ b/crawl-ref/source/terrain.cc @@ -480,17 +480,6 @@ void get_door_description(int door_size, const char** adjective, const char** no *noun = descriptions[idx+1]; } -unsigned int show_appearance(const coord_def &ep) -{ - unsigned int object = env.show(ep); - const coord_def gc = show2grid(ep); - - if (object == DNGN_SECRET_DOOR) - object = grid_secret_door_appearance(gc); - - return object; -} - dungeon_feature_type grid_appearance(const coord_def &gc) { dungeon_feature_type feat = env.grid(gc); diff --git a/crawl-ref/source/terrain.h b/crawl-ref/source/terrain.h index 2c442ced2f..2bb3fb5d1e 100644 --- a/crawl-ref/source/terrain.h +++ b/crawl-ref/source/terrain.h @@ -62,7 +62,6 @@ void find_connected_range(coord_def d, dungeon_feature_type ft_min, void get_door_description(int door_size, const char** adjective, const char** noun); dungeon_feature_type grid_secret_door_appearance(const coord_def &where); dungeon_feature_type grid_appearance(const coord_def &gc); -unsigned int show_appearance(const coord_def &ep); bool feat_destroys_items(dungeon_feature_type feat); const char *feat_item_destruction_message( dungeon_feature_type feat ); diff --git a/crawl-ref/source/tilepick.cc b/crawl-ref/source/tilepick.cc index 9e43162d58..8b696a0ae5 100644 --- a/crawl-ref/source/tilepick.cc +++ b/crawl-ref/source/tilepick.cc @@ -2343,11 +2343,9 @@ static int _tileidx_shop(coord_def where) } } -int tileidx_feature(int object, int gx, int gy) +int tileidx_feature(dungeon_feature_type feat, int gx, int gy) { - ASSERT(object < NUM_REAL_FEATURES); - - switch (object) + switch (feat) { case DNGN_UNSEEN: return TILE_DNGN_UNSEEN; @@ -2363,7 +2361,7 @@ int tileidx_feature(int object, int gx, int gy) const dungeon_feature_type appear = grid_secret_door_appearance(coord_def(gx, gy)); ASSERT(!feat_is_secret_door(appear)); - return tileidx_feature((int) appear, gx, gy); + return tileidx_feature(appear, gx, gy); } case DNGN_CLEAR_ROCK_WALL: case DNGN_CLEAR_STONE_WALL: @@ -2553,9 +2551,9 @@ int tileidx_feature(int object, int gx, int gy) case DNGN_DRY_FOUNTAIN_BLOOD: case DNGN_PERMADRY_FOUNTAIN: return TILE_DNGN_DRY_FOUNTAIN; + default: + return TILE_DNGN_ERROR; } - - return TILE_DNGN_ERROR; } static int _tileidx_cloud(int type, int decay) @@ -4534,18 +4532,15 @@ void tile_draw_floor() const coord_def gc = show2grid(ep); int bg = TILE_DNGN_UNSEEN | tile_unseen_flag(gc); - int object = show_appearance(ep); - if (object != 0 && map_bounds(gc)) + if (env.show_los(ep)) { - bg = tileidx_feature(object, gc.x, gc.y); + dungeon_feature_type feat = grid_appearance(gc); + bg = tileidx_feature(feat, gc.x, gc.y); - if (in_bounds(gc)) - { - if (object == DNGN_DETECTED_SECRET_DOOR) - bg |= TILE_FLAG_WAS_SECRET; - else if (is_unknown_stair(gc)) - bg |= TILE_FLAG_NEW_STAIR; - } + if (feat == DNGN_DETECTED_SECRET_DOOR) + bg |= TILE_FLAG_WAS_SECRET; + else if (is_unknown_stair(gc)) + bg |= TILE_FLAG_NEW_STAIR; } // init tiles @@ -4673,11 +4668,11 @@ void tile_place_monster(int gx, int gy, int idx, bool foreground, bool detected) // features. if (is_terrain_mapped(gc)) { - unsigned int feature = grd(gc); + dungeon_feature_type feature = grd(gc); unsigned int grid_symbol; unsigned short grid_colour; - get_item_symbol(feature, &grid_symbol, &grid_colour); + get_show_symbol(show_type(feature), &grid_symbol, &grid_colour); unsigned int fg; unsigned int bg; diff --git a/crawl-ref/source/tiles.h b/crawl-ref/source/tiles.h index 3f588cb86b..9c3cf7d8ce 100644 --- a/crawl-ref/source/tiles.h +++ b/crawl-ref/source/tiles.h @@ -14,6 +14,7 @@ #include "beam.h" #include "enum.h" +#include "show.h" enum tag_version { @@ -33,8 +34,7 @@ struct demon_data //*tile1.cc: get data from core part and drives tile drawing codes //**convert in-game data to tile index -int tileidx(unsigned int object, int extra); -int tileidx_feature(int object, int gx, int gy); +int tileidx_feature(dungeon_feature_type feat, int gx, int gy); int tileidx_player(int job); void tileidx_unseen(unsigned int &fg, unsigned int &bg, int ch, const coord_def& gc); diff --git a/crawl-ref/source/tilesdl.cc b/crawl-ref/source/tilesdl.cc index 376f1dc620..59dae41a82 100644 --- a/crawl-ref/source/tilesdl.cc +++ b/crawl-ref/source/tilesdl.cc @@ -1310,9 +1310,9 @@ void TilesFramework::update_minimap(int gx, int gy) if (!player_in_mappable_area()) return; - int object = env.map[gx][gy].object; - map_feature f = (object >= DNGN_START_OF_MONSTERS) ? MF_MONS_HOSTILE : - get_feature_def((dungeon_feature_type)object).minimap; + show_type object = env.map[gx][gy].object; + map_feature f = (object.cls == SH_MONSTER) ? MF_MONS_HOSTILE : + get_feature_def(object).minimap; if (f == MF_SKIP) f = get_feature_def(grd[gx][gy]).minimap; diff --git a/crawl-ref/source/travel.cc b/crawl-ref/source/travel.cc index 967ef627d5..99cd5bc7bf 100644 --- a/crawl-ref/source/travel.cc +++ b/crawl-ref/source/travel.cc @@ -232,7 +232,7 @@ inline bool is_player_altar(const coord_def &c) bool is_unknown_stair(const coord_def &p, dungeon_feature_type remembered_feat) { - dungeon_feature_type feat = (remembered_feat == NUM_REAL_FEATURES) + dungeon_feature_type feat = (remembered_feat == NUM_FEATURES) ? env.grid(p) : remembered_feat; return (feat_is_travelable_stair(feat) && !travel_cache.know_stair(p)); } @@ -349,14 +349,14 @@ bool is_travelsafe_square(const coord_def& c, bool ignore_hostile, // Also make note of what's displayed on the level map for // plant/fungus checks. - const int levelmap_object = get_envmap_obj(c); + const show_type levelmap_object = get_envmap_obj(c); // Travel will not voluntarily cross squares blocked by immobile monsters. if (!ignore_hostile - && levelmap_object >= DNGN_START_OF_MONSTERS + && levelmap_object.cls == SH_MONSTER && _is_monster_blocked(c) // _is_monster_blocked can only return true if monster_at(c) != NULL - && monster_at(c)->type == levelmap_object - DNGN_START_OF_MONSTERS) + && monster_at(c)->type == levelmap_object.mons) { return (false); } @@ -481,7 +481,7 @@ void travel_init_new_level() // Sets up travel-related stuff. void initialise_travel() { - for (int feat = DNGN_FLOOR_MIN; feat < NUM_REAL_FEATURES; feat++) + for (int feat = DNGN_FLOOR_MIN; feat < NUM_FEATURES; feat++) { if (feat >= DNGN_TRAP_MECHANICAL && feat <= DNGN_TRAP_NATURAL) continue; diff --git a/crawl-ref/source/travel.h b/crawl-ref/source/travel.h index 2b08a3841f..22afdfee8a 100644 --- a/crawl-ref/source/travel.h +++ b/crawl-ref/source/travel.h @@ -68,7 +68,7 @@ const char *trap_name(const coord_def &p); void explore_pickup_event(int did_pickup, int tried_pickup); bool feat_is_traversable(dungeon_feature_type feat); bool is_unknown_stair(const coord_def &p, - dungeon_feature_type remembered_feat = NUM_REAL_FEATURES); + dungeon_feature_type remembered_feat = NUM_FEATURES); void find_travel_pos(const coord_def& youpos, char *move_x, char *move_y, std::vector<coord_def>* coords = NULL); diff --git a/crawl-ref/source/tutorial.cc b/crawl-ref/source/tutorial.cc index 1e037c9832..2965d15190 100644 --- a/crawl-ref/source/tutorial.cc +++ b/crawl-ref/source/tutorial.cc @@ -1669,7 +1669,7 @@ void learned_something_new(tutorial_event_type seen_what, coord_def gc) const coord_def e = gc - you.pos() + coord_def(9,9); unsigned ch; unsigned short colour; - int object; + show_type object; #endif Options.tut_just_triggered = true; @@ -1716,7 +1716,7 @@ void learned_something_new(tutorial_event_type seen_what, coord_def gc) #ifndef USE_TILE text << "('<w>"; - get_item_symbol(DNGN_ITEM_BOOK, &ch, &colour); + get_show_symbol(show_type(SHOW_ITEM_BOOK), &ch, &colour); text << static_cast<char>(ch) << "'</w>) " << "that you can read by typing <w>r</w>. " @@ -1971,7 +1971,7 @@ void learned_something_new(tutorial_event_type seen_what, coord_def gc) #ifndef USE_TILE ", both of which are represented by '<w>"; - get_item_symbol(DNGN_ITEM_STAVE, &ch, &colour); + get_show_symbol(show_type(SHOW_ITEM_STAVE), &ch, &colour); text << static_cast<char>(ch) << "</w>'" #endif @@ -2021,8 +2021,8 @@ void learned_something_new(tutorial_event_type seen_what, coord_def gc) DELAY_EVENT; object = env.show(e); - colour = env.show_col(e); - { unsigned short dummy; get_item_symbol( object, &ch, &dummy ); } + colour = object.colour; + { unsigned short dummy; get_show_symbol( object, &ch, &dummy ); } text << _colourize_glyph(colour, ch) << " "; #else @@ -2052,8 +2052,8 @@ void learned_something_new(tutorial_event_type seen_what, coord_def gc) text << "These "; #ifndef USE_TILE object = env.show(e); - colour = env.show_col(e); - get_item_symbol( object, &ch, &colour ); + colour = object.colour; + get_show_symbol( object, &ch, &colour ); text << _colourize_glyph(colour, ch); text << " "; @@ -2081,8 +2081,8 @@ void learned_something_new(tutorial_event_type seen_what, coord_def gc) // FIXME: Branch entrance character is not being colored yellow. object = env.show(e); - colour = env.show_col(e); - { unsigned short dummy; get_item_symbol( object, &ch, &dummy ); } + colour = object.colour; + { unsigned short dummy; get_show_symbol( object, &ch, &dummy ); } text << _colourize_glyph(colour, ch) << " "; #else @@ -2119,8 +2119,8 @@ void learned_something_new(tutorial_event_type seen_what, coord_def gc) DELAY_EVENT; object = env.show(e); - colour = env.show_col(e); - { unsigned short dummy; get_item_symbol( object, &ch, &dummy ); } + colour = object.colour; + { unsigned short dummy; get_show_symbol( object, &ch, &dummy ); } text << _colourize_glyph(colour, ch) << " "; #else @@ -2192,8 +2192,8 @@ void learned_something_new(tutorial_event_type seen_what, coord_def gc) "of these nasty constructions"; #ifndef USE_TILE object = env.show(e); - colour = env.show_col(e); - get_item_symbol( object, &ch, &colour ); + colour = object.colour; + get_show_symbol( object, &ch, &colour ); if (ch == ' ' || colour == BLACK) colour = LIGHTCYAN; @@ -2209,8 +2209,8 @@ void learned_something_new(tutorial_event_type seen_what, coord_def gc) text << "That "; #ifndef USE_TILE object = env.show(e); - colour = env.show_col(e); - get_item_symbol( object, &ch, &colour ); + colour = object.colour; + get_show_symbol( object, &ch, &colour ); text << _colourize_glyph(colour, ch) << " "; #else { diff --git a/crawl-ref/source/view.cc b/crawl-ref/source/view.cc index 057591bbba..87e18225a7 100644 --- a/crawl-ref/source/view.cc +++ b/crawl-ref/source/view.cc @@ -88,26 +88,20 @@ #define MC_MONS 0x02 crawl_view_geometry crawl_view; -FixedArray < unsigned int, ENV_SHOW_DIAMETER, ENV_SHOW_DIAMETER > Show_Backup; extern int stealth; // defined in acr.cc screen_buffer_t colour_code_map( const coord_def& p, bool item_colour = false, bool travel_colour = false, bool on_level = true ); -void cloud_grid(void); -void monster_grid(bool do_updates); - static void _get_symbol( const coord_def& where, - int object, unsigned *ch, + show_type object, unsigned *ch, unsigned short *colour, bool magic_mapped = false ); -static unsigned _get_symbol(int object, unsigned short *colour = NULL, +static unsigned _get_symbol(show_type object, unsigned short *colour = NULL, bool magic_mapped = false); -static int _get_item_dngn_code(const item_def &item); -static void _set_show_backup( int ex, int ey ); -static int _get_viewobj_flags(int viewobj); +static int _get_viewobj_flags(show_type viewobj); unsigned map_cell::glyph() const { @@ -141,7 +135,7 @@ unsigned get_envmap_char(int x, int y) return env.map[x][y].glyph(); } -int get_envmap_obj(int x, int y) +show_type get_envmap_obj(int x, int y) { return (env.map[x][y].object); } @@ -172,7 +166,7 @@ bool is_envmap_detected_mons(int x, int y) return (env.map[x][y].flags & MAP_DETECTED_MONSTER); } -void set_envmap_glyph(int x, int y, int object, int col) +void set_envmap_glyph(int x, int y, show_type object, int col) { map_cell &c = env.map[x][y]; c.object = object; @@ -182,12 +176,12 @@ void set_envmap_glyph(int x, int y, int object, int col) #endif } -void set_envmap_glyph(const coord_def& c, int object, int col) +void set_envmap_glyph(const coord_def& c, show_type object, int col) { set_envmap_glyph(c.x, c.y, object, col); } -void set_envmap_obj( const coord_def& where, int obj ) +void set_envmap_obj(const coord_def& where, show_type obj) { env.map(where).object = obj; #ifdef USE_TILE @@ -398,14 +392,14 @@ unsigned real_colour(unsigned raw_colour) return (raw_colour); } -static int _get_viewobj_flags(int object) +static int _get_viewobj_flags(show_type object) { // Check for monster glyphs. - if (object >= DNGN_START_OF_MONSTERS) + if (object.cls == SH_MONSTER) return (MC_MONS); // Check for item glyphs. - if (object >= DNGN_ITEM_ORB && object < DNGN_CLOUD) + if (object.cls == SH_ITEM) return (MC_ITEM); // We don't care to look further; we could check for @@ -413,7 +407,7 @@ static int _get_viewobj_flags(int object) return (0); } -static unsigned _get_symbol(int object, unsigned short *colour, +static unsigned _get_symbol(show_type object, unsigned short *colour, bool magic_mapped) { unsigned ch; @@ -450,24 +444,23 @@ static unsigned short _tree_colour(const coord_def& where) } static void _get_symbol( const coord_def& where, - int object, unsigned *ch, + show_type object, unsigned *ch, unsigned short *colour, bool magic_mapped ) { ASSERT( ch != NULL ); - if (object < NUM_FEATURES) + if (object.cls < SH_MONSTER) { - const dungeon_feature_type feat = - static_cast<dungeon_feature_type>(object); - const feature_def &fdef = get_feature_def(feat); + const feature_def &fdef = get_feature_def(object); *ch = magic_mapped? fdef.magic_symbol : fdef.symbol; // Don't recolor items - if (colour && object < NUM_REAL_FEATURES) + if (colour && object.cls == SH_FEATURE) { + dungeon_feature_type feat = object.feat; const int colmask = *colour & COLFLAG_MASK; // TODO: consolidate with feat_is_stair etc. @@ -553,13 +546,14 @@ static void _get_symbol( const coord_def& where, // Note anything we see that's notable if (!where.origin() && fdef.is_notable()) { - seen_notable_thing(feat, where); + if (object.cls == SH_FEATURE) // other notable things? + seen_notable_thing(object.feat, where); } } else { - ASSERT(object >= DNGN_START_OF_MONSTERS); - *ch = mons_char(object - DNGN_START_OF_MONSTERS); + ASSERT(object.cls == SH_MONSTER); + *ch = mons_char(object.mons); } if (colour) @@ -575,41 +569,19 @@ unsigned grid_character_at(const coord_def &c) return glych; } -void get_item_symbol(unsigned int object, unsigned *ch, - unsigned short *colour) -{ - if (object < NUM_FEATURES) - { - dungeon_feature_type feat = static_cast<dungeon_feature_type>(object); - *ch = get_feature_def(feat).symbol; - - // Don't clobber with BLACK, because the colour should be already set. - if (get_feature_def(feat).colour != BLACK) - *colour = get_feature_def(feat).colour; - } - *colour = real_colour(*colour); - -} - -dungeon_char_type get_feature_dchar( dungeon_feature_type feat ) +dungeon_char_type get_feature_dchar(dungeon_feature_type feat) { return (get_feature_def(feat).dchar); } -unsigned get_sightmap_char(dungeon_feature_type feature) +unsigned get_sightmap_char(dungeon_feature_type feat) { - if (feature < NUM_FEATURES) - return (get_feature_def(feature).symbol); - - return (0); + return (get_feature_def(feat).symbol); } -unsigned get_magicmap_char(dungeon_feature_type feature) +unsigned get_magicmap_char(dungeon_feature_type feat) { - if (feature < NUM_FEATURES) - return (get_feature_def(feature).magic_symbol); - - return (0); + return (get_feature_def(feat).magic_symbol); } static char _get_travel_colour( const coord_def& p ) @@ -721,9 +693,9 @@ screen_buffer_t colour_code_map(const coord_def& p, bool item_colour, dungeon_feature_type feat_value = grd(p); if (!see_cell(p)) { - const int remembered = get_envmap_obj(p); - if (remembered < NUM_REAL_FEATURES) - feat_value = static_cast<dungeon_feature_type>(remembered); + const show_type remembered = get_envmap_obj(p); + if (remembered.cls == SH_FEATURE) + feat_value = remembered.feat; } unsigned tc = travel_colour ? _get_travel_colour(p) : DARKGREY; @@ -770,7 +742,7 @@ screen_buffer_t colour_code_map(const coord_def& p, bool item_colour, const int olddist = grid_distance(you.pos(), mon.pos()); const int newdist = grid_distance(p, mon.pos()); - if (olddist < newdist || !see_cell(env.show, p, mon.pos())) + if (olddist < newdist || !see_cell(env.show_los, p, mon.pos())) { blocked_movement = true; break; @@ -847,19 +819,19 @@ void clear_map(bool clear_detected_items, bool clear_detected_monsters) continue; #endif - set_envmap_obj(p, is_terrain_seen(p) || is_terrain_mapped(p) - ? grd(p) : DNGN_UNSEEN); + set_envmap_obj(p, show_type(is_terrain_seen(p) || is_terrain_mapped(p) + ? grd(p) : DNGN_UNSEEN)); set_envmap_detected_mons(p, false); set_envmap_detected_item(p, false); #ifdef USE_TILE if (is_terrain_mapped(p)) { - unsigned int feature = grd(p); + dungeon_feature_type feature = grd(p); unsigned int feat_symbol; unsigned short feat_colour; - get_item_symbol(feature, &feat_symbol, &feat_colour); + get_show_symbol(show_type(feature), &feat_symbol, &feat_colour); unsigned int fg; unsigned int bg; @@ -1329,58 +1301,6 @@ void force_monster_shout(monsters* monster) } #endif -inline static bool _update_monster_grid(const monsters *monster) -{ - const coord_def e = grid2show(monster->pos()); - - if (!monster->visible_to(&you)) - { - // ripple effect? - if (grd(monster->pos()) == DNGN_SHALLOW_WATER - && !mons_flies(monster) - && env.cgrid(monster->pos()) == EMPTY_CLOUD) - { - _set_show_backup(e.x, e.y); - env.show(e) = DNGN_INVIS_EXPOSED; - - // Translates between colours used for shallow and deep water, - // if not using the normal LIGHTCYAN / BLUE. The ripple uses - // the deep water colour. - unsigned short base_colour = env.grid_colours(monster->pos()); - - static const unsigned short ripple_table[] = - {BLUE, // BLACK => BLUE (default) - BLUE, // BLUE => BLUE - GREEN, // GREEN => GREEN - CYAN, // CYAN => CYAN - RED, // RED => RED - MAGENTA, // MAGENTA => MAGENTA - BROWN, // BROWN => BROWN - DARKGREY, // LIGHTGREY => DARKGREY - DARKGREY, // DARKGREY => DARKGREY - BLUE, // LIGHTBLUE => BLUE - GREEN, // LIGHTGREEN => GREEN - BLUE, // LIGHTCYAN => BLUE - RED, // LIGHTRED => RED - MAGENTA, // LIGHTMAGENTA => MAGENTA - BROWN, // YELLOW => BROWN - LIGHTGREY}; // WHITE => LIGHTGREY - - env.show_col(e) = ripple_table[base_colour & 0x0f]; - } - return (false); - } - - // Mimics are always left on map. - if (!mons_is_mimic( monster->type )) - _set_show_backup(e.x, e.y); - - env.show(e) = monster->type + DNGN_START_OF_MONSTERS; - env.show_col(e) = get_mons_colour( monster ); - - return (true); -} - void monster_grid(bool do_updates) { do_updates = do_updates && !crawl_state.arena; @@ -1415,7 +1335,7 @@ void monster_grid(bool do_updates) mgrd(monster->pos()) = s; } - if (!_update_monster_grid(monster)) + if (!env.show.update_monster(monster)) continue; #ifdef USE_TILE @@ -1558,197 +1478,18 @@ bool check_awaken(monsters* monster) return (false); } -static void _set_show_backup( int ex, int ey ) -{ - // Must avoid double setting it. - // We want the base terrain/item, not the cloud or monster that replaced it. - if (!Show_Backup[ex][ey]) - Show_Backup[ex][ey] = env.show[ex][ey]; -} - -static int _get_item_dngn_code(const item_def &item) -{ - switch (item.base_type) - { - case OBJ_ORBS: return (DNGN_ITEM_ORB); - case OBJ_WEAPONS: return (DNGN_ITEM_WEAPON); - case OBJ_MISSILES: return (DNGN_ITEM_MISSILE); - case OBJ_ARMOUR: return (DNGN_ITEM_ARMOUR); - case OBJ_WANDS: return (DNGN_ITEM_WAND); - case OBJ_FOOD: return (DNGN_ITEM_FOOD); - case OBJ_SCROLLS: return (DNGN_ITEM_SCROLL); - case OBJ_JEWELLERY: - return (jewellery_is_amulet(item)? DNGN_ITEM_AMULET : DNGN_ITEM_RING); - case OBJ_POTIONS: return (DNGN_ITEM_POTION); - case OBJ_BOOKS: return (DNGN_ITEM_BOOK); - case OBJ_STAVES: return (DNGN_ITEM_STAVE); - case OBJ_MISCELLANY: return (DNGN_ITEM_MISCELLANY); - case OBJ_CORPSES: return (DNGN_ITEM_CORPSE); - case OBJ_GOLD: return (DNGN_ITEM_GOLD); - default: return (DNGN_ITEM_ORB); // bad item character - } -} - -inline static void _update_item_grid(const coord_def &gp, const coord_def &ep) -{ - const item_def &eitem = mitm[igrd(gp)]; - unsigned short &ecol = env.show_col(ep); - - const dungeon_feature_type feat = grd(gp); - if (Options.feature_item_brand && is_critical_feature(feat)) - ecol |= COLFLAG_FEATURE_ITEM; - else if (Options.trap_item_brand && feat_is_trap(feat)) - ecol |= COLFLAG_TRAP_ITEM; - else - { - const unsigned short gcol = env.grid_colours(gp); - ecol = (feat == DNGN_SHALLOW_WATER) ? - (gcol != BLACK ? gcol : CYAN) : eitem.colour; - if (eitem.link != NON_ITEM && !crawl_state.arena) - ecol |= COLFLAG_ITEM_HEAP; - env.show(ep) = _get_item_dngn_code( eitem ); - } - -#ifdef USE_TILE - int idx = igrd(gp); - if (feat_is_stair(feat)) - tile_place_item_marker(ep.x, ep.y, idx); - else - tile_place_item(ep.x, ep.y, idx); -#endif -} - -void item_grid() -{ - const coord_def c(crawl_view.glosc()); - const coord_def offset(ENV_SHOW_OFFSET, ENV_SHOW_OFFSET); - for (radius_iterator ri(c, LOS_RADIUS, true, false); ri; ++ri) - { - if (igrd(*ri) != NON_ITEM) - { - const coord_def ep = *ri - c + offset; - if (env.show(ep)) - _update_item_grid(*ri, ep); - } - } -} - -void get_item_glyph( const item_def *item, unsigned *glych, - unsigned short *glycol ) +void get_item_glyph(const item_def *item, unsigned *glych, + unsigned short *glycol) { *glycol = item->colour; - _get_symbol( coord_def(0,0), _get_item_dngn_code( *item ), glych, glycol ); -} - -void get_mons_glyph( const monsters *mons, unsigned *glych, - unsigned short *glycol ) -{ - *glycol = get_mons_colour( mons ); - _get_symbol( coord_def(0,0), mons->type + DNGN_START_OF_MONSTERS, - glych, glycol ); -} - -inline static void _update_cloud_grid(int cloudno) -{ - int which_colour = LIGHTGREY; - const coord_def e = grid2show(env.cloud[cloudno].pos); - - switch (env.cloud[cloudno].type) - { - case CLOUD_FIRE: - case CLOUD_FOREST_FIRE: - if (env.cloud[cloudno].decay <= 20) - which_colour = RED; - else if (env.cloud[cloudno].decay <= 40) - which_colour = LIGHTRED; - else if (one_chance_in(4)) - which_colour = RED; - else if (one_chance_in(4)) - which_colour = LIGHTRED; - else - which_colour = YELLOW; - break; - - case CLOUD_STINK: - which_colour = GREEN; - break; - - case CLOUD_COLD: - if (env.cloud[cloudno].decay <= 20) - which_colour = BLUE; - else if (env.cloud[cloudno].decay <= 40) - which_colour = LIGHTBLUE; - else if (one_chance_in(4)) - which_colour = BLUE; - else if (one_chance_in(4)) - which_colour = LIGHTBLUE; - else - which_colour = WHITE; - break; - - case CLOUD_POISON: - which_colour = (one_chance_in(3) ? LIGHTGREEN : GREEN); - break; - - case CLOUD_BLUE_SMOKE: - which_colour = LIGHTBLUE; - break; - - case CLOUD_PURP_SMOKE: - which_colour = MAGENTA; - break; - - case CLOUD_MIASMA: - case CLOUD_BLACK_SMOKE: - which_colour = DARKGREY; - break; - - case CLOUD_RAIN: - case CLOUD_MIST: - which_colour = ETC_MIST; - break; - - case CLOUD_CHAOS: - which_colour = ETC_RANDOM; - break; - - case CLOUD_MUTAGENIC: - which_colour = ETC_MUTAGENIC; - break; - - default: - which_colour = LIGHTGREY; - break; - } - - _set_show_backup(e.x, e.y); - env.show(e) = DNGN_CLOUD; - env.show_col(e) = which_colour; - -#ifdef USE_TILE - tile_place_cloud(e.x, e.y, env.cloud[cloudno].type, - env.cloud[cloudno].decay); -#endif + _get_symbol(coord_def(0,0), show_type(*item), glych, glycol); } -void cloud_grid(void) +void get_mons_glyph(const monsters *mons, unsigned *glych, + unsigned short *glycol) { - int mnc = 0; - - for (int s = 0; s < MAX_CLOUDS; s++) - { - // can anyone explain this??? {dlb} - // its an optimization to avoid looking past the last cloud -bwr - if (mnc >= env.cloud_no) - break; - - if (env.cloud[s].type != CLOUD_NONE) - { - mnc++; - if (see_cell(env.cloud[s].pos)) - _update_cloud_grid(s); - } - } + *glycol = get_mons_colour(mons); + _get_symbol(coord_def(0,0), show_type(mons), glych, glycol); } // Noisy now has a messenging service for giving messages to the @@ -3391,18 +3132,18 @@ unsigned get_screen_glyph( int x, int y ) return get_screen_glyph(coord_def(x,y)); } -unsigned get_screen_glyph( const coord_def& p ) +unsigned get_screen_glyph(const coord_def& p) { const coord_def ep = view2show(grid2view(p)); - int object = show_appearance(ep); - unsigned short colour = env.show_col(ep); + show_type object = env.show(ep); + unsigned short colour = object.colour; unsigned ch; if (!object) return get_envmap_char(p.x, p.y); - _get_symbol( p, object, &ch, &colour ); + _get_symbol(p, object, &ch, &colour); return (ch); } @@ -3436,7 +3177,7 @@ std::string screenshot(bool fullscreen) char_table_bk = Options.char_table; init_char_table(CSET_ASCII); - init_feature_table(); + init_show_table(); int firstnonspace = -1; int firstpopline = -1; @@ -3461,7 +3202,7 @@ std::string screenshot(bool fullscreen) if (ch && !isprint(ch)) { // [ds] Evil hack time again. Peek at grid, use that character. - int object = grid_appearance(gc); + show_type object = show_type(grid_appearance(gc)); unsigned glych; unsigned short glycol = 0; @@ -3494,7 +3235,7 @@ std::string screenshot(bool fullscreen) // Restore char and feature tables. Options.char_table = char_table_bk; - init_feature_table(); + init_show_table(); std::ostringstream ss; if (firstpopline != -1 && lastpopline != -1) @@ -3524,27 +3265,6 @@ static int _viewmap_flash_colour() return (BLACK); } -static void _update_env_show(const coord_def &gp, const coord_def &ep) -{ - // The sequence is grid, items, clouds, monsters. - env.show(ep) = grd(gp); - env.show_col(ep) = 0; - - if (igrd(gp) != NON_ITEM) - _update_item_grid(gp, ep); - - const int cloud = env.cgrid(gp); - if (cloud != EMPTY_CLOUD && env.cloud[cloud].type != CLOUD_NONE - && env.cloud[cloud].pos == gp) - { - _update_cloud_grid(cloud); - } - - const monsters *mons = monster_at(gp); - if (mons && mons->alive()) - _update_monster_grid(mons); -} - // Updates one square of the view area. Should only be called for square // in LOS. void view_update_at(const coord_def &pos) @@ -3554,14 +3274,14 @@ void view_update_at(const coord_def &pos) const coord_def vp = grid2view(pos); const coord_def ep = view2show(vp); - _update_env_show(pos, ep); + env.show.update_at(pos, ep); - int object = show_appearance(ep); + show_type object = env.show(ep); if (!object) return; - unsigned short colour = env.show_col(ep); + unsigned short colour = object.colour; unsigned ch = 0; _get_symbol( pos, object, &ch, &colour ); @@ -3680,12 +3400,9 @@ void viewwindow(bool draw_it, bool do_updates) mcache.clear_nonref(); #endif - env.show_col.init(LIGHTGREY); - Show_Backup.init(0); + env.show.init(); - item_grid(); // Must be done before cloud and monster. - cloud_grid(); - monster_grid( do_updates ); + monster_grid(true); #ifdef USE_TILE tile_draw_rays(true); @@ -3769,8 +3486,8 @@ void viewwindow(bool draw_it, bool do_updates) else if (gc == you.pos() && !crawl_state.arena && !crawl_state.arena_suspended) { - int object = env.show(ep); - unsigned short colour = env.show_col(ep); + show_type object = env.show(ep); + unsigned short colour = object.colour; unsigned ch; _get_symbol(gc, object, &ch, &colour); @@ -3810,8 +3527,8 @@ void viewwindow(bool draw_it, bool do_updates) } else { - int object = show_appearance(ep); - unsigned short colour = env.show_col(ep); + show_type object = env.show(ep); + unsigned short colour = object.colour; unsigned ch; _get_symbol( gc, object, &ch, &colour ); @@ -3868,11 +3585,11 @@ void viewwindow(bool draw_it, bool do_updates) // to the grid before monsters and clouds were // added otherwise. if (Options.clean_map - && Show_Backup(ep) + && env.show.get_backup(ep) && is_terrain_seen(gc)) { - _get_symbol(gc, Show_Backup(ep), &ch, &colour); - set_envmap_glyph(gc, Show_Backup(ep), colour); + _get_symbol(gc, env.show.get_backup(ep), &ch, &colour); + set_envmap_glyph(gc, env.show.get_backup(ep), colour); } // Now we get to filling in both the unseen diff --git a/crawl-ref/source/view.h b/crawl-ref/source/view.h index 88b2958a79..978fcad050 100644 --- a/crawl-ref/source/view.h +++ b/crawl-ref/source/view.h @@ -9,6 +9,7 @@ #define VIEW_H #include "externs.h" +#include "show.h" void init_char_table(char_set_type set); void init_monsters_seens(); @@ -49,22 +50,19 @@ unsigned get_screen_glyph( const coord_def &p ); std::string stringize_glyph(unsigned glyph); int multibyte_strlen(const std::string &s); -void get_item_symbol(unsigned int object, unsigned *ch, - unsigned short *colour); - // Applies ETC_ colour substitutions and brands. unsigned real_colour(unsigned raw_colour); int get_mons_colour(const monsters *mons); -void set_envmap_obj( const coord_def& where, int object ); +void set_envmap_obj(const coord_def& where, show_type object); unsigned get_envmap_char(int x, int y); inline unsigned get_envmap_char(const coord_def& c) { return get_envmap_char(c.x, c.y); } bool inside_level_bounds(int x, int y); bool inside_level_bounds(const coord_def &p); -int get_envmap_obj(int x, int y); -inline int get_envmap_obj(const coord_def& c) { +show_type get_envmap_obj(int x, int y); +inline show_type get_envmap_obj(const coord_def& c) { return get_envmap_obj(c.x, c.y); } void set_envmap_detected_item(int x, int y, bool detected = true); diff --git a/crawl-ref/source/xom.cc b/crawl-ref/source/xom.cc index 9fd5def20c..e20073681f 100644 --- a/crawl-ref/source/xom.cc +++ b/crawl-ref/source/xom.cc @@ -2291,7 +2291,7 @@ static item_def* _tran_get_eq(equipment_type eq) } // Which types of dungeon features are in view? -static void _get_in_view(FixedVector<bool, NUM_REAL_FEATURES>& in_view) +static void _get_in_view(FixedVector<bool, NUM_FEATURES>& in_view) { in_view.init(false); @@ -2321,7 +2321,7 @@ static void _xom_zero_miscast() /////////////////////////////////// // Dungeon feature dependent stuff. - FixedVector<bool, NUM_REAL_FEATURES> in_view; + FixedVector<bool, NUM_FEATURES> in_view; _get_in_view(in_view); if (in_view[DNGN_LAVA]) |