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 int GetHouseType(TileIndex t)

    11

{

    12

	assert(IsTileType(t, MP_HOUSE));

    13

	return _m[t].m4;

    14

}

    15

    16

static inline TownID GetTownIndex(TileIndex t)

    17

{

    18

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

    19

	return _m[t].m2;

    20

}

    21

    22

/**

    23

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

    24

 * @param tile the tile

    25

 * @param index the index of the town

    26

 */

    27

static inline void SetTownIndex(TileIndex t, TownID index)

    28

{

    29

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

    30

	_m[t].m2 = index;

    31

}

    32

    33

static inline bool LiftHasDestination(TileIndex t)

    34

{

    35

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

    36

}

    37

    38

static inline void SetLiftDestination(TileIndex t, byte dest)

    39

{

    40

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

    41

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

    42

}

    43

    44

static inline byte GetLiftDestination(TileIndex t)

    45

{

    46

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

    47

}

    48

    49

static inline bool IsLiftMoving(TileIndex t)

    50

{

    51

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

    52

}

    53

    54

static inline void BeginLiftMovement(TileIndex t)

    55

{

    56

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

    57

}

    58

    59

static inline void HaltLift(TileIndex t)

    60

{

    61

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

    62

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

    63

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

    64

    65

	DeleteAnimatedTile(t);

    66

}

    67

    68

static inline byte GetLiftPosition(TileIndex t)

    69

{

    70

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

    71

}

    72

    73

static inline void SetLiftPosition(TileIndex t, byte pos)

    74

{

    75

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

    76

}

    77

    78

static inline Town* GetTownByTile(TileIndex t)

    79

{

    80

	return GetTown(GetTownIndex(t));

    81

}

    82

    83

    84

Town* CalcClosestTownFromTile(TileIndex tile, uint threshold);

    85

    86

    87

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

    88

{

    89

	assert(IsTileType(t, MP_CLEAR));

    90

    91

	SetTileType(t, MP_HOUSE);

    92

	_m[t].m1 = 0;

    93

	_m[t].m2 = tid;

    94

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

    95

	_m[t].m4 = type;

    96

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

    97

    98

	MarkTileDirtyByTile(t);

    99

}

   100

   101

enum {

   102

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

   103

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

   104

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

   105

};

   106

   107

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

   108

{

   109

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

   110

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

   111

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

   112

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

   113

}

   114

   115

/**

   116

 * House Construction Scheme.

   117

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

   118

 *  periodic tile processing.

   119

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

   120

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

   121

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

   122

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

   123

 *  different stages

   124

 */

   125

   126

/**

   127

 * Gets the building stage of a house

   128

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

   129

 * @pre IsTileType(t, MP_HOUSE)

   130

 * @return the building stage of the house

   131

 */

   132

static inline byte GetHouseBuildingStage(TileIndex t)

   133

{

   134

	assert(IsTileType(t, MP_HOUSE));

   135

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

   136

}

   137

   138

/**

   139

 * Sets the building stage of a house

   140

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

   141

 * @param stage the new stage

   142

 * @pre IsTileType(t, MP_HOUSE)

   143

 */

   144

static inline void SetHouseBuildingStage(TileIndex t, byte stage)

   145

{

   146

	assert(IsTileType(t, MP_HOUSE));

   147

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

   148

}

   149

   150

/**

   151

 * Increments the building stage of a house

   152

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

   153

 * @pre IsTileType(t, MP_HOUSE)

   154

 */

   155

static inline void IncHouseBuildingStage( TileIndex t )

   156

{

   157

	assert(IsTileType(t, MP_HOUSE));

   158

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

   159

}

   160

   161

/**

   162

 * Gets the construction stage of a house

   163

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

   164

 * @pre IsTileType(t, MP_HOUSE)

   165

 * @return the construction stage of the house

   166

 */

   167

static inline byte GetHouseConstructionTick(TileIndex t)

   168

{

   169

	assert(IsTileType(t, MP_HOUSE));

   170

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

   171

}

   172

   173

/**

   174

 * Sets the construction stage of a house

   175

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

   176

 * @param stage the new stage

   177

 * @pre IsTileType(t, MP_HOUSE)

   178

 */

   179

static inline void SetHouseConstructionTick(TileIndex t, byte stage)

   180

{

   181

	assert(IsTileType(t, MP_HOUSE));

   182

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

   183

}

   184

   185

/**

   186

 * Sets the increment stage of a house

   187

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

   188

 * @pre IsTileType(t, MP_HOUSE)

   189

 */

   190

static inline void IncHouseConstructionTick(TileIndex t)

   191

{

   192

	assert(IsTileType(t, MP_HOUSE));

   193

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

   194

}

   195

   196

   197

#endif /* TOWN_MAP_H */