add_subdirectory(yapf)

add_files(

    follow_track.hpp

    pathfinder_func.h

    pathfinder_type.h

)

#include "../station_base.h"

#include "../train.h"

#include "../tunnelbridge.h"

#include "../tunnelbridge_map.h"

#include "../depot_map.h"

#include "pathfinder_func.h"

/**

 * Track follower helper template class (can serve pathfinders and vehicle

 *  controllers). See 6 different typedefs below for 3 different transport

 *  types w/ or w/o 90-deg turns allowed

 */

	DiagDirection       m_exitdir;       ///< exit direction (leaving the old tile)

	bool                m_is_tunnel;     ///< last turn passed tunnel

	bool                m_is_bridge;     ///< last turn passed bridge ramp

	bool                m_is_station;    ///< last turn passed station

	int                 m_tiles_skipped; ///< number of skipped tunnel or station tiles

	ErrorCode           m_err;

	RailTypes           m_railtypes;

	{

	}

	{

		assert(IsRailTT());

		m_veh = nullptr;

	}

	{

		assert(!IsRailTT() || (v != nullptr && v->type == VEH_TRAIN));

		m_veh = v;

	}

	{

		assert(!IsRoadTT() || m_veh != nullptr);

		assert(!IsRailTT() || railtype_override != INVALID_RAILTYPES);

		m_veh_owner = o;

		/* don't worry, all is inlined so compiler should remove unnecessary initializations */

		m_old_tile = INVALID_TILE;

		m_old_td = INVALID_TRACKDIR;

		m_new_tile = INVALID_TILE;

		m_new_td_bits = TRACKDIR_BIT_NONE;

		m_exitdir = INVALID_DIAGDIR;

		}

	}

	/** stores track status (available trackdirs) for the new tile into m_new_td_bits */

	inline bool QueryNewTileTrackStatus()

	{

		if (IsRailTT() && IsPlainRailTile(m_new_tile)) {

			m_new_td_bits = (TrackdirBits)(GetTrackBits(m_new_tile) * 0x101);

		} else if (IsRoadTT()) {

			m_new_td_bits = GetTrackdirBitsForRoad(m_new_tile, this->IsTram() ? RTT_TRAM : RTT_ROAD);

		} else {

			m_new_td_bits = TrackStatusToTrackdirBits(GetTileTrackStatus(m_new_tile, TT(), 0));

 * 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/>.

 */

/** @file npf.cpp Implementation of the NPF pathfinder. */

#include "../../stdafx.h"

#include "../../network/network.h"

#include "../../viewport_func.h"

#include "../../ship.h"

#include "../../roadstop_base.h"

#include "../../vehicle_func.h"

#include "../pathfinder_func.h"

#ifndef YAPF_HPP

#define YAPF_HPP

#include "../../landscape.h"

#include "../pathfinder_func.h"

#include "yapf.h"

#include "../../misc/fixedsizearray.hpp"

#include "../../misc/array.hpp"

#include "../../misc/hashtable.hpp"

#include "../../misc/binaryheap.hpp"

#ifndef YAPF_BASE_HPP

#define YAPF_BASE_HPP

#include "../../debug.h"

#include "../../settings_type.h"

/**

 * CYapfBaseT - A-star type path finder base class.

 *  Derive your own pathfinder from it. You must provide the following template argument:

 *    Types      - used as collection of local types used in pathfinder

 *

 * Requirements for the Types struct:

	const VehicleType   *m_veh;                ///< vehicle that we are trying to drive

	int                  m_stats_cost_calcs;   ///< stats - how many node's costs were calculated

	int                  m_stats_cache_hits;   ///< stats - how many node's costs were reused from cache

public:

	int                  m_num_steps;          ///< this is there for debugging purposes (hope it doesn't hurt)

public:

	/** default constructor */

	inline CYapfBaseT()

		: m_pBestDestNode(nullptr)

	 * @return true if the path was found

	 */

	inline bool FindPath(const VehicleType *v)

	{

		m_veh = v;

		Yapf().PfSetStartupNodes();

		bool bDestFound = true;

		for (;;) {

			m_num_steps++;

			Node *n = m_nodes.GetBestOpenNode();

				break;

			}

		}

		bDestFound &= (m_pBestDestNode != nullptr);

		return bDestFound;

	}

	/**

	 * If path was found return the best node that has reached the destination. Otherwise

	 *  return the best visited node (which was nearest to the destination).

		return *static_cast<Tpf *>(this);

	}

	inline static Cache& stGetGlobalCache()

	{

		static int last_rail_change_counter = 0;

		static Cache C;

		/* delete the cache sometimes... */

		if (last_rail_change_counter != Cache::s_rail_change_counter) {

			last_rail_change_counter = Cache::s_rail_change_counter;

			C.Flush();

		}

		return C;

		return *static_cast<Tpf *>(this);

	}

public:

	inline int SlopeCost(TileIndex tile, Trackdir td)

	{

		if (!stSlopeCost(tile, td)) return 0;

		return Yapf().PfGetSettings().rail_slope_penalty;

	}

	inline int CurveCost(Trackdir td1, Trackdir td2)

	{

	}

	int SignalCost(Node &n, TileIndex tile, Trackdir trackdir)

	{

		int cost = 0;

		/* if there is one-way signal in the opposite direction, then it is not our way */

		if (IsTileType(tile, MP_RAILWAY)) {

			bool has_signal_against = HasSignalOnTrackdir(tile, ReverseTrackdir(trackdir));

			bool has_signal_along = HasSignalOnTrackdir(tile, trackdir);

			if (has_signal_against && !has_signal_along && IsOnewaySignal(tile, TrackdirToTrack(trackdir))) {

				/* one-way signal in opposite direction */

				n.m_segment->m_end_segment_reason |= ESRB_DEAD_END;

	inline bool PfCalcCost(Node &n, const TrackFollower *tf)

	{

		assert(!n.flags_u.flags_s.m_targed_seen);

		assert(tf->m_new_tile == n.m_key.m_tile);

		assert((HasTrackdir(tf->m_new_td_bits, n.m_key.m_td)));

		/* Does the node have some parent node? */

		bool has_parent = (n.m_parent != nullptr);

		/* Do we already have a cached segment? */

		CachedData &segment = *n.m_segment;

		bool is_cached_segment = (segment.m_cost >= 0);

		/* the previous tile will be needed for transition cost calculations */

		TILE prev = !has_parent ? TILE() : TILE(n.m_parent->GetLastTile(), n.m_parent->GetLastTrackdir());

		EndSegmentReasonBits end_segment_reason = ESRB_NONE;

		if (!has_parent) {

			/* We will jump to the middle of the cost calculator assuming that segment cache is not used. */

			assert(!is_cached_segment);

			/* Skip the first transition cost calculation. */

			goto no_entry_cost;

			if (m_max_cost > 0 && (parent_cost + segment_entry_cost + segment_cost) > m_max_cost) {

				end_segment_reason |= ESRB_PATH_TOO_LONG;

			}

			/* Move to the next tile/trackdir. */

			tf = &tf_local;

			if (!tf_local.Follow(cur.tile, cur.td)) {

				assert(tf_local.m_err != TrackFollower::EC_NONE);

				/* Can't move to the next tile (EOL?). */

				if (tf_local.m_err == TrackFollower::EC_RAIL_ROAD_TYPE) {

					end_segment_reason |= ESRB_RAIL_TYPE;

	fwrite(dmp1.m_out.c_str(), 1, dmp1.m_out.size(), f1);

	fwrite(dmp2.m_out.c_str(), 1, dmp2.m_out.size(), f2);

	fclose(f1);

	fclose(f2);

}

template <class Types>

class CYapfReserveTrack

{

public:

	typedef typename Types::Tpf Tpf;                     ///< the pathfinder class (derived from THIS class)

	typedef typename Types::TrackFollower TrackFollower;