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:

    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 = IsRailDepotTile(tile);

    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:

    88

	{

    89

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

    90

			case OT_GOTO_STATION:

    91

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

    92

				m_dest_station_id = v->current_order.GetDestination();

    93

				m_destTrackdirs = INVALID_TRACKDIR_BIT;

    94

				break;

    95

    96

			case OT_GOTO_WAYPOINT: {

    97

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

    98

				if (wp == NULL) {

    99

					/* Invalid waypoint in orders! */

   100

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

   101

					break;

   102

				}

   103

				m_destTile = wp->xy;

   104

				if (m_destTile != v->dest_tile) {

   105

					/* Something is wrong with orders! */

   106

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

   107

				}

   108

				m_dest_station_id = INVALID_STATION;

   109

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

   110

				break;

   111

			}

   112

   113

			default:

   114

				m_destTile = v->dest_tile;

   115

				m_dest_station_id = INVALID_STATION;

   116

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

   117

				break;

   118

		}

   119

		CYapfDestinationRailBase::SetDestination(v);

   120

	}

   121

   122

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

   123

	FORCEINLINE bool PfDetectDestination(Node& n)

   124

	{

   125

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

   126

	}

   127

   128

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

   129

	FORCEINLINE bool PfDetectDestination(TileIndex tile, Trackdir td)

   130

	{

   131

		bool bDest;

   132

		if (m_dest_station_id != INVALID_STATION) {

   133

			bDest = IsRailwayStationTile(tile)

   134

				&& (GetStationIndex(tile) == m_dest_station_id)

   135

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

   136

		} else {

   137

			bDest = (tile == m_destTile)

   138

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

   139

		}

   140

		return bDest;

   141

	}

   142

   143

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

   144

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

   145

	FORCEINLINE bool PfCalcEstimate(Node& n)

   146

	{

   147

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

   148

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

   149

		if (PfDetectDestination(n)) {

   150

			n.m_estimate = n.m_cost;

   151

			return true;

   152

		}

   153

   154

		TileIndex tile = n.GetLastTile();

   155

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

   156

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

   157

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

   158

		int x2 = 2 * TileX(m_destTile);

   159

		int y2 = 2 * TileY(m_destTile);

   160

		int dx = abs(x1 - x2);

   161

		int dy = abs(y1 - y2);

   162

		int dmin = min(dx, dy);

   163

		int dxy = abs(dx - dy);

   164

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

   165

		n.m_estimate = n.m_cost + d;

   166

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

   167

		return true;

   168

	}

   169

};

   170

   171

   172

#endif /* YAPF_DESTRAIL_HPP */