1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
/* $Id$ */
/*
* This file is part of OpenTTD.
* OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
* OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
*/
/** @file road_func.h Functions related to roads. */
#ifndef ROAD_FUNC_H
#define ROAD_FUNC_H
#include "core/bitmath_func.hpp"
#include "road_type.h"
#include "economy_func.h"
/**
* Iterate through each set RoadType in a RoadTypes value.
* For more informations see FOR_EACH_SET_BIT_EX.
*
* @param var Loop index variable that stores fallowing set road type. Must be of type RoadType.
* @param road_types The value to iterate through (any expression).
*
* @see FOR_EACH_SET_BIT_EX
*/
#define FOR_EACH_SET_ROADTYPE(var, road_types) FOR_EACH_SET_BIT_EX(RoadType, var, RoadTypes, road_types)
/**
* Whether the given roadtype is valid.
* @param rt the roadtype to check for validness
* @return true if and only if valid
*/
static inline bool IsValidRoadType(RoadType rt)
{
return rt == ROADTYPE_ROAD || rt == ROADTYPE_TRAM;
}
/**
* Whether the given roadtype is valid.
* @param r the roadtype to check for validness
* @return true if and only if valid
*/
static inline bool IsValidRoadBits(RoadBits r)
{
return r < ROAD_END;
}
/**
* Maps a RoadType to the corresponding RoadTypes value
*
* @param rt the roadtype to get the roadtypes from
* @return the roadtypes with the given roadtype
*/
static inline RoadTypes RoadTypeToRoadTypes(RoadType rt)
{
assert(IsValidRoadType(rt));
return (RoadTypes)(1 << rt);
}
/**
* Returns the RoadTypes which are not present in the given RoadTypes
*
* This function returns the complement of a given RoadTypes.
*
* @param r The given RoadTypes
* @return The complement of the given RoadTypes
*/
static inline RoadTypes ComplementRoadTypes(RoadTypes r)
{
return (RoadTypes)(ROADTYPES_ALL ^ r);
}
/**
* Calculate the complement of a RoadBits value
*
* Simply flips all bits in the RoadBits value to get the complement
* of the RoadBits.
*
* @param r The given RoadBits value
* @return the complement
*/
static inline RoadBits ComplementRoadBits(RoadBits r)
{
assert(IsValidRoadBits(r));
return (RoadBits)(ROAD_ALL ^ r);
}
/**
* Calculate the mirrored RoadBits
*
* Simply move the bits to their new position.
*
* @param r The given RoadBits value
* @return the mirrored
*/
static inline RoadBits MirrorRoadBits(RoadBits r)
{
assert(IsValidRoadBits(r));
return (RoadBits)(GB(r, 0, 2) << 2 | GB(r, 2, 2));
}
/**
* Calculate rotated RoadBits
*
* Move the Roadbits clockwise until they are in their final position.
*
* @param r The given RoadBits value
* @param rot The given Rotation angle
* @return the rotated
*/
static inline RoadBits RotateRoadBits(RoadBits r, DiagDirDiff rot)
{
assert(IsValidRoadBits(r));
for (; rot > (DiagDirDiff)0; rot--) {
r = (RoadBits)(GB(r, 0, 1) << 3 | GB(r, 1, 3));
}
return r;
}
/**
* Check if we've got a straight road
*
* @param r The given RoadBits
* @return true if we've got a straight road
*/
static inline bool IsStraightRoad(RoadBits r)
{
assert(IsValidRoadBits(r));
return (r == ROAD_X || r == ROAD_Y);
}
/**
* Create the road-part which belongs to the given DiagDirection
*
* This function returns a RoadBits value which belongs to
* the given DiagDirection.
*
* @param d The DiagDirection
* @return The result RoadBits which the selected road-part set
*/
static inline RoadBits DiagDirToRoadBits(DiagDirection d)
{
assert(IsValidDiagDirection(d));
return (RoadBits)(ROAD_NW << (3 ^ d));
}
/**
* Create the road-part which belongs to the given Axis
*
* This function returns a RoadBits value which belongs to
* the given Axis.
*
* @param a The Axis
* @return The result RoadBits which the selected road-part set
*/
static inline RoadBits AxisToRoadBits(Axis a)
{
assert(IsValidAxis(a));
return a == AXIS_X ? ROAD_X : ROAD_Y;
}
/**
* Calculates the maintenance cost of a number of road bits.
* @param roadtype Road type to get the cost for.
* @param num Number of road bits.
* @return Total cost.
*/
static inline Money RoadMaintenanceCost(RoadType roadtype, uint32 num)
{
assert(IsValidRoadType(roadtype));
return (_price[PR_INFRASTRUCTURE_ROAD] * (roadtype == ROADTYPE_TRAM ? 3 : 2) * num * (1 + IntSqrt(num))) >> 9; // 2 bits fraction for the multiplier and 7 bits scaling.
}
bool HasRoadTypesAvail(const CompanyID company, const RoadTypes rts);
bool ValParamRoadType(const RoadType rt);
RoadTypes GetCompanyRoadtypes(const CompanyID company);
void UpdateLevelCrossing(TileIndex tile, bool sound = true);
#endif /* ROAD_FUNC_H */
|
