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

    10

static inline TownID GetTownIndex(TileIndex t)

    11

{

    12

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

    13

	return _m[t].m2;

    14

}

    15

    16

/**

    17

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

    18

 * @param tile the tile

    19

 * @param index the index of the town

    20

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

    21

 */

    22

static inline void SetTownIndex(TileIndex t, TownID index)

    23

{

    24

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

    25

	_m[t].m2 = index;

    26

}

    27

    28

/**

    29

 * Gets the town associated with the house or road tile

    30

 * @param t the tile to get the town of

    31

 * @return the town

    32

 */

    33

static inline Town* GetTownByTile(TileIndex t)

    34

{

    35

	return GetTown(GetTownIndex(t));

    36

}

    37

    38

    39

static inline int GetHouseType(TileIndex t)

    40

{

    41

	assert(IsTileType(t, MP_HOUSE));

    42

	return _m[t].m4;

    43

}

    44

    45

static inline bool LiftHasDestination(TileIndex t)

    46

{

    47

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

    48

}

    49

    50

static inline void SetLiftDestination(TileIndex t, byte dest)

    51

{

    52

	SB(_m[t].m5, 0, 6, dest);

    53

	SETBIT(_m[t].m1, 7); /* Start moving */

    54

}

    55

    56

static inline byte GetLiftDestination(TileIndex t)

    57

{

    58

	return GB(_m[t].m5, 0, 6);

    59

}

    60

    61

static inline bool IsLiftMoving(TileIndex t)

    62

{

    63

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

    64

}

    65

    66

static inline void BeginLiftMovement(TileIndex t)

    67

{

    68

	SETBIT(_m[t].m5, 7);

    69

}

    70

    71

static inline void HaltLift(TileIndex t)

    72

{

    73

	CLRBIT(_m[t].m1, 7);

    74

	CLRBIT(_m[t].m5, 7);

    75

	SB(_m[t].m5, 0, 6, 0);

    76

    77

	DeleteAnimatedTile(t);

    78

}

    79

    80

static inline byte GetLiftPosition(TileIndex t)

    81

{

    82

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

    83

}

    84

    85

static inline void SetLiftPosition(TileIndex t, byte pos)

    86

{

    87

	SB(_m[t].m1, 0, 7, pos);

    88

}

    89

    90

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

    91

{

    92

	assert(IsTileType(t, MP_CLEAR));

    93

    94

	SetTileType(t, MP_HOUSE);

    95

	_m[t].m1 = 0;

    96

	_m[t].m2 = tid;

    97

	SB(_m[t].m3, 6, 2, stage);

    98

	_m[t].m4 = type;

    99

	SB(_m[t].m5, 0, 2, counter);

   100

   101

	MarkTileDirtyByTile(t);

   102

}

   103

   104

enum {

   105

	TWO_BY_TWO_BIT = 2, ///< House is two tiles in X and Y directions

   106

	ONE_BY_TWO_BIT = 1, ///< House is two tiles in Y direction

   107

	TWO_BY_ONE_BIT = 0, ///< House is two tiles in X direction

   108

};

   109

   110

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

   111

{

   112

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

   113

	if (HASBIT(size, TWO_BY_TWO_BIT) || HASBIT(size, ONE_BY_TWO_BIT)) MakeHouseTile(t + TileDiffXY(0, 1), tid, counter, stage, ++type);

   114

	if (HASBIT(size, TWO_BY_TWO_BIT) || HASBIT(size, TWO_BY_ONE_BIT)) MakeHouseTile(t + TileDiffXY(1, 0), tid, counter, stage, ++type);

   115

	if (HASBIT(size, TWO_BY_TWO_BIT)) MakeHouseTile(t + TileDiffXY(1, 1), tid, counter, stage, ++type);

   116

}

   117

   118

/**

   119

 * House Construction Scheme.

   120

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

   121

 *  periodic tile processing.

   122

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

   123

 *  (Get|Set|Inc)HouseBuildingStage are taking care of the real stages,

   124

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

   125

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

   126

 *  different stages

   127

 */

   128

   129

/**

   130

 * Gets the building stage of a house

   131

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

   132

 * @pre IsTileType(t, MP_HOUSE)

   133

 * @return the building stage of the house

   134

 */

   135

static inline byte GetHouseBuildingStage(TileIndex t)

   136

{

   137

	assert(IsTileType(t, MP_HOUSE));

   138

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

   139

}

   140

   141

/**

   142

 * Sets the building stage of a house

   143

 * @param tile the tile of the house to set the building stage of

   144

 * @param stage the new stage

   145

 * @pre IsTileType(t, MP_HOUSE)

   146

 */

   147

static inline void SetHouseBuildingStage(TileIndex t, byte stage)

   148

{

   149

	assert(IsTileType(t, MP_HOUSE));

   150

	SB(_m[t].m3, 6, 2, stage);

   151

}

   152

   153

/**

   154

 * Increments the building stage of a house

   155

 * @param tile the tile of the house to increment the building stage of

   156

 * @pre IsTileType(t, MP_HOUSE)

   157

 */

   158

static inline void IncHouseBuildingStage( TileIndex t )

   159

{

   160

	assert(IsTileType(t, MP_HOUSE));

   161

	AB(_m[t].m3, 6, 2, 1);

   162

}

   163

   164

/**

   165

 * Gets the construction stage of a house

   166

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

   167

 * @pre IsTileType(t, MP_HOUSE)

   168

 * @return the construction stage of the house

   169

 */

   170

static inline byte GetHouseConstructionTick(TileIndex t)

   171

{

   172

	assert(IsTileType(t, MP_HOUSE));

   173

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

   174

}

   175

   176

/**

   177

 * Sets the construction stage of a house

   178

 * @param tile the tile of the house to set the construction stage of

   179

 * @param stage the new stage

   180

 * @pre IsTileType(t, MP_HOUSE)

   181

 */

   182

static inline void SetHouseConstructionTick(TileIndex t, byte stage)

   183

{

   184

	assert(IsTileType(t, MP_HOUSE));

   185

	SB(_m[t].m5, 0, 3, stage);

   186

}

   187

   188

/**

   189

 * Sets the increment stage of a house

   190

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

   191

 * @pre IsTileType(t, MP_HOUSE)

   192

 */

   193

static inline void IncHouseConstructionTick(TileIndex t)

   194

{

   195

	assert(IsTileType(t, MP_HOUSE));

   196

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

   197

}

   198

   199

   200

#endif /* TOWN_MAP_H */