From 2f4f4c4056e244dfb45cd5aded80781af15376f3 Mon Sep 17 00:00:00 2001 From: Erich Eckner Date: Wed, 21 Nov 2018 14:17:43 +0100 Subject: openttd-git: everything.patch -> signaltunnel.patch, sloped-stations.patch, underground.patch --- openttd-git/sloped-stations.patch | 436 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 436 insertions(+) create mode 100644 openttd-git/sloped-stations.patch (limited to 'openttd-git/sloped-stations.patch') diff --git a/openttd-git/sloped-stations.patch b/openttd-git/sloped-stations.patch new file mode 100644 index 00000000..ee682db6 --- /dev/null +++ b/openttd-git/sloped-stations.patch @@ -0,0 +1,436 @@ +diff --git a/src/rail_cmd.cpp b/src/rail_cmd.cpp +index a0fd968cc6..980e2fb42b 100644 +--- a/src/rail_cmd.cpp ++++ b/src/rail_cmd.cpp +@@ -186,14 +186,6 @@ RailType AllocateRailType(RailTypeLabel label) + return INVALID_RAILTYPE; + } + +-static const byte _track_sloped_sprites[14] = { +- 14, 15, 22, 13, +- 0, 21, 17, 12, +- 23, 0, 18, 20, +- 19, 16 +-}; +- +- + /* 4 + * --------- + * |\ /| +diff --git a/src/road_cmd.cpp b/src/road_cmd.cpp +index bdc8ce7f30..b1c1744eee 100644 +--- a/src/road_cmd.cpp ++++ b/src/road_cmd.cpp +@@ -35,6 +35,7 @@ + #include "date_func.h" + #include "genworld.h" + #include "company_gui.h" ++#include "road_cmd.h" + + #include "table/strings.h" + +@@ -101,8 +102,6 @@ static const RoadBits _invalid_tileh_slopes_road[2][15] = { + } + }; + +-static Foundation GetRoadFoundation(Slope tileh, RoadBits bits); +- + /** + * Is it allowed to remove the given road bits from the given tile? + * @param tile the tile to remove the road from +@@ -1143,7 +1142,7 @@ struct DrawRoadTileStruct { + * @param bits The RoadBits part + * @return The resulting Foundation + */ +-static Foundation GetRoadFoundation(Slope tileh, RoadBits bits) ++Foundation GetRoadFoundation(Slope tileh, RoadBits bits) + { + /* Flat land and land without a road doesn't require a foundation */ + if (tileh == SLOPE_FLAT || bits == ROAD_NONE) return FOUNDATION_NONE; +@@ -1165,13 +1164,6 @@ static Foundation GetRoadFoundation(Slope tileh, RoadBits bits) + return (bits == ROAD_X ? FOUNDATION_INCLINED_X : FOUNDATION_INCLINED_Y); + } + +-const byte _road_sloped_sprites[14] = { +- 0, 0, 2, 0, +- 0, 1, 0, 0, +- 3, 0, 0, 0, +- 0, 0 +-}; +- + /** + * Should the road be drawn as a unpaved snow/desert road? + * By default, roads are always drawn as unpaved if they are on desert or +diff --git a/src/road_cmd.h b/src/road_cmd.h +index 3cf588dcd6..2a0da61427 100644 +--- a/src/road_cmd.h ++++ b/src/road_cmd.h +@@ -14,8 +14,11 @@ + + #include "direction_type.h" + #include "road_type.h" ++#include "slope_type.h" + + void DrawRoadDepotSprite(int x, int y, DiagDirection dir, RoadType rt); + void UpdateNearestTownForRoadTiles(bool invalidate); + ++Foundation GetRoadFoundation(Slope tileh, RoadBits bits); ++ + #endif /* ROAD_CMD_H */ +diff --git a/src/road_type.h b/src/road_type.h +index 5251a53923..ce9ac81518 100644 +--- a/src/road_type.h ++++ b/src/road_type.h +@@ -73,4 +73,11 @@ enum RoadBits { + DECLARE_ENUM_AS_BIT_SET(RoadBits) + template <> struct EnumPropsT : MakeEnumPropsT {}; + ++const byte _road_sloped_sprites[14] = { ++ 0, 0, 2, 0, ++ 0, 1, 0, 0, ++ 3, 0, 0, 0, ++ 0, 0 ++}; ++ + #endif /* ROAD_TYPE_H */ +diff --git a/src/station_cmd.cpp b/src/station_cmd.cpp +index 16f135df25..726205fd8b 100644 +--- a/src/station_cmd.cpp ++++ b/src/station_cmd.cpp +@@ -53,6 +53,7 @@ + #include "linkgraph/linkgraph_base.h" + #include "linkgraph/refresh.h" + #include "widgets/station_widget.h" ++#include "road_cmd.h" + + #include "table/strings.h" + +@@ -721,7 +722,7 @@ CommandCost ClearTile_Station(TileIndex tile, DoCommandFlag flags); + * Checks if the given tile is buildable, flat and has a certain height. + * @param tile TileIndex to check. + * @param invalid_dirs Prohibited directions for slopes (set of #DiagDirection). +- * @param allowed_z Height allowed for the tile. If allowed_z is negative, it will be set to the height of this tile. ++ * @param allowed_z Height allowed for the tile. If allowed_z is -1, it will be set to the height of this tile. + * @param allow_steep Whether steep slopes are allowed. + * @param check_bridge Check for the existence of a bridge. + * @return The cost in case of success, or an error code if it failed. +@@ -760,10 +761,10 @@ CommandCost CheckBuildableTile(TileIndex tile, uint invalid_dirs, int &allowed_z + } + + /* The level of this tile must be equal to allowed_z. */ +- if (allowed_z < 0) { ++ if (allowed_z == -1) { + /* First tile. */ + allowed_z = flat_z; +- } else if (allowed_z != flat_z) { ++ } else if (allowed_z != flat_z && allowed_z >= 0) { + return_cmd_error(STR_ERROR_FLAT_LAND_REQUIRED); + } + +@@ -811,14 +812,14 @@ CommandCost CheckFlatLand(TileArea tile_area, DoCommandFlag flags) + static CommandCost CheckFlatLandRailStation(TileArea tile_area, DoCommandFlag flags, Axis axis, StationID *station, RailType rt, SmallVector &affected_vehicles, StationClassID spec_class, byte spec_index, byte plat_len, byte numtracks) + { + CommandCost cost(EXPENSES_CONSTRUCTION); +- int allowed_z = -1; ++ int allowed_z = -2; + uint invalid_dirs = 5 << axis; + + const StationSpec *statspec = StationClass::Get(spec_class)->GetSpec(spec_index); + bool slope_cb = statspec != NULL && HasBit(statspec->callback_mask, CBM_STATION_SLOPE_CHECK); + + TILE_AREA_LOOP(tile_cur, tile_area) { +- CommandCost ret = CheckBuildableTile(tile_cur, invalid_dirs, allowed_z, false); ++ CommandCost ret = CheckBuildableTile(tile_cur, 0, allowed_z, true); + if (ret.Failed()) return ret; + cost.AddCost(ret); + +@@ -897,10 +898,10 @@ static CommandCost CheckFlatLandRailStation(TileArea tile_area, DoCommandFlag fl + static CommandCost CheckFlatLandRoadStop(TileArea tile_area, DoCommandFlag flags, uint invalid_dirs, bool is_drive_through, bool is_truck_stop, Axis axis, StationID *station, RoadTypes rts) + { + CommandCost cost(EXPENSES_CONSTRUCTION); +- int allowed_z = -1; ++ int allowed_z = -2; + + TILE_AREA_LOOP(cur_tile, tile_area) { +- CommandCost ret = CheckBuildableTile(cur_tile, invalid_dirs, allowed_z, !is_drive_through); ++ CommandCost ret = CheckBuildableTile(cur_tile, invalid_dirs, allowed_z, true); + if (ret.Failed()) return ret; + cost.AddCost(ret); + +@@ -1803,7 +1804,7 @@ CommandCost CmdBuildRoadStop(TileIndex tile, DoCommandFlag flags, uint32 p1, uin + /* Total road stop cost. */ + CommandCost cost(EXPENSES_CONSTRUCTION, roadstop_area.w * roadstop_area.h * _price[type ? PR_BUILD_STATION_TRUCK : PR_BUILD_STATION_BUS]); + StationID est = INVALID_STATION; +- ret = CheckFlatLandRoadStop(roadstop_area, flags, is_drive_through ? 5 << axis : 1 << ddir, is_drive_through, type, axis, &est, rts); ++ ret = CheckFlatLandRoadStop(roadstop_area, flags, is_drive_through ? 0 : 1 << ddir, is_drive_through, type, axis, &est, rts); + if (ret.Failed()) return ret; + cost.AddCost(ret); + +@@ -2766,6 +2767,32 @@ static void DrawTile_Station(TileInfo *ti) + palette = PALETTE_TO_GREY; + } + ++ /* always draw leveled foundations only for airports and road bays! */ ++ if (ti->tileh != SLOPE_FLAT && (IsAirport(ti->tile) || IsStandardRoadStopTile(ti->tile))) ++ DrawFoundation(ti, FOUNDATION_LEVELED); ++ ++ if (HasStationTileRail(ti->tile) && IsCustomStationSpecIndex(ti->tile)) { ++ /* look for customization */ ++ st = BaseStation::GetByTile(ti->tile); ++ statspec = st->speclist[GetCustomStationSpecIndex(ti->tile)].spec; ++ ++ if (statspec != NULL) { ++ uint tile = GetStationGfx(ti->tile); ++ ++ relocation = GetCustomStationRelocation(statspec, st, ti->tile); ++ ++ if (HasBit(statspec->callback_mask, CBM_STATION_SPRITE_LAYOUT)) { ++ uint16 callback = GetStationCallback(CBID_STATION_SPRITE_LAYOUT, 0, 0, statspec, st, ti->tile); ++ if (callback != CALLBACK_FAILED) tile = (callback & ~1) + GetRailStationAxis(ti->tile); ++ } ++ ++ /* Ensure the chosen tile layout is valid for this custom station */ ++ if (statspec->renderdata != NULL) { ++ t = &statspec->renderdata[tile < statspec->tiles ? tile : (uint)GetRailStationAxis(ti->tile)]; ++ } ++ } ++ } ++ + if (layout == NULL && (t == NULL || t->seq == NULL)) t = GetStationTileLayout(GetStationType(ti->tile), gfx); + + /* don't show foundation for docks */ +@@ -2832,10 +2859,10 @@ static void DrawTile_Station(TileInfo *ti) + } + + OffsetGroundSprite(31, 1); +- ti->z += ApplyPixelFoundationToSlope(FOUNDATION_LEVELED, &ti->tileh); ++ ti->z += ApplyPixelFoundationToSlope(FOUNDATION_NONE, &ti->tileh); //FOUNDATION_LEVELED, &ti->tileh); + } else { + draw_default_foundation: +- DrawFoundation(ti, FOUNDATION_LEVELED); ++ DrawFoundation(ti, FOUNDATION_NONE); //FOUNDATION_LEVELED); + } + } + +@@ -2891,14 +2918,64 @@ draw_default_foundation: + DrawGroundSprite(overlay + overlay_offset, PALETTE_CRASH); + } + } else { +- image += HasBit(image, SPRITE_MODIFIER_CUSTOM_SPRITE) ? ground_relocation : total_offset; +- if (HasBit(pal, SPRITE_MODIFIER_CUSTOM_SPRITE)) pal += ground_relocation; ++ if (HasBit(pal, SPRITE_MODIFIER_CUSTOM_SPRITE)) { ++ pal += ground_relocation; ++ } else { ++ if (HasBit(image, SPRITE_MODIFIER_CUSTOM_SPRITE)) { ++ image += ground_relocation; ++ } else { ++ if (ti->tileh != SLOPE_FLAT && (IsRailStation(ti->tile) || IsRoadStop(ti->tile))) { ++ /* It's a sloped rail station? */ ++ Foundation rf = FOUNDATION_NONE; ++ if (IsRoadStop(ti->tile)) { ++ /* Roadstops without foundation on a slope ++ * and on Slopes with one corner raised */ ++ rf = GetRoadFoundation(ti->tileh, AxisToRoadBits(DiagDirToAxis(GetRoadStopDir(ti->tile)))); ++ DrawFoundation(ti, rf); ++ /* Draws the sloped road */ ++ if (ti->tileh != SLOPE_FLAT) image = _road_sloped_sprites[ti->tileh - 1] + 0x53F; ++ } else { ++ /* sloped rail station */ ++ TrackBits track = AxisToTrackBits(GetRailStationAxis(ti->tile)); ++ rf = GetRailFoundation(ti->tileh, track); ++ DrawFoundation(ti, rf); ++ if (rf != FOUNDATION_LEVELED) { ++ image = _track_sloped_sprites[ti->tileh - 1] + rti->base_sprites.track_y; ++ } else { ++ (image = rti->base_sprites.track_y, track == TRACK_BIT_Y ) || (image++, track == TRACK_BIT_X); ++ } ++ } ++ } else { ++ /* it's not a slope */ ++ image += total_offset; ++ } ++ } ++ } + DrawGroundSprite(image, GroundSpritePaletteTransform(image, pal, palette)); + + /* PBS debugging, draw reserved tracks darker */ + if (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation && HasStationRail(ti->tile) && HasStationReservation(ti->tile)) { + const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile)); +- DrawGroundSprite(GetRailStationAxis(ti->tile) == AXIS_X ? rti->base_sprites.single_x : rti->base_sprites.single_y, PALETTE_CRASH); ++ TrackBits pbs = AxisToTrackBits(GetRailStationAxis(ti->tile)); ++ // TODO: possibly inverted in 7b136d1fddbb2d0840076dfe2ddbe666b29fee8d ++ if (pbs & TRACK_BIT_X) { ++ if (ti->tileh == SLOPE_FLAT || ti->tileh == SLOPE_ELEVATED) { ++ DrawGroundSprite(rti->base_sprites.single_y, PALETTE_CRASH); ++ } else { ++ DrawGroundSprite(_track_sloped_sprites[ti->tileh - 1] + rti->base_sprites.single_sloped - 20, PALETTE_CRASH); ++ } ++ } ++ if (pbs & TRACK_BIT_Y) { ++ if (ti->tileh == SLOPE_FLAT || ti->tileh == SLOPE_ELEVATED) { ++ DrawGroundSprite(rti->base_sprites.single_x, PALETTE_CRASH); ++ } else { ++ DrawGroundSprite(_track_sloped_sprites[ti->tileh - 1] + rti->base_sprites.single_sloped - 20, PALETTE_CRASH); ++ } ++ } ++ if (pbs & TRACK_BIT_UPPER) AddSortableSpriteToDraw(rti->base_sprites.single_n, PALETTE_CRASH, ti->x, ti->y, 16, 16, 0, ti->z + (ti->tileh & SLOPE_N ? 8 : 0)); ++ if (pbs & TRACK_BIT_LOWER) AddSortableSpriteToDraw(rti->base_sprites.single_s, PALETTE_CRASH, ti->x, ti->y, 16, 16, 0, ti->z + (ti->tileh & SLOPE_S ? 8 : 0)); ++ if (pbs & TRACK_BIT_LEFT) AddSortableSpriteToDraw(rti->base_sprites.single_w, PALETTE_CRASH, ti->x, ti->y, 16, 16, 0, ti->z + (ti->tileh & SLOPE_W ? 8 : 0)); ++ if (pbs & TRACK_BIT_RIGHT) AddSortableSpriteToDraw(rti->base_sprites.single_e, PALETTE_CRASH, ti->x, ti->y, 16, 16, 0, ti->z + (ti->tileh & SLOPE_E ? 8 : 0)); + } + } + } +@@ -2951,6 +3028,16 @@ void StationPickerDrawSprite(int x, int y, StationType st, RailType railtype, Ro + + static int GetSlopePixelZ_Station(TileIndex tile, uint x, uint y) + { ++ /* this code makes vehicles and trains follow the slope on sloped stations */ ++ if (IsRailStation(tile)) { ++ int z; ++ Slope tileh = GetTilePixelSlope(tile, &z); ++ Axis axis = GetRailStationAxis(tile); ++ ++ z += 8*ApplyFoundationToSlope(GetRailFoundation(tileh,AxisToTrackBits(axis)), &tileh); ++ return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh); ++ } ++ + return GetTileMaxPixelZ(tile); + } + +diff --git a/src/table/sprites.h b/src/table/sprites.h +index 81d5388f99..12ef72840f 100644 +--- a/src/table/sprites.h ++++ b/src/table/sprites.h +@@ -255,7 +255,26 @@ static const SpriteID SPR_TRUCK_STOP_DT_Y_W = SPR_ROADSTOP_BASE + 4; + static const SpriteID SPR_TRUCK_STOP_DT_Y_E = SPR_ROADSTOP_BASE + 5; + static const SpriteID SPR_TRUCK_STOP_DT_X_W = SPR_ROADSTOP_BASE + 6; + static const SpriteID SPR_TRUCK_STOP_DT_X_E = SPR_ROADSTOP_BASE + 7; +-static const uint16 ROADSTOP_SPRITE_COUNT = 8; ++ ++/* sprites for sloped graphics */ ++static const SpriteID SPR_BUS_STOP_DT_SE_W = SPR_ROADSTOP_BASE + 12; ++static const SpriteID SPR_BUS_STOP_DT_SE_E = SPR_ROADSTOP_BASE + 13; ++static const SpriteID SPR_BUS_STOP_DT_NE_E = SPR_ROADSTOP_BASE + 14; ++static const SpriteID SPR_BUS_STOP_DT_NE_W = SPR_ROADSTOP_BASE + 15; ++static const SpriteID SPR_BUS_STOP_DT_NW_W = SPR_ROADSTOP_BASE + 16; ++static const SpriteID SPR_BUS_STOP_DT_NW_E = SPR_ROADSTOP_BASE + 17; ++static const SpriteID SPR_BUS_STOP_DT_SW_E = SPR_ROADSTOP_BASE + 18; ++static const SpriteID SPR_BUS_STOP_DT_SW_W = SPR_ROADSTOP_BASE + 19; ++static const SpriteID SPR_TRUCK_STOP_DT_SE_W = SPR_ROADSTOP_BASE + 20; ++static const SpriteID SPR_TRUCK_STOP_DT_SE_E = SPR_ROADSTOP_BASE + 21; ++static const SpriteID SPR_TRUCK_STOP_DT_NE_E = SPR_ROADSTOP_BASE + 22; ++static const SpriteID SPR_TRUCK_STOP_DT_NE_W = SPR_ROADSTOP_BASE + 23; ++static const SpriteID SPR_TRUCK_STOP_DT_NW_W = SPR_ROADSTOP_BASE + 24; ++static const SpriteID SPR_TRUCK_STOP_DT_NW_E = SPR_ROADSTOP_BASE + 25; ++static const SpriteID SPR_TRUCK_STOP_DT_SW_E = SPR_ROADSTOP_BASE + 26; ++static const SpriteID SPR_TRUCK_STOP_DT_SW_W = SPR_ROADSTOP_BASE + 27; ++ ++static const uint16 ROADSTOP_SPRITE_COUNT = 28; + + /** Tramway sprites */ + static const SpriteID SPR_TRAMWAY_BASE = SPR_ROADSTOP_BASE + ROADSTOP_SPRITE_COUNT; +diff --git a/src/table/station_land.h b/src/table/station_land.h +index 3327dab5dd..991c5d3bec 100644 +--- a/src/table/station_land.h ++++ b/src/table/station_land.h +@@ -777,6 +777,62 @@ static const DrawTileSeqStruct _station_display_datas_waypoint_Y[] = { + TILE_SEQ_END() + }; + ++// drive-through bus stop SE slope ++static const DrawTileSeqStruct _station_display_datas_0172[] = { ++ TILE_SEQ_LINE( 0, 0, 0, 16, 3, 16, SPR_BUS_STOP_DT_SE_W | (1 << PALETTE_MODIFIER_COLOUR)) ++ TILE_SEQ_LINE( 0, 13, 0, 16, 3, 16, SPR_BUS_STOP_DT_SE_E | (1 << PALETTE_MODIFIER_COLOUR)) ++ TILE_SEQ_END() ++}; ++ ++// drive-through bus stop NE slope ++static const DrawTileSeqStruct _station_display_datas_0173[] = { ++ TILE_SEQ_LINE( 0, 0, 0, 16, 3, 16, SPR_BUS_STOP_DT_NE_W | (1 << PALETTE_MODIFIER_COLOUR)) ++ TILE_SEQ_LINE( 0, 13, 0, 16, 3, 16, SPR_BUS_STOP_DT_NE_E | (1 << PALETTE_MODIFIER_COLOUR)) ++ TILE_SEQ_END() ++}; ++ ++// drive-through bus stop NW slope ++static const DrawTileSeqStruct _station_display_datas_0174[] = { ++ TILE_SEQ_LINE( 0, 0, 0, 16, 3, 16, SPR_BUS_STOP_DT_NW_W | (1 << PALETTE_MODIFIER_COLOUR)) ++ TILE_SEQ_LINE( 0, 13, 0, 16, 3, 16, SPR_BUS_STOP_DT_NW_E | (1 << PALETTE_MODIFIER_COLOUR)) ++ TILE_SEQ_END() ++}; ++ ++// drive-through bus stop SW slope ++static const DrawTileSeqStruct _station_display_datas_0175[] = { ++ TILE_SEQ_LINE( 0, 0, 0, 16, 3, 16, SPR_BUS_STOP_DT_SW_W | (1 << PALETTE_MODIFIER_COLOUR)) ++ TILE_SEQ_LINE( 0, 13, 0, 16, 3, 16, SPR_BUS_STOP_DT_SW_E | (1 << PALETTE_MODIFIER_COLOUR)) ++ TILE_SEQ_END() ++}; ++ ++// drive-through truck stop SE slope ++static const DrawTileSeqStruct _station_display_datas_0176[] = { ++ TILE_SEQ_LINE( 0, 0, 0, 16, 3, 16, SPR_TRUCK_STOP_DT_SE_W | (1 << PALETTE_MODIFIER_COLOUR)) ++ TILE_SEQ_LINE( 0, 13, 0, 16, 3, 16, SPR_TRUCK_STOP_DT_SE_E | (1 << PALETTE_MODIFIER_COLOUR)) ++ TILE_SEQ_END() ++}; ++ ++// drive-through truck stop NE slope ++static const DrawTileSeqStruct _station_display_datas_0177[] = { ++ TILE_SEQ_LINE( 0, 0, 0, 16, 3, 16, SPR_TRUCK_STOP_DT_NE_W | (1 << PALETTE_MODIFIER_COLOUR)) ++ TILE_SEQ_LINE( 0, 13, 0, 16, 3, 16, SPR_TRUCK_STOP_DT_NE_E | (1 << PALETTE_MODIFIER_COLOUR)) ++ TILE_SEQ_END() ++}; ++ ++// drive-through truck stop NW slope ++static const DrawTileSeqStruct _station_display_datas_0178[] = { ++ TILE_SEQ_LINE( 0, 0, 0, 16, 3, 16, SPR_TRUCK_STOP_DT_NW_W | (1 << PALETTE_MODIFIER_COLOUR)) ++ TILE_SEQ_LINE( 0, 13, 0, 16, 3, 16, SPR_TRUCK_STOP_DT_NW_E | (1 << PALETTE_MODIFIER_COLOUR)) ++ TILE_SEQ_END() ++}; ++ ++// drive-through truck stop SW slope ++static const DrawTileSeqStruct _station_display_datas_0179[] = { ++ TILE_SEQ_LINE( 0, 0, 0, 16, 3, 16, SPR_TRUCK_STOP_DT_SW_W | (1 << PALETTE_MODIFIER_COLOUR)) ++ TILE_SEQ_LINE( 0, 13, 0, 16, 3, 16, SPR_TRUCK_STOP_DT_SW_E | (1 << PALETTE_MODIFIER_COLOUR)) ++ TILE_SEQ_END() ++}; ++ + #undef TILE_SEQ_END + #undef TILE_SEQ_LINE + #undef TILE_SEQ_LINE_PAL +@@ -946,6 +1002,10 @@ static const DrawTileSprites _station_display_datas_truck[] = { + TILE_SPRITE_LINE(SPR_TRUCK_STOP_NW_GROUND | (1U << PALETTE_MODIFIER_COLOUR), _station_display_datas_70) + TILE_SPRITE_LINE(SPR_ROAD_PAVED_STRAIGHT_X, _station_display_datas_0168) + TILE_SPRITE_LINE(SPR_ROAD_PAVED_STRAIGHT_Y, _station_display_datas_0169) ++ TILE_SPRITE_LINE(SPR_ROAD_PAVED_STRAIGHT_X, _station_display_datas_0176) ++ TILE_SPRITE_LINE(SPR_ROAD_PAVED_STRAIGHT_Y, _station_display_datas_0177) ++ TILE_SPRITE_LINE(SPR_ROAD_PAVED_STRAIGHT_X, _station_display_datas_0178) ++ TILE_SPRITE_LINE(SPR_ROAD_PAVED_STRAIGHT_Y, _station_display_datas_0179) + }; + + static const DrawTileSprites _station_display_datas_bus[] = { +@@ -955,6 +1015,10 @@ static const DrawTileSprites _station_display_datas_bus[] = { + TILE_SPRITE_LINE(SPR_BUS_STOP_NW_GROUND | (1U << PALETTE_MODIFIER_COLOUR), _station_display_datas_74) + TILE_SPRITE_LINE(SPR_ROAD_PAVED_STRAIGHT_X, _station_display_datas_0170) + TILE_SPRITE_LINE(SPR_ROAD_PAVED_STRAIGHT_Y, _station_display_datas_0171) ++ TILE_SPRITE_LINE(SPR_ROAD_PAVED_STRAIGHT_X, _station_display_datas_0172) ++ TILE_SPRITE_LINE(SPR_ROAD_PAVED_STRAIGHT_Y, _station_display_datas_0173) ++ TILE_SPRITE_LINE(SPR_ROAD_PAVED_STRAIGHT_X, _station_display_datas_0174) ++ TILE_SPRITE_LINE(SPR_ROAD_PAVED_STRAIGHT_Y, _station_display_datas_0175) + }; + + static const DrawTileSprites _station_display_datas_oilrig[] = { +diff --git a/src/track_type.h b/src/track_type.h +index 2982288bba..a89fd708cd 100644 +--- a/src/track_type.h ++++ b/src/track_type.h +@@ -126,4 +126,11 @@ typedef SimpleTinyEnumT TrackdirBitsShort; + + typedef uint32 TrackStatus; + ++static const byte _track_sloped_sprites[14] = { ++ 14, 15, 22, 13, ++ 0, 21, 17, 12, ++ 23, 0, 18, 20, ++ 19, 16 ++}; ++ + #endif /* TRACK_TYPE_H */ -- cgit v1.2.3-54-g00ecf