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"

    10

#include "tile_map.h"

    12

    13

/**

    14

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

    15

 * @param t the tile

    16

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

    17

 * @return TownID

    18

 */

    19

static inline TownID GetTownIndex(TileIndex t)

    20

{

    21

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

    22

	return _m[t].m2;

    23

}

    24

    25

/**

    26

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

    27

 * @param t the tile

    28

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

    29

 * @param index the index of the town

    30

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

    31

 */

    32

static inline void SetTownIndex(TileIndex t, TownID index)

    33

{

    34

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

    35

	_m[t].m2 = index;

    36

}

    37

    38

/**

    39

 * Gets the town associated with the house or road tile

    40

 * @param t the tile to get the town of

    41

 * @return the town

    42

 */

    43

static inline Town *GetTownByTile(TileIndex t)

    44

{

    45

	return GetTown(GetTownIndex(t));

    46

}

    47

    48

/**

    49

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

    50

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

    51

 * of m3 as an additional bit to house type.

    52

 * @param t the tile

    53

 * @pre IsTileType(t, MP_HOUSE)

    54

 * @return house type

    55

 */

    56

static inline HouseID GetHouseType(TileIndex t)

    57

{

    58

	assert(IsTileType(t, MP_HOUSE));

    59

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

    60

}

    61

    62

/**

    63

 * Set the house type.

    64

 * @param t the tile

    65

 * @param house_id the new house type

    66

 * @pre IsTileType(t, MP_HOUSE)

    67

 */

    68

static inline void SetHouseType(TileIndex t, HouseID house_id)

    69

{

    70

	assert(IsTileType(t, MP_HOUSE));

    71

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

    72

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

    73

}

    74

    75

/**

    76

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

    77

 * @param t the tile

    78

 * @return has destination

    79

 */

    80

static inline bool LiftHasDestination(TileIndex t)

    81

{

    82

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

    83

}

    84

    85

/**

    86

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

    87

 * the LiftHasDestination bit.

    88

 * @param t the tile

    89

 * @param dest new destination

    90

 */

    91

static inline void SetLiftDestination(TileIndex t, byte dest)

    92

{

    93

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

    94

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

    95

}

    96

    97

/**

    98

 * Get the current destination for this lift

    99

 * @param t the tile

   100

 * @return destination

   101

 */

   102

static inline byte GetLiftDestination(TileIndex t)

   103

{

   104

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

   105

}

   106

   107

/**

   108

 * Stop the lift of this animated house from moving.

   109

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

   110

 * and the destination.

   111

 * @param t the tile

   112

 */

   113

static inline void HaltLift(TileIndex t)

   114

{

   115

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

   116

	DeleteAnimatedTile(t);

   117

}

   118

   119

/**

   120

 * Get the position of the lift on this animated house

   121

 * @param t the tile

   122

 * @return position, from 0 to 36

   123

 */

   124

static inline byte GetLiftPosition(TileIndex t)

   125

{

   126

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

   127

}

   128

   129

/**

   130

 * Set the position of the lift on this animated house

   131

 * @param t the tile

   132

 * @param pos position, from 0 to 36

   133

 */

   134

static inline void SetLiftPosition(TileIndex t, byte pos)

   135

{

   136

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

   137

}

   138

   139

/**

   140

 * Get the current animation frame for this house

   141

 * @param t the tile

   142

 * @pre IsTileType(t, MP_HOUSE)

   143

 * @return frame number

   144

 */

   145

static inline byte GetHouseAnimationFrame(TileIndex t)

   146

{

   147

	assert(IsTileType(t, MP_HOUSE));

   148

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

   149

}

   150

   151

/**

   152

 * Set a new animation frame for this house

   153

 * @param t the tile

   154

 * @param frame the new frame number

   155

 * @pre IsTileType(t, MP_HOUSE)

   156

 */

   157

static inline void SetHouseAnimationFrame(TileIndex t, byte frame)

   158

{

   159

	assert(IsTileType(t, MP_HOUSE));

   160

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

   161

}

   162

   163

/**

   164

 * Get the completion of this house

   165

 * @param t the tile

   166

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

   167

 */

   168

static inline bool IsHouseCompleted(TileIndex t)

   169

{

   170

	assert(IsTileType(t, MP_HOUSE));

   171

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

   172

}

   173

   174

/**

   175

 * Mark this house as been completed

   176

 * @param t the tile

   177

 * @param status

   178

 */

   179

static inline void SetHouseCompleted(TileIndex t, bool status)

   180

{

   181

	assert(IsTileType(t, MP_HOUSE));

   182

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

   183

}

   184

   185

/**

   186

 * Make the tile a house.

   187

 * @param t tile index

   188

 * @param tid Town index

   189

 * @param counter of construction step

   190

 * @param stage of construction (used for drawing)

   191

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

   192

 * @param random_bits required for newgrf houses

   193

 * @pre IsTileType(t, MP_CLEAR)

   194

 */

   195

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

   196

{

   197

	assert(IsTileType(t, MP_CLEAR));

   198

   199

	SetTileType(t, MP_HOUSE);

   200

	_m[t].m1 = random_bits;

   201

	_m[t].m2 = tid;

   202

	_m[t].m3 = 0;

   203

	SetHouseType(t, type);

   204

	SetHouseCompleted(t, stage == TOWN_HOUSE_COMPLETED);

   205

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

   206

	SetHouseAnimationFrame(t, 0);

   207

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

   208

   209

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

   210

	MarkTileDirtyByTile(t);

   211

}

   212

   213

/**

   214

 * Helper function for MakeHouseTile.

   215

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

   216

 * Parametes are the same.

   217

 * @param t tile index

   218

 * @param tid Town index

   219

 * @param counter of construction step

   220

 * @param stage of construction (used for drawing)

   221

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

   222

 * @param random_bits required for newgrf houses

   223

 */

   224

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

   225

{

   226

	BuildingFlags size = GetHouseSpecs(type)->building_flags;

   227

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

   228

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

   229

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

   230

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

   231

}

   232

   233

/**

   234

 * House Construction Scheme.

   235

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

   236

 *  periodic tile processing.

   237

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

   238

 *  GetHouseBuildingStage is taking care of the real stages,

   239

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

   240

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

   241

 *  different stages

   242

 */

   243

   244

/**

   245

 * Gets the building stage of a house

   246

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

   247

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

   248

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

   249

 * thus showing a beautiful complete house.

   250

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

   251

 * @pre IsTileType(t, MP_HOUSE)

   252

 * @return the building stage of the house

   253

 */

   254

static inline byte GetHouseBuildingStage(TileIndex t)

   255

{

   256

	assert(IsTileType(t, MP_HOUSE));

   257

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

   258

}

   259

   260

/**

   261

 * Gets the construction stage of a house

   262

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

   263

 * @pre IsTileType(t, MP_HOUSE)

   264

 * @return the construction stage of the house

   265

 */

   266

static inline byte GetHouseConstructionTick(TileIndex t)

   267

{

   268

	assert(IsTileType(t, MP_HOUSE));

   269

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

   270

}

   271

   272

/**

   273

 * Sets the increment stage of a house

   274

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

   275

 * easier to work:  the wraparound is automatic.

   276

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

   277

 * @pre IsTileType(t, MP_HOUSE)

   278

 */

   279

static inline void IncHouseConstructionTick(TileIndex t)

   280

{

   281

	assert(IsTileType(t, MP_HOUSE));

   282

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

   283

   284

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

   285

		/* House is now completed.

   286

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

   287

		SetHouseCompleted(t, true);

   288

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

   289

	}

   290

}

   291

   292

/**

   293

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

   294

 * @param t the tile of this house

   295

 * @pre IsTileType(t, MP_HOUSE)

   296

 * @return year

   297

 */

   298

static inline Year GetHouseConstructionYear(TileIndex t)

   299

{

   300

	assert(IsTileType(t, MP_HOUSE));

   301

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

   302

}

   303

   304

/**

   305

 * Set the random bits for this house.

   306

 * This is required for newgrf house

   307

 * @param t      the tile of this house

   308

 * @param random the new random bits

   309

 * @pre IsTileType(t, MP_HOUSE)

   310

 */

   311

static inline void SetHouseRandomBits(TileIndex t, byte random)

   312

{

   313

	assert(IsTileType(t, MP_HOUSE));

   314

	_m[t].m1 = random;

   315

}

   316

   317

/**

   318

 * Get the random bits for this house.

   319

 * This is required for newgrf house

   320

 * @param t the tile of this house

   321

 * @pre IsTileType(t, MP_HOUSE)

   322

 * @return random bits

   323

 */

   324

static inline byte GetHouseRandomBits(TileIndex t)

   325

{

   326

	assert(IsTileType(t, MP_HOUSE));

   327

	return _m[t].m1;

   328

}

   329

   330

/**

   331

 * Set the activated triggers bits for this house.

   332

 * This is required for newgrf house

   333

 * @param t        the tile of this house

   334

 * @param triggers the activated triggers

   335

 * @pre IsTileType(t, MP_HOUSE)

   336

 */

   337

static inline void SetHouseTriggers(TileIndex t, byte triggers)

   338

{

   339

	assert(IsTileType(t, MP_HOUSE));

   340

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

   341

}

   342

   343

/**

   344

 * Get the already activated triggers bits for this house.

   345

 * This is required for newgrf house

   346

 * @param t the tile of this house

   347

 * @pre IsTileType(t, MP_HOUSE)

   348

 * @return triggers

   349

 */

   350

static inline byte GetHouseTriggers(TileIndex t)

   351

{

   352

	assert(IsTileType(t, MP_HOUSE));

   353

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

   354

}

   355

   356

/**

   357

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

   358

 * @param t the house tile

   359

 * @pre IsTileType(t, MP_HOUSE)

   360

 * @return time remaining

   361

 */

   362

static inline byte GetHouseProcessingTime(TileIndex t)

   363

{

   364

	assert(IsTileType(t, MP_HOUSE));

   365

	return _me[t].m7;

   366

}

   367

   368

/**

   369

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

   370

 * @param t the house tile

   371

 * @param time the time to be set

   372

 * @pre IsTileType(t, MP_HOUSE)

   373

 */

   374

static inline void SetHouseProcessingTime(TileIndex t, byte time)

   375

{

   376

	assert(IsTileType(t, MP_HOUSE));

   377

	_me[t].m7 = time;

   378

}

   379

   380

/**

   381

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

   382

 * @param t the house tile

   383

 * @pre IsTileType(t, MP_HOUSE)

   384

 */

   385

static inline void DecHouseProcessingTime(TileIndex t)

   386

{

   387

	assert(IsTileType(t, MP_HOUSE));

   388

	_me[t].m7--;

   389

}

   390

   391

#endif /* TOWN_MAP_H */