1

/* $Id$ */

     2

     3

/** @file pbs.cpp */

     4

#include "stdafx.h"

     5

#include "openttd.h"

     6

#include "pbs.h"

     7

#include "rail_map.h"

     8

#include "road_map.h"

     9

#include "station_map.h"

    10

#include "tunnelbridge_map.h"

    11

#include "functions.h"

    12

#include "debug.h"

    13

#include "direction_func.h"

    14

#include "settings_type.h"

    15

#include "road_func.h"

    16

#include "vehicle_base.h"

    17

#include "vehicle_func.h"

    18

#include "yapf/follow_track.hpp"

    19

    20

/**

    21

 * Get the reserved trackbits for any tile, regardless of type.

    22

 * @param t the tile

    23

 * @return the reserved trackbits. TRACK_BIT_NONE on nothing reserved or

    24

 *     a tile without rail.

    25

 */

    26

TrackBits GetReservedTrackbits(TileIndex t)

    27

{

    28

	switch (GetTileType(t)) {

    29

		case MP_RAILWAY:

    30

			if (IsRailWaypoint(t) || IsRailDepot(t)) return GetRailWaypointReservation(t);

    31

			if (IsPlainRailTile(t)) return GetTrackReservation(t);

    32

			break;

    33

    34

		case MP_ROAD:

    35

			if (IsLevelCrossing(t)) return GetRailCrossingReservation(t);

    36

			break;

    37

    38

		case MP_STATION:

    39

			if (IsRailwayStation(t)) return GetRailStationReservation(t);

    40

			break;

    41

    42

		case MP_TUNNELBRIDGE:

    43

			if (GetTunnelBridgeTransportType(t) == TRANSPORT_RAIL) return GetRailTunnelBridgeReservation(t);

    44

			break;

    45

    46

		default:

    47

			break;

    48

	}

    49

	return TRACK_BIT_NONE;

    50

}

    51

    52

/**

    53

 * Set the reservation for a complete station platform.

    54

 * @pre IsRailwayStationTile(start)

    55

 * @param start starting tile of the platform

    56

 * @param dir the direction in which to follow the platform

    57

 * @param b the state the reservation should be set to

    58

 */

    59

void SetRailwayStationPlatformReservation(TileIndex start, DiagDirection dir, bool b)

    60

{

    61

	TileIndex     tile = start;

    62

	TileIndexDiff diff = TileOffsByDiagDir(dir);

    63

    64

	assert(IsRailwayStationTile(start));

    65

	assert(GetRailStationAxis(start) == DiagDirToAxis(dir));

    66

    67

	do {

    68

		SetRailwayStationReservation(tile, b);

    69

		MarkTileDirtyByTile(tile);

    70

		tile = TILE_ADD(tile, diff);

    71

	} while (IsCompatibleTrainStationTile(tile, start));

    72

}

    73

    74

/**

    75

 * Try to reserve a specific track on a tile

    76

 * @param tile the tile

    77

 * @param t the track

    78

 * @return true if reservation was successfull, i.e. the track was

    79

 *     free and didn't cross any other reserved tracks.

    80

 */

    81

bool TryReserveRailTrack(TileIndex tile, Track t)

    82

{

    83

	assert((GetTileTrackStatus(tile, TRANSPORT_RAIL, 0) & TrackToTrackBits(t)) != 0);

    84

    85

	if (_settings_client.gui.show_track_reservation) {

    86

		MarkTileDirtyByTile(tile);

    87

	}

    88

    89

	switch (GetTileType(tile)) {

    90

		case MP_RAILWAY:

    91

			if (IsPlainRailTile(tile)) return TryReserveTrack(tile, t);

    92

			if (IsRailWaypoint(tile) || IsRailDepot(tile)) {

    93

				if (!GetDepotWaypointReservation(tile)) {

    94

					SetDepotWaypointReservation(tile, true);

    95

					MarkTileDirtyByTile(tile);

    96

					return true;

    97

				}

    98

			}

    99

			break;

   100

   101

		case MP_ROAD:

   102

			if (IsLevelCrossing(tile) && !GetCrossingReservation(tile)) {

   103

				SetCrossingReservation(tile, true);

   104

				BarCrossing(tile);

   105

				MarkTileDirtyByTile(tile);

   106

				return true;

   107

			}

   108

			break;

   109

   110

		case MP_STATION:

   111

			if (IsRailwayStation(tile) && !GetRailwayStationReservation(tile)) {

   112

				SetRailwayStationReservation(tile, true);

   113

				MarkTileDirtyByTile(tile);

   114

				return true;

   115

			}

   116

			break;

   117

   118

		case MP_TUNNELBRIDGE:

   119

			if (GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL && !GetRailTunnelBridgeReservation(tile)) {

   120

				SetTunnelBridgeReservation(tile, true);

   121

				return true;

   122

			}

   123

			break;

   124

   125

		default:

   126

			break;

   127

	}

   128

	return false;

   129

}

   130

   131

/**

   132

 * Lift the reservation of a specific track on a tile

   133

 * @param tile the tile

   134

 * @param t the track

   135

 */

   136

 void UnreserveRailTrack(TileIndex tile, Track t)

   137

{

   138

	assert((GetTileTrackStatus(tile, TRANSPORT_RAIL, 0) & TrackToTrackBits(t)) != 0);

   139

   140

	if (_settings_client.gui.show_track_reservation) {

   141

		MarkTileDirtyByTile(tile);

   142

	}

   143

   144

	switch (GetTileType(tile)) {

   145

		case MP_RAILWAY:

   146

			if (IsRailWaypoint(tile) || IsRailDepot(tile)) {

   147

				SetDepotWaypointReservation(tile, false);

   148

				MarkTileDirtyByTile(tile);

   149

			}

   150

			if (IsPlainRailTile(tile)) UnreserveTrack(tile, t);

   151

			break;

   152

   153

		case MP_ROAD:

   154

			if (IsLevelCrossing(tile)) {

   155

				SetCrossingReservation(tile, false);

   156

				UpdateLevelCrossing(tile);

   157

			}

   158

			break;

   159

   160

		case MP_STATION:

   161

			if (IsRailwayStation(tile)) {

   162

				SetRailwayStationReservation(tile, false);

   163

				MarkTileDirtyByTile(tile);

   164

			}

   165

			break;

   166

   167

		case MP_TUNNELBRIDGE:

   168

			if (GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL) SetTunnelBridgeReservation(tile, false);

   169

			break;

   170

   171

		default:

   172

			break;

   173

	}

   174

}

   175

   176

   177

/** Follow a reservation starting from a specific tile to the end. */

   178

static PBSTileInfo FollowReservation(Owner o, RailTypes rts, TileIndex tile, Trackdir trackdir, bool ignore_oneway = false)

   179

{

   180

	/* Do not disallow 90 deg turns as the setting might have changed between reserving and now. */

   181

	CFollowTrackRail ft(o, rts);

   182

	while (ft.Follow(tile, trackdir)) {

   183

		TrackdirBits reserved = (TrackdirBits)(ft.m_new_td_bits & (GetReservedTrackbits(ft.m_new_tile) * 0x101));

   184

   185

		/* No reservation --> path end found */

   186

		if (reserved == TRACKDIR_BIT_NONE) break;

   187

   188

		/* Can't have more than one reserved trackdir */

   189

		Trackdir new_trackdir = FindFirstTrackdir(reserved);

   190

   191

		/* One-way signal against us. The reservation can't be ours as it is not

   192

		 * a safe position from our direction and we can never pass the signal. */

   193

		if (!ignore_oneway && HasOnewaySignalBlockingTrackdir(ft.m_new_tile, new_trackdir)) break;

   194

   195

		tile = ft.m_new_tile;

   196

		trackdir = new_trackdir;

   197

   198

		/* Depot tile? Can't continue. */

   199

		if (IsRailDepotTile(tile)) break;

   200

		/* Non-pbs signal? Reservation can't continue. */

   201

		if (IsTileType(tile, MP_RAILWAY) && HasSignalOnTrackdir(tile, trackdir) && !IsPbsSignal(GetSignalType(tile, TrackdirToTrack(trackdir)))) break;

   202

	}

   203

   204

	return PBSTileInfo(tile, trackdir, false);

   205

}

   206

   207

/** Callback for VehicleFromPos to find a train on a specific track. */

   208

static Vehicle *FindTrainOnTrackEnum(Vehicle *v, void *data)

   209

{

   210

	PBSTileInfo info = *(PBSTileInfo *)data;

   211

   212

	if (v->type == VEH_TRAIN && !(v->vehstatus & VS_CRASHED) && HasBit((TrackBits)v->u.rail.track, TrackdirToTrack(info.trackdir))) return v;

   213

   214

	return NULL;

   215

}

   216

   217

/**

   218

 * Follow a train reservation to the last tile.

   219

 *

   220

 * @param v the vehicle

   221

 * @param train_on_res Is set to a train we might encounter

   222

 * @returns The last tile of the reservation or the current train tile if no reservation present.

   223

 */

   224

PBSTileInfo FollowTrainReservation(const Vehicle *v, Vehicle **train_on_res)

   225

{

   226

	assert(v->type == VEH_TRAIN);

   227

   228

	TileIndex tile = v->tile;

   229

	Trackdir  trackdir = GetVehicleTrackdir(v);

   230

   231

	if (IsRailDepotTile(tile) && !GetRailDepotReservation(tile)) return PBSTileInfo(tile, trackdir, false);

   232

   233

	PBSTileInfo res = FollowReservation(v->owner, GetRailTypeInfo(v->u.rail.railtype)->compatible_railtypes, tile, trackdir);

   234

	res.okay = IsSafeWaitingPosition(v, res.tile, res.trackdir, true, _settings_game.pf.forbid_90_deg);

   235

	if (train_on_res != NULL) *train_on_res = VehicleFromPos(res.tile, &res, FindTrainOnTrackEnum);

   236

	return res;

   237

}

   238

   239

/**

   240

 * Find the train which has reserved a specific path.

   241

 *

   242

 * @param tile A tile on the path.

   243

 * @param track A reserved track on the tile.

   244

 * @return The vehicle holding the reservation or NULL if the path is stray.

   245

 */

   246

Vehicle *GetTrainForReservation(TileIndex tile, Track track)

   247

{

   248

	assert(HasReservedTracks(tile, TrackToTrackBits(track)));

   249

	Trackdir  trackdir = TrackToTrackdir(track);

   250

   251

	RailTypes rts = GetRailTypeInfo(GetTileRailType(tile))->compatible_railtypes;

   252

   253

	/* Follow the path from tile to both ends, one of the end tiles should

   254

	 * have a train on it. We need FollowReservation to ignore one-way signals

   255

	 * here, as one of the two search directions will be the "wrong" way. */

   256

	for (int i = 0; i < 2; ++i, trackdir = ReverseTrackdir(trackdir)) {

   257

		PBSTileInfo dest = FollowReservation(GetTileOwner(tile), rts, tile, trackdir, true);

   258

   259

		Vehicle *v = VehicleFromPos(dest.tile, &dest, FindTrainOnTrackEnum);

   260

		if (v != NULL) return v->First();

   261

   262

		/* Special case for stations: check the whole platform for a vehicle. */

   263

		if (IsRailwayStationTile(dest.tile)) {

   264

			TileIndexDiff diff = TileOffsByDiagDir(TrackdirToExitdir(ReverseTrackdir(dest.trackdir)));

   265

			for (TileIndex st_tile = dest.tile + diff; IsCompatibleTrainStationTile(st_tile, dest.tile); st_tile += diff) {

   266

				v = VehicleFromPos(st_tile, &dest, FindTrainOnTrackEnum);

   267

				if (v != NULL) return v->First();

   268

			}

   269

		}

   270

   271

		/* Special case for bridges/tunnels: check the other end as well. */

   272

		if (IsTileType(dest.tile, MP_TUNNELBRIDGE)) {

   273

			v = VehicleFromPos(GetOtherTunnelBridgeEnd(dest.tile), &dest, FindTrainOnTrackEnum);

   274

			if (v != NULL) return v->First();

   275

		}

   276

	}

   277

   278

	return NULL;

   279

}

   280

   281

/**

   282

 * Determine whether a certain track on a tile is a safe position to end a path.

   283

 *

   284

 * @param v the vehicle to test for

   285

 * @param tile The tile

   286

 * @param trackdir The trackdir to test

   287

 * @param include_line_end Should end-of-line tiles be considered safe?

   288

 * @param forbid_90def Don't allow trains to make 90 degree turns

   289

 * @return True if it is a safe position

   290

 */

   291

bool IsSafeWaitingPosition(const Vehicle *v, TileIndex tile, Trackdir trackdir, bool include_line_end, bool forbid_90deg)

   292

{

   293

	if (IsRailDepotTile(tile)) return true;

   294

   295

	if (IsTileType(tile, MP_RAILWAY)) {

   296

		/* For non-pbs signals, stop on the signal tile. */

   297

		if (HasSignalOnTrackdir(tile, trackdir) && !IsPbsSignal(GetSignalType(tile, TrackdirToTrack(trackdir)))) return true;

   298

	}

   299

   300

	/* Check next tile. For perfomance reasons, we check for 90 degree turns ourself. */

   301

	CFollowTrackRail ft(v, GetRailTypeInfo(v->u.rail.railtype)->compatible_railtypes);

   302

   303

	/* End of track? */

   304

	if (!ft.Follow(tile, trackdir)) {

   305

		/* Last tile of a terminus station is a safe position. */

   306

		if (include_line_end) return true;

   307

	}

   308

   309

	/* Check for reachable tracks. */

   310

	ft.m_new_td_bits &= DiagdirReachesTrackdirs(ft.m_exitdir);

   311

	if (ft.m_new_td_bits == TRACKDIR_BIT_NONE) return include_line_end;

   312

	if (forbid_90deg) ft.m_new_td_bits &= ~TrackdirCrossesTrackdirs(trackdir);

   313

   314

	if (ft.m_new_td_bits != TRACKDIR_BIT_NONE && KillFirstBit(ft.m_new_td_bits) == TRACKDIR_BIT_NONE) {

   315

		/* PBS signal on next trackdir? Safe position. */

   316

		if (HasPbsSignalOnTrackdir(ft.m_new_tile, FindFirstTrackdir(ft.m_new_td_bits))) return true;

   317

	}

   318

   319

	return false;

   320

}

   321

   322

/**

   323

 * Check if a safe position is free.

   324

 *

   325

 * @param v the vehicle to test for

   326

 * @param tile The tile

   327

 * @param trackdir The trackdir to test

   328

 * @param forbid_90def Don't allow trains to make 90 degree turns

   329

 * @return True if the position is free

   330

 */

   331

bool IsWaitingPositionFree(const Vehicle *v, TileIndex tile, Trackdir trackdir, bool forbid_90deg)

   332

{

   333

	Track     track = TrackdirToTrack(trackdir);

   334

	TrackBits reserved = GetReservedTrackbits(tile);

   335

   336

	/* Tile reserved? Can never be a free waiting position. */

   337

	if (TrackOverlapsTracks(reserved, track)) return false;

   338

   339

	/* Not reserved and depot or not a pbs signal -> free. */

   340

	if (IsRailDepotTile(tile)) return true;

   341

	if (IsTileType(tile, MP_RAILWAY) && HasSignalOnTrackdir(tile, trackdir) && !IsPbsSignal(GetSignalType(tile, track))) return true;

   342

   343

	/* Check the next tile, if it's a PBS signal, it has to be free as well. */

   344

	CFollowTrackRail ft(v, GetRailTypeInfo(v->u.rail.railtype)->compatible_railtypes);

   345

   346

	if (!ft.Follow(tile, trackdir)) return true;

   347

   348

	/* Check for reachable tracks. */

   349

	ft.m_new_td_bits &= DiagdirReachesTrackdirs(ft.m_exitdir);

   350

	if (forbid_90deg) ft.m_new_td_bits &= ~TrackdirCrossesTrackdirs(trackdir);

   351

   352

	return !HasReservedTracks(ft.m_new_tile, TrackdirBitsToTrackBits(ft.m_new_td_bits));

   353

}