mirror
/
OpenTTD
mirror of https://github.com/OpenTTD/OpenTTD
1
0
Fork 0
Code Issues

Codechange: Move platform related code to separate files.

pull/8480/head
J0anJosep 2020-12-23 22:32:53 +01:00
parent f161a138b9
commit 4854685bec
17 changed files with 301 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/CMakeLists.txt
View File

@ -342,6 +342,9 @@ add_files(
picker_func.h
picker_gui.cpp
picker_gui.h
platform_func.h
platform_type.h
platform.cpp
progress.cpp
progress.h
querystring_gui.h

18
src/base_station_base.h
View File

@ -140,24 +140,6 @@ struct BaseStation : StationPool::PoolItem<&_station_pool> {
*/
virtual void GetTileArea(TileArea *ta, StationType type) const = 0;
/**
* Obtain the length of a platform
* @pre tile must be a rail station tile
* @param tile A tile that contains the platform in question
* @return The length of the platform
*/
virtual uint GetPlatformLength(TileIndex tile) const = 0;
/**
* Determines the REMAINING length of a platform, starting at (and including)
* the given tile.
* @param tile the tile from which to start searching. Must be a rail station tile
* @param dir The direction in which to search.
* @return The platform length
*/
virtual uint GetPlatformLength(TileIndex tile, DiagDirection dir) const = 0;
/**
* Get the base station belonging to a specific tile.
* @param tile The tile to get the base station from.

10
src/economy.cpp
View File

@ -56,6 +56,7 @@
#include "timer/timer_game_calendar.h"
#include "timer/timer_game_economy.h"
#include "depot_base.h"
#include "platform_func.h"
#include "table/strings.h"
#include "table/pricebase.h"
@ -1621,14 +1622,13 @@ static void ReserveConsist(Station *st, Vehicle *u, CargoArray *consist_capleft,
* Update the vehicle's load_unload_ticks, the time it will wait until it tries to load or unload
* again. Adjust for overhang of trains and set it at least to 1.
* @param front The vehicle to be updated.
* @param st The station the vehicle is loading at.
* @param ticks The time it would normally wait, based on cargo loaded and unloaded.
*/
static void UpdateLoadUnloadTicks(Vehicle *front, const Station *st, int ticks)
static void UpdateLoadUnloadTicks(Vehicle *front, int ticks)
{
if (front->type == VEH_TRAIN && _settings_game.order.station_length_loading_penalty) {
/* Each platform tile is worth 2 rail vehicles. */
int overhang = front->GetGroundVehicleCache()->cached_total_length - st->GetPlatformLength(front->tile) * TILE_SIZE;
int overhang = front->GetGroundVehicleCache()->cached_total_length - GetPlatformLength(front->tile) * TILE_SIZE;
if (overhang > 0) {
ticks <<= 1;
ticks += (overhang * ticks) / 8;
@ -1890,9 +1890,9 @@ static void LoadUnloadVehicle(Vehicle *front)
SetBit(front->vehicle_flags, VF_STOP_LOADING);
}
UpdateLoadUnloadTicks(front, st, new_load_unload_ticks);
UpdateLoadUnloadTicks(front, new_load_unload_ticks);
} else {
UpdateLoadUnloadTicks(front, st, 20); // We need the ticks for link refreshing.
UpdateLoadUnloadTicks(front, 20); // We need the ticks for link refreshing.
bool finished_loading = true;
if (front->current_order.GetLoadType() & OLFB_FULL_LOAD) {
if (front->current_order.GetLoadType() == OLF_FULL_LOAD_ANY) {

1
src/newgrf_station.cpp
View File

@ -24,6 +24,7 @@
#include "newgrf_animation_base.h"
#include "newgrf_class_func.h"
#include "timer/timer_game_calendar.h"
#include "platform_func.h"
#include "safeguards.h"

12
src/pathfinder/follow_track.hpp
View File

@ -18,6 +18,7 @@
#include "../tunnelbridge_map.h"
#include "../depot_map.h"
#include "pathfinder_func.h"
#include "../platform_func.h"
/**
* Track follower helper template class (can serve pathfinders and vehicle
@ -370,12 +371,11 @@ protected:
/* special handling for rail stations - get to the end of platform */
if (IsRailTT() && m_is_station) {
/* entered railway station
* get platform length */
uint length = BaseStation::GetByTile(m_new_tile)->GetPlatformLength(m_new_tile, TrackdirToExitdir(m_old_td));
/* how big step we must do to get to the last platform tile? */
m_tiles_skipped = length - 1;
/* move to the platform end */
/* Entered a platform. */
assert(HasStationTileRail(m_new_tile));
/* How big step we must do to get to the last platform tile? */
m_tiles_skipped = GetPlatformLength(m_new_tile, TrackdirToExitdir(m_old_td)) - 1;
/* Move to the platform end. */
TileIndexDiff diff = TileOffsByDiagDir(m_exitdir);
diff *= m_tiles_skipped;
m_new_tile = TileAdd(m_new_tile, diff);

9
src/pathfinder/yapf/yapf_costrail.hpp
View File

@ -590,12 +590,11 @@ no_entry_cost: // jump here at the beginning if the node has no parent (it is th
}
}
/* Station platform-length penalty. */
/* Platform-length penalty. */
if ((end_segment_reason & ESRB_STATION) != ESRB_NONE) {
const BaseStation *st = BaseStation::GetByTile(n.GetLastTile());
assert(st != nullptr);
uint platform_length = st->GetPlatformLength(n.GetLastTile(), ReverseDiagDir(TrackdirToExitdir(n.GetLastTrackdir())));
/* Reduce the extra cost caused by passing-station penalty (each station receives it in the segment cost). */
assert(HasStationTileRail(n.GetLastTile()));
uint platform_length = GetPlatformLength(n.GetLastTile(), ReverseDiagDir(TrackdirToExitdir(n.GetLastTrackdir())));
/* Reduce the extra cost caused by passing-platform penalty (each platform receives it in the segment cost). */
extra_cost -= Yapf().PfGetSettings().rail_station_penalty * platform_length;
/* Add penalty for the inappropriate platform length. */
extra_cost += PlatformLengthPenalty(platform_length);

1
src/pathfinder/yapf/yapf_rail.cpp
View File

@ -16,6 +16,7 @@
#include "yapf_destrail.hpp"
#include "../../viewport_func.h"
#include "../../newgrf_station.h"
#include "../../platform_func.h"
#include "../../safeguards.h"

22
src/pbs.cpp
View File

@ -47,28 +47,6 @@ TrackBits GetReservedTrackbits(TileIndex t)
return TRACK_BIT_NONE;
}
/**
* Set the reservation for a complete station platform.
* @pre IsRailStationTile(start)
* @param start starting tile of the platform
* @param dir the direction in which to follow the platform
* @param b the state the reservation should be set to
*/
void SetRailStationPlatformReservation(TileIndex start, DiagDirection dir, bool b)
{
TileIndex tile = start;
TileIndexDiff diff = TileOffsByDiagDir(dir);
assert(IsRailStationTile(start));
assert(GetRailStationAxis(start) == DiagDirToAxis(dir));
do {
SetRailStationReservation(tile, b);
MarkTileDirtyByTile(tile);
tile = TileAdd(tile, diff);
} while (IsCompatibleTrainStationTile(tile, start));
}
/**
* Try to reserve a specific track on a tile
* @param tile the tile

138
src/platform.cpp 100644
View File

@ -0,0 +1,138 @@
/*
* This file is part of OpenTTD.
* OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
* OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
*/
/** @file platform.cpp Implementation of platform functions. */
#include "stdafx.h"
#include "station_map.h"
#include "platform_func.h"
#include "viewport_func.h"
/**
* Set the reservation for a complete station platform.
* @pre IsRailStationTile(start)
* @param start starting tile of the platform
* @param dir the direction in which to follow the platform
* @param b the state the reservation should be set to
*/
void SetRailStationPlatformReservation(TileIndex start, DiagDirection dir, bool b)
{
TileIndex tile = start;
TileIndexDiff diff = TileOffsByDiagDir(dir);
assert(IsRailStationTile(start));
assert(GetRailStationAxis(start) == DiagDirToAxis(dir));
do {
SetRailStationReservation(tile, b);
MarkTileDirtyByTile(tile);
tile = TileAdd(tile, diff);
} while (IsCompatibleTrainStationTile(tile, start));
}
/**
* Set the reservation for a complete platform in a given direction.
* @param start starting tile of the platform
* @param dir the direction in which to follow the platform
* @param b the state the reservation should be set to
*/
void SetPlatformReservation(TileIndex start, DiagDirection dir, bool b)
{
switch (GetPlatformType(start)) {
case PT_RAIL_STATION:
SetRailStationPlatformReservation(start, dir, b);
return;
case PT_RAIL_WAYPOINT:
SetRailStationReservation(start, b);
return;
default: NOT_REACHED();
}
}
/**
* Get the length of a rail station platform.
* @pre IsRailStationTile(tile)
* @param tile Tile to check
* @return The length of the platform in tile length.
*/
uint GetRailStationPlatformLength(TileIndex tile)
{
assert(IsRailStationTile(tile));
TileIndexDiff delta = (GetRailStationAxis(tile) == AXIS_X ? TileDiffXY(1, 0) : TileDiffXY(0, 1));
TileIndex t = tile;
uint len = 0;
do {
t -= delta;
len++;
} while (IsCompatibleTrainStationTile(t, tile));
t = tile;
do {
t += delta;
len++;
} while (IsCompatibleTrainStationTile(t, tile));
return len - 1;
}
/**
* Get the length of a rail station platform in a given direction.
* @pre IsRailStationTile(tile)
* @param tile Tile to check
* @param dir Direction to check
* @return The length of the platform in tile length in the given direction.
*/
uint GetRailStationPlatformLength(TileIndex tile, DiagDirection dir)
{
TileIndex start_tile = tile;
uint length = 0;
assert(IsRailStationTile(tile));
assert(dir < DIAGDIR_END);
do {
length++;
tile += TileOffsByDiagDir(dir);
} while (IsCompatibleTrainStationTile(tile, start_tile));
return length;
}
/**
* Get the length of a platform.
* @param tile Tile to check
* @return The length of the platform in tile length.
*/
uint GetPlatformLength(TileIndex tile)
{
switch (GetPlatformType(tile)) {
case PT_RAIL_STATION:
return GetRailStationPlatformLength(tile);
case PT_RAIL_WAYPOINT:
return 1;
default: NOT_REACHED();
}
}
/**
* Get the length of a rail depot platform in a given direction.
* @pre IsRailDepotTile(tile)
* @param tile Tile to check
* @param dir Direction to check
* @return The length of the platform in tile length in the given direction.
*/
uint GetPlatformLength(TileIndex tile, DiagDirection dir)
{
switch (GetPlatformType(tile)) {
case PT_RAIL_STATION:
return GetRailStationPlatformLength(tile, dir);
case PT_RAIL_WAYPOINT:
return 1;
default: NOT_REACHED();
}
}

104
src/platform_func.h 100644
View File

@ -0,0 +1,104 @@
/*
* This file is part of OpenTTD.
* OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
* OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
*/
/** @file platform_func.h Functions related with platforms (tiles in a row that are connected somehow). */
#ifndef PLATFORM_FUNC_H
#define PLATFORM_FUNC_H
#include "station_map.h"
#include "platform_type.h"
/**
* Check if a tile is a valid continuation to a railstation tile.
* The tile \a test_tile is a valid continuation to \a station_tile, if all of the following are true:
* \li \a test_tile is a rail station tile
* \li the railtype of \a test_tile is compatible with the railtype of \a station_tile
* \li the tracks on \a test_tile and \a station_tile are in the same direction
* \li both tiles belong to the same station
* \li \a test_tile is not blocked (@see IsStationTileBlocked)
* @param test_tile Tile to test
* @param station_tile Station tile to compare with
* @pre IsRailStationTile(station_tile)
* @return true if the two tiles are compatible
*/
static inline bool IsCompatibleTrainStationTile(TileIndex test_tile, TileIndex station_tile)
{
assert(IsRailStationTile(station_tile));
return IsRailStationTile(test_tile) && !IsStationTileBlocked(test_tile) &&
IsCompatibleRail(GetRailType(test_tile), GetRailType(station_tile)) &&
GetRailStationAxis(test_tile) == GetRailStationAxis(station_tile) &&
GetStationIndex(test_tile) == GetStationIndex(station_tile);
}
/**
* Returns the type of platform of a given tile.
* @param tile Tile to check
* @return the type of platform (rail station, rail waypoint...)
*/
static inline PlatformType GetPlatformType(TileIndex tile)
{
switch (GetTileType(tile)) {
case MP_STATION:
if (IsRailStation(tile)) return PT_RAIL_STATION;
if (IsRailWaypoint(tile)) return PT_RAIL_WAYPOINT;
break;
default: break;
}
return INVALID_PLATFORM_TYPE;
}
/**
* Check whether a tile is a known platform type.
* @param tile to check
* @return whether the tile is a known platform type.
*/
static inline bool IsPlatformTile(TileIndex tile)
{
return GetPlatformType(tile) != INVALID_PLATFORM_TYPE;
}
/**
* Check whether a platform tile is reserved.
* @param tile to check
* @return whether the platform tile is reserved
*/
static inline bool HasPlatformReservation(TileIndex tile)
{
switch(GetPlatformType(tile)) {
case PT_RAIL_STATION:
case PT_RAIL_WAYPOINT:
return HasStationReservation(tile);
default: NOT_REACHED();
}
}
/**
* Check whether two tiles are compatible platform tiles: they must have the same
* platform type and (depending on the platform type) its railtype or other specs.
* @param test_tile the tile to check
* @param orig_tile the tile with the platform type we are interested in
* @return whether the two tiles are compatible tiles for defining a platform
*/
static inline bool IsCompatiblePlatformTile(TileIndex test_tile, TileIndex orig_tile)
{
switch (GetPlatformType(orig_tile)) {
case PT_RAIL_STATION:
return IsCompatibleTrainStationTile(test_tile, orig_tile);
case PT_RAIL_WAYPOINT:
return test_tile == orig_tile;
default: NOT_REACHED();
}
}
void SetPlatformReservation(TileIndex start, DiagDirection dir, bool b);
uint GetPlatformLength(TileIndex tile);
uint GetPlatformLength(TileIndex tile, DiagDirection dir);
#endif /* PLATFORM_FUNC_H */

22
src/platform_type.h 100644
View File

@ -0,0 +1,22 @@
/*
* This file is part of OpenTTD.
* OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
* OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
*/
/** @file platform_type.h Types related to platforms. */
#ifndef PLATFORM_TYPE_H
#define PLATFORM_TYPE_H
#include "core/enum_type.hpp"
enum PlatformType {
PT_RAIL_STATION,
PT_RAIL_WAYPOINT,
PT_END,
INVALID_PLATFORM_TYPE = PT_END,
};
#endif /* PLATFORM_TYPE_H */

37
src/station.cpp
View File

@ -269,43 +269,6 @@ void Station::MarkTilesDirty(bool cargo_change) const
}
}
/* virtual */ uint Station::GetPlatformLength(TileIndex tile) const
{
assert(this->TileBelongsToRailStation(tile));
TileIndexDiff delta = (GetRailStationAxis(tile) == AXIS_X ? TileDiffXY(1, 0) : TileDiffXY(0, 1));
TileIndex t = tile;
uint len = 0;
do {
t -= delta;
len++;
} while (IsCompatibleTrainStationTile(t, tile));
t = tile;
do {
t += delta;
len++;
} while (IsCompatibleTrainStationTile(t, tile));
return len - 1;
}
/* virtual */ uint Station::GetPlatformLength(TileIndex tile, DiagDirection dir) const
{
TileIndex start_tile = tile;
uint length = 0;
assert(IsRailStationTile(tile));
assert(dir < DIAGDIR_END);
do {
length++;
tile += TileOffsByDiagDir(dir);
} while (IsCompatibleTrainStationTile(tile, start_tile));
return length;
}
/**
* Get the catchment size of an individual station tile.
* @param tile Station tile to get catchment size of.

3
src/station_base.h
View File

@ -488,9 +488,6 @@ public:
void MoveSign(TileIndex new_xy) override;
void AfterStationTileSetChange(bool adding, StationType type);
uint GetPlatformLength(TileIndex tile, DiagDirection dir) const override;
uint GetPlatformLength(TileIndex tile) const override;
void RecomputeCatchment(bool no_clear_nearby_lists = false);
static void RecomputeCatchmentForAll();

18
src/station_cmd.cpp
View File

@ -68,6 +68,7 @@
#include "cheat_type.h"
#include "road_func.h"
#include "depot_base.h"
#include "platform_func.h"
#include "widgets/station_widget.h"
@ -1240,9 +1241,10 @@ CommandCost FindJoiningWaypoint(StationID existing_waypoint, StationID waypoint_
static void FreeTrainReservation(Train *v)
{
FreeTrainTrackReservation(v);
if (IsRailStationTile(v->tile)) SetRailStationPlatformReservation(v->tile, TrackdirToExitdir(v->GetVehicleTrackdir()), false);
if (IsPlatformTile(v->tile)) SetPlatformReservation(v->tile, TrackdirToExitdir(v->GetVehicleTrackdir()), false);
v = v->Last();
if (IsRailStationTile(v->tile)) SetRailStationPlatformReservation(v->tile, TrackdirToExitdir(ReverseTrackdir(v->GetVehicleTrackdir())), false);
if (IsPlatformTile(v->tile)) SetPlatformReservation(v->tile, TrackdirToExitdir(ReverseTrackdir(v->GetVehicleTrackdir())), false);
}
/**
@ -1251,10 +1253,10 @@ static void FreeTrainReservation(Train *v)
*/
static void RestoreTrainReservation(Train *v)
{
if (IsRailStationTile(v->tile)) SetRailStationPlatformReservation(v->tile, TrackdirToExitdir(v->GetVehicleTrackdir()), true);
if (IsPlatformTile(v->tile)) SetPlatformReservation(v->tile, TrackdirToExitdir(v->GetVehicleTrackdir()), true);
TryPathReserve(v, true, true);
v = v->Last();
if (IsRailStationTile(v->tile)) SetRailStationPlatformReservation(v->tile, TrackdirToExitdir(ReverseTrackdir(v->GetVehicleTrackdir())), true);
if (IsPlatformTile(v->tile)) SetPlatformReservation(v->tile, TrackdirToExitdir(ReverseTrackdir(v->GetVehicleTrackdir())), true);
}
/**
@ -1522,21 +1524,21 @@ CommandCost CmdBuildRailStation(DoCommandFlag flags, TileIndex tile_org, RailTyp
TileIndex platform_end = tile;
/* We can only account for tiles that are reachable from this tile, so ignore primarily blocked tiles while finding the platform begin and end. */
for (TileIndex next_tile = platform_begin - tile_offset; IsCompatibleTrainStationTile(next_tile, platform_begin); next_tile -= tile_offset) {
for (TileIndex next_tile = platform_begin - tile_offset; IsCompatiblePlatformTile(next_tile, platform_begin); next_tile -= tile_offset) {
platform_begin = next_tile;
}
for (TileIndex next_tile = platform_end + tile_offset; IsCompatibleTrainStationTile(next_tile, platform_end); next_tile += tile_offset) {
for (TileIndex next_tile = platform_end + tile_offset; IsCompatiblePlatformTile(next_tile, platform_end); next_tile += tile_offset) {
platform_end = next_tile;
}
/* If there is at least on reservation on the platform, we reserve the whole platform. */
bool reservation = false;
for (TileIndex t = platform_begin; !reservation && t <= platform_end; t += tile_offset) {
reservation = HasStationReservation(t);
reservation = HasPlatformReservation(t);
}
if (reservation) {
SetRailStationPlatformReservation(platform_begin, dir, true);
SetPlatformReservation(platform_begin, dir, true);
}
}

22
src/station_map.h
View File

@ -521,28 +521,6 @@ inline TrackBits GetRailStationTrackBits(Tile t)
return AxisToTrackBits(GetRailStationAxis(t));
}
/**
* Check if a tile is a valid continuation to a railstation tile.
* The tile \a test_tile is a valid continuation to \a station_tile, if all of the following are true:
* \li \a test_tile is a rail station tile
* \li the railtype of \a test_tile is compatible with the railtype of \a station_tile
* \li the tracks on \a test_tile and \a station_tile are in the same direction
* \li both tiles belong to the same station
* \li \a test_tile is not blocked (@see IsStationTileBlocked)
* @param test_tile Tile to test
* @param station_tile Station tile to compare with
* @pre IsRailStationTile(station_tile)
* @return true if the two tiles are compatible
*/
inline bool IsCompatibleTrainStationTile(Tile test_tile, Tile station_tile)
{
assert(IsRailStationTile(station_tile));
return IsRailStationTile(test_tile) && !IsStationTileBlocked(test_tile) &&
IsCompatibleRail(GetRailType(test_tile), GetRailType(station_tile)) &&
GetRailStationAxis(test_tile) == GetRailStationAxis(station_tile) &&
GetStationIndex(test_tile) == GetStationIndex(station_tile);
}
/**
* Get the reservation state of the rail station
* @pre HasStationRail(t)

13
src/train_cmd.cpp
View File

@ -39,6 +39,7 @@
#include "timer/timer_game_calendar.h"
#include "timer/timer_game_economy.h"
#include "depot_base.h"
#include "platform_func.h"
#include "table/strings.h"
#include "table/train_sprites.h"
@ -263,9 +264,9 @@ void Train::ConsistChanged(ConsistChangeFlags allowed_changes)
*/
int GetTrainStopLocation(StationID station_id, TileIndex tile, const Train *v, int *station_ahead, int *station_length)
{
const Station *st = Station::Get(station_id);
*station_ahead = st->GetPlatformLength(tile, DirToDiagDir(v->direction)) * TILE_SIZE;
*station_length = st->GetPlatformLength(tile) * TILE_SIZE;
assert(IsRailStationTile(tile));
*station_ahead = GetPlatformLength(tile, DirToDiagDir(v->direction)) * TILE_SIZE;
*station_length = GetPlatformLength(tile) * TILE_SIZE;
/* Default to the middle of the station for stations stops that are not in
* the order list like intermediate stations when non-stop is disabled */
@ -2183,7 +2184,7 @@ void ReverseTrainDirection(Train *v)
/* If we are on a depot tile facing outwards, do not treat the current tile as safe. */
if (IsStandardRailDepotTile(v->tile) && TrackdirToExitdir(v->GetVehicleTrackdir()) == GetRailDepotDirection(v->tile)) first_tile_okay = false;
if (IsRailStationTile(v->tile)) SetRailStationPlatformReservation(v->tile, TrackdirToExitdir(v->GetVehicleTrackdir()), true);
if (IsPlatformTile(v->tile)) SetPlatformReservation(v->tile, TrackdirToExitdir(v->GetVehicleTrackdir()), true);
if (TryPathReserve(v, false, first_tile_okay)) {
/* Do a look-ahead now in case our current tile was already a safe tile. */
CheckNextTrainTile(v);
@ -2526,8 +2527,8 @@ static void ClearPathReservation(const Train *v, TileIndex tile, Trackdir track_
TileIndex new_tile = TileAddByDiagDir(tile, dir);
/* If the new tile is not a further tile of the same station, we
* clear the reservation for the whole platform. */
if (!IsCompatibleTrainStationTile(new_tile, tile)) {
SetRailStationPlatformReservation(tile, ReverseDiagDir(dir), false);
if (!IsCompatiblePlatformTile(new_tile, tile)) {
SetPlatformReservation(tile, ReverseDiagDir(dir), false);
}
} else {
/* Any other tile */

10
src/waypoint_base.h
View File

@ -45,16 +45,6 @@ struct Waypoint final : SpecializedStation<Waypoint, true> {
void GetTileArea(TileArea *ta, StationType type) const override;
uint GetPlatformLength(TileIndex, DiagDirection) const override
{
return 1;
}
uint GetPlatformLength(TileIndex) const override
{
return 1;
}
/**
* Is this a single tile waypoint?
* @return true if it is.