From 89ff79ab008f440bc9126103fc21ed71aac0526f Mon Sep 17 00:00:00 2001 From: Robert Vollmert Date: Wed, 4 Nov 2009 08:33:35 +0100 Subject: Split game_options from externs.h into options.h. --- crawl-ref/source/options.h | 473 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 473 insertions(+) create mode 100644 crawl-ref/source/options.h (limited to 'crawl-ref/source/options.h') diff --git a/crawl-ref/source/options.h b/crawl-ref/source/options.h new file mode 100644 index 0000000000..612a45816a --- /dev/null +++ b/crawl-ref/source/options.h @@ -0,0 +1,473 @@ +#ifndef OPTIONS_H +#define OPTIONS_H + +#include "feature.h" + +class InitLineInput; +struct game_options +{ +public: + game_options(); + void reset_startup_options(); + void reset_options(); + + void read_option_line(const std::string &s, bool runscripts = false); + void read_options(InitLineInput &, bool runscripts, + bool clear_aliases = true); + + void include(const std::string &file, bool resolve, bool runscript); + void report_error(const std::string &error); + + std::string resolve_include(const std::string &file, + const char *type = ""); + + bool was_included(const std::string &file) const; + + static std::string resolve_include( + std::string including_file, + std::string included_file, + const std::vector *rcdirs = NULL) + throw (std::string); + +public: + std::string filename; // The name of the file containing options. + std::string basefilename; // Base (pathless) file name + int line_num; // Current line number being processed. + + // View options + std::vector feature_overrides; + std::vector mon_glyph_overrides; + unsigned cset_override[NUM_CSET][NUM_DCHAR_TYPES]; + + std::string save_dir; // Directory where saves and bones go. + std::string macro_dir; // Directory containing macro.txt + std::string morgue_dir; // Directory where character dumps and morgue + // dumps are saved. Overrides crawl_dir. + std::vector additional_macro_files; + + std::string player_name; + +#ifdef DGL_SIMPLE_MESSAGING + bool messaging; // Check for messages. +#endif + + bool suppress_startup_errors; + + bool mouse_input; + + int view_max_width; + int view_max_height; + int mlist_min_height; + int msg_max_height; + bool mlist_allow_alternate_layout; + int mlist_targetting; // not actually a real option + bool classic_hud; + bool msg_condense_repeats; + + // The view lock variables force centering the viewport around the PC @ + // at all times (the default). If view locking is not enabled, the viewport + // scrolls only when the PC hits the edge of it. + bool view_lock_x; + bool view_lock_y; + + // For an unlocked viewport, this will center the viewport when scrolling. + bool center_on_scroll; + + // If symmetric_scroll is set, for diagonal moves, if the view + // scrolls at all, it'll scroll diagonally. + bool symmetric_scroll; + + // How far from the viewport edge is scrolling forced. + int scroll_margin_x; + int scroll_margin_y; + + bool verbose_monster_pane; + + int autopickup_on; + int default_friendly_pickup; + bool show_more_prompt; + + bool show_gold_turns; // Show gold and turns in HUD. + bool show_beam; // Show targetting beam by default. + + long autopickups; // items to autopickup + bool show_inventory_weights; // show weights in inventory listings + bool colour_map; // add colour to the map + bool clean_map; // remove unseen clouds/monsters + bool show_uncursed; // label known uncursed items as "uncursed" + bool easy_open; // open doors with movement + bool easy_unequip; // allow auto-removing of armour / jewellery + bool equip_unequip; // Make 'W' = 'T', and 'P' = 'R'. + bool easy_butcher; // autoswap to butchering tool + bool always_confirm_butcher; // even if only one corpse + bool chunks_autopickup; // Autopickup chunks after butchering + bool prompt_for_swap; // Prompt to switch back from butchering + // tool if hostile monsters are around. + bool list_rotten; // list slots for rotting corpses/chunks + bool prefer_safe_chunks; // prefer clean chunks to contaminated ones + bool easy_eat_chunks; // make 'e' auto-eat the oldest safe chunk + bool easy_eat_gourmand; // with easy_eat_chunks, and wearing a + // "OfGourmand, auto-eat contaminated + // chunks if no safe ones are present + bool easy_eat_contaminated; // like easy_eat_gourmand, but + // always active. + bool default_target; // start targetting on a real target + bool autopickup_no_burden; // don't autopickup if it changes burden + + bool note_all_skill_levels; // take note for all skill levels (1-27) + bool note_skill_max; // take note when skills reach new max + bool note_all_spells; // take note when learning any spell + std::string user_note_prefix; // Prefix for user notes + int note_hp_percent; // percentage hp for notetaking + bool note_xom_effects; // take note of all Xom effects + int ood_interesting; // how many levels OOD is noteworthy? + int rare_interesting; // what monster rarity is noteworthy? + confirm_level_type easy_confirm; // make yesno() confirming easier + bool easy_quit_item_prompts; // make item prompts quitable on space + confirm_prompt_type allow_self_target; // yes, no, prompt + + int colour[16]; // macro fg colours to other colours + int background; // select default background colour + int channels[NUM_MESSAGE_CHANNELS]; // msg channel colouring + int target_range; // for whether targetting is out of range + + bool use_old_selection_order; // use old order of species/classes in + // selection screen + int weapon; // auto-choose weapon for character + int book; // auto-choose book for character + int wand; // auto-choose wand for character + int chaos_knight; // choice of god for Chaos Knights (Xom/Makleb) + int death_knight; // choice of god/necromancy for Death Knights + god_type priest; // choice of god for priests (Zin/Yred) + bool random_pick; // randomly generate character + bool good_random; // when chosing randomly only choose + // unrestricted combinations + int hp_warning; // percentage hp for danger warning + int magic_point_warning; // percentage mp for danger warning + char race; // preselected race + char cls; // preselected class + bool delay_message_clear; // avoid clearing messages each turn + unsigned friend_brand; // Attribute for branding friendly monsters + unsigned neutral_brand; // Attribute for branding neutral monsters + bool no_dark_brand; // Attribute for branding friendly monsters + bool macro_meta_entry; // Allow user to use numeric sequences when + // creating macros + + int fire_items_start; // index of first item for fire command + std::vector fire_order; // missile search order for 'f' command + + bool auto_list; // automatically jump to appropriate item lists + + bool flush_input[NUM_FLUSH_REASONS]; // when to flush input buff + + char_set_type char_set; + FixedVector char_table; + + int num_colours; // used for setting up curses colour table (8 or 16) + + std::string pizza; + +#ifdef WIZARD + int wiz_mode; // yes, no, never in wiz mode to start +#endif + + // internal use only: + int sc_entries; // # of score entries + int sc_format; // Format for score entries + + std::vector > hp_colour; + std::vector > mp_colour; + std::vector > stat_colour; + + std::string map_file_name; // name of mapping file to use + std::vector > force_autopickup; + std::vector note_monsters; // Interesting monsters + std::vector note_messages; // Interesting messages + std::vector > autoinscriptions; + std::vector note_items; // Objects to note + std::vector note_skill_levels; // Skill levels to note + + bool autoinscribe_artefacts; // Auto-inscribe identified artefacts. + + bool pickup_thrown; // Pickup thrown missiles + bool pickup_dropped; // Pickup dropped objects + int travel_delay; // How long to pause between travel moves + int explore_delay; // How long to pause between explore moves + + int arena_delay; + bool arena_dump_msgs; + bool arena_dump_msgs_all; + bool arena_list_eq; + bool arena_force_ai; + + // Messages that stop travel + std::vector travel_stop_message; + std::vector force_more_message; + + int stash_tracking; // How stashes are tracked + + int tc_reachable; // Colour for squares that are reachable + int tc_excluded; // Colour for excluded squares. + int tc_exclude_circle; // Colour for squares in the exclusion radius + int tc_dangerous; // Colour for trapped squares, deep water, lava. + int tc_disconnected;// Areas that are completely disconnected. + std::vector auto_exclude; // Automatically set an exclusion + // around certain monsters. + + int travel_stair_cost; + + bool show_waypoints; + + bool classic_item_colours; // Use old-style item colours + bool item_colour; // Colour items on level map + + unsigned evil_colour; // Colour for things player's god dissapproves + + unsigned detected_monster_colour; // Colour of detected monsters + unsigned detected_item_colour; // Colour of detected items + unsigned status_caption_colour; // Colour of captions in HUD. + + unsigned heap_brand; // Highlight heaps of items + unsigned stab_brand; // Highlight monsters that are stabbable + unsigned may_stab_brand; // Highlight potential stab candidates + unsigned feature_item_brand; // Highlight features covered by items. + unsigned trap_item_brand; // Highlight traps covered by items. + + bool trap_prompt; // Prompt when stepping on mechnical traps + // without enough hp (using trapwalk.lua) + + // What is the minimum number of items in a stack for which + // you show summary (one-line) information + int item_stack_summary_minimum; + + int explore_stop; // Stop exploring if a previously unseen + // item comes into view + + int explore_stop_prompt; + + bool explore_greedy; // Explore goes after items as well. + + // How much more eager greedy-explore is for items than to explore. + int explore_item_greed; + + // Some experimental improvements to explore + bool explore_improved; + + std::vector sound_mappings; + std::vector menu_colour_mappings; + std::vector message_colour_mappings; + + bool menu_colour_prefix_class; // Prefix item class to string + bool menu_colour_shops; // Use menu colours in shops? + + std::vector sort_menus; + + int dump_kill_places; // How to dump place information for kills. + int dump_message_count; // How many old messages to dump + + int dump_item_origins; // Show where items came from? + int dump_item_origin_price; + bool dump_book_spells; + + // Order of sections in the character dump. + std::vector dump_order; + + bool level_map_title; // Show title in level map + bool target_zero_exp; // If true, targetting targets zero-exp + // monsters. + bool target_wrap; // Wrap around from last to first target + bool target_oos; // 'x' look around can target out-of-LOS + bool target_los_first; // 'x' look around first goes to visible + // objects/features, then goes to stuff + // outside LOS. + bool target_unshifted_dirs; // Unshifted keys target if cursor is + // on player. + + int drop_mode; // Controls whether single or multidrop + // is the default. + int pickup_mode; // -1 for single, 0 for menu, + // X for 'if at least X items present' + + bool easy_exit_menu; // Menus are easier to get out of + + int assign_item_slot; // How free slots are assigned + + std::vector drop_filter; + + FixedArray activity_interrupts; + + // Previous startup options + bool remember_name; // Remember and reprompt with last name + + bool dos_use_background_intensity; + + bool use_fake_cursor; // Draw a fake cursor instead of relying + // on the term's own cursor. + + int level_map_cursor_step; // The cursor increment in the level + // map. + + // If the player prefers to merge kill records, this option can do that. + int kill_map[KC_NCATEGORIES]; + + bool rest_wait_both; // Stop resting only when both HP and MP are + // fully restored. + +#ifdef WIZARD + // Parameters for fight simulations. + long fsim_rounds; + int fsim_str, fsim_int, fsim_dex; + int fsim_xl; + std::string fsim_mons; + std::vector fsim_kit; +#endif // WIZARD + +#ifdef USE_TILE + char tile_show_items[20]; // show which item types in tile inventory + bool tile_title_screen; // display title screen? + bool tile_menu_icons; // display icons in menus? + // minimap colours + char tile_player_col; + char tile_monster_col; + char tile_neutral_col; + char tile_friendly_col; + char tile_plant_col; + char tile_item_col; + char tile_unseen_col; + char tile_floor_col; + char tile_wall_col; + char tile_mapped_wall_col; + char tile_door_col; + char tile_downstairs_col; + char tile_upstairs_col; + char tile_feature_col; + char tile_trap_col; + char tile_water_col; + char tile_lava_col; + char tile_excluded_col; + char tile_excl_centre_col; + char tile_window_col; + // font settings + std::string tile_font_crt_file; + int tile_font_crt_size; + std::string tile_font_msg_file; + int tile_font_msg_size; + std::string tile_font_stat_file; + int tile_font_stat_size; + std::string tile_font_lbl_file; + int tile_font_lbl_size; + std::string tile_font_tip_file; + int tile_font_tip_size; + // window settings + screen_mode tile_full_screen; + int tile_window_width; + int tile_window_height; + int tile_map_pixels; + // display settings + int tile_update_rate; + int tile_key_repeat_delay; + int tile_tooltip_ms; + tag_pref tile_tag_pref; + tile_display_type tile_display; +#endif + + typedef std::map opt_map; + opt_map named_options; // All options not caught above are + // recorded here. + + /////////////////////////////////////////////////////////////////////// + // These options cannot be directly set by the user. Instead they're + // set indirectly to the choices the user made for the last character + // created. XXX: Isn't there a better place for these? + std::string prev_name; + char prev_race; + char prev_cls; + int prev_ck, prev_dk; + god_type prev_pr; + int prev_weapon; + int prev_book; + int prev_wand; + bool prev_randpick; + + /////////////////////////////////////////////////////////////////////// + // tutorial + FixedVector tutorial_events; + bool tut_explored; + bool tut_stashes; + bool tut_travel; + unsigned int tut_spell_counter; + unsigned int tut_throw_counter; + unsigned int tut_berserk_counter; + unsigned int tut_melee_counter; + unsigned int tut_last_healed; + unsigned int tut_seen_invisible; + + bool tut_just_triggered; + unsigned int tutorial_type; + unsigned int tutorial_left; + +private: + typedef std::map string_map; + string_map aliases; + string_map variables; + std::set constants; // Variables that can't be changed + std::set included; // Files we've included already. + +public: + // Convenience accessors for the second-class options in named_options. + int o_int(const char *name, int def = 0) const; + long o_long(const char *name, long def = 0L) const; + bool o_bool(const char *name, bool def = false) const; + std::string o_str(const char *name, const char *def = NULL) const; + int o_colour(const char *name, int def = LIGHTGREY) const; + + // Fix option values if necessary, specifically file paths. + void fixup_options(); + +private: + std::string unalias(const std::string &key) const; + std::string expand_vars(const std::string &field) const; + void add_alias(const std::string &alias, const std::string &name); + + void clear_feature_overrides(); + void clear_cset_overrides(); + void add_cset_override(char_set_type set, const std::string &overrides); + void add_cset_override(char_set_type set, dungeon_char_type dc, + unsigned symbol); + void add_feature_override(const std::string &); + + void add_message_colour_mappings(const std::string &); + void add_message_colour_mapping(const std::string &); + message_filter parse_message_filter(const std::string &s); + + void set_default_activity_interrupts(); + void clear_activity_interrupts(FixedVector &eints); + void set_activity_interrupt( + FixedVector &eints, + const std::string &interrupt); + void set_activity_interrupt(const std::string &activity_name, + const std::string &interrupt_names, + bool append_interrupts, + bool remove_interrupts); + void set_fire_order(const std::string &full, bool add); + void add_fire_order_slot(const std::string &s); + void set_menu_sort(std::string field); + void new_dump_fields(const std::string &text, bool add = true); + void do_kill_map(const std::string &from, const std::string &to); + int read_explore_stop_conditions(const std::string &) const; + + void split_parse(const std::string &s, const std::string &separator, + void (game_options::*add)(const std::string &)); + void add_mon_glyph_override(monster_type mtype, mon_display &mdisp); + void add_mon_glyph_overrides(const std::string &mons, mon_display &mdisp); + void add_mon_glyph_override(const std::string &); + mon_display parse_mon_glyph(const std::string &s) const; + void set_option_fragment(const std::string &s); + + static const std::string interrupt_prefix; +}; + +extern game_options Options; + +#endif + -- cgit v1.2.3-54-g00ecf