1

/* $Id$ */

     2

     3

#ifndef  YAPF_DESTRAIL_HPP

     4

#define  YAPF_DESTRAIL_HPP

     5

     6

class CYapfDestinationRailBase

     7

{

     8

protected:

     9

	RailTypeMask m_compatible_railtypes;

    10

    11

public:

    12

	void SetDestination(Vehicle* v)

    13

	{

    14

		m_compatible_railtypes = v->u.rail.compatible_railtypes;

    15

	}

    16

    17

	bool IsCompatibleRailType(RailType rt)

    18

	{

    19

		return HASBIT(m_compatible_railtypes, rt);

    20

	}

    21

};

    22

    23

template <class Types>

    24

class CYapfDestinationAnyDepotRailT

    25

	: public CYapfDestinationRailBase

    26

{

    27

public:

    28

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

    29

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

    30

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

    31

    32

	/// to access inherited path finder

    33

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

    34

    35

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

    36

	FORCEINLINE bool PfDetectDestination(Node& n)

    37

	{

    38

		bool bDest = IsTileDepotType(n.GetLastTile(), TRANSPORT_RAIL);

    39

		return bDest;

    40

	}

    41

    42

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

    43

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

    44

	FORCEINLINE bool PfCalcEstimate(Node& n)

    45

	{

    46

		n.m_estimate = n.m_cost;

    47

		return true;

    48

	}

    49

};

    50

    51

template <class Types>

    52

class CYapfDestinationTileOrStationRailT

    53

	: public CYapfDestinationRailBase

    54

{

    55

public:

    56

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

    57

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

    58

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

    59

    60

protected:

    61

	TileIndex    m_destTile;

    62

	TrackdirBits m_destTrackdirs;

    63

	StationID    m_dest_station_id;

    64

    65

	/// to access inherited path finder

    66

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

    67

    68

	static TileIndex CalcStationCenterTile(StationID station)

    69

	{

    70

		const Station* st = GetStation(station);

    71

    72

		uint x = TileX(st->train_tile) + st->trainst_w / 2;

    73

		uint y = TileY(st->train_tile) + st->trainst_h / 2;

    74

		// return the tile of our target coordinates

    75

		return TileXY(x, y);

    76

	}

    77

    78

public:

    79

	void SetDestination(Vehicle* v)

    80

	{

    81

		if (v->current_order.type == OT_GOTO_STATION) {

    82

			m_destTile = CalcStationCenterTile(v->current_order.station);

    83

			m_dest_station_id = v->current_order.station;

    84

			m_destTrackdirs = INVALID_TRACKDIR_BIT;

    85

		} else {

    86

			m_destTile = v->dest_tile;

    87

			m_dest_station_id = INVALID_STATION;

    88

			m_destTrackdirs = (TrackdirBits)(GetTileTrackStatus(v->dest_tile, TRANSPORT_RAIL) & TRACKDIR_BIT_MASK);

    89

		}

    90

		CYapfDestinationRailBase::SetDestination(v);

    91

	}

    92

    93

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

    94

	FORCEINLINE bool PfDetectDestination(Node& n)

    95

	{

    96

		bool bDest;

    97

		if (m_dest_station_id != INVALID_STATION) {

    98

			bDest = IsRailwayStationTile(n.GetLastTile())

    99

				&& (GetStationIndex(n.GetLastTile()) == m_dest_station_id)

   100

				&& (GetRailStationTrack(n.GetLastTile()) == TrackdirToTrack(n.GetLastTrackdir()));

   101

		} else {

   102

			bDest = (n.GetLastTile() == m_destTile)

   103

				&& ((m_destTrackdirs & TrackdirToTrackdirBits(n.GetLastTrackdir())) != TRACKDIR_BIT_NONE);

   104

		}

   105

		return bDest;

   106

	}

   107

   108

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

   109

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

   110

	FORCEINLINE bool PfCalcEstimate(Node& n)

   111

	{

   112

		static int dg_dir_to_x_offs[] = {-1, 0, 1, 0};

   113

		static int dg_dir_to_y_offs[] = {0, 1, 0, -1};

   114

		if (PfDetectDestination(n)) {

   115

			n.m_estimate = n.m_cost;

   116

			return true;

   117

		}

   118

   119

		TileIndex tile = n.GetLastTile();

   120

		DiagDirection exitdir = TrackdirToExitdir(n.GetLastTrackdir());

   121

		int x1 = 2 * TileX(tile) + dg_dir_to_x_offs[(int)exitdir];

   122

		int y1 = 2 * TileY(tile) + dg_dir_to_y_offs[(int)exitdir];

   123

		int x2 = 2 * TileX(m_destTile);

   124

		int y2 = 2 * TileY(m_destTile);

   125

		int dx = abs(x1 - x2);

   126

		int dy = abs(y1 - y2);

   127

		int dmin = min(dx, dy);

   128

		int dxy = abs(dx - dy);

   129

		int d = dmin * YAPF_TILE_CORNER_LENGTH + (dxy - 1) * (YAPF_TILE_LENGTH / 2);

   130

		n.m_estimate = n.m_cost + d;

   131

		assert(n.m_estimate >= n.m_parent->m_estimate);

   132

		return true;

   133

	}

   134

};

   135

   136

   137

#endif /* YAPF_DESTRAIL_HPP */