void AIInstance::LoadDummyScript()

{

	ScriptAllocatorScope alloc_scope(this->engine);

	Script_CreateDummy(this->engine->GetVM(), STR_ERROR_AI_NO_AI_FOUND, "AI");

}

	/* Create the dummy AI */

	this->main_script = "%_dummy";

	Script_CreateDummyInfo(this->engine->GetVM(), "AI", "ai");

}

void GetRotorImage(const Aircraft *v, EngineImageType image_type, VehicleSpriteSeq *result);

Station *GetTargetAirportIfValid(const Aircraft *v);

#endif /* AIRCRAFT_H */

#include "ini_type.h"

#include "string_func.h"

/**

 * Try to read a single piece of metadata and return false if it doesn't exist.

 * @param name the name of the item to fetch.

template <class Tbase_set>

/* static */ bool BaseMedia<Tbase_set>::SetSet(const std::string &name)

{

	if (name.empty()) {

		if (!BaseMedia<Tbase_set>::DetermineBestSet()) return false;

		CheckExternalFiles();

#include "safeguards.h"

void ClearEnginesHiddenFlagOfCompany(CompanyID cid);

CompanyID _local_company;   ///< Company controlled by the human player at this client. Can also be #COMPANY_SPECTATOR.

CompanyID _current_company; ///< Company currently doing an action.

			if (v->owner == _current_company) v->InvalidateNewGRFCache();

		}

		UpdateObjectColours(c);

	}

	return CommandCost();

 *  default console commands

 ******************************/

extern bool CloseConsoleLogIfActive();

DEF_CONSOLE_CMD(ConScript)

{

		return true;

	}

	const std::vector<GRFFile *> &files = GetAllGRFFiles();

	/* "list" sub-command */

DEF_CONSOLE_CMD(ConFramerate)

{

	if (argc == 0) {

		IConsolePrint(CC_HELP, "Show frame rate and game speed information.");

		return true;

DEF_CONSOLE_CMD(ConFramerateWindow)

{

	if (argc == 0) {

		IConsolePrint(CC_HELP, "Open the frame rate window.");

		return true;

#include "mem_func.hpp"

#include "pool_type.hpp"

/**

 * Helper for defining the method's signature.

 * @param type The return type of the method.

 */

DEFINE_POOL_METHOD(void *)::GetNew(size_t size, size_t index)

{

	if (index >= Tmax_size) {

		SlErrorCorruptFmt("%s index " PRINTF_SIZE " out of range (" PRINTF_SIZE ")", this->name, index, Tmax_size);

	}

#include "slope_func.h"

void ShowDepotWindow(TileIndex tile, VehicleType type);

void DeleteDepotHighlightOfVehicle(const Vehicle *v);

#ifndef ERROR_H

#define ERROR_H

#include "strings_type.h"

#include "company_type.h"

#include "core/geometry_type.hpp"

	void CopyOutDParams();

};

void ScheduleErrorMessage(const ErrorMessageData &data);

void ShowErrorMessage(StringID summary_msg, StringID detailed_msg, WarningLevel wl, int x = 0, int y = 0, const GRFFile *textref_stack_grffile = nullptr, uint textref_stack_size = 0, const uint32 *textref_stack = nullptr);

	this->SetDParamStr(n, str.c_str());

}

/** The actual queue with errors. */

/** Whether the window system is initialized or not. */

bool _window_system_initialized = false;

typedef std::map<std::string, std::string> TarLinkList;

static TarLinkList _tar_linklist[NUM_SUBDIRS]; ///< List of directory links

/**

 * Checks whether the given search path is a valid search path

 * @param sp the search path to check

 */

static uint ScanPath(FileScanner *fs, const char *extension, const char *path, size_t basepath_length, bool recursive)

{

	uint num = 0;

	struct stat sb;

	struct dirent *dirent;

FiosType FiosGetSavegameListCallback(SaveLoadOperation fop, const std::string &file, const char *ext, char *title, const char *last);

/**

 * A savegame name automatically numbered.

 */

	if (_save_config) SaveToConfig();

}

/**

 * (Re)initialize the font cache related things, i.e. load the non-sprite fonts.

 * @param monospace Whether to initialise the monospace or regular fonts.

		if (fc->HasParent()) delete fc;

#ifdef WITH_FREETYPE

		LoadFreeTypeFont(fs);

#elif defined(_WIN32)

		LoadWin32Font(fs);

#elif defined(WITH_COCOA)

		LoadCoreTextFont(fs);

#endif

	}

	}

#ifdef WITH_FREETYPE

	UninitFreeType();

#endif /* WITH_FREETYPE */

}

};

void ShowFramerateWindow();

#endif /* FRAMERATE_TYPE_H */

	char text[512];             ///< Cargo suffix text.

};

static void ShowIndustryCargoesWindow(IndustryType id);

/**

		if (Town::GetNumItems() == 0) {

			ShowErrorMessage(STR_ERROR_CAN_T_GENERATE_INDUSTRIES, STR_ERROR_MUST_FOUND_TOWN_FIRST, WL_INFO);

		} else {

			Backup<bool> old_generating_world(_generating_world, true, FILE_LINE);

			BasePersistentStorageArray::SwitchMode(PSM_ENTER_GAMELOOP);

			GenerateIndustries();

			break;

		case CONTENT_TYPE_SCENARIO:

		case CONTENT_TYPE_HEIGHTMAP:

			tmp = FindScenario(this, true);

			break;

	}

{

	/* Clients drop back to the main menu */

	if (!_network_server && _networking) {

		ClientNetworkEmergencySave();

		_switch_mode = SM_MENU;

		_networking = false;

/** The amount of clients connected */

byte _network_clients_connected = 0;

/**

 * Return whether there is any client connected or trying to connect at all.

 * @return whether we have any client activity

	NetworkExecuteLocalCommandQueue();

	StateGameLoop();

	/* Check if we are in sync! */

#include "../querystring_gui.h"

#include "../core/geometry_func.hpp"

#include "../textfile_gui.h"

#include "network_content_gui.h"

				case CONTENT_TYPE_SCENARIO:

				case CONTENT_TYPE_HEIGHTMAP:

					ScanScenarios();

					InvalidateWindowData(WC_SAVELOAD, 0, 0);

					break;

	/** Search external websites for content */

	void OpenExternalSearch()

	{

		char url[1024];

		const char *last = lastof(url);

			case WID_NCL_OPEN_URL:

				if (this->selected != nullptr) {

					OpenBrowser(this->selected->url.c_str());

				}

				break;

uint NetworkServerKickOrBanIP(const std::string &ip, bool ban, const std::string &reason);

void NetworkInitChatMessage();

void CDECL NetworkAddChatMessage(TextColour colour, uint duration, const std::string &message);

void NetworkUndrawChatMessage();

void NetworkChatMessageLoop();

NetworkAddress ParseConnectionString(const std::string &connection_string, uint16 default_port);

std::string NormalizeConnectionString(const std::string &connection_string, uint16 default_port);

#endif /* NETWORK_INTERNAL_H */

#include "safeguards.h"

AirportTileSpec AirportTileSpec::tiles[NUM_AIRPORTTILES];

{

	assert(this->st != nullptr);

	switch (variable) {

		/* Terrain type */

		case 0x41: return GetTerrainType(this->tile);

	friend void AirportTileOverrideManager::SetEntitySpec(const AirportTileSpec *airpts);

};

void AnimateAirportTile(TileIndex tile);

void AirportTileAnimationTrigger(Station *st, TileIndex tile, AirpAnimationTrigger trigger, CargoID cargo_type = CT_INVALID);

void AirportAnimationTrigger(Station *st, AirpAnimationTrigger trigger, CargoID cargo_type = CT_INVALID);

EngineID GetNewEngineID(const GRFFile *file, VehicleType type, uint16 internal_id);

#endif /* NEWGRF_ENGINE_H */

void AddGenericCallback(uint8 feature, const GRFFile *file, const SpriteGroup *group);

uint16 GetAiPurchaseCallbackResult(uint8 feature, CargoID cargo_type, uint8 default_selection, IndustryType src_industry, IndustryType dst_industry, uint8 distance, AIConstructionEvent event, uint8 count, uint8 station_size, const GRFFile **file);

/** Play an ambient sound effect for an empty tile. */

static inline void AmbientSoundEffect(TileIndex tile)

	/* Only run callback if enabled. */

	if (!HasGrfMiscBit(GMB_AMBIENT_SOUND_CALLBACK)) return;

	AmbientSoundEffectCallback(tile);

}

			case WID_NS_OPEN_URL: {

				const GRFConfig *c = (this->avail_sel == nullptr) ? this->active_sel : this->avail_sel;

				OpenBrowser(c->GetURL());

				break;

			}

void CallWindowGameTickEvent();

bool HandleBootstrap();

extern Company *DoStartupNewCompany(bool is_ai, CompanyID company = INVALID_COMPANY);

extern void ShowOSErrorBox(const char *buf, bool system);

extern std::string _config_file;

	/* Make sure we only accept urls that are sure to open a browser. */

	if (strstr(url, "http://") != url && strstr(url, "https://") != url) return;

	OSOpenBrowser(url);

}

		old_town_caches.push_back(t->cache);

	}

	RebuildTownCaches();

	RebuildSubsidisedSourceAndDestinationCache();

	std::vector<CompanyInfrastructure> old_infrastructure;

	for (const Company *c : Company::Iterate()) old_infrastructure.push_back(c->infrastructure);

	AfterLoadCompanyStats();

	i = 0;

	}

	for (Vehicle *v : Vehicle::Iterate()) {

		if (v != v->First() || v->vehstatus & VS_CRASHED || !v->IsPrimaryVehicle()) continue;

		uint length = 0;

void AskExitToGameMenu();

int openttd_main(int argc, char *argv[]);

void HandleExitGameRequest();

void SwitchToMode(SwitchMode new_mode);

bool RequestNewGRFScan(struct NewGRFScanCallback *callback = nullptr);

#endif /* OPENTTD_H */

						Aircraft *a = Aircraft::From(v);

						if (a->state == FLYING && a->targetairport != closestDepot.destination) {

							/* The aircraft is now heading for a different hangar than the next in the orders */

							AircraftNextAirportPos_and_Order(a);

						}

					}

	if (order == nullptr || (v->type == VEH_AIRCRAFT && !CheckForValidOrders(v))) {

		if (v->type == VEH_AIRCRAFT) {

			/* Aircraft do something vastly different here, so handle separately */

			HandleMissingAircraftOrders(Aircraft::From(v));

			return false;

		}

#include "vehicle_type.h"

bool RoadVehLeaveDepot(RoadVehicle *v, bool first);

CommandCost CmdBuildRoadVehicle(DoCommandFlag flags, TileIndex tile, const Engine *e, Vehicle **v);

				RoadVehicle *u = v;

				RoadVehicle *prev = nullptr;

				for (uint sf : skip_frames) {

					if (sf >= cur_skip) IndividualRoadVehicleController(u, prev);

					prev = u;

	SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, msg);

}

/**

 * Issue an SlErrorCorrupt with a format string.

 * @param format format string

void SlObject(void *object, const SaveLoadTable &slt);

void NORETURN SlError(StringID string, const char *extra_msg = nullptr);

void NORETURN SlErrorCorrupt(const char *msg);

bool SaveloadCrashWithMissingNewGRFs();

/* static */ int ScriptAirport::GetNoiseLevelIncrease(TileIndex tile, AirportType type)

{

	if (!::IsValidTile(tile)) return -1;

	if (!IsAirportInformationAvailable(type)) return -1;

/* static */ TownID ScriptAirport::GetNearestTown(TileIndex tile, AirportType type)

{

	if (!::IsValidTile(tile)) return INVALID_TOWN;

	if (!IsAirportInformationAvailable(type)) return INVALID_TOWN;

	class ScriptScanner *scanner; ///< ScriptScanner object that was used to scan this script info.

};

#endif /* SCRIPT_INFO_HPP */

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

#include "../script/squirrel_class.hpp"

#include "script_fatalerror.hpp"

#include "script_storage.hpp"

void ScriptInstance::RegisterAPI()

{

	squirrel_register_std(this->engine);

}

std::string _private_file; ///< Private configuration file of OpenTTD.

std::string _secrets_file; ///< Secrets configuration file of OpenTTD.

static ErrorList _settings_error_list; ///< Errors while loading minimal settings.

/**

		DebugReconsiderSendRemoteMessages();

		/* Display scheduled errors */

		ScheduleErrorMessage(_settings_error_list);

		if (FindWindowById(WC_ERRMSG, 0) == nullptr) ShowFirstError();

	}

#include "ship.h"

#include "smallmap_gui.h"

#include "roadveh.h"

#include "vehicle_func.h"

#include "void_map.h"

#include "table/strings.h"

static void ZoomMinMaxChanged(int32 new_value)

{

	ConstrainAllViewportsZoom();

	GfxClearSpriteCache();

	if (_settings_client.gui.zoom_min > _gui_zoom) {

 */

static bool CheckRoadSide(int32 &new_value)

{

	return _game_mode == GM_MENU || !RoadVehiclesAreBuilt();

}

enum StationClassID : byte;

CommandCost CmdBuildAirport(DoCommandFlag flags, TileIndex tile, byte airport_type, byte layout, StationID station_to_join, bool allow_adjacent);

CommandCost CmdBuildDock(DoCommandFlag flags, TileIndex tile, StationID station_to_join, bool adjacent);

CommandCost CmdBuildRailStation(DoCommandFlag flags, TileIndex tile_org, RailType rt, Axis axis, byte numtracks, byte plat_len, StationClassID spec_class, byte spec_index, StationID station_to_join, bool adjacent);

	return IsRoadStopTile(t) && GetStationGfx(t) >= GFX_TRUCK_BUS_DRIVETHROUGH_OFFSET;

}

/**

 * Get the station graphics of this airport tile

 * @param t the tile to query

static inline StationGfx GetAirportGfx(TileIndex t)

{

	assert(IsAirport(t));

	return GetTranslatedAirportTileID(GetStationGfx(t));

}

	DeleteVehicleOrders(this);

	DeleteDepotHighlightOfVehicle(this);

	StopGlobalFollowVehicle(this);

	ReleaseDisastersTargetingVehicle(this->index);

			Aircraft *a = Aircraft::From(this);

			if (a->state == FLYING && a->targetairport != closestDepot.destination) {

				/* The aircraft is now heading for a different hangar than the next in the orders */

				AircraftNextAirportPos_and_Order(a);

			}

		}

void StartStopVehicle(const Vehicle *v, bool texteffect);

Vehicle *CheckClickOnVehicle(const struct Viewport *vp, int x, int y);

void DrawVehicleImage(const Vehicle *v, const Rect &r, VehicleID selection, EngineImageType image_type, int skip);

void SetMouseCursorVehicle(const Vehicle *v, EngineImageType image_type);

bool DoZoomInOutWindow(ZoomStateChange how, Window *w);

void ZoomInOrOutToCursorWindow(bool in, Window * w);

Point GetTileZoomCenterWindow(bool in, Window * w);

void FixTitleGameZoom(int zoom_adjust = 0);

void HandleZoomMessage(Window *w, const Viewport *vp, byte widget_zoom_in, byte widget_zoom_out);

#include "blitter/factory.hpp"

#include "zoom_func.h"

#include "vehicle_base.h"

#include "window_func.h"

#include "tilehighlight_func.h"

#include "network/network.h"

	PerformanceMeasurer framerate(PFE_DRAWING);

	PerformanceAccumulator::Reset(PFE_DRAWWORLD);

	ProcessPendingPerformanceMeasurements();

	CallWindowRealtimeTickEvent(delta_ms);

	NWidgetLeaf::InvalidateDimensionCache(); // Reset cached sizes of several widgets.

	NWidgetScrollbar::InvalidateDimensionCache();

	InitDepotWindowBlockSizes();

	/* When _gui_zoom has changed, we need to resize toolbar and statusbar first,

		ReInitWindow(w, zoom_changed);

	}

	NetworkReInitChatBoxSize();

	/* Make sure essential parts of all windows are visible */