PS_YES,

};

/** Right-click to close window actions. */

enum RightClickClose : uint8_t {

	RCC_NO = 0,

	RCC_YES,

	RCC_YES_EXCEPT_STICKY,

};

/** Settings related to the difficulty of the game */

struct DifficultySettings {

	uint16_t competitors_interval;             ///< the interval (in minutes) between adding competitors

	uint32_t max_loan;                         ///< the maximum initial loan

	uint16_t subsidy_duration;                 ///< duration of subsidies

	bool   economy;                          ///< how volatile is the economy

	bool   line_reverse_mode;                ///< reversing at stations or not

	bool   disasters;                        ///< are disasters enabled

	bool   infinite_money;                   ///< whether spending money despite negative balance is allowed

};

/** Settings relating to viewport/smallmap scrolling. */

enum ViewportScrollMode {

	VSM_VIEWPORT_RMB_FIXED, ///< Viewport moves with mouse movement on holding right mouse button, cursor position is fixed.

	VSM_MAP_RMB_FIXED,      ///< Map moves with mouse movement on holding right mouse button, cursor position is fixed.

	VSM_MAP_RMB,            ///< Map moves with mouse movement on holding right mouse button, cursor moves.

	VSM_MAP_LMB,            ///< Map moves with mouse movement on holding left mouse button, cursor moves.

	VSM_END,                ///< Number of scroll mode settings.

};

/** Settings related to the GUI and other stuff that is not saved in the savegame. */

struct GUISettings {

	bool   sg_full_load_any;                 ///< new full load calculation, any cargo must be full read from pre v93 savegames

	bool   lost_vehicle_warn;                ///< if a vehicle can't find its destination, show a warning

	uint8_t  order_review_system;              ///< perform order reviews on vehicles

	bool   vehicle_income_warn;              ///< if a vehicle isn't generating income, show a warning

	bool   show_finances;                    ///< show finances at end of year

	bool   sg_new_nonstop;                   ///< ttdpatch compatible nonstop handling read from pre v93 savegames

	bool   new_nonstop;                      ///< ttdpatch compatible nonstop handling

	uint8_t  stop_location;                    ///< what is the default stop location of trains?

	uint8_t  auto_scrolling;                   ///< scroll when moving mouse to the edge (see #ViewportAutoscrolling)

	uint16_t hover_delay_ms;                   ///< time required to activate a hover event, in milliseconds

	bool   link_terraform_toolbar;           ///< display terraform toolbar when displaying rail, road, water and airport toolbars

	uint8_t  smallmap_land_colour;             ///< colour used for land and heightmap at the smallmap

	uint8_t  linkgraph_colours;                ///< linkgraph overlay colours

	uint8_t  scroll_mode;                      ///< viewport scroll mode

	bool   smooth_scroll;                    ///< smooth scroll viewports

	bool   measure_tooltip;                  ///< show a permanent tooltip when dragging tools

	bool   prefer_teamchat;                  ///< choose the chat message target with \<ENTER\>, true=all clients, false=your team

	uint8_t  advanced_vehicle_list;            ///< use the "advanced" vehicle list

	uint8_t  loading_indicators;               ///< show loading indicators

	uint8_t  default_rail_type;                ///< the default rail type for the rail GUI

	uint8_t  toolbar_pos;                      ///< position of toolbars, 0=left, 1=center, 2=right

	uint8_t  statusbar_pos;                    ///< position of statusbar, 0=left, 1=center, 2=right

	uint8_t  window_snap_radius;               ///< windows snap at each other if closer than this

	uint8_t  window_soft_limit;                ///< soft limit of maximum number of non-stickied non-vital windows (0 = no limit)

	ZoomLevel zoom_min;                      ///< minimum zoom out level

	ZoomLevel zoom_max;                      ///< maximum zoom out level

	ZoomLevel sprite_zoom_min;               ///< maximum zoom level at which higher-resolution alternative sprites will be used (if available) instead of scaling a lower resolution sprite

	uint32_t autosave_interval;              ///< how often should we do autosaves?

	bool   threaded_saves;                   ///< should we do threaded saves?

	bool   keep_all_autosave;                ///< name the autosave in a different way

	bool   autosave_on_exit;                 ///< save an autosave when you quit the game, but do not ask "Do you really want to quit?"

	bool   autosave_on_network_disconnect;   ///< save an autosave when you get disconnected from a network game with an error?

	uint8_t  date_format_in_default_names;     ///< should the default savegame/screenshot name use long dates (31th Dec 2008), short dates (31-12-2008) or ISO dates (2008-12-31)

	bool   population_in_label;              ///< show the population of a town in its label?

	uint8_t  right_mouse_btn_emulation;        ///< should we emulate right mouse clicking?

	uint8_t  scrollwheel_scrolling;            ///< scrolling using the scroll wheel?

	uint8_t  scrollwheel_multiplier;           ///< how much 'wheel' per incoming event from the OS?

	bool   timetable_arrival_departure;      ///< show arrivals and departures in vehicle timetables

	RightClickClose  right_click_wnd_close;  ///< close window with right click

	bool   pause_on_newgame;                 ///< whether to start new games paused or not

	SignalGUISettings signal_gui_mode;       ///< select which signal types are shown in the signal GUI

	SignalCycleSettings cycle_signal_types;  ///< Which signal types to cycle with the build signal tool.

	SignalType default_signal_type;          ///< The default signal type, which is set automatically by the last signal used. Not available in Settings.

	TimerGameCalendar::Year coloured_news_year; ///< when does newspaper become coloured?

	TimetableMode timetable_mode;            ///< Time units for timetables: days, seconds, or ticks

	bool   quick_goto;                       ///< Allow quick access to 'goto button' in vehicle orders window

	bool   auto_euro;                        ///< automatically switch to euro in 2002

	bool   drag_signals_fixed_distance;      ///< keep fixed distance between signals when dragging

	TimerGameCalendar::Year semaphore_build_before; ///< build semaphore signals automatically before this year

	bool   show_track_reservation;           ///< highlight reserved tracks.

	bool   station_dragdrop;                 ///< whether drag and drop is enabled for stations

	bool   station_show_coverage;            ///< whether to highlight coverage area

	bool   persistent_buildingtools;         ///< keep the building tools active after usage

	bool   expenses_layout;                  ///< layout of expenses window

	uint32_t last_newgrf_count;                ///< the numbers of NewGRFs we found during the last scan

	uint8_t  graph_line_thickness;             ///< the thickness of the lines in the various graph guis

	uint8_t  osk_activation;                   ///< Mouse gesture to trigger the OSK.

	Colours starting_colour;                 ///< default color scheme for the company to start a new game with

	Colours starting_colour_secondary;       ///< default secondary color scheme for the company to start a new game with

	bool   show_newgrf_name;                 ///< Show the name of the NewGRF in the build vehicle window

	bool   show_cargo_in_vehicle_lists;      ///< Show the cargoes the vehicles can carry in the list windows

	bool   auto_remove_signals;              ///< automatically remove signals when in the way during rail construction

	uint16_t refresh_rate;                     ///< How often we refresh the screen (time between draw-ticks).

	uint16_t fast_forward_speed_limit;         ///< Game speed to use when fast-forward is enabled.

	uint16_t console_backlog_timeout;          ///< the minimum amount of time items should be in the console backlog before they will be removed in ~3 seconds granularity.

	uint16_t console_backlog_length;           ///< the minimum amount of items in the console backlog before items will be removed.

struct MusicSettings {

	byte playlist;     ///< The playlist (number) to play

	byte music_vol;    ///< The requested music volume

	byte effect_vol;   ///< The requested effects volume

	byte custom_1[33]; ///< The order of the first custom playlist

	byte custom_2[33]; ///< The order of the second custom playlist

	bool playing;      ///< Whether music is playing

	bool shuffle;      ///< Whether to shuffle the music

};

/** Settings related to currency/unit systems. */

struct LocaleSettings {

	std::string digit_group_separator;            ///< thousand separator for non-currencies

	std::string digit_group_separator_currency;   ///< thousand separator for currencies

	std::string digit_decimal_separator;          ///< decimal separator

};

/** Settings related to news */

struct NewsSettings {

	uint8_t arrival_player;                                 ///< NewsDisplay of vehicles arriving at new stations of current player

	uint8_t arrival_other;                                  ///< NewsDisplay of vehicles arriving at new stations of other players

	uint8_t accident;                                       ///< NewsDisplay of accidents that occur

	uint8_t accident_other;                                 ///< NewsDisplay if a vehicle from another company is involved in an accident

	uint8_t company_info;                                   ///< NewsDisplay of general company information

	std::string last_joined;                              ///< Last joined server

	UseRelayService use_relay_service;                    ///< Use relay service?

	ParticipateSurvey participate_survey;                 ///< Participate in the automated survey

};

/** Settings related to the creation of games. */

struct GameCreationSettings {

	uint32_t generation_seed;                  ///< noise seed for world generation

	TimerGameCalendar::Year starting_year;   ///< starting date

	TimerGameCalendar::Year ending_year;     ///< scoring end date

	uint8_t  map_x;                            ///< X size of map

	uint8_t  map_y;                            ///< Y size of map

	uint16_t custom_town_number;               ///< manually entered number of towns

	uint16_t custom_industry_number;           ///< manually entered number of industries

};

/** Settings related to construction in-game */

struct ConstructionSettings {

	uint8_t  map_height_limit;                 ///< the maximum allowed heightlevel

	bool   build_on_slopes;                  ///< allow building on slopes

	bool   autoslope;                        ///< allow terraforming under things

	uint16_t max_bridge_length;                ///< maximum length of bridges

	uint16_t max_tunnel_length;                ///< maximum length of tunnels

	bool   extra_dynamite;                   ///< extra dynamite

	bool   road_stop_on_town_road;           ///< allow building of drive-through road stops on town owned roads

	bool   road_stop_on_competitor_road;     ///< allow building of drive-through road stops on roads owned by competitors

	bool   crossing_with_competitor;         ///< allow building of level crossings with competitor roads or rails

	uint8_t  raw_industry_construction;        ///< type of (raw) industry construction (none, "normal", prospecting)

	uint8_t  industry_platform;                ///< the amount of flat land around an industry

	bool   freeform_edges;                   ///< allow terraforming the tiles at the map edges

	uint8_t  extra_tree_placement;             ///< (dis)allow building extra trees in-game

	uint8_t  command_pause_level;              ///< level/amount of commands that can't be executed while paused

	uint32_t terraform_per_64k_frames;         ///< how many tile heights may, over a long period, be terraformed per 65536 frames?

	uint16_t terraform_frame_burst;            ///< how many tile heights may, over a short period, be terraformed?

/** Settings related to all pathfinders. */

struct PathfinderSettings {

	uint8_t  pathfinder_for_trains;            ///< the pathfinder to use for trains

	uint8_t  pathfinder_for_roadvehs;          ///< the pathfinder to use for roadvehicles

	uint8_t  pathfinder_for_ships;             ///< the pathfinder to use for ships

	bool   new_pathfinding_all;              ///< use the newest pathfinding algorithm for all

	bool   roadveh_queue;                    ///< buggy road vehicle queueing

	bool   forbid_90_deg;                    ///< forbid trains to make 90 deg turns

	bool   reverse_at_signals;               ///< whether to reverse at signals at all

	bool   reserve_paths;                    ///< always reserve paths regardless of signal type.

	NPFSettings  npf;                        ///< pathfinder settings for the new pathfinder

	YAPFSettings yapf;                       ///< pathfinder settings for the yet another pathfinder

};

/** Settings related to orders. */

struct OrderSettings {

	bool   improved_load;                    ///< improved loading algorithm

	bool   gradual_loading;                  ///< load vehicles gradually

	bool   selectgoods;                      ///< only send the goods to station if a train has been there

	bool   no_servicing_if_no_breakdowns;    ///< don't send vehicles to depot when breakdowns are disabled

	bool   serviceathelipad;                 ///< service helicopters at helipads automatically (no need to send to depot)

	uint8_t  train_slope_steepness;            ///< Steepness of hills for trains when using realistic acceleration

	uint8_t  roadveh_slope_steepness;          ///< Steepness of hills for road vehicles when using realistic acceleration

	bool   wagon_speed_limits;               ///< enable wagon speed limits

	bool   disable_elrails;                  ///< when true, the elrails are disabled

	UnitID max_trains;                       ///< max trains in game per company

	UnitID max_roadveh;                      ///< max trucks in game per company

	UnitID max_aircraft;                     ///< max planes in game per company

	UnitID max_ships;                        ///< max ships in game per company

	uint8_t  plane_speed;                      ///< divisor for speed of aircraft

	uint8_t  freight_trains;                   ///< value to multiply the weight of cargo by

	bool   dynamic_engines;                  ///< enable dynamic allocation of engine data

	bool   never_expire_vehicles;            ///< never expire vehicles

	uint8_t  plane_crashes;                    ///< number of plane crashes, 0 = none, 1 = reduced, 2 = normal

};

/** Settings related to the economy. */

struct EconomySettings {

	bool   inflation;                        ///< disable inflation

	bool   bribe;                            ///< enable bribing the local authority

	EconomyType type;                        ///< economy type (original/smooth/frozen)

	uint8_t  feeder_payment_share;             ///< percentage of leg payment to virtually pay in feeder systems

	bool   exclusive_rights;                 ///< allow buying exclusive rights

	bool   fund_buildings;                   ///< allow funding new buildings

	bool   fund_roads;                       ///< allow funding local road reconstruction

	bool   give_money;                       ///< allow giving other companies money

	bool   mod_road_rebuild;                 ///< roadworks remove unnecessary RoadBits

	bool   multiple_industry_per_town;       ///< allow many industries of the same type per town

	uint8_t  town_growth_rate;                 ///< town growth rate

	uint8_t  larger_towns;                     ///< the number of cities to build. These start off larger and grow twice as fast

	uint8_t  initial_city_size;                ///< multiplier for the initial size of the cities compared to towns

	TownLayout town_layout;                  ///< select town layout, @see TownLayout

	TownCargoGenMode town_cargogen_mode;     ///< algorithm for generating cargo from houses, @see TownCargoGenMode

	bool   allow_town_roads;                 ///< towns are allowed to build roads (always allowed when generating world / in SE)

		if (IsCargoInClass(cargo, CC_ARMOURED)) return this->distribution_armoured;

		return this->distribution_default;

	}

};

/** Settings related to stations. */

struct StationSettings {

	bool   modified_catchment;               ///< different-size catchment areas

	bool   serve_neutral_industries;         ///< company stations can serve industries with attached neutral stations

	bool   adjacent_stations;                ///< allow stations to be built directly adjacent to other stations

	bool   distant_join_stations;            ///< allow to join non-adjacent stations

	bool   never_expire_airports;            ///< never expire airports

};

/** Default settings for vehicles. */

struct VehicleDefaultSettings {

	bool   servint_ispercent;                ///< service intervals are in percents

	uint16_t servint_trains;                   ///< service interval for trains

	uint16_t servint_roadveh;                  ///< service interval for road vehicles

	uint16_t servint_aircraft;                 ///< service interval for aircraft

	uint16_t servint_ships;                    ///< service interval for ships

};

/** Settings that can be set per company. */