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/ 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;

    38

    40

	{

    42

	}

    43

    45

	{

    46

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

    47

		m_veh = v;

    48

		m_pPerf = pPerf;

    49

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

    50

		m_new_tile = INVALID_TILE;

    51

		m_new_td_bits = TRACKDIR_BIT_NONE;

    52

		m_exitdir = INVALID_DIAGDIR;

    53

		m_is_station = m_is_bridge = m_is_tunnel = false;

    54

		m_tiles_skipped = 0;

    55

		m_err = EC_NONE;

    57

	}

    58

    59

	FORCEINLINE static TransportType TT() {return Ttr_type_;}

    60

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

    61

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

    62

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

    63

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

    64

	FORCEINLINE static bool Allow90degTurns() {return T90deg_turns_allowed_;}

    65

    66

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

    67

	FORCEINLINE DiagDirection GetSingleTramBit(TileIndex tile)

    68

	{

    69

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

    70

			RoadBits rb = GetRoadBits(tile, ROADTYPE_TRAM);

    71

			switch (rb) {

    72

				case ROAD_NW: return DIAGDIR_NW;

    73

				case ROAD_SW: return DIAGDIR_SW;

    74

				case ROAD_SE: return DIAGDIR_SE;

    75

				case ROAD_NE: return DIAGDIR_NE;

    76

				default: break;

    77

			}

    78

		}

    79

		return INVALID_DIAGDIR;

    80

	}

    81

    82

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

    83

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

    85

	{

    86

		m_old_tile = old_tile;

    87

		m_old_td = old_td;

    88

		m_err = EC_NONE;

    89

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

    90

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

    91

		m_exitdir = TrackdirToExitdir(m_old_td);

    92

		if (ForcedReverse()) return true;

    93

		if (!CanExitOldTile()) return false;

    94

		FollowTileExit();

    95

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

    96

		if (!CanEnterNewTile()) return false;

    97

		m_new_td_bits &= DiagdirReachesTrackdirs(m_exitdir);

    98

		if (m_new_td_bits == TRACKDIR_BIT_NONE) {

    99

			m_err = EC_NO_WAY;

   100

			return false;

   101

		}

   102

		if (!Allow90degTurns()) {

   103

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

   104

			if (m_new_td_bits == TRACKDIR_BIT_NONE) {

   105

				m_err = EC_90DEG;

   106

				return false;

   107

			}

   108

		}

   109

		return true;

   110

	}

   111

   112

protected:

   113

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

   114

	FORCEINLINE void FollowTileExit()

   115

	{

   116

		m_is_station = m_is_bridge = m_is_tunnel = false;

   117

		m_tiles_skipped = 0;

   118

   119

		// extra handling for tunnels and bridges in our direction

   120

		if (IsTileType(m_old_tile, MP_TUNNELBRIDGE)) {

   121

			DiagDirection enterdir = GetTunnelBridgeDirection(m_old_tile);

   122

			if (enterdir == m_exitdir) {

   123

				// we are entering the tunnel / bridge

   124

				if (IsTunnel(m_old_tile)) {

   125

					m_is_tunnel = true;

   126

					m_new_tile = GetOtherTunnelEnd(m_old_tile);

   127

				} else { // IsBridge(m_old_tile)

   128

					m_is_bridge = true;

   129

					m_new_tile = GetOtherBridgeEnd(m_old_tile);

   130

				}

   131

				m_tiles_skipped = GetTunnelBridgeLength(m_new_tile, m_old_tile);

   132

				return;

   133

			}

   134

			assert(ReverseDiagDir(enterdir) == m_exitdir);

   135

		}

   136

   137

		// normal or station tile, do one step

   138

		TileIndexDiff diff = TileOffsByDiagDir(m_exitdir);

   139

		m_new_tile = TILE_ADD(m_old_tile, diff);

   140

   141

		// special handling for stations

   142

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

   143

			m_is_station = true;

   144

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

   145

			m_is_station = true;

   146

		} else {

   147

			m_is_station = false;

   148

		}

   149

	}

   150

   151

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

   152

	FORCEINLINE bool QueryNewTileTrackStatus()

   153

	{

   154

		CPerfStart perf(*m_pPerf);

   155

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

   156

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

   157

		} else {

   158

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

   159

   160

			if (m_new_td_bits == 0) {

   161

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

   162

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

   163

				switch (GetSingleTramBit(m_new_tile)) {

   164

					case DIAGDIR_NE:

   165

					case DIAGDIR_SW:

   166

						m_new_td_bits = TRACKDIR_BIT_X_NE | TRACKDIR_BIT_X_SW;

   167

						break;

   168

   169

					case DIAGDIR_NW:

   170

					case DIAGDIR_SE:

   171

						m_new_td_bits = TRACKDIR_BIT_Y_NW | TRACKDIR_BIT_Y_SE;

   172

						break;

   173

   174

					default: break;

   175

				}

   176

			}

   177

		}

   178

		return (m_new_td_bits != TRACKDIR_BIT_NONE);

   179

	}

   180

   181

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

   182

	FORCEINLINE bool CanExitOldTile()

   183

	{

   184

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

   185

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

   186

			DiagDirection exitdir = GetRoadStopDir(m_old_tile);

   187

			if (exitdir != m_exitdir) {

   188

				m_err = EC_NO_WAY;

   189

				return false;

   190

			}

   191

		}

   192

   193

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

   194

		DiagDirection single_tram = GetSingleTramBit(m_old_tile);

   195

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

   196

			m_err = EC_NO_WAY;

   197

			return false;

   198

		}

   199

   200

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

   201

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

   202

			DiagDirection exitdir = GetRoadDepotDirection(m_old_tile);

   203

			if (exitdir != m_exitdir) {

   204

				m_err = EC_NO_WAY;

   205

				return false;

   206

			}

   207

		}

   208

		return true;

   209

	}

   210

   211

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

   212

	FORCEINLINE bool CanEnterNewTile()

   213

	{

   214

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

   215

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

   216

			DiagDirection exitdir = GetRoadStopDir(m_new_tile);

   217

			if (ReverseDiagDir(exitdir) != m_exitdir) {

   218

				m_err = EC_NO_WAY;

   219

				return false;

   220

			}

   221

		}

   222

   223

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

   224

		DiagDirection single_tram = GetSingleTramBit(m_new_tile);

   225

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

   226

			m_err = EC_NO_WAY;

   227

			return false;

   228

		}

   229

   230

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

   231

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

   232

			DiagDirection exitdir = GetRoadDepotDirection(m_new_tile);

   233

			if (ReverseDiagDir(exitdir) != m_exitdir) {

   234

				m_err = EC_NO_WAY;

   235

				return false;

   236

			}

   237

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

   238

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

   239

				m_err = EC_OWNER;

   240

				return false;

   241

			}

   242

		}

   243

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

   244

			DiagDirection exitdir = GetRailDepotDirection(m_new_tile);

   245

			if (ReverseDiagDir(exitdir) != m_exitdir) {

   246

				m_err = EC_NO_WAY;

   247

				return false;

   248

			}

   249

		}

   250

   251

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

   252

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

   253

			// different owner

   254

			m_err = EC_NO_WAY;

   255

			return false;

   256

		}

   257

   258

		// rail transport is possible only on compatible rail types

   259

		if (IsRailTT()) {

   260

			RailType rail_type = GetTileRailType(m_new_tile);

   262

				// incompatible rail type

   263

				m_err = EC_RAIL_TYPE;

   264

				return false;

   265

			}

   266

		}

   267

   268

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

   269

		if (IsTileType(m_new_tile, MP_TUNNELBRIDGE)) {

   270

			if (IsTunnel(m_new_tile)) {

   271

				if (!m_is_tunnel) {

   272

					DiagDirection tunnel_enterdir = GetTunnelBridgeDirection(m_new_tile);

   273

					if (tunnel_enterdir != m_exitdir) {

   274

						m_err = EC_NO_WAY;

   275

						return false;

   276

					}

   277

				}

   278

			} else { // IsBridge(m_new_tile)

   279

				if (!m_is_bridge) {

   280

					DiagDirection ramp_enderdir = GetTunnelBridgeDirection(m_new_tile);

   281

					if (ramp_enderdir != m_exitdir) {

   282

						m_err = EC_NO_WAY;

   283

						return false;

   284

					}

   285

				}

   286

			}

   287

		}

   288

   289

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

   290

		if (IsRailTT() && m_is_station) {

   291

			// entered railway station

   292

			// get platform length

   293

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

   294

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

   295

			m_tiles_skipped = length - 1;

   296

			// move to the platform end

   297

			TileIndexDiff diff = TileOffsByDiagDir(m_exitdir);

   298

			diff *= m_tiles_skipped;

   299

			m_new_tile = TILE_ADD(m_new_tile, diff);

   300

			return true;

   301

		}

   302

   303

		return true;

   304

	}

   305

   306

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

   307

	FORCEINLINE bool ForcedReverse()

   308

	{

   309

		// rail and road depots cause reversing

   310

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

   311

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

   312

			if (exitdir != m_exitdir) {

   313

				// reverse

   314

				m_new_tile = m_old_tile;

   315

				m_new_td_bits = TrackdirToTrackdirBits(ReverseTrackdir(m_old_td));

   316

				m_exitdir = exitdir;

   317

				m_tiles_skipped = 0;

   318

				m_is_tunnel = m_is_bridge = m_is_station = false;

   319

				return true;

   320

			}

   321

		}

   322

   323

		// single tram bits cause reversing

   324

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

   325

			// reverse

   326

			m_new_tile = m_old_tile;

   327

			m_new_td_bits = TrackdirToTrackdirBits(ReverseTrackdir(m_old_td));

   328

			m_exitdir = ReverseDiagDir(m_exitdir);

   329

			m_tiles_skipped = 0;

   330

			m_is_tunnel = m_is_bridge = m_is_station = false;

   331

			return true;

   332

		}

   333

   334

		return false;

   335

	}

   336

   337

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

   338

	FORCEINLINE bool TryReverse()

   339

	{

   340

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

   341

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

   342

			m_exitdir = ReverseDiagDir(m_exitdir);

   343

			// new tile will be the same as old one

   344

			m_new_tile = m_old_tile;

   345

			// set new trackdir bits to all reachable trackdirs

   346

			QueryNewTileTrackStatus();

   347

			m_new_td_bits &= DiagdirReachesTrackdirs(m_exitdir);

   348

			if (m_new_td_bits != TRACKDIR_BIT_NONE) {

   349

				// we have some trackdirs reachable after reversal

   350

				return true;

   351

			}

   352

		}

   353

		m_err = EC_NO_WAY;

   354

		return false;

   355

	}

   356

   357

public:

   358

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

   359

	int GetSpeedLimit(int *pmin_speed = NULL) const

   360

	{

   361

		int min_speed = 0;

   362

		int max_speed = INT_MAX; // no limit

   363

   364

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

   365

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

   366

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

   367

			if (IsRoadTT()) spd *= 2;

   368

			if (max_speed > spd) max_speed = spd;

   369

		}

   370

   371

		// if min speed was requested, return it

   372

		if (pmin_speed) *pmin_speed = min_speed;

   373

		return max_speed;

   374

	}

   375

};

   376

   377

typedef CFollowTrackT<TRANSPORT_WATER, true > CFollowTrackWater;

   378

typedef CFollowTrackT<TRANSPORT_ROAD , true > CFollowTrackRoad;

   379

typedef CFollowTrackT<TRANSPORT_RAIL , true > CFollowTrackRail;

   380

   381

typedef CFollowTrackT<TRANSPORT_WATER, false> CFollowTrackWaterNo90;

   382

typedef CFollowTrackT<TRANSPORT_ROAD , false> CFollowTrackRoadNo90;

   383

typedef CFollowTrackT<TRANSPORT_RAIL , false> CFollowTrackRailNo90;

   384

   385

#endif /* FOLLOW_TRACK_HPP */