1

/* $Id$ */

     2

     3

/** @file industry_map.h Accessors for industries */

     4

     5

#ifndef INDUSTRY_MAP_H

     6

#define INDUSTRY_MAP_H

     7

     8

#include "industry.h"

     9

#include "macros.h"

    10

#include "tile.h"

    11

    12

    13

    14

/**

    15

 * The following enums are indices used to know what to draw for this industry tile.

    16

 * They all are pointing toward array _industry_draw_tile_data, in table/industry_land.h

    17

 * How to calculate the correct position ? GFXid << 2 | IndustryStage (0 to 3)

    18

 */

    19

enum {

    20

	GFX_COAL_MINE_TOWER_NOT_ANIMATED   =   0,

    21

	GFX_COAL_MINE_TOWER_ANIMATED       =   1,

    22

	GFX_POWERPLANT_CHIMNEY             =   8,

    23

	GFX_POWERPLANT_SPARKS              =  10,

    24

	GFX_OILRIG_1                       =  24,

    25

	GFX_OILRIG_2                       =  25,

    26

	GFX_OILRIG_3                       =  26,

    27

	GFX_OILRIG_4                       =  27,

    28

	GFX_OILRIG_5                       =  28,

    29

	GFX_OILWELL_NOT_ANIMATED           =  29,

    30

	GFX_OILWELL_ANIMATED_1             =  30,

    31

	GFX_OILWELL_ANIMATED_2             =  31,

    32

	GFX_OILWELL_ANIMATED_3             =  32,

    33

	GFX_COPPER_MINE_TOWER_NOT_ANIMATED =  47,

    34

	GFX_COPPER_MINE_TOWER_ANIMATED     =  48,

    35

	GFX_COPPER_MINE_CHIMNEY            =  49,

    36

	GFX_GOLD_MINE_TOWER_NOT_ANIMATED   =  79,

    37

	GFX_GOLD_MINE_TOWER_ANIMATED       =  88,

    38

	GFX_TOY_FACTORY                    = 143,

    39

	GFX_PLASTIC_FOUNTAIN_ANIMATED_1    = 148,

    40

	GFX_PLASTIC_FOUNTAIN_ANIMATED_2    = 149,

    41

	GFX_PLASTIC_FOUNTAIN_ANIMATED_3    = 150,

    42

	GFX_PLASTIC_FOUNTAIN_ANIMATED_4    = 151,

    43

	GFX_PLASTIC_FOUNTAIN_ANIMATED_5    = 152,

    44

	GFX_PLASTIC_FOUNTAIN_ANIMATED_6    = 153,

    45

	GFX_PLASTIC_FOUNTAIN_ANIMATED_7    = 154,

    46

	GFX_PLASTIC_FOUNTAIN_ANIMATED_8    = 155,

    47

	GFX_BUBBLE_GENERATOR               = 161,

    48

	GFX_BUBBLE_CATCHER                 = 162,

    49

	GFX_TOFFEE_QUARY                   = 165,

    50

	GFX_SUGAR_MINE_SIEVE               = 174,

    51

	NUM_INDUSTRY_GFXES                 = 175,

    52

};

    53

    54

static inline IndustryID GetIndustryIndex(TileIndex t)

    55

{

    56

	assert(IsTileType(t, MP_INDUSTRY));

    57

	return _m[t].m2;

    58

}

    59

    60

static inline Industry* GetIndustryByTile(TileIndex t)

    61

{

    62

	return GetIndustry(GetIndustryIndex(t));

    63

}

    64

    65

static inline bool IsIndustryCompleted(TileIndex t)

    66

{

    67

	assert(IsTileType(t, MP_INDUSTRY));

    68

	return HASBIT(_m[t].m1, 7);

    69

}

    70

    71

IndustryType GetIndustryType(TileIndex tile);

    72

    73

/**

    74

 * Set if the industry that owns the tile as under construction or not

    75

 * @param tile the tile to query

    76

 * @param isCompleted whether it is completed or not

    77

 * @pre IsTileType(tile, MP_INDUSTRY)

    78

 */

    79

static inline void SetIndustryCompleted(TileIndex tile, bool isCompleted)

    80

{

    81

	assert(IsTileType(tile, MP_INDUSTRY));

    82

	SB(_m[tile].m1, 7, 1, isCompleted ? 1 :0);

    83

}

    84

    85

/**

    86

 * Returns the industry construction stage of the specified tile

    87

 * @param tile the tile to query

    88

 * @pre IsTileType(tile, MP_INDUSTRY)

    89

 * @return the construction stage

    90

 */

    91

static inline byte GetIndustryConstructionStage(TileIndex tile)

    92

{

    93

	assert(IsTileType(tile, MP_INDUSTRY));

    94

	return GB(_m[tile].m1, 0, 2);

    95

}

    96

    97

/**

    98

 * Sets the industry construction stage of the specified tile

    99

 * @param tile the tile to query

   100

 * @param value the new construction stage

   101

 * @pre IsTileType(tile, MP_INDUSTRY)

   102

 */

   103

static inline void SetIndustryConstructionStage(TileIndex tile, byte value)

   104

{

   105

	assert(IsTileType(tile, MP_INDUSTRY));

   106

	SB(_m[tile].m1, 0, 2, value);

   107

}

   108

   109

static inline IndustryGfx GetIndustryGfx(TileIndex t)

   110

{

   111

	assert(IsTileType(t, MP_INDUSTRY));

   112

	return _m[t].m5;

   113

}

   114

   115

static inline void SetIndustryGfx(TileIndex t, IndustryGfx gfx)

   116

{

   117

	assert(IsTileType(t, MP_INDUSTRY));

   118

	_m[t].m5 = gfx;

   119

}

   120

   121

static inline void MakeIndustry(TileIndex t, IndustryID index, IndustryGfx gfx)

   122

{

   123

	SetTileType(t, MP_INDUSTRY);

   124

	_m[t].m1 = 0;

   125

	_m[t].m2 = index;

   126

	_m[t].m3 = 0;

   127

	_m[t].m4 = 0;

   128

	_m[t].m5 = gfx;

   129

}

   130

   131

/**

   132

 * Returns this indutry tile's construction counter value

   133

 * @param tile the tile to query

   134

 * @pre IsTileType(tile, MP_INDUSTRY)

   135

 * @return the construction counter

   136

 */

   137

static inline byte GetIndustryConstructionCounter(TileIndex tile)

   138

{

   139

	assert(IsTileType(tile, MP_INDUSTRY));

   140

	return GB(_m[tile].m1, 2, 2);

   141

}

   142

   143

/**

   144

 * Sets this indutry tile's construction counter value

   145

 * @param tile the tile to query

   146

 * @param value the new value for the construction counter

   147

 * @pre IsTileType(tile, MP_INDUSTRY)

   148

 */

   149

static inline void SetIndustryConstructionCounter(TileIndex tile, byte value)

   150

{

   151

	assert(IsTileType(tile, MP_INDUSTRY));

   152

	SB(_m[tile].m1, 2, 2, value);

   153

}

   154

   155

/**

   156

 * Reset the construction stage counter of the industry,

   157

 * as well as the completion bit.

   158

 * In fact, it is the same as restarting construction frmo ground up

   159

 * @param tile the tile to query

   160

 * @param generating_world whether generating a world or not

   161

 * @pre IsTileType(tile, MP_INDUSTRY)

   162

 */

   163

static inline void ResetIndustryConstructionStage(TileIndex tile)

   164

{

   165

	assert(IsTileType(tile, MP_INDUSTRY));

   166

	_m[tile].m1 = 0;

   167

}

   168

   169

typedef struct IndustryTypeSolver {

   170

	IndustryGfx MinGfx;

   171

	IndustryGfx MaxGfx;

   172

} IndustryTypeSolver;

   173

   174

static const IndustryTypeSolver industry_gfx_Solver [IT_END] = {

   175

	{  0,   6}, //IT_COAL_MINE

   176

	{  7,  10}, //IT_POWER_STATION,

   177

	{ 11,  15}, //IT_SAWMILL,

   178

	{ 16,  17}, //IT_FOREST,

   179

	{ 18,  23}, //IT_OIL_REFINERY,

   180

	{ 24,  28}, //IT_OIL_RIG,

   181

	{ 29,  31}, //IT_OIL_WELL,

   182

	{ 32,  38}, //IT_FARM,

   183

	{ 39,  42}, //IT_FACTORY,

   184

	{ 43,  46}, //IT_PRINTING_WORKS,

   185

	{ 47,  51}, //IT_COPPER_MINE,

   186

	{ 52,  57}, //IT_STEEL_MILL,

   187

	{ 58,  59}, //IT_BANK_TEMP,

   188

	{ 60,  63}, //IT_FOOD_PROCESS,

   189

	{ 64,  71}, //IT_PAPER_MILL,

   190

	{ 72,  88}, //IT_GOLD_MINE,

   191

	{ 89,  90}, //IT_BANK_TROPIC_ARCTIC,

   192

	{ 91,  99}, //IT_DIAMOND_MINE,

   193

	{100, 115}, //IT_IRON_MINE,

   194

	{116, 116}, //IT_FRUIT_PLANTATION,

   195

	{117, 117}, //IT_RUBBER_PLANTATION,

   196

	{118, 119}, //IT_WATER_SUPPLY,

   197

	{120, 120}, //IT_WATER_TOWER,

   198

	{121, 124}, //IT_FACTORY_2,

   199

	{125, 128}, //IT_LUMBER_MILL,

   200

	{129, 130}, //IT_COTTON_CANDY,

   201

	{131, 134}, //IT_CANDY_FACTORY or sweet factory

   202

	{135, 136}, //IT_BATTERY_FARM,

   203

	{137, 137}, //IT_COLA_WELLS,

   204

	{138, 141}, //IT_TOY_SHOP,

   205

	{142, 147}, //IT_TOY_FACTORY,

   206

	{148, 155}, //IT_PLASTIC_FOUNTAINS,

   207

	{156, 159}, //IT_FIZZY_DRINK_FACTORY,

   208

	{160, 163}, //IT_BUBBLE_GENERATOR,

   209

	{164, 166}, //IT_TOFFEE_QUARRY,

   210

	{167, 174}  //IT_SUGAR_MINE,

   211

};

   212

   213

/**

   214

 * Get the animation loop number

   215

 * @param tile the tile to get the animation loop number of

   216

 * @pre IsTileType(tile, MP_INDUSTRY)

   217

 */

   218

static inline byte GetIndustryAnimationLoop(TileIndex tile)

   219

{

   220

	assert(IsTileType(tile, MP_INDUSTRY));

   221

	return _m[tile].m4;

   222

}

   223

   224

/**

   225

 * Set the animation loop number

   226

 * @param tile the tile to set the animation loop number of

   227

 * @param count the new animation frame number

   228

 * @pre IsTileType(tile, MP_INDUSTRY)

   229

 */

   230

static inline void SetIndustryAnimationLoop(TileIndex tile, byte count)

   231

{

   232

	assert(IsTileType(tile, MP_INDUSTRY));

   233

	_m[tile].m4 = count;

   234

}

   235

   236

/**

   237

 * Get the animation state

   238

 * @param tile the tile to get the animation state of

   239

 * @pre IsTileType(tile, MP_INDUSTRY)

   240

 */

   241

static inline byte GetIndustryAnimationState(TileIndex tile)

   242

{

   243

	assert(IsTileType(tile, MP_INDUSTRY));

   244

	return _m[tile].m3;

   245

}

   246

   247

/**

   248

 * Set the animation state

   249

 * @param tile the tile to set the animation state of

   250

 * @param count the new animation state

   251

 * @pre IsTileType(tile, MP_INDUSTRY)

   252

 */

   253

static inline void SetIndustryAnimationState(TileIndex tile, byte state)

   254

{

   255

	assert(IsTileType(tile, MP_INDUSTRY));

   256

	_m[tile].m3 = state;

   257

}

   258

   259

#endif /* INDUSTRY_MAP_H */