station_cmd.cpp

Go to the documentation of this file.

/* $Id: station_cmd.cpp 14933 2009-01-09 14:59:02Z rubidium $ */

#include "stdafx.h"
#include "openttd.h"
#include "aircraft.h"
#include "bridge_map.h"
#include "cmd_helper.h"
#include "debug.h"
#include "tile_cmd.h"
#include "landscape.h"
#include "station_map.h"
#include "viewport_func.h"
#include "command_func.h"
#include "town.h"
#include "news_func.h"
#include "airport.h"
#include "sprite.h"
#include "train.h"
#include "roadveh.h"
#include "water_map.h"
#include "industry_map.h"
#include "newgrf_callbacks.h"
#include "newgrf_station.h"
#include "newgrf_commons.h"
#include "yapf/yapf.h"
#include "road_type.h"
#include "road_internal.h" /* For drawing catenary/checking road removal */
#include "cargotype.h"
#include "variables.h"
#include "autoslope.h"
#include "transparency.h"
#include "water.h"
#include "station_gui.h"
#include "strings_func.h"
#include "functions.h"
#include "window_func.h"
#include "date_func.h"
#include "vehicle_func.h"
#include "string_func.h"
#include "signal_func.h"
#include "oldpool_func.h"
#include "animated_tile_func.h"
#include "elrail_func.h"
#include "newgrf.h"
#include "core/smallvec_type.hpp"

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

DEFINE_OLD_POOL_GENERIC(Station, Station)
DEFINE_OLD_POOL_GENERIC(RoadStop, RoadStop)


bool IsHangar(TileIndex t)
{
  assert(IsTileType(t, MP_STATION));

  const Station *st = GetStationByTile(t);
  const AirportFTAClass *apc = st->Airport();

  for (uint i = 0; i < apc->nof_depots; i++) {
    if (st->airport_tile + ToTileIndexDiff(apc->airport_depots[i]) == t) return true;
  }

  return false;
}

RoadStop *GetRoadStopByTile(TileIndex tile, RoadStopType type)
{
  const Station *st = GetStationByTile(tile);

  for (RoadStop *rs = st->GetPrimaryRoadStop(type);; rs = rs->next) {
    if (rs->xy == tile) return rs;
    assert(rs->next != NULL);
  }
}


static uint GetNumRoadStopsInStation(const Station *st, RoadStopType type)
{
  uint num = 0;

  assert(st != NULL);
  for (const RoadStop *rs = st->GetPrimaryRoadStop(type); rs != NULL; rs = rs->next) {
    num++;
  }

  return num;
}


#define CHECK_STATIONS_ERR ((Station*)-1)

static Station *GetStationAround(TileIndex tile, int w, int h, StationID closest_station)
{
  /* check around to see if there's any stations there */
  BEGIN_TILE_LOOP(tile_cur, w + 2, h + 2, tile - TileDiffXY(1, 1))
    if (IsTileType(tile_cur, MP_STATION)) {
      StationID t = GetStationIndex(tile_cur);

      if (closest_station == INVALID_STATION) {
        closest_station = t;
      } else if (closest_station != t) {
        _error_message = STR_3006_ADJOINS_MORE_THAN_ONE_EXISTING;
        return CHECK_STATIONS_ERR;
      }
    }
  END_TILE_LOOP(tile_cur, w + 2, h + 2, tile - TileDiffXY(1, 1))
  return (closest_station == INVALID_STATION) ? NULL : GetStation(closest_station);
}

typedef bool (*CMSAMatcher)(TileIndex tile);

static int CountMapSquareAround(TileIndex tile, CMSAMatcher cmp)
{
  int num = 0;

  for (int dx = -3; dx <= 3; dx++) {
    for (int dy = -3; dy <= 3; dy++) {
      if (cmp(TILE_MASK(tile + TileDiffXY(dx, dy)))) num++;
    }
  }

  return num;
}

static bool CMSAMine(TileIndex tile)
{
  /* No industry */
  if (!IsTileType(tile, MP_INDUSTRY)) return false;

  const Industry *ind = GetIndustryByTile(tile);

  /* No extractive industry */
  if ((GetIndustrySpec(ind->type)->life_type & INDUSTRYLIFE_EXTRACTIVE) == 0) return false;

  for (uint i = 0; i < lengthof(ind->produced_cargo); i++) {
    /* The industry extracts something non-liquid, i.e. no oil or plastic, so it is a mine */
    if (ind->produced_cargo[i] != CT_INVALID && (GetCargo(ind->produced_cargo[i])->classes & CC_LIQUID) == 0) return true;
  }

  return false;
}

static bool CMSAWater(TileIndex tile)
{
  return IsTileType(tile, MP_WATER) && IsWater(tile);
}

static bool CMSATree(TileIndex tile)
{
  return IsTileType(tile, MP_TREES);
}

static bool CMSAForest(TileIndex tile)
{
  /* No industry */
  if (!IsTileType(tile, MP_INDUSTRY)) return false;

  const Industry *ind = GetIndustryByTile(tile);

  /* No extractive industry */
  if ((GetIndustrySpec(ind->type)->life_type & INDUSTRYLIFE_ORGANIC) == 0) return false;

  for (uint i = 0; i < lengthof(ind->produced_cargo); i++) {
    /* The industry produces wood. */
    if (ind->produced_cargo[i] != CT_INVALID && GetCargo(ind->produced_cargo[i])->label == 'WOOD') return true;
  }

  return false;
}

#define M(x) ((x) - STR_SV_STNAME)

enum StationNaming {
  STATIONNAMING_RAIL = 0,
  STATIONNAMING_ROAD = 0,
  STATIONNAMING_AIRPORT,
  STATIONNAMING_OILRIG,
  STATIONNAMING_DOCK,
  STATIONNAMING_BUOY,
  STATIONNAMING_HELIPORT,
};

struct StationNameInformation {
  uint32 free_names; 
  bool *indtypes;    
};

static bool FindNearIndustryName(TileIndex tile, void *user_data)
{
  /* All already found industry types */
  StationNameInformation *sni = (StationNameInformation*)user_data;
  if (!IsTileType(tile, MP_INDUSTRY)) return false;

  /* If the station name is undefined it means that it doesn't name a station */
  IndustryType indtype = GetIndustryType(tile);
  if (GetIndustrySpec(indtype)->station_name == STR_UNDEFINED) return false;

  /* In all cases if an industry that provides a name is found two of
   * the standard names will be disabled. */
  sni->free_names &= ~(1 << M(STR_SV_STNAME_OILFIELD) | 1 << M(STR_SV_STNAME_MINES));
  return !sni->indtypes[indtype];
}

static StringID GenerateStationName(Station *st, TileIndex tile, int flag)
{
  static const uint32 _gen_station_name_bits[] = {
    0,                                      /* 0 */
    1 << M(STR_SV_STNAME_AIRPORT),          /* 1 */
    1 << M(STR_SV_STNAME_OILFIELD),         /* 2 */
    1 << M(STR_SV_STNAME_DOCKS),            /* 3 */
    0x1FF << M(STR_SV_STNAME_BUOY_1),       /* 4 */
    1 << M(STR_SV_STNAME_HELIPORT),         /* 5 */
  };

  const Town *t = st->town;
  uint32 free_names = UINT32_MAX;

  bool indtypes[NUM_INDUSTRYTYPES];
  memset(indtypes, 0, sizeof(indtypes));

  const Station *s;
  FOR_ALL_STATIONS(s) {
    if (s != st && s->town == t) {
      if (s->indtype != IT_INVALID) {
        indtypes[s->indtype] = true;
        continue;
      }
      uint str = M(s->string_id);
      if (str <= 0x20) {
        if (str == M(STR_SV_STNAME_FOREST)) {
          str = M(STR_SV_STNAME_WOODS);
        }
        ClrBit(free_names, str);
      }
    }
  }

  if (flag != STATIONNAMING_BUOY) {
    TileIndex indtile = tile;
    StationNameInformation sni = { free_names, indtypes };
    if (CircularTileSearch(&indtile, 7, FindNearIndustryName, &sni)) {
      /* An industry has been found nearby */
      IndustryType indtype = GetIndustryType(indtile);
      const IndustrySpec *indsp = GetIndustrySpec(indtype);
      /* STR_NULL means it only disables oil rig/mines */
      if (indsp->station_name != STR_NULL) {
        st->indtype = indtype;
        return STR_SV_STNAME_FALLBACK;
      }
    }

    /* Oil rigs/mines name could be marked not free by looking for a near by industry. */
    free_names = sni.free_names;
  }

  /* check default names */
  uint32 tmp = free_names & _gen_station_name_bits[flag];
  if (tmp != 0) return STR_SV_STNAME + FindFirstBit(tmp);

  /* check mine? */
  if (HasBit(free_names, M(STR_SV_STNAME_MINES))) {
    if (CountMapSquareAround(tile, CMSAMine) >= 2) {
      return STR_SV_STNAME_MINES;
    }
  }

  /* check close enough to town to get central as name? */
  if (DistanceMax(tile, t->xy) < 8) {
    if (HasBit(free_names, M(STR_SV_STNAME))) return STR_SV_STNAME;

    if (HasBit(free_names, M(STR_SV_STNAME_CENTRAL))) return STR_SV_STNAME_CENTRAL;
  }

  /* Check lakeside */
  if (HasBit(free_names, M(STR_SV_STNAME_LAKESIDE)) &&
      DistanceFromEdge(tile) < 20 &&
      CountMapSquareAround(tile, CMSAWater) >= 5) {
    return STR_SV_STNAME_LAKESIDE;
  }

  /* Check woods */
  if (HasBit(free_names, M(STR_SV_STNAME_WOODS)) && (
        CountMapSquareAround(tile, CMSATree) >= 8 ||
        CountMapSquareAround(tile, CMSAForest) >= 2)
      ) {
    return _settings_game.game_creation.landscape == LT_TROPIC ? STR_SV_STNAME_FOREST : STR_SV_STNAME_WOODS;
  }

  /* check elevation compared to town */
  uint z = GetTileZ(tile);
  uint z2 = GetTileZ(t->xy);
  if (z < z2) {
    if (HasBit(free_names, M(STR_SV_STNAME_VALLEY))) return STR_SV_STNAME_VALLEY;
  } else if (z > z2) {
    if (HasBit(free_names, M(STR_SV_STNAME_HEIGHTS))) return STR_SV_STNAME_HEIGHTS;
  }

  /* check direction compared to town */
  static const int8 _direction_and_table[] = {
    ~( (1 << M(STR_SV_STNAME_WEST))  | (1 << M(STR_SV_STNAME_EAST)) | (1 << M(STR_SV_STNAME_NORTH)) ),
    ~( (1 << M(STR_SV_STNAME_SOUTH)) | (1 << M(STR_SV_STNAME_WEST)) | (1 << M(STR_SV_STNAME_NORTH)) ),
    ~( (1 << M(STR_SV_STNAME_SOUTH)) | (1 << M(STR_SV_STNAME_EAST)) | (1 << M(STR_SV_STNAME_NORTH)) ),
    ~( (1 << M(STR_SV_STNAME_SOUTH)) | (1 << M(STR_SV_STNAME_WEST)) | (1 << M(STR_SV_STNAME_EAST)) ),
  };

  free_names &= _direction_and_table[
    (TileX(tile) < TileX(t->xy)) +
    (TileY(tile) < TileY(t->xy)) * 2];

  tmp = free_names & ((1 << 1) | (1 << 2) | (1 << 3) | (1 << 4) | (1 << 6) | (1 << 7) | (1 << 12) | (1 << 26) | (1 << 27) | (1 << 28) | (1 << 29) | (1 << 30));
  return (tmp == 0) ? STR_SV_STNAME_FALLBACK : (STR_SV_STNAME + FindFirstBit(tmp));
}
#undef M

static Station *GetClosestDeletedStation(TileIndex tile)
{
  uint threshold = 8;
  Station *best_station = NULL;
  Station *st;

  FOR_ALL_STATIONS(st) {
    if (st->facilities == 0 && st->owner == _current_company) {
      uint cur_dist = DistanceManhattan(tile, st->xy);

      if (cur_dist < threshold) {
        threshold = cur_dist;
        best_station = st;
      }
    }
  }

  return best_station;
}

static void UpdateStationVirtCoord(Station *st)
{
  Point pt = RemapCoords2(TileX(st->xy) * TILE_SIZE, TileY(st->xy) * TILE_SIZE);

  pt.y -= 32;
  if (st->facilities & FACIL_AIRPORT && st->airport_type == AT_OILRIG) pt.y -= 16;

  SetDParam(0, st->index);
  SetDParam(1, st->facilities);
  UpdateViewportSignPos(&st->sign, pt.x, pt.y, STR_305C_0);
}

void UpdateAllStationVirtCoord()
{
  Station *st;

  FOR_ALL_STATIONS(st) {
    UpdateStationVirtCoord(st);
  }
}

static void UpdateStationVirtCoordDirty(Station *st)
{
  st->MarkDirty();
  UpdateStationVirtCoord(st);
  st->MarkDirty();
}

static uint GetAcceptanceMask(const Station *st)
{
  uint mask = 0;

  for (CargoID i = 0; i < NUM_CARGO; i++) {
    if (HasBit(st->goods[i].acceptance_pickup, GoodsEntry::ACCEPTANCE)) mask |= 1 << i;
  }
  return mask;
}

static void ShowRejectOrAcceptNews(const Station *st, uint num_items, CargoID *cargo, StringID msg)
{
  for (uint i = 0; i < num_items; i++) {
    SetDParam(i + 1, GetCargo(cargo[i])->name);
  }

  SetDParam(0, st->index);
  AddNewsItem(msg, NS_ACCEPTANCE, st->xy, st->index);
}

void GetProductionAroundTiles(AcceptedCargo produced, TileIndex tile,
  int w, int h, int rad)
{
  memset(produced, 0, sizeof(AcceptedCargo)); // sizeof(AcceptedCargo) != sizeof(produced) (== sizeof(uint *))

  int x = TileX(tile);
  int y = TileY(tile);

  /* expand the region by rad tiles on each side
   * while making sure that we remain inside the board. */
  int x2 = min(x + w + rad, MapSizeX());
  int x1 = max(x - rad, 0);

  int y2 = min(y + h + rad, MapSizeY());
  int y1 = max(y - rad, 0);

  assert(x1 < x2);
  assert(y1 < y2);
  assert(w > 0);
  assert(h > 0);

  for (int yc = y1; yc != y2; yc++) {
    for (int xc = x1; xc != x2; xc++) {
      TileIndex tile = TileXY(xc, yc);

      if (!IsTileType(tile, MP_STATION)) {
        GetProducedCargoProc *gpc = _tile_type_procs[GetTileType(tile)]->get_produced_cargo_proc;
        if (gpc != NULL) {
          CargoID cargos[256]; // Required for CBID_HOUSE_PRODUCE_CARGO.
          memset(cargos, CT_INVALID, sizeof(cargos));

          gpc(tile, cargos);
          for (uint i = 0; i < lengthof(cargos); ++i) {
            if (cargos[i] != CT_INVALID) produced[cargos[i]]++;
          }
        }
      }
    }
  }
}

void GetAcceptanceAroundTiles(AcceptedCargo accepts, TileIndex tile,
  int w, int h, int rad)
{
  memset(accepts, 0, sizeof(AcceptedCargo)); // sizeof(AcceptedCargo) != sizeof(accepts) (== sizeof(uint *))

  int x = TileX(tile);
  int y = TileY(tile);

  /* expand the region by rad tiles on each side
   * while making sure that we remain inside the board. */
  int x2 = min(x + w + rad, MapSizeX());
  int y2 = min(y + h + rad, MapSizeY());
  int x1 = max(x - rad, 0);
  int y1 = max(y - rad, 0);

  assert(x1 < x2);
  assert(y1 < y2);
  assert(w > 0);
  assert(h > 0);

  for (int yc = y1; yc != y2; yc++) {
    for (int xc = x1; xc != x2; xc++) {
      TileIndex tile = TileXY(xc, yc);

      if (!IsTileType(tile, MP_STATION)) {
        AcceptedCargo ac;

        GetAcceptedCargo(tile, ac);
        for (uint i = 0; i < lengthof(ac); ++i) accepts[i] += ac[i];
      }
    }
  }
}

static inline void MergePoint(Rect *rect, TileIndex tile)
{
  int x = TileX(tile);
  int y = TileY(tile);

  if (rect->left   > x) rect->left   = x;
  if (rect->bottom > y) rect->bottom = y;
  if (rect->right  < x) rect->right  = x;
  if (rect->top    < y) rect->top    = y;
}

static void UpdateStationAcceptance(Station *st, bool show_msg)
{
  /* Don't update acceptance for a buoy */
  if (st->IsBuoy()) return;

  Rect rect;
  rect.left   = MapSizeX();
  rect.bottom = MapSizeY();
  rect.right  = 0;
  rect.top    = 0;

  /* old accepted goods types */
  uint old_acc = GetAcceptanceMask(st);

  /* Put all the tiles that span an area in the table. */
  if (st->train_tile != INVALID_TILE) {
    MergePoint(&rect, st->train_tile);
    MergePoint(&rect, st->train_tile + TileDiffXY(st->trainst_w - 1, st->trainst_h - 1));
  }

  if (st->airport_tile != INVALID_TILE) {
    const AirportFTAClass *afc = st->Airport();

    MergePoint(&rect, st->airport_tile);
    MergePoint(&rect, st->airport_tile + TileDiffXY(afc->size_x - 1, afc->size_y - 1));
  }

  if (st->dock_tile != INVALID_TILE) {
    MergePoint(&rect, st->dock_tile);
    if (IsDockTile(st->dock_tile)) {
      MergePoint(&rect, st->dock_tile + TileOffsByDiagDir(GetDockDirection(st->dock_tile)));
    } // else OilRig
  }

  for (const RoadStop *rs = st->bus_stops; rs != NULL; rs = rs->next) {
    MergePoint(&rect, rs->xy);
  }

  for (const RoadStop *rs = st->truck_stops; rs != NULL; rs = rs->next) {
    MergePoint(&rect, rs->xy);
  }

  /* And retrieve the acceptance. */
  AcceptedCargo accepts;
  assert((rect.right >= rect.left) == !st->rect.IsEmpty());
  if (rect.right >= rect.left) {
    assert(rect.left == st->rect.left);
    assert(rect.top == st->rect.bottom);
    assert(rect.right == st->rect.right);
    assert(rect.bottom == st->rect.top);
    GetAcceptanceAroundTiles(
      accepts,
      TileXY(rect.left, rect.bottom),
      rect.right - rect.left   + 1,
      rect.top   - rect.bottom + 1,
      st->GetCatchmentRadius()
    );
  } else {
    memset(accepts, 0, sizeof(accepts));
  }

  /* Adjust in case our station only accepts fewer kinds of goods */
  for (CargoID i = 0; i < NUM_CARGO; i++) {
    uint amt = min(accepts[i], 15);

    /* Make sure the station can accept the goods type. */
    bool is_passengers = IsCargoInClass(i, CC_PASSENGERS);
    if ((!is_passengers && !(st->facilities & (byte)~FACIL_BUS_STOP)) ||
        (is_passengers && !(st->facilities & (byte)~FACIL_TRUCK_STOP))) {
      amt = 0;
    }

    SB(st->goods[i].acceptance_pickup, GoodsEntry::ACCEPTANCE, 1, amt >= 8);
  }

  /* Only show a message in case the acceptance was actually changed. */
  uint new_acc = GetAcceptanceMask(st);
  if (old_acc == new_acc) return;

  /* show a message to report that the acceptance was changed? */
  if (show_msg && st->owner == _local_company && st->facilities) {
    /* List of accept and reject strings for different number of
     * cargo types */
    static const StringID accept_msg[] = {
      STR_3040_NOW_ACCEPTS,
      STR_3041_NOW_ACCEPTS_AND,
    };
    static const StringID reject_msg[] = {
      STR_303E_NO_LONGER_ACCEPTS,
      STR_303F_NO_LONGER_ACCEPTS_OR,
    };

    /* Array of accepted and rejected cargo types */
    CargoID accepts[2] = { CT_INVALID, CT_INVALID };
    CargoID rejects[2] = { CT_INVALID, CT_INVALID };
    uint num_acc = 0;
    uint num_rej = 0;

    /* Test each cargo type to see if its acceptange has changed */
    for (CargoID i = 0; i < NUM_CARGO; i++) {
      if (HasBit(new_acc, i)) {
        if (!HasBit(old_acc, i) && num_acc < lengthof(accepts)) {
          /* New cargo is accepted */
          accepts[num_acc++] = i;
        }
      } else {
        if (HasBit(old_acc, i) && num_rej < lengthof(rejects)) {
          /* Old cargo is no longer accepted */
          rejects[num_rej++] = i;
        }
      }
    }

    /* Show news message if there are any changes */
    if (num_acc > 0) ShowRejectOrAcceptNews(st, num_acc, accepts, accept_msg[num_acc - 1]);
    if (num_rej > 0) ShowRejectOrAcceptNews(st, num_rej, rejects, reject_msg[num_rej - 1]);
  }

  /* redraw the station view since acceptance changed */
  InvalidateWindowWidget(WC_STATION_VIEW, st->index, SVW_ACCEPTLIST);
}

static void UpdateStationSignCoord(Station *st)
{
  const StationRect *r = &st->rect;

  if (r->IsEmpty()) return; /* no tiles belong to this station */

  /* clamp sign coord to be inside the station rect */
  st->xy = TileXY(ClampU(TileX(st->xy), r->left, r->right), ClampU(TileY(st->xy), r->top, r->bottom));
  UpdateStationVirtCoordDirty(st);
}

static void DeleteStationIfEmpty(Station *st)
{
  if (st->facilities == 0) {
    st->delete_ctr = 0;
    InvalidateWindowData(WC_STATION_LIST, st->owner, 0);
  }
  /* station remains but it probably lost some parts - station sign should stay in the station boundaries */
  UpdateStationSignCoord(st);
}

static CommandCost ClearTile_Station(TileIndex tile, byte flags);

CommandCost CheckFlatLandBelow(TileIndex tile, uint w, uint h, uint flags, uint invalid_dirs, StationID *station, bool check_clear = true)
{
  CommandCost cost(EXPENSES_CONSTRUCTION);
  int allowed_z = -1;

  BEGIN_TILE_LOOP(tile_cur, w, h, tile) {
    if (MayHaveBridgeAbove(tile_cur) && IsBridgeAbove(tile_cur)) {
      return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);
    }

    if (!EnsureNoVehicleOnGround(tile_cur)) return CMD_ERROR;

    uint z;
    Slope tileh = GetTileSlope(tile_cur, &z);

    /* Prohibit building if
     *   1) The tile is "steep" (i.e. stretches two height levels)
     * -OR-
     *   2) The tile is non-flat if
     *     a) the company building is an "old-school" AI
     *   -OR-
     *     b) the build_on_slopes switch is disabled
     */
    if (IsSteepSlope(tileh) ||
        ((_is_old_ai_company || !_settings_game.construction.build_on_slopes) && tileh != SLOPE_FLAT)) {
      return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);
    }

    int flat_z = z;
    if (tileh != SLOPE_FLAT) {
      /* need to check so the entrance to the station is not pointing at a slope.
       * This must be valid for all station tiles, as the user can remove single station tiles. */
      if ((HasBit(invalid_dirs, DIAGDIR_NE) && !(tileh & SLOPE_NE)) ||
          (HasBit(invalid_dirs, DIAGDIR_SE) && !(tileh & SLOPE_SE)) ||
          (HasBit(invalid_dirs, DIAGDIR_SW) && !(tileh & SLOPE_SW)) ||
          (HasBit(invalid_dirs, DIAGDIR_NW) && !(tileh & SLOPE_NW))) {
        return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);
      }
      cost.AddCost(_price.terraform);
      flat_z += TILE_HEIGHT;
    }

    /* get corresponding flat level and make sure that all parts of the station have the same level. */
    if (allowed_z == -1) {
      /* first tile */
      allowed_z = flat_z;
    } else if (allowed_z != flat_z) {
      return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);
    }

    /* if station is set, then we have special handling to allow building on top of already existing stations.
     * so station points to INVALID_STATION if we can build on any station.
     * Or it points to a station if we're only allowed to build on exactly that station. */
    if (station != NULL && IsTileType(tile_cur, MP_STATION)) {
      if (!IsRailwayStation(tile_cur)) {
        return ClearTile_Station(tile_cur, DC_AUTO); // get error message
      } else {
        StationID st = GetStationIndex(tile_cur);
        if (*station == INVALID_STATION) {
          *station = st;
        } else if (*station != st) {
          return_cmd_error(STR_3006_ADJOINS_MORE_THAN_ONE_EXISTING);
        }
      }
    } else if (check_clear) {
      CommandCost ret = DoCommand(tile_cur, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
      if (CmdFailed(ret)) return ret;
      cost.AddCost(ret);
    }
  } END_TILE_LOOP(tile_cur, w, h, tile)

  return cost;
}

static bool CanExpandRailroadStation(const Station *st, uint *fin, Axis axis)
{
  uint curw = st->trainst_w;
  uint curh = st->trainst_h;
  TileIndex tile = fin[0];
  uint w = fin[1];
  uint h = fin[2];

  if (_settings_game.station.nonuniform_stations) {
    /* determine new size of train station region.. */
    int x = min(TileX(st->train_tile), TileX(tile));
    int y = min(TileY(st->train_tile), TileY(tile));
    curw = max(TileX(st->train_tile) + curw, TileX(tile) + w) - x;
    curh = max(TileY(st->train_tile) + curh, TileY(tile) + h) - y;
    tile = TileXY(x, y);
  } else {
    /* do not allow modifying non-uniform stations,
     * the uniform-stations code wouldn't handle it well */
    BEGIN_TILE_LOOP(t, st->trainst_w, st->trainst_h, st->train_tile)
      if (!st->TileBelongsToRailStation(t)) { // there may be adjoined station
        _error_message = STR_NONUNIFORM_STATIONS_DISALLOWED;
        return false;
      }
    END_TILE_LOOP(t, st->trainst_w, st->trainst_h, st->train_tile)

    /* check so the orientation is the same */
    if (GetRailStationAxis(st->train_tile) != axis) {
      _error_message = STR_NONUNIFORM_STATIONS_DISALLOWED;
      return false;
    }

    /* check if the new station adjoins the old station in either direction */
    if (curw == w && st->train_tile == tile + TileDiffXY(0, h)) {
      /* above */
      curh += h;
    } else if (curw == w && st->train_tile == tile - TileDiffXY(0, curh)) {
      /* below */
      tile -= TileDiffXY(0, curh);
      curh += h;
    } else if (curh == h && st->train_tile == tile + TileDiffXY(w, 0)) {
      /* to the left */
      curw += w;
    } else if (curh == h && st->train_tile == tile - TileDiffXY(curw, 0)) {
      /* to the right */
      tile -= TileDiffXY(curw, 0);
      curw += w;
    } else {
      _error_message = STR_NONUNIFORM_STATIONS_DISALLOWED;
      return false;
    }
  }
  /* make sure the final size is not too big. */
  if (curw > _settings_game.station.station_spread || curh > _settings_game.station.station_spread) {
    _error_message = STR_306C_STATION_TOO_SPREAD_OUT;
    return false;
  }

  /* now tile contains the new value for st->train_tile
   * curw, curh contain the new value for width and height */
  fin[0] = tile;
  fin[1] = curw;
  fin[2] = curh;
  return true;
}

static inline byte *CreateSingle(byte *layout, int n)
{
  int i = n;
  do *layout++ = 0; while (--i);
  layout[((n - 1) >> 1) - n] = 2;
  return layout;
}

static inline byte *CreateMulti(byte *layout, int n, byte b)
{
  int i = n;
  do *layout++ = b; while (--i);
  if (n > 4) {
    layout[0 - n] = 0;
    layout[n - 1 - n] = 0;
  }
  return layout;
}

static void GetStationLayout(byte *layout, int numtracks, int plat_len, const StationSpec *statspec)
{
  if (statspec != NULL && statspec->lengths >= plat_len &&
      statspec->platforms[plat_len - 1] >= numtracks &&
      statspec->layouts[plat_len - 1][numtracks - 1]) {
    /* Custom layout defined, follow it. */
    memcpy(layout, statspec->layouts[plat_len - 1][numtracks - 1],
      plat_len * numtracks);
    return;
  }

  if (plat_len == 1) {
    CreateSingle(layout, numtracks);
  } else {
    if (numtracks & 1) layout = CreateSingle(layout, plat_len);
    numtracks >>= 1;

    while (--numtracks >= 0) {
      layout = CreateMulti(layout, plat_len, 4);
      layout = CreateMulti(layout, plat_len, 6);
    }
  }
}

CommandCost CmdBuildRailroadStation(TileIndex tile_org, uint32 flags, uint32 p1, uint32 p2, const char *text)
{
  /* Does the authority allow this? */
  if (!(flags & DC_NO_TOWN_RATING) && !CheckIfAuthorityAllows(tile_org)) return CMD_ERROR;
  if (!ValParamRailtype((RailType)(p1 & 0xF))) return CMD_ERROR;

  /* unpack parameters */
  Axis axis = Extract<Axis, 4>(p1);
  uint numtracks = GB(p1,  8, 8);
  uint plat_len  = GB(p1, 16, 8);

  int w_org, h_org;
  if (axis == AXIS_X) {
    w_org = plat_len;
    h_org = numtracks;
  } else {
    h_org = plat_len;
    w_org = numtracks;
  }

  StationID station_to_join = GB(p2, 16, 16);
  bool distant_join = (station_to_join != INVALID_STATION);

  if (distant_join && (!_settings_game.station.distant_join_stations || !IsValidStationID(station_to_join))) return CMD_ERROR;

  if (h_org > _settings_game.station.station_spread || w_org > _settings_game.station.station_spread) return CMD_ERROR;

  /* these values are those that will be stored in train_tile and station_platforms */
  uint finalvalues[3];
  finalvalues[0] = tile_org;
  finalvalues[1] = w_org;
  finalvalues[2] = h_org;

  /* Make sure the area below consists of clear tiles. (OR tiles belonging to a certain rail station) */
  StationID est = INVALID_STATION;
  /* If DC_EXEC is in flag, do not want to pass it to CheckFlatLandBelow, because of a nice bug
   * for detail info, see:
   * https://sourceforge.net/tracker/index.php?func=detail&aid=1029064&group_id=103924&atid=636365 */
  CommandCost ret = CheckFlatLandBelow(tile_org, w_org, h_org, flags & ~DC