/* $Id$ */

/*

 * This file is part of OpenTTD.

 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.

 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

/** @file linkgraph_type.h Declaration of link graph types used for cargo distribution. */

#ifndef LINKGRAPH_TYPE_H

#define LINKGRAPH_TYPE_H

typedef uint16 LinkGraphID;

static const LinkGraphID INVALID_LINK_GRAPH = UINT16_MAX;

typedef uint16 LinkGraphJobID;

static const LinkGraphID INVALID_LINK_GRAPH_JOB = UINT16_MAX;

typedef uint16 NodeID;

static const NodeID INVALID_NODE = UINT16_MAX;

	DT_BEGIN = 0,

	DT_MIN = 0,

	DT_MANUAL = 0,           ///< Manual distribution. No link graph calculations are run.

	DT_ASYMMETRIC = 1,       ///< Asymmetric distribution. Usually cargo will only travel in one direction.

	DT_MAX_NONSYMMETRIC = 1, ///< Maximum non-symmetric distribution.

	DT_SYMMETRIC = 2,        ///< Symmetric distribution. The same amount of cargo travels in each direction between each pair of nodes.

	DT_MAX = 2,

	DT_NUM = 3,

	DT_END = 3

};

/* It needs to be 8bits, because we save and load it as such

 * Define basic enum properties

 */

template <> struct EnumPropsT<DistributionType> : MakeEnumPropsT<DistributionType, byte, DT_BEGIN, DT_END, DT_NUM> {};

/**

 * Special modes for updating links. 'Restricted' means that vehicles with

 * 'no loading' orders are serving the link. If a link is only served by

 * such vehicles it's 'fully restricted'. This means the link can be used

 * by cargo arriving in such vehicles, but not by cargo generated or

 * transferring at the source station of the link. In order to find out

 * about this condition we keep two update timestamps in each link, one for

 * the restricted and one for the unrestricted part of it. If either one

 * times out while the other is still valid the link becomes fully

 * restricted or fully unrestricted, respectively.

 * Refreshing a link makes just sure a minimum capacity is kept. Increasing

 * actually adds the given capacity.

 */

enum EdgeUpdateMode {

	EUM_INCREASE     = 1,      ///< Increase capacity.

	EUM_REFRESH      = 1 << 1, ///< Refresh capacity.

	EUM_RESTRICTED   = 1 << 2, ///< Use restricted link.

	EUM_UNRESTRICTED = 1 << 3, ///< Use unrestricted link.

};

DECLARE_ENUM_AS_BIT_SET(EdgeUpdateMode)

#endif /* LINKGRAPH_TYPE_H */

	uint32 rail_pbs_station_penalty;         ///< penalty for crossing a reserved station tile

	uint32 rail_pbs_signal_back_penalty;     ///< penalty for passing a pbs signal from the backside

	uint32 rail_doubleslip_penalty;          ///< penalty for passing a double slip switch

	uint32 rail_longer_platform_penalty;           ///< penalty for longer  station platform than train

	uint32 rail_longer_platform_per_tile_penalty;  ///< penalty for longer  station platform than train (per tile)

	uint32 rail_shorter_platform_penalty;          ///< penalty for shorter station platform than train

	uint32 rail_shorter_platform_per_tile_penalty; ///< penalty for shorter station platform than train (per tile)

	uint32 ship_curve45_penalty;                   ///< penalty for 45-deg curve for ships

	uint32 ship_curve90_penalty;                   ///< penalty for 90-deg curve for ships

};

/** Settings related to all pathfinders. */

struct PathfinderSettings {

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

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

	uint8  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

	byte   wait_oneway_signal;               ///< waitingtime in days before a oneway signal

	byte   wait_twoway_signal;               ///< waitingtime in days before a twoway signal

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

	byte   wait_for_pbs_path;                ///< how long to wait for a path reservation.

	byte   path_backoff_interval;            ///< ticks between checks for a free path.

	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)

};

/** Settings related to vehicles. */

struct VehicleSettings {

	uint8  max_train_length;                 ///< maximum length for trains

	uint8  smoke_amount;                     ///< amount of smoke/sparks locomotives produce

	uint8  train_acceleration_model;         ///< realistic acceleration for trains

	uint8  roadveh_acceleration_model;       ///< realistic acceleration for road vehicles

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

	uint8  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  plane_speed;                      ///< divisor for speed of aircraft

	uint8  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

	byte   extend_vehicle_life;              ///< extend vehicle life by this many years

	byte   road_side;                        ///< the side of the road vehicles drive on

	uint8  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

	bool   smooth_economy;                   ///< smooth economy

	bool   allow_shares;                     ///< allow the buying/selling of shares

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

	byte   dist_local_authority;             ///< distance for town local authority, default 20

	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  town_growth_rate;                 ///< town growth rate

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

	uint8  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)

	TownFounding found_town;                 ///< town founding.

	bool   station_noise_level;              ///< build new airports when the town noise level is still within accepted limits

	uint16 town_noise_population[3];         ///< population to base decision on noise evaluation (@see town_council_tolerance)

	bool   allow_town_level_crossings;       ///< towns are allowed to build level crossings

	bool   infrastructure_maintenance;       ///< enable monthly maintenance fee for owner infrastructure

};

struct LinkGraphSettings {

	uint16 recalc_time;                         ///< time (in days) for recalculating each link graph component.

	uint16 recalc_interval;                     ///< time (in days) between subsequent checks for link graphs to be calculated.

	uint8 accuracy;                             ///< accuracy when calculating things on the link graph. low accuracy => low running time

	uint8 demand_size;                          ///< influence of supply ("station size") on the demand function

	uint8 demand_distance;                      ///< influence of distance between stations on the demand function

	uint8 short_path_saturation;                ///< percentage up to which short paths are saturated before saturating most capacious paths

	inline DistributionType GetDistributionType(CargoID cargo) const {

		if (IsCargoInClass(cargo, CC_PASSENGERS)) return this->distribution_pax;

		if (IsCargoInClass(cargo, CC_MAIL)) return this->distribution_mail;

		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

	byte   station_spread;                   ///< amount a station may spread

};

/** Default settings for vehicles. */

struct VehicleDefaultSettings {

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

	uint16 servint_trains;                   ///< service interval for trains

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

	uint16 servint_aircraft;                 ///< service interval for aircraft

	uint16 servint_ships;                    ///< service interval for ships

};

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

struct CompanySettings {

	bool engine_renew;                       ///< is autorenew enabled

	int16 engine_renew_months;               ///< months before/after the maximum vehicle age a vehicle should be renewed

	uint32 engine_renew_money;               ///< minimum amount of money before autorenew is used

	bool renew_keep_length;                  ///< sell some wagons if after autoreplace the train is longer than before

	VehicleDefaultSettings vehicle;          ///< default settings for vehicles

};

/** All settings together for the game. */

struct GameSettings {

	DifficultySettings   difficulty;         ///< settings related to the difficulty

	GameCreationSettings game_creation;      ///< settings used during the creation of a game (map)

	ConstructionSettings construction;       ///< construction of things in-game

	AISettings           ai;                 ///< what may the AI do?

	ScriptSettings       script;             ///< settings for scripts

	class AIConfig      *ai_config[MAX_COMPANIES]; ///< settings per company

	class GameConfig    *game_config;        ///< settings for gamescript

	PathfinderSettings   pf;                 ///< settings for all pathfinders

	OrderSettings        order;              ///< settings related to orders

	VehicleSettings      vehicle;            ///< options for vehicles

	EconomySettings      economy;            ///< settings to change the economy

	LinkGraphSettings    linkgraph;          ///< settings for link graph calculations

	StationSettings      station;            ///< settings related to station management

	LocaleSettings       locale;             ///< settings related to used currency/unit system in the current game

};

/** All settings that are only important for the local client. */

struct ClientSettings {

	GUISettings          gui;                ///< settings related to the GUI

	NetworkSettings      network;            ///< settings related to the network

	CompanySettings      company;            ///< default values for per-company settings

	SoundSettings        sound;              ///< sound effect settings

	MusicSettings        music;              ///< settings related to music/sound

	NewsSettings         news_display;       ///< news display settings.

};

/** The current settings for this game. */

extern ClientSettings _settings_client;

/** The current settings for this game. */

extern GameSettings _settings_game;

/** The settings values that are used for new games and/or modified in config file. */

extern GameSettings _settings_newgame;

/** Old vehicle settings, which were game settings before, and are company settings now. (Needed for savegame conversion) */

extern VehicleDefaultSettings _old_vds;

/**

 * Get the settings-object applicable for the current situation: the newgame settings

 * when we're in the main menu and otherwise the settings of the current game.

 */

static inline GameSettings &GetGameSettings()

{

	return (_game_mode == GM_MENU) ? _settings_newgame : _settings_game;

}

#endif /* SETTINGS_TYPE_H */