1

/* $Id$ */

     2

     3

#ifndef  YAPF_COMMON_HPP

     4

#define  YAPF_COMMON_HPP

     5

     6

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

     7

template <class Types>

     8

class CYapfOriginTileT

     9

{

    10

public:

    11

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

    12

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

    13

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

    14

    15

protected:

    16

	TileIndex    m_orgTile;                       ///< origin tile

    17

	TrackdirBits m_orgTrackdirs;                  ///< origin trackdir mask

    18

    19

	/// to access inherited path finder

    20

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

    21

    22

public:

    23

	/// Set origin tile / trackdir mask

    24

	void SetOrigin(TileIndex tile, TrackdirBits trackdirs)

    25

	{

    26

		m_orgTile = tile;

    27

		m_orgTrackdirs = trackdirs;

    28

	}

    29

    30

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

    31

	void PfSetStartupNodes()

    32

	{

    33

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

    34

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

    35

			Trackdir td = (Trackdir)FindFirstBit2x64(tdb);

    36

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

    37

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

    38

			Yapf().AddStartupNode(n1);

    39

		}

    40

	}

    41

};

    42

    43

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

    44

template <class Types>

    45

class CYapfOriginTileTwoWayT

    46

{

    47

public:

    48

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

    49

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

    50

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

    51

    52

protected:

    53

	TileIndex   m_orgTile;                        ///< first origin tile

    54

	Trackdir    m_orgTd;                          ///< first origin trackdir

    55

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

    56

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

    57

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

    58

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

    59

    60

	/// to access inherited path finder

    61

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

    62

    63

public:

    64

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

    65

	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)

    66

	{

    67

		m_orgTile = tile;

    68

		m_orgTd = td;

    69

		m_revTile = tiler;

    70

		m_revTd = tdr;

    71

		m_reverse_penalty = reverse_penalty;

    72

		m_treat_first_red_two_way_signal_as_eol = treat_first_red_two_way_signal_as_eol;

    73

	}

    74

    75

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

    76

	void PfSetStartupNodes()

    77

	{

    78

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

    79

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

    80

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

    81

			Yapf().AddStartupNode(n1);

    82

		}

    83

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

    84

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

    85

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

    86

			n2.m_cost = m_reverse_penalty;

    87

			Yapf().AddStartupNode(n2);

    88

		}

    89

	}

    90

    91

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

    92

	FORCEINLINE bool TreatFirstRedTwoWaySignalAsEOL()

    93

	{

    94

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

    95

	}

    96

};

    97

    98

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

    99

template <class Types>

   100

class CYapfDestinationTileT

   101

{

   102

public:

   103

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

   104

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

   105

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

   106

   107

protected:

   108

	TileIndex    m_destTile;                      ///< destination tile

   109

	TrackdirBits m_destTrackdirs;                 ///< destination trackdir mask

   110

   111

public:

   112

	/// set the destination tile / more trackdirs

   113

	void SetDestination(TileIndex tile, TrackdirBits trackdirs)

   114

	{

   115

		m_destTile = tile;

   116

		m_destTrackdirs = trackdirs;

   117

	}

   118

   119

protected:

   120

	/// to access inherited path finder

   121

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

   122

   123

public:

   124

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

   125

	FORCEINLINE bool PfDetectDestination(Node& n)

   126

	{

   127

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

   128

		return bDest;

   129

	}

   130

   131

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

   132

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

   133

	inline bool PfCalcEstimate(Node& n)

   134

	{

   135

		int dx = abs(TileX(n.GetTile()) - TileX(m_destTile));

   136

		int dy = abs(TileY(n.GetTile()) - TileY(m_destTile));

   137

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

   138

		int dd = min(dx, dy);

   139

		int dxy = abs(dx - dy);

   140

		int d = 14 * dd + 10 * dxy;

   141

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

   142

		return true;

   143

	}

   144

};

   145

   146

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

   147

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

   148

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

   149

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

   150

template <class Ttypes>

   151

class CYapfT

   152

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

   153

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

   154

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

   155

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

   156

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

   157

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

   158

{

   159

};

   160

   161

   162

   163

#endif /* YAPF_COMMON_HPP */