OpenTTD Source 20261112-master-gbcbec5e63f
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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
6 */
7
9
10#include "stdafx.h"
11#include "bridge.h"
12#include "tilearea_type.h"
13#include "viewport_func.h"
14#include "command_func.h"
15#include "depot_base.h"
17#include "newgrf_debug.h"
18#include "newgrf_railtype.h"
19#include "train.h"
20#include "autoslope.h"
21#include "water.h"
22#include "tunnelbridge_map.h"
23#include "vehicle_func.h"
24#include "tunnelbridge.h"
25#include "elrail_func.h"
26#include "town.h"
27#include "pbs.h"
28#include "company_base.h"
29#include "core/backup_type.hpp"
31#include "company_gui.h"
32#include "object_map.h"
33#include "rail_cmd.h"
34#include "landscape_cmd.h"
35
36#include "table/strings.h"
37#include "table/railtypes.h"
38#include "table/track_land.h"
39
40#include "safeguards.h"
41
43typedef std::vector<Train *> TrainList;
44
45RailTypeInfo _railtypes[RAILTYPE_END];
46std::vector<RailType> _sorted_railtypes;
47RailTypes _railtypes_hidden_mask;
48
51 SIGNAL_TO_SOUTHWEST,
52 SIGNAL_TO_NORTHEAST,
53 SIGNAL_TO_SOUTHEAST,
54 SIGNAL_TO_NORTHWEST,
55 SIGNAL_TO_EAST,
56 SIGNAL_TO_WEST,
57 SIGNAL_TO_SOUTH,
58 SIGNAL_TO_NORTH,
59};
60
65{
66 static_assert(std::size(_original_railtypes) <= std::size(_railtypes));
67
68 auto insert = std::copy(std::begin(_original_railtypes), std::end(_original_railtypes), std::begin(_railtypes));
69 std::fill(insert, std::end(_railtypes), RailTypeInfo{});
70
71 _railtypes_hidden_mask = {};
72}
73
74void ResolveRailTypeGUISprites(RailTypeInfo *rti)
75{
77 if (cursors_base != 0) {
78 rti->gui_sprites.build_ns_rail = cursors_base + 0;
79 rti->gui_sprites.build_x_rail = cursors_base + 1;
80 rti->gui_sprites.build_ew_rail = cursors_base + 2;
81 rti->gui_sprites.build_y_rail = cursors_base + 3;
82 rti->gui_sprites.auto_rail = cursors_base + 4;
83 rti->gui_sprites.build_depot = cursors_base + 5;
84 rti->gui_sprites.build_tunnel = cursors_base + 6;
85 rti->gui_sprites.convert_rail = cursors_base + 7;
86 rti->cursor.rail_ns = cursors_base + 8;
87 rti->cursor.rail_swne = cursors_base + 9;
88 rti->cursor.rail_ew = cursors_base + 10;
89 rti->cursor.rail_nwse = cursors_base + 11;
90 rti->cursor.autorail = cursors_base + 12;
91 rti->cursor.depot = cursors_base + 13;
92 rti->cursor.tunnel = cursors_base + 14;
93 rti->cursor.convert = cursors_base + 15;
94 }
95
96 /* Array of default GUI signal sprite numbers. */
100
103 }}};
104
105 for (SignalType type : EnumRange(SignalType::End)) {
107 SpriteID red = GetCustomSignalSprite(rti, INVALID_TILE, type, var, SignalState::Red, true);
108 SpriteID green = GetCustomSignalSprite(rti, INVALID_TILE, type, var, SignalState::Green, true);
109 rti->gui_sprites.signals[type][var][SignalState::Red] = (red != 0) ? red + SIGNAL_TO_SOUTH : _signal_lookup[var][type];
110 rti->gui_sprites.signals[type][var][SignalState::Green] = (green != 0) ? green + SIGNAL_TO_SOUTH : _signal_lookup[var][type] + 1;
111 }
112 }
113}
114
121static bool CompareRailTypes(const RailType &first, const RailType &second)
122{
124}
125
130{
131 _sorted_railtypes.clear();
132 for (RailTypeInfo &rti : _railtypes) {
133 RailType rt = rti.Index();
134
135 ResolveRailTypeGUISprites(&rti);
136 _railtypes_hidden_mask.Set(rt, rti.flags.Test(RailTypeFlag::Hidden));
137
138 if (rti.label.Empty()) continue;
139 _sorted_railtypes.push_back(rt);
140 }
141 std::sort(_sorted_railtypes.begin(), _sorted_railtypes.end(), CompareRailTypes);
142}
143
149RailType AllocateRailType(RailTypeLabel label)
150{
151 auto it = std::ranges::find(_railtypes, RailTypeLabel{}, &RailTypeInfo::label);
152 if (it == std::end(_railtypes)) return INVALID_RAILTYPE;
153
154 RailTypeInfo &rti = *it;
155 RailType rt = rti.Index();
156
157 /* Set up new rail type based on default rail. */
159 rti.label = label;
160 rti.alternate_labels.clear();
161
162 /* Make us compatible with ourself. */
163 rti.powered_railtypes = rt;
164 rti.compatible_railtypes = rt;
165
166 /* We also introduce ourself. */
167 rti.introduces_railtypes = rt;
168
169 /* Default sort order; order of allocation, but with some
170 * offsets so it's easier for NewGRF to pick a spot without
171 * changing the order of other (original) rail types.
172 * The << is so you can place other railtypes in between the
173 * other railtypes, the 7 is to be able to place something
174 * before the first (default) rail type. */
175 rti.sorting_order = rt << 4 | 7;
176
177 return rt;
178}
179
182 0xFF, // Dummy value to prevent `index - 1` while accesing.
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
230{
231 return EnsureNoTrainOnTrackBits(tile, track);
232}
233
241{
242 if (!IsPlainRail(tile)) return CommandCost(STR_ERROR_IMPOSSIBLE_TRACK_COMBINATION);
243
244 /* So, we have a tile with tracks on it (and possibly signals). Let's see
245 * what tracks first */
246 TrackBits current = GetTrackBits(tile); // The current track layout.
247 TrackBits future = current | to_build; // The track layout we want to build.
248
249 /* Are we really building something new? */
250 if (current == future) {
251 /* Nothing new is being built */
252 return CommandCost(STR_ERROR_ALREADY_BUILT);
253 }
254
255 /* Normally, we may overlap and any combination is valid */
256 return CommandCost();
257}
258
259
281
303
312{
313 if (bits.None()) return Foundation::None;
314
315 if (IsSteepSlope(tileh)) {
316 /* Test for inclined foundations */
317 if (bits == Track::X) return Foundation::InclinedX;
318 if (bits == Track::Y) return Foundation::InclinedY;
319
320 /* Get higher track */
321 Corner highest_corner = GetHighestSlopeCorner(tileh);
322 TrackBits higher_track = CornerToTrackBits(highest_corner);
323
324 /* Only higher track? */
325 if (bits == higher_track) return HalftileFoundation(highest_corner);
326
327 /* Overlap with higher track? */
328 if (TracksOverlap(bits | higher_track)) return Foundation::Invalid;
329
330 /* either lower track or both higher and lower track */
331 return bits.Any(higher_track) ? Foundation::SteepBoth : Foundation::SteepLower;
332 } else {
333 if (TrackBits{bits}.Reset(_valid_tracks_without_foundation[tileh]).None()) return Foundation::None;
334
335 bool valid_on_leveled = TrackBits{bits}.Reset(_valid_tracks_on_leveled_foundation[tileh]).None();
336
337 Corner track_corner;
338 switch (bits.base()) {
339 case TrackBits{Track::Left}.base(): track_corner = Corner::W; break;
340 case TrackBits{Track::Lower}.base(): track_corner = Corner::S; break;
341 case TrackBits{Track::Right}.base(): track_corner = Corner::E; break;
342 case TrackBits{Track::Upper}.base(): track_corner = Corner::N; break;
343
344 case TRACK_BIT_HORZ.base():
345 if (tileh == SLOPE_N) return HalftileFoundation(Corner::N);
346 if (tileh == SLOPE_S) return HalftileFoundation(Corner::S);
347 return (valid_on_leveled ? Foundation::Leveled : Foundation::Invalid);
348
349 case TRACK_BIT_VERT.base():
350 if (tileh == SLOPE_W) return HalftileFoundation(Corner::W);
351 if (tileh == SLOPE_E) return HalftileFoundation(Corner::E);
352 return (valid_on_leveled ? Foundation::Leveled : Foundation::Invalid);
353
354 case TrackBits{Track::X}.base():
356 return (valid_on_leveled ? Foundation::Leveled : Foundation::Invalid);
357
358 case TrackBits{Track::Y}.base():
360 return (valid_on_leveled ? Foundation::Leveled : Foundation::Invalid);
361
362 default:
363 return (valid_on_leveled ? Foundation::Leveled : Foundation::Invalid);
364 }
365 /* Single diagonal track */
366
367 /* Track must be at least valid on leveled foundation */
368 if (!valid_on_leveled) return Foundation::Invalid;
369
370 /* If slope has three raised corners, build leveled foundation */
372
373 /* If neighboured corners of track_corner are lowered, build halftile foundation */
374 if ((tileh & SlopeWithThreeCornersRaised(OppositeCorner(track_corner))) == SlopeWithOneCornerRaised(track_corner)) return HalftileFoundation(track_corner);
375
376 /* else special anti-zig-zag foundation */
377 return SpecialRailFoundation(track_corner);
378 }
379}
380
381
391static CommandCost CheckRailSlope(Slope tileh, TrackBits rail_bits, TrackBits existing, TileIndex tile)
392{
393 /* don't allow building on the lower side of a coast */
395 if (!IsSteepSlope(tileh) && TrackBits{rail_bits}.Set(existing).Reset(_valid_tracks_on_leveled_foundation[tileh]).Any()) return CommandCost(STR_ERROR_CAN_T_BUILD_ON_WATER);
396 }
397
398 Foundation f_new = GetRailFoundation(tileh, TrackBits{rail_bits}.Set(existing));
399
400 /* check track/slope combination */
401 if ((f_new == Foundation::Invalid) ||
402 ((f_new != Foundation::None) && (!_settings_game.construction.build_on_slopes))) {
403 return CommandCost(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
404 }
405
406 Foundation f_old = GetRailFoundation(tileh, existing);
407 return CommandCost(ExpensesType::Construction, f_new != f_old ? _price[Price::BuildFoundation] : Money{});
408}
409
410/* Validate functions for rail building */
411static inline bool ValParamTrackOrientation(Track track)
412{
413 return IsValidTrack(track);
414}
415
425CommandCost CmdBuildSingleRail(DoCommandFlags flags, TileIndex tile, RailType railtype, Track track, bool auto_remove_signals)
426{
428
429 if (!ValParamRailType(railtype) || !ValParamTrackOrientation(track)) return CMD_ERROR;
430
431 Slope tileh = GetTileSlope(tile);
432 TrackBits trackbit = track;
433
434 switch (GetTileType(tile)) {
435 case TileType::Railway: {
437 if (ret.Failed()) return ret;
438
439 if (!IsPlainRail(tile)) return Command<Commands::LandscapeClear>::Do(flags, tile); // just get appropriate error message
440
441 if (!IsCompatibleRail(GetRailType(tile), railtype)) return CommandCost(STR_ERROR_IMPOSSIBLE_TRACK_COMBINATION);
442
443 ret = CheckTrackCombination(tile, trackbit);
444 if (ret.Succeeded()) ret = EnsureNoTrainOnTrack(tile, track);
445 if (ret.Failed()) return ret;
446
447 ret = CheckRailSlope(tileh, trackbit, GetTrackBits(tile), tile);
448 if (ret.Failed()) return ret;
449 cost.AddCost(ret.GetCost());
450
451 if (HasSignals(tile) && TracksOverlap(GetTrackBits(tile) | track)) {
452 /* If adding the new track causes any overlap, all signals must be removed first */
453 if (!auto_remove_signals) return CommandCost(STR_ERROR_MUST_REMOVE_SIGNALS_FIRST);
454
455 for (Track existing_track : GetTrackBits(tile)) {
456 if (HasSignalOnTrack(tile, existing_track)) {
457 CommandCost ret_remove_signals = Command<Commands::RemoveSignal>::Do(flags, tile, existing_track);
458 if (ret_remove_signals.Failed()) return ret_remove_signals;
459 cost.AddCost(ret_remove_signals.GetCost());
460 }
461 }
462 }
463
464 /* If the rail types don't match, try to convert only if engines of
465 * the new rail type are not powered on the present rail type and engines of
466 * the present rail type are powered on the new rail type. */
467 if (GetRailType(tile) != railtype && !HasPowerOnRail(railtype, GetRailType(tile))) {
468 if (HasPowerOnRail(GetRailType(tile), railtype)) {
469 ret = Command<Commands::ConvertRail>::Do(flags, tile, tile, railtype, false);
470 if (ret.Failed()) return ret;
471 cost.AddCost(ret.GetCost());
472 } else {
473 return CMD_ERROR;
474 }
475 }
476
477 if (flags.Test(DoCommandFlag::Execute)) {
479 TrackBits bits = GetTrackBits(tile);
480 SetTrackBits(tile, bits | trackbit);
481 /* Subtract old infrastructure count. */
482 uint pieces = bits.Count();
483 if (TracksOverlap(bits)) pieces *= pieces;
484 Company::Get(GetTileOwner(tile))->infrastructure.rail[GetRailType(tile)] -= pieces;
485 /* Add new infrastructure count. */
486 pieces = (bits | trackbit).Count();
487 if (TracksOverlap(bits | trackbit)) pieces *= pieces;
488 Company::Get(GetTileOwner(tile))->infrastructure.rail[GetRailType(tile)] += pieces;
490 }
491 break;
492 }
493
494 case TileType::Road: {
495 /* Level crossings may only be built on these slopes */
496 if (!HasBit(VALID_LEVEL_CROSSING_SLOPES, tileh)) return CommandCost(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
497
498 if (!_settings_game.construction.crossing_with_competitor && _current_company != OWNER_DEITY) {
500 if (ret.Failed()) return ret;
501 }
502
504 if (ret.Failed()) return ret;
505
506 if (IsNormalRoad(tile)) {
507 if (HasRoadWorks(tile)) return CommandCost(STR_ERROR_ROAD_WORKS_IN_PROGRESS);
508
509 if (GetDisallowedRoadDirections(tile).Any()) return CommandCost(STR_ERROR_CROSSING_ON_ONEWAY_ROAD);
510
511 if (RailNoLevelCrossings(railtype)) return CommandCost(STR_ERROR_CROSSING_DISALLOWED_RAIL);
512
513 RoadType roadtype_road = GetRoadTypeRoad(tile);
514 RoadType roadtype_tram = GetRoadTypeTram(tile);
515
516 if (roadtype_road != INVALID_ROADTYPE && RoadNoLevelCrossing(roadtype_road)) return CommandCost(STR_ERROR_CROSSING_DISALLOWED_ROAD);
517 if (roadtype_tram != INVALID_ROADTYPE && RoadNoLevelCrossing(roadtype_tram)) return CommandCost(STR_ERROR_CROSSING_DISALLOWED_ROAD);
518
521 if ((track == Track::X && !(road | tram).Any(ROAD_X)) ||
522 (track == Track::Y && !(road | tram).Any(ROAD_Y))) {
523 Owner road_owner = GetRoadOwner(tile, RoadTramType::Road);
524 Owner tram_owner = GetRoadOwner(tile, RoadTramType::Tram);
525 /* Disallow breaking end-of-line of someone else
526 * so trams can still reverse on this tile. */
527 if (Company::IsValidID(tram_owner) && tram.Count() == 1) {
528 ret = CheckOwnership(tram_owner);
529 if (ret.Failed()) return ret;
530 }
531
532 uint num_new_road_pieces = road.Any() ? 2 - road.Count() : 0;
533 if (num_new_road_pieces > 0) {
534 cost.AddCost(num_new_road_pieces * RoadBuildCost(roadtype_road));
535 }
536
537 uint num_new_tram_pieces = tram.Any() ? 2 - tram.Count() : 0;
538 if (num_new_tram_pieces > 0) {
539 cost.AddCost(num_new_tram_pieces * RoadBuildCost(roadtype_tram));
540 }
541
542 if (flags.Test(DoCommandFlag::Execute)) {
543 MakeRoadCrossing(tile, road_owner, tram_owner, _current_company, (track == Track::X ? Axis::Y : Axis::X), railtype, roadtype_road, roadtype_tram, GetTownIndex(tile));
544 UpdateLevelCrossing(tile, false);
546 Company::Get(_current_company)->infrastructure.rail[railtype] += LEVELCROSSING_TRACKBIT_FACTOR;
548 if (num_new_road_pieces > 0 && Company::IsValidID(road_owner)) {
549 Company::Get(road_owner)->infrastructure.road[roadtype_road] += num_new_road_pieces;
551 }
552 if (num_new_tram_pieces > 0 && Company::IsValidID(tram_owner)) {
553 Company::Get(tram_owner)->infrastructure.road[roadtype_tram] += num_new_tram_pieces;
555 }
556 }
557 break;
558 }
559 }
560
561 if (IsLevelCrossing(tile) && GetCrossingRailTrack(tile) == trackbit) {
562 return CommandCost(STR_ERROR_ALREADY_BUILT);
563 }
564 [[fallthrough]];
565 }
566
567 default: {
568 /* Will there be flat water on the lower halftile? */
569 bool water_ground = IsTileType(tile, TileType::Water) && IsSlopeWithOneCornerRaised(tileh);
570
571 CommandCost ret = CheckRailSlope(tileh, trackbit, {}, tile);
572 if (ret.Failed()) return ret;
573 cost.AddCost(ret.GetCost());
574
575 ret = Command<Commands::LandscapeClear>::Do(flags, tile);
576 if (ret.Failed()) return ret;
577 cost.AddCost(ret.GetCost());
578
579 if (water_ground) {
582 }
583
584 if (flags.Test(DoCommandFlag::Execute)) {
585 MakeRailNormal(tile, _current_company, trackbit, railtype);
586 if (water_ground) {
589 }
590 Company::Get(_current_company)->infrastructure.rail[railtype]++;
592 }
593 break;
594 }
595 }
596
597 if (flags.Test(DoCommandFlag::Execute)) {
600 YapfNotifyTrackLayoutChange(tile, track);
601 }
602
603 cost.AddCost(RailBuildCost(railtype));
604 return cost;
605}
606
615{
617 bool crossing = false;
618
619 if (!ValParamTrackOrientation(track)) return CMD_ERROR;
620
621 /* Need to read tile owner now because it may change when the rail is removed
622 * Also, in case of floods, _current_company != owner
623 * There may be invalid tiletype even in exec run (when removing long track),
624 * so do not call GetTileOwner(tile) in any case here */
625 Owner owner = INVALID_OWNER;
626
627 Train *v = nullptr;
628
629 switch (GetTileType(tile)) {
630 case TileType::Road: {
631 if (!IsLevelCrossing(tile) || GetCrossingRailTrack(tile) != track) return CommandCost(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
632
635 if (ret.Failed()) return ret;
636 }
637
638 if (!flags.Test(DoCommandFlag::Bankrupt)) {
640 if (ret.Failed()) return ret;
641 }
642
643 cost.AddCost(RailClearCost(GetRailType(tile)));
644
645 if (flags.Test(DoCommandFlag::Execute)) {
647
648 if (HasReservedTracks(tile, track)) {
649 v = GetTrainForReservation(tile, track);
650 if (v != nullptr) FreeTrainTrackReservation(v);
651 }
652
653 owner = GetTileOwner(tile);
654 Company::Get(owner)->infrastructure.rail[GetRailType(tile)] -= LEVELCROSSING_TRACKBIT_FACTOR;
658 }
659 break;
660 }
661
662 case TileType::Railway: {
663 TrackBits present;
664 /* There are no rails present at depots. */
665 if (!IsPlainRail(tile)) return CommandCost(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
666
669 if (ret.Failed()) return ret;
670 }
671
672 CommandCost ret = EnsureNoTrainOnTrack(tile, track);
673 if (ret.Failed()) return ret;
674
675 present = GetTrackBits(tile);
676 if (!present.Test(track)) return CommandCost(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
677 if (present == TRACK_BIT_CROSS) crossing = true;
678
679 cost.AddCost(RailClearCost(GetRailType(tile)));
680
681 /* Charge extra to remove signals on the track, if they are there */
682 if (HasSignalOnTrack(tile, track)) {
683 cost.AddCost(Command<Commands::RemoveSignal>::Do(flags, tile, track));
684 }
685
686 if (flags.Test(DoCommandFlag::Execute)) {
687 if (HasReservedTracks(tile, track)) {
688 v = GetTrainForReservation(tile, track);
689 if (v != nullptr) FreeTrainTrackReservation(v);
690 }
691
692 owner = GetTileOwner(tile);
693
694 /* Subtract old infrastructure count. */
695 uint pieces = present.Count();
696 if (TracksOverlap(present)) pieces *= pieces;
697 Company::Get(owner)->infrastructure.rail[GetRailType(tile)] -= pieces;
698 /* Add new infrastructure count. */
699 present.Flip(track);
700 pieces = present.Count();
701 if (TracksOverlap(present)) pieces *= pieces;
702 Company::Get(owner)->infrastructure.rail[GetRailType(tile)] += pieces;
704
705 if (present.None()) {
706 Slope tileh = GetTileSlope(tile);
707 /* If there is flat water on the lower halftile, convert the tile to shore so the water remains */
709 bool docking = IsDockingTile(tile);
710 MakeShore(tile);
711 SetDockingTile(tile, docking);
712 } else {
713 DoClearSquare(tile);
714 }
716 } else {
717 SetTrackBits(tile, present);
719 }
720 }
721 break;
722 }
723
724 default: return CommandCost(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
725 }
726
727 if (flags.Test(DoCommandFlag::Execute)) {
728 /* if we got that far, 'owner' variable is set correctly */
729 assert(Company::IsValidID(owner));
730
732 if (crossing) {
733 /* crossing is set when only TRACK_BIT_X and TRACK_BIT_Y are set. As we
734 * are removing one of these pieces, we'll need to update signals for
735 * both directions explicitly, as after the track is removed it won't
736 * 'connect' with the other piece. */
737 AddTrackToSignalBuffer(tile, Track::X, owner);
738 AddTrackToSignalBuffer(tile, Track::Y, owner);
741 } else {
742 AddTrackToSignalBuffer(tile, track, owner);
743 YapfNotifyTrackLayoutChange(tile, track);
744 }
745
746 if (v != nullptr) TryPathReserve(v, true);
747 }
748
749 return cost;
750}
751
752
761{
762 assert(IsPlainRailTile(t));
763
764 bool flooded = false;
765 if (GetRailGroundType(t) == RailGroundType::HalfTileWater) return flooded;
766
767 Slope tileh = GetTileSlope(t);
768 TrackBits rail_bits = GetTrackBits(t);
769
770 if (IsSlopeWithOneCornerRaised(tileh)) {
772
773 TrackBits to_remove = lower_track & rail_bits;
774 if (to_remove.Any()) {
776 flooded = Command<Commands::RemoveRail>::Do(DoCommandFlag::Execute, t, FindFirstTrack(to_remove)).Succeeded();
777 if (!flooded) return flooded; // not yet floodable
778
779 rail_bits.Reset(to_remove);
780 if (rail_bits.None()) {
781 MakeShore(t);
783 return flooded;
784 }
785 }
786
787 if (IsNonContinuousFoundation(GetRailFoundation(tileh, rail_bits))) {
788 flooded = true;
791 }
792 } else {
793 /* Make shore on steep slopes and 'three-corners-raised'-slopes. */
794 if (ApplyFoundationToSlope(GetRailFoundation(tileh, rail_bits), tileh) == 0) {
795 if (IsSteepSlope(tileh) || IsSlopeWithThreeCornersRaised(tileh)) {
796 flooded = true;
799 }
800 }
801 }
802 return flooded;
803}
804
807 { -1, 0 }, { 0, 1 }, { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, 1 },
808 { 0, 0 },
809 { 0, 0 },
810 { 1, 0 }, { 0, -1 }, { 0, -1 }, { 1, 0 }, { 0, -1 }, { -1, 0 },
811 { 0, 0 },
812 { 0, 0 }
813}}};
814
822{
823 return static_cast<Trackdir>(to_underlying(trackdir) ^ 1);
824}
825
826static CommandCost ValidateAutoDrag(Trackdir *trackdir, TileIndex start, TileIndex end)
827{
828 int x = TileX(start);
829 int y = TileY(start);
830 int ex = TileX(end);
831 int ey = TileY(end);
832
833 if (!ValParamTrackOrientation(TrackdirToTrack(*trackdir))) return CMD_ERROR;
834
835 /* calculate delta x,y from start to end tile */
836 int dx = ex - x;
837 int dy = ey - y;
838
839 /* calculate delta x,y for the first direction */
840 int trdx = _trackdelta[*trackdir].x;
841 int trdy = _trackdelta[*trackdir].y;
842
843 if (!IsDiagonalTrackdir(*trackdir)) {
844 trdx += _trackdelta[GetOtherTrackdir(*trackdir)].x;
845 trdy += _trackdelta[GetOtherTrackdir(*trackdir)].y;
846 }
847
848 /* validate the direction */
849 while ((trdx <= 0 && dx > 0) ||
850 (trdx >= 0 && dx < 0) ||
851 (trdy <= 0 && dy > 0) ||
852 (trdy >= 0 && dy < 0)) {
853 if (!HasBit(to_underlying(*trackdir), 3)) { // first direction is invalid, try the other
854 *trackdir = ReverseTrackdir(*trackdir); // reverse the direction
855 trdx = -trdx;
856 trdy = -trdy;
857 } else { // other direction is invalid too, invalid drag
858 return CMD_ERROR;
859 }
860 }
861
862 /* (for diagonal tracks, this is already made sure of by above test), but:
863 * for non-diagonal tracks, check if the start and end tile are on 1 line */
864 if (!IsDiagonalTrackdir(*trackdir)) {
865 trdx = _trackdelta[*trackdir].x;
866 trdy = _trackdelta[*trackdir].y;
867 if (abs(dx) != abs(dy) && abs(dx) + abs(trdy) != abs(dy) + abs(trdx)) return CMD_ERROR;
868 }
869
870 return CommandCost();
871}
872
885static CommandCost CmdRailTrackHelper(DoCommandFlags flags, TileIndex tile, TileIndex end_tile, RailType railtype, Track track, bool remove, bool auto_remove_signals, bool fail_on_obstacle)
886{
888
889 if ((!remove && !ValParamRailType(railtype)) || !ValParamTrackOrientation(track)) return CMD_ERROR;
890 if (end_tile >= Map::Size() || tile >= Map::Size()) return CMD_ERROR;
891
892 Trackdir trackdir = TrackToTrackdir(track);
893
894 CommandCost ret = ValidateAutoDrag(&trackdir, tile, end_tile);
895 if (ret.Failed()) return ret;
896
897 bool had_success = false;
898 CommandCost last_error = CMD_ERROR;
899 for (;;) {
900 ret = remove ? Command<Commands::RemoveRail>::Do(flags, tile, TrackdirToTrack(trackdir)) : Command<Commands::BuildRail>::Do(flags, tile, railtype, TrackdirToTrack(trackdir), auto_remove_signals);
901 if (!remove && !fail_on_obstacle && last_error.GetErrorMessage() == STR_ERROR_ALREADY_BUILT) had_success = true;
902
903 if (ret.Failed()) {
904 last_error = std::move(ret);
905 if (last_error.GetErrorMessage() != STR_ERROR_ALREADY_BUILT && !remove) {
906 if (fail_on_obstacle) return last_error;
907 if (had_success) break; // Keep going if we haven't constructed any rail yet, skipping the start of the drag
908 }
909
910 /* Ownership errors are more important. */
911 if (last_error.GetErrorMessage() == STR_ERROR_OWNED_BY && remove) break;
912 } else {
913 had_success = true;
914 total_cost.AddCost(ret.GetCost());
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)) trackdir = GetOtherTrackdir(trackdir);
923 }
924
925 if (had_success) return total_cost;
926 return last_error;
927}
928
942CommandCost CmdBuildRailroadTrack(DoCommandFlags 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
958{
959 return CmdRailTrackHelper(flags, start_tile, end_tile, INVALID_RAILTYPE, track, true, false, false);
960}
961
971{
972 /* check railtype and valid direction for depot (0 through 3), 4 in total */
973 if (!ValParamRailType(railtype) || !IsValidDiagDirection(dir)) return CMD_ERROR;
974
975 Slope tileh = GetTileSlope(tile);
976
978
979 /* Prohibit construction if
980 * The tile is non-flat AND
981 * 1) build-on-slopes is disabled
982 * 2) the tile is steep i.e. spans two height levels
983 * 3) the exit points in the wrong direction
984 */
985
986 if (tileh != SLOPE_FLAT) {
987 if (!_settings_game.construction.build_on_slopes) return CommandCost(STR_ERROR_FLAT_LAND_REQUIRED);
988 if (!CanBuildDepotByTileh(dir, tileh)) return CommandCost(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
990 }
991
992 /* Allow the user to rotate the depot instead of having to destroy it and build it again */
993 bool rotate_existing_depot = false;
994 Train *v = nullptr;
995 if (IsRailDepotTile(tile) && railtype == GetRailType(tile)) {
997 if (ret.Failed()) return ret;
998
999 DiagDirection old_dir = GetRailDepotDirection(tile);
1000 if (dir == old_dir) return CommandCost();
1001
1002 ret = EnsureNoVehicleOnGround(tile);
1003 if (ret.Failed()) return ret;
1004
1005 if (HasDepotReservation(tile)) {
1006 v = GetTrainForReservation(tile, DiagDirToDiagTrack(old_dir));
1007 }
1008
1009 rotate_existing_depot = true;
1010 }
1011
1012 if (!rotate_existing_depot) {
1013 cost.AddCost(Command<Commands::LandscapeClear>::Do(flags, tile));
1014 if (cost.Failed()) return cost;
1015
1016 if (IsBridgeAbove(tile)) {
1018 if (height_diff > 0) return CommandCostWithParam(STR_ERROR_BRIDGE_TOO_LOW_FOR_TRAIN_DEPOT, height_diff * TILE_HEIGHT_STEP);
1019 }
1020
1021 if (!Depot::CanAllocateItem()) return CMD_ERROR;
1022 }
1023
1024 if (flags.Test(DoCommandFlag::Execute)) {
1025 if (v != nullptr) FreeTrainTrackReservation(v);
1026
1027 if (rotate_existing_depot) {
1028 SetDepotReservation(tile, false);
1029 SetRailDepotExitDirection(tile, dir);
1030 } else {
1031 Depot *d = Depot::Create(tile);
1032
1033 MakeRailDepot(tile, _current_company, d->index, dir, railtype);
1034 MakeDefaultName(d);
1035
1036 Company::Get(_current_company)->infrastructure.rail[railtype]++;
1038 }
1039
1040 MarkTileDirtyByTile(tile);
1043
1044 if (v != nullptr) TryPathReserve(v, true);
1045 }
1046
1048 cost.AddCost(RailBuildCost(railtype));
1049 return cost;
1050}
1051
1070CommandCost CmdBuildSingleSignal(DoCommandFlags 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, uint8_t signals_copy)
1071{
1072 if (sigtype >= SignalType::End || sigvar >= SignalVariant::End) return CMD_ERROR;
1073 if (cycle_start > cycle_stop || cycle_stop >= SignalType::End) return CMD_ERROR;
1074
1075 if (ctrl_pressed) sigvar = (sigvar == SignalVariant::Electric ? SignalVariant::Semaphore : SignalVariant::Electric);
1076
1077 /* You can only build signals on plain rail tiles, and the selected track must exist */
1078 if (!ValParamTrackOrientation(track) || !IsPlainRailTile(tile) ||
1079 !HasTrack(tile, track)) {
1080 return CommandCost(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
1081 }
1082 /* Protect against invalid signal copying */
1083 if (signals_copy != 0 && (signals_copy & SignalOnTrack(track)) == 0) return CMD_ERROR;
1084
1085 CommandCost ret = CheckTileOwnership(tile);
1086 if (ret.Failed()) return ret;
1087
1088 /* See if this is a valid track combination for signals (no overlap) */
1089 if (TracksOverlap(GetTrackBits(tile))) return CommandCost(STR_ERROR_NO_SUITABLE_RAILROAD_TRACK);
1090
1091 /* In case we don't want to change an existing signal, return without error. */
1092 if (skip_existing_signals && HasSignalOnTrack(tile, track)) return CommandCost();
1093
1094 /* you can not convert a signal if no signal is on track */
1095 if (convert_signal && !HasSignalOnTrack(tile, track)) return CommandCost(STR_ERROR_THERE_ARE_NO_SIGNALS);
1096
1097 CommandCost cost;
1098 if (!HasSignalOnTrack(tile, track)) {
1099 /* build new signals */
1101 } else {
1102 if (signals_copy != 0 && sigvar != GetSignalVariant(tile, track)) {
1103 /* convert signals <-> semaphores */
1105
1106 } else if (convert_signal) {
1107 /* convert button pressed */
1108 if (ctrl_pressed || GetSignalVariant(tile, track) != sigvar) {
1109 /* it costs money to change signal variant (light or semaphore) */
1111 } else {
1112 /* it is free to change signal type (block, exit, entry, combo, path, etc) */
1113 cost = CommandCost();
1114 }
1115
1116 } else {
1117 /* it is free to change orientation or number of signals on the tile (for block/presignals which allow signals in both directions) */
1118 cost = CommandCost();
1119 }
1120 }
1121
1122 if (flags.Test(DoCommandFlag::Execute)) {
1123 Train *v = nullptr;
1124 /* The new/changed signal could block our path. As this can lead to
1125 * stale reservations, we clear the path reservation here and try
1126 * to redo it later on. */
1127 if (HasReservedTracks(tile, track)) {
1128 v = GetTrainForReservation(tile, track);
1129 if (v != nullptr) FreeTrainTrackReservation(v);
1130 }
1131
1132 if (!HasSignals(tile)) {
1133 /* there are no signals at all on this tile yet */
1134 SetHasSignals(tile, true);
1135 SetSignalStates(tile, 0xF); // all signals are on
1136 SetPresentSignals(tile, 0); // no signals built by default
1137 SetSignalType(tile, track, sigtype);
1138 SetSignalVariant(tile, track, sigvar);
1139 }
1140
1141 /* Subtract old signal infrastructure count. */
1142 Company::Get(GetTileOwner(tile))->infrastructure.signal -= CountBits(GetPresentSignals(tile));
1143
1144 if (signals_copy == 0) {
1145 if (!HasSignalOnTrack(tile, track)) {
1146 /* build new signals */
1147 SetPresentSignals(tile, GetPresentSignals(tile) | (IsPbsSignal(sigtype) ? KillFirstBit(SignalOnTrack(track)) : SignalOnTrack(track)));
1148 SetSignalType(tile, track, sigtype);
1149 SetSignalVariant(tile, track, sigvar);
1150 while (num_dir_cycle-- > 0) CycleSignalSide(tile, track);
1151 } else {
1152 if (convert_signal) {
1153 /* convert signal button pressed */
1154 if (ctrl_pressed) {
1155 /* toggle the present signal variant: SignalVariant::Electric <-> SignalVariant::Semaphore */
1157 /* Query current signal type so the check for PBS signals below works. */
1158 sigtype = GetSignalType(tile, track);
1159 } else {
1160 /* convert the present signal to the chosen type and variant */
1161 SetSignalType(tile, track, sigtype);
1162 SetSignalVariant(tile, track, sigvar);
1163 if (IsPbsSignal(sigtype) && (GetPresentSignals(tile) & SignalOnTrack(track)) == SignalOnTrack(track)) {
1165 }
1166 }
1167
1168 } else if (ctrl_pressed) {
1169 /* cycle between cycle_start and cycle_end */
1170 sigtype = static_cast<SignalType>(to_underlying(GetSignalType(tile, track)) + 1);
1171
1172 if (sigtype < cycle_start || sigtype > cycle_stop) sigtype = cycle_start;
1173
1174 SetSignalType(tile, track, sigtype);
1175 if (IsPbsSignal(sigtype) && (GetPresentSignals(tile) & SignalOnTrack(track)) == SignalOnTrack(track)) {
1177 }
1178 } else {
1179 /* cycle the signal side: both -> left -> right -> both -> ... */
1180 CycleSignalSide(tile, track);
1181 /* Query current signal type so the check for PBS signals below works. */
1182 sigtype = GetSignalType(tile, track);
1183 }
1184 }
1185 } else {
1186 /* If CmdBuildManySignals is called with copying signals, just copy the
1187 * direction of the first signal given as parameter by CmdBuildManySignals */
1188 SetPresentSignals(tile, (GetPresentSignals(tile) & ~SignalOnTrack(track)) | (signals_copy & SignalOnTrack(track)));
1189 SetSignalVariant(tile, track, sigvar);
1190 SetSignalType(tile, track, sigtype);
1191 }
1192
1193 /* Add new signal infrastructure count. */
1194 Company::Get(GetTileOwner(tile))->infrastructure.signal += CountBits(GetPresentSignals(tile));
1196
1197 if (IsPbsSignal(sigtype)) {
1198 /* PBS signals should show red unless they are on reserved tiles without a train. */
1199 uint mask = GetPresentSignals(tile) & SignalOnTrack(track);
1200 SetSignalStates(tile, (GetSignalStates(tile) & ~mask) | ((GetRailReservationTrackBits(tile).Test(track) && EnsureNoVehicleOnGround(tile).Succeeded() ? UINT_MAX : 0) & mask));
1201 }
1202 MarkTileDirtyByTile(tile);
1204 YapfNotifyTrackLayoutChange(tile, track);
1205 if (v != nullptr && v->track != Track::Depot) {
1206 Train *moving_front = v->GetMovingFront();
1207 /* Extend the train's path if it's not stopped or loading, or not at a safe position. */
1208 if (!((v->vehstatus.Test(VehState::Stopped) && v->cur_speed == 0) || v->current_order.IsType(OT_LOADING)) ||
1209 !IsSafeWaitingPosition(v, moving_front->tile, moving_front->GetVehicleTrackdir(), true, _settings_game.pf.forbid_90_deg)) {
1210 TryPathReserve(v, true);
1211 }
1212 }
1213 }
1214
1215 return cost;
1216}
1217
1218static bool AdvanceSignalAutoFill(TileIndex &tile, Trackdir &trackdir, bool remove)
1219{
1220 /* We only process starting tiles of tunnels or bridges so jump to the other end before moving further. */
1222
1223 tile = AddTileIndexDiffCWrap(tile, _trackdelta[trackdir]);
1224 if (tile == INVALID_TILE) return false;
1225
1226 /* Check for track bits on the new tile */
1228
1229 if (TracksOverlap(TrackdirBitsToTrackBits(trackdirbits))) return false;
1230 trackdirbits &= TrackdirReachesTrackdirs(trackdir);
1231
1232 /* No track bits, must stop */
1233 if (trackdirbits.None()) return false;
1234
1235 /* Get the first track dir */
1236 trackdir = RemoveFirstTrackdir(trackdirbits);
1237
1238 /* Any left? It's a junction so we stop */
1239 if (trackdirbits.Any()) return false;
1240
1241 switch (GetTileType(tile)) {
1242 case TileType::Railway:
1243 if (IsRailDepot(tile)) return false;
1244 if (!remove && HasSignalOnTrack(tile, TrackdirToTrack(trackdir))) return false;
1245 break;
1246
1247 case TileType::Road:
1248 if (!IsLevelCrossing(tile)) return false;
1249 break;
1250
1252 if (GetTunnelBridgeTransportType(tile) != TransportType::Rail) return false;
1253 if (GetTunnelBridgeDirection(tile) != TrackdirToExitdir(trackdir)) return false;
1254 break;
1255 }
1256
1257 default: return false;
1258 }
1259 return true;
1260}
1261
1277static CommandCost CmdSignalTrackHelper(DoCommandFlags flags, TileIndex tile, TileIndex end_tile, Track track, SignalType sigtype, SignalVariant sigvar, bool mode, bool remove, bool autofill, bool minimise_gaps, int signal_density)
1278{
1280
1281 if (end_tile >= Map::Size() || !ValParamTrackOrientation(track)) return CMD_ERROR;
1282 if (signal_density == 0 || signal_density > 20) return CMD_ERROR;
1283 if (!remove && (sigtype >= SignalType::End || sigvar >= SignalVariant::End)) return CMD_ERROR;
1284
1285 if (!IsPlainRailTile(tile)) return CommandCost(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
1286 TileIndex start_tile = tile;
1287
1288 /* Interpret signal_density as the logical length of said amount of tiles in X/Y direction. */
1289 signal_density *= TILE_AXIAL_DISTANCE;
1290
1291 Trackdir trackdir = TrackToTrackdir(track);
1292 CommandCost ret = ValidateAutoDrag(&trackdir, tile, end_tile);
1293 if (ret.Failed()) return ret;
1294
1295 track = TrackdirToTrack(trackdir); // trackdir might have changed, keep track in sync
1296 Trackdir start_trackdir = trackdir;
1297
1298 /* Must start on a valid track to be able to avoid loops */
1299 if (!HasTrack(tile, track)) return CMD_ERROR;
1300
1301 uint8_t signals;
1302 /* copy the signal-style of the first rail-piece if existing */
1303 if (HasSignalOnTrack(tile, track)) {
1304 signals = GetPresentSignals(tile) & SignalOnTrack(track);
1305 assert(signals != 0);
1306
1307 /* copy signal/semaphores style (independent of CTRL) */
1308 sigvar = GetSignalVariant(tile, track);
1309
1310 sigtype = GetSignalType(tile, track);
1311 /* Don't but copy entry or exit-signal type */
1312 if (sigtype == SignalType::Entry || sigtype == SignalType::Exit) sigtype = SignalType::Block;
1313 } else { // no signals exist, drag a two-way signal stretch
1314 signals = IsPbsSignal(sigtype) ? SignalAlongTrackdir(trackdir) : SignalOnTrack(track);
1315 }
1316
1317 uint8_t signal_dir = 0;
1318 if (signals & SignalAlongTrackdir(trackdir)) SetBit(signal_dir, 0);
1319 if (signals & SignalAgainstTrackdir(trackdir)) SetBit(signal_dir, 1);
1320
1321 /* signal_ctr - amount of tiles already processed
1322 * last_used_ctr - amount of tiles before previously placed signal
1323 * signals_density - setting to put signal on every Nth tile (double space on |, -- tracks)
1324 * last_suitable_ctr - amount of tiles before last possible signal place
1325 * last_suitable_tile - last tile where it is possible to place a signal
1326 * last_suitable_trackdir - trackdir of the last tile
1327 **********
1328 * trackdir - trackdir to build with autorail
1329 * semaphores - semaphores or signals
1330 * signals - is there a signal/semaphore on the first tile, copy its style (two-way/single-way)
1331 * and convert all others to semaphore/signal
1332 * remove - 1 remove signals, 0 build signals */
1333 int signal_ctr = 0;
1334 int last_used_ctr = -signal_density; // to force signal at first tile
1335 int last_suitable_ctr = 0;
1336 TileIndex last_suitable_tile = INVALID_TILE;
1337 Trackdir last_suitable_trackdir = Trackdir::Invalid;
1338 CommandCost last_error = CMD_ERROR;
1339 bool had_success = false;
1340 auto build_signal = [&](TileIndex tile, Trackdir trackdir, bool test_only) {
1341 /* Pick the correct orientation for the track direction */
1342 uint8_t signals = 0;
1343 if (HasBit(signal_dir, 0)) signals |= SignalAlongTrackdir(trackdir);
1344 if (HasBit(signal_dir, 1)) signals |= SignalAgainstTrackdir(trackdir);
1345
1346 DoCommandFlags do_flags = test_only ? DoCommandFlags{flags}.Reset(DoCommandFlag::Execute) : flags;
1347 CommandCost ret = remove ? Command<Commands::RemoveSignal>::Do(do_flags, tile, TrackdirToTrack(trackdir)) : Command<Commands::BuildSignal>::Do(do_flags, tile, TrackdirToTrack(trackdir), sigtype, sigvar, false, signal_ctr == 0, mode, SignalType::Block, SignalType::Block, 0, signals);
1348
1349 if (test_only) return ret.Succeeded();
1350
1351 if (ret.Succeeded()) {
1352 had_success = true;
1353 total_cost.AddCost(ret.GetCost());
1354 } else {
1355 /* The "No railway" error is the least important one. */
1356 if (ret.GetErrorMessage() != STR_ERROR_THERE_IS_NO_RAILROAD_TRACK ||
1357 last_error.GetErrorMessage() == INVALID_STRING_ID) {
1358 last_error = ret;
1359 }
1360 }
1361 return ret.Succeeded();
1362 };
1363
1364 for (;;) {
1365 if (remove) {
1366 /* In remove mode last_* stuff doesn't matter, we simply try to clear every tile. */
1367 build_signal(tile, trackdir, false);
1368 } else if (minimise_gaps) {
1369 /* We're trying to minimize gaps wherever possible, so keep track of last suitable
1370 * position and use it if current gap exceeds required signal density. */
1371
1372 if (signal_ctr > last_used_ctr + signal_density && last_suitable_tile != INVALID_TILE) {
1373 /* We overshot so build a signal in last good location. */
1374 if (build_signal(last_suitable_tile, last_suitable_trackdir, false)) {
1375 last_suitable_tile = INVALID_TILE;
1376 last_used_ctr = last_suitable_ctr;
1377 }
1378 }
1379
1380 if (signal_ctr == last_used_ctr + signal_density) {
1381 /* Current gap matches the required density, build a signal. */
1382 if (build_signal(tile, trackdir, false)) {
1383 last_used_ctr = signal_ctr;
1384 last_suitable_tile = INVALID_TILE;
1385 }
1386 } else {
1387 /* Test tile for a potential signal spot. */
1388 if (build_signal(tile, trackdir, true)) {
1389 last_suitable_tile = tile;
1390 last_suitable_ctr = signal_ctr;
1391 last_suitable_trackdir = trackdir;
1392 }
1393 }
1394 } else if (signal_ctr >= last_used_ctr + signal_density) {
1395 /* We're always keeping regular interval between signals so doesn't matter whether we succeed or not. */
1396 build_signal(tile, trackdir, false);
1397 last_used_ctr = signal_ctr;
1398 }
1399
1400 if (autofill) {
1401 switch (GetTileType(tile)) {
1402 case TileType::Railway:
1403 signal_ctr += (IsDiagonalTrackdir(trackdir) ? TILE_AXIAL_DISTANCE : TILE_CORNER_DISTANCE);
1404 break;
1405
1406 case TileType::Road:
1407 signal_ctr += TILE_AXIAL_DISTANCE;
1408 break;
1409
1412 if (remove || minimise_gaps) {
1413 signal_ctr += len;
1414 } else {
1415 /* To keep regular interval we need to emulate placing signals on a bridge.
1416 * We start with TILE_AXIAL_DISTANCE as one bridge tile gets processed in the main loop. */
1417 signal_ctr += TILE_AXIAL_DISTANCE;
1418 for (uint i = TILE_AXIAL_DISTANCE; i < len; i += TILE_AXIAL_DISTANCE) {
1419 if (signal_ctr >= last_used_ctr + signal_density) last_used_ctr = signal_ctr;
1420 signal_ctr += TILE_AXIAL_DISTANCE;
1421 }
1422 }
1423 break;
1424 }
1425
1426 default: break;
1427 }
1428
1429 if (!AdvanceSignalAutoFill(tile, trackdir, remove)) break;
1430
1431 /* Prevent possible loops */
1432 if (tile == start_tile && trackdir == start_trackdir) break;
1433 } else {
1434 if (tile == end_tile) break;
1435
1436 signal_ctr += (IsDiagonalTrackdir(trackdir) ? TILE_AXIAL_DISTANCE : TILE_CORNER_DISTANCE);
1437 /* toggle railbit for the non-diagonal tracks (|, -- tracks) */
1438
1439 tile += ToTileIndexDiff(_trackdelta[trackdir]);
1440 if (!IsDiagonalTrackdir(trackdir)) trackdir = GetOtherTrackdir(trackdir);
1441 }
1442 }
1443
1444 /* We may end up with the current gap exceeding the signal density so fix that if needed. */
1445 if (!remove && minimise_gaps && signal_ctr > last_used_ctr + signal_density && last_suitable_tile != INVALID_TILE) {
1446 build_signal(last_suitable_tile, last_suitable_trackdir, false);
1447 }
1448
1449 return had_success ? total_cost : last_error;
1450}
1451
1468CommandCost CmdBuildSignalTrack(DoCommandFlags flags, TileIndex tile, TileIndex end_tile, Track track, SignalType sigtype, SignalVariant sigvar, bool mode, bool autofill, bool minimise_gaps, uint8_t signal_density)
1469{
1470 return CmdSignalTrackHelper(flags, tile, end_tile, track, sigtype, sigvar, mode, false, autofill, minimise_gaps, signal_density);
1471}
1472
1481{
1482 if (!ValParamTrackOrientation(track) || !IsPlainRailTile(tile) || !HasTrack(tile, track)) {
1483 return CommandCost(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
1484 }
1485 if (!HasSignalOnTrack(tile, track)) {
1486 return CommandCost(STR_ERROR_THERE_ARE_NO_SIGNALS);
1487 }
1488
1489 /* Only water can remove signals from anyone */
1491 CommandCost ret = CheckTileOwnership(tile);
1492 if (ret.Failed()) return ret;
1493 }
1494
1495 /* Do it? */
1496 if (flags.Test(DoCommandFlag::Execute)) {
1497 Train *v = nullptr;
1498 if (HasReservedTracks(tile, track)) {
1499 v = GetTrainForReservation(tile, track);
1500 } else if (IsPbsSignal(GetSignalType(tile, track))) {
1501 /* PBS signal, might be the end of a path reservation. */
1502 Trackdir td = TrackToTrackdir(track);
1503 for (int i = 0; v == nullptr && i < 2; i++, td = ReverseTrackdir(td)) {
1504 /* Only test the active signal side. */
1505 if (!HasSignalOnTrackdir(tile, ReverseTrackdir(td))) continue;
1508 if (HasReservedTracks(next, tracks)) {
1510 }
1511 }
1512 }
1513 Company::Get(GetTileOwner(tile))->infrastructure.signal -= CountBits(GetPresentSignals(tile));
1514 SetPresentSignals(tile, GetPresentSignals(tile) & ~SignalOnTrack(track));
1515 Company::Get(GetTileOwner(tile))->infrastructure.signal += CountBits(GetPresentSignals(tile));
1517
1518 /* removed last signal from tile? */
1519 if (GetPresentSignals(tile) == 0) {
1520 SetSignalStates(tile, 0);
1521 SetHasSignals(tile, false);
1522 SetSignalVariant(tile, Track::Invalid, SignalVariant::Electric); // remove any possible semaphores
1523 }
1524
1525 AddTrackToSignalBuffer(tile, track, GetTileOwner(tile));
1526 YapfNotifyTrackLayoutChange(tile, track);
1527 if (v != nullptr) TryPathReserve(v, false);
1528
1529 MarkTileDirtyByTile(tile);
1530 }
1531
1533}
1534
1546CommandCost CmdRemoveSignalTrack(DoCommandFlags flags, TileIndex tile, TileIndex end_tile, Track track, bool autofill)
1547{
1548 return CmdSignalTrackHelper(flags, tile, end_tile, track, SignalType::Block, SignalVariant::Electric, false, true, autofill, false, 1); // bit 5 is remove bit
1549}
1550
1561CommandCost CmdConvertRail(DoCommandFlags flags, TileIndex tile, TileIndex area_start, RailType totype, bool diagonal)
1562{
1563 TileIndex area_end = tile;
1564
1565 if (!ValParamRailType(totype)) return CMD_ERROR;
1566 if (area_start >= Map::Size()) return CMD_ERROR;
1567
1568 TrainList affected_trains;
1569
1571 CommandCost error = CommandCost(STR_ERROR_NO_SUITABLE_RAILROAD_TRACK); // by default, there is no track to convert.
1572 bool found_convertible_track = false; // whether we actually did convert some track (see bug #7633)
1573
1574 auto tilearea = CreateOrthoDiagonalArea(area_end, area_start, diagonal);
1575 for (TileIndex cur_tile : tilearea) {
1576 TileType tt = GetTileType(cur_tile);
1577
1578 /* Check if there is any track on tile */
1579 switch (tt) {
1580 case TileType::Railway:
1581 break;
1582 case TileType::Station:
1583 if (!HasStationRail(cur_tile)) continue;
1584 break;
1585 case TileType::Road:
1586 if (!IsLevelCrossing(cur_tile)) continue;
1587 if (RailNoLevelCrossings(totype)) {
1588 error.MakeError(STR_ERROR_CROSSING_DISALLOWED_RAIL);
1589 continue;
1590 }
1591 break;
1593 if (GetTunnelBridgeTransportType(cur_tile) != TransportType::Rail) continue;
1594 break;
1595 default: continue;
1596 }
1597
1598 /* Original railtype we are converting from */
1599 RailType type = GetRailType(cur_tile);
1600
1601 /* Converting to the same type or converting 'hidden' elrail -> rail */
1602 if (type == totype || (_settings_game.vehicle.disable_elrails && totype == RAILTYPE_RAIL && type == RAILTYPE_ELECTRIC)) continue;
1603
1604 /* Trying to convert other's rail */
1605 CommandCost ret = CheckTileOwnership(cur_tile);
1606 if (ret.Failed()) {
1607 error = std::move(ret);
1608 continue;
1609 }
1610
1611 std::vector<Train *> vehicles_affected;
1612
1613 /* Vehicle on the tile when not converting Rail <-> ElRail
1614 * Tunnels and bridges have special check later */
1615 if (tt != TileType::TunnelBridge) {
1616 if (!IsCompatibleRail(type, totype)) {
1617 ret = IsPlainRailTile(cur_tile) ? EnsureNoTrainOnTrackBits(cur_tile, GetTrackBits(cur_tile)) : EnsureNoVehicleOnGround(cur_tile);
1618 if (ret.Failed()) {
1619 error = std::move(ret);
1620 continue;
1621 }
1622 }
1623 if (flags.Test(DoCommandFlag::Execute)) { // we can safely convert, too
1624 for (Track track : GetReservedTrackbits(cur_tile)) {
1625 Train *v = GetTrainForReservation(cur_tile, track);
1626 if (v != nullptr && !HasPowerOnRail(v->railtypes, totype)) {
1627 /* No power on new rail type, reroute. */
1629 vehicles_affected.push_back(v);
1630 }
1631 }
1632
1633 /* Update the company infrastructure counters. */
1634 if (!IsRailStationTile(cur_tile) || !IsStationTileBlocked(cur_tile)) {
1635 Company *c = Company::Get(GetTileOwner(cur_tile));
1636 uint num_pieces = IsLevelCrossingTile(cur_tile) ? LEVELCROSSING_TRACKBIT_FACTOR : 1;
1637 if (IsPlainRailTile(cur_tile)) {
1638 TrackBits bits = GetTrackBits(cur_tile);
1639 num_pieces = bits.Count();
1640 if (TracksOverlap(bits)) num_pieces *= num_pieces;
1641 }
1642 c->infrastructure.rail[type] -= num_pieces;
1643 c->infrastructure.rail[totype] += num_pieces;
1645 }
1646
1647 SetRailType(cur_tile, totype);
1648 MarkTileDirtyByTile(cur_tile);
1649 /* update power of train on this tile */
1650 for (Vehicle *v : VehiclesOnTile(cur_tile)) {
1651 if (v->type == VehicleType::Train) include(affected_trains, Train::From(v)->First());
1652 }
1653 }
1654 }
1655
1656 switch (tt) {
1657 default: NOT_REACHED();
1658 case TileType::Railway:
1659 switch (GetRailTileType(cur_tile)) {
1661 if (flags.Test(DoCommandFlag::Execute)) {
1662 /* notify YAPF about the track layout change */
1664
1665 /* Update build vehicle window related to this depot */
1666 InvalidateWindowData(WindowClass::VehicleDepot, cur_tile);
1667 InvalidateWindowData(WindowClass::BuildVehicle, cur_tile);
1668 }
1669 found_convertible_track = true;
1670 cost.AddCost(RailConvertCost(type, totype));
1671 break;
1672
1673 default: // RailTileType::Normal, RailTileType::Signals
1674 if (flags.Test(DoCommandFlag::Execute)) {
1675 /* notify YAPF about the track layout change */
1676 for (Track track : GetTrackBits(cur_tile)) {
1677 YapfNotifyTrackLayoutChange(cur_tile, track);
1678 }
1679 }
1680 found_convertible_track = true;
1681 cost.AddCost(RailConvertCost(type, totype) * GetTrackBits(cur_tile).Count());
1682 break;
1683 }
1684 break;
1685
1687 TileIndex endtile = GetOtherTunnelBridgeEnd(cur_tile);
1688
1689 /* If both ends of tunnel/bridge are in the range, do not try to convert twice -
1690 * it would cause assert because of different test and exec runs */
1691 if (endtile < cur_tile) {
1692 if (tilearea.Contains(endtile)) continue;
1693 }
1694
1695 /* When not converting rail <-> el. rail, any vehicle cannot be in tunnel/bridge */
1696 if (!IsCompatibleRail(GetRailType(cur_tile), totype)) {
1697 ret = TunnelBridgeIsFree(cur_tile, endtile);
1698 if (ret.Failed()) {
1699 error = std::move(ret);
1700 continue;
1701 }
1702 }
1703
1704 if (flags.Test(DoCommandFlag::Execute)) {
1706 if (HasTunnelBridgeReservation(cur_tile)) {
1707 Train *v = GetTrainForReservation(cur_tile, track);
1708 if (v != nullptr && !HasPowerOnRail(v->railtypes, totype)) {
1709 /* No power on new rail type, reroute. */
1711 vehicles_affected.push_back(v);
1712 }
1713 }
1714
1715 /* Update the company infrastructure counters. */
1716 uint num_pieces = (GetTunnelBridgeLength(cur_tile, endtile) + 2) * TUNNELBRIDGE_TRACKBIT_FACTOR;
1717 Company *c = Company::Get(GetTileOwner(cur_tile));
1718 c->infrastructure.rail[GetRailType(cur_tile)] -= num_pieces;
1719 c->infrastructure.rail[totype] += num_pieces;
1721
1722 SetRailType(cur_tile, totype);
1723 SetRailType(endtile, totype);
1724
1725 for (Vehicle *v : VehiclesOnTile(cur_tile)) {
1726 if (v->type == VehicleType::Train) include(affected_trains, Train::From(v)->First());
1727 }
1728 for (Vehicle *v : VehiclesOnTile(endtile)) {
1729 if (v->type == VehicleType::Train) include(affected_trains, Train::From(v)->First());
1730 }
1731
1732 YapfNotifyTrackLayoutChange(cur_tile, track);
1733 YapfNotifyTrackLayoutChange(endtile, track);
1734
1735 if (IsBridge(cur_tile)) {
1736 MarkBridgeDirty(cur_tile);
1737 } else {
1738 MarkTileDirtyByTile(cur_tile);
1739 MarkTileDirtyByTile(endtile);
1740 }
1741 }
1742
1743 found_convertible_track = true;
1744 cost.AddCost((GetTunnelBridgeLength(cur_tile, endtile) + 2) * RailConvertCost(type, totype));
1745 break;
1746 }
1747
1748 case TileType::Station:
1749 case TileType::Road:
1750 if (flags.Test(DoCommandFlag::Execute)) {
1751 Track track = ((tt == TileType::Station) ? GetRailStationTrack(cur_tile) : GetCrossingRailTrack(cur_tile));
1752 YapfNotifyTrackLayoutChange(cur_tile, track);
1753 }
1754
1755 found_convertible_track = true;
1756 cost.AddCost(RailConvertCost(type, totype));
1757 break;
1758 }
1759
1760 for (uint i = 0; i < vehicles_affected.size(); ++i) {
1761 TryPathReserve(vehicles_affected[i], true);
1762 }
1763 }
1764
1765 if (flags.Test(DoCommandFlag::Execute)) {
1766 /* Railtype changed, update trains as when entering different track */
1767 for (Train *v : affected_trains) {
1768 v->ConsistChanged(CCF_TRACK);
1769 }
1770 }
1771
1772 return found_convertible_track ? cost : error;
1773}
1774
1775static CommandCost RemoveTrainDepot(TileIndex tile, DoCommandFlags flags)
1776{
1778 CommandCost ret = CheckTileOwnership(tile);
1779 if (ret.Failed()) return ret;
1780 }
1781
1783 if (ret.Failed()) return ret;
1784
1785 if (flags.Test(DoCommandFlag::Execute)) {
1786 /* read variables before the depot is removed */
1788 Owner owner = GetTileOwner(tile);
1789 Train *v = nullptr;
1790
1791 if (HasDepotReservation(tile)) {
1793 if (v != nullptr) FreeTrainTrackReservation(v);
1794 }
1795
1796 Company::Get(owner)->infrastructure.rail[GetRailType(tile)]--;
1798
1799 delete Depot::GetByTile(tile);
1800 DoClearSquare(tile);
1801 AddSideToSignalBuffer(tile, dir, owner);
1803 if (v != nullptr) TryPathReserve(v, true);
1804 }
1805
1807}
1808
1811{
1813
1814 if (flags.Test(DoCommandFlag::Auto)) {
1815 if (!IsTileOwner(tile, _current_company)) {
1816 return CommandCost(STR_ERROR_AREA_IS_OWNED_BY_ANOTHER);
1817 }
1818
1819 if (IsPlainRail(tile)) {
1820 return CommandCost(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK);
1821 } else {
1822 return CommandCost(STR_ERROR_BUILDING_MUST_BE_DEMOLISHED);
1823 }
1824 }
1825
1826 switch (GetRailTileType(tile)) {
1828 case RailTileType::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) == RailGroundType::HalfTileWater && IsSlopeWithOneCornerRaised(tileh));
1832
1833 for (Track track : GetTrackBits(tile)) {
1834 CommandCost ret = Command<Commands::RemoveRail>::Do(flags, tile, track);
1835 if (ret.Failed()) return ret;
1836 cost.AddCost(ret.GetCost());
1837 }
1838
1839 /* When bankrupting, don't make water dirty, there could be a ship on lower halftile.
1840 * Same holds for non-companies clearing the tile, e.g. disasters. */
1841 if (water_ground && !flags.Test(DoCommandFlag::Bankrupt) && Company::IsValidID(_current_company)) {
1843 if (ret.Failed()) return ret;
1844
1845 /* The track was removed, and left a coast tile. Now also clear the water. */
1846 if (flags.Test(DoCommandFlag::Execute)) {
1847 DoClearSquare(tile);
1848 }
1850 }
1851
1852 return cost;
1853 }
1854
1856 return RemoveTrainDepot(tile, flags);
1857
1858 default:
1859 return CMD_ERROR;
1860 }
1861}
1862
1871static uint GetSafeSlopeZ(uint x, uint y, Track track)
1872{
1873 switch (track) {
1874 case Track::Upper: x &= ~0xF; y &= ~0xF; break;
1875 case Track::Lower: x |= 0xF; y |= 0xF; break;
1876 case Track::Left: x |= 0xF; y &= ~0xF; break;
1877 case Track::Right: x &= ~0xF; y |= 0xF; break;
1878 default: break;
1879 }
1880 return GetSlopePixelZ(x, y);
1881}
1882
1888{
1889 switch (_settings_game.construction.train_signal_side) {
1891 return false;
1893 return true;
1895 return _settings_game.vehicle.road_side == RoadVehicleDrivingSide::Right;
1896 default:
1897 NOT_REACHED();
1898 }
1899}
1900
1901static void DrawSingleSignal(TileIndex tile, const RailTypeInfo *rti, Track track, SignalState condition, SignalOffsets image, uint pos)
1902{
1903 static const Point SignalPositions[2][12] = {
1904 { // Signals on the left side
1905 /* LEFT LEFT RIGHT RIGHT UPPER UPPER */
1906 { 8, 5}, {14, 1}, { 1, 14}, { 9, 11}, { 1, 0}, { 3, 10},
1907 /* LOWER LOWER X X Y Y */
1908 {11, 4}, {14, 14}, {11, 3}, { 4, 13}, { 3, 4}, {11, 13}
1909 }, { // Signals on the right side
1910 /* LEFT LEFT RIGHT RIGHT UPPER UPPER */
1911 {14, 1}, {12, 10}, { 4, 6}, { 1, 14}, {10, 4}, { 0, 1},
1912 /* LOWER LOWER X X Y Y */
1913 {14, 14}, { 5, 12}, {11, 13}, { 4, 3}, {13, 4}, { 3, 11}
1914 }
1915 };
1916
1917 bool signal_on_right = IsTrainSignalSideRight();
1918 uint x = TileX(tile) * TILE_SIZE + SignalPositions[signal_on_right][pos].x;
1919 uint y = TileY(tile) * TILE_SIZE + SignalPositions[signal_on_right][pos].y;
1920
1921 SignalType type = GetSignalType(tile, track);
1922 SignalVariant variant = GetSignalVariant(tile, track);
1923
1924 SpriteID sprite = GetCustomSignalSprite(rti, tile, type, variant, condition);
1925 if (sprite != 0) {
1926 sprite += image;
1927 } else {
1928 /* Normal electric signals are stored in a different sprite block than all other signals. */
1929 sprite = (type == SignalType::Block && variant == SignalVariant::Electric) ? SPR_ORIGINAL_SIGNALS_BASE : SPR_SIGNALS_BASE - 16;
1930 sprite += to_underlying(type) * 16 + to_underlying(variant) * 64 + image * 2 + to_underlying(condition) + (type >= SignalType::Path ? 64 : 0);
1931 }
1932
1933 AddSortableSpriteToDraw(sprite, PAL_NONE, x, y, GetSafeSlopeZ(x, y, track), {{}, {1, 1, BB_HEIGHT_UNDER_BRIDGE}, {}});
1934}
1935
1937struct FenceOffset : SpriteBounds {
1939
1940 constexpr FenceOffset(Corner height_ref, int8_t origin_x, int8_t origin_y, uint8_t extent_x, uint8_t extent_y) :
1941 SpriteBounds({origin_x, origin_y, 0}, {extent_x, extent_y, 4}, {}), height_ref(height_ref) {}
1942};
1943
1946 FenceOffset(Corner::Invalid, 0, 1, 16, 1), // RailFenceOffset::FlatXNW
1947 FenceOffset(Corner::Invalid, 1, 0, 1, 16), // RailFenceOffset::FlatYNE
1948 FenceOffset(Corner::W, 8, 8, 1, 1), // RailFenceOffset::FlatLeft
1949 FenceOffset(Corner::N, 8, 8, 1, 1), // RailFenceOffset::FlatUpper
1950 FenceOffset(Corner::Invalid, 0, 1, 16, 1), // RailFenceOffset::SlopeSWNW
1951 FenceOffset(Corner::Invalid, 1, 0, 1, 16), // RailFenceOffset::SlopeSENE
1952 FenceOffset(Corner::Invalid, 0, 1, 16, 1), // RailFenceOffset::SlopeNENW
1953 FenceOffset(Corner::Invalid, 1, 0, 1, 16), // RailFenceOffset::SlopeNWNE
1954 FenceOffset(Corner::Invalid, 0, 15, 16, 1), // RailFenceOffset::FlatXSE
1955 FenceOffset(Corner::Invalid, 15, 0, 1, 16), // RailFenceOffset::FlatYSW
1956 FenceOffset(Corner::E, 8, 8, 1, 1), // RailFenceOffset::FlatRight
1957 FenceOffset(Corner::S, 8, 8, 1, 1), // RailFenceOffset::FlatLower
1958 FenceOffset(Corner::Invalid, 0, 15, 16, 1), // RailFenceOffset::SlopeSWSE
1959 FenceOffset(Corner::Invalid, 15, 0, 1, 16), // RailFenceOffset::SlopeSESW
1960 FenceOffset(Corner::Invalid, 0, 15, 16, 1), // RailFenceOffset::SlopNESE
1961 FenceOffset(Corner::Invalid, 15, 0, 1, 16), // RailFenceOffset::SlopeNWSW
1962};
1963
1971static void DrawTrackFence(const TileInfo *ti, const PalSpriteID &psid, uint num_sprites, RailFenceOffset rfo)
1972{
1973 int z = ti->z;
1974 if (IsValidCorner(fence_offsets[rfo].height_ref)) {
1976 }
1977 AddSortableSpriteToDraw(psid.sprite + (to_underlying(rfo) % num_sprites), psid.pal, ti->x, ti->y, z, fence_offsets[rfo]);
1978}
1979
1986static void DrawTrackFence_NW(const TileInfo *ti, const PalSpriteID &psid, uint num_sprites)
1987{
1990 DrawTrackFence(ti, psid, num_sprites, rfo);
1991}
1992
1999static void DrawTrackFence_SE(const TileInfo *ti, const PalSpriteID &psid, uint num_sprites)
2000{
2003 DrawTrackFence(ti, psid, num_sprites, rfo);
2004}
2005
2012static void DrawTrackFence_NE(const TileInfo *ti, const PalSpriteID &psid, uint num_sprites)
2013{
2016 DrawTrackFence(ti, psid, num_sprites, rfo);
2017}
2018
2025static void DrawTrackFence_SW(const TileInfo *ti, const PalSpriteID &psid, uint num_sprites)
2026{
2029 DrawTrackFence(ti, psid, num_sprites, rfo);
2030}
2031
2038static void DrawTrackDetails(const TileInfo *ti, const RailTypeInfo *rti, PaletteID pal)
2039{
2040 /* Base sprite for track fences.
2041 * Note: Halftile slopes only have fences on the upper part. */
2042 uint num_sprites = 0;
2043 PalSpriteID psid{
2045 .pal = pal,
2046 };
2047 if (psid.sprite == 0) {
2049 num_sprites = 8;
2050 }
2051
2052 assert(num_sprites > 0);
2053
2054 switch (GetRailGroundType(ti->tile)) {
2055 case RailGroundType::FenceNW: DrawTrackFence_NW(ti, psid, num_sprites); break;
2056 case RailGroundType::FenceSE: DrawTrackFence_SE(ti, psid, num_sprites); break;
2057 case RailGroundType::FenceSENW: DrawTrackFence_NW(ti, psid, num_sprites); DrawTrackFence_SE(ti, psid, num_sprites); break;
2058 case RailGroundType::FenceNE: DrawTrackFence_NE(ti, psid, num_sprites); break;
2059 case RailGroundType::FenceSW: DrawTrackFence_SW(ti, psid, num_sprites); break;
2060 case RailGroundType::FenceNESW: DrawTrackFence_NE(ti, psid, num_sprites); DrawTrackFence_SW(ti, psid, num_sprites); break;
2061 case RailGroundType::FenceVert1: DrawTrackFence(ti, psid, num_sprites, RailFenceOffset::FlatLeft); break;
2062 case RailGroundType::FenceVert2: DrawTrackFence(ti, psid, num_sprites, RailFenceOffset::FlatRight); break;
2063 case RailGroundType::FenceHoriz1: DrawTrackFence(ti, psid, num_sprites, RailFenceOffset::FlatUpper); break;
2064 case RailGroundType::FenceHoriz2: DrawTrackFence(ti, psid, num_sprites, RailFenceOffset::FlatLower); break;
2066 Corner track_corner;
2067 if (IsHalftileSlope(ti->tileh)) {
2068 /* Steep slope or one-corner-raised slope with halftile foundation */
2069 track_corner = GetHalftileSlopeCorner(ti->tileh);
2070 } else {
2071 /* Three-corner-raised slope */
2073 }
2074 switch (track_corner) {
2075 case Corner::W: DrawTrackFence(ti, psid, num_sprites, RailFenceOffset::FlatLeft); break;
2076 case Corner::S: DrawTrackFence(ti, psid, num_sprites, RailFenceOffset::FlatLower); break;
2077 case Corner::E: DrawTrackFence(ti, psid, num_sprites, RailFenceOffset::FlatRight); break;
2078 case Corner::N: DrawTrackFence(ti, psid, num_sprites, RailFenceOffset::FlatUpper); break;
2079 default: NOT_REACHED();
2080 }
2081 break;
2082 }
2083 default: break;
2084 }
2085}
2086
2087static const int INF = 1000;
2090 { -INF , -INF , 32 - 33, INF }, // Corner::W, clip 33 pixels from right
2091 { -INF , 0 + 7, INF , INF }, // Corner::S, clip 7 pixels from top
2092 { -31 + 33, -INF , INF , INF }, // Corner::E, clip 33 pixels from left
2093 { -INF , -INF , INF , 30 - 23 } // Corner::N, clip 23 pixels from bottom
2094}}};
2095
2096static inline void DrawTrackSprite(SpriteID sprite, PaletteID pal, const TileInfo *ti, Slope s)
2097{
2098 DrawGroundSprite(sprite, pal, nullptr, 0, (ti->tileh & s) ? -8 : 0);
2099}
2100
2101static void DrawTrackBitsOverlay(TileInfo *ti, TrackBits track, const RailTypeInfo *rti)
2102{
2104 Foundation f = GetRailFoundation(ti->tileh, track);
2105 Corner halftile_corner = Corner::Invalid;
2106
2108 /* Save halftile corner */
2110 /* Draw lower part first */
2111 track.Reset(CornerToTrackBits(halftile_corner));
2113 }
2114
2115 DrawFoundation(ti, f);
2116 /* DrawFoundation modifies ti */
2117
2118 /* Draw ground */
2119 if (rgt == RailGroundType::HalfTileWater) {
2120 if (track.Any() || IsSteepSlope(ti->tileh)) {
2121 /* three-corner-raised slope or steep slope with track on upper part */
2122 DrawShoreTile(ti->tileh);
2123 } else {
2124 /* single-corner-raised slope with track on upper part */
2126 }
2127 } else {
2128 SpriteID image;
2129
2130 switch (rgt) {
2131 case RailGroundType::Barren: image = SPR_FLAT_BARE_LAND; break;
2133 default: image = SPR_FLAT_GRASS_TILE; break;
2134 }
2135
2136 image += SlopeToSpriteOffset(ti->tileh);
2137
2138 DrawGroundSprite(image, PAL_NONE);
2139 }
2140
2141 bool no_combine = ti->tileh == SLOPE_FLAT && rti->flags.Test(RailTypeFlag::NoSpriteCombine);
2144 TrackBits pbs = _settings_client.gui.show_track_reservation ? GetRailReservationTrackBits(ti->tile) : TrackBits{};
2145
2146 if (track.None()) {
2147 /* Half-tile foundation, no track here? */
2148 } else if (no_combine) {
2149 /* Use trackbits as direct index from ground sprite, subtract 1
2150 * because there is no sprite for no bits. */
2151 DrawGroundSprite(ground + track.base() - 1, PAL_NONE);
2152
2153 /* Draw reserved track bits */
2156 if (pbs.Test(Track::Upper)) DrawTrackSprite(overlay + RailTrackOffset::N, PALETTE_CRASH, ti, SLOPE_N);
2157 if (pbs.Test(Track::Lower)) DrawTrackSprite(overlay + RailTrackOffset::S, PALETTE_CRASH, ti, SLOPE_S);
2158 if (pbs.Test(Track::Right)) DrawTrackSprite(overlay + RailTrackOffset::E, PALETTE_CRASH, ti, SLOPE_E);
2159 if (pbs.Test(Track::Left)) DrawTrackSprite(overlay + RailTrackOffset::W, PALETTE_CRASH, ti, SLOPE_W);
2160 } else if (ti->tileh == SLOPE_NW && track == Track::Y) {
2161 DrawGroundSprite(ground + RailTrackOffset::SlopeNW, PAL_NONE);
2163 } else if (ti->tileh == SLOPE_NE && track == Track::X) {
2164 DrawGroundSprite(ground + RailTrackOffset::SlopeNE, PAL_NONE);
2166 } else if (ti->tileh == SLOPE_SE && track == Track::Y) {
2167 DrawGroundSprite(ground + RailTrackOffset::SlopeSE, PAL_NONE);
2169 } else if (ti->tileh == SLOPE_SW && track == Track::X) {
2170 DrawGroundSprite(ground + RailTrackOffset::SlopeSW, PAL_NONE);
2172 } else {
2173 switch (track.base()) {
2174 /* Draw single ground sprite when not overlapping. No track overlay
2175 * is necessary for these sprites. */
2176 case TrackBits{Track::X}.base(): DrawGroundSprite(ground + RailTrackOffset::X, PAL_NONE); break;
2177 case TrackBits{Track::Y}.base(): DrawGroundSprite(ground + RailTrackOffset::Y, PAL_NONE); break;
2178 case TrackBits{Track::Upper}.base(): DrawTrackSprite(ground + RailTrackOffset::N, PAL_NONE, ti, SLOPE_N); break;
2179 case TrackBits{Track::Lower}.base(): DrawTrackSprite(ground + RailTrackOffset::S, PAL_NONE, ti, SLOPE_S); break;
2180 case TrackBits{Track::Right}.base(): DrawTrackSprite(ground + RailTrackOffset::E, PAL_NONE, ti, SLOPE_E); break;
2181 case TrackBits{Track::Left}.base(): DrawTrackSprite(ground + RailTrackOffset::W, PAL_NONE, ti, SLOPE_W); break;
2182 case TRACK_BIT_CROSS.base(): DrawGroundSprite(ground + RailTrackOffset::CrossingXY, PAL_NONE); break;
2183 case TRACK_BIT_HORZ.base():
2184 DrawTrackSprite(ground + RailTrackOffset::N, PAL_NONE, ti, SLOPE_N);
2185 DrawTrackSprite(ground + RailTrackOffset::S, PAL_NONE, ti, SLOPE_S);
2186 break;
2187 case TRACK_BIT_VERT.base():
2188 DrawTrackSprite(ground + RailTrackOffset::E, PAL_NONE, ti, SLOPE_E);
2189 DrawTrackSprite(ground + RailTrackOffset::W, PAL_NONE, ti, SLOPE_W);
2190 break;
2191
2192 default:
2193 /* We're drawing a junction tile */
2194 if (!track.Any(TRACK_BIT_3WAY_NE)) {
2196 } else if (!track.Any(TRACK_BIT_3WAY_SW)) {
2198 } else if (!track.Any(TRACK_BIT_3WAY_NW)) {
2200 } else if (!track.Any(TRACK_BIT_3WAY_SE)) {
2202 } else {
2204 }
2205
2206 /* Mask out PBS bits as we shall draw them afterwards anyway. */
2207 track.Reset(pbs);
2208
2209 /* Draw regular track bits */
2210 if (track.Test(Track::X)) DrawGroundSprite(overlay + RailTrackOffset::X, PAL_NONE);
2211 if (track.Test(Track::Y)) DrawGroundSprite(overlay + RailTrackOffset::Y, PAL_NONE);
2212 if (track.Test(Track::Upper)) DrawGroundSprite(overlay + RailTrackOffset::N, PAL_NONE);
2213 if (track.Test(Track::Lower)) DrawGroundSprite(overlay + RailTrackOffset::S, PAL_NONE);
2214 if (track.Test(Track::Right)) DrawGroundSprite(overlay + RailTrackOffset::E, PAL_NONE);
2215 if (track.Test(Track::Left)) DrawGroundSprite(overlay + RailTrackOffset::W, PAL_NONE);
2216 }
2217
2218 /* Draw reserved track bits */
2221 if (pbs.Test(Track::Upper)) DrawTrackSprite(overlay + RailTrackOffset::N, PALETTE_CRASH, ti, SLOPE_N);
2222 if (pbs.Test(Track::Lower)) DrawTrackSprite(overlay + RailTrackOffset::S, PALETTE_CRASH, ti, SLOPE_S);
2223 if (pbs.Test(Track::Right)) DrawTrackSprite(overlay + RailTrackOffset::E, PALETTE_CRASH, ti, SLOPE_E);
2224 if (pbs.Test(Track::Left)) DrawTrackSprite(overlay + RailTrackOffset::W, PALETTE_CRASH, ti, SLOPE_W);
2225 }
2226
2227 if (IsValidCorner(halftile_corner)) {
2228 DrawFoundation(ti, HalftileFoundation(halftile_corner));
2231
2232 /* Draw higher halftile-overlay: Use the sloped sprites with three corners raised. They probably best fit the lightning. */
2233 Slope fake_slope = SlopeWithThreeCornersRaised(OppositeCorner(halftile_corner));
2234
2235 SpriteID image;
2236 switch (rgt) {
2237 case RailGroundType::Barren: image = SPR_FLAT_BARE_LAND; break;
2240 default: image = SPR_FLAT_GRASS_TILE; break;
2241 }
2242
2243 image += SlopeToSpriteOffset(fake_slope);
2244
2245 DrawGroundSprite(image, PAL_NONE, &(_halftile_sub_sprite[halftile_corner]));
2246
2247 track = CornerToTrackBits(halftile_corner);
2248
2249 int offset;
2250 switch (FindFirstTrack(track)) {
2251 default: NOT_REACHED();
2252 case Track::Upper: offset = to_underlying(RailTrackOffset::N); break;
2253 case Track::Lower: offset = to_underlying(RailTrackOffset::S); break;
2254 case Track::Right: offset = to_underlying(RailTrackOffset::E); break;
2255 case Track::Left: offset = to_underlying(RailTrackOffset::W); break;
2256 }
2257
2258 DrawTrackSprite(ground + offset, PAL_NONE, ti, fake_slope);
2259 if (_settings_client.gui.show_track_reservation && HasReservedTracks(ti->tile, track)) {
2260 DrawTrackSprite(overlay + offset, PALETTE_CRASH, ti, fake_slope);
2261 }
2262 }
2263}
2264
2273{
2274 /* If none of the tracks end up in the NE corner, return the ground sprite
2275 * where the NE of the tile is not covered. Repeat for the other directions.
2276 * What remains are junctions where all directions are covered. */
2277 if (!track.Any(TRACK_BIT_3WAY_NE)) return 0;
2278 if (!track.Any(TRACK_BIT_3WAY_SW)) return 1;
2279 if (!track.Any(TRACK_BIT_3WAY_NW)) return 2;
2280 if (!track.Any(TRACK_BIT_3WAY_SE)) return 3;
2281 return 4;
2282}
2283
2289static void DrawTrackBits(TileInfo *ti, TrackBits track)
2290{
2291 const RailTypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile));
2292
2293 if (rti->UsesOverlay()) {
2294 DrawTrackBitsOverlay(ti, track, rti);
2295 return;
2296 }
2297
2299 Foundation f = GetRailFoundation(ti->tileh, track);
2300 Corner halftile_corner = Corner::Invalid;
2301
2303 /* Save halftile corner */
2305 /* Draw lower part first */
2306 track.Reset(CornerToTrackBits(halftile_corner));
2308 }
2309
2310 DrawFoundation(ti, f);
2311 /* DrawFoundation modifies ti */
2312
2313 SpriteID image;
2314 PaletteID pal = PAL_NONE;
2315 const SubSprite *sub = nullptr;
2316 bool junction = false;
2317
2318 /* Select the sprite to use. */
2319 if (track.None()) {
2320 /* Clear ground (only track on halftile foundation) */
2321 if (rgt == RailGroundType::HalfTileWater) {
2322 if (IsSteepSlope(ti->tileh)) {
2323 DrawShoreTile(ti->tileh);
2324 image = 0;
2325 } else {
2326 image = SPR_FLAT_WATER_TILE;
2327 }
2328 } else {
2329 switch (rgt) {
2330 case RailGroundType::Barren: image = SPR_FLAT_BARE_LAND; break;
2332 default: image = SPR_FLAT_GRASS_TILE; break;
2333 }
2334 image += SlopeToSpriteOffset(ti->tileh);
2335 }
2336 } else {
2337 if (ti->tileh != SLOPE_FLAT) {
2338 /* track on non-flat ground */
2339 image = _track_sloped_sprites[ti->tileh] + rti->base_sprites.track_y;
2340 } else {
2341 /* track on flat ground */
2342 switch (track.base()) {
2343 /* single track, select combined track + ground sprite*/
2344 case TrackBits{Track::Y}.base(): image = rti->base_sprites.track_y; break;
2345 case TrackBits{Track::X}.base(): image = rti->base_sprites.track_y + 1; break;
2346 case TrackBits{Track::Upper}.base(): image = rti->base_sprites.track_y + 2; break;
2347 case TrackBits{Track::Lower}.base(): image = rti->base_sprites.track_y + 3; break;
2348 case TrackBits{Track::Right}.base(): image = rti->base_sprites.track_y + 4; break;
2349 case TrackBits{Track::Left}.base(): image = rti->base_sprites.track_y + 5; break;
2350 case TRACK_BIT_CROSS.base(): image = rti->base_sprites.track_y + 6; break;
2351
2352 /* double diagonal track, select combined track + ground sprite*/
2353 case TRACK_BIT_HORZ.base(): image = rti->base_sprites.track_ns; break;
2354 case TRACK_BIT_VERT.base(): image = rti->base_sprites.track_ns + 1; break;
2355
2356 /* junction, select only ground sprite, handle track sprite later */
2357 default:
2358 junction = true;
2360 break;
2361 }
2362 }
2363
2364 switch (rgt) {
2366 case RailGroundType::SnowOrDesert: image += rti->snow_offset; break;
2368 /* three-corner-raised slope */
2369 DrawShoreTile(ti->tileh);
2371 sub = &(_halftile_sub_sprite[track_corner]);
2372 break;
2373 }
2374 default: break;
2375 }
2376 }
2377
2378 if (image != 0) DrawGroundSprite(image, pal, sub);
2379
2380 /* Draw track pieces individually for junction tiles */
2381 if (junction) {
2382 if (track.Test(Track::X)) DrawGroundSprite(rti->base_sprites.single_x, PAL_NONE);
2383 if (track.Test(Track::Y)) DrawGroundSprite(rti->base_sprites.single_y, PAL_NONE);
2384 if (track.Test(Track::Upper)) DrawGroundSprite(rti->base_sprites.single_n, PAL_NONE);
2385 if (track.Test(Track::Lower)) DrawGroundSprite(rti->base_sprites.single_s, PAL_NONE);
2386 if (track.Test(Track::Left)) DrawGroundSprite(rti->base_sprites.single_w, PAL_NONE);
2387 if (track.Test(Track::Right)) DrawGroundSprite(rti->base_sprites.single_e, PAL_NONE);
2388 }
2389
2390 /* PBS debugging, draw reserved tracks darker */
2391 if (_game_mode != GameMode::Menu && _settings_client.gui.show_track_reservation) {
2392 /* Get reservation, but mask track on halftile slope */
2393 TrackBits pbs = GetRailReservationTrackBits(ti->tile) & track;
2394 if (pbs.Test(Track::X)) {
2395 if (ti->tileh == SLOPE_FLAT || ti->tileh == SLOPE_ELEVATED) {
2397 } else {
2399 }
2400 }
2401 if (pbs.Test(Track::Y)) {
2402 if (ti->tileh == SLOPE_FLAT || ti->tileh == SLOPE_ELEVATED) {
2404 } else {
2406 }
2407 }
2408 if (pbs.Test(Track::Upper)) DrawGroundSprite(rti->base_sprites.single_n, PALETTE_CRASH, nullptr, 0, ti->tileh & SLOPE_N ? -(int)TILE_HEIGHT : 0);
2409 if (pbs.Test(Track::Lower)) DrawGroundSprite(rti->base_sprites.single_s, PALETTE_CRASH, nullptr, 0, ti->tileh & SLOPE_S ? -(int)TILE_HEIGHT : 0);
2410 if (pbs.Test(Track::Left)) DrawGroundSprite(rti->base_sprites.single_w, PALETTE_CRASH, nullptr, 0, ti->tileh & SLOPE_W ? -(int)TILE_HEIGHT : 0);
2411 if (pbs.Test(Track::Right)) DrawGroundSprite(rti->base_sprites.single_e, PALETTE_CRASH, nullptr, 0, ti->tileh & SLOPE_E ? -(int)TILE_HEIGHT : 0);
2412 }
2413
2414 if (IsValidCorner(halftile_corner)) {
2415 DrawFoundation(ti, HalftileFoundation(halftile_corner));
2416
2417 /* Draw higher halftile-overlay: Use the sloped sprites with three corners raised. They probably best fit the lightning. */
2418 Slope fake_slope = SlopeWithThreeCornersRaised(OppositeCorner(halftile_corner));
2419 image = _track_sloped_sprites[fake_slope] + rti->base_sprites.track_y;
2420 pal = PAL_NONE;
2421 switch (rgt) {
2424 case RailGroundType::HalfTileSnow: image += rti->snow_offset; break; // higher part has snow in this case too
2425 default: break;
2426 }
2427 DrawGroundSprite(image, pal, &(_halftile_sub_sprite[halftile_corner]));
2428
2429 if (_game_mode != GameMode::Menu && _settings_client.gui.show_track_reservation && HasReservedTracks(ti->tile, CornerToTrackBits(halftile_corner))) {
2430 static constexpr CornerIndexArray<uint8_t> corner_to_track_sprite = {3, 1, 2, 0};
2431 DrawGroundSprite(corner_to_track_sprite[halftile_corner] + rti->base_sprites.single_n, PALETTE_CRASH, nullptr, 0, -static_cast<int>(TILE_HEIGHT));
2432 }
2433 }
2434}
2435
2436static void DrawSignals(TileIndex tile, TrackBits rails, const RailTypeInfo *rti)
2437{
2438 auto MAYBE_DRAW_SIGNAL = [&](uint8_t signalbit, SignalOffsets image, uint pos, Track track) {
2439 if (IsSignalPresent(tile, signalbit)) DrawSingleSignal(tile, rti, track, GetSingleSignalState(tile, signalbit), image, pos);
2440 };
2441
2442 if (!rails.Test(Track::Y)) {
2443 if (!rails.Test(Track::X)) {
2444 if (rails.Test(Track::Left)) {
2445 MAYBE_DRAW_SIGNAL(2, SIGNAL_TO_NORTH, 0, Track::Left);
2446 MAYBE_DRAW_SIGNAL(3, SIGNAL_TO_SOUTH, 1, Track::Left);
2447 }
2448 if (rails.Test(Track::Right)) {
2449 MAYBE_DRAW_SIGNAL(0, SIGNAL_TO_NORTH, 2, Track::Right);
2450 MAYBE_DRAW_SIGNAL(1, SIGNAL_TO_SOUTH, 3, Track::Right);
2451 }
2452 if (rails.Test(Track::Upper)) {
2453 MAYBE_DRAW_SIGNAL(3, SIGNAL_TO_WEST, 4, Track::Upper);
2454 MAYBE_DRAW_SIGNAL(2, SIGNAL_TO_EAST, 5, Track::Upper);
2455 }
2456 if (rails.Test(Track::Lower)) {
2457 MAYBE_DRAW_SIGNAL(1, SIGNAL_TO_WEST, 6, Track::Lower);
2458 MAYBE_DRAW_SIGNAL(0, SIGNAL_TO_EAST, 7, Track::Lower);
2459 }
2460 } else {
2461 MAYBE_DRAW_SIGNAL(3, SIGNAL_TO_SOUTHWEST, 8, Track::X);
2462 MAYBE_DRAW_SIGNAL(2, SIGNAL_TO_NORTHEAST, 9, Track::X);
2463 }
2464 } else {
2465 MAYBE_DRAW_SIGNAL(3, SIGNAL_TO_SOUTHEAST, 10, Track::Y);
2466 MAYBE_DRAW_SIGNAL(2, SIGNAL_TO_NORTHWEST, 11, Track::Y);
2467 }
2468}
2469
2471static void DrawTile_Rail(TileInfo *ti)
2472{
2473 const RailTypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile));
2474 BridgePillarFlags blocked_pillars{};
2476
2477 if (IsPlainRail(ti->tile)) {
2478 TrackBits rails = GetTrackBits(ti->tile);
2479
2480 DrawTrackBits(ti, rails);
2481
2483
2485
2486 if (HasSignals(ti->tile)) DrawSignals(ti->tile, rails, rti);
2487
2488 if (IsBridgeAbove(ti->tile)) {
2489 if (rails.Any(TRACK_BIT_3WAY_NE)) blocked_pillars.Set(BridgePillarFlag::EdgeNE);
2490 if (rails.Any(TRACK_BIT_3WAY_SE)) blocked_pillars.Set(BridgePillarFlag::EdgeSE);
2491 if (rails.Any(TRACK_BIT_3WAY_SW)) blocked_pillars.Set(BridgePillarFlag::EdgeSW);
2492 if (rails.Any(TRACK_BIT_3WAY_NW)) blocked_pillars.Set(BridgePillarFlag::EdgeNW);
2493 }
2494 } else {
2495 /* draw depot */
2496 const DrawTileSprites *dts;
2498
2500
2502 /* Draw rail instead of depot */
2503 dts = &_depot_invisible_gfx_table[dir];
2504 } else {
2505 dts = &_depot_gfx_table[dir];
2506 }
2507
2508 SpriteID image;
2509 if (rti->UsesOverlay()) {
2510 image = SPR_FLAT_GRASS_TILE;
2511 } else {
2512 image = dts->ground.sprite;
2513 if (image != SPR_FLAT_GRASS_TILE) image += rti->GetRailtypeSpriteOffset();
2514 }
2515
2516 /* Adjust ground tile for desert and snow. */
2517 if (IsSnowOrDesertRailGround(ti->tile)) {
2518 if (image != SPR_FLAT_GRASS_TILE) {
2519 image += rti->snow_offset; // tile with tracks
2520 } else {
2521 image = SPR_FLAT_SNOW_DESERT_TILE; // flat ground
2522 }
2523 }
2524
2525 DrawGroundSprite(image, GroundSpritePaletteTransform(image, PAL_NONE, pal));
2526
2527 if (rti->UsesOverlay()) {
2529
2530 switch (GetRailDepotDirection(ti->tile)) {
2531 case DiagDirection::NE:
2533 [[fallthrough]];
2534 case DiagDirection::SW:
2535 DrawGroundSprite(ground + RailTrackOffset::X, PAL_NONE);
2536 break;
2537 case DiagDirection::NW:
2539 [[fallthrough]];
2540 case DiagDirection::SE:
2541 DrawGroundSprite(ground + RailTrackOffset::Y, PAL_NONE);
2542 break;
2543 default:
2544 break;
2545 }
2546
2547 if (_settings_client.gui.show_track_reservation && HasDepotReservation(ti->tile)) {
2549
2550 switch (GetRailDepotDirection(ti->tile)) {
2551 case DiagDirection::NE:
2553 [[fallthrough]];
2554 case DiagDirection::SW:
2556 break;
2557 case DiagDirection::NW:
2559 [[fallthrough]];
2560 case DiagDirection::SE:
2562 break;
2563 default:
2564 break;
2565 }
2566 }
2567 } else {
2568 /* PBS debugging, draw reserved tracks darker */
2569 if (_game_mode != GameMode::Menu && _settings_client.gui.show_track_reservation && HasDepotReservation(ti->tile)) {
2570 switch (GetRailDepotDirection(ti->tile)) {
2571 case DiagDirection::NE:
2573 [[fallthrough]];
2574 case DiagDirection::SW:
2576 break;
2577 case DiagDirection::NW:
2579 [[fallthrough]];
2580 case DiagDirection::SE:
2582 break;
2583 default:
2584 break;
2585 }
2586 }
2587 }
2588 int depot_sprite = GetCustomRailSprite(rti, ti->tile, RailSpriteType::Depot);
2589 int relocation = depot_sprite != 0 ? depot_sprite - SPR_RAIL_DEPOT_SE_1 : rti->GetRailtypeSpriteOffset();
2590
2592
2593 DrawRailTileSeq(ti, dts, TransparencyOption::Buildings, relocation, 0, pal);
2594 blocked_pillars = BRIDGEPILLARFLAGS_ALL;
2595 }
2596 DrawBridgeMiddle(ti, blocked_pillars);
2597}
2598
2606void DrawTrainDepotSprite(int x, int y, DiagDirection dir, RailType railtype)
2607{
2608 const DrawTileSprites *dts = &_depot_gfx_table[dir];
2609 const RailTypeInfo *rti = GetRailTypeInfo(railtype);
2610 SpriteID image = rti->UsesOverlay() ? SPR_FLAT_GRASS_TILE : dts->ground.sprite;
2611 uint32_t offset = rti->GetRailtypeSpriteOffset();
2612
2613 if (image != SPR_FLAT_GRASS_TILE) image += offset;
2615
2616 DrawSprite(image, PAL_NONE, x, y);
2617
2618 if (rti->UsesOverlay()) {
2620
2621 switch (dir) {
2622 case DiagDirection::SW: DrawSprite(ground + RailTrackOffset::X, PAL_NONE, x, y); break;
2623 case DiagDirection::SE: DrawSprite(ground + RailTrackOffset::Y, PAL_NONE, x, y); break;
2624 default: break;
2625 }
2626 }
2627 int depot_sprite = GetCustomRailSprite(rti, INVALID_TILE, RailSpriteType::Depot);
2628 if (depot_sprite != 0) offset = depot_sprite - SPR_RAIL_DEPOT_SE_1;
2629
2630 DrawRailTileSeqInGUI(x, y, dts, offset, 0, palette);
2631}
2632
2634static int GetSlopePixelZ_Rail(TileIndex tile, uint x, uint y, [[maybe_unused]] bool ground_vehicle)
2635{
2636 if (IsPlainRail(tile)) {
2637 auto [tileh, z] = GetTilePixelSlope(tile);
2638 if (tileh == SLOPE_FLAT) return z;
2639
2641 return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh);
2642 } else {
2643 return GetTileMaxPixelZ(tile);
2644 }
2645}
2646
2649{
2650 return IsPlainRail(tile) ? GetRailFoundation(tileh, GetTrackBits(tile)) : FlatteningFoundation(tileh);
2651}
2652
2654static void TileLoop_Rail(TileIndex tile)
2655{
2656 RailGroundType old_ground = GetRailGroundType(tile);
2657 RailGroundType new_ground;
2658
2659 if (old_ground == RailGroundType::HalfTileWater) {
2660 TileLoop_Water(tile);
2661 return;
2662 }
2663
2664 switch (_settings_game.game_creation.landscape) {
2665 case LandscapeType::Arctic: {
2666 auto [slope, z] = GetTileSlopeZ(tile);
2667 bool half = false;
2668
2669 /* for non-flat track, use lower part of track
2670 * in other cases, use the highest part with track */
2671 if (IsPlainRail(tile)) {
2672 TrackBits track = GetTrackBits(tile);
2673 Foundation f = GetRailFoundation(slope, track);
2674
2675 switch (f) {
2676 case Foundation::None:
2677 /* no foundation - is the track on the upper side of three corners raised tile? */
2678 if (IsSlopeWithThreeCornersRaised(slope)) z++;
2679 break;
2680
2683 /* sloped track - is it on a steep slope? */
2684 if (IsSteepSlope(slope)) z++;
2685 break;
2686
2688 /* only lower part of steep slope */
2689 z++;
2690 break;
2691
2692 default:
2693 /* if it is a steep slope, then there is a track on higher part */
2694 if (IsSteepSlope(slope)) z++;
2695 z++;
2696 break;
2697 }
2698
2699 half = IsNonContinuousFoundation(f);
2700 } else {
2701 /* is the depot on a non-flat tile? */
2702 if (slope != SLOPE_FLAT) z++;
2703 }
2704
2705 /* 'z' is now the lowest part of the highest track bit -
2706 * for sloped track, it is 'z' of lower part
2707 * for two track bits, it is 'z' of higher track bit
2708 * For non-continuous foundations (and STEEP_BOTH), 'half' is set */
2709 if (z > GetSnowLine()) {
2710 if (half && z - GetSnowLine() == 1) {
2711 /* track on non-continuous foundation, lower part is not under snow */
2712 new_ground = RailGroundType::HalfTileSnow;
2713 } else {
2714 new_ground = RailGroundType::SnowOrDesert;
2715 }
2716 goto set_ground;
2717 }
2718 break;
2719 }
2720
2722 if (GetTropicZone(tile) == TropicZone::Desert) {
2723 new_ground = RailGroundType::SnowOrDesert;
2724 goto set_ground;
2725 }
2726 break;
2727
2728 default:
2729 break;
2730 }
2731
2732 new_ground = RailGroundType::Grass;
2733
2734 if (IsPlainRail(tile) && old_ground != RailGroundType::Barren) { // wait until bottom is green
2735 /* determine direction of fence */
2736 TrackBits rail = GetTrackBits(tile);
2737
2738 Owner owner = GetTileOwner(tile);
2739 DiagDirections fences{};
2740
2743
2744 /* Track bit on this edge => no fence. */
2745 if (rail.Any(dir_to_trackbits[d])) continue;
2746
2747 TileIndex tile2 = tile + TileOffsByDiagDir(d);
2748
2749 /* Show fences if it's a house, industry, object, road, tunnelbridge or not owned by us. */
2750 if (!IsValidTile(tile2) || IsTileType(tile2, TileType::House) || IsTileType(tile2, TileType::Industry) ||
2752 fences.Set(d);
2753 }
2754 }
2755
2756 switch (fences.base()) {
2757 case DiagDirections{}.base(): break;
2758 case DiagDirections{DiagDirection::NE}.base(): new_ground = RailGroundType::FenceNE; break;
2759 case DiagDirections{DiagDirection::SE}.base(): new_ground = RailGroundType::FenceSE; break;
2760 case DiagDirections{DiagDirection::SW}.base(): new_ground = RailGroundType::FenceSW; break;
2761 case DiagDirections{DiagDirection::NW}.base(): new_ground = RailGroundType::FenceNW; break;
2768 default: NOT_REACHED();
2769 }
2770 }
2771
2772set_ground:
2773 if (old_ground != new_ground) {
2774 SetRailGroundType(tile, new_ground);
2775 MarkTileDirtyByTile(tile);
2776 }
2777}
2778
2779
2782{
2783 /* Case of half tile slope with water. */
2785 TrackBits tb = GetTrackBits(tile);
2786 switch (tb.base()) {
2787 default: NOT_REACHED();
2788 case TrackBits{Track::Upper}.base(): tb = Track::Lower; break;
2789 case TrackBits{Track::Lower}.base(): tb = Track::Upper; break;
2790 case TrackBits{Track::Left}.base(): tb = Track::Right; break;
2791 case TrackBits{Track::Right}.base(): tb = Track::Left; break;
2792 }
2793 return {TrackBitsToTrackdirBits(tb), {}};
2794 }
2795
2796 if (mode != TransportType::Rail) return {};
2797
2798 TrackBits trackbits{};
2799 TrackdirBits red_signals{};
2800
2801 switch (GetRailTileType(tile)) {
2802 default: NOT_REACHED();
2804 trackbits = GetTrackBits(tile);
2805 break;
2806
2807 case RailTileType::Signals: {
2808 trackbits = GetTrackBits(tile);
2809 uint8_t a = GetPresentSignals(tile);
2810 uint b = GetSignalStates(tile);
2811
2812 b &= a;
2813
2814 /* When signals are not present (in neither direction),
2815 * we pretend them to be green. Otherwise, it depends on
2816 * the signal type. For signals that are only active from
2817 * one side, we set the missing signals explicitly to
2818 * `green'. Otherwise, they implicitly become `red'. */
2819 if (!IsOnewaySignal(tile, Track::Upper) || (a & SignalOnTrack(Track::Upper)) == 0) b |= ~a & SignalOnTrack(Track::Upper);
2820 if (!IsOnewaySignal(tile, Track::Lower) || (a & SignalOnTrack(Track::Lower)) == 0) b |= ~a & SignalOnTrack(Track::Lower);
2821
2822 if ((b & 0x8) == 0) red_signals.Set({Trackdir::Left_N, Trackdir::X_NE, Trackdir::Y_SE, Trackdir::Upper_E});
2823 if ((b & 0x4) == 0) red_signals.Set({Trackdir::Left_S, Trackdir::X_SW, Trackdir::Y_NW, Trackdir::Upper_W});
2824 if ((b & 0x2) == 0) red_signals.Set({Trackdir::Right_N, Trackdir::Lower_E});
2825 if ((b & 0x1) == 0) red_signals.Set({Trackdir::Right_S, Trackdir::Lower_W});
2826
2827 break;
2828 }
2829
2830 case RailTileType::Depot: {
2832
2833 if (side != DiagDirection::Invalid && side != dir) break;
2834
2835 trackbits = DiagDirToDiagTrack(dir);
2836 break;
2837 }
2838 }
2839
2840 return {TrackBitsToTrackdirBits(trackbits), red_signals};
2841}
2842
2844static bool ClickTile_Rail(TileIndex tile)
2845{
2846 if (!IsRailDepot(tile)) return false;
2847
2849 return true;
2850}
2851
2854{
2855 const RailTypeInfo *rti = GetRailTypeInfo(GetRailType(tile));
2856 td.rail_speed = rti->max_speed;
2857 td.railtype = rti->strings.name;
2858 td.owner[0] = GetTileOwner(tile);
2859 switch (GetRailTileType(tile)) {
2861 td.str = STR_LAI_RAIL_DESCRIPTION_TRACK;
2862 break;
2863
2864 case RailTileType::Signals: {
2866 {
2867 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_SIGNALS,
2868 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_PRESIGNALS,
2869 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_EXITSIGNALS,
2870 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_COMBOSIGNALS,
2871 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_PBSSIGNALS,
2872 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_NOENTRYSIGNALS
2873 },
2874 {
2875 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_PRESIGNALS,
2876 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRESIGNALS,
2877 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_EXITSIGNALS,
2878 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_COMBOSIGNALS,
2879 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_PBSSIGNALS,
2880 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_NOENTRYSIGNALS
2881 },
2882 {
2883 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_EXITSIGNALS,
2884 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_EXITSIGNALS,
2885 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXITSIGNALS,
2886 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXIT_COMBOSIGNALS,
2887 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXIT_PBSSIGNALS,
2888 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXIT_NOENTRYSIGNALS
2889 },
2890 {
2891 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_COMBOSIGNALS,
2892 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_COMBOSIGNALS,
2893 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXIT_COMBOSIGNALS,
2894 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_COMBOSIGNALS,
2895 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_COMBO_PBSSIGNALS,
2896 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_COMBO_NOENTRYSIGNALS
2897 },
2898 {
2899 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_PBSSIGNALS,
2900 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_PBSSIGNALS,
2901 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXIT_PBSSIGNALS,
2902 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_COMBO_PBSSIGNALS,
2903 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PBSSIGNALS,
2904 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PBS_NOENTRYSIGNALS
2905 },
2906 {
2907 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_NOENTRYSIGNALS,
2908 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_NOENTRYSIGNALS,
2909 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXIT_NOENTRYSIGNALS,
2910 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_COMBO_NOENTRYSIGNALS,
2911 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PBS_NOENTRYSIGNALS,
2912 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NOENTRYSIGNALS
2913 },
2914 }}};
2915
2916 SignalType primary_signal;
2917 SignalType secondary_signal;
2918 if (HasSignalOnTrack(tile, Track::Upper)) {
2919 primary_signal = GetSignalType(tile, Track::Upper);
2920 secondary_signal = HasSignalOnTrack(tile, Track::Lower) ? GetSignalType(tile, Track::Lower) : primary_signal;
2921 } else {
2922 secondary_signal = primary_signal = GetSignalType(tile, Track::Lower);
2923 }
2924
2925 td.str = signal_type[secondary_signal][primary_signal];
2926 break;
2927 }
2928
2930 td.str = STR_LAI_RAIL_DESCRIPTION_TRAIN_DEPOT;
2931 if (_settings_game.vehicle.train_acceleration_model != AccelerationModel::Original) {
2932 if (td.rail_speed > 0) {
2933 td.rail_speed = std::min<uint16_t>(td.rail_speed, 61);
2934 } else {
2935 td.rail_speed = 61;
2936 }
2937 }
2938 td.build_date = Depot::GetByTile(tile)->build_date;
2939 break;
2940
2941 default:
2942 NOT_REACHED();
2943 }
2944}
2945
2947static void ChangeTileOwner_Rail(TileIndex tile, Owner old_owner, Owner new_owner)
2948{
2949 if (!IsTileOwner(tile, old_owner)) return;
2950
2951 if (new_owner != INVALID_OWNER) {
2952 /* Update company infrastructure counts. No need to dirty windows here, we'll redraw the whole screen anyway. */
2953 uint num_pieces = 1;
2954 if (IsPlainRail(tile)) {
2955 TrackBits bits = GetTrackBits(tile);
2956 num_pieces = bits.Count();
2957 if (TracksOverlap(bits)) num_pieces *= num_pieces;
2958 }
2959 RailType rt = GetRailType(tile);
2960 Company::Get(old_owner)->infrastructure.rail[rt] -= num_pieces;
2961 Company::Get(new_owner)->infrastructure.rail[rt] += num_pieces;
2962
2963 if (HasSignals(tile)) {
2964 uint num_sigs = CountBits(GetPresentSignals(tile));
2965 Company::Get(old_owner)->infrastructure.signal -= num_sigs;
2966 Company::Get(new_owner)->infrastructure.signal += num_sigs;
2967 }
2968
2969 SetTileOwner(tile, new_owner);
2970 } else {
2971 Command<Commands::LandscapeClear>::Do({DoCommandFlag::Execute, DoCommandFlag::Bankrupt}, tile);
2972 }
2973}
2974
2977 {15, 8}, // NE
2978 {8, 0}, // SE
2979 {0, 8}, // SW
2980 {8, 15}, // NW
2981}}};
2982
2985 {10, 8}, // NE
2986 {8, 4}, // SE
2987 {4, 8}, // SW
2988 {8, 10}, // NW
2989}}};
2990
2996 {-1, 0}, // NE
2997 {0, 1}, // SE
2998 {1, 0}, // SW
2999 {0, -1}, // NW
3000}}};
3001
3009{
3011 int length = v->CalcNextVehicleOffset() + 1;
3012
3013 switch (dir) {
3014 case DiagDirection::NE: return (static_cast<int>(v->x_pos & TILE_UNIT_MASK) - (_fractcoords_enter[dir].x - length));
3015 case DiagDirection::SE: return -(static_cast<int>(v->y_pos & TILE_UNIT_MASK) - (_fractcoords_enter[dir].y + length));
3016 case DiagDirection::SW: return -(static_cast<int>(v->x_pos & TILE_UNIT_MASK) - (_fractcoords_enter[dir].x + length));
3017 case DiagDirection::NW: return (static_cast<int>(v->y_pos & TILE_UNIT_MASK) - (_fractcoords_enter[dir].y - length));
3018 default: NOT_REACHED();
3019 }
3020}
3021
3024{
3025 /* This routine applies only to trains in depot tiles. */
3026 if (v->type != VehicleType::Train || !IsRailDepotTile(tile)) return {};
3027
3028 /* Depot direction. */
3030
3031 Coord2D<uint8_t> fract_coord{
3032 static_cast<uint8_t>(x & TILE_UNIT_MASK),
3033 static_cast<uint8_t>(y & TILE_UNIT_MASK)};
3034
3035 /* Make sure a train is not entering the tile from behind. */
3036 if (_fractcoords_behind[dir] == fract_coord) return VehicleEnterTileState::CannotEnter;
3037
3038 /* Leaving depot? */
3039 if (v->GetMovingDirection() == DiagDirToDir(dir)) {
3040 /* Calculate the point where the following wagon should be activated. */
3041 int length = Train::From(v)->CalcNextVehicleOffset() + 1;
3042
3043 Coord2D<uint8_t> fract_coord_leave{
3044 static_cast<uint8_t>(_fractcoords_enter[dir].x + length * _deltacoord_leaveoffset[dir].x),
3045 static_cast<uint8_t>(_fractcoords_enter[dir].y + length * _deltacoord_leaveoffset[dir].y)};
3046
3047 if (fract_coord_leave == fract_coord) {
3048 /* Leave the depot. */
3049 if ((v = v->GetMovingNext()) != nullptr) {
3052 }
3053 }
3054 } else if (_fractcoords_enter[dir] == fract_coord) {
3055 /* Entering depot. */
3056 assert(DiagDirToDir(ReverseDiagDir(dir)) == v->GetMovingDirection());
3059 if (v->GetMovingNext() == nullptr) {
3060 Train *consist = Train::From(v)->First();
3062 /* Trains always drive forwards out of a depot.
3063 * This allows a player to easily reset a confused train,
3064 * and matches the behaviour of the \c VehicleRailFlag::Reversed variable. */
3066 } else {
3067 for (Train *u = consist; u != nullptr; u = u->Next()) {
3068 u->direction = ReverseDir(u->direction);
3069 }
3070 }
3071 VehicleEnterDepot(consist);
3072 }
3073 v->tile = tile;
3074
3075 InvalidateWindowData(WindowClass::VehicleDepot, v->tile);
3077 }
3078
3079 return {};
3080}
3081
3094static CommandCost TestAutoslopeOnRailTile(TileIndex tile, DoCommandFlags flags, int z_old, Slope tileh_old, int z_new, Slope tileh_new, TrackBits rail_bits)
3095{
3096 if (!_settings_game.construction.build_on_slopes || !AutoslopeEnabled()) return CommandCost(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK);
3097
3098 /* Is the slope-rail_bits combination valid in general? I.e. is it safe to call GetRailFoundation() ? */
3099 if (CheckRailSlope(tileh_new, rail_bits, {}, tile).Failed()) return CommandCost(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK);
3100
3101 /* Get the slopes on top of the foundations */
3102 z_old += ApplyFoundationToSlope(GetRailFoundation(tileh_old, rail_bits), tileh_old);
3103 z_new += ApplyFoundationToSlope(GetRailFoundation(tileh_new, rail_bits), tileh_new);
3104
3105 Corner track_corner;
3106 switch (rail_bits.base()) {
3107 case TrackBits{Track::Left}.base(): track_corner = Corner::W; break;
3108 case TrackBits{Track::Lower}.base(): track_corner = Corner::S; break;
3109 case TrackBits{Track::Right}.base(): track_corner = Corner::E; break;
3110 case TrackBits{Track::Upper}.base(): track_corner = Corner::N; break;
3111
3112 /* Surface slope must not be changed */
3113 default:
3114 if (z_old != z_new || tileh_old != tileh_new) return CommandCost(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK);
3116 }
3117
3118 /* The height of the track_corner must not be changed. The rest ensures GetRailFoundation() already. */
3119 z_old += GetSlopeZInCorner(RemoveHalftileSlope(tileh_old), track_corner);
3120 z_new += GetSlopeZInCorner(RemoveHalftileSlope(tileh_new), track_corner);
3121 if (z_old != z_new) return CommandCost(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK);
3122
3124 /* Make the ground dirty, if surface slope has changed */
3125 if (tileh_old != tileh_new) {
3126 /* If there is flat water on the lower halftile add the cost for clearing it */
3129 }
3130 return cost;
3131}
3132
3134static CommandCost TerraformTile_Rail(TileIndex tile, DoCommandFlags flags, int z_new, Slope tileh_new)
3135{
3136 auto [tileh_old, z_old] = GetTileSlopeZ(tile);
3137 if (IsPlainRail(tile)) {
3138 TrackBits rail_bits = GetTrackBits(tile);
3139 /* Is there flat water on the lower halftile that must be cleared expensively? */
3140 bool was_water = (GetRailGroundType(tile) == RailGroundType::HalfTileWater && IsSlopeWithOneCornerRaised(tileh_old));
3141
3142 /* Allow clearing the water only if there is no ship */
3143 if (was_water && HasVehicleOnTile(tile, [](const Vehicle *v) {
3144 return v->type == VehicleType::Ship;
3145 })) return CommandCost(STR_ERROR_SHIP_IN_THE_WAY);
3146
3147 /* First test autoslope. However if it succeeds we still have to test the rest, because non-autoslope terraforming is cheaper. */
3148 CommandCost autoslope_result = TestAutoslopeOnRailTile(tile, flags, z_old, tileh_old, z_new, tileh_new, rail_bits);
3149
3150 /* When there is only a single horizontal/vertical track, one corner can be terraformed. */
3151 Corner allowed_corner;
3152 switch (rail_bits.base()) {
3153 case TrackBits{Track::Right}.base(): allowed_corner = Corner::W; break;
3154 case TrackBits{Track::Upper}.base(): allowed_corner = Corner::S; break;
3155 case TrackBits{Track::Left}.base(): allowed_corner = Corner::E; break;
3156 case TrackBits{Track::Lower}.base(): allowed_corner = Corner::N; break;
3157 default: return autoslope_result;
3158 }
3159
3160 Foundation f_old = GetRailFoundation(tileh_old, rail_bits);
3161
3162 /* Do not allow terraforming if allowed_corner is part of anti-zig-zag foundations */
3163 if (tileh_old != SLOPE_NS && tileh_old != SLOPE_EW && IsSpecialRailFoundation(f_old)) return autoslope_result;
3164
3165 /* Everything is valid, which only changes allowed_corner */
3166 for (Corner corner : EnumRange(Corner::End)) {
3167 if (allowed_corner == corner) continue;
3168 if (z_old + GetSlopeZInCorner(tileh_old, corner) != z_new + GetSlopeZInCorner(tileh_new, corner)) return autoslope_result;
3169 }
3170
3171 /* Make the ground dirty */
3173
3174 /* allow terraforming */
3175 return CommandCost(ExpensesType::Construction, was_water ? _price[Price::ClearWater] : Money{});
3176 } else if (_settings_game.construction.build_on_slopes && AutoslopeEnabled() &&
3177 AutoslopeCheckForEntranceEdge(tile, z_new, tileh_new, GetRailDepotDirection(tile))) {
3179 }
3180 return Command<Commands::LandscapeClear>::Do(flags, tile);
3181}
3182
3184static CommandCost CheckBuildAbove_Rail(TileIndex tile, [[maybe_unused]] DoCommandFlags flags, [[maybe_unused]] Axis axis, int height)
3185{
3186 if (IsPlainRail(tile)) return CommandCost();
3187
3188 int height_diff = GetTileMaxZ(tile) + MINIMAL_DEPOT_BRIDGE_HEIGHT - height;
3189 if (height_diff <= 0) return CommandCost();
3190 return CommandCostWithParam(STR_ERROR_BRIDGE_TOO_LOW_FOR_TRAIN_DEPOT, height_diff * TILE_HEIGHT_STEP);
3191}
3192
3194extern const TileTypeProcs _tile_type_rail_procs = {
3195 .draw_tile_proc = DrawTile_Rail,
3196 .get_slope_pixel_z_proc = GetSlopePixelZ_Rail,
3197 .clear_tile_proc = ClearTile_Rail,
3198 .get_tile_desc_proc = GetTileDesc_Rail,
3199 .get_tile_track_status_proc = GetTileTrackStatus_Rail,
3200 .click_tile_proc = ClickTile_Rail,
3201 .tile_loop_proc = TileLoop_Rail,
3202 .change_tile_owner_proc = ChangeTileOwner_Rail,
3203 .vehicle_enter_tile_proc = VehicleEnterTile_Rail,
3204 .get_foundation_proc = GetFoundation_Rail,
3205 .terraform_tile_proc = TerraformTile_Rail,
3206 .check_build_above_proc = CheckBuildAbove_Rail,
3207};
@ None
Tile is not animated.
Functions related to autoslope.
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
bool AutoslopeEnabled()
Tests if autoslope is enabled for _current_company.
Definition autoslope.h:65
Class for backupping variables and making sure they are restored later.
@ DrivingBackwards
Vehicle is driving backwards.
constexpr T SetBit(T &x, const uint8_t y)
Set a bit in a variable.
constexpr uint CountBits(T value)
Counts the number of set bits in a variable.
constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
constexpr T KillFirstBit(T value)
Clear the first bit in an integer.
Header file for bridges.
void DrawBridgeMiddle(const TileInfo *ti, BridgePillarFlags blocked_pillars)
Draw the middle bits of a bridge.
TileIndex GetSouthernBridgeEnd(TileIndex t)
Finds the southern end of a bridge starting at a middle tile.
int GetBridgeHeight(TileIndex t)
Get the height ('z') of a bridge.
bool IsBridgeAbove(Tile t)
checks if a bridge is set above the ground of this tile
Definition bridge_map.h:45
bool IsBridge(Tile t)
Checks if this is a bridge, instead of a tunnel.
Definition bridge_map.h:24
EnumBitSet< BridgePillarFlag, uint8_t > BridgePillarFlags
Bitset of BridgePillarFlag elements.
Definition bridge_type.h:53
@ EdgeNE
Northeast edge is obstructed.
Definition bridge_type.h:46
@ EdgeSW
Southwest edge is obstructed.
Definition bridge_type.h:48
@ EdgeNW
Northwest edge is obstructed.
Definition bridge_type.h:49
@ EdgeSE
Southeast edge is obstructed.
Definition bridge_type.h:47
uint Count() const
Count the number of set bits.
constexpr bool Test(Tvalue_type value) const
Test if the value-th bit is set.
constexpr Tstorage base() const noexcept
Retrieve the raw value behind this bit set.
constexpr bool None() const
Test if none of the values are set.
constexpr Timpl & Flip()
Flip all bits.
constexpr Timpl & Reset()
Reset all bits.
constexpr Timpl & Set()
Set all bits.
constexpr bool Any(const Timpl &other) const
Test if any of the given values are set.
Common return value for all commands.
bool Succeeded() const
Did this command succeed?
void AddCost(const Money &cost)
Adds the given cost to the cost of the command.
void MakeError(StringID message)
Makes this CommandCost behave like an error command.
Money GetCost() const
The costs as made up to this moment.
bool Failed() const
Did this command fail?
StringID GetErrorMessage() const
Returns the error message of a command.
Iterate a range of enum values.
This struct contains all the info that is needed to draw and construct tracks.
Definition rail.h:134
RailType Index() const
Get the RailType for this RailTypeInfo.
Definition rail.cpp:26
SpriteID single_x
single piece of rail in X direction, without ground
Definition rail.h:144
uint16_t max_speed
Maximum speed for vehicles travelling on this rail type.
Definition rail.h:239
SpriteID build_tunnel
button for building a tunnel
Definition rail.h:167
CursorID rail_swne
Cursor for building rail in X direction.
Definition rail.h:174
SpriteID convert_rail
button for converting rail
Definition rail.h:168
struct RailTypeInfo::@157247141350136173143103254227157213063052244122 strings
Strings associated with the rail type.
CursorID convert
Cursor for converting track.
Definition rail.h:180
CursorID depot
Cursor for building a depot.
Definition rail.h:178
RailTypes powered_railtypes
bitmask to the OTHER railtypes on which an engine of THIS railtype generates power
Definition rail.h:196
RailTypes introduces_railtypes
Bitmask of which other railtypes are introduced when this railtype is introduced.
Definition rail.h:274
SpriteID ground
ground sprite for a 3-way switch
Definition rail.h:143
CursorID rail_nwse
Cursor for building rail in Y direction.
Definition rail.h:176
SpriteID build_x_rail
button for building single rail in X direction
Definition rail.h:162
uint8_t sorting_order
The sorting order of this railtype for the toolbar dropdown.
Definition rail.h:279
RailTypeLabel label
Unique 32 bit rail type identifier.
Definition rail.h:244
SpriteID single_n
single piece of rail in the northern corner
Definition rail.h:146
CursorID rail_ew
Cursor for building rail in E-W direction.
Definition rail.h:175
SpriteID auto_rail
button for the autorail construction
Definition rail.h:165
CursorID autorail
Cursor for autorail tool.
Definition rail.h:177
SpriteID single_y
single piece of rail in Y direction, without ground
Definition rail.h:145
StringID name
Name of this rail type.
Definition rail.h:184
RailTypes compatible_railtypes
bitmask to the OTHER railtypes on which an engine of THIS railtype can physically travel
Definition rail.h:199
uint GetRailtypeSpriteOffset() const
Offset between the current railtype and normal rail.
Definition rail.h:306
struct RailTypeInfo::@047376261311064105134233254254216006075341230376 gui_sprites
struct containing the sprites for the rail GUI.
SpriteID single_s
single piece of rail in the southern corner
Definition rail.h:147
RailTypeFlags flags
Bit mask of rail type flags.
Definition rail.h:219
SpriteID build_ew_rail
button for building single rail in E-W direction
Definition rail.h:163
SpriteID build_y_rail
button for building single rail in Y direction
Definition rail.h:164
FlatSet< RailTypeLabel > alternate_labels
Rail type labels this type provides in addition to the main label.
Definition rail.h:249
EnumIndexArray< EnumIndexArray< EnumIndexArray< SpriteID, SignalState, SignalState::End >, SignalVariant, SignalVariant::End >, SignalType, SignalType::End > signals
signal GUI sprites (type, variant, state)
Definition rail.h:169
SpriteID track_ns
two pieces of rail in North and South corner (East-West direction)
Definition rail.h:142
struct RailTypeInfo::@332027037331076264023214171276243307073252216167 base_sprites
Struct containing the main sprites.
SpriteID snow_offset
sprite number difference between a piece of track on a snowy ground and the corresponding one on norm...
Definition rail.h:193
SpriteID track_y
single piece of rail in Y direction, with ground
Definition rail.h:141
SpriteID build_depot
button for building depots
Definition rail.h:166
SpriteID single_w
single piece of rail in the western corner
Definition rail.h:149
SpriteID single_e
single piece of rail in the eastern corner
Definition rail.h:148
SpriteID build_ns_rail
button for building single rail in N-S direction
Definition rail.h:161
CursorID rail_ns
Cursor for building rail in N-S direction.
Definition rail.h:173
SpriteID tunnel
tunnel sprites base
Definition rail.h:152
SpriteID single_sloped
single piece of rail for slopes
Definition rail.h:150
struct RailTypeInfo::@057010233226120022371265166156055202241326366156 cursor
Cursors associated with the rail type.
Iterate over all vehicles on a tile.
CommandCost CommandCostWithParam(StringID str, uint64_t value)
Return an error status, with string and parameter.
Definition command.cpp:415
Functions related to commands.
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
@ Auto
don't allow building on structures
@ Execute
execute the given command
@ Bankrupt
company bankrupts, skip money check, skip vehicle on tile check in some cases
EnumBitSet< DoCommandFlag, uint16_t > DoCommandFlags
Bitset of DoCommandFlag elements.
Definition of stuff that is very close to a company, like the company struct itself.
CommandCost CheckTileOwnership(TileIndex tile)
Check whether the current owner owns the stuff on the given tile.
PaletteID GetCompanyPalette(CompanyID company)
Get the palette for recolouring with a company colour.
CommandCost CheckOwnership(Owner owner, TileIndex tile)
Check whether the current owner owns something.
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
CompanyID _current_company
Company currently doing an action.
void DirtyCompanyInfrastructureWindows(CompanyID company)
Redraw all windows with company infrastructure counts.
GUI Functions related to companies.
static constexpr Owner OWNER_DEITY
The object is owned by a superuser / goal script.
static constexpr Owner INVALID_OWNER
An invalid owner.
static constexpr Owner OWNER_WATER
The tile/execution is done by "water".
Some simple functions to help with accessing containers.
bool include(Container &container, typename Container::const_reference &item)
Helper function to append an item to a container if it is not already contained.
Base for all depots (except hangars).
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
void ShowDepotWindow(TileIndex tile, VehicleType type)
Opens a depot window.
static constexpr uint8_t MINIMAL_DEPOT_BRIDGE_HEIGHT
Minimal height for a bridge above any depot tile.
Definition depot_type.h:21
Direction DiagDirToDir(DiagDirection dir)
Convert a DiagDirection to a Direction.
DiagDirection ReverseDiagDir(DiagDirection d)
Returns the reverse direction of the given DiagDirection.
Direction ReverseDir(Direction d)
Return the reverse of a direction.
bool IsValidDiagDirection(DiagDirection d)
Checks if an integer value is a valid DiagDirection.
Axis DiagDirToAxis(DiagDirection d)
Convert a DiagDirection to the axis.
EnumIndexArray< T, DiagDirection, DiagDirection::End > DiagDirectionIndexArray
Array with DiagDirection as index.
Axis
Enumeration for the two axis X and Y.
@ X
The X axis.
@ Y
The y axis.
DiagDirection
Enumeration for diagonal directions.
@ Invalid
Flag for an invalid DiagDirection.
@ SW
Southwest.
@ NW
Northwest.
@ End
Used for iterations.
@ NE
Northeast, upper right on your monitor.
@ SE
Southeast.
EnumBitSet< DiagDirection, uint8_t > DiagDirections
Bitset of DiagDirection elements.
Prices _price
Prices and also the fractional part.
Definition economy.cpp:109
static const uint LEVELCROSSING_TRACKBIT_FACTOR
Multiplier for how many regular track bits a level crossing counts.
@ Construction
Construction costs.
static const uint TUNNELBRIDGE_TRACKBIT_FACTOR
Multiplier for how many regular track bits a tunnel/bridge counts.
@ ClearRough
Price for destroying rough land.
@ BuildSignals
Price for building rail signals.
@ BuildFoundation
Price for building foundation under other constructions e.g. roads, rails, depots,...
@ ClearWater
Price for destroying water e.g. see, rives.
@ ClearSignals
Price for destroying rail signals.
@ ClearDepotTrain
Price for destroying train depots.
@ BuildDepotTrain
Price for building train depots.
void DrawRailCatenary(const TileInfo *ti)
Draws overhead wires and pylons for electric railways.
Definition elrail.cpp:554
Header file for electrified rail specific functions.
bool HasRailCatenaryDrawn(RailType rt)
Test if we should draw rail catenary.
Definition elrail_func.h:32
constexpr std::underlying_type_t< enum_type > to_underlying(enum_type e)
Implementation of std::to_underlying (from C++23).
Definition enum_type.hpp:21
EnumClassIndexContainer< std::array< T, to_underlying(N)>, Index > EnumIndexArray
A typedef for EnumClassIndexContainer using std::array as the backing container type.
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:1032
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition gfx_type.h:17
uint32_t PaletteID
The number of the palette.
Definition gfx_type.h:18
uint8_t GetSnowLine()
Get the current snow line, either variable or static.
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
static const SpriteID SPR_RAIL_DEPOT_SE_1
Definition sprites.h:457
static const SpriteID SPR_ORIGINAL_SIGNALS_BASE
Sprite number of the first block sginall.
Definition sprites.h:440
static const SpriteID SPR_TRACK_FENCE_FLAT_X
Definition sprites.h:519
uint GetPartialPixelZ(int x, int y, Slope corners)
Determines height at given coordinate of a slope.
void DrawFoundation(TileInfo *ti, Foundation f)
Draw foundation f at tile ti.
int GetSlopeZInCorner(Slope tileh, Corner corner)
Determine the Z height of a corner relative to TileZ.
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, RoadTramType sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
const TileTypeProcs _tile_type_rail_procs
TileTypeProcs definitions for TileType::Rail tiles.
Definition landscape.cpp:55
uint ApplyFoundationToSlope(Foundation f, Slope &s)
Applies a foundation to a slope.
int GetSlopePixelZ(int x, int y, bool ground_vehicle)
Return world Z coordinate of a given point of a tile.
uint ApplyPixelFoundationToSlope(Foundation f, Slope &s)
Applies a foundation to a slope.
Definition landscape.h:128
int GetSlopePixelZInCorner(Slope tileh, Corner corner)
Determine the Z height of a corner relative to TileZ.
Definition landscape.h:55
Command definitions related to landscape (slopes etc.).
@ Arctic
Landscape with snow levels.
@ Tropic
Landscape with distinct rainforests and deserts,.
#define Point
Macro that prevents name conflicts between included headers.
TileIndex AddTileIndexDiffCWrap(TileIndex tile, TileIndexDiffC diff)
Add a TileIndexDiffC to a TileIndex and returns the new one.
Definition map_func.h:519
TileIndexDiff ToTileIndexDiff(TileIndexDiffC tidc)
Return the offset between two tiles from a TileIndexDiffC struct.
Definition map_func.h:444
TileIndex TileAddByDiagDir(TileIndex tile, DiagDirection dir)
Adds a DiagDir to a tile.
Definition map_func.h:615
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition map_func.h:429
static uint TileX(TileIndex tile)
Get the X component of a tile.
Definition map_func.h:419
TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Definition map_func.h:574
constexpr T abs(const T a)
Returns the absolute value of (scalar) variable.
Definition math_func.hpp:23
@ First
The first client ID.
@ RailTypes
Rail types feature.
Definition newgrf.h:98
@ UpperHalftile
Querying information about the upper part of a tile with halftile foundation.
@ Normal
Nothing special.
@ Any
Use first found.
Functions/types related to NewGRF debugging.
void DeleteNewGRFInspectWindow(GrfSpecFeature feature, uint index)
Delete inspect window for a given feature and index.
SpriteID GetCustomSignalSprite(const RailTypeInfo *rti, TileIndex tile, SignalType type, SignalVariant var, SignalState state, bool gui)
Get the sprite to draw for a given signal.
SpriteID GetCustomRailSprite(const RailTypeInfo *rti, TileIndex tile, RailSpriteType rtsg, TileContext context, uint *num_results)
Get the sprite to draw for the given tile.
NewGRF handling of rail types.
Map accessors for object tiles.
bool IsObjectType(Tile t, ObjectType type)
Check whether the object on a tile is of a specific type.
Definition object_map.h:25
static const ObjectType OBJECT_OWNED_LAND
Owned land 'flag'.
Definition object_type.h:21
@ FullDetail
Also draw details of track and roads.
Definition openttd.h:50
@ Menu
In the main menu.
Definition openttd.h:19
Train * GetTrainForReservation(TileIndex tile, Track track)
Find the train which has reserved a specific path.
Definition pbs.cpp:345
TrackBits GetReservedTrackbits(TileIndex t)
Get the reserved trackbits for any tile, regardless of type.
Definition pbs.cpp:24
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:395
PBS support routines.
bool HasReservedTracks(TileIndex tile, TrackBits tracks)
Check whether some of tracks is reserved on a tile.
Definition pbs.h:58
bool ValParamRailType(const RailType rail)
Validate functions for rail building.
Definition rail.cpp:92
Money RailConvertCost(RailType from, RailType to)
Calculates the cost of rail conversion.
Definition rail.h:476
@ Ground
Main group of ground images.
Definition rail.h:45
@ GroundComplete
Complete ground images.
Definition rail.h:55
@ Overlay
Images for overlaying track.
Definition rail.h:44
@ UI
Cursor and toolbar icon images.
Definition rail.h:43
@ Depot
Depot images.
Definition rail.h:51
@ Fences
Fence images.
Definition rail.h:52
Money RailClearCost(RailType railtype)
Returns the 'cost' of clearing the specified railtype.
Definition rail.h:459
Money RailBuildCost(RailType railtype)
Returns the cost of building the specified railtype.
Definition rail.h:448
std::vector< RailType > _sorted_railtypes
Sorted list of rail types.
Definition rail_cmd.cpp:46
RailFenceOffset
Offsets from base sprite for fence sprites.
Definition rail.h:111
@ SlopeNENW
Slope NE, Track X, Fence NW.
Definition rail.h:118
@ SlopeNESE
Slope NE, Track X, Fence SE.
Definition rail.h:126
@ SlopeSWNW
Slope SW, Track X, Fence NW.
Definition rail.h:116
@ FlatRight
Slope FLAT, Track RIGHT, Fence W.
Definition rail.h:122
@ FlatXSE
Slope FLAT, Track X, Fence SE.
Definition rail.h:120
@ FlatXNW
Slope FLAT, Track X, Fence NW.
Definition rail.h:112
@ SlopeSESW
Slope SE, Track Y, Fence SW.
Definition rail.h:125
@ SlopeNWNE
Slope NW, Track Y, Fence NE.
Definition rail.h:119
@ SlopeSWSE
Slope SW, Track X, Fence SE.
Definition rail.h:124
@ FlatUpper
Slope FLAT, Track UPPER, Fence S.
Definition rail.h:115
@ FlatYNE
Slope FLAT, Track Y, Fence NE.
Definition rail.h:113
@ FlatYSW
Slope FLAT, Track Y, Fence SW.
Definition rail.h:121
@ FlatLeft
Slope FLAT, Track LEFT, Fence E.
Definition rail.h:114
@ SlopeNWSW
Slope NW, Track Y, Fence SW.
Definition rail.h:127
@ SlopeSENE
Slope SE, Track Y, Fence NE.
Definition rail.h:117
@ FlatLower
Slope FLAT, Track LOWER, Fence N.
Definition rail.h:123
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:371
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:396
const RailTypeInfo * GetRailTypeInfo(RailType railtype)
Returns a pointer to the Railtype information for a given railtype.
Definition rail.h:320
@ Hidden
Bit number for hiding from selection.
Definition rail.h:30
@ NoSpriteCombine
Bit number for using non-combined junctions.
Definition rail.h:31
@ X
Piece of rail in X direction.
Definition rail.h:64
@ JunctionNW
Ballast for junction 'pointing' NW.
Definition rail.h:78
@ E
Piece of rail in eastern corner.
Definition rail.h:68
@ JunctionSW
Ballast for junction 'pointing' SW.
Definition rail.h:75
@ Y
Piece of rail in Y direction.
Definition rail.h:65
@ S
Piece of rail in southern corner.
Definition rail.h:67
@ W
Piece of rail in western corner.
Definition rail.h:69
@ JunctionSE
Ballast for junction 'pointing' SE.
Definition rail.h:77
@ N
Piece of rail in northern corner.
Definition rail.h:66
@ SlopeSE
Piece of rail on slope with south-east raised.
Definition rail.h:71
@ SlopeSW
Piece of rail on slope with south-west raised.
Definition rail.h:72
@ SlopeNE
Piece of rail on slope with north-east raised.
Definition rail.h:70
@ JunctionNSEW
Ballast for full junction.
Definition rail.h:79
@ CrossingXY
Crossing of X and Y rail, with ballast.
Definition rail.h:74
@ JunctionNE
Ballast for junction 'pointing' NE.
Definition rail.h:76
@ SlopeNW
Piece of rail on slope with north-west raised.
Definition rail.h:73
bool RailNoLevelCrossings(RailType rt)
Test if a RailType disallows build of level crossings.
Definition rail.h:418
CommandCost CmdRemoveSignalTrack(DoCommandFlags flags, TileIndex tile, TileIndex end_tile, Track track, bool autofill)
Remove signals on a stretch of track.
int TicksToLeaveDepot(const Train *v)
Compute number of ticks when next wagon will leave a depot.
static bool IsTrainSignalSideRight()
Helper to determine whether the train signals are to be placed on the right side.
static CommandCost CheckTrackCombination(TileIndex tile, TrackBits to_build)
Check that the new track bits may be built.
Definition rail_cmd.cpp:240
void DrawTrainDepotSprite(int x, int y, DiagDirection dir, RailType railtype)
Draw train depot sprite in the UI.
static CommandCost CmdRailTrackHelper(DoCommandFlags 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:885
static Trackdir GetOtherTrackdir(Trackdir trackdir)
Get the other Trackdir for a non-diagonal Trackdir.
Definition rail_cmd.cpp:821
static const int INF
Big number compared to tilesprite size.
CommandCost CmdBuildTrainDepot(DoCommandFlags flags, TileIndex tile, RailType railtype, DiagDirection dir)
Build a train depot.
Definition rail_cmd.cpp:970
static void DrawTile_Rail(TileInfo *ti)
Tile callback function signature for drawing a tile and its contents to the screen.
CommandCost CmdBuildSingleSignal(DoCommandFlags 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, uint8_t signals_copy)
Build signals, alternate between double/single, signal/semaphore, pre/exit/combo-signals,...
CommandCost CmdBuildRailroadTrack(DoCommandFlags 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
CommandCost CmdBuildSignalTrack(DoCommandFlags flags, TileIndex tile, TileIndex end_tile, Track track, SignalType sigtype, SignalVariant sigvar, bool mode, bool autofill, bool minimise_gaps, uint8_t signal_density)
Build signals on a stretch of track.
static CommandCost ClearTile_Rail(TileIndex tile, DoCommandFlags flags)
Tile callback function signature for clearing a tile.
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:760
RailType AllocateRailType(RailTypeLabel label)
Allocate a new rail type label.
Definition rail_cmd.cpp:149
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:391
CommandCost CmdRemoveSingleRail(DoCommandFlags flags, TileIndex tile, Track track)
Remove a single piece of track.
Definition rail_cmd.cpp:614
static constexpr EnumIndexArray< FenceOffset, RailFenceOffset, RailFenceOffset::End > fence_offsets
Offsets for drawing fences.
CommandCost CmdRemoveSingleSignal(DoCommandFlags flags, TileIndex tile, Track track)
Remove signals.
static constexpr NonSteepSlopeIndexArray< uint8_t > _track_sloped_sprites
Lookup table to convert tile's slope into corresponding track sprite offset.
Definition rail_cmd.cpp:181
static uint GetSafeSlopeZ(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.
static CommandCost EnsureNoTrainOnTrack(TileIndex tile, Track track)
Tests if a vehicle interacts with the specified track.
Definition rail_cmd.cpp:229
static constexpr DiagDirectionIndexArray< Coord2D< uint8_t > > _fractcoords_enter
Coordinates where a train should enter a depot for each depot direction.
static CommandCost CmdSignalTrackHelper(DoCommandFlags 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.
static int GetSlopePixelZ_Rail(TileIndex tile, uint x, uint y, bool ground_vehicle)
Tile callback function signature for obtaining the world Z coordinate of a given point of a tile.
static void DrawTrackBits(TileInfo *ti, TrackBits track)
Draw ground sprite and track bits.
static void DrawTrackDetails(const TileInfo *ti, const RailTypeInfo *rti, PaletteID pal)
Draw track fences.
SignalOffsets
Enum holding the signal offset in the sprite sheet according to the side it is representing.
Definition rail_cmd.cpp:50
CommandCost CmdRemoveRailroadTrack(DoCommandFlags flags, TileIndex end_tile, TileIndex start_tile, Track track)
Build rail on a stretch of track.
Definition rail_cmd.cpp:957
static VehicleEnterTileStates VehicleEnterTile_Rail(Vehicle *v, TileIndex tile, int x, int y)
Tile callback function for a vehicle entering a tile.
CommandCost CmdBuildSingleRail(DoCommandFlags flags, TileIndex tile, RailType railtype, Track track, bool auto_remove_signals)
Build a single piece of rail.
Definition rail_cmd.cpp:425
static constexpr DiagDirectionIndexArray< Coord2D< uint8_t > > _fractcoords_behind
Coordinates to detect when a train is approaching a depot from behind for each depot direction.
CommandCost CmdConvertRail(DoCommandFlags flags, TileIndex tile, TileIndex area_start, RailType totype, bool diagonal)
Convert one rail type to the other.
void InitRailTypes()
Resolve sprites of custom rail types.
Definition rail_cmd.cpp:129
static TrackStatus GetTileTrackStatus_Rail(TileIndex tile, TransportType mode, RoadTramType sub_mode, DiagDirection side)
Tile callback function signature for getting the possible tracks that can be taken on a given tile by...
static void ChangeTileOwner_Rail(TileIndex tile, Owner old_owner, Owner new_owner)
Tile callback function signature for changing the owner of a tile.
static void DrawTrackFence_SW(const TileInfo *ti, const PalSpriteID &psid, uint num_sprites)
Draw fence at SW border matching the tile slope.
static bool ClickTile_Rail(TileIndex tile)
Tile callback function signature for clicking a tile.
static void GetTileDesc_Rail(TileIndex tile, TileDesc &td)
Tile callback function signature for obtaining a tile description.
void ResetRailTypes()
Reset all rail type information to its default values.
Definition rail_cmd.cpp:64
static const TrackdirIndexArray< TileIndexDiffC > _trackdelta
Tile deltas for each trackdir.
Definition rail_cmd.cpp:806
static CommandCost TestAutoslopeOnRailTile(TileIndex tile, DoCommandFlags flags, int z_old, Slope tileh_old, int z_new, Slope tileh_new, TrackBits rail_bits)
Tests if autoslope is allowed.
static constexpr CornerIndexArray< SubSprite > _halftile_sub_sprite
SubSprite for drawing the track halftile of 'three-corners-raised'-sloped rail sprites.
static constexpr NonSteepSlopeIndexArray< TrackBits > _valid_tracks_without_foundation
Valid TrackBits on a specific (non-steep)-slope without foundation.
Definition rail_cmd.cpp:261
static int GetJunctionGroundSpriteOffset(TrackBits track)
Returns which of the 5 junction-'Rail underlays' to use for the given track bits.
static constexpr NonSteepSlopeIndexArray< TrackBits > _valid_tracks_on_leveled_foundation
Valid TrackBits on a specific (non-steep)-slope with leveled foundation.
Definition rail_cmd.cpp:283
static bool CompareRailTypes(const RailType &first, const RailType &second)
Compare railtypes based on their sorting order.
Definition rail_cmd.cpp:121
static Foundation GetFoundation_Rail(TileIndex tile, Slope tileh)
Tile callback function signature for getting the foundation of a tile.
static constexpr DiagDirectionIndexArray< Coord2D< int8_t > > _deltacoord_leaveoffset
Offsets (to be multiplied by length) from the depot enter coordinates where a train should appear whe...
static void DrawTrackFence_NW(const TileInfo *ti, const PalSpriteID &psid, uint num_sprites)
Draw fence at NW border matching the tile slope.
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:311
static void DrawTrackFence_NE(const TileInfo *ti, const PalSpriteID &psid, uint num_sprites)
Draw fence at NE border matching the tile slope.
static void DrawTrackFence_SE(const TileInfo *ti, const PalSpriteID &psid, uint num_sprites)
Draw fence at SE border matching the tile slope.
static CommandCost CheckBuildAbove_Rail(TileIndex tile, DoCommandFlags flags, Axis axis, int height)
Tile callback function signature to test if a bridge can be built above a tile.
std::vector< Train * > TrainList
Helper type for lists/vectors of trains.
Definition rail_cmd.cpp:43
static void TileLoop_Rail(TileIndex tile)
Tile callback function signature for running periodic tile updates.
static CommandCost TerraformTile_Rail(TileIndex tile, DoCommandFlags flags, int z_new, Slope tileh_new)
Tile callback function signature of the terraforming callback.
static void DrawTrackFence(const TileInfo *ti, const PalSpriteID &psid, uint num_sprites, RailFenceOffset rfo)
Draw a track fence.
Command definitions for rail.
static RailTileType GetRailTileType(Tile t)
Returns the RailTileType (normal with or without signals, waypoint or depot).
Definition rail_map.h:36
static bool IsPlainRail(Tile t)
Returns whether this is plain rails, with or without signals.
Definition rail_map.h:49
uint GetSignalStates(Tile tile)
Set the states of the signals (Along/AgainstTrackDir).
Definition rail_map.h:420
void MakeRailDepot(Tile tile, Owner owner, DepotID depot_id, DiagDirection dir, RailType rail_type)
Make a rail depot.
Definition rail_map.h:657
RailType GetRailType(Tile t)
Gets the rail type of the given tile.
Definition rail_map.h:115
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:490
static bool IsRailDepot(Tile t)
Is this rail tile a rail depot?
Definition rail_map.h:95
SignalVariant GetSignalVariant(Tile t, Track track)
Get the signal variant for a track on a tile.
Definition rail_map.h:385
RailGroundType GetRailGroundType(Tile t)
Get the ground type for rail tiles.
Definition rail_map.h:601
TrackBits GetTrackBits(Tile tile)
Gets the track bits of the given tile.
Definition rail_map.h:136
static bool IsPlainRailTile(Tile t)
Checks whether the tile is a rail tile or rail tile with signals.
Definition rail_map.h:60
bool IsPbsSignal(SignalType s)
Checks whether the given signal is a path based signal.
Definition rail_map.h:291
void CycleSignalSide(Tile t, Track track)
Cycle to the next signal side at the given track on a tile.
Definition rail_map.h:368
void MakeRailNormal(Tile t, Owner o, TrackBits b, RailType r)
Make the given tile a normal rail.
Definition rail_map.h:624
@ Normal
Normal rail tile without signals.
Definition rail_map.h:24
@ Depot
Depot (one entrance).
Definition rail_map.h:26
@ Signals
Normal rail tile with signals.
Definition rail_map.h:25
Track GetRailDepotTrack(Tile t)
Returns the track of a depot, ignoring direction.
Definition rail_map.h:182
void SetTrackReservation(Tile t, TrackBits b)
Sets the reserved track bits of the tile.
Definition rail_map.h:209
bool IsSignalPresent(Tile t, uint8_t signalbit)
Checks whether the given signals is present.
Definition rail_map.h:462
DiagDirection GetRailDepotDirection(Tile t)
Returns the direction the depot is facing to.
Definition rail_map.h:171
void SetTrackBits(Tile t, TrackBits b)
Sets the track bits of the given tile.
Definition rail_map.h:147
RailGroundType
The ground 'under' the rail.
Definition rail_map.h:568
@ FenceSENW
Grass with a fence at the NW and SE edges.
Definition rail_map.h:573
@ FenceVert2
Grass with a fence at the western side.
Definition rail_map.h:578
@ HalfTileSnow
Snow only on higher part of slope (steep or one corner raised).
Definition rail_map.h:583
@ Barren
Nothing (dirt).
Definition rail_map.h:569
@ FenceNESW
Grass with a fence at the NE and SW edges.
Definition rail_map.h:576
@ FenceHoriz2
Grass with a fence at the northern side.
Definition rail_map.h:580
@ SnowOrDesert
Icy or sandy.
Definition rail_map.h:581
@ HalfTileWater
Grass with a fence and shore or water on the free halftile.
Definition rail_map.h:582
@ FenceVert1
Grass with a fence at the eastern side.
Definition rail_map.h:577
@ FenceNW
Grass with a fence at the NW edge.
Definition rail_map.h:571
@ FenceSE
Grass with a fence at the SE edge.
Definition rail_map.h:572
@ FenceNE
Grass with a fence at the NE edge.
Definition rail_map.h:574
@ Grass
Grassy.
Definition rail_map.h:570
@ FenceSW
Grass with a fence at the SW edge.
Definition rail_map.h:575
@ FenceHoriz1
Grass with a fence at the southern side.
Definition rail_map.h:579
uint GetPresentSignals(Tile tile)
Get whether the given signals are present (Along/AgainstTrackDir).
Definition rail_map.h:451
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:474
bool IsOnewaySignal(Tile t, Track track)
Is the signal at the given track on a tile a one way signal?
Definition rail_map.h:357
void SetPresentSignals(Tile tile, uint signals)
Set whether the given signals are present (Along/AgainstTrackDir).
Definition rail_map.h:441
void SetRailGroundType(Tile t, RailGroundType rgt)
Set the ground type for rail tiles.
Definition rail_map.h:591
void SetRailDepotExitDirection(Tile tile, DiagDirection dir)
Sets the exit direction of a rail depot.
Definition rail_map.h:643
SignalType GetSignalType(Tile t, Track track)
Get the signal type for a track on a tile.
Definition rail_map.h:303
void SetDepotReservation(Tile t, bool b)
Set the reservation state of the depot.
Definition rail_map.h:268
TrackBits GetRailReservationTrackBits(Tile t)
Returns the reserved track bits of the tile.
Definition rail_map.h:194
void SetSignalType(Tile t, Track track, SignalType s)
Set the signal type for a track on a tile.
Definition rail_map.h:317
bool HasDepotReservation(Tile t)
Get the reservation state of the depot.
Definition rail_map.h:256
void SetHasSignals(Tile tile, bool signals)
Add/remove the 'has signal' bit from the RailTileType.
Definition rail_map.h:83
bool IsSnowOrDesertRailGround(Tile t)
Is the given rail tile snowy or deserty.
Definition rail_map.h:611
bool HasSignals(Tile t)
Checks if a rail tile has signals.
Definition rail_map.h:72
void SetSignalVariant(Tile t, Track track, SignalVariant v)
Set the signal variant for a track on a tile.
Definition rail_map.h:398
static bool IsRailDepotTile(Tile t)
Is this tile rail tile and a rail depot?
Definition rail_map.h:105
bool HasTrack(Tile tile, Track track)
Returns whether the given track is present on the given tile.
Definition rail_map.h:160
SignalState GetSingleSignalState(Tile t, uint8_t signalbit)
Get the state of a single signal.
Definition rail_map.h:431
void SetSignalStates(Tile tile, uint state)
Set the states of the signals (Along/AgainstTrackDir).
Definition rail_map.h:410
void SetRailType(Tile t, RailType r)
Sets the rail type of the given tile.
Definition rail_map.h:125
EnumBitSet< RailType, uint64_t > RailTypes
Bitset of RailType elements.
Definition rail_type.h:37
RailType
Enumeration for all possible railtypes.
Definition rail_type.h:26
@ RAILTYPE_END
Used for iterations.
Definition rail_type.h:32
@ INVALID_RAILTYPE
Flag for invalid railtype.
Definition rail_type.h:33
@ RAILTYPE_ELECTRIC
Electric rails.
Definition rail_type.h:29
@ RAILTYPE_RAIL
Standard non-electric rails.
Definition rail_type.h:28
All the railtype-specific information is stored here.
static const RailTypeInfo _original_railtypes[]
Global Railtype definition.
Definition railtypes.h:18
bool RoadNoLevelCrossing(RoadType roadtype)
Test if road disallows level crossings.
Definition road.h:285
Money RoadBuildCost(RoadType roadtype)
Returns the cost of building the specified roadtype.
Definition road.h:242
void UpdateAdjacentLevelCrossingTilesOnLevelCrossingRemoval(TileIndex tile, Axis road_axis)
Update adjacent level crossing tiles in this multi-track crossing, due to removal of a level crossing...
void MarkDirtyAdjacentLevelCrossingTiles(TileIndex tile, Axis road_axis)
Find adjacent level crossing tiles in this multi-track crossing and mark them dirty.
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).
RoadType GetRoadTypeRoad(Tile t)
Get the road type for RoadTramType being RoadTramType::Road.
Definition road_map.h:152
bool IsLevelCrossingTile(Tile t)
Return whether a tile is a level crossing tile.
Definition road_map.h:79
RoadBits GetRoadBits(Tile t, RoadTramType rtt)
Get the present road bits for a specific road type.
Definition road_map.h:112
Axis GetCrossingRoadAxis(Tile t)
Get the road axis of a level crossing.
Definition road_map.h:346
Track GetCrossingRailTrack(Tile tile)
Get the rail track of a level crossing.
Definition road_map.h:379
DisallowedRoadDirections GetDisallowedRoadDirections(Tile t)
Gets the disallowed directions.
Definition road_map.h:311
RoadType GetRoadTypeTram(Tile t)
Get the road type for RoadTramType being RoadTramType::Tram.
Definition road_map.h:163
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:646
void MakeRoadCrossing(Tile t, Owner road, Owner tram, Owner rail, Axis roaddir, RailType rat, RoadType road_rt, RoadType tram_rt, TownID town)
Make a level crossing.
Definition road_map.h:672
RoadBits GetCrossingRoadBits(Tile tile)
Get the road bits of a level crossing.
Definition road_map.h:369
Owner GetRoadOwner(Tile t, RoadTramType rtt)
Get the owner of a specific road type.
Definition road_map.h:244
bool IsLevelCrossing(Tile t)
Return whether a tile is a level crossing.
Definition road_map.h:69
static bool IsNormalRoad(Tile t)
Return whether a tile is a normal road.
Definition road_map.h:48
bool HasRoadWorks(Tile t)
Check if a tile has road works.
Definition road_map.h:519
static constexpr RoadBits ROAD_X
Full road along the x-axis (south-west + north-east).
Definition road_type.h:67
EnumBitSet< RoadBit, uint8_t > RoadBits
Bitset of RoadBit elements.
Definition road_type.h:65
static constexpr RoadBits ROAD_Y
Full road along the y-axis (north-west + south-east).
Definition road_type.h:68
RoadType
The different roadtypes we support.
Definition road_type.h:24
@ INVALID_ROADTYPE
flag for invalid roadtype
Definition road_type.h:29
RoadTramType
The different types of road type.
Definition road_type.h:38
@ Invalid
Invalid marker.
Definition road_type.h:42
@ Tram
Tram type.
Definition road_type.h:40
@ Road
Road type.
Definition road_type.h:39
A number of safeguards to prevent using unsafe methods.
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition settings.cpp:61
ClientSettings _settings_client
The current settings for this game.
Definition settings.cpp:60
@ RoadVehicleDrivingSide
Signals at the driving side of road vehicles.
@ Right
Signals at the right side.
@ Left
Signals at the left side.
@ Right
Drive on the right side.
void AddTrackToSignalBuffer(TileIndex tile, Track track, Owner owner)
Add track to signal update buffer.
Definition signal.cpp:597
void AddSideToSignalBuffer(TileIndex tile, DiagDirection side, Owner owner)
Add side of tile to signal update buffer.
Definition signal.cpp:629
uint8_t 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:36
uint8_t 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:24
uint8_t 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:48
SignalType
Type of signal, i.e.
Definition signal_type.h:22
@ End
End marker.
Definition signal_type.h:29
@ Path
normal path signal.
Definition signal_type.h:27
@ Entry
presignal block entry.
Definition signal_type.h:24
@ Block
block signal.
Definition signal_type.h:23
@ Exit
presignal block exit.
Definition signal_type.h:25
SignalState
These are states in which a signal can be.
Definition signal_type.h:38
@ Green
The signal is green.
Definition signal_type.h:40
@ Red
The signal is red.
Definition signal_type.h:39
SignalVariant
Variant of the signal, i.e.
Definition signal_type.h:14
@ End
End marker.
Definition signal_type.h:17
@ Electric
Light signal.
Definition signal_type.h:15
@ Semaphore
Old-fashioned semaphore signal.
Definition signal_type.h:16
bool IsSpecialRailFoundation(Foundation f)
Tests if a foundation is a special rail foundation for single horizontal/vertical track.
Definition slope_func.h:355
Slope SlopeWithThreeCornersRaised(Corner corner)
Returns the slope with all except one corner raised.
Definition slope_func.h:216
Corner OppositeCorner(Corner corner)
Returns the opposite corner.
Definition slope_func.h:194
static constexpr Corner GetHalftileSlopeCorner(Slope s)
Returns the leveled halftile of a halftile slope.
Definition slope_func.h:158
static constexpr Slope RemoveHalftileSlope(Slope s)
Removes a halftile slope from a slope.
Definition slope_func.h:70
bool IsSlopeWithOneCornerRaised(Slope s)
Tests if a specific slope has exactly one corner raised.
Definition slope_func.h:98
uint SlopeToSpriteOffset(Slope s)
Returns the Sprite offset for a given Slope.
Definition slope_func.h:423
bool IsNonContinuousFoundation(Foundation f)
Tests if a foundation is a non-continuous foundation, i.e.
Definition slope_func.h:330
Corner GetHighestSlopeCorner(Slope s)
Returns the highest corner of a slope (one corner raised or a steep slope).
Definition slope_func.h:136
Corner GetHalftileFoundationCorner(Foundation f)
Returns the halftile corner of a halftile-foundation.
Definition slope_func.h:343
static constexpr bool IsValidCorner(Corner corner)
Rangecheck for Corner enumeration.
Definition slope_func.h:24
static constexpr bool IsSteepSlope(Slope s)
Checks if a slope is steep.
Definition slope_func.h:36
bool IsSlopeWithThreeCornersRaised(Slope s)
Tests if a specific slope has exactly three corners raised.
Definition slope_func.h:205
Foundation FlatteningFoundation(Slope s)
Returns the foundation needed to flatten a slope.
Definition slope_func.h:377
static constexpr bool IsHalftileSlope(Slope s)
Checks for non-continuous slope on halftile foundations.
Definition slope_func.h:57
Foundation HalftileFoundation(Corner corner)
Returns the halftile foundation for single horizontal/vertical track.
Definition slope_func.h:399
Foundation SpecialRailFoundation(Corner corner)
Returns the special rail foundation for single horizontal/vertical track.
Definition slope_func.h:411
Slope ComplementSlope(Slope s)
Return the complement of a slope.
Definition slope_func.h:86
Slope SlopeWithOneCornerRaised(Corner corner)
Returns the slope with a specific corner raised.
Definition slope_func.h:109
Corner
Enumeration of tile corners.
Definition slope_type.h:21
@ E
East tile corner.
Definition slope_type.h:24
@ Invalid
Invalid marker.
Definition slope_type.h:27
@ S
South tile corner.
Definition slope_type.h:23
@ W
West tile corner.
Definition slope_type.h:22
@ End
End marker.
Definition slope_type.h:26
@ N
North tile corner.
Definition slope_type.h:25
Slope
Enumeration for the slope-type.
Definition slope_type.h:53
@ SLOPE_W
the west corner of the tile is raised
Definition slope_type.h:55
@ SLOPE_ELEVATED
bit mask containing all 'simple' slopes
Definition slope_type.h:66
@ SLOPE_NS
north and south corner are raised
Definition slope_type.h:65
@ SLOPE_E
the east corner of the tile is raised
Definition slope_type.h:57
@ SLOPE_S
the south corner of the tile is raised
Definition slope_type.h:56
@ SLOPE_N
the north corner of the tile is raised
Definition slope_type.h:58
@ SLOPE_SW
south and west corner are raised
Definition slope_type.h:61
@ SLOPE_FLAT
a flat tile
Definition slope_type.h:54
@ SLOPE_NE
north and east corner are raised
Definition slope_type.h:63
@ SLOPE_SE
south and east corner are raised
Definition slope_type.h:62
@ SLOPE_NW
north and west corner are raised
Definition slope_type.h:60
@ SLOPE_EW
east and west corner are raised
Definition slope_type.h:64
Foundation
Enumeration for Foundations.
Definition slope_type.h:119
@ Leveled
The tile is leveled up to a flat slope.
Definition slope_type.h:121
@ SteepLower
The tile has a steep slope. The lowest corner is raised by a foundation to allow building railroad on...
Definition slope_type.h:124
@ Invalid
Used inside "rail_cmd.cpp" to indicate invalid slope/track combination.
Definition slope_type.h:141
@ None
The tile has no foundation, the slope remains unchanged.
Definition slope_type.h:120
@ InclinedY
The tile has an along Y-axis inclined foundation.
Definition slope_type.h:123
@ SteepBoth
The tile has a steep slope. The lowest corner is raised by a foundation and the upper halftile is lev...
Definition slope_type.h:127
@ InclinedX
The tile has an along X-axis inclined foundation.
Definition slope_type.h:122
static const uint32_t VALID_LEVEL_CROSSING_SLOPES
Constant bitset with safe slopes for building a level crossing.
Definition slope_type.h:112
EnumClassIndexContainer< std::array< T, SLOPE_ELEVATED >, Slope > NonSteepSlopeIndexArray
Array with non steep Slope as index.
Definition slope_type.h:104
EnumIndexArray< T, Corner, Corner::End > CornerIndexArray
Array with Corner as index.
Definition slope_type.h:35
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:122
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:108
PaletteID GroundSpritePaletteTransform(SpriteID image, PaletteID pal, PaletteID default_pal)
Applies PALETTE_MODIFIER_COLOUR to a palette entry of a ground sprite.
Definition sprite.h:207
static const SpriteID SPR_IMG_SIGNAL_SEMAPHORE_PBS
Definition sprites.h:1529
static const SpriteID SPR_IMG_SIGNAL_SEMAPHORE_PBS_OWAY
Definition sprites.h:1530
static const SpriteID SPR_IMG_SIGNAL_SEMAPHORE_NORM
Definition sprites.h:1525
static const SpriteID SPR_IMG_SIGNAL_ELECTRIC_PBS
Definition sprites.h:1523
static const SpriteID SPR_IMG_SIGNAL_ELECTRIC_COMBO
Definition sprites.h:1522
static const SpriteID SPR_IMG_SIGNAL_SEMAPHORE_ENTRY
Definition sprites.h:1526
static const SpriteID SPR_IMG_SIGNAL_ELECTRIC_ENTRY
Definition sprites.h:1520
static const PaletteID PALETTE_CRASH
Recolour sprite greying of crashed vehicles.
Definition sprites.h:1794
static const SpriteID SPR_FLAT_BARE_LAND
Definition sprites.h:674
static const SpriteID SPR_FLAT_WATER_TILE
Definition sprites.h:685
static const SpriteID SPR_FLAT_SNOW_DESERT_TILE
Definition sprites.h:689
static const SpriteID SPR_IMG_SIGNAL_ELECTRIC_NORM
Definition sprites.h:1519
static const SpriteID SPR_IMG_SIGNAL_SEMAPHORE_COMBO
Definition sprites.h:1528
static const SpriteID SPR_IMG_SIGNAL_ELECTRIC_EXIT
Definition sprites.h:1521
static const SpriteID SPR_FLAT_GRASS_TILE
Definition sprites.h:677
static const PaletteID PALETTE_TO_BARE_LAND
sets colour to bare land stuff for rail, road and crossings
Definition sprites.h:1782
static const SpriteID SPR_IMG_SIGNAL_SEMAPHORE_EXIT
Definition sprites.h:1527
static const SpriteID SPR_IMG_SIGNAL_ELECTRIC_PBS_OWAY
Definition sprites.h:1524
@ Count
by amount of cargo
bool IsRailStationTile(Tile t)
Is this tile a station tile and a rail station?
Track GetRailStationTrack(Tile t)
Get the rail track of a rail station tile.
bool IsStationTileBlocked(Tile t)
Is tile t a blocked tile?
bool HasStationRail(Tile t)
Has this station tile a rail?
Definition of base types and functions in a cross-platform compatible way.
static constexpr StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames).
Class to backup a specific variable and restore it upon destruction of this object to prevent stack v...
VehicleFlags vehicle_flags
Used for gradual loading and other miscellaneous things (.
constexpr bool Empty() const
Check whether the label is empty.
VehicleType type
Type of vehicle.
std::array< uint32_t, RAILTYPE_END > rail
Count of company owned track bits for each rail type.
CompanyInfrastructure infrastructure
NOSAVE: Counts of company owned infrastructure.
A coordinate with two dimensions.
T y
Y coordinate.
T x
X coordinate.
T x
X coordinate.
T y
Y coordinate.
T z
Z coordinate.
Ground palette sprite of a tile, together with its sprite layout.
Definition sprite.h:55
PalSpriteID ground
Palette and sprite for the ground.
Definition sprite.h:56
Offsets for drawing fences.
Corner height_ref
Corner to use height offset from.
static uint Size()
Get the size of the map.
Definition map_func.h:280
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition order_base.h:66
Combination of a palette sprite and a 'real' sprite.
Definition gfx_type.h:22
SpriteID sprite
The 'real' sprite.
Definition gfx_type.h:23
PaletteID pal
The palette (use PAL_NONE) if not needed).
Definition gfx_type.h:24
static T * Create(Targs &&... args)
static Company * Get(auto index)
static bool CanAllocateItem(size_t n=1)
T * GetMovingFront() const
Get the moving front of the vehicle chain.
T * Next() const
Get next vehicle in the chain.
static Train * From(Vehicle *v)
T * First() const
Get the first vehicle in the chain.
Used to only draw a part of the sprite.
Definition gfx_type.h:278
Tile description for the 'land area information' tool.
Definition tile_cmd.h:40
uint16_t rail_speed
Speed limit of rail (bridges and track).
Definition tile_cmd.h:53
StringID str
Description of the tile.
Definition tile_cmd.h:41
TimerGameCalendar::Date build_date
Date of construction of tile contents.
Definition tile_cmd.h:45
std::array< Owner, 4 > owner
Name of the owner(s).
Definition tile_cmd.h:43
StringID railtype
Type of rail on the tile.
Definition tile_cmd.h:52
Tile information, used while rendering the tile.
Definition tile_cmd.h:34
Slope tileh
Slope of the tile.
Definition tile_cmd.h:35
TileIndex tile
Tile index.
Definition tile_cmd.h:36
Set of callback functions for performing tile operations of a given tile type.
Definition tile_cmd.h:214
Track status of a tile.
Definition track_type.h:105
TrackdirBits trackdirs
Trackdirs present on the tile.
Definition track_type.h:106
'Train' is either a loco or a wagon.
Definition train.h:97
Trackdir GetVehicleTrackdir() const override
Get the tracks of the train vehicle.
RailTypes railtypes
On which rail types the train can run.
Definition train.h:108
TrackBits track
On which track the train currently is.
Definition train.h:110
int CalcNextVehicleOffset() const
Calculate the offset from this vehicle's center to the following center taking the vehicle lengths in...
Definition train.h:180
Vehicle data structure.
Direction GetMovingDirection() const
Get the moving direction of this vehicle chain.
VehStates vehstatus
Status.
Order current_order
The current order (+ status, like: loading).
int32_t y_pos
y coordinate.
int32_t x_pos
x coordinate.
uint16_t cur_speed
current speed
Vehicle * GetMovingNext() const
Get the next vehicle in the vehicle chain, relative to its current movement.
TileIndex tile
Current tile index.
@ CannotEnter
The vehicle cannot enter the tile.
Definition tile_cmd.h:27
@ EnteredWormhole
The vehicle either entered a bridge, tunnel or depot tile (this includes the last tile of the bridge/...
Definition tile_cmd.h:26
EnumBitSet< VehicleEnterTileState, uint8_t > VehicleEnterTileStates
Bitset of VehicleEnterTileState elements.
Definition tile_cmd.h:31
std::tuple< Slope, int > GetTileSlopeZ(TileIndex tile)
Return the slope of a given tile inside the map.
Definition tile_map.cpp:55
int GetTileMaxZ(TileIndex t)
Get top height of the tile inside the map.
Definition tile_map.cpp:135
static bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition tile_map.h:150
bool IsTileOwner(Tile tile, Owner owner)
Checks if a tile belongs to the given owner.
Definition tile_map.h:214
Owner GetTileOwner(Tile tile)
Returns the owner of a tile.
Definition tile_map.h:178
void SetTileOwner(Tile tile, Owner owner)
Sets the owner of a tile.
Definition tile_map.h:198
int GetTileMaxPixelZ(TileIndex tile)
Get top height of the tile.
Definition tile_map.h:312
std::tuple< Slope, int > GetTilePixelSlope(TileIndex tile)
Return the slope of a given tile.
Definition tile_map.h:289
bool IsValidTile(Tile tile)
Checks if a tile is valid.
Definition tile_map.h:161
TropicZone GetTropicZone(Tile tile)
Get the tropic zone.
Definition tile_map.h:238
Slope GetTileSlope(TileIndex tile)
Return the slope of a given tile inside the map.
Definition tile_map.h:279
static TileType GetTileType(Tile tile)
Get the tiletype of a given tile.
Definition tile_map.h:96
static constexpr uint TILE_UNIT_MASK
For masking in/out the inner-tile world coordinate units.
Definition tile_type.h:16
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > > TileIndex
The index/ID of a Tile.
Definition tile_type.h:92
@ Desert
Tile is desert.
Definition tile_type.h:83
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition tile_type.h:100
static constexpr uint TILE_SIZE
Tile size in world coordinates.
Definition tile_type.h:15
static constexpr uint TILE_HEIGHT
Height of a height level in world coordinate AND in pixels in ZOOM_BASE.
Definition tile_type.h:18
TileType
The different types of tiles.
Definition tile_type.h:48
@ TunnelBridge
Tunnel entry/exit and bridge heads.
Definition tile_type.h:58
@ Water
Water tile.
Definition tile_type.h:55
@ Station
A tile of a station or airport.
Definition tile_type.h:54
@ Object
Contains objects such as transmitters and owned land.
Definition tile_type.h:59
@ Industry
Part of an industry.
Definition tile_type.h:57
@ Railway
A tile with railway.
Definition tile_type.h:50
@ House
A house by a town.
Definition tile_type.h:52
@ Road
A tile with road and/or tram tracks.
Definition tile_type.h:51
OrthoDiagonalTileArea CreateOrthoDiagonalArea(TileIndex corner1, TileIndex corner2, bool diagonal)
Create an Orthogonal/Diagonal tile area wrapper.
Definition tilearea.cpp:23
Type for storing the 'area' of something uses on the map.
Base of the town class.
void MakeDefaultName(T *obj)
Set the default name for a depot/waypoint.
Definition town.h:335
TownID GetTownIndex(Tile t)
Get the index of which town this house/street is attached to.
Definition town_map.h:23
Trackdir TrackToTrackdir(Track track)
Returns a Trackdir for the given Track.
Definition track_func.h:252
Track TrackdirToTrack(Trackdir trackdir)
Returns the Track that a given Trackdir represents.
Definition track_func.h:235
TrackBits CornerToTrackBits(Corner corner)
Returns a single horizontal/vertical trackbit that is in a specific tile corner.
Definition track_func.h:74
TrackdirBits TrackBitsToTrackdirBits(TrackBits bits)
Converts TrackBits to TrackdirBits while allowing both directions.
Definition track_func.h:292
Track TrackBitsToTrack(TrackBits tracks)
Converts TrackBits to Track.
Definition track_func.h:166
Trackdir ReverseTrackdir(Trackdir trackdir)
Maps a trackdir to the reverse trackdir.
Definition track_func.h:220
bool TracksOverlap(TrackBits bits)
Checks if the given tracks overlap, ie form a crossing.
Definition track_func.h:540
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:479
bool IsValidTrack(Track track)
Checks if a Track is valid.
Definition track_func.h:24
Track FindFirstTrack(TrackBits tracks)
Returns first Track from TrackBits or Track::Invalid.
Definition track_func.h:150
Trackdir RemoveFirstTrackdir(TrackdirBits &trackdirs)
Removes first Trackdir from TrackdirBits and returns it.
Definition track_func.h:130
bool IsDiagonalTrackdir(Trackdir trackdir)
Checks if a given Trackdir is diagonal.
Definition track_func.h:526
Track AxisToTrack(Axis a)
Convert an Axis to the corresponding Track Axis::X -> Track::X Axis::Y -> Track::Y Uses the fact that...
Definition track_func.h:62
DiagDirection TrackdirToExitdir(Trackdir trackdir)
Maps a trackdir to the (4-way) direction the tile is exited when following that trackdir.
Definition track_func.h:343
Track DiagDirToDiagTrack(DiagDirection diagdir)
Maps a DiagDirection to the associated diagonal Track.
Definition track_func.h:419
TrackBits TrackdirBitsToTrackBits(TrackdirBits bits)
Discards all directional information from a TrackdirBits value.
Definition track_func.h:281
Sprites to use and how to display them for train depot tiles.
static const DiagDirectionIndexArray< DrawTileSpriteSpan > _depot_gfx_table
Sprite layout of a depot for each direction.
Definition track_land.h:32
static const DiagDirectionIndexArray< DrawTileSpriteSpan > _depot_invisible_gfx_table
Sprite layout of an invisible depot with for each direction.
Definition track_land.h:40
static constexpr TrackBits TRACK_BIT_3WAY_NE
"Arrow" to the north-east
Definition track_type.h:48
static constexpr TrackBits TRACK_BIT_HORZ
Upper and lower track.
Definition track_type.h:46
EnumBitSet< Trackdir, uint16_t > TrackdirBits
Bitset of Trackdir elements.
Definition track_type.h:93
EnumBitSet< Track, uint8_t > TrackBits
Bitset of Track elements.
Definition track_type.h:43
static constexpr TrackBits TRACK_BIT_ALL
All possible tracks.
Definition track_type.h:52
Trackdir
Enumeration for tracks and directions.
Definition track_type.h:63
@ Right_N
Right track and direction to north.
Definition track_type.h:77
@ X_NE
X-axis and direction to north-east.
Definition track_type.h:64
@ Right_S
Right track and direction to south.
Definition track_type.h:69
@ Left_S
Left track and direction to south.
Definition track_type.h:68
@ Lower_E
Lower track and direction to east.
Definition track_type.h:67
@ X_SW
X-axis and direction to south-west.
Definition track_type.h:72
@ Invalid
Flag for an invalid trackdir.
Definition track_type.h:82
@ Y_SE
Y-axis and direction to south-east.
Definition track_type.h:65
@ Y_NW
Y-axis and direction to north-west.
Definition track_type.h:73
@ Upper_W
Upper track and direction to west.
Definition track_type.h:74
@ Upper_E
Upper track and direction to east.
Definition track_type.h:66
@ Left_N
Left track and direction to north.
Definition track_type.h:76
@ Lower_W
Lower track and direction to west.
Definition track_type.h:75
static constexpr TrackBits TRACK_BIT_VERT
Left and right track.
Definition track_type.h:47
static constexpr TrackBits TRACK_BIT_CROSS
X-Y-axis cross.
Definition track_type.h:45
static constexpr TrackBits TRACK_BIT_3WAY_SW
"Arrow" to the south-west
Definition track_type.h:50
static constexpr TrackBits TRACK_BIT_3WAY_SE
"Arrow" to the south-east
Definition track_type.h:49
EnumIndexArray< T, Trackdir, Trackdir::End > TrackdirIndexArray
Array with Trackdir as index.
Definition track_type.h:90
static constexpr TrackBits TRACK_BIT_3WAY_NW
"Arrow" to the north-west
Definition track_type.h:51
Track
These are used to specify a single track.
Definition track_type.h:19
@ X
Track along the x-axis (north-east to south-west).
Definition track_type.h:21
@ Upper
Track in the upper corner of the tile (north).
Definition track_type.h:23
@ Invalid
Flag for an invalid track.
Definition track_type.h:32
@ Y
Track along the y-axis (north-west to south-east).
Definition track_type.h:22
@ Right
Track in the right corner of the tile (east).
Definition track_type.h:26
@ Left
Track in the left corner of the tile (west).
Definition track_type.h:25
@ Depot
Special flag indicating a vehicle is inside a depot.
Definition track_type.h:30
@ Lower
Track in the lower corner of the tile (south).
Definition track_type.h:24
Base for the train class.
static constexpr ConsistChangeFlags CCF_TRACK
Valid changes while vehicle is driving, and possibly changing tracks.
Definition train.h:53
bool TryPathReserve(Train *v, bool mark_as_stuck=false, bool first_tile_okay=false)
Try to reserve a path to a safe position.
void FreeTrainTrackReservation(const Train *v)
Free the reserved path in front of a vehicle.
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...
DisplayOptions _display_opt
What do we want to draw/do?
@ Buildings
company buildings - depots, stations, HQ, ...
TransportType
Available types of transport.
@ Water
Transport over water.
@ Rail
Transport by train.
Header file for things common for tunnels and bridges.
void MarkBridgeDirty(TileIndex begin, TileIndex end, DiagDirection direction, uint bridge_height)
Mark bridge tiles dirty.
uint GetTunnelBridgeLength(TileIndex begin, TileIndex end)
Calculates the length of a tunnel or a bridge (without end tiles).
Functions that have tunnels and bridges in common.
DiagDirection GetTunnelBridgeDirection(Tile t)
Get the direction pointing to the other end.
bool HasTunnelBridgeReservation(Tile t)
Get the reservation state of the rail tunnel/bridge.
TransportType GetTunnelBridgeTransportType(Tile t)
Tunnel: Get the transport type of the tunnel (road or rail) Bridge: Get the transport type of the bri...
TileIndex GetOtherTunnelBridgeEnd(Tile t)
Determines type of the wormhole and returns its other end.
CommandCost EnsureNoVehicleOnGround(TileIndex tile)
Ensure there is no vehicle at the ground at the given position.
Definition vehicle.cpp:559
void VehicleEnterDepot(Vehicle *v)
Vehicle entirely entered the depot, update its status, orders, vehicle windows, service it,...
Definition vehicle.cpp:1564
CommandCost EnsureNoTrainOnTrackBits(TileIndex tile, TrackBits track_bits)
Tests if a vehicle interacts with the specified track bits.
Definition vehicle.cpp:607
CommandCost TunnelBridgeIsFree(TileIndex tile, TileIndex endtile, const Vehicle *ignore)
Finds vehicle in tunnel / bridge.
Definition vehicle.cpp:583
const uint TILE_AXIAL_DISTANCE
Logical length of the tile in any DiagDirection used in vehicle movement.
const uint TILE_CORNER_DISTANCE
Logical length of the tile corner crossing in any non-diagonal direction used in vehicle movement.
@ Hidden
Vehicle is not visible.
@ Stopped
Vehicle is stopped by the player.
Functions related to vehicles.
bool HasVehicleOnTile(TileIndex tile, UnaryPred &&predicate)
Loop over vehicles on a tile, and check whether a predicate is true for any of them.
@ Ship
Ship vehicle type.
@ Train
Train vehicle type.
@ Original
Original acceleration model.
void AddSortableSpriteToDraw(SpriteID image, PaletteID pal, int x, int y, int z, const SpriteBounds &bounds, bool transparent, const SubSprite *sub)
Draw a (transparent) sprite at given coordinates with a given bounding box.
Definition viewport.cpp:665
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:580
Functions related to (drawing on) viewports.
static const int TILE_HEIGHT_STEP
One Z unit tile height difference is displayed as 50m.
static constexpr int BB_HEIGHT_UNDER_BRIDGE
Some values for constructing bounding boxes (BB).
Functions related to water management.
void TileLoop_Water(TileIndex tile)
Tile callback function signature for running periodic tile updates.
@ None
The tile does not flood neighboured tiles.
Definition water.h:20
FloodingBehaviour GetFloodingBehaviour(TileIndex tile)
Returns the behaviour of a tile during flooding.
void CheckForDockingTile(TileIndex t)
Mark the supplied tile as a docking tile if it is suitable for docking.
bool IsPossibleDockingTile(Tile t)
Check whether it is feasible that the given tile could be a docking tile.
void MakeShore(Tile t, bool rocks=false)
Helper function to make a coast tile.
Definition water_map.h:389
bool IsDockingTile(Tile t)
Checks whether the tile is marked as a dockling tile.
Definition water_map.h:378
void SetDockingTile(Tile t, bool b)
Set the docking tile state of a tile.
Definition water_map.h:367
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:3377
Entry point for OpenTTD to YAPF's cache.
void YapfNotifyTrackLayoutChange(TileIndex tile, Track track)
Use this function to notify YAPF that track layout (or signal configuration) has change.