1

/* $Id$ */

     2

     5

#ifndef  YAPF_DESTRAIL_HPP

     6

#define  YAPF_DESTRAIL_HPP

     7

     8

class CYapfDestinationRailBase

     9

{

    10

protected:

    11

	RailTypeMask m_compatible_railtypes;

    12

    13

public:

    14

	void SetDestination(Vehicle* v)

    15

	{

    16

		m_compatible_railtypes = v->u.rail.compatible_railtypes;

    17

	}

    18

    19

	bool IsCompatibleRailType(RailType rt)

    20

	{

    21

		return HASBIT(m_compatible_railtypes, rt);

    22

	}

    23

};

    24

    25

template <class Types>

    26

class CYapfDestinationAnyDepotRailT

    27

	: public CYapfDestinationRailBase

    28

{

    29

public:

    30

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

    31

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

    32

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

    33

    34

	/// to access inherited path finder

    35

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

    36

    37

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

    38

	FORCEINLINE bool PfDetectDestination(Node& n)

    39

	{

    40

		return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());

    41

	}

    42

    43

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

    44

	FORCEINLINE bool PfDetectDestination(TileIndex tile, Trackdir td)

    45

	{

    46

		bool bDest = IsTileDepotType(tile, TRANSPORT_RAIL);

    47

		return bDest;

    48

	}

    49

    50

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

    51

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

    52

	FORCEINLINE bool PfCalcEstimate(Node& n)

    53

	{

    54

		n.m_estimate = n.m_cost;

    55

		return true;

    56

	}

    57

};

    58

    59

template <class Types>

    60

class CYapfDestinationTileOrStationRailT

    61

	: public CYapfDestinationRailBase

    62

{

    63

public:

    64

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

    65

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

    66

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

    67

    68

protected:

    69

	TileIndex    m_destTile;

    70

	TrackdirBits m_destTrackdirs;

    71

	StationID    m_dest_station_id;

    72

    73

	/// to access inherited path finder

    74

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

    75

    76

	static TileIndex CalcStationCenterTile(StationID station)

    77

	{

    78

		const Station* st = GetStation(station);

    79

    80

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

    81

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

    82

		// return the tile of our target coordinates

    83

		return TileXY(x, y);

    84

	}

    85

    86

public:

    87

	void SetDestination(Vehicle* v)

    88

	{

    89

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

    90

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

    91

			m_dest_station_id = v->current_order.dest;

    92

			m_destTrackdirs = INVALID_TRACKDIR_BIT;

    93

		} else {

    94

			m_destTile = v->dest_tile;

    95

			m_dest_station_id = INVALID_STATION;

    96

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

    97

		}

    98

		CYapfDestinationRailBase::SetDestination(v);

    99

	}

   100

   101

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

   102

	FORCEINLINE bool PfDetectDestination(Node& n)

   103

	{

   104

		return PfDetectDestination(n.GetLastTile(), n.GetLastTrackdir());

   105

	}

   106

   107

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

   108

	FORCEINLINE bool PfDetectDestination(TileIndex tile, Trackdir td)

   109

	{

   110

		bool bDest;

   111

		if (m_dest_station_id != INVALID_STATION) {

   112

			bDest = IsRailwayStationTile(tile)

   113

				&& (GetStationIndex(tile) == m_dest_station_id)

   114

				&& (GetRailStationTrack(tile) == TrackdirToTrack(td));

   115

		} else {

   116

			bDest = (tile == m_destTile)

   117

				&& ((m_destTrackdirs & TrackdirToTrackdirBits(td)) != TRACKDIR_BIT_NONE);

   118

		}

   119

		return bDest;

   120

	}

   121

   122

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

   123

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

   124

	FORCEINLINE bool PfCalcEstimate(Node& n)

   125

	{

   126

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

   127

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

   128

		if (PfDetectDestination(n)) {

   129

			n.m_estimate = n.m_cost;

   130

			return true;

   131

		}

   132

   133

		TileIndex tile = n.GetLastTile();

   134

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

   135

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

   136

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

   137

		int x2 = 2 * TileX(m_destTile);

   138

		int y2 = 2 * TileY(m_destTile);

   139

		int dx = abs(x1 - x2);

   140

		int dy = abs(y1 - y2);

   141

		int dmin = min(dx, dy);

   142

		int dxy = abs(dx - dy);

   143

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

   144

		n.m_estimate = n.m_cost + d;

   145

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

   146

		return true;

   147

	}

   148

};

   149

   150

   151

#endif /* YAPF_DESTRAIL_HPP */