1

/* $Id$ */

     2

     3

/** @file yapf_destrail.hpp Determining the destination for rail vehicles. */

     4

     5

#ifndef  YAPF_DESTRAIL_HPP

     6

#define  YAPF_DESTRAIL_HPP

     7

     8

class CYapfDestinationRailBase

     9

{

    10

protected:

    11

	RailTypes m_compatible_railtypes;

    12

    13

public:

    14

	void SetDestination(const Vehicle *v, bool override_rail_type = false)

    15

	{

    16

		m_compatible_railtypes = v->u.rail.compatible_railtypes;

    17

		if (override_rail_type) m_compatible_railtypes |= GetRailTypeInfo(v->u.rail.railtype)->compatible_railtypes;

    18

	}

    19

    20

	bool IsCompatibleRailType(RailType rt)

    21

	{

    22

		return HasBit(m_compatible_railtypes, rt);

    23

	}

    24

    25

	RailTypes GetCompatibleRailTypes() const

    26

	{

    27

		return m_compatible_railtypes;

    28

	}

    29

};

    30

    31

template <class Types>

    32

class CYapfDestinationAnyDepotRailT

    33

	: public CYapfDestinationRailBase

    34

{

    35

public:

    36

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

    37

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

    38

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

    39

    40

	/// to access inherited path finder

    41

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

    42

    43

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

    44

	FORCEINLINE bool PfDetectDestination(Node& n)

    45

	{

    46

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

    47

	}

    48

    49

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

    50

	FORCEINLINE bool PfDetectDestination(TileIndex tile, Trackdir td)

    51

	{

    52

		bool bDest = IsRailDepotTile(tile);

    53

		return bDest;

    54

	}

    55

    56

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

    57

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

    58

	FORCEINLINE bool PfCalcEstimate(Node& n)

    59

	{

    60

		n.m_estimate = n.m_cost;

    61

		return true;

    62

	}

    63

};

    64

    65

template <class Types>

    66

class CYapfDestinationAnySafeTileRailT

    67

	: public CYapfDestinationRailBase

    68

{

    69

public:

    70

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

    71

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

    72

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

    73

	typedef typename Types::TrackFollower TrackFollower; ///< TrackFollower. Need to typedef for gcc 2.95

    74

    75

	/// to access inherited path finder

    76

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

    77

    78

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

    79

	FORCEINLINE bool PfDetectDestination(Node& n)

    80

	{

    81

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

    82

	}

    83

    84

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

    85

	FORCEINLINE bool PfDetectDestination(TileIndex tile, Trackdir td)

    86

	{

    87

		return

    88

			IsSafeWaitingPosition(Yapf().GetVehicle(), tile, td, true, !TrackFollower::Allow90degTurns()) &&

    89

			IsWaitingPositionFree(Yapf().GetVehicle(), tile, td, !TrackFollower::Allow90degTurns());

    90

	}

    91

    92

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

    93

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

    94

	FORCEINLINE bool PfCalcEstimate(Node& n)

    95

	{

    96

		n.m_estimate = n.m_cost;

    97

		return true;

    98

	}

    99

};

   100

   101

template <class Types>

   102

class CYapfDestinationTileOrStationRailT

   103

	: public CYapfDestinationRailBase

   104

{

   105

public:

   106

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

   107

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

   108

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

   109

   110

protected:

   111

	TileIndex    m_destTile;

   112

	TrackdirBits m_destTrackdirs;

   113

	StationID    m_dest_station_id;

   114

   115

	/// to access inherited path finder

   116

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

   117

   118

	static TileIndex CalcStationCenterTile(StationID station)

   119

	{

   120

		const Station* st = GetStation(station);

   121

   122

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

   123

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

   124

		// return the tile of our target coordinates

   125

		return TileXY(x, y);

   126

	}

   127

   128

public:

   129

	void SetDestination(const Vehicle* v)

   130

	{

   131

		switch (v->current_order.GetType()) {

   132

			case OT_GOTO_STATION:

   133

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

   134

				m_dest_station_id = v->current_order.GetDestination();

   135

				m_destTrackdirs = INVALID_TRACKDIR_BIT;

   136

				break;

   137

   138

			case OT_GOTO_WAYPOINT: {

   139

				Waypoint *wp = GetWaypoint(v->current_order.GetDestination());

   140

				if (wp == NULL) {

   141

					/* Invalid waypoint in orders! */

   142

					DEBUG(yapf, 0, "Invalid waypoint in orders == 0x%04X (train %d, company %d)", v->current_order.GetDestination(), v->unitnumber, (CompanyID)v->owner);

   143

					break;

   144

				}

   145

				m_destTile = wp->xy;

   146

				if (m_destTile != v->dest_tile) {

   147

					/* Something is wrong with orders! */

   148

					DEBUG(yapf, 0, "Invalid v->dest_tile == 0x%04X (train %d, company %d)", v->dest_tile, v->unitnumber, (CompanyID)v->owner);

   149

				}

   150

				m_dest_station_id = INVALID_STATION;

   151

				m_destTrackdirs = TrackToTrackdirBits(AxisToTrack(GetWaypointAxis(wp->xy)));

   152

				break;

   153

			}

   154

   155

			default:

   156

				m_destTile = v->dest_tile;

   157

				m_dest_station_id = INVALID_STATION;

   158

				m_destTrackdirs = TrackStatusToTrackdirBits(GetTileTrackStatus(v->dest_tile, TRANSPORT_RAIL, 0));

   159

				break;

   160

		}

   161

		CYapfDestinationRailBase::SetDestination(v);

   162

	}

   163

   164

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

   165

	FORCEINLINE bool PfDetectDestination(Node& n)

   166

	{

   167

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

   168

	}

   169

   170

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

   171

	FORCEINLINE bool PfDetectDestination(TileIndex tile, Trackdir td)

   172

	{

   173

		bool bDest;

   174

		if (m_dest_station_id != INVALID_STATION) {

   175

			bDest = IsRailwayStationTile(tile)

   176

				&& (GetStationIndex(tile) == m_dest_station_id)

   177

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

   178

		} else {

   179

			bDest = (tile == m_destTile)

   180

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

   181

		}

   182

		return bDest;

   183

	}

   184

   185

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

   186

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

   187

	FORCEINLINE bool PfCalcEstimate(Node& n)

   188

	{

   189

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

   190

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

   191

		if (PfDetectDestination(n)) {

   192

			n.m_estimate = n.m_cost;

   193

			return true;

   194

		}

   195

   196

		TileIndex tile = n.GetLastTile();

   197

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

   198

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

   199

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

   200

		int x2 = 2 * TileX(m_destTile);

   201

		int y2 = 2 * TileY(m_destTile);

   202

		int dx = abs(x1 - x2);

   203

		int dy = abs(y1 - y2);

   204

		int dmin = min(dx, dy);

   205

		int dxy = abs(dx - dy);

   206

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

   207

		n.m_estimate = n.m_cost + d;

   208

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

   209

		return true;

   210

	}

   211

};

   212

   213

   214

#endif /* YAPF_DESTRAIL_HPP */