/* $Id$ */

/** @file industry.h */

#ifndef INDUSTRY_H

#define INDUSTRY_H

#include "oldpool.h"

#include "helpers.hpp"

typedef byte IndustryGfx;

typedef uint8 IndustryType;

enum {

	INVALID_INDUSTRY = 0xFFFF,

	INVALID_INDUSTRYTYPE = NUM_INDUSTRYTYPES, ///< one above amount is considered invalid

};

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 {

	CHECK_NOTHING    = 0,

	CHECK_FOREST     = 1,

	CHECK_REFINERY   = 2,

	CHECK_FARM       = 3,

	CHECK_PLANTATION = 4,

	CHECK_WATER      = 5,

	CHECK_LUMBERMILL = 6,

	CHECK_BUBBLEGEN  = 7,

	CHECK_OIL_RIG    = 8,

	CHECK_END,

};

enum IndustyBehaviour {

	INDUSTRYBEH_NONE                  =      0,

	INDUSTRYBEH_PLANT_FIELDS          = 1 << 0,  ///< periodically plants fileds around itself (temp and artic farms)

	INDUSTRYBEH_CUT_TREES             = 1 << 1,  ///< cuts trees and produce first output cargo from them (lumber mill)

	INDUSTRYBEH_BUILT_ONWATER         = 1 << 2,  ///< is built on water (oil rig)

	INDUSTRYBEH_TOWN1200_MORE         = 1 << 3,  ///< can only be built in towns larger then 1200 inhabitants (temperate bank)

	INDUSTRYBEH_ONLY_INTOWN           = 1 << 4,  ///< can only be built in towns (arctic/tropic banks, water tower)

	INDUSTRYBEH_ONLY_NEARTOWN         = 1 << 5,  ///< is always built near towns (toy shop)

	INDUSTRYBEH_PLANT_ON_BUILT        = 1 << 6,  ///< Fields are planted around when built (all farms)

	INDUSTRYBEH_DONT_INCR_PROD        = 1 << 7,  ///< do not increase production (oil wells)

	INDUSTRYBEH_BEFORE_1950           = 1 << 8,  ///< can only be built before 1950 (oil wells)

	INDUSTRYBEH_AFTER_1960            = 1 << 9,  ///< can only be built after 1960 (oil rigs)

	INDUSTRYBEH_AI_AIRSHIP_ROUTES     = 1 << 10, ///< ai will attempt to establish air/ship routes to this industry (oil rig)

	INDUSTRYBEH_AIRPLANE_ATTACKS      = 1 << 11, ///< can be exploded by a military airplane (oil refinery)

	INDUSTRYBEH_CHOPPER_ATTACKS       = 1 << 12, ///< can be exploded by a military helicopter (factory)

	INDUSTRYBEH_CAN_SUBSIDENCE        = 1 << 13, ///< can cause a subsidence (coal mine, shaft that collapses)

};

DECLARE_ENUM_AS_BIT_SET(IndustyBehaviour);

/**

 * Defines the internal data of a functionnal industry

 */

struct Industry {

	const IndustryTileTable *const *table;///< List of the tiles composing the industry

	byte num_table;                       ///< Number of elements in the table

	byte cost_multiplier;                 ///< Base cost multiplier. Watch out for this one, << 5  VS << 8

	IndustryType conflicting[3];          ///< Industries this industry cannot be close to

	byte check_proc;                      ///< Index to a procedure to check for conflicting circumstances

	CargoID produced_cargo[2];

	byte production_rate[2];

	byte minimal_cargo;                   ///< minimum amount of cargo transported to the stations

	                                      ///< If the waiting cargo is less than this number, no cargo is moved to it

	CargoID accepts_cargo[3];             ///< 3 accepted cargos

	uint16 input_cargo_multiplier[3][2];  ///< Input cargo multipliers (multiply amount of incoming cargo for the produced cargos)

	IndustryLifeType life_type;           ///< This is also known as Industry production flag, in newgrf specs

	byte climate_availability;            ///< Bitmask, giving landscape enums as bit position

	IndustyBehaviour behaviour;           ///< How this industry will behave, and how others entities can use it

	byte map_colour;                      ///< colour used for the small map

	StringID name;                        ///< Displayed name of the industry

	StringID new_industry_text;           ///< Message appearing when the industry is built

	StringID closure_text;                ///< Message appearing when the industry closes

	StringID production_up_text;          ///< Message appearing when the industry's production is increasing

	StringID production_down_text;        ///< Message appearing when the industry's production is decreasing

	byte appear_ingame[NUM_LANDSCAPE];    ///< Probability of appearance in game

	byte appear_creation[NUM_LANDSCAPE];  ///< Probability of appearance during map creation

	uint8 number_of_sounds;               ///< Number of sounds available in the sounds array

	const uint8 *random_sounds;           ///< array of random sounds.

	/* Newgrf data */

	uint16 callback_flags;                ///< Flags telling which grf callback is set

	bool enabled;                         ///< entity still avaible (by default true).newgrf can disable it, though

	struct GRFFileProps grf_prop;         ///< properties related the the grf file

};

/**

 * Defines the data structure of each indivudual tile of an industry.

 */

struct IndustryTileSpec {

	CargoID accepts_cargo[3];             ///< Cargo accepted by this tile

	uint8 acceptance[3];                  ///< Level of aceptance per cargo type

	Slope slopes_refused;                 ///< slope pattern on which this tile cannot be built

	byte anim_production;                 ///< Animation frame to start when goods are produced

	byte anim_next;                       ///< Next frame in an animation

	bool anim_state;                      ///< When true, the tile has to be drawn using the animation

	                                      ///< state instead of the construction state

	/* Newgrf data */

	uint8 callback_flags;                ///< Flags telling which grf callback is set

	bool enabled;                         ///< entity still avaible (by default true).newgrf can disable it, though

	struct GRFFileProps grf_prop;

};

/* industry_cmd.cpp*/

void ResetIndustries();

void PlantRandomFarmField(const Industry *i);

/* smallmap_gui.cpp */

void BuildIndustriesLegend();

DECLARE_OLD_POOL(Industry, Industry, 3, 8000)

/**

 * Check if an Industry really exists.

 * @param industry to check

 * @return true if position is a valid one

 */

static inline bool IsValidIndustry(const Industry *industry)

{

	return industry->xy != 0;

}

/**

 * Check if an Industry exists whithin the pool of industries

 * @param index of the desired industry

 * @return true if it is inside the pool

 */

static inline bool IsValidIndustryID(IndustryID index)

{

	return index < GetIndustryPoolSize() && IsValidIndustry(GetIndustry(index));

}

VARDEF int _total_industries; //general counter

static inline IndustryID GetMaxIndustryIndex()

{

	/* TODO - This isn't the real content of the function, but

	 *  with the new pool-system this will be replaced with one that

	 *  _really_ returns the highest index. Now it just returns

	 *  the next safe value we are sure about everything is below.

	 */

	return GetIndustryPoolSize() - 1;

}

static inline uint GetNumIndustries()

{

	return _total_industries;

}

/**

 * Return a random valid industry.

 */

static inline Industry *GetRandomIndustry()

{

	int num = RandomRange(GetNumIndustries());

/* $Id$ */

/** @file industry_cmd.cpp */

#include "stdafx.h"

#include "openttd.h"

#include "clear_map.h"

#include "functions.h"

#include "industry_map.h"

#include "station_map.h"

#include "table/strings.h"

#include "table/sprites.h"

#include "map.h"

#include "tile.h"

#include "landscape.h"

#include "viewport.h"

#include "command.h"

#include "industry.h"

#include "town.h"

#include "vehicle.h"

#include "news.h"

#include "saveload.h"

#include "economy.h"

#include "sound.h"

#include "variables.h"

#include "table/industry_land.h"

#include "table/build_industry.h"

#include "genworld.h"

#include "date.h"

#include "water_map.h"

#include "tree_map.h"

#include "cargotype.h"

void ShowIndustryViewWindow(int industry);

void BuildOilRig(TileIndex tile);

static byte _industry_sound_ctr;

static TileIndex _industry_sound_tile;

/**

 * Called if a new block is added to the industry-pool

 */

static void IndustryPoolNewBlock(uint start_item)

{

	Industry *i;

	/* We don't use FOR_ALL here, because FOR_ALL skips invalid items.

	 * TODO - This is just a temporary stage, this will be removed. */

	for (i = GetIndustry(start_item); i != NULL; i = (i->index + 1U < GetIndustryPoolSize()) ? GetIndustry(i->index + 1U) : NULL) i->index = start_item++;

}

DEFINE_OLD_POOL(Industry, Industry, IndustryPoolNewBlock, NULL)

/**

 * Retrieve the type for this industry.  Although it is accessed by a tile,

 * it will return the general type of industry, and not the sprite index

 * as would do GetIndustryGfx.

 * @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)

{

	assert(IsTileType(tile, MP_INDUSTRY));

	const Industry *ind = GetIndustryByTile(tile);

	return IsValidIndustry(ind) ? ind->type : (IndustryType)IT_INVALID;

}

/**

 * 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)

 * @pre thistype < NUM_INDUSTRYTYPES

 * @return a pointer to the corresponding industry spec

 **/

const IndustrySpec *GetIndustrySpec(IndustryType thistype)

{

	assert(thistype < NUM_INDUSTRYTYPES);

	return &_industry_specs[thistype];

}

/**

 * Accessor for array _industry_tile_specs.

 * This will ensure at once : proper access and

 * not allowing modifications of it.

	td->str = GetIndustrySpec(i->type)->name;

	if (!IsIndustryCompleted(tile)) {

		SetDParamX(td->dparam, 0, td->str);

		td->str = STR_2058_UNDER_CONSTRUCTION;

	}

}

static int32 ClearTile_Industry(TileIndex tile, byte flags)

{

	Industry *i = GetIndustryByTile(tile);

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

	/* water can destroy industries

	 * in editor you can bulldoze industries

	 * with magic_bulldozer cheat you can destroy industries

	 * (area around OILRIG is water, so water shouldn't flood it

	 */

	if ((_current_player != OWNER_WATER && _game_mode != GM_EDITOR &&

			!_cheats.magic_bulldozer.value) ||

			(_current_player == OWNER_WATER && (indspec->behaviour & INDUSTRYBEH_BUILT_ONWATER))) {

		SetDParam(0, indspec->name);

		return_cmd_error(STR_4800_IN_THE_WAY);

	}

	if (flags & DC_EXEC) DeleteIndustry(i);

	return 0;

}

static void TransportIndustryGoods(TileIndex tile)

{

	Industry *i = GetIndustryByTile(tile);

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

	uint cw, am;

	cw = min(i->cargo_waiting[0], 255);

	if (cw > indspec->minimal_cargo/* && i->produced_cargo[0] != 0xFF*/) {

		i->cargo_waiting[0] -= cw;

		/* fluctuating economy? */

		if (_economy.fluct <= 0) cw = (cw + 1) / 2;

		i->last_mo_production[0] += cw;

		am = MoveGoodsToStation(i->xy, i->width, i->height, indspec->produced_cargo[0], cw);

		i->last_mo_transported[0] += am;

		if (am != 0) {

			uint newgfx = GetIndustryTileSpec(GetIndustryGfx(tile))->anim_production;

				ResetIndustryConstructionStage(tile);

				SetIndustryCompleted(tile, true);

				SetIndustryGfx(tile, newgfx);

				MarkTileDirtyByTile(tile);

			}

		}

	}

	cw = min(i->cargo_waiting[1], 255);

	if (cw > indspec->minimal_cargo) {

		i->cargo_waiting[1] -= cw;

		if (_economy.fluct <= 0) cw = (cw + 1) / 2;

		i->last_mo_production[1] += cw;

		am = MoveGoodsToStation(i->xy, i->width, i->height, indspec->produced_cargo[1], cw);

		i->last_mo_transported[1] += am;

	}

}

static void AnimateTile_Industry(TileIndex tile)

{

	byte m;

	switch (GetIndustryGfx(tile)) {

	case GFX_SUGAR_MINE_SIEVE:

		if ((_tick_counter & 1) == 0) {

			m = GetIndustryAnimationState(tile) + 1;

			switch (m & 7) {

			case 2: SndPlayTileFx(SND_2D_RIP_2, tile); break;

			case 6: SndPlayTileFx(SND_29_RIP, tile); break;

			}

			if (m >= 96) {

				m = 0;

				DeleteAnimatedTile(tile);

			}

			SetIndustryAnimationState(tile, m);

			MarkTileDirtyByTile(tile);

		}

		break;

	case GFX_TOFFEE_QUARY:

		if ((_tick_counter & 3) == 0) {

	case GFX_PLASTIC_FOUNTAIN_ANIMATED_3: case GFX_PLASTIC_FOUNTAIN_ANIMATED_4:

	case GFX_PLASTIC_FOUNTAIN_ANIMATED_5: case GFX_PLASTIC_FOUNTAIN_ANIMATED_6:

	case GFX_PLASTIC_FOUNTAIN_ANIMATED_7: case GFX_PLASTIC_FOUNTAIN_ANIMATED_8:

		AddAnimatedTile(tile);

		break;

	}

}

static void TileLoopIndustry_BubbleGenerator(TileIndex tile)

{

	int dir;

	Vehicle *v;

	static const int8 _tileloop_ind_case_161[12] = {

		11,   0, -4, -14,

		-4, -10, -4,   1,

		49,  59, 60,  65,

	};

	SndPlayTileFx(SND_2E_EXTRACT_AND_POP, tile);

	dir = Random() & 3;

	v = CreateEffectVehicleAbove(

		TileX(tile) * TILE_SIZE + _tileloop_ind_case_161[dir + 0],

		TileY(tile) * TILE_SIZE + _tileloop_ind_case_161[dir + 4],

		_tileloop_ind_case_161[dir + 8],

		EV_BUBBLE

	);

	if (v != NULL) v->u.special.unk2 = dir;

}

static void TileLoop_Industry(TileIndex tile)

{

	IndustryGfx newgfx;

	IndustryGfx gfx;

	if (!IsIndustryCompleted(tile)) {

		MakeIndustryTileBigger(tile);

		return;

	}

	if (_game_mode == GM_EDITOR) return;

	TransportIndustryGoods(tile);

	newgfx = GetIndustryTileSpec(GetIndustryGfx(tile))->anim_next;

		ResetIndustryConstructionStage(tile);

		SetIndustryGfx(tile, newgfx);

		MarkTileDirtyByTile(tile);

		return;

	}

	gfx = GetIndustryGfx(tile);

	switch (gfx) {

	case GFX_OILRIG_1: // coast line at oilrigs

	case GFX_OILRIG_2:

	case GFX_OILRIG_3:

	case GFX_OILRIG_4:

	case GFX_OILRIG_5:

		TileLoop_Water(tile);

		break;

	case GFX_COAL_MINE_TOWER_NOT_ANIMATED:

	case GFX_COPPER_MINE_TOWER_NOT_ANIMATED:

	case GFX_GOLD_MINE_TOWER_NOT_ANIMATED:

		if (!(_tick_counter & 0x400) && CHANCE16(1, 2)) {

			switch (gfx) {

				case GFX_COAL_MINE_TOWER_NOT_ANIMATED:   gfx = GFX_COAL_MINE_TOWER_ANIMATED;   break;

				case GFX_COPPER_MINE_TOWER_NOT_ANIMATED: gfx = GFX_COPPER_MINE_TOWER_ANIMATED; break;

				case GFX_GOLD_MINE_TOWER_NOT_ANIMATED:   gfx = GFX_GOLD_MINE_TOWER_ANIMATED;   break;

			}

			SetIndustryGfx(tile, gfx);

			SetIndustryAnimationState(tile, 0x80);

			AddAnimatedTile(tile);

		}

		break;

	case GFX_OILWELL_NOT_ANIMATED:

		if (CHANCE16(1, 6)) {

			SetIndustryGfx(tile, GFX_OILWELL_ANIMATED_1);

			SetIndustryAnimationState(tile, 0);

			AddAnimatedTile(tile);

		}

		break;

	case GFX_COAL_MINE_TOWER_ANIMATED:

	case GFX_COPPER_MINE_TOWER_ANIMATED:

	case GFX_GOLD_MINE_TOWER_ANIMATED:

		if (!(_tick_counter & 0x400)) {

			switch (gfx) {

				case GFX_COAL_MINE_TOWER_ANIMATED:   gfx = GFX_COAL_MINE_TOWER_NOT_ANIMATED;   break;

				case GFX_COPPER_MINE_TOWER_ANIMATED: gfx = GFX_COPPER_MINE_TOWER_NOT_ANIMATED; break;

				case GFX_GOLD_MINE_TOWER_ANIMATED:   gfx = GFX_GOLD_MINE_TOWER_NOT_ANIMATED;   break;

 * Reset all NewGRF loaded data

 * TODO

 */

static void ResetNewGRFData()

{

	CleanUpStrings();

	/* Copy/reset original engine info data */

	memcpy(&_engine_info, &orig_engine_info, sizeof(orig_engine_info));

	memcpy(&_rail_vehicle_info, &orig_rail_vehicle_info, sizeof(orig_rail_vehicle_info));

	memcpy(&_ship_vehicle_info, &orig_ship_vehicle_info, sizeof(orig_ship_vehicle_info));

	memcpy(&_aircraft_vehicle_info, &orig_aircraft_vehicle_info, sizeof(orig_aircraft_vehicle_info));

	memcpy(&_road_vehicle_info, &orig_road_vehicle_info, sizeof(orig_road_vehicle_info));

	/* Copy/reset original bridge info data

	 * First, free sprite table data */

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

		if (_bridge[i].sprite_table != NULL) {

			for (uint j = 0; j < 7; j++) free(_bridge[i].sprite_table[j]);

			free(_bridge[i].sprite_table);

		}

	}

	memcpy(&_bridge, &orig_bridge, sizeof(_bridge));

	/* Reset refit/cargo class data */

	memset(&cargo_allowed, 0, sizeof(cargo_allowed));

	memset(&cargo_disallowed, 0, sizeof(cargo_disallowed));

	/* Reset GRM reservations */

	memset(&_grm_engines, 0, sizeof(_grm_engines));

	/* Unload sprite group data */

	UnloadWagonOverrides();

	UnloadRotorOverrideSprites();

	UnloadCustomEngineSprites();

	UnloadCustomEngineNames();

	ResetEngineListOrder();

	/* Reset price base data */

	ResetPriceBaseMultipliers();

	/* Reset the curencies array */

	ResetCurrencies();

	/* Reset the house array */

	ResetCustomHouses();

	ResetHouses();

	/* Reset station classes */

	ResetStationClasses();

	ResetCustomStations();

	/* Reset canal sprite groups */

	memset(_canal_sg, 0, sizeof(_canal_sg));

	/* Reset the snowline table. */

	ClearSnowLine();

	/* Reset NewGRF files */

	ResetNewGRF();

	/* Add engine type to engine data. This is needed for the refit precalculation. */

	AddTypeToEngines();

	/* Set up the default cargo types */

	SetupCargoForClimate(_opt.landscape);

	/* Reset misc GRF features and train list display variables */

	_misc_grf_features = 0;

	_traininfo_vehicle_pitch = 0;

	_traininfo_vehicle_width = 29;

	_have_2cc = false;

	_have_newhouses = false;

	_signal_base = 0;

	_coast_base = 0;

	InitializeSoundPool();

	InitializeSpriteGroupPool();

}

/** Reset all NewGRFData that was used only while processing data */

static void ClearTemporaryNewGRFData()

{

	/* Clear the GOTO labels used for GRF processing */

	for (GRFLabel *l = _cur_grffile->label; l != NULL;) {

		GRFLabel *l2 = l->next;

		free(l);

		l = l2;

	}

	_cur_grffile->label = NULL;

	/* Clear the list of spritegroups */

	free(_cur_grffile->spritegroups);

	_cur_grffile->spritegroups = NULL;

	_cur_grffile->spritegroups_count = 0;

}

/** Array with... hem... a sound of toyland */

static const uint8 _plastic_mine_sounds[] = { SND_33_PLASTIC_MINE };

/**

 * Writes the properties of an industry into the IndustrySpec struct.

 * @param tbl  tile table

 * @param sndc number of sounds

 * @param snd  sounds table

 * @param d    cost multiplier

 * @param ai1  appear chance ingame - temperate

 * @param ai2  appear chance ingame - arctic

 * @param ai3  appear chance ingame - tropic

 * @param ai4  appear chance ingame - toyland

 * @param ag1  appear chance random creation - temperate

 * @param ag2  appear chance random creation - arctic

 * @param ag3  appear chance random creation - tropic

 * @param ag4  appear chance random creation - toyland

 * @param col  map colour

 * @param c1   industry proximity refusal - 1st

 * @param c2   industry proximity refusal - 2nd

 * @param c3   industry proximity refusal - 3th

 * @param proc check procedure index

 * @param p1   produce cargo 1

 * @param r1   rate of production 1

 * @param p2   produce cargo 2

 * @param r2   rate of production 1

 * @param m    minimum cargo moved to station

 * @param a1   accepted cargo 1

 * @param im1  input multiplier for cargo 1

 * @param a2   accepted cargo 2

 * @param im2  input multiplier for cargo 2

 * @param a3   accepted cargo 3

 * @param im3  input multiplier for cargo 3

 * @param pr   industry life (actually, the same as extractive, organic, processing in ttdpatch's specs)

 * @param clim climate availaility

 * @param bev  industry behaviour

 * @param in   name

 * @param intx text while building

 * @param s1   text for closure

 * @param s2   text for production up

 * @param s3   text for production down

 */

#define MI(tbl, sndc, snd, d, ai1, ai2, ai3, ai4, ag1, ag2, ag3, ag4, col, \

           c1, c2, c3, proc, p1, r1, p2, r2, m, a1, im1, a2, im2, a3, im3, pr, clim, bev, in, intx, s1, s2, s3) \

	 {tbl, lengthof(tbl), d, {c1, c2, c3}, proc, {p1, p2}, {r1, r2}, m,            \

	 {a1, a2, a3}, {{im1, 0}, {im2, 0}, {im3, 0}}, pr, clim, bev, col, in, intx, s1, s2, s3, {ai1, ai2, ai3, ai4}, {ag1, ag2, ag3, ag4}, \

	 sndc, snd, 0, true, {0, 0, NULL, NULL, INVALID_INDUSTRYTYPE}}

	/* Format:

	   tile table                              count and sounds table

	   cost multiplier                         appear chances(4ingame, 4random)  map colour

	   cannot be close to these industries (3 times)             check proc

	   (produced cargo + rate) (twice)         minimum cargo moved to station

	   3 accepted cargo and their corresponding input multiplier

	   industry life                           climate availability

	   industry behaviours

	   industry name                           building text

	   messages : Closure                      production up                      production down   */

	MI(_tile_table_coal_mine,                  0, NULL,

	   210,                                    2, 3, 0, 0,    8, 8, 0, 0,        215,

	   IT_POWER_STATION,  IT_INVALID,          IT_INVALID,       CHECK_NOTHING,

	   CT_COAL,       15, CT_INVALID,       0, 5,

	   CT_INVALID,     0, CT_INVALID,       0, CT_INVALID,     0,

	   INDUSTRYLIFE_PRODUCTION,                1 << LT_TEMPERATE | 1 << LT_ARCTIC,

	   INDUSTRYBEH_CAN_SUBSIDENCE,

	   STR_4802_COAL_MINE,                     STR_482D_NEW_UNDER_CONSTRUCTION,

	   STR_4832_ANNOUNCES_IMMINENT_CLOSURE,    STR_4836_NEW_COAL_SEAM_FOUND_AT,   STR_4839_PRODUCTION_DOWN_BY_50),

	MI(_tile_table_power_station,              0, NULL,

	   30,                                     2, 2, 0, 0,    5, 5, 0, 0,        184,

	   IT_COAL_MINE,      IT_INVALID,          IT_INVALID,       CHECK_NOTHING,

	   CT_INVALID,     0, CT_INVALID,       0, 5,

	   CT_COAL,        0, CT_INVALID,       0, CT_INVALID,     0,

	   INDUSTRYLIFE_NOT_CLOSABLE,              1 << LT_TEMPERATE | 1 << LT_ARCTIC,

	   INDUSTRYBEH_NONE,

	   STR_4803_POWER_STATION,                 STR_482D_NEW_UNDER_CONSTRUCTION,

	   STR_4832_ANNOUNCES_IMMINENT_CLOSURE,    STR_4835_INCREASES_PRODUCTION,     STR_4839_PRODUCTION_DOWN_BY_50),

	MI(_tile_table_sawmill,                    1, _sawmill_sounds,

	   28,                                     2, 0, 0, 0,    5, 0, 0, 0,        194,

	   IT_FOREST,         IT_INVALID,          IT_INVALID,       CHECK_NOTHING,

	   CT_GOODS,       0, CT_INVALID,       0, 5,

	   CT_WOOD,      256, CT_INVALID,       0, CT_INVALID,     0,

	   INDUSTRYLIFE_CLOSABLE,                  1 << LT_TEMPERATE,

	   INDUSTRYBEH_NONE,

	   STR_4804_SAWMILL,                       STR_482D_NEW_UNDER_CONSTRUCTION,

	   STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,      STR_4835_INCREASES_PRODUCTION,     STR_4839_PRODUCTION_DOWN_BY_50),

	MI(_tile_table_forest,                     0, NULL,

	   200,                                    3, 4, 0, 0,    5, 5, 0, 0,         86,

	   IT_SAWMILL,        IT_PAPER_MILL,       IT_INVALID,       CHECK_FOREST,

	   CT_WOOD,       13, CT_INVALID,       0, 30,

	   CT_INVALID,     0, CT_INVALID,       0, CT_INVALID,     0,

	   INDUSTRYLIFE_PRODUCTION,                1 << LT_TEMPERATE | 1 << LT_ARCTIC,

	   INDUSTRYBEH_NONE,

	   STR_4805_FOREST,                        STR_482E_NEW_BEING_PLANTED_NEAR,

	   STR_4832_ANNOUNCES_IMMINENT_CLOSURE,    STR_4835_INCREASES_PRODUCTION,     STR_483A_INSECT_INFESTATION_CAUSES),

	MI(_tile_table_oil_refinery,               0, NULL,

	   31,                                     2, 2, 2, 0,    4, 4, 4, 0,        191,

	   IT_OIL_RIG,        IT_INVALID,          IT_INVALID,       CHECK_REFINERY,

	   CT_GOODS,       0, CT_INVALID,       0, 5,

	   CT_OIL,       256, CT_INVALID,       0, CT_INVALID,     0,

	   INDUSTRYLIFE_CLOSABLE,                  1 << LT_TEMPERATE | 1 << LT_ARCTIC | 1 << LT_TROPIC,

	   INDUSTRYBEH_AIRPLANE_ATTACKS,

	   STR_4806_OIL_REFINERY,                  STR_482D_NEW_UNDER_CONSTRUCTION,

	   STR_4823_FIZZY_DRINK_FACTORY,           STR_482D_NEW_UNDER_CONSTRUCTION,

	   STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,      STR_4835_INCREASES_PRODUCTION,     STR_4839_PRODUCTION_DOWN_BY_50),

	MI(_tile_table_bubble_generator,           0, NULL,

	   203,                                    0, 0, 0, 3,    0, 0, 0, 5,        152,

	   IT_FIZZY_DRINK_FACTORY, IT_INVALID,     IT_INVALID,       CHECK_BUBBLEGEN,

	   CT_BUBBLES,    13, CT_INVALID,       0, 5,

	   CT_INVALID,     0, CT_INVALID,       0, CT_INVALID,     0,

	   INDUSTRYLIFE_PRODUCTION,                1 << LT_TOYLAND,

	   INDUSTRYBEH_NONE,

	   STR_4824_BUBBLE_GENERATOR,              STR_482D_NEW_UNDER_CONSTRUCTION,

	   STR_4832_ANNOUNCES_IMMINENT_CLOSURE,    STR_4835_INCREASES_PRODUCTION,     STR_4839_PRODUCTION_DOWN_BY_50),

	MI(_tile_table_toffee_quarry,              0, NULL,

	   213,                                    0, 0, 0, 3,    0, 0, 0, 5,        194,

	   IT_CANDY_FACTORY,  IT_INVALID,          IT_INVALID,       CHECK_NOTHING,

	   CT_TOFFEE,     10, CT_INVALID,       0, 5,

	   CT_INVALID,     0, CT_INVALID,       0, CT_INVALID,     0,

	   INDUSTRYLIFE_PRODUCTION,                1 << LT_TOYLAND,

	   INDUSTRYBEH_NONE,

	   STR_4825_TOFFEE_QUARRY,                 STR_482D_NEW_UNDER_CONSTRUCTION,

	   STR_4832_ANNOUNCES_IMMINENT_CLOSURE,    STR_4835_INCREASES_PRODUCTION,     STR_4839_PRODUCTION_DOWN_BY_50),

	MI(_tile_table_sugar_mine,                 0, NULL,

	   210,                                    0, 0, 0, 2,    0, 0, 0, 4,         15,

	   IT_CANDY_FACTORY,  IT_INVALID,          IT_INVALID,       CHECK_NOTHING,

	   CT_SUGAR,      11, CT_INVALID,       0, 5,

	   CT_INVALID,     0, CT_INVALID,       0, CT_INVALID,     0,

	   INDUSTRYLIFE_PRODUCTION,                1 << LT_TOYLAND,

	   INDUSTRYBEH_NONE,

	   STR_4826_SUGAR_MINE,                    STR_482D_NEW_UNDER_CONSTRUCTION,

	   STR_4832_ANNOUNCES_IMMINENT_CLOSURE,    STR_4835_INCREASES_PRODUCTION,     STR_4839_PRODUCTION_DOWN_BY_50),

};

#undef MI

/** Writes the properties of an industry tile into the IndustryTileSpec struct.

 * @param ca1 acceptance of first cargo

 * @param c1  first type of cargo accepted for this tile

 * @param ca2 acceptance of second cargo

 * @param c2  second cargo

 * @param ca3 acceptance of third cargo

 * @param c3  and third cargo. Those three are in an array

 * @param s1  slope refused upon choosing a place to build

 * @param a1  animation frame on production

 * @param a2  next frame of animation

 * @param a3  chooses between animation or construction state

 */

#define MT(ca1, c1, ca2, c2, ca3, c3, sl, a1, a2, a3) {{c1, c2, c3}, {ca1, ca2, ca3}, sl, a1, a2, a3, 0, true, {0, 0, NULL, NULL, 0}}

	/* Coal Mine */

	/* Power Station */

	/* Sawmill */

	/* Forest Artic, temperate */

	/* Oil refinery */