* @return Relative probability for the industry to appear.

 */

static uint32 GetScaledIndustryGenerationProbability(IndustryType it, bool *force_at_least_one)

{

	const IndustrySpec *ind_spc = GetIndustrySpec(it);

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

	if (!ind_spc->enabled || chance == 0 || ind_spc->num_table == 0 ||

			!CheckIfCallBackAllowsAvailability(it, IACT_MAPGENERATION) ||

			(_game_mode != GM_EDITOR && _settings_game.difficulty.number_industries == 0)) {

		*force_at_least_one = false;

		return 0;

	} else {

		/* We want industries appearing at coast to appear less often on bigger maps, as length of coast increases slower than map area.

		 * For simplicity we scale in both cases, though scaling the probabilities of all industries has no effect. */

		chance = (ind_spc->check_proc == CHECK_REFINERY || ind_spc->check_proc == CHECK_OIL_RIG) ? ScaleByMapSize1D(chance) : ScaleByMapSize(chance);

		*force_at_least_one = (chance > 0) && !(ind_spc->behaviour & INDUSTRYBEH_NOBUILT_MAPCREATION) && (_game_mode != GM_EDITOR);

		return chance;

	}

}

/**

 * Compute the probability for constructing a new industry during game play.

 * @param it Industry type to compute.

 * @return Relative probability for the industry to appear.

 */

{

	const IndustrySpec *ind_spc = GetIndustrySpec(it);

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

	if (!ind_spc->enabled || chance == 0 || ind_spc->num_table == 0 ||

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

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

			!CheckIfCallBackAllowsAvailability(it, IACT_RANDOMCREATION)) {

		return 0;

	}

	return chance;

}

/**

 * Get wanted number of industries on the map.

 * @return Wanted number of industries at the map.

 */

static uint GetNumberOfIndustries()

{

	/* Number of industries on a 256x256 map. */

	static const uint16 numof_industry_table[] = {

		0,    // none

		10,   // very low

		25,   // low

		55,   // normal

		80,   // high

	};

	assert(_settings_game.difficulty.number_industries < lengthof(numof_industry_table));

	uint difficulty = (_game_mode != GM_EDITOR) ? _settings_game.difficulty.number_industries : 1;

	return ScaleByMapSize(numof_industry_table[difficulty]);

}

/**

	Backup<CompanyByte> cur_company(_current_company, OWNER_NONE, FILE_LINE);

	IncreaseGeneratingWorldProgress(GWP_INDUSTRY);

	PlaceIndustry(type, IACT_MAPGENERATION, try_hard);

	cur_company.Restore();

}

/**

 * Get total number of industries existing in the game.

 * @return Number of industries currently in the game.

 */

static uint GetCurrentTotalNumberOfIndustries()

{

	int total = 0;

	for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) total += Industry::GetIndustryTypeCount(it);

	return total;

}

/** Reset the entry. */

void IndustryTypeBuildData::Reset()

{

	this->probability  = 0;

	this->target_count = 0;

	this->max_wait     = 1;

	this->wait_count   = 0;

}

/** Completely reset the industry build data. */

void IndustryBuildData::Reset()

{

	this->wanted_inds = GetCurrentTotalNumberOfIndustries() << 16;

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

		this->builddata[it].Reset();

	}

}

/** Monthly update of industry build data. */

void IndustryBuildData::MonthlyLoop()

{

	static const int NEWINDS_PER_MONTH = 0x38000 / (10 * 12); // lower 16 bits is a float fraction, 3.5 industries per decade, divided by 10 * 12 months.

	if (_settings_game.difficulty.number_industries == 0) return; // 'no industries' setting,

	/* To prevent running out of unused industries for the player to connect,

	 * add a fraction of new industries each month, but only if the manager can keep up. */

	uint max_behind = 1 + min(99u, ScaleByMapSize(3)); // At most 2 industries for small maps, and 100 at the biggest map (about 6 months industry build attempts).

			i->this_month_production[j] = 0;

			i->last_month_transported[j] = i->this_month_transported[j];

			i->this_month_transported[j] = 0;

		}

	}

}

/**

 * Recompute #production_rate for current #prod_level.

 * This function is only valid when not using smooth economy.

 */

void Industry::RecomputeProductionMultipliers()

{

	const IndustrySpec *indspec = GetIndustrySpec(this->type);

	assert(!indspec->UsesSmoothEconomy());

	/* Rates are rounded up, so e.g. oilrig always produces some passengers */

	this->production_rate[0] = min(CeilDiv(indspec->production_rate[0] * this->prod_level, PRODLEVEL_DEFAULT), 0xFF);

	this->production_rate[1] = min(CeilDiv(indspec->production_rate[1] * this->prod_level, PRODLEVEL_DEFAULT), 0xFF);

}

/**

 * @param it Industry type.

 */

bool IndustryTypeBuildData::GetIndustryTypeData(IndustryType it)

{

	this->probability = probability;

	return changed;

}

/** Decide how many industries of each type are needed. */

void IndustryBuildData::SetupTargetCount()

{

	bool changed = false;

	uint num_planned = 0; // Number of industries planned in the industry build data.

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

		changed |= this->builddata[it].GetIndustryTypeData(it);

		num_planned += this->builddata[it].target_count;

	}

	uint total_amount = this->wanted_inds >> 16; // Desired total number of industries.

	changed |= num_planned != total_amount;

	if (!changed) return; // All industries are still the same, no need to re-randomize.

	uint32 total_prob = 0; // Sum of probabilities.

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

	}

	/* Assign number of industries that should be aimed for, by using the probability as a weight. */

	while (total_amount > 0) {

		uint32 r = RandomRange(total_prob);

		IndustryType it = 0;

		while (r >= this->builddata[it].probability) {

			r -= this->builddata[it].probability;

			it++;

			assert(it < NUM_INDUSTRYTYPES);

		}

		assert(this->builddata[it].probability > 0);

		this->builddata[it].target_count++;

		total_amount--;

	}

}

/**

 * Try to create a random industry, during gameplay

 */

void IndustryBuildData::TryBuildNewIndustry()

{

	this->SetupTargetCount();

	int missing = 0;       // Number of industries that need to be build.

	uint count = 0;        // Number of industry types eligible for build.

	uint32 total_prob = 0; // Sum of probabilities.

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

		int difference = this->builddata[it].target_count - Industry::GetIndustryTypeCount(it);

		missing += difference;

		if (this->builddata[it].wait_count > 0) continue; // This type may not be built now.

		if (difference > 0) {

			total_prob += difference;

			count++;

		}

	}

	if (count >= 1) {

		 * For the case that count == 1, there is no need to draw a random number. */

		IndustryType it;

		}

		/* Try to create the industry. */

		const Industry *ind = PlaceIndustry(it, IACT_RANDOMCREATION, false);

		if (ind == NULL) {

			this->builddata[it].wait_count = this->builddata[it].max_wait + 1; // Compensate for decrementing below.

			this->builddata[it].max_wait = min(1000, this->builddata[it].max_wait + 2);

		} else {

			AdvertiseIndustryOpening(ind);

			this->builddata[it].max_wait = max(this->builddata[it].max_wait / 2, 1); // Reduce waiting time of the industry type.

		}

	}

	/* Decrement wait counters. */

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

		if (this->builddata[it].wait_count > 0) this->builddata[it].wait_count--;

	}

}

/**

 * Protects an industry from closure if the appropriate flags and conditions are met

 * INDUSTRYBEH_CANCLOSE_LASTINSTANCE must be set (which, by default, it is not) and the

 * count of industries of this type must one (or lower) in order to be protected

 * against closure.

 * @param type IndustryType been queried