1

/* $Id$ */

     2

     3

/** @file town_map.h Accessors for towns */

     4

     5

#ifndef TOWN_MAP_H

     6

#define TOWN_MAP_H

     7

     8

#include "town.h"

     9

#include "tile_map.h"

    10

    11

/**

    12

 * Get the index of which town this house/street is attached to.

    13

 * @param t the tile

    14

 * @pre IsTileType(t, MP_HOUSE) or IsTileType(t, MP_ROAD)

    15

 * @return TownID

    16

 */

    17

static inline TownID GetTownIndex(TileIndex t)

    18

{

    19

	assert(IsTileType(t, MP_HOUSE) || IsTileType(t, MP_ROAD)); // XXX incomplete

    20

	return _m[t].m2;

    21

}

    22

    23

/**

    24

 * Set the town index for a road or house tile.

    25

 * @param t the tile

    26

 * @pre IsTileType(t, MP_HOUSE) or IsTileType(t, MP_ROAD)

    27

 * @param index the index of the town

    28

 * @pre IsTileType(t, MP_ROAD) || IsTileType(t, MP_HOUSE)

    29

 */

    30

static inline void SetTownIndex(TileIndex t, TownID index)

    31

{

    32

	assert(IsTileType(t, MP_HOUSE) || IsTileType(t, MP_ROAD));

    33

	_m[t].m2 = index;

    34

}

    35

    36

/**

    37

 * Gets the town associated with the house or road tile

    38

 * @param t the tile to get the town of

    39

 * @return the town

    40

 */

    41

static inline Town *GetTownByTile(TileIndex t)

    42

{

    43

	return GetTown(GetTownIndex(t));

    44

}

    45

    46

/**

    47

 * Get the type of this house, which is an index into the house spec array

    48

 * Since m4 is only a byte and we want to support 512 houses, we use the bit 6

    49

 * of m3 as an additional bit to house type.

    50

 * @param t the tile

    51

 * @pre IsTileType(t, MP_HOUSE)

    52

 * @return house type

    53

 */

    54

static inline HouseID GetHouseType(TileIndex t)

    55

{

    56

	assert(IsTileType(t, MP_HOUSE));

    57

	return _m[t].m4 | (GB(_m[t].m3, 6, 1) << 8);

    58

}

    59

    60

/**

    61

 * Set the house type.

    62

 * @param t the tile

    63

 * @param house_id the new house type

    64

 * @pre IsTileType(t, MP_HOUSE)

    65

 */

    66

static inline void SetHouseType(TileIndex t, HouseID house_id)

    67

{

    68

	assert(IsTileType(t, MP_HOUSE));

    69

	_m[t].m4 = GB(house_id, 0, 8);

    70

	SB(_m[t].m3, 6, 1, GB(house_id, 8, 1));

    71

}

    72

    73

/**

    74

 * Check if the lift of this animated house has a destination

    75

 * @param t the tile

    76

 * @return has destination

    77

 */

    78

static inline bool LiftHasDestination(TileIndex t)

    79

{

    80

	return HasBit(_me[t].m7, 0);

    81

}

    82

    83

/**

    84

 * Set the new destination of the lift for this animated house, and activate

    85

 * the LiftHasDestination bit.

    86

 * @param t the tile

    87

 * @param dest new destination

    88

 */

    89

static inline void SetLiftDestination(TileIndex t, byte dest)

    90

{

    91

	SetBit(_me[t].m7, 0);

    92

	SB(_me[t].m7, 1, 3, dest);

    93

}

    94

    95

/**

    96

 * Get the current destination for this lift

    97

 * @param t the tile

    98

 * @return destination

    99

 */

   100

static inline byte GetLiftDestination(TileIndex t)

   101

{

   102

	return GB(_me[t].m7, 1, 3);

   103

}

   104

   105

/**

   106

 * Stop the lift of this animated house from moving.

   107

 * Clears the first 4 bits of m7 at once, clearing the LiftHasDestination bit

   108

 * and the destination.

   109

 * @param t the tile

   110

 */

   111

static inline void HaltLift(TileIndex t)

   112

{

   113

	SB(_me[t].m7, 0, 4, 0);

   114

}

   115

   116

/**

   117

 * Get the position of the lift on this animated house

   118

 * @param t the tile

   119

 * @return position, from 0 to 36

   120

 */

   121

static inline byte GetLiftPosition(TileIndex t)

   122

{

   123

	return GB(_m[t].m6, 2, 6);

   124

}

   125

   126

/**

   127

 * Set the position of the lift on this animated house

   128

 * @param t the tile

   129

 * @param pos position, from 0 to 36

   130

 */

   131

static inline void SetLiftPosition(TileIndex t, byte pos)

   132

{

   133

	SB(_m[t].m6, 2, 6, pos);

   134

}

   135

   136

/**

   137

 * Get the current animation frame for this house

   138

 * @param t the tile

   139

 * @pre IsTileType(t, MP_HOUSE)

   140

 * @return frame number

   141

 */

   142

static inline byte GetHouseAnimationFrame(TileIndex t)

   143

{

   144

	assert(IsTileType(t, MP_HOUSE));

   145

	return GB(_m[t].m6, 2, 6) | (GB(_m[t].m3, 5, 1) << 6);

   146

}

   147

   148

/**

   149

 * Set a new animation frame for this house

   150

 * @param t the tile

   151

 * @param frame the new frame number

   152

 * @pre IsTileType(t, MP_HOUSE)

   153

 */

   154

static inline void SetHouseAnimationFrame(TileIndex t, byte frame)

   155

{

   156

	assert(IsTileType(t, MP_HOUSE));

   157

	SB(_m[t].m6, 2, 6, GB(frame, 0, 6));

   158

	SB(_m[t].m3, 5, 1, GB(frame, 6, 1));

   159

}

   160

   161

/**

   162

 * Get the completion of this house

   163

 * @param t the tile

   164

 * @return true if it is, false if it is not

   165

 */

   166

static inline bool IsHouseCompleted(TileIndex t)

   167

{

   168

	assert(IsTileType(t, MP_HOUSE));

   169

	return HasBit(_m[t].m3, 7);

   170

}

   171

   172

/**

   173

 * Mark this house as been completed

   174

 * @param t the tile

   175

 * @param status

   176

 */

   177

static inline void SetHouseCompleted(TileIndex t, bool status)

   178

{

   179

	assert(IsTileType(t, MP_HOUSE));

   180

	SB(_m[t].m3, 7, 1, !!status);

   181

}

   182

   183

/**

   184

 * Make the tile a house.

   185

 * @param t tile index

   186

 * @param tid Town index

   187

 * @param counter of construction step

   188

 * @param stage of construction (used for drawing)

   189

 * @param type of house.  Index into house specs array

   190

 * @param random_bits required for newgrf houses

   191

 * @pre IsTileType(t, MP_CLEAR)

   192

 */

   193

static inline void MakeHouseTile(TileIndex t, TownID tid, byte counter, byte stage, HouseID type, byte random_bits)

   194

{

   195

	assert(IsTileType(t, MP_CLEAR));

   196

   197

	SetTileType(t, MP_HOUSE);

   198

	_m[t].m1 = random_bits;

   199

	_m[t].m2 = tid;

   200

	_m[t].m3 = 0;

   201

	SetHouseType(t, type);

   202

	SetHouseCompleted(t, stage == TOWN_HOUSE_COMPLETED);

   203

	_m[t].m5 = IsHouseCompleted(t) ? 0 : (stage << 3 | counter);

   204

	SetHouseAnimationFrame(t, 0);

   205

	_me[t].m7 = GetHouseSpecs(type)->processing_time;

   206

}

   207

   208

/**

   209

 * House Construction Scheme.

   210

 *  Construction counter, for buildings under construction. Incremented on every

   211

 *  periodic tile processing.

   212

 *  On wraparound, the stage of building in is increased.

   213

 *  GetHouseBuildingStage is taking care of the real stages,

   214

 *  (as the sprite for the next phase of house building)

   215

 *  (Get|Inc)HouseConstructionTick is simply a tick counter between the

   216

 *  different stages

   217

 */

   218

   219

/**

   220

 * Gets the building stage of a house

   221

 * Since the stage is used for determining what sprite to use,

   222

 * if the house is complete (and that stage no longuer is available),

   223

 * fool the system by returning the TOWN_HOUSE_COMPLETE (3),

   224

 * thus showing a beautiful complete house.

   225

 * @param t the tile of the house to get the building stage of

   226

 * @pre IsTileType(t, MP_HOUSE)

   227

 * @return the building stage of the house

   228

 */

   229

static inline byte GetHouseBuildingStage(TileIndex t)

   230

{

   231

	assert(IsTileType(t, MP_HOUSE));

   232

	return IsHouseCompleted(t) ? (byte)TOWN_HOUSE_COMPLETED : GB(_m[t].m5, 3, 2);

   233

}

   234

   235

/**

   236

 * Gets the construction stage of a house

   237

 * @param t the tile of the house to get the construction stage of

   238

 * @pre IsTileType(t, MP_HOUSE)

   239

 * @return the construction stage of the house

   240

 */

   241

static inline byte GetHouseConstructionTick(TileIndex t)

   242

{

   243

	assert(IsTileType(t, MP_HOUSE));

   244

	return IsHouseCompleted(t) ? 0 : GB(_m[t].m5, 0, 3);

   245

}

   246

   247

/**

   248

 * Sets the increment stage of a house

   249

 * It is working with the whole counter + stage 5 bits, making it

   250

 * easier to work:  the wraparound is automatic.

   251

 * @param t the tile of the house to increment the construction stage of

   252

 * @pre IsTileType(t, MP_HOUSE)

   253

 */

   254

static inline void IncHouseConstructionTick(TileIndex t)

   255

{

   256

	assert(IsTileType(t, MP_HOUSE));

   257

	AB(_m[t].m5, 0, 5, 1);

   258

   259

	if (GB(_m[t].m5, 3, 2) == TOWN_HOUSE_COMPLETED) {

   260

		/* House is now completed.

   261

		 * Store the year of construction as well, for newgrf house purpose */

   262

		SetHouseCompleted(t, true);

   263

	}

   264

}

   265

   266

/**

   267

 * Sets the age of the house to zero.

   268

 * Needs to be called after the house is completed. During construction stages the map space is used otherwise.

   269

 * @param t the tile of this house

   270

 * @pre IsTileType(t, MP_HOUSE) && IsHouseCompleted(t)

   271

 */

   272

static inline void ResetHouseAge(TileIndex t)

   273

{

   274

	assert(IsTileType(t, MP_HOUSE) && IsHouseCompleted(t));

   275

	_m[t].m5 = 0;

   276

}

   277

   278

/**

   279

 * Increments the age of the house.

   280

 * @param t the tile of this house

   281

 * @pre IsTileType(t, MP_HOUSE)

   282

 */

   283

static inline void IncrementHouseAge(TileIndex t)

   284

{

   285

	assert(IsTileType(t, MP_HOUSE));

   286

	if (IsHouseCompleted(t) && _m[t].m5 < 0xFF) _m[t].m5++;

   287

}

   288

   289

/**

   290

 * Get the age of the house

   291

 * @param t the tile of this house

   292

 * @pre IsTileType(t, MP_HOUSE)

   293

 * @return year

   294

 */

   295

static inline Year GetHouseAge(TileIndex t)

   296

{

   297

	assert(IsTileType(t, MP_HOUSE));

   298

	return IsHouseCompleted(t) ? _m[t].m5 : 0;

   299

}

   300

   301

/**

   302

 * Set the random bits for this house.

   303

 * This is required for newgrf house

   304

 * @param t      the tile of this house

   305

 * @param random the new random bits

   306

 * @pre IsTileType(t, MP_HOUSE)

   307

 */

   308

static inline void SetHouseRandomBits(TileIndex t, byte random)

   309

{

   310

	assert(IsTileType(t, MP_HOUSE));

   311

	_m[t].m1 = random;

   312

}

   313

   314

/**

   315

 * Get the random bits for this house.

   316

 * This is required for newgrf house

   317

 * @param t the tile of this house

   318

 * @pre IsTileType(t, MP_HOUSE)

   319

 * @return random bits

   320

 */

   321

static inline byte GetHouseRandomBits(TileIndex t)

   322

{

   323

	assert(IsTileType(t, MP_HOUSE));

   324

	return _m[t].m1;

   325

}

   326

   327

/**

   328

 * Set the activated triggers bits for this house.

   329

 * This is required for newgrf house

   330

 * @param t        the tile of this house

   331

 * @param triggers the activated triggers

   332

 * @pre IsTileType(t, MP_HOUSE)

   333

 */

   334

static inline void SetHouseTriggers(TileIndex t, byte triggers)

   335

{

   336

	assert(IsTileType(t, MP_HOUSE));

   337

	SB(_m[t].m3, 0, 5, triggers);

   338

}

   339

   340

/**

   341

 * Get the already activated triggers bits for this house.

   342

 * This is required for newgrf house

   343

 * @param t the tile of this house

   344

 * @pre IsTileType(t, MP_HOUSE)

   345

 * @return triggers

   346

 */

   347

static inline byte GetHouseTriggers(TileIndex t)

   348

{

   349

	assert(IsTileType(t, MP_HOUSE));

   350

	return GB(_m[t].m3, 0, 5);

   351

}

   352

   353

/**

   354

 * Get the amount of time remaining before the tile loop processes this tile.

   355

 * @param t the house tile

   356

 * @pre IsTileType(t, MP_HOUSE)

   357

 * @return time remaining

   358

 */

   359

static inline byte GetHouseProcessingTime(TileIndex t)

   360

{

   361

	assert(IsTileType(t, MP_HOUSE));

   362

	return _me[t].m7;

   363

}

   364

   365

/**

   366

 * Set the amount of time remaining before the tile loop processes this tile.

   367

 * @param t the house tile

   368

 * @param time the time to be set

   369

 * @pre IsTileType(t, MP_HOUSE)

   370

 */

   371

static inline void SetHouseProcessingTime(TileIndex t, byte time)

   372

{

   373

	assert(IsTileType(t, MP_HOUSE));

   374

	_me[t].m7 = time;

   375

}

   376

   377

/**

   378

 * Decrease the amount of time remaining before the tile loop processes this tile.

   379

 * @param t the house tile

   380

 * @pre IsTileType(t, MP_HOUSE)

   381

 */

   382

static inline void DecHouseProcessingTime(TileIndex t)

   383

{

   384

	assert(IsTileType(t, MP_HOUSE));

   385

	_me[t].m7--;

   386

}

   387

   388

#endif /* TOWN_MAP_H */