From 114be07283e625ba2fc42a895a38d36b2ad4ac33 Mon Sep 17 00:00:00 2001 From: Erich Eckner Date: Sun, 3 Jan 2021 14:40:43 +0100 Subject: chunnel patch original --- src/CMakeLists.txt | 1 + src/ground_vehicle.cpp | 65 ++++++++++++++++++++ src/ground_vehicle.hpp | 14 ++++- src/industry_cmd.cpp | 6 ++ src/lang/english.txt | 7 +++ src/roadveh_cmd.cpp | 3 +- src/saveload/CMakeLists.txt | 1 + src/saveload/afterload.cpp | 48 ++++++++++++++- src/saveload/saveload.cpp | 2 + src/saveload/tunnel_sl.cpp | 48 +++++++++++++++ src/table/settings/misc_settings.ini | 4 +- src/terraform_cmd.cpp | 2 +- src/train_cmd.cpp | 14 ++++- src/transparency.h | 1 + src/transparency_gui.cpp | 7 ++- src/tunnel_base.h | 39 ++++++++++++ src/tunnel_map.cpp | 75 ++++++++++++----------- src/tunnel_map.h | 26 ++++++-- src/tunnelbridge_cmd.cpp | 111 ++++++++++++++++++++++++++++++----- src/tunnelbridge_map.h | 2 +- src/vehicle.cpp | 14 ++++- src/vehicle_base.h | 6 ++ src/widgets/transparency_widget.h | 1 + 23 files changed, 423 insertions(+), 74 deletions(-) create mode 100644 src/saveload/tunnel_sl.cpp create mode 100644 src/tunnel_base.h diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 631eaf6de..908e04128 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -446,6 +446,7 @@ add_files( tree_cmd.cpp tree_gui.cpp tree_map.h + tunnel_base.h tunnel_map.cpp tunnel_map.h tunnelbridge.h diff --git a/src/ground_vehicle.cpp b/src/ground_vehicle.cpp index f6e44c2e2..08879b084 100644 --- a/src/ground_vehicle.cpp +++ b/src/ground_vehicle.cpp @@ -11,6 +11,8 @@ #include "train.h" #include "roadveh.h" #include "depot_map.h" +#include "tunnel_base.h" +#include "slope_type.h" #include "safeguards.h" @@ -203,6 +205,69 @@ bool GroundVehicle::IsChainInDepot() const return true; } +/** + * Updates vehicle's Z inclination inside a wormhole, where applicable. + */ +template +void GroundVehicle::UpdateZPositionInWormhole() +{ + if (!IsTunnel(this->tile)) return; + + const Tunnel *t = Tunnel::GetByTile(this->tile); + if (!t->is_chunnel) return; + + TileIndex pos_tile = TileVirtXY(this->x_pos, this->y_pos); + + ClrBit(this->gv_flags, GVF_GOINGUP_BIT); + ClrBit(this->gv_flags, GVF_GOINGDOWN_BIT); + + if (pos_tile == t->tile_n || pos_tile == t->tile_s) { + this->z_pos = 0; + return; + } + + int north_coord, south_coord, pos_coord; + Slope slope = SLOPE_FLAT; + int delta; + if (t->tile_s - t->tile_n > MapMaxX()) { + // tunnel extends along Y axis (DIAGDIR_SE from north end), has same X values + north_coord = TileY(t->tile_n); + south_coord = TileY(t->tile_s); + pos_coord = TileY(pos_tile); + + if ((delta = pos_coord - north_coord) <= 3) { + this->z_pos = TILE_HEIGHT * (delta == 3 ? -2 : -1); + if (delta != 2) { + slope = SLOPE_NW; + SetBit(this->gv_flags, this->direction == DIR_NW ? GVF_GOINGUP_BIT : GVF_GOINGDOWN_BIT); + } + } else if ((delta = south_coord - pos_coord) <= 3) { + this->z_pos = TILE_HEIGHT * (delta == 3 ? -2 : -1); + if (delta != 2) { + slope = SLOPE_ELEVATED ^ SLOPE_NW; + SetBit(this->gv_flags, this->direction == DIR_NW ? GVF_GOINGDOWN_BIT : GVF_GOINGUP_BIT); + } + } + } else { + // tunnel extends along X axis (DIAGDIR_SW from north end), has same Y values + north_coord = TileX(t->tile_n); + south_coord = TileX(t->tile_s); + pos_coord = TileX(pos_tile); + + if ((delta = pos_coord - north_coord) <= 3) { + this->z_pos = TILE_HEIGHT * (delta == 3 ? -3 : (delta == 2 ? -2 : -1)); + slope = SLOPE_NE; + SetBit(this->gv_flags, this->direction == DIR_NE ? GVF_GOINGUP_BIT : GVF_GOINGDOWN_BIT); + } else if ((delta = south_coord - pos_coord) <= 3) { + this->z_pos = TILE_HEIGHT * (delta == 3 ? -3 : (delta == 2 ? -2 : -1)); + slope = SLOPE_ELEVATED ^ SLOPE_NE; + SetBit(this->gv_flags, this->direction == DIR_NE ? GVF_GOINGDOWN_BIT : GVF_GOINGUP_BIT); + } + } + + if (slope != SLOPE_FLAT) this->z_pos += GetPartialPixelZ(this->x_pos & 0xF, this->y_pos & 0xF, slope); +} + /* Instantiation for Train */ template struct GroundVehicle; /* Instantiation for RoadVehicle */ diff --git a/src/ground_vehicle.hpp b/src/ground_vehicle.hpp index 15aac1f36..b08a23d0e 100644 --- a/src/ground_vehicle.hpp +++ b/src/ground_vehicle.hpp @@ -14,6 +14,7 @@ #include "vehicle_gui.h" #include "landscape.h" #include "window_func.h" +#include "tunnel_map.h" #include "widgets/vehicle_widget.h" /** What is the status of our acceleration? */ @@ -52,6 +53,7 @@ enum GroundVehicleFlags { GVF_GOINGUP_BIT = 0, ///< Vehicle is currently going uphill. (Cached track information for acceleration) GVF_GOINGDOWN_BIT = 1, ///< Vehicle is currently going downhill. (Cached track information for acceleration) GVF_SUPPRESS_IMPLICIT_ORDERS = 2, ///< Disable insertion and removal of automatic orders until the vehicle completes the real order. + GVF_CHUNNEL_BIT = 3, ///< Vehicle may currently be in a chunnel. (Cached track information for inclination changes) }; /** @@ -220,20 +222,28 @@ struct GroundVehicle : public SpecializedVehicle { this->z_pos += HasBit(this->gv_flags, GVF_GOINGUP_BIT) ? d : -d; } + if (HasBit(this->gv_flags, GVF_CHUNNEL_BIT) && !IsTunnelTile(this->tile)) { + ClrBit(this->gv_flags, GVF_CHUNNEL_BIT); + } + assert(this->z_pos == GetSlopePixelZ(this->x_pos, this->y_pos)); } + void UpdateZPositionInWormhole(); + /** * Checks if the vehicle is in a slope and sets the required flags in that case. * @param new_tile True if the vehicle reached a new tile. * @param update_delta Indicates to also update the delta. * @return Old height of the vehicle. */ - inline int UpdateInclination(bool new_tile, bool update_delta) + inline int UpdateInclination(bool new_tile, bool update_delta, bool in_wormhole = false) { int old_z = this->z_pos; - if (new_tile) { + if (in_wormhole) { + if (HasBit(this->gv_flags, GVF_CHUNNEL_BIT)) this->UpdateZPositionInWormhole(); + } else if (new_tile) { this->UpdateZPositionAndInclination(); } else { this->UpdateZPosition(); diff --git a/src/industry_cmd.cpp b/src/industry_cmd.cpp index 8be44488d..69727bfd7 100644 --- a/src/industry_cmd.cpp +++ b/src/industry_cmd.cpp @@ -20,6 +20,7 @@ #include "company_base.h" #include "genworld.h" #include "tree_map.h" +#include "tunnel_map.h" #include "newgrf_cargo.h" #include "newgrf_debug.h" #include "newgrf_industrytiles.h" @@ -1523,6 +1524,11 @@ static CommandCost CheckIfIndustryIsAllowed(TileIndex tile, int type, const Town return_cmd_error(STR_ERROR_CAN_ONLY_BE_BUILT_NEAR_TOWN_CENTER); } + if (type == IT_OIL_RIG && + (IsTunnelInWay(tile, 0) || + IsTunnelInWay(tile + TileDiffXY(0, 1), 0) || + IsTunnelInWay(tile + TileDiffXY(1, 2), 0))) return_cmd_error(STR_ERROR_NO_DRILLING_ABOVE_CHUNNEL); + return CommandCost(); } diff --git a/src/lang/english.txt b/src/lang/english.txt index 44d226cbf..09f6c1f67 100644 --- a/src/lang/english.txt +++ b/src/lang/english.txt @@ -2402,6 +2402,7 @@ STR_TRANSPARENT_BRIDGES_TOOLTIP :{BLACK}Toggle t STR_TRANSPARENT_STRUCTURES_TOOLTIP :{BLACK}Toggle transparency for structures like lighthouses and antennas. Ctrl+Click to lock STR_TRANSPARENT_CATENARY_TOOLTIP :{BLACK}Toggle transparency for catenary. Ctrl+Click to lock STR_TRANSPARENT_LOADING_TOOLTIP :{BLACK}Toggle transparency for loading indicators. Ctrl+Click to lock +STR_TRANSPARENT_TUNNELS_TOOLTIP :{BLACK}Toggle transparency for vehicles in tunnels. Ctrl+Click to lock. STR_TRANSPARENT_INVISIBLE_TOOLTIP :{BLACK}Set objects invisible instead of transparent # Linkgraph legend window @@ -2811,7 +2812,9 @@ STR_LAI_WATER_DESCRIPTION_SHIP_DEPOT :Ship depot # Industries come directly from their industry names STR_LAI_TUNNEL_DESCRIPTION_RAILROAD :Railway tunnel +STR_LAI_TUNNEL_DESCRIPTION_RAILROAD_CHUNNEL :Railway tunnel (underwater) STR_LAI_TUNNEL_DESCRIPTION_ROAD :Road tunnel +STR_LAI_TUNNEL_DESCRIPTION_ROAD_CHUNNEL :Road tunnel (underwater) STR_LAI_BRIDGE_DESCRIPTION_RAIL_SUSPENSION_STEEL :Steel suspension rail bridge STR_LAI_BRIDGE_DESCRIPTION_RAIL_GIRDER_STEEL :Steel girder rail bridge @@ -4652,6 +4655,10 @@ STR_ERROR_ANOTHER_TUNNEL_IN_THE_WAY :{WHITE}Another STR_ERROR_TUNNEL_THROUGH_MAP_BORDER :{WHITE}Tunnel would end out of the map STR_ERROR_UNABLE_TO_EXCAVATE_LAND :{WHITE}Unable to excavate land for other end of tunnel STR_ERROR_TUNNEL_TOO_LONG :{WHITE}... tunnel too long +STR_ERROR_TUNNEL_RAMP_TOO_SHORT :{WHITE}... ramp too short, tunnels under water must have a ramp at least three tiles long at both ends. +STR_ERROR_TUNNEL_TOO_MANY :{WHITE}... too many tunnels +STR_ERROR_NO_DRILLING_ABOVE_CHUNNEL :{WHITE}No oil rigs allowed above underwater tunnels. +STR_ERROR_ANOTHER_TUNNEL_IN_THE_WAY_FOR_CHUNNEL :{WHITE}Three tiles are needed to pass under the other tunnel. # Object related errors STR_ERROR_TOO_MANY_OBJECTS :{WHITE}... too many objects diff --git a/src/roadveh_cmd.cpp b/src/roadveh_cmd.cpp index 86c2de78e..67259c783 100644 --- a/src/roadveh_cmd.cpp +++ b/src/roadveh_cmd.cpp @@ -1178,6 +1178,7 @@ bool IndividualRoadVehicleController(RoadVehicle *v, const RoadVehicle *prev) v->x_pos = gp.x; v->y_pos = gp.y; v->UpdatePosition(); + RoadZPosAffectSpeed(v, v->UpdateInclination(false, false, true)); if ((v->vehstatus & VS_HIDDEN) == 0) v->Vehicle::UpdateViewport(true); return true; } @@ -1554,7 +1555,7 @@ again: v->x_pos = x; v->y_pos = y; v->UpdatePosition(); - RoadZPosAffectSpeed(v, v->UpdateInclination(false, true)); + RoadZPosAffectSpeed(v, v->UpdateInclination(false, true, v->state == RVSB_WORMHOLE)); return true; } diff --git a/src/saveload/CMakeLists.txt b/src/saveload/CMakeLists.txt index 32bcc57ac..f1fce31c2 100644 --- a/src/saveload/CMakeLists.txt +++ b/src/saveload/CMakeLists.txt @@ -41,6 +41,7 @@ add_files( story_sl.cpp subsidy_sl.cpp town_sl.cpp + tunnel_sl.cpp vehicle_sl.cpp waypoint_sl.cpp ) diff --git a/src/saveload/afterload.cpp b/src/saveload/afterload.cpp index df1b4e44f..9696e390d 100644 --- a/src/saveload/afterload.cpp +++ b/src/saveload/afterload.cpp @@ -11,6 +11,7 @@ #include "../void_map.h" #include "../signs_base.h" #include "../depot_base.h" +#include "../tunnel_base.h" #include "../fios.h" #include "../gamelog_internal.h" #include "../network/network.h" @@ -537,6 +538,25 @@ static inline bool MayHaveBridgeAbove(TileIndex t) IsTileType(t, MP_WATER) || IsTileType(t, MP_TUNNELBRIDGE) || IsTileType(t, MP_OBJECT); } +TileIndex GetOtherTunnelBridgeEndOld(TileIndex tile) +{ + DiagDirection dir = GetTunnelBridgeDirection(tile); + TileIndexDiff delta = TileOffsByDiagDir(dir); + int z = GetTileZ(tile); + + dir = ReverseDiagDir(dir); + do { + tile += delta; + } while ( + !IsTunnelTile(tile) || + GetTunnelBridgeDirection(tile) != dir || + GetTileZ(tile) != z + ); + + return tile; +} + + /** * Perform a (large) amount of savegame conversion *magic* in order to * load older savegames and to fill the caches for various purposes. @@ -1942,6 +1962,32 @@ bool AfterLoadGame() } } + /* Tunnel pool has to be initiated before reservations. */ + if (IsSavegameVersionBefore(SLV_196)) { + for (TileIndex t = 0; t < map_size; t++) { + if (IsTunnelTile(t)) { + DiagDirection dir = GetTunnelBridgeDirection(t); + if (dir == DIAGDIR_SE || dir == DIAGDIR_SW) { + TileIndex start_tile = t; + TileIndex end_tile = GetOtherTunnelBridgeEndOld(start_tile); + + if (!Tunnel::CanAllocateItem()) { + SetSaveLoadError(STR_ERROR_TUNNEL_TOO_MANY); + /* Restore the signals */ + ResetSignalHandlers(); + return false; + } + + const Tunnel *t = new Tunnel(start_tile, end_tile, false); + + _m[start_tile].m2 = t->index; + _m[end_tile].m2 = t->index; + } + } + } + } + + /* Move the signal variant back up one bit for PBS. We don't convert the old PBS * format here, as an old layout wouldn't work properly anyway. To be safe, we * clear any possible PBS reservations as well. */ @@ -2545,7 +2591,7 @@ bool AfterLoadGame() } else if (dir == ReverseDiagDir(vdir)) { // Leaving tunnel hidden = frame < TILE_SIZE - _tunnel_visibility_frame[dir]; /* v->tile changes at the moment when the vehicle leaves the tunnel. */ - v->tile = hidden ? GetOtherTunnelBridgeEnd(vtile) : vtile; + v->tile = hidden ? GetOtherTunnelBridgeEndOld(vtile) : vtile; } else { /* We could get here in two cases: * - for road vehicles, it is reversing at the end of the tunnel diff --git a/src/saveload/saveload.cpp b/src/saveload/saveload.cpp index c8a1a0d29..6ce5493b7 100644 --- a/src/saveload/saveload.cpp +++ b/src/saveload/saveload.cpp @@ -252,6 +252,7 @@ static const std::vector &ChunkHandlers() extern const ChunkHandlerTable _airport_chunk_handlers; extern const ChunkHandlerTable _object_chunk_handlers; extern const ChunkHandlerTable _persistent_storage_chunk_handlers; + extern const ChunkHandlerTable _tunnel_chunk_handlers[]; /** List of all chunks in a savegame. */ static const ChunkHandlerTable _chunk_handler_tables[] = { @@ -288,6 +289,7 @@ static const std::vector &ChunkHandlers() _airport_chunk_handlers, _object_chunk_handlers, _persistent_storage_chunk_handlers, + _tunnel_chunk_handlers, }; static std::vector _chunk_handlers; diff --git a/src/saveload/tunnel_sl.cpp b/src/saveload/tunnel_sl.cpp new file mode 100644 index 000000000..7ad37b12b --- /dev/null +++ b/src/saveload/tunnel_sl.cpp @@ -0,0 +1,48 @@ +/* $Id$ */ + +/* + * 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 . + */ + +/** @file tunnel_sl.cpp Code handling saving and loading of tunnels */ + +#include "../stdafx.h" +#include "../tunnel_base.h" + +#include "saveload.h" + +#include "../safeguards.h" + + +static const SaveLoad _tunnel_desc[] = { + SLE_CONDVAR(Tunnel, tile_n, SLE_UINT32, SLV_196, SL_MAX_VERSION), + SLE_CONDVAR(Tunnel, tile_s, SLE_UINT32, SLV_196, SL_MAX_VERSION), + SLE_CONDVAR(Tunnel, is_chunnel, SLE_BOOL, SLV_196, SL_MAX_VERSION), + SLE_END() +}; + +static void Save_TUNN() +{ + for(Tunnel *tunnel : Tunnel::Iterate()) { + SlSetArrayIndex(tunnel->index); + SlObject(tunnel, _tunnel_desc); + } +} + +static void Load_TUNN() +{ + int index; + + while ((index = SlIterateArray()) != -1) { + Tunnel *tunnel = new (index) Tunnel(); + SlObject(tunnel, _tunnel_desc); + } +} + + +extern const ChunkHandler _tunnel_chunk_handlers[] = { + { 'TUNN', Save_TUNN, Load_TUNN, nullptr, nullptr, CH_ARRAY | CH_LAST}, +}; diff --git a/src/table/settings/misc_settings.ini b/src/table/settings/misc_settings.ini index daca4a817..ae630d2fd 100644 --- a/src/table/settings/misc_settings.ini +++ b/src/table/settings/misc_settings.ini @@ -289,7 +289,7 @@ type = SLE_UINT var = _transparency_opt def = 0 min = 0 -max = 0x1FF +max = 0x3FF cat = SC_BASIC [SDTG_VAR] @@ -298,7 +298,7 @@ type = SLE_UINT var = _transparency_lock def = 0 min = 0 -max = 0x1FF +max = 0x3FF cat = SC_BASIC [SDTG_VAR] diff --git a/src/terraform_cmd.cpp b/src/terraform_cmd.cpp index eaed9e71c..ddb34c065 100644 --- a/src/terraform_cmd.cpp +++ b/src/terraform_cmd.cpp @@ -269,7 +269,7 @@ CommandCost CmdTerraformLand(TileIndex tile, DoCommandFlag flags, uint32 p1, uin } } /* Check if tunnel would take damage */ - if (direction == -1 && IsTunnelInWay(t, z_min)) { + if (direction == -1 && IsTunnelInWay(t, z_min, true)) { _terraform_err_tile = t; // highlight the tile above the tunnel return_cmd_error(STR_ERROR_EXCAVATION_WOULD_DAMAGE); } diff --git a/src/train_cmd.cpp b/src/train_cmd.cpp index 17e298c33..1112e9237 100644 --- a/src/train_cmd.cpp +++ b/src/train_cmd.cpp @@ -1577,6 +1577,7 @@ static void UpdateStatusAfterSwap(Train *v) } v->UpdatePosition(); + if (v->track == TRACK_BIT_WORMHOLE) v->UpdateInclination(false, false, true); v->UpdateViewport(true, true); } @@ -3340,6 +3341,15 @@ bool TrainController(Train *v, Vehicle *nomove, bool reverse) v->x_pos = gp.x; v->y_pos = gp.y; v->UpdatePosition(); + if (v->track == TRACK_BIT_WORMHOLE) { + /* update the Z position of the vehicle */ + int old_z = v->UpdateInclination(false, false, true); + + if (prev == nullptr) { + /* This is the first vehicle in the train */ + AffectSpeedByZChange(v, old_z); + } + } if ((v->vehstatus & VS_HIDDEN) == 0) v->Vehicle::UpdateViewport(true); continue; } @@ -3353,7 +3363,7 @@ bool TrainController(Train *v, Vehicle *nomove, bool reverse) v->UpdatePosition(); /* update the Z position of the vehicle */ - int old_z = v->UpdateInclination(gp.new_tile != gp.old_tile, false); + int old_z = v->UpdateInclination(gp.new_tile != gp.old_tile, false, v->track == TRACK_BIT_WORMHOLE); if (prev == nullptr) { /* This is the first vehicle in the train */ @@ -3866,7 +3876,7 @@ static bool TrainLocoHandler(Train *v, bool mode) } for (Train *u = v; u != nullptr; u = u->Next()) { - if ((u->vehstatus & VS_HIDDEN) != 0) continue; + if (!u->IsDrawn()) continue; u->UpdateViewport(false, false); } diff --git a/src/transparency.h b/src/transparency.h index 54ba24e93..08b13ca9b 100644 --- a/src/transparency.h +++ b/src/transparency.h @@ -29,6 +29,7 @@ enum TransparencyOption { TO_STRUCTURES, ///< other objects such as transmitters and lighthouses TO_CATENARY, ///< catenary TO_LOADING, ///< loading indicators + TO_TUNNELS, ///< vehicles in tunnels TO_END, TO_INVALID, ///< Invalid transparency option }; diff --git a/src/transparency_gui.cpp b/src/transparency_gui.cpp index 153dcb5d0..611094cde 100644 --- a/src/transparency_gui.cpp +++ b/src/transparency_gui.cpp @@ -50,7 +50,8 @@ public: case WID_TT_BRIDGES: case WID_TT_STRUCTURES: case WID_TT_CATENARY: - case WID_TT_LOADING: { + case WID_TT_LOADING: + case WID_TT_TUNNELS: { uint i = widget - WID_TT_BEGIN; if (HasBit(_transparency_lock, i)) DrawSprite(SPR_LOCK, PAL_NONE, r.left + 1, r.top + 1); break; @@ -58,6 +59,7 @@ public: case WID_TT_BUTTONS: for (uint i = WID_TT_BEGIN; i < WID_TT_END; i++) { if (i == WID_TT_LOADING) continue; // Do not draw button for invisible loading indicators. + if (i == WID_TT_TUNNELS) continue; // Do not draw button for invisible vehicles in tunnels. const NWidgetBase *wi = this->GetWidget(i); DrawFrameRect(wi->pos_x + 1, r.top + 2, wi->pos_x + wi->current_x - 2, r.bottom - 2, COLOUR_PALE_GREEN, @@ -69,7 +71,7 @@ public: void OnClick(Point pt, int widget, int click_count) override { - if (widget >= WID_TT_BEGIN && widget < WID_TT_END) { + if (IsInsideMM(widget, WID_TT_BEGIN, WID_TT_END)) { if (_ctrl_pressed) { /* toggle the bit of the transparencies lock variable */ ToggleTransparencyLock((TransparencyOption)(widget - WID_TT_BEGIN)); @@ -139,6 +141,7 @@ static const NWidgetPart _nested_transparency_widgets[] = { NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_TT_STRUCTURES), SetMinimalSize(22, 22), SetFill(0, 1), SetDataTip(SPR_IMG_TRANSMITTER, STR_TRANSPARENT_STRUCTURES_TOOLTIP), NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_TT_CATENARY), SetMinimalSize(22, 22), SetFill(0, 1), SetDataTip(SPR_BUILD_X_ELRAIL, STR_TRANSPARENT_CATENARY_TOOLTIP), NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_TT_LOADING), SetMinimalSize(22, 22), SetFill(0, 1), SetDataTip(SPR_IMG_TRAINLIST, STR_TRANSPARENT_LOADING_TOOLTIP), + NWidget(WWT_IMGBTN, COLOUR_DARK_GREEN, WID_TT_TUNNELS), SetMinimalSize(22, 22), SetFill(0, 1), SetDataTip(SPR_IMG_ROAD_TUNNEL, STR_TRANSPARENT_TUNNELS_TOOLTIP), NWidget(WWT_PANEL, COLOUR_DARK_GREEN), SetFill(1, 1), EndContainer(), EndContainer(), /* Panel with 'invisibility' buttons. */ diff --git a/src/tunnel_base.h b/src/tunnel_base.h new file mode 100644 index 000000000..4a2493fa7 --- /dev/null +++ b/src/tunnel_base.h @@ -0,0 +1,39 @@ +/* $Id$ */ + +/* + * 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 . + */ + +/** @file tunnel_base.h Base for all tunnels */ + +#ifndef TUNNEL_BASE_H +#define TUNNEL_BASE_H + +#include "tunnel_map.h" +#include "core/pool_type.hpp" + +struct Tunnel; + +typedef Pool TunnelPool; +extern TunnelPool _tunnel_pool; + +struct Tunnel : TunnelPool::PoolItem<&_tunnel_pool> { + + TileIndex tile_n; // North tile of tunnel. + TileIndex tile_s; // South tile of tunnel. + bool is_chunnel; + + Tunnel() {} + Tunnel(TileIndex tile_n, TileIndex tile_s, bool is_chunnel) : tile_n(tile_n), tile_s(tile_s), is_chunnel(is_chunnel) {} + ~Tunnel(); + + static inline Tunnel *GetByTile(TileIndex tile) + { + return Tunnel::Get(GetTunnelIndex(tile)); + } +}; + +#endif /* TUNNEL_BASE_H */ diff --git a/src/tunnel_map.cpp b/src/tunnel_map.cpp index 9de523580..6234193e1 100644 --- a/src/tunnel_map.cpp +++ b/src/tunnel_map.cpp @@ -10,63 +10,62 @@ #include "stdafx.h" #include "tunnelbridge_map.h" +#include "core/pool_func.hpp" + #include "safeguards.h" +/** All tunnel portals tucked away in a pool. */ +TunnelPool _tunnel_pool("Tunnel"); +INSTANTIATE_POOL_METHODS(Tunnel) /** - * Gets the other end of the tunnel. Where a vehicle would reappear when it - * enters at the given tile. - * @param tile the tile to search from. - * @return the tile of the other end of the tunnel. + * Clean up a tunnel tile */ -TileIndex GetOtherTunnelEnd(TileIndex tile) +Tunnel::~Tunnel() { - DiagDirection dir = GetTunnelBridgeDirection(tile); - TileIndexDiff delta = TileOffsByDiagDir(dir); - int z = GetTileZ(tile); - - dir = ReverseDiagDir(dir); - do { - tile += delta; - } while ( - !IsTunnelTile(tile) || - GetTunnelBridgeDirection(tile) != dir || - GetTileZ(tile) != z - ); - - return tile; + if (CleaningPool()) return; } - /** - * Is there a tunnel in the way in the given direction? + * Gets the other end of the tunnel. Where a vehicle would reappear when it + * enters at the given tile. * @param tile the tile to search from. - * @param z the 'z' to search on. - * @param dir the direction to start searching to. - * @return true if and only if there is a tunnel. + * @return the tile of the other end of the tunnel. */ -bool IsTunnelInWayDir(TileIndex tile, int z, DiagDirection dir) +TileIndex GetOtherTunnelEnd(TileIndex tile) { - TileIndexDiff delta = TileOffsByDiagDir(dir); - int height; - - do { - tile -= delta; - if (!IsValidTile(tile)) return false; - height = GetTileZ(tile); - } while (z < height); - - return z == height && IsTunnelTile(tile) && GetTunnelBridgeDirection(tile) == dir; + Tunnel *t = Tunnel::GetByTile(tile); + return t->tile_n == tile ? t->tile_s : t->tile_n; } /** * Is there a tunnel in the way in any direction? * @param tile the tile to search from. * @param z the 'z' to search on. + * @param chunnel_allowed True if chunnel mid-parts are allowed, used when terraforming. * @return true if and only if there is a tunnel. */ -bool IsTunnelInWay(TileIndex tile, int z) +bool IsTunnelInWay(TileIndex tile, int z, bool chunnel_allowed) { - return IsTunnelInWayDir(tile, z, (TileX(tile) > (MapMaxX() / 2)) ? DIAGDIR_NE : DIAGDIR_SW) || - IsTunnelInWayDir(tile, z, (TileY(tile) > (MapMaxY() / 2)) ? DIAGDIR_NW : DIAGDIR_SE); + uint x = TileX(tile); + uint y = TileY(tile); + + for(Tunnel *t : Tunnel::Iterate()) { + if (t->tile_n > tile || tile > t->tile_s) continue; + + if (t->tile_s - t->tile_n > MapMaxX()){ + if (TileX(t->tile_n) != x || (int)TileHeight(t->tile_n) != z) continue; // dir DIAGDIR_SE + } else { + if (TileY(t->tile_n) != y || (int)TileHeight(t->tile_n) != z) continue; // dir DIAGDIR_SW + } + + if (t->is_chunnel && chunnel_allowed) { + /* Only if tunnel was build over water terraforming is allowed between portals. */ + TileIndexDiff delta = GetTunnelBridgeDirection(t->tile_n) == DIAGDIR_SE ? TileOffsByDiagDir(DIAGDIR_SE) * 4 : 4; // 4 tiles ramp. + if (tile < t->tile_n + delta || t->tile_s - delta < tile) return true; + continue; + } + return true; + } + return false; } diff --git a/src/tunnel_map.h b/src/tunnel_map.h index c347626d5..45589dacb 100644 --- a/src/tunnel_map.h +++ b/src/tunnel_map.h @@ -13,6 +13,7 @@ #include "rail_map.h" #include "road_map.h" +typedef uint16 TunnelID; ///< Type for the unique identifier of tunnels. /** * Is this a tunnel (entrance)? @@ -36,22 +37,34 @@ static inline bool IsTunnelTile(TileIndex t) return IsTileType(t, MP_TUNNELBRIDGE) && IsTunnel(t); } +/** + * Get the index of tunnel tile. + * @param t the tile + * @pre IsTunnelTile(t) + * @return TunnelID + */ +static inline TunnelID GetTunnelIndex(TileIndex t) +{ + assert(IsTunnelTile(t)); + return _m[t].m2; +} + TileIndex GetOtherTunnelEnd(TileIndex); -bool IsTunnelInWay(TileIndex, int z); -bool IsTunnelInWayDir(TileIndex tile, int z, DiagDirection dir); +bool IsTunnelInWay(TileIndex, int z, bool chunnel_allowed = false); /** * Makes a road tunnel entrance * @param t the entrance of the tunnel * @param o the owner of the entrance + * @param id the tunnel ID * @param d the direction facing out of the tunnel * @param r the road type used in the tunnel */ -static inline void MakeRoadTunnel(TileIndex t, Owner o, DiagDirection d, RoadType road_rt, RoadType tram_rt) +static inline void MakeRoadTunnel(TileIndex t, Owner o, TunnelID id, DiagDirection d, RoadType road_rt, RoadType tram_rt) { SetTileType(t, MP_TUNNELBRIDGE); SetTileOwner(t, o); - _m[t].m2 = 0; + _m[t].m2 = id; _m[t].m3 = 0; _m[t].m4 = 0; _m[t].m5 = TRANSPORT_ROAD << 2 | d; @@ -67,14 +80,15 @@ static inline void MakeRoadTunnel(TileIndex t, Owner o, DiagDirection d, RoadTyp * Makes a rail tunnel entrance * @param t the entrance of the tunnel * @param o the owner of the entrance + * @param id the tunnel ID * @param d the direction facing out of the tunnel * @param r the rail type used in the tunnel */ -static inline void MakeRailTunnel(TileIndex t, Owner o, DiagDirection d, RailType r) +static inline void MakeRailTunnel(TileIndex t, Owner o, TunnelID id, DiagDirection d, RailType r) { SetTileType(t, MP_TUNNELBRIDGE); SetTileOwner(t, o); - _m[t].m2 = 0; + _m[t].m2 = id; _m[t].m3 = 0; _m[t].m4 = 0; _m[t].m5 = TRANSPORT_RAIL << 2 | d; diff --git a/src/tunnelbridge_cmd.cpp b/src/tunnelbridge_cmd.cpp index 5181dfdca..a0e33641d 100644 --- a/src/tunnelbridge_cmd.cpp +++ b/src/tunnelbridge_cmd.cpp @@ -40,12 +40,15 @@ #include "water.h" #include "company_gui.h" #include "station_func.h" +#include "station_map.h" +#include "industry_map.h" #include "table/strings.h" #include "table/bridge_land.h" #include "safeguards.h" + BridgeSpec _bridge[MAX_BRIDGES]; ///< The specification of all bridges. TileIndex _build_tunnel_endtile; ///< The end of a tunnel; as hidden return from the tunnel build command for GUI purposes. @@ -681,12 +684,6 @@ CommandCost CmdBuildTunnel(TileIndex start_tile, DoCommandFlag flags, uint32 p1, * position, because of increased-cost-by-length: 'cost += cost >> 3' */ TileIndexDiff delta = TileOffsByDiagDir(direction); - DiagDirection tunnel_in_way_dir; - if (DiagDirToAxis(direction) == AXIS_Y) { - tunnel_in_way_dir = (TileX(start_tile) < (MapMaxX() / 2)) ? DIAGDIR_SW : DIAGDIR_NE; - } else { - tunnel_in_way_dir = (TileY(start_tile) < (MapMaxX() / 2)) ? DIAGDIR_SE : DIAGDIR_NW; - } TileIndex end_tile = start_tile; @@ -694,9 +691,15 @@ CommandCost CmdBuildTunnel(TileIndex start_tile, DoCommandFlag flags, uint32 p1, int tiles_coef = 3; /* Number of tiles from start of tunnel */ int tiles = 0; + /* flag for chunnels. */ + bool is_chunnel = false; + /* Number of chunnel head tiles. */ + int head_tiles = 0; /* Number of tiles at which the cost increase coefficient per tile is halved */ int tiles_bump = 25; + TileIndex found_tunnel_tile = INVALID_TILE; + CommandCost cost(EXPENSES_CONSTRUCTION); Slope end_tileh; for (;;) { @@ -704,13 +707,69 @@ CommandCost CmdBuildTunnel(TileIndex start_tile, DoCommandFlag flags, uint32 p1, if (!IsValidTile(end_tile)) return_cmd_error(STR_ERROR_TUNNEL_THROUGH_MAP_BORDER); end_tileh = GetTileSlope(end_tile, &end_z); - if (start_z == end_z) break; + if (start_z == end_z) { + _build_tunnel_endtile = found_tunnel_tile != INVALID_TILE ? found_tunnel_tile : end_tile; + + /* Test if we are on a shore. */ + if (end_z == 0 && + (IsCoastTile(end_tile) || + (IsValidTile(end_tile + delta) && HasTileWaterGround(end_tile + delta)) || + (IsValidTile(end_tile + delta * 2) && HasTileWaterGround(end_tile + delta * 2)))) { + if (!is_chunnel) { + /*We are about to pass water for the first time so check if not to close to other tunnel */ + if (tiles + 1 < head_tiles + 4 && found_tunnel_tile != INVALID_TILE) return_cmd_error(STR_ERROR_ANOTHER_TUNNEL_IN_THE_WAY_FOR_CHUNNEL); + if (tiles + 1 < 4) return_cmd_error(STR_ERROR_TUNNEL_RAMP_TOO_SHORT); + } + } else {/* We are leaving.*/ + if (is_chunnel) { + /* Check if there is enough ramp space to come up. */ + if (head_tiles < 4 && found_tunnel_tile != INVALID_TILE) return_cmd_error(STR_ERROR_ANOTHER_TUNNEL_IN_THE_WAY_FOR_CHUNNEL); + if (head_tiles < 4) return_cmd_error(STR_ERROR_TUNNEL_RAMP_TOO_SHORT); + } else { + if (found_tunnel_tile != INVALID_TILE) return_cmd_error(STR_ERROR_ANOTHER_TUNNEL_IN_THE_WAY); + } + break; + } - if (!_cheats.crossing_tunnels.value && IsTunnelInWayDir(end_tile, start_z, tunnel_in_way_dir)) { - return_cmd_error(STR_ERROR_ANOTHER_TUNNEL_IN_THE_WAY); - } + /* A shore was found so pass the water and find a proper shore tile that potentially + * could have a tunnel portal behind. */ + for (;;) { + if (!IsValidTile(end_tile)) return_cmd_error(STR_ERROR_TUNNEL_THROUGH_MAP_BORDER); + + end_tileh = GetTileSlope(end_tile); + if(direction == DIAGDIR_NE && (end_tileh & SLOPE_NE) == SLOPE_NE) break; + if(direction == DIAGDIR_SE && (end_tileh & SLOPE_SE) == SLOPE_SE) break; + if(direction == DIAGDIR_SW && (end_tileh & SLOPE_SW) == SLOPE_SW) break; + if(direction == DIAGDIR_NW && (end_tileh & SLOPE_NW) == SLOPE_NW) break; + + /* No drilling under oil rigs.*/ + if ((IsTileType(end_tile, MP_STATION) && IsOilRig(end_tile)) || + (IsTileType(end_tile, MP_INDUSTRY) && + GetIndustryGfx(end_tile) >= GFX_OILRIG_1 && + GetIndustryGfx(end_tile) <= GFX_OILRIG_5)) { + _build_tunnel_endtile = end_tile; + return_cmd_error(STR_ERROR_NO_DRILLING_ABOVE_CHUNNEL); + } + end_tile += delta; + tiles++; + } + /* The water was passed */ + is_chunnel = true; + head_tiles = 0; + found_tunnel_tile = INVALID_TILE; + } + if (!_cheats.crossing_tunnels.value && IsTunnelInWay(end_tile, start_z, (tiles + 1 < 4 || (is_chunnel && head_tiles < 4) ? false : true))) { + if (found_tunnel_tile == INVALID_TILE || is_chunnel) { // Remember the first or the last when we pass a tunnel. + found_tunnel_tile = end_tile; + head_tiles = 0; + } + } + head_tiles++; tiles++; + } + /* The cost of the digging. */ + for (int i = tiles; i > 0; i--) { if (tiles == tiles_bump) { tiles_coef++; tiles_bump *= 2; @@ -778,21 +837,32 @@ CommandCost CmdBuildTunnel(TileIndex start_tile, DoCommandFlag flags, uint32 p1, default: NOT_REACHED(); } + if (is_chunnel) cost.MultiplyCost(2); + if (flags & DC_EXEC) { Company *c = Company::GetIfValid(company); uint num_pieces = (tiles + 2) * TUNNELBRIDGE_TRACKBIT_FACTOR; + + /* The most northern tile first. */ + TileIndex tn = start_tile; + TileIndex ts = end_tile; + if(start_tile > end_tile) Swap(tn, ts); + + if (!Tunnel::CanAllocateItem()) return_cmd_error(STR_ERROR_TUNNEL_TOO_MANY); + const Tunnel *t = new Tunnel(tn, ts, is_chunnel); + if (transport_type == TRANSPORT_RAIL) { if (c != nullptr) c->infrastructure.rail[railtype] += num_pieces; - MakeRailTunnel(start_tile, company, direction, railtype); - MakeRailTunnel(end_tile, company, ReverseDiagDir(direction), railtype); + MakeRailTunnel(start_tile, company, t->index, direction, railtype); + MakeRailTunnel(end_tile, company, t->index, ReverseDiagDir(direction), railtype); AddSideToSignalBuffer(start_tile, INVALID_DIAGDIR, company); YapfNotifyTrackLayoutChange(start_tile, DiagDirToDiagTrack(direction)); } else { if (c != nullptr) c->infrastructure.road[roadtype] += num_pieces * 2; // A full diagonal road has two road bits. RoadType road_rt = RoadTypeIsRoad(roadtype) ? roadtype : INVALID_ROADTYPE; RoadType tram_rt = RoadTypeIsTram(roadtype) ? roadtype : INVALID_ROADTYPE; - MakeRoadTunnel(start_tile, company, direction, road_rt, tram_rt); - MakeRoadTunnel(end_tile, company, ReverseDiagDir(direction), road_rt, tram_rt); + MakeRoadTunnel(start_tile, company, t->index, direction, road_rt, tram_rt); + MakeRoadTunnel(end_tile, company, t->index, ReverseDiagDir(direction), road_rt, tram_rt); } DirtyCompanyInfrastructureWindows(company); } @@ -883,6 +953,8 @@ static CommandCost DoClearTunnel(TileIndex tile, DoCommandFlag flags) } Money base_cost = TunnelBridgeClearCost(tile, PR_CLEAR_TUNNEL); + const bool is_chunnel = Tunnel::GetByTile(tile)->is_chunnel; + uint len = GetTunnelBridgeLength(tile, endtile) + 2; // Don't forget the end tiles. if (flags & DC_EXEC) { @@ -903,6 +975,8 @@ static CommandCost DoClearTunnel(TileIndex tile, DoCommandFlag flags) DirtyCompanyInfrastructureWindows(owner); } + delete Tunnel::GetByTile(tile); + DoClearSquare(tile); DoClearSquare(endtile); @@ -919,12 +993,14 @@ static CommandCost DoClearTunnel(TileIndex tile, DoCommandFlag flags) UpdateCompanyRoadInfrastructure(GetRoadTypeRoad(tile), GetRoadOwner(tile, RTT_ROAD), -(int)(len * 2 * TUNNELBRIDGE_TRACKBIT_FACTOR)); UpdateCompanyRoadInfrastructure(GetRoadTypeTram(tile), GetRoadOwner(tile, RTT_TRAM), -(int)(len * 2 * TUNNELBRIDGE_TRACKBIT_FACTOR)); + delete Tunnel::GetByTile(tile); + DoClearSquare(tile); DoClearSquare(endtile); } } - return CommandCost(EXPENSES_CONSTRUCTION, len * base_cost); + return CommandCost(EXPENSES_CONSTRUCTION, len * base_cost * (is_chunnel ? 2 : 1)); } @@ -1900,6 +1976,7 @@ static VehicleEnterTileStatus VehicleEnter_TunnelBridge(Vehicle *v, TileIndex ti if (frame == _tunnel_visibility_frame[dir]) { t->tile = tile; t->track = TRACK_BIT_WORMHOLE; + if (Tunnel::GetByTile(tile)->is_chunnel) SetBit(t->gv_flags, GVF_CHUNNEL_BIT); t->vehstatus |= VS_HIDDEN; return VETSB_ENTERED_WORMHOLE; } @@ -1907,6 +1984,7 @@ static VehicleEnterTileStatus VehicleEnter_TunnelBridge(Vehicle *v, TileIndex ti if (dir == ReverseDiagDir(vdir) && frame == TILE_SIZE - _tunnel_visibility_frame[dir] && z == 0) { /* We're at the tunnel exit ?? */ + if (t->tile != tile && GetOtherTunnelEnd(t->tile) != tile) return VETSB_CONTINUE; // In chunnel t->tile = tile; t->track = DiagDirToDiagTrackBits(vdir); assert(t->track); @@ -1923,6 +2001,7 @@ static VehicleEnterTileStatus VehicleEnter_TunnelBridge(Vehicle *v, TileIndex ti assert(frame == rv->frame + 1); rv->tile = tile; rv->state = RVSB_WORMHOLE; + if (Tunnel::GetByTile(tile)->is_chunnel) SetBit(rv->gv_flags, GVF_CHUNNEL_BIT); rv->vehstatus |= VS_HIDDEN; return VETSB_ENTERED_WORMHOLE; } else { @@ -1932,6 +2011,7 @@ static VehicleEnterTileStatus VehicleEnter_TunnelBridge(Vehicle *v, TileIndex ti /* We're at the tunnel exit ?? */ if (dir == ReverseDiagDir(vdir) && frame == TILE_SIZE - _tunnel_visibility_frame[dir] && z == 0) { + if (rv->tile != tile && GetOtherTunnelEnd(rv->tile) != tile) return VETSB_CONTINUE; // In chunnel rv->tile = tile; rv->state = DiagDirToDiagTrackdir(vdir); rv->frame = frame; @@ -1940,6 +2020,7 @@ static VehicleEnterTileStatus VehicleEnter_TunnelBridge(Vehicle *v, TileIndex ti } } } else { // IsBridge(tile) + if (v->vehstatus & VS_HIDDEN) return VETSB_CONTINUE; // Building bridges between chunnel portals allowed. if (v->type != VEH_SHIP) { /* modify speed of vehicle */ uint16 spd = GetBridgeSpec(GetBridgeType(tile))->speed; diff --git a/src/tunnelbridge_map.h b/src/tunnelbridge_map.h index 62d3c14b2..37e00457e 100644 --- a/src/tunnelbridge_map.h +++ b/src/tunnelbridge_map.h @@ -11,7 +11,7 @@ #define TUNNELBRIDGE_MAP_H #include "bridge_map.h" -#include "tunnel_map.h" +#include "tunnel_base.h" /** diff --git a/src/vehicle.cpp b/src/vehicle.cpp index 955f9bde0..8f6a28bd1 100644 --- a/src/vehicle.cpp +++ b/src/vehicle.cpp @@ -285,6 +285,14 @@ uint Vehicle::Crash(bool flooded) return RandomRange(pass + 1); // Randomise deceased passengers. } +bool Vehicle::IsDrawn() const +{ + return !(this->vehstatus & VS_HIDDEN) || + (!IsTransparencySet(TO_TUNNELS) && + ((this->type == VEH_TRAIN && Train::From(this)->track == TRACK_BIT_WORMHOLE) || + (this->type == VEH_ROAD && RoadVehicle::From(this)->state == RVSB_WORMHOLE))); +} + /** * Displays a "NewGrf Bug" error message for a engine, and pauses the game if not networking. @@ -1082,7 +1090,7 @@ static void DoDrawVehicle(const Vehicle *v) if (v->vehstatus & VS_DEFPAL) pal = (v->vehstatus & VS_CRASHED) ? PALETTE_CRASH : GetVehiclePalette(v); /* Check whether the vehicle shall be transparent due to the game state */ - bool shadowed = (v->vehstatus & VS_SHADOW) != 0; + bool shadowed = (v->vehstatus & (VS_SHADOW | VS_HIDDEN)) != 0; if (v->type == VEH_EFFECT) { /* Check whether the vehicle shall be transparent/invisible due to GUI settings. @@ -1144,7 +1152,7 @@ void ViewportAddVehicles(DrawPixelInfo *dpi) while (v != nullptr) { - if (!(v->vehstatus & VS_HIDDEN) && + if (v->IsDrawn() && l <= v->coord.right + xb && t <= v->coord.bottom + yb && r >= v->coord.left - xb && @@ -1210,7 +1218,7 @@ Vehicle *CheckClickOnVehicle(const Viewport *vp, int x, int y) y = ScaleByZoom(y, vp->zoom) + vp->virtual_top; for (Vehicle *v : Vehicle::Iterate()) { - if ((v->vehstatus & (VS_HIDDEN | VS_UNCLICKABLE)) == 0 && + if (v->IsDrawn() && !(v->vehstatus & VS_UNCLICKABLE) && x >= v->coord.left && x <= v->coord.right && y >= v->coord.top && y <= v->coord.bottom) { diff --git a/src/vehicle_base.h b/src/vehicle_base.h index a5549b444..91d4ac0f9 100644 --- a/src/vehicle_base.h +++ b/src/vehicle_base.h @@ -366,6 +366,12 @@ public: uint GetConsistTotalCapacity() const; + /** + * Is this vehicle drawn? + * @return true if it is drawn + */ + bool IsDrawn() const; + /** * Marks the vehicles to be redrawn and updates cached variables * diff --git a/src/widgets/transparency_widget.h b/src/widgets/transparency_widget.h index 2b096e733..099d48a33 100644 --- a/src/widgets/transparency_widget.h +++ b/src/widgets/transparency_widget.h @@ -23,6 +23,7 @@ enum TransparencyToolbarWidgets { WID_TT_STRUCTURES, ///< Object structure transparency toggle button. WID_TT_CATENARY, ///< Catenary transparency toggle button. WID_TT_LOADING, ///< Loading indicators transparency toggle button. + WID_TT_TUNNELS, ///< Vehicles in tunnels toggle button. WID_TT_END, ///< End of toggle buttons. /* Panel with buttons for invisibility */ -- cgit v1.2.3-70-g09d2