src/bridge_map.cpp

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * 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.
   6  * 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.
   7  * 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/>.
   8  */
   9
  10 /** @file bridge_map.cpp Map accessor functions for bridges. */
  11
  12 #include "stdafx.h"
  13 #include "landscape.h"
  14 #include "tunnelbridge_map.h"
  15 #include "bridge_signal_map.h"
  16 #include "debug.h"
  17
  18 #include "safeguards.h"
  19
  20
  21 /**
  22  * Finds the end of a bridge in the specified direction starting at a middle tile
  23  * @param tile the bridge tile to find the bridge ramp for
  24  * @param dir  the direction to search in
  25  */
  26 static TileIndex GetBridgeEnd(TileIndex tile, DiagDirection dir)
  27 {
  28         TileIndexDiff delta = TileOffsByDiagDir(dir);
  29
  30         dir = ReverseDiagDir(dir);
  31         do {
  32                 tile += delta;
  33         } while (!IsBridgeTile(tile) || GetTunnelBridgeDirection(tile) != dir);
  34
  35         return tile;
  36 }
  37
  38
  39 /**
  40  * Finds the northern end of a bridge starting at a middle tile
  41  * @param t the bridge tile to find the bridge ramp for
  42  */
  43 TileIndex GetNorthernBridgeEnd(TileIndex t)
  44 {
  45         return GetBridgeEnd(t, ReverseDiagDir(AxisToDiagDir(GetBridgeAxis(t))));
  46 }
  47
  48
  49 /**
  50  * Finds the southern end of a bridge starting at a middle tile
  51  * @param t the bridge tile to find the bridge ramp for
  52  */
  53 TileIndex GetSouthernBridgeEnd(TileIndex t)
  54 {
  55         return GetBridgeEnd(t, AxisToDiagDir(GetBridgeAxis(t)));
  56 }
  57
  58
  59 /**
  60  * Starting at one bridge end finds the other bridge end
  61  * @param t the bridge ramp tile to find the other bridge ramp for
  62  */
  63 TileIndex GetOtherBridgeEnd(TileIndex tile)
  64 {
  65         assert(IsBridgeTile(tile));
  66         return GetBridgeEnd(tile, GetTunnelBridgeDirection(tile));
  67 }
  68
  69 /**
  70  * Get the height ('z') of a bridge.
  71  * @param tile the bridge ramp tile to get the bridge height from
  72  * @return the height of the bridge.
  73  */
  74 int GetBridgeHeight(TileIndex t)
  75 {
  76         int h;
  77         Slope tileh = GetTileSlope(t, &h);
  78         Foundation f = GetBridgeFoundation(tileh, DiagDirToAxis(GetTunnelBridgeDirection(t)));
  79
  80         /* one height level extra for the ramp */
  81         return h + 1 + ApplyFoundationToSlope(f, &tileh);
  82 }
  83
  84 std::unordered_map<TileIndex, LongBridgeSignalStorage> _long_bridge_signal_sim_map;
  85
  86 SignalState GetBridgeEntranceSimulatedSignalStateExtended(TileIndex t, uint16 signal)
  87 {
  88         const auto it = _long_bridge_signal_sim_map.find(t);
  89         if (it != _long_bridge_signal_sim_map.end()) {
  90                 const LongBridgeSignalStorage &lbss = it->second;
  91                 uint16 offset = signal - 15;
  92                 uint16 slot = offset >> 6;
  93                 uint16 bit = offset & 0x3F;
  94                 if (slot >= lbss.signal_red_bits.size()) return SIGNAL_STATE_GREEN;
  95                 return GB(lbss.signal_red_bits[slot], bit, 1) ? SIGNAL_STATE_RED : SIGNAL_STATE_GREEN;
  96         } else {
  97                 return SIGNAL_STATE_GREEN;
  98         }
  99 }
 100
 101 void SetBridgeEntranceSimulatedSignalStateExtended(TileIndex t, uint16 signal, SignalState state)
 102 {
 103         LongBridgeSignalStorage &lbss = _long_bridge_signal_sim_map[t];
 104         uint16 offset = signal - 15;
 105         uint16 slot = offset >> 6;
 106         uint16 bit = offset & 0x3F;
 107         if (slot >= lbss.signal_red_bits.size()) lbss.signal_red_bits.resize(slot + 1);
 108         SB(lbss.signal_red_bits[slot], bit, 1, (uint64) ((state == SIGNAL_STATE_RED) ? 1 : 0));
 109         _m[t].m2 |= 0x8000;
 110 }
 111
 112 void SetAllBridgeEntranceSimulatedSignalsGreenExtended(TileIndex t)
 113 {
 114         auto it = _long_bridge_signal_sim_map.find(t);
 115         if (it != _long_bridge_signal_sim_map.end()) {
 116                 LongBridgeSignalStorage &lbss = it->second;
 117                 for (auto &it : lbss.signal_red_bits) {
 118                         it = 0;
 119                 }
 120                 _m[t].m2 = 0x8000;
 121         } else {
 122                 _m[t].m2 = 0;
 123         }
 124 }
 125
 126 void ClearBridgeEntranceSimulatedSignalsExtended(TileIndex t)
 127 {
 128         _long_bridge_signal_sim_map.erase(t);
 129         _m[t].m2 = 0;
 130 }
 131
 132 void ClearBridgeSimulatedSignalMapping()
 133 {
 134         _long_bridge_signal_sim_map.clear();
 135 }