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

    21

    22

static inline uint GetIndustryIndex(TileIndex t)

    23

{

    24

	assert(IsTileType(t, MP_INDUSTRY));

    25

	return _m[t].m2;

    26

}

    27

    28

static inline Industry* GetIndustryByTile(TileIndex t)

    29

{

    30

	return GetIndustry(GetIndustryIndex(t));

    31

}

    32

    33

static inline bool IsIndustryCompleted(TileIndex t)

    34

{

    35

	assert(IsTileType(t, MP_INDUSTRY));

    36

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

    37

}

    38

    39

IndustryType GetIndustryType(TileIndex tile);

    40

    41

/**

    42

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

    43

 * @param tile the tile to query

    44

 * @param isCompleted whether it is completed or not

    45

 * @pre IsTileType(tile, MP_INDUSTRY)

    46

 */

    47

static inline void SetIndustryCompleted(TileIndex tile, bool isCompleted)

    48

{

    49

	assert(IsTileType(tile, MP_INDUSTRY));

    50

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

    51

}

    52

    53

/**

    54

 * Returns the industry construction stage of the specified tile

    55

 * @param tile the tile to query

    56

 * @pre IsTileType(tile, MP_INDUSTRY)

    57

 * @return the construction stage

    58

 */

    59

static inline byte GetIndustryConstructionStage(TileIndex tile)

    60

{

    61

	assert(IsTileType(tile, MP_INDUSTRY));

    62

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

    63

}

    64

    65

/**

    66

 * Sets the industry construction stage of the specified tile

    67

 * @param tile the tile to query

    68

 * @param value the new construction stage

    69

 * @pre IsTileType(tile, MP_INDUSTRY)

    70

 */

    71

static inline void SetIndustryConstructionStage(TileIndex tile, byte value)

    72

{

    73

	assert(IsTileType(tile, MP_INDUSTRY));

    74

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

    75

}

    76

    77

static inline IndustryGfx GetIndustryGfx(TileIndex t)

    78

{

    79

	assert(IsTileType(t, MP_INDUSTRY));

    80

	return _m[t].m5;

    81

}

    82

    83

static inline void SetIndustryGfx(TileIndex t, IndustryGfx gfx)

    84

{

    85

	assert(IsTileType(t, MP_INDUSTRY));

    86

	_m[t].m5 = gfx;

    87

}

    88

    89

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

    90

{

    91

	SetTileType(t, MP_INDUSTRY);

    92

	_m[t].m1 = 0;

    93

	_m[t].m2 = index;

    94

	_m[t].m3 = 0;

    95

	_m[t].m4 = 0;

    96

	_m[t].m5 = gfx;

    97

}

    98

    99

/**

   100

 * Returns this indutry tile's construction counter value

   101

 * @param tile the tile to query

   102

 * @pre IsTileType(tile, MP_INDUSTRY)

   103

 * @return the construction counter

   104

 */

   105

static inline byte GetIndustryConstructionCounter(TileIndex tile)

   106

{

   107

	assert(IsTileType(tile, MP_INDUSTRY));

   108

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

   109

}

   110

   111

/**

   112

 * Sets this indutry tile's construction counter value

   113

 * @param tile the tile to query

   114

 * @param value the new value for the construction counter

   115

 * @pre IsTileType(tile, MP_INDUSTRY)

   116

 */

   117

static inline void SetIndustryConstructionCounter(TileIndex tile, byte value)

   118

{

   119

	assert(IsTileType(tile, MP_INDUSTRY));

   120

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

   121

}

   122

   123

/**

   124

 * Reset the construction stage counter of the industry,

   125

 * as well as the completion bit.

   126

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

   127

 * @param tile the tile to query

   128

 * @param generating_world whether generating a world or not

   129

 * @pre IsTileType(tile, MP_INDUSTRY)

   130

 */

   131

static inline void ResetIndustryConstructionStage(TileIndex tile)

   132

{

   133

	assert(IsTileType(tile, MP_INDUSTRY));

   134

	_m[tile].m1 = 0;

   135

}

   136

   137

typedef struct IndustryTypeSolver {

   138

	IndustryGfx MinGfx;

   139

	IndustryGfx MaxGfx;

   140

 } IndustryTypeSolver;

   141

   142

static const IndustryTypeSolver industry_gfx_Solver [IT_END] = {

   143

	{  0,   6}, //IT_COAL_MINE

   144

	{  7,  10}, //IT_POWER_STATION,

   145

	{ 11,  15}, //IT_SAWMILL,

   146

	{ 16,  17}, //IT_FOREST,

   147

	{ 18,  23}, //IT_OIL_REFINERY,

   148

	{ 24,  28}, //IT_OIL_RIG,

   149

	{ 29,  31}, //IT_OIL_WELL,

   150

	{ 32,  38}, //IT_FARM,

   151

	{ 39,  42}, //IT_FACTORY,

   152

	{ 43,  46}, //IT_PRINTING_WORKS,

   153

	{ 47,  51}, //IT_COPPER_MINE,

   154

	{ 52,  57}, //IT_STEEL_MILL,

   155

	{ 58,  59}, //IT_BANK_TEMP,

   156

	{ 60,  63}, //IT_FOOD_PROCESS,

   157

	{ 64,  71}, //IT_PAPER_MILL,

   158

	{ 72,  88}, //IT_GOLD_MINE,

   159

	{ 89,  90}, //IT_BANK_TROPIC_ARCTIC,

   160

	{ 91,  99}, //IT_DIAMOND_MINE,

   161

	{100, 115}, //IT_IRON_MINE,

   162

	{116, 116}, //IT_FRUIT_PLANTATION,

   163

	{117, 117}, //IT_RUBBER_PLANTATION,

   164

	{118, 119}, //IT_WATER_SUPPLY,

   165

	{120, 120}, //IT_WATER_TOWER,

   166

	{121, 124}, //IT_FACTORY_2,

   167

	{125, 128}, //IT_LUMBER_MILL,

   168

	{129, 130}, //IT_COTTON_CANDY,

   169

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

   170

	{135, 136}, //IT_BATTERY_FARM,

   171

	{137, 137}, //IT_COLA_WELLS,

   172

	{138, 141}, //IT_TOY_SHOP,

   173

	{142, 147}, //IT_TOY_FACTORY,

   174

	{148, 155}, //IT_PLASTIC_FOUNTAINS,

   175

	{156, 159}, //IT_FIZZY_DRINK_FACTORY,

   176

	{160, 163}, //IT_BUBBLE_GENERATOR,

   177

	{164, 166}, //IT_TOFFEE_QUARRY,

   178

	{167, 174}  //IT_SUGAR_MINE,

   179

};

   180

   181

/**

   182

 * Get the animation loop number

   183

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

   184

 * @pre IsTileType(tile, MP_INDUSTRY

   185

 */

   186

static inline byte GetIndustryAnimationLoop(TileIndex tile)

   187

{

   188

	assert(IsTileType(tile, MP_INDUSTRY));

   189

	return _m[tile].m4;

   190

}

   191

   192

/**

   193

 * Set the animation loop number

   194

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

   195

 * @param count the new animation frame number

   196

 * @pre IsTileType(tile, MP_INDUSTRY

   197

 */

   198

static inline void SetIndustryAnimationLoop(TileIndex tile, byte count)

   199

{

   200

	assert(IsTileType(tile, MP_INDUSTRY));

   201

	_m[tile].m4 = count;

   202

}

   203

   204

#endif /* INDUSTRY_MAP_H */