yapf_ship_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 "../../ship.h"
 
#include "yapf.hpp"
#include "yapf_ship_regions.h"
#include "../water_regions.h"
 
#include "../../safeguards.h"
 
constexpr int DIRECT_NEIGHBOR_COST = 100;
constexpr int NODES_PER_REGION = 4;
constexpr int MAX_NUMBER_OF_NODES = 65536;
 
struct CYapfRegionPatchNodeKey {
  WaterRegionPatchDesc water_region_patch;
 
  inline void Set(const WaterRegionPatchDesc &water_region_patch)
  {
    this->water_region_patch = water_region_patch;
  }
 
  inline int CalcHash() const { return CalculateWaterRegionPatchHash(this->water_region_patch); }
  inline bool operator==(const CYapfRegionPatchNodeKey &other) const { return this->CalcHash() == other.CalcHash(); }
};
 
inline uint ManhattanDistance(const CYapfRegionPatchNodeKey &a, const CYapfRegionPatchNodeKey &b)
{
  return (std::abs(a.water_region_patch.x - b.water_region_patch.x) + std::abs(a.water_region_patch.y - b.water_region_patch.y)) * DIRECT_NEIGHBOR_COST;
}
 
template <class Tkey_>
struct CYapfRegionNodeT {
  typedef Tkey_ Key;
  typedef CYapfRegionNodeT<Tkey_> Node;
 
  Tkey_ key;
  Node *hash_next;
  Node *parent;
  int cost;
  int estimate;
 
  inline void Set(Node *parent, const WaterRegionPatchDesc &water_region_patch)
  {
    this->key.Set(water_region_patch);
    this->hash_next = nullptr;
    this->parent = parent;
    this->cost = 0;
    this->estimate = 0;
  }
 
  inline void Set(Node *parent, const Key &key)
  {
    this->Set(parent, key.water_region_patch);
  }
 
  DiagDirection GetDiagDirFromParent() const
  {
    if (!this->parent) return INVALID_DIAGDIR;
    const int dx = this->key.water_region_patch.x - this->parent->key.water_region_patch.x;
    const int dy = this->key.water_region_patch.y - this->parent->key.water_region_patch.y;
    if (dx > 0 && dy == 0) return DIAGDIR_SW;
    if (dx < 0 && dy == 0) return DIAGDIR_NE;
    if (dx == 0 && dy > 0) return DIAGDIR_SE;
    if (dx == 0 && dy < 0) return DIAGDIR_NW;
    return INVALID_DIAGDIR;
  }
 
  inline Node *GetHashNext() { return this->hash_next; }
  inline void SetHashNext(Node *pNext) { this->hash_next = pNext; }
  inline const Tkey_ &GetKey() const { return this->key; }
  inline int GetCost() { return this->cost; }
  inline int GetCostEstimate() { return this->estimate; }
  inline bool operator<(const Node &other) const { return this->estimate < other.estimate; }
};
 
template <class Types>
class CYapfOriginRegionT
{
public:
  typedef typename Types::Tpf Tpf;              
  typedef typename Types::NodeList::Titem Node; 
  typedef typename Node::Key Key;               
 
protected:
  inline Tpf &Yapf() { return *static_cast<Tpf*>(this); }
 
private:
  std::vector<CYapfRegionPatchNodeKey> origin_keys;
 
public:
  void AddOrigin(const WaterRegionPatchDesc &water_region_patch)
  {
    if (water_region_patch.label == INVALID_WATER_REGION_PATCH) return;
    if (!HasOrigin(water_region_patch)) this->origin_keys.push_back(CYapfRegionPatchNodeKey{ water_region_patch });
  }
 
  bool HasOrigin(const WaterRegionPatchDesc &water_region_patch)
  {
    return std::find(this->origin_keys.begin(), this->origin_keys.end(), CYapfRegionPatchNodeKey{ water_region_patch }) != this->origin_keys.end();
  }
 
  void PfSetStartupNodes()
  {
    for (const CYapfRegionPatchNodeKey &origin_key : this->origin_keys) {
      Node &node = Yapf().CreateNewNode();
      node.Set(nullptr, origin_key);
      Yapf().AddStartupNode(node);
    }
  }
};
 
template <class Types>
class CYapfDestinationRegionT
{
public:
  typedef typename Types::Tpf Tpf;              
  typedef typename Types::NodeList::Titem Node; 
  typedef typename Node::Key Key;               
 
protected:
  Key dest;
 
public:
  void SetDestination(const WaterRegionPatchDesc &water_region_patch)
  {
    this->dest.Set(water_region_patch);
  }
 
protected:
  Tpf &Yapf() { return *static_cast<Tpf*>(this); }
 
public:
  inline bool PfDetectDestination(Node &n) const
  {
    return n.key == this->dest;
  }
 
  inline bool PfCalcEstimate(Node &n)
  {
    if (this->PfDetectDestination(n)) {
      n.estimate = n.cost;
      return true;
    }
 
    n.estimate = n.cost + ManhattanDistance(n.key, this->dest);
 
    return true;
  }
};
 
template <class Types>
class CYapfFollowRegionT
{
public:
  typedef typename Types::Tpf Tpf;                     
  typedef typename Types::TrackFollower TrackFollower;
  typedef typename Types::NodeList::Titem Node;        
  typedef typename Node::Key Key;                      
 
protected:
  inline Tpf &Yapf() { return *static_cast<Tpf*>(this); }
 
public:
  inline void PfFollowNode(Node &old_node)
  {
    TVisitWaterRegionPatchCallBack visitFunc = [&](const WaterRegionPatchDesc &water_region_patch)
    {
      Node &node = Yapf().CreateNewNode();
      node.Set(&old_node, water_region_patch);
      Yapf().AddNewNode(node, TrackFollower{});
    };
    VisitWaterRegionPatchNeighbors(old_node.key.water_region_patch, visitFunc);
  }
 
  inline char TransportTypeChar() const { return '^'; }
 
  static std::vector<WaterRegionPatchDesc> FindWaterRegionPath(const Ship *v, TileIndex start_tile, int max_returned_path_length)
  {
    const WaterRegionPatchDesc start_water_region_patch = GetWaterRegionPatchInfo(start_tile);
 
    /* We reserve 4 nodes (patches) per water region. The vast majority of water regions have 1 or 2 regions so this should be a pretty
     * safe limit. We cap the limit at 65536 which is at a region size of 16x16 is equivalent to one node per region for a 4096x4096 map. */
    Tpf pf(std::min(static_cast<int>(Map::Size() * NODES_PER_REGION) / WATER_REGION_NUMBER_OF_TILES, MAX_NUMBER_OF_NODES));
    pf.SetDestination(start_water_region_patch);
 
    if (v->current_order.IsType(OT_GOTO_STATION)) {
      DestinationID station_id = v->current_order.GetDestination();
      const BaseStation *station = BaseStation::Get(station_id);
      TileArea tile_area;
      station->GetTileArea(&tile_area, STATION_DOCK);
      for (const auto &tile : tile_area) {
        if (IsDockingTile(tile) && IsShipDestinationTile(tile, station_id)) {
          pf.AddOrigin(GetWaterRegionPatchInfo(tile));
        }
      }
    } else {
      TileIndex tile = v->dest_tile;
      pf.AddOrigin(GetWaterRegionPatchInfo(tile));
    }
 
    /* If origin and destination are the same we simply return that water patch. */
    std::vector<WaterRegionPatchDesc> path = { start_water_region_patch };
    path.reserve(max_returned_path_length);
    if (pf.HasOrigin(start_water_region_patch)) return path;
 
    /* Find best path. */
    if (!pf.FindPath(v)) return {}; // Path not found.
 
    Node *node = pf.GetBestNode();
    for (int i = 0; i < max_returned_path_length - 1; ++i) {
      if (node != nullptr) {
        node = node->parent;
        if (node != nullptr) path.push_back(node->key.water_region_patch);
      }
    }
 
    assert(!path.empty());
    return path;
  }
};
 
template <class Types>
class CYapfCostRegionT
{
public:
  typedef typename Types::Tpf Tpf;              
  typedef typename Types::TrackFollower TrackFollower;
  typedef typename Types::NodeList::Titem Node; 
  typedef typename Node::Key Key;               
 
protected:
  Tpf &Yapf() { return *static_cast<Tpf*>(this); }
 
public:
  inline bool PfCalcCost(Node &n, const TrackFollower *)
  {
    n.cost = n.parent->cost + ManhattanDistance(n.key, n.parent->key);
 
    /* Incentivise zigzagging by adding a slight penalty when the search continues in the same direction. */
    Node *grandparent = n.parent->parent;
    if (grandparent != nullptr) {
      const DiagDirDiff dir_diff = DiagDirDifference(n.parent->GetDiagDirFromParent(), n.GetDiagDirFromParent());
      if (dir_diff != DIAGDIRDIFF_90LEFT && dir_diff != DIAGDIRDIFF_90RIGHT) n.cost += 1;
    }
 
    return true;
  }
};
 
/* We don't need a follower but YAPF requires one. */
struct DummyFollower : public CFollowTrackWater {};
 
template <class Tpf_, class Tnode_list>
struct CYapfRegion_TypesT
{
  typedef CYapfRegion_TypesT<Tpf_, Tnode_list> Types;         
  typedef Tpf_                                 Tpf;           
  typedef DummyFollower                        TrackFollower; 
  typedef Tnode_list                           NodeList;
  typedef Ship                                 VehicleType;
 
  typedef CYapfBaseT<Types>                 PfBase;        
  typedef CYapfFollowRegionT<Types>         PfFollow;      
  typedef CYapfOriginRegionT<Types>         PfOrigin;      
  typedef CYapfDestinationRegionT<Types>    PfDestination; 
  typedef CYapfSegmentCostCacheNoneT<Types> PfCache;       
  typedef CYapfCostRegionT<Types>           PfCost;        
};
 
typedef CNodeList_HashTableT<CYapfRegionNodeT<CYapfRegionPatchNodeKey>, 12, 12> CRegionNodeListWater;
 
struct CYapfRegionWater : CYapfT<CYapfRegion_TypesT<CYapfRegionWater, CRegionNodeListWater>>
{
  explicit CYapfRegionWater(int max_nodes) { this->max_search_nodes = max_nodes; }
};
 
std::vector<WaterRegionPatchDesc> YapfShipFindWaterRegionPath(const Ship *v, TileIndex start_tile, int max_returned_path_length)
{
  return CYapfRegionWater::FindWaterRegionPath(v, start_tile, max_returned_path_length);
}