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

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

    34

			Trackdir td = (Trackdir)FindFirstBit2x64(tdb);

    35

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

    36

			n1.Set(NULL, m_orgTile, td);

    37

			Yapf().AddStartupNode(n1);

    38

		}

    39

	}

    40

};

    41

    42

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

    43

template <class Types>

    44

class CYapfOriginTileTwoWayT

    45

{

    46

public:

    47

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

    48

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

    49

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

    50

    51

protected:

    52

	TileIndex   m_orgTile;                        ///< first origin tile

    53

	Trackdir    m_orgTd;                          ///< first origin trackdir

    54

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

    55

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

    56

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

    57

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

    58

    59

	/// to access inherited path finder

    60

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

    61

    62

public:

    63

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

    64

	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)

    65

	{

    66

		m_orgTile = tile;

    67

		m_orgTd = td;

    68

		m_revTile = tiler;

    69

		m_revTd = tdr;

    70

		m_reverse_penalty = reverse_penalty;

    71

		m_treat_first_red_two_way_signal_as_eol = treat_first_red_two_way_signal_as_eol;

    72

	}

    73

    74

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

    75

	void PfSetStartupNodes()

    76

	{

    77

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

    78

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

    79

			n1.Set(NULL, m_orgTile, m_orgTd);

    80

			Yapf().AddStartupNode(n1);

    81

		}

    82

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

    83

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

    84

			n2.Set(NULL, m_revTile, m_revTd);

    85

			n2.m_cost = m_reverse_penalty;

    86

			Yapf().AddStartupNode(n2);

    87

		}

    88

	}

    89

    90

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

    91

	FORCEINLINE bool TreatFirstRedTwoWaySignalAsEOL()

    92

	{

    93

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

    94

	}

    95

};

    96

    97

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

    98

template <class Types>

    99

class CYapfDestinationTileT

   100

{

   101

public:

   102

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

   103

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

   104

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

   105

   106

protected:

   107

	TileIndex    m_destTile;                      ///< destination tile

   108

	TrackdirBits m_destTrackdirs;                 ///< destination trackdir mask

   109

   110

public:

   111

	/// set the destination tile / more trackdirs

   112

	void SetDestination(TileIndex tile, TrackdirBits trackdirs)

   113

	{

   114

		m_destTile = tile;

   115

		m_destTrackdirs = trackdirs;

   116

	}

   117

   118

protected:

   119

	/// to access inherited path finder

   120

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

   121

   122

public:

   123

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

   124

	FORCEINLINE bool PfDetectDestination(Node& n)

   125

	{

   126

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

   127

		return bDest;

   128

	}

   129

   130

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

   131

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

   132

	inline bool PfCalcEstimate(Node& n)

   133

	{

   134

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

   135

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

   136

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

   137

		int dd = min(dx, dy);

   138

		int dxy = abs(dx - dy);

   139

		int d = 14 * dd + 10 * dxy;

   140

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

   141

		return true;

   142

	}

   143

};

   144

   145

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

   146

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

   147

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

   148

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

   149

template <class Ttypes>

   150

class CYapfT

   151

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

   152

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

   153

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

   154

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

   155

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

   156

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

   157

{

   158

};

   159

   160

   161

   162

#endif /* YAPF_COMMON_HPP */