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_org_tile;                        ///< first origin tile

    54

	TrackdirBits m_org_td_bits;                    ///< first origin trackdirbits

    55

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

    56

	TrackdirBits m_rev_td_bits;                   ///< 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, TrackdirBits td_bits, TileIndex tiler = INVALID_TILE, TrackdirBits tdr_bits = INVALID_TRACKDIR_BIT, int reverse_penalty = 0, bool treat_first_red_two_way_signal_as_eol = true)

    66

	{

    67

		m_org_tile = tile;

    68

		m_org_td_bits = td_bits;

    69

		m_rev_tile = tiler;

    70

		m_rev_td_bits = tdr_bits;

    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_org_tile != INVALID_TILE && m_org_td_bits != INVALID_TRACKDIR_BIT) {

    79

			for (TrackdirBits td_bits = m_org_td_bits; td_bits != TRACKDIR_BIT_NONE; td_bits = (TrackdirBits)KillFirstBit2x64(td_bits)) {

    80

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

    81

				Trackdir td = (Trackdir)FindFirstBit2x64(td_bits);

    82

				n.Set(NULL, m_org_tile, td, false);

    83

				Yapf().AddStartupNode(n);

    84

			}

    85

		}

    86

		if (m_rev_tile != INVALID_TILE && m_rev_td_bits != INVALID_TRACKDIR_BIT) {

    87

			for (TrackdirBits td_bits = m_rev_td_bits; td_bits != TRACKDIR_BIT_NONE; td_bits = (TrackdirBits)KillFirstBit2x64(td_bits)) {

    88

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

    89

				Trackdir td = (Trackdir)FindFirstBit2x64(td_bits);

    90

				n.Set(NULL, m_rev_tile, td, false);

    91

				n.m_cost = m_reverse_penalty;

    92

				Yapf().AddStartupNode(n);

    93

			}

    94

		}

    95

	}

    96

    97

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

    98

	FORCEINLINE bool TreatFirstRedTwoWaySignalAsEOL()

    99

	{

   100

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

   101

	}

   102

};

   103

   104

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

   105

template <class Types>

   106

class CYapfDestinationTileT

   107

{

   108

public:

   109

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

   110

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

   111

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

   112

   113

protected:

   114

	TileIndex    m_destTile;                      ///< destination tile

   115

	TrackdirBits m_destTrackdirs;                 ///< destination trackdir mask

   116

   117

public:

   118

	/// set the destination tile / more trackdirs

   119

	void SetDestination(TileIndex tile, TrackdirBits trackdirs)

   120

	{

   121

		m_destTile = tile;

   122

		m_destTrackdirs = trackdirs;

   123

	}

   124

   125

protected:

   126

	/// to access inherited path finder

   127

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

   128

   129

public:

   130

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

   131

	FORCEINLINE bool PfDetectDestination(Node& n)

   132

	{

   133

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

   134

		return bDest;

   135

	}

   136

   137

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

   138

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

   139

	inline bool PfCalcEstimate(Node& n)

   140

	{

   143

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

   144

		int dd = min(dx, dy);

   145

		int dxy = abs(dx - dy);

   146

		int d = 14 * dd + 10 * dxy;

   147

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

   148

		return true;

   149

	}

   150

};

   151

   152

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

   153

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

   154

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

   155

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

   156

template <class Ttypes>

   157

class CYapfT

   158

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

   159

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

   160

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

   161

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

   162

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

   163

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

   164

{

   165

};

   166

   167

   168

   169

#endif /* YAPF_COMMON_HPP */