1

/* $Id$ */

     2

     3

/** @file follow_track.hpp Template function for track followers */

     4

     5

#ifndef  FOLLOW_TRACK_HPP

     6

#define  FOLLOW_TRACK_HPP

     7

     8

#include "yapf.hpp"

     9

#include "../depot_map.h"

    10

    11

/** Track follower helper template class (can serve pathfinders and vehicle

    12

 *  controllers). See 6 different typedefs below for 3 different transport

    13

 *  types w/ or w/o 90-deg turns allowed */

    14

template <TransportType Ttr_type_, bool T90deg_turns_allowed_ = true, bool Tmask_reserved_tracks = false>

    15

struct CFollowTrackT

    16

{

    17

	enum ErrorCode {

    18

		EC_NONE,

    19

		EC_OWNER,

    20

		EC_RAIL_TYPE,

    21

		EC_90DEG,

    22

		EC_NO_WAY,

    23

		EC_RESERVED,

    24

	};

    25

    26

	const Vehicle      *m_veh;           ///< moving vehicle

    27

	Owner               m_veh_owner;     ///< owner of the vehicle

    28

	TileIndex           m_old_tile;      ///< the origin (vehicle moved from) before move

    29

	Trackdir            m_old_td;        ///< the trackdir (the vehicle was on) before move

    30

	TileIndex           m_new_tile;      ///< the new tile (the vehicle has entered)

    31

	TrackdirBits        m_new_td_bits;   ///< the new set of available trackdirs

    32

	DiagDirection       m_exitdir;       ///< exit direction (leaving the old tile)

    33

	bool                m_is_tunnel;     ///< last turn passed tunnel

    34

	bool                m_is_bridge;     ///< last turn passed bridge ramp

    35

	bool                m_is_station;    ///< last turn passed station

    36

	int                 m_tiles_skipped; ///< number of skipped tunnel or station tiles

    37

	ErrorCode           m_err;

    38

	CPerformanceTimer  *m_pPerf;

    39

	RailTypes           m_railtypes;

    40

    41

	FORCEINLINE CFollowTrackT(const Vehicle *v = NULL, RailTypes railtype_override = INVALID_RAILTYPES, CPerformanceTimer *pPerf = NULL)

    42

	{

    43

		Init(v, railtype_override, pPerf);

    44

	}

    45

    46

	FORCEINLINE CFollowTrackT(Owner o, RailTypes railtype_override = INVALID_RAILTYPES, CPerformanceTimer *pPerf = NULL)

    47

	{

    48

		m_veh = NULL;

    49

		Init(o, railtype_override, pPerf);

    50

	}

    51

    52

	FORCEINLINE void Init(const Vehicle *v, RailTypes railtype_override, CPerformanceTimer *pPerf)

    53

	{

    54

		assert(!IsRailTT() || (v != NULL && v->type == VEH_TRAIN));

    55

		m_veh = v;

    56

		Init(v != NULL ? v->owner : INVALID_OWNER, railtype_override == INVALID_RAILTYPES ? v->u.rail.compatible_railtypes : railtype_override, pPerf);

    57

	}

    58

    59

	FORCEINLINE void Init(Owner o, RailTypes railtype_override, CPerformanceTimer *pPerf)

    60

	{

    61

		assert((!IsRoadTT() || m_veh != NULL) && (!IsRailTT() || railtype_override != INVALID_RAILTYPES));

    62

		m_veh_owner = o;

    63

		m_pPerf = pPerf;

    64

		// don't worry, all is inlined so compiler should remove unnecessary initializations

    65

		m_new_tile = INVALID_TILE;

    66

		m_new_td_bits = TRACKDIR_BIT_NONE;

    67

		m_exitdir = INVALID_DIAGDIR;

    68

		m_is_station = m_is_bridge = m_is_tunnel = false;

    69

		m_tiles_skipped = 0;

    70

		m_err = EC_NONE;

    71

		m_railtypes = railtype_override;

    72

	}

    73

    74

	FORCEINLINE static TransportType TT() {return Ttr_type_;}

    75

	FORCEINLINE static bool IsWaterTT() {return TT() == TRANSPORT_WATER;}

    76

	FORCEINLINE static bool IsRailTT() {return TT() == TRANSPORT_RAIL;}

    77

	FORCEINLINE bool IsTram() {return IsRoadTT() && HasBit(m_veh->u.road.compatible_roadtypes, ROADTYPE_TRAM);}

    78

	FORCEINLINE static bool IsRoadTT() {return TT() == TRANSPORT_ROAD;}

    79

	FORCEINLINE static bool Allow90degTurns() {return T90deg_turns_allowed_;}

    80

	FORCEINLINE static bool DoTrackMasking() {return IsRailTT() && Tmask_reserved_tracks;}

    81

    82

	/** Tests if a tile is a road tile with a single tramtrack (tram can reverse) */

    83

	FORCEINLINE DiagDirection GetSingleTramBit(TileIndex tile)

    84

	{

    85

		if (IsTram() && IsNormalRoadTile(tile)) {

    86

			RoadBits rb = GetRoadBits(tile, ROADTYPE_TRAM);

    87

			switch (rb) {

    88

				case ROAD_NW: return DIAGDIR_NW;

    89

				case ROAD_SW: return DIAGDIR_SW;

    90

				case ROAD_SE: return DIAGDIR_SE;

    91

				case ROAD_NE: return DIAGDIR_NE;

    92

				default: break;

    93

			}

    94

		}

    95

		return INVALID_DIAGDIR;

    96

	}

    97

    98

	/** main follower routine. Fills all members and return true on success.

    99

	 *  Otherwise returns false if track can't be followed. */

   100

	inline bool Follow(TileIndex old_tile, Trackdir old_td)

   101

	{

   102

		m_old_tile = old_tile;

   103

		m_old_td = old_td;

   104

		m_err = EC_NONE;

   105

		assert(((TrackStatusToTrackdirBits(GetTileTrackStatus(m_old_tile, TT(), m_veh ? m_veh->u.road.compatible_roadtypes : 0)) & TrackdirToTrackdirBits(m_old_td)) != 0) ||

   106

		       (GetSingleTramBit(m_old_tile) != INVALID_DIAGDIR)); // Disable the assertion for single tram bits

   107

		m_exitdir = TrackdirToExitdir(m_old_td);

   108

		if (ForcedReverse()) return true;

   109

		if (!CanExitOldTile()) return false;

   110

		FollowTileExit();

   111

		if (!QueryNewTileTrackStatus()) return TryReverse();

   112

		if (!CanEnterNewTile()) return false;

   113

		m_new_td_bits &= DiagdirReachesTrackdirs(m_exitdir);

   114

		if (m_new_td_bits == TRACKDIR_BIT_NONE) {

   115

			m_err = EC_NO_WAY;

   116

			return false;

   117

		}

   118

		if (!Allow90degTurns()) {

   119

			m_new_td_bits &= (TrackdirBits)~(int)TrackdirCrossesTrackdirs(m_old_td);

   120

			if (m_new_td_bits == TRACKDIR_BIT_NONE) {

   121

				m_err = EC_90DEG;

   122

				return false;

   123

			}

   124

		}

   125

		return true;

   126

	}

   127

   128

	inline bool MaskReservedTracks()

   129

	{

   130

		if (!DoTrackMasking()) return true;

   131

   132

		if (m_is_station) {

   133

			/* Check skipped station tiles as well. */

   134

			TileIndexDiff diff = TileOffsByDiagDir(m_exitdir);

   135

			for (TileIndex tile = m_new_tile - diff * m_tiles_skipped; tile != m_new_tile; tile += diff) {

   136

				if (GetRailwayStationReservation(tile)) {

   137

					m_new_td_bits = TRACKDIR_BIT_NONE;

   138

					m_err = EC_RESERVED;

   139

					return false;

   140

				}

   141

			}

   142

		}

   143

   144

		TrackBits reserved = GetReservedTrackbits(m_new_tile);

   145

		/* Mask already reserved trackdirs. */

   146

		m_new_td_bits &= ~TrackBitsToTrackdirBits(reserved);

   147

		/* Mask out all trackdirs that conflict with the reservation. */

   148

		uint bits = (uint)TrackdirBitsToTrackBits(m_new_td_bits);

   149

		int i;

   150

		FOR_EACH_SET_BIT(i, bits) {

   151

			if (TracksOverlap(reserved | TrackToTrackBits((Track)i))) m_new_td_bits &= ~TrackToTrackdirBits((Track)i);

   152

		}

   153

		if (m_new_td_bits == TRACKDIR_BIT_NONE) {

   154

			m_err = EC_RESERVED;

   155

			return false;

   156

		}

   157

		return true;

   158

	}

   159

   160

protected:

   161

	/** Follow the m_exitdir from m_old_tile and fill m_new_tile and m_tiles_skipped */

   162

	FORCEINLINE void FollowTileExit()

   163

	{

   164

		m_is_station = m_is_bridge = m_is_tunnel = false;

   165

		m_tiles_skipped = 0;

   166

   167

		// extra handling for tunnels and bridges in our direction

   168

		if (IsTileType(m_old_tile, MP_TUNNELBRIDGE)) {

   169

			DiagDirection enterdir = GetTunnelBridgeDirection(m_old_tile);

   170

			if (enterdir == m_exitdir) {

   171

				// we are entering the tunnel / bridge

   172

				if (IsTunnel(m_old_tile)) {

   173

					m_is_tunnel = true;

   174

					m_new_tile = GetOtherTunnelEnd(m_old_tile);

   175

				} else { // IsBridge(m_old_tile)

   176

					m_is_bridge = true;

   177

					m_new_tile = GetOtherBridgeEnd(m_old_tile);

   178

				}

   179

				m_tiles_skipped = GetTunnelBridgeLength(m_new_tile, m_old_tile);

   180

				return;

   181

			}

   182

			assert(ReverseDiagDir(enterdir) == m_exitdir);

   183

		}

   184

   185

		// normal or station tile, do one step

   186

		TileIndexDiff diff = TileOffsByDiagDir(m_exitdir);

   187

		m_new_tile = TILE_ADD(m_old_tile, diff);

   188

   189

		// special handling for stations

   190

		if (IsRailTT() && IsRailwayStationTile(m_new_tile)) {

   191

			m_is_station = true;

   192

		} else if (IsRoadTT() && IsRoadStopTile(m_new_tile)) {

   193

			m_is_station = true;

   194

		} else {

   195

			m_is_station = false;

   196

		}

   197

	}

   198

   199

	/** stores track status (available trackdirs) for the new tile into m_new_td_bits */

   200

	FORCEINLINE bool QueryNewTileTrackStatus()

   201

	{

   202

		CPerfStart perf(*m_pPerf);

   203

		if (IsRailTT() && GetTileType(m_new_tile) == MP_RAILWAY && IsPlainRailTile(m_new_tile)) {

   204

			m_new_td_bits = (TrackdirBits)(GetTrackBits(m_new_tile) * 0x101);

   205

		} else {

   206

			m_new_td_bits = TrackStatusToTrackdirBits(GetTileTrackStatus(m_new_tile, TT(), m_veh != NULL ? m_veh->u.road.compatible_roadtypes : 0));

   207

   208

			if (m_new_td_bits == 0) {

   209

				/* GetTileTrackStatus() returns 0 for single tram bits.

   210

				 * As we cannot change it there (easily) without breaking something, change it here */

   211

				switch (GetSingleTramBit(m_new_tile)) {

   212

					case DIAGDIR_NE:

   213

					case DIAGDIR_SW:

   214

						m_new_td_bits = TRACKDIR_BIT_X_NE | TRACKDIR_BIT_X_SW;

   215

						break;

   216

   217

					case DIAGDIR_NW:

   218

					case DIAGDIR_SE:

   219

						m_new_td_bits = TRACKDIR_BIT_Y_NW | TRACKDIR_BIT_Y_SE;

   220

						break;

   221

   222

					default: break;

   223

				}

   224

			}

   225

		}

   226

		return (m_new_td_bits != TRACKDIR_BIT_NONE);

   227

	}

   228

   229

	/** return true if we can leave m_old_tile in m_exitdir */

   230

	FORCEINLINE bool CanExitOldTile()

   231

	{

   232

		// road stop can be left at one direction only unless it's a drive-through stop

   233

		if (IsRoadTT() && IsStandardRoadStopTile(m_old_tile)) {

   234

			DiagDirection exitdir = GetRoadStopDir(m_old_tile);

   235

			if (exitdir != m_exitdir) {

   236

				m_err = EC_NO_WAY;

   237

				return false;

   238

			}

   239

		}

   240

   241

		/* single tram bits can only be left in one direction */

   242

		DiagDirection single_tram = GetSingleTramBit(m_old_tile);

   243

		if (single_tram != INVALID_DIAGDIR && single_tram != m_exitdir) {

   244

			m_err = EC_NO_WAY;

   245

			return false;

   246

		}

   247

   248

		// road depots can be also left in one direction only

   249

		if (IsRoadTT() && IsDepotTypeTile(m_old_tile, TT())) {

   250

			DiagDirection exitdir = GetRoadDepotDirection(m_old_tile);

   251

			if (exitdir != m_exitdir) {

   252

				m_err = EC_NO_WAY;

   253

				return false;

   254

			}

   255

		}

   256

		return true;

   257

	}

   258

   259

	/** return true if we can enter m_new_tile from m_exitdir */

   260

	FORCEINLINE bool CanEnterNewTile()

   261

	{

   262

		if (IsRoadTT() && IsStandardRoadStopTile(m_new_tile)) {

   263

			// road stop can be entered from one direction only unless it's a drive-through stop

   264

			DiagDirection exitdir = GetRoadStopDir(m_new_tile);

   265

			if (ReverseDiagDir(exitdir) != m_exitdir) {

   266

				m_err = EC_NO_WAY;

   267

				return false;

   268

			}

   269

		}

   270

   271

		/* single tram bits can only be entered from one direction */

   272

		DiagDirection single_tram = GetSingleTramBit(m_new_tile);

   273

		if (single_tram != INVALID_DIAGDIR && single_tram != ReverseDiagDir(m_exitdir)) {

   274

			m_err = EC_NO_WAY;

   275

			return false;

   276

		}

   277

   278

		// road and rail depots can also be entered from one direction only

   279

		if (IsRoadTT() && IsDepotTypeTile(m_new_tile, TT())) {

   280

			DiagDirection exitdir = GetRoadDepotDirection(m_new_tile);

   281

			if (ReverseDiagDir(exitdir) != m_exitdir) {

   282

				m_err = EC_NO_WAY;

   283

				return false;

   284

			}

   285

			// don't try to enter other player's depots

   286

			if (GetTileOwner(m_new_tile) != m_veh_owner) {

   287

				m_err = EC_OWNER;

   288

				return false;

   289

			}

   290

		}

   291

		if (IsRailTT() && IsDepotTypeTile(m_new_tile, TT())) {

   292

			DiagDirection exitdir = GetRailDepotDirection(m_new_tile);

   293

			if (ReverseDiagDir(exitdir) != m_exitdir) {

   294

				m_err = EC_NO_WAY;

   295

				return false;

   296

			}

   297

		}

   298

   299

		// rail transport is possible only on tiles with the same owner as vehicle

   300

		if (IsRailTT() && GetTileOwner(m_new_tile) != m_veh_owner) {

   301

			// different owner

   302

			m_err = EC_NO_WAY;

   303

			return false;

   304

		}

   305

   306

		// rail transport is possible only on compatible rail types

   307

		if (IsRailTT()) {

   308

			RailType rail_type = GetTileRailType(m_new_tile);

   309

			if (!HasBit(m_railtypes, rail_type)) {

   310

				// incompatible rail type

   311

				m_err = EC_RAIL_TYPE;

   312

				return false;

   313

			}

   314

		}

   315

   316

		// tunnel holes and bridge ramps can be entered only from proper direction

   317

		if (IsTileType(m_new_tile, MP_TUNNELBRIDGE)) {

   318

			if (IsTunnel(m_new_tile)) {

   319

				if (!m_is_tunnel) {

   320

					DiagDirection tunnel_enterdir = GetTunnelBridgeDirection(m_new_tile);

   321

					if (tunnel_enterdir != m_exitdir) {

   322

						m_err = EC_NO_WAY;

   323

						return false;

   324

					}

   325

				}

   326

			} else { // IsBridge(m_new_tile)

   327

				if (!m_is_bridge) {

   328

					DiagDirection ramp_enderdir = GetTunnelBridgeDirection(m_new_tile);

   329

					if (ramp_enderdir != m_exitdir) {

   330

						m_err = EC_NO_WAY;

   331

						return false;

   332

					}

   333

				}

   334

			}

   335

		}

   336

   337

		// special handling for rail stations - get to the end of platform

   338

		if (IsRailTT() && m_is_station) {

   339

			// entered railway station

   340

			// get platform length

   341

			uint length = GetStationByTile(m_new_tile)->GetPlatformLength(m_new_tile, TrackdirToExitdir(m_old_td));

   342

			// how big step we must do to get to the last platform tile;

   343

			m_tiles_skipped = length - 1;

   344

			// move to the platform end

   345

			TileIndexDiff diff = TileOffsByDiagDir(m_exitdir);

   346

			diff *= m_tiles_skipped;

   347

			m_new_tile = TILE_ADD(m_new_tile, diff);

   348

			return true;

   349

		}

   350

   351

		return true;

   352

	}

   353

   354

	/** return true if we must reverse (in depots and single tram bits) */

   355

	FORCEINLINE bool ForcedReverse()

   356

	{

   357

		// rail and road depots cause reversing

   358

		if (!IsWaterTT() && IsDepotTypeTile(m_old_tile, TT())) {

   359

			DiagDirection exitdir = IsRailTT() ? GetRailDepotDirection(m_old_tile) : GetRoadDepotDirection(m_old_tile);

   360

			if (exitdir != m_exitdir) {

   361

				// reverse

   362

				m_new_tile = m_old_tile;

   363

				m_new_td_bits = TrackdirToTrackdirBits(ReverseTrackdir(m_old_td));

   364

				m_exitdir = exitdir;

   365

				m_tiles_skipped = 0;

   366

				m_is_tunnel = m_is_bridge = m_is_station = false;

   367

				return true;

   368

			}

   369

		}

   370

   371

		// single tram bits cause reversing

   372

		if (GetSingleTramBit(m_old_tile) == ReverseDiagDir(m_exitdir)) {

   373

			// reverse

   374

			m_new_tile = m_old_tile;

   375

			m_new_td_bits = TrackdirToTrackdirBits(ReverseTrackdir(m_old_td));

   376

			m_exitdir = ReverseDiagDir(m_exitdir);

   377

			m_tiles_skipped = 0;

   378

			m_is_tunnel = m_is_bridge = m_is_station = false;

   379

			return true;

   380

		}

   381

   382

		return false;

   383

	}

   384

   385

	/** return true if we successfully reversed at end of road/track */

   386

	FORCEINLINE bool TryReverse()

   387

	{

   388

		if (IsRoadTT() && !IsTram()) {

   389

			// if we reached the end of road, we can reverse the RV and continue moving

   390

			m_exitdir = ReverseDiagDir(m_exitdir);

   391

			// new tile will be the same as old one

   392

			m_new_tile = m_old_tile;

   393

			// set new trackdir bits to all reachable trackdirs

   394

			QueryNewTileTrackStatus();

   395

			m_new_td_bits &= DiagdirReachesTrackdirs(m_exitdir);

   396

			if (m_new_td_bits != TRACKDIR_BIT_NONE) {

   397

				// we have some trackdirs reachable after reversal

   398

				return true;

   399

			}

   400

		}

   401

		m_err = EC_NO_WAY;

   402

		return false;

   403

	}

   404

   405

public:

   406

	/** Helper for pathfinders - get min/max speed on the m_old_tile/m_old_td */

   407

	int GetSpeedLimit(int *pmin_speed = NULL) const

   408

	{

   409

		int min_speed = 0;

   410

		int max_speed = INT_MAX; // no limit

   411

   412

		// for now we handle only on-bridge speed limit

   413

		if (!IsWaterTT() && IsBridgeTile(m_old_tile)) {

   414

			int spd = GetBridgeSpec(GetBridgeType(m_old_tile))->speed;

   415

			if (IsRoadTT()) spd *= 2;

   416

			if (max_speed > spd) max_speed = spd;

   417

		}

   418

   419

		// if min speed was requested, return it

   420

		if (pmin_speed) *pmin_speed = min_speed;

   421

		return max_speed;

   422

	}

   423

};

   424

   425

typedef CFollowTrackT<TRANSPORT_WATER, true > CFollowTrackWater;

   426

typedef CFollowTrackT<TRANSPORT_ROAD , true > CFollowTrackRoad;

   427

typedef CFollowTrackT<TRANSPORT_RAIL , true > CFollowTrackRail;

   428

   429

typedef CFollowTrackT<TRANSPORT_WATER, false> CFollowTrackWaterNo90;

   430

typedef CFollowTrackT<TRANSPORT_ROAD , false> CFollowTrackRoadNo90;

   431

typedef CFollowTrackT<TRANSPORT_RAIL , false> CFollowTrackRailNo90;

   432

   433

typedef CFollowTrackT<TRANSPORT_RAIL , true , true> CFollowTrackFreeRail;

   434

typedef CFollowTrackT<TRANSPORT_RAIL , false, true> CFollowTrackFreeRailNo90;

   435

   436

#endif /* FOLLOW_TRACK_HPP */