1

/* $Id$ */

     2

     3

/** @file industry.h */

     4

     5

#ifndef INDUSTRY_H

     6

#define INDUSTRY_H

     7

     8

#include "oldpool.h"

    10

#include "newgrf_storage.h"

    19

    20

enum {

    21

	INVALID_INDUSTRY       = 0xFFFF,

    22

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

    23

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

    24

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

    25

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

    26

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

    27

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

    28

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

    29

	INDUSTRY_COMPLETED     = 3,                          ///< final stage of industry construction.

    30

};

    31

    32

enum {

    33

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

    34

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

    35

};

    36

    37

enum IndustryLifeType {

    38

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

    39

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

    40

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

    41

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

    42

};

    43

    44

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

    45

 * build at location the given to the procedure */

    46

enum CheckProc {

    47

	CHECK_NOTHING,

    48

	CHECK_FOREST,

    49

	CHECK_REFINERY,

    50

	CHECK_FARM,

    51

	CHECK_PLANTATION,

    52

	CHECK_WATER,

    53

	CHECK_LUMBERMILL,

    54

	CHECK_BUBBLEGEN,

    55

	CHECK_OIL_RIG,

    56

	CHECK_END,

    57

};

    58

    59

/** How was the industry created */

    60

enum IndustryConstructionType {

    61

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

    62

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

    63

	ICT_MAP_GENERATION,   ///< during random map creation

    64

	ICT_SCENARIO_EDITOR   ///< while scenarion edition

    65

};

    66

    67

enum IndustryBehaviour {

    68

	INDUSTRYBEH_NONE                  =      0,

    69

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

    70

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

    71

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

    72

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

    73

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

    74

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

    75

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

    76

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

    77

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

    78

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

    79

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

    80

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

    81

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

    82

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

    83

	/* The following flags are only used for newindustries and do no represent any normal behaviour */

    84

	INDUSTRYBEH_PROD_MULTI_HNDLING    = 1 << 14, ///< Automatic production multiplier handling

    85

	INDUSTRYBEH_PRODCALLBACK_RANDOM   = 1 << 15, ///< Production callback needs random bits in var 10

    86

	INDUSTRYBEH_NOBUILT_MAPCREATION   = 1 << 16, ///< Do not force one instance of this type to appear on map generation

    87

	INDUSTRYBEH_CANCLOSE_LASTINSTANCE = 1 << 17, ///< Allow closing down the last instance of this type

    88

};

    89

    90

    91

DECLARE_ENUM_AS_BIT_SET(IndustryBehaviour);

    92

    93

DECLARE_OLD_POOL(Industry, Industry, 3, 8000)

    94

    95

/**

    96

 * Defines the internal data of a functionnal industry

    97

 */

    98

struct Industry : PoolItem<Industry, IndustryID, &_Industry_pool> {

    99

	typedef PersistentStorageArray<uint32, 16> PersistentStorage;

   100

   101

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

   102

	byte width;

   103

	byte height;

   104

	const Town *town;                   ///< Nearest town

   105

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

   106

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

   107

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

   108

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

   109

	byte prod_level;                    ///< general production level

   110

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

   111

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

   112

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

   113

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

   114

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

   115

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

   116

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

   117

   118

	IndustryType type;                  ///< type of industry.

   119

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

   120

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

   121

	Year last_prod_year;                ///< last year of production

   122

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

   123

   124

	OwnerByte founder;                  ///< Founder of the industry

   125

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

   126

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

   127

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

   128

	byte selected_layout;               ///< Which tile layout was used when creating the industry

   129

   130

	byte random_triggers;               ///< Triggers for the random

   131

	uint16 random;                      ///< Random value used for randomisation of all kinds of things

   132

   133

	PersistentStorage psa;              ///< Persistent storage for NewGRF industries.

   134

   135

	Industry(TileIndex tile = 0) : xy(tile) {}

   136

	~Industry();

   137

   138

	inline bool IsValid() const { return this->xy != 0; }

   139

};

   140

   141

struct IndustryTileTable {

   142

	TileIndexDiffC ti;

   143

	IndustryGfx gfx;

   144

};

   145

   146

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

   147

struct GRFFileProps {

   148

	uint16 subst_id;

   149

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

   150

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

   151

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

   152

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

   153

};

   154

   155

/**

   156

 * Defines the data structure for constructing industry.

   157

 */

   158

struct IndustrySpec {

   159

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

   160

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

   161

	uint8 cost_multiplier;                ///< Base construction cost multiplier.

   162

	uint32 removal_cost_multiplier;       ///< Base removal cost multiplier.

   163

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

   164

	uint32 prospecting_chance;            ///< Chance prospecting succeeds

   165

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

   166

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

   167

	CargoID produced_cargo[2];

   168

	byte production_rate[2];

   169

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

   170

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

   171

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

   172

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

   173

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

   174

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

   175

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

   176

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

   182

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

   183

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

   184

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

   185

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

   186

	/* Newgrf data */

   187

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

   188

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

   189

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

   190

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

   191

   192

	/**

   193

	 * Is an industry with the spec a raw industry?

   194

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

   195

	 */

   196

	bool IsRawIndustry() const;

   197

   198

	/**

   199

	 * Get the cost for constructing this industry

   200

	 * @return the cost (inflation corrected etc)

   201

	 */

   202

	Money GetConstructionCost() const;

   203

   204

	/**

   205

	 * Get the cost for removing this industry

   206

	 * Take note that the cost will always be zero for non-grf industries.

   207

	 * Only if the grf author did specified a cost will it be applicable.

   208

	 * @return the cost (inflation corrected etc)

   209

	 */

   210

	Money GetRemovalCost() const;

   211

};

   212

   213

/**

   214

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

   215

 */

   216

struct IndustryTileSpec {

   217

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

   218

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

   219

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

   220

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

   221

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

   222

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

   223

	                                      ///< state instead of the construction state

   224

	/* Newgrf data */

   225

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

   226

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

   227

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

   228

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

   229

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

   230

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

   231

	struct GRFFileProps grf_prop;

   232

};

   233

   234

/* industry_cmd.cpp*/

   235

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

   236

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

   237

void ResetIndustries();

   238

void PlantRandomFarmField(const Industry *i);

   239

   240

/* writable arrays of specs */

   241

extern IndustrySpec _industry_specs[NUM_INDUSTRYTYPES];

   242

extern IndustryTileSpec _industry_tile_specs[NUM_INDUSTRYTILES];

   243

   244

static inline IndustryGfx GetTranslatedIndustryTileID(IndustryGfx gfx)

   245

{

   246

	/* the 0xFF should be GFX_WATERTILE_SPECIALCHECK but for reasons of include mess,

   247

	 * we'll simplify the writing.

   248

	 * Basically, the first test is required since the GFX_WATERTILE_SPECIALCHECK value

   249

	 * will never be assigned as a tile index and is only required in order to do some

   250

	 * tests while building the industry (as in WATER REQUIRED */

   251

	if (gfx != 0xFF) {

   252

		assert(gfx < INVALID_INDUSTRYTILE);

   253

		const IndustryTileSpec *it = &_industry_tile_specs[gfx];

   254

		return it->grf_prop.override == INVALID_INDUSTRYTILE ? gfx : it->grf_prop.override;

   255

	} else {

   256

		return gfx;

   257

	}

   258

}

   259

   260

/* smallmap_gui.cpp */

   261

void BuildIndustriesLegend();

   262

   263

/**

   264

 * Check if an Industry exists whithin the pool of industries

   265

 * @param index of the desired industry

   266

 * @return true if it is inside the pool

   267

 */

   268

static inline bool IsValidIndustryID(IndustryID index)

   269

{

   270

	return index < GetIndustryPoolSize() && GetIndustry(index)->IsValid();

   271

}

   272

   273

   274

static inline IndustryID GetMaxIndustryIndex()

   275

{

   276

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

   277

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

   278

	 *  _really_ returns the highest index. Now it just returns

   279

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

   280

	 */

   281

	return GetIndustryPoolSize() - 1;

   282

}

   283

   284

extern int _total_industries;  // general counter

   285

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

   286

   287

static inline uint GetNumIndustries()

   288

{

   289

	return _total_industries;

   290

}

   291

   292

/** Increment the count of industries for this type

   293

 * @param type IndustryType to increment

   294

 * @pre type < INVALID_INDUSTRYTYPE */

   295

static inline void IncIndustryTypeCount(IndustryType type)

   296

{

   297

	assert(type < INVALID_INDUSTRYTYPE);

   298

	_industry_counts[type]++;

   299

	_total_industries++;

   300

}

   301

   302

/** Decrement the count of industries for this type

   303

 * @param type IndustryType to decrement

   304

 * @pre type < INVALID_INDUSTRYTYPE */

   305

static inline void DecIndustryTypeCount(IndustryType type)

   306

{

   307

	assert(type < INVALID_INDUSTRYTYPE);

   308

	_industry_counts[type]--;

   309

	_total_industries--;

   310

}

   311

   312

/** get the count of industries for this type

   313

 * @param type IndustryType to query

   314

 * @pre type < INVALID_INDUSTRYTYPE */

   315

static inline uint8 GetIndustryTypeCount(IndustryType type)

   316

{

   317

	assert(type < INVALID_INDUSTRYTYPE);

   318

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

   319

}

   320

   321

/** Resets both the total_industries and the _industry_counts

   322

 * This way, we centralize all counts activities */

   323

static inline void ResetIndustryCounts()

   324

{

   325

	_total_industries = 0;

   326

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

   327

}

   328

   329

/**

   330

 * Return a random valid industry.

   331

 */

   332

static inline Industry *GetRandomIndustry()

   333

{

   334

	int num = RandomRange(GetNumIndustries());

   335

	IndustryID index = INVALID_INDUSTRY;

   336

   337

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

   338

   339

	while (num >= 0) {

   340

		num--;

   341

		index++;

   342

   343

		/* Make sure we have a valid industry */

   344

		while (!IsValidIndustryID(index)) {

   345

			index++;

   346

			assert(index <= GetMaxIndustryIndex());

   347

		}

   348

	}

   349

   350

	return GetIndustry(index);

   351

}

   352

   353

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

   354

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

   355

   356

extern const Industry **_industry_sort;

   357

extern bool _industry_sort_dirty;

   358

   359

static const uint8 IT_INVALID = 255;

   360

   361

#endif /* INDUSTRY_H */