miguel.horta/openttd-cmclient
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/master'

Browse Source
This commit is contained in:
dP
2025-09-28 02:33:49 +05:00
parent 6a1400b6a6 d785467c28
commit 8404c2a7cc
926 changed files with 37902 additions and 27369 deletions
Download Patch File Download Diff File Expand all files Collapse all files

197
src/rail_cmd.cpp
View File

@@ -1543,17 +1543,6 @@ CommandCost CmdRemoveSignalTrack(DoCommandFlags flags, TileIndex tile, TileIndex
return CmdSignalTrackHelper(flags, tile, end_tile, track, SIGTYPE_BLOCK, SIG_ELECTRIC, false, true, autofill, false, 1); // bit 5 is remove bit
}
/** Update power of train under which is the railtype being converted */
static Vehicle *UpdateTrainPowerProc(Vehicle *v, void *data)
{
if (v->type != VEH_TRAIN) return nullptr;
TrainList *affected_trains = static_cast<TrainList*>(data);
include(*affected_trains, Train::From(v)->First());
return nullptr;
}
/**
* Convert one rail type to the other. You can convert normal rail to
* monorail/maglev easily or vice-versa.
@@ -1655,7 +1644,9 @@ CommandCost CmdConvertRail(DoCommandFlags flags, TileIndex tile, TileIndex area_
SetRailType(tile, totype);
MarkTileDirtyByTile(tile);
/* update power of train on this tile */
FindVehicleOnPos(tile, &affected_trains, &UpdateTrainPowerProc);
for (Vehicle *v : VehiclesOnTile(tile)) {
if (v->type == VEH_TRAIN) include(affected_trains, Train::From(v)->First());
}
}
}
@@ -1732,8 +1723,12 @@ CommandCost CmdConvertRail(DoCommandFlags flags, TileIndex tile, TileIndex area_
SetRailType(tile, totype);
SetRailType(endtile, totype);
FindVehicleOnPos(tile, &affected_trains, &UpdateTrainPowerProc);
FindVehicleOnPos(endtile, &affected_trains, &UpdateTrainPowerProc);
for (Vehicle *v : VehiclesOnTile(tile)) {
if (v->type == VEH_TRAIN) include(affected_trains, Train::From(v)->First());
}
for (Vehicle *v : VehiclesOnTile(endtile)) {
if (v->type == VEH_TRAIN) include(affected_trains, Train::From(v)->First());
}
YapfNotifyTrackLayoutChange(tile, track);
YapfNotifyTrackLayoutChange(endtile, track);
@@ -1919,24 +1914,19 @@ static void DrawSingleSignal(TileIndex tile, const RailTypeInfo *rti, Track trac
sprite += type * 16 + variant * 64 + image * 2 + condition + (type > SIGTYPE_LAST_NOPBS ? 64 : 0);
}
AddSortableSpriteToDraw(sprite, PAL_NONE, x, y, 1, 1, BB_HEIGHT_UNDER_BRIDGE, GetSaveSlopeZ(x, y, track));
AddSortableSpriteToDraw(sprite, PAL_NONE, x, y, GetSaveSlopeZ(x, y, track), {{}, {1, 1, BB_HEIGHT_UNDER_BRIDGE}, {}});
}
static uint32_t _drawtile_track_palette;
/** Offsets for drawing fences */
struct FenceOffset {
Corner height_ref; //!< Corner to use height offset from.
int x_offs; //!< Bounding box X offset.
int y_offs; //!< Bounding box Y offset.
int x_size; //!< Bounding box X size.
int y_size; //!< Bounding box Y size.
struct FenceOffset : SpriteBounds {
Corner height_ref; ///< Corner to use height offset from.
constexpr FenceOffset(Corner height_ref, int8_t origin_x, int8_t origin_y, uint8_t extent_x, uint8_t extent_y) :
SpriteBounds({origin_x, origin_y, 0}, {extent_x, extent_y, 4}, {}), height_ref(height_ref) {}
};
/** Offsets for drawing fences */
static FenceOffset _fence_offsets[] = {
static const FenceOffset _fence_offsets[] = {
{ CORNER_INVALID, 0, 1, 16, 1 }, // RFO_FLAT_X_NW
{ CORNER_INVALID, 1, 0, 1, 16 }, // RFO_FLAT_Y_NE
{ CORNER_W, 8, 8, 1, 1 }, // RFO_FLAT_LEFT
@@ -1962,58 +1952,53 @@ static FenceOffset _fence_offsets[] = {
* @param num_sprites Number of fence sprites.
* @param rfo Fence to draw.
*/
static void DrawTrackFence(const TileInfo *ti, SpriteID base_image, uint num_sprites, RailFenceOffset rfo)
static void DrawTrackFence(const TileInfo *ti, const PalSpriteID &psid, uint num_sprites, RailFenceOffset rfo)
{
int z = ti->z;
if (_fence_offsets[rfo].height_ref != CORNER_INVALID) {
z += GetSlopePixelZInCorner(RemoveHalftileSlope(ti->tileh), _fence_offsets[rfo].height_ref);
}
AddSortableSpriteToDraw(base_image + (rfo % num_sprites), _drawtile_track_palette,
ti->x + _fence_offsets[rfo].x_offs,
ti->y + _fence_offsets[rfo].y_offs,
_fence_offsets[rfo].x_size,
_fence_offsets[rfo].y_size,
4, z);
AddSortableSpriteToDraw(psid.sprite + (rfo % num_sprites), psid.pal, ti->x, ti->y, z, _fence_offsets[rfo]);
}
/**
* Draw fence at NW border matching the tile slope.
*/
static void DrawTrackFence_NW(const TileInfo *ti, SpriteID base_image, uint num_sprites)
static void DrawTrackFence_NW(const TileInfo *ti, const PalSpriteID &psid, uint num_sprites)
{
RailFenceOffset rfo = RFO_FLAT_X_NW;
if (ti->tileh & SLOPE_NW) rfo = (ti->tileh & SLOPE_W) ? RFO_SLOPE_SW_NW : RFO_SLOPE_NE_NW;
DrawTrackFence(ti, base_image, num_sprites, rfo);
DrawTrackFence(ti, psid, num_sprites, rfo);
}
/**
* Draw fence at SE border matching the tile slope.
*/
static void DrawTrackFence_SE(const TileInfo *ti, SpriteID base_image, uint num_sprites)
static void DrawTrackFence_SE(const TileInfo *ti, const PalSpriteID &psid, uint num_sprites)
{
RailFenceOffset rfo = RFO_FLAT_X_SE;
if (ti->tileh & SLOPE_SE) rfo = (ti->tileh & SLOPE_S) ? RFO_SLOPE_SW_SE : RFO_SLOPE_NE_SE;
DrawTrackFence(ti, base_image, num_sprites, rfo);
DrawTrackFence(ti, psid, num_sprites, rfo);
}
/**
* Draw fence at NE border matching the tile slope.
*/
static void DrawTrackFence_NE(const TileInfo *ti, SpriteID base_image, uint num_sprites)
static void DrawTrackFence_NE(const TileInfo *ti, const PalSpriteID &psid, uint num_sprites)
{
RailFenceOffset rfo = RFO_FLAT_Y_NE;
if (ti->tileh & SLOPE_NE) rfo = (ti->tileh & SLOPE_E) ? RFO_SLOPE_SE_NE : RFO_SLOPE_NW_NE;
DrawTrackFence(ti, base_image, num_sprites, rfo);
DrawTrackFence(ti, psid, num_sprites, rfo);
}
/**
* Draw fence at SW border matching the tile slope.
*/
static void DrawTrackFence_SW(const TileInfo *ti, SpriteID base_image, uint num_sprites)
static void DrawTrackFence_SW(const TileInfo *ti, const PalSpriteID &psid, uint num_sprites)
{
RailFenceOffset rfo = RFO_FLAT_Y_SW;
if (ti->tileh & SLOPE_SW) rfo = (ti->tileh & SLOPE_S) ? RFO_SLOPE_SE_SW : RFO_SLOPE_NW_SW;
DrawTrackFence(ti, base_image, num_sprites, rfo);
DrawTrackFence(ti, psid, num_sprites, rfo);
}
/**
@@ -2021,32 +2006,35 @@ static void DrawTrackFence_SW(const TileInfo *ti, SpriteID base_image, uint num_
* @param ti Tile drawing information.
* @param rti Rail type information.
*/
static void DrawTrackDetails(const TileInfo *ti, const RailTypeInfo *rti)
static void DrawTrackDetails(const TileInfo *ti, const RailTypeInfo *rti, PaletteID pal)
{
/* Base sprite for track fences.
* Note: Halftile slopes only have fences on the upper part. */
uint num_sprites = 0;
SpriteID base_image = GetCustomRailSprite(rti, ti->tile, RTSG_FENCES, IsHalftileSlope(ti->tileh) ? TCX_UPPER_HALFTILE : TCX_NORMAL, &num_sprites);
if (base_image == 0) {
base_image = SPR_TRACK_FENCE_FLAT_X;
PalSpriteID psid{
.sprite = GetCustomRailSprite(rti, ti->tile, RTSG_FENCES, IsHalftileSlope(ti->tileh) ? TCX_UPPER_HALFTILE : TCX_NORMAL, &num_sprites),
.pal = pal,
};
if (psid.sprite == 0) {
psid.sprite = SPR_TRACK_FENCE_FLAT_X;
num_sprites = 8;
}
assert(num_sprites > 0);
switch (GetRailGroundType(ti->tile)) {
case RAIL_GROUND_FENCE_NW: DrawTrackFence_NW(ti, base_image, num_sprites); break;
case RAIL_GROUND_FENCE_SE: DrawTrackFence_SE(ti, base_image, num_sprites); break;
case RAIL_GROUND_FENCE_SENW: DrawTrackFence_NW(ti, base_image, num_sprites);
DrawTrackFence_SE(ti, base_image, num_sprites); break;
case RAIL_GROUND_FENCE_NE: DrawTrackFence_NE(ti, base_image, num_sprites); break;
case RAIL_GROUND_FENCE_SW: DrawTrackFence_SW(ti, base_image, num_sprites); break;
case RAIL_GROUND_FENCE_NESW: DrawTrackFence_NE(ti, base_image, num_sprites);
DrawTrackFence_SW(ti, base_image, num_sprites); break;
case RAIL_GROUND_FENCE_VERT1: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_LEFT); break;
case RAIL_GROUND_FENCE_VERT2: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_RIGHT); break;
case RAIL_GROUND_FENCE_HORIZ1: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_UPPER); break;
case RAIL_GROUND_FENCE_HORIZ2: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_LOWER); break;
case RAIL_GROUND_FENCE_NW: DrawTrackFence_NW(ti, psid, num_sprites); break;
case RAIL_GROUND_FENCE_SE: DrawTrackFence_SE(ti, psid, num_sprites); break;
case RAIL_GROUND_FENCE_SENW: DrawTrackFence_NW(ti, psid, num_sprites);
DrawTrackFence_SE(ti, psid, num_sprites); break;
case RAIL_GROUND_FENCE_NE: DrawTrackFence_NE(ti, psid, num_sprites); break;
case RAIL_GROUND_FENCE_SW: DrawTrackFence_SW(ti, psid, num_sprites); break;
case RAIL_GROUND_FENCE_NESW: DrawTrackFence_NE(ti, psid, num_sprites);
DrawTrackFence_SW(ti, psid, num_sprites); break;
case RAIL_GROUND_FENCE_VERT1: DrawTrackFence(ti, psid, num_sprites, RFO_FLAT_LEFT); break;
case RAIL_GROUND_FENCE_VERT2: DrawTrackFence(ti, psid, num_sprites, RFO_FLAT_RIGHT); break;
case RAIL_GROUND_FENCE_HORIZ1: DrawTrackFence(ti, psid, num_sprites, RFO_FLAT_UPPER); break;
case RAIL_GROUND_FENCE_HORIZ2: DrawTrackFence(ti, psid, num_sprites, RFO_FLAT_LOWER); break;
case RAIL_GROUND_WATER: {
Corner track_corner;
if (IsHalftileSlope(ti->tileh)) {
@@ -2057,10 +2045,10 @@ static void DrawTrackDetails(const TileInfo *ti, const RailTypeInfo *rti)
track_corner = OppositeCorner(GetHighestSlopeCorner(ComplementSlope(ti->tileh)));
}
switch (track_corner) {
case CORNER_W: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_LEFT); break;
case CORNER_S: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_LOWER); break;
case CORNER_E: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_RIGHT); break;
case CORNER_N: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_UPPER); break;
case CORNER_W: DrawTrackFence(ti, psid, num_sprites, RFO_FLAT_LEFT); break;
case CORNER_S: DrawTrackFence(ti, psid, num_sprites, RFO_FLAT_LOWER); break;
case CORNER_E: DrawTrackFence(ti, psid, num_sprites, RFO_FLAT_RIGHT); break;
case CORNER_N: DrawTrackFence(ti, psid, num_sprites, RFO_FLAT_UPPER); break;
default: NOT_REACHED();
}
break;
@@ -2436,32 +2424,38 @@ static void DrawSignals(TileIndex tile, TrackBits rails, const RailTypeInfo *rti
static void DrawTile_Track(TileInfo *ti)
{
const RailTypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile));
_drawtile_track_palette = COMPANY_SPRITE_COLOUR(GetTileOwner(ti->tile));
BridgePillarFlags blocked_pillars{};
PaletteID pal = GetCompanyPalette(GetTileOwner(ti->tile));
if (IsPlainRail(ti->tile)) {
TrackBits rails = GetTrackBits(ti->tile);
DrawTrackBits(ti, rails);
if (HasBit(_display_opt, DO_FULL_DETAIL)) DrawTrackDetails(ti, rti);
if (HasBit(_display_opt, DO_FULL_DETAIL)) DrawTrackDetails(ti, rti, pal);
if (HasRailCatenaryDrawn(GetRailType(ti->tile))) DrawRailCatenary(ti);
if (HasSignals(ti->tile)) DrawSignals(ti->tile, rails, rti);
if (IsBridgeAbove(ti->tile)) {
if ((rails & TRACK_BIT_3WAY_NE) != 0) blocked_pillars.Set(BridgePillarFlag::EdgeNE);
if ((rails & TRACK_BIT_3WAY_SE) != 0) blocked_pillars.Set(BridgePillarFlag::EdgeSE);
if ((rails & TRACK_BIT_3WAY_SW) != 0) blocked_pillars.Set(BridgePillarFlag::EdgeSW);
if ((rails & TRACK_BIT_3WAY_NW) != 0) blocked_pillars.Set(BridgePillarFlag::EdgeNW);
}
} else {
/* draw depot */
const DrawTileSprites *dts;
PaletteID pal = PAL_NONE;
SpriteID relocation;
DiagDirection dir = GetRailDepotDirection(ti->tile);
if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED);
if (IsInvisibilitySet(TO_BUILDINGS)) {
/* Draw rail instead of depot */
dts = &_depot_invisible_gfx_table[GetRailDepotDirection(ti->tile)];
dts = &_depot_invisible_gfx_table[dir];
} else {
dts = &_depot_gfx_table[GetRailDepotDirection(ti->tile)];
dts = &_depot_gfx_table[dir];
}
SpriteID image;
@@ -2481,7 +2475,7 @@ static void DrawTile_Track(TileInfo *ti)
}
}
DrawGroundSprite(image, GroundSpritePaletteTransform(image, pal, _drawtile_track_palette));
DrawGroundSprite(image, GroundSpritePaletteTransform(image, PAL_NONE, pal));
if (rti->UsesOverlay()) {
SpriteID ground = GetCustomRailSprite(rti, ti->tile, RTSG_GROUND);
@@ -2545,13 +2539,14 @@ static void DrawTile_Track(TileInfo *ti)
}
}
int depot_sprite = GetCustomRailSprite(rti, ti->tile, RTSG_DEPOT);
relocation = depot_sprite != 0 ? depot_sprite - SPR_RAIL_DEPOT_SE_1 : rti->GetRailtypeSpriteOffset();
int relocation = depot_sprite != 0 ? depot_sprite - SPR_RAIL_DEPOT_SE_1 : rti->GetRailtypeSpriteOffset();
if (HasRailCatenaryDrawn(GetRailType(ti->tile))) DrawRailCatenary(ti);
DrawRailTileSeq(ti, dts, TO_BUILDINGS, relocation, 0, _drawtile_track_palette);
DrawRailTileSeq(ti, dts, TO_BUILDINGS, relocation, 0, pal);
/* Depots can't have bridges above so no blocked pillars. */
}
DrawBridgeMiddle(ti);
DrawBridgeMiddle(ti, blocked_pillars);
}
void DrawTrainDepotSprite(int x, int y, int dir, RailType railtype)
@@ -2562,7 +2557,7 @@ void DrawTrainDepotSprite(int x, int y, int dir, RailType railtype)
uint32_t offset = rti->GetRailtypeSpriteOffset();
if (image != SPR_FLAT_GRASS_TILE) image += offset;
PaletteID palette = COMPANY_SPRITE_COLOUR(_local_company);
PaletteID palette = GetCompanyPalette(_local_company);
DrawSprite(image, PAL_NONE, x, y);
@@ -2684,7 +2679,7 @@ static void TileLoop_Track(TileIndex tile)
TrackBits rail = GetTrackBits(tile);
Owner owner = GetTileOwner(tile);
uint8_t fences = 0;
DiagDirections fences{};
for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; d++) {
static const TrackBits dir_to_trackbits[DIAGDIR_END] = {TRACK_BIT_3WAY_NE, TRACK_BIT_3WAY_SE, TRACK_BIT_3WAY_SW, TRACK_BIT_3WAY_NW};
@@ -2697,22 +2692,22 @@ static void TileLoop_Track(TileIndex tile)
/* Show fences if it's a house, industry, object, road, tunnelbridge or not owned by us. */
if (!IsValidTile(tile2) || IsTileType(tile2, MP_HOUSE) || IsTileType(tile2, MP_INDUSTRY) ||
IsTileType(tile2, MP_ROAD) || (IsTileType(tile2, MP_OBJECT) && !IsObjectType(tile2, OBJECT_OWNED_LAND)) || IsTileType(tile2, MP_TUNNELBRIDGE) || !IsTileOwner(tile2, owner)) {
fences |= 1 << d;
fences.Set(d);
}
}
switch (fences) {
case 0: break;
case (1 << DIAGDIR_NE): new_ground = RAIL_GROUND_FENCE_NE; break;
case (1 << DIAGDIR_SE): new_ground = RAIL_GROUND_FENCE_SE; break;
case (1 << DIAGDIR_SW): new_ground = RAIL_GROUND_FENCE_SW; break;
case (1 << DIAGDIR_NW): new_ground = RAIL_GROUND_FENCE_NW; break;
case (1 << DIAGDIR_NE) | (1 << DIAGDIR_SW): new_ground = RAIL_GROUND_FENCE_NESW; break;
case (1 << DIAGDIR_SE) | (1 << DIAGDIR_NW): new_ground = RAIL_GROUND_FENCE_SENW; break;
case (1 << DIAGDIR_NE) | (1 << DIAGDIR_SE): new_ground = RAIL_GROUND_FENCE_VERT1; break;
case (1 << DIAGDIR_NE) | (1 << DIAGDIR_NW): new_ground = RAIL_GROUND_FENCE_HORIZ2; break;
case (1 << DIAGDIR_SE) | (1 << DIAGDIR_SW): new_ground = RAIL_GROUND_FENCE_HORIZ1; break;
case (1 << DIAGDIR_SW) | (1 << DIAGDIR_NW): new_ground = RAIL_GROUND_FENCE_VERT2; break;
switch (fences.base()) {
case DiagDirections{}.base(): break;
case DiagDirections{DIAGDIR_NE}.base(): new_ground = RAIL_GROUND_FENCE_NE; break;
case DiagDirections{DIAGDIR_SE}.base(): new_ground = RAIL_GROUND_FENCE_SE; break;
case DiagDirections{DIAGDIR_SW}.base(): new_ground = RAIL_GROUND_FENCE_SW; break;
case DiagDirections{DIAGDIR_NW}.base(): new_ground = RAIL_GROUND_FENCE_NW; break;
case DiagDirections{DIAGDIR_NE, DIAGDIR_SW}.base(): new_ground = RAIL_GROUND_FENCE_NESW; break;
case DiagDirections{DIAGDIR_SE, DIAGDIR_NW}.base(): new_ground = RAIL_GROUND_FENCE_SENW; break;
case DiagDirections{DIAGDIR_NE, DIAGDIR_SE}.base(): new_ground = RAIL_GROUND_FENCE_VERT1; break;
case DiagDirections{DIAGDIR_NE, DIAGDIR_NW}.base(): new_ground = RAIL_GROUND_FENCE_HORIZ2; break;
case DiagDirections{DIAGDIR_SE, DIAGDIR_SW}.base(): new_ground = RAIL_GROUND_FENCE_HORIZ1; break;
case DiagDirections{DIAGDIR_SW, DIAGDIR_NW}.base(): new_ground = RAIL_GROUND_FENCE_VERT2; break;
default: NOT_REACHED();
}
}
@@ -2948,10 +2943,10 @@ int TicksToLeaveDepot(const Train *v)
* Tile callback routine when vehicle enters tile
* @see vehicle_enter_tile_proc
*/
static VehicleEnterTileStatus VehicleEnter_Track(Vehicle *u, TileIndex tile, int x, int y)
static VehicleEnterTileStates VehicleEnter_Track(Vehicle *u, TileIndex tile, int x, int y)
{
/* This routine applies only to trains in depot tiles. */
if (u->type != VEH_TRAIN || !IsRailDepotTile(tile)) return VETSB_CONTINUE;
if (u->type != VEH_TRAIN || !IsRailDepotTile(tile)) return {};
/* Depot direction. */
DiagDirection dir = GetRailDepotDirection(tile);
@@ -2959,7 +2954,7 @@ static VehicleEnterTileStatus VehicleEnter_Track(Vehicle *u, TileIndex tile, int
uint8_t fract_coord = (x & 0xF) + ((y & 0xF) << 4);
/* Make sure a train is not entering the tile from behind. */
if (_fractcoords_behind[dir] == fract_coord) return VETSB_CANNOT_ENTER;
if (_fractcoords_behind[dir] == fract_coord) return VehicleEnterTileState::CannotEnter;
Train *v = Train::From(u);
@@ -2991,10 +2986,10 @@ static VehicleEnterTileStatus VehicleEnter_Track(Vehicle *u, TileIndex tile, int
v->tile = tile;
InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
return VETSB_ENTERED_WORMHOLE;
return VehicleEnterTileState::EnteredWormhole;
}
return VETSB_CONTINUE;
return {};
}
/**
@@ -3047,14 +3042,6 @@ static CommandCost TestAutoslopeOnRailTile(TileIndex tile, DoCommandFlags flags,
return cost;
}
/**
* Test-procedure for HasVehicleOnPos to check for a ship.
*/
static Vehicle *EnsureNoShipProc(Vehicle *v, void *)
{
return v->type == VEH_SHIP ? v : nullptr;
}
static CommandCost TerraformTile_Track(TileIndex tile, DoCommandFlags flags, int z_new, Slope tileh_new)
{
auto [tileh_old, z_old] = GetTileSlopeZ(tile);
@@ -3064,7 +3051,9 @@ static CommandCost TerraformTile_Track(TileIndex tile, DoCommandFlags flags, int
bool was_water = (GetRailGroundType(tile) == RAIL_GROUND_WATER && IsSlopeWithOneCornerRaised(tileh_old));
/* Allow clearing the water only if there is no ship */
if (was_water && HasVehicleOnPos(tile, nullptr, &EnsureNoShipProc)) return CommandCost(STR_ERROR_SHIP_IN_THE_WAY);
if (was_water && HasVehicleOnTile(tile, [](const Vehicle *v) {
return v->type == VEH_SHIP;
})) return CommandCost(STR_ERROR_SHIP_IN_THE_WAY);
/* First test autoslope. However if it succeeds we still have to test the rest, because non-autoslope terraforming is cheaper. */
CommandCost autoslope_result = TestAutoslopeOnRailTile(tile, flags, z_old, tileh_old, z_new, tileh_new, rail_bits);
@@ -3102,6 +3091,11 @@ static CommandCost TerraformTile_Track(TileIndex tile, DoCommandFlags flags, int
return Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile);
}
static CommandCost CheckBuildAbove_Track(TileIndex tile, DoCommandFlags flags, Axis, int)
{
if (IsPlainRail(tile)) return CommandCost();
return Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile);
}
extern const TileTypeProcs _tile_type_rail_procs = {
DrawTile_Track, // draw_tile_proc
@@ -3118,4 +3112,5 @@ extern const TileTypeProcs _tile_type_rail_procs = {
VehicleEnter_Track, // vehicle_enter_tile_proc
GetFoundation_Track, // get_foundation_proc
TerraformTile_Track, // terraform_tile_proc
CheckBuildAbove_Track, // check_build_above_proc
};