if (ind->index == source) continue;

		uint cargo_index;

		for (cargo_index = 0; cargo_index < lengthof(ind->accepts_cargo); cargo_index++) {

			if (cargo_type == ind->accepts_cargo[cargo_index]) break;

		}

		/* Check if matching cargo has been found */

		if (cargo_index >= lengthof(ind->accepts_cargo)) continue;

		/* Check if industry temporarily refuses acceptance */

		if (IndustryTemporarilyRefusesCargo(ind, cargo_type)) continue;

		/* Insert the industry into _cargo_delivery_destinations, if not yet contained */

		include(_cargo_delivery_destinations, ind);

		uint amount = min(num_pieces, 0xFFFFU - ind->incoming_cargo_waiting[cargo_index]);

		ind->incoming_cargo_waiting[cargo_index] += amount;

		ind->last_cargo_accepted_at[cargo_index] = _date;

		num_pieces -= amount;

		accepted += amount;

		/* Update the cargo monitor. */

		AddCargoDelivery(cargo_type, company, amount, ST_INDUSTRY, source, st, ind->index);

	}

void SetPriceBaseMultiplier(Price price, int factor);

extern const ScoreInfo _score_info[];

extern int64 _score_part[MAX_COMPANIES][SCORE_END];

extern Economy _economy;

/* Prices and also the fractional part. */

extern Prices _price;

int UpdateCompanyRatingAndValue(Company *c, bool update);

void StartupIndustryDailyChanges(bool init_counter);

Money GetTransportedGoodsIncome(uint num_pieces, uint dist, byte transit_days, CargoID cargo_type);

void PrepareUnload(Vehicle *front_v);

void LoadUnloadStation(Station *st);

Money GetPrice(Price index, uint cost_factor, const struct GRFFile *grf_file, int shift = 0);

void InitializeEconomy();

void RecomputePrices();

bool AddInflation(bool check_year = true);

/**

 * Is the economy in recession?

	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

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

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

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

	Owner founder;                 ///< Founder of the industry

	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

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

	uint16 random;                 ///< Random value used for randomisation of all kinds of things

	PersistentStorage *psa;        ///< Persistent storage for NewGRF industries.

	Industry(TileIndex tile = INVALID_TILE) : location(tile, 0, 0) {}

	~Industry();

	void RecomputeProductionMultipliers();

	/**

	 * Check if a given tile belongs to this industry.

/** @file industry_cmd.cpp Handling of industry tiles. */

#include "stdafx.h"

#include "clear_map.h"

#include "industry.h"

#include "station_base.h"

#include "landscape.h"

#include "viewport_func.h"

#include "command_func.h"

#include "town.h"

#include "news_func.h"

#include "cheat_type.h"

#include "genworld.h"

#include "tree_map.h"

#include "newgrf_cargo.h"

#include "newgrf_debug.h"

#include "newgrf_industrytiles.h"

#include "autoslope.h"

#include "water.h"

#include "strings_func.h"

#include "window_func.h"

#include "date_func.h"

#include "vehicle_func.h"

#include "sound_func.h"

	bool moved_cargo = false;

	for (uint j = 0; j < lengthof(i->produced_cargo_waiting); j++) {

		uint cw = min(i->produced_cargo_waiting[j], 255);

		if (cw > indspec->minimal_cargo && i->produced_cargo[j] != CT_INVALID) {

			i->produced_cargo_waiting[j] -= cw;

			/* fluctuating economy? */

			if (EconomyIsInRecession()) cw = (cw + 1) / 2;

			i->this_month_production[j] += cw;

			i->this_month_transported[j] += am;

			moved_cargo |= (am != 0);

		}

	}

	return moved_cargo;

}

static void AnimateTile_Industry(TileIndex tile)

{

}

static TrackStatus GetTileTrackStatus_Industry(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)

{

	return 0;

}

static void ChangeTileOwner_Industry(TileIndex tile, Owner old_owner, Owner new_owner)

{

	/* If the founder merges, the industry was created by the merged company */

	Industry *i = Industry::GetByTile(tile);

	if (i->founder == old_owner) i->founder = (new_owner == INVALID_OWNER) ? OWNER_NONE : new_owner;

}

/**

 * Check whether the tile is a forest.

 * @param tile the tile to investigate.

 * @return true if and only if the tile is a forest

 */

bool IsTileForestIndustry(TileIndex tile)

{

	/* Check for industry tile */

	if (!IsTileType(tile, MP_INDUSTRY)) return false;

	i->founder = founder;

	i->ctlflags = INDCTL_NONE;

	i->construction_date = _date;

	i->construction_type = (_game_mode == GM_EDITOR) ? ICT_SCENARIO_EDITOR :

			(_generating_world ? ICT_MAP_GENERATION : ICT_NORMAL_GAMEPLAY);

	/* Adding 1 here makes it conform to specs of var44 of varaction2 for industries

	 * 0 = created prior of newindustries

	 * else, chosen layout + 1 */

	i->selected_layout = (byte)(layout_index + 1);

	i->prod_level = PRODLEVEL_DEFAULT;

	/* Call callbacks after the regular fields got initialised. */

	if (HasBit(indspec->callback_mask, CBM_IND_PROD_CHANGE_BUILD)) {

		uint16 res = GetIndustryCallback(CBID_INDUSTRY_PROD_CHANGE_BUILD, 0, Random(), i, type, INVALID_TILE);

		if (res != CALLBACK_FAILED) {

			if (res < PRODLEVEL_MINIMUM || res > PRODLEVEL_MAXIMUM) {

				ErrorUnknownCallbackResult(indspec->grf_prop.grffile->grfid, CBID_INDUSTRY_PROD_CHANGE_BUILD, res);

			} else {

				i->prod_level = res;

				i->RecomputeProductionMultipliers();

	return CommandCost(EXPENSES_OTHER, indspec->GetConstructionCost());

}

/**

 * Change industry properties

 * @param tile Unused.

 * @param flags Type of operation.

 * @param p1 IndustryID

 * @param p2 various bitstuffed elements

 * - p2 = (bit 0 - 7) - action to perform:

 *                      0 = set control flags

 * - p2 = (bit 8 - 15) - IndustryControlFlags

 *                       (only used with set control flags)

 * @param text unused

 * @return Empty cost or an error.

 */

CommandCost CmdIndustryCtrl(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)

{

	if (_current_company != OWNER_DEITY) return CMD_ERROR;

	Industry *ind = Industry::GetIfValid(p1);

	if (ind == nullptr) return CMD_ERROR;

	uint8 action = GB(p2, 0, 8);

	switch (action) {

		case 0: {

			IndustryControlFlags ctlflags = (IndustryControlFlags)GB(p2, 8, 8) & INDCTL_MASK;

			if (flags & DC_EXEC) ind->ctlflags = ctlflags;

			break;

		}

		default:

			NOT_REACHED();

	}

	return CommandCost();

}

/**

 * Create a new industry of random layout.

 * @param tile The location to build the industry.

 * @param type The industry type to build.

 * @param creation_type The circumstances the industry is created under.

		for (Station *st : Station::Iterate()) {

			if (st->ship_station.tile != INVALID_TILE) UpdateStationDockingTiles(st);

		}

		/* Reset roadtype/streetcartype info for non-road bridges. */

		for (TileIndex t = 0; t < map_size; t++) {

			if (IsTileType(t, MP_TUNNELBRIDGE) && GetTunnelBridgeTransportType(t) != TRANSPORT_ROAD) {

				SetRoadTypes(t, INVALID_ROADTYPE, INVALID_ROADTYPE);

			}

		}

	}

	/* Compute station catchment areas. This is needed here in case UpdateStationAcceptance is called below. */

	Station::RecomputeCatchmentForAll();

	/* Station acceptance is some kind of cache */

	if (IsSavegameVersionBefore(SLV_127)) {

		for (Station *st : Station::Iterate()) UpdateStationAcceptance(st, false);

	}

	/* Road stops is 'only' updating some caches */

	AfterLoadRoadStops();

	AfterLoadLabelMaps();

	AfterLoadCompanyStats();

	    SLE_VAR(Industry, random_colour,              SLE_UINT8),

	SLE_CONDVAR(Industry, last_prod_year,             SLE_FILE_U8 | SLE_VAR_I32,  SL_MIN_VERSION, SLV_31),

	SLE_CONDVAR(Industry, last_prod_year,             SLE_INT32,                 SLV_31, SL_MAX_VERSION),

	    SLE_VAR(Industry, was_cargo_delivered,        SLE_UINT8),

	SLE_CONDVAR(Industry, ctlflags,                   SLE_UINT8,                 SLV_GS_INDUSTRY_CONTROL, SL_MAX_VERSION),

	SLE_CONDVAR(Industry, founder,                    SLE_UINT8,                 SLV_70, SL_MAX_VERSION),

	SLE_CONDVAR(Industry, construction_date,          SLE_INT32,                 SLV_70, SL_MAX_VERSION),

	SLE_CONDVAR(Industry, construction_type,          SLE_UINT8,                 SLV_70, SL_MAX_VERSION),

	SLE_CONDVAR(Industry, last_cargo_accepted_at[0],  SLE_INT32,                 SLV_70, SLV_EXTEND_INDUSTRY_CARGO_SLOTS),

	SLE_CONDARR(Industry, last_cargo_accepted_at,     SLE_INT32, 16,            SLV_EXTEND_INDUSTRY_CARGO_SLOTS, SL_MAX_VERSION),

	SLE_CONDVAR(Industry, selected_layout,            SLE_UINT8,                 SLV_73, SL_MAX_VERSION),

	SLEG_CONDARR(_old_ind_persistent_storage.storage, SLE_UINT32, 16,            SLV_76, SLV_161),

	SLE_CONDREF(Industry, psa,                        REF_STORAGE,              SLV_161, SL_MAX_VERSION),

	SLE_CONDNULL(1, SLV_82, SLV_197), // random_triggers

	SLE_CONDVAR(Industry, random,                     SLE_UINT16,                SLV_82, SL_MAX_VERSION),

	SLE_CONDNULL(32, SLV_2, SLV_144), // old reserved space

	SLE_END()

};

	 * savegame will simply fail to load because they all contain chunks we

	 * cannot digest. But, this gives for ugly errors. As we have plenty of

	 * versions anyway, we simply skip the versions we know belong to

	 * patchpacks. This way we can present the user with a clean error

	 * indicate he is loading a savegame from a patchpack.

	 * For future patchpack creators: please follow a system like JGRPP, where

	 * the version is masked with 0x8000, and the true version is stored in

	 * its own chunk with feature toggles.

	 */

	SLV_START_PATCHPACKS,                   ///< 220  First known patchpack to use a version just above ours.

	SLV_END_PATCHPACKS = 286,               ///< 286  Last known patchpack to use a version just above ours.

	SL_MAX_VERSION,                         ///< Highest possible saveload version

};

/** Save or load result codes. */

enum SaveOrLoadResult {

	SL_OK     = 0, ///< completed successfully

	SL_ERROR  = 1, ///< error that was caught before internal structures were modified

	SL_REINIT = 2, ///< error that was caught in the middle of updating game state, need to clear it. (can only happen during load)

};

/** Deals with the type of the savegame, independent of extension */

 * in GetAPIVersion() in info.nut.

 *

 * \b 1.11.0

 *

 * This version is not yet released. The following changes are not set in stone yet.

 *

 * API additions:

 * \li GSEventStoryPageButtonClick

 * \li GSEventStoryPageTileSelect

 * \li GSEventStoryPageVehicleSelect

 * \li GSIndustry::GetCargoLastAcceptedDate

 * \li GSIndustry::GetControlFlags

 * \li GSIndustry::GetLastProductionYear

 * \li GSIndustry::SetControlFlags

 * \li GSStoryPage::MakePushButtonReference

 * \li GSStoryPage::MakeTileButtonReference

 * \li GSStoryPage::MakeVehicleButtonReference

 * \li GSPriorityQueue

 *

 * \b 1.10.0

 *

 * API additions:

 * \li GSVehicle::BuildVehicleWithRefit

 * \li GSVehicle::GetBuildWithRefitCapacity

 * \li GSRoad::GetName

 * \li GSRoad::RoadVehCanRunOnRoad

/*

 * This file is part of OpenTTD.

 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.

 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 * 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 script_industry.cpp Implementation of ScriptIndustry. */

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

#include "script_industry.hpp"

#include "script_cargo.hpp"

#include "script_map.hpp"

#include "../../industry.h"

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

#include "../../station_base.h"

#include "../../newgrf_industries.h"

#include "table/strings.h"

#include <numeric>

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

/* static */ int32 ScriptIndustry::GetIndustryCount()

{

	return (int32)::Industry::GetNumItems();

	Industry *i = Industry::GetIfValid(industry_id);

	if (i == nullptr) return 0;

	return i->ctlflags;

}

bool ScriptIndustry::SetControlFlags(IndustryID industry_id, uint32 control_flags)

{

	if (ScriptObject::GetCompany() != OWNER_DEITY) return false;

	if (!IsValidIndustry(industry_id)) return false;

	return ScriptObject::DoCommand(0, industry_id, 0 | ((control_flags & ::INDCTL_MASK) << 8), CMD_INDUSTRY_CTRL);

}

/*

 * This file is part of OpenTTD.

 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.

 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 * 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 script_industry.hpp Everything to query and build industries. */

#ifndef SCRIPT_INDUSTRY_HPP

#define SCRIPT_INDUSTRY_HPP

#include "script_object.hpp"

#include "../../industry.h"

/**

 * Class that handles all industry related functions.

 * @api ai game

 */

class ScriptIndustry : public ScriptObject {

public:

	/** Ways for an industry to accept a cargo. */

	enum CargoAcceptState {

		CAS_NOT_ACCEPTED, ///< The CargoID is not accepted by this industry.

		CAS_ACCEPTED,     ///< The industry currently accepts this CargoID.

	static uint32 GetControlFlags(IndustryID industry_id);

	/**

	 * Change the control flags for an industry.

	 * @param industry_id The index of the industry.

	 * @param control_flags New flags as a combination of IndustryControlFlags values.

	 * @pre IsValidIndustry(industry_id).

	 * @pre No ScriptCompanyMode may be in scope.

	 * @return True if the action succeeded.

	 * @api -ai

	 */

	static bool SetControlFlags(IndustryID industry_id, uint32 control_flags);

};

#endif /* SCRIPT_INDUSTRY_HPP */

	if (_settings_game.order.selectgoods && !st->goods[type].HasVehicleEverTriedLoading()) return false;

	if (IsCargoInClass(type, CC_PASSENGERS)) {

		/* Passengers are never served by just a truck stop. */

		if (st->facilities == FACIL_TRUCK_STOP) return false;

	} else {

		/* Non-passengers are never served by just a bus stop. */

		if (st->facilities == FACIL_BUS_STOP) return false;

	}

	return true;

}

{

	/* Return if nothing to do. Also the rounding below fails for 0. */

	if (all_stations->empty()) return 0;

	if (amount == 0) return 0;

	Station *first_station = nullptr;

	typedef std::pair<Station *, uint> StationInfo;

	std::vector<StationInfo> used_stations;

	for (Station *st : *all_stations) {

		if (!CanMoveGoodsToStation(st, type)) continue;

		/* Avoid allocating a vector if there is only one station to significantly

		 * improve performance in this common case. */

		if (first_station == nullptr) {

			first_station = st;

			continue;

		}

		if  (used_stations.empty()) {

			used_stations.reserve(2);

			used_stations.emplace_back(std::make_pair(first_station, 0));

		}