/* $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 */

	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. */