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_POWERPLANT_SPARKS =  10,

    21

	GFX_OILWELL_BASE      =  29,

    22

	GFX_OILWELL_ANIM1     =  30,

    23

	GFX_OILWELL_ANIM2     =  31,

    24

	GFX_OILWELL_ANIM3     =  32,

    25

	GFX_BUBBLE_CATCHER    = 162,

    26

	GFX_TOFFEE_QUARY      = 165,

    27

	GFX_SUGAR_MINE_SIEVE  = 174,

    28

	GFX_TOY_FACTORY       = 143

    29

};

    30

    31

static inline uint GetIndustryIndex(TileIndex t)

    32

{

    33

	assert(IsTileType(t, MP_INDUSTRY));

    34

	return _m[t].m2;

    35

}

    36

    37

static inline Industry* GetIndustryByTile(TileIndex t)

    38

{

    39

	return GetIndustry(GetIndustryIndex(t));

    40

}

    41

    42

static inline bool IsIndustryCompleted(TileIndex t)

    43

{

    44

	assert(IsTileType(t, MP_INDUSTRY));

    45

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

    46

}

    47

    48

IndustryType GetIndustryType(TileIndex tile);

    49

    50

/**

    51

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

    52

 * @param tile the tile to query

    53

 * @param isCompleted whether it is completed or not

    54

 * @pre IsTileType(tile, MP_INDUSTRY)

    55

 */

    56

static inline void SetIndustryCompleted(TileIndex tile, bool isCompleted)

    57

{

    58

	assert(IsTileType(tile, MP_INDUSTRY));

    59

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

    60

}

    61

    62

/**

    63

 * Returns the industry construction stage of the specified tile

    64

 * @param tile the tile to query

    65

 * @pre IsTileType(tile, MP_INDUSTRY)

    66

 * @return the construction stage

    67

 */

    68

static inline byte GetIndustryConstructionStage(TileIndex tile)

    69

{

    70

	assert(IsTileType(tile, MP_INDUSTRY));

    71

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

    72

}

    73

    74

/**

    75

 * Sets the industry construction stage of the specified tile

    76

 * @param tile the tile to query

    77

 * @param value the new construction stage

    78

 * @pre IsTileType(tile, MP_INDUSTRY)

    79

 */

    80

static inline void SetIndustryConstructionStage(TileIndex tile, byte value)

    81

{

    82

	assert(IsTileType(tile, MP_INDUSTRY));

    83

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

    84

}

    85

    86

static inline IndustryGfx GetIndustryGfx(TileIndex t)

    87

{

    88

	assert(IsTileType(t, MP_INDUSTRY));

    89

	return _m[t].m5;

    90

}

    91

    92

static inline void SetIndustryGfx(TileIndex t, IndustryGfx gfx)

    93

{

    94

	assert(IsTileType(t, MP_INDUSTRY));

    95

	_m[t].m5 = gfx;

    96

}

    97

    98

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

    99

{

   100

	SetTileType(t, MP_INDUSTRY);

   101

	_m[t].m1 = 0;

   102

	_m[t].m2 = index;

   103

	_m[t].m3 = 0;

   104

	_m[t].m4 = 0;

   105

	_m[t].m5 = gfx;

   106

}

   107

   108

/**

   109

 * Returns this indutry tile's construction counter value

   110

 * @param tile the tile to query

   111

 * @pre IsTileType(tile, MP_INDUSTRY)

   112

 * @return the construction counter

   113

 */

   114

static inline byte GetIndustryConstructionCounter(TileIndex tile)

   115

{

   116

	assert(IsTileType(tile, MP_INDUSTRY));

   117

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

   118

}

   119

   120

/**

   121

 * Sets this indutry tile's construction counter value

   122

 * @param tile the tile to query

   123

 * @param value the new value for the construction counter

   124

 * @pre IsTileType(tile, MP_INDUSTRY)

   125

 */

   126

static inline void SetIndustryConstructionCounter(TileIndex tile, byte value)

   127

{

   128

	assert(IsTileType(tile, MP_INDUSTRY));

   129

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

   130

}

   131

   132

/**

   133

 * Reset the construction stage counter of the industry,

   134

 * as well as the completion bit.

   135

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

   136

 * @param tile the tile to query

   137

 * @param generating_world whether generating a world or not

   138

 * @pre IsTileType(tile, MP_INDUSTRY)

   139

 */

   140

static inline void ResetIndustryConstructionStage(TileIndex tile)

   141

{

   142

	assert(IsTileType(tile, MP_INDUSTRY));

   143

	_m[tile].m1 = 0;

   144

}

   145

   146

typedef struct IndustryTypeSolver {

   147

	IndustryGfx MinGfx;

   148

	IndustryGfx MaxGfx;

   149

 } IndustryTypeSolver;

   150

   151

static const IndustryTypeSolver industry_gfx_Solver [IT_END] = {

   152

	{  0,   6}, //IT_COAL_MINE

   153

	{  7,  10}, //IT_POWER_STATION,

   154

	{ 11,  15}, //IT_SAWMILL,

   155

	{ 16,  17}, //IT_FOREST,

   156

	{ 18,  23}, //IT_OIL_REFINERY,

   157

	{ 24,  28}, //IT_OIL_RIG,

   158

	{ 29,  31}, //IT_OIL_WELL,

   159

	{ 32,  38}, //IT_FARM,

   160

	{ 39,  42}, //IT_FACTORY,

   161

	{ 43,  46}, //IT_PRINTING_WORKS,

   162

	{ 47,  51}, //IT_COPPER_MINE,

   163

	{ 52,  57}, //IT_STEEL_MILL,

   164

	{ 58,  59}, //IT_BANK_TEMP,

   165

	{ 60,  63}, //IT_FOOD_PROCESS,

   166

	{ 64,  71}, //IT_PAPER_MILL,

   167

	{ 72,  88}, //IT_GOLD_MINE,

   168

	{ 89,  90}, //IT_BANK_TROPIC_ARCTIC,

   169

	{ 91,  99}, //IT_DIAMOND_MINE,

   170

	{100, 115}, //IT_IRON_MINE,

   171

	{116, 116}, //IT_FRUIT_PLANTATION,

   172

	{117, 117}, //IT_RUBBER_PLANTATION,

   173

	{118, 119}, //IT_WATER_SUPPLY,

   174

	{120, 120}, //IT_WATER_TOWER,

   175

	{121, 124}, //IT_FACTORY_2,

   176

	{125, 128}, //IT_LUMBER_MILL,

   177

	{129, 130}, //IT_COTTON_CANDY,

   178

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

   179

	{135, 136}, //IT_BATTERY_FARM,

   180

	{137, 137}, //IT_COLA_WELLS,

   181

	{138, 141}, //IT_TOY_SHOP,

   182

	{142, 147}, //IT_TOY_FACTORY,

   183

	{148, 155}, //IT_PLASTIC_FOUNTAINS,

   184

	{156, 159}, //IT_FIZZY_DRINK_FACTORY,

   185

	{160, 163}, //IT_BUBBLE_GENERATOR,

   186

	{164, 166}, //IT_TOFFEE_QUARRY,

   187

	{167, 174}  //IT_SUGAR_MINE,

   188

};

   189

   190

/**

   191

 * Get the animation loop number

   192

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

   193

 * @pre IsTileType(tile, MP_INDUSTRY

   194

 */

   195

static inline byte GetIndustryAnimationLoop(TileIndex tile)

   196

{

   197

	assert(IsTileType(tile, MP_INDUSTRY));

   198

	return _m[tile].m4;

   199

}

   200

   201

/**

   202

 * Set the animation loop number

   203

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

   204

 * @param count the new animation frame number

   205

 * @pre IsTileType(tile, MP_INDUSTRY

   206

 */

   207

static inline void SetIndustryAnimationLoop(TileIndex tile, byte count)

   208

{

   209

	assert(IsTileType(tile, MP_INDUSTRY));

   210

	_m[tile].m4 = count;

   211

}

   212

   213

#endif /* INDUSTRY_MAP_H */