src/pathfinder/yapf/yapf_destrail.hpp

   1 /*
   2  * This file is part of OpenTTD.
   3  * 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.
   4  * 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.
   5  * 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/>.
   6  */
   7
   8 /** @file yapf_destrail.hpp Determining the destination for rail vehicles. */
   9
  10 #ifndef YAPF_DESTRAIL_HPP
  11 #define YAPF_DESTRAIL_HPP
  12
  13 #include "../../train.h"
  14 #include "../pathfinder_func.h"
  15 #include "../pathfinder_type.h"
  16
  17 class CYapfDestinationRailBase {
  18 protected:
  19         RailTypes compatible_railtypes;
  20
  21 public:
  22         void SetDestination(const Train *v, bool override_rail_type = false)
  23         {
  24                 this->compatible_railtypes = v->compatible_railtypes;
  25                 if (override_rail_type) this->compatible_railtypes |= GetRailTypeInfo(v->railtype)->compatible_railtypes;
  26         }
  27
  28         bool IsCompatibleRailType(RailType rt)
  29         {
  30                 return HasBit(this->compatible_railtypes, rt);
  31         }
  32
  33         RailTypes GetCompatibleRailTypes() const
  34         {
  35                 return this->compatible_railtypes;
  36         }
  37 };
  38
  39 template <class Types>
  40 class CYapfDestinationAnyDepotRailT : public CYapfDestinationRailBase {
  41 public:
  42         typedef typename Types::Tpf Tpf; ///< the pathfinder class (derived from THIS class)
  43         typedef typename Types::NodeList::Item Node; ///< this will be our node type
  44         typedef typename Node::Key Key; ///< key to hash tables
  45
  46         /** to access inherited path finder */
  47         Tpf &Yapf()
  48         {
  49                 return *static_cast<Tpf *>(this);
  50         }
  51
  52         /** Called by YAPF to detect if node ends in the desired destination */
  53         inline bool PfDetectDestination(Node &n)
  54         {
  55                 return this->PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
  56         }
  57
  58         /** Called by YAPF to detect if node ends in the desired destination */
  59         inline bool PfDetectDestination(TileIndex tile, Trackdir)
  60         {
  61                 return IsRailDepotTile(tile);
  62         }
  63
  64         /**
  65          * Called by YAPF to calculate cost estimate. Calculates distance to the destination
  66          *  adds it to the actual cost from origin and stores the sum to the Node::estimate
  67          */
  68         inline bool PfCalcEstimate(Node &n)
  69         {
  70                 n.estimate = n.cost;
  71                 return true;
  72         }
  73 };
  74
  75 template <class Types>
  76 class CYapfDestinationAnySafeTileRailT : public CYapfDestinationRailBase {
  77 public:
  78         typedef typename Types::Tpf Tpf; ///< the pathfinder class (derived from THIS class)
  79         typedef typename Types::NodeList::Item Node; ///< this will be our node type
  80         typedef typename Node::Key Key; ///< key to hash tables
  81         typedef typename Types::TrackFollower TrackFollower; ///< TrackFollower. Need to typedef for gcc 2.95
  82
  83         /** to access inherited path finder */
  84         Tpf &Yapf()
  85         {
  86                 return *static_cast<Tpf *>(this);
  87         }
  88
  89         /** Called by YAPF to detect if node ends in the desired destination */
  90         inline bool PfDetectDestination(Node &n)
  91         {
  92                 return this->PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
  93         }
  94
  95         /** Called by YAPF to detect if node ends in the desired destination */
  96         inline bool PfDetectDestination(TileIndex tile, Trackdir td)
  97         {
  98                 return IsSafeWaitingPosition(Yapf().GetVehicle(), tile, td, true, !TrackFollower::Allow90degTurns()) &&
  99                                 IsWaitingPositionFree(Yapf().GetVehicle(), tile, td, !TrackFollower::Allow90degTurns());
 100         }
 101
 102         /**
 103          * Called by YAPF to calculate cost estimate. Calculates distance to the destination
 104          *  adds it to the actual cost from origin and stores the sum to the Node::estimate.
 105          */
 106         inline bool PfCalcEstimate(Node &n)
 107         {
 108                 n.estimate = n.cost;
 109                 return true;
 110         }
 111 };
 112
 113 template <class Types>
 114 class CYapfDestinationTileOrStationRailT : public CYapfDestinationRailBase {
 115 public:
 116         typedef typename Types::Tpf Tpf; ///< the pathfinder class (derived from THIS class)
 117         typedef typename Types::NodeList::Item Node; ///< this will be our node type
 118         typedef typename Node::Key Key; ///< key to hash tables
 119
 120 protected:
 121         TileIndex dest_tile;
 122         TrackdirBits dest_trackdirs;
 123         StationID dest_station_id;
 124         bool any_depot;
 125
 126         /** to access inherited path finder */
 127         Tpf &Yapf()
 128         {
 129                 return *static_cast<Tpf *>(this);
 130         }
 131
 132 public:
 133         void SetDestination(const Train *v)
 134         {
 135                 this->any_depot = false;
 136                 switch (v->current_order.GetType()) {
 137                         case OT_GOTO_WAYPOINT:
 138                                 if (!Waypoint::Get(v->current_order.GetDestination())->IsSingleTile()) {
 139                                         /* In case of 'complex' waypoints we need to do a look
 140                                          * ahead. This look ahead messes a bit about, which
 141                                          * means that it 'corrupts' the cache. To prevent this
 142                                          * we disable caching when we're looking for a complex
 143                                          * waypoint. */
 144                                         Yapf().DisableCache(true);
 145                                 }
 146                                 [[fallthrough]];
 147
 148                         case OT_GOTO_STATION:
 149                                 this->dest_tile = CalcClosestStationTile(v->current_order.GetDestination(), v->tile, v->current_order.IsType(OT_GOTO_STATION) ? STATION_RAIL : STATION_WAYPOINT);
 150                                 this->dest_station_id = v->current_order.GetDestination();
 151                                 this->dest_trackdirs = INVALID_TRACKDIR_BIT;
 152                                 break;
 153
 154                         case OT_GOTO_DEPOT:
 155                                 if (v->current_order.GetDepotActionType() & ODATFB_NEAREST_DEPOT) {
 156                                         this->any_depot = true;
 157                                 }
 158                                 [[fallthrough]];
 159
 160                         default:
 161                                 this->dest_tile = v->dest_tile;
 162                                 this->dest_station_id = INVALID_STATION;
 163                                 this->dest_trackdirs = TrackStatusToTrackdirBits(GetTileTrackStatus(v->dest_tile, TRANSPORT_RAIL, 0));
 164                                 break;
 165                 }
 166                 this->CYapfDestinationRailBase::SetDestination(v);
 167         }
 168
 169         /** Called by YAPF to detect if node ends in the desired destination */
 170         inline bool PfDetectDestination(Node &n)
 171         {
 172                 return this->PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());
 173         }
 174
 175         /** Called by YAPF to detect if node ends in the desired destination */
 176         inline bool PfDetectDestination(TileIndex tile, Trackdir td)
 177         {
 178                 if (this->dest_station_id != INVALID_STATION) {
 179                         return HasStationTileRail(tile)
 180                                 && (GetStationIndex(tile) == this->dest_station_id)
 181                                 && (GetRailStationTrack(tile) == TrackdirToTrack(td));
 182                 }
 183
 184                 if (this->any_depot) {
 185                         return IsRailDepotTile(tile);
 186                 }
 187
 188                 return (tile == this->dest_tile) && HasTrackdir(this->dest_trackdirs, td);
 189         }
 190
 191         /**
 192          * Called by YAPF to calculate cost estimate. Calculates distance to the destination
 193          *  adds it to the actual cost from origin and stores the sum to the Node::estimate
 194          */
 195         inline bool PfCalcEstimate(Node &n)
 196         {
 197                 static const int dg_dir_to_x_offs[] = {-1, 0, 1, 0};
 198                 static const int dg_dir_to_y_offs[] = {0, 1, 0, -1};
 199                 if (this->PfDetectDestination(n)) {
 200                         n.estimate = n.cost;
 201                         return true;
 202                 }
 203
 204                 TileIndex tile = n.GetLastTile();
 205                 DiagDirection exitdir = TrackdirToExitdir(n.GetLastTrackdir());
 206                 int x1 = 2 * TileX(tile) + dg_dir_to_x_offs[(int)exitdir];
 207                 int y1 = 2 * TileY(tile) + dg_dir_to_y_offs[(int)exitdir];
 208                 int x2 = 2 * TileX(this->dest_tile);
 209                 int y2 = 2 * TileY(this->dest_tile);
 210                 int dx = abs(x1 - x2);
 211                 int dy = abs(y1 - y2);
 212                 int dmin = std::min(dx, dy);
 213                 int dxy = abs(dx - dy);
 214                 int d = dmin * YAPF_TILE_CORNER_LENGTH + (dxy - 1) * (YAPF_TILE_LENGTH / 2);
 215                 n.estimate = n.cost + d;
 216                 assert(n.estimate >= n.parent->estimate);
 217                 return true;
 218         }
 219 };
 220
 221 #endif /* YAPF_DESTRAIL_HPP */