/** @file airport.h Various declarations for airports */

#ifndef AIRPORT_H

#define AIRPORT_H

#include "direction_type.h"

enum {MAX_TERMINALS =  10};

enum {MAX_HELIPADS  =   4};

enum {MAX_ELEMENTS  = 255};

enum {MAX_HEADINGS  =  22};

 */

#ifndef AYSTAR_H

#define AYSTAR_H

#include "queue.h"

//#define AYSTAR_DEBUG

enum {

	AYSTAR_FOUND_END_NODE,

	AYSTAR_EMPTY_OPENLIST,

	AYSTAR_STILL_BUSY,

/** @file bridge.h Header file for bridges */

#ifndef BRIDGE_H

#define BRIDGE_H

#include "gfx_type.h"

enum {

	MAX_BRIDGES = 13

};

/** Struct containing information about a single bridge type

#include "genworld.h"

#include "industry.h"

#include "water_map.h"

#include "tile_cmd.h"

#include "vehicle.h"

#include "functions.h"

/*

 * In one terraforming command all four corners of a initial tile can be raised/lowered (though this is not available to the player).

 * The maximal amount of height modifications is archieved when raising a complete flat land from sea level to MAX_TILE_HEIGHT or vice versa.

 * This affects all corners with a manhatten distance smaller than MAX_TILE_HEIGHT to one of the initial 4 corners.

 * Their maximal amount is computed to 4 * \sum_{i=1}^{h_max} i  =  2 * h_max * (h_max + 1).

#define ECONOMY_FUNC_H

#include "core/geometry_type.hpp"

#include "economy_type.h"

#include "cargo_type.h"

#include "vehicle_type.h"

struct Player;

void ResetPriceBaseMultipliers();

void SetPriceBaseMultiplier(uint price, byte factor);

#ifndef FUNCTIONS_H

#define FUNCTIONS_H

#include "core/random_func.hpp"

#include "command_type.h"

#include "openttd.h"

/* clear_land.cpp */

void DrawHillyLandTile(const TileInfo *ti);

void DrawClearLandTile(const TileInfo *ti, byte set);

void DrawClearLandFence(const TileInfo *ti);

void TileLoopClearHelper(TileIndex tile);

#include "network/network.h"

#include "debug.h"

#include "settings.h"

#include "heightmap.h"

#include "date.h"

#include "viewport.h"

void GenerateClearTile();

void GenerateIndustries();

void GenerateUnmovables();

bool GenerateTowns();

void GenerateTrees();

#define GUI_H

#include "window_type.h"

#include "vehicle_type.h"

#include "gfx_type.h"

#include "economy_type.h"

/* main_gui.cpp */

void CcPlaySound10(bool success, TileIndex tile, uint32 p1, uint32 p2);

void CcBuildCanal(bool success, TileIndex tile, uint32 p1, uint32 p2);

void CcTerraform(bool success, TileIndex tile, uint32 p1, uint32 p2);

void ShowTerraformToolbar(Window *link = NULL);

/* tgp_gui.cpp */

void ShowGenerateLandscape();

void ShowHeightmapLoad();

void PlaceProc_DemolishArea(TileIndex tile);

void PlaceProc_LevelLand(TileIndex tile);

void PlaceProc_BuyLand(TileIndex tile);

bool GUIPlaceProcDragXY(const WindowEvent *e);

/** Drag and drop selection process, or, what to do with an area of land when

 * you've selected it. */

enum {

	DDSP_DEMOLISH_AREA,

	DDSP_LEVEL_AREA,

void ShowBuildIndustryWindow();

void ShowMusicWindow();

/* main_gui.cpp */

void HandleOnEditText(const char *str);

VARDEF bool _station_show_coverage;

void InitializeGUI();

#endif /* GUI_H */

#include "oldpool.h"

#include "core/random_func.hpp"

#include "newgrf_storage.h"

#include "cargo_type.h"

#include "economy_type.h"

typedef uint16 IndustryGfx;

typedef uint8 IndustryType;

enum {

	INVALID_INDUSTRY       = 0xFFFF,

/** @file landscape.h */

#ifndef LANDSCAPE_H

#define LANDSCAPE_H

#include "core/geometry_type.hpp"

enum {

	SNOW_LINE_MONTHS = 12,

	SNOW_LINE_DAYS   = 32,

};

static inline TileIndex TileVirtXY(uint x, uint y)

{

	return (y >> 4 << MapLogX()) + (x >> 4);

}

/**

 * Get the X component of a tile

 * @param tile the tile to get the X component of

 * @return the X component

 */

static inline uint TileX(TileIndex tile)

#ifndef NEWS_H

#define NEWS_H

#include "window_type.h"

#include "vehicle_type.h"

struct NewsItem {

	StringID string_id; ///< Message text (sometimes also used for storing other info)

	uint16 duration;    ///< Remaining time for showing this news message

	Date date;          ///< Date of the news

	byte flags;         ///< NewsFlags bits @see NewsFlags

#define OPENTTD_H

#ifndef VARDEF

#define VARDEF extern

#endif

#include "strings_type.h"

// Forward declarations of structs.

struct Depot;

struct Waypoint;

struct Station;

struct ViewPort;

struct Town;

/** Define basic enum properties */

template <> struct EnumPropsT<TransportType> : MakeEnumPropsT<TransportType, byte, TRANSPORT_BEGIN, TRANSPORT_END, INVALID_TRANSPORT> {};

typedef TinyEnumT<TransportType> TransportTypeByte;

/* Display Options */

enum {

	DO_SHOW_TOWN_NAMES    = 0,

	DO_SHOW_STATION_NAMES = 1,

	DO_SHOW_SIGNS         = 2,

	DO_FULL_ANIMATION     = 3,

	GDType economy;

	GDType line_reverse_mode;

	GDType disasters;

	GDType town_council_tolerance; // minimum required town ratings to be allowed to demolish stuff

};

struct ViewportSign {

	int32 left;

	int32 top;

	byte width_1, width_2;

};

enum {

	SORT_ASCENDING  = 0,

	SORT_DESCENDING = 1,

	SORT_BY_DATE    = 0,

	SORT_BY_NAME    = 2

};

#define ORDER_H

#include "oldpool.h"

#include "core/bitmath_func.hpp"

#include "cargo_type.h"

#include "vehicle_type.h"

enum {

	INVALID_VEH_ORDER_ID = 0xFF,

};

static const OrderID INVALID_ORDER = 0xFFFF;

#include "track_type.h"

#include "vehicle_type.h"

#include "gfx_type.h"

#include "core/bitmath_func.hpp"

#include "economy_func.h"

#include "variables.h"

/** This struct contains all the info that is needed to draw and construct tracks.

 */

struct RailtypeInfo {

	/** Struct containing the main sprites. @note not all sprites are listed, but only

	 *  the ones used directly in the code */

/** these are the maximums used for updating signal blocks, and checking if a depot is in a pbs block */

enum {

	NUM_SSD_ENTRY = 256, ///< max amount of blocks

	NUM_SSD_STACK =  32, ///< max amount of blocks to check recursively

};

/**

 * Returns a pointer to the Railtype information for a given railtype

 * @param railtype the rail type which the information is requested for

 * @return The pointer to the RailtypeInfo

/** @file rail_map.h Hides the direct accesses to the map array with map accessors */

#ifndef RAIL_MAP_H

#define RAIL_MAP_H

#include "direction_func.h"

#include "track_func.h"

#include "tile_map.h"

/** Different types of Rail-related tiles */

enum RailTileType {

	RAIL_TILE_NORMAL   = 0, ///< Normal rail tile without signals

#ifndef ROAD_FUNC_H

#define ROAD_FUNC_H

#include "core/bitmath_func.hpp"

#include "road_type.h"

/**

 * Whether the given roadtype is valid.

 * @param rt the roadtype to check for validness

 * @return true if and only if valid

 */

/** @file road_internal.h Functions used internally by the roads. */

#ifndef ROAD_INTERNAL_H

#define ROAD_INTERNAL_H

/**

 * Clean up unneccesary RoadBits of a planed tile.

 * @param tile current tile

 * @param org_rb planed RoadBits

 * @return optimised RoadBits

 */

#include "blitter/factory.hpp"

#include "fileio.h"

#include "strings_func.h"

#include "zoom_func.h"

#include "core/alloc_func.hpp"

#include "core/endian_func.hpp"

char _screenshot_format_name[8];

uint _num_screenshot_formats;

uint _cur_screenshot_format;

ScreenshotType current_screenshot_type;

#ifndef SLOPE_FUNC_H

#define SLOPE_FUNC_H

#include "core/math_func.hpp"

#include "slope_type.h"

#include "direction_type.h"

/**

 * Rangecheck for Corner enumeration.

 *

 * @param corner A #Corner.

 * @return true iff corner is in a valid range.

#ifndef SOUND_H

#define SOUND_H

#include "core/enum_type.hpp"

#include "vehicle_type.h"

struct MusicFileSettings {

	byte playlist;

	byte music_vol;

	byte effect_vol;

	byte custom_1[33];

#ifndef STATION_MAP_H

#define STATION_MAP_H

#include "rail_map.h"

#include "road_map.h"

#include "station.h"

typedef byte StationGfx;

static inline StationID GetStationIndex(TileIndex t)

{

	assert(IsTileType(t, MP_STATION));

/** @file tile_cmd.h Generic 'commands' that can be performed on all tiles. */

#ifndef TILE_CMD_H

#define TILE_CMD_H

#include "slope_type.h"

#include "command_type.h"

#include "vehicle_type.h"

#include "cargo_type.h"

/** The returned bits of VehicleEnterTile. */

enum VehicleEnterTileStatus {

	VETS_ENTERED_STATION  = 1, ///< The vehicle entered a station

	VETS_ENTERED_WORMHOLE = 2, ///< The vehicle either entered a bridge, tunnel or depot tile (this includes the last tile of the bridge/tunnel)

	VETS_CANNOT_ENTER     = 3, ///< The vehicle cannot enter the tile

	VETSB_ENTERED_STATION  = 1 << VETS_ENTERED_STATION,  ///< The vehicle entered a station

	VETSB_ENTERED_WORMHOLE = 1 << VETS_ENTERED_WORMHOLE, ///< The vehicle either entered a bridge, tunnel or depot tile (this includes the last tile of the bridge/tunnel)

	VETSB_CANNOT_ENTER     = 1 << VETS_CANNOT_ENTER,     ///< The vehicle cannot enter the tile

};

DECLARE_ENUM_AS_BIT_SET(VehicleEnterTileStatus);

typedef void DrawTileProc(TileInfo *ti);

typedef uint GetSlopeZProc(TileIndex tile, uint x, uint y);

typedef CommandCost ClearTileProc(TileIndex tile, byte flags);

typedef void GetAcceptedCargoProc(TileIndex tile, AcceptedCargo res);

typedef void GetTileDescProc(TileIndex tile, TileDesc *td);

#ifndef TILE_TYPE_H

#define TILE_TYPE_H

#include "core/enum_type.hpp"

/**

 * The different type of a tile.

 *

 * Each tile belongs to one type, according whatever is build on it.

 *

/**

 * The index/ID of a Tile.

 */

typedef uint32 TileIndex;

#endif /* TILE_TYPE_H */

#ifndef TOWN_H

#define TOWN_H

#include "oldpool.h"

#include "core/random_func.hpp"

#include "cargo_type.h"

enum {

	HOUSE_NO_CLASS   = 0,

	NEW_HOUSE_OFFSET = 110,

	HOUSE_MAX        = 512,

	INVALID_TOWN     = 0xFFFF,

#ifndef VARIABLES_H

#define VARIABLES_H

#include "yapf/yapf_settings.h"

#include "openttd.h"

/* ********* START OF SAVE REGION */

struct GameOptions {

	GameDifficulty diff;

	byte diff_level;

#include "vehicle_type.h"

#include "track_type.h"

#include "rail_type.h"

#include "road_type.h"

#include "cargo_type.h"

#include "window_type.h"

#include "gfx_type.h"

#include "command_type.h"

#include "oldpool.h"

#include "order.h"

#include "cargopacket.h"

#define VIEWPORT_H

#include "zoom_type.h"

#include "window_type.h"

#include "vehicle_type.h"

#include "gfx_func.h"

struct ViewPort {

	int left,top;                       // screen coordinates for the viewport

	int width, height;                  // screen width/height for the viewport

	int virtual_left, virtual_top;      // virtual coordinates

#include "command_func.h"

#include "landscape.h"

#include "map.h"

#include "order.h"

#include "rail_map.h"

#include "bridge_map.h"

#include "saveload.h"

#include "station.h"

#include "town.h"

#include "waypoint.h"

#include "variables.h"

#include "string.h"

#include "misc/autoptr.hpp"

#include "strings_func.h"

#include "viewport.h"

#include "functions.h"

#include "window_func.h"

enum {

	MAX_WAYPOINTS_PER_TOWN = 64,

};

DEFINE_OLD_POOL_GENERIC(Waypoint, Waypoint)