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

    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/ of w/o 90-deg turns allowed */

    14

template <TransportType Ttr_type_, bool T90deg_turns_allowed_ = true>

    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

	};

    24

    25

	const Vehicle*      m_veh;           ///< moving vehicle

    26

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

    27

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

    28

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

    29

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

    30

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

    31

	bool                m_is_tunnel;     ///< last turn passed tunnel

    32

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

    33

	bool                m_is_station;    ///< last turn passed station

    34

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

    35

	ErrorCode           m_err;

    36

	CPerformanceTimer* m_pPerf;

    37

    38

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

    39

	{

    40

		Init(v, pPerf);

    41

	}

    42

    43

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

    44

	{

    45

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

    46

		m_veh = v;

    47

		m_pPerf = pPerf;

    48

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

    49

		m_new_tile = INVALID_TILE;

    50

		m_new_td_bits = TRACKDIR_BIT_NONE;

    51

		m_exitdir = INVALID_DIAGDIR;

    52

		m_is_station = m_is_bridge = m_is_tunnel = false;

    53

		m_tiles_skipped = 0;

    54

		m_err = EC_NONE;

    55

	}

    56

    57

	FORCEINLINE static TransportType TT() {return Ttr_type_;}

    58

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

    59

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

    60

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

    61

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

    62

	FORCEINLINE static bool Allow90degTurns() {return T90deg_turns_allowed_;}

    63

    64

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

    65

	FORCEINLINE DiagDirection GetSingleTramBit(TileIndex tile)

    66

	{

    67

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

    68

			RoadBits rb = GetRoadBits(tile, ROADTYPE_TRAM);

    69

			switch (rb) {

    70

				case ROAD_NW: return DIAGDIR_NW;

    71

				case ROAD_SW: return DIAGDIR_SW;

    72

				case ROAD_SE: return DIAGDIR_SE;

    73

				case ROAD_NE: return DIAGDIR_NE;

    74

				default: break;

    75

			}

    76

		}

    77

		return INVALID_DIAGDIR;

    78

	}

    79

    80

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

    81

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

    82

	FORCEINLINE bool Follow(TileIndex old_tile, Trackdir old_td)

    83

	{

    84

		m_old_tile = old_tile;

    85

		m_old_td = old_td;

    86

		m_err = EC_NONE;

    87

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

    88

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

    89

		m_exitdir = TrackdirToExitdir(m_old_td);

    90

		if (ForcedReverse()) return true;

    91

		if (!CanExitOldTile()) return false;

    92

		FollowTileExit();

    93

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

    94

		if (!CanEnterNewTile()) return false;

    95

		m_new_td_bits &= DiagdirReachesTrackdirs(m_exitdir);

    96

		if (m_new_td_bits == TRACKDIR_BIT_NONE) {

    97

			m_err = EC_NO_WAY;

    98

			return false;

    99

		}

   100

		if (!Allow90degTurns()) {

   101

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

   102

			if (m_new_td_bits == TRACKDIR_BIT_NONE) {

   103

				m_err = EC_90DEG;

   104

				return false;

   105

			}

   106

		}

   107

		return true;

   108

	}

   109

   110

protected:

   111

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

   112

	FORCEINLINE void FollowTileExit()

   113

	{

   114

		m_is_station = m_is_bridge = m_is_tunnel = false;

   115

		m_tiles_skipped = 0;

   116

   117

		// extra handling for tunnels and bridges in our direction

   118

		if (IsTileType(m_old_tile, MP_TUNNELBRIDGE)) {

   119

			DiagDirection enterdir = GetTunnelBridgeDirection(m_old_tile);

   120

			if (enterdir == m_exitdir) {

   121

				// we are entering the tunnel / bridge

   122

				if (IsTunnel(m_old_tile)) {

   123

					m_is_tunnel = true;

   124

					m_new_tile = GetOtherTunnelEnd(m_old_tile);

   125

				} else { // IsBridge(m_old_tile)

   126

					m_is_bridge = true;

   127

					m_new_tile = GetOtherBridgeEnd(m_old_tile);

   128

				}

   129

				m_tiles_skipped = GetTunnelBridgeLength(m_new_tile, m_old_tile);

   130

				return;

   131

			}

   132

			assert(ReverseDiagDir(enterdir) == m_exitdir);

   133

		}

   134

   135

		// normal or station tile, do one step

   136

		TileIndexDiff diff = TileOffsByDiagDir(m_exitdir);

   137

		m_new_tile = TILE_ADD(m_old_tile, diff);

   138

   139

		// special handling for stations

   140

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

   141

			m_is_station = true;

   142

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

   143

			m_is_station = true;

   144

		} else {

   145

			m_is_station = false;

   146

		}

   147

	}

   148

   149

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

   150

	FORCEINLINE bool QueryNewTileTrackStatus()

   151

	{

   152

		CPerfStart perf(*m_pPerf);

   153

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

   154

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

   155

		} else {

   156

			m_new_td_bits = TrackStatusToTrackdirBits(GetTileTrackStatus(m_new_tile, TT(), m_veh->u.road.compatible_roadtypes));

   157

   158

			if (m_new_td_bits == 0) {

   159

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

   160

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

   161

				switch (GetSingleTramBit(m_new_tile)) {

   162

					case DIAGDIR_NE:

   163

					case DIAGDIR_SW:

   164

						m_new_td_bits = TRACKDIR_BIT_X_NE | TRACKDIR_BIT_X_SW;

   165

						break;

   166

   167

					case DIAGDIR_NW:

   168

					case DIAGDIR_SE:

   169

						m_new_td_bits = TRACKDIR_BIT_Y_NW | TRACKDIR_BIT_Y_SE;

   170

						break;

   171

   172

					default: break;

   173

				}

   174

			}

   175

		}

   176

		return (m_new_td_bits != TRACKDIR_BIT_NONE);

   177

	}

   178

   179

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

   180

	FORCEINLINE bool CanExitOldTile()

   181

	{

   182

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

   183

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

   184

			DiagDirection exitdir = GetRoadStopDir(m_old_tile);

   185

			if (exitdir != m_exitdir) {

   186

				m_err = EC_NO_WAY;

   187

				return false;

   188

			}

   189

		}

   190

   191

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

   192

		DiagDirection single_tram = GetSingleTramBit(m_old_tile);

   193

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

   194

			m_err = EC_NO_WAY;

   195

			return false;

   196

		}

   197

   198

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

   199

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

   200

			DiagDirection exitdir = GetRoadDepotDirection(m_old_tile);

   201

			if (exitdir != m_exitdir) {

   202

				m_err = EC_NO_WAY;

   203

				return false;

   204

			}

   205

		}

   206

		return true;

   207

	}

   208

   209

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

   210

	FORCEINLINE bool CanEnterNewTile()

   211

	{

   212

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

   213

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

   214

			DiagDirection exitdir = GetRoadStopDir(m_new_tile);

   215

			if (ReverseDiagDir(exitdir) != m_exitdir) {

   216

				m_err = EC_NO_WAY;

   217

				return false;

   218

			}

   219

		}

   220

   221

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

   222

		DiagDirection single_tram = GetSingleTramBit(m_new_tile);

   223

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

   224

			m_err = EC_NO_WAY;

   225

			return false;

   226

		}

   227

   228

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

   229

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

   230

			DiagDirection exitdir = GetRoadDepotDirection(m_new_tile);

   231

			if (ReverseDiagDir(exitdir) != m_exitdir) {

   232

				m_err = EC_NO_WAY;

   233

				return false;

   234

			}

   235

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

   236

			if (GetTileOwner(m_new_tile) != m_veh->owner) {

   237

				m_err = EC_OWNER;

   238

				return false;

   239

			}

   240

		}

   241

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

   242

			DiagDirection exitdir = GetRailDepotDirection(m_new_tile);

   243

			if (ReverseDiagDir(exitdir) != m_exitdir) {

   244

				m_err = EC_NO_WAY;

   245

				return false;

   246

			}

   247

		}

   248

   249

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

   250

		if (IsRailTT() && GetTileOwner(m_new_tile) != m_veh->owner) {

   251

			// different owner

   252

			m_err = EC_NO_WAY;

   253

			return false;

   254

		}

   255

   256

		// rail transport is possible only on compatible rail types

   257

		if (IsRailTT()) {

   258

			RailType rail_type = GetTileRailType(m_new_tile);

   259

			if (!HasBit(m_veh->u.rail.compatible_railtypes, rail_type)) {

   260

				// incompatible rail type

   261

				m_err = EC_RAIL_TYPE;

   262

				return false;

   263

			}

   264

		}

   265

   266

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

   267

		if (!IsWaterTT() && IsTileType(m_new_tile, MP_TUNNELBRIDGE)) {

   268

			if (IsTunnel(m_new_tile)) {

   269

				if (!m_is_tunnel) {

   270

					DiagDirection tunnel_enterdir = GetTunnelBridgeDirection(m_new_tile);

   271

					if (tunnel_enterdir != m_exitdir) {

   272

						m_err = EC_NO_WAY;

   273

						return false;

   274

					}

   275

				}

   276

			} else { // IsBridge(m_new_tile)

   277

				if (!m_is_bridge) {

   278

					DiagDirection ramp_enderdir = GetTunnelBridgeDirection(m_new_tile);

   279

					if (ramp_enderdir != m_exitdir) {

   280

						m_err = EC_NO_WAY;

   281

						return false;

   282

					}

   283

				}

   284

			}

   285

		}

   286

   287

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

   288

		if (IsRailTT() && m_is_station) {

   289

			// entered railway station

   290

			// get platform length

   291

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

   292

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

   293

			m_tiles_skipped = length - 1;

   294

			// move to the platform end

   295

			TileIndexDiff diff = TileOffsByDiagDir(m_exitdir);

   296

			diff *= m_tiles_skipped;

   297

			m_new_tile = TILE_ADD(m_new_tile, diff);

   298

			return true;

   299

		}

   300

   301

		return true;

   302

	}

   303

   304

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

   305

	FORCEINLINE bool ForcedReverse()

   306

	{

   307

		// rail and road depots cause reversing

   308

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

   309

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

   310

			if (exitdir != m_exitdir) {

   311

				// reverse

   312

				m_new_tile = m_old_tile;

   313

				m_new_td_bits = TrackdirToTrackdirBits(ReverseTrackdir(m_old_td));

   314

				m_exitdir = exitdir;

   315

				m_tiles_skipped = 0;

   316

				m_is_tunnel = m_is_bridge = m_is_station = false;

   317

				return true;

   318

			}

   319

		}

   320

   321

		// single tram bits cause reversing

   322

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

   323

			// reverse

   324

			m_new_tile = m_old_tile;

   325

			m_new_td_bits = TrackdirToTrackdirBits(ReverseTrackdir(m_old_td));

   326

			m_exitdir = ReverseDiagDir(m_exitdir);

   327

			m_tiles_skipped = 0;

   328

			m_is_tunnel = m_is_bridge = m_is_station = false;

   329

			return true;

   330

		}

   331

   332

		return false;

   333

	}

   334

   335

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

   336

	FORCEINLINE bool TryReverse()

   337

	{

   338

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

   339

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

   340

			m_exitdir = ReverseDiagDir(m_exitdir);

   341

			// new tile will be the same as old one

   342

			m_new_tile = m_old_tile;

   343

			// set new trackdir bits to all reachable trackdirs

   344

			QueryNewTileTrackStatus();

   345

			m_new_td_bits &= DiagdirReachesTrackdirs(m_exitdir);

   346

			if (m_new_td_bits != TRACKDIR_BIT_NONE) {

   347

				// we have some trackdirs reachable after reversal

   348

				return true;

   349

			}

   350

		}

   351

		m_err = EC_NO_WAY;

   352

		return false;

   353

	}

   354

   355

public:

   356

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

   357

	int GetSpeedLimit(int *pmin_speed = NULL) const

   358

	{

   359

		int min_speed = 0;

   360

		int max_speed = INT_MAX; // no limit

   361

   362

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

   363

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

   364

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

   365

			if (IsRoadTT()) spd *= 2;

   366

			if (max_speed > spd) max_speed = spd;

   367

		}

   368

   369

		// if min speed was requested, return it

   370

		if (pmin_speed) *pmin_speed = min_speed;

   371

		return max_speed;

   372

	}

   373

};

   374

   375

typedef CFollowTrackT<TRANSPORT_WATER, true > CFollowTrackWater;

   376

typedef CFollowTrackT<TRANSPORT_ROAD , true > CFollowTrackRoad;

   377

typedef CFollowTrackT<TRANSPORT_RAIL , true > CFollowTrackRail;

   378

   379

typedef CFollowTrackT<TRANSPORT_WATER, false> CFollowTrackWaterNo90;

   380

typedef CFollowTrackT<TRANSPORT_ROAD , false> CFollowTrackRoadNo90;

   381

typedef CFollowTrackT<TRANSPORT_RAIL , false> CFollowTrackRailNo90;

   382

   383

#endif /* FOLLOW_TRACK_HPP */