|
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 */ |