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

/**

    54

 * Get the industry ID of the given tile

    55

 * @param t the tile to get the industry ID from

    56

 * @pre IsTileType(t, MP_INDUSTRY)

    57

 * @return the industry ID

    58

 */

    59

static inline IndustryID GetIndustryIndex(TileIndex t)

    60

{

    61

	assert(IsTileType(t, MP_INDUSTRY));

    62

	return _m[t].m2;

    63

}

    64

    65

/**

    66

 * Get the industry of the given tile

    67

 * @param t the tile to get the industry from

    68

 * @pre IsTileType(t, MP_INDUSTRY)

    69

 * @return the industry

    70

 */

    71

static inline Industry* GetIndustryByTile(TileIndex t)

    72

{

    73

	return GetIndustry(GetIndustryIndex(t));

    74

}

    75

    76

/**

    77

 * Is this industry tile fully built?

    78

 * @param t the tile to analyze

    79

 * @pre IsTileType(t, MP_INDUSTRY)

    80

 * @return true if and only if the industry tile is fully built

    81

 */

    82

static inline bool IsIndustryCompleted(TileIndex t)

    83

{

    84

	assert(IsTileType(t, MP_INDUSTRY));

    85

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

    86

}

    87

    88

IndustryType GetIndustryType(TileIndex tile);

    89

    90

/**

    91

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

    92

 * @param tile the tile to query

    93

 * @param isCompleted whether it is completed or not

    94

 * @pre IsTileType(tile, MP_INDUSTRY)

    95

 */

    96

static inline void SetIndustryCompleted(TileIndex tile, bool isCompleted)

    97

{

    98

	assert(IsTileType(tile, MP_INDUSTRY));

    99

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

   100

}

   101

   102

/**

   103

 * Returns the industry construction stage of the specified tile

   104

 * @param tile the tile to query

   105

 * @pre IsTileType(tile, MP_INDUSTRY)

   106

 * @return the construction stage

   107

 */

   108

static inline byte GetIndustryConstructionStage(TileIndex tile)

   109

{

   110

	assert(IsTileType(tile, MP_INDUSTRY));

   111

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

   112

}

   113

   114

/**

   115

 * Sets the industry construction stage of the specified tile

   116

 * @param tile the tile to query

   117

 * @param value the new construction stage

   118

 * @pre IsTileType(tile, MP_INDUSTRY)

   119

 */

   120

static inline void SetIndustryConstructionStage(TileIndex tile, byte value)

   121

{

   122

	assert(IsTileType(tile, MP_INDUSTRY));

   123

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

   124

}

   125

   126

/**

   127

 * Get the industry graphics ID for the given industry tile

   128

 * @param t the tile to get the gfx for

   129

 * @pre IsTileType(t, MP_INDUSTRY)

   130

 * @return the gfx ID

   131

 */

   132

static inline IndustryGfx GetIndustryGfx(TileIndex t)

   133

{

   134

	assert(IsTileType(t, MP_INDUSTRY));

   135

	return _m[t].m5;

   136

}

   137

   138

/**

   139

 * Set the industry graphics ID for the given industry tile

   140

 * @param t   the tile to set the gfx for

   141

 * @pre IsTileType(t, MP_INDUSTRY)

   142

 * @param gfx the graphics ID

   143

 */

   144

static inline void SetIndustryGfx(TileIndex t, IndustryGfx gfx)

   145

{

   146

	assert(IsTileType(t, MP_INDUSTRY));

   147

	_m[t].m5 = gfx;

   148

}

   149

   150

/**

   151

 * Make the given tile an industry tile

   152

 * @param t     the tile to make an industry tile

   153

 * @param index the industry this tile belongs to

   154

 * @param gfx   the graphics to use for the tile

   155

 */

   156

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

   157

{

   158

	SetTileType(t, MP_INDUSTRY);

   159

	_m[t].m1 = 0;

   160

	_m[t].m2 = index;

   161

	_m[t].m3 = 0;

   162

	_m[t].m4 = 0;

   164

}

   165

   166

/**

   167

 * Returns this indutry tile's construction counter value

   168

 * @param tile the tile to query

   169

 * @pre IsTileType(tile, MP_INDUSTRY)

   170

 * @return the construction counter

   171

 */

   172

static inline byte GetIndustryConstructionCounter(TileIndex tile)

   173

{

   174

	assert(IsTileType(tile, MP_INDUSTRY));

   175

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

   176

}

   177

   178

/**

   179

 * Sets this indutry tile's construction counter value

   180

 * @param tile the tile to query

   181

 * @param value the new value for the construction counter

   182

 * @pre IsTileType(tile, MP_INDUSTRY)

   183

 */

   184

static inline void SetIndustryConstructionCounter(TileIndex tile, byte value)

   185

{

   186

	assert(IsTileType(tile, MP_INDUSTRY));

   187

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

   188

}

   189

   190

/**

   191

 * Reset the construction stage counter of the industry,

   192

 * as well as the completion bit.

   193

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

   194

 * @param tile the tile to query

   195

 * @pre IsTileType(tile, MP_INDUSTRY)

   196

 */

   197

static inline void ResetIndustryConstructionStage(TileIndex tile)

   198

{

   199

	assert(IsTileType(tile, MP_INDUSTRY));

   200

	_m[tile].m1 = 0;

   201

}

   202

   203

/**

   204

 * Get the animation loop number

   205

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

   206

 * @pre IsTileType(tile, MP_INDUSTRY)

   207

 */

   208

static inline byte GetIndustryAnimationLoop(TileIndex tile)

   209

{

   210

	assert(IsTileType(tile, MP_INDUSTRY));

   211

	return _m[tile].m4;

   212

}

   213

   214

/**

   215

 * Set the animation loop number

   216

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

   217

 * @param count the new animation frame number

   218

 * @pre IsTileType(tile, MP_INDUSTRY)

   219

 */

   220

static inline void SetIndustryAnimationLoop(TileIndex tile, byte count)

   221

{

   222

	assert(IsTileType(tile, MP_INDUSTRY));

   223

	_m[tile].m4 = count;

   224

}

   225

   226

/**

   227

 * Get the animation state

   228

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

   229

 * @pre IsTileType(tile, MP_INDUSTRY)

   230

 */

   231

static inline byte GetIndustryAnimationState(TileIndex tile)

   232

{

   233

	assert(IsTileType(tile, MP_INDUSTRY));

   234

	return _m[tile].m3;

   235

}

   236

   237

/**

   238

 * Set the animation state

   239

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

   240

 * @param state the new animation state

   241

 * @pre IsTileType(tile, MP_INDUSTRY)

   242

 */

   243

static inline void SetIndustryAnimationState(TileIndex tile, byte state)

   244

{

   245

	assert(IsTileType(tile, MP_INDUSTRY));

   246

	_m[tile].m3 = state;

   247

}

   248

   290

#endif /* INDUSTRY_MAP_H */