water_regions.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 <http://www.gnu.org/licenses/>.
 */
 
#include "../stdafx.h"
#include "../map_func.h"
#include "water_regions.h"
#include "../tilearea_type.h"
#include "../track_func.h"
#include "../transport_type.h"
#include "../landscape.h"
#include "../tunnelbridge_map.h"
#include "follow_track.hpp"
#include "../ship.h"
#include "../debug.h"
#include "../3rdparty/fmt/ranges.h"
#include "../core/convertible_through_base.hpp"
#include "../safeguards.h"
 
using WaterRegionTraversabilityBits = uint16_t;
constexpr WaterRegionPatchLabel FIRST_REGION_LABEL{1};
 
static_assert(sizeof(WaterRegionTraversabilityBits) * 8 == WATER_REGION_EDGE_LENGTH);
static_assert(sizeof(WaterRegionPatchLabel) == sizeof(uint8_t)); // Important for the hash calculation.
 
static inline TrackBits GetWaterTracks(TileIndex tile) { return TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, 0)); }
static inline bool IsAqueductTile(TileIndex tile) { return IsBridgeTile(tile) && GetTunnelBridgeTransportType(tile) == TRANSPORT_WATER; }
 
static inline int GetWaterRegionX(TileIndex tile) { return TileX(tile) / WATER_REGION_EDGE_LENGTH; }
static inline int GetWaterRegionY(TileIndex tile) { return TileY(tile) / WATER_REGION_EDGE_LENGTH; }
 
static inline int GetWaterRegionMapSizeX() { return Map::SizeX() / WATER_REGION_EDGE_LENGTH; }
static inline int GetWaterRegionMapSizeY() { return Map::SizeY() / WATER_REGION_EDGE_LENGTH; }
 
static inline WaterRegionIndex GetWaterRegionIndex(int region_x, int region_y) { return WaterRegionIndex(GetWaterRegionMapSizeX() * region_y + region_x); }
static inline WaterRegionIndex GetWaterRegionIndex(TileIndex tile) { return GetWaterRegionIndex(GetWaterRegionX(tile), GetWaterRegionY(tile)); }
 
using WaterRegionPatchLabelArray = std::array<WaterRegionPatchLabel, WATER_REGION_NUMBER_OF_TILES>;
 
class WaterRegionData {
  friend class WaterRegion;
 
  std::array<WaterRegionTraversabilityBits, DIAGDIR_END> edge_traversability_bits{};
  std::unique_ptr<WaterRegionPatchLabelArray> tile_patch_labels; // Tile patch labels, this may be nullptr in the following trivial cases: region is invalid, region is only land (0 patches), region is only water (1 patch)
  bool has_cross_region_aqueducts = false;
  WaterRegionPatchLabel::BaseType number_of_patches{0}; // 0 = no water, 1 = one single patch of water, etc...
};
class WaterRegionData {…};
 
class WaterRegion {
private:
  WaterRegionData &data;
  const OrthogonalTileArea tile_area;
 
  inline int GetLocalIndex(TileIndex tile) const
  {
    assert(this->tile_area.Contains(tile));
    return (TileX(tile) - TileX(this->tile_area.tile)) + WATER_REGION_EDGE_LENGTH * (TileY(tile) - TileY(this->tile_area.tile));
  }
  inline int GetLocalIndex(TileIndex tile) const {…}
 
public:
  WaterRegion(int region_x, int region_y, WaterRegionData &water_region_data)
    : data(water_region_data)
    , tile_area(TileXY(region_x * WATER_REGION_EDGE_LENGTH, region_y * WATER_REGION_EDGE_LENGTH), WATER_REGION_EDGE_LENGTH, WATER_REGION_EDGE_LENGTH)
  {}
 
  OrthogonalTileIterator begin() const { return this->tile_area.begin(); }
  OrthogonalTileIterator end() const { return this->tile_area.end(); }
 
  WaterRegionTraversabilityBits GetEdgeTraversabilityBits(DiagDirection side) const { return this->data.edge_traversability_bits[side]; }
 
  int NumberOfPatches() const { return static_cast<int>(this->data.number_of_patches); }
 
  bool HasCrossRegionAqueducts() const { return this->data.has_cross_region_aqueducts; }
 
  WaterRegionPatchLabel GetLabel(TileIndex tile) const
  {
    assert(this->tile_area.Contains(tile));
    if (this->data.tile_patch_labels == nullptr) {
      return this->NumberOfPatches() == 0 ? INVALID_WATER_REGION_PATCH : FIRST_REGION_LABEL;
    }
    return (*this->data.tile_patch_labels)[this->GetLocalIndex(tile)];
  }
  WaterRegionPatchLabel GetLabel(TileIndex tile) const {…}
 
  void ForceUpdate()
  {
    Debug(map, 3, "Updating water region ({},{})", GetWaterRegionX(this->tile_area.tile), GetWaterRegionY(this->tile_area.tile));
    this->data.has_cross_region_aqueducts = false;
 
    /* Acquire a tile patch label array if this region does not already have one */
    if (this->data.tile_patch_labels == nullptr) {
      this->data.tile_patch_labels = std::make_unique<WaterRegionPatchLabelArray>();
    }
 
    this->data.tile_patch_labels->fill(INVALID_WATER_REGION_PATCH);
    this->data.edge_traversability_bits.fill(0);
 
    WaterRegionPatchLabel current_label = FIRST_REGION_LABEL;
    WaterRegionPatchLabel highest_assigned_label = INVALID_WATER_REGION_PATCH;
 
    /* Perform connected component labeling. This uses a flooding algorithm that expands until no
     * additional tiles can be added. Only tiles inside the water region are considered. */
    for (const TileIndex start_tile : this->tile_area) {
      static std::vector<TileIndex> tiles_to_check;
      tiles_to_check.clear();
      tiles_to_check.push_back(start_tile);
 
      bool increase_label = false;
      while (!tiles_to_check.empty()) {
        const TileIndex tile = tiles_to_check.back();
        tiles_to_check.pop_back();
 
        const TrackdirBits valid_dirs = TrackBitsToTrackdirBits(GetWaterTracks(tile));
        if (valid_dirs == TRACKDIR_BIT_NONE) continue;
 
        WaterRegionPatchLabel &tile_patch = (*this->data.tile_patch_labels)[this->GetLocalIndex(tile)];
        if (tile_patch != INVALID_WATER_REGION_PATCH) continue;
 
        tile_patch = current_label;
        highest_assigned_label = current_label;
        increase_label = true;
 
        for (const Trackdir dir : SetTrackdirBitIterator(valid_dirs)) {
          /* By using a TrackFollower we "play by the same rules" as the actual ship pathfinder */
          CFollowTrackWater ft;
          if (ft.Follow(tile, dir)) {
            if (this->tile_area.Contains(ft.new_tile)) {
              tiles_to_check.push_back(ft.new_tile);
            } else if (!ft.is_bridge) {
              assert(DistanceManhattan(ft.new_tile, tile) == 1);
              const auto side = DiagdirBetweenTiles(tile, ft.new_tile);
              const int local_x_or_y = DiagDirToAxis(side) == AXIS_X ? TileY(tile) - TileY(this->tile_area.tile) : TileX(tile) - TileX(this->tile_area.tile);
              SetBit(this->data.edge_traversability_bits[side], local_x_or_y);
            } else {
              this->data.has_cross_region_aqueducts = true;
            }
          }
        }
      }
 
      if (increase_label) current_label++;
    }
 
    this->data.number_of_patches = highest_assigned_label.base();
 
    if (this->NumberOfPatches() == 0 || (this->NumberOfPatches() == 1 &&
        std::all_of(this->data.tile_patch_labels->begin(), this->data.tile_patch_labels->end(), [](WaterRegionPatchLabel label) { return label == FIRST_REGION_LABEL; }))) {
      /* No need for patch storage: trivial cases */
      this->data.tile_patch_labels.reset();
    }
  }
  void ForceUpdate() {…}
 
  void PrintDebugInfo()
  {
    Debug(map, 9, "Water region {},{} labels and edge traversability = ...", GetWaterRegionX(this->tile_area.tile), GetWaterRegionY(this->tile_area.tile));
 
    const size_t max_element_width = fmt::format("{}", this->NumberOfPatches()).size();
 
    std::string traversability = fmt::format("{:0{}b}", this->GetEdgeTraversabilityBits(DIAGDIR_NW), WATER_REGION_EDGE_LENGTH);
    Debug(map, 9, "    {:{}}", fmt::join(traversability, " "), max_element_width);
    Debug(map, 9, "  +{:->{}}+", "", WATER_REGION_EDGE_LENGTH * (max_element_width + 1) + 1);
 
    for (int y = 0; y < WATER_REGION_EDGE_LENGTH; ++y) {
      std::string line{};
      for (int x = 0; x < WATER_REGION_EDGE_LENGTH; ++x) {
        const auto label = this->GetLabel(TileAddXY(this->tile_area.tile, x, y));
        if (label == INVALID_WATER_REGION_PATCH) {
          line = fmt::format("{:{}} {}", ".", max_element_width, line);
        } else {
          line = fmt::format("{:{}} {}", label, max_element_width, line);
        }
      }
      Debug(map, 9, "{} | {}| {}", GB(this->GetEdgeTraversabilityBits(DIAGDIR_SW), y, 1), line, GB(this->GetEdgeTraversabilityBits(DIAGDIR_NE), y, 1));
    }
 
    Debug(map, 9, "  +{:->{}}+", "", WATER_REGION_EDGE_LENGTH * (max_element_width + 1) + 1);
    traversability = fmt::format("{:0{}b}", this->GetEdgeTraversabilityBits(DIAGDIR_SE), WATER_REGION_EDGE_LENGTH);
    Debug(map, 9, "    {:{}}", fmt::join(traversability, " "), max_element_width);
  }
};
class WaterRegion {…};
 
TypedIndexContainer<std::vector<WaterRegionData>, WaterRegionIndex> _water_region_data;
TypedIndexContainer<std::vector<bool>, WaterRegionIndex> _is_water_region_valid;
 
static TileIndex GetTileIndexFromLocalCoordinate(int region_x, int region_y, int local_x, int local_y)
{
  assert(local_x >= 0 && local_x < WATER_REGION_EDGE_LENGTH);
  assert(local_y >= 0 && local_y < WATER_REGION_EDGE_LENGTH);
  return TileXY(WATER_REGION_EDGE_LENGTH * region_x + local_x, WATER_REGION_EDGE_LENGTH * region_y + local_y);
}
 
static TileIndex GetEdgeTileCoordinate(int region_x, int region_y, DiagDirection side, int x_or_y)
{
  assert(x_or_y >= 0 && x_or_y < WATER_REGION_EDGE_LENGTH);
  switch (side) {
    case DIAGDIR_NE: return GetTileIndexFromLocalCoordinate(region_x, region_y, 0, x_or_y);
    case DIAGDIR_SW: return GetTileIndexFromLocalCoordinate(region_x, region_y, WATER_REGION_EDGE_LENGTH - 1, x_or_y);
    case DIAGDIR_NW: return GetTileIndexFromLocalCoordinate(region_x, region_y, x_or_y, 0);
    case DIAGDIR_SE: return GetTileIndexFromLocalCoordinate(region_x, region_y, x_or_y, WATER_REGION_EDGE_LENGTH - 1);
    default: NOT_REACHED();
  }
}
 
static WaterRegion GetUpdatedWaterRegion(uint16_t region_x, uint16_t region_y)
{
  const WaterRegionIndex index = GetWaterRegionIndex(region_x, region_y);
  WaterRegion water_region(region_x, region_y, _water_region_data[index]);
  if (!_is_water_region_valid[index]) {
    water_region.ForceUpdate();
    _is_water_region_valid[index] = true;
  }
  return water_region;
}
 
static WaterRegion GetUpdatedWaterRegion(TileIndex tile)
{
  return GetUpdatedWaterRegion(GetWaterRegionX(tile), GetWaterRegionY(tile));
}
 
static WaterRegionIndex GetWaterRegionIndex(const WaterRegionDesc &water_region)
{
  return GetWaterRegionIndex(water_region.x, water_region.y);
}
static WaterRegionIndex GetWaterRegionIndex(const WaterRegionDesc &water_region) {…}
 
int CalculateWaterRegionPatchHash(const WaterRegionPatchDesc &water_region_patch)
{
  return water_region_patch.label.base() | GetWaterRegionIndex(water_region_patch).base() << 8;
}
int CalculateWaterRegionPatchHash(const WaterRegionPatchDesc &water_region_patch) {…}
 
TileIndex GetWaterRegionCenterTile(const WaterRegionDesc &water_region)
{
  return TileXY(water_region.x * WATER_REGION_EDGE_LENGTH + (WATER_REGION_EDGE_LENGTH / 2), water_region.y * WATER_REGION_EDGE_LENGTH + (WATER_REGION_EDGE_LENGTH / 2));
}
TileIndex GetWaterRegionCenterTile(const WaterRegionDesc &water_region) {…}
 
WaterRegionDesc GetWaterRegionInfo(TileIndex tile)
{
  return WaterRegionDesc{ GetWaterRegionX(tile), GetWaterRegionY(tile) };
}
WaterRegionDesc GetWaterRegionInfo(TileIndex tile) {…}
 
WaterRegionPatchDesc GetWaterRegionPatchInfo(TileIndex tile)
{
  const WaterRegion region = GetUpdatedWaterRegion(tile);
  return WaterRegionPatchDesc{ GetWaterRegionX(tile), GetWaterRegionY(tile), region.GetLabel(tile) };
}
WaterRegionPatchDesc GetWaterRegionPatchInfo(TileIndex tile) {…}
 
void InvalidateWaterRegion(TileIndex tile)
{
  if (!IsValidTile(tile)) return;
 
  auto invalidate_region = [](TileIndex tile) {
    const WaterRegionIndex water_region_index = GetWaterRegionIndex(tile);
    if (!_is_water_region_valid[water_region_index]) Debug(map, 3, "Invalidated water region ({},{})", GetWaterRegionX(tile), GetWaterRegionY(tile));
    _is_water_region_valid[water_region_index] = false;
  };
 
  invalidate_region(tile);
 
  /* When updating the water region we look into the first tile of adjacent water regions to determine edge
   * traversability. This means that if we invalidate any region edge tiles we might also change the traversability
   * of the adjacent region. This code ensures the adjacent regions also get invalidated in such a case. */
  for (DiagDirection side = DIAGDIR_BEGIN; side < DIAGDIR_END; side++) {
    const TileIndex adjacent_tile = AddTileIndexDiffCWrap(tile, TileIndexDiffCByDiagDir(side));
    if (adjacent_tile == INVALID_TILE) continue;
    if (GetWaterRegionIndex(adjacent_tile) != GetWaterRegionIndex(tile)) invalidate_region(adjacent_tile);
  }
}
void InvalidateWaterRegion(TileIndex tile) {…}
 
static inline void VisitAdjacentWaterRegionPatchNeighbours(const WaterRegionPatchDesc &water_region_patch, DiagDirection side, VisitWaterRegionPatchCallback &func)
{
  if (water_region_patch.label == INVALID_WATER_REGION_PATCH) return;
 
  const WaterRegion current_region = GetUpdatedWaterRegion(water_region_patch.x, water_region_patch.y);
 
  const TileIndexDiffC offset = TileIndexDiffCByDiagDir(side);
  const int nx = water_region_patch.x + offset.x;
  const int ny = water_region_patch.y + offset.y;
 
  if (nx < 0 || ny < 0 || nx >= GetWaterRegionMapSizeX() || ny >= GetWaterRegionMapSizeY()) return;
 
  const WaterRegion neighbouring_region = GetUpdatedWaterRegion(nx, ny);
  const DiagDirection opposite_side = ReverseDiagDir(side);
 
  /* Indicates via which local x or y coordinates (depends on the "side" parameter) we can cross over into the adjacent region. */
  const WaterRegionTraversabilityBits traversability_bits = current_region.GetEdgeTraversabilityBits(side)
    & neighbouring_region.GetEdgeTraversabilityBits(opposite_side);
  if (traversability_bits == 0) return;
 
  if (current_region.NumberOfPatches() == 1 && neighbouring_region.NumberOfPatches() == 1) {
    func(WaterRegionPatchDesc{ nx, ny, FIRST_REGION_LABEL }); // No further checks needed because we know there is just one patch for both adjacent regions
    return;
  }
 
  /* Multiple water patches can be reached from the current patch. Check each edge tile individually. */
  static std::vector<WaterRegionPatchLabel> unique_labels; // static and vector-instead-of-map for performance reasons
  unique_labels.clear();
  for (int x_or_y = 0; x_or_y < WATER_REGION_EDGE_LENGTH; ++x_or_y) {
    if (!HasBit(traversability_bits, x_or_y)) continue;
 
    const TileIndex current_edge_tile = GetEdgeTileCoordinate(water_region_patch.x, water_region_patch.y, side, x_or_y);
    const WaterRegionPatchLabel current_label = current_region.GetLabel(current_edge_tile);
    if (current_label != water_region_patch.label) continue;
 
    const TileIndex neighbour_edge_tile = GetEdgeTileCoordinate(nx, ny, opposite_side, x_or_y);
    const WaterRegionPatchLabel neighbour_label = neighbouring_region.GetLabel(neighbour_edge_tile);
    assert(neighbour_label != INVALID_WATER_REGION_PATCH);
    if (std::ranges::find(unique_labels, neighbour_label) == unique_labels.end()) unique_labels.push_back(neighbour_label);
  }
  for (WaterRegionPatchLabel unique_label : unique_labels) func(WaterRegionPatchDesc{ nx, ny, unique_label });
}
static inline void VisitAdjacentWaterRegionPatchNeighbours(const WaterRegionPatchDesc &water_region_patch, DiagDirection side, VisitWaterRegionPatchCallback &func) {…}
 
void VisitWaterRegionPatchNeighbours(const WaterRegionPatchDesc &water_region_patch, VisitWaterRegionPatchCallback &callback)
{
  if (water_region_patch.label == INVALID_WATER_REGION_PATCH) return;
 
  const WaterRegion current_region = GetUpdatedWaterRegion(water_region_patch.x, water_region_patch.y);
 
  /* Visit adjacent water region patches in each cardinal direction */
  for (DiagDirection side = DIAGDIR_BEGIN; side < DIAGDIR_END; side++) VisitAdjacentWaterRegionPatchNeighbours(water_region_patch, side, callback);
 
  /* Visit neighbouring water patches accessible via cross-region aqueducts */
  if (current_region.HasCrossRegionAqueducts()) {
    for (const TileIndex tile : current_region) {
      if (GetWaterRegionPatchInfo(tile) == water_region_patch && IsAqueductTile(tile)) {
        const TileIndex other_end_tile = GetOtherBridgeEnd(tile);
        if (GetWaterRegionIndex(tile) != GetWaterRegionIndex(other_end_tile)) callback(GetWaterRegionPatchInfo(other_end_tile));
      }
    }
  }
}
void VisitWaterRegionPatchNeighbours(const WaterRegionPatchDesc &water_region_patch, VisitWaterRegionPatchCallback &callback) {…}
 
void AllocateWaterRegions()
{
  const int number_of_regions = GetWaterRegionMapSizeX() * GetWaterRegionMapSizeY();
 
  _water_region_data.clear();
  _water_region_data.resize(number_of_regions);
 
  _is_water_region_valid.clear();
  _is_water_region_valid.resize(number_of_regions, false);
 
  Debug(map, 2, "Allocating {} x {} water regions", GetWaterRegionMapSizeX(), GetWaterRegionMapSizeY());
  assert(_is_water_region_valid.size() == _water_region_data.size());
}
void AllocateWaterRegions() {…}
 
void PrintWaterRegionDebugInfo(TileIndex tile)
{
  GetUpdatedWaterRegion(tile).PrintDebugInfo();
}