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 street tile.

    24

 * @param tile the tile

    25

 * @param index the index of the town

    26

 * @pre IsTileType(tile, MP_STREET)

    27

 */

    28

static inline void SetTownIndex(TileIndex t, TownID index)

    29

{

    30

	assert(IsTileType(t, MP_STREET));

    31

	_m[t].m2 = index;

    32

}

    33

    34

static inline bool LiftHasDestination(TileIndex t)

    35

{

    36

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

    37

}

    38

    39

static inline void SetLiftDestination(TileIndex t, byte dest)

    40

{

    41

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

    42

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

    43

}

    44

    45

static inline byte GetLiftDestination(TileIndex t)

    46

{

    47

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

    48

}

    49

    50

static inline bool IsLiftMoving(TileIndex t)

    51

{

    52

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

    53

}

    54

    55

static inline void BeginLiftMovement(TileIndex t)

    56

{

    57

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

    58

}

    59

    60

static inline void HaltLift(TileIndex t)

    61

{

    62

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

    63

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

    64

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

    65

    66

	DeleteAnimatedTile(t);

    67

}

    68

    69

static inline byte GetLiftPosition(TileIndex t)

    70

{

    71

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

    72

}

    73

    74

static inline void SetLiftPosition(TileIndex t, byte pos)

    75

{

    76

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

    77

}

    78

    79

static inline Town* GetTownByTile(TileIndex t)

    80

{

    81

	return GetTown(GetTownIndex(t));

    82

}

    83

    84

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

    85

{

    86

	assert(IsTileType(t, MP_CLEAR));

    87

    88

	SetTileType(t, MP_HOUSE);

    89

	_m[t].m1 = 0;

    90

	_m[t].m2 = tid;

    91

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

    92

	_m[t].m4 = type;

    93

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

    94

    95

	MarkTileDirtyByTile(t);

    96

}

    97

    98

enum {

    99

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

   100

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

   101

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

   102

};

   103

   104

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

   105

{

   106

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

   107

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

   108

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

   109

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

   110

}

   111

   112

/**

   113

 * House Construction Scheme.

   114

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

   115

 *  periodic tile processing.

   116

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

   117

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

   118

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

   119

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

   120

 *  different stages

   121

 */

   122

   123

/**

   124

 * Gets the building stage of a house

   125

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

   126

 * @pre IsTileType(t, MP_HOUSE)

   127

 * @return the building stage of the house

   128

 */

   129

static inline byte GetHouseBuildingStage(TileIndex t)

   130

{

   131

	assert(IsTileType(t, MP_HOUSE));

   132

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

   133

}

   134

   135

/**

   136

 * Sets the building stage of a house

   137

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

   138

 * @param stage the new stage

   139

 * @pre IsTileType(t, MP_HOUSE)

   140

 */

   141

static inline void SetHouseBuildingStage(TileIndex t, byte stage)

   142

{

   143

	assert(IsTileType(t, MP_HOUSE));

   144

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

   145

}

   146

   147

/**

   148

 * Increments the building stage of a house

   149

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

   150

 * @pre IsTileType(t, MP_HOUSE)

   151

 */

   152

static inline void IncHouseBuildingStage( TileIndex t )

   153

{

   154

	assert(IsTileType(t, MP_HOUSE));

   155

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

   156

}

   157

   158

/**

   159

 * Gets the construction stage of a house

   160

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

   161

 * @pre IsTileType(t, MP_HOUSE)

   162

 * @return the construction stage of the house

   163

 */

   164

static inline byte GetHouseConstructionTick(TileIndex t)

   165

{

   166

	assert(IsTileType(t, MP_HOUSE));

   167

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

   168

}

   169

   170

/**

   171

 * Sets the construction stage of a house

   172

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

   173

 * @param stage the new stage

   174

 * @pre IsTileType(t, MP_HOUSE)

   175

 */

   176

static inline void SetHouseConstructionTick(TileIndex t, byte stage)

   177

{

   178

	assert(IsTileType(t, MP_HOUSE));

   179

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

   180

}

   181

   182

/**

   183

 * Sets the increment stage of a house

   184

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

   185

 * @pre IsTileType(t, MP_HOUSE)

   186

 */

   187

static inline void IncHouseConstructionTick(TileIndex t)

   188

{

   189

	assert(IsTileType(t, MP_HOUSE));

   190

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

   191

}

   192

   193

   194

#endif /* TOWN_MAP_H */