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

};

    52

    53

static inline IndustryID GetIndustryIndex(TileIndex t)

    54

{

    55

	assert(IsTileType(t, MP_INDUSTRY));

    56

	return _m[t].m2;

    57

}

    58

    59

static inline Industry* GetIndustryByTile(TileIndex t)

    60

{

    61

	return GetIndustry(GetIndustryIndex(t));

    62

}

    63

    64

static inline bool IsIndustryCompleted(TileIndex t)

    65

{

    66

	assert(IsTileType(t, MP_INDUSTRY));

    67

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

    68

}

    69

    70

IndustryType GetIndustryType(TileIndex tile);

    71

    72

/**

    73

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

    74

 * @param tile the tile to query

    75

 * @param isCompleted whether it is completed or not

    76

 * @pre IsTileType(tile, MP_INDUSTRY)

    77

 */

    78

static inline void SetIndustryCompleted(TileIndex tile, bool isCompleted)

    79

{

    80

	assert(IsTileType(tile, MP_INDUSTRY));

    81

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

    82

}

    83

    84

/**

    85

 * Returns the industry construction stage of the specified tile

    86

 * @param tile the tile to query

    87

 * @pre IsTileType(tile, MP_INDUSTRY)

    88

 * @return the construction stage

    89

 */

    90

static inline byte GetIndustryConstructionStage(TileIndex tile)

    91

{

    92

	assert(IsTileType(tile, MP_INDUSTRY));

    93

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

    94

}

    95

    96

/**

    97

 * Sets the industry construction stage of the specified tile

    98

 * @param tile the tile to query

    99

 * @param value the new construction stage

   100

 * @pre IsTileType(tile, MP_INDUSTRY)

   101

 */

   102

static inline void SetIndustryConstructionStage(TileIndex tile, byte value)

   103

{

   104

	assert(IsTileType(tile, MP_INDUSTRY));

   105

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

   106

}

   107

   108

static inline IndustryGfx GetIndustryGfx(TileIndex t)

   109

{

   110

	assert(IsTileType(t, MP_INDUSTRY));

   111

	return _m[t].m5;

   112

}

   113

   114

static inline void SetIndustryGfx(TileIndex t, IndustryGfx gfx)

   115

{

   116

	assert(IsTileType(t, MP_INDUSTRY));

   117

	_m[t].m5 = gfx;

   118

}

   119

   120

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

   121

{

   122

	SetTileType(t, MP_INDUSTRY);

   123

	_m[t].m1 = 0;

   124

	_m[t].m2 = index;

   125

	_m[t].m3 = 0;

   126

	_m[t].m4 = 0;

   127

	_m[t].m5 = gfx;

   128

}

   129

   130

/**

   131

 * Returns this indutry tile's construction counter value

   132

 * @param tile the tile to query

   133

 * @pre IsTileType(tile, MP_INDUSTRY)

   134

 * @return the construction counter

   135

 */

   136

static inline byte GetIndustryConstructionCounter(TileIndex tile)

   137

{

   138

	assert(IsTileType(tile, MP_INDUSTRY));

   139

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

   140

}

   141

   142

/**

   143

 * Sets this indutry tile's construction counter value

   144

 * @param tile the tile to query

   145

 * @param value the new value for the construction counter

   146

 * @pre IsTileType(tile, MP_INDUSTRY)

   147

 */

   148

static inline void SetIndustryConstructionCounter(TileIndex tile, byte value)

   149

{

   150

	assert(IsTileType(tile, MP_INDUSTRY));

   151

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

   152

}

   153

   154

/**

   155

 * Reset the construction stage counter of the industry,

   156

 * as well as the completion bit.

   157

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

   158

 * @param tile the tile to query

   159

 * @param generating_world whether generating a world or not

   160

 * @pre IsTileType(tile, MP_INDUSTRY)

   161

 */

   162

static inline void ResetIndustryConstructionStage(TileIndex tile)

   163

{

   164

	assert(IsTileType(tile, MP_INDUSTRY));

   165

	_m[tile].m1 = 0;

   166

}

   167

   168

typedef struct IndustryTypeSolver {

   169

	IndustryGfx MinGfx;

   170

	IndustryGfx MaxGfx;

   171

} IndustryTypeSolver;

   172

   173

static const IndustryTypeSolver industry_gfx_Solver [IT_END] = {

   174

	{  0,   6}, //IT_COAL_MINE

   175

	{  7,  10}, //IT_POWER_STATION,

   176

	{ 11,  15}, //IT_SAWMILL,

   177

	{ 16,  17}, //IT_FOREST,

   178

	{ 18,  23}, //IT_OIL_REFINERY,

   179

	{ 24,  28}, //IT_OIL_RIG,

   180

	{ 29,  31}, //IT_OIL_WELL,

   181

	{ 32,  38}, //IT_FARM,

   182

	{ 39,  42}, //IT_FACTORY,

   183

	{ 43,  46}, //IT_PRINTING_WORKS,

   184

	{ 47,  51}, //IT_COPPER_MINE,

   185

	{ 52,  57}, //IT_STEEL_MILL,

   186

	{ 58,  59}, //IT_BANK_TEMP,

   187

	{ 60,  63}, //IT_FOOD_PROCESS,

   188

	{ 64,  71}, //IT_PAPER_MILL,

   189

	{ 72,  88}, //IT_GOLD_MINE,

   190

	{ 89,  90}, //IT_BANK_TROPIC_ARCTIC,

   191

	{ 91,  99}, //IT_DIAMOND_MINE,

   192

	{100, 115}, //IT_IRON_MINE,

   193

	{116, 116}, //IT_FRUIT_PLANTATION,

   194

	{117, 117}, //IT_RUBBER_PLANTATION,

   195

	{118, 119}, //IT_WATER_SUPPLY,

   196

	{120, 120}, //IT_WATER_TOWER,

   197

	{121, 124}, //IT_FACTORY_2,

   198

	{125, 128}, //IT_LUMBER_MILL,

   199

	{129, 130}, //IT_COTTON_CANDY,

   200

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

   201

	{135, 136}, //IT_BATTERY_FARM,

   202

	{137, 137}, //IT_COLA_WELLS,

   203

	{138, 141}, //IT_TOY_SHOP,

   204

	{142, 147}, //IT_TOY_FACTORY,

   205

	{148, 155}, //IT_PLASTIC_FOUNTAINS,

   206

	{156, 159}, //IT_FIZZY_DRINK_FACTORY,

   207

	{160, 163}, //IT_BUBBLE_GENERATOR,

   208

	{164, 166}, //IT_TOFFEE_QUARRY,

   209

	{167, 174}  //IT_SUGAR_MINE,

   210

};

   211

   212

/**

   213

 * Get the animation loop number

   214

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

   215

 * @pre IsTileType(tile, MP_INDUSTRY

   216

 */

   217

static inline byte GetIndustryAnimationLoop(TileIndex tile)

   218

{

   219

	assert(IsTileType(tile, MP_INDUSTRY));

   220

	return _m[tile].m4;

   221

}

   222

   223

/**

   224

 * Set the animation loop number

   225

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

   226

 * @param count the new animation frame number

   227

 * @pre IsTileType(tile, MP_INDUSTRY

   228

 */

   229

static inline void SetIndustryAnimationLoop(TileIndex tile, byte count)

   230

{

   231

	assert(IsTileType(tile, MP_INDUSTRY));

   232

	_m[tile].m4 = count;

   233

}

   234

   235

#endif /* INDUSTRY_MAP_H */