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

typedef uint IndustryGfx;

    13

    14

static inline uint GetIndustryIndex(TileIndex t)

    15

{

    16

	assert(IsTileType(t, MP_INDUSTRY));

    17

	return _m[t].m2;

    18

}

    19

    20

static inline Industry* GetIndustryByTile(TileIndex t)

    21

{

    22

	return GetIndustry(GetIndustryIndex(t));

    23

}

    24

    25

static inline bool IsIndustryCompleted(TileIndex t)

    26

{

    27

	assert(IsTileType(t, MP_INDUSTRY));

    28

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

    29

}

    30

    31

IndustryType GetIndustryType(TileIndex tile);

    32

    33

/**

    34

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

    35

 * @param tile the tile to query

    36

 * @param isCompleted whether it is completed or not

    37

 * @pre IsTileType(tile, MP_INDUSTRY)

    38

 */

    39

static inline void SetIndustryCompleted(TileIndex tile, bool isCompleted)

    40

{

    41

	assert(IsTileType(tile, MP_INDUSTRY));

    42

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

    43

}

    44

    45

/**

    46

 * Returns the industry construction stage of the specified tile

    47

 * @param tile the tile to query

    48

 * @pre IsTileType(tile, MP_INDUSTRY)

    49

 * @return the construction stage

    50

 */

    51

static inline byte GetIndustryConstructionStage(TileIndex tile)

    52

{

    53

	assert(IsTileType(tile, MP_INDUSTRY));

    54

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

    55

}

    56

    57

/**

    58

 * Sets the industry construction stage of the specified tile

    59

 * @param tile the tile to query

    60

 * @param value the new construction stage

    61

 * @pre IsTileType(tile, MP_INDUSTRY)

    62

 */

    63

static inline void SetIndustryConstructionStage(TileIndex tile, byte value)

    64

{

    65

	assert(IsTileType(tile, MP_INDUSTRY));

    66

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

    67

}

    68

    69

static inline IndustryGfx GetIndustryGfx(TileIndex t)

    70

{

    71

	assert(IsTileType(t, MP_INDUSTRY));

    72

	return _m[t].m5;

    73

}

    74

    75

static inline void SetIndustryGfx(TileIndex t, IndustryGfx gfx)

    76

{

    77

	assert(IsTileType(t, MP_INDUSTRY));

    78

	_m[t].m5 = gfx;

    79

}

    80

    81

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

    82

{

    83

	SetTileType(t, MP_INDUSTRY);

    84

	_m[t].m1 = 0;

    85

	_m[t].m2 = index;

    86

	_m[t].m3 = 0;

    87

	_m[t].m4 = 0;

    88

	_m[t].m5 = gfx;

    89

}

    90

    91

/**

    92

 * Returns this indutry tile's construction counter value

    93

 * @param tile the tile to query

    94

 * @pre IsTileType(tile, MP_INDUSTRY)

    95

 * @return the construction counter

    96

 */

    97

static inline byte GetIndustryConstructionCounter(TileIndex tile)

    98

{

    99

	assert(IsTileType(tile, MP_INDUSTRY));

   100

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

   101

}

   102

   103

/**

   104

 * Sets this indutry tile's construction counter value

   105

 * @param tile the tile to query

   106

 * @param value the new value for the construction counter

   107

 * @pre IsTileType(tile, MP_INDUSTRY)

   108

 */

   109

static inline void SetIndustryConstructionCounter(TileIndex tile, byte value)

   110

{

   111

	assert(IsTileType(tile, MP_INDUSTRY));

   112

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

   113

}

   114

   115

/**

   116

 * Reset the construction stage counter of the industry,

   117

 * as well as the completion bit.

   118

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

   119

 * @param tile the tile to query

   120

 * @param generating_world whether generating a world or not

   121

 * @pre IsTileType(tile, MP_INDUSTRY)

   122

 */

   123

static inline void ResetIndustryConstructionStage(TileIndex tile)

   124

{

   125

	assert(IsTileType(tile, MP_INDUSTRY));

   126

	_m[tile].m1 = 0;

   127

}

   128

   129

typedef struct IndustryTypeSolver {

   130

	IndustryGfx MinGfx;

   131

	IndustryGfx MaxGfx;

   132

 } IndustryTypeSolver;

   133

   134

static const IndustryTypeSolver industry_gfx_Solver [IT_END] = {

   135

	{  0,   6}, //IT_COAL_MINE

   136

	{  7,  10}, //IT_POWER_STATION,

   137

	{ 11,  15}, //IT_SAWMILL,

   138

	{ 16,  17}, //IT_FOREST,

   139

	{ 18,  23}, //IT_OIL_REFINERY,

   140

	{ 24,  28}, //IT_OIL_RIG,

   141

	{ 29,  31}, //IT_OIL_WELL,

   142

	{ 32,  38}, //IT_FARM,

   143

	{ 39,  42}, //IT_FACTORY,

   144

	{ 43,  46}, //IT_PRINTING_WORKS,

   145

	{ 47,  51}, //IT_COPPER_MINE,

   146

	{ 52,  57}, //IT_STEEL_MILL,

   147

	{ 58,  59}, //IT_BANK_TEMP,

   148

	{ 60,  63}, //IT_FOOD_PROCESS,

   149

	{ 64,  71}, //IT_PAPER_MILL,

   150

	{ 72,  88}, //IT_GOLD_MINE,

   151

	{ 89,  90}, //IT_BANK_TROPIC_ARCTIC,

   152

	{ 91,  99}, //IT_DIAMOND_MINE,

   153

	{100, 115}, //IT_IRON_MINE,

   154

	{116, 116}, //IT_FRUIT_PLANTATION,

   155

	{117, 117}, //IT_RUBBER_PLANTATION,

   156

	{118, 119}, //IT_WATER_SUPPLY,

   157

	{120, 120}, //IT_WATER_TOWER,

   158

	{121, 124}, //IT_FACTORY_2,

   159

	{125, 128}, //IT_LUMBER_MILL,

   160

	{129, 130}, //IT_COTTON_CANDY,

   161

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

   162

	{135, 136}, //IT_BATTERY_FARM,

   163

	{137, 137}, //IT_COLA_WELLS,

   164

	{138, 141}, //IT_TOY_SHOP,

   165

	{142, 147}, //IT_TOY_FACTORY,

   166

	{148, 155}, //IT_PLASTIC_FOUNTAINS,

   167

	{156, 159}, //IT_FIZZY_DRINK_FACTORY,

   168

	{160, 163}, //IT_BUBBLE_GENERATOR,

   169

	{164, 166}, //IT_TOFFEE_QUARRY,

   170

	{167, 174}  //IT_SUGAR_MINE,

   171

};

   172

   173

#endif /* INDUSTRY_MAP_H */