#define BASE_CONSIST_H

#include "order_type.h"

#include <string>

/** Various front vehicle properties that are preserved when autoreplacing, using order-backup or switching front engines within a consist. */

	std::string name;                   ///< Name of vehicle

	/* Used for timetabling. */

	uint16 service_interval;            ///< The interval for (automatic) servicing; either in days or %.

#include "command_type.h"

#include "viewport_type.h"

#include "station_map.h"

typedef Pool<BaseStation, StationID, 32, 64000> StationPool;

extern StationPool _station_pool;

	std::vector<StationSpecList> speclist;           ///< List of rail station specs of this station.

	std::vector<RoadStopSpecList> roadstop_speclist; ///< List of road stop specs of this station

	uint16 random_bits;             ///< Random bits assigned to this station

	byte waiting_triggers;          ///< Waiting triggers (NewGRF) for this station

#include "gfx_type.h"

#include "tile_cmd.h"

/**

 * This enum is related to the definition of bridge pieces,

 * Struct containing information about a single bridge type

 */

struct BridgeSpec {

};

extern BridgeSpec _bridge[MAX_BRIDGES];

	YearMonthDay ymd;

	ConvertDateToYMD(TimerGameCalendar::date, &ymd);

	/* Shift cached dates before we change the date. */

	for (auto v : Vehicle::Iterate()) v->ShiftDates(new_date - TimerGameCalendar::date);

#include "livery.h"

#include "autoreplace_type.h"

#include "tile_type.h"

#include "settings_type.h"

#include "group.h"

#include <string>

	std::array<Owner, MAX_COMPANY_SHARE_OWNERS> share_owners; ///< Owners of the shares of the company. #INVALID_OWNER if nobody has bought them yet.

	byte months_of_bankruptcy;       ///< Number of months that the company is unable to pay its debts

	CompanyMask bankrupt_asked;      ///< which companies were asked about buying it?

	uint i;

	for (i = 0; i < CURRENCY_END; i++) {

		if (to_euro != CF_NOEURO && to_euro != CF_ISEURO && TimerGameCalendar::year >= to_euro) continue;

		if (to_euro == CF_ISEURO && TimerGameCalendar::year < 2000) continue;

#ifndef CURRENCY_H

#define CURRENCY_H

#include "string_func.h"

#include "strings_type.h"

struct CurrencySpec {

	uint16 rate;           ///< The conversion rate compared to the base currency.

	std::string separator; ///< The thousands separator for this currency.

	std::string prefix;    ///< Prefix to apply when formatting money in this currency.

	std::string suffix;    ///< Suffix to apply when formatting money in this currency.

	/**

	CurrencySpec() = default;

		rate(rate), separator(separator), to_euro(to_euro), prefix(prefix), suffix(suffix), symbol_pos(symbol_pos), name(name)

	{

	}

 * @param date the date to convert from

 * @param ymd  the year, month and day to write to

 */

{

	/* Year determination in multiple steps to account for leap

	 * years. First do the large steps, then the smaller ones.

	 */

	/* There are 97 leap years in 400 years */

	int rem = date % (DAYS_IN_YEAR * 400 + 97);

	uint16 x;

 * @param month is a number between 0..11

 * @param day   is a number between 1..31

 */

{

	/* Day-offset in a leap year */

	int days = _accum_days_for_month[month] + day - 1;

#include "date_type.h"

/**

 * Checks whether the given year is a leap year or not.

 * @param yr The year to check.

 * @return True if \c yr is a leap year, otherwise false.

 */

{

	return yr % 4 == 0 && (yr % 100 != 0 || yr % 400 == 0);

}

	SetDateCallback *callback; ///< Callback to call when a date has been selected

	void *callback_data;       ///< Callback data pointer.

	YearMonthDay date; ///< The currently selected date

	/**

	 * Create the new 'set date' window

	 * @param max_year the maximum year (inclusive) to show in the year dropdown

	 * @param callback the callback to call once a date has been selected

	 */

			Window(desc),

			callback(callback),

			callback_data(callback_data),

				break;

			case WID_SD_YEAR:

					DropDownListParamStringItem *item = new DropDownListParamStringItem(STR_JUST_INT, i, false);

					item->SetParam(0, i);

					list.emplace_back(item);

 * @param callback the callback to call once a date has been selected

 * @param callback_data extra callback data

 */

{

	CloseWindowByClass(WC_SET_DATE);

	new SetDateWindow(&_set_date_desc, window_number, parent, initial_date, min_year, max_year, callback, callback_data);

#ifndef DATE_GUI_H

#define DATE_GUI_H

#include "window_type.h"

/**

 * @param w the window that sends the callback

 * @param date the date that has been chosen

 */

#endif /* DATE_GUI_H */

#ifndef DATE_TYPE_H

#define DATE_TYPE_H

typedef int32  Ticks;     ///< The type to store ticks in

/**

 * 1 day is 74 ticks; TimerGameCalendar::date_fract used to be uint16 and incremented by 885. On

 */

/** The minimum starting year/base year of the original TTD */

/** The original ending year */

/** The maximum year of the original TTD */

/**

 * Calculate the number of leap years till a given year.

#define DAYS_TILL_ORIGINAL_BASE_YEAR DAYS_TILL(ORIGINAL_BASE_YEAR)

/** The absolute minimum & maximum years in OTTD */

/** The default starting year */

/** The default scoring end year */

/**

 * MAX_YEAR, nicely rounded value of the number of years that can

 * be encoded in a single 32 bits date, about 2^31 / 366 years.

 */

/** The number of days till the last day */

#define MAX_DAY (DAYS_TILL(MAX_YEAR + 1) - 1)

 * @see ConvertDateToYMD(), ConvertYMDToDate()

 */

struct YearMonthDay {

};

static const Ticks INVALID_TICKS = -1; ///< Representation of an invalid number of ticks

#endif /* DATE_TYPE_H */

#include "depot_map.h"

#include "core/pool_type.hpp"

typedef Pool<Depot, DepotID, 64, 64000> DepotPool;

extern DepotPool _depot_pool;

	std::string name;

	TileIndex xy;

	Depot(TileIndex xy = INVALID_TILE) : xy(xy) {}

	~Depot();

}

struct Disaster {

};

static const Disaster _disasters[] = {

 * Year that engine aging stops. Engines will not reduce in reliability

 * and no more engines will be introduced

 */

/** Number of engines of each vehicle type in original engine data */

const uint8 _engine_counts[4] = {

 * Returns the vehicle's (not model's!) life length in days.

 * @return the life length

 */

{

	/* Assume leap years; this gives the player a bit more than the given amount of years, but never less. */

	return (this->info.lifelength + _settings_game.vehicle.extend_vehicle_life) * DAYS_IN_LEAP_YEAR;

 * @param aging_date The date used for age calculations.

 * @param seed Random seed.

 */

{

	const EngineInfo *ei = &e->info;

	/* Don't randomise the start-date in the first two years after gamestart to ensure availability

	 * of engines in early starting games.

	 * Note: TTDP uses fixed 1922 */

	if (e->intro_date <= TimerGameCalendar::date) {

		e->age = (aging_date - e->intro_date) >> 5;

		e->company_avail = MAX_UVALUE(CompanyMask);

void StartupEngines()

{

	/* Aging of vehicles stops, so account for that when starting late */

	uint32 seed = Random();

	for (Engine *e : Engine::Iterate()) {

 */

void CheckEngines()

{

	for (const Engine *e : Engine::Iterate()) {

		if (!e->IsEnabled()) continue;

#include "vehicle_type.h"

#include "core/pool_type.hpp"

#include "newgrf_commons.h"

struct WagonOverride {

	std::vector<EngineID> engines;

struct Engine : EnginePool::PoolItem<&_engine_pool> {

	std::string name;           ///< Custom name of engine.

	uint16 reliability;         ///< Current reliability of the engine.

	uint16 reliability_spd_dec; ///< Speed of reliability decay between services (per day).

	uint16 reliability_start;   ///< Initial reliability of the engine.

	uint GetPower() const;

	uint GetDisplayWeight() const;

	uint GetDisplayMaxTractiveEffort() const;

	uint16 GetRange() const;

	StringID GetAircraftTypeText() const;

#include "engine_type.h"

#include "vehicle_type.h"

#include "company_type.h"

void SetupEngines();

void StartupEngines();

bool IsEngineRefittable(EngineID engine);

void SetYearEngineAgingStops();

void CalcEngineReliability(Engine *e, bool new_month);

uint GetTotalCapacityOfArticulatedParts(EngineID engine);

#include "rail_type.h"

#include "road_type.h"

#include "cargo_type.h"

#include "sound_type.h"

#include "strings_type.h"

 *  @see table/engines.h

 */

struct EngineInfo {

	byte decay_speed;

	byte load_amount;

	byte climates;      ///< Climates supported by the engine.

#include "company_base.h"

#include "newgrf_config.h"

#include "network/core/tcp_content_type.h"

/** Special values for save-load window for the data parameter of #InvalidateWindowData. */

	char *error_data;   ///< Data to pass to SetDParamStr when displaying #error.

	uint32 map_size_x, map_size_y;

	GameSettings settings;

#include "cargotype.h"

#include "strings_func.h"

#include "window_func.h"

#include "timer/timer_game_calendar.h"

#include "gfx_func.h"

#include "core/geometry_func.hpp"

	/* The starting month and year that values are plotted against. */

	byte month;

	bool draw_dates = true; ///< Should we draw months and years on the time axis?

			x = r.left;

			y = r.bottom + ScaleGUITrad(2);

			byte month = this->month;

			for (int i = 0; i < this->num_on_x_axis; i++) {

				SetDParam(0, month + STR_MONTH_ABBREV_JAN);

				SetDParam(1, year);

		/* Draw x-axis labels and markings for graphs based on financial quarters and years.  */

		if (this->draw_dates) {

			byte month = this->month;

			for (int i = 0; i < this->num_on_x_axis; i++) {

				SetDParam(0, month + STR_MONTH_ABBREV_JAN);

				SetDParam(1, year);

#define HOUSE_H

#include "cargo_type.h"

#include "house_type.h"

#include "newgrf_animation_type.h"

#include "newgrf_commons.h"

struct HouseSpec {

	/* Standard properties */

	byte population;                          ///< population (Zero on other tiles in multi tile house.)

	byte removal_cost;                        ///< cost multiplier for removing it

	StringID building_name;                   ///< building name

#include "industrytype.h"

#include "tilearea_type.h"

#include "station_base.h"

typedef Pool<Industry, IndustryID, 64, 64000> IndustryPool;

extern IndustryPool _industry_pool;

/**

 * Production level maximum, minimum and default values.

	IndustryType type;             ///< type of industry.

	Owner owner;                   ///< owner of the industry.  Which SHOULD always be (imho) OWNER_NONE

	byte random_colour;            ///< randomized colour of the industry, for display purpose

	byte was_cargo_delivered;      ///< flag that indicate this has been the closest industry chosen for cargo delivery by a station. see DeliverGoodsToIndustry

	IndustryControlFlags ctlflags; ///< flags overriding standard behaviours

	mutable std::string cached_name; ///< NOSAVE: Cache of the resolved name of the industry

	Owner founder;                 ///< Founder of the industry

	uint8 construction_type;       ///< Way the industry was constructed (@see IndustryConstructionType)

	byte selected_layout;          ///< Which tile layout was used when creating the industry

	Owner exclusive_supplier;      ///< Which company has exclusive rights to deliver cargo (INVALID_OWNER = anyone)

	Owner exclusive_consumer;      ///< Which company has exclusive rights to take cargo (INVALID_OWNER = anyone)

 */

void LinkGraph::Merge(LinkGraph *other)

{

	NodeID first = this->Size();

	for (NodeID node1 = 0; node1 < other->Size(); ++node1) {

		Station *st = Station::Get(other->nodes[node1].station);

#include "../core/smallmap_type.hpp"

#include "../station_base.h"

#include "../cargotype.h"

#include "../timer/timer_game_calendar.h"

#include "../saveload/saveload.h"

#include "linkgraph_type.h"

		uint capacity;                 ///< Capacity of the link.

		uint usage;                    ///< Usage of the link.

		uint64 travel_time_sum;        ///< Sum of the travel times of the link, in ticks.

		NodeID dest_node;              ///< Destination of the edge.

		BaseEdge(NodeID dest_node = INVALID_NODE);

		 * Get the date of the last update to any part of the edge's capacity.

		 * @return Last update.

		 */

		void Update(uint capacity, uint usage, uint32 time, EdgeUpdateMode mode);

		void Restrict() { this->last_unrestricted_update = INVALID_DATE; }

		uint demand;             ///< Acceptance at the station.

		StationID station;       ///< Station ID.

		TileIndex xy;            ///< Location of the station referred to by the node.

		std::vector<BaseEdge> edges; ///< Sorted list of outgoing edges from this node.

	 * Get date of last compression.

	 * @return Date of last compression.

	 */

	/**

	 * Get the cargo ID this component's link graph refers to.

	friend class LinkGraphJob;

	CargoID cargo;         ///< Cargo of this component's link graph.

	NodeVector nodes;      ///< Nodes in the component.

};

	friend class LinkGraphSchedule;

protected:

	void EraseFlows(NodeID from);

	void JoinThread();

	 * Get the date when the job should be finished.

	 * @return Join date.

	 */

	/**

	 * Change the join date on date cheating.

	 * Get the date when the underlying link graph was last compressed.

	 * @return Compression date.

	 */

	/**

	 * Get the ID of the underlying link graph.

void OnTick_LinkGraph()

{

	if (TimerGameCalendar::date_fract != LinkGraphSchedule::SPAWN_JOIN_TICK) return;

	if (offset == 0) {

		LinkGraphSchedule::instance.SpawnNext();

	} else if (offset == (_settings_game.linkgraph.recalc_interval / SECONDS_PER_DAY) / 2) {

 */

void DeserializeNetworkGameInfo(Packet *p, NetworkGameInfo *info, const GameInfoNewGRFLookupTable *newgrf_lookup_table)

{

	byte game_info_version = p->Recv_uint8();

	NewGRFSerializationType newgrf_serialisation = NST_GRFID_MD5;

#include "config.h"

#include "core.h"

#include "../../newgrf_config.h"