1

/* $Id$ */

     2

     3

/** @file yapf_common.hpp */

     4

     5

#ifndef  YAPF_COMMON_HPP

     6

#define  YAPF_COMMON_HPP

     7

     8

/** YAPF origin provider base class - used when origin is one tile / multiple trackdirs */

     9

template <class Types>

    10

class CYapfOriginTileT

    11

{

    12

public:

    13

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

    14

	typedef typename Types::NodeList::Titem Node; ///< this will be our node type

    15

	typedef typename Node::Key Key;               ///< key to hash tables

    16

    17

protected:

    18

	TileIndex    m_orgTile;                       ///< origin tile

    19

	TrackdirBits m_orgTrackdirs;                  ///< origin trackdir mask

    20

    21

	/// to access inherited path finder

    22

	FORCEINLINE Tpf& Yapf() {return *static_cast<Tpf*>(this);}

    23

    24

public:

    25

	/// Set origin tile / trackdir mask

    26

	void SetOrigin(TileIndex tile, TrackdirBits trackdirs)

    27

	{

    28

		m_orgTile = tile;

    29

		m_orgTrackdirs = trackdirs;

    30

	}

    31

    32

	/// Called when YAPF needs to place origin nodes into open list

    33

	void PfSetStartupNodes()

    34

	{

    35

		bool is_choice = (KillFirstBit2x64(m_orgTrackdirs) != 0);

    36

		for (TrackdirBits tdb = m_orgTrackdirs; tdb != TRACKDIR_BIT_NONE; tdb = (TrackdirBits)KillFirstBit2x64(tdb)) {

    37

			Trackdir td = (Trackdir)FindFirstBit2x64(tdb);

    38

			Node& n1 = Yapf().CreateNewNode();

    39

			n1.Set(NULL, m_orgTile, td, is_choice);

    40

			Yapf().AddStartupNode(n1);

    41

		}

    42

	}

    43

};

    44

    45

/** YAPF origin provider base class - used when there are two tile/trackdir origins */

    46

template <class Types>

    47

class CYapfOriginTileTwoWayT

    48

{

    49

public:

    50

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

    51

	typedef typename Types::NodeList::Titem Node; ///< this will be our node type

    52

	typedef typename Node::Key Key;               ///< key to hash tables

    53

    54

protected:

    55

	TileIndex   m_orgTile;                        ///< first origin tile

    56

	Trackdir    m_orgTd;                          ///< first origin trackdir

    57

	TileIndex   m_revTile;                        ///< second (reversed) origin tile

    58

	Trackdir    m_revTd;                          ///< second (reversed) origin trackdir

    59

	int         m_reverse_penalty;                ///< penalty to be added for using the reversed origin

    60

	bool        m_treat_first_red_two_way_signal_as_eol; ///< in some cases (leaving station) we need to handle first two-way signal differently

    61

    62

	/// to access inherited path finder

    63

	FORCEINLINE Tpf& Yapf() {return *static_cast<Tpf*>(this);}

    64

    65

public:

    66

	/// set origin (tiles, trackdirs, etc.)

    67

	void SetOrigin(TileIndex tile, Trackdir td, TileIndex tiler = INVALID_TILE, Trackdir tdr = INVALID_TRACKDIR, int reverse_penalty = 0, bool treat_first_red_two_way_signal_as_eol = true)

    68

	{

    69

		m_orgTile = tile;

    70

		m_orgTd = td;

    71

		m_revTile = tiler;

    72

		m_revTd = tdr;

    73

		m_reverse_penalty = reverse_penalty;

    74

		m_treat_first_red_two_way_signal_as_eol = treat_first_red_two_way_signal_as_eol;

    75

	}

    76

    77

	/// Called when YAPF needs to place origin nodes into open list

    78

	void PfSetStartupNodes()

    79

	{

    80

		if (m_orgTile != INVALID_TILE && m_orgTd != INVALID_TRACKDIR) {

    81

			Node& n1 = Yapf().CreateNewNode();

    82

			n1.Set(NULL, m_orgTile, m_orgTd, false);

    83

			Yapf().AddStartupNode(n1);

    84

		}

    85

		if (m_revTile != INVALID_TILE && m_revTd != INVALID_TRACKDIR) {

    86

			Node& n2 = Yapf().CreateNewNode();

    87

			n2.Set(NULL, m_revTile, m_revTd, false);

    88

			n2.m_cost = m_reverse_penalty;

    89

			Yapf().AddStartupNode(n2);

    90

		}

    91

	}

    92

    93

	/// return true if first two-way signal should be treated as dead end

    94

	FORCEINLINE bool TreatFirstRedTwoWaySignalAsEOL()

    95

	{

    96

		return Yapf().PfGetSettings().rail_firstred_twoway_eol && m_treat_first_red_two_way_signal_as_eol;

    97

	}

    98

};

    99

   100

/** YAPF destination provider base class - used when destination is single tile / multiple trackdirs */

   101

template <class Types>

   102

class CYapfDestinationTileT

   103

{

   104

public:

   105

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

   106

	typedef typename Types::NodeList::Titem Node; ///< this will be our node type

   107

	typedef typename Node::Key Key;               ///< key to hash tables

   108

   109

protected:

   110

	TileIndex    m_destTile;                      ///< destination tile

   111

	TrackdirBits m_destTrackdirs;                 ///< destination trackdir mask

   112

   113

public:

   114

	/// set the destination tile / more trackdirs

   115

	void SetDestination(TileIndex tile, TrackdirBits trackdirs)

   116

	{

   117

		m_destTile = tile;

   118

		m_destTrackdirs = trackdirs;

   119

	}

   120

   121

protected:

   122

	/// to access inherited path finder

   123

	Tpf& Yapf() {return *static_cast<Tpf*>(this);}

   124

   125

public:

   126

	/// Called by YAPF to detect if node ends in the desired destination

   127

	FORCEINLINE bool PfDetectDestination(Node& n)

   128

	{

   129

		bool bDest = (n.m_key.m_tile == m_destTile) && ((m_destTrackdirs & TrackdirToTrackdirBits(n.GetTrackdir())) != TRACKDIR_BIT_NONE);

   130

		return bDest;

   131

	}

   132

   133

	/** Called by YAPF to calculate cost estimate. Calculates distance to the destination

   134

	 *  adds it to the actual cost from origin and stores the sum to the Node::m_estimate */

   135

	inline bool PfCalcEstimate(Node& n)

   136

	{

   137

		int dx = delta(TileX(n.GetTile()), TileX(m_destTile));

   138

		int dy = delta(TileY(n.GetTile()), TileY(m_destTile));

   139

		assert(dx >= 0 && dy >= 0);

   140

		int dd = min(dx, dy);

   141

		int dxy = abs(dx - dy);

   142

		int d = 14 * dd + 10 * dxy;

   143

		n.m_estimate = n.m_cost + d /*+ d / 8*/;

   144

		return true;

   145

	}

   146

};

   147

   148

/** YAPF template that uses Ttypes template argument to determine all YAPF

   149

 *  components (base classes) from which the actual YAPF is composed.

   150

 *  For example classes consult: CYapfRail_TypesT template and its instantiations:

   151

 *  CYapfRail1, CYapfRail2, CYapfRail3, CYapfAnyDepotRail1, CYapfAnyDepotRail2, CYapfAnyDepotRail3 */

   152

template <class Ttypes>

   153

class CYapfT

   154

	: public Ttypes::PfBase         ///< Instance of CYapfBaseT - main YAPF loop and support base class

   155

	, public Ttypes::PfCost         ///< Cost calculation provider base class

   156

	, public Ttypes::PfCache        ///< Segment cost cache provider

   157

	, public Ttypes::PfOrigin       ///< Origin (tile or two-tile origin)

   158

	, public Ttypes::PfDestination  ///< Destination detector and distance (estimate) calculation provider

   159

	, public Ttypes::PfFollow       ///< Node follower (stepping provider)

   160

{

   161

};

   162

   163

   164

   165

#endif /* YAPF_COMMON_HPP */