landscape.cpp

Go to the documentation of this file.

/*
 * 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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */


 
#include "stdafx.h"
#include "heightmap.h"
#include "clear_map.h"
#include "spritecache.h"
#include "station_map.h"
#include "viewport_func.h"
#include "command_func.h"
#include "landscape.h"
#include "void_map.h"
#include "tgp.h"
#include "genworld.h"
#include "fios.h"
#include "error_func.h"
#include "timer/timer_game_calendar.h"
#include "timer/timer_game_tick.h"
#include "water.h"
#include "effectvehicle_func.h"
#include "landscape_type.h"
#include "animated_tile_func.h"
#include "core/random_func.hpp"
#include "object_base.h"
#include "tree_cmd.h"
#include "company_func.h"
#include "company_gui.h"
#include "saveload/saveload_func.h"
#include "framerate_type.h"
#include "landscape_cmd.h"
#include "terraform_cmd.h"
#include "station_func.h"
#include "pathfinder/water_regions.h"
#include "pathfinder/yapf/yapf_river_builder.h"
 
#include "table/strings.h"
#include "table/sprites.h"
 
#include <unordered_set>
 
#include "safeguards.h"
 
extern const TileTypeProcs
  _tile_type_clear_procs,
  _tile_type_rail_procs,
  _tile_type_road_procs,
  _tile_type_town_procs,
  _tile_type_trees_procs,
  _tile_type_station_procs,
  _tile_type_water_procs,
  _tile_type_void_procs,
  _tile_type_industry_procs,
  _tile_type_tunnelbridge_procs,
  _tile_type_object_procs;

const EnumIndexArray<const TileTypeProcs *, TileType, TileType::MaxSize> _tile_type_procs = {
  &_tile_type_clear_procs, // Callback functions for TileType::Clear tiles
  &_tile_type_rail_procs, // Callback functions for TileType::Railway tiles
  &_tile_type_road_procs, // Callback functions for TileType::Road tiles
  &_tile_type_town_procs, // Callback functions for TileType::House tiles
  &_tile_type_trees_procs, // Callback functions for TileType::Trees tiles
  &_tile_type_station_procs, // Callback functions for TileType::Station tiles
  &_tile_type_water_procs, // Callback functions for TileType::Water tiles
  &_tile_type_void_procs, // Callback functions for TileType::Void tiles
  &_tile_type_industry_procs, // Callback functions for TileType::Industry tiles
  &_tile_type_tunnelbridge_procs, // Callback functions for TileType::TunnelBridge tiles
  &_tile_type_object_procs, // Callback functions for TileType::Object tiles
  /* Explicitly initialize invalid elements to make sure that they are nullptr. */
  nullptr,
  nullptr,
  nullptr,
  nullptr,
  nullptr,
};

extern const SlopeIndexArray<uint8_t> _slope_to_sprite_offset = {
  0, 1, 2, 3, 4, 5, 6,  7, 8, 9, 10, 11, 12, 13, 14, 0,
  0, 0, 0, 0, 0, 0, 0, 16, 0, 0,  0, 17,  0, 15, 18,
};
 
static const uint TILE_UPDATE_FREQUENCY_LOG = 8;  
static const uint TILE_UPDATE_FREQUENCY = 1 << TILE_UPDATE_FREQUENCY_LOG;  

static std::unique_ptr<SnowLine> _snow_line;

Point InverseRemapCoords2(int x, int y, bool clamp_to_map, bool *clamped)
{
  if (clamped != nullptr) *clamped = false; // Not clamping yet.
 
  /* Initial x/y world coordinate is like if the landscape
   * was completely flat on height 0. */
  Point pt = InverseRemapCoords(x, y);
 
  const uint min_coord = _settings_game.construction.freeform_edges ? TILE_SIZE : 0;
  const uint max_x = Map::MaxX() * TILE_SIZE - 1;
  const uint max_y = Map::MaxY() * TILE_SIZE - 1;
 
  if (clamp_to_map) {
    /* Bring the coordinates near to a valid range. At the top we allow a number
     * of extra tiles. This is mostly due to the tiles on the north side of
     * the map possibly being drawn higher due to the extra height levels. */
    int extra_tiles = CeilDiv(_settings_game.construction.map_height_limit * TILE_HEIGHT, TILE_PIXELS);
    Point old_pt = pt;
    pt.x = Clamp(pt.x, -extra_tiles * TILE_SIZE, max_x);
    pt.y = Clamp(pt.y, -extra_tiles * TILE_SIZE, max_y);
    if (clamped != nullptr) *clamped = (pt.x != old_pt.x) || (pt.y != old_pt.y);
  }
 
  /* Now find the Z-world coordinate by fix point iteration.
   * This is a bit tricky because the tile height is non-continuous at foundations.
   * The clicked point should be approached from the back, otherwise there are regions that are not clickable.
   * (FOUNDATION_HALFTILE_LOWER on SLOPE_STEEP_S hides north halftile completely)
   * So give it a z-malus of 4 in the first iterations. */
  int z = 0;
  if (clamp_to_map) {
    for (int i = 0; i < 5; i++) z = GetSlopePixelZ(Clamp(pt.x + std::max(z, 4) - 4, min_coord, max_x), Clamp(pt.y + std::max(z, 4) - 4, min_coord, max_y)) / 2;
    for (int m = 3; m > 0; m--) z = GetSlopePixelZ(Clamp(pt.x + std::max(z, m) - m, min_coord, max_x), Clamp(pt.y + std::max(z, m) - m, min_coord, max_y)) / 2;
    for (int i = 0; i < 5; i++) z = GetSlopePixelZ(Clamp(pt.x + z,             min_coord, max_x), Clamp(pt.y + z,             min_coord, max_y)) / 2;
  } else {
    for (int i = 0; i < 5; i++) z = GetSlopePixelZOutsideMap(pt.x + std::max(z, 4) - 4, pt.y + std::max(z, 4) - 4) / 2;
    for (int m = 3; m > 0; m--) z = GetSlopePixelZOutsideMap(pt.x + std::max(z, m) - m, pt.y + std::max(z, m) - m) / 2;
    for (int i = 0; i < 5; i++) z = GetSlopePixelZOutsideMap(pt.x + z,             pt.y + z            ) / 2;
  }
 
  pt.x += z;
  pt.y += z;
  if (clamp_to_map) {
    Point old_pt = pt;
    pt.x = Clamp(pt.x, min_coord, max_x);
    pt.y = Clamp(pt.y, min_coord, max_y);
    if (clamped != nullptr) *clamped = *clamped || (pt.x != old_pt.x) || (pt.y != old_pt.y);
  }
 
  return pt;
}

uint ApplyFoundationToSlope(Foundation f, Slope &s)
{
  if (!IsFoundation(f)) return 0;
 
  if (IsLeveledFoundation(f)) {
    uint dz = 1 + (IsSteepSlope(s) ? 1 : 0);
    s = SLOPE_FLAT;
    return dz;
  }
 
  if (f != Foundation::SteepBoth && IsNonContinuousFoundation(f)) {
    s = HalftileSlope(s, GetHalftileFoundationCorner(f));
    return 0;
  }
 
  if (IsSpecialRailFoundation(f)) {
    s = SlopeWithThreeCornersRaised(OppositeCorner(GetRailFoundationCorner(f)));
    return 0;
  }
 
  uint dz = IsSteepSlope(s) ? 1 : 0;
  Corner highest_corner = GetHighestSlopeCorner(s);
 
  switch (f) {
    case Foundation::InclinedX:
      s = (((highest_corner == Corner::W) || (highest_corner == Corner::S)) ? SLOPE_SW : SLOPE_NE);
      break;
 
    case Foundation::InclinedY:
      s = (((highest_corner == Corner::S) || (highest_corner == Corner::E)) ? SLOPE_SE : SLOPE_NW);
      break;
 
    case Foundation::SteepLower:
      s = SlopeWithOneCornerRaised(highest_corner);
      break;
 
    case Foundation::SteepBoth:
      s = HalftileSlope(SlopeWithOneCornerRaised(highest_corner), highest_corner);
      break;
 
    default: NOT_REACHED();
  }
  return dz;
}
 

uint GetPartialPixelZ(int x, int y, Slope corners)
{
  if (IsHalftileSlope(corners)) {
    /* A foundation is placed on half the tile at a specific corner. This means that,
     * depending on the corner, that one half of the tile is at the maximum height. */
    switch (GetHalftileSlopeCorner(corners)) {
      case Corner::W:
        if (x > y) return GetSlopeMaxPixelZ(corners);
        break;
 
      case Corner::S:
        if (x + y >= (int)TILE_SIZE) return GetSlopeMaxPixelZ(corners);
        break;
 
      case Corner::E:
        if (x <= y) return GetSlopeMaxPixelZ(corners);
        break;
 
      case Corner::N:
        if (x + y < (int)TILE_SIZE) return GetSlopeMaxPixelZ(corners);
        break;
 
      default: NOT_REACHED();
    }
  }
 
  switch (RemoveHalftileSlope(corners)) {
    case SLOPE_FLAT: return 0;
 
    /* One corner is up.*/
    case SLOPE_N: return x + y <= (int)TILE_SIZE ? (TILE_SIZE - x - y)     >> 1 : 0;
    case SLOPE_E: return y >= x                  ? (1 + y - x)             >> 1 : 0;
    case SLOPE_S: return x + y >= (int)TILE_SIZE ? (1 + x + y - TILE_SIZE) >> 1 : 0;
    case SLOPE_W: return x >= y                  ? (x - y)                 >> 1 : 0;
 
    /* Two corners next to each other are up. */
    case SLOPE_NE: return (TILE_SIZE - x) >> 1;
    case SLOPE_SE: return (y + 1) >> 1;
    case SLOPE_SW: return (x + 1) >> 1;
    case SLOPE_NW: return (TILE_SIZE - y) >> 1;
 
    /* Three corners are up on the same level. */
    case SLOPE_ENW: return x + y >= (int)TILE_SIZE ? TILE_HEIGHT - ((1 + x + y - TILE_SIZE) >> 1) : TILE_HEIGHT;
    case SLOPE_SEN: return y < x                   ? TILE_HEIGHT - ((x - y)                 >> 1) : TILE_HEIGHT;
    case SLOPE_WSE: return x + y <= (int)TILE_SIZE ? TILE_HEIGHT - ((TILE_SIZE - x - y)     >> 1) : TILE_HEIGHT;
    case SLOPE_NWS: return x < y                   ? TILE_HEIGHT - ((1 + y - x)             >> 1) : TILE_HEIGHT;
 
    /* Two corners at opposite sides are up. */
    case SLOPE_NS: return x + y < (int)TILE_SIZE ? (TILE_SIZE - x - y) >> 1 : (1 + x + y - TILE_SIZE) >> 1;
    case SLOPE_EW: return x >= y ? (x - y) >> 1 : (1 + y - x) >> 1;
 
    /* Very special cases. */
    case SLOPE_ELEVATED: return TILE_HEIGHT;
 
    /* Steep slopes. The top is at 2 * TILE_HEIGHT. */
    case SLOPE_STEEP_N: return (TILE_SIZE - x + TILE_SIZE - y) >> 1;
    case SLOPE_STEEP_E: return (TILE_SIZE + 1 + y - x) >> 1;
    case SLOPE_STEEP_S: return (1 + x + y) >> 1;
    case SLOPE_STEEP_W: return (TILE_SIZE + x - y) >> 1;
 
    default: NOT_REACHED();
  }
}

int GetSlopePixelZ(int x, int y, bool ground_vehicle)
{
  TileIndex tile = TileVirtXY(x, y);
 
  return _tile_type_procs[GetTileType(tile)]->get_slope_pixel_z_proc(tile, x, y, ground_vehicle);
}

int GetSlopePixelZOutsideMap(int x, int y)
{
  if (IsInsideBS(x, 0, Map::SizeX() * TILE_SIZE) && IsInsideBS(y, 0, Map::SizeY() * TILE_SIZE)) {
    return GetSlopePixelZ(x, y, false);
  } else {
    return _tile_type_procs[TileType::Void]->get_slope_pixel_z_proc(INVALID_TILE, x, y, false);
  }
}

int GetSlopeZInCorner(Slope tileh, Corner corner)
{
  assert(!IsHalftileSlope(tileh));
  return ((tileh & SlopeWithOneCornerRaised(corner)) != 0 ? 1 : 0) + (tileh == SteepSlope(corner) ? 1 : 0);
}

std::tuple<int, int> GetSlopePixelZOnEdge(Slope tileh, DiagDirection edge, int z)
{
  static const DiagDirectionIndexArray<std::array<Slope, 4>> corners{{{
    /*    corner     |          steep slope
     *  z1      z2   |       z1             z2        */
    {SLOPE_E, SLOPE_N, SLOPE_STEEP_E, SLOPE_STEEP_N}, // DiagDirection::NE, z1 = E, z2 = N
    {SLOPE_S, SLOPE_E, SLOPE_STEEP_S, SLOPE_STEEP_E}, // DiagDirection::SE, z1 = S, z2 = E
    {SLOPE_S, SLOPE_W, SLOPE_STEEP_S, SLOPE_STEEP_W}, // DiagDirection::SW, z1 = S, z2 = W
    {SLOPE_W, SLOPE_N, SLOPE_STEEP_W, SLOPE_STEEP_N}, // DiagDirection::NW, z1 = W, z2 = N
  }}};
 
  int z1 = z;
  int z2 = z;
 
  Slope halftile_test = IsHalftileSlope(tileh) ? SlopeWithOneCornerRaised(GetHalftileSlopeCorner(tileh)) : SLOPE_FLAT;
  if (halftile_test == corners[edge][0]) z2 += TILE_HEIGHT; // The slope is non-continuous in z2. z2 is on the upper side.
  if (halftile_test == corners[edge][1]) z1 += TILE_HEIGHT; // The slope is non-continuous in z1. z1 is on the upper side.
 
  if ((tileh & corners[edge][0]) != 0) z1 += TILE_HEIGHT; // z1 is raised
  if ((tileh & corners[edge][1]) != 0) z2 += TILE_HEIGHT; // z2 is raised
  if (RemoveHalftileSlope(tileh) == corners[edge][2]) z1 += TILE_HEIGHT; // z1 is highest corner of a steep slope
  if (RemoveHalftileSlope(tileh) == corners[edge][3]) z2 += TILE_HEIGHT; // z2 is highest corner of a steep slope
 
  return {z1, z2};
}

std::tuple<Slope, int> GetFoundationSlope(TileIndex tile)
{
  auto [tileh, z] = GetTileSlopeZ(tile);
  Foundation f = _tile_type_procs[GetTileType(tile)]->get_foundation_proc(tile, tileh);
  z += ApplyFoundationToSlope(f, tileh);
  return {tileh, z};
}

static bool HasFoundation(TileIndex tile, Slope slope_here, uint z_here, DiagDirection edge)
{
  auto [z1_here, z2_here] = GetSlopePixelZOnEdge(slope_here, edge, z_here);
 
  auto [slope, z] = GetFoundationPixelSlope(TileAddByDiagDir(tile, edge));
  auto [z1, z2] = GetSlopePixelZOnEdge(slope, ChangeDiagDir(edge, DiagDirDiff::Reverse), z);
 
  return (z1_here > z1) || (z2_here > z2);
}

uint GetFoundationSpriteBlock(TileIndex tile)
{
  auto [slope, z] = GetFoundationPixelSlope(tile);
  uint block = 0;
  if (!HasFoundation(tile, slope, z, DiagDirection::NW)) block += 1;
  if (!HasFoundation(tile, slope, z, DiagDirection::NE)) block += 2;
  return block;
}

void DrawFoundation(TileInfo *ti, Foundation f)
{
  if (!IsFoundation(f)) return;
 
  /* Two part foundations must be drawn separately */
  assert(f != Foundation::SteepBoth);
 
  uint sprite_block = GetFoundationSpriteBlock(ti->tile);
 
  /* Use the original slope sprites if NW and NE borders should be visible */
  SpriteID leveled_base = (sprite_block == 0 ? (int)SPR_FOUNDATION_BASE : (SPR_SLOPES_VIRTUAL_BASE + sprite_block * TRKFOUND_BLOCK_SIZE));
  SpriteID inclined_base = SPR_SLOPES_VIRTUAL_BASE + SLOPES_INCLINED_OFFSET + sprite_block * TRKFOUND_BLOCK_SIZE;
  SpriteID halftile_base = SPR_HALFTILE_FOUNDATION_BASE + sprite_block * HALFTILE_BLOCK_SIZE;
 
  if (IsSteepSlope(ti->tileh)) {
    if (!IsNonContinuousFoundation(f)) {
      /* Lower part of foundation */
      static constexpr SpriteBounds bounds{{}, {TILE_SIZE, TILE_SIZE, TILE_HEIGHT - 1}, {}};
      AddSortableSpriteToDraw(leveled_base + RemoveSteepSlope(ti->tileh), PAL_NONE, *ti, bounds);
    }
 
    Corner highest_corner = GetHighestSlopeCorner(ti->tileh);
    ti->z += ApplyPixelFoundationToSlope(f, ti->tileh);
 
    if (IsInclinedFoundation(f)) {
      /* inclined foundation */
      uint8_t inclined = to_underlying(highest_corner) * 2 + (f == Foundation::InclinedY ? 1 : 0);
 
      SpriteBounds bounds{{}, {1, 1, TILE_HEIGHT}, {}};
      if (f == Foundation::InclinedX) bounds.extent.x = TILE_SIZE;
      if (f == Foundation::InclinedY) bounds.extent.y = TILE_SIZE;
      AddSortableSpriteToDraw(inclined_base + inclined, PAL_NONE, *ti, bounds);
      OffsetGroundSprite(0, 0);
    } else if (IsLeveledFoundation(f)) {
      static constexpr SpriteBounds bounds{{0, 0, -(int)TILE_HEIGHT}, {TILE_SIZE, TILE_SIZE, TILE_HEIGHT - 1}, {}};
      AddSortableSpriteToDraw(leveled_base + SlopeWithOneCornerRaised(highest_corner), PAL_NONE, *ti, bounds);
      OffsetGroundSprite(0, -(int)TILE_HEIGHT);
    } else if (f == Foundation::SteepLower) {
      /* one corner raised */
      OffsetGroundSprite(0, -(int)TILE_HEIGHT);
    } else {
      /* halftile foundation */
      int8_t x_bb = (((highest_corner == Corner::W) || (highest_corner == Corner::S)) ? TILE_SIZE / 2 : 0);
      int8_t y_bb = (((highest_corner == Corner::S) || (highest_corner == Corner::E)) ? TILE_SIZE / 2 : 0);
 
      SpriteBounds bounds{{x_bb, y_bb, TILE_HEIGHT}, {TILE_SIZE / 2, TILE_SIZE / 2, TILE_HEIGHT - 1}, {}};
      AddSortableSpriteToDraw(halftile_base + to_underlying(highest_corner), PAL_NONE, *ti, bounds);
      /* Reposition ground sprite back to original position after bounding box change above. This is similar to
       * RemapCoords() but without zoom scaling. */
      Point pt = {(y_bb - x_bb) * 2, y_bb + x_bb};
      OffsetGroundSprite(-pt.x, -pt.y);
    }
  } else {
    if (IsLeveledFoundation(f)) {
      /* leveled foundation */
      static constexpr SpriteBounds bounds{{}, {TILE_SIZE, TILE_SIZE, TILE_HEIGHT - 1}, {}};
      AddSortableSpriteToDraw(leveled_base + ti->tileh, PAL_NONE, *ti, bounds);
      OffsetGroundSprite(0, -(int)TILE_HEIGHT);
    } else if (IsNonContinuousFoundation(f)) {
      /* halftile foundation */
      Corner halftile_corner = GetHalftileFoundationCorner(f);
      int8_t x_bb = (((halftile_corner == Corner::W) || (halftile_corner == Corner::S)) ? TILE_SIZE / 2 : 0);
      int8_t y_bb = (((halftile_corner == Corner::S) || (halftile_corner == Corner::E)) ? TILE_SIZE / 2 : 0);
 
      SpriteBounds bounds{{x_bb, y_bb, 0}, {TILE_SIZE / 2, TILE_SIZE / 2, TILE_HEIGHT - 1}, {}};
      AddSortableSpriteToDraw(halftile_base + to_underlying(halftile_corner), PAL_NONE, *ti, bounds);
      /* Reposition ground sprite back to original position after bounding box change above. This is similar to
       * RemapCoords() but without zoom scaling. */
      Point pt = {(y_bb - x_bb) * 2, y_bb + x_bb};
      OffsetGroundSprite(-pt.x, -pt.y);
    } else if (IsSpecialRailFoundation(f)) {
      /* anti-zig-zag foundation */
      SpriteID spr;
      if (ti->tileh == SLOPE_NS || ti->tileh == SLOPE_EW) {
        /* half of leveled foundation under track corner */
        spr = leveled_base + SlopeWithThreeCornersRaised(GetRailFoundationCorner(f));
      } else {
        /* tile-slope = sloped along X/Y, foundation-slope = three corners raised */
        spr = inclined_base + 2 * to_underlying(GetRailFoundationCorner(f)) + ((ti->tileh == SLOPE_SW || ti->tileh == SLOPE_NE) ? 1 : 0);
      }
      static constexpr SpriteBounds bounds{{}, {TILE_SIZE, TILE_SIZE, TILE_HEIGHT - 1}, {}};
      AddSortableSpriteToDraw(spr, PAL_NONE, *ti, bounds);
      OffsetGroundSprite(0, 0);
    } else {
      /* inclined foundation */
      uint8_t inclined = to_underlying(GetHighestSlopeCorner(ti->tileh)) * 2 + (f == Foundation::InclinedY ? 1 : 0);
 
      SpriteBounds bounds{{}, {1, 1, TILE_HEIGHT}, {}};
      if (f == Foundation::InclinedX) bounds.extent.x = TILE_SIZE;
      if (f == Foundation::InclinedY) bounds.extent.y = TILE_SIZE;
      AddSortableSpriteToDraw(inclined_base + inclined, PAL_NONE, *ti, bounds);
      OffsetGroundSprite(0, 0);
    }
    ti->z += ApplyPixelFoundationToSlope(f, ti->tileh);
  }
}
 
void DoClearSquare(TileIndex tile)
{
  /* If the tile can have animation and we clear it, delete it from the animated tile list. */
  if (MayAnimateTile(tile)) DeleteAnimatedTile(tile, true);
 
  bool remove = IsDockingTile(tile);
  MakeClear(tile, ClearGround::Grass, _generating_world ? 3 : 0);
  MarkTileDirtyByTile(tile);
  if (remove) RemoveDockingTile(tile);
 
  ClearNeighbourNonFloodingStates(tile);
  InvalidateWaterRegion(tile);
}

TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, RoadTramType sub_mode, DiagDirection side)
{
  return _tile_type_procs[GetTileType(tile)]->get_tile_track_status_proc(tile, mode, sub_mode, side);
}

void ChangeTileOwner(TileIndex tile, Owner old_owner, Owner new_owner)
{
  _tile_type_procs[GetTileType(tile)]->change_tile_owner_proc(tile, old_owner, new_owner);
}
 
void GetTileDesc(TileIndex tile, TileDesc &td)
{
  _tile_type_procs[GetTileType(tile)]->get_tile_desc_proc(tile, td);
}

bool IsSnowLineSet()
{
  return _snow_line != nullptr;
}

void SetSnowLine(std::unique_ptr<SnowLine> &&snow_line)
{
  _snow_line = std::move(snow_line);
}

uint8_t GetSnowLine()
{
  if (_snow_line == nullptr) return _settings_game.game_creation.snow_line_height;
 
  TimerGameCalendar::YearMonthDay ymd = TimerGameCalendar::ConvertDateToYMD(TimerGameCalendar::date);
  return _snow_line->table[ymd.month][ymd.day];
}

uint8_t HighestSnowLine()
{
  return _snow_line == nullptr ? _settings_game.game_creation.snow_line_height : _snow_line->highest_value;
}

uint8_t LowestSnowLine()
{
  return _snow_line == nullptr ? _settings_game.game_creation.snow_line_height : _snow_line->lowest_value;
}

void ClearSnowLine()
{
  _snow_line = nullptr;
}

bool IsMapSurroundedByWater()
{
  auto check_tile = [](uint x, uint y) -> bool {
    auto [slope, h] = GetTilePixelSlopeOutsideMap(x, y);
    return ((slope == SLOPE_FLAT) && (h == 0));
  };
 
  /* Check the map corners. */
  if (!check_tile(0, 0)) return false;
  if (!check_tile(0, Map::SizeY())) return false;
  if (!check_tile(Map::SizeX(), 0)) return false;
  if (!check_tile(Map::SizeX(), Map::SizeY())) return false;
 
  /* Check the map edges.*/
  for (uint x = 0; x <= Map::SizeX(); x++) {
    if (!check_tile(x, 0)) return false;
    if (!check_tile(x, Map::SizeY())) return false;
  }
  for (uint y = 1; y < Map::SizeY(); y++) {
    if (!check_tile(0, y)) return false;
    if (!check_tile(Map::SizeX(), y)) return false;
  }
 
  return true;
}

CommandCost CmdLandscapeClear(DoCommandFlags flags, TileIndex tile)
{
  CommandCost cost(ExpensesType::Construction);
  bool do_clear = false;
  /* Test for stuff which results in water when cleared. Then add the cost to also clear the water. */
  if (flags.Test(DoCommandFlag::ForceClearTile) && HasTileWaterClass(tile) && IsTileOnWater(tile) && !IsWaterTile(tile) && !IsCoastTile(tile)) {
    if (flags.Test(DoCommandFlag::Auto) && GetWaterClass(tile) == WaterClass::Canal) return CommandCost(STR_ERROR_MUST_DEMOLISH_CANAL_FIRST);
    /* Buoy tiles are special as they can be cleared by anyone, but the underlying tile shouldn't be cleared if it has a different owner. */
    if (!IsBuoyTile(tile) || GetTileOwner(tile) == _current_company) {
      do_clear = true;
      cost.AddCost(GetWaterClass(tile) == WaterClass::Canal ? _price[Price::ClearCanal] : _price[Price::ClearWater]);
    }
  }
 
  Company *c = flags.Any({DoCommandFlag::Auto, DoCommandFlag::Bankrupt}) ? nullptr : Company::GetIfValid(_current_company);
  if (c != nullptr && (int)GB(c->clear_limit, 16, 16) < 1) {
    return CommandCost(STR_ERROR_CLEARING_LIMIT_REACHED);
  }
 
  const ClearedObjectArea *coa = FindClearedObject(tile);
 
  /* If this tile was the first tile which caused object destruction, always
   * pass it on to the tile_type_proc. That way multiple test runs and the exec run stay consistent. */
  if (coa != nullptr && coa->first_tile != tile) {
    /* If this tile belongs to an object which was already cleared via another tile, pretend it has been
     * already removed.
     * However, we need to check stuff, which is not the same for all object tiles. (e.g. being on water or not) */
 
    /* If a object is removed, it leaves either bare land or water. */
    if (flags.Test(DoCommandFlag::NoWater) && HasTileWaterClass(tile) && IsTileOnWater(tile)) {
      return CommandCost(STR_ERROR_CAN_T_BUILD_ON_WATER);
    }
  } else {
    cost.AddCost(_tile_type_procs[GetTileType(tile)]->clear_tile_proc(tile, flags));
  }
 
  if (flags.Test(DoCommandFlag::Execute)) {
    if (c != nullptr) c->clear_limit -= 1 << 16;
    if (do_clear) {
      if (IsWaterTile(tile) && IsCanal(tile)) {
        Owner owner = GetTileOwner(tile);
        if (Company::IsValidID(owner)) {
          Company::Get(owner)->infrastructure.water--;
          DirtyCompanyInfrastructureWindows(owner);
        }
      }
      DoClearSquare(tile);
      ClearNeighbourNonFloodingStates(tile);
    }
  }
  return cost;
}

std::tuple<CommandCost, Money> CmdClearArea(DoCommandFlags flags, TileIndex tile, TileIndex start_tile, bool diagonal)
{
  if (start_tile >= Map::Size()) return { CMD_ERROR, 0 };
 
  Money money = GetAvailableMoneyForCommand();
  CommandCost cost(ExpensesType::Construction);
  CommandCost last_error = CMD_ERROR;
  bool had_success = false;
 
  const Company *c = flags.Any({DoCommandFlag::Auto, DoCommandFlag::Bankrupt}) ? nullptr : Company::GetIfValid(_current_company);
  int limit = (c == nullptr ? INT32_MAX : GB(c->clear_limit, 16, 16));
 
  if (tile != start_tile) flags.Set(DoCommandFlag::ForceClearTile);
 
  std::unique_ptr<TileIterator> iter = TileIterator::Create(tile, start_tile, diagonal);
  for (; *iter != INVALID_TILE; ++(*iter)) {
    TileIndex t = *iter;
    CommandCost ret = Command<Commands::LandscapeClear>::Do(DoCommandFlags{flags}.Reset(DoCommandFlag::Execute), t);
    if (ret.Failed()) {
      last_error = std::move(ret);
 
      /* We may not clear more tiles. */
      if (c != nullptr && GB(c->clear_limit, 16, 16) < 1) break;
      continue;
    }
 
    had_success = true;
    if (flags.Test(DoCommandFlag::Execute)) {
      money -= ret.GetCost();
      if (ret.GetCost() > 0 && money < 0) {
        return { cost, ret.GetCost() };
      }
      Command<Commands::LandscapeClear>::Do(flags, t);
 
      /* draw explosion animation...
       * Disable explosions when game is paused. Looks silly and blocks the view. */
      if ((t == tile || t == start_tile) && _pause_mode.None()) {
        /* big explosion in two corners, or small explosion for single tiles */
        CreateEffectVehicleAbove(TileX(t) * TILE_SIZE + TILE_SIZE / 2, TileY(t) * TILE_SIZE + TILE_SIZE / 2, 2,
          TileX(tile) == TileX(start_tile) && TileY(tile) == TileY(start_tile) ? EV_EXPLOSION_SMALL : EV_EXPLOSION_LARGE
        );
      }
    } else {
      /* When we're at the clearing limit we better bail (unneed) testing as well. */
      if (ret.GetCost() != 0 && --limit <= 0) break;
    }
    cost.AddCost(ret.GetCost());
  }
 
  return { had_success ? cost : last_error, 0 };
}
 
 
TileIndex _cur_tileloop_tile;

void RunTileLoop()
{
  PerformanceAccumulator framerate(PerformanceElement::GameLoopLandscape);
 
  /* The pseudorandom sequence of tiles is generated using a Galois linear feedback
   * shift register (LFSR). This allows a deterministic pseudorandom ordering, but
   * still with minimal state and fast iteration. */
 
  /* Maximal length LFSR feedback terms, from 12-bit (for 64x64 maps) to 24-bit (for 4096x4096 maps).
   * Extracted from http://www.ece.cmu.edu/~koopman/lfsr/ */
  static const uint32_t feedbacks[] = {
    0xD8F, 0x1296, 0x2496, 0x4357, 0x8679, 0x1030E, 0x206CD, 0x403FE, 0x807B8, 0x1004B2, 0x2006A8, 0x4004B2, 0x800B87
  };
  static_assert(lengthof(feedbacks) == 2 * MAX_MAP_SIZE_BITS - 2 * MIN_MAP_SIZE_BITS + 1);
  const uint32_t feedback = feedbacks[Map::LogX() + Map::LogY() - 2 * MIN_MAP_SIZE_BITS];
 
  /* We update every tile every TILE_UPDATE_FREQUENCY ticks, so divide the map size by 2^TILE_UPDATE_FREQUENCY_LOG = TILE_UPDATE_FREQUENCY */
  static_assert(2 * MIN_MAP_SIZE_BITS >= TILE_UPDATE_FREQUENCY_LOG);
  uint count = 1 << (Map::LogX() + Map::LogY() - TILE_UPDATE_FREQUENCY_LOG);
 
  TileIndex tile = _cur_tileloop_tile;
  /* The LFSR cannot have a zeroed state. */
  assert(tile != 0);
 
  /* Manually update tile 0 every TILE_UPDATE_FREQUENCY ticks - the LFSR never iterates over it itself.  */
  if (TimerGameTick::counter % TILE_UPDATE_FREQUENCY == 0) {
    _tile_type_procs[GetTileType(0)]->tile_loop_proc(TileIndex{});
    count--;
  }
 
  while (count--) {
    _tile_type_procs[GetTileType(tile)]->tile_loop_proc(tile);
 
    /* Get the next tile in sequence using a Galois LFSR. */
    tile = TileIndex{(tile.base() >> 1) ^ (-(int32_t)(tile.base() & 1) & feedback)};
  }
 
  _cur_tileloop_tile = tile;
}
 
void InitializeLandscape()
{
  for (uint y = _settings_game.construction.freeform_edges ? 1 : 0; y < Map::MaxY(); y++) {
    for (uint x = _settings_game.construction.freeform_edges ? 1 : 0; x < Map::MaxX(); x++) {
      MakeClear(TileXY(x, y), ClearGround::Grass, 3);
      SetTileHeight(TileXY(x, y), 0);
      SetTropicZone(TileXY(x, y), TropicZone::Normal);
      ClearBridgeMiddle(TileXY(x, y));
    }
  }
 
  for (uint x = 0; x < Map::SizeX(); x++) MakeVoid(TileXY(x, Map::MaxY()));
  for (uint y = 0; y < Map::SizeY(); y++) MakeVoid(TileXY(Map::MaxX(), y));
}
 
static const uint8_t _genterrain_tbl_1[5] = { 10, 22, 33, 37, 4  };
static const uint8_t _genterrain_tbl_2[5] = {  0,  0,  0,  0, 33 };
 
static void GenerateTerrain(int type, uint flag)
{
  uint32_t r = Random();
 
  /* Choose one of the templates from the graphics file. */
  const Sprite *templ = GetSprite((((r >> 24) * _genterrain_tbl_1[type]) >> 8) + _genterrain_tbl_2[type] + SPR_MAPGEN_BEGIN, SpriteType::MapGen);
  if (templ == nullptr) UserError("Map generator sprites could not be loaded");
 
  /* Chose a random location to apply the template to. */
  uint x = r & Map::MaxX();
  uint y = (r >> Map::LogX()) & Map::MaxY();
 
  /* Make sure the template is not too close to the upper edges; bottom edges are checked later. */
  uint edge_distance = 1 + (_settings_game.construction.freeform_edges ? 1 : 0);
  if (x <= edge_distance || y <= edge_distance) return;
 
  DiagDirection direction = (DiagDirection)GB(r, 22, 2);
  uint w = templ->width;
  uint h = templ->height;
 
  if (DiagDirToAxis(direction) == Axis::Y) std::swap(w, h);
 
  const uint8_t *p = reinterpret_cast<const uint8_t *>(templ->data);
 
  if ((flag & 4) != 0) {
    /* This is only executed in secondary/tertiary loops to generate the terrain for arctic and tropic.
     * It prevents the templates to be applied to certain parts of the map based on the flags, thus
     * creating regions with different elevations/topography. */
    uint xw = x * Map::SizeY();
    uint yw = y * Map::SizeX();
    uint bias = (Map::SizeX() + Map::SizeY()) * 16;
 
    switch (flag & 3) {
      default: NOT_REACHED();
      case 0:
        if (xw + yw > Map::Size() - bias) return;
        break;
 
      case 1:
        if (yw < xw + bias) return;
        break;
 
      case 2:
        if (xw + yw < Map::Size() + bias) return;
        break;
 
      case 3:
        if (xw < yw + bias) return;
        break;
    }
  }
 
  /* Ensure the template does not overflow at the bottom edges of the map; upper edges were checked before. */
  if (x + w >= Map::MaxX()) return;
  if (y + h >= Map::MaxY()) return;
 
  TileIndex tile = TileXY(x, y);
 
  /* Get the template and overlay in a particular direction over the map's height from the given
   * origin point (tile), and update the map's height everywhere where the height from the template
   * is higher than the height of the map. In other words, this only raises the tile heights. */
  switch (direction) {
    default: NOT_REACHED();
    case DiagDirection::NE:
      do {
        TileIndex tile_cur = tile;
 
        for (uint w_cur = w; w_cur != 0; --w_cur) {
          if (GB(*p, 0, 4) >= TileHeight(tile_cur)) SetTileHeight(tile_cur, GB(*p, 0, 4));
          p++;
          tile_cur += TileDiffXY(1, 0);
        }
        tile += TileDiffXY(0, 1);
      } while (--h != 0);
      break;
 
    case DiagDirection::SE:
      do {
        TileIndex tile_cur = tile;
 
        for (uint h_cur = h; h_cur != 0; --h_cur) {
          if (GB(*p, 0, 4) >= TileHeight(tile_cur)) SetTileHeight(tile_cur, GB(*p, 0, 4));
          p++;
          tile_cur += TileDiffXY(0, 1);
        }
        tile += TileDiffXY(1, 0);
      } while (--w != 0);
      break;
 
    case DiagDirection::SW:
      tile += TileDiffXY(w - 1, 0);
      do {
        TileIndex tile_cur = tile;
 
        for (uint w_cur = w; w_cur != 0; --w_cur) {
          if (GB(*p, 0, 4) >= TileHeight(tile_cur)) SetTileHeight(tile_cur, GB(*p, 0, 4));
          p++;
          tile_cur -= TileDiffXY(1, 0);
        }
        tile += TileDiffXY(0, 1);
      } while (--h != 0);
      break;
 
    case DiagDirection::NW:
      tile += TileDiffXY(0, h - 1);
      do {
        TileIndex tile_cur = tile;
 
        for (uint h_cur = h; h_cur != 0; --h_cur) {
          if (GB(*p, 0, 4) >= TileHeight(tile_cur)) SetTileHeight(tile_cur, GB(*p, 0, 4));
          p++;
          tile_cur -= TileDiffXY(0, 1);
        }
        tile += TileDiffXY(1, 0);
      } while (--w != 0);
      break;
  }
}
 
 
#include "table/genland.h"
 
static void CreateDesertOrRainForest(uint desert_tropic_line)
{
  uint update_freq = Map::Size() / 4;
 
  for (const auto tile : Map::Iterate()) {
    if ((tile % update_freq) == 0) IncreaseGeneratingWorldProgress(GenWorldProgress::Landscape);
 
    if (!IsValidTile(tile)) continue;
 
    auto allows_desert = [tile, desert_tropic_line](auto &offset) {
      TileIndex t = AddTileIndexDiffCWrap(tile, offset);
      return t == INVALID_TILE || (TileHeight(t) < desert_tropic_line && !IsTileType(t, TileType::Water));
    };
    if (std::all_of(std::begin(_make_desert_or_rainforest_data), std::end(_make_desert_or_rainforest_data), allows_desert)) {
      SetTropicZone(tile, TropicZone::Desert);
    }
  }
 
  for (uint i = 0; i != TILE_UPDATE_FREQUENCY; i++) {
    if ((i % 64) == 0) IncreaseGeneratingWorldProgress(GenWorldProgress::Landscape);
 
    RunTileLoop();
  }
 
  for (const auto tile : Map::Iterate()) {
    if ((tile % update_freq) == 0) IncreaseGeneratingWorldProgress(GenWorldProgress::Landscape);
 
    if (!IsValidTile(tile)) continue;
 
    auto allows_rainforest = [tile](auto &offset) {
      TileIndex t = AddTileIndexDiffCWrap(tile, offset);
      return t == INVALID_TILE || !IsTileType(t, TileType::Clear) || !IsClearGround(t, ClearGround::Desert);
    };
    if (std::all_of(std::begin(_make_desert_or_rainforest_data), std::end(_make_desert_or_rainforest_data), allows_rainforest)) {
      SetTropicZone(tile, TropicZone::Rainforest);
    }
  }
}

static bool FindSpring(TileIndex tile)
{
  if (!IsValidTile(tile)) return false;
 
  int reference_height;
  if (!IsTileFlat(tile, &reference_height) || IsWaterTile(tile)) return false;
 
  /* In the tropics rivers start in the rainforest. */
  if (_settings_game.game_creation.landscape == LandscapeType::Tropic && GetTropicZone(tile) != TropicZone::Rainforest) return false;
 
  /* Rivers begin where water flows off hillsides and collects at the bottom. */
  uint max_hill_distance = 1;
  uint required_num_hills = 3;
 
  /* If we don't have many hills, loosen the standards so we still get rivers. */
  if (_settings_game.difficulty.terrain_type < GenworldMaxHeight::Hilly) {
    max_hill_distance = 3;
    required_num_hills = 1;
  };
 
  uint num_hills = 0;
  for (DiagDirection d : EnumRange(DiagDirection::End)) {
    TileIndex check_tile = tile;
    for (uint i = 0; i < max_hill_distance; i++) {
      check_tile = TileAddByDiagDir(check_tile, d);
      if (!IsValidTile(check_tile)) break;
      if (GetTileMaxZ(check_tile) > reference_height) {
        num_hills++;
        break;
      }
    }
  }
 
  return num_hills >= required_num_hills;
}

static bool IsValidRiverTerminusTile(TileIndex tile, uint height)
{
  if (!IsValidTile(tile) || TileHeight(tile) != height || !IsTileFlat(tile)) return false;
  if (_settings_game.game_creation.landscape == LandscapeType::Tropic && GetTropicZone(tile) == TropicZone::Desert) return false;
 
  return true;
}

static void MakeLake(TileIndex lake_centre, uint height_lake)
{
  MakeRiverAndModifyDesertZoneAround(lake_centre);
  uint diameter = RandomRange(8) + 3;
 
  /* Run the loop twice, so artefacts from going circular in one direction get (mostly) hidden. */
  for (uint loops = 0; loops < 2; ++loops) {
    for (TileIndex tile : SpiralTileSequence(lake_centre, diameter)) {
      if (!IsValidRiverTerminusTile(tile, height_lake)) continue;
      for (DiagDirection d : EnumRange(DiagDirection::End)) {
        TileIndex t = tile + TileOffsByDiagDir(d);
        if (IsWaterTile(t)) {
          MakeRiverAndModifyDesertZoneAround(tile);
          break;
        }
      }
    }
  }
}

static void MakeWetlands(TileIndex centre, uint height, uint river_length)
{
  MakeRiverAndModifyDesertZoneAround(centre);
 
  uint diameter = std::max((river_length), 16u);
 
  /* Some wetlands have trees planted among the water tiles. */
  bool has_trees = Chance16(1, 2);
 
  /* Create the main wetland area. */
  for (TileIndex tile : SpiralTileSequence(centre, diameter)) {
    if (!IsValidRiverTerminusTile(tile, height)) continue;
 
    /* Don't make a perfect square, but a circle with a noisy border. */
    uint radius = diameter / 2;
    if ((DistanceSquare(tile, centre) > radius * radius) && Chance16(3, 4)) continue;
 
    if (Chance16(1, 3)) {
      /* This tile is water. */
      MakeRiverAndModifyDesertZoneAround(tile);
    } else if (IsTileType(tile, TileType::Clear)) {
      /* This tile is ground, which we always make rough. */
      SetClearGroundDensity(tile, ClearGround::Rough, 3);
      /* Maybe place trees? */
      if (has_trees && _settings_game.game_creation.tree_placer != TreePlacer::None) {
        PlaceTree(tile, Random(), true);
      }
    }
  }
}

static bool TryMakeRiverTerminus(TileIndex tile, TileIndex begin)
{
  if (!IsValidTile(tile)) return false;
 
  /* We don't want to end the river at the entry of the valley. */
  if (tile == begin) return false;
 
  /* We don't want the river to end in the desert. */
  if (_settings_game.game_creation.landscape == LandscapeType::Tropic && GetTropicZone(tile) == TropicZone::Desert) return false;
 
  /* Only end on flat slopes. */
  int height_lake;
  if (!IsTileFlat(tile, &height_lake)) return false;
 
  /* Only build at the height of the river. */
  int height_begin = TileHeight(begin);
  if (height_lake != height_begin) return false;
 
  /* Checks successful, time to build.
   * Chance of water feature is split evenly between a lake, a wetland with trees, and a wetland with grass. */
  if (Chance16(1, 3)) {
    MakeLake(tile, height_lake);
  } else {
    MakeWetlands(tile, height_lake, DistanceManhattan(tile, begin));
  }
 
  /* This is the new end of the river. */
  return true;
}

void RiverMakeWider(TileIndex tile, TileIndex origin_tile)
{
  /* Don't expand into void tiles. */
  if (!IsValidTile(tile)) return;
 
  /* If the tile is already sea or river, don't expand. */
  if (IsWaterTile(tile)) return;
 
  /* If the tile is at height 0 after terraforming but the ocean hasn't flooded yet, don't build river. */
  if (GetTileMaxZ(tile) == 0) return;
 
  Slope cur_slope = GetTileSlope(tile);
  Slope desired_slope = GetTileSlope(origin_tile); // Initialize matching the origin tile as a shortcut if no terraforming is needed.
 
  /* Never flow uphill. */
  if (GetTileMaxZ(tile) > GetTileMaxZ(origin_tile)) return;
 
  /* If the new tile can't hold a river tile, try terraforming. */
  if (!IsTileFlat(tile) && !IsInclinedSlope(cur_slope)) {
    /* Don't try to terraform steep slopes. */
    if (IsSteepSlope(cur_slope)) return;
 
    bool flat_river_found = false;
    bool sloped_river_found = false;
 
    /* There are two common possibilities:
     * 1. River flat, adjacent tile has one corner lowered.
     * 2. River descending, adjacent tile has either one or three corners raised.
     */
 
    /* First, determine the desired slope based on adjacent river tiles. This doesn't necessarily match the origin tile for the SpiralTileSequence. */
    for (DiagDirection d : EnumRange(DiagDirection::End)) {
      TileIndex other_tile = TileAddByDiagDir(tile, d);
      Slope other_slope = GetTileSlope(other_tile);
 
      /* Only consider river tiles. */
      if (IsWaterTile(other_tile) && IsRiver(other_tile)) {
        /* If the adjacent river tile flows downhill, we need to check where we are relative to the slope. */
        if (IsInclinedSlope(other_slope) && GetTileMaxZ(tile) == GetTileMaxZ(other_tile)) {
          /* Check for a parallel slope. If we don't find one, we're above or below the slope instead. */
          if (GetInclinedSlopeDirection(other_slope) == ChangeDiagDir(d, DiagDirDiff::Right90) ||
              GetInclinedSlopeDirection(other_slope) == ChangeDiagDir(d, DiagDirDiff::Left90)) {
            desired_slope = other_slope;
            sloped_river_found = true;
            break;
          }
        }
        /* If we find an adjacent river tile, remember it. We'll terraform to match it later if we don't find a slope. */
        if (IsTileFlat(other_tile)) flat_river_found = true;
      }
    }
    /* We didn't find either an inclined or flat river, so we're climbing the wrong slope. Bail out. */
    if (!sloped_river_found && !flat_river_found) return;
 
    /* We didn't find an inclined river, but there is a flat river. */
    if (!sloped_river_found && flat_river_found) desired_slope = SLOPE_FLAT;
 
    /* Now that we know the desired slope, it's time to terraform! */
 
    /* If the river is flat and the adjacent tile has one corner lowered, we want to raise it. */
    if (desired_slope == SLOPE_FLAT && IsSlopeWithThreeCornersRaised(cur_slope)) {
      /* Make sure we're not affecting an existing river slope tile. */
      for (DiagDirection d : EnumRange(DiagDirection::End)) {
        TileIndex other_tile = TileAddByDiagDir(tile, d);
        if (IsInclinedSlope(GetTileSlope(other_tile)) && IsWaterTile(other_tile)) return;
      }
      Command<Commands::TerraformLand>::Do({DoCommandFlag::Execute, DoCommandFlag::Auto}, tile, ComplementSlope(cur_slope), true);
 
    /* If the river is descending and the adjacent tile has either one or three corners raised, we want to make it match the slope. */
    } else if (IsInclinedSlope(desired_slope)) {
      /* Don't break existing flat river tiles by terraforming under them. */
      DiagDirection river_direction = ReverseDiagDir(GetInclinedSlopeDirection(desired_slope));
 
      for (DiagDirDiff d : {DiagDirDiff::Right90, DiagDirDiff::Left90}) {
        /* We don't care about downstream or upstream tiles, just the riverbanks. */
        TileIndex other_tile = (TileAddByDiagDir(tile, ChangeDiagDir(river_direction, d)));
        if (IsWaterTile(other_tile) && IsRiver(other_tile) && IsTileFlat(other_tile)) return;
      }
 
      /* Get the corners which are different between the current and desired slope. */
      Slope to_change = cur_slope ^ desired_slope;
 
      /* Lower unwanted corners first. If only one corner is raised, no corners need lowering. */
      if (!IsSlopeWithOneCornerRaised(cur_slope)) {
        to_change = to_change & ComplementSlope(desired_slope);
        Command<Commands::TerraformLand>::Do({DoCommandFlag::Execute, DoCommandFlag::Auto}, tile, to_change, false);
      }
 
      /* Now check the match and raise any corners needed. */
      cur_slope = GetTileSlope(tile);
      if (cur_slope != desired_slope && IsSlopeWithOneCornerRaised(cur_slope)) {
        to_change = cur_slope ^ desired_slope;
        Command<Commands::TerraformLand>::Do({DoCommandFlag::Execute, DoCommandFlag::Auto}, tile, to_change, true);
      }
    }
    /* Update cur_slope after possibly terraforming. */
    cur_slope = GetTileSlope(tile);
  }
 
  /* Sloped rivers need water both upstream and downstream. */
  if (IsInclinedSlope(cur_slope)) {
    DiagDirection slope_direction = GetInclinedSlopeDirection(cur_slope);
 
    TileIndex upstream_tile = TileAddByDiagDir(tile, slope_direction);
    TileIndex downstream_tile = TileAddByDiagDir(tile, ReverseDiagDir(slope_direction));
 
    /* Don't look outside the map. */
    if (!IsValidTile(upstream_tile) || !IsValidTile(downstream_tile)) return;
 
    /* Downstream might be new ocean created by our terraforming, and it hasn't flooded yet. */
    bool downstream_is_ocean = GetTileZ(downstream_tile) == 0 && (GetTileSlope(downstream_tile) == SLOPE_FLAT || IsSlopeWithOneCornerRaised(GetTileSlope(downstream_tile)));
 
    /* If downstream is dry, flat, and not ocean, try making it a river tile. */
    if (!IsWaterTile(downstream_tile) && !downstream_is_ocean) {
      /* If the tile upstream isn't flat, don't bother. */
      if (GetTileSlope(downstream_tile) != SLOPE_FLAT) return;
 
      MakeRiverAndModifyDesertZoneAround(downstream_tile);
    }
 
    /* If upstream is dry and flat, try making it a river tile. */
    if (!IsWaterTile(upstream_tile)) {
      /* If the tile upstream isn't flat, don't bother. */
      if (GetTileSlope(upstream_tile) != SLOPE_FLAT) return;
 
      MakeRiverAndModifyDesertZoneAround(upstream_tile);
    }
  }
 
  /* If the tile slope matches the desired slope, add a river tile. */
  if (cur_slope == desired_slope) {
    MakeRiverAndModifyDesertZoneAround(tile);
  }
}

bool RiverFlowsDown(TileIndex begin, TileIndex end)
{
  assert(DistanceManhattan(begin, end) == 1);
 
  auto [slope_end, height_end] = GetTileSlopeZ(end);
 
  /* Slope either is inclined or flat; rivers don't support other slopes. */
  if (slope_end != SLOPE_FLAT && !IsInclinedSlope(slope_end)) return false;
 
  auto [slope_begin, height_begin] = GetTileSlopeZ(begin);
 
  /* It can't flow uphill. */
  if (height_end > height_begin) return false;
 
  /* Slope continues, then it must be lower... */
  if (slope_end == slope_begin && height_end < height_begin) return true;
 
  /* ... or either end must be flat. */
  return slope_end == SLOPE_FLAT || slope_begin == SLOPE_FLAT;
}

static bool CountConnectedSeaTiles(TileIndex tile, std::unordered_set<TileIndex> &sea, const uint limit)
{
  /* This tile might not be sea. */
  if (!IsWaterTile(tile) || GetWaterClass(tile) != WaterClass::Sea || !IsTileFlat(tile)) return false;
 
  /* If we've found an edge tile, we are "connected to the sea outside the map." */
  if (DistanceFromEdge(tile) <= 1) return true;
 
  /* We have now evaluated this tile and don't want to check it again. */
  sea.insert(tile);
 
  /* We might want to cut our search short if the size of the sea is "big enough".
   * Count this tile but don't check its neighbors. */
  if (sea.size() > limit) return false;
 
  /* Count adjacent tiles using recursion. */
  for (DiagDirection d : EnumRange(DiagDirection::End)) {
    TileIndex t = tile + TileOffsByDiagDir(d);
    if (IsValidTile(t) && !sea.contains(t)) {
      if (CountConnectedSeaTiles(t, sea, limit)) return true;
    }
  }
 
  return false;
}

static std::tuple<bool, bool> FlowRiver(TileIndex spring, TileIndex begin, uint min_river_length)
{
  if (IsWaterTile(begin)) {
    return { DistanceManhattan(spring, begin) > min_river_length, GetTileZ(begin) == 0 };
  }
 
  int height_begin = TileHeight(begin);
 
  std::unordered_set<TileIndex> marks;
  marks.insert(begin);
 
  std::vector<TileIndex> queue;
  queue.push_back(begin);
 
  /* Breadth first search for the closest tile we can flow down to.
   * We keep the queue to find the Nth tile for lake guessing. The tiles
   * in the queue are neatly ordered by insertion.
   */
  bool found = false;
  TileIndex end;
  for (size_t i = 0; i != queue.size(); i++) {
    end = queue[i];
 
    int height_end;
    if (IsTileFlat(end, &height_end) && (height_end < height_begin || (height_end == height_begin && IsWaterTile(end)))) {
      /* We don't want rivers to flow into tiny bits of sea, so we fill them, unless using the original land generator. */
      if (_settings_game.game_creation.land_generator != LG_ORIGINAL && IsWaterTile(end) && GetWaterClass(end) == WaterClass::Sea) {
        /* If we've found the sea, make sure it's large enough. Scale by the map size but set a cap to avoid performance issues on large maps. */
        const uint MAX_SEA_SIZE_THRESHOLD = 1024;
        const uint SEA_SIZE_THRESHOLD = std::min(static_cast<uint>(2 * std::sqrt(Map::SizeX() * Map::SizeY())), MAX_SEA_SIZE_THRESHOLD);
        std::unordered_set<TileIndex> sea;
        /* Count the connected tiles, if the sea is large we can end the river here. */
        bool found_edge = CountConnectedSeaTiles(end, sea, SEA_SIZE_THRESHOLD);
        if (found_edge || sea.size() > SEA_SIZE_THRESHOLD) {
          found = true;
          break;
        } else {
          /* Sea is too small, flatten it so the river keeps looking or forms a lake / wetland. */
          for (TileIndex sea_tile : sea) {
            Command<Commands::TerraformLand>::Do(DoCommandFlag::Execute, sea_tile, SLOPE_ELEVATED, false);
            Slope slope = ComplementSlope(GetTileSlope(sea_tile));
            Command<Commands::TerraformLand>::Do(DoCommandFlag::Execute, sea_tile, slope, true);
          }
        }
      } else {
        /* We've found a river, or a sea if using the original land generator. */
        found = true;
        break;
      }
    }
 
    for (DiagDirection d : EnumRange(DiagDirection::End)) {
      TileIndex t = end + TileOffsByDiagDir(d);
      if (IsValidTile(t) && !marks.contains(t) && RiverFlowsDown(end, t)) {
        marks.insert(t);
        queue.push_back(t);
      }
    }
  }
 
  bool main_river = false;
  if (found) {
    /* Flow further down hill. */
    std::tie(found, main_river) = FlowRiver(spring, end, min_river_length);
  } else if (queue.size() > 32) {
    /* Maybe we can make a lake. Find the Nth of the considered tiles. */
    TileIndex lake_centre = queue[RandomRange(static_cast<uint32_t>(queue.size()))];
    if (DistanceManhattan(spring, lake_centre) > min_river_length) {
      if (TryMakeRiverTerminus(lake_centre, begin)) {
        /* If successful, this becomes the new end of the river. */
        end = lake_centre;
        found = true;
      }
    }
  }
 
  if (found) YapfBuildRiver(begin, end, spring, main_river);
  return { found, main_river };
}

static void CreateRivers()
{
  int amount = _settings_game.game_creation.amount_of_rivers;
  if (amount == 0) return;
 
  uint wells = Map::ScaleBySize(4 << _settings_game.game_creation.amount_of_rivers);
  const uint num_short_rivers = wells - std::max(1u, wells / 10);
  SetGeneratingWorldProgress(GenWorldProgress::Rivers, wells + TILE_UPDATE_FREQUENCY / 64); // Include the tile loop calls below.
 
  /* Try to create long rivers. */
  for (; wells > num_short_rivers; wells--) {
    IncreaseGeneratingWorldProgress(GenWorldProgress::Rivers);
    bool done = false;
    for (int tries = 0; tries < 512; tries++) {
      for (auto t : SpiralTileSequence(RandomTile(), 8)) {
        if (FindSpring(t)) {
          done = std::get<0>(FlowRiver(t, t, _settings_game.game_creation.min_river_length * 4));
          break;
        }
      }
      if (done) break;
    }
  }
 
  /* Try to create short rivers. */
  for (; wells != 0; wells--) {
    IncreaseGeneratingWorldProgress(GenWorldProgress::Rivers);
    bool done = false;
    for (int tries = 0; tries < 128; tries++) {
      for (auto t : SpiralTileSequence(RandomTile(), 8)) {
        if (FindSpring(t)) {
          done = std::get<0>(FlowRiver(t, t, _settings_game.game_creation.min_river_length));
          break;
        }
      }
      if (done) break;
    }
  }
 
  /* Widening rivers may have left some tiles requiring to be watered. */
  ConvertGroundTilesIntoWaterTiles();
 
  /* Run tile loop to update the ground density. */
  for (uint i = 0; i != TILE_UPDATE_FREQUENCY; i++) {
    if (i % 64 == 0) IncreaseGeneratingWorldProgress(GenWorldProgress::Rivers);
    RunTileLoop();
  }
}

static uint CalculateCoverageLine(uint coverage, uint edge_multiplier)
{
  /* Histogram of how many tiles per height level exist. */
  std::array<int, MAX_TILE_HEIGHT + 1> histogram = {};
  /* Histogram of how many neighbour tiles are lower than the tiles of the height level. */
  std::array<int, MAX_TILE_HEIGHT + 1> edge_histogram = {};
 
  /* Build a histogram of the map height. */
  for (const auto tile : Map::Iterate()) {
    uint h = TileHeight(tile);
    histogram[h]++;
 
    if (edge_multiplier != 0) {
      /* Check if any of our neighbours is below us. */
      for (DiagDirection dir : EnumRange(DiagDirection::End)) {
        TileIndex neighbour_tile = AddTileIndexDiffCWrap(tile, TileIndexDiffCByDiagDir(dir));
        if (IsValidTile(neighbour_tile) && TileHeight(neighbour_tile) < h) {
          edge_histogram[h]++;
        }
      }
    }
  }
 
  /* The amount of land we have is the map size minus the first (sea) layer. */
  uint land_tiles = Map::Size() - histogram[0];
  int best_score = land_tiles;
 
  /* Our goal is the coverage amount of the land-mass. */
  int goal_tiles = land_tiles * coverage / 100;
 
  /* We scan from top to bottom. */
  uint h = MAX_TILE_HEIGHT;
  uint best_h = h;
 
  int current_tiles = 0;
  for (; h > 0; h--) {
    current_tiles += histogram[h];
    int current_score = goal_tiles - current_tiles;
 
    /* Tropic grows from water and mountains into the desert. This is a
     * great visual, but it also means we* need to take into account how
     * much less desert tiles are being created if we are on this
     * height-level. We estimate this based on how many neighbouring
     * tiles are below us for a given length, assuming that is where
     * tropic is growing from.
     */
    if (edge_multiplier != 0 && h > 1) {
      /* From water tropic tiles grow for a few tiles land inward. */
      current_score -= edge_histogram[1] * edge_multiplier;
      /* Tropic tiles grow into the desert for a few tiles. */
      current_score -= edge_histogram[h] * edge_multiplier;
    }
 
    if (std::abs(current_score) < std::abs(best_score)) {
      best_score = current_score;
      best_h = h;
    }
 
    /* Always scan all height-levels, as h == 1 might give a better
     * score than any before. This is true for example with 0% desert
     * coverage. */
  }
 
  return best_h;
}

static void CalculateSnowLine()
{
  /* We do not have snow sprites on coastal tiles, so never allow "1" as height. */
  _settings_game.game_creation.snow_line_height = std::max<uint8_t>(CalculateCoverageLine(_settings_game.game_creation.snow_coverage, 0), 2u);
}

static uint8_t CalculateDesertLine()
{
  /* CalculateCoverageLine() runs from top to bottom, so we need to invert the coverage. */
  return CalculateCoverageLine(100 - _settings_game.game_creation.desert_coverage, 4);
}
 
bool GenerateLandscape(uint8_t mode)
{
  /* Number of steps of landscape generation */
  static constexpr uint GLS_HEIGHTMAP = 3; 
  static constexpr uint GLS_TERRAGENESIS = 4; 
  static constexpr uint GLS_ORIGINAL = 2; 
  static constexpr uint GLS_TROPIC = 12; 
  static constexpr uint GLS_OTHER = 0; 
  uint steps = (_settings_game.game_creation.landscape == LandscapeType::Tropic) ? GLS_TROPIC : GLS_OTHER;
 
  if (mode == GWM_HEIGHTMAP) {
    SetGeneratingWorldProgress(GenWorldProgress::Landscape, steps + GLS_HEIGHTMAP);
    if (!LoadHeightmap(_file_to_saveload.ftype.detailed, _file_to_saveload.name)) {
      return false;
    }
    IncreaseGeneratingWorldProgress(GenWorldProgress::Landscape);
  } else if (_settings_game.game_creation.land_generator == LG_TERRAGENESIS) {
    SetGeneratingWorldProgress(GenWorldProgress::Landscape, steps + GLS_TERRAGENESIS);
    GenerateTerrainPerlin();
  } else {
    SetGeneratingWorldProgress(GenWorldProgress::Landscape, steps + GLS_ORIGINAL);
    if (_settings_game.construction.freeform_edges) {
      for (uint x = 0; x < Map::SizeX(); x++) MakeVoid(TileXY(x, 0));
      for (uint y = 0; y < Map::SizeY(); y++) MakeVoid(TileXY(0, y));
    }
    switch (_settings_game.game_creation.landscape) {
      case LandscapeType::Arctic: {
        uint32_t r = Random();
 
        for (uint i = Map::ScaleBySize(GB(r, 0, 7) + 950); i != 0; --i) {
          GenerateTerrain(2, 0);
        }
 
        uint flag = GB(r, 7, 2) | 4;
        for (uint i = Map::ScaleBySize(GB(r, 9, 7) + 450); i != 0; --i) {
          GenerateTerrain(4, flag);
        }
        break;
      }
 
      case LandscapeType::Tropic: {
        uint32_t r = Random();
 
        for (uint i = Map::ScaleBySize(GB(r, 0, 7) + 170); i != 0; --i) {
          GenerateTerrain(0, 0);
        }
 
        uint flag = GB(r, 7, 2) | 4;
        for (uint i = Map::ScaleBySize(GB(r, 9, 8) + 1700); i != 0; --i) {
          GenerateTerrain(0, flag);
        }
 
        flag ^= 2;
 
        for (uint i = Map::ScaleBySize(GB(r, 17, 7) + 410); i != 0; --i) {
          GenerateTerrain(3, flag);
        }
        break;
      }
 
      default: {
        uint32_t r = Random();
 
        assert(_settings_game.difficulty.quantity_sea_lakes != CUSTOM_SEA_LEVEL_NUMBER_DIFFICULTY);
        uint i = Map::ScaleBySize(GB(r, 0, 7) + (3 - _settings_game.difficulty.quantity_sea_lakes) * 256 + 100);
        for (; i != 0; --i) {
          /* Make sure we do not overflow. */
          GenerateTerrain(static_cast<int>(Clamp(_settings_game.difficulty.terrain_type, GenworldMaxHeight::VeryFlat, GenworldMaxHeight::Mountainous)), 0);
        }
        break;
      }
    }
  }
 
  /* Do not call IncreaseGeneratingWorldProgress() before FixSlopes(),
   * it allows screen redraw. Drawing of broken slopes crashes the game */
  FixSlopes();
  MarkWholeScreenDirty();
  IncreaseGeneratingWorldProgress(GenWorldProgress::Landscape);
 
  ConvertGroundTilesIntoWaterTiles();
  MarkWholeScreenDirty();
  IncreaseGeneratingWorldProgress(GenWorldProgress::Landscape);
 
  switch (_settings_game.game_creation.landscape) {
    case LandscapeType::Arctic:
      CalculateSnowLine();
      break;
 
    case LandscapeType::Tropic: {
      uint desert_tropic_line = CalculateDesertLine();
      CreateDesertOrRainForest(desert_tropic_line);
      break;
    }
 
    default:
      break;
  }
 
  CreateRivers();
  return true;
}
 
void OnTick_Town();
void OnTick_Trees();
void OnTick_Station();
void OnTick_Industry();
 
void OnTick_Companies();
void OnTick_LinkGraph();
 
void CallLandscapeTick()
{
  {
    PerformanceAccumulator framerate(PerformanceElement::GameLoopLandscape);
 
    OnTick_Town();
    OnTick_Trees();
    OnTick_Station();
    OnTick_Industry();
  }
 
  OnTick_Companies();
  OnTick_LinkGraph();
}