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

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

    52

};

    53

    54

/**

    55

 * Get the industry ID of the given tile

    56

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

    57

 * @pre IsTileType(t, MP_INDUSTRY)

    58

 * @return the industry ID

    59

 */

    60

static inline IndustryID GetIndustryIndex(TileIndex t)

    61

{

    62

	assert(IsTileType(t, MP_INDUSTRY));

    63

	return _m[t].m2;

    64

}

    65

    66

/**

    67

 * Get the industry of the given tile

    68

 * @param t the tile to get the industry from

    69

 * @pre IsTileType(t, MP_INDUSTRY)

    70

 * @return the industry

    71

 */

    72

static inline Industry *GetIndustryByTile(TileIndex t)

    73

{

    74

	return GetIndustry(GetIndustryIndex(t));

    75

}

    76

    77

/**

    78

 * Is this industry tile fully built?

    79

 * @param t the tile to analyze

    80

 * @pre IsTileType(t, MP_INDUSTRY)

    81

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

    82

 */

    83

static inline bool IsIndustryCompleted(TileIndex t)

    84

{

    85

	assert(IsTileType(t, MP_INDUSTRY));

    86

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

    87

}

    88

    89

IndustryType GetIndustryType(TileIndex tile);

    90

    91

/**

    92

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

    93

 * @param tile the tile to query

    94

 * @param isCompleted whether it is completed or not

    95

 * @pre IsTileType(tile, MP_INDUSTRY)

    96

 */

    97

static inline void SetIndustryCompleted(TileIndex tile, bool isCompleted)

    98

{

    99

	assert(IsTileType(tile, MP_INDUSTRY));

   100

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

   101

}

   102

   103

/**

   104

 * Returns the industry construction stage of the specified tile

   105

 * @param tile the tile to query

   106

 * @pre IsTileType(tile, MP_INDUSTRY)

   107

 * @return the construction stage

   108

 */

   109

static inline byte GetIndustryConstructionStage(TileIndex tile)

   110

{

   111

	assert(IsTileType(tile, MP_INDUSTRY));

   112

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

   113

}

   114

   115

/**

   116

 * Sets the industry construction stage of the specified tile

   117

 * @param tile the tile to query

   118

 * @param value the new construction stage

   119

 * @pre IsTileType(tile, MP_INDUSTRY)

   120

 */

   121

static inline void SetIndustryConstructionStage(TileIndex tile, byte value)

   122

{

   123

	assert(IsTileType(tile, MP_INDUSTRY));

   124

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

   125

}

   126

   127

/**

   128

 * Get the industry graphics ID for the given industry tile

   129

 * @param t the tile to get the gfx for

   130

 * @pre IsTileType(t, MP_INDUSTRY)

   131

 * @return the gfx ID

   132

 */

   133

static inline IndustryGfx GetIndustryGfx(TileIndex t)

   134

{

   135

	assert(IsTileType(t, MP_INDUSTRY));

   136

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

   137

}

   138

   139

/**

   140

 * Set the industry graphics ID for the given industry tile

   141

 * @param t   the tile to set the gfx for

   142

 * @pre IsTileType(t, MP_INDUSTRY)

   143

 * @param gfx the graphics ID

   144

 */

   145

static inline void SetIndustryGfx(TileIndex t, IndustryGfx gfx)

   146

{

   147

	assert(IsTileType(t, MP_INDUSTRY));

   148

	_m[t].m5 = gfx;

   149

}

   150

   151

/**

   152

 * Make the given tile an industry tile

   153

 * @param t     the tile to make an industry tile

   154

 * @param index the industry this tile belongs to

   155

 * @param gfx   the graphics to use for the tile

   156

 */

   157

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

   158

{

   159

	SetTileType(t, MP_INDUSTRY);

   160

	_m[t].m1 = 0;

   161

	_m[t].m2 = index;

   162

	_m[t].m3 = 0;

   163

	_m[t].m4 = 0;

   164

	SetIndustryGfx(t, gfx);

   165

}

   166

   167

/**

   168

 * Returns this indutry tile's construction counter value

   169

 * @param tile the tile to query

   170

 * @pre IsTileType(tile, MP_INDUSTRY)

   171

 * @return the construction counter

   172

 */

   173

static inline byte GetIndustryConstructionCounter(TileIndex tile)

   174

{

   175

	assert(IsTileType(tile, MP_INDUSTRY));

   176

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

   177

}

   178

   179

/**

   180

 * Sets this indutry tile's construction counter value

   181

 * @param tile the tile to query

   182

 * @param value the new value for the construction counter

   183

 * @pre IsTileType(tile, MP_INDUSTRY)

   184

 */

   185

static inline void SetIndustryConstructionCounter(TileIndex tile, byte value)

   186

{

   187

	assert(IsTileType(tile, MP_INDUSTRY));

   188

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

   189

}

   190

   191

/**

   192

 * Reset the construction stage counter of the industry,

   193

 * as well as the completion bit.

   194

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

   195

 * @param tile the tile to query

   196

 * @pre IsTileType(tile, MP_INDUSTRY)

   197

 */

   198

static inline void ResetIndustryConstructionStage(TileIndex tile)

   199

{

   200

	assert(IsTileType(tile, MP_INDUSTRY));

   201

	_m[tile].m1 = 0;

   202

}

   203

   204

/**

   205

 * Get the animation loop number

   206

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

   207

 * @pre IsTileType(tile, MP_INDUSTRY)

   208

 */

   209

static inline byte GetIndustryAnimationLoop(TileIndex tile)

   210

{

   211

	assert(IsTileType(tile, MP_INDUSTRY));

   212

	return _m[tile].m4;

   213

}

   214

   215

/**

   216

 * Set the animation loop number

   217

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

   218

 * @param count the new animation frame number

   219

 * @pre IsTileType(tile, MP_INDUSTRY)

   220

 */

   221

static inline void SetIndustryAnimationLoop(TileIndex tile, byte count)

   222

{

   223

	assert(IsTileType(tile, MP_INDUSTRY));

   224

	_m[tile].m4 = count;

   225

}

   226

   227

/**

   228

 * Get the animation state

   229

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

   230

 * @pre IsTileType(tile, MP_INDUSTRY)

   231

 */

   232

static inline byte GetIndustryAnimationState(TileIndex tile)

   233

{

   234

	assert(IsTileType(tile, MP_INDUSTRY));

   235

	return _m[tile].m3;

   236

}

   237

   238

/**

   239

 * Set the animation state

   240

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

   241

 * @param state the new animation state

   242

 * @pre IsTileType(tile, MP_INDUSTRY)

   243

 */

   244

static inline void SetIndustryAnimationState(TileIndex tile, byte state)

   245

{

   246

	assert(IsTileType(tile, MP_INDUSTRY));

   247

	_m[tile].m3 = state;

   248

}

   249

   250

/**

   251

 * Get the random bits for this tile.

   252

 * Used for grf callbacks

   253

 * @param tile TileIndex of the tile to query

   254

 * @pre IsTileType(tile, MP_INDUSTRY)

   255

 * @return requested bits

   256

 * @todo implement the storage in map array

   257

 */

   258

static inline byte GetIndustryRandomBits(TileIndex tile)

   259

{

   260

	assert(IsTileType(tile, MP_INDUSTRY));

   261

	return 0;

   262

}

   263

   264

/**

   265

 * Get the activated triggers bits for this industry tile

   266

 * Used for grf callbacks

   267

 * @param tile TileIndex of the tile to query

   268

 * @pre IsTileType(tile, MP_INDUSTRY)

   269

 * @return requested triggers

   270

 * @todo implement the storage in map array

   271

 */

   272

static inline byte GetIndustryTriggers(TileIndex tile)

   273

{

   274

	assert(IsTileType(tile, MP_INDUSTRY));

   275

	return 0;

   276

}

   277

   278

   279

/**

   280

 * Set the activated triggers bits for this industry tile

   281

 * Used for grf callbacks

   282

 * @param tile TileIndex of the tile to query

   283

 * @pre IsTileType(tile, MP_INDUSTRY)

   284

 * @todo implement the storage in map array

   285

 */

   286

static inline void SetIndustryTriggers(TileIndex tile, byte triggers)

   287

{

   288

	assert(IsTileType(tile, MP_INDUSTRY));

   289

}

   290

   291

#endif /* INDUSTRY_MAP_H */