#ifndef INDUSTRY_H

#define INDUSTRY_H

#include "oldpool.h"

#include "helpers.hpp"

typedef byte IndustryGfx;

typedef uint8 IndustryType;

enum {

	INVALID_INDUSTRY = 0xFFFF,

	INDUTILE_NOANIM = 0xFF,        ///< flag to mark industry tiles as having no animation

};

enum IndustryLifeType {

	INDUSTRYLIFE_NOT_CLOSABLE,     ///< Industry can never close

	INDUSTRYLIFE_PRODUCTION,       ///< Industry can close and change of production

	INDUSTRYLIFE_CLOSABLE,         ///< Industry can only close (no production change)

};

/* Procedures that can be run to check whether an industry may

 * build at location the given to the procedure */

enum CheckProc {

 * The same information can be accessed by looking at Industry->type

 * @param tile that is queried

 * @pre IsTileType(tile, MP_INDUSTRY)

 * @return general type for this industry, as defined in industry.h

 **/

IndustryType GetIndustryType(TileIndex tile)

{

	IndustryGfx this_type = GetIndustryGfx(tile);

	IndustryType iloop;

	assert(IsTileType(tile, MP_INDUSTRY));

		if (IS_BYTE_INSIDE(this_type, industry_gfx_Solver[iloop].MinGfx,

				industry_gfx_Solver[iloop].MaxGfx + 1)) {

			return iloop;

		}

	}

	return IT_INVALID;  //we have not found equivalent, whatever the reason

}

/**

 * Accessor for array _industry_specs.

 * This will ensure at once : proper access and

 * not allowing modifications of it.

 * @param thistype of industry (which is the index in _industry_specs)

 * @return a pointer to the corresponding industry spec

 **/

const IndustrySpec *GetIndustrySpec(IndustryType thistype)

{

	return &_industry_specs[thistype];

}

/**

 * Accessor for array _industry_tile_specs.

 * This will ensure at once : proper access and

 * not allowing modifications of it.

 * @param gfx of industrytile (which is the index in _industry_specs)

 * @pre gfx < NUM_INDUSTRY_GFXES

 * @return a pointer to the corresponding industrytile spec

 **/

const IndustryTileSpec *GetIndustryTileSpec(IndustryGfx gfx)

}

/** This function will create ramdon industries during game creation.

 * It will scale the amount of industries by map size as well as difficulty level */

void GenerateIndustries()

{

	uint i = 0;

	uint8 chance;

	IndustryType it;

	const IndustrySpec *ind_spc;

	/* Find the total amount of industries */

		int num;

		ind_spc = GetIndustrySpec(it);

		chance = ind_spc->appear_creation[_opt.landscape];

		if (chance > 0) {

			/* once the chance of appearance is determind, it have to be scaled by

			 * the difficulty level. The "chance" in question is more an index into

			 * the _numof_industry_table,in fact */

			num = _numof_industry_table[_opt.diff.number_industries][chance];

			/* These are always placed next to the coastline, so we scale by the perimeter instead. */

			num = (it == IT_OIL_REFINERY || it == IT_OIL_RIG) ? ScaleByMapSize1D(num) : ScaleByMapSize(num);

			i += num;

		}

	}

	SetGeneratingWorldProgress(GWP_INDUSTRY, i);

		/* Once the number of industries has been determined, let's really create them.

		 * The test for chance allows us to try create industries that are available only

		 * for this landscape.

		 * @todo :  Do we really have to pass chance as un-scaled value, since we've already

		 *          processed that scaling above? No, don't think so.  Will find a way. */

		chance = GetIndustrySpec(it)->appear_creation[_opt.landscape];

		if (chance > 0) PlaceInitialIndustry(it, chance);

	};

}

/* Change industry production or do closure */

static void ExtChangeIndustryProduction(Industry *i)

	IndustryType ind; ///< industry id correcponding

};

/**

 * Try to create a random industry, during gameplay

 */

static void MaybeNewIndustry(void)

{

	Industry *ind;               //will receive the industry's creation pointer

	IndustryType rndtype, j;     // Loop controlers

	const IndustrySpec *ind_spc;

	uint num = 0;

	uint16 probability_max = 0;

	/* Generate a list of all possible industries that can be built. */

		byte chance = GetIndustrySpec(j)->appear_ingame[_opt.landscape];

		/* if appearing chance for this landscape is above 0, this industry can be chosen */

		if (chance != 0) {

			probability_max += chance;

			/* adds the result for this industry */

			cumulative_probs[num].ind = j;

			cumulative_probs[num++].prob = probability_max;

		}

	}

	/* Find a random type, with maximum being what has been evaluate above*/

	rndtype = RandomRange(probability_max);

		/* and choose the index of the industry that matches as close as possible this random type */

		if (cumulative_probs[j].prob >= rndtype) break;

	}

	ind_spc = GetIndustrySpec(cumulative_probs[j].ind);

	/*  Check if it is allowed */

	if ((ind_spc->behaviour & INDUSTRYBEH_BEFORE_1950) && _cur_year > 1950) return;

	if ((ind_spc->behaviour & INDUSTRYBEH_AFTER_1960) && _cur_year < 1960) return;

	/* try to create 2000 times this industry */

	num = 2000;

	for (;;) {