#ifndef BASE_CONSIST_H

#define BASE_CONSIST_H

#include "order_type.h"

#include "timer/timer_game_calendar.h"

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

struct BaseConsist {

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

	/* Used for timetabling. */

/** @file bitmap_type.hpp Bitmap functions. */

#ifndef BITMAP_TYPE_HPP

#define BITMAP_TYPE_HPP

/** Represents a tile area containing containing individually set tiles.

 * Each tile must be contained within the preallocated area.

 * A std::vector<bool> is used to mark which tiles are contained.

 */

class BitmapTileArea : public TileArea {

#include "cargo_type.h"

#include "gfx_type.h"

#include "strings_type.h"

#include "landscape_type.h"

#include "core/bitmath_func.hpp"

#include "core/span_type.hpp"

/** Globally unique label of a cargo type. */

typedef uint32 CargoLabel;

/** Town growth effect when delivering cargo. */

enum TownEffect : byte {

#ifndef COMMAND_TYPE_H

#define COMMAND_TYPE_H

#include "economy_type.h"

#include "strings_type.h"

#include "tile_type.h"

struct GRFFile;

/**

 * Common return value for all commands. Wraps the cost and

 * a possible error message/state together.

#include "livery.h"

#include "autoreplace_type.h"

#include "tile_type.h"

#include "timer/timer_game_calendar.h"

#include "settings_type.h"

#include "group.h"

#include <array>

/** Statistics about the economy. */

struct CompanyEconomyEntry {

	Money income;               ///< The amount of income.

	Money expenses;             ///< The amount of expenses.

#include "console_func.h"

#include "rev.h"

#include "video/video_driver.hpp"

#include "timer/timer.h"

#include "timer/timer_window.h"

#include <deque>

#include "widgets/console_widget.h"

#include "table/strings.h"

#include "safeguards.h"

/** @file kdtree.hpp K-d tree template specialised for 2-dimensional Manhattan geometry */

#ifndef KDTREE_HPP

#define KDTREE_HPP

#include "../stdafx.h"

/**

 * K-dimensional tree, specialised for 2-dimensional space.

 * This is not intended as a primary storage of data, but as an index into existing data.

 * Usually the type stored by this tree should be an index into an existing array.

 *

/** @file math_func.hpp Integer math functions */

#ifndef MATH_FUNC_HPP

#define MATH_FUNC_HPP

/**

 * Returns the absolute value of (scalar) variable.

 *

 * @note assumes variable to be signed

 * @param a The value we want to unsign

#ifndef OVERFLOWSAFE_TYPE_HPP

#define OVERFLOWSAFE_TYPE_HPP

#include "math_func.hpp"

#ifdef __has_builtin

#	if __has_builtin(__builtin_add_overflow) && __has_builtin(__builtin_sub_overflow) && __has_builtin(__builtin_mul_overflow)

#		define HAS_OVERFLOW_BUILTINS

#	endif

#endif

/** @file smallvec_type.hpp Simple vector class that allows allocating an item without the need to copy this->data needlessly. */

#ifndef SMALLVEC_TYPE_HPP

#define SMALLVEC_TYPE_HPP

#include "mem_func.hpp"

/**

 * Helper function to append an item to a vector if it is not already contained

 * Consider using std::set, std::unordered_set or std::flat_set in new code

 *

 * @param vec A reference to the vector to be extended

/** @file dedicated.cpp Forking support for dedicated servers. */

#include "stdafx.h"

#include "fileio_func.h"

#include "debug.h"

std::string _log_file; ///< File to reroute output of a forked OpenTTD to

std::unique_ptr<FILE, FileDeleter> _log_fd; ///< File to reroute output of a forked OpenTTD to

#if defined(UNIX)

#include "error_func.h"

#include "sound/sound_driver.hpp"

#include "music/music_driver.hpp"

#include "video/video_driver.hpp"

#include "string_func.h"

#include "table/strings.h"

#include <sstream>

#include "safeguards.h"

std::string _ini_videodriver;        ///< The video driver a stored in the configuration file.

std::vector<Dimension> _resolutions; ///< List of resolutions.

#ifndef FILEIO_FUNC_H

#define FILEIO_FUNC_H

#include "core/enum_type.hpp"

#include "fileio_type.h"

void FioFCloseFile(FILE *f);

FILE *FioFOpenFile(const std::string &filename, const char *mode, Subdirectory subdir, size_t *filesize = nullptr);

bool FioCheckFileExists(const std::string &filename, Subdirectory subdir);

std::string FioFindFullPath(Subdirectory subdir, const std::string &filename);

std::string FioGetDirectory(Searchpath sp, Subdirectory subdir);

#include "network/network_content.h"

#include "screenshot.h"

#include "string_func.h"

#include "strings_func.h"

#include "tar_type.h"

#include <sys/stat.h>

#include <charconv>

#ifndef _WIN32

# include <unistd.h>

#endif /* _WIN32 */

#include "timer/timer_window.h"

#include "widgets/framerate_widget.h"

#include <atomic>

#include <mutex>

#include "safeguards.h"

static std::mutex _sound_perf_lock;

static std::atomic<bool> _sound_perf_pending;

static std::vector<TimingMeasurement> _sound_perf_measurements;

#include "game_info.hpp"

#include "table/strings.h"

#include "table/strgen_tables.h"

#include <stdarg.h>

#include "../safeguards.h"

void CDECL StrgenWarningI(const std::string &msg)

{

	Debug(script, 0, "{}:{}: warning: {}", _file, _cur_line, msg);

/** @file gamelog.h Functions to be called to log possibly unsafe game events */

#ifndef GAMELOG_H

#define GAMELOG_H

#include "newgrf_config.h"

/** The actions we log. */

enum GamelogActionType : uint8 {

	GLAT_START,        ///< Game created

	GLAT_LOAD,         ///< Game loaded

#include "fontcache.h"

#include "gfx_func.h"

#include "core/smallmap_type.hpp"

#include <map>

#include <stack>

#include <string_view>

/**

 * Text drawing parameters, which can change while drawing a line, but are kept between multiple parts

 * of the same text, e.g. on line breaks.

 */

struct FontState {

#include "group_type.h"

#include "core/pool_type.hpp"

#include "company_type.h"

#include "vehicle_type.h"

#include "engine_type.h"

#include "livery.h"

typedef Pool<Group, GroupID, 16, 64000> GroupPool;

extern GroupPool _group_pool; ///< Pool of groups.

/** Statistics and caches on the vehicles in a group. */

struct GroupStatistics {

/** @file industrytype.h %Industry type specs. */

#ifndef INDUSTRYTYPE_H

#define INDUSTRYTYPE_H

#include <array>

#include "map_type.h"

#include "slope_type.h"

#include "industry_type.h"

#include "landscape_type.h"

#include "cargo_type.h"

#include "newgrf_animation_type.h"

/** @file ini_type.h Types related to reading/writing '*.ini' files. */

#ifndef INI_TYPE_H

#define INI_TYPE_H

#include "fileio_type.h"

/** Types of groups */

enum IniGroupType {

	IGT_VARIABLES = 0, ///< Values of the form "landscape = hilly".

	IGT_LIST      = 1, ///< A list of values, separated by \n and terminated by the next group block.

	IGT_SEQUENCE  = 2, ///< A list of uninterpreted lines, terminated by the next group block.

#include "../company_func.h"

#include "../station_base.h"

#include "../widget_type.h"

#include "../window_gui.h"

#include "linkgraph_base.h"

#include <map>

/**

 * Monthly statistics for a link between two stations.

 * Only the cargo type of the most saturated linkgraph is taken into account.

 */

struct LinkProperties {

/** @file mcf.h Declaration of Multi-Commodity-Flow solver */

#ifndef MCF_H

#define MCF_H

#include "linkgraphjob_base.h"

typedef std::vector<Path *> PathVector;

/**

 * Multi-commodity flow calculating base class.

 */

#ifndef REFRESH_H

#define REFRESH_H

#include "../cargo_type.h"

#include "../vehicle_base.h"

#include <map>

#include <set>

/**

 * Utility to refresh links a consist will visit.

 */

#ifndef DBG_HELPERS_H

#define DBG_HELPERS_H

#include <map>

#include <stack>

#include "../direction_type.h"

#include "../signal_type.h"

#include "../tile_type.h"

#include "../track_type.h"

/** @file endian_buffer.hpp Endian-aware buffer. */

#ifndef ENDIAN_BUFFER_HPP

#define ENDIAN_BUFFER_HPP

#include <string_view>

#include "../core/span_type.hpp"

#include "../core/bitmath_func.hpp"

#include "../core/overflowsafe_type.hpp"

struct StrongTypedefBase;

#ifndef LRUCACHE_HPP

#define LRUCACHE_HPP

#include <utility>

#include <list>

#include <unordered_map>

/**

 * Size limited cache with a least recently used eviction strategy.

 * @tparam Tkey Type of the cache key.

 * @tparam Tdata Type of the cache item. The cache will store a pointer of this type.

 */

#ifndef MUSIC_MIDIFILE_HPP

#define MUSIC_MIDIFILE_HPP

#include "../stdafx.h"

#include "../core/smallvec_type.hpp"

#include "midi.h"

struct MusicSongInfo;

struct MidiFile {

	struct DataBlock {

		uint32 ticktime;        ///< tick number since start of file this block should be triggered at

 * 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 music_gui.cpp GUI for the music playback. */

#include "stdafx.h"

#include "openttd.h"

#include "base_media_base.h"

#include "music/music_driver.hpp"

#include "window_gui.h"

#include "strings_func.h"

#include "window_func.h"

#include "os_abstraction.h"

#include "config.h"

#include "../../company_type.h"

#include "../../string_func.h"

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

class NetworkAddress;

typedef std::vector<NetworkAddress> NetworkAddressList; ///< Type for a list of addresses.

typedef SmallMap<NetworkAddress, SOCKET> SocketList;    ///< Type for a mapping between address and socket.

/**

/**

 * @file config.cpp Configuration of the connection strings for network stuff using environment variables.

 */

#include "../../stdafx.h"

#include "../../string_func.h"

#include "../../safeguards.h"

/**

 * Get the environment variable using std::getenv and when it is an empty string (or nullptr), return a fallback value instead.

#include "http.h"

#include <atomic>

#include <condition_variable>

#include <curl/curl.h>

#include <mutex>

#include <queue>

#include "../../safeguards.h"

#if defined(UNIX)

#define NETWORK_CORE_PACKET_H

#include "os_abstraction.h"

#include "config.h"

#include "core.h"

#include "../../string_type.h"

typedef uint16 PacketSize; ///< Size of the whole packet.

typedef uint8  PacketType; ///< Identifier for the packet

/**

 * Internal entity of a packet. As everything is sent as a packet,

 * @file tcp_content_type.h Basic types related to the content on the content server.

 */

#ifndef NETWORK_CORE_TCP_CONTENT_TYPE_H

#define NETWORK_CORE_TCP_CONTENT_TYPE_H

/** The values in the enum are important; they are used as database 'keys' */

enum ContentType {

	CONTENT_TYPE_BEGIN         = 1, ///< Helper to mark the begin of the types

	CONTENT_TYPE_BASE_GRAPHICS = 1, ///< The content consists of base graphics

	CONTENT_TYPE_NEWGRF        = 2, ///< The content consists of a NewGRF

	CONTENT_TYPE_AI            = 3, ///< The content consists of an AI

#ifndef NEWGRF_CLASS_H

#define NEWGRF_CLASS_H

#include "strings_type.h"

/**

 * Struct containing information relating to NewGRF classes for stations and airports.

 */

template <typename Tspec, typename Tid, Tid Tmax>

struct NewGRFClass {

#include "core/alloc_type.hpp"

#include "core/smallmap_type.hpp"

#include "misc/countedptr.hpp"

#include "fileio_type.h"

#include "textfile_type.h"

#include "newgrf_text.h"

/** GRF config bit flags */

enum GCF_Flags {

	GCF_SYSTEM,     ///< GRF file is an openttd-internal system grf

	GCF_UNSAFE,     ///< GRF file is unsafe for static usage

	GCF_STATIC,     ///< GRF file is used statically (can be used in any MP game)

#include "date_type.h"

#include "timer/timer_game_calendar.h"

#include "newgrf.h"

#include "newgrf_callbacks.h"

#include "newgrf_spritegroup.h"

/**

 * Callback profiler for NewGRF development

 */

struct NewGRFProfiler {

	NewGRFProfiler(const GRFFile *grffile);

#include "string_type.h"

#include "strings_type.h"

#include "core/smallvec_type.hpp"

#include "table/control_codes.h"

#include <utility>

/** This character, the thorn ('þ'), indicates a unicode string to NFO. */

static const WChar NFO_UTF8_IDENTIFIER = 0x00DE;

/** A GRF text with associated language ID. */

struct GRFText {

 * Header of Action 0F "universal holder" structure and functions

 */

#ifndef NEWGRF_TOWNNAME_H

#define NEWGRF_TOWNNAME_H

#include "strings_type.h"

struct NamePart {

	std::string text; ///< If probability bit 7 is clear

	byte id;          ///< If probability bit 7 is set

	byte prob;        ///< The relative probability of the following name to appear in the bottom 7 bits.

#include "../../fileio_func.h"

#include "../../fontdetection.h"

#include "../../string_func.h"

#include "../../strings_func.h"

#include "../../zoom_func.h"

#include "macos.h"

#include "../../table/control_codes.h"

#include "safeguards.h"

#include "../../string_func.h"

#include "../../strings_func.h"

#include "../../table/control_codes.h"

#include "../../fontcache.h"

#include "../../zoom_func.h"

#include "macos.h"

#include <CoreFoundation/CoreFoundation.h>

/* CTRunDelegateCreate is supported since MacOS X 10.5, but was only included in the SDKs starting with the 10.9 SDK. */

#ifndef HAVE_OSX_109_SDK

#ifndef STRING_OSX_H

#define STRING_OSX_H

#include "../../gfx_layout.h"

#include "../../string_base.h"

/** String iterator using CoreText as a backend. */

class OSXStringIterator : public StringIterator {

	/** Break info for a character. */

	struct CharInfo {

		bool word_stop : 1; ///< Code point is suitable as a word break.

#include "../../language.h"

#include "../../strings_func.h"

#include "../../string_func.h"

#include "../../table/control_codes.h"

#include "../../zoom_func.h"

#include "win32.h"

#include <windows.h>

#include <usp10.h>

#include "../../safeguards.h"

#ifndef STRING_UNISCRIBE_H

#define STRING_UNISCRIBE_H

#include "../../gfx_layout.h"

#include "../../string_base.h"

void UniscribeResetScriptCache(FontSize size);

/**

/** @file yapf_costrail.hpp Cost determination for rails. */

#ifndef YAPF_COSTRAIL_HPP

#define YAPF_COSTRAIL_HPP

#include "../../pbs.h"

template <class Types>

class CYapfCostRailT : public CYapfCostBase {

public:

 /** @file random_access_file_type.h Class related to random access to files. */

#ifndef RANDOM_ACCESS_FILE_TYPE_H

#define RANDOM_ACCESS_FILE_TYPE_H

#include "fileio_type.h"

/**

 * A file from which bytes, words and double words are read in (potentially) a random order.

 *

 * This is mostly intended to be used for things that can be read from GRFs when needed, so

 * the graphics but also the sounds. This also ties into the spritecache as it uses these

#include "strings_type.h"

#include "timer/timer_game_calendar.h"

#include "core/enum_type.hpp"

#include "newgrf.h"

#include "economy_func.h"

enum RoadTramType : bool {

	RTT_ROAD,

	RTT_TRAM,

};

#include "saveload.h"

#include "compat/engine_sl_compat.h"

#include "saveload_internal.h"

#include "../engine_base.h"

#include "../string_func.h"