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 "tile_map.h"

    10

    11

    12

    13

/**

    14

 * The following enums are indices used to know what to draw for this industry tile.

    15

 * They all are pointing toward array _industry_draw_tile_data, in table/industry_land.h

    16

 * How to calculate the correct position ? GFXid << 2 | IndustryStage (0 to 3)

    17

 */

    18

enum {

    19

	GFX_COAL_MINE_TOWER_NOT_ANIMATED   =   0,

    20

	GFX_COAL_MINE_TOWER_ANIMATED       =   1,

    21

	GFX_POWERPLANT_CHIMNEY             =   8,

    22

	GFX_POWERPLANT_SPARKS              =  10,

    23

	GFX_OILRIG_1                       =  24,

    24

	GFX_OILRIG_2                       =  25,

    25

	GFX_OILRIG_3                       =  26,

    26

	GFX_OILRIG_4                       =  27,

    27

	GFX_OILRIG_5                       =  28,

    28

	GFX_OILWELL_NOT_ANIMATED           =  29,

    29

	GFX_OILWELL_ANIMATED_1             =  30,

    30

	GFX_OILWELL_ANIMATED_2             =  31,

    31

	GFX_OILWELL_ANIMATED_3             =  32,

    32

	GFX_COPPER_MINE_TOWER_NOT_ANIMATED =  47,

    33

	GFX_COPPER_MINE_TOWER_ANIMATED     =  48,

    34

	GFX_COPPER_MINE_CHIMNEY            =  49,

    35

	GFX_GOLD_MINE_TOWER_NOT_ANIMATED   =  79,

    36

	GFX_GOLD_MINE_TOWER_ANIMATED       =  88,

    37

	GFX_TOY_FACTORY                    = 143,

    38

	GFX_PLASTIC_FOUNTAIN_ANIMATED_1    = 148,

    39

	GFX_PLASTIC_FOUNTAIN_ANIMATED_2    = 149,

    40

	GFX_PLASTIC_FOUNTAIN_ANIMATED_3    = 150,

    41

	GFX_PLASTIC_FOUNTAIN_ANIMATED_4    = 151,

    42

	GFX_PLASTIC_FOUNTAIN_ANIMATED_5    = 152,

    43

	GFX_PLASTIC_FOUNTAIN_ANIMATED_6    = 153,

    44

	GFX_PLASTIC_FOUNTAIN_ANIMATED_7    = 154,

    45

	GFX_PLASTIC_FOUNTAIN_ANIMATED_8    = 155,

    46

	GFX_BUBBLE_GENERATOR               = 161,

    47

	GFX_BUBBLE_CATCHER                 = 162,

    48

	GFX_TOFFEE_QUARY                   = 165,

    49

	GFX_SUGAR_MINE_SIEVE               = 174,

    50

	GFX_WATERTILE_SPECIALCHECK         = 255,  ///< not really a tile, but rather a very special check

    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 IsIndustryCompleted(tile) ? (byte)INDUSTRY_COMPLETED : 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

static inline IndustryGfx GetCleanIndustryGfx(TileIndex t)

   127

{

   128

	assert(IsTileType(t, MP_INDUSTRY));

   129

	return _m[t].m5 | (GB(_m[t].m6, 2, 1) << 8);

   130

}

   131

   132

/**

   133

 * Get the industry graphics ID for the given industry tile

   134

 * @param t the tile to get the gfx for

   135

 * @pre IsTileType(t, MP_INDUSTRY)

   136

 * @return the gfx ID

   137

 */

   138

static inline IndustryGfx GetIndustryGfx(TileIndex t)

   139

{

   140

	assert(IsTileType(t, MP_INDUSTRY));

   141

	return GetTranslatedIndustryTileID(GetCleanIndustryGfx(t));

   142

}

   143

   144

/**

   145

 * Set the industry graphics ID for the given industry tile

   146

 * @param t   the tile to set the gfx for

   147

 * @pre IsTileType(t, MP_INDUSTRY)

   148

 * @param gfx the graphics ID

   149

 */

   150

static inline void SetIndustryGfx(TileIndex t, IndustryGfx gfx)

   151

{

   152

	assert(IsTileType(t, MP_INDUSTRY));

   153

	_m[t].m5 = GB(gfx, 0, 8);

   154

	SB(_m[t].m6, 2, 1, GB(gfx, 8, 1));

   155

}

   156

   157

/**

   158

 * Make the given tile an industry tile

   159

 * @param t      the tile to make an industry tile

   160

 * @param index  the industry this tile belongs to

   161

 * @param gfx    the graphics to use for the tile

   162

 * @param random the random value

   163

 */

   164

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

   165

{

   166

	SetTileType(t, MP_INDUSTRY);

   167

	_m[t].m1 = 0;

   168

	_m[t].m2 = index;

   169

	_m[t].m3 = 0;

   170

	_m[t].m4 = 0;

   171

	SetIndustryGfx(t, gfx);

   172

	_me[t].m7 = random;

   173

}

   174

   175

/**

   176

 * Returns this indutry tile's construction counter value

   177

 * @param tile the tile to query

   178

 * @pre IsTileType(tile, MP_INDUSTRY)

   179

 * @return the construction counter

   180

 */

   181

static inline byte GetIndustryConstructionCounter(TileIndex tile)

   182

{

   183

	assert(IsTileType(tile, MP_INDUSTRY));

   184

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

   185

}

   186

   187

/**

   188

 * Sets this indutry tile's construction counter value

   189

 * @param tile the tile to query

   190

 * @param value the new value for the construction counter

   191

 * @pre IsTileType(tile, MP_INDUSTRY)

   192

 */

   193

static inline void SetIndustryConstructionCounter(TileIndex tile, byte value)

   194

{

   195

	assert(IsTileType(tile, MP_INDUSTRY));

   196

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

   197

}

   198

   199

/**

   200

 * Reset the construction stage counter of the industry,

   201

 * as well as the completion bit.

   202

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

   203

 * @param tile the tile to query

   204

 * @pre IsTileType(tile, MP_INDUSTRY)

   205

 */

   206

static inline void ResetIndustryConstructionStage(TileIndex tile)

   207

{

   208

	assert(IsTileType(tile, MP_INDUSTRY));

   209

	_m[tile].m1 = 0;

   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

/**

   236

 * Get the animation state

   237

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

   238

 * @pre IsTileType(tile, MP_INDUSTRY)

   239

 */

   240

static inline byte GetIndustryAnimationState(TileIndex tile)

   241

{

   242

	assert(IsTileType(tile, MP_INDUSTRY));

   243

	return _m[tile].m3;

   244

}

   245

   246

/**

   247

 * Set the animation state

   248

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

   249

 * @param state the new animation state

   250

 * @pre IsTileType(tile, MP_INDUSTRY)

   251

 */

   252

static inline void SetIndustryAnimationState(TileIndex tile, byte state)

   253

{

   254

	assert(IsTileType(tile, MP_INDUSTRY));

   255

	_m[tile].m3 = state;

   256

}

   257

   258

/**

   259

 * Get the random bits for this tile.

   260

 * Used for grf callbacks

   261

 * @param tile TileIndex of the tile to query

   262

 * @pre IsTileType(tile, MP_INDUSTRY)

   263

 * @return requested bits

   264

 */

   265

static inline byte GetIndustryRandomBits(TileIndex tile)

   266

{

   267

	assert(IsTileType(tile, MP_INDUSTRY));

   268

	return _me[tile].m7;

   269

}

   270

   271

/**

   272

 * Set the random bits for this tile.

   273

 * Used for grf callbacks

   274

 * @param tile TileIndex of the tile to query

   275

 * @param bits the random bits

   276

 * @pre IsTileType(tile, MP_INDUSTRY)

   277

 */

   278

static inline void SetIndustryRandomBits(TileIndex tile, byte bits)

   279

{

   280

	assert(IsTileType(tile, MP_INDUSTRY));

   281

	_me[tile].m7 = bits;

   282

}

   283

   284

/**

   285

 * Get the activated triggers bits for this industry tile

   286

 * Used for grf callbacks

   287

 * @param tile TileIndex of the tile to query

   288

 * @pre IsTileType(tile, MP_INDUSTRY)

   289

 * @return requested triggers

   290

 */

   291

static inline byte GetIndustryTriggers(TileIndex tile)

   292

{

   293

	assert(IsTileType(tile, MP_INDUSTRY));

   294

	return GB(_m[tile].m6, 3, 3);

   295

}

   296

   297

   298

/**

   299

 * Set the activated triggers bits for this industry tile

   300

 * Used for grf callbacks

   301

 * @param tile TileIndex of the tile to query

   302

 * @param triggers the triggers to set

   303

 * @pre IsTileType(tile, MP_INDUSTRY)

   304

 */

   305

static inline void SetIndustryTriggers(TileIndex tile, byte triggers)

   306

{

   307

	assert(IsTileType(tile, MP_INDUSTRY));

   308

	SB(_m[tile].m6, 3, 3, triggers);

   309

}

   310

   311

#endif /* INDUSTRY_MAP_H */