tunnelbridge_cmd.cpp

Go to the documentation of this file.

/* $Id: tunnelbridge_cmd.cpp 14789 2009-01-02 22:42:05Z rubidium $ */

#include "stdafx.h"
#include "openttd.h"
#include "bridge_map.h"
#include "rail_map.h"
#include "road_map.h"
#include "tile_cmd.h"
#include "landscape.h"
#include "tunnel_map.h"
#include "unmovable_map.h"
#include "viewport_func.h"
#include "command_func.h"
#include "town.h"
#include "variables.h"
#include "bridge.h"
#include "train.h"
#include "water_map.h"
#include "yapf/yapf.h"
#include "newgrf_sound.h"
#include "autoslope.h"
#include "transparency.h"
#include "tunnelbridge_map.h"
#include "strings_func.h"
#include "date_func.h"
#include "functions.h"
#include "vehicle_func.h"
#include "sound_func.h"
#include "signal_func.h"
#include "tunnelbridge.h"
#include "company_base.h"
#include "engine_func.h"
#include "engine_base.h"
#include "economy_func.h"
#include "rail.h"
#include "cheat_func.h"
#include "elrail_func.h"
#include "landscape_type.h"

#include "table/sprites.h"
#include "table/strings.h"
#include "table/bridge_land.h"

BridgeSpec _bridge[MAX_BRIDGES];
TileIndex _build_tunnel_endtile;

void ResetBridges()
{
  /* First, free sprite table data */
  for (BridgeType i = 0; i < MAX_BRIDGES; i++) {
    if (_bridge[i].sprite_table != NULL) {
      for (BridgePieces j = BRIDGE_PIECE_NORTH; j < BRIDGE_PIECE_INVALID; j++) free(_bridge[i].sprite_table[j]);
      free(_bridge[i].sprite_table);
    }
  }

  /* Then, wipe out current bidges */
  memset(&_bridge, 0, sizeof(_bridge));
  /* And finally, reinstall default data */
  memcpy(&_bridge, &_orig_bridge, sizeof(_orig_bridge));
}

int CalcBridgeLenCostFactor(int x)
{
  int n;
  int r;

  if (x < 2) return x;
  x -= 2;
  for (n = 0, r = 2;; n++) {
    if (x <= n) return r + x * n;
    r += n * n;
    x -= n;
  }
}

Foundation GetBridgeFoundation(Slope tileh, Axis axis)
{
  if ((tileh == SLOPE_FLAT) ||
      (((tileh == SLOPE_NE) || (tileh == SLOPE_SW)) && (axis == AXIS_X)) ||
      (((tileh == SLOPE_NW) || (tileh == SLOPE_SE)) && (axis == AXIS_Y))) return FOUNDATION_NONE;

  return (HasSlopeHighestCorner(tileh) ? InclinedFoundation(axis) : FlatteningFoundation(tileh));
}

bool HasBridgeFlatRamp(Slope tileh, Axis axis)
{
  ApplyFoundationToSlope(GetBridgeFoundation(tileh, axis), &tileh);
  /* If the foundation slope is flat the bridge has a non-flat ramp and vice versa. */
  return (tileh != SLOPE_FLAT);
}

static inline const PalSpriteID *GetBridgeSpriteTable(int index, BridgePieces table)
{
  const BridgeSpec *bridge = GetBridgeSpec(index);
  assert(table < BRIDGE_PIECE_INVALID);
  if (bridge->sprite_table == NULL || bridge->sprite_table[table] == NULL) {
    return _bridge_sprite_table[index][table];
  } else {
    return bridge->sprite_table[table];
  }
}


static CommandCost CheckBridgeSlopeNorth(Axis axis, Slope *tileh, uint *z)
{
  Foundation f = GetBridgeFoundation(*tileh, axis);
  *z += ApplyFoundationToSlope(f, tileh);

  Slope valid_inclined = (axis == AXIS_X ? SLOPE_NE : SLOPE_NW);
  if ((*tileh != SLOPE_FLAT) && (*tileh != valid_inclined)) return CMD_ERROR;

  if (f == FOUNDATION_NONE) return CommandCost();

  return CommandCost(EXPENSES_CONSTRUCTION, _price.terraform);
}

static CommandCost CheckBridgeSlopeSouth(Axis axis, Slope *tileh, uint *z)
{
  Foundation f = GetBridgeFoundation(*tileh, axis);
  *z += ApplyFoundationToSlope(f, tileh);

  Slope valid_inclined = (axis == AXIS_X ? SLOPE_SW : SLOPE_SE);
  if ((*tileh != SLOPE_FLAT) && (*tileh != valid_inclined)) return CMD_ERROR;

  if (f == FOUNDATION_NONE) return CommandCost();

  return CommandCost(EXPENSES_CONSTRUCTION, _price.terraform);
}

bool CheckBridge_Stuff(BridgeType bridge_type, uint bridge_len, uint32 flags)
{
  if (flags & DC_QUERY_COST) {
    return bridge_len <= (_settings_game.construction.longbridges ? 100U : 16U);
  }

  if (bridge_type >= MAX_BRIDGES) return false;

  const BridgeSpec *b = GetBridgeSpec(bridge_type);
  if (b->avail_year > _cur_year) return false;

  uint max = b->max_length;
  if (max >= 16 && _settings_game.construction.longbridges) max = 100;

  return b->min_length <= bridge_len && bridge_len <= max;
}

CommandCost CmdBuildBridge(TileIndex end_tile, uint32 flags, uint32 p1, uint32 p2, const char *text)
{
  BridgeType bridge_type;
  RailType railtype = INVALID_RAILTYPE;
  RoadTypes roadtypes = ROADTYPES_NONE;
  uint x;
  uint y;
  uint sx;
  uint sy;
  TileIndex tile_start;
  TileIndex tile_end;
  Slope tileh_start;
  Slope tileh_end;
  uint z_start;
  uint z_end;
  TileIndex tile;
  TileIndexDiff delta;
  uint bridge_len;
  Axis direction;
  CommandCost cost(EXPENSES_CONSTRUCTION);
  CommandCost ret;
  bool replace_bridge = false;
  BridgeType replaced_bridge_type;
  TransportType transport_type;

  /* unpack parameters */
  bridge_type = GB(p2, 0, 8);

  if (p1 >= MapSize()) return CMD_ERROR;

  transport_type = (TransportType)GB(p2, 15, 2);

  /* type of bridge */
  switch (transport_type) {
    case TRANSPORT_ROAD:
      roadtypes = (RoadTypes)GB(p2, 8, 3);
      if (!AreValidRoadTypes(roadtypes) || !HasRoadTypesAvail(_current_company, roadtypes)) return CMD_ERROR;
      break;

    case TRANSPORT_RAIL:
      railtype = (RailType)GB(p2, 8, 7);
      if (!ValParamRailtype(railtype)) return CMD_ERROR;
      break;

    case TRANSPORT_WATER:
      break;

    default:
      /* Airports don't have tunnels. */
      return CMD_ERROR;
  }

  x = TileX(end_tile);
  y = TileY(end_tile);
  sx = TileX(p1);
  sy = TileY(p1);

  /* check if valid, and make sure that (x,y) are smaller than (sx,sy) */
  if (x == sx) {
    if (y == sy) return_cmd_error(STR_5008_CANNOT_START_AND_END_ON);
    direction = AXIS_Y;
    if (y > sy) Swap(y, sy);
  } else if (y == sy) {
    direction = AXIS_X;
    if (x > sx) Swap(x, sx);
  } else {
    return_cmd_error(STR_500A_START_AND_END_MUST_BE_IN);
  }

  bridge_len = sx + sy - x - y - 1;
  if (transport_type != TRANSPORT_WATER) {
    /* set and test bridge length, availability */
    if (!CheckBridge_Stuff(bridge_type, bridge_len, flags)) return_cmd_error(STR_5015_CAN_T_BUILD_BRIDGE_HERE);
  }

  /* retrieve landscape height and ensure it's on land */
  tile_start = TileXY(x, y);
  tile_end = TileXY(sx, sy);
  if (IsWaterTile(tile_start) || IsWaterTile(tile_end)) {
    return_cmd_error(STR_02A0_ENDS_OF_BRIDGE_MUST_BOTH);
  }

  tileh_start = GetTileSlope(tile_start, &z_start);
  tileh_end = GetTileSlope(tile_end, &z_end);

  CommandCost terraform_cost_north = CheckBridgeSlopeNorth(direction, &tileh_start, &z_start);
  CommandCost terraform_cost_south = CheckBridgeSlopeSouth(direction, &tileh_end,   &z_end);

  if (z_start != z_end) return_cmd_error(STR_BRIDGEHEADS_NOT_SAME_HEIGHT);

  if (IsBridgeTile(tile_start) && IsBridgeTile(tile_end) &&
      GetOtherBridgeEnd(tile_start) == tile_end &&
      GetTunnelBridgeTransportType(tile_start) == transport_type) {
    /* Replace a current bridge. */

    /* If this is a railway bridge, make sure the railtypes match. */
    if (transport_type == TRANSPORT_RAIL && GetRailType(tile_start) != railtype) {
      return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);
    }

    /* Do not replace town bridges with lower speed bridges. */
    if (!(flags & DC_QUERY_COST) && IsTileOwner(tile_start, OWNER_TOWN) &&
        GetBridgeSpec(bridge_type)->speed < GetBridgeSpec(GetBridgeType(tile_start))->speed) {
      Town *t = ClosestTownFromTile(tile_start, UINT_MAX);

      if (t == NULL) {
        return CMD_ERROR;
      } else {
        SetDParam(0, t->index);
        return_cmd_error(STR_2009_LOCAL_AUTHORITY_REFUSES);
      }
    }

    /* Do not replace the bridge with the same bridge type. */
    if (!(flags & DC_QUERY_COST) && bridge_type == GetBridgeType(tile_start)) {
      return_cmd_error(STR_1007_ALREADY_BUILT);
    }

    /* Do not allow replacing another company's bridges. */
    if (!IsTileOwner(tile_start, _current_company) && !IsTileOwner(tile_start, OWNER_TOWN)) {
      return_cmd_error(STR_1024_AREA_IS_OWNED_BY_ANOTHER);
    }

    cost.AddCost((bridge_len + 1) * _price.clear_bridge); // The cost of clearing the current bridge.
    replace_bridge = true;
    replaced_bridge_type = GetBridgeType(tile_start);

    /* Do not remove road types when upgrading a bridge */
    roadtypes |= GetRoadTypes(tile_start);
  } else {
    /* Build a new bridge. */

    bool allow_on_slopes = (!_is_old_ai_company && _settings_game.construction.build_on_slopes && transport_type != TRANSPORT_WATER);

    /* Try and clear the start landscape */
    ret = DoCommand(tile_start, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
    if (CmdFailed(ret)) return ret;
    cost = ret;

    if (CmdFailed(terraform_cost_north) || (terraform_cost_north.GetCost() != 0 && !allow_on_slopes))
      return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
    cost.AddCost(terraform_cost_north);

    /* Try and clear the end landscape */
    ret = DoCommand(tile_end, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
    if (CmdFailed(ret)) return ret;
    cost.AddCost(ret);

    /* false - end tile slope check */
    if (CmdFailed(terraform_cost_south) || (terraform_cost_south.GetCost() != 0 && !allow_on_slopes))
      return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
    cost.AddCost(terraform_cost_south);

    if (transport_type == TRANSPORT_WATER && (tileh_start == SLOPE_FLAT || tileh_end == SLOPE_FLAT)) return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
  }

  if (!replace_bridge) {
    TileIndex Heads[] = {tile_start, tile_end};
    int i;

    for (i = 0; i < 2; i++) {
      if (MayHaveBridgeAbove(Heads[i])) {
        if (IsBridgeAbove(Heads[i])) {
          TileIndex north_head = GetNorthernBridgeEnd(Heads[i]);

          if (direction == GetBridgeAxis(Heads[i])) return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);

          if (z_start + TILE_HEIGHT == GetBridgeHeight(north_head)) {
            return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);
          }
        }
      }
    }
  }

  /* do the drill? */
  if (flags & DC_EXEC) {
    DiagDirection dir = AxisToDiagDir(direction);
    Owner owner = (replace_bridge && IsTileOwner(tile_start, OWNER_TOWN)) ? OWNER_TOWN : _current_company;

    switch (transport_type) {
      case TRANSPORT_RAIL:
        MakeRailBridgeRamp(tile_start, owner, bridge_type, dir,                 railtype);
        MakeRailBridgeRamp(tile_end,   owner, bridge_type, ReverseDiagDir(dir), railtype);
        break;

      case TRANSPORT_ROAD:
        MakeRoadBridgeRamp(tile_start, owner, bridge_type, dir,                 roadtypes);
        MakeRoadBridgeRamp(tile_end,   owner, bridge_type, ReverseDiagDir(dir), roadtypes);
        break;

      case TRANSPORT_WATER:
        MakeAqueductBridgeRamp(tile_start, owner, dir);
        MakeAqueductBridgeRamp(tile_end,   owner, ReverseDiagDir(dir));
        break;

      default:
        NOT_REACHED();
        break;
    }
    MarkTileDirtyByTile(tile_start);
    MarkTileDirtyByTile(tile_end);
  }

  delta = (direction == AXIS_X ? TileDiffXY(1, 0) : TileDiffXY(0, 1));
  for (tile = tile_start + delta; tile != tile_end; tile += delta) {
    if (GetTileMaxZ(tile) > z_start) return_cmd_error(STR_BRIDGE_TOO_LOW_FOR_TERRAIN);

    if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile) && !replace_bridge) {
      /* Disallow crossing bridges for the time being */
      return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);
    }

    switch (GetTileType(tile)) {
      case MP_WATER:
        if (!IsWater(tile) && !IsCoast(tile)) goto not_valid_below;
        break;

      case MP_RAILWAY:
        if (!IsPlainRailTile(tile)) goto not_valid_below;
        break;

      case MP_ROAD:
        if (IsRoadDepot(tile)) goto not_valid_below;
        break;

      case MP_TUNNELBRIDGE:
        if (IsTunnel(tile)) break;
        if (replace_bridge) break;
        if (direction == DiagDirToAxis(GetTunnelBridgeDirection(tile))) goto not_valid_below;
        if (z_start < GetBridgeHeight(tile)) goto not_valid_below;
        break;

      case MP_UNMOVABLE:
        if (!IsOwnedLand(tile)) goto not_valid_below;
        break;

      case MP_CLEAR:
        break;

      default:
not_valid_below:;
        /* try and clear the middle landscape */
        ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
        if (CmdFailed(ret)) return ret;
        cost.AddCost(ret);
        break;
    }

    if (flags & DC_EXEC) {
      SetBridgeMiddle(tile, direction);
      MarkTileDirtyByTile(tile);
    }
  }

  if (flags & DC_EXEC && transport_type == TRANSPORT_RAIL) {
    Track track = AxisToTrack(direction);
    AddSideToSignalBuffer(tile_start, INVALID_DIAGDIR, _current_company);
    YapfNotifyTrackLayoutChange(tile_start, track);
  }

  /* for human player that builds the bridge he gets a selection to choose from bridges (DC_QUERY_COST)
   * It's unnecessary to execute this command every time for every bridge. So it is done only
   * and cost is computed in "bridge_gui.c". For AI, Towns this has to be of course calculated
   */
  if (!(flags & DC_QUERY_COST) || (IsValidCompanyID(_current_company) && GetCompany(_current_company)->is_ai)) {
    bridge_len += 2; // begin and end tiles/ramps

    if (IsValidCompanyID(_current_company) && !_is_old_ai_company)
      bridge_len = CalcBridgeLenCostFactor(bridge_len);

    cost.AddCost((int64)bridge_len * _price.build_bridge * GetBridgeSpec(bridge_type)->price >> 8);

    /* Aqueducts are a little more expensive. */
    if (transport_type == TRANSPORT_WATER) cost.AddCost((int64)bridge_len * _price.clear_water);
  }

  return cost;
}


CommandCost CmdBuildTunnel(TileIndex start_tile, uint32 flags, uint32 p1, uint32 p2, const char *text)
{
  TileIndexDiff delta;
  TileIndex end_tile;
  DiagDirection direction;
  Slope start_tileh;
  Slope end_tileh;
  TransportType transport_type = (TransportType)GB(p1, 9, 1);
  uint start_z;
  uint end_z;
  CommandCost cost(EXPENSES_CONSTRUCTION);
  CommandCost ret;

  _build_tunnel_endtile = 0;
  if (transport_type == TRANSPORT_RAIL) {
    if (!ValParamRailtype((RailType)p1)) return CMD_ERROR;
  } else {
    const RoadTypes rts = (RoadTypes)GB(p1, 0, 3);
    if (!AreValidRoadTypes(rts) || !HasRoadTypesAvail(_current_company, rts)) return CMD_ERROR;
  }

  start_tileh = GetTileSlope(start_tile, &start_z);
  direction = GetInclinedSlopeDirection(start_tileh);
  if (direction == INVALID_DIAGDIR) return_cmd_error(STR_500B_SITE_UNSUITABLE_FOR_TUNNEL);

  if (IsWaterTile(start_tile)) return_cmd_error(STR_3807_CAN_T_BUILD_ON_WATER);

  ret = DoCommand(start_tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
  if (CmdFailed(ret)) return ret;

  /* XXX - do NOT change 'ret' in the loop, as it is used as the price
   * for the clearing of the entrance of the tunnel. Assigning it to
   * cost before the loop will yield different costs depending on start-
   * position, because of increased-cost-by-length: 'cost += cost >> 3' */

  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;
  }

  end_tile = start_tile;

  int tiles_coef = 3;
  int tiles = 0;
  int tiles_bump = 25;

  for (;;) {
    end_tile += delta;
    end_tileh = GetTileSlope(end_tile, &end_z);

    if (start_z == end_z) break;

    if (!_cheats.crossing_tunnels.value && IsTunnelInWayDir(end_tile, start_z, tunnel_in_way_dir)) {
      return_cmd_error(STR_5003_ANOTHER_TUNNEL_IN_THE_WAY);
    }

    tiles++;
    if (tiles == tiles_bump) {
      tiles_coef++;
      tiles_bump *= 2;
    }

    cost.AddCost(_price.build_tunnel);
    cost.AddCost(cost.GetCost() >> tiles_coef); // add a multiplier for longer tunnels
  }

  /* Add the cost of the entrance */
  cost.AddCost(_price.build_tunnel);
  cost.AddCost(ret);

  /* if the command fails from here on we want the end tile to be highlighted */
  _build_tunnel_endtile = end_tile;

  if (IsWaterTile(end_tile)) return_cmd_error(STR_3807_CAN_T_BUILD_ON_WATER);

  /* slope of end tile must be complementary to the slope of the start tile */
  if (end_tileh != ComplementSlope(start_tileh)) {
    /* Check if there is a structure on the terraformed tile. Do not add the cost, that will be done by the terraforming
     * Note: Currently the town rating is also affected by this clearing-test. So effectivly the player is punished twice for clearing
     *       the tree on end_tile.
     */
    ret = DoCommand(end_tile, 0, 0, DC_AUTO, CMD_LANDSCAPE_CLEAR);
    if (CmdFailed(ret)) return_cmd_error(STR_5005_UNABLE_TO_EXCAVATE_LAND);

    ret = DoCommand(end_tile, end_tileh & start_tileh, 0, flags, CMD_TERRAFORM_LAND);
    if (CmdFailed(ret)) return_cmd_error(STR_5005_UNABLE_TO_EXCAVATE_LAND);
  } else {
    ret = DoCommand(end_tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
    if (CmdFailed(ret)) return ret;
  }
  cost.AddCost(_price.build_tunnel);
  cost.AddCost(ret);

  if (flags & DC_EXEC) {
    if (transport_type == TRANSPORT_RAIL) {
      MakeRailTunnel(start_tile, _current_company, direction,                 (RailType)GB(p1, 0, 4));
      MakeRailTunnel(end_tile,   _current_company, ReverseDiagDir(direction), (RailType)GB(p1, 0, 4));
      AddSideToSignalBuffer(start_tile, INVALID_DIAGDIR, _current_company);
      YapfNotifyTrackLayoutChange(start_tile, DiagDirToDiagTrack(direction));
    } else {
      MakeRoadTunnel(start_tile, _current_company, direction,                 (RoadTypes)GB(p1, 0, 3));
      MakeRoadTunnel(end_tile,   _current_company, ReverseDiagDir(direction), (RoadTypes)GB(p1, 0, 3));
    }
  }

  return cost;
}


static inline bool CheckAllowRemoveTunnelBridge(TileIndex tile)
{
  /* Floods can remove anything as well as the scenario editor */
  if (_current_company == OWNER_WATER || _game_mode == GM_EDITOR) return true;
  /* Obviously if the bridge/tunnel belongs to us, or no-one, we can remove it */
  if (CheckTileOwnership(tile) || IsTileOwner(tile, OWNER_NONE)) return true;
  /* Otherwise we can only remove town-owned stuff with extra patch-settings, or cheat */
  if (IsTileOwner(tile, OWNER_TOWN) && (_settings_game.construction.extra_dynamite || _cheats.magic_bulldozer.value)) return true;
  return false;
}

static CommandCost DoClearTunnel(TileIndex tile, uint32 flags)
{
  Town *t = NULL;
  TileIndex endtile;

  if (!CheckAllowRemoveTunnelBridge(tile)) return CMD_ERROR;

  endtile = GetOtherTunnelEnd(tile);

  if (HasVehicleOnTunnelBridge(tile, endtile)) return CMD_ERROR;

  _build_tunnel_endtile = endtile;

  if (IsTileOwner(tile, OWNER_TOWN) && _game_mode != GM_EDITOR) {
    t = ClosestTownFromTile(tile, UINT_MAX); // town penalty rating

    /* Check if you are allowed to remove the tunnel owned by a town
     * Removal depends on difficulty settings */
    if (!CheckforTownRating(flags, t, TUNNELBRIDGE_REMOVE)) {
      SetDParam(0, t->index);
      return_cmd_error(STR_2009_LOCAL_AUTHORITY_REFUSES);
    }
  }

  /* checks if the owner is town then decrease town rating by RATING_TUNNEL_BRIDGE_DOWN_STEP until
   * you have a "Poor" (0) town rating */
  if (IsTileOwner(tile, OWNER_TOWN) && _game_mode != GM_EDITOR) {
    ChangeTownRating(t, RATING_TUNNEL_BRIDGE_DOWN_STEP, RATING_TUNNEL_BRIDGE_MINIMUM);
  }

  if (flags & DC_EXEC) {
    if (GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL) {
      /* We first need to request values before calling DoClearSquare */
      DiagDirection dir = GetTunnelBridgeDirection(tile);
      Track track = DiagDirToDiagTrack(dir);
      Owner owner = GetTileOwner(tile);

      Vehicle *v = NULL;
      if (GetTunnelBridgeReservation(tile)) {
        v = GetTrainForReservation(tile, track);
        if (v != NULL) FreeTrainTrackReservation(v);
      }

      DoClearSquare(tile);
      DoClearSquare(endtile);

      /* cannot use INVALID_DIAGDIR for signal update because the tunnel doesn't exist anymore */
      AddSideToSignalBuffer(tile,    ReverseDiagDir(dir), owner);
      AddSideToSignalBuffer(endtile, dir,                 owner);

      YapfNotifyTrackLayoutChange(tile,    track);
      YapfNotifyTrackLayoutChange(endtile, track);

      if (v != NULL) TryPathReserve(v);
    } else {
      DoClearSquare(tile);
      DoClearSquare(endtile);
    }
  }
  return CommandCost(EXPENSES_CONSTRUCTION, _price.clear_tunnel * (GetTunnelBridgeLength(tile, endtile) + 2));
}


static CommandCost DoClearBridge(TileIndex tile, uint32 flags)
{
  DiagDirection direction;
  TileIndexDiff delta;
  TileIndex endtile;
  Town *t = NULL;

  if (!CheckAllowRemoveTunnelBridge(tile)) return CMD_ERROR;

  endtile = GetOtherBridgeEnd(tile);

  if (HasVehicleOnTunnelBridge(tile, endtile)) return CMD_ERROR;

  direction = GetTunnelBridgeDirection(tile);
  delta = TileOffsByDiagDir(direction);

  if (IsTileOwner(tile, OWNER_TOWN) && _game_mode != GM_EDITOR) {
    t = ClosestTownFromTile(tile, UINT_MAX); // town penalty rating

    /* Check if you are allowed to remove the bridge owned by a town
     * Removal depends on difficulty settings */
    if (!CheckforTownRating(flags, t, TUNNELBRIDGE_REMOVE)) {
      SetDParam(0, t->index);
      return_cmd_error(STR_2009_LOCAL_AUTHORITY_REFUSES);
    }
  }

  /* checks if the owner is town then decrease town rating by RATING_TUNNEL_BRIDGE_DOWN_STEP until
   * you have a "Poor" (0) town rating */
  if (IsTileOwner(tile, OWNER_TOWN) && _game_mode != GM_EDITOR) {
    ChangeTownRating(t, RATING_TUNNEL_BRIDGE_DOWN_STEP, RATING_TUNNEL_BRIDGE_MINIMUM);
  }

  if (flags & DC_EXEC) {
    /* read this value before actual removal of bridge */
    bool rail = GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL;
    Owner owner = GetTileOwner(tile);
    uint height = GetBridgeHeight(tile);
    Vehicle *v = NULL;

    if (rail && GetTunnelBridgeReservation(tile)) {
      v = GetTrainForReservation(tile, DiagDirToDiagTrack(direction));
      if (v != NULL) FreeTrainTrackReservation(v);
    }

    DoClearSquare(tile);
    DoClearSquare(endtile);
    for (TileIndex c = tile + delta; c != endtile; c += delta) {
      /* do not let trees appear from 'nowhere' after removing bridge */
      if (IsNormalRoadTile(c) && GetRoadside(c) == ROADSIDE_TREES) {
        uint minz = GetTileMaxZ(c) + 3 * TILE_HEIGHT;
        if (height < minz) SetRoadside(c, ROADSIDE_PAVED);
      }
      ClearBridgeMiddle(c);
      MarkTileDirtyByTile(c);
    }

    if (rail) {
      /* cannot use INVALID_DIAGDIR for signal update because the bridge doesn't exist anymore */
      AddSideToSignalBuffer(tile,    ReverseDiagDir(direction), owner);
      AddSideToSignalBuffer(endtile, direction,                 owner);

      Track track = DiagDirToDiagTrack(direction);
      YapfNotifyTrackLayoutChange(tile,    track);
      YapfNotifyTrackLayoutChange(endtile, track);

      if (v != NULL) TryPathReserve(v, true);
    }
  }

  return CommandCost(EXPENSES_CONSTRUCTION, (GetTunnelBridgeLength(tile, endtile) + 2) * _price.clear_bridge);
}

static CommandCost ClearTile_TunnelBridge(TileIndex tile, byte flags)
{
  if (IsTunnel(tile)) {
    if (flags & DC_AUTO) return_cmd_error(STR_5006_MUST_DEMOLISH_TUNNEL_FIRST);
    return DoClearTunnel(tile, flags);
  } else { // IsBridge(tile)
    if (flags & DC_AUTO) return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);
    return DoClearBridge(tile, flags);
  }

  return CMD_ERROR;
}

static void DrawBridgePillars(const PalSpriteID *psid, const TileInfo* ti, Axis axis, bool drawfarpillar, int x, int y, int z_bridge)
{
  /* Do not draw bridge pillars if they are invisible */
  if (IsInvisibilitySet(TO_BRIDGES)) return;

  SpriteID image = psid->sprite;

  if (image != 0) {
    /* "side" specifies the side the pillars stand on.
     * The length of the pillars is then set to the height of the bridge over the corners of this edge.
     *
     *                axis==AXIS_X  axis==AXIS_Y
     *   side==false      SW            NW
     *   side==true       NE            SE
     *
     * I have no clue, why this was done this way.
     */
    bool side = HasBit(image, 0);

    /* "dir" means the edge the pillars stand on */
    DiagDirection dir = AxisToDiagDir(axis);
    if (side != (axis == AXIS_Y)) dir = ReverseDiagDir(dir);

    /* Determine ground height under pillars */
    int front_height = ti->z;
    int back_height = ti->z;
    GetSlopeZOnEdge(ti->tileh, dir, &front_height, &back_height);

    /* x and y size of bounding-box of pillars */
    int w = (axis == AXIS_X ? 16 : 2);
    int h = (axis == AXIS_X ? 2 : 16);
    /* sprite position of back facing pillar */
    int x_back = x - (axis == AXIS_X ? 0 : 9);
    int y_back = y - (axis == AXIS_X ? 9 : 0);

    for (int cur_z = z_bridge; cur_z >= front_height || cur_z >= back_height; cur_z -= TILE_HEIGHT) {
      /* Draw front facing pillar */
      if (cur_z >= front_height) {
        AddSortableSpriteToDraw(image, psid->pal, x, y, w, h, BB_HEIGHT_UNDER_BRIDGE - 5, cur_z, IsTransparencySet(TO_BRIDGES), 0, 0, -5);
      }

      /* Draw back facing pillar, but not the highest part directly under the bridge-floor */
      if (drawfarpillar && cur_z >= back_height && cur_z < z_bridge - TILE_HEIGHT) {
        AddSortableSpriteToDraw(image, psid->pal, x_back, y_back, w, h, BB_HEIGHT_UNDER_BRIDGE - 5, cur_z, IsTransparencySet(TO_BRIDGES), 0, 0, -5);
      }
    }
  }
}

static void DrawBridgeTramBits(int x, int y, byte z, int offset, bool overlay, bool head)
{
  static const SpriteID tram_offsets[2][6] = { { 107, 108, 109, 110, 111, 112 }, { 4, 5, 15, 16, 17, 18 } };
  static const SpriteID back_offsets[6]    =   {  95,  96,  99, 102, 100, 101 };
  static const SpriteID front_offsets[6]   =   {  97,  98, 103, 106, 104, 105 };

  static const uint size_x[6] = {  1, 16, 16,  1, 16,  1 };
  static const uint size_y[6] = { 16,  1,  1, 16,  1, 16 };
  static const uint front_bb_offset_x[6] = { 15,  0,  0, 15,  0, 15 };
  static const uint front_bb_offset_y[6] = {  0, 15, 15,  0, 15,  0 };

  /* The sprites under the vehicles are drawn as SpriteCombine. StartSpriteCombine() has already been called
   * The bounding boxes here are the same as for bridge front/roof */
  if (head || !IsInvisibilitySet(TO_BRIDGES)) {
    AddSortableSpriteToDraw(SPR_TRAMWAY_BASE + tram_offsets[overlay][offset], PAL_NONE,
      x, y, size_x[offset], size_y[offset], 0x28, z,
      !head && IsTransparencySet(TO_BRIDGES));
  }

  /* Do not draw catenary if it is set invisible */
  if (!IsInvisibilitySet(TO_CATENARY)) {
    AddSortableSpriteToDraw(SPR_TRAMWAY_BASE + back_offsets[offset], PAL_NON