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

#include "water_map.h"

    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

 * Tests if the industry tile was built on water.

   159

 * @param t the industry tile

   160

 * @return true iff on water

   161

 */

   162

static inline bool IsIndustryTileOnWater(TileIndex t)

   163

{

   164

	assert(IsTileType(t, MP_INDUSTRY));

   165

	return (GetWaterClass(t) != WATER_CLASS_INVALID);

   166

}

   167

   168

/**

   169

 * Make the given tile an industry tile

   170

 * @param t      the tile to make an industry tile

   171

 * @param index  the industry this tile belongs to

   172

 * @param gfx    the graphics to use for the tile

   173

 * @param random the random value

   174

 */

   175

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

   176

{

   177

	SetTileType(t, MP_INDUSTRY);

   178

	_m[t].m1 = 0;

   179

	_m[t].m2 = index;

   180

	_m[t].m3 = 0;

   181

	_m[t].m4 = 0;

   182

	SetIndustryGfx(t, gfx);

   183

	_me[t].m7 = random;

   184

	SetWaterClass(t, wc);

   185

}

   186

   187

/**

   188

 * Returns this indutry tile's construction counter value

   189

 * @param tile the tile to query

   190

 * @pre IsTileType(tile, MP_INDUSTRY)

   191

 * @return the construction counter

   192

 */

   193

static inline byte GetIndustryConstructionCounter(TileIndex tile)

   194

{

   195

	assert(IsTileType(tile, MP_INDUSTRY));

   196

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

   197

}

   198

   199

/**

   200

 * Sets this indutry tile's construction counter value

   201

 * @param tile the tile to query

   202

 * @param value the new value for the construction counter

   203

 * @pre IsTileType(tile, MP_INDUSTRY)

   204

 */

   205

static inline void SetIndustryConstructionCounter(TileIndex tile, byte value)

   206

{

   207

	assert(IsTileType(tile, MP_INDUSTRY));

   208

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

   209

}

   210

   211

/**

   212

 * Reset the construction stage counter of the industry,

   213

 * as well as the completion bit.

   214

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

   215

 * @param tile the tile to query

   216

 * @pre IsTileType(tile, MP_INDUSTRY)

   217

 */

   218

static inline void ResetIndustryConstructionStage(TileIndex tile)

   219

{

   220

	assert(IsTileType(tile, MP_INDUSTRY));

   221

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

   222

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

   223

}

   224

   225

/**

   226

 * Get the animation loop number

   227

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

   228

 * @pre IsTileType(tile, MP_INDUSTRY)

   229

 */

   230

static inline byte GetIndustryAnimationLoop(TileIndex tile)

   231

{

   232

	assert(IsTileType(tile, MP_INDUSTRY));

   233

	return _m[tile].m4;

   234

}

   235

   236

/**

   237

 * Set the animation loop number

   238

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

   239

 * @param count the new animation frame number

   240

 * @pre IsTileType(tile, MP_INDUSTRY)

   241

 */

   242

static inline void SetIndustryAnimationLoop(TileIndex tile, byte count)

   243

{

   244

	assert(IsTileType(tile, MP_INDUSTRY));

   245

	_m[tile].m4 = count;

   246

}

   247

   248

/**

   249

 * Get the animation state

   250

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

   251

 * @pre IsTileType(tile, MP_INDUSTRY)

   252

 */

   253

static inline byte GetIndustryAnimationState(TileIndex tile)

   254

{

   255

	assert(IsTileType(tile, MP_INDUSTRY));

   256

	return _m[tile].m3;

   257

}

   258

   259

/**

   260

 * Set the animation state

   261

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

   262

 * @param state the new animation state

   263

 * @pre IsTileType(tile, MP_INDUSTRY)

   264

 */

   265

static inline void SetIndustryAnimationState(TileIndex tile, byte state)

   266

{

   267

	assert(IsTileType(tile, MP_INDUSTRY));

   268

	_m[tile].m3 = state;

   269

}

   270

   271

/**

   272

 * Get the random bits for this tile.

   273

 * Used for grf callbacks

   274

 * @param tile TileIndex of the tile to query

   275

 * @pre IsTileType(tile, MP_INDUSTRY)

   276

 * @return requested bits

   277

 */

   278

static inline byte GetIndustryRandomBits(TileIndex tile)

   279

{

   280

	assert(IsTileType(tile, MP_INDUSTRY));

   281

	return _me[tile].m7;

   282

}

   283

   284

/**

   285

 * Set the random bits for this tile.

   286

 * Used for grf callbacks

   287

 * @param tile TileIndex of the tile to query

   288

 * @param bits the random bits

   289

 * @pre IsTileType(tile, MP_INDUSTRY)

   290

 */

   291

static inline void SetIndustryRandomBits(TileIndex tile, byte bits)

   292

{

   293

	assert(IsTileType(tile, MP_INDUSTRY));

   294

	_me[tile].m7 = bits;

   295

}

   296

   297

/**

   298

 * Get the activated triggers bits for this industry tile

   299

 * Used for grf callbacks

   300

 * @param tile TileIndex of the tile to query

   301

 * @pre IsTileType(tile, MP_INDUSTRY)

   302

 * @return requested triggers

   303

 */

   304

static inline byte GetIndustryTriggers(TileIndex tile)

   305

{

   306

	assert(IsTileType(tile, MP_INDUSTRY));

   307

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

   308

}

   309

   310

   311

/**

   312

 * Set the activated triggers bits for this industry tile

   313

 * Used for grf callbacks

   314

 * @param tile TileIndex of the tile to query

   315

 * @param triggers the triggers to set

   316

 * @pre IsTileType(tile, MP_INDUSTRY)

   317

 */

   318

static inline void SetIndustryTriggers(TileIndex tile, byte triggers)

   319

{

   320

	assert(IsTileType(tile, MP_INDUSTRY));

   321

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

   322

}

   323

   324

#endif /* INDUSTRY_MAP_H */