1

/* $Id$ */

     2

     3

/** @file yapf_destrail.hpp */

     4

     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

	{

   110

		}

   111

		CYapfDestinationRailBase::SetDestination(v);

   112

	}

   113

   114

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

   115

	FORCEINLINE bool PfDetectDestination(Node& n)

   116

	{

   117

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

   118

	}

   119

   120

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

   121

	FORCEINLINE bool PfDetectDestination(TileIndex tile, Trackdir td)

   122

	{

   123

		bool bDest;

   124

		if (m_dest_station_id != INVALID_STATION) {

   125

			bDest = IsRailwayStationTile(tile)

   126

				&& (GetStationIndex(tile) == m_dest_station_id)

   127

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

   128

		} else {

   129

			bDest = (tile == m_destTile)

   130

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

   131

		}

   132

		return bDest;

   133

	}

   134

   135

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

   136

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

   137

	FORCEINLINE bool PfCalcEstimate(Node& n)

   138

	{

   139

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

   140

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

   141

		if (PfDetectDestination(n)) {

   142

			n.m_estimate = n.m_cost;

   143

			return true;

   144

		}

   145

   146

		TileIndex tile = n.GetLastTile();

   147

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

   148

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

   149

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

   150

		int x2 = 2 * TileX(m_destTile);

   151

		int y2 = 2 * TileY(m_destTile);

   152

		int dx = abs(x1 - x2);

   153

		int dy = abs(y1 - y2);

   154

		int dmin = min(dx, dy);

   155

		int dxy = abs(dx - dy);

   156

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

   157

		n.m_estimate = n.m_cost + d;

   158

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

   159

		return true;

   160

	}

   161

};

   162

   163

   164

#endif /* YAPF_DESTRAIL_HPP */