1

/* $Id$ */

     2

     3

#include "../stdafx.h"

     4

     5

#include "yapf.hpp"

     6

#include "yapf_node_road.hpp"

     7

     8

     9

template <class Types>

    10

class CYapfCostRoadT

    11

{

    12

public:

    13

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

    14

	typedef typename Types::TrackFollower TrackFollower; ///< track follower helper

    15

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

    16

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

    17

    18

protected:

    19

	/// to access inherited path finder

    20

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

    21

    22

	int SlopeCost(TileIndex tile, TileIndex next_tile, Trackdir trackdir)

    23

	{

    24

		// height of the center of the current tile

    25

		int x1 = TileX(tile) * TILE_SIZE;

    26

		int y1 = TileY(tile) * TILE_SIZE;

    27

		int z1 = GetSlopeZ(x1 + TILE_HEIGHT, y1 + TILE_HEIGHT);

    28

    29

		// height of the center of the next tile

    30

		int x2 = TileX(next_tile) * TILE_SIZE;

    31

		int y2 = TileY(next_tile) * TILE_SIZE;

    32

		int z2 = GetSlopeZ(x2 + TILE_HEIGHT, y2 + TILE_HEIGHT);

    33

    34

		if (z2 - z1 > 1) {

    35

			/* Slope up */

    36

			return Yapf().PfGetSettings().rail_slope_penalty;

    37

		}

    38

		return 0;

    39

	}

    40

    41

	/** return one tile cost */

    42

	FORCEINLINE int OneTileCost(TileIndex tile, Trackdir trackdir)

    43

	{

    44

		int cost = 0;

    45

		// set base cost

    46

		if (IsDiagonalTrackdir(trackdir)) {

    47

			cost += 10;

    48

			switch (GetTileType(tile)) {

    49

				case MP_STREET:

    50

					/* Increase the cost for level crossings */

    51

					if (IsLevelCrossing(tile))

    52

						cost += Yapf().PfGetSettings().rail_crossing_penalty;

    53

					break;

    54

    55

				default:

    56

					break;

    57

			}

    58

		} else {

    59

			// non-diagonal trackdir

    60

			cost = 7;

    61

		}

    62

		return cost;

    63

	}

    64

    65

public:

    66

	/** Called by YAPF to calculate the cost from the origin to the given node.

    67

	*   Calculates only the cost of given node, adds it to the parent node cost

    68

	*   and stores the result into Node::m_cost member */

    69

	FORCEINLINE bool PfCalcCost(Node& n)

    70

	{

    71

		int segment_cost = 0;

    72

		// start at n.m_key.m_tile / n.m_key.m_td and walk to the end of segment

    73

		TileIndex tile = n.m_key.m_tile;

    74

		Trackdir trackdir = n.m_key.m_td;

    75

		while (true) {

    76

			// base tile cost depending on distance between edges

    77

			segment_cost += Yapf().OneTileCost(tile, trackdir);

    78

    79

			// if there are no reachable trackdirs n new tile, we have end of road

    80

			TrackFollower F;

    81

			if (!F.Follow(tile, trackdir)) break;

    82

    83

			// if there are more trackdirs available & reachable, we are at the end of segment

    84

			if (KillFirstBit2x64(F.m_new_td_bits) != 0) break;

    85

    86

			Trackdir new_td = (Trackdir)FindFirstBit2x64(F.m_new_td_bits);

    87

    88

			// stop if RV is on simple loop with no junctions

    89

			if (F.m_new_tile == n.m_key.m_tile && new_td == n.m_key.m_td) return false;

    90

    91

			// if we skipped some tunnel tiles, add their cost

    92

			segment_cost += 10 * F.m_tunnel_tiles_skipped;

    93

    94

			// add hilly terrain penalty

    95

			segment_cost += Yapf().SlopeCost(tile, F.m_new_tile, trackdir);

    96

    97

			// add min/max speed penalties

    98

			int min_speed = 0;

    99

			int max_speed = F.GetSpeedLimit(&min_speed);

   101

			if (max_speed < v->max_speed) segment_cost += 1 * (v->max_speed - max_speed);

   102

			if (min_speed > v->max_speed) segment_cost += 10 * (min_speed - v->max_speed);

   103

   104

			// move to the next tile

   105

			tile = F.m_new_tile;

   106

			trackdir = new_td;

   107

		};

   108

   109

		// save end of segment back to the node

   110

		n.m_segment_last_tile = tile;

   111

		n.m_segment_last_td = trackdir;

   112

   113

		// save also tile cost

   114

		int parent_cost = (n.m_parent != NULL) ? n.m_parent->m_cost : 0;

   115

		n.m_cost = parent_cost + segment_cost;

   116

		return true;

   117

	}

   118

};

   119

   120

   121

template <class Types>

   122

class CYapfDestinationAnyDepotRoadT

   123

{

   124

public:

   125

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

   126

	typedef typename Types::TrackFollower TrackFollower;

   127

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

   128

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

   129

   130

	/// to access inherited path finder

   131

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

   132

   133

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

   134

	FORCEINLINE bool PfDetectDestination(Node& n)

   135

	{

   136

		bool bDest = IsTileDepotType(n.m_segment_last_tile, TRANSPORT_ROAD);

   137

		return bDest;

   138

	}

   139

   140

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

   141

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

   142

	FORCEINLINE bool PfCalcEstimate(Node& n)

   143

	{

   144

		n.m_estimate = n.m_cost;

   145

		return true;

   146

	}

   147

};

   148

   149

   150

template <class Types>

   151

class CYapfDestinationTileRoadT

   152

{

   153

public:

   154

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

   155

	typedef typename Types::TrackFollower TrackFollower;

   156

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

   157

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

   158

   159

protected:

   160

	TileIndex    m_destTile;

   161

	TrackdirBits m_destTrackdirs;

   162

   163

public:

   164

	void SetDestination(TileIndex tile, TrackdirBits trackdirs)

   165

	{

   166

		m_destTile = tile;

   167

		m_destTrackdirs = trackdirs;

   168

	}

   169

   170

protected:

   171

	/// to access inherited path finder

   172

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

   173

   174

public:

   175

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

   176

	FORCEINLINE bool PfDetectDestination(Node& n)

   177

	{

   178

		bool bDest = (n.m_segment_last_tile == m_destTile) && ((m_destTrackdirs & TrackdirToTrackdirBits(n.m_segment_last_td)) != TRACKDIR_BIT_NONE);

   179

		return bDest;

   180

	}

   181

   182

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

   183

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

   184

	inline bool PfCalcEstimate(Node& n)

   185

	{

   186

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

   187

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

   188

		if (PfDetectDestination(n)) {

   189

			n.m_estimate = n.m_cost;

   190

			return true;

   191

		}

   192

   193

		TileIndex tile = n.m_segment_last_tile;

   194

		DiagDirection exitdir = TrackdirToExitdir(n.m_segment_last_td);

   195

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

   196

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

   197

		int x2 = 2 * TileX(m_destTile);

   198

		int y2 = 2 * TileY(m_destTile);

   199

		int dx = abs(x1 - x2);

   200

		int dy = abs(y1 - y2);

   201

		int dmin = min(dx, dy);

   202

		int dxy = abs(dx - dy);

   203

		int d = dmin * 7 + (dxy - 1) * 5;

   204

		n.m_estimate = n.m_cost + d;

   205

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

   206

		return true;

   207

	}

   208

};

   209

   210

   211

   212

template <class Types>

   213

class CYapfFollowRoadT

   214

{

   215

public:

   216

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

   217

	typedef typename Types::TrackFollower TrackFollower;

   218

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

   219

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

   220

   221

protected:

   222

	/// to access inherited path finder

   223

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

   224

   225

public:

   226

   227

	/** Called by YAPF to move from the given node to the next tile. For each

   228

	*   reachable trackdir on the new tile creates new node, initializes it

   229

	*   and adds it to the open list by calling Yapf().AddNewNode(n) */

   230

	inline void PfFollowNode(Node& old_node)

   231

	{

   232

		TrackFollower F;

   233

		if (F.Follow(old_node.m_segment_last_tile, old_node.m_segment_last_td))

   234

			Yapf().AddMultipleNodes(&old_node, F.m_new_tile, F.m_new_td_bits);

   235

	}

   236

   237

	/// return debug report character to identify the transportation type

   238

	FORCEINLINE char TransportTypeChar() const {return 'r';}

   239

   240

	static Trackdir stChooseRoadTrack(Vehicle *v, TileIndex tile, DiagDirection enterdir)

   241

	{

   242

		Tpf pf;

   243

		return pf.ChooseRoadTrack(v, tile, enterdir);

   244

	}

   245

   246

	FORCEINLINE Trackdir ChooseRoadTrack(Vehicle *v, TileIndex tile, DiagDirection enterdir)

   247

	{

   248

		// handle special case - when next tile is destination tile

   249

		if (tile == v->dest_tile) {

   250

			// choose diagonal trackdir reachable from enterdir

   251

			return (Trackdir)DiagdirToDiagTrackdir(enterdir);

   252

		}

   253

		// our source tile will be the next vehicle tile (should be the given one)

   254

		TileIndex src_tile = tile;

   255

		// get available trackdirs on the start tile

   256

		uint ts = GetTileTrackStatus(tile, TRANSPORT_ROAD);

   257

		TrackdirBits src_trackdirs = (TrackdirBits)(ts & TRACKDIR_BIT_MASK);

   258

		// select reachable trackdirs only

   259

		src_trackdirs &= DiagdirReachesTrackdirs(enterdir);

   260

   261

		// get available trackdirs on the destination tile

   262

		TileIndex dest_tile = v->dest_tile;

   263

		uint dest_ts = GetTileTrackStatus(dest_tile, TRANSPORT_ROAD);

   264

		TrackdirBits dest_trackdirs = (TrackdirBits)(dest_ts & TRACKDIR_BIT_MASK);

   265

   266

		// set origin and destination nodes

   267

		Yapf().SetOrigin(src_tile, src_trackdirs);

   268

		Yapf().SetDestination(dest_tile, dest_trackdirs);

   269

   270

		// find the best path

   271

		Yapf().FindPath(v);

   272

   273

		// if path not found - return INVALID_TRACKDIR

   274

		Trackdir next_trackdir = INVALID_TRACKDIR;

   275

		Node* pNode = &Yapf().GetBestNode();

   276

		if (pNode != NULL) {

   277

			// path was found or at least suggested

   278

			// walk through the path back to its origin

   279

			while (pNode->m_parent != NULL) {

   280

				pNode = pNode->m_parent;

   281

			}

   282

			// return trackdir from the best origin node (one of start nodes)

   283

			Node& best_next_node = *pNode;

   284

			assert(best_next_node.GetTile() == tile);

   285

			next_trackdir = best_next_node.GetTrackdir();

   286

		}

   287

		return next_trackdir;

   288

	}

   289

   330

	static Depot* stFindNearestDepot(Vehicle* v, TileIndex tile, Trackdir td)

   331

	{

   332

		Tpf pf;

   333

		return pf.FindNearestDepot(v, tile, td);

   334

	}

   335

   336

	FORCEINLINE Depot* FindNearestDepot(Vehicle* v, TileIndex tile, Trackdir td)

   337

	{

   338

		// set origin and destination nodes

   339

		Yapf().SetOrigin(tile, TrackdirToTrackdirBits(td));

   340

   341

		// find the best path

   342

		bool bFound = Yapf().FindPath(v);

   343

		if (!bFound) return false;

   344

   345

		// some path found

   346

		// get found depot tile

   347

		Node& n = Yapf().GetBestNode();

   348

		TileIndex depot_tile = n.m_segment_last_tile;

   349

		assert(IsTileDepotType(depot_tile, TRANSPORT_ROAD));

   350

		Depot* ret = GetDepotByTile(depot_tile);

   351

		return ret;

   352

	}

   353

};

   354

   355

template <class Tpf_, class Tnode_list, template <class Types> class Tdestination>

   356

struct CYapfRoad_TypesT

   357

{

   358

	typedef CYapfRoad_TypesT<Tpf_, Tnode_list, Tdestination>  Types;

   359

   360

	typedef Tpf_                              Tpf;

   361

	typedef CFollowTrackRoad                  TrackFollower;

   362

	typedef Tnode_list                        NodeList;

   363

	typedef CYapfBaseT<Types>                 PfBase;

   364

	typedef CYapfFollowRoadT<Types>           PfFollow;

   365

	typedef CYapfOriginTileT<Types>           PfOrigin;

   366

	typedef Tdestination<Types>               PfDestination;

   367

	typedef CYapfSegmentCostCacheNoneT<Types> PfCache;

   368

	typedef CYapfCostRoadT<Types>             PfCost;

   369

};

   370

   371

struct CYapfRoad1         : CYapfT<CYapfRoad_TypesT<CYapfRoad1        , CRoadNodeListTrackDir, CYapfDestinationTileRoadT    > > {};

   372

struct CYapfRoad2         : CYapfT<CYapfRoad_TypesT<CYapfRoad2        , CRoadNodeListExitDir , CYapfDestinationTileRoadT    > > {};

   373

   374

struct CYapfRoadAnyDepot1 : CYapfT<CYapfRoad_TypesT<CYapfRoadAnyDepot1, CRoadNodeListTrackDir, CYapfDestinationAnyDepotRoadT> > {};

   375

struct CYapfRoadAnyDepot2 : CYapfT<CYapfRoad_TypesT<CYapfRoadAnyDepot2, CRoadNodeListExitDir , CYapfDestinationAnyDepotRoadT> > {};

   376

   377

   378

Trackdir YapfChooseRoadTrack(Vehicle *v, TileIndex tile, DiagDirection enterdir)

   379

{

   380

	// default is YAPF type 2

   381

	typedef Trackdir (*PfnChooseRoadTrack)(Vehicle*, TileIndex, DiagDirection);

   382

	PfnChooseRoadTrack pfnChooseRoadTrack = &CYapfRoad2::stChooseRoadTrack; // default: ExitDir, allow 90-deg

   383

   384

	// check if non-default YAPF type should be used

   385

	if (_patches.yapf.disable_node_optimization)

   386

		pfnChooseRoadTrack = &CYapfRoad1::stChooseRoadTrack; // Trackdir, allow 90-deg

   387

   388

	Trackdir td_ret = pfnChooseRoadTrack(v, tile, enterdir);

   389

	return td_ret;

   390

}

   391

   411

Depot* YapfFindNearestRoadDepot(const Vehicle *v)

   412

{

   413

	TileIndex tile = v->tile;

   414

	if (v->u.road.state == 255) tile = GetVehicleOutOfTunnelTile(v);

   415

	Trackdir trackdir = GetVehicleTrackdir(v);

   416

	if ((GetTileTrackStatus(tile, TRANSPORT_ROAD) & TrackdirToTrackdirBits(trackdir)) == 0)

   417

		return NULL;

   418

   419

	// default is YAPF type 2

   420

	typedef Depot* (*PfnFindNearestDepot)(Vehicle*, TileIndex, Trackdir);

   421

	PfnFindNearestDepot pfnFindNearestDepot = &CYapfRoadAnyDepot2::stFindNearestDepot;

   422

   423

	// check if non-default YAPF type should be used

   424

	if (_patches.yapf.disable_node_optimization)

   425

		pfnFindNearestDepot = &CYapfRoadAnyDepot1::stFindNearestDepot; // Trackdir, allow 90-deg

   426

   427

	Depot* ret = pfnFindNearestDepot(const_cast<Vehicle*>(v), tile, trackdir);

   428

	return ret;

   429

}