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

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

    39

	}

    40

    41

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

    42

	FORCEINLINE bool PfDetectDestination(TileIndex tile, Trackdir td)

    43

	{

    44

		bool bDest = IsTileDepotType(tile, TRANSPORT_RAIL);

    45

		return bDest;

    46

	}

    47

    48

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

    49

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

    50

	FORCEINLINE bool PfCalcEstimate(Node& n)

    51

	{

    52

		n.m_estimate = n.m_cost;

    53

		return true;

    54

	}

    55

};

    56

    57

template <class Types>

    58

class CYapfDestinationTileOrStationRailT

    59

	: public CYapfDestinationRailBase

    60

{

    61

public:

    62

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

    63

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

    64

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

    65

    66

protected:

    67

	TileIndex    m_destTile;

    68

	TrackdirBits m_destTrackdirs;

    69

	StationID    m_dest_station_id;

    70

    71

	/// to access inherited path finder

    72

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

    73

    74

	static TileIndex CalcStationCenterTile(StationID station)

    75

	{

    76

		const Station* st = GetStation(station);

    77

    78

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

    79

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

    80

		// return the tile of our target coordinates

    81

		return TileXY(x, y);

    82

	}

    83

    84

public:

    85

	void SetDestination(Vehicle* v)

    86

	{

    87

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

    88

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

    89

			m_dest_station_id = v->current_order.station;

    90

			m_destTrackdirs = INVALID_TRACKDIR_BIT;

    91

		} else {

    92

			m_destTile = v->dest_tile;

    93

			m_dest_station_id = INVALID_STATION;

    94

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

    95

		}

    96

		CYapfDestinationRailBase::SetDestination(v);

    97

	}

    98

    99

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

   100

	FORCEINLINE bool PfDetectDestination(Node& n)

   101

	{

   102

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

   103

	}

   104

   105

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

   106

	FORCEINLINE bool PfDetectDestination(TileIndex tile, Trackdir td)

   107

	{

   108

		bool bDest;

   109

		if (m_dest_station_id != INVALID_STATION) {

   110

			bDest = IsRailwayStationTile(tile)

   111

				&& (GetStationIndex(tile) == m_dest_station_id)

   112

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

   113

		} else {

   114

			bDest = (tile == m_destTile)

   115

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

   116

		}

   117

		return bDest;

   118

	}

   119

   120

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

   121

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

   122

	FORCEINLINE bool PfCalcEstimate(Node& n)

   123

	{

   124

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

   125

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

   126

		if (PfDetectDestination(n)) {

   127

			n.m_estimate = n.m_cost;

   128

			return true;

   129

		}

   130

   131

		TileIndex tile = n.GetLastTile();

   132

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

   133

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

   134

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

   135

		int x2 = 2 * TileX(m_destTile);

   136

		int y2 = 2 * TileY(m_destTile);

   137

		int dx = abs(x1 - x2);

   138

		int dy = abs(y1 - y2);

   139

		int dmin = min(dx, dy);

   140

		int dxy = abs(dx - dy);

   141

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

   142

		n.m_estimate = n.m_cost + d;

   143

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

   144

		return true;

   145

	}

   146

};

   147

   148

   149

#endif /* YAPF_DESTRAIL_HPP */