*/

void ResetIndustries()

{

	for (IndustryType i = 0; i < NUM_INDUSTRYTYPES; i++) {

		_industry_specs[i].enabled = i < NEW_INDUSTRYOFFSET &&

				HasBit(_origin_industry_specs[i].climate_availability, _settings_game.game_creation.landscape);

	}

/**

 * Are the tiles of the industry free?

 * @param tile                    Position to check.

 * @param type                    Type of the industry.

 * @param initial_random_bits     The random bits the industry is going to have after construction.

 * @param founder                 Industry founder

 * @param[out] custom_shape_check Perform custom check for the site.

 * @return Failed or succeeded command.

 */

{

	bool refused_slope = false;

	bool custom_shape = false;

		if (!IsValidTile(cur_tile)) {

			return_cmd_error(STR_ERROR_SITE_UNSUITABLE);

			if (HasBit(its->callback_mask, CBM_INDT_SHAPE_CHECK)) {

				custom_shape = true;

				if (ret.Failed()) return ret;

			} else {

				Slope tileh = GetTileSlope(cur_tile);

				if (ret.Failed()) return ret;

			}

		}

	if (custom_shape_check != nullptr) *custom_shape_check = custom_shape;

 * This function tries to flatten out the land below an industry, without

 *  damaging the surroundings too much.

 */

{

	int max_x = 0;

	int max_y = 0;

	/* Finds dimensions of largest variant of this industry */

	/* Remember level height */

	uint h = TileHeight(tile);

 * @param i       Just allocated poolitem, mostly empty.

 * @param tile    North tile of the industry.

 * @param type    Type of the industry.

 * @param t       Nearest town.

 * @param founder Founder of the industry; OWNER_NONE in case of random construction.

 * @param initial_random_bits Random bits for the industry.

 */

{

	const IndustrySpec *indspec = GetIndustrySpec(type);

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

	 * 0 = created prior of newindustries

	 * else, chosen layout + 1 */

	i->prod_level = PRODLEVEL_DEFAULT;

	/* Plant the tiles */

			i->location.Add(cur_tile);

			WaterClass wc = (IsWaterTile(cur_tile) ? GetWaterClass(cur_tile) : WATER_CLASS_INVALID);

			DoCommand(cur_tile, 0, 0, DC_EXEC | DC_NO_TEST_TOWN_RATING | DC_NO_MODIFY_TOWN_RATING, CMD_LANDSCAPE_CLEAR);

			if (_generating_world) {

				SetIndustryConstructionCounter(cur_tile, 3);

			}

			/* it->gfx is stored in the map. But the translated ID cur_gfx is the interesting one */

			const IndustryTileSpec *its = GetIndustryTileSpec(cur_gfx);

			if (its->animation.status != ANIM_STATUS_NO_ANIMATION) AddAnimatedTile(cur_tile);

		}

	if (GetIndustrySpec(i->type)->behaviour & INDUSTRYBEH_PLANT_ON_BUILT) {

		for (uint j = 0; j != 50; j++) PlantRandomFarmField(i);

 * @param type of industry to build

 * @param flags of operations to conduct

 * @param indspec pointer to industry specifications

 * @param random_var8f random seed (possibly) used by industries

 * @param random_initial_bits The random bits the industry is going to have after construction.

 * @param founder Founder of the industry

 *

 * @post \c *ip contains the newly created industry if all checks are successful and the \a flags request actual creation, else it contains \c nullptr afterwards.

 */

{

	bool custom_shape_check = false;

	*ip = nullptr;

	std::vector<ClearedObjectArea> object_areas(_cleared_object_areas);

	_cleared_object_areas = object_areas;

	if (ret.Failed()) return ret;

	if (HasBit(GetIndustrySpec(type)->callback_mask, CBM_IND_LOCATION)) {

	} else {

		ret = _check_new_industry_procs[indspec->check_proc](tile);

	}

	if (ret.Failed()) return ret;

	if (!custom_shape_check && _settings_game.game_creation.land_generator == LG_TERRAGENESIS && _generating_world &&

		return_cmd_error(STR_ERROR_SITE_UNSUITABLE);

	}

	if (flags & DC_EXEC) {

		*ip = new Industry(tile);

	}

	return CommandCost();

	const IndustrySpec *indspec = GetIndustrySpec(it);

	/* Check if the to-be built/founded industry is available for this climate. */

	/* If the setting for raw-material industries is not on, you cannot build raw-material industries.

	 * Raw material industries are industries that do not accept cargo (at least for now) */

	randomizer.SetSeed(p2);

	uint16 random_initial_bits = GB(p2, 0, 16);

	uint32 random_var8f = randomizer.Next();

	CommandCost ret = CommandCost(STR_ERROR_SITE_UNSUITABLE);

	const bool deity_prospect = _current_company == OWNER_DEITY && !HasBit(p1, 16);

					 */

					tile = RandomTile();

					/* Start with a random layout */

					/* Check now each layout, starting with the random one */

					for (int j = 0; j < num_layouts; j++) {

						layout = (layout + 1) % num_layouts;

	uint32 seed = Random();

	uint32 seed2 = Random();

	Industry *i = nullptr;

	assert(i != nullptr || ret.Failed());

	return i;

}

{

	const IndustrySpec *ind_spc = GetIndustrySpec(it);

	uint32 chance = ind_spc->appear_creation[_settings_game.game_creation.landscape] * 16; // * 16 to increase precision

			(_game_mode != GM_EDITOR && _settings_game.difficulty.industry_density == ID_FUND_ONLY) ||

			(chance = GetIndustryProbabilityCallback(it, IACT_MAPGENERATION, chance)) == 0) {

		*force_at_least_one = false;

	const IndustrySpec *ind_spc = GetIndustrySpec(it);

	byte chance = ind_spc->appear_ingame[_settings_game.game_creation.landscape];

			((ind_spc->behaviour & INDUSTRYBEH_BEFORE_1950) && _cur_year > 1950) ||

			((ind_spc->behaviour & INDUSTRYBEH_AFTER_1960) && _cur_year < 1960) ||

			(chance = GetIndustryProbabilityCallback(it, IACT_RANDOMCREATION, chance)) == 0) {

		!(HasBit(this->callback_mask, CBM_IND_MONTHLYPROD_CHANGE) || HasBit(this->callback_mask, CBM_IND_PRODUCTION_CHANGE) || HasBit(this->callback_mask, CBM_IND_PROD_CHANGE_BUILD)); // production change callbacks

}

static CommandCost TerraformTile_Industry(TileIndex tile, DoCommandFlag flags, int z_new, Slope tileh_new)

{

	if (AutoslopeEnabled()) {

		/* We do not need to protect ourselves against "Random Many Industries" in this mode */

		const IndustrySpec *indsp = GetIndustrySpec(this->selected_type);

		uint32 seed = InteractiveRandom();

		if (_game_mode == GM_EDITOR) {

			/* Show error if no town exists at all */

			_generating_world = true;

			_ignore_restrictions = true;

					CMD_BUILD_INDUSTRY | CMD_MSG(STR_ERROR_CAN_T_CONSTRUCT_THIS_INDUSTRY), &CcBuildIndustry);

			cur_company.Restore();

			_ignore_restrictions = false;

			_generating_world = false;

		} else {

		}

		/* If an industry has been built, just reset the cursor and the system */

#define INDUSTRYTYPE_H

#include <array>

#include "map_type.h"

#include "slope_type.h"

#include "industry_type.h"

enum IndustryCleanupType {

	CLEAN_RANDOMSOUNDS,    ///< Free the dynamically allocated sounds table

};

/** Available types of industry lifetimes. */

};

DECLARE_ENUM_AS_BIT_SET(IndustryTileSpecialFlags)

	TileIndexDiffC ti;

	IndustryGfx gfx;

};

/**

 * Defines the data structure for constructing industry.

 */

struct IndustrySpec {

	uint8 cost_multiplier;                      ///< Base construction cost multiplier.

	uint32 removal_cost_multiplier;             ///< Base removal cost multiplier.

	uint32 prospecting_chance;                  ///< Chance prospecting succeeds

	Money GetConstructionCost() const;

	Money GetRemovalCost() const;

	bool UsesSmoothEconomy() const;

};

/**

/**

 * Validate the industry layout; e.g. to prevent duplicate tiles.

 * @param layout The layout to check.

 * @return True if the layout is deemed valid.

 */

			if (layout[i].ti.x == layout[j].ti.x &&

					layout[i].ti.y == layout[j].ti.y) {

				return false;

	return true;

}

/**

 * Define properties for industries

 * @param indid Local ID of the industry.

				 * Only need to do it once. If ever it is called again, it should not

				 * do anything */

				if (*indspec == nullptr) {

					indsp = *indspec;

					indsp->enabled = true;

					indsp->grf_prop.local_id = indid + i;

					indsp->grf_prop.subst_id = subs_id;

			}

			case 0x0A: { // Set industry layout(s)

					for (byte j = 0; j < new_num_layouts; j++) {

						for (uint k = 0;; k++) {

								grfmsg(3, "IndustriesChangeInfo: Incorrect size for industry tile layout definition for industry %u.", indid);

								/* This means we have to borrow the layout from an old industry */

								/* Use a new tile from this GRF */

								int local_tile_id = buf->ReadWord();

								/* Read the ID from the _industile_mngr. */

								int tempid = _industile_mngr.GetID(local_tile_id, _cur.grffile->grfid);

									grfmsg(2, "IndustriesChangeInfo: Attempt to use industry tile %u with industry id %u, not yet defined. Ignoring.", local_tile_id, indid);

								} else {

									/* Declared as been valid, can be used */

								/* When there were only 256x256 maps, TileIndex was a uint16 and

								 * As such negative "x" values were shifted into the "y" position.

								 *   x = -1, y = 1 -> x = 255, y = 0

								 * Since GRF version 8 the position is interpreted as pair of independent int8.

								 * For GRF version < 8 we need to emulate the old shifting behaviour.

								 */

							/* The industry layout was not valid, so skip this one. */

							grfmsg(1, "IndustriesChangeInfo: Invalid industry layout for industry id %u. Ignoring", indid);

							new_num_layouts--;

							j--;

						} else {

				/* Install final layout construction in the industry spec */

				break;

			}

		if (industryspec != nullptr) {

			for (uint i = 0; i < NUM_INDUSTRYTYPES_PER_GRF; i++) {

				IndustrySpec *ind = industryspec[i];

			}

			free(industryspec);

	}

	/* Now that we know we can use the given id, copy the spec to its final destination... */

	/* ... and mark it as usable*/

	_industry_specs[ind_id].enabled = true;

}

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

 * @return Succeeded or failed command.

 */

{

	const IndustrySpec *indspec = GetIndustrySpec(type);

	ind.location.tile = tile;

	ind.location.w = 0; // important to mark the industry invalid

	ind.type = type;

	ind.town = ClosestTownFromTile(tile, UINT_MAX);

	ind.random = initial_random_bits;

	ind.founder = founder;

uint16 GetIndustryCallback(CallbackID callback, uint32 param1, uint32 param2, Industry *industry, IndustryType type, TileIndex tile);

uint32 GetIndustryIDAtOffset(TileIndex new_tile, const Industry *i, uint32 cur_grfid);

void IndustryProductionCallback(Industry *ind, int reason);

uint32 GetIndustryProbabilityCallback(IndustryType type, IndustryAvailabilityCallType creation_type, uint32 default_prob);

bool IndustryTemporarilyRefusesCargo(Industry *ind, CargoID cargo_type);

 * @param its           Tile specification.

 * @param type          Industry type.

 * @param gfx           Gfx of the tile.

 * @param initial_random_bits Random bits of industry after construction

 * @param founder       Industry founder

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

 * @return Succeeded or failed command.

 */

{

	Industry ind;

	ind.index = INVALID_INDUSTRY;

	ind.random = initial_random_bits;

	ind.founder = founder;

	if (callback_res == CALLBACK_FAILED) {

		if (!IsSlopeRefused(GetTileSlope(ind_tile), its->slopes_refused)) return CommandCost();

		return_cmd_error(STR_ERROR_SITE_UNSUITABLE);

bool DrawNewIndustryTile(TileInfo *ti, Industry *i, IndustryGfx gfx, const IndustryTileSpec *inds);

uint16 GetIndustryTileCallback(CallbackID callback, uint32 param1, uint32 param2, IndustryGfx gfx_id, Industry *industry, TileIndex tile);

void AnimateNewIndustryTile(TileIndex tile);

bool StartStopIndustryTileAnimation(TileIndex tile, IndustryAnimationTrigger iat, uint32 random = Random());