1

/* $Id$ */

     2

     3

#ifndef  YAPF_COMMON_HPP

     4

#define  YAPF_COMMON_HPP

     5

     6

     7

template <class Types>

     8

class CYapfOriginTileT

     9

{

    10

public:

    11

	typedef typename Types::Tpf Tpf;

    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;

    17

	TrackdirBits m_orgTrackdirs;

    18

    19

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

    20

    21

public:

    22

	void SetOrigin(TileIndex tile, TrackdirBits trackdirs)

    23

	{

    24

		m_orgTile = tile;

    25

		m_orgTrackdirs = trackdirs;

    26

	}

    27

    28

	void PfSetStartupNodes()

    29

	{

    30

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

    31

			Trackdir td = (Trackdir)FindFirstBit2x64(tdb);

    32

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

    33

			n1.Set(NULL, m_orgTile, td);

    34

			Yapf().AddStartupNode(n1);

    35

		}

    36

	}

    37

};

    38

    39

template <class Types>

    40

class CYapfOriginTileTwoWayT

    41

{

    42

public:

    43

	typedef typename Types::Tpf Tpf;

    44

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

    45

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

    46

    47

protected:

    48

	TileIndex   m_orgTile;

    49

	Trackdir    m_orgTd;

    50

	TileIndex   m_revTile;

    51

	Trackdir    m_revTd;

    52

	int         m_reverse_penalty;

    53

	bool        m_treat_first_red_two_way_signal_as_eol;

    54

    55

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

    56

    57

public:

    58

	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)

    59

	{

    60

		m_orgTile = tile;

    61

		m_orgTd = td;

    62

		m_revTile = tiler;

    63

		m_revTd = tdr;

    64

		m_reverse_penalty = reverse_penalty;

    65

		m_treat_first_red_two_way_signal_as_eol = treat_first_red_two_way_signal_as_eol;

    66

	}

    67

    68

	void PfSetStartupNodes()

    69

	{

    70

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

    71

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

    72

			n1.Set(NULL, m_orgTile, m_orgTd);

    73

			Yapf().AddStartupNode(n1);

    74

		}

    75

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

    76

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

    77

			n2.Set(NULL, m_revTile, m_revTd);

    78

			n2.m_cost = m_reverse_penalty;

    79

			Yapf().AddStartupNode(n2);

    80

		}

    81

	}

    82

    83

	FORCEINLINE bool TreatFirstRedTwoWaySignalAsEOL()

    84

	{

    85

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

    86

	}

    87

};

    88

    89

template <class Types>

    90

class CYapfDestinationTileT

    91

{

    92

public:

    93

	typedef typename Types::Tpf Tpf;

    94

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

    95

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

    96

    97

protected:

    98

	TileIndex    m_destTile;

    99

	TrackdirBits m_destTrackdirs;

   100

   101

public:

   102

	void SetDestination(TileIndex tile, TrackdirBits trackdirs)

   103

	{

   104

		m_destTile = tile;

   105

		m_destTrackdirs = trackdirs;

   106

	}

   107

   108

protected:

   109

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

   110

   111

public:

   112

	FORCEINLINE bool PfDetectDestination(Node& n)

   113

	{

   114

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

   115

		return bDest;

   116

	}

   117

   118

	inline bool PfCalcEstimate(Node& n)

   119

	{

   120

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

   121

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

   122

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

   123

		int dd = min(dx, dy);

   124

		int dxy = abs(dx - dy);

   125

		int d = 14 * dd + 10 * dxy;

   126

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

   127

		return true;

   128

	}

   129

};

   130

   131

template <class Ttypes>

   132

class CYapfT

   133

	: public Ttypes::PfBase

   134

	, public Ttypes::PfCost

   135

	, public Ttypes::PfCache

   136

	, public Ttypes::PfOrigin

   137

	, public Ttypes::PfDestination

   138

	, public Ttypes::PfFollow

   139

{

   140

};

   141

   142

   143

   144

#endif /* YAPF_COMMON_HPP */