OpenTTD

- Main Page
- Related Pages
- Modules
- Namespaces
- Data Structures
- Files

- File List
- Globals

rail.h
Go to the documentation of this file.
1 /* $Id: rail.h 27687 2016-12-10 13:26:29Z frosch $ */
2
3 /*
4 * This file is part of OpenTTD.
5 * 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.
6 * 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.
7 * 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/>.
8 */
9
12 #ifndef RAIL_H
13 #define RAIL_H
14
15 #include "rail_type.h"
16 #include "track_type.h"
17 #include "gfx_type.h"
18 #include "core/bitmath_func.hpp"
19 #include "economy_func.h"
20 #include "slope_type.h"
21 #include "strings_type.h"
22 #include "date_type.h"
23 #include "signal_type.h"
24
26 enum RailTypeFlags {
27 RTF_CATENARY = 0,
28 RTF_NO_LEVEL_CROSSING = 1,
29
30 RTFB_NONE = 0,
31 RTFB_CATENARY = 1 << RTF_CATENARY,
32 RTFB_NO_LEVEL_CROSSING = 1 << RTF_NO_LEVEL_CROSSING,
33 };
34 DECLARE_ENUM_AS_BIT_SET(RailTypeFlags)
35
36 struct SpriteGroup;
37
39 enum RailTypeSpriteGroup {
40 RTSG_CURSORS,
41 RTSG_OVERLAY,
42 RTSG_GROUND,
43 RTSG_TUNNEL,
44 RTSG_WIRES,
45 RTSG_PYLONS,
46 RTSG_BRIDGE,
47 RTSG_CROSSING,
48 RTSG_DEPOT,
49 RTSG_FENCES,
50 RTSG_TUNNEL_PORTAL,
51 RTSG_SIGNALS,
52 RTSG_END,
53 };
54
59 enum RailTrackOffset {
60 RTO_X,
61 RTO_Y,
62 RTO_N,
63 RTO_S,
64 RTO_E,
65 RTO_W,
66 RTO_SLOPE_NE,
67 RTO_SLOPE_SE,
68 RTO_SLOPE_SW,
69 RTO_SLOPE_NW,
70 RTO_CROSSING_XY,
71 RTO_JUNCTION_SW,
72 RTO_JUNCTION_NE,
73 RTO_JUNCTION_SE,
74 RTO_JUNCTION_NW,
75 RTO_JUNCTION_NSEW,
76 };
77
81 enum RailTrackBridgeOffset {
82 RTBO_X,
83 RTBO_Y,
84 RTBO_SLOPE,
85 };
86
91 enum RailFenceOffset {
92 RFO_FLAT_X_NW,
93 RFO_FLAT_Y_NE,
94 RFO_FLAT_LEFT,
95 RFO_FLAT_UPPER,
96 RFO_SLOPE_SW_NW,
97 RFO_SLOPE_SE_NE,
98 RFO_SLOPE_NE_NW,
99 RFO_SLOPE_NW_NE,
100 RFO_FLAT_X_SE,
101 RFO_FLAT_Y_SW,
102 RFO_FLAT_RIGHT,
103 RFO_FLAT_LOWER,
104 RFO_SLOPE_SW_SE,
105 RFO_SLOPE_SE_SW,
106 RFO_SLOPE_NE_SE,
107 RFO_SLOPE_NW_SW,
108 };
109
111 typedef SmallVector<RailTypeLabel, 4> RailTypeLabelList;
112
116 class RailtypeInfo {
117 public:
122 struct {
123 SpriteID track_y;
124 SpriteID track_ns;
125 SpriteID ground;
126 SpriteID single_x;
127 SpriteID single_y;
128 SpriteID single_n;
129 SpriteID single_s;
130 SpriteID single_e;
131 SpriteID single_w;
132 SpriteID single_sloped;
133 SpriteID crossing;
134 SpriteID tunnel;
135 } base_sprites;
136
141 struct {
142 SpriteID build_ns_rail;
143 SpriteID build_x_rail;
144 SpriteID build_ew_rail;
145 SpriteID build_y_rail;
146 SpriteID auto_rail;
147 SpriteID build_depot;
148 SpriteID build_tunnel;
149 SpriteID convert_rail;
150 SpriteID signals[SIGTYPE_END][2][2];
151 } gui_sprites;
152
153 struct {
154 CursorID rail_ns;
155 CursorID rail_swne;
156 CursorID rail_ew;
157 CursorID rail_nwse;
158 CursorID autorail;
159 CursorID depot;
160 CursorID tunnel;
161 CursorID convert;
162 } cursor;
163
164 struct {
165 StringID name;
166 StringID toolbar_caption;
167 StringID menu_text;
168 StringID build_caption;
169 StringID replace_text;
170 StringID new_loco;
171 } strings;
172
174 SpriteID snow_offset;
175
177 RailTypes powered_railtypes;
178
180 RailTypes compatible_railtypes;
181
185 SpriteID bridge_offset;
186
190 byte fallback_railtype;
191
195 byte curve_speed;
196
200 RailTypeFlags flags;
201
205 uint16 cost_multiplier;
206
210 uint16 maintenance_multiplier;
211
215 uint8 acceleration_type;
216
220 uint16 max_speed;
221
225 RailTypeLabel label;
226
230 RailTypeLabelList alternate_labels;
231
235 byte map_colour;
236
244 Date introduction_date;
245
250 RailTypes introduction_required_railtypes;
251
255 RailTypes introduces_railtypes;
256
260 byte sorting_order;
261
265 const GRFFile *grffile[RTSG_END];
266
270 const SpriteGroup *group[RTSG_END];
271
272 inline bool UsesOverlay() const
273 {
274 return this->group[RTSG_GROUND] != NULL;
275 }
276
284 inline uint GetRailtypeSpriteOffset() const
285 {
286 return 82 * this->fallback_railtype;
287 }
288 };
289
290
296 static inline const RailtypeInfo *GetRailTypeInfo(RailType railtype)
297 {
298 extern RailtypeInfo _railtypes[RAILTYPE_END];
299 assert(railtype < RAILTYPE_END);
300 return &_railtypes[railtype];
301 }
302
311 static inline bool IsCompatibleRail(RailType enginetype, RailType tiletype)
312 {
313 return HasBit(GetRailTypeInfo(enginetype)->compatible_railtypes, tiletype);
314 }
315
324 static inline bool HasPowerOnRail(RailType enginetype, RailType tiletype)
325 {
326 return HasBit(GetRailTypeInfo(enginetype)->powered_railtypes, tiletype);
327 }
328
334 static inline bool RailNoLevelCrossings(RailType rt)
335 {
336 return HasBit(GetRailTypeInfo(rt)->flags, RTF_NO_LEVEL_CROSSING);
337 }
338
344 static inline Money RailBuildCost(RailType railtype)
345 {
346 assert(railtype < RAILTYPE_END);
347 return (_price[PR_BUILD_RAIL] * GetRailTypeInfo(railtype)->cost_multiplier) >> 3;
348 }
349
355 static inline Money RailClearCost(RailType railtype)
356 {
357 /* Clearing rail in fact earns money, but if the build cost is set
358 * very low then a loophole exists where money can be made.
359 * In this case we limit the removal earnings to 3/4s of the build
360 * cost.
361 */
362 assert(railtype < RAILTYPE_END);
363 return max(_price[PR_CLEAR_RAIL], -RailBuildCost(railtype) * 3 / 4);
364 }
365
372 static inline Money RailConvertCost(RailType from, RailType to)
373 {
374 /* Get the costs for removing and building anew
375 * A conversion can never be more costly */
376 Money rebuildcost = RailBuildCost(to) + RailClearCost(from);
377
378 /* Conversion between somewhat compatible railtypes:
379 * Pay 1/8 of the target rail cost (labour costs) and additionally any difference in the
380 * build costs, if the target type is more expensive (material upgrade costs).
381 * Upgrade can never be more expensive than re-building. */
382 if (HasPowerOnRail(from, to) || HasPowerOnRail(to, from)) {
383 Money upgradecost = RailBuildCost(to) / 8 + max((Money)0, RailBuildCost(to) - RailBuildCost(from));
384 return min(upgradecost, rebuildcost);
385 }
386
387 /* make the price the same as remove + build new type for rail types
388 * which are not compatible in any way */
389 return rebuildcost;
390 }
391
399 static inline Money RailMaintenanceCost(RailType railtype, uint32 num, uint32 total_num)
400 {
401 assert(railtype < RAILTYPE_END);
402 return (_price[PR_INFRASTRUCTURE_RAIL] * GetRailTypeInfo(railtype)->maintenance_multiplier * num * (1 + IntSqrt(total_num))) >> 11; // 4 bits fraction for the multiplier and 7 bits scaling.
403 }
404
410 static inline Money SignalMaintenanceCost(uint32 num)
411 {
412 return (_price[PR_INFRASTRUCTURE_RAIL] * 15 * num * (1 + IntSqrt(num))) >> 8; // 1 bit fraction for the multiplier and 7 bits scaling.
413 }
414
415 void DrawTrainDepotSprite(int x, int y, int image, RailType railtype);
416 int TicksToLeaveDepot(const Train *v);
417
418 Foundation GetRailFoundation(Slope tileh, TrackBits bits);
419
420
421 bool HasRailtypeAvail(const CompanyID company, const RailType railtype);
422 bool ValParamRailtype(const RailType rail);
423
424 RailTypes AddDateIntroducedRailTypes(RailTypes current, Date date);
425
426 RailType GetBestRailtype(const CompanyID company);
427 RailTypes GetCompanyRailtypes(const CompanyID c);
428
429 RailType GetRailTypeByLabel(RailTypeLabel label, bool allow_alternate_labels = true);
430
431 void ResetRailTypes();
432 void InitRailTypes();
433 RailType AllocateRailType(RailTypeLabel label);
434
435 extern RailType _sorted_railtypes[RAILTYPE_END];
436 extern uint8 _sorted_railtypes_size;
437
442 #define FOR_ALL_SORTED_RAILTYPES(var) for (uint8 index = 0; index < _sorted_railtypes_size && (var = _sorted_railtypes[index], true) ; index++)
443
444 #endif /* RAIL_H */