87 default: NOT_REACHED(); |
87 default: NOT_REACHED(); |
88 case ROAD_TILE_NORMAL: |
88 case ROAD_TILE_NORMAL: |
89 switch (rt) { |
89 switch (rt) { |
90 default: NOT_REACHED(); |
90 default: NOT_REACHED(); |
91 case ROADTYPE_ROAD: return (Owner)GB( _m[t].m1, 0, 5); |
91 case ROADTYPE_ROAD: return (Owner)GB( _m[t].m1, 0, 5); |
92 case ROADTYPE_TRAM: return (Owner)GB( _m[t].m5, 0, 5); |
92 case ROADTYPE_TRAM: { |
|
93 /* Trams don't need OWNER_TOWN, and remapping OWNER_NONE |
|
94 * to OWNER_TOWN makes it use one bit less */ |
|
95 Owner o = (Owner)GB( _m[t].m5, 0, 4); |
|
96 return o == OWNER_TOWN ? OWNER_NONE : o; |
|
97 } |
93 case ROADTYPE_HWAY: return (Owner)GB(_me[t].m7, 0, 5); |
98 case ROADTYPE_HWAY: return (Owner)GB(_me[t].m7, 0, 5); |
94 } |
99 } |
95 case ROAD_TILE_CROSSING: |
100 case ROAD_TILE_CROSSING: |
96 switch (rt) { |
101 switch (rt) { |
97 default: NOT_REACHED(); |
102 default: NOT_REACHED(); |
98 case ROADTYPE_ROAD: return (Owner)GB( _m[t].m4, 0, 5); |
103 case ROADTYPE_ROAD: return (Owner)GB( _m[t].m4, 0, 5); |
99 case ROADTYPE_TRAM: return (Owner)GB( _m[t].m5, 0, 5); |
104 case ROADTYPE_TRAM: { |
|
105 /* Trams don't need OWNER_TOWN, and remapping OWNER_NONE |
|
106 * to OWNER_TOWN makes it use one bit less */ |
|
107 Owner o = (Owner)GB( _m[t].m5, 0, 4); |
|
108 return o == OWNER_TOWN ? OWNER_NONE : o; |
|
109 } |
100 case ROADTYPE_HWAY: return (Owner)GB(_me[t].m7, 0, 5); |
110 case ROADTYPE_HWAY: return (Owner)GB(_me[t].m7, 0, 5); |
101 } |
111 } |
102 case ROAD_TILE_DEPOT: return GetTileOwner(t); |
112 case ROAD_TILE_DEPOT: return GetTileOwner(t); |
103 } |
113 } |
104 } |
114 } |
111 default: NOT_REACHED(); |
121 default: NOT_REACHED(); |
112 case ROAD_TILE_NORMAL: |
122 case ROAD_TILE_NORMAL: |
113 switch (rt) { |
123 switch (rt) { |
114 default: NOT_REACHED(); |
124 default: NOT_REACHED(); |
115 case ROADTYPE_ROAD: SB( _m[t].m1, 0, 5, o); break; |
125 case ROADTYPE_ROAD: SB( _m[t].m1, 0, 5, o); break; |
116 case ROADTYPE_TRAM: SB( _m[t].m5, 0, 5, o); break; |
126 /* Trams don't need OWNER_TOWN, and remapping OWNER_NONE |
|
127 * to OWNER_TOWN makes it use one bit less */ |
|
128 case ROADTYPE_TRAM: SB( _m[t].m5, 0, 4, o == OWNER_NONE ? OWNER_TOWN : o); break; |
117 case ROADTYPE_HWAY: SB(_me[t].m7, 0, 5, o); break; |
129 case ROADTYPE_HWAY: SB(_me[t].m7, 0, 5, o); break; |
118 } |
130 } |
119 break; |
131 break; |
120 case ROAD_TILE_CROSSING: |
132 case ROAD_TILE_CROSSING: |
121 switch (rt) { |
133 switch (rt) { |
122 default: NOT_REACHED(); |
134 default: NOT_REACHED(); |
123 case ROADTYPE_ROAD: SB( _m[t].m4, 0, 5, o); break; |
135 case ROADTYPE_ROAD: SB( _m[t].m4, 0, 5, o); break; |
124 case ROADTYPE_TRAM: SB( _m[t].m5, 0, 5, o); break; |
136 /* Trams don't need OWNER_TOWN, and remapping OWNER_NONE |
|
137 * to OWNER_TOWN makes it use one bit less */ |
|
138 case ROADTYPE_TRAM: SB( _m[t].m5, 0, 4, o == OWNER_NONE ? OWNER_TOWN : o); break; |
125 case ROADTYPE_HWAY: SB(_me[t].m7, 0, 5, o); break; |
139 case ROADTYPE_HWAY: SB(_me[t].m7, 0, 5, o); break; |
126 } |
140 } |
127 break; |
141 break; |
128 case ROAD_TILE_DEPOT: return SetTileOwner(t, o); |
142 case ROAD_TILE_DEPOT: return SetTileOwner(t, o); |
129 } |
143 } |
|
144 } |
|
145 |
|
146 /** Which directions are disallowed ? */ |
|
147 enum DisallowedRoadDirections { |
|
148 DRD_NONE, ///< None of the directions are disallowed |
|
149 DRD_SOUTHBOUND, ///< All southbound traffic is disallowed |
|
150 DRD_NORTHBOUND, ///< All northbound traffic is disallowed |
|
151 DRD_BOTH, ///< All directions are disallowed |
|
152 DRD_END |
|
153 }; |
|
154 DECLARE_ENUM_AS_BIT_SET(DisallowedRoadDirections); |
|
155 |
|
156 /** |
|
157 * Gets the disallowed directions |
|
158 * @param t the tile to get the directions from |
|
159 * @return the disallowed directions |
|
160 */ |
|
161 static inline DisallowedRoadDirections GetDisallowedRoadDirections(TileIndex t) |
|
162 { |
|
163 assert(GetRoadTileType(t) == ROAD_TILE_NORMAL); |
|
164 return (DisallowedRoadDirections)GB(_m[t].m5, 4, 2); |
|
165 } |
|
166 |
|
167 /** |
|
168 * Sets the disallowed directions |
|
169 * @param t the tile to set the directions for |
|
170 * @param drd the disallowed directions |
|
171 */ |
|
172 static inline void SetDisallowedRoadDirections(TileIndex t, DisallowedRoadDirections drd) |
|
173 { |
|
174 assert(GetRoadTileType(t) == ROAD_TILE_NORMAL); |
|
175 assert(drd < DRD_END); |
|
176 SB(_m[t].m5, 4, 2, drd); |
130 } |
177 } |
131 |
178 |
132 static inline Axis GetCrossingRoadAxis(TileIndex t) |
179 static inline Axis GetCrossingRoadAxis(TileIndex t) |
133 { |
180 { |
134 assert(GetRoadTileType(t) == ROAD_TILE_CROSSING); |
181 assert(GetRoadTileType(t) == ROAD_TILE_CROSSING); |