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

    11

    12

/**

    13

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

    14

 * @param t the tile

    15

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

    16

 * @return TownID

    17

 */

    18

static inline TownID GetTownIndex(TileIndex t)

    19

{

    20

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

    21

	return _m[t].m2;

    22

}

    23

    24

/**

    25

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

    26

 * @param t the tile

    27

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

    28

 * @param index the index of the town

    29

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

    30

 */

    31

static inline void SetTownIndex(TileIndex t, TownID index)

    32

{

    33

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

    34

	_m[t].m2 = index;

    35

}

    36

    37

/**

    38

 * Gets the town associated with the house or road tile

    39

 * @param t the tile to get the town of

    40

 * @return the town

    41

 */

    42

static inline Town *GetTownByTile(TileIndex t)

    43

{

    44

	return GetTown(GetTownIndex(t));

    45

}

    46

    47

/**

    48

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

    49

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

    50

 * of m3 as an additional bit to house type.

    51

 * @param t the tile

    52

 * @pre IsTileType(t, MP_HOUSE)

    53

 * @return house type

    54

 */

    55

static inline HouseID GetHouseType(TileIndex t)

    56

{

    57

	assert(IsTileType(t, MP_HOUSE));

    58

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

    59

}

    60

    61

/**

    62

 * Set the house type.

    63

 * @param t the tile

    64

 * @param house_id the new house type

    65

 * @pre IsTileType(t, MP_HOUSE)

    66

 */

    67

static inline void SetHouseType(TileIndex t, HouseID house_id)

    68

{

    69

	assert(IsTileType(t, MP_HOUSE));

    70

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

    71

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

    72

}

    73

    74

/**

    75

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

    76

 * @param t the tile

    77

 * @return has destination

    78

 */

    79

static inline bool LiftHasDestination(TileIndex t)

    80

{

    81

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

    82

}

    83

    84

/**

    85

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

    86

 * the LiftHasDestination bit.

    87

 * @param t the tile

    88

 * @param dest new destination

    89

 */

    90

static inline void SetLiftDestination(TileIndex t, byte dest)

    91

{

    92

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

    93

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

    94

}

    95

    96

/**

    97

 * Get the current destination for this lift

    98

 * @param t the tile

    99

 * @return destination

   100

 */

   101

static inline byte GetLiftDestination(TileIndex t)

   102

{

   103

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

   104

}

   105

   106

/**

   107

 * Stop the lift of this animated house from moving.

   108

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

   109

 * and the destination.

   110

 * @param t the tile

   111

 */

   112

static inline void HaltLift(TileIndex t)

   113

{

   114

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

   115

	DeleteAnimatedTile(t);

   116

}

   117

   118

/**

   119

 * Get the position of the lift on this animated house

   120

 * @param t the tile

   121

 * @return position, from 0 to 36

   122

 */

   123

static inline byte GetLiftPosition(TileIndex t)

   124

{

   125

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

   126

}

   127

   128

/**

   129

 * Set the position of the lift on this animated house

   130

 * @param t the tile

   131

 * @param pos position, from 0 to 36

   132

 */

   133

static inline void SetLiftPosition(TileIndex t, byte pos)

   134

{

   135

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

   136

}

   137

   138

/**

   139

 * Get the current animation frame for this house

   140

 * @param t the tile

   141

 * @pre IsTileType(t, MP_HOUSE)

   142

 * @return frame number

   143

 */

   144

static inline byte GetHouseAnimationFrame(TileIndex t)

   145

{

   146

	assert(IsTileType(t, MP_HOUSE));

   147

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

   148

}

   149

   150

/**

   151

 * Set a new animation frame for this house

   152

 * @param t the tile

   153

 * @param frame the new frame number

   154

 * @pre IsTileType(t, MP_HOUSE)

   155

 */

   156

static inline void SetHouseAnimationFrame(TileIndex t, byte frame)

   157

{

   158

	assert(IsTileType(t, MP_HOUSE));

   159

	SB(_m[t].m6, 3, 5, frame);

   160

}

   161

   162

/**

   163

 * Get the completion of this house

   164

 * @param t the tile

   165

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

   166

 */

   167

static inline bool IsHouseCompleted(TileIndex t)

   168

{

   169

	assert(IsTileType(t, MP_HOUSE));

   170

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

   171

}

   172

   173

/**

   174

 * Mark this house as been completed

   175

 * @param t the tile

   176

 * @param status

   177

 */

   178

static inline void SetHouseCompleted(TileIndex t, bool status)

   179

{

   180

	assert(IsTileType(t, MP_HOUSE));

   181

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

   182

}

   183

   184

/**

   185

 * Make the tile a house.

   186

 * @param t tile index

   187

 * @param tid Town index

   188

 * @param counter of construction step

   189

 * @param stage of construction (used for drawing)

   190

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

   191

 * @param random_bits required for newgrf houses

   192

 * @pre IsTileType(t, MP_CLEAR)

   193

 */

   194

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

   195

{

   196

	assert(IsTileType(t, MP_CLEAR));

   197

   198

	SetTileType(t, MP_HOUSE);

   199

	_m[t].m1 = random_bits;

   200

	_m[t].m2 = tid;

   201

	_m[t].m3 = 0;

   202

	SetHouseType(t, type);

   203

	SetHouseCompleted(t, stage == TOWN_HOUSE_COMPLETED);

   204

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

   205

	SetHouseAnimationFrame(t, 0);

   206

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

   207

   208

	if (GetHouseSpecs(type)->building_flags & BUILDING_IS_ANIMATED) AddAnimatedTile(t);

   209

	MarkTileDirtyByTile(t);

   210

}

   211

   212

/**

   213

 * Helper function for MakeHouseTile.

   214

 * It is called  for each tile of a multi-tile house.

   215

 * Parametes are the same.

   216

 * @param t tile index

   217

 * @param tid Town index

   218

 * @param counter of construction step

   219

 * @param stage of construction (used for drawing)

   220

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

   221

 * @param random_bits required for newgrf houses

   222

 */

   223

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

   224

{

   225

	BuildingFlags size = GetHouseSpecs(type)->building_flags;

   226

	MakeHouseTile(t, tid, counter, stage, type, random_bits);

   227

	if (size & BUILDING_2_TILES_Y)   MakeHouseTile(t + TileDiffXY(0, 1), tid, counter, stage, ++type, random_bits);

   228

	if (size & BUILDING_2_TILES_X)   MakeHouseTile(t + TileDiffXY(1, 0), tid, counter, stage, ++type, random_bits);

   229

	if (size & BUILDING_HAS_4_TILES) MakeHouseTile(t + TileDiffXY(1, 1), tid, counter, stage, ++type, random_bits);

   230

}

   231

   232

/**

   233

 * House Construction Scheme.

   234

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

   235

 *  periodic tile processing.

   236

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

   237

 *  GetHouseBuildingStage is taking care of the real stages,

   238

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

   239

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

   240

 *  different stages

   241

 */

   242

   243

/**

   244

 * Gets the building stage of a house

   245

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

   246

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

   247

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

   248

 * thus showing a beautiful complete house.

   249

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

   250

 * @pre IsTileType(t, MP_HOUSE)

   251

 * @return the building stage of the house

   252

 */

   253

static inline byte GetHouseBuildingStage(TileIndex t)

   254

{

   255

	assert(IsTileType(t, MP_HOUSE));

   256

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

   257

}

   258

   259

/**

   260

 * Gets the construction stage of a house

   261

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

   262

 * @pre IsTileType(t, MP_HOUSE)

   263

 * @return the construction stage of the house

   264

 */

   265

static inline byte GetHouseConstructionTick(TileIndex t)

   266

{

   267

	assert(IsTileType(t, MP_HOUSE));

   268

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

   269

}

   270

   271

/**

   272

 * Sets the increment stage of a house

   273

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

   274

 * easier to work:  the wraparound is automatic.

   275

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

   276

 * @pre IsTileType(t, MP_HOUSE)

   277

 */

   278

static inline void IncHouseConstructionTick(TileIndex t)

   279

{

   280

	assert(IsTileType(t, MP_HOUSE));

   281

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

   282

   283

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

   284

		/* House is now completed.

   285

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

   286

		SetHouseCompleted(t, true);

   287

		_m[t].m5 = Clamp(_cur_year - ORIGINAL_BASE_YEAR, 0, 0xFF);

   288

	}

   289

}

   290

   291

/**

   292

 * Get the year that this house was constructed (between 1920 and 2175).

   293

 * @param t the tile of this house

   294

 * @pre IsTileType(t, MP_HOUSE)

   295

 * @return year

   296

 */

   297

static inline Year GetHouseConstructionYear(TileIndex t)

   298

{

   299

	assert(IsTileType(t, MP_HOUSE));

   300

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

   301

}

   302

   303

/**

   304

 * Set the random bits for this house.

   305

 * This is required for newgrf house

   306

 * @param t      the tile of this house

   307

 * @param random the new random bits

   308

 * @pre IsTileType(t, MP_HOUSE)

   309

 */

   310

static inline void SetHouseRandomBits(TileIndex t, byte random)

   311

{

   312

	assert(IsTileType(t, MP_HOUSE));

   313

	_m[t].m1 = random;

   314

}

   315

   316

/**

   317

 * Get the random bits for this house.

   318

 * This is required for newgrf house

   319

 * @param t the tile of this house

   320

 * @pre IsTileType(t, MP_HOUSE)

   321

 * @return random bits

   322

 */

   323

static inline byte GetHouseRandomBits(TileIndex t)

   324

{

   325

	assert(IsTileType(t, MP_HOUSE));

   326

	return _m[t].m1;

   327

}

   328

   329

/**

   330

 * Set the activated triggers bits for this house.

   331

 * This is required for newgrf house

   332

 * @param t        the tile of this house

   333

 * @param triggers the activated triggers

   334

 * @pre IsTileType(t, MP_HOUSE)

   335

 */

   336

static inline void SetHouseTriggers(TileIndex t, byte triggers)

   337

{

   338

	assert(IsTileType(t, MP_HOUSE));

   339

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

   340

}

   341

   342

/**

   343

 * Get the already activated triggers bits for this house.

   344

 * This is required for newgrf house

   345

 * @param t the tile of this house

   346

 * @pre IsTileType(t, MP_HOUSE)

   347

 * @return triggers

   348

 */

   349

static inline byte GetHouseTriggers(TileIndex t)

   350

{

   351

	assert(IsTileType(t, MP_HOUSE));

   352

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

   353

}

   354

   355

/**

   356

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

   357

 * @param t the house tile

   358

 * @pre IsTileType(t, MP_HOUSE)

   359

 * @return time remaining

   360

 */

   361

static inline byte GetHouseProcessingTime(TileIndex t)

   362

{

   363

	assert(IsTileType(t, MP_HOUSE));

   364

	return _me[t].m7;

   365

}

   366

   367

/**

   368

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

   369

 * @param t the house tile

   370

 * @param time the time to be set

   371

 * @pre IsTileType(t, MP_HOUSE)

   372

 */

   373

static inline void SetHouseProcessingTime(TileIndex t, byte time)

   374

{

   375

	assert(IsTileType(t, MP_HOUSE));

   376

	_me[t].m7 = time;

   377

}

   378

   379

/**

   380

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

   381

 * @param t the house tile

   382

 * @pre IsTileType(t, MP_HOUSE)

   383

 */

   384

static inline void DecHouseProcessingTime(TileIndex t)

   385

{

   386

	assert(IsTileType(t, MP_HOUSE));

   387

	_me[t].m7--;

   388

}

   389

   390

#endif /* TOWN_MAP_H */