1

/* $Id$ */

     2

     3

/** @file industry.h */

     4

     5

#ifndef INDUSTRY_H

     6

#define INDUSTRY_H

     7

     8

#include "oldpool.h"

     9

#include "helpers.hpp"

    10

    11

typedef byte IndustryGfx;

    12

typedef uint8 IndustryType;

    13

    14

enum {

    15

	INVALID_INDUSTRY = 0xFFFF,

    17

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

    18

};

    19

    20

enum IndustryLifeType {

    21

	INDUSTRYLIFE_NOT_CLOSABLE,     ///< Industry can never close

    22

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

    23

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

    24

};

    25

    26

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

    27

 * build at location the given to the procedure */

    28

enum CheckProc {

    29

	CHECK_NOTHING    = 0,

    30

	CHECK_FOREST     = 1,

    31

	CHECK_REFINERY   = 2,

    32

	CHECK_FARM       = 3,

    33

	CHECK_PLANTATION = 4,

    34

	CHECK_WATER      = 5,

    35

	CHECK_LUMBERMILL = 6,

    36

	CHECK_BUBBLEGEN  = 7,

    37

	CHECK_OIL_RIG    = 8,

    38

	CHECK_END,

    39

};

    40

    41

enum IndustyBehaviour {

    42

	INDUSTRYBEH_NONE                  =      0,

    43

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

    44

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

    45

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

    46

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

    47

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

    48

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

    49

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

    50

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

    51

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

    52

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

    53

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

    54

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

    55

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

    56

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

    57

};

    58

    59

    60

DECLARE_ENUM_AS_BIT_SET(IndustyBehaviour);

    61

    62

/**

    63

 * Defines the internal data of a functionnal industry

    64

 */

    65

struct Industry {

    66

	TileIndex xy;                   ///< coordinates of the primary tile the industry is built one

    67

	byte width;

    68

	byte height;

    69

	const Town* town;               ///< Nearest town

    70

	CargoID produced_cargo[2];      ///< 2 production cargo slots

    71

	uint16 cargo_waiting[2];        ///< amount of cargo produced per cargo

    72

	byte production_rate[2];        ///< production rate for each cargo

    73

	CargoID accepts_cargo[3];       ///< 3 input cargo slots

    74

	byte prod_level;                ///< general production level

    75

	uint16 last_mo_production[2];   ///< stats of last month production per cargo

    76

	uint16 last_mo_transported[2];  ///< stats of last month transport per cargo

    77

	byte pct_transported[2];        ///< percentage transported per cargo

    78

	uint16 total_production[2];     ///< total units produced per cargo

    79

	uint16 total_transported[2];    ///< total units transported per cargo

    80

	uint16 counter;                 ///< used for animation and/or production (if available cargo)

    81

    82

	byte type;                      ///< type of industry. see IT_COAL_MINE and others

    83

	OwnerByte owner;                ///< owner of the industry.  Which SHOULD always be (imho) OWNER_NONE

    84

	byte random_color;              ///< randomized colour of the industry, for display purpose

    85

	Year last_prod_year;            ///< last year of production

    86

	byte was_cargo_delivered;       ///< flag that indicate this has been the closest industry chosen for cargo delivery by a station. see DeliverGoodsToIndustry

    87

    88

	IndustryID index;               ///< index of the industry in the pool of industries

    89

};

    90

    91

struct IndustryTileTable {

    92

	TileIndexDiffC ti;

    93

	IndustryGfx gfx;

    94

};

    95

    96

/**

    97

 * Defines the data structure for constructing industry.

    98

 */

    99

struct IndustrySpec {

   100

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

   101

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

   102

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

   103

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

   104

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

   105

	CargoID produced_cargo[2];

   106

	byte production_rate[2];

   107

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

   108

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

   109

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

   110

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

   111

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

   112

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

   113

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

   114

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

   115

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

   116

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

   117

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

   118

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

   119

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

   120

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

   121

	/* Newgrf stuff coming in */

   122

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

   123

	byte subst_id;

   124

	uint32 grfid;

   125

	byte override;

   126

};

   127

   128

/**

   129

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

   130

 */

   131

struct IndustryTileSpec {

   132

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

   133

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

   134

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

   135

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

   136

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

   137

                                         ///< state instead of the construction state

   138

};

   139

   140

const IndustrySpec *GetIndustrySpec(IndustryType thistype);    ///< Array of industries default data

   141

const IndustryTileSpec *GetIndustryTileSpec(IndustryGfx gfx);  ///< Array of industry tiles default data

   142

   143

DECLARE_OLD_POOL(Industry, Industry, 3, 8000)

   144

   145

/**

   146

 * Check if an Industry really exists.

   147

 * @param industry to check

   148

 * @return true if position is a valid one

   149

 */

   150

static inline bool IsValidIndustry(const Industry *industry)

   151

{

   152

	return industry->xy != 0;

   153

}

   154

   155

/**

   156

 * Check if an Industry exists whithin the pool of industries

   157

 * @param index of the desired industry

   158

 * @return true if it is inside the pool

   159

 */

   160

static inline bool IsValidIndustryID(IndustryID index)

   161

{

   162

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

   163

}

   164

   165

VARDEF int _total_industries; //general counter

   166

   167

static inline IndustryID GetMaxIndustryIndex()

   168

{

   169

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

   170

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

   171

	 *  _really_ returns the highest index. Now it just returns

   172

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

   173

	 */

   174

	return GetIndustryPoolSize() - 1;

   175

}

   176

   177

static inline uint GetNumIndustries()

   178

{

   179

	return _total_industries;

   180

}

   181

   182

/**

   183

 * Return a random valid industry.

   184

 */

   185

static inline Industry *GetRandomIndustry()

   186

{

   187

	int num = RandomRange(GetNumIndustries());

   188

	IndustryID index = INVALID_INDUSTRY;

   189

   190

	if (GetNumIndustries() == 0) return NULL;

   191

   192

	while (num >= 0) {

   193

		num--;

   194

		index++;

   195

   196

		/* Make sure we have a valid industry */

   197

		while (!IsValidIndustryID(index)) {

   198

			index++;

   199

			assert(index <= GetMaxIndustryIndex());

   200

		}

   201

	}

   202

   203

	return GetIndustry(index);

   204

}

   205

   206

void DestroyIndustry(Industry *i);

   207

   208

static inline void DeleteIndustry(Industry *i)

   209

{

   210

	DestroyIndustry(i);

   211

	i->xy = 0;

   212

}

   213

   214

#define FOR_ALL_INDUSTRIES_FROM(i, start) for (i = GetIndustry(start); i != NULL; i = (i->index + 1U < GetIndustryPoolSize()) ? GetIndustry(i->index + 1U) : NULL) if (IsValidIndustry(i))

   215

#define FOR_ALL_INDUSTRIES(i) FOR_ALL_INDUSTRIES_FROM(i, 0)

   216

   217

VARDEF const Industry** _industry_sort;

   218

VARDEF bool _industry_sort_dirty;

   219

   220

   221

void DeleteIndustry(Industry *is);

   222

void PlantRandomFarmField(const Industry *i);

   223

   224

enum {

   225

	IT_COAL_MINE           =   0,

   226

	IT_POWER_STATION       =   1,

   227

	IT_SAWMILL             =   2,

   228

	IT_FOREST              =   3,

   229

	IT_OIL_REFINERY        =   4,

   230

	IT_OIL_RIG             =   5,

   231

	IT_FACTORY             =   6,

   232

	IT_PRINTING_WORKS      =   7,

   233

	IT_STEEL_MILL          =   8,

   234

	IT_FARM                =   9,

   235

	IT_COPPER_MINE         =  10,

   236

	IT_OIL_WELL            =  11,

   237

	IT_BANK_TEMP           =  12,

   238

	IT_FOOD_PROCESS        =  13,

   239

	IT_PAPER_MILL          =  14,

   240

	IT_GOLD_MINE           =  15,

   241

	IT_BANK_TROPIC_ARCTIC  =  16,

   242

	IT_DIAMOND_MINE        =  17,

   243

	IT_IRON_MINE           =  18,

   244

	IT_FRUIT_PLANTATION    =  19,

   245

	IT_RUBBER_PLANTATION   =  20,

   246

	IT_WATER_SUPPLY        =  21,

   247

	IT_WATER_TOWER         =  22,

   248

	IT_FACTORY_2           =  23,

   249

	IT_FARM_2              =  24,

   250

	IT_LUMBER_MILL         =  25,

   251

	IT_COTTON_CANDY        =  26,

   252

	IT_CANDY_FACTORY       =  27,

   253

	IT_BATTERY_FARM        =  28,

   254

	IT_COLA_WELLS          =  29,

   255

	IT_TOY_SHOP            =  30,

   256

	IT_TOY_FACTORY         =  31,

   257

	IT_PLASTIC_FOUNTAINS   =  32,

   258

	IT_FIZZY_DRINK_FACTORY =  33,

   259

	IT_BUBBLE_GENERATOR    =  34,

   260

	IT_TOFFEE_QUARRY       =  35,

   261

	IT_SUGAR_MINE          =  36,

   262

	IT_END,

   263

	IT_INVALID             = 255,

   264

};

   265

   266

#endif /* INDUSTRY_H */