OpenTTD Source: src/rail_cmd.cpp Source File

OpenTTD Source 14.0-beta1

rail_cmd.cpp
Go to the documentation of this file.
1 /*
2 * This file is part of OpenTTD.
3 * 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.
4 * 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.
5 * 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/>.
6 */
7
10 #include "stdafx.h"
11 #include "viewport_func.h"
12 #include "command_func.h"
13 #include "depot_base.h"
14 #include "pathfinder/yapf/yapf_cache.h"
15 #include "newgrf_debug.h"
16 #include "newgrf_railtype.h"
17 #include "train.h"
18 #include "autoslope.h"
19 #include "water.h"
20 #include "tunnelbridge_map.h"
21 #include "vehicle_func.h"
22 #include "sound_func.h"
23 #include "tunnelbridge.h"
24 #include "elrail_func.h"
25 #include "town.h"
26 #include "pbs.h"
27 #include "company_base.h"
28 #include "core/backup_type.hpp"
29 #include "core/container_func.hpp"
30 #include "timer/timer_game_calendar.h"
31 #include "strings_func.h"
32 #include "company_gui.h"
33 #include "object_map.h"
34 #include "rail_cmd.h"
35 #include "landscape_cmd.h"
36
37 #include "table/strings.h"
38 #include "table/railtypes.h"
39 #include "table/track_land.h"
40
41 #include "safeguards.h"
42
44 typedef std::vector<Train *> TrainList;
45
46 RailTypeInfo _railtypes[RAILTYPE_END];
47 std::vector<RailType> _sorted_railtypes;
48 RailTypes _railtypes_hidden_mask;
49
51 enum SignalOffsets {
52 SIGNAL_TO_SOUTHWEST,
53 SIGNAL_TO_NORTHEAST,
54 SIGNAL_TO_SOUTHEAST,
55 SIGNAL_TO_NORTHWEST,
56 SIGNAL_TO_EAST,
57 SIGNAL_TO_WEST,
58 SIGNAL_TO_SOUTH,
59 SIGNAL_TO_NORTH,
60 };
61
65 void ResetRailTypes()
66 {
67 static_assert(lengthof(_original_railtypes) <= lengthof(_railtypes));
68
69 auto insert = std::copy(std::begin(_original_railtypes), std::end(_original_railtypes), std::begin(_railtypes));
70 std::fill(insert, std::end(_railtypes), RailTypeInfo{});
71
72 _railtypes_hidden_mask = RAILTYPES_NONE;
73 }
74
75 void ResolveRailTypeGUISprites(RailTypeInfo *rti)
76 {
77 SpriteID cursors_base = GetCustomRailSprite(rti, INVALID_TILE, RTSG_CURSORS);
78 if (cursors_base != 0) {
79 rti->gui_sprites.build_ns_rail = cursors_base + 0;
80 rti->gui_sprites.build_x_rail = cursors_base + 1;
81 rti->gui_sprites.build_ew_rail = cursors_base + 2;
82 rti->gui_sprites.build_y_rail = cursors_base + 3;
83 rti->gui_sprites.auto_rail = cursors_base + 4;
84 rti->gui_sprites.build_depot = cursors_base + 5;
85 rti->gui_sprites.build_tunnel = cursors_base + 6;
86 rti->gui_sprites.convert_rail = cursors_base + 7;
87 rti->cursor.rail_ns = cursors_base + 8;
88 rti->cursor.rail_swne = cursors_base + 9;
89 rti->cursor.rail_ew = cursors_base + 10;
90 rti->cursor.rail_nwse = cursors_base + 11;
91 rti->cursor.autorail = cursors_base + 12;
92 rti->cursor.depot = cursors_base + 13;
93 rti->cursor.tunnel = cursors_base + 14;
94 rti->cursor.convert = cursors_base + 15;
95 }
96
97 /* Array of default GUI signal sprite numbers. */
98 const SpriteID _signal_lookup[2][SIGTYPE_END] = {
99 {SPR_IMG_SIGNAL_ELECTRIC_NORM, SPR_IMG_SIGNAL_ELECTRIC_ENTRY, SPR_IMG_SIGNAL_ELECTRIC_EXIT,
100 SPR_IMG_SIGNAL_ELECTRIC_COMBO, SPR_IMG_SIGNAL_ELECTRIC_PBS, SPR_IMG_SIGNAL_ELECTRIC_PBS_OWAY},
101
102 {SPR_IMG_SIGNAL_SEMAPHORE_NORM, SPR_IMG_SIGNAL_SEMAPHORE_ENTRY, SPR_IMG_SIGNAL_SEMAPHORE_EXIT,
103 SPR_IMG_SIGNAL_SEMAPHORE_COMBO, SPR_IMG_SIGNAL_SEMAPHORE_PBS, SPR_IMG_SIGNAL_SEMAPHORE_PBS_OWAY},
104 };
105
106 for (SignalType type = SIGTYPE_BLOCK; type < SIGTYPE_END; type = (SignalType)(type + 1)) {
107 for (SignalVariant var = SIG_ELECTRIC; var <= SIG_SEMAPHORE; var = (SignalVariant)(var + 1)) {
108 SpriteID red = GetCustomSignalSprite(rti, INVALID_TILE, type, var, SIGNAL_STATE_RED, true);
109 SpriteID green = GetCustomSignalSprite(rti, INVALID_TILE, type, var, SIGNAL_STATE_GREEN, true);
110 rti->gui_sprites.signals[type][var][0] = (red != 0) ? red + SIGNAL_TO_SOUTH : _signal_lookup[var][type];
111 rti->gui_sprites.signals[type][var][1] = (green != 0) ? green + SIGNAL_TO_SOUTH : _signal_lookup[var][type] + 1;
112 }
113 }
114 }
115
122 static bool CompareRailTypes(const RailType &first, const RailType &second)
123 {
124 return GetRailTypeInfo(first)->sorting_order < GetRailTypeInfo(second)->sorting_order;
125 }
126
130 void InitRailTypes()
131 {
132 for (RailType rt = RAILTYPE_BEGIN; rt != RAILTYPE_END; rt++) {
133 RailTypeInfo *rti = &_railtypes[rt];
134 ResolveRailTypeGUISprites(rti);
135 if (HasBit(rti->flags, RTF_HIDDEN)) SetBit(_railtypes_hidden_mask, rt);
136 }
137
138 _sorted_railtypes.clear();
139 for (RailType rt = RAILTYPE_BEGIN; rt != RAILTYPE_END; rt++) {
140 if (_railtypes[rt].label != 0 && !HasBit(_railtypes_hidden_mask, rt)) {
141 _sorted_railtypes.push_back(rt);
142 }
143 }
144 std::sort(_sorted_railtypes.begin(), _sorted_railtypes.end(), CompareRailTypes);
145 }
146
150 RailType AllocateRailType(RailTypeLabel label)
151 {
152 for (RailType rt = RAILTYPE_BEGIN; rt != RAILTYPE_END; rt++) {
153 RailTypeInfo *rti = &_railtypes[rt];
154
155 if (rti->label == 0) {
156 /* Set up new rail type */
157 *rti = _original_railtypes[RAILTYPE_RAIL];
158 rti->label = label;
159 rti->alternate_labels.clear();
160
161 /* Make us compatible with ourself. */
162 rti->powered_railtypes = (RailTypes)(1LL << rt);
163 rti->compatible_railtypes = (RailTypes)(1LL << rt);
164
165 /* We also introduce ourself. */
166 rti->introduces_railtypes = (RailTypes)(1LL << rt);
167
168 /* Default sort order; order of allocation, but with some
169 * offsets so it's easier for NewGRF to pick a spot without
170 * changing the order of other (original) rail types.
171 * The << is so you can place other railtypes in between the
172 * other railtypes, the 7 is to be able to place something
173 * before the first (default) rail type. */
174 rti->sorting_order = rt << 4 | 7;
175 return rt;
176 }
177 }
178
179 return INVALID_RAILTYPE;
180 }
181
182 static const byte _track_sloped_sprites[14] = {
183 14, 15, 22, 13,
184 0, 21, 17, 12,
185 23, 0, 18, 20,
186 19, 16
187 };
188
189
190 /* 4
191 * ---------
192 * |\ /|
193 * | \ 1/ |
194 * | \ / |
195 * | \ / |
196 * 16| \ |32
197 * | / \2 |
198 * | / \ |
199 * | / \ |
200 * |/ \|
201 * ---------
202 * 8
203 */
204
205
206
207 /* MAP2 byte: abcd???? => Signal On? Same coding as map3lo
208 * MAP3LO byte: abcd???? => Signal Exists?
209 * a and b are for diagonals, upper and left,
210 * one for each direction. (ie a == NE->SW, b ==
211 * SW->NE, or v.v., I don't know. b and c are
212 * similar for lower and right.
213 * MAP2 byte: ????abcd => Type of ground.
214 * MAP3LO byte: ????abcd => Type of rail.
215 * MAP5: 00abcdef => rail
216 * 01abcdef => rail w/ signals
217 * 10uuuuuu => unused
218 * 11uuuudd => rail depot
219 */
220
229 static CommandCost EnsureNoTrainOnTrack(TileIndex tile, Track track)
230 {
231 TrackBits rail_bits = TrackToTrackBits(track);
232 return EnsureNoTrainOnTrackBits(tile, rail_bits);
233 }
234
241 static CommandCost CheckTrackCombination(TileIndex tile, TrackBits to_build)
242 {
243 if (!IsPlainRail(tile)) return_cmd_error(STR_ERROR_IMPOSSIBLE_TRACK_COMBINATION);
244
245 /* So, we have a tile with tracks on it (and possibly signals). Let's see
246 * what tracks first */
247 TrackBits current = GetTrackBits(tile); // The current track layout.
248 TrackBits future = current | to_build; // The track layout we want to build.
249
250 /* Are we really building something new? */
251 if (current == future) {
252 /* Nothing new is being built */
253 return_cmd_error(STR_ERROR_ALREADY_BUILT);
254 }
255
256 /* Normally, we may overlap and any combination is valid */
257 return CommandCost();
258 }
259
260
262 static const TrackBits _valid_tracks_without_foundation[15] = {
263 TRACK_BIT_ALL,
264 TRACK_BIT_RIGHT,
265 TRACK_BIT_UPPER,
266 TRACK_BIT_X,
267
268 TRACK_BIT_LEFT,
269 TRACK_BIT_NONE,
270 TRACK_BIT_Y,
271 TRACK_BIT_LOWER,
272
273 TRACK_BIT_LOWER,
274 TRACK_BIT_Y,
275 TRACK_BIT_NONE,
276 TRACK_BIT_LEFT,
277
278 TRACK_BIT_X,
279 TRACK_BIT_UPPER,
280 TRACK_BIT_RIGHT,
281 };
282
284 static const TrackBits _valid_tracks_on_leveled_foundation[15] = {
285 TRACK_BIT_NONE,
286 TRACK_BIT_LEFT,
287 TRACK_BIT_LOWER,
288 TRACK_BIT_Y | TRACK_BIT_LOWER | TRACK_BIT_LEFT,
289
290 TRACK_BIT_RIGHT,
291 TRACK_BIT_ALL,
292 TRACK_BIT_X | TRACK_BIT_LOWER | TRACK_BIT_RIGHT,
293 TRACK_BIT_ALL,
294
295 TRACK_BIT_UPPER,
296 TRACK_BIT_X | TRACK_BIT_UPPER | TRACK_BIT_LEFT,
297 TRACK_BIT_ALL,
298 TRACK_BIT_ALL,
299
300 TRACK_BIT_Y | TRACK_BIT_UPPER | TRACK_BIT_RIGHT,
301 TRACK_BIT_ALL,
302 TRACK_BIT_ALL
303 };
304
312 Foundation GetRailFoundation(Slope tileh, TrackBits bits)
313 {
314 if (bits == TRACK_BIT_NONE) return FOUNDATION_NONE;
315
316 if (IsSteepSlope(tileh)) {
317 /* Test for inclined foundations */
318 if (bits == TRACK_BIT_X) return FOUNDATION_INCLINED_X;
319 if (bits == TRACK_BIT_Y) return FOUNDATION_INCLINED_Y;
320
321 /* Get higher track */
322 Corner highest_corner = GetHighestSlopeCorner(tileh);
323 TrackBits higher_track = CornerToTrackBits(highest_corner);
324
325 /* Only higher track? */
326 if (bits == higher_track) return HalftileFoundation(highest_corner);
327
328 /* Overlap with higher track? */
329 if (TracksOverlap(bits | higher_track)) return FOUNDATION_INVALID;
330
331 /* either lower track or both higher and lower track */
332 return ((bits & higher_track) != 0 ? FOUNDATION_STEEP_BOTH : FOUNDATION_STEEP_LOWER);
333 } else {
334 if ((~_valid_tracks_without_foundation[tileh] & bits) == 0) return FOUNDATION_NONE;
335
336 bool valid_on_leveled = ((~_valid_tracks_on_leveled_foundation[tileh] & bits) == 0);
337
338 Corner track_corner;
339 switch (bits) {
340 case TRACK_BIT_LEFT: track_corner = CORNER_W; break;
341 case TRACK_BIT_LOWER: track_corner = CORNER_S; break;
342 case TRACK_BIT_RIGHT: track_corner = CORNER_E; break;
343 case TRACK_BIT_UPPER: track_corner = CORNER_N; break;
344
345 case TRACK_BIT_HORZ:
346 if (tileh == SLOPE_N) return HalftileFoundation(CORNER_N);
347 if (tileh == SLOPE_S) return HalftileFoundation(CORNER_S);
348 return (valid_on_leveled ? FOUNDATION_LEVELED : FOUNDATION_INVALID);
349
350 case TRACK_BIT_VERT:
351 if (tileh == SLOPE_W) return HalftileFoundation(CORNER_W);
352 if (tileh == SLOPE_E) return HalftileFoundation(CORNER_E);
353 return (valid_on_leveled ? FOUNDATION_LEVELED : FOUNDATION_INVALID);
354
355 case TRACK_BIT_X:
356 if (IsSlopeWithOneCornerRaised(tileh)) return FOUNDATION_INCLINED_X;
357 return (valid_on_leveled ? FOUNDATION_LEVELED : FOUNDATION_INVALID);
358
359 case TRACK_BIT_Y:
360 if (IsSlopeWithOneCornerRaised(tileh)) return FOUNDATION_INCLINED_Y;
361 return (valid_on_leveled ? FOUNDATION_LEVELED : FOUNDATION_INVALID);
362
363 default:
364 return (valid_on_leveled ? FOUNDATION_LEVELED : FOUNDATION_INVALID);
365 }
366 /* Single diagonal track */
367
368 /* Track must be at least valid on leveled foundation */
369 if (!valid_on_leveled) return FOUNDATION_INVALID;
370
371 /* If slope has three raised corners, build leveled foundation */
372 if (IsSlopeWithThreeCornersRaised(tileh)) return FOUNDATION_LEVELED;
373
374 /* If neighboured corners of track_corner are lowered, build halftile foundation */
375 if ((tileh & SlopeWithThreeCornersRaised(OppositeCorner(track_corner))) == SlopeWithOneCornerRaised(track_corner)) return HalftileFoundation(track_corner);
376
377 /* else special anti-zig-zag foundation */
378 return SpecialRailFoundation(track_corner);
379 }
380 }
381
382
392 static CommandCost CheckRailSlope(Slope tileh, TrackBits rail_bits, TrackBits existing, TileIndex tile)
393 {
394 /* don't allow building on the lower side of a coast */
395 if (GetFloodingBehaviour(tile) != FLOOD_NONE) {
396 if (!IsSteepSlope(tileh) && ((~_valid_tracks_on_leveled_foundation[tileh] & (rail_bits | existing)) != 0)) return_cmd_error(STR_ERROR_CAN_T_BUILD_ON_WATER);
397 }
398
399 Foundation f_new = GetRailFoundation(tileh, rail_bits | existing);
400
401 /* check track/slope combination */
402 if ((f_new == FOUNDATION_INVALID) ||
403 ((f_new != FOUNDATION_NONE) && (!_settings_game.construction.build_on_slopes))) {
404 return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
405 }
406
407 Foundation f_old = GetRailFoundation(tileh, existing);
408 return CommandCost(EXPENSES_CONSTRUCTION, f_new != f_old ? _price[PR_BUILD_FOUNDATION] : (Money)0);
409 }
410
411 /* Validate functions for rail building */
412 static inline bool ValParamTrackOrientation(Track track)
413 {
414 return IsValidTrack(track);
415 }
416
426 CommandCost CmdBuildSingleRail(DoCommandFlag flags, TileIndex tile, RailType railtype, Track track, bool auto_remove_signals)
427 {
428 CommandCost cost(EXPENSES_CONSTRUCTION);
429
430 if (!ValParamRailType(railtype) || !ValParamTrackOrientation(track)) return CMD_ERROR;
431
432 Slope tileh = GetTileSlope(tile);
433 TrackBits trackbit = TrackToTrackBits(track);
434
435 switch (GetTileType(tile)) {
436 case MP_RAILWAY: {
437 CommandCost ret = CheckTileOwnership(tile);
438 if (ret.Failed()) return ret;
439
440 if (!IsPlainRail(tile)) return Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile); // just get appropriate error message
441
442 if (!IsCompatibleRail(GetRailType(tile), railtype)) return_cmd_error(STR_ERROR_IMPOSSIBLE_TRACK_COMBINATION);
443
444 ret = CheckTrackCombination(tile, trackbit);
445 if (ret.Succeeded()) ret = EnsureNoTrainOnTrack(tile, track);
446 if (ret.Failed()) return ret;
447
448 ret = CheckRailSlope(tileh, trackbit, GetTrackBits(tile), tile);
449 if (ret.Failed()) return ret;
450 cost.AddCost(ret);
451
452 if (HasSignals(tile) && TracksOverlap(GetTrackBits(tile) | TrackToTrackBits(track))) {
453 /* If adding the new track causes any overlap, all signals must be removed first */
454 if (!auto_remove_signals) return_cmd_error(STR_ERROR_MUST_REMOVE_SIGNALS_FIRST);
455
456 for (Track track_it = TRACK_BEGIN; track_it < TRACK_END; track_it++) {
457 if (HasTrack(tile, track_it) && HasSignalOnTrack(tile, track_it)) {
458 CommandCost ret_remove_signals = Command<CMD_REMOVE_SINGLE_SIGNAL>::Do(flags, tile, track_it);
459 if (ret_remove_signals.Failed()) return ret_remove_signals;
460 cost.AddCost(ret_remove_signals);
461 }
462 }
463 }
464
465 /* If the rail types don't match, try to convert only if engines of
466 * the new rail type are not powered on the present rail type and engines of
467 * the present rail type are powered on the new rail type. */
468 if (GetRailType(tile) != railtype && !HasPowerOnRail(railtype, GetRailType(tile))) {
469 if (HasPowerOnRail(GetRailType(tile), railtype)) {
470 ret = Command<CMD_CONVERT_RAIL>::Do(flags, tile, tile, railtype, false);
471 if (ret.Failed()) return ret;
472 cost.AddCost(ret);
473 } else {
474 return CMD_ERROR;
475 }
476 }
477
478 if (flags & DC_EXEC) {
479 SetRailGroundType(tile, RAIL_GROUND_BARREN);
480 TrackBits bits = GetTrackBits(tile);
481 SetTrackBits(tile, bits | trackbit);
482 /* Subtract old infrastructure count. */
483 uint pieces = CountBits(bits);
484 if (TracksOverlap(bits)) pieces *= pieces;
485 Company::Get(GetTileOwner(tile))->infrastructure.rail[GetRailType(tile)] -= pieces;
486 /* Add new infrastructure count. */
487 pieces = CountBits(bits | trackbit);
488 if (TracksOverlap(bits | trackbit)) pieces *= pieces;
489 Company::Get(GetTileOwner(tile))->infrastructure.rail[GetRailType(tile)] += pieces;
490 DirtyCompanyInfrastructureWindows(GetTileOwner(tile));
491 }
492 break;
493 }
494
495 case MP_ROAD: {
496 /* Level crossings may only be built on these slopes */
497 if (!HasBit(VALID_LEVEL_CROSSING_SLOPES, tileh)) return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
498
499 if (!_settings_game.construction.crossing_with_competitor && _current_company != OWNER_DEITY) {
500 CommandCost ret = CheckTileOwnership(tile);
501 if (ret.Failed()) return ret;
502 }
503
504 CommandCost ret = EnsureNoVehicleOnGround(tile);
505 if (ret.Failed()) return ret;
506
507 if (IsNormalRoad(tile)) {
508 if (HasRoadWorks(tile)) return_cmd_error(STR_ERROR_ROAD_WORKS_IN_PROGRESS);
509
510 if (GetDisallowedRoadDirections(tile) != DRD_NONE) return_cmd_error(STR_ERROR_CROSSING_ON_ONEWAY_ROAD);
511
512 if (RailNoLevelCrossings(railtype)) return_cmd_error(STR_ERROR_CROSSING_DISALLOWED_RAIL);
513
514 RoadType roadtype_road = GetRoadTypeRoad(tile);
515 RoadType roadtype_tram = GetRoadTypeTram(tile);
516
517 if (roadtype_road != INVALID_ROADTYPE && RoadNoLevelCrossing(roadtype_road)) return_cmd_error(STR_ERROR_CROSSING_DISALLOWED_ROAD);
518 if (roadtype_tram != INVALID_ROADTYPE && RoadNoLevelCrossing(roadtype_tram)) return_cmd_error(STR_ERROR_CROSSING_DISALLOWED_ROAD);
519
520 RoadBits road = GetRoadBits(tile, RTT_ROAD);
521 RoadBits tram = GetRoadBits(tile, RTT_TRAM);
522 if ((track == TRACK_X && ((road | tram) & ROAD_X) == 0) ||
523 (track == TRACK_Y && ((road | tram) & ROAD_Y) == 0)) {
524 Owner road_owner = GetRoadOwner(tile, RTT_ROAD);
525 Owner tram_owner = GetRoadOwner(tile, RTT_TRAM);
526 /* Disallow breaking end-of-line of someone else
527 * so trams can still reverse on this tile. */
528 if (Company::IsValidID(tram_owner) && HasExactlyOneBit(tram)) {
529 ret = CheckOwnership(tram_owner);
530 if (ret.Failed()) return ret;
531 }
532
533 uint num_new_road_pieces = (road != ROAD_NONE) ? 2 - CountBits(road) : 0;
534 if (num_new_road_pieces > 0) {
535 cost.AddCost(num_new_road_pieces * RoadBuildCost(roadtype_road));
536 }
537
538 uint num_new_tram_pieces = (tram != ROAD_NONE) ? 2 - CountBits(tram) : 0;
539 if (num_new_tram_pieces > 0) {
540 cost.AddCost(num_new_tram_pieces * RoadBuildCost(roadtype_tram));
541 }
542
543 if (flags & DC_EXEC) {
544 MakeRoadCrossing(tile, road_owner, tram_owner, _current_company, (track == TRACK_X ? AXIS_Y : AXIS_X), railtype, roadtype_road, roadtype_tram, GetTownIndex(tile));
545 UpdateLevelCrossing(tile, false);
546 MarkDirtyAdjacentLevelCrossingTiles(tile, GetCrossingRoadAxis(tile));
547 Company::Get(_current_company)->infrastructure.rail[railtype] += LEVELCROSSING_TRACKBIT_FACTOR;
548 DirtyCompanyInfrastructureWindows(_current_company);
549 if (num_new_road_pieces > 0 && Company::IsValidID(road_owner)) {
550 Company::Get(road_owner)->infrastructure.road[roadtype_road] += num_new_road_pieces;
551 DirtyCompanyInfrastructureWindows(road_owner);
552 }
553 if (num_new_tram_pieces > 0 && Company::IsValidID(tram_owner)) {
554 Company::Get(tram_owner)->infrastructure.road[roadtype_tram] += num_new_tram_pieces;
555 DirtyCompanyInfrastructureWindows(tram_owner);
556 }
557 }
558 break;
559 }
560 }
561
562 if (IsLevelCrossing(tile) && GetCrossingRailBits(tile) == trackbit) {
563 return_cmd_error(STR_ERROR_ALREADY_BUILT);
564 }
565 [[fallthrough]];
566 }
567
568 default: {
569 /* Will there be flat water on the lower halftile? */
570 bool water_ground = IsTileType(tile, MP_WATER) && IsSlopeWithOneCornerRaised(tileh);
571
572 CommandCost ret = CheckRailSlope(tileh, trackbit, TRACK_BIT_NONE, tile);
573 if (ret.Failed()) return ret;
574 cost.AddCost(ret);
575
576 ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile);
577 if (ret.Failed()) return ret;
578 cost.AddCost(ret);
579
580 if (water_ground) {
581 cost.AddCost(-_price[PR_CLEAR_WATER]);
582 cost.AddCost(_price[PR_CLEAR_ROUGH]);
583 }
584
585 if (flags & DC_EXEC) {
586 MakeRailNormal(tile, _current_company, trackbit, railtype);
587 if (water_ground) {
588 SetRailGroundType(tile, RAIL_GROUND_WATER);
589 if (IsPossibleDockingTile(tile)) CheckForDockingTile(tile);
590 }
591 Company::Get(_current_company)->infrastructure.rail[railtype]++;
592 DirtyCompanyInfrastructureWindows(_current_company);
593 }
594 break;
595 }
596 }
597
598 if (flags & DC_EXEC) {
599 MarkTileDirtyByTile(tile);
600 AddTrackToSignalBuffer(tile, track, _current_company);
601 YapfNotifyTrackLayoutChange(tile, track);
602 }
603
604 cost.AddCost(RailBuildCost(railtype));
605 return cost;
606 }
607
615 CommandCost CmdRemoveSingleRail(DoCommandFlag flags, TileIndex tile, Track track)
616 {
617 CommandCost cost(EXPENSES_CONSTRUCTION);
618 bool crossing = false;
619
620 if (!ValParamTrackOrientation(track)) return CMD_ERROR;
621 TrackBits trackbit = TrackToTrackBits(track);
622
623 /* Need to read tile owner now because it may change when the rail is removed
624 * Also, in case of floods, _current_company != owner
625 * There may be invalid tiletype even in exec run (when removing long track),
626 * so do not call GetTileOwner(tile) in any case here */
627 Owner owner = INVALID_OWNER;
628
629 Train *v = nullptr;
630
631 switch (GetTileType(tile)) {
632 case MP_ROAD: {
633 if (!IsLevelCrossing(tile) || GetCrossingRailBits(tile) != trackbit) return_cmd_error(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
634
635 if (_current_company != OWNER_WATER) {
636 CommandCost ret = CheckTileOwnership(tile);
637 if (ret.Failed()) return ret;
638 }
639
640 if (!(flags & DC_BANKRUPT)) {
641 CommandCost ret = EnsureNoVehicleOnGround(tile);
642 if (ret.Failed()) return ret;
643 }
644
645 cost.AddCost(RailClearCost(GetRailType(tile)));
646
647 if (flags & DC_EXEC) {
648 UpdateAdjacentLevelCrossingTilesOnLevelCrossingRemoval(tile, GetCrossingRoadAxis(tile));
649
650 if (HasReservedTracks(tile, trackbit)) {
651 v = GetTrainForReservation(tile, track);
652 if (v != nullptr) FreeTrainTrackReservation(v);
653 }
654
655 owner = GetTileOwner(tile);
656 Company::Get(owner)->infrastructure.rail[GetRailType(tile)] -= LEVELCROSSING_TRACKBIT_FACTOR;
657 DirtyCompanyInfrastructureWindows(owner);
658 MakeRoadNormal(tile, GetCrossingRoadBits(tile), GetRoadTypeRoad(tile), GetRoadTypeTram(tile), GetTownIndex(tile), GetRoadOwner(tile, RTT_ROAD), GetRoadOwner(tile, RTT_TRAM));
659 DeleteNewGRFInspectWindow(GSF_RAILTYPES, tile.base());
660 }
661 break;
662 }
663
664 case MP_RAILWAY: {
665 TrackBits present;
666 /* There are no rails present at depots. */
667 if (!IsPlainRail(tile)) return_cmd_error(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
668
669 if (_current_company != OWNER_WATER) {
670 CommandCost ret = CheckTileOwnership(tile);
671 if (ret.Failed()) return ret;
672 }
673
674 CommandCost ret = EnsureNoTrainOnTrack(tile, track);
675 if (ret.Failed()) return ret;
676
677 present = GetTrackBits(tile);
678 if ((present & trackbit) == 0) return_cmd_error(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
679 if (present == (TRACK_BIT_X | TRACK_BIT_Y)) crossing = true;
680
681 cost.AddCost(RailClearCost(GetRailType(tile)));
682
683 /* Charge extra to remove signals on the track, if they are there */
684 if (HasSignalOnTrack(tile, track)) {
685 cost.AddCost(Command<CMD_REMOVE_SINGLE_SIGNAL>::Do(flags, tile, track));
686 }
687
688 if (flags & DC_EXEC) {
689 if (HasReservedTracks(tile, trackbit)) {
690 v = GetTrainForReservation(tile, track);
691 if (v != nullptr) FreeTrainTrackReservation(v);
692 }
693
694 owner = GetTileOwner(tile);
695
696 /* Subtract old infrastructure count. */
697 uint pieces = CountBits(present);
698 if (TracksOverlap(present)) pieces *= pieces;
699 Company::Get(owner)->infrastructure.rail[GetRailType(tile)] -= pieces;
700 /* Add new infrastructure count. */
701 present ^= trackbit;
702 pieces = CountBits(present);
703 if (TracksOverlap(present)) pieces *= pieces;
704 Company::Get(owner)->infrastructure.rail[GetRailType(tile)] += pieces;
705 DirtyCompanyInfrastructureWindows(owner);
706
707 if (present == 0) {
708 Slope tileh = GetTileSlope(tile);
709 /* If there is flat water on the lower halftile, convert the tile to shore so the water remains */
710 if (GetRailGroundType(tile) == RAIL_GROUND_WATER && IsSlopeWithOneCornerRaised(tileh)) {
711 bool docking = IsDockingTile(tile);
712 MakeShore(tile);
713 SetDockingTile(tile, docking);
714 } else {
715 DoClearSquare(tile);
716 }
717 DeleteNewGRFInspectWindow(GSF_RAILTYPES, tile.base());
718 } else {
719 SetTrackBits(tile, present);
720 SetTrackReservation(tile, GetRailReservationTrackBits(tile) & present);
721 }
722 }
723 break;
724 }
725
726 default: return_cmd_error(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
727 }
728
729 if (flags & DC_EXEC) {
730 /* if we got that far, 'owner' variable is set correctly */
731 assert(Company::IsValidID(owner));
732
733 MarkTileDirtyByTile(tile);
734 if (crossing) {
735 /* crossing is set when only TRACK_BIT_X and TRACK_BIT_Y are set. As we
736 * are removing one of these pieces, we'll need to update signals for
737 * both directions explicitly, as after the track is removed it won't
738 * 'connect' with the other piece. */
739 AddTrackToSignalBuffer(tile, TRACK_X, owner);
740 AddTrackToSignalBuffer(tile, TRACK_Y, owner);
741 YapfNotifyTrackLayoutChange(tile, TRACK_X);
742 YapfNotifyTrackLayoutChange(tile, TRACK_Y);
743 } else {
744 AddTrackToSignalBuffer(tile, track, owner);
745 YapfNotifyTrackLayoutChange(tile, track);
746 }
747
748 if (v != nullptr) TryPathReserve(v, true);
749 }
750
751 return cost;
752 }
753
754
762 bool FloodHalftile(TileIndex t)
763 {
764 assert(IsPlainRailTile(t));
765
766 bool flooded = false;
767 if (GetRailGroundType(t) == RAIL_GROUND_WATER) return flooded;
768
769 Slope tileh = GetTileSlope(t);
770 TrackBits rail_bits = GetTrackBits(t);
771
772 if (IsSlopeWithOneCornerRaised(tileh)) {
773 TrackBits lower_track = CornerToTrackBits(OppositeCorner(GetHighestSlopeCorner(tileh)));
774
775 TrackBits to_remove = lower_track & rail_bits;
776 if (to_remove != 0) {
777 Backup<CompanyID> cur_company(_current_company, OWNER_WATER, FILE_LINE);
778 flooded = Command<CMD_REMOVE_SINGLE_RAIL>::Do(DC_EXEC, t, FindFirstTrack(to_remove)).Succeeded();
779 cur_company.Restore();
780 if (!flooded) return flooded; // not yet floodable
781 rail_bits = rail_bits & ~to_remove;
782 if (rail_bits == 0) {
783 MakeShore(t);
784 MarkTileDirtyByTile(t);
785 return flooded;
786 }
787 }
788
789 if (IsNonContinuousFoundation(GetRailFoundation(tileh, rail_bits))) {
790 flooded = true;
791 SetRailGroundType(t, RAIL_GROUND_WATER);
792 MarkTileDirtyByTile(t);
793 }
794 } else {
795 /* Make shore on steep slopes and 'three-corners-raised'-slopes. */
796 if (ApplyFoundationToSlope(GetRailFoundation(tileh, rail_bits), &tileh) == 0) {
797 if (IsSteepSlope(tileh) || IsSlopeWithThreeCornersRaised(tileh)) {
798 flooded = true;
799 SetRailGroundType(t, RAIL_GROUND_WATER);
800 MarkTileDirtyByTile(t);
801 }
802 }
803 }
804 return flooded;
805 }
806
807 static const TileIndexDiffC _trackdelta[] = {
808 { -1, 0 }, { 0, 1 }, { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, 1 },
809 { 0, 0 },
810 { 0, 0 },
811 { 1, 0 }, { 0, -1 }, { 0, -1 }, { 1, 0 }, { 0, -1 }, { -1, 0 },
812 { 0, 0 },
813 { 0, 0 }
814 };
815
816
817 static CommandCost ValidateAutoDrag(Trackdir *trackdir, TileIndex start, TileIndex end)
818 {
819 int x = TileX(start);
820 int y = TileY(start);
821 int ex = TileX(end);
822 int ey = TileY(end);
823
824 if (!ValParamTrackOrientation(TrackdirToTrack(*trackdir))) return CMD_ERROR;
825
826 /* calculate delta x,y from start to end tile */
827 int dx = ex - x;
828 int dy = ey - y;
829
830 /* calculate delta x,y for the first direction */
831 int trdx = _trackdelta[*trackdir].x;
832 int trdy = _trackdelta[*trackdir].y;
833
834 if (!IsDiagonalTrackdir(*trackdir)) {
835 trdx += _trackdelta[*trackdir ^ 1].x;
836 trdy += _trackdelta[*trackdir ^ 1].y;
837 }
838
839 /* validate the direction */
840 while ((trdx <= 0 && dx > 0) ||
841 (trdx >= 0 && dx < 0) ||
842 (trdy <= 0 && dy > 0) ||
843 (trdy >= 0 && dy < 0)) {
844 if (!HasBit(*trackdir, 3)) { // first direction is invalid, try the other
845 SetBit(*trackdir, 3); // reverse the direction
846 trdx = -trdx;
847 trdy = -trdy;
848 } else { // other direction is invalid too, invalid drag
849 return CMD_ERROR;
850 }
851 }
852
853 /* (for diagonal tracks, this is already made sure of by above test), but:
854 * for non-diagonal tracks, check if the start and end tile are on 1 line */
855 if (!IsDiagonalTrackdir(*trackdir)) {
856 trdx = _trackdelta[*trackdir].x;
857 trdy = _trackdelta[*trackdir].y;
858 if (abs(dx) != abs(dy) && abs(dx) + abs(trdy) != abs(dy) + abs(trdx)) return CMD_ERROR;
859 }
860
861 return CommandCost();
862 }
863
876 static CommandCost CmdRailTrackHelper(DoCommandFlag flags, TileIndex tile, TileIndex end_tile, RailType railtype, Track track, bool remove, bool auto_remove_signals, bool fail_on_obstacle)
877 {
878 CommandCost total_cost(EXPENSES_CONSTRUCTION);
879
880 if ((!remove && !ValParamRailType(railtype)) || !ValParamTrackOrientation(track)) return CMD_ERROR;
881 if (end_tile >= Map::Size() || tile >= Map::Size()) return CMD_ERROR;
882
883 Trackdir trackdir = TrackToTrackdir(track);
884
885 CommandCost ret = ValidateAutoDrag(&trackdir, tile, end_tile);
886 if (ret.Failed()) return ret;
887
888 bool had_success = false;
889 bool under_tunnelbridge = false;
890 CommandCost last_error = CMD_ERROR;
891 for (;;) {
892 /* Don't try to place rail between tunnelbridge ends */
893 if (IsTileType(tile, MP_TUNNELBRIDGE)) {
894 under_tunnelbridge = !under_tunnelbridge;
895 } else if (!under_tunnelbridge) {
896 if (remove) {
897 ret = Command<CMD_REMOVE_SINGLE_RAIL>::Do(flags, tile, TrackdirToTrack(trackdir));
898 } else {
899 ret = Command<CMD_BUILD_SINGLE_RAIL>::Do(flags, tile, railtype, TrackdirToTrack(trackdir), auto_remove_signals);
900 }
901
902 if (ret.Failed()) {
903 last_error = ret;
904 if (last_error.GetErrorMessage() != STR_ERROR_ALREADY_BUILT && !remove) {
905 if (fail_on_obstacle) return last_error;
906 if (had_success) break; // Keep going if we haven't constructed any rail yet, skipping the start of the drag
907 }
908
909 /* Ownership errors are more important. */
910 if (last_error.GetErrorMessage() == STR_ERROR_OWNED_BY && remove) break;
911 } else {
912 had_success = true;
913 total_cost.AddCost(ret);
914 }
915 }
916
917 if (tile == end_tile) break;
918
919 tile += ToTileIndexDiff(_trackdelta[trackdir]);
920
921 /* toggle railbit for the non-diagonal tracks */
922 if (!IsDiagonalTrackdir(trackdir)) ToggleBit(trackdir, 0);
923 }
924
925 if (had_success) return total_cost;
926 return last_error;
927 }
928
942 CommandCost CmdBuildRailroadTrack(DoCommandFlag flags, TileIndex end_tile, TileIndex start_tile, RailType railtype, Track track, bool auto_remove_signals, bool fail_on_obstacle)
943 {
944 return CmdRailTrackHelper(flags, start_tile, end_tile, railtype, track, false, auto_remove_signals, fail_on_obstacle);
945 }
946
957 CommandCost CmdRemoveRailroadTrack(DoCommandFlag flags, TileIndex end_tile, TileIndex start_tile, Track track)
958 {
959 return CmdRailTrackHelper(flags, start_tile, end_tile, INVALID_RAILTYPE, track, true, false, false);
960 }
961
973 CommandCost CmdBuildTrainDepot(DoCommandFlag flags, TileIndex tile, RailType railtype, DiagDirection dir)
974 {
975 /* check railtype and valid direction for depot (0 through 3), 4 in total */
976 if (!ValParamRailType(railtype) || !IsValidDiagDirection(dir)) return CMD_ERROR;
977
978 Slope tileh = GetTileSlope(tile);
979
980 CommandCost cost(EXPENSES_CONSTRUCTION);
981
982 /* Prohibit construction if
983 * The tile is non-flat AND
984 * 1) build-on-slopes is disabled
985 * 2) the tile is steep i.e. spans two height levels
986 * 3) the exit points in the wrong direction
987 */
988
989 if (tileh != SLOPE_FLAT) {
990 if (!_settings_game.construction.build_on_slopes || !CanBuildDepotByTileh(dir, tileh)) {
991 return_cmd_error(STR_ERROR_FLAT_LAND_REQUIRED);
992 }
993 cost.AddCost(_price[PR_BUILD_FOUNDATION]);
994 }
995
996 /* Allow the user to rotate the depot instead of having to destroy it and build it again */
997 bool rotate_existing_depot = false;
998 if (IsRailDepotTile(tile) && railtype == GetRailType(tile)) {
999 CommandCost ret = CheckTileOwnership(tile);
1000 if (ret.Failed()) return ret;
1001
1002 if (dir == GetRailDepotDirection(tile)) return_cmd_error(STR_ERROR_ALREADY_BUILT);
1003
1004 ret = EnsureNoVehicleOnGround(tile);
1005 if (ret.Failed()) return ret;
1006
1007 rotate_existing_depot = true;
1008 }
1009
1010 if (!rotate_existing_depot) {
1011 cost.AddCost(Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile));
1012 if (cost.Failed()) return cost;
1013
1014 if (IsBridgeAbove(tile)) return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
1015
1016 if (!Depot::CanAllocateItem()) return CMD_ERROR;
1017 }
1018
1019 if (flags & DC_EXEC) {
1020 if (rotate_existing_depot) {
1021 SetRailDepotExitDirection(tile, dir);
1022 } else {
1023 Depot *d = new Depot(tile);
1024 d->build_date = TimerGameCalendar::date;
1025
1026 MakeRailDepot(tile, _current_company, d->index, dir, railtype);
1027 MakeDefaultName(d);
1028
1029 Company::Get(_current_company)->infrastructure.rail[railtype]++;
1030 DirtyCompanyInfrastructureWindows(_current_company);
1031 }
1032
1033 MarkTileDirtyByTile(tile);
1034 AddSideToSignalBuffer(tile, INVALID_DIAGDIR, _current_company);
1035 YapfNotifyTrackLayoutChange(tile, DiagDirToDiagTrack(dir));
1036 }
1037
1038 cost.AddCost(_price[PR_BUILD_DEPOT_TRAIN]);
1039 cost.AddCost(RailBuildCost(railtype));
1040 return cost;
1041 }
1042
1062 CommandCost CmdBuildSingleSignal(DoCommandFlag flags, TileIndex tile, Track track, SignalType sigtype, SignalVariant sigvar, bool convert_signal, bool skip_existing_signals, bool ctrl_pressed, SignalType cycle_start, SignalType cycle_stop, uint8_t num_dir_cycle, byte signals_copy)
1063 {
1064 if (sigtype > SIGTYPE_LAST || sigvar > SIG_SEMAPHORE) return CMD_ERROR;
1065 if (cycle_start > cycle_stop || cycle_stop > SIGTYPE_LAST) return CMD_ERROR;
1066
1067 if (ctrl_pressed) sigvar = (SignalVariant)(sigvar ^ SIG_SEMAPHORE);
1068
1069 /* You can only build signals on plain rail tiles, and the selected track must exist */
1070 if (!ValParamTrackOrientation(track) || !IsPlainRailTile(tile) ||
1071 !HasTrack(tile, track)) {
1072 return_cmd_error(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
1073 }
1074 /* Protect against invalid signal copying */
1075 if (signals_copy != 0 && (signals_copy & SignalOnTrack(track)) == 0) return CMD_ERROR;
1076
1077 CommandCost ret = CheckTileOwnership(tile);
1078 if (ret.Failed()) return ret;
1079
1080 /* See if this is a valid track combination for signals (no overlap) */
1081 if (TracksOverlap(GetTrackBits(tile))) return_cmd_error(STR_ERROR_NO_SUITABLE_RAILROAD_TRACK);
1082
1083 /* In case we don't want to change an existing signal, return without error. */
1084 if (skip_existing_signals && HasSignalOnTrack(tile, track)) return CommandCost();
1085
1086 /* you can not convert a signal if no signal is on track */
1087 if (convert_signal && !HasSignalOnTrack(tile, track)) return_cmd_error(STR_ERROR_THERE_ARE_NO_SIGNALS);
1088
1089 CommandCost cost;
1090 if (!HasSignalOnTrack(tile, track)) {
1091 /* build new signals */
1092 cost = CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_SIGNALS]);
1093 } else {
1094 if (signals_copy != 0 && sigvar != GetSignalVariant(tile, track)) {
1095 /* convert signals <-> semaphores */
1096 cost = CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_SIGNALS] + _price[PR_CLEAR_SIGNALS]);
1097
1098 } else if (convert_signal) {
1099 /* convert button pressed */
1100 if (ctrl_pressed || GetSignalVariant(tile, track) != sigvar) {
1101 /* it costs money to change signal variant (light or semaphore) */
1102 cost = CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_SIGNALS] + _price[PR_CLEAR_SIGNALS]);
1103 } else {
1104 /* it is free to change signal type (block, exit, entry, combo, path, etc) */
1105 cost = CommandCost();
1106 }
1107
1108 } else {
1109 /* it is free to change orientation or number of signals on the tile (for block/presignals which allow signals in both directions) */
1110 cost = CommandCost();
1111 }
1112 }
1113
1114 if (flags & DC_EXEC) {
1115 Train *v = nullptr;
1116 /* The new/changed signal could block our path. As this can lead to
1117 * stale reservations, we clear the path reservation here and try
1118 * to redo it later on. */
1119 if (HasReservedTracks(tile, TrackToTrackBits(track))) {
1120 v = GetTrainForReservation(tile, track);
1121 if (v != nullptr) FreeTrainTrackReservation(v);
1122 }
1123
1124 if (!HasSignals(tile)) {
1125 /* there are no signals at all on this tile yet */
1126 SetHasSignals(tile, true);
1127 SetSignalStates(tile, 0xF); // all signals are on
1128 SetPresentSignals(tile, 0); // no signals built by default
1129 SetSignalType(tile, track, sigtype);
1130 SetSignalVariant(tile, track, sigvar);
1131 }
1132
1133 /* Subtract old signal infrastructure count. */
1134 Company::Get(GetTileOwner(tile))->infrastructure.signal -= CountBits(GetPresentSignals(tile));
1135
1136 if (signals_copy == 0) {
1137 if (!HasSignalOnTrack(tile, track)) {
1138 /* build new signals */
1139 SetPresentSignals(tile, GetPresentSignals(tile) | (IsPbsSignal(sigtype) ? KillFirstBit(SignalOnTrack(track)) : SignalOnTrack(track)));
1140 SetSignalType(tile, track, sigtype);
1141 SetSignalVariant(tile, track, sigvar);
1142 while (num_dir_cycle-- > 0) CycleSignalSide(tile, track);
1143 } else {
1144 if (convert_signal) {
1145 /* convert signal button pressed */
1146 if (ctrl_pressed) {
1147 /* toggle the present signal variant: SIG_ELECTRIC <-> SIG_SEMAPHORE */
1148 SetSignalVariant(tile, track, (GetSignalVariant(tile, track) == SIG_ELECTRIC) ? SIG_SEMAPHORE : SIG_ELECTRIC);
1149 /* Query current signal type so the check for PBS signals below works. */
1150 sigtype = GetSignalType(tile, track);
1151 } else {
1152 /* convert the present signal to the chosen type and variant */
1153 SetSignalType(tile, track, sigtype);
1154 SetSignalVariant(tile, track, sigvar);
1155 if (IsPbsSignal(sigtype) && (GetPresentSignals(tile) & SignalOnTrack(track)) == SignalOnTrack(track)) {
1156 SetPresentSignals(tile, (GetPresentSignals(tile) & ~SignalOnTrack(track)) | KillFirstBit(SignalOnTrack(track)));
1157 }
1158 }
1159
1160 } else if (ctrl_pressed) {
1161 /* cycle between cycle_start and cycle_end */
1162 sigtype = (SignalType)(GetSignalType(tile, track) + 1);
1163
1164 if (sigtype < cycle_start || sigtype > cycle_stop) sigtype = cycle_start;
1165
1166 SetSignalType(tile, track, sigtype);
1167 if (IsPbsSignal(sigtype) && (GetPresentSignals(tile) & SignalOnTrack(track)) == SignalOnTrack(track)) {
1168 SetPresentSignals(tile, (GetPresentSignals(tile) & ~SignalOnTrack(track)) | KillFirstBit(SignalOnTrack(track)));
1169 }
1170 } else {
1171 /* cycle the signal side: both -> left -> right -> both -> ... */
1172 CycleSignalSide(tile, track);
1173 /* Query current signal type so the check for PBS signals below works. */
1174 sigtype = GetSignalType(tile, track);
1175 }
1176 }
1177 } else {
1178 /* If CmdBuildManySignals is called with copying signals, just copy the
1179 * direction of the first signal given as parameter by CmdBuildManySignals */
1180 SetPresentSignals(tile, (GetPresentSignals(tile) & ~SignalOnTrack(track)) | (signals_copy & SignalOnTrack(track)));
1181 SetSignalVariant(tile, track, sigvar);
1182 SetSignalType(tile, track, sigtype);
1183 }
1184
1185 /* Add new signal infrastructure count. */
1186 Company::Get(GetTileOwner(tile))->infrastructure.signal += CountBits(GetPresentSignals(tile));
1187 DirtyCompanyInfrastructureWindows(GetTileOwner(tile));
1188
1189 if (IsPbsSignal(sigtype)) {
1190 /* PBS signals should show red unless they are on reserved tiles without a train. */
1191 uint mask = GetPresentSignals(tile) & SignalOnTrack(track);
1192 SetSignalStates(tile, (GetSignalStates(tile) & ~mask) | ((HasBit(GetRailReservationTrackBits(tile), track) && EnsureNoVehicleOnGround(tile).Succeeded() ? UINT_MAX : 0) & mask));
1193 }
1194 MarkTileDirtyByTile(tile);
1195 AddTrackToSignalBuffer(tile, track, _current_company);
1196 YapfNotifyTrackLayoutChange(tile, track);
1197 if (v != nullptr && v->track != TRACK_BIT_DEPOT) {
1198 /* Extend the train's path if it's not stopped or loading, or not at a safe position. */
1199 if (!(((v->vehstatus & VS_STOPPED) && v->cur_speed == 0) || v->current_order.IsType(OT_LOADING)) ||
1200 !IsSafeWaitingPosition(v, v->tile, v->GetVehicleTrackdir(), true, _settings_game.pf.forbid_90_deg)) {
1201 TryPathReserve(v, true);
1202 }
1203 }
1204 }
1205
1206 return cost;
1207 }
1208
1209 static bool AdvanceSignalAutoFill(TileIndex &tile, Trackdir &trackdir, bool remove)
1210 {
1211 /* We only process starting tiles of tunnels or bridges so jump to the other end before moving further. */
1212 if (IsTileType(tile, MP_TUNNELBRIDGE)) tile = GetOtherTunnelBridgeEnd(tile);
1213
1214 tile = AddTileIndexDiffCWrap(tile, _trackdelta[trackdir]);
1215 if (tile == INVALID_TILE) return false;
1216
1217 /* Check for track bits on the new tile */
1218 TrackdirBits trackdirbits = TrackStatusToTrackdirBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, 0));
1219
1220 if (TracksOverlap(TrackdirBitsToTrackBits(trackdirbits))) return false;
1221 trackdirbits &= TrackdirReachesTrackdirs(trackdir);
1222
1223 /* No track bits, must stop */
1224 if (trackdirbits == TRACKDIR_BIT_NONE) return false;
1225
1226 /* Get the first track dir */
1227 trackdir = RemoveFirstTrackdir(&trackdirbits);
1228
1229 /* Any left? It's a junction so we stop */
1230 if (trackdirbits != TRACKDIR_BIT_NONE) return false;
1231
1232 switch (GetTileType(tile)) {
1233 case MP_RAILWAY:
1234 if (IsRailDepot(tile)) return false;
1235 if (!remove && HasSignalOnTrack(tile, TrackdirToTrack(trackdir))) return false;
1236 break;
1237
1238 case MP_ROAD:
1239 if (!IsLevelCrossing(tile)) return false;
1240 break;
1241
1242 case MP_TUNNELBRIDGE: {
1243 if (GetTunnelBridgeTransportType(tile) != TRANSPORT_RAIL) return false;
1244 if (GetTunnelBridgeDirection(tile) != TrackdirToExitdir(trackdir)) return false;
1245 break;
1246 }
1247
1248 default: return false;
1249 }
1250 return true;
1251 }
1252
1268 static CommandCost CmdSignalTrackHelper(DoCommandFlag flags, TileIndex tile, TileIndex end_tile, Track track, SignalType sigtype, SignalVariant sigvar, bool mode, bool remove, bool autofill, bool minimise_gaps, int signal_density)
1269 {
1270 CommandCost total_cost(EXPENSES_CONSTRUCTION);
1271
1272 if (end_tile >= Map::Size() || !ValParamTrackOrientation(track)) return CMD_ERROR;
1273 if (signal_density == 0 || signal_density > 20) return CMD_ERROR;
1274 if (!remove && (sigtype > SIGTYPE_LAST || sigvar > SIG_SEMAPHORE)) return CMD_ERROR;
1275
1276 if (!IsPlainRailTile(tile)) return_cmd_error(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
1277 TileIndex start_tile = tile;
1278
1279 /* Interpret signal_density as the logical length of said amount of tiles in X/Y direction. */
1280 signal_density *= TILE_AXIAL_DISTANCE;
1281
1282 Trackdir trackdir = TrackToTrackdir(track);
1283 CommandCost ret = ValidateAutoDrag(&trackdir, tile, end_tile);
1284 if (ret.Failed()) return ret;
1285
1286 track = TrackdirToTrack(trackdir); // trackdir might have changed, keep track in sync
1287 Trackdir start_trackdir = trackdir;
1288
1289 /* Must start on a valid track to be able to avoid loops */
1290 if (!HasTrack(tile, track)) return CMD_ERROR;
1291
1292 byte signals;
1293 /* copy the signal-style of the first rail-piece if existing */
1294 if (HasSignalOnTrack(tile, track)) {
1295 signals = GetPresentSignals(tile) & SignalOnTrack(track);
1296 assert(signals != 0);
1297
1298 /* copy signal/semaphores style (independent of CTRL) */
1299 sigvar = GetSignalVariant(tile, track);
1300
1301 sigtype = GetSignalType(tile, track);
1302 /* Don't but copy entry or exit-signal type */
1303 if (sigtype == SIGTYPE_ENTRY || sigtype == SIGTYPE_EXIT) sigtype = SIGTYPE_BLOCK;
1304 } else { // no signals exist, drag a two-way signal stretch
1305 signals = IsPbsSignal(sigtype) ? SignalAlongTrackdir(trackdir) : SignalOnTrack(track);
1306 }
1307
1308 byte signal_dir = 0;
1309 if (signals & SignalAlongTrackdir(trackdir)) SetBit(signal_dir, 0);
1310 if (signals & SignalAgainstTrackdir(trackdir)) SetBit(signal_dir, 1);
1311
1312 /* signal_ctr - amount of tiles already processed
1313 * last_used_ctr - amount of tiles before previously placed signal
1314 * signals_density - setting to put signal on every Nth tile (double space on |, -- tracks)
1315 * last_suitable_ctr - amount of tiles before last possible signal place
1316 * last_suitable_tile - last tile where it is possible to place a signal
1317 * last_suitable_trackdir - trackdir of the last tile
1318 **********
1319 * trackdir - trackdir to build with autorail
1320 * semaphores - semaphores or signals
1321 * signals - is there a signal/semaphore on the first tile, copy its style (two-way/single-way)
1322 * and convert all others to semaphore/signal
1323 * remove - 1 remove signals, 0 build signals */
1324 int signal_ctr = 0;
1325 int last_used_ctr = -signal_density; // to force signal at first tile
1326 int last_suitable_ctr = 0;
1327 TileIndex last_suitable_tile = INVALID_TILE;
1328 Trackdir last_suitable_trackdir = INVALID_TRACKDIR;
1329 CommandCost last_error = CMD_ERROR;
1330 bool had_success = false;
1331 auto build_signal = [&](TileIndex tile, Trackdir trackdir, bool test_only) {
1332 /* Pick the correct orientation for the track direction */
1333 byte signals = 0;
1334 if (HasBit(signal_dir, 0)) signals |= SignalAlongTrackdir(trackdir);
1335 if (HasBit(signal_dir, 1)) signals |= SignalAgainstTrackdir(trackdir);
1336
1337 DoCommandFlag do_flags = test_only ? flags & ~DC_EXEC : flags;
1338 CommandCost ret = remove ? Command<CMD_REMOVE_SINGLE_SIGNAL>::Do(do_flags, tile, TrackdirToTrack(trackdir)) : Command<CMD_BUILD_SINGLE_SIGNAL>::Do(do_flags, tile, TrackdirToTrack(trackdir), sigtype, sigvar, false, signal_ctr == 0, mode, SIGTYPE_BLOCK, SIGTYPE_BLOCK, 0, signals);
1339
1340 if (test_only) return ret.Succeeded();
1341
1342 if (ret.Succeeded()) {
1343 had_success = true;
1344 total_cost.AddCost(ret);
1345 } else {
1346 /* The "No railway" error is the least important one. */
1347 if (ret.GetErrorMessage() != STR_ERROR_THERE_IS_NO_RAILROAD_TRACK ||
1348 last_error.GetErrorMessage() == INVALID_STRING_ID) {
1349 last_error = ret;
1350 }
1351 }
1352 return ret.Succeeded();
1353 };
1354
1355 for (;;) {
1356 if (remove) {
1357 /* In remove mode last_* stuff doesn't matter, we simply try to clear every tile. */
1358 build_signal(tile, trackdir, false);
1359 } else if (minimise_gaps) {
1360 /* We're trying to minimize gaps wherever possible, so keep track of last suitable
1361 * position and use it if current gap exceeds required signal density. */
1362
1363 if (signal_ctr > last_used_ctr + signal_density && last_suitable_tile != INVALID_TILE) {
1364 /* We overshot so build a signal in last good location. */
1365 if (build_signal(last_suitable_tile, last_suitable_trackdir, false)) {
1366 last_suitable_tile = INVALID_TILE;
1367 last_used_ctr = last_suitable_ctr;
1368 }
1369 }
1370
1371 if (signal_ctr == last_used_ctr + signal_density) {
1372 /* Current gap matches the required density, build a signal. */
1373 if (build_signal(tile, trackdir, false)) {
1374 last_used_ctr = signal_ctr;
1375 last_suitable_tile = INVALID_TILE;
1376 }
1377 } else {
1378 /* Test tile for a potential signal spot. */
1379 if (build_signal(tile, trackdir, true)) {
1380 last_suitable_tile = tile;
1381 last_suitable_ctr = signal_ctr;
1382 last_suitable_trackdir = trackdir;
1383 }
1384 }
1385 } else if (signal_ctr >= last_used_ctr + signal_density) {
1386 /* We're always keeping regular interval between signals so doesn't matter whether we succeed or not. */
1387 build_signal(tile, trackdir, false);
1388 last_used_ctr = signal_ctr;
1389 }
1390
1391 if (autofill) {
1392 switch (GetTileType(tile)) {
1393 case MP_RAILWAY:
1394 signal_ctr += (IsDiagonalTrackdir(trackdir) ? TILE_AXIAL_DISTANCE : TILE_CORNER_DISTANCE);
1395 break;
1396
1397 case MP_ROAD:
1398 signal_ctr += TILE_AXIAL_DISTANCE;
1399 break;
1400
1401 case MP_TUNNELBRIDGE: {
1402 uint len = (GetTunnelBridgeLength(tile, GetOtherTunnelBridgeEnd(tile)) + 2) * TILE_AXIAL_DISTANCE;
1403 if (remove || minimise_gaps) {
1404 signal_ctr += len;
1405 } else {
1406 /* To keep regular interval we need to emulate placing signals on a bridge.
1407 * We start with TILE_AXIAL_DISTANCE as one bridge tile gets processed in the main loop. */
1408 signal_ctr += TILE_AXIAL_DISTANCE;
1409 for (uint i = TILE_AXIAL_DISTANCE; i < len; i += TILE_AXIAL_DISTANCE) {
1410 if (signal_ctr >= last_used_ctr + signal_density) last_used_ctr = signal_ctr;
1411 signal_ctr += TILE_AXIAL_DISTANCE;
1412 }
1413 }
1414 break;
1415 }
1416
1417 default: break;
1418 }
1419
1420 if (!AdvanceSignalAutoFill(tile, trackdir, remove)) break;
1421
1422 /* Prevent possible loops */
1423 if (tile == start_tile && trackdir == start_trackdir) break;
1424 } else {
1425 if (tile == end_tile) break;
1426
1427 signal_ctr += (IsDiagonalTrackdir(trackdir) ? TILE_AXIAL_DISTANCE : TILE_CORNER_DISTANCE);
1428 /* toggle railbit for the non-diagonal tracks (|, -- tracks) */
1429
1430 tile += ToTileIndexDiff(_trackdelta[trackdir]);
1431 if (!IsDiagonalTrackdir(trackdir)) ToggleBit(trackdir, 0);
1432 }
1433 }
1434
1435 /* We may end up with the current gap exceeding the signal density so fix that if needed. */
1436 if (!remove && minimise_gaps && signal_ctr > last_used_ctr + signal_density && last_suitable_tile != INVALID_TILE) {
1437 build_signal(last_suitable_tile, last_suitable_trackdir, false);
1438 }
1439
1440 return had_success ? total_cost : last_error;
1441 }
1442
1459 CommandCost CmdBuildSignalTrack(DoCommandFlag flags, TileIndex tile, TileIndex end_tile, Track track, SignalType sigtype, SignalVariant sigvar, bool mode, bool autofill, bool minimise_gaps, byte signal_density)
1460 {
1461 return CmdSignalTrackHelper(flags, tile, end_tile, track, sigtype, sigvar, mode, false, autofill, minimise_gaps, signal_density);
1462 }
1463
1471 CommandCost CmdRemoveSingleSignal(DoCommandFlag flags, TileIndex tile, Track track)
1472 {
1473 if (!ValParamTrackOrientation(track) || !IsPlainRailTile(tile) || !HasTrack(tile, track)) {
1474 return_cmd_error(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
1475 }
1476 if (!HasSignalOnTrack(tile, track)) {
1477 return_cmd_error(STR_ERROR_THERE_ARE_NO_SIGNALS);
1478 }
1479
1480 /* Only water can remove signals from anyone */
1481 if (_current_company != OWNER_WATER) {
1482 CommandCost ret = CheckTileOwnership(tile);
1483 if (ret.Failed()) return ret;
1484 }
1485
1486 /* Do it? */
1487 if (flags & DC_EXEC) {
1488 Train *v = nullptr;
1489 if (HasReservedTracks(tile, TrackToTrackBits(track))) {
1490 v = GetTrainForReservation(tile, track);
1491 } else if (IsPbsSignal(GetSignalType(tile, track))) {
1492 /* PBS signal, might be the end of a path reservation. */
1493 Trackdir td = TrackToTrackdir(track);
1494 for (int i = 0; v == nullptr && i < 2; i++, td = ReverseTrackdir(td)) {
1495 /* Only test the active signal side. */
1496 if (!HasSignalOnTrackdir(tile, ReverseTrackdir(td))) continue;
1497 TileIndex next = TileAddByDiagDir(tile, TrackdirToExitdir(td));
1498 TrackBits tracks = TrackdirBitsToTrackBits(TrackdirReachesTrackdirs(td));
1499 if (HasReservedTracks(next, tracks)) {
1500 v = GetTrainForReservation(next, TrackBitsToTrack(GetReservedTrackbits(next) & tracks));
1501 }
1502 }
1503 }
1504 Company::Get(GetTileOwner(tile))->infrastructure.signal -= CountBits(GetPresentSignals(tile));
1505 SetPresentSignals(tile, GetPresentSignals(tile) & ~SignalOnTrack(track));
1506 Company::Get(GetTileOwner(tile))->infrastructure.signal += CountBits(GetPresentSignals(tile));
1507 DirtyCompanyInfrastructureWindows(GetTileOwner(tile));
1508
1509 /* removed last signal from tile? */
1510 if (GetPresentSignals(tile) == 0) {
1511 SetSignalStates(tile, 0);
1512 SetHasSignals(tile, false);
1513 SetSignalVariant(tile, INVALID_TRACK, SIG_ELECTRIC); // remove any possible semaphores
1514 }
1515
1516 AddTrackToSignalBuffer(tile, track, GetTileOwner(tile));
1517 YapfNotifyTrackLayoutChange(tile, track);
1518 if (v != nullptr) TryPathReserve(v, false);
1519
1520 MarkTileDirtyByTile(tile);
1521 }
1522
1523 return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_SIGNALS]);
1524 }
1525
1537 CommandCost CmdRemoveSignalTrack(DoCommandFlag flags, TileIndex tile, TileIndex end_tile, Track track, bool autofill)
1538 {
1539 return CmdSignalTrackHelper(flags, tile, end_tile, track, SIGTYPE_BLOCK, SIG_ELECTRIC, false, true, autofill, false, 1); // bit 5 is remove bit
1540 }
1541
1543 static Vehicle *UpdateTrainPowerProc(Vehicle *v, void *data)
1544 {
1545 if (v->type != VEH_TRAIN) return nullptr;
1546
1547 TrainList *affected_trains = static_cast<TrainList*>(data);
1548 include(*affected_trains, Train::From(v)->First());
1549
1550 return nullptr;
1551 }
1552
1563 CommandCost CmdConvertRail(DoCommandFlag flags, TileIndex tile, TileIndex area_start, RailType totype, bool diagonal)
1564 {
1565 TileIndex area_end = tile;
1566
1567 if (!ValParamRailType(totype)) return CMD_ERROR;
1568 if (area_start >= Map::Size()) return CMD_ERROR;
1569
1570 TrainList affected_trains;
1571
1572 CommandCost cost(EXPENSES_CONSTRUCTION);
1573 CommandCost error = CommandCost(STR_ERROR_NO_SUITABLE_RAILROAD_TRACK); // by default, there is no track to convert.
1574 bool found_convertible_track = false; // whether we actually did convert some track (see bug #7633)
1575
1576 std::unique_ptr<TileIterator> iter = TileIterator::Create(area_start, area_end, diagonal);
1577 for (; (tile = *iter) != INVALID_TILE; ++(*iter)) {
1578 TileType tt = GetTileType(tile);
1579
1580 /* Check if there is any track on tile */
1581 switch (tt) {
1582 case MP_RAILWAY:
1583 break;
1584 case MP_STATION:
1585 if (!HasStationRail(tile)) continue;
1586 break;
1587 case MP_ROAD:
1588 if (!IsLevelCrossing(tile)) continue;
1589 if (RailNoLevelCrossings(totype)) {
1590 error.MakeError(STR_ERROR_CROSSING_DISALLOWED_RAIL);
1591 continue;
1592 }
1593 break;
1594 case MP_TUNNELBRIDGE:
1595 if (GetTunnelBridgeTransportType(tile) != TRANSPORT_RAIL) continue;
1596 break;
1597 default: continue;
1598 }
1599
1600 /* Original railtype we are converting from */
1601 RailType type = GetRailType(tile);
1602
1603 /* Converting to the same type or converting 'hidden' elrail -> rail */
1604 if (type == totype || (_settings_game.vehicle.disable_elrails && totype == RAILTYPE_RAIL && type == RAILTYPE_ELECTRIC)) continue;
1605
1606 /* Trying to convert other's rail */
1607 CommandCost ret = CheckTileOwnership(tile);
1608 if (ret.Failed()) {
1609 error = ret;
1610 continue;
1611 }
1612
1613 std::vector<Train *> vehicles_affected;
1614
1615 /* Vehicle on the tile when not converting Rail <-> ElRail
1616 * Tunnels and bridges have special check later */
1617 if (tt != MP_TUNNELBRIDGE) {
1618 if (!IsCompatibleRail(type, totype)) {
1619 ret = IsPlainRailTile(tile) ? EnsureNoTrainOnTrackBits(tile, GetTrackBits(tile)) : EnsureNoVehicleOnGround(tile);
1620 if (ret.Failed()) {
1621 error = ret;
1622 continue;
1623 }
1624 }
1625 if (flags & DC_EXEC) { // we can safely convert, too
1626 TrackBits reserved = GetReservedTrackbits(tile);
1627 Track track;
1628 while ((track = RemoveFirstTrack(&reserved)) != INVALID_TRACK) {
1629 Train *v = GetTrainForReservation(tile, track);
1630 if (v != nullptr && !HasPowerOnRail(v->railtype, totype)) {
1631 /* No power on new rail type, reroute. */
1632 FreeTrainTrackReservation(v);
1633 vehicles_affected.push_back(v);
1634 }
1635 }
1636
1637 /* Update the company infrastructure counters. */
1638 if (!IsRailStationTile(tile) || !IsStationTileBlocked(tile)) {
1639 Company *c = Company::Get(GetTileOwner(tile));
1640 uint num_pieces = IsLevelCrossingTile(tile) ? LEVELCROSSING_TRACKBIT_FACTOR : 1;
1641 if (IsPlainRailTile(tile)) {
1642 TrackBits bits = GetTrackBits(tile);
1643 num_pieces = CountBits(bits);
1644 if (TracksOverlap(bits)) num_pieces *= num_pieces;
1645 }
1646 c->infrastructure.rail[type] -= num_pieces;
1647 c->infrastructure.rail[totype] += num_pieces;
1648 DirtyCompanyInfrastructureWindows(c->index);
1649 }
1650
1651 SetRailType(tile, totype);
1652 MarkTileDirtyByTile(tile);
1653 /* update power of train on this tile */
1654 FindVehicleOnPos(tile, &affected_trains, &UpdateTrainPowerProc);
1655 }
1656 }
1657
1658 switch (tt) {
1659 case MP_RAILWAY:
1660 switch (GetRailTileType(tile)) {
1661 case RAIL_TILE_DEPOT:
1662 if (flags & DC_EXEC) {
1663 /* notify YAPF about the track layout change */
1664 YapfNotifyTrackLayoutChange(tile, GetRailDepotTrack(tile));
1665
1666 /* Update build vehicle window related to this depot */
1667 InvalidateWindowData(WC_VEHICLE_DEPOT, tile);
1668 InvalidateWindowData(WC_BUILD_VEHICLE, tile);
1669 }
1670 found_convertible_track = true;
1671 cost.AddCost(RailConvertCost(type, totype));
1672 break;
1673
1674 default: // RAIL_TILE_NORMAL, RAIL_TILE_SIGNALS
1675 if (flags & DC_EXEC) {
1676 /* notify YAPF about the track layout change */
1677 TrackBits tracks = GetTrackBits(tile);
1678 while (tracks != TRACK_BIT_NONE) {
1679 YapfNotifyTrackLayoutChange(tile, RemoveFirstTrack(&tracks));
1680 }
1681 }
1682 found_convertible_track = true;
1683 cost.AddCost(RailConvertCost(type, totype) * CountBits(GetTrackBits(tile)));
1684 break;
1685 }
1686 break;
1687
1688 case MP_TUNNELBRIDGE: {
1689 TileIndex endtile = GetOtherTunnelBridgeEnd(tile);
1690
1691 /* If both ends of tunnel/bridge are in the range, do not try to convert twice -
1692 * it would cause assert because of different test and exec runs */
1693 if (endtile < tile) {
1694 if (diagonal) {
1695 if (DiagonalTileArea(area_start, area_end).Contains(endtile)) continue;
1696 } else {
1697 if (OrthogonalTileArea(area_start, area_end).Contains(endtile)) continue;
1698 }
1699 }
1700
1701 /* When not converting rail <-> el. rail, any vehicle cannot be in tunnel/bridge */
1702 if (!IsCompatibleRail(GetRailType(tile), totype)) {
1703 ret = TunnelBridgeIsFree(tile, endtile);
1704 if (ret.Failed()) {
1705 error = ret;
1706 continue;
1707 }
1708 }
1709
1710 if (flags & DC_EXEC) {
1711 Track track = DiagDirToDiagTrack(GetTunnelBridgeDirection(tile));
1712 if (HasTunnelBridgeReservation(tile)) {
1713 Train *v = GetTrainForReservation(tile, track);
1714 if (v != nullptr && !HasPowerOnRail(v->railtype, totype)) {
1715 /* No power on new rail type, reroute. */
1716 FreeTrainTrackReservation(v);
1717 vehicles_affected.push_back(v);
1718 }
1719 }
1720
1721 /* Update the company infrastructure counters. */
1722 uint num_pieces = (GetTunnelBridgeLength(tile, endtile) + 2) * TUNNELBRIDGE_TRACKBIT_FACTOR;
1723 Company *c = Company::Get(GetTileOwner(tile));
1724 c->infrastructure.rail[GetRailType(tile)] -= num_pieces;
1725 c->infrastructure.rail[totype] += num_pieces;
1726 DirtyCompanyInfrastructureWindows(c->index);
1727
1728 SetRailType(tile, totype);
1729 SetRailType(endtile, totype);
1730
1731 FindVehicleOnPos(tile, &affected_trains, &UpdateTrainPowerProc);
1732 FindVehicleOnPos(endtile, &affected_trains, &UpdateTrainPowerProc);
1733
1734 YapfNotifyTrackLayoutChange(tile, track);
1735 YapfNotifyTrackLayoutChange(endtile, track);
1736
1737 if (IsBridge(tile)) {
1738 MarkBridgeDirty(tile);
1739 } else {
1740 MarkTileDirtyByTile(tile);
1741 MarkTileDirtyByTile(endtile);
1742 }
1743 }
1744
1745 found_convertible_track = true;
1746 cost.AddCost((GetTunnelBridgeLength(tile, endtile) + 2) * RailConvertCost(type, totype));
1747 break;
1748 }
1749
1750 default: // MP_STATION, MP_ROAD
1751 if (flags & DC_EXEC) {
1752 Track track = ((tt == MP_STATION) ? GetRailStationTrack(tile) : GetCrossingRailTrack(tile));
1753 YapfNotifyTrackLayoutChange(tile, track);
1754 }
1755
1756 found_convertible_track = true;
1757 cost.AddCost(RailConvertCost(type, totype));
1758 break;
1759 }
1760
1761 for (uint i = 0; i < vehicles_affected.size(); ++i) {
1762 TryPathReserve(vehicles_affected[i], true);
1763 }
1764 }
1765
1766 if (flags & DC_EXEC) {
1767 /* Railtype changed, update trains as when entering different track */
1768 for (Train *v : affected_trains) {
1769 v->ConsistChanged(CCF_TRACK);
1770 }
1771 }
1772
1773 return found_convertible_track ? cost : error;
1774 }
1775
1776 static CommandCost RemoveTrainDepot(TileIndex tile, DoCommandFlag flags)
1777 {
1778 if (_current_company != OWNER_WATER) {
1779 CommandCost ret = CheckTileOwnership(tile);
1780 if (ret.Failed()) return ret;
1781 }
1782
1783 CommandCost ret = EnsureNoVehicleOnGround(tile);
1784 if (ret.Failed()) return ret;
1785
1786 if (flags & DC_EXEC) {
1787 /* read variables before the depot is removed */
1788 DiagDirection dir = GetRailDepotDirection(tile);
1789 Owner owner = GetTileOwner(tile);
1790 Train *v = nullptr;
1791
1792 if (HasDepotReservation(tile)) {
1793 v = GetTrainForReservation(tile, DiagDirToDiagTrack(dir));
1794 if (v != nullptr) FreeTrainTrackReservation(v);
1795 }
1796
1797 Company::Get(owner)->infrastructure.rail[GetRailType(tile)]--;
1798 DirtyCompanyInfrastructureWindows(owner);
1799
1800 delete Depot::GetByTile(tile);
1801 DoClearSquare(tile);
1802 AddSideToSignalBuffer(tile, dir, owner);
1803 YapfNotifyTrackLayoutChange(tile, DiagDirToDiagTrack(dir));
1804 if (v != nullptr) TryPathReserve(v, true);
1805 }
1806
1807 return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_DEPOT_TRAIN]);
1808 }
1809
1810 static CommandCost ClearTile_Track(TileIndex tile, DoCommandFlag flags)
1811 {
1812 CommandCost cost(EXPENSES_CONSTRUCTION);
1813
1814 if (flags & DC_AUTO) {
1815 if (!IsTileOwner(tile, _current_company)) {
1816 return_cmd_error(STR_ERROR_AREA_IS_OWNED_BY_ANOTHER);
1817 }
1818
1819 if (IsPlainRail(tile)) {
1820 return_cmd_error(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK);
1821 } else {
1822 return_cmd_error(STR_ERROR_BUILDING_MUST_BE_DEMOLISHED);
1823 }
1824 }
1825
1826 switch (GetRailTileType(tile)) {
1827 case RAIL_TILE_SIGNALS:
1828 case RAIL_TILE_NORMAL: {
1829 Slope tileh = GetTileSlope(tile);
1830 /* Is there flat water on the lower halftile that gets cleared expensively? */
1831 bool water_ground = (GetRailGroundType(tile) == RAIL_GROUND_WATER && IsSlopeWithOneCornerRaised(tileh));
1832
1833 TrackBits tracks = GetTrackBits(tile);
1834 while (tracks != TRACK_BIT_NONE) {
1835 Track track = RemoveFirstTrack(&tracks);
1836 CommandCost ret = Command<CMD_REMOVE_SINGLE_RAIL>::Do(flags, tile, track);
1837 if (ret.Failed()) return ret;
1838 cost.AddCost(ret);
1839 }
1840
1841 /* When bankrupting, don't make water dirty, there could be a ship on lower halftile.
1842 * Same holds for non-companies clearing the tile, e.g. disasters. */
1843 if (water_ground && !(flags & DC_BANKRUPT) && Company::IsValidID(_current_company)) {
1844 CommandCost ret = EnsureNoVehicleOnGround(tile);
1845 if (ret.Failed()) return ret;
1846
1847 /* The track was removed, and left a coast tile. Now also clear the water. */
1848 if (flags & DC_EXEC) {
1849 DoClearSquare(tile);
1850 }
1851 cost.AddCost(_price[PR_CLEAR_WATER]);
1852 }
1853
1854 return cost;
1855 }
1856
1857 case RAIL_TILE_DEPOT:
1858 return RemoveTrainDepot(tile, flags);
1859
1860 default:
1861 return CMD_ERROR;
1862 }
1863 }
1864
1869 static uint GetSaveSlopeZ(uint x, uint y, Track track)
1870 {
1871 switch (track) {
1872 case TRACK_UPPER: x &= ~0xF; y &= ~0xF; break;
1873 case TRACK_LOWER: x |= 0xF; y |= 0xF; break;
1874 case TRACK_LEFT: x |= 0xF; y &= ~0xF; break;
1875 case TRACK_RIGHT: x &= ~0xF; y |= 0xF; break;
1876 default: break;
1877 }
1878 return GetSlopePixelZ(x, y);
1879 }
1880
1881 static void DrawSingleSignal(TileIndex tile, const RailTypeInfo *rti, Track track, SignalState condition, SignalOffsets image, uint pos)
1882 {
1883 bool side;
1884 switch (_settings_game.construction.train_signal_side) {
1885 case 0: side = false; break; // left
1886 case 2: side = true; break; // right
1887 default: side = _settings_game.vehicle.road_side != 0; break; // driving side
1888 }
1889 static const Point SignalPositions[2][12] = {
1890 { // Signals on the left side
1891 /* LEFT LEFT RIGHT RIGHT UPPER UPPER */
1892 { 8, 5}, {14, 1}, { 1, 14}, { 9, 11}, { 1, 0}, { 3, 10},
1893 /* LOWER LOWER X X Y Y */
1894 {11, 4}, {14, 14}, {11, 3}, { 4, 13}, { 3, 4}, {11, 13}
1895 }, { // Signals on the right side
1896 /* LEFT LEFT RIGHT RIGHT UPPER UPPER */
1897 {14, 1}, {12, 10}, { 4, 6}, { 1, 14}, {10, 4}, { 0, 1},
1898 /* LOWER LOWER X X Y Y */
1899 {14, 14}, { 5, 12}, {11, 13}, { 4, 3}, {13, 4}, { 3, 11}
1900 }
1901 };
1902
1903 uint x = TileX(tile) * TILE_SIZE + SignalPositions[side][pos].x;
1904 uint y = TileY(tile) * TILE_SIZE + SignalPositions[side][pos].y;
1905
1906 SignalType type = GetSignalType(tile, track);
1907 SignalVariant variant = GetSignalVariant(tile, track);
1908
1909 SpriteID sprite = GetCustomSignalSprite(rti, tile, type, variant, condition);
1910 if (sprite != 0) {
1911 sprite += image;
1912 } else {
1913 /* Normal electric signals are stored in a different sprite block than all other signals. */
1914 sprite = (type == SIGTYPE_BLOCK && variant == SIG_ELECTRIC) ? SPR_ORIGINAL_SIGNALS_BASE : SPR_SIGNALS_BASE - 16;
1915 sprite += type * 16 + variant * 64 + image * 2 + condition + (type > SIGTYPE_LAST_NOPBS ? 64 : 0);
1916 }
1917
1918 AddSortableSpriteToDraw(sprite, PAL_NONE, x, y, 1, 1, BB_HEIGHT_UNDER_BRIDGE, GetSaveSlopeZ(x, y, track));
1919 }
1920
1921 static uint32_t _drawtile_track_palette;
1922
1923
1924
1926 struct FenceOffset {
1927 Corner height_ref;
1928 int x_offs;
1929 int y_offs;
1930 int x_size;
1931 int y_size;
1932 };
1933
1935 static FenceOffset _fence_offsets[] = {
1936 { CORNER_INVALID, 0, 1, 16, 1 }, // RFO_FLAT_X_NW
1937 { CORNER_INVALID, 1, 0, 1, 16 }, // RFO_FLAT_Y_NE
1938 { CORNER_W, 8, 8, 1, 1 }, // RFO_FLAT_LEFT
1939 { CORNER_N, 8, 8, 1, 1 }, // RFO_FLAT_UPPER
1940 { CORNER_INVALID, 0, 1, 16, 1 }, // RFO_SLOPE_SW_NW
1941 { CORNER_INVALID, 1, 0, 1, 16 }, // RFO_SLOPE_SE_NE
1942 { CORNER_INVALID, 0, 1, 16, 1 }, // RFO_SLOPE_NE_NW
1943 { CORNER_INVALID, 1, 0, 1, 16 }, // RFO_SLOPE_NW_NE
1944 { CORNER_INVALID, 0, 15, 16, 1 }, // RFO_FLAT_X_SE
1945 { CORNER_INVALID, 15, 0, 1, 16 }, // RFO_FLAT_Y_SW
1946 { CORNER_E, 8, 8, 1, 1 }, // RFO_FLAT_RIGHT
1947 { CORNER_S, 8, 8, 1, 1 }, // RFO_FLAT_LOWER
1948 { CORNER_INVALID, 0, 15, 16, 1 }, // RFO_SLOPE_SW_SE
1949 { CORNER_INVALID, 15, 0, 1, 16 }, // RFO_SLOPE_SE_SW
1950 { CORNER_INVALID, 0, 15, 16, 1 }, // RFO_SLOPE_NE_SE
1951 { CORNER_INVALID, 15, 0, 1, 16 }, // RFO_SLOPE_NW_SW
1952 };
1953
1961 static void DrawTrackFence(const TileInfo *ti, SpriteID base_image, uint num_sprites, RailFenceOffset rfo)
1962 {
1963 int z = ti->z;
1964 if (_fence_offsets[rfo].height_ref != CORNER_INVALID) {
1965 z += GetSlopePixelZInCorner(RemoveHalftileSlope(ti->tileh), _fence_offsets[rfo].height_ref);
1966 }
1967 AddSortableSpriteToDraw(base_image + (rfo % num_sprites), _drawtile_track_palette,
1968 ti->x + _fence_offsets[rfo].x_offs,
1969 ti->y + _fence_offsets[rfo].y_offs,
1970 _fence_offsets[rfo].x_size,
1971 _fence_offsets[rfo].y_size,
1972 4, z);
1973 }
1974
1978 static void DrawTrackFence_NW(const TileInfo *ti, SpriteID base_image, uint num_sprites)
1979 {
1980 RailFenceOffset rfo = RFO_FLAT_X_NW;
1981 if (ti->tileh & SLOPE_NW) rfo = (ti->tileh & SLOPE_W) ? RFO_SLOPE_SW_NW : RFO_SLOPE_NE_NW;
1982 DrawTrackFence(ti, base_image, num_sprites, rfo);
1983 }
1984
1988 static void DrawTrackFence_SE(const TileInfo *ti, SpriteID base_image, uint num_sprites)
1989 {
1990 RailFenceOffset rfo = RFO_FLAT_X_SE;
1991 if (ti->tileh & SLOPE_SE) rfo = (ti->tileh & SLOPE_S) ? RFO_SLOPE_SW_SE : RFO_SLOPE_NE_SE;
1992 DrawTrackFence(ti, base_image, num_sprites, rfo);
1993 }
1994
1998 static void DrawTrackFence_NE(const TileInfo *ti, SpriteID base_image, uint num_sprites)
1999 {
2000 RailFenceOffset rfo = RFO_FLAT_Y_NE;
2001 if (ti->tileh & SLOPE_NE) rfo = (ti->tileh & SLOPE_E) ? RFO_SLOPE_SE_NE : RFO_SLOPE_NW_NE;
2002 DrawTrackFence(ti, base_image, num_sprites, rfo);
2003 }
2004
2008 static void DrawTrackFence_SW(const TileInfo *ti, SpriteID base_image, uint num_sprites)
2009 {
2010 RailFenceOffset rfo = RFO_FLAT_Y_SW;
2011 if (ti->tileh & SLOPE_SW) rfo = (ti->tileh & SLOPE_S) ? RFO_SLOPE_SE_SW : RFO_SLOPE_NW_SW;
2012 DrawTrackFence(ti, base_image, num_sprites, rfo);
2013 }
2014
2020 static void DrawTrackDetails(const TileInfo *ti, const RailTypeInfo *rti)
2021 {
2022 /* Base sprite for track fences.
2023 * Note: Halftile slopes only have fences on the upper part. */
2024 uint num_sprites = 0;
2025 SpriteID base_image = GetCustomRailSprite(rti, ti->tile, RTSG_FENCES, IsHalftileSlope(ti->tileh) ? TCX_UPPER_HALFTILE : TCX_NORMAL, &num_sprites);
2026 if (base_image == 0) {
2027 base_image = SPR_TRACK_FENCE_FLAT_X;
2028 num_sprites = 8;
2029 }
2030
2031 assert(num_sprites > 0);
2032
2033 switch (GetRailGroundType(ti->tile)) {
2034 case RAIL_GROUND_FENCE_NW: DrawTrackFence_NW(ti, base_image, num_sprites); break;
2035 case RAIL_GROUND_FENCE_SE: DrawTrackFence_SE(ti, base_image, num_sprites); break;
2036 case RAIL_GROUND_FENCE_SENW: DrawTrackFence_NW(ti, base_image, num_sprites);
2037 DrawTrackFence_SE(ti, base_image, num_sprites); break;
2038 case RAIL_GROUND_FENCE_NE: DrawTrackFence_NE(ti, base_image, num_sprites); break;
2039 case RAIL_GROUND_FENCE_SW: DrawTrackFence_SW(ti, base_image, num_sprites); break;
2040 case RAIL_GROUND_FENCE_NESW: DrawTrackFence_NE(ti, base_image, num_sprites);
2041 DrawTrackFence_SW(ti, base_image, num_sprites); break;
2042 case RAIL_GROUND_FENCE_VERT1: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_LEFT); break;
2043 case RAIL_GROUND_FENCE_VERT2: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_RIGHT); break;
2044 case RAIL_GROUND_FENCE_HORIZ1: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_UPPER); break;
2045 case RAIL_GROUND_FENCE_HORIZ2: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_LOWER); break;
2046 case RAIL_GROUND_WATER: {
2047 Corner track_corner;
2048 if (IsHalftileSlope(ti->tileh)) {
2049 /* Steep slope or one-corner-raised slope with halftile foundation */
2050 track_corner = GetHalftileSlopeCorner(ti->tileh);
2051 } else {
2052 /* Three-corner-raised slope */
2053 track_corner = OppositeCorner(GetHighestSlopeCorner(ComplementSlope(ti->tileh)));
2054 }
2055 switch (track_corner) {
2056 case CORNER_W: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_LEFT); break;
2057 case CORNER_S: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_LOWER); break;
2058 case CORNER_E: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_RIGHT); break;
2059 case CORNER_N: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_UPPER); break;
2060 default: NOT_REACHED();
2061 }
2062 break;
2063 }
2064 default: break;
2065 }
2066 }
2067
2068 /* SubSprite for drawing the track halftile of 'three-corners-raised'-sloped rail sprites. */
2069 static const int INF = 1000; // big number compared to tilesprite size
2070 static const SubSprite _halftile_sub_sprite[4] = {
2071 { -INF , -INF , 32 - 33, INF }, // CORNER_W, clip 33 pixels from right
2072 { -INF , 0 + 7, INF , INF }, // CORNER_S, clip 7 pixels from top
2073 { -31 + 33, -INF , INF , INF }, // CORNER_E, clip 33 pixels from left
2074 { -INF , -INF , INF , 30 - 23 } // CORNER_N, clip 23 pixels from bottom
2075 };
2076
2077 static inline void DrawTrackSprite(SpriteID sprite, PaletteID pal, const TileInfo *ti, Slope s)
2078 {
2079 DrawGroundSprite(sprite, pal, nullptr, 0, (ti->tileh & s) ? -8 : 0);
2080 }
2081
2082 static void DrawTrackBitsOverlay(TileInfo *ti, TrackBits track, const RailTypeInfo *rti)
2083 {
2084 RailGroundType rgt = GetRailGroundType(ti->tile);
2085 Foundation f = GetRailFoundation(ti->tileh, track);
2086 Corner halftile_corner = CORNER_INVALID;
2087
2088 if (IsNonContinuousFoundation(f)) {
2089 /* Save halftile corner */
2090 halftile_corner = (f == FOUNDATION_STEEP_BOTH ? GetHighestSlopeCorner(ti->tileh) : GetHalftileFoundationCorner(f));
2091 /* Draw lower part first */
2092 track &= ~CornerToTrackBits(halftile_corner);
2093 f = (f == FOUNDATION_STEEP_BOTH ? FOUNDATION_STEEP_LOWER : FOUNDATION_NONE);
2094 }
2095
2096 DrawFoundation(ti, f);
2097 /* DrawFoundation modifies ti */
2098
2099 /* Draw ground */
2100 if (rgt == RAIL_GROUND_WATER) {
2101 if (track != TRACK_BIT_NONE || IsSteepSlope(ti->tileh)) {
2102 /* three-corner-raised slope or steep slope with track on upper part */
2103 DrawShoreTile(ti->tileh);
2104 } else {
2105 /* single-corner-raised slope with track on upper part */
2106 DrawGroundSprite(SPR_FLAT_WATER_TILE, PAL_NONE);
2107 }
2108 } else {
2109 SpriteID image;
2110
2111 switch (rgt) {
2112 case RAIL_GROUND_BARREN: image = SPR_FLAT_BARE_LAND; break;
2113 case RAIL_GROUND_ICE_DESERT: image = SPR_FLAT_SNOW_DESERT_TILE; break;
2114 default: image = SPR_FLAT_GRASS_TILE; break;
2115 }
2116
2117 image += SlopeToSpriteOffset(ti->tileh);
2118
2119 DrawGroundSprite(image, PAL_NONE);
2120 }
2121
2122 bool no_combine = ti->tileh == SLOPE_FLAT && HasBit(rti->flags, RTF_NO_SPRITE_COMBINE);
2123 SpriteID overlay = GetCustomRailSprite(rti, ti->tile, RTSG_OVERLAY);
2124 SpriteID ground = GetCustomRailSprite(rti, ti->tile, no_combine ? RTSG_GROUND_COMPLETE : RTSG_GROUND);
2125 TrackBits pbs = _settings_client.gui.show_track_reservation ? GetRailReservationTrackBits(ti->tile) : TRACK_BIT_NONE;
2126
2127 if (track == TRACK_BIT_NONE) {
2128 /* Half-tile foundation, no track here? */
2129 } else if (no_combine) {
2130 /* Use trackbits as direct index from ground sprite, subtract 1
2131 * because there is no sprite for no bits. */
2132 DrawGroundSprite(ground + track - 1, PAL_NONE);
2133
2134 /* Draw reserved track bits */
2135 if (pbs & TRACK_BIT_X) DrawGroundSprite(overlay + RTO_X, PALETTE_CRASH);
2136 if (pbs & TRACK_BIT_Y) DrawGroundSprite(overlay + RTO_Y, PALETTE_CRASH);
2137 if (pbs & TRACK_BIT_UPPER) DrawTrackSprite(overlay + RTO_N, PALETTE_CRASH, ti, SLOPE_N);
2138 if (pbs & TRACK_BIT_LOWER) DrawTrackSprite(overlay + RTO_S, PALETTE_CRASH, ti, SLOPE_S);
2139 if (pbs & TRACK_BIT_RIGHT) DrawTrackSprite(overlay + RTO_E, PALETTE_CRASH, ti, SLOPE_E);
2140 if (pbs & TRACK_BIT_LEFT) DrawTrackSprite(overlay + RTO_W, PALETTE_CRASH, ti, SLOPE_W);
2141 } else if (ti->tileh == SLOPE_NW && track == TRACK_BIT_Y) {
2142 DrawGroundSprite(ground + RTO_SLOPE_NW, PAL_NONE);
2143 if (pbs != TRACK_BIT_NONE) DrawGroundSprite(overlay + RTO_SLOPE_NW, PALETTE_CRASH);
2144 } else if (ti->tileh == SLOPE_NE && track == TRACK_BIT_X) {
2145 DrawGroundSprite(ground + RTO_SLOPE_NE, PAL_NONE);
2146 if (pbs != TRACK_BIT_NONE) DrawGroundSprite(overlay + RTO_SLOPE_NE, PALETTE_CRASH);
2147 } else if (ti->tileh == SLOPE_SE && track == TRACK_BIT_Y) {
2148 DrawGroundSprite(ground + RTO_SLOPE_SE, PAL_NONE);
2149 if (pbs != TRACK_BIT_NONE) DrawGroundSprite(overlay + RTO_SLOPE_SE, PALETTE_CRASH);
2150 } else if (ti->tileh == SLOPE_SW && track == TRACK_BIT_X) {
2151 DrawGroundSprite(ground + RTO_SLOPE_SW, PAL_NONE);
2152 if (pbs != TRACK_BIT_NONE) DrawGroundSprite(overlay + RTO_SLOPE_SW, PALETTE_CRASH);
2153 } else {
2154 switch (track) {
2155 /* Draw single ground sprite when not overlapping. No track overlay
2156 * is necessary for these sprites. */
2157 case TRACK_BIT_X: DrawGroundSprite(ground + RTO_X, PAL_NONE); break;
2158 case TRACK_BIT_Y: DrawGroundSprite(ground + RTO_Y, PAL_NONE); break;
2159 case TRACK_BIT_UPPER: DrawTrackSprite(ground + RTO_N, PAL_NONE, ti, SLOPE_N); break;
2160 case TRACK_BIT_LOWER: DrawTrackSprite(ground + RTO_S, PAL_NONE, ti, SLOPE_S); break;
2161 case TRACK_BIT_RIGHT: DrawTrackSprite(ground + RTO_E, PAL_NONE, ti, SLOPE_E); break;
2162 case TRACK_BIT_LEFT: DrawTrackSprite(ground + RTO_W, PAL_NONE, ti, SLOPE_W); break;
2163 case TRACK_BIT_CROSS: DrawGroundSprite(ground + RTO_CROSSING_XY, PAL_NONE); break;
2164 case TRACK_BIT_HORZ: DrawTrackSprite(ground + RTO_N, PAL_NONE, ti, SLOPE_N);
2165 DrawTrackSprite(ground + RTO_S, PAL_NONE, ti, SLOPE_S); break;
2166 case TRACK_BIT_VERT: DrawTrackSprite(ground + RTO_E, PAL_NONE, ti, SLOPE_E);
2167 DrawTrackSprite(ground + RTO_W, PAL_NONE, ti, SLOPE_W); break;
2168
2169 default:
2170 /* We're drawing a junction tile */
2171 if ((track & TRACK_BIT_3WAY_NE) == 0) {
2172 DrawGroundSprite(ground + RTO_JUNCTION_SW, PAL_NONE);
2173 } else if ((track & TRACK_BIT_3WAY_SW) == 0) {
2174 DrawGroundSprite(ground + RTO_JUNCTION_NE, PAL_NONE);
2175 } else if ((track & TRACK_BIT_3WAY_NW) == 0) {
2176 DrawGroundSprite(ground + RTO_JUNCTION_SE, PAL_NONE);
2177 } else if ((track & TRACK_BIT_3WAY_SE) == 0) {
2178 DrawGroundSprite(ground + RTO_JUNCTION_NW, PAL_NONE);
2179 } else {
2180 DrawGroundSprite(ground + RTO_JUNCTION_NSEW, PAL_NONE);
2181 }
2182
2183 /* Mask out PBS bits as we shall draw them afterwards anyway. */
2184 track &= ~pbs;
2185
2186 /* Draw regular track bits */
2187 if (track & TRACK_BIT_X) DrawGroundSprite(overlay + RTO_X, PAL_NONE);
2188 if (track & TRACK_BIT_Y) DrawGroundSprite(overlay + RTO_Y, PAL_NONE);
2189 if (track & TRACK_BIT_UPPER) DrawGroundSprite(overlay + RTO_N, PAL_NONE);
2190 if (track & TRACK_BIT_LOWER) DrawGroundSprite(overlay + RTO_S, PAL_NONE);
2191 if (track & TRACK_BIT_RIGHT) DrawGroundSprite(overlay + RTO_E, PAL_NONE);
2192 if (track & TRACK_BIT_LEFT) DrawGroundSprite(overlay + RTO_W, PAL_NONE);
2193 }
2194
2195 /* Draw reserved track bits */
2196 if (pbs & TRACK_BIT_X) DrawGroundSprite(overlay + RTO_X, PALETTE_CRASH);
2197 if (pbs & TRACK_BIT_Y) DrawGroundSprite(overlay + RTO_Y, PALETTE_CRASH);
2198 if (pbs & TRACK_BIT_UPPER) DrawTrackSprite(overlay + RTO_N, PALETTE_CRASH, ti, SLOPE_N);
2199 if (pbs & TRACK_BIT_LOWER) DrawTrackSprite(overlay + RTO_S, PALETTE_CRASH, ti, SLOPE_S);
2200 if (pbs & TRACK_BIT_RIGHT) DrawTrackSprite(overlay + RTO_E, PALETTE_CRASH, ti, SLOPE_E);
2201 if (pbs & TRACK_BIT_LEFT) DrawTrackSprite(overlay + RTO_W, PALETTE_CRASH, ti, SLOPE_W);
2202 }
2203
2204 if (IsValidCorner(halftile_corner)) {
2205 DrawFoundation(ti, HalftileFoundation(halftile_corner));
2206 overlay = GetCustomRailSprite(rti, ti->tile, RTSG_OVERLAY, TCX_UPPER_HALFTILE);
2207 ground = GetCustomRailSprite(rti, ti->tile, RTSG_GROUND, TCX_UPPER_HALFTILE);
2208
2209 /* Draw higher halftile-overlay: Use the sloped sprites with three corners raised. They probably best fit the lightning. */
2210 Slope fake_slope = SlopeWithThreeCornersRaised(OppositeCorner(halftile_corner));
2211
2212 SpriteID image;
2213 switch (rgt) {
2214 case RAIL_GROUND_BARREN: image = SPR_FLAT_BARE_LAND; break;
2215 case RAIL_GROUND_ICE_DESERT:
2216 case RAIL_GROUND_HALF_SNOW: image = SPR_FLAT_SNOW_DESERT_TILE; break;
2217 default: image = SPR_FLAT_GRASS_TILE; break;
2218 }
2219
2220 image += SlopeToSpriteOffset(fake_slope);
2221
2222 DrawGroundSprite(image, PAL_NONE, &(_halftile_sub_sprite[halftile_corner]));
2223
2224 track = CornerToTrackBits(halftile_corner);
2225
2226 int offset;
2227 switch (track) {
2228 default: NOT_REACHED();
2229 case TRACK_BIT_UPPER: offset = RTO_N; break;
2230 case TRACK_BIT_LOWER: offset = RTO_S; break;
2231 case TRACK_BIT_RIGHT: offset = RTO_E; break;
2232 case TRACK_BIT_LEFT: offset = RTO_W; break;
2233 }
2234
2235 DrawTrackSprite(ground + offset, PAL_NONE, ti, fake_slope);
2236 if (_settings_client.gui.show_track_reservation && HasReservedTracks(ti->tile, track)) {
2237 DrawTrackSprite(overlay + offset, PALETTE_CRASH, ti, fake_slope);
2238 }
2239 }
2240 }
2241
2247 static void DrawTrackBits(TileInfo *ti, TrackBits track)
2248 {
2249 const RailTypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile));
2250
2251 if (rti->UsesOverlay()) {
2252 DrawTrackBitsOverlay(ti, track, rti);
2253 return;
2254 }
2255
2256 RailGroundType rgt = GetRailGroundType(ti->tile);
2257 Foundation f = GetRailFoundation(ti->tileh, track);
2258 Corner halftile_corner = CORNER_INVALID;
2259
2260 if (IsNonContinuousFoundation(f)) {
2261 /* Save halftile corner */
2262 halftile_corner = (f == FOUNDATION_STEEP_BOTH ? GetHighestSlopeCorner(ti->tileh) : GetHalftileFoundationCorner(f));
2263 /* Draw lower part first */
2264 track &= ~CornerToTrackBits(halftile_corner);
2265 f = (f == FOUNDATION_STEEP_BOTH ? FOUNDATION_STEEP_LOWER : FOUNDATION_NONE);
2266 }
2267
2268 DrawFoundation(ti, f);
2269 /* DrawFoundation modifies ti */
2270
2271 SpriteID image;
2272 PaletteID pal = PAL_NONE;
2273 const SubSprite *sub = nullptr;
2274 bool junction = false;
2275
2276 /* Select the sprite to use. */
2277 if (track == 0) {
2278 /* Clear ground (only track on halftile foundation) */
2279 if (rgt == RAIL_GROUND_WATER) {
2280 if (IsSteepSlope(ti->tileh)) {
2281 DrawShoreTile(ti->tileh);
2282 image = 0;
2283 } else {
2284 image = SPR_FLAT_WATER_TILE;
2285 }
2286 } else {
2287 switch (rgt) {
2288 case RAIL_GROUND_BARREN: image = SPR_FLAT_BARE_LAND; break;
2289 case RAIL_GROUND_ICE_DESERT: image = SPR_FLAT_SNOW_DESERT_TILE; break;
2290 default: image = SPR_FLAT_GRASS_TILE; break;
2291 }
2292 image += SlopeToSpriteOffset(ti->tileh);
2293 }
2294 } else {
2295 if (ti->tileh != SLOPE_FLAT) {
2296 /* track on non-flat ground */
2297 image = _track_sloped_sprites[ti->tileh - 1] + rti->base_sprites.track_y;
2298 } else {
2299 /* track on flat ground */
2300 switch (track) {
2301 /* single track, select combined track + ground sprite*/
2302 case TRACK_BIT_Y: image = rti->base_sprites.track_y; break;
2303 case TRACK_BIT_X: image = rti->base_sprites.track_y + 1; break;
2304 case TRACK_BIT_UPPER: image = rti->base_sprites.track_y + 2; break;
2305 case TRACK_BIT_LOWER: image = rti->base_sprites.track_y + 3; break;
2306 case TRACK_BIT_RIGHT: image = rti->base_sprites.track_y + 4; break;
2307 case TRACK_BIT_LEFT: image = rti->base_sprites.track_y + 5; break;
2308 case TRACK_BIT_CROSS: image = rti->base_sprites.track_y + 6; break;
2309
2310 /* double diagonal track, select combined track + ground sprite*/
2311 case TRACK_BIT_HORZ: image = rti->base_sprites.track_ns; break;
2312 case TRACK_BIT_VERT: image = rti->base_sprites.track_ns + 1; break;
2313
2314 /* junction, select only ground sprite, handle track sprite later */
2315 default:
2316 junction = true;
2317 if ((track & TRACK_BIT_3WAY_NE) == 0) { image = rti->base_sprites.ground; break; }
2318 if ((track & TRACK_BIT_3WAY_SW) == 0) { image = rti->base_sprites.ground + 1; break; }
2319 if ((track & TRACK_BIT_3WAY_NW) == 0) { image = rti->base_sprites.ground + 2; break; }
2320 if ((track & TRACK_BIT_3WAY_SE) == 0) { image = rti->base_sprites.ground + 3; break; }
2321 image = rti->base_sprites.ground + 4;
2322 break;
2323 }
2324 }
2325
2326 switch (rgt) {
2327 case RAIL_GROUND_BARREN: pal = PALETTE_TO_BARE_LAND; break;
2328 case RAIL_GROUND_ICE_DESERT: image += rti->snow_offset; break;
2329 case RAIL_GROUND_WATER: {
2330 /* three-corner-raised slope */
2331 DrawShoreTile(ti->tileh);
2332 Corner track_corner = OppositeCorner(GetHighestSlopeCorner(ComplementSlope(ti->tileh)));
2333 sub = &(_halftile_sub_sprite[track_corner]);
2334 break;
2335 }
2336 default: break;
2337 }
2338 }
2339
2340 if (image != 0) DrawGroundSprite(image, pal, sub);
2341
2342 /* Draw track pieces individually for junction tiles */
2343 if (junction) {
2344 if (track & TRACK_BIT_X) DrawGroundSprite(rti->base_sprites.single_x, PAL_NONE);
2345 if (track & TRACK_BIT_Y) DrawGroundSprite(rti->base_sprites.single_y, PAL_NONE);
2346 if (track & TRACK_BIT_UPPER) DrawGroundSprite(rti->base_sprites.single_n, PAL_NONE);
2347 if (track & TRACK_BIT_LOWER) DrawGroundSprite(rti->base_sprites.single_s, PAL_NONE);
2348 if (track & TRACK_BIT_LEFT) DrawGroundSprite(rti->base_sprites.single_w, PAL_NONE);
2349 if (track & TRACK_BIT_RIGHT) DrawGroundSprite(rti->base_sprites.single_e, PAL_NONE);
2350 }
2351
2352 /* PBS debugging, draw reserved tracks darker */
2353 if (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation) {
2354 /* Get reservation, but mask track on halftile slope */
2355 TrackBits pbs = GetRailReservationTrackBits(ti->tile) & track;
2356 if (pbs & TRACK_BIT_X) {
2357 if (ti->tileh == SLOPE_FLAT || ti->tileh == SLOPE_ELEVATED) {
2358 DrawGroundSprite(rti->base_sprites.single_x, PALETTE_CRASH);
2359 } else {
2360 DrawGroundSprite(_track_sloped_sprites[ti->tileh - 1] + rti->base_sprites.single_sloped - 20, PALETTE_CRASH);
2361 }
2362 }
2363 if (pbs & TRACK_BIT_Y) {
2364 if (ti->tileh == SLOPE_FLAT || ti->tileh == SLOPE_ELEVATED) {
2365 DrawGroundSprite(rti->base_sprites.single_y, PALETTE_CRASH);
2366 } else {
2367 DrawGroundSprite(_track_sloped_sprites[ti->tileh - 1] + rti->base_sprites.single_sloped - 20, PALETTE_CRASH);
2368 }
2369 }
2370 if (pbs & TRACK_BIT_UPPER) DrawGroundSprite(rti->base_sprites.single_n, PALETTE_CRASH, nullptr, 0, ti->tileh & SLOPE_N ? -(int)TILE_HEIGHT : 0);
2371 if (pbs & TRACK_BIT_LOWER) DrawGroundSprite(rti->base_sprites.single_s, PALETTE_CRASH, nullptr, 0, ti->tileh & SLOPE_S ? -(int)TILE_HEIGHT : 0);
2372 if (pbs & TRACK_BIT_LEFT) DrawGroundSprite(rti->base_sprites.single_w, PALETTE_CRASH, nullptr, 0, ti->tileh & SLOPE_W ? -(int)TILE_HEIGHT : 0);
2373 if (pbs & TRACK_BIT_RIGHT) DrawGroundSprite(rti->base_sprites.single_e, PALETTE_CRASH, nullptr, 0, ti->tileh & SLOPE_E ? -(int)TILE_HEIGHT : 0);
2374 }
2375
2376 if (IsValidCorner(halftile_corner)) {
2377 DrawFoundation(ti, HalftileFoundation(halftile_corner));
2378
2379 /* Draw higher halftile-overlay: Use the sloped sprites with three corners raised. They probably best fit the lightning. */
2380 Slope fake_slope = SlopeWithThreeCornersRaised(OppositeCorner(halftile_corner));
2381 image = _track_sloped_sprites[fake_slope - 1] + rti->base_sprites.track_y;
2382 pal = PAL_NONE;
2383 switch (rgt) {
2384 case RAIL_GROUND_BARREN: pal = PALETTE_TO_BARE_LAND; break;
2385 case RAIL_GROUND_ICE_DESERT:
2386 case RAIL_GROUND_HALF_SNOW: image += rti->snow_offset; break; // higher part has snow in this case too
2387 default: break;
2388 }
2389 DrawGroundSprite(image, pal, &(_halftile_sub_sprite[halftile_corner]));
2390
2391 if (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation && HasReservedTracks(ti->tile, CornerToTrackBits(halftile_corner))) {
2392 static const byte _corner_to_track_sprite[] = {3, 1, 2, 0};
2393 DrawGroundSprite(_corner_to_track_sprite[halftile_corner] + rti->base_sprites.single_n, PALETTE_CRASH, nullptr, 0, -(int)TILE_HEIGHT);
2394 }
2395 }
2396 }
2397
2398 static void DrawSignals(TileIndex tile, TrackBits rails, const RailTypeInfo *rti)
2399 {
2400 auto MAYBE_DRAW_SIGNAL = [&](byte signalbit, SignalOffsets image, uint pos, Track track) {
2401 if (IsSignalPresent(tile, signalbit)) DrawSingleSignal(tile, rti, track, GetSingleSignalState(tile, signalbit), image, pos);
2402 };
2403
2404 if (!(rails & TRACK_BIT_Y)) {
2405 if (!(rails & TRACK_BIT_X)) {
2406 if (rails & TRACK_BIT_LEFT) {
2407 MAYBE_DRAW_SIGNAL(2, SIGNAL_TO_NORTH, 0, TRACK_LEFT);
2408 MAYBE_DRAW_SIGNAL(3, SIGNAL_TO_SOUTH, 1, TRACK_LEFT);
2409 }
2410 if (rails & TRACK_BIT_RIGHT) {
2411 MAYBE_DRAW_SIGNAL(0, SIGNAL_TO_NORTH, 2, TRACK_RIGHT);
2412 MAYBE_DRAW_SIGNAL(1, SIGNAL_TO_SOUTH, 3, TRACK_RIGHT);
2413 }
2414 if (rails & TRACK_BIT_UPPER) {
2415 MAYBE_DRAW_SIGNAL(3, SIGNAL_TO_WEST, 4, TRACK_UPPER);
2416 MAYBE_DRAW_SIGNAL(2, SIGNAL_TO_EAST, 5, TRACK_UPPER);
2417 }
2418 if (rails & TRACK_BIT_LOWER) {
2419 MAYBE_DRAW_SIGNAL(1, SIGNAL_TO_WEST, 6, TRACK_LOWER);
2420 MAYBE_DRAW_SIGNAL(0, SIGNAL_TO_EAST, 7, TRACK_LOWER);
2421 }
2422 } else {
2423 MAYBE_DRAW_SIGNAL(3, SIGNAL_TO_SOUTHWEST, 8, TRACK_X);
2424 MAYBE_DRAW_SIGNAL(2, SIGNAL_TO_NORTHEAST, 9, TRACK_X);
2425 }
2426 } else {
2427 MAYBE_DRAW_SIGNAL(3, SIGNAL_TO_SOUTHEAST, 10, TRACK_Y);
2428 MAYBE_DRAW_SIGNAL(2, SIGNAL_TO_NORTHWEST, 11, TRACK_Y);
2429 }
2430 }
2431
2432 static void DrawTile_Track(TileInfo *ti)
2433 {
2434 const RailTypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile));
2435
2436 _drawtile_track_palette = COMPANY_SPRITE_COLOUR(GetTileOwner(ti->tile));
2437
2438 if (IsPlainRail(ti->tile)) {
2439 TrackBits rails = GetTrackBits(ti->tile);
2440
2441 DrawTrackBits(ti, rails);
2442
2443 if (HasBit(_display_opt, DO_FULL_DETAIL)) DrawTrackDetails(ti, rti);
2444
2445 if (HasRailCatenaryDrawn(GetRailType(ti->tile))) DrawRailCatenary(ti);
2446
2447 if (HasSignals(ti->tile)) DrawSignals(ti->tile, rails, rti);
2448 } else {
2449 /* draw depot */
2450 const DrawTileSprites *dts;
2451 PaletteID pal = PAL_NONE;
2452 SpriteID relocation;
2453
2454 if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED);
2455
2456 if (IsInvisibilitySet(TO_BUILDINGS)) {
2457 /* Draw rail instead of depot */
2458 dts = &_depot_invisible_gfx_table[GetRailDepotDirection(ti->tile)];
2459 } else {
2460 dts = &_depot_gfx_table[GetRailDepotDirection(ti->tile)];
2461 }
2462
2463 SpriteID image;
2464 if (rti->UsesOverlay()) {
2465 image = SPR_FLAT_GRASS_TILE;
2466 } else {
2467 image = dts->ground.sprite;
2468 if (image != SPR_FLAT_GRASS_TILE) image += rti->GetRailtypeSpriteOffset();
2469 }
2470
2471 /* Adjust ground tile for desert and snow. */
2472 if (IsSnowRailGround(ti->tile)) {
2473 if (image != SPR_FLAT_GRASS_TILE) {
2474 image += rti->snow_offset; // tile with tracks
2475 } else {
2476 image = SPR_FLAT_SNOW_DESERT_TILE; // flat ground
2477 }
2478 }
2479
2480 DrawGroundSprite(image, GroundSpritePaletteTransform(image, pal, _drawtile_track_palette));
2481
2482 if (rti->UsesOverlay()) {
2483 SpriteID ground = GetCustomRailSprite(rti, ti->tile, RTSG_GROUND);
2484
2485 switch (GetRailDepotDirection(ti->tile)) {
2486 case DIAGDIR_NE:
2487 if (!IsInvisibilitySet(TO_BUILDINGS)) break;
2488 [[fallthrough]];
2489 case DIAGDIR_SW:
2490 DrawGroundSprite(ground + RTO_X, PAL_NONE);
2491 break;
2492 case DIAGDIR_NW:
2493 if (!IsInvisibilitySet(TO_BUILDINGS)) break;
2494 [[fallthrough]];
2495 case DIAGDIR_SE:
2496 DrawGroundSprite(ground + RTO_Y, PAL_NONE);
2497 break;
2498 default:
2499 break;
2500 }
2501
2502 if (_settings_client.gui.show_track_reservation && HasDepotReservation(ti->tile)) {
2503 SpriteID overlay = GetCustomRailSprite(rti, ti->tile, RTSG_OVERLAY);
2504
2505 switch (GetRailDepotDirection(ti->tile)) {
2506 case DIAGDIR_NE:
2507 if (!IsInvisibilitySet(TO_BUILDINGS)) break;
2508 [[fallthrough]];
2509 case DIAGDIR_SW:
2510 DrawGroundSprite(overlay + RTO_X, PALETTE_CRASH);
2511 break;
2512 case DIAGDIR_NW:
2513 if (!IsInvisibilitySet(TO_BUILDINGS)) break;
2514 [[fallthrough]];
2515 case DIAGDIR_SE:
2516 DrawGroundSprite(overlay + RTO_Y, PALETTE_CRASH);
2517 break;
2518 default:
2519 break;
2520 }
2521 }
2522 } else {
2523 /* PBS debugging, draw reserved tracks darker */
2524 if (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation && HasDepotReservation(ti->tile)) {
2525 switch (GetRailDepotDirection(ti->tile)) {
2526 case DIAGDIR_NE:
2527 if (!IsInvisibilitySet(TO_BUILDINGS)) break;
2528 [[fallthrough]];
2529 case DIAGDIR_SW:
2530 DrawGroundSprite(rti->base_sprites.single_x, PALETTE_CRASH);
2531 break;
2532 case DIAGDIR_NW:
2533 if (!IsInvisibilitySet(TO_BUILDINGS)) break;
2534 [[fallthrough]];
2535 case DIAGDIR_SE:
2536 DrawGroundSprite(rti->base_sprites.single_y, PALETTE_CRASH);
2537 break;
2538 default:
2539 break;
2540 }
2541 }
2542 }
2543 int depot_sprite = GetCustomRailSprite(rti, ti->tile, RTSG_DEPOT);
2544 relocation = depot_sprite != 0 ? depot_sprite - SPR_RAIL_DEPOT_SE_1 : rti->GetRailtypeSpriteOffset();
2545
2546 if (HasRailCatenaryDrawn(GetRailType(ti->tile))) DrawRailCatenary(ti);
2547
2548 DrawRailTileSeq(ti, dts, TO_BUILDINGS, relocation, 0, _drawtile_track_palette);
2549 }
2550 DrawBridgeMiddle(ti);
2551 }
2552
2553 void DrawTrainDepotSprite(int x, int y, int dir, RailType railtype)
2554 {
2555 const DrawTileSprites *dts = &_depot_gfx_table[dir];
2556 const RailTypeInfo *rti = GetRailTypeInfo(railtype);
2557 SpriteID image = rti->UsesOverlay() ? SPR_FLAT_GRASS_TILE : dts->ground.sprite;
2558 uint32_t offset = rti->GetRailtypeSpriteOffset();
2559
2560 if (image != SPR_FLAT_GRASS_TILE) image += offset;
2561 PaletteID palette = COMPANY_SPRITE_COLOUR(_local_company);
2562
2563 DrawSprite(image, PAL_NONE, x, y);
2564
2565 if (rti->UsesOverlay()) {
2566 SpriteID ground = GetCustomRailSprite(rti, INVALID_TILE, RTSG_GROUND);
2567
2568 switch (dir) {
2569 case DIAGDIR_SW: DrawSprite(ground + RTO_X, PAL_NONE, x, y); break;
2570 case DIAGDIR_SE: DrawSprite(ground + RTO_Y, PAL_NONE, x, y); break;
2571 default: break;
2572 }
2573 }
2574 int depot_sprite = GetCustomRailSprite(rti, INVALID_TILE, RTSG_DEPOT);
2575 if (depot_sprite != 0) offset = depot_sprite - SPR_RAIL_DEPOT_SE_1;
2576
2577 DrawRailTileSeqInGUI(x, y, dts, offset, 0, palette);
2578 }
2579
2580 static int GetSlopePixelZ_Track(TileIndex tile, uint x, uint y, bool)
2581 {
2582 if (IsPlainRail(tile)) {
2583 int z;
2584 Slope tileh = GetTilePixelSlope(tile, &z);
2585 if (tileh == SLOPE_FLAT) return z;
2586
2587 z += ApplyPixelFoundationToSlope(GetRailFoundation(tileh, GetTrackBits(tile)), &tileh);
2588 return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh);
2589 } else {
2590 return GetTileMaxPixelZ(tile);
2591 }
2592 }
2593
2594 static Foundation GetFoundation_Track(TileIndex tile, Slope tileh)
2595 {
2596 return IsPlainRail(tile) ? GetRailFoundation(tileh, GetTrackBits(tile)) : FlatteningFoundation(tileh);
2597 }
2598
2599 static void TileLoop_Track(TileIndex tile)
2600 {
2601 RailGroundType old_ground = GetRailGroundType(tile);
2602 RailGroundType new_ground;
2603
2604 if (old_ground == RAIL_GROUND_WATER) {
2605 TileLoop_Water(tile);
2606 return;
2607 }
2608
2609 switch (_settings_game.game_creation.landscape) {
2610 case LT_ARCTIC: {
2611 int z;
2612 Slope slope = GetTileSlope(tile, &z);
2613 bool half = false;
2614
2615 /* for non-flat track, use lower part of track
2616 * in other cases, use the highest part with track */
2617 if (IsPlainRail(tile)) {
2618 TrackBits track = GetTrackBits(tile);
2619 Foundation f = GetRailFoundation(slope, track);
2620
2621 switch (f) {
2622 case FOUNDATION_NONE:
2623 /* no foundation - is the track on the upper side of three corners raised tile? */
2624 if (IsSlopeWithThreeCornersRaised(slope)) z++;
2625 break;
2626
2627 case FOUNDATION_INCLINED_X:
2628 case FOUNDATION_INCLINED_Y:
2629 /* sloped track - is it on a steep slope? */
2630 if (IsSteepSlope(slope)) z++;
2631 break;
2632
2633 case FOUNDATION_STEEP_LOWER:
2634 /* only lower part of steep slope */
2635 z++;
2636 break;
2637
2638 default:
2639 /* if it is a steep slope, then there is a track on higher part */
2640 if (IsSteepSlope(slope)) z++;
2641 z++;
2642 break;
2643 }
2644
2645 half = IsInsideMM(f, FOUNDATION_STEEP_BOTH, FOUNDATION_HALFTILE_N + 1);
2646 } else {
2647 /* is the depot on a non-flat tile? */
2648 if (slope != SLOPE_FLAT) z++;
2649 }
2650
2651 /* 'z' is now the lowest part of the highest track bit -
2652 * for sloped track, it is 'z' of lower part
2653 * for two track bits, it is 'z' of higher track bit
2654 * For non-continuous foundations (and STEEP_BOTH), 'half' is set */
2655 if (z > GetSnowLine()) {
2656 if (half && z - GetSnowLine() == 1) {
2657 /* track on non-continuous foundation, lower part is not under snow */
2658 new_ground = RAIL_GROUND_HALF_SNOW;
2659 } else {
2660 new_ground = RAIL_GROUND_ICE_DESERT;
2661 }
2662 goto set_ground;
2663 }
2664 break;
2665 }
2666
2667 case LT_TROPIC:
2668 if (GetTropicZone(tile) == TROPICZONE_DESERT) {
2669 new_ground = RAIL_GROUND_ICE_DESERT;
2670 goto set_ground;
2671 }
2672 break;
2673 }
2674
2675 new_ground = RAIL_GROUND_GRASS;
2676
2677 if (IsPlainRail(tile) && old_ground != RAIL_GROUND_BARREN) { // wait until bottom is green
2678 /* determine direction of fence */
2679 TrackBits rail = GetTrackBits(tile);
2680
2681 Owner owner = GetTileOwner(tile);
2682 byte fences = 0;
2683
2684 for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; d++) {
2685 static const TrackBits dir_to_trackbits[DIAGDIR_END] = {TRACK_BIT_3WAY_NE, TRACK_BIT_3WAY_SE, TRACK_BIT_3WAY_SW, TRACK_BIT_3WAY_NW};
2686
2687 /* Track bit on this edge => no fence. */
2688 if ((rail & dir_to_trackbits[d]) != TRACK_BIT_NONE) continue;
2689
2690 TileIndex tile2 = tile + TileOffsByDiagDir(d);
2691
2692 /* Show fences if it's a house, industry, object, road, tunnelbridge or not owned by us. */
2693 if (!IsValidTile(tile2) || IsTileType(tile2, MP_HOUSE) || IsTileType(tile2, MP_INDUSTRY) ||
2694 IsTileType(tile2, MP_ROAD) || (IsTileType(tile2, MP_OBJECT) && !IsObjectType(tile2, OBJECT_OWNED_LAND)) || IsTileType(tile2, MP_TUNNELBRIDGE) || !IsTileOwner(tile2, owner)) {
2695 fences |= 1 << d;
2696 }
2697 }
2698
2699 switch (fences) {
2700 case 0: break;
2701 case (1 << DIAGDIR_NE): new_ground = RAIL_GROUND_FENCE_NE; break;
2702 case (1 << DIAGDIR_SE): new_ground = RAIL_GROUND_FENCE_SE; break;
2703 case (1 << DIAGDIR_SW): new_ground = RAIL_GROUND_FENCE_SW; break;
2704 case (1 << DIAGDIR_NW): new_ground = RAIL_GROUND_FENCE_NW; break;
2705 case (1 << DIAGDIR_NE) | (1 << DIAGDIR_SW): new_ground = RAIL_GROUND_FENCE_NESW; break;
2706 case (1 << DIAGDIR_SE) | (1 << DIAGDIR_NW): new_ground = RAIL_GROUND_FENCE_SENW; break;
2707 case (1 << DIAGDIR_NE) | (1 << DIAGDIR_SE): new_ground = RAIL_GROUND_FENCE_VERT1; break;
2708 case (1 << DIAGDIR_NE) | (1 << DIAGDIR_NW): new_ground = RAIL_GROUND_FENCE_HORIZ2; break;
2709 case (1 << DIAGDIR_SE) | (1 << DIAGDIR_SW): new_ground = RAIL_GROUND_FENCE_HORIZ1; break;
2710 case (1 << DIAGDIR_SW) | (1 << DIAGDIR_NW): new_ground = RAIL_GROUND_FENCE_VERT2; break;
2711 default: NOT_REACHED();
2712 }
2713 }
2714
2715 set_ground:
2716 if (old_ground != new_ground) {
2717 SetRailGroundType(tile, new_ground);
2718 MarkTileDirtyByTile(tile);
2719 }
2720 }
2721
2722
2723 static TrackStatus GetTileTrackStatus_Track(TileIndex tile, TransportType mode, uint, DiagDirection side)
2724 {
2725 /* Case of half tile slope with water. */
2726 if (mode == TRANSPORT_WATER && IsPlainRail(tile) && GetRailGroundType(tile) == RAIL_GROUND_WATER && IsSlopeWithOneCornerRaised(GetTileSlope(tile))) {
2727 TrackBits tb = GetTrackBits(tile);
2728 switch (tb) {
2729 default: NOT_REACHED();
2730 case TRACK_BIT_UPPER: tb = TRACK_BIT_LOWER; break;
2731 case TRACK_BIT_LOWER: tb = TRACK_BIT_UPPER; break;
2732 case TRACK_BIT_LEFT: tb = TRACK_BIT_RIGHT; break;
2733 case TRACK_BIT_RIGHT: tb = TRACK_BIT_LEFT; break;
2734 }
2735 return CombineTrackStatus(TrackBitsToTrackdirBits(tb), TRACKDIR_BIT_NONE);
2736 }
2737
2738 if (mode != TRANSPORT_RAIL) return 0;
2739
2740 TrackBits trackbits = TRACK_BIT_NONE;
2741 TrackdirBits red_signals = TRACKDIR_BIT_NONE;
2742
2743 switch (GetRailTileType(tile)) {
2744 default: NOT_REACHED();
2745 case RAIL_TILE_NORMAL:
2746 trackbits = GetTrackBits(tile);
2747 break;
2748
2749 case RAIL_TILE_SIGNALS: {
2750 trackbits = GetTrackBits(tile);
2751 byte a = GetPresentSignals(tile);
2752 uint b = GetSignalStates(tile);
2753
2754 b &= a;
2755
2756 /* When signals are not present (in neither direction),
2757 * we pretend them to be green. Otherwise, it depends on
2758 * the signal type. For signals that are only active from
2759 * one side, we set the missing signals explicitly to
2760 * `green'. Otherwise, they implicitly become `red'. */
2761 if (!IsOnewaySignal(tile, TRACK_UPPER) || (a & SignalOnTrack(TRACK_UPPER)) == 0) b |= ~a & SignalOnTrack(TRACK_UPPER);
2762 if (!IsOnewaySignal(tile, TRACK_LOWER) || (a & SignalOnTrack(TRACK_LOWER)) == 0) b |= ~a & SignalOnTrack(TRACK_LOWER);
2763
2764 if ((b & 0x8) == 0) red_signals |= (TRACKDIR_BIT_LEFT_N | TRACKDIR_BIT_X_NE | TRACKDIR_BIT_Y_SE | TRACKDIR_BIT_UPPER_E);
2765 if ((b & 0x4) == 0) red_signals |= (TRACKDIR_BIT_LEFT_S | TRACKDIR_BIT_X_SW | TRACKDIR_BIT_Y_NW | TRACKDIR_BIT_UPPER_W);
2766 if ((b & 0x2) == 0) red_signals |= (TRACKDIR_BIT_RIGHT_N | TRACKDIR_BIT_LOWER_E);
2767 if ((b & 0x1) == 0) red_signals |= (TRACKDIR_BIT_RIGHT_S | TRACKDIR_BIT_LOWER_W);
2768
2769 break;
2770 }
2771
2772 case RAIL_TILE_DEPOT: {
2773 DiagDirection dir = GetRailDepotDirection(tile);
2774
2775 if (side != INVALID_DIAGDIR && side != dir) break;
2776
2777 trackbits = DiagDirToDiagTrackBits(dir);
2778 break;
2779 }
2780 }
2781
2782 return CombineTrackStatus(TrackBitsToTrackdirBits(trackbits), red_signals);
2783 }
2784
2785 static bool ClickTile_Track(TileIndex tile)
2786 {
2787 if (!IsRailDepot(tile)) return false;
2788
2789 ShowDepotWindow(tile, VEH_TRAIN);
2790 return true;
2791 }
2792
2793 static void GetTileDesc_Track(TileIndex tile, TileDesc *td)
2794 {
2795 const RailTypeInfo *rti = GetRailTypeInfo(GetRailType(tile));
2796 td->rail_speed = rti->max_speed;
2797 td->railtype = rti->strings.name;
2798 td->owner[0] = GetTileOwner(tile);
2799 switch (GetRailTileType(tile)) {
2800 case RAIL_TILE_NORMAL:
2801 td->str = STR_LAI_RAIL_DESCRIPTION_TRACK;
2802 break;
2803
2804 case RAIL_TILE_SIGNALS: {
2805 static const StringID signal_type[6][6] = {
2806 {
2807 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_SIGNALS,
2808 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_PRESIGNALS,
2809 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_EXITSIGNALS,
2810 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_COMBOSIGNALS,
2811 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_PBSSIGNALS,
2812 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_NOENTRYSIGNALS
2813 },
2814 {
2815 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_PRESIGNALS,
2816 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRESIGNALS,
2817 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_EXITSIGNALS,
2818 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_COMBOSIGNALS,
2819 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_PBSSIGNALS,
2820 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_NOENTRYSIGNALS
2821 },
2822 {
2823 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_EXITSIGNALS,
2824 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_EXITSIGNALS,
2825 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXITSIGNALS,
2826 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXIT_COMBOSIGNALS,
2827 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXIT_PBSSIGNALS,
2828 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXIT_NOENTRYSIGNALS
2829 },
2830 {
2831 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_COMBOSIGNALS,
2832 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_COMBOSIGNALS,
2833 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXIT_COMBOSIGNALS,
2834 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_COMBOSIGNALS,
2835 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_COMBO_PBSSIGNALS,
2836 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_COMBO_NOENTRYSIGNALS
2837 },
2838 {
2839 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_PBSSIGNALS,
2840 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_PBSSIGNALS,
2841 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXIT_PBSSIGNALS,
2842 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_COMBO_PBSSIGNALS,
2843 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PBSSIGNALS,
2844 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PBS_NOENTRYSIGNALS
2845 },
2846 {
2847 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_NOENTRYSIGNALS,
2848 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_NOENTRYSIGNALS,
2849 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXIT_NOENTRYSIGNALS,
2850 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_COMBO_NOENTRYSIGNALS,
2851 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PBS_NOENTRYSIGNALS,
2852 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NOENTRYSIGNALS
2853 }
2854 };
2855
2856 SignalType primary_signal;
2857 SignalType secondary_signal;
2858 if (HasSignalOnTrack(tile, TRACK_UPPER)) {
2859 primary_signal = GetSignalType(tile, TRACK_UPPER);
2860 secondary_signal = HasSignalOnTrack(tile, TRACK_LOWER) ? GetSignalType(tile, TRACK_LOWER) : primary_signal;
2861 } else {
2862 secondary_signal = primary_signal = GetSignalType(tile, TRACK_LOWER);
2863 }
2864
2865 td->str = signal_type[secondary_signal][primary_signal];
2866 break;
2867 }
2868
2869 case RAIL_TILE_DEPOT:
2870 td->str = STR_LAI_RAIL_DESCRIPTION_TRAIN_DEPOT;
2871 if (_settings_game.vehicle.train_acceleration_model != AM_ORIGINAL) {
2872 if (td->rail_speed > 0) {
2873 td->rail_speed = std::min<uint16_t>(td->rail_speed, 61);
2874 } else {
2875 td->rail_speed = 61;
2876 }
2877 }
2878 td->build_date = Depot::GetByTile(tile)->build_date;
2879 break;
2880
2881 default:
2882 NOT_REACHED();
2883 }
2884 }
2885
2886 static void ChangeTileOwner_Track(TileIndex tile, Owner old_owner, Owner new_owner)
2887 {
2888 if (!IsTileOwner(tile, old_owner)) return;
2889
2890 if (new_owner != INVALID_OWNER) {
2891 /* Update company infrastructure counts. No need to dirty windows here, we'll redraw the whole screen anyway. */
2892 uint num_pieces = 1;
2893 if (IsPlainRail(tile)) {
2894 TrackBits bits = GetTrackBits(tile);
2895 num_pieces = CountBits(bits);
2896 if (TracksOverlap(bits)) num_pieces *= num_pieces;
2897 }
2898 RailType rt = GetRailType(tile);
2899 Company::Get(old_owner)->infrastructure.rail[rt] -= num_pieces;
2900 Company::Get(new_owner)->infrastructure.rail[rt] += num_pieces;
2901
2902 if (HasSignals(tile)) {
2903 uint num_sigs = CountBits(GetPresentSignals(tile));
2904 Company::Get(old_owner)->infrastructure.signal -= num_sigs;
2905 Company::Get(new_owner)->infrastructure.signal += num_sigs;
2906 }
2907
2908 SetTileOwner(tile, new_owner);
2909 } else {
2910 Command<CMD_LANDSCAPE_CLEAR>::Do(DC_EXEC | DC_BANKRUPT, tile);
2911 }
2912 }
2913
2914 static const byte _fractcoords_behind[4] = { 0x8F, 0x8, 0x80, 0xF8 };
2915 static const byte _fractcoords_enter[4] = { 0x8A, 0x48, 0x84, 0xA8 };
2916 static const int8_t _deltacoord_leaveoffset[8] = {
2917 -1, 0, 1, 0, /* x */
2918 0, 1, 0, -1 /* y */
2919 };
2920
2921
2928 int TicksToLeaveDepot(const Train *v)
2929 {
2930 DiagDirection dir = GetRailDepotDirection(v->tile);
2931 int length = v->CalcNextVehicleOffset();
2932
2933 switch (dir) {
2934 case DIAGDIR_NE: return ((int)(v->x_pos & 0x0F) - ((_fractcoords_enter[dir] & 0x0F) - (length + 1)));
2935 case DIAGDIR_SE: return -((int)(v->y_pos & 0x0F) - ((_fractcoords_enter[dir] >> 4) + (length + 1)));
2936 case DIAGDIR_SW: return -((int)(v->x_pos & 0x0F) - ((_fractcoords_enter[dir] & 0x0F) + (length + 1)));
2937 case DIAGDIR_NW: return ((int)(v->y_pos & 0x0F) - ((_fractcoords_enter[dir] >> 4) - (length + 1)));
2938 default: NOT_REACHED();
2939 }
2940 }
2941
2946 static VehicleEnterTileStatus VehicleEnter_Track(Vehicle *u, TileIndex tile, int x, int y)
2947 {
2948 /* This routine applies only to trains in depot tiles. */
2949 if (u->type != VEH_TRAIN || !IsRailDepotTile(tile)) return VETSB_CONTINUE;
2950
2951 /* Depot direction. */
2952 DiagDirection dir = GetRailDepotDirection(tile);
2953
2954 byte fract_coord = (x & 0xF) + ((y & 0xF) << 4);
2955
2956 /* Make sure a train is not entering the tile from behind. */
2957 if (_fractcoords_behind[dir] == fract_coord) return VETSB_CANNOT_ENTER;
2958
2959 Train *v = Train::From(u);
2960
2961 /* Leaving depot? */
2962 if (v->direction == DiagDirToDir(dir)) {
2963 /* Calculate the point where the following wagon should be activated. */
2964 int length = v->CalcNextVehicleOffset();
2965
2966 byte fract_coord_leave =
2967 ((_fractcoords_enter[dir] & 0x0F) + // x
2968 (length + 1) * _deltacoord_leaveoffset[dir]) +
2969 (((_fractcoords_enter[dir] >> 4) + // y
2970 ((length + 1) * _deltacoord_leaveoffset[dir + 4])) << 4);
2971
2972 if (fract_coord_leave == fract_coord) {
2973 /* Leave the depot. */
2974 if ((v = v->Next()) != nullptr) {
2975 v->vehstatus &= ~VS_HIDDEN;
2976 v->track = (DiagDirToAxis(dir) == AXIS_X ? TRACK_BIT_X : TRACK_BIT_Y);
2977 }
2978 }
2979 } else if (_fractcoords_enter[dir] == fract_coord) {
2980 /* Entering depot. */
2981 assert(DiagDirToDir(ReverseDiagDir(dir)) == v->direction);
2982 v->track = TRACK_BIT_DEPOT,
2983 v->vehstatus |= VS_HIDDEN;
2984 v->direction = ReverseDir(v->direction);
2985 if (v->Next() == nullptr) VehicleEnterDepot(v->First());
2986 v->tile = tile;
2987
2988 InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
2989 return VETSB_ENTERED_WORMHOLE;
2990 }
2991
2992 return VETSB_CONTINUE;
2993 }
2994
3006 static CommandCost TestAutoslopeOnRailTile(TileIndex tile, uint flags, int z_old, Slope tileh_old, int z_new, Slope tileh_new, TrackBits rail_bits)
3007 {
3008 if (!_settings_game.construction.build_on_slopes || !AutoslopeEnabled()) return_cmd_error(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK);
3009
3010 /* Is the slope-rail_bits combination valid in general? I.e. is it safe to call GetRailFoundation() ? */
3011 if (CheckRailSlope(tileh_new, rail_bits, TRACK_BIT_NONE, tile).Failed()) return_cmd_error(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK);
3012
3013 /* Get the slopes on top of the foundations */
3014 z_old += ApplyFoundationToSlope(GetRailFoundation(tileh_old, rail_bits), &tileh_old);
3015 z_new += ApplyFoundationToSlope(GetRailFoundation(tileh_new, rail_bits), &tileh_new);
3016
3017 Corner track_corner;
3018 switch (rail_bits) {
3019 case TRACK_BIT_LEFT: track_corner = CORNER_W; break;
3020 case TRACK_BIT_LOWER: track_corner = CORNER_S; break;
3021 case TRACK_BIT_RIGHT: track_corner = CORNER_E; break;
3022 case TRACK_BIT_UPPER: track_corner = CORNER_N; break;
3023
3024 /* Surface slope must not be changed */
3025 default:
3026 if (z_old != z_new || tileh_old != tileh_new) return_cmd_error(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK);
3027 return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
3028 }
3029
3030 /* The height of the track_corner must not be changed. The rest ensures GetRailFoundation() already. */
3031 z_old += GetSlopeZInCorner(RemoveHalftileSlope(tileh_old), track_corner);
3032 z_new += GetSlopeZInCorner(RemoveHalftileSlope(tileh_new), track_corner);
3033 if (z_old != z_new) return_cmd_error(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK);
3034
3035 CommandCost cost = CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
3036 /* Make the ground dirty, if surface slope has changed */
3037 if (tileh_old != tileh_new) {
3038 /* If there is flat water on the lower halftile add the cost for clearing it */
3039 if (GetRailGroundType(tile) == RAIL_GROUND_WATER && IsSlopeWithOneCornerRaised(tileh_old)) cost.AddCost(_price[PR_CLEAR_WATER]);
3040 if ((flags & DC_EXEC) != 0) SetRailGroundType(tile, RAIL_GROUND_BARREN);
3041 }
3042 return cost;
3043 }
3044
3048 static Vehicle *EnsureNoShipProc(Vehicle *v, void *)
3049 {
3050 return v->type == VEH_SHIP ? v : nullptr;
3051 }
3052
3053 static CommandCost TerraformTile_Track(TileIndex tile, DoCommandFlag flags, int z_new, Slope tileh_new)
3054 {
3055 int z_old;
3056 Slope tileh_old = GetTileSlope(tile, &z_old);
3057 if (IsPlainRail(tile)) {
3058 TrackBits rail_bits = GetTrackBits(tile);
3059 /* Is there flat water on the lower halftile that must be cleared expensively? */
3060 bool was_water = (GetRailGroundType(tile) == RAIL_GROUND_WATER && IsSlopeWithOneCornerRaised(tileh_old));
3061
3062 /* Allow clearing the water only if there is no ship */
3063 if (was_water && HasVehicleOnPos(tile, nullptr, &EnsureNoShipProc)) return_cmd_error(STR_ERROR_SHIP_IN_THE_WAY);
3064
3065 /* First test autoslope. However if it succeeds we still have to test the rest, because non-autoslope terraforming is cheaper. */
3066 CommandCost autoslope_result = TestAutoslopeOnRailTile(tile, flags, z_old, tileh_old, z_new, tileh_new, rail_bits);
3067
3068 /* When there is only a single horizontal/vertical track, one corner can be terraformed. */
3069 Corner allowed_corner;
3070 switch (rail_bits) {
3071 case TRACK_BIT_RIGHT: allowed_corner = CORNER_W; break;
3072 case TRACK_BIT_UPPER: allowed_corner = CORNER_S; break;
3073 case TRACK_BIT_LEFT: allowed_corner = CORNER_E; break;
3074 case TRACK_BIT_LOWER: allowed_corner = CORNER_N; break;
3075 default: return autoslope_result;
3076 }
3077
3078 Foundation f_old = GetRailFoundation(tileh_old, rail_bits);
3079
3080 /* Do not allow terraforming if allowed_corner is part of anti-zig-zag foundations */
3081 if (tileh_old != SLOPE_NS && tileh_old != SLOPE_EW && IsSpecialRailFoundation(f_old)) return autoslope_result;
3082
3083 /* Everything is valid, which only changes allowed_corner */
3084 for (Corner corner = (Corner)0; corner < CORNER_END; corner = (Corner)(corner + 1)) {
3085 if (allowed_corner == corner) continue;
3086 if (z_old + GetSlopeZInCorner(tileh_old, corner) != z_new + GetSlopeZInCorner(tileh_new, corner)) return autoslope_result;
3087 }
3088
3089 /* Make the ground dirty */
3090 if ((flags & DC_EXEC) != 0) SetRailGroundType(tile, RAIL_GROUND_BARREN);
3091
3092 /* allow terraforming */
3093 return CommandCost(EXPENSES_CONSTRUCTION, was_water ? _price[PR_CLEAR_WATER] : (Money)0);
3094 } else if (_settings_game.construction.build_on_slopes && AutoslopeEnabled() &&
3095 AutoslopeCheckForEntranceEdge(tile, z_new, tileh_new, GetRailDepotDirection(tile))) {
3096 return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
3097 }
3098 return Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile);
3099 }
3100
3101
3102 extern const TileTypeProcs _tile_type_rail_procs = {
3103 DrawTile_Track, // draw_tile_proc
3104 GetSlopePixelZ_Track, // get_slope_z_proc
3105 ClearTile_Track, // clear_tile_proc
3106 nullptr, // add_accepted_cargo_proc
3107 GetTileDesc_Track, // get_tile_desc_proc
3108 GetTileTrackStatus_Track, // get_tile_track_status_proc
3109 ClickTile_Track, // click_tile_proc
3110 nullptr, // animate_tile_proc
3111 TileLoop_Track, // tile_loop_proc
3112 ChangeTileOwner_Track, // change_tile_owner_proc
3113 nullptr, // add_produced_cargo_proc
3114 VehicleEnter_Track, // vehicle_enter_tile_proc
3115 GetFoundation_Track, // get_foundation_proc
3116 TerraformTile_Track, // terraform_tile_proc
3117 };
RailTypeInfo::convert
CursorID convert
Cursor for converting track.
Definition: rail.h:172
RailTypeInfo::track_y
SpriteID track_y
single piece of rail in Y direction, with ground
Definition: rail.h:134
TileY
static debug_inline uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:437
TileInfo::z
int z
Height.
Definition: tile_cmd.h:48
MP_HOUSE
@ MP_HOUSE
A house by a town.
Definition: tile_type.h:51
DeleteNewGRFInspectWindow
void DeleteNewGRFInspectWindow(GrfSpecFeature feature, uint index)
Delete inspect window for a given feature and index.
Definition: newgrf_debug_gui.cpp:739
CmdSignalTrackHelper
static CommandCost CmdSignalTrackHelper(DoCommandFlag flags, TileIndex tile, TileIndex end_tile, Track track, SignalType sigtype, SignalVariant sigvar, bool mode, bool remove, bool autofill, bool minimise_gaps, int signal_density)
Build many signals by dragging; AutoSignals.
Definition: rail_cmd.cpp:1268
DIAGDIR_SE
@ DIAGDIR_SE
Southeast.
Definition: direction_type.h:76
SLOPE_SE
@ SLOPE_SE
south and east corner are raised
Definition: slope_type.h:57
tunnelbridge.h
VETSB_CANNOT_ENTER
@ VETSB_CANNOT_ENTER
The vehicle cannot enter the tile.
Definition: tile_cmd.h:38
TCX_UPPER_HALFTILE
@ TCX_UPPER_HALFTILE
Querying information about the upper part of a tile with halftile foundation.
Definition: newgrf_commons.h:25
CmdRemoveSingleRail
CommandCost CmdRemoveSingleRail(DoCommandFlag flags, TileIndex tile, Track track)
Remove a single piece of track.
Definition: rail_cmd.cpp:615
RTO_JUNCTION_SE
@ RTO_JUNCTION_SE
Ballast for junction 'pointing' SE.
Definition: rail.h:84
TROPICZONE_DESERT
@ TROPICZONE_DESERT
Tile is desert.
Definition: tile_type.h:78
RailTypeInfo::build_ew_rail
SpriteID build_ew_rail
button for building single rail in E-W direction
Definition: rail.h:155
ReverseDir
Direction ReverseDir(Direction d)
Return the reverse of a direction.
Definition: direction_func.h:54
InvalidateWindowData
void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
Mark window data of the window of a given class and specific window number as invalid (in need of re-...
Definition: window.cpp:3200
sound_func.h
GroundSpritePaletteTransform
PaletteID GroundSpritePaletteTransform(SpriteID image, PaletteID pal, PaletteID default_pal)
Applies PALETTE_MODIFIER_COLOUR to a palette entry of a ground sprite.
Definition: sprite.h:168
RTO_W
@ RTO_W
Piece of rail in western corner.
Definition: rail.h:76
FOUNDATION_HALFTILE_N
@ FOUNDATION_HALFTILE_N
Level north halftile non-continuously.
Definition: slope_type.h:105
_original_railtypes
static const RailTypeInfo _original_railtypes[]
Global Railtype definition.
Definition: railtypes.h:19
AXIS_Y
@ AXIS_Y
The y axis.
Definition: direction_type.h:118
FindFirstTrack
Track FindFirstTrack(TrackBits tracks)
Returns first Track from TrackBits or INVALID_TRACK.
Definition: track_func.h:177
EnsureNoShipProc
static Vehicle * EnsureNoShipProc(Vehicle *v, void *)
Test-procedure for HasVehicleOnPos to check for a ship.
Definition: rail_cmd.cpp:3048
TRACK_BIT_NONE
@ TRACK_BIT_NONE
No track.
Definition: track_type.h:36
SetBit
constexpr T SetBit(T &x, const uint8_t y)
Set a bit in a variable.
Definition: bitmath_func.hpp:121
Order::IsType
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition: order_base.h:71
Pool::PoolItem<&_company_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:335
GetDisallowedRoadDirections
DisallowedRoadDirections GetDisallowedRoadDirections(Tile t)
Gets the disallowed directions.
Definition: road_map.h:301
GetCrossingRailTrack
Track GetCrossingRailTrack(Tile tile)
Get the rail track of a level crossing.
Definition: road_map.h:358
water.h
TRACK_BIT_3WAY_SW
@ TRACK_BIT_3WAY_SW
"Arrow" to the south-west
Definition: track_type.h:48
IsHalftileSlope
static constexpr bool IsHalftileSlope(Slope s)
Checks for non-continuous slope on halftile foundations.
Definition: slope_func.h:47
CmdRemoveRailroadTrack
CommandCost CmdRemoveRailroadTrack(DoCommandFlag flags, TileIndex end_tile, TileIndex start_tile, Track track)
Build rail on a stretch of track.
Definition: rail_cmd.cpp:957
RFO_SLOPE_NW_SW
@ RFO_SLOPE_NW_SW
Slope NW, Track Y, Fence SW.
Definition: rail.h:118
RAIL_GROUND_HALF_SNOW
@ RAIL_GROUND_HALF_SNOW
Snow only on higher part of slope (steep or one corner raised)
Definition: rail_map.h:500
RFO_SLOPE_SW_SE
@ RFO_SLOPE_SW_SE
Slope SW, Track X, Fence SE.
Definition: rail.h:115
train.h
ValParamRailType
bool ValParamRailType(const RailType rail)
Validate functions for rail building.
Definition: rail.cpp:206
command_func.h
RailFenceOffset
RailFenceOffset
Offsets from base sprite for fence sprites.
Definition: rail.h:102
IsInsideMM
constexpr bool IsInsideMM(const T x, const size_t min, const size_t max) noexcept
Checks if a value is in an interval.
Definition: math_func.hpp:268
_fence_offsets
static FenceOffset _fence_offsets[]
Offsets for drawing fences.
Definition: rail_cmd.cpp:1935
YapfNotifyTrackLayoutChange
void YapfNotifyTrackLayoutChange(TileIndex tile, Track track)
Use this function to notify YAPF that track layout (or signal configuration) has change.
Definition: yapf_rail.cpp:644
GetTunnelBridgeLength
uint GetTunnelBridgeLength(TileIndex begin, TileIndex end)
Calculates the length of a tunnel or a bridge (without end tiles)
Definition: tunnelbridge.h:25
PathfinderSettings::forbid_90_deg
bool forbid_90_deg
forbid trains to make 90 deg turns
Definition: settings_type.h:490
CMD_ERROR
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
Definition: command_func.h:28
RailTypeInfo::build_y_rail
SpriteID build_y_rail
button for building single rail in Y direction
Definition: rail.h:156
TrackStatusToTrackdirBits
TrackdirBits TrackStatusToTrackdirBits(TrackStatus ts)
Returns the present-trackdir-information of a TrackStatus.
Definition: track_func.h:352
AddTileIndexDiffCWrap
TileIndex AddTileIndexDiffCWrap(TileIndex tile, TileIndexDiffC diff)
Add a TileIndexDiffC to a TileIndex and returns the new one.
Definition: map_func.h:522
FlatteningFoundation
Foundation FlatteningFoundation(Slope s)
Returns the foundation needed to flatten a slope.
Definition: slope_func.h:369
CanBuildDepotByTileh
bool CanBuildDepotByTileh(DiagDirection direction, Slope tileh)
Find out if the slope of the tile is suitable to build a depot of given direction.
Definition: depot_func.h:27
GetRailTypeInfo
const RailTypeInfo * GetRailTypeInfo(RailType railtype)
Returns a pointer to the Railtype information for a given railtype.
Definition: rail.h:307
CmdBuildSingleSignal
CommandCost CmdBuildSingleSignal(DoCommandFlag flags, TileIndex tile, Track track, SignalType sigtype, SignalVariant sigvar, bool convert_signal, bool skip_existing_signals, bool ctrl_pressed, SignalType cycle_start, SignalType cycle_stop, uint8_t num_dir_cycle, byte signals_copy)
Build signals, alternate between double/single, signal/semaphore, pre/exit/combo-signals,...
Definition: rail_cmd.cpp:1062
RailTypeInfo::GetRailtypeSpriteOffset
uint GetRailtypeSpriteOffset() const
Offset between the current railtype and normal rail.
Definition: rail.h:295
CmdBuildSignalTrack
CommandCost CmdBuildSignalTrack(DoCommandFlag flags, TileIndex tile, TileIndex end_tile, Track track, SignalType sigtype, SignalVariant sigvar, bool mode, bool autofill, bool minimise_gaps, byte signal_density)
Build signals on a stretch of track.
Definition: rail_cmd.cpp:1459
TicksToLeaveDepot
int TicksToLeaveDepot(const Train *v)
Compute number of ticks when next wagon will leave a depot.
Definition: rail_cmd.cpp:2928
TO_BUILDINGS
@ TO_BUILDINGS
company buildings - depots, stations, HQ, ...
Definition: transparency.h:27
TileInfo
Tile information, used while rendering the tile.
Definition: tile_cmd.h:43
HasVehicleOnPos
bool HasVehicleOnPos(TileIndex tile, void *data, VehicleFromPosProc *proc)
Checks whether a vehicle is on a specific location.
Definition: vehicle.cpp:520
GameCreationSettings::landscape
byte landscape
the landscape we're currently in
Definition: settings_type.h:356
Backup
Class to backup a specific variable and restore it later.
Definition: backup_type.hpp:21
TileDesc::railtype
StringID railtype
Type of rail on the tile.
Definition: tile_cmd.h:64
RTF_NO_SPRITE_COMBINE
@ RTF_NO_SPRITE_COMBINE
Bit number for using non-combined junctions.
Definition: rail.h:29
RailTypeInfo::tunnel
SpriteID tunnel
tunnel sprites base
Definition: rail.h:145
company_base.h
SignalAlongTrackdir
byte SignalAlongTrackdir(Trackdir trackdir)
Maps a trackdir to the bit that stores its status in the map arrays, in the direction along with the ...
Definition: signal_func.h:22
RAIL_GROUND_FENCE_SE
@ RAIL_GROUND_FENCE_SE
Grass with a fence at the SE edge.
Definition: rail_map.h:489
SpecializedVehicle::Next
T * Next() const
Get next vehicle in the chain.
Definition: vehicle_base.h:1116
tunnelbridge_map.h
timer_game_calendar.h
RailClearCost
Money RailClearCost(RailType railtype)
Returns the 'cost' of clearing the specified railtype.
Definition: rail.h:386
IsOnewaySignal
bool IsOnewaySignal(Tile t, Track track)
One-way signals can't be passed the 'wrong' way.
Definition: rail_map.h:319
GetReservedTrackbits
TrackBits GetReservedTrackbits(TileIndex t)
Get the reserved trackbits for any tile, regardless of type.
Definition: pbs.cpp:24
TileDesc::owner
Owner owner[4]
Name of the owner(s)
Definition: tile_cmd.h:55
CmdRailTrackHelper
static CommandCost CmdRailTrackHelper(DoCommandFlag flags, TileIndex tile, TileIndex end_tile, RailType railtype, Track track, bool remove, bool auto_remove_signals, bool fail_on_obstacle)
Build or remove a stretch of railroad tracks.
Definition: rail_cmd.cpp:876
SLOPE_NW
@ SLOPE_NW
north and west corner are raised
Definition: slope_type.h:55
company_gui.h
TrackdirToTrack
Track TrackdirToTrack(Trackdir trackdir)
Returns the Track that a given Trackdir represents.
Definition: track_func.h:262
TrackdirToExitdir
DiagDirection TrackdirToExitdir(Trackdir trackdir)
Maps a trackdir to the (4-way) direction the tile is exited when following that trackdir.
Definition: track_func.h:439
RemoveHalftileSlope
static constexpr Slope RemoveHalftileSlope(Slope s)
Removes a halftile slope from a slope.
Definition: slope_func.h:60
LEVELCROSSING_TRACKBIT_FACTOR
static const uint LEVELCROSSING_TRACKBIT_FACTOR
Multiplier for how many regular track bits a level crossing counts.
Definition: economy_type.h:243
IsPlainRail
static debug_inline bool IsPlainRail(Tile t)
Returns whether this is plain rails, with or without signals.
Definition: rail_map.h:49
elrail_func.h
VehicleEnter_Track
static VehicleEnterTileStatus VehicleEnter_Track(Vehicle *u, TileIndex tile, int x, int y)
Tile callback routine when vehicle enters tile.
Definition: rail_cmd.cpp:2946
StringID
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
TRACK_LOWER
@ TRACK_LOWER
Track in the lower corner of the tile (south)
Definition: track_type.h:24
SIG_SEMAPHORE
@ SIG_SEMAPHORE
Old-fashioned semaphore signal.
Definition: signal_type.h:18
RAIL_TILE_SIGNALS
@ RAIL_TILE_SIGNALS
Normal rail tile with signals.
Definition: rail_map.h:25
MarkDirtyAdjacentLevelCrossingTiles
void MarkDirtyAdjacentLevelCrossingTiles(TileIndex tile, Axis road_axis)
Find adjacent level crossing tiles in this multi-track crossing and mark them dirty.
Definition: train_cmd.cpp:1802
Vehicle::vehstatus
byte vehstatus
Status.
Definition: vehicle_base.h:348
GetSlopeZInCorner
int GetSlopeZInCorner(Slope tileh, Corner corner)
Determine the Z height of a corner relative to TileZ.
Definition: landscape.cpp:332
GetCrossingRailBits
TrackBits GetCrossingRailBits(Tile tile)
Get the rail track bits of a level crossing.
Definition: road_map.h:368
DIAGDIR_END
@ DIAGDIR_END
Used for iterations.
Definition: direction_type.h:79
UpdateTrainPowerProc
static Vehicle * UpdateTrainPowerProc(Vehicle *v, void *data)
Update power of train under which is the railtype being converted.
Definition: rail_cmd.cpp:1543
AutoslopeEnabled
bool AutoslopeEnabled()
Tests if autoslope is enabled for _current_company.
Definition: autoslope.h:44
TRACK_BEGIN
@ TRACK_BEGIN
Used for iterations.
Definition: track_type.h:20
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:234
DiagDirToAxis
Axis DiagDirToAxis(DiagDirection d)
Convert a DiagDirection to the axis.
Definition: direction_func.h:214
HalftileFoundation
Foundation HalftileFoundation(Corner corner)
Returns the halftile foundation for single horizontal/vertical track.
Definition: slope_func.h:391
HasDepotReservation
bool HasDepotReservation(Tile t)
Get the reservation state of the depot.
Definition: rail_map.h:258
SetPresentSignals
void SetPresentSignals(Tile tile, uint signals)
Set whether the given signals are present (Along/AgainstTrackDir)
Definition: rail_map.h:383
RailTypeInfo::signals
SpriteID signals[SIGTYPE_END][2][2]
signal GUI sprites (type, variant, state)
Definition: rail.h:161
TRACK_X
@ TRACK_X
Track along the x-axis (north-east to south-west)
Definition: track_type.h:21
RAIL_GROUND_FENCE_NW
@ RAIL_GROUND_FENCE_NW
Grass with a fence at the NW edge.
Definition: rail_map.h:488
FloodHalftile
bool FloodHalftile(TileIndex t)
Called from water_cmd if a non-flat rail-tile gets flooded and should be converted to shore.
Definition: rail_cmd.cpp:762
PalSpriteID::sprite
SpriteID sprite
The 'real' sprite.
Definition: gfx_type.h:23
HasTunnelBridgeReservation
bool HasTunnelBridgeReservation(Tile t)
Get the reservation state of the rail tunnel/bridge.
Definition: tunnelbridge_map.h:91
SLOPE_ELEVATED
@ SLOPE_ELEVATED
bit mask containing all 'simple' slopes
Definition: slope_type.h:61
INVALID_TILE
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:95
RTO_SLOPE_SW
@ RTO_SLOPE_SW
Piece of rail on slope with south-west raised.
Definition: rail.h:79
SIGNAL_STATE_GREEN
@ SIGNAL_STATE_GREEN
The signal is green.
Definition: signal_type.h:44
RAIL_GROUND_FENCE_VERT1
@ RAIL_GROUND_FENCE_VERT1
Grass with a fence at the eastern side.
Definition: rail_map.h:494
TileIterator::Create
static std::unique_ptr< TileIterator > Create(TileIndex corner1, TileIndex corner2, bool diagonal)
Create either an OrthogonalTileIterator or DiagonalTileIterator given the diagonal parameter.
Definition: tilearea.cpp:291
RailTypeInfo
This struct contains all the info that is needed to draw and construct tracks.
Definition: rail.h:127
VETSB_CONTINUE
@ VETSB_CONTINUE
Bit sets of the above specified bits.
Definition: tile_cmd.h:35
RailTypeInfo::autorail
CursorID autorail
Cursor for autorail tool.
Definition: rail.h:169
MP_RAILWAY
@ MP_RAILWAY
A railway.
Definition: tile_type.h:49
TRACKDIR_BIT_LEFT_N
@ TRACKDIR_BIT_LEFT_N
Track left, direction north.
Definition: track_type.h:111
RailTypeInfo::alternate_labels
RailTypeLabelList alternate_labels
Rail type labels this type provides in addition to the main label.
Definition: rail.h:241
BB_HEIGHT_UNDER_BRIDGE
static const uint BB_HEIGHT_UNDER_BRIDGE
Some values for constructing bounding boxes (BB).
Definition: viewport_type.h:84
IsSteepSlope
static constexpr bool IsSteepSlope(Slope s)
Checks if a slope is steep.
Definition: slope_func.h:36
IsRailStationTile
bool IsRailStationTile(Tile t)
Is this tile a station tile and a rail station?
Definition: station_map.h:102
GetPartialPixelZ
uint GetPartialPixelZ(int x, int y, Slope corners)
Determines height at given coordinate of a slope.
Definition: landscape.cpp:224
TILE_SIZE
static const uint TILE_SIZE
Tile size in world coordinates.
Definition: tile_type.h:15
RAIL_GROUND_BARREN
@ RAIL_GROUND_BARREN
Nothing (dirt)
Definition: rail_map.h:486
DrawBridgeMiddle
void DrawBridgeMiddle(const TileInfo *ti)
Draw the middle bits of a bridge.
Definition: tunnelbridge_cmd.cpp:1544
SignalState
SignalState
These are states in which a signal can be.
Definition: signal_type.h:42
IsNormalRoad
static debug_inline bool IsNormalRoad(Tile t)
Return whether a tile is a normal road.
Definition: road_map.h:64
IsLevelCrossingTile
bool IsLevelCrossingTile(Tile t)
Return whether a tile is a level crossing tile.
Definition: road_map.h:95
RailTypeInfo::single_n
SpriteID single_n
single piece of rail in the northern corner
Definition: rail.h:139
RAIL_GROUND_FENCE_SENW
@ RAIL_GROUND_FENCE_SENW
Grass with a fence at the NW and SE edges.
Definition: rail_map.h:490
IsLevelCrossing
bool IsLevelCrossing(Tile t)
Return whether a tile is a level crossing.
Definition: road_map.h:85
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:54
RailTypeInfo::rail_swne
CursorID rail_swne
Cursor for building rail in X direction.
Definition: rail.h:166
DrawRailTileSeqInGUI
void DrawRailTileSeqInGUI(int x, int y, const DrawTileSprites *dts, int32_t total_offset, uint32_t newgrf_offset, PaletteID default_palette)
Draw tile sprite sequence in GUI with railroad specifics.
Definition: sprite.h:99
VehicleEnterDepot
void VehicleEnterDepot(Vehicle *v)
Vehicle entirely entered the depot, update its status, orders, vehicle windows, service it,...
Definition: vehicle.cpp:1534
RAIL_GROUND_FENCE_VERT2
@ RAIL_GROUND_FENCE_VERT2
Grass with a fence at the western side.
Definition: rail_map.h:495
IsValidTrack
bool IsValidTrack(Track track)
Checks if a Track is valid.
Definition: track_func.h:28
SignalVariant
SignalVariant
Variant of the signal, i.e.
Definition: signal_type.h:16
MP_INDUSTRY
@ MP_INDUSTRY
Part of an industry.
Definition: tile_type.h:56
TRANSPORT_WATER
@ TRANSPORT_WATER
Transport over water.
Definition: transport_type.h:29
town.h
newgrf_debug.h
TileInfo::y
int y
Y position of the tile in unit coordinates.
Definition: tile_cmd.h:45
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > >
SLOPE_S
@ SLOPE_S
the south corner of the tile is raised
Definition: slope_type.h:51
InitRailTypes
void InitRailTypes()
Resolve sprites of custom rail types.
Definition: rail_cmd.cpp:130
DIAGDIR_NW
@ DIAGDIR_NW
Northwest.
Definition: direction_type.h:78
Company::infrastructure
CompanyInfrastructure infrastructure
NOSAVE: Counts of company owned infrastructure.
Definition: company_base.h:129
RFO_SLOPE_SW_NW
@ RFO_SLOPE_SW_NW
Slope SW, Track X, Fence NW.
Definition: rail.h:107
CheckTrackCombination
static CommandCost CheckTrackCombination(TileIndex tile, TrackBits to_build)
Check that the new track bits may be built.
Definition: rail_cmd.cpp:241
GetHalftileSlopeCorner
static constexpr Corner GetHalftileSlopeCorner(Slope s)
Returns the leveled halftile of a halftile slope.
Definition: slope_func.h:148
_display_opt
byte _display_opt
What do we want to draw/do?
Definition: transparency_gui.cpp:26
CmdBuildRailroadTrack
CommandCost CmdBuildRailroadTrack(DoCommandFlag flags, TileIndex end_tile, TileIndex start_tile, RailType railtype, Track track, bool auto_remove_signals, bool fail_on_obstacle)
Build rail on a stretch of track.
Definition: rail_cmd.cpp:942
SetHasSignals
void SetHasSignals(Tile tile, bool signals)
Add/remove the 'has signal' bit from the RailTileType.
Definition: rail_map.h:83
VehicleSettings::road_side
byte road_side
the side of the road vehicles drive on
Definition: settings_type.h:533
TRACKDIR_BIT_Y_NW
@ TRACKDIR_BIT_Y_NW
Track y-axis, direction north-west.
Definition: track_type.h:108
Vehicle
Vehicle data structure.
Definition: vehicle_base.h:240
RailTypeInfo::strings
struct RailTypeInfo::@26 strings
Strings associated with the rail type.
GetRailType
RailType GetRailType(Tile t)
Gets the rail type of the given tile.
Definition: rail_map.h:115
DiagonalTileArea
Represents a diagonal tile area.
Definition: tilearea_type.h:70
Owner
Owner
Enum for all companies/owners.
Definition: company_type.h:18
DC_EXEC
@ DC_EXEC
execute the given command
Definition: command_type.h:371
GetSlopePixelZ
int GetSlopePixelZ(int x, int y, bool ground_vehicle)
Return world Z coordinate of a given point of a tile.
Definition: landscape.cpp:299
SubSprite
Used to only draw a part of the sprite.
Definition: gfx_type.h:225
PaletteID
uint32_t PaletteID
The number of the palette.
Definition: gfx_type.h:18
RailTypes
RailTypes
Allow incrementing of Track variables.
Definition: rail_type.h:44
RFO_SLOPE_SE_SW
@ RFO_SLOPE_SE_SW
Slope SE, Track Y, Fence SW.
Definition: rail.h:116
MP_ROAD
@ MP_ROAD
A tile with road (or tram tracks)
Definition: tile_type.h:50
CommandCost::GetErrorMessage
StringID GetErrorMessage() const
Returns the error message of a command.
Definition: command_type.h:142
TileDesc
Tile description for the 'land area information' tool.
Definition: tile_cmd.h:52
HasExactlyOneBit
constexpr bool HasExactlyOneBit(T value)
Test whether value has exactly 1 bit set.
Definition: bitmath_func.hpp:259
SetSignalStates
void SetSignalStates(Tile tile, uint state)
Set the states of the signals (Along/AgainstTrackDir)
Definition: rail_map.h:352
SLOPE_E
@ SLOPE_E
the east corner of the tile is raised
Definition: slope_type.h:52
DoCommandFlag
DoCommandFlag
List of flags for a command.
Definition: command_type.h:369
INVALID_ROADTYPE
@ INVALID_ROADTYPE
flag for invalid roadtype
Definition: road_type.h:30
TRACK_RIGHT
@ TRACK_RIGHT
Track in the right corner of the tile (east)
Definition: track_type.h:26
Foundation
Foundation
Enumeration for Foundations.
Definition: slope_type.h:93
KillFirstBit
constexpr T KillFirstBit(T value)
Clear the first bit in an integer.
Definition: bitmath_func.hpp:231
EnsureNoVehicleOnGround
CommandCost EnsureNoVehicleOnGround(TileIndex tile)
Ensure there is no vehicle at the ground at the given position.
Definition: vehicle.cpp:546
GetSignalStates
uint GetSignalStates(Tile tile)
Set the states of the signals (Along/AgainstTrackDir)
Definition: rail_map.h:362
AllocateRailType
RailType AllocateRailType(RailTypeLabel label)
Allocate a new rail type label.
Definition: rail_cmd.cpp:150
GetCrossingRoadBits
RoadBits GetCrossingRoadBits(Tile tile)
Get the road bits of a level crossing.
Definition: road_map.h:348
TRACK_BIT_UPPER
@ TRACK_BIT_UPPER
Upper track.
Definition: track_type.h:39
CommandCost::Succeeded
bool Succeeded() const
Did this command succeed?
Definition: command_type.h:162
RTO_JUNCTION_NE
@ RTO_JUNCTION_NE
Ballast for junction 'pointing' NE.
Definition: rail.h:83
TrackToTrackBits
TrackBits TrackToTrackBits(Track track)
Maps a Track to the corresponding TrackBits value.
Definition: track_func.h:77
TracksOverlap
bool TracksOverlap(TrackBits bits)
Checks if the given tracks overlap, ie form a crossing.
Definition: track_func.h:645
pbs.h
RailTypeInfo::sorting_order
byte sorting_order
The sorting order of this railtype for the toolbar dropdown.
Definition: rail.h:271
Vehicle::x_pos
int32_t x_pos
x coordinate.
Definition: vehicle_base.h:299
SignalType
SignalType
Type of signal, i.e.
Definition: signal_type.h:23
GameSettings::game_creation
GameCreationSettings game_creation
settings used during the creation of a game (map)
Definition: settings_type.h:619
GetTileTrackStatus
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
Definition: landscape.cpp:556
RAILTYPE_ELECTRIC
@ RAILTYPE_ELECTRIC
Electric rails.
Definition: rail_type.h:30
RailTypeInfo::ground
SpriteID ground
ground sprite for a 3-way switch
Definition: rail.h:136
TRACK_BIT_RIGHT
@ TRACK_BIT_RIGHT
Right track.
Definition: track_type.h:42
SlopeWithThreeCornersRaised
Slope SlopeWithThreeCornersRaised(Corner corner)
Returns the slope with all except one corner raised.
Definition: slope_func.h:206
DiagDirToDiagTrackBits
TrackBits DiagDirToDiagTrackBits(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal track bits incidating with that diagdir.
Definition: track_func.h:524
RailTypeInfo::build_depot
SpriteID build_depot
button for building depots
Definition: rail.h:158
ComplementSlope
Slope ComplementSlope(Slope s)
Return the complement of a slope.
Definition: slope_func.h:76
TileInfo::tileh
Slope tileh
Slope of the tile.
Definition: tile_cmd.h:46
DrawTrackFence_SE
static void DrawTrackFence_SE(const TileInfo *ti, SpriteID base_image, uint num_sprites)
Draw fence at SE border matching the tile slope.
Definition: rail_cmd.cpp:1988
GetTileType
static debug_inline TileType GetTileType(Tile tile)
Get the tiletype of a given tile.
Definition: tile_map.h:96
ROAD_X
@ ROAD_X
Full road along the x-axis (south-west + north-east)
Definition: road_type.h:58
RTO_SLOPE_NE
@ RTO_SLOPE_NE
Piece of rail on slope with north-east raised.
Definition: rail.h:77
DrawTrackBits
static void DrawTrackBits(TileInfo *ti, TrackBits track)
Draw ground sprite and track bits.
Definition: rail_cmd.cpp:2247
RailTypeInfo::compatible_railtypes
RailTypes compatible_railtypes
bitmask to the OTHER railtypes on which an engine of THIS railtype can physically travel
Definition: rail.h:191
TRACK_BIT_CROSS
@ TRACK_BIT_CROSS
X-Y-axis cross.
Definition: track_type.h:43
GetRailDepotDirection
DiagDirection GetRailDepotDirection(Tile t)
Returns the direction the depot is facing to.
Definition: rail_map.h:171
IsInvisibilitySet
bool IsInvisibilitySet(TransparencyOption to)
Check if the invisibility option bit is set and if we aren't in the game menu (there's never transpar...
Definition: transparency.h:59
RoadBuildCost
Money RoadBuildCost(RoadType roadtype)
Returns the cost of building the specified roadtype.
Definition: road.h:252
DrawTileSprites::ground
PalSpriteID ground
Palette and sprite for the ground.
Definition: sprite.h:59
include
bool include(Container &container, typename Container::const_reference &item)
Helper function to append an item to a container if it is not already contained.
Definition: container_func.hpp:24
VehicleSettings::train_acceleration_model
uint8_t train_acceleration_model
realistic acceleration for trains
Definition: settings_type.h:518
FenceOffset::x_offs
int x_offs
Bounding box X offset.
Definition: rail_cmd.cpp:1928
TileDesc::build_date
TimerGameCalendar::Date build_date
Date of construction of tile contents.
Definition: tile_cmd.h:57
RailTypeInfo::name
StringID name
Name of this rail type.
Definition: rail.h:176
IsObjectType
bool IsObjectType(Tile t, ObjectType type)
Check whether the object on a tile is of a specific type.
Definition: object_map.h:25
ROAD_Y
@ ROAD_Y
Full road along the y-axis (north-west + south-east)
Definition: road_type.h:59
Slope
Slope
Enumeration for the slope-type.
Definition: slope_type.h:48
TrackToTrackdir
Trackdir TrackToTrackdir(Track track)
Returns a Trackdir for the given Track.
Definition: track_func.h:279
GameSettings::pf
PathfinderSettings pf
settings for all pathfinders
Definition: settings_type.h:625
TRACK_BIT_VERT
@ TRACK_BIT_VERT
Left and right track.
Definition: track_type.h:45
DIAGDIR_SW
@ DIAGDIR_SW
Southwest.
Definition: direction_type.h:77
CheckForDockingTile
void CheckForDockingTile(TileIndex t)
Mark the supplied tile as a docking tile if it is suitable for docking.
Definition: water_cmd.cpp:184
VS_HIDDEN
@ VS_HIDDEN
Vehicle is not visible.
Definition: vehicle_base.h:33
depot_base.h
landscape_cmd.h
TrainList
std::vector< Train * > TrainList
Helper type for lists/vectors of trains.
Definition: rail_cmd.cpp:44
IsRailDepot
static debug_inline bool IsRailDepot(Tile t)
Is this rail tile a rail depot?
Definition: rail_map.h:95
railtypes.h
RAIL_GROUND_GRASS
@ RAIL_GROUND_GRASS
Grassy.
Definition: rail_map.h:487
TRANSPORT_RAIL
@ TRANSPORT_RAIL
Transport by train.
Definition: transport_type.h:27
CheckOwnership
CommandCost CheckOwnership(Owner owner, TileIndex tile)
Check whether the current owner owns something.
Definition: company_cmd.cpp:360
FOUNDATION_INCLINED_Y
@ FOUNDATION_INCLINED_Y
The tile has an along Y-axis inclined foundation.
Definition: slope_type.h:97
return_cmd_error
#define return_cmd_error(errcode)
Returns from a function with a specific StringID as error.
Definition: command_func.h:38
TrackBitsToTrackdirBits
TrackdirBits TrackBitsToTrackdirBits(TrackBits bits)
Converts TrackBits to TrackdirBits while allowing both directions.
Definition: track_func.h:319
ToTileIndexDiff
TileIndexDiff ToTileIndexDiff(TileIndexDiffC tidc)
Return the offset between two tiles from a TileIndexDiffC struct.
Definition: map_func.h:452
RTO_N
@ RTO_N
Piece of rail in northern corner.
Definition: rail.h:73
EXPENSES_CONSTRUCTION
@ EXPENSES_CONSTRUCTION
Construction costs.
Definition: economy_type.h:173
RailType
RailType
Enumeration for all possible railtypes.
Definition: rail_type.h:27
CommandCost
Common return value for all commands.
Definition: command_type.h:23
GetSnowLine
byte GetSnowLine()
Get the current snow line, either variable or static.
Definition: landscape.cpp:611
TRACK_Y
@ TRACK_Y
Track along the y-axis (north-west to south-east)
Definition: track_type.h:22
IsBridge
bool IsBridge(Tile t)
Checks if this is a bridge, instead of a tunnel.
Definition: bridge_map.h:24
_valid_tracks_on_leveled_foundation
static const TrackBits _valid_tracks_on_leveled_foundation[15]
Valid TrackBits on a specific (non-steep)-slope with leveled foundation.
Definition: rail_cmd.cpp:284
GetRailStationTrack
Track GetRailStationTrack(Tile t)
Get the rail track of a rail station tile.
Definition: station_map.h:422
RemoveFirstTrack
Track RemoveFirstTrack(TrackBits *tracks)
Removes first Track from TrackBits and returns it.
Definition: track_func.h:131
GetRailDepotTrack
Track GetRailDepotTrack(Tile t)
Returns the track of a depot, ignoring direction.
Definition: rail_map.h:182
Train::GetVehicleTrackdir
Trackdir GetVehicleTrackdir() const override
Get the tracks of the train vehicle.
Definition: train_cmd.cpp:4220
RailTypeInfo::rail_ns
CursorID rail_ns
Cursor for building rail in N-S direction.
Definition: rail.h:165
RTSG_GROUND_COMPLETE
@ RTSG_GROUND_COMPLETE
Complete ground images.
Definition: rail.h:62
SIG_ELECTRIC
@ SIG_ELECTRIC
Light signal.
Definition: signal_type.h:17
FOUNDATION_STEEP_BOTH
@ FOUNDATION_STEEP_BOTH
The tile has a steep slope. The lowest corner is raised by a foundation and the upper halftile is lev...
Definition: slope_type.h:101
SLOPE_NE
@ SLOPE_NE
north and east corner are raised
Definition: slope_type.h:58
FenceOffset::y_offs
int y_offs
Bounding box Y offset.
Definition: rail_cmd.cpp:1929
TrackBitsToTrack
Track TrackBitsToTrack(TrackBits tracks)
Converts TrackBits to Track.
Definition: track_func.h:193
DirtyCompanyInfrastructureWindows
void DirtyCompanyInfrastructureWindows(CompanyID company)
Redraw all windows with company infrastructure counts.
Definition: company_gui.cpp:2651
VALID_LEVEL_CROSSING_SLOPES
static const uint32_t VALID_LEVEL_CROSSING_SLOPES
Constant bitset with safe slopes for building a level crossing.
Definition: slope_type.h:86
RTO_CROSSING_XY
@ RTO_CROSSING_XY
Crossing of X and Y rail, with ballast.
Definition: rail.h:81
FenceOffset::height_ref
Corner height_ref
Corner to use height offset from.
Definition: rail_cmd.cpp:1927
RoadNoLevelCrossing
bool RoadNoLevelCrossing(RoadType roadtype)
Test if road disallows level crossings.
Definition: road.h:295
RailTypeInfo::auto_rail
SpriteID auto_rail
button for the autorail construction
Definition: rail.h:157
Vehicle::tile
TileIndex tile
Current tile index.
Definition: vehicle_base.h:260
SIGNAL_STATE_RED
@ SIGNAL_STATE_RED
The signal is red.
Definition: signal_type.h:43
HasReservedTracks
bool HasReservedTracks(TileIndex tile, TrackBits tracks)
Check whether some of tracks is reserved on a tile.
Definition: pbs.h:58
autoslope.h
CmdRemoveSingleSignal
CommandCost CmdRemoveSingleSignal(DoCommandFlag flags, TileIndex tile, Track track)
Remove signals.
Definition: rail_cmd.cpp:1471
MP_OBJECT
@ MP_OBJECT
Contains objects such as transmitters and owned land.
Definition: tile_type.h:58
TransportType
TransportType
Available types of transport.
Definition: transport_type.h:19
GetRailReservationTrackBits
TrackBits GetRailReservationTrackBits(Tile t)
Returns the reserved track bits of the tile.
Definition: rail_map.h:194
rail_cmd.h
HasTrack
bool HasTrack(Tile tile, Track track)
Returns whether the given track is present on the given tile.
Definition: rail_map.h:160
CommandCost::MakeError
void MakeError(StringID message, StringID extra_message=INVALID_STRING_ID)
Makes this CommandCost behave like an error command.
Definition: command_type.h:101
TRACKDIR_BIT_NONE
@ TRACKDIR_BIT_NONE
No track build.
Definition: track_type.h:99
INVALID_OWNER
@ INVALID_OWNER
An invalid owner.
Definition: company_type.h:29
MP_WATER
@ MP_WATER
Water tile.
Definition: tile_type.h:54
ReverseDiagDir
DiagDirection ReverseDiagDir(DiagDirection d)
Returns the reverse direction of the given DiagDirection.
Definition: direction_func.h:118
FOUNDATION_INCLINED_X
@ FOUNDATION_INCLINED_X
The tile has an along X-axis inclined foundation.
Definition: slope_type.h:96
HasSignalOnTrack
bool HasSignalOnTrack(Tile tile, Track track)
Checks for the presence of signals (either way) on the given track on the given rail tile.
Definition: rail_map.h:413
CommandCost::Failed
bool Failed() const
Did this command fail?
Definition: command_type.h:171
RTO_SLOPE_SE
@ RTO_SLOPE_SE
Piece of rail on slope with south-east raised.
Definition: rail.h:78
IsValidCorner
static constexpr bool IsValidCorner(Corner corner)
Rangecheck for Corner enumeration.
Definition: slope_func.h:24
Corner
Corner
Enumeration of tile corners.
Definition: slope_type.h:22
IsNonContinuousFoundation
bool IsNonContinuousFoundation(Foundation f)
Tests if a foundation is a non-continuous foundation, i.e.
Definition: slope_func.h:320
RTSG_FENCES
@ RTSG_FENCES
Fence images.
Definition: rail.h:59
Vehicle::current_order
Order current_order
The current order (+ status, like: loading)
Definition: vehicle_base.h:349
TRACK_UPPER
@ TRACK_UPPER
Track in the upper corner of the tile (north)
Definition: track_type.h:23
RailTypeInfo::build_ns_rail
SpriteID build_ns_rail
button for building single rail in N-S direction
Definition: rail.h:153
DiagDirToDir
Direction DiagDirToDir(DiagDirection dir)
Convert a DiagDirection to a Direction.
Definition: direction_func.h:182
TRACKDIR_BIT_LOWER_W
@ TRACKDIR_BIT_LOWER_W
Track lower, direction west.
Definition: track_type.h:110
OrthogonalTileArea
Represents the covered area of e.g.
Definition: tilearea_type.h:18
TrackdirReachesTrackdirs
TrackdirBits TrackdirReachesTrackdirs(Trackdir trackdir)
Maps a trackdir to the trackdirs that can be reached from it (ie, when entering the next tile.
Definition: track_func.h:584
TUNNELBRIDGE_TRACKBIT_FACTOR
static const uint TUNNELBRIDGE_TRACKBIT_FACTOR
Multiplier for how many regular track bits a tunnel/bridge counts.
Definition: economy_type.h:241
Vehicle::cur_speed
uint16_t cur_speed
current speed
Definition: vehicle_base.h:323
FenceOffset
Offsets for drawing fences.
Definition: rail_cmd.cpp:1926
ReverseTrackdir
Trackdir ReverseTrackdir(Trackdir trackdir)
Maps a trackdir to the reverse trackdir.
Definition: track_func.h:247
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:55
TRACKDIR_BIT_UPPER_E
@ TRACKDIR_BIT_UPPER_E
Track upper, direction east.
Definition: track_type.h:102
RailTypeInfo::label
RailTypeLabel label
Unique 32 bit rail type identifier.
Definition: rail.h:236
RFO_SLOPE_NE_NW
@ RFO_SLOPE_NE_NW
Slope NE, Track X, Fence NW.
Definition: rail.h:109
TrackdirBitsToTrackBits
TrackBits TrackdirBitsToTrackBits(TrackdirBits bits)
Discards all directional information from a TrackdirBits value.
Definition: track_func.h:308
VS_STOPPED
@ VS_STOPPED
Vehicle is stopped by the player.
Definition: vehicle_base.h:34
GetRailFoundation
Foundation GetRailFoundation(Slope tileh, TrackBits bits)
Checks if a track combination is valid on a specific slope and returns the needed foundation.
Definition: rail_cmd.cpp:312
_local_company
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:49
TRACKDIR_BIT_LEFT_S
@ TRACKDIR_BIT_LEFT_S
Track left, direction south.
Definition: track_type.h:104
TRACK_BIT_X
@ TRACK_BIT_X
X-axis track.
Definition: track_type.h:37
RTSG_CURSORS
@ RTSG_CURSORS
Cursor and toolbar icon images.
Definition: rail.h:50
safeguards.h
Train
'Train' is either a loco or a wagon.
Definition: train.h:89
TRACKDIR_BIT_RIGHT_S
@ TRACKDIR_BIT_RIGHT_S
Track right, direction south.
Definition: track_type.h:105
FOUNDATION_INVALID
@ FOUNDATION_INVALID
Used inside "rail_cmd.cpp" to indicate invalid slope/track combination.
Definition: slope_type.h:113
FreeTrainTrackReservation
void FreeTrainTrackReservation(const Train *v)
Free the reserved path in front of a vehicle.
Definition: train_cmd.cpp:2393
SignalAgainstTrackdir
byte SignalAgainstTrackdir(Trackdir trackdir)
Maps a trackdir to the bit that stores its status in the map arrays, in the direction against the tra...
Definition: signal_func.h:32
GetTileSlope
Slope GetTileSlope(TileIndex tile, int *h)
Return the slope of a given tile inside the map.
Definition: tile_map.cpp:59
RemoveFirstTrackdir
Trackdir RemoveFirstTrackdir(TrackdirBits *trackdirs)
Removes first Trackdir from TrackdirBits and returns it.
Definition: track_func.h:156
TRACK_LEFT
@ TRACK_LEFT
Track in the left corner of the tile (west)
Definition: track_type.h:25
IsCompatibleRail
bool IsCompatibleRail(RailType enginetype, RailType tiletype)
Checks if an engine of the given RailType can drive on a tile with a given RailType.
Definition: rail.h:322
SetTrackReservation
void SetTrackReservation(Tile t, TrackBits b)
Sets the reserved track bits of the tile.
Definition: rail_map.h:209
IsSafeWaitingPosition
bool IsSafeWaitingPosition(const Train *v, TileIndex tile, Trackdir trackdir, bool include_line_end, bool forbid_90deg)
Determine whether a certain track on a tile is a safe position to end a path.
Definition: pbs.cpp:380
DrawTileSprites
Ground palette sprite of a tile, together with its sprite layout.
Definition: sprite.h:58
TCX_NORMAL
@ TCX_NORMAL
Nothing special.
Definition: newgrf_commons.h:24
Depot::build_date
TimerGameCalendar::Date build_date
Date of construction.
Definition: depot_base.h:26
RFO_FLAT_LEFT
@ RFO_FLAT_LEFT
Slope FLAT, Track LEFT, Fence E.
Definition: rail.h:105
GetTileOwner
Owner GetTileOwner(Tile tile)
Returns the owner of a tile.
Definition: tile_map.h:178
UpdateAdjacentLevelCrossingTilesOnLevelCrossingRemoval
void UpdateAdjacentLevelCrossingTilesOnLevelCrossingRemoval(TileIndex tile, Axis road_axis)
Update adjacent level crossing tiles in this multi-track crossing, due to removal of a level crossing...
Definition: train_cmd.cpp:1819
INVALID_DIAGDIR
@ INVALID_DIAGDIR
Flag for an invalid DiagDirection.
Definition: direction_type.h:80
RTF_HIDDEN
@ RTF_HIDDEN
Bit number for hiding from selection.
Definition: rail.h:28
DrawSprite
void DrawSprite(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub, ZoomLevel zoom)
Draw a sprite, not in a viewport.
Definition: gfx.cpp:1007
MP_TUNNELBRIDGE
@ MP_TUNNELBRIDGE
Tunnel entry/exit and bridge heads.
Definition: tile_type.h:57
RailTypeInfo::single_e
SpriteID single_e
single piece of rail in the eastern corner
Definition: rail.h:141
RTSG_GROUND
@ RTSG_GROUND
Main group of ground images.
Definition: rail.h:52
INVALID_TRACKDIR
@ INVALID_TRACKDIR
Flag for an invalid trackdir.
Definition: track_type.h:86
Point
Coordinates of a point in 2D.
Definition: geometry_type.hpp:21
HasRoadWorks
bool HasRoadWorks(Tile t)
Check if a tile has road works.
Definition: road_map.h:513
FOUNDATION_NONE
@ FOUNDATION_NONE
The tile has no foundation, the slope remains unchanged.
Definition: slope_type.h:94
MarkBridgeDirty
void MarkBridgeDirty(TileIndex begin, TileIndex end, DiagDirection direction, uint bridge_height)
Mark bridge tiles dirty.
Definition: tunnelbridge_cmd.cpp:67
GetHalftileFoundationCorner
Corner GetHalftileFoundationCorner(Foundation f)
Returns the halftile corner of a halftile-foundation.
Definition: slope_func.h:333
SLOPE_NS
@ SLOPE_NS
north and south corner are raised
Definition: slope_type.h:60
DiagDirection
DiagDirection
Enumeration for diagonal directions.
Definition: direction_type.h:73
DrawTrackFence_SW
static void DrawTrackFence_SW(const TileInfo *ti, SpriteID base_image, uint num_sprites)
Draw fence at SW border matching the tile slope.
Definition: rail_cmd.cpp:2008
GetRailTileType
static debug_inline RailTileType GetRailTileType(Tile t)
Returns the RailTileType (normal with or without signals, waypoint or depot).
Definition: rail_map.h:36
RailTypeInfo::cursor
struct RailTypeInfo::@25 cursor
Cursors associated with the rail type.
TRACK_BIT_ALL
@ TRACK_BIT_ALL
All possible tracks.
Definition: track_type.h:50
CombineTrackStatus
TrackStatus CombineTrackStatus(TrackdirBits trackdirbits, TrackdirBits red_signals)
Builds a TrackStatus.
Definition: track_func.h:388
GetPresentSignals
uint GetPresentSignals(Tile tile)
Get whether the given signals are present (Along/AgainstTrackDir)
Definition: rail_map.h:393
SIGTYPE_EXIT
@ SIGTYPE_EXIT
presignal block exit
Definition: signal_type.h:26
RailTypeInfo::gui_sprites
struct RailTypeInfo::@24 gui_sprites
struct containing the sprites for the rail GUI.
CommandCost::AddCost
void AddCost(const Money &cost)
Adds the given cost to the cost of the command.
Definition: command_type.h:63
GUISettings::show_track_reservation
bool show_track_reservation
highlight reserved tracks.
Definition: settings_type.h:185
TRACK_BIT_LOWER
@ TRACK_BIT_LOWER
Lower track.
Definition: track_type.h:40
stdafx.h
RailTypeInfo::rail_ew
CursorID rail_ew
Cursor for building rail in E-W direction.
Definition: rail.h:167
DO_FULL_DETAIL
@ DO_FULL_DETAIL
Also draw details of track and roads.
Definition: openttd.h:50
TileTypeProcs
Set of callback functions for performing tile operations of a given tile type.
Definition: tile_cmd.h:158
SetTileOwner
void SetTileOwner(Tile tile, Owner owner)
Sets the owner of a tile.
Definition: tile_map.h:198
DRD_NONE
@ DRD_NONE
None of the directions are disallowed.
Definition: road_type.h:74
SpriteID
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:17
CountBits
constexpr uint CountBits(T value)
Counts the number of set bits in a variable.
Definition: bitmath_func.hpp:243
DC_BANKRUPT
@ DC_BANKRUPT
company bankrupts, skip money check, skip vehicle on tile check in some cases
Definition: command_type.h:377
CheckRailSlope
static CommandCost CheckRailSlope(Slope tileh, TrackBits rail_bits, TrackBits existing, TileIndex tile)
Tests if a track can be build on a tile.
Definition: rail_cmd.cpp:392
DrawTrackFence_NE
static void DrawTrackFence_NE(const TileInfo *ti, SpriteID base_image, uint num_sprites)
Draw fence at NE border matching the tile slope.
Definition: rail_cmd.cpp:1998
RTSG_OVERLAY
@ RTSG_OVERLAY
Images for overlaying track.
Definition: rail.h:51
viewport_func.h
TileLoop_Water
void TileLoop_Water(TileIndex tile)
Let a water tile floods its diagonal adjoining tiles called from tunnelbridge_cmd,...
Definition: water_cmd.cpp:1230
GetSaveSlopeZ
static uint GetSaveSlopeZ(uint x, uint y, Track track)
Get surface height in point (x,y) On tiles with halftile foundations move (x,y) to a safe point wrt.
Definition: rail_cmd.cpp:1869
RailGroundType
RailGroundType
The ground 'under' the rail.
Definition: rail_map.h:485
IsPlainRailTile
static debug_inline bool IsPlainRailTile(Tile t)
Checks whether the tile is a rail tile or rail tile with signals.
Definition: rail_map.h:60
AddSortableSpriteToDraw
void AddSortableSpriteToDraw(SpriteID image, PaletteID pal, int x, int y, int w, int h, int dz, int z, bool transparent, int bb_offset_x, int bb_offset_y, int bb_offset_z, const SubSprite *sub)
Draw a (transparent) sprite at given coordinates with a given bounding box.
Definition: viewport.cpp:673
SLOPE_W
@ SLOPE_W
the west corner of the tile is raised
Definition: slope_type.h:50
RailTypeInfo::single_sloped
SpriteID single_sloped
single piece of rail for slopes
Definition: rail.h:143
RailTypeInfo::snow_offset
SpriteID snow_offset
sprite number difference between a piece of track on a snowy ground and the corresponding one on norm...
Definition: rail.h:185
IsValidTile
bool IsValidTile(Tile tile)
Checks if a tile is valid.
Definition: tile_map.h:161
yapf_cache.h
GetTrackBits
TrackBits GetTrackBits(Tile tile)
Gets the track bits of the given tile.
Definition: rail_map.h:136
RAIL_GROUND_WATER
@ RAIL_GROUND_WATER
Grass with a fence and shore or water on the free halftile.
Definition: rail_map.h:499
Vehicle::direction
Direction direction
facing
Definition: vehicle_base.h:302
RailTypeInfo::max_speed
uint16_t max_speed
Maximum speed for vehicles travelling on this rail type.
Definition: rail.h:231
TileOffsByDiagDir
TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Definition: map_func.h:563
FOUNDATION_STEEP_LOWER
@ FOUNDATION_STEEP_LOWER
The tile has a steep slope. The lowest corner is raised by a foundation to allow building railroad on...
Definition: slope_type.h:98
SIGTYPE_BLOCK
@ SIGTYPE_BLOCK
block signal
Definition: signal_type.h:24
object_map.h
RailTypeInfo::powered_railtypes
RailTypes powered_railtypes
bitmask to the OTHER railtypes on which an engine of THIS railtype generates power
Definition: rail.h:188
TRACK_BIT_DEPOT
@ TRACK_BIT_DEPOT
Bitflag for a depot.
Definition: track_type.h:53
RailTypeInfo::single_x
SpriteID single_x
single piece of rail in X direction, without ground
Definition: rail.h:137
TileIndexDiffC
A pair-construct of a TileIndexDiff.
Definition: map_type.h:31
track_land.h
DrawFoundation
void DrawFoundation(TileInfo *ti, Foundation f)
Draw foundation f at tile ti.
Definition: landscape.cpp:427
OBJECT_OWNED_LAND
static const ObjectType OBJECT_OWNED_LAND
Owned land 'flag'.
Definition: object_type.h:19
RAILTYPE_RAIL
@ RAILTYPE_RAIL
Standard non-electric rails.
Definition: rail_type.h:29
TRACK_END
@ TRACK_END
Used for iterations.
Definition: track_type.h:27
MakeRailDepot
void MakeRailDepot(Tile tile, Owner owner, DepotID depot_id, DiagDirection dir, RailType rail_type)
Make a rail depot.
Definition: rail_map.h:552
TRACKDIR_BIT_X_NE
@ TRACKDIR_BIT_X_NE
Track x-axis, direction north-east.
Definition: track_type.h:100
GetFloodingBehaviour
FloodingBehaviour GetFloodingBehaviour(TileIndex tile)
Returns the behaviour of a tile during flooding.
Definition: water_cmd.cpp:1077
TRACK_BIT_HORZ
@ TRACK_BIT_HORZ
Upper and lower track.
Definition: track_type.h:44
MakeDefaultName
void MakeDefaultName(T *obj)
Set the default name for a depot/waypoint.
Definition: town.h:245
RFO_FLAT_X_NW
@ RFO_FLAT_X_NW
Slope FLAT, Track X, Fence NW.
Definition: rail.h:103
RFO_SLOPE_SE_NE
@ RFO_SLOPE_SE_NE
Slope SE, Track Y, Fence NE.
Definition: rail.h:108
IsValidDiagDirection
bool IsValidDiagDirection(DiagDirection d)
Checks if an integer value is a valid DiagDirection.
Definition: direction_func.h:21
_current_company
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:50
SIGTYPE_ENTRY
@ SIGTYPE_ENTRY
presignal block entry
Definition: signal_type.h:25
vehicle_func.h
PALETTE_CRASH
static const PaletteID PALETTE_CRASH
Recolour sprite greying of crashed vehicles.
Definition: sprites.h:1602
GetCustomSignalSprite
SpriteID GetCustomSignalSprite(const RailTypeInfo *rti, TileIndex tile, SignalType type, SignalVariant var, SignalState state, bool gui)
Get the sprite to draw for a given signal.
Definition: newgrf_railtype.cpp:121
strings_func.h
MakeRoadCrossing
void MakeRoadCrossing(Tile t, Owner road, Owner tram, Owner rail, Axis roaddir, RailType rat, RoadType road_rt, RoadType tram_rt, uint town)
Make a level crossing.
Definition: road_map.h:660
PALETTE_TO_BARE_LAND
static const PaletteID PALETTE_TO_BARE_LAND
sets colour to bare land stuff for rail, road and crossings
Definition: sprites.h:1590
RAIL_GROUND_FENCE_HORIZ1
@ RAIL_GROUND_FENCE_HORIZ1
Grass with a fence at the southern side.
Definition: rail_map.h:496
EnsureNoTrainOnTrackBits
CommandCost EnsureNoTrainOnTrackBits(TileIndex tile, TrackBits track_bits)
Tests if a vehicle interacts with the specified track bits.
Definition: vehicle.cpp:608
SLOPE_EW
@ SLOPE_EW
east and west corner are raised
Definition: slope_type.h:59
TRACK_BIT_LEFT
@ TRACK_BIT_LEFT
Left track.
Definition: track_type.h:41
RailTypeInfo::depot
CursorID depot
Cursor for building a depot.
Definition: rail.h:170
CmdBuildTrainDepot
CommandCost CmdBuildTrainDepot(DoCommandFlag flags, TileIndex tile, RailType railtype, DiagDirection dir)
Build a train depot.
Definition: rail_cmd.cpp:973
GetCrossingRoadAxis
Axis GetCrossingRoadAxis(Tile t)
Get the road axis of a level crossing.
Definition: road_map.h:325
DrawTrackFence_NW
static void DrawTrackFence_NW(const TileInfo *ti, SpriteID base_image, uint num_sprites)
Draw fence at NW border matching the tile slope.
Definition: rail_cmd.cpp:1978
IsDockingTile
bool IsDockingTile(Tile t)
Checks whether the tile is marked as a dockling tile.
Definition: water_map.h:374
WC_BUILD_VEHICLE
@ WC_BUILD_VEHICLE
Build vehicle; Window numbers:
Definition: window_type.h:383
IsRailDepotTile
static debug_inline bool IsRailDepotTile(Tile t)
Is this tile rail tile and a rail depot?
Definition: rail_map.h:105
Backup::Restore
void Restore()
Restore the variable.
Definition: backup_type.hpp:112
TRACK_BIT_3WAY_NE
@ TRACK_BIT_3WAY_NE
"Arrow" to the north-east
Definition: track_type.h:46
TryPathReserve
bool TryPathReserve(Train *v, bool mark_as_stuck=false, bool first_tile_okay=false)
Try to reserve a path to a safe position.
Definition: train_cmd.cpp:2858
EnsureNoTrainOnTrack
static CommandCost EnsureNoTrainOnTrack(TileIndex tile, Track track)
Tests if a vehicle interacts with the specified track.
Definition: rail_cmd.cpp:229
SpecializedVehicle< Train, Type >::From
static Train * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
Definition: vehicle_base.h:1201
SLOPE_N
@ SLOPE_N
the north corner of the tile is raised
Definition: slope_type.h:53
IsSlopeWithThreeCornersRaised
bool IsSlopeWithThreeCornersRaised(Slope s)
Tests if a specific slope has exactly three corners raised.
Definition: slope_func.h:195
GetTilePixelSlope
Slope GetTilePixelSlope(TileIndex tile, int *h)
Return the slope of a given tile.
Definition: tile_map.h:280
abs
constexpr T abs(const T a)
Returns the absolute value of (scalar) variable.
Definition: math_func.hpp:23
RailConvertCost
Money RailConvertCost(RailType from, RailType to)
Calculates the cost of rail conversion.
Definition: rail.h:403
TileType
TileType
The different types of tiles.
Definition: tile_type.h:47
GetHighestSlopeCorner
Corner GetHighestSlopeCorner(Slope s)
Returns the highest corner of a slope (one corner raised or a steep slope).
Definition: slope_func.h:126
Map::Size
static debug_inline uint Size()
Get the size of the map.
Definition: map_func.h:288
MakeShore
void MakeShore(Tile t)
Helper function to make a coast tile.
Definition: water_map.h:384
TRACKDIR_BIT_LOWER_E
@ TRACKDIR_BIT_LOWER_E
Track lower, direction east.
Definition: track_type.h:103
RFO_FLAT_UPPER
@ RFO_FLAT_UPPER
Slope FLAT, Track UPPER, Fence S.
Definition: rail.h:106
RAILTYPE_END
@ RAILTYPE_END
Used for iterations.
Definition: rail_type.h:33
GetSingleSignalState
SignalState GetSingleSignalState(Tile t, byte signalbit)
Get the state of a single signal.
Definition: rail_map.h:373
RailTypeInfo::build_tunnel
SpriteID build_tunnel
button for building a tunnel
Definition: rail.h:159
ConstructionSettings::build_on_slopes
bool build_on_slopes
allow building on slopes
Definition: settings_type.h:371
RFO_SLOPE_NE_SE
@ RFO_SLOPE_NE_SE
Slope NE, Track X, Fence SE.
Definition: rail.h:117
TestAutoslopeOnRailTile
static CommandCost TestAutoslopeOnRailTile(TileIndex tile, uint flags, int z_old, Slope tileh_old, int z_new, Slope tileh_new, TrackBits rail_bits)
Tests if autoslope is allowed.
Definition: rail_cmd.cpp:3006
RTO_X
@ RTO_X
Piece of rail in X direction.
Definition: rail.h:71
HasStationRail
bool HasStationRail(Tile t)
Has this station tile a rail? In other words, is this station tile a rail station or rail waypoint?
Definition: station_map.h:135
SLOPE_SW
@ SLOPE_SW
south and west corner are raised
Definition: slope_type.h:56
DrawTrackDetails
static void DrawTrackDetails(const TileInfo *ti, const RailTypeInfo *rti)
Draw track fences.
Definition: rail_cmd.cpp:2020
RailTypeInfo::single_s
SpriteID single_s
single piece of rail in the southern corner
Definition: rail.h:140
HasSignals
bool HasSignals(Tile t)
Checks if a rail tile has signals.
Definition: rail_map.h:72
GetSlopePixelZInCorner
int GetSlopePixelZInCorner(Slope tileh, Corner corner)
Determine the Z height of a corner relative to TileZ.
Definition: landscape.h:53
MarkTileDirtyByTile
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
Definition: viewport.cpp:2051
AddSideToSignalBuffer
void AddSideToSignalBuffer(TileIndex tile, DiagDirection side, Owner owner)
Add side of tile to signal update buffer.
Definition: signal.cpp:610
RailTypeInfo::build_x_rail
SpriteID build_x_rail
button for building single rail in X direction
Definition: rail.h:154
SetDockingTile
void SetDockingTile(Tile t, bool b)
Set the docking tile state of a tile.
Definition: water_map.h:364
SetRailType
void SetRailType(Tile t, RailType r)
Sets the rail type of the given tile.
Definition: rail_map.h:125
FOUNDATION_LEVELED
@ FOUNDATION_LEVELED
The tile is leveled up to a flat slope.
Definition: slope_type.h:95
RTSG_DEPOT
@ RTSG_DEPOT
Depot images.
Definition: rail.h:58
TRACK_BIT_3WAY_SE
@ TRACK_BIT_3WAY_SE
"Arrow" to the south-east
Definition: track_type.h:47
WC_VEHICLE_DEPOT
@ WC_VEHICLE_DEPOT
Depot view; Window numbers:
Definition: window_type.h:351
MP_STATION
@ MP_STATION
A tile of a station.
Definition: tile_type.h:53
GetRoadOwner
Owner GetRoadOwner(Tile t, RoadTramType rtt)
Get the owner of a specific road type.
Definition: road_map.h:234
RTO_JUNCTION_NSEW
@ RTO_JUNCTION_NSEW
Ballast for full junction.
Definition: rail.h:86
ConstructionSettings::train_signal_side
byte train_signal_side
show signals on left / driving / right side
Definition: settings_type.h:376
FindVehicleOnPos
void FindVehicleOnPos(TileIndex tile, void *data, VehicleFromPosProc *proc)
Find a vehicle from a specific location.
Definition: vehicle.cpp:505
FLOOD_NONE
@ FLOOD_NONE
The tile does not flood neighboured tiles.
Definition: water.h:20
RTO_Y
@ RTO_Y
Piece of rail in Y direction.
Definition: rail.h:72
RAIL_TILE_NORMAL
@ RAIL_TILE_NORMAL
Normal rail tile without signals.
Definition: rail_map.h:24
Pool::PoolItem<&_depot_pool >::CanAllocateItem
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
Definition: pool_type.hpp:305
HasRailCatenaryDrawn
bool HasRailCatenaryDrawn(RailType rt)
Test if we should draw rail catenary.
Definition: elrail_func.h:30
GetTunnelBridgeTransportType
TransportType GetTunnelBridgeTransportType(Tile t)
Tunnel: Get the transport type of the tunnel (road or rail) Bridge: Get the transport type of the bri...
Definition: tunnelbridge_map.h:39
VehicleSettings::disable_elrails
bool disable_elrails
when true, the elrails are disabled
Definition: settings_type.h:523
DIAGDIR_BEGIN
@ DIAGDIR_BEGIN
Used for iterations.
Definition: direction_type.h:74
RoadType
RoadType
The different roadtypes we support.
Definition: road_type.h:25
SetRailDepotExitDirection
void SetRailDepotExitDirection(Tile tile, DiagDirection dir)
Sets the exit direction of a rail depot.
Definition: rail_map.h:538
GetRoadBits
RoadBits GetRoadBits(Tile t, RoadTramType rtt)
Get the present road bits for a specific road type.
Definition: road_map.h:128
RAIL_GROUND_FENCE_NE
@ RAIL_GROUND_FENCE_NE
Grass with a fence at the NE edge.
Definition: rail_map.h:491
OWNER_DEITY
@ OWNER_DEITY
The object is owned by a superuser / goal script.
Definition: company_type.h:27
IsBridgeAbove
bool IsBridgeAbove(Tile t)
checks if a bridge is set above the ground of this tile
Definition: bridge_map.h:45
TileDesc::str
StringID str
Description of the tile.
Definition: tile_cmd.h:53
RTO_SLOPE_NW
@ RTO_SLOPE_NW
Piece of rail on slope with north-west raised.
Definition: rail.h:80
DC_AUTO
@ DC_AUTO
don't allow building on structures
Definition: command_type.h:372
AddTrackToSignalBuffer
void AddTrackToSignalBuffer(TileIndex tile, Track track, Owner owner)
Add track to signal update buffer.
Definition: signal.cpp:578
DiagDirToDiagTrack
Track DiagDirToDiagTrack(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal track incidating with that diagdir.
Definition: track_func.h:512
RTO_E
@ RTO_E
Piece of rail in eastern corner.
Definition: rail.h:75
container_func.hpp
SpecialRailFoundation
Foundation SpecialRailFoundation(Corner corner)
Returns the special rail foundation for single horizontal/vertical track.
Definition: slope_func.h:403
IsSpecialRailFoundation
bool IsSpecialRailFoundation(Foundation f)
Tests if a foundation is a special rail foundation for single horizontal/vertical track.
Definition: slope_func.h:345
RoadBits
RoadBits
Enumeration for the road parts on a tile.
Definition: road_type.h:52
IsDiagonalTrackdir
bool IsDiagonalTrackdir(Trackdir trackdir)
Checks if a given Trackdir is diagonal.
Definition: track_func.h:631
GetOtherTunnelBridgeEnd
TileIndex GetOtherTunnelBridgeEnd(Tile t)
Determines type of the wormhole and returns its other end.
Definition: tunnelbridge_map.h:78
Vehicle::y_pos
int32_t y_pos
y coordinate.
Definition: vehicle_base.h:300
AXIS_X
@ AXIS_X
The X axis.
Definition: direction_type.h:117
UpdateLevelCrossing
void UpdateLevelCrossing(TileIndex tile, bool sound=true, bool force_bar=false)
Update a level crossing to barred or open (crossing may include multiple adjacent tiles).
Definition: train_cmd.cpp:1770
RailTypeInfo::rail_nwse
CursorID rail_nwse
Cursor for building rail in Y direction.
Definition: rail.h:168
TileIndexDiffC::y
int16_t y
The y value of the coordinate.
Definition: map_type.h:33
RailTypeInfo::introduces_railtypes
RailTypes introduces_railtypes
Bitmask of which other railtypes are introduced when this railtype is introduced.
Definition: rail.h:266
TrackBits
TrackBits
Allow incrementing of Track variables.
Definition: track_type.h:35
CheckTileOwnership
CommandCost CheckTileOwnership(TileIndex tile)
Check whether the current owner owns the stuff on the given tile.
Definition: company_cmd.cpp:378
CommandHelper
Definition: command_func.h:93
TRACKDIR_BIT_Y_SE
@ TRACKDIR_BIT_Y_SE
Track y-axis, direction south-east.
Definition: track_type.h:101
TRACKDIR_BIT_RIGHT_N
@ TRACKDIR_BIT_RIGHT_N
Track right, direction north.
Definition: track_type.h:112
Depot
Definition: depot_base.h:20
RFO_SLOPE_NW_NE
@ RFO_SLOPE_NW_NE
Slope NW, Track Y, Fence NE.
Definition: rail.h:110
IsStationTileBlocked
bool IsStationTileBlocked(Tile t)
Is tile t a blocked tile?
Definition: station_map.h:338
lengthof
#define lengthof(x)
Return the length of an fixed size array.
Definition: stdafx.h:300
RailTypeInfo::track_ns
SpriteID track_ns
two pieces of rail in North and South corner (East-West direction)
Definition: rail.h:135
ROAD_NONE
@ ROAD_NONE
No road-part is build.
Definition: road_type.h:53
SlopeToSpriteOffset
uint SlopeToSpriteOffset(Slope s)
Returns the Sprite offset for a given Slope.
Definition: slope_func.h:415
GetTileMaxPixelZ
int GetTileMaxPixelZ(TileIndex tile)
Get top height of the tile.
Definition: tile_map.h:304
RailTypeInfo::base_sprites
struct RailTypeInfo::@23 base_sprites
Struct containing the main sprites.
TILE_HEIGHT
static const uint TILE_HEIGHT
Height of a height level in world coordinate AND in pixels in #ZOOM_LVL_BASE.
Definition: tile_type.h:18
OverflowSafeInt< int64_t >
SignalOffsets
SignalOffsets
Enum holding the signal offset in the sprite sheet according to the side it is representing.
Definition: rail_cmd.cpp:51
ConstructionSettings::crossing_with_competitor
bool crossing_with_competitor
allow building of level crossings with competitor roads or rails
Definition: settings_type.h:380
MakeRoadNormal
void MakeRoadNormal(Tile t, RoadBits bits, RoadType road_rt, RoadType tram_rt, TownID town, Owner road, Owner tram)
Make a normal road tile.
Definition: road_map.h:635
DrawRailCatenary
void DrawRailCatenary(const TileInfo *ti)
Draws overhead wires and pylons for electric railways.
Definition: elrail.cpp:568
DrawRailTileSeq
void DrawRailTileSeq(const struct TileInfo *ti, const DrawTileSprites *dts, TransparencyOption to, int32_t total_offset, uint32_t newgrf_offset, PaletteID default_palette)
Draw tile sprite sequence on tile with railroad specifics.
Definition: sprite.h:89
RFO_FLAT_Y_SW
@ RFO_FLAT_Y_SW
Slope FLAT, Track Y, Fence SW.
Definition: rail.h:112
RailTypeInfo::flags
RailTypeFlags flags
Bit mask of rail type flags.
Definition: rail.h:211
DrawTrackFence
static void DrawTrackFence(const TileInfo *ti, SpriteID base_image, uint num_sprites, RailFenceOffset rfo)
Draw a track fence.
Definition: rail_cmd.cpp:1961
RailNoLevelCrossings
bool RailNoLevelCrossings(RailType rt)
Test if a RailType disallows build of level crossings.
Definition: rail.h:345
CmdConvertRail
CommandCost CmdConvertRail(DoCommandFlag flags, TileIndex tile, TileIndex area_start, RailType totype, bool diagonal)
Convert one rail type to the other.
Definition: rail_cmd.cpp:1563
CmdBuildSingleRail
CommandCost CmdBuildSingleRail(DoCommandFlag flags, TileIndex tile, RailType railtype, Track track, bool auto_remove_signals)
Build a single piece of rail.
Definition: rail_cmd.cpp:426
IsSignalPresent
bool IsSignalPresent(Tile t, byte signalbit)
Checks whether the given signals is present.
Definition: rail_map.h:404
TileInfo::x
int x
X position of the tile in unit coordinates.
Definition: tile_cmd.h:44
RAIL_GROUND_FENCE_HORIZ2
@ RAIL_GROUND_FENCE_HORIZ2
Grass with a fence at the northern side.
Definition: rail_map.h:497
TRACK_BIT_Y
@ TRACK_BIT_Y
Y-axis track.
Definition: track_type.h:38
TimerGameCalendar::date
static Date date
Current date in days (day counter).
Definition: timer_game_calendar.h:34
TileInfo::tile
TileIndex tile
Tile index.
Definition: tile_cmd.h:47
Train::CalcNextVehicleOffset
int CalcNextVehicleOffset() const
Calculate the offset from this vehicle's center to the following center taking the vehicle lengths in...
Definition: train.h:173
GameSettings::construction
ConstructionSettings construction
construction of things in-game
Definition: settings_type.h:620
CCF_TRACK
@ CCF_TRACK
Valid changes while vehicle is driving, and possibly changing tracks.
Definition: train.h:48
GameSettings::vehicle
VehicleSettings vehicle
options for vehicles
Definition: settings_type.h:627
Trackdir
Trackdir
Enumeration for tracks and directions.
Definition: track_type.h:67
RFO_FLAT_X_SE
@ RFO_FLAT_X_SE
Slope FLAT, Track X, Fence SE.
Definition: rail.h:111
_valid_tracks_without_foundation
static const TrackBits _valid_tracks_without_foundation[15]
Valid TrackBits on a specific (non-steep)-slope without foundation.
Definition: rail_cmd.cpp:262
RTO_S
@ RTO_S
Piece of rail in southern corner.
Definition: rail.h:74
SlopeWithOneCornerRaised
Slope SlopeWithOneCornerRaised(Corner corner)
Returns the slope with a specific corner raised.
Definition: slope_func.h:99
RFO_FLAT_RIGHT
@ RFO_FLAT_RIGHT
Slope FLAT, Track RIGHT, Fence W.
Definition: rail.h:113
TileDesc::rail_speed
uint16_t rail_speed
Speed limit of rail (bridges and track)
Definition: tile_cmd.h:65
IsTileType
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
VEH_TRAIN
@ VEH_TRAIN
Train vehicle type.
Definition: vehicle_type.h:24
Pool::PoolItem<&_company_pool >::IsValidID
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition: pool_type.hpp:324
BaseVehicle::type
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:51
RAIL_TILE_DEPOT
@ RAIL_TILE_DEPOT
Depot (one entrance)
Definition: rail_map.h:26
TrackdirBits
TrackdirBits
Allow incrementing of Trackdir variables.
Definition: track_type.h:98
TileX
static debug_inline uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:427
SpecializedVehicle::First
T * First() const
Get the first vehicle in the chain.
Definition: vehicle_base.h:1098
ResetRailTypes
void ResetRailTypes()
Reset all rail type information to its default values.
Definition: rail_cmd.cpp:65
HasPowerOnRail
bool HasPowerOnRail(RailType enginetype, RailType tiletype)
Checks if an engine of the given RailType got power on a tile with a given RailType.
Definition: rail.h:335
SetTrackBits
void SetTrackBits(Tile t, TrackBits b)
Sets the track bits of the given tile.
Definition: rail_map.h:147
SLOPE_FLAT
@ SLOPE_FLAT
a flat tile
Definition: slope_type.h:49
Track
Track
These are used to specify a single track.
Definition: track_type.h:19
CompareRailTypes
static bool CompareRailTypes(const RailType &first, const RailType &second)
Compare railtypes based on their sorting order.
Definition: rail_cmd.cpp:122
CmdRemoveSignalTrack
CommandCost CmdRemoveSignalTrack(DoCommandFlag flags, TileIndex tile, TileIndex end_tile, Track track, bool autofill)
Remove signals on a stretch of track.
Definition: rail_cmd.cpp:1537
ApplyFoundationToSlope
uint ApplyFoundationToSlope(Foundation f, Slope *s)
Applies a foundation to a slope.
Definition: landscape.cpp:166
FenceOffset::x_size
int x_size
Bounding box X size.
Definition: rail_cmd.cpp:1930
ShowDepotWindow
void ShowDepotWindow(TileIndex tile, VehicleType type)
Opens a depot window.
Definition: depot_gui.cpp:1141
DIAGDIR_NE
@ DIAGDIR_NE
Northeast, upper right on your monitor.
Definition: direction_type.h:75
VEH_SHIP
@ VEH_SHIP
Ship vehicle type.
Definition: vehicle_type.h:26
Company
Definition: company_base.h:116
IsSlopeWithOneCornerRaised
bool IsSlopeWithOneCornerRaised(Slope s)
Tests if a specific slope has exactly one corner raised.
Definition: slope_func.h:88
TRACK_BIT_3WAY_NW
@ TRACK_BIT_3WAY_NW
"Arrow" to the north-west
Definition: track_type.h:49
IsTileOwner
bool IsTileOwner(Tile tile, Owner owner)
Checks if a tile belongs to the given owner.
Definition: tile_map.h:214
OWNER_WATER
@ OWNER_WATER
The tile/execution is done by "water".
Definition: company_type.h:26
GetTropicZone
TropicZone GetTropicZone(Tile tile)
Get the tropic zone.
Definition: tile_map.h:238
RTO_JUNCTION_SW
@ RTO_JUNCTION_SW
Ballast for junction 'pointing' SW.
Definition: rail.h:82
TileAddByDiagDir
TileIndex TileAddByDiagDir(TileIndex tile, DiagDirection dir)
Adds a DiagDir to a tile.
Definition: map_func.h:604
RFO_FLAT_Y_NE
@ RFO_FLAT_Y_NE
Slope FLAT, Track Y, Fence NE.
Definition: rail.h:104
TRACKDIR_BIT_UPPER_W
@ TRACKDIR_BIT_UPPER_W
Track upper, direction west.
Definition: track_type.h:109
ApplyPixelFoundationToSlope
uint ApplyPixelFoundationToSlope(Foundation f, Slope *s)
Applies a foundation to a slope.
Definition: landscape.h:129
TileIndexDiffC::x
int16_t x
The x value of the coordinate.
Definition: map_type.h:32
CornerToTrackBits
TrackBits CornerToTrackBits(Corner corner)
Returns a single horizontal/vertical trackbit that is in a specific tile corner.
Definition: track_func.h:99
RailTypeInfo::convert_rail
SpriteID convert_rail
button for converting rail
Definition: rail.h:160
FenceOffset::y_size
int y_size
Bounding box Y size.
Definition: rail_cmd.cpp:1931
RAIL_GROUND_ICE_DESERT
@ RAIL_GROUND_ICE_DESERT
Icy or sandy.
Definition: rail_map.h:498
RailTypeInfo::single_y
SpriteID single_y
single piece of rail in Y direction, without ground
Definition: rail.h:138
ToggleBit
constexpr T ToggleBit(T &x, const uint8_t y)
Toggles a bit in a variable.
Definition: bitmath_func.hpp:181
VehicleEnterTileStatus
VehicleEnterTileStatus
The returned bits of VehicleEnterTile.
Definition: tile_cmd.h:21
newgrf_railtype.h
TunnelBridgeIsFree
CommandCost TunnelBridgeIsFree(TileIndex tile, TileIndex endtile, const Vehicle *ignore)
Finds vehicle in tunnel / bridge.
Definition: vehicle.cpp:575
RAIL_GROUND_FENCE_SW
@ RAIL_GROUND_FENCE_SW
Grass with a fence at the SW edge.
Definition: rail_map.h:492
DrawGroundSprite
void DrawGroundSprite(SpriteID image, PaletteID pal, const SubSprite *sub, int extra_offs_x, int extra_offs_y)
Draws a ground sprite for the current tile.
Definition: viewport.cpp:589
INVALID_STRING_ID
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
Definition: strings_type.h:17
RailBuildCost
Money RailBuildCost(RailType railtype)
Returns the cost of building the specified railtype.
Definition: rail.h:375
ClientSettings::gui
GUISettings gui
settings related to the GUI
Definition: settings_type.h:636
RFO_FLAT_LOWER
@ RFO_FLAT_LOWER
Slope FLAT, Track LOWER, Fence N.
Definition: rail.h:114
GetTrainForReservation
Train * GetTrainForReservation(TileIndex tile, Track track)
Find the train which has reserved a specific path.
Definition: pbs.cpp:330
SignalOnTrack
byte SignalOnTrack(Track track)
Maps a Track to the bits that store the status of the two signals that can be present on the given tr...
Definition: signal_func.h:42
RailTypeInfo::single_w
SpriteID single_w
single piece of rail in the western corner
Definition: rail.h:142
CompanyInfrastructure::rail
uint32_t rail[RAILTYPE_END]
Count of company owned track bits for each rail type.
Definition: company_base.h:35
GetCustomRailSprite
SpriteID GetCustomRailSprite(const RailTypeInfo *rti, TileIndex tile, RailTypeSpriteGroup rtsg, TileContext context, uint *num_results)
Get the sprite to draw for the given tile.
Definition: newgrf_railtype.cpp:96
TRACKDIR_BIT_X_SW
@ TRACKDIR_BIT_X_SW
Track x-axis, direction south-west.
Definition: track_type.h:107
HasSignalOnTrackdir
bool HasSignalOnTrackdir(Tile tile, Trackdir trackdir)
Checks for the presence of signals along the given trackdir on the given rail tile.
Definition: rail_map.h:426
VETSB_ENTERED_WORMHOLE
@ VETSB_ENTERED_WORMHOLE
The vehicle either entered a bridge, tunnel or depot tile (this includes the last tile of the bridge/...
Definition: tile_cmd.h:37
GetTunnelBridgeDirection
DiagDirection GetTunnelBridgeDirection(Tile t)
Get the direction pointing to the other end.
Definition: tunnelbridge_map.h:26
OppositeCorner
Corner OppositeCorner(Corner corner)
Returns the opposite corner.
Definition: slope_func.h:184
INVALID_RAILTYPE
@ INVALID_RAILTYPE
Flag for invalid railtype.
Definition: rail_type.h:34
AutoslopeCheckForEntranceEdge
bool AutoslopeCheckForEntranceEdge(TileIndex tile, int z_new, Slope tileh_new, DiagDirection entrance)
Autoslope check for tiles with an entrance on an edge.
Definition: autoslope.h:31
GetTownIndex
TownID GetTownIndex(Tile t)
Get the index of which town this house/street is attached to.
Definition: town_map.h:23
backup_type.hpp
RAILTYPE_BEGIN
@ RAILTYPE_BEGIN
Used for iterations.
Definition: rail_type.h:28
INVALID_TRACK
@ INVALID_TRACK
Flag for an invalid track.
Definition: track_type.h:28
RTO_JUNCTION_NW
@ RTO_JUNCTION_NW
Ballast for junction 'pointing' NW.
Definition: rail.h:85
RAIL_GROUND_FENCE_NESW
@ RAIL_GROUND_FENCE_NESW
Grass with a fence at the NE and SW edges.
Definition: rail_map.h:493
RAILTYPES_NONE
@ RAILTYPES_NONE
No rail types.
Definition: rail_type.h:45
HasBit
constexpr debug_inline bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
Definition: bitmath_func.hpp:103