}

	config->AnchorUnchangeableSettings();

	Company *c = Company::Get(company);

	c->ai_info = info;

	assert(_settings_game.difficulty.competitor_speed <= 4);

	if ((AI::frame_counter & ((1 << (4 - _settings_game.difficulty.competitor_speed)) - 1)) != 0) return;

	const Company *c;

	FOR_ALL_COMPANIES(c) {

		if (c->is_ai) {

	if (_networking && !_network_server) return;

	PerformanceMeasurer::SetInactive((PerformanceElement)(PFE_AI0 + company));

	Company *c = Company::Get(company);

	delete c->ai_instance;

	 * for the server owner to unpause the script again. */

	if (_network_dedicated) return;

	Company::Get(company)->ai_instance->Pause();

	cur_company.Restore();

/* static */ void AI::Unpause(CompanyID company)

{

	Company::Get(company)->ai_instance->Unpause();

	cur_company.Restore();

/* static */ bool AI::IsPaused(CompanyID company)

{

	bool paused = Company::Get(company)->ai_instance->IsPaused();

	cur_company.Restore();

	}

	/* Queue the event */

	Company::Get(_current_company)->ai_instance->InsertEvent(event);

	cur_company.Restore();

		Company *c = Company::GetIfValid(company);

		assert(c != nullptr && c->ai_instance != nullptr);

		c->ai_instance->Save();

		cur_company.Restore();

	} else {

		Company *c = Company::GetIfValid(company);

		assert(c != nullptr && c->ai_instance != nullptr);

		c->ai_instance->Load(version);

		cur_company.Restore();

	} else {

		if (_game_mode != GM_NORMAL) {

			return slot > 0 && slot <= GetGameSettings().difficulty.max_no_competitors;

		}

		int max_slot = GetGameSettings().difficulty.max_no_competitors;

		for (CompanyID cid = COMPANY_FIRST; cid < (CompanyID)max_slot && cid < MAX_COMPANIES; cid++) {

	 */

	const Station *st = GetTargetAirportIfValid(v);

	if (st == nullptr) {

		CommandCost ret = DoCommand(v->tile, v->index, 0, DC_EXEC, CMD_SEND_VEHICLE_TO_DEPOT);

		cur_company.Restore();

	/* Send the helicopter to a hangar if needed for replacement */

	if (v->NeedsAutomaticServicing()) {

		DoCommand(v->tile, v->index | DEPOT_SERVICE | DEPOT_LOCATE_HANGAR, 0, DC_EXEC, CMD_SEND_VEHICLE_TO_DEPOT);

		cur_company.Restore();

	}

	/* check if the aircraft needs to be replaced or renewed and send it to a hangar if needed */

	if (v->NeedsAutomaticServicing()) {

		DoCommand(v->tile, v->index | DEPOT_SERVICE, 0, DC_EXEC, CMD_SEND_VEHICLE_TO_DEPOT);

		cur_company.Restore();

	}

	StringID string_id;             ///< Default name (town area) of station

	Town *town;                     ///< The town this station is associated with

	StationFacility facilities;     ///< The facilities that this station has

	uint8 num_specs;                ///< Number of specs in the speclist

		return_dcpi(CMD_ERROR);

	}

	if (exec_as_spectator) cur_company.Change(COMPANY_SPECTATOR);

	bool test_and_exec_can_differ = (cmd_flags & CMD_NO_TEST) != 0;

	TileIndex location_of_HQ;        ///< Northern tile of HQ; #INVALID_TILE when there is none.

	TileIndex last_build_coordinate; ///< Coordinate of the last build thing by this company.

	Year inaugurated_year;           ///< Year of starting the company.

void ClearEnginesHiddenFlagOfCompany(CompanyID cid);

Colours _company_colours[MAX_COMPANIES];  ///< NOSAVE: can be determined from company structs.

CompanyManagerFace _company_manager_face; ///< for company manager face storage in openttd.cfg

uint _next_competitor_start;              ///< the number of ticks before the next AI is started

CommandCost CheckOwnership(Owner owner, TileIndex tile = 0);

CommandCost CheckTileOwnership(TileIndex tile);

extern Colours _company_colours[MAX_COMPANIES];

extern CompanyManagerFace _company_manager_face;

/**

 * Enum for all companies/owners.

 */

	/* All companies below MAX_COMPANIES are playable

	 * companies, above, they are special, computer controlled 'companies' */

	OWNER_BEGIN     = 0x00, ///< First owner

/** Define basic enum properties */

template <> struct EnumPropsT<Owner> : MakeEnumPropsT<Owner, byte, OWNER_BEGIN, OWNER_END, INVALID_OWNER> {};

typedef Owner CompanyID;

typedef uint16 CompanyMask;

		default:

			/* From a user pov 0 is a new company, internally it's different and all

			 * companies are offset by one to ease up on users (eg companies 1-8 not 0-7) */

			break;

	}

	switch (GetTileType(tile)) {

		case MP_RAILWAY:

			if (Company::IsHumanID(GetTileOwner(tile)) && !IsRailDepot(tile)) {

				DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);

				cur_company.Restore();

			break;

		case MP_HOUSE: {

			DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);

			cur_company.Restore();

			break;

	/* We need to set _current_company to old_owner before we try to move

	 * the client. This is needed as it needs to know whether "you" really

	 * are the current local company. */

	/* In all cases, make spectators of clients connected to that company */

	if (_networking) NetworkClientsToSpectators(old_owner);

	if (old_owner == _local_company) {

		/* Single player cheated to AI company.

		 * There are no spectators in single player, so we must pick some other company. */

		assert(!_networking);

		Company *c;

		FOR_ALL_COMPANIES(c) {

			if (c->index != old_owner) {

		}

		/* Sell all the shares that people have on this company */

		c = Company::Get(old_owner);

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

			cur_company2.Change(c->share_owners[i]);

		CompanyCheckBankrupt(c);

	}

	if (!_settings_game.economy.infrastructure_maintenance) {

		Station *st;

{

	const Company *c;

	FOR_ALL_COMPANIES(c) {

		cur_company.Change(c->index);

	if (this->visual_profit == 0 && this->visual_transfer == 0) return;

	SubtractMoneyFromCompany(CommandCost(this->front->GetExpenseType(true), -this->route_profit));

	this->front->profit_this_year += (this->visual_profit + this->visual_transfer) << 8;

	Vehicle *v_start = v->GetFirstEnginePart();

	if (!IterateVehicleParts(v_start, IsEmptyAction())) return;

	CargoTypes refit_mask = v->GetEngine()->info.refit_mask;

	cost.AddCost(CalculateCompanyValue(c) >> 2);

	if (flags & DC_EXEC) {

		while (*b != COMPANY_SPECTATOR) b++; // share owners is guaranteed to contain at least one COMPANY_SPECTATOR

		*b = _current_company;

	cost = -(cost - (cost >> 7));

	if (flags & DC_EXEC) {

		while (*b != _current_company) b++; // share owners is guaranteed to contain company

		*b = COMPANY_SPECTATOR;

		InvalidateWindowData(WC_COMPANY, target_company);

	uint16 duration_phase_3;    ///< Third reliability phase on months, decaying to #reliability_final.

	byte flags;                 ///< Flags of the engine. @see EngineFlags

	CompanyMask preview_asked;  ///< Bit for each company which has already been offered a preview.

	byte preview_wait;          ///< Daily countdown timer for timeout of offering the engine to the #preview_company company.

	CompanyMask company_avail;  ///< Bit for each company whether the engine is available for that company.

	CompanyMask company_hidden; ///< Bit for each company whether the engine is normally hidden in the build gui for that company.

	 * @param c Company to check.

	 * @return \c true iff the engine is hidden in the GUI for the given company.

	 */

	{

		return c < MAX_COMPANIES && HasBit(this->company_hidden, c);

	}

	Game::frame_counter++;

	cur_company.Change(OWNER_DEITY);

	Game::instance->GameLoop();

	cur_company.Restore();

	config->AnchorUnchangeableSettings();

	cur_company.Change(OWNER_DEITY);

	Game::info = info;

/* static */ void Game::Uninitialize(bool keepConfig)

{

	delete Game::instance;

	Game::instance = nullptr;

	}

	/* Queue the event */

	Game::instance->InsertEvent(event);

	cur_company.Restore();

/* static */ void Game::Save()

{

	if (Game::instance != nullptr && (!_networking || _network_server)) {

		Game::instance->Save();

		cur_company.Restore();

	} else {

/* static */ void Game::Load(int version)

{

	if (Game::instance != nullptr && (!_networking || _network_server)) {

		Game::instance->Load(version);

		cur_company.Restore();

	} else {

static void _GenerateWorld()

{

	/* Make sure everything is done via OWNER_NONE. */

	std::unique_lock<std::mutex> lock(_modal_progress_work_mutex, std::defer_lock);

	try {

		case GT_STORY_PAGE: {

			if (!StoryPage::IsValidID(p2)) return CMD_ERROR;

			if (company == INVALID_COMPANY ? story_company != INVALID_COMPANY : story_company != INVALID_COMPANY && story_company != company) return CMD_ERROR;

			break;

		}

/** Struct about goals, current and completed */

struct Goal : GoalPool::PoolItem<&_goal_pool> {

	/**

	 * We need an (empty) constructor so struct isn't zeroed (as C++ standard states)

/** Group data. */

struct Group : GroupPool::PoolItem<&_group_pool> {

	char *name;                 ///< Group Name

	VehicleType vehicle_type;   ///< Vehicle type of the group

	bool replace_protection;    ///< If set to true, the global autoreplace have no effect on the group

	uint16 counter;                                        ///< used for animation and/or production (if available cargo)

	IndustryType type;                  ///< type of industry.

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

	Year last_prod_year;                ///< last year of production

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

	PartOfSubsidyByte part_of_subsidy;  ///< NOSAVE: is this industry a source/destination of a subsidy?

	StationList stations_near;          ///< NOSAVE: List of nearby stations.

	Date construction_date;             ///< Date of the construction of the industry

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

	Date last_cargo_accepted_at[INDUSTRY_NUM_INPUTS]; ///< Last day each cargo type was accepted by this industry

	if (IsTileType(tile, MP_TREES) && GetTreeGrowth(tile) > 2) { ///< 3 and up means all fully grown trees

		/* found a tree */

		_industry_sound_ctr = 1;

		_industry_sound_tile = tile;

				}

				/* Clear the tiles as OWNER_TOWN to not affect town rating, and to not clear protected buildings */

				CommandCost ret = DoCommand(cur_tile, 0, 0, DC_NONE, CMD_LANDSCAPE_CLEAR);

				cur_company.Restore();

	/* _current_company is OWNER_NONE for randomly generated industries and in editor, or the company who funded or prospected the industry.

	 * Perform terraforming as OWNER_TOWN to disable autoslope and town ratings. */

	TILE_AREA_LOOP(tile_walk, ta) {

		uint curh = TileHeight(tile_walk);

	if (deity_prospect || (_game_mode != GM_EDITOR && _current_company != OWNER_DEITY && _settings_game.construction.raw_industry_construction == 2 && indspec->IsRawIndustry())) {

		if (flags & DC_EXEC) {

			/* Prospected industries are build as OWNER_TOWN to not e.g. be build on owned land of the founder */

			/* Prospecting has a chance to fail, however we cannot guarantee that something can

			 * be built on the map, so the chance gets lower when the map is fuller, but there

			 * is nothing we can really do about that. */

 */

static void PlaceInitialIndustry(IndustryType type, bool try_hard)

{

	IncreaseGeneratingWorldProgress(GWP_INDUSTRY);

	PlaceIndustry(type, IACT_MAPGENERATION, try_hard);

		return;  // Nothing to do? get out

	}

	/* perform the required industry changes for the day */

void IndustryMonthlyLoop()

{

	_industry_builder.MonthlyLoop();

				return;

			}

			_generating_world = true;

			_ignore_restrictions = true;

	if (flags & DC_EXEC) {

		/* Change company bank balance of company. */

		SubtractMoneyFromCompany(CommandCost(expenses_type, -delta));

		cur_company.Restore();

	}

	if (flags & DC_EXEC) {

		/* Add money to company */

		SubtractMoneyFromCompany(CommandCost(EXPENSES_OTHER, -amount.GetCost()));

		cur_company.Restore();

	}

 */

void NetworkClientsToSpectators(CompanyID cid)

{

	/* If our company is changing owner, go to spectators */

	if (cid == _local_company) SetLocalCompany(COMPANY_SPECTATOR);

		/* All these actions has to be done from OWNER_NONE

		 *  for multiplayer compatibility */

		BasePersistentStorageArray::SwitchMode(PSM_ENTER_GAMELOOP);

		AnimateAnimatedTiles();

		TrackBits to_remove = lower_track & rail_bits;

		if (to_remove != 0) {

			flooded = DoCommand(t, 0, FIND_FIRST_BIT(to_remove), DC_EXEC, CMD_REMOVE_SINGLE_RAIL).Succeeded();

			cur_company.Restore();

			if (!flooded) return flooded; // not yet floodable

static bool CanBuildTramTrackOnTile(CompanyID c, TileIndex t, RoadBits r)

{

	/* The 'current' company is not necessarily the owner of the vehicle. */

	CommandCost ret = DoCommand(t, ROADTYPE_TRAM << 4 | r, 0, DC_NO_WATER, CMD_BUILD_ROAD);

			if (IsBuoyTile(t) || IsDriveThroughStopTile(t) || IsTileType(t, MP_WATER)) {

				Owner o = GetTileOwner(t);

				if (o < MAX_COMPANIES && !Company::IsValidID(o)) {

					ChangeTileOwner(t, o, INVALID_OWNER);

					cur_company.Restore();

				}

	uint8 localidx;

	uint32 grfid;

	const StationSpec *spec;

	size_t new_index;

};

/* static */ int32 ScriptCargoMonitor::GetTownDeliveryAmount(ScriptCompany::CompanyID company, CargoID cargo, TownID town_id, bool keep_monitoring)

{

	CompanyID cid = static_cast<CompanyID>(company);

	if (!ScriptCargo::IsValidCargo(cargo)) return -1;

	if (!::Town::IsValidID(town_id)) return -1;

/* static */ int32 ScriptCargoMonitor::GetIndustryDeliveryAmount(ScriptCompany::CompanyID company, CargoID cargo, IndustryID industry_id, bool keep_monitoring)

{

	CompanyID cid = static_cast<CompanyID>(company);

	if (!ScriptCargo::IsValidCargo(cargo)) return -1;

	if (!::Industry::IsValidID(industry_id)) return -1;

/* static */ int32 ScriptCargoMonitor::GetTownPickupAmount(ScriptCompany::CompanyID company, CargoID cargo, TownID town_id, bool keep_monitoring)

{

	CompanyID cid = static_cast<CompanyID>(company);

	if (!ScriptCargo::IsValidCargo(cargo)) return -1;

	if (!::Town::IsValidID(town_id)) return -1;

/* static */ int32 ScriptCargoMonitor::GetIndustryPickupAmount(ScriptCompany::CompanyID company, CargoID cargo, IndustryID industry_id, bool keep_monitoring)

{

	CompanyID cid = static_cast<CompanyID>(company);

	if (!ScriptCargo::IsValidCargo(cargo)) return -1;

	if (!::Industry::IsValidID(industry_id)) return -1;

	int32        x;

	int32        y;

	int32        z;

	Sign(Owner owner = INVALID_OWNER);

	~Sign();

struct StoryPage : StoryPagePool::PoolItem<&_story_page_pool> {

	uint32 sort_value;   ///< A number that increases for every created story page. Used for sorting. The id of a story page is the pool index.

	Date date;           ///< Date when the page was created.

	char *title;         ///< Title of story page

struct Subsidy : SubsidyPool::PoolItem<&_subsidy_pool> {

	CargoID cargo_type;      ///< Cargo type involved in this subsidy, CT_INVALID for invalid subsidy

	byte remaining;          ///< Remaining months when this subsidy is valid

	SourceTypeByte src_type; ///< Source of subsidised path (ST_INDUSTRY or ST_TOWN)

	SourceTypeByte dst_type; ///< Destination of subsidised path (ST_INDUSTRY or ST_TOWN)

	SourceID src;            ///< Index of source. Either TownID or IndustryID

	/* Company ratings. */

	CompanyMask have_ratings;      ///< which companies have a rating

	uint8 unwanted[MAX_COMPANIES]; ///< how many months companies aren't wanted by towns (bribe)

	uint8 exclusive_counter;       ///< months till the exclusivity expires

	int16 ratings[MAX_COMPANIES];  ///< ratings of each company for this town

		}

	}

	if ((hs->building_flags & BUILDING_HAS_1_TILE) &&

			HasBit(t->flags, TOWN_IS_GROWING) &&

	};

	/* Current "company" is a town */

	TileIndex tile = t->xy; // The tile we are working with ATM

		 * placement is so bad it couldn't grow at all */

		if (t->cache.population > 0) return t;

		CommandCost rc = DoCommand(t->xy, t->index, 0, DC_EXEC, CMD_DELETE_TOWN);

		cur_company.Restore();

		assert(rc.Succeeded());

 */

static bool TryClearTile(TileIndex tile)

{