1

/* $Id$ */

     2

     3

/** @file yapf_rail.cpp The rail pathfinding. */

     4

     5

#include "../stdafx.h"

     6

     7

#include "yapf.hpp"

     8

#include "yapf_node_rail.hpp"

     9

#include "yapf_costrail.hpp"

    10

#include "yapf_destrail.hpp"

    11

#include "../vehicle_func.h"

    12

#include "../pbs.h"

    13

    14

#define DEBUG_YAPF_CACHE 0

    15

    16

int _total_pf_time_us = 0;

    17

    18

    19

    20

template <class Types>

    21

class CYapfReserveTrack

    22

{

    23

public:

    24

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

    25

	typedef typename Types::TrackFollower TrackFollower;

    26

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

    27

    28

protected:

    29

	/// to access inherited pathfinder

    30

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

    31

    32

private:

    33

	TileIndex m_res_dest;         ///< The reservation target tile

    34

	Trackdir  m_res_dest_td;      ///< The reservation target trackdir

    35

	Node      *m_res_node;        ///< The reservation target node

    36

	TileIndex m_res_fail_tile;    ///< The tile where the reservation failed

    37

	Trackdir  m_res_fail_td;      ///< The trackdir where the reservation failed

    38

    39

	bool FindSafePositionProc(TileIndex tile, Trackdir td)

    40

	{

    41

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

    42

			m_res_dest = tile;

    43

			m_res_dest_td = td;

    44

			return false;   // Stop iterating segment

    45

		}

    46

		return true;

    47

	}

    48

    49

	bool ReserveSingleTrack(TileIndex tile, Trackdir td)

    50

	{

    51

		if (!TryReserveRailTrack(tile, TrackdirToTrack(td))) {

    52

			/* Tile couldn't be reserved, undo. */

    53

			m_res_fail_tile = tile;

    54

			m_res_fail_td = td;

    55

			return false;

    56

		}

    57

		/* YAPF can sometimes skip parts of a station, so make sure we

    58

		 * always reserve the whole platform. */

    59

		if (IsRailwayStationTile(tile)) SetRailwayStationPlatformReservation(tile, TrackdirToExitdir(ReverseTrackdir(td)), true);

    60

		return tile != m_res_dest;

    61

	}

    62

    63

	bool UnreserveSingleTrack(TileIndex tile, Trackdir td)

    64

	{

    65

		if (tile != m_res_fail_tile || td != m_res_fail_td) UnreserveRailTrack(tile, TrackdirToTrack(td));

    66

		return tile != m_res_dest && (tile != m_res_fail_tile || td != m_res_fail_td);

    67

	}

    68

    69

public:

    70

	/** Set the target to where the reservation should be extended. */

    71

	inline void SetReservationTarget(Node *node, TileIndex tile, Trackdir td)

    72

	{

    73

		m_res_node = node;

    74

		m_res_dest = tile;

    75

		m_res_dest_td = td;

    76

	}

    77

    78

	/** Check the node for a possible reservation target. */

    79

	inline void FindSafePositionOnNode(Node *node)

    80

	{

    81

		assert(node->m_parent != NULL);

    82

    83

		/* We will never pass more than two signals, no need to check for a safe tile. */

    84

		if (node->m_parent->m_num_signals_passed >= 2) return;

    85

    86

		if (!node->IterateTiles(Yapf().GetVehicle(), Yapf(), *this, &CYapfReserveTrack<Types>::FindSafePositionProc)) {

    87

			m_res_node = node;

    88

		}

    89

	}

    90

    91

	/** Try to reserve the path till the reservation target. */

    92

	bool TryReservePath(PBSTileInfo *target)

    93

	{

    94

		m_res_fail_tile = INVALID_TILE;

    95

    96

		if (target != NULL) {

    97

			target->tile = m_res_dest;

    98

			target->trackdir = m_res_dest_td;

    99

			target->okay = false;

   100

		}

   101

   102

		/* Don't bother if the target is reserved. */

   103

		if (!IsWaitingPositionFree(Yapf().GetVehicle(), m_res_dest, m_res_dest_td)) return false;

   104

   105

		for (Node *node = m_res_node; node->m_parent != NULL; node = node->m_parent) {

   106

			node->IterateTiles(Yapf().GetVehicle(), Yapf(), *this, &CYapfReserveTrack<Types>::ReserveSingleTrack);

   107

			if (m_res_fail_tile != INVALID_TILE) {

   108

				/* Reservation failed, undo. */

   109

				Node *fail_node = m_res_node;

   110

				TileIndex stop_tile = m_res_fail_tile;

   111

				do {

   112

					/* If this is the node that failed, stop at the failed tile. */

   113

					m_res_fail_tile = fail_node == node ? stop_tile : INVALID_TILE;

   114

					fail_node->IterateTiles(Yapf().GetVehicle(), Yapf(), *this, &CYapfReserveTrack<Types>::UnreserveSingleTrack);

   115

				} while (fail_node != node && (fail_node = fail_node->m_parent) != NULL);

   116

   117

				return false;

   118

			}

   119

		}

   120

   121

		if (target != NULL) target->okay = true;

   122

   123

		if (Yapf().CanUseGlobalCache(*m_res_node))

   124

			YapfNotifyTrackLayoutChange(INVALID_TILE, INVALID_TRACK);

   125

   126

		return true;

   127

	}

   128

};

   129

   130

template <class Types>

   131

class CYapfFollowAnyDepotRailT

   132

{

   133

public:

   134

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

   135

	typedef typename Types::TrackFollower TrackFollower;

   136

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

   137

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

   138

   139

protected:

   140

	/// to access inherited path finder

   141

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

   142

   143

public:

   144

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

   145

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

   146

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

   147

	inline void PfFollowNode(Node& old_node)

   148

	{

   149

		TrackFollower F(Yapf().GetVehicle());

   150

		if (F.Follow(old_node.GetLastTile(), old_node.GetLastTrackdir()))

   151

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

   152

	}

   153

   154

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

   155

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

   156

   157

	static bool stFindNearestDepotTwoWay(const Vehicle *v, TileIndex t1, Trackdir td1, TileIndex t2, Trackdir td2, int max_distance, int reverse_penalty, TileIndex* depot_tile, bool* reversed)

   158

	{

   159

		Tpf pf1;

   160

		bool result1 = pf1.FindNearestDepotTwoWay(v, t1, td1, t2, td2, max_distance, reverse_penalty, depot_tile, reversed);

   161

   162

#if DEBUG_YAPF_CACHE

   163

		Tpf pf2;

   164

		TileIndex depot_tile2 = INVALID_TILE;

   165

		bool reversed2 = false;

   166

		pf2.DisableCache(true);

   167

		bool result2 = pf2.FindNearestDepotTwoWay(v, t1, td1, t2, td2, max_distance, reverse_penalty, &depot_tile2, &reversed2);

   168

		if (result1 != result2 || (result1 && (*depot_tile != depot_tile2 || *reversed != reversed2))) {

   169

			DEBUG(yapf, 0, "CACHE ERROR: FindNearestDepotTwoWay() = [%s, %s]", result1 ? "T" : "F", result2 ? "T" : "F");

   170

		}

   171

#endif

   172

   173

		return result1;

   174

	}

   175

   176

	FORCEINLINE bool FindNearestDepotTwoWay(const Vehicle *v, TileIndex t1, Trackdir td1, TileIndex t2, Trackdir td2, int max_distance, int reverse_penalty, TileIndex* depot_tile, bool* reversed)

   177

	{

   178

		// set origin and destination nodes

   179

		Yapf().SetOrigin(t1, td1, t2, td2, reverse_penalty, true);

   180

		Yapf().SetDestination(v);

   181

		Yapf().SetMaxCost(YAPF_TILE_LENGTH * max_distance);

   182

   183

		// find the best path

   184

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

   185

		if (!bFound) return false;

   186

   187

		// some path found

   188

		// get found depot tile

   189

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

   190

		*depot_tile = n->GetLastTile();

   191

   192

		// walk through the path back to the origin

   193

		Node *pNode = n;

   194

		while (pNode->m_parent != NULL) {

   195

			pNode = pNode->m_parent;

   196

		}

   197

   198

		// if the origin node is our front vehicle tile/Trackdir then we didn't reverse

   199

		// but we can also look at the cost (== 0 -> not reversed, == reverse_penalty -> reversed)

   200

		*reversed = (pNode->m_cost != 0);

   201

   202

		return true;

   203

	}

   204

};

   205

   206

template <class Types>

   207

class CYapfFollowAnySafeTileRailT : protected CYapfReserveTrack<Types>

   208

{

   209

public:

   210

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

   211

	typedef typename Types::TrackFollower TrackFollower;

   212

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

   213

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

   214

   215

protected:

   216

	/// to access inherited path finder

   217

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

   218

   219

public:

   220

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

   221

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

   222

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

   223

	inline void PfFollowNode(Node& old_node)

   224

	{

   225

		TrackFollower F(Yapf().GetVehicle(), Yapf().GetCompatibleRailTypes());

   226

		if (F.Follow(old_node.GetLastTile(), old_node.GetLastTrackdir()) && F.MaskReservedTracks())

   227

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

   228

	}

   229

   230

	/** Return debug report character to identify the transportation type */

   231

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

   232

   233

	static bool stFindNearestSafeTile(const Vehicle *v, TileIndex t1, Trackdir td, bool override_railtype)

   234

	{

   235

		/* Create pathfinder instance */

   236

		Tpf pf1;

   237

#if !DEBUG_YAPF_CACHE

   238

		bool result1 = pf1.FindNearestSafeTile(v, t1, td, override_railtype, false);

   239

   240

#else

   241

		bool result2 = pf1.FindNearestSafeTile(v, t1, td, override_railtype, true);

   242

		Tpf pf2;

   243

		pf2.DisableCache(true);

   244

		bool result1 = pf2.FindNearestSafeTile(v, t1, td, override_railtype, false);

   245

		if (result1 != result2) {

   246

			DEBUG(yapf, 0, "CACHE ERROR: FindSafeTile() = [%s, %s]", result2 ? "T" : "F", result1 ? "T" : "F");

   247

			DumpTarget dmp1, dmp2;

   248

			pf1.DumpBase(dmp1);

   249

			pf2.DumpBase(dmp2);

   250

			FILE *f1 = fopen("C:\\yapf1.txt", "wt");

   251

			FILE *f2 = fopen("C:\\yapf2.txt", "wt");

   252

			fwrite(dmp1.m_out.Data(), 1, dmp1.m_out.Size(), f1);

   253

			fwrite(dmp2.m_out.Data(), 1, dmp2.m_out.Size(), f2);

   254

			fclose(f1);

   255

			fclose(f2);

   256

		}

   257

#endif

   258

   259

		return result1;

   260

	}

   261

   262

	bool FindNearestSafeTile(const Vehicle *v, TileIndex t1, Trackdir td, bool override_railtype, bool dont_reserve)

   263

	{

   264

		/* Set origin and destination. */

   265

		Yapf().SetOrigin(t1, td);

   266

		Yapf().SetDestination(v, override_railtype);

   267

   268

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

   269

		if (!bFound) return false;

   270

   271

		/* Found a destination, set as reservation target. */

   272

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

   273

		this->SetReservationTarget(pNode, pNode->GetLastTile(), pNode->GetLastTrackdir());

   274

   275

		/* Walk through the path back to the origin. */

   276

		Node* pPrev = NULL;

   277

		while (pNode->m_parent != NULL) {

   278

			pPrev = pNode;

   279

			pNode = pNode->m_parent;

   280

   281

			this->FindSafePositionOnNode(pPrev);

   282

		}

   283

   284

		return dont_reserve || this->TryReservePath(NULL);

   285

	}

   286

};

   287

   288

template <class Types>

   289

class CYapfFollowRailT : protected CYapfReserveTrack<Types>

   290

{

   291

public:

   292

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

   293

	typedef typename Types::TrackFollower TrackFollower;

   294

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

   295

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

   296

   297

protected:

   298

	/// to access inherited path finder

   299

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

   300

   301

public:

   302

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

   303

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

   304

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

   305

	inline void PfFollowNode(Node& old_node)

   306

	{

   307

		TrackFollower F(Yapf().GetVehicle());

   308

		if (F.Follow(old_node.GetLastTile(), old_node.GetLastTrackdir()))

   309

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

   310

	}

   311

   312

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

   313

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

   314

   315

	static Trackdir stChooseRailTrack(const Vehicle *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool *path_not_found, bool reserve_track, PBSTileInfo *target)

   316

	{

   317

		// create pathfinder instance

   318

		Tpf pf1;

   319

#if !DEBUG_YAPF_CACHE

   320

		Trackdir result1 = pf1.ChooseRailTrack(v, tile, enterdir, tracks, path_not_found, reserve_track, target);

   321

   322

#else

   323

		Trackdir result1 = pf1.ChooseRailTrack(v, tile, enterdir, tracks, path_not_found, false, NULL);

   324

		Tpf pf2;

   325

		pf2.DisableCache(true);

   326

		Trackdir result2 = pf2.ChooseRailTrack(v, tile, enterdir, tracks, path_not_found, reserve_track, target);

   327

		if (result1 != result2) {

   328

			DEBUG(yapf, 0, "CACHE ERROR: ChooseRailTrack() = [%d, %d]", result1, result2);

   329

			DumpTarget dmp1, dmp2;

   330

			pf1.DumpBase(dmp1);

   331

			pf2.DumpBase(dmp2);

   332

			FILE *f1 = fopen("C:\\yapf1.txt", "wt");

   333

			FILE *f2 = fopen("C:\\yapf2.txt", "wt");

   334

			fwrite(dmp1.m_out.Data(), 1, dmp1.m_out.Size(), f1);

   335

			fwrite(dmp2.m_out.Data(), 1, dmp2.m_out.Size(), f2);

   336

			fclose(f1);

   337

			fclose(f2);

   338

		}

   339

#endif

   340

   341

		return result1;

   342

	}

   343

   344

	FORCEINLINE Trackdir ChooseRailTrack(const Vehicle *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool *path_not_found, bool reserve_track, PBSTileInfo *target)

   345

	{

   346

		if (target != NULL) target->tile = INVALID_TILE;

   347

   348

		// set origin and destination nodes

   349

		PBSTileInfo origin = FollowTrainReservation(v);

   350

		Yapf().SetOrigin(origin.tile, origin.trackdir, INVALID_TILE, INVALID_TRACKDIR, 1, true);

   351

		Yapf().SetDestination(v);

   352

   353

		// find the best path

   354

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

   355

		if (path_not_found != NULL) {

   356

			// tell controller that the path was only 'guessed'

   357

			// treat the path as found if stopped on the first two way signal(s)

   358

			*path_not_found = !(path_found || Yapf().m_stopped_on_first_two_way_signal);

   359

		}

   360

   361

		// if path not found - return INVALID_TRACKDIR

   362

		Trackdir next_trackdir = INVALID_TRACKDIR;

   363

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

   364

		if (pNode != NULL) {

   365

			// reserve till end of path

   366

			this->SetReservationTarget(pNode, pNode->GetLastTile(), pNode->GetLastTrackdir());

   367

   368

			// path was found or at least suggested

   369

			// walk through the path back to the origin

   370

			Node* pPrev = NULL;

   371

			while (pNode->m_parent != NULL) {

   372

				pPrev = pNode;

   373

				pNode = pNode->m_parent;

   374

   375

				this->FindSafePositionOnNode(pPrev);

   376

			}

   377

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

   378

			Node& best_next_node = *pPrev;

   379

			next_trackdir = best_next_node.GetTrackdir();

   380

   381

			if (reserve_track && path_found) this->TryReservePath(target);

   382

		}

   383

		return next_trackdir;

   384

	}

   385

   386

	static bool stCheckReverseTrain(const Vehicle *v, TileIndex t1, Trackdir td1, TileIndex t2, Trackdir td2, int reverse_penalty)

   387

	{

   388

		Tpf pf1;

   389

		bool result1 = pf1.CheckReverseTrain(v, t1, td1, t2, td2, reverse_penalty);

   390

   391

#if DEBUG_YAPF_CACHE

   392

		Tpf pf2;

   393

		pf2.DisableCache(true);

   394

		bool result2 = pf2.CheckReverseTrain(v, t1, td1, t2, td2, reverse_penalty);

   395

		if (result1 != result2) {

   396

			DEBUG(yapf, 0, "CACHE ERROR: CheckReverseTrain() = [%s, %s]", result1 ? "T" : "F", result2 ? "T" : "F");

   397

		}

   398

#endif

   399

   400

		return result1;

   401

	}

   402

   403

	FORCEINLINE bool CheckReverseTrain(const Vehicle *v, TileIndex t1, Trackdir td1, TileIndex t2, Trackdir td2, int reverse_penalty)

   404

	{

   405

		// create pathfinder instance

   406

		// set origin and destination nodes

   407

		Yapf().SetOrigin(t1, td1, t2, td2, reverse_penalty, false);

   408

		Yapf().SetDestination(v);

   409

   410

		// find the best path

   411

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

   412

   413

		if (!bFound) return false;

   414

   415

		// path was found

   416

		// walk through the path back to the origin

   417

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

   418

		while (pNode->m_parent != NULL) {

   419

			pNode = pNode->m_parent;

   420

		}

   421

   422

		// check if it was reversed origin

   423

		Node& best_org_node = *pNode;

   424

		bool reversed = (best_org_node.m_cost != 0);

   425

		return reversed;

   426

	}

   427

};

   428

   429

template <class Tpf_, class Ttrack_follower, class Tnode_list, template <class Types> class TdestinationT, template <class Types> class TfollowT>

   430

struct CYapfRail_TypesT

   431

{

   432

	typedef CYapfRail_TypesT<Tpf_, Ttrack_follower, Tnode_list, TdestinationT, TfollowT>  Types;

   433

   434

	typedef Tpf_                                Tpf;

   435

	typedef Ttrack_follower                     TrackFollower;

   436

	typedef Tnode_list                          NodeList;

   437

	typedef CYapfBaseT<Types>                   PfBase;

   438

	typedef TfollowT<Types>                     PfFollow;

   439

	typedef CYapfOriginTileTwoWayT<Types>       PfOrigin;

   440

	typedef TdestinationT<Types>                PfDestination;

   441

	typedef CYapfSegmentCostCacheGlobalT<Types> PfCache;

   442

	typedef CYapfCostRailT<Types>               PfCost;

   443

};

   444

   445

struct CYapfRail1         : CYapfT<CYapfRail_TypesT<CYapfRail1        , CFollowTrackRail    , CRailNodeListTrackDir, CYapfDestinationTileOrStationRailT, CYapfFollowRailT> > {};

   446

struct CYapfRail2         : CYapfT<CYapfRail_TypesT<CYapfRail2        , CFollowTrackRailNo90, CRailNodeListTrackDir, CYapfDestinationTileOrStationRailT, CYapfFollowRailT> > {};

   447

   448

struct CYapfAnyDepotRail1 : CYapfT<CYapfRail_TypesT<CYapfAnyDepotRail1, CFollowTrackRail    , CRailNodeListTrackDir, CYapfDestinationAnyDepotRailT     , CYapfFollowAnyDepotRailT> > {};

   449

struct CYapfAnyDepotRail2 : CYapfT<CYapfRail_TypesT<CYapfAnyDepotRail2, CFollowTrackRailNo90, CRailNodeListTrackDir, CYapfDestinationAnyDepotRailT     , CYapfFollowAnyDepotRailT> > {};

   450

   451

struct CYapfAnySafeTileRail1 : CYapfT<CYapfRail_TypesT<CYapfAnySafeTileRail1, CFollowTrackFreeRail    , CRailNodeListTrackDir, CYapfDestinationAnySafeTileRailT , CYapfFollowAnySafeTileRailT> > {};

   452

struct CYapfAnySafeTileRail2 : CYapfT<CYapfRail_TypesT<CYapfAnySafeTileRail2, CFollowTrackFreeRailNo90, CRailNodeListTrackDir, CYapfDestinationAnySafeTileRailT , CYapfFollowAnySafeTileRailT> > {};

   453

   454

   455

Trackdir YapfChooseRailTrack(const Vehicle *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool *path_not_found, bool reserve_track, PBSTileInfo *target)

   456

{

   457

	// default is YAPF type 2

   458

	typedef Trackdir (*PfnChooseRailTrack)(const Vehicle*, TileIndex, DiagDirection, TrackBits, bool*, bool, PBSTileInfo*);

   459

	PfnChooseRailTrack pfnChooseRailTrack = &CYapfRail1::stChooseRailTrack;

   460

   461

	// check if non-default YAPF type needed

   462

	if (_settings_game.pf.forbid_90_deg) {

   463

		pfnChooseRailTrack = &CYapfRail2::stChooseRailTrack; // Trackdir, forbid 90-deg

   464

	}

   465

   466

	Trackdir td_ret = pfnChooseRailTrack(v, tile, enterdir, tracks, path_not_found, reserve_track, target);

   467

   468

	return td_ret;

   469

}

   470

   471

bool YapfCheckReverseTrain(const Vehicle* v)

   472

{

   473

	/* last wagon */

   474

	const Vehicle *last_veh = GetLastVehicleInChain(v);

   475

   476

	// get trackdirs of both ends

   477

	Trackdir td = GetVehicleTrackdir(v);

   478

	Trackdir td_rev = ReverseTrackdir(GetVehicleTrackdir(last_veh));

   479

   480

	/* tiles where front and back are */

   481

	TileIndex tile = v->tile;

   482

	TileIndex tile_rev = last_veh->tile;

   483

   484

	int reverse_penalty = 0;

   485

   486

	if (v->u.rail.track == TRACK_BIT_WORMHOLE) {

   487

		/* front in tunnel / on bridge */

   488

		DiagDirection dir_into_wormhole = GetTunnelBridgeDirection(tile);

   489

   490

		if (TrackdirToExitdir(td) == dir_into_wormhole) tile = GetOtherTunnelBridgeEnd(tile);

   491

		/* Now 'tile' is the tunnel entry/bridge ramp the train will reach when driving forward */

   492

   493

		/* Current position of the train in the wormhole */

   494

		TileIndex cur_tile = TileVirtXY(v->x_pos, v->y_pos);

   495

   496

		/* Add distance to drive in the wormhole as penalty for the forward path, i.e. bonus for the reverse path

   497

		 * Note: Negative penalties are ok for the start tile. */

   498

		reverse_penalty -= DistanceManhattan(cur_tile, tile) * YAPF_TILE_LENGTH;

   499

	}