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

#include "../functions.h"

    14

    15

#define DEBUG_YAPF_CACHE 0

    16

    17

int _total_pf_time_us = 0;

    18

    19

    20

    21

template <class Types>

    22

class CYapfReserveTrack

    23

{

    24

public:

    25

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

    26

	typedef typename Types::TrackFollower TrackFollower;

    27

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

    28

    29

protected:

    30

	/// to access inherited pathfinder

    31

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

    32

    33

private:

    34

	TileIndex m_res_dest;         ///< The reservation target tile

    35

	Trackdir  m_res_dest_td;      ///< The reservation target trackdir

    36

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

    37

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

    38

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

    39

    40

	bool FindSafePositionProc(TileIndex tile, Trackdir td)

    41

	{

    42

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

    43

			m_res_dest = tile;

    44

			m_res_dest_td = td;

    45

			return false;   // Stop iterating segment

    46

		}

    47

		return true;

    48

	}

    49

    50

	/** Reserve a railway platform. Tile contains the failed tile on abort. */

    51

	bool ReserveRailwayStationPlatform(TileIndex &tile, DiagDirection dir)

    52

	{

    53

		TileIndex     start = tile;

    54

		TileIndexDiff diff = TileOffsByDiagDir(dir);

    55

    56

		do {

    57

			if (GetRailwayStationReservation(tile)) return false;

    58

			SetRailwayStationReservation(tile, true);

    59

			MarkTileDirtyByTile(tile);

    60

			tile = TILE_ADD(tile, diff);

    61

		} while (IsCompatibleTrainStationTile(tile, start));

    62

    63

		return true;

    64

	}

    65

    66

	/** Try to reserve a single track/platform. */

    67

	bool ReserveSingleTrack(TileIndex tile, Trackdir td)

    68

	{

    69

		if (IsRailwayStationTile(tile)) {

    70

			if (!ReserveRailwayStationPlatform(tile, TrackdirToExitdir(ReverseTrackdir(td)))) {

    71

				/* Platform could not be reserved, undo. */

    72

				m_res_fail_tile = tile;

    73

				m_res_fail_td = td;

    74

			}

    75

		} else {

    76

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

    77

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

    78

				m_res_fail_tile = tile;

    79

				m_res_fail_td = td;

    80

				return false;

    81

			}

    82

		}

    83

    84

		return tile != m_res_dest;

    85

	}

    86

    87

	/** Unreserve a single track/platform. Stops when the previous failer is reached. */

    88

	bool UnreserveSingleTrack(TileIndex tile, Trackdir td)

    89

	{

    90

		if (IsRailwayStationTile(tile)) {

    91

			TileIndex     start = tile;

    92

			TileIndexDiff diff = TileOffsByDiagDir(TrackdirToExitdir(ReverseTrackdir(td)));

    93

			while ((tile != m_res_fail_tile || td != m_res_fail_td) && IsCompatibleTrainStationTile(tile, start)) {

    94

				SetRailwayStationReservation(tile, false);

    95

				tile = TILE_ADD(tile, diff);

    96

			}

    97

		} else if (tile != m_res_fail_tile || td != m_res_fail_td) {

    98

			UnreserveRailTrack(tile, TrackdirToTrack(td));

    99

		}

   100

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

   101

	}

   102

   103

public:

   104

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

   105

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

   106

	{

   107

		m_res_node = node;

   108

		m_res_dest = tile;

   109

		m_res_dest_td = td;

   110

	}

   111

   112

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

   113

	inline void FindSafePositionOnNode(Node *node)

   114

	{

   115

		assert(node->m_parent != NULL);

   116

   117

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

   118

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

   119

   120

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

   121

			m_res_node = node;

   122

		}

   123

	}

   124

   125

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

   126

	bool TryReservePath(PBSTileInfo *target)

   127

	{

   128

		m_res_fail_tile = INVALID_TILE;

   129

   130

		if (target != NULL) {

   131

			target->tile = m_res_dest;

   132

			target->trackdir = m_res_dest_td;

   133

			target->okay = false;

   134

		}

   135

   136

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

   137

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

   138

   139

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

   140

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

   141

			if (m_res_fail_tile != INVALID_TILE) {

   142

				/* Reservation failed, undo. */

   143

				Node *fail_node = m_res_node;

   144

				TileIndex stop_tile = m_res_fail_tile;

   145

				do {

   146

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

   147

					m_res_fail_tile = fail_node == node ? stop_tile : INVALID_TILE;

   148

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

   149

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

   150

   151

				return false;

   152

			}

   153

		}

   154

   155

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

   156

   157

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

   158

			YapfNotifyTrackLayoutChange(INVALID_TILE, INVALID_TRACK);

   159

   160

		return true;

   161

	}

   162

};

   163

   164

template <class Types>

   165

class CYapfFollowAnyDepotRailT

   166

{

   167

public:

   168

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

   169

	typedef typename Types::TrackFollower TrackFollower;

   170

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

   171

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

   172

   173

protected:

   174

	/// to access inherited path finder

   175

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

   176

   177

public:

   178

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

   179

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

   180

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

   181

	inline void PfFollowNode(Node& old_node)

   182

	{

   183

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

   184

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

   185

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

   186

	}

   187

   188

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

   189

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

   190

   191

	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)

   192

	{

   193

		Tpf pf1;

   194

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

   195

   196

#if DEBUG_YAPF_CACHE

   197

		Tpf pf2;

   198

		TileIndex depot_tile2 = INVALID_TILE;

   199

		bool reversed2 = false;

   200

		pf2.DisableCache(true);

   201

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

   202

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

   203

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

   204

		}

   205

#endif

   206

   207

		return result1;

   208

	}

   209

   210

	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)

   211

	{

   212

		// set origin and destination nodes

   213

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

   214

		Yapf().SetDestination(v);

   215

		Yapf().SetMaxCost(YAPF_TILE_LENGTH * max_distance);

   216

   217

		// find the best path

   218

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

   219

		if (!bFound) return false;

   220

   221

		// some path found

   222

		// get found depot tile

   223

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

   224

		*depot_tile = n->GetLastTile();

   225

   226

		// walk through the path back to the origin

   227

		Node *pNode = n;

   228

		while (pNode->m_parent != NULL) {

   229

			pNode = pNode->m_parent;

   230

		}

   231

   232

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

   233

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

   234

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

   235

   236

		return true;

   237

	}

   238

};

   239

   240

template <class Types>

   241

class CYapfFollowAnySafeTileRailT : protected CYapfReserveTrack<Types>

   242

{

   243

public:

   244

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

   245

	typedef typename Types::TrackFollower TrackFollower;

   246

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

   247

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

   248

   249

protected:

   250

	/// to access inherited path finder

   251

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

   252

   253

public:

   254

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

   255

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

   256

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

   257

	inline void PfFollowNode(Node& old_node)

   258

	{

   259

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

   260

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

   261

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

   262

	}

   263

   264

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

   265

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

   266

   267

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

   268

	{

   269

		/* Create pathfinder instance */

   270

		Tpf pf1;

   271

#if !DEBUG_YAPF_CACHE

   272

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

   273

   274

#else

   275

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

   276

		Tpf pf2;

   277

		pf2.DisableCache(true);

   278

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

   279

		if (result1 != result2) {

   280

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

   281

			DumpTarget dmp1, dmp2;

   282

			pf1.DumpBase(dmp1);

   283

			pf2.DumpBase(dmp2);

   284

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

   285

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

   286

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

   287

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

   288

			fclose(f1);

   289

			fclose(f2);

   290

		}

   291

#endif

   292

   293

		return result1;

   294

	}

   295

   296

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

   297

	{

   298

		/* Set origin and destination. */

   299

		Yapf().SetOrigin(t1, td);

   300

		Yapf().SetDestination(v, override_railtype);

   301

   302

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

   303

		if (!bFound) return false;

   304

   305

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

   306

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

   307

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

   308

   309

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

   310

		Node* pPrev = NULL;

   311

		while (pNode->m_parent != NULL) {

   312

			pPrev = pNode;

   313

			pNode = pNode->m_parent;

   314

   315

			this->FindSafePositionOnNode(pPrev);

   316

		}

   317

   318

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

   319

	}

   320

};

   321

   322

template <class Types>

   323

class CYapfFollowRailT : protected CYapfReserveTrack<Types>

   324

{

   325

public:

   326

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

   327

	typedef typename Types::TrackFollower TrackFollower;

   328

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

   329

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

   330

   331

protected:

   332

	/// to access inherited path finder

   333

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

   334

   335

public:

   336

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

   337

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

   338

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

   339

	inline void PfFollowNode(Node& old_node)

   340

	{

   341

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

   342

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

   343

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

   344

	}

   345

   346

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

   347

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

   348

   349

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

   350

	{

   351

		// create pathfinder instance

   352

		Tpf pf1;

   353

#if !DEBUG_YAPF_CACHE

   354

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

   355

   356

#else

   357

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

   358

		Tpf pf2;

   359

		pf2.DisableCache(true);

   360

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

   361

		if (result1 != result2) {

   362

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

   363

			DumpTarget dmp1, dmp2;

   364

			pf1.DumpBase(dmp1);

   365

			pf2.DumpBase(dmp2);

   366

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

   367

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

   368

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

   369

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

   370

			fclose(f1);

   371

			fclose(f2);

   372

		}

   373

#endif

   374

   375

		return result1;

   376

	}

   377

   378

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

   379

	{

   380

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

   381

   382

		// set origin and destination nodes

   383

		PBSTileInfo origin = FollowTrainReservation(v);

   384

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

   385

		Yapf().SetDestination(v);

   386

   387

		// find the best path

   388

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

   389

		if (path_not_found != NULL) {

   390

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

   391

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

   392

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

   393

		}

   394

   395

		// if path not found - return INVALID_TRACKDIR

   396

		Trackdir next_trackdir = INVALID_TRACKDIR;

   397

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

   398

		if (pNode != NULL) {

   399

			// reserve till end of path

   400

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

   401

   402

			// path was found or at least suggested

   403

			// walk through the path back to the origin

   404

			Node* pPrev = NULL;

   405

			while (pNode->m_parent != NULL) {

   406

				pPrev = pNode;

   407

				pNode = pNode->m_parent;

   408

   409

				this->FindSafePositionOnNode(pPrev);

   410

			}

   411

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

   412

			Node& best_next_node = *pPrev;

   413

			next_trackdir = best_next_node.GetTrackdir();

   414

   415

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

   416

		}

   417

		return next_trackdir;

   418

	}

   419

   420

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

   421

	{

   422

		Tpf pf1;

   423

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

   424

   425

#if DEBUG_YAPF_CACHE

   426

		Tpf pf2;

   427

		pf2.DisableCache(true);

   428

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

   429

		if (result1 != result2) {

   430

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

   431

		}

   432

#endif

   433

   434

		return result1;

   435

	}

   436

   437

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

   438

	{

   439

		// create pathfinder instance

   440

		// set origin and destination nodes

   441

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

   442

		Yapf().SetDestination(v);

   443

   444

		// find the best path

   445

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

   446

   447

		if (!bFound) return false;

   448

   449

		// path was found

   450

		// walk through the path back to the origin

   451

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

   452

		while (pNode->m_parent != NULL) {

   453

			pNode = pNode->m_parent;

   454

		}

   455

   456

		// check if it was reversed origin

   457

		Node& best_org_node = *pNode;

   458

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

   459

		return reversed;

   460

	}

   461

};

   462

   463

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

   464

struct CYapfRail_TypesT

   465

{

   466

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

   467

   468

	typedef Tpf_                                Tpf;

   469

	typedef Ttrack_follower                     TrackFollower;

   470

	typedef Tnode_list                          NodeList;

   471

	typedef CYapfBaseT<Types>                   PfBase;

   472

	typedef TfollowT<Types>                     PfFollow;

   473

	typedef CYapfOriginTileTwoWayT<Types>       PfOrigin;

   474

	typedef TdestinationT<Types>                PfDestination;

   475

	typedef CYapfSegmentCostCacheGlobalT<Types> PfCache;

   476

	typedef CYapfCostRailT<Types>               PfCost;

   477

};

   478

   479

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

   480

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

   481

   482

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

   483

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

   484

   485

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

   486

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

   487

   488

   489

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

   490

{

   491

	// default is YAPF type 2

   492

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

   493

	PfnChooseRailTrack pfnChooseRailTrack = &CYapfRail1::stChooseRailTrack;

   494

   495

	// check if non-default YAPF type needed

   496

	if (_settings_game.pf.forbid_90_deg) {

   497

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

   498

	}