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,

    16

	NEW_INDUSTRYOFFSET     = 37,                         ///< original number of industries

    17

	NUM_INDUSTRYTYPES      = 37,                         ///< total number of industries, new and old

    18

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

    19

	NEW_INDUSTRYTILEOFFSET = 175,                        ///< original number of tiles

    20

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

    21

	NUM_INDUSTRYTILES      = NEW_INDUSTRYTILEOFFSET,     ///< total number of industry tiles, new and old

    22

	INVALID_INDUSTRYTILE   = NUM_INDUSTRYTILES,          ///< one above amount is considered invalid

    24

};

    25

    26

enum {

    27

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

    28

	CLEAN_TILELSAYOUT,     ///< Free the dynamically allocated tile layout structure

    29

};

    30

    31

enum IndustryLifeType {

    32

	INDUSTRYLIFE_BLACK_HOLE =      0, ///< Like power plants and banks

    33

	INDUSTRYLIFE_EXTRACTIVE = 1 << 0, ///< Like mines

    34

	INDUSTRYLIFE_ORGANIC    = 1 << 1, ///< Like forests

    35

	INDUSTRYLIFE_PROCESSING = 1 << 2, ///< Like factories

    36

};

    37

    38

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

    39

 * build at location the given to the procedure */

    40

enum CheckProc {

    41

	CHECK_NOTHING,

    42

	CHECK_FOREST,

    43

	CHECK_REFINERY,

    44

	CHECK_FARM,

    45

	CHECK_PLANTATION,

    46

	CHECK_WATER,

    47

	CHECK_LUMBERMILL,

    48

	CHECK_BUBBLEGEN,

    49

	CHECK_OIL_RIG,

    50

	CHECK_END,

    51

};

    52

    53

/** How was the industry created */

    54

enum IndustryConstructionType {

    55

	ICT_UNKNOWN,          ///< in previous game version or without newindustries activated

    56

	ICT_NORMAL_GAMEPLAY,  ///< either by user or random creation proccess

    57

	ICT_MAP_GENERATION,   ///< during random map creation

    58

	ICT_SCENARIO_EDITOR   ///< while scenarion edition

    59

};

    60

    61

/** From where is callback CBID_INDUSTRY_AVAILABLE been called */

    62

enum IndustryAvailabilityCallType {

    63

	IACT_MAPGENERATION,   ///< during random map generation

    64

	IACT_RANDOMCREATION,  ///< during creation of random ingame industry

    65

	IACT_USERCREATION,    ///< from the Fund/build window

    66

};

    67

    68

enum IndustyBehaviour {

    69

	INDUSTRYBEH_NONE                  =      0,

    70

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

    71

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

    72

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

    73

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

    74

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

    75

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

    76

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

    77

	INDUSTRYBEH_DONT_INCR_PROD        = 1 << 7,  ///< do not increase production (oil wells) in the temperate climate

    78

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

    79

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

    80

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

    81

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

    82

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

    83

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

    84

};

    85

    86

    87

DECLARE_ENUM_AS_BIT_SET(IndustyBehaviour);

    88

    89

/**

    90

 * Defines the internal data of a functionnal industry

    91

 */

    92

struct Industry {

    93

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

    94

	byte width;

    95

	byte height;

    96

	const Town *town;                   ///< Nearest town

    97

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

    98

	uint16 incoming_cargo_waiting[3];   ///< incoming cargo waiting to be processed

    99

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

   100

	byte prod_level;                    ///< general production level

   101

	uint16 this_month_production[2];    ///< stats of this month's production per cargo

   102

	uint16 this_month_transported[2];   ///< stats of this month's transport per cargo

   103

	byte last_month_pct_transported[2]; ///< percentage transported per cargo in the last full month

   104

	uint16 last_month_production[2];    ///< total units produced per cargo in the last full month

   105

	uint16 last_month_transported[2];   ///< total units transported per cargo in the last full month

   106

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

   107

   108

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

   109

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

   110

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

   111

	Year last_prod_year;                ///< last year of production

   112

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

   113

   114

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

   115

   116

	OwnerByte founder;                  ///< Founder of the industry

   117

	Date construction_date;             ///< Date of the construction of the industry

   118

	uint8 construction_type;            ///< Way the industry was constructed (@see IndustryConstructionType)

   119

	Date last_cargo_accepted_at;        ///< Last day cargo was accepted by this industry

   120

};

   121

   122

struct IndustryTileTable {

   123

	TileIndexDiffC ti;

   124

	IndustryGfx gfx;

   125

};

   126

   127

/** Data related to the handling of grf files.  Common to both industry and industry tile */

   128

struct GRFFileProps {

   129

	uint8 subst_id;

   130

	uint16 local_id;                      ///< id defined by the grf file for this industry

   131

	struct SpriteGroup *spritegroup;      ///< pointer to the different sprites of the industry

   132

	const struct GRFFile *grffile;        ///< grf file that introduced this industry

   133

	uint16 override;                      ///< id of the entity been replaced by

   134

};

   135

   136

/**

   137

 * Defines the data structure for constructing industry.

   138

 */

   139

struct IndustrySpec {

   140

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

   141

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

   142

	uint8 cost_multiplier;                ///< Base cost multiplier.

   143

	uint16 raw_industry_cost_multiplier;  ///< Multiplier for the raw industries cost

   144

	uint32 prospecting_chance;            ///< Chance prospecting succeeds

   145

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

   146

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

   147

	CargoID produced_cargo[2];

   148

	byte production_rate[2];

   149

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

   150

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

   151

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

   152

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

   153

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

   154

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

   155

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

   156

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

   157

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

   158

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

   159

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

   160

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

   161

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

   162

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

   163

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

   164

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

   165

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

   166

	/* Newgrf data */

   167

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

   168

	uint8 cleanup_flag;                   ///< flags indicating which data should be freed upon cleaning up

   169

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

   170

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

   171

   172

	/**

   173

	 * Is an industry with the spec a raw industry?

   174

	 * @return true if it should be handled as a raw industry

   175

	 */

   176

	bool IsRawIndustry() const;

   177

   178

	/**

   179

	 * Get the cost for constructing this industry

   180

	 * @return the cost (inflation corrected etc)

   181

	 */

   182

	Money GetConstructionCost() const;

   183

};

   184

   185

/**

   186

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

   187

 */

   188

struct IndustryTileSpec {

   189

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

   190

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

   191

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

   192

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

   193

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

   194

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

   195

	                                      ///< state instead of the construction state

   196

	/* Newgrf data */

   197

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

   198

	uint16 animation_info;                ///< Information about the animation (is it looping, how many loops etc)

   199

	uint8 animation_speed;                ///< The speed of the animation

   200

	uint8 animation_triggers;             ///< When to start the animation

   201

	uint8 animation_special_flags;        ///< Extra flags to influence the animation

   202

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

   203

	struct GRFFileProps grf_prop;

   204

};

   205

   206

/* industry_cmd.cpp*/

   207

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

   208

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

   209

void ResetIndustries();

   210

void PlantRandomFarmField(const Industry *i);

   211

   212

/* writable arrays of specs */

   213

extern IndustrySpec _industry_specs[NUM_INDUSTRYTYPES];

   214

extern IndustryTileSpec _industry_tile_specs[NUM_INDUSTRYTILES];

   215

   216

/* smallmap_gui.cpp */

   217

void BuildIndustriesLegend();

   218

   219

DECLARE_OLD_POOL(Industry, Industry, 3, 8000)

   220

   221

/**

   222

 * Check if an Industry really exists.

   223

 * @param industry to check

   224

 * @return true if position is a valid one

   225

 */

   226

static inline bool IsValidIndustry(const Industry *industry)

   227

{

   228

	return industry->xy != 0;

   229

}

   230

   231

/**

   232

 * Check if an Industry exists whithin the pool of industries

   233

 * @param index of the desired industry

   234

 * @return true if it is inside the pool

   235

 */

   236

static inline bool IsValidIndustryID(IndustryID index)

   237

{

   238

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

   239

}

   240

   241

   242

static inline IndustryID GetMaxIndustryIndex()

   243

{

   244

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

   245

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

   246

	 *  _really_ returns the highest index. Now it just returns

   247

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

   248

	 */

   249

	return GetIndustryPoolSize() - 1;

   250

}

   251

   252

extern int _total_industries;  // general counter

   253

extern uint16 _industry_counts[NUM_INDUSTRYTYPES]; // Number of industries per type ingame

   254

   255

static inline uint GetNumIndustries()

   256

{

   257

	return _total_industries;

   258

}

   259

   260

/** Increment the count of industries for this type

   261

 * @param type IndustryType to increment

   262

 * @pre type < INVALID_INDUSTRYTYPE */

   263

static inline void IncIndustryTypeCount(IndustryType type)

   264

{

   265

	assert(type < INVALID_INDUSTRYTYPE);

   266

	_industry_counts[type]++;

   267

	_total_industries++;

   268

}

   269

   270

/** Decrement the count of industries for this type

   271

 * @param type IndustryType to decrement

   272

 * @pre type < INVALID_INDUSTRYTYPE */

   273

static inline void DecIndustryTypeCount(IndustryType type)

   274

{

   275

	assert(type < INVALID_INDUSTRYTYPE);

   276

	_industry_counts[type]--;

   277

	_total_industries--;

   278

}

   279

   280

/** get the count of industries for this type

   281

 * @param type IndustryType to query

   282

 * @pre type < INVALID_INDUSTRYTYPE */

   283

static inline uint8 GetIndustryTypeCount(IndustryType type)

   284

{

   285

	assert(type < INVALID_INDUSTRYTYPE);

   286

	return min(_industry_counts[type], 0xFF); // callback expects only a byte, so cut it

   287

}

   288

   289

/** Resets both the total_industries and the _industry_counts

   290

 * This way, we centralize all counts activities */

   291

static inline void ResetIndustryCounts()

   292

{

   293

	_total_industries = 0;

   294

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

   295

}

   296

   297

/**

   298

 * Return a random valid industry.

   299

 */

   300

static inline Industry *GetRandomIndustry()

   301

{

   302

	int num = RandomRange(GetNumIndustries());

   303

	IndustryID index = INVALID_INDUSTRY;

   304

   305

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

   306

   307

	while (num >= 0) {

   308

		num--;

   309

		index++;

   310

   311

		/* Make sure we have a valid industry */

   312

		while (!IsValidIndustryID(index)) {

   313

			index++;

   314

			assert(index <= GetMaxIndustryIndex());

   315

		}

   316

	}

   317

   318

	return GetIndustry(index);

   319

}

   320

   321

void DestroyIndustry(Industry *i);

   322

   323

static inline void DeleteIndustry(Industry *i)

   324

{

   325

	DestroyIndustry(i);

   326

	i->xy = 0;

   327

}

   328

   329

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

   330

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

   331

   332

extern const Industry **_industry_sort;

   333

extern bool _industry_sort_dirty;

   334

   335

enum {

   336

	IT_COAL_MINE           =   0,

   337

	IT_POWER_STATION       =   1,

   338

	IT_SAWMILL             =   2,

   339

	IT_FOREST              =   3,

   340

	IT_OIL_REFINERY        =   4,

   341

	IT_OIL_RIG             =   5,

   342

	IT_FACTORY             =   6,

   343

	IT_PRINTING_WORKS      =   7,

   344

	IT_STEEL_MILL          =   8,

   345

	IT_FARM                =   9,

   346

	IT_COPPER_MINE         =  10,

   347

	IT_OIL_WELL            =  11,

   348

	IT_BANK_TEMP           =  12,

   349

	IT_FOOD_PROCESS        =  13,

   350

	IT_PAPER_MILL          =  14,

   351

	IT_GOLD_MINE           =  15,

   352

	IT_BANK_TROPIC_ARCTIC  =  16,

   353

	IT_DIAMOND_MINE        =  17,

   354

	IT_IRON_MINE           =  18,

   355

	IT_FRUIT_PLANTATION    =  19,

   356

	IT_RUBBER_PLANTATION   =  20,

   357

	IT_WATER_SUPPLY        =  21,

   358

	IT_WATER_TOWER         =  22,

   359

	IT_FACTORY_2           =  23,

   360

	IT_FARM_2              =  24,

   361

	IT_LUMBER_MILL         =  25,

   362

	IT_COTTON_CANDY        =  26,

   363

	IT_CANDY_FACTORY       =  27,

   364

	IT_BATTERY_FARM        =  28,

   365

	IT_COLA_WELLS          =  29,

   366

	IT_TOY_SHOP            =  30,

   367

	IT_TOY_FACTORY         =  31,

   368

	IT_PLASTIC_FOUNTAINS   =  32,

   369

	IT_FIZZY_DRINK_FACTORY =  33,

   370

	IT_BUBBLE_GENERATOR    =  34,

   371

	IT_TOFFEE_QUARRY       =  35,

   372

	IT_SUGAR_MINE          =  36,

   373

	IT_END,

   374

	IT_INVALID             = 255,

   375

};

   376

   377

#endif /* INDUSTRY_H */