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

		/* show the reserved rail if needed */

    87

		MarkTileDirtyByTile(tile);

    88

	}

    89

    90

	switch (GetTileType(tile)) {

    91

		case MP_RAILWAY:

    92

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

    93

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

    94

				if (!GetDepotWaypointReservation(tile)) {

    95

					SetDepotWaypointReservation(tile, true);

    96

					MarkTileDirtyByTile(tile); // some GRFs change their appearance when tile is reserved

    97

					return true;

    98

				}

    99

			}

   100

			break;

   101

   102

		case MP_ROAD:

   103

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

   104

				SetCrossingReservation(tile, true);

   105

				BarCrossing(tile);

   106

				MarkTileDirtyByTile(tile); // crossing barred, make tile dirty

   107

				return true;

   108

			}

   109

			break;

   110

   111

		case MP_STATION:

   112

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

   113

				SetRailwayStationReservation(tile, true);

   114

				MarkTileDirtyByTile(tile); // some GRFs need redraw after reserving track

   115

				return true;

   116

			}

   117

			break;

   118

   119

		case MP_TUNNELBRIDGE:

   120

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

   121

				SetTunnelBridgeReservation(tile, true);

   122

				return true;

   123

			}

   124

			break;

   125

   126

		default:

   127

			break;

   128

	}

   129

	return false;

   130

}

   131

   132

/**

   133

 * Lift the reservation of a specific track on a tile

   134

 * @param tile the tile

   135

 * @param t the track

   136

 */

   137

 void UnreserveRailTrack(TileIndex tile, Track t)

   138

{

   139

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

   140

   141

	if (_settings_client.gui.show_track_reservation) {

   142

		MarkTileDirtyByTile(tile);

   143

	}

   144

   145

	switch (GetTileType(tile)) {

   146

		case MP_RAILWAY:

   147

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

   148

				SetDepotWaypointReservation(tile, false);

   149

				MarkTileDirtyByTile(tile);

   150

				break;

   151

			}

   152

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

   153

			break;

   154

   155

		case MP_ROAD:

   156

			if (IsLevelCrossing(tile)) {

   157

				SetCrossingReservation(tile, false);

   158

				UpdateLevelCrossing(tile);

   159

			}

   160

			break;

   161

   162

		case MP_STATION:

   163

			if (IsRailwayStation(tile)) {

   164

				SetRailwayStationReservation(tile, false);

   165

				MarkTileDirtyByTile(tile);

   166

			}

   167

			break;

   168

   169

		case MP_TUNNELBRIDGE:

   170

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

   171

			break;

   172

   173

		default:

   174

			break;

   175

	}

   176

}

   177

   178

   179

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

   180

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

   181

{

   182

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

   183

	CFollowTrackRail ft(o, rts);

   184

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

   185

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

   186

   187

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

   188

		if (reserved == TRACKDIR_BIT_NONE) break;

   189

   190

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

   191

		Trackdir new_trackdir = FindFirstTrackdir(reserved);

   192

   193

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

   194

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

   195

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

   196

   197

		tile = ft.m_new_tile;

   198

		trackdir = new_trackdir;

   199

   200

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

   201

		if (IsRailDepotTile(tile)) break;

   202

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

   203

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

   204

	}

   205

   206

	return PBSTileInfo(tile, trackdir, false);

   207

}

   208

   209

/**

   210

 * Helper struct for finding the best matching vehicle on a specific track.

   211

 */

   212

struct FindTrainOnTrackInfo {

   213

	PBSTileInfo res; ///< Information about the track.

   214

	Vehicle *best;   ///< The currently "best" vehicle we have found.

   215

   216

	/** Init the best location to NULL always! */

   217

	FindTrainOnTrackInfo() : best(NULL) {}

   218

};

   219

   220

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

   221

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

   222

{

   223

	FindTrainOnTrackInfo *info = (FindTrainOnTrackInfo *)data;

   224

   225

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

   226

		v = v->First();

   227

   228

		/* ALWAYS return the lowest ID (anti-desync!) */

   229

		if (info->best == NULL || v->index < info->best->index) info->best = v;

   230

		return v;

   231

	}

   232

   233

	return NULL;

   234

}

   235

   236

/**

   237

 * Follow a train reservation to the last tile.

   238

 *

   239

 * @param v the vehicle

   240

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

   241

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

   242

 */

   243

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

   244

{

   245

	assert(v->type == VEH_TRAIN);

   246

   247

	TileIndex tile = v->tile;

   248

	Trackdir  trackdir = GetVehicleTrackdir(v);

   249

   250

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

   251

   252

	FindTrainOnTrackInfo ftoti;

   253

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

   254

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

   255

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

   256

	return ftoti.res;

   257

}

   258

   259

/**

   260

 * Find the train which has reserved a specific path.

   261

 *

   262

 * @param tile A tile on the path.

   263

 * @param track A reserved track on the tile.

   264

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

   265

 */

   266

Vehicle *GetTrainForReservation(TileIndex tile, Track track)

   267

{

   268

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

   269

	Trackdir  trackdir = TrackToTrackdir(track);

   270

   271

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

   272

   273

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

   274

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

   275

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

   276

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

   277

		FindTrainOnTrackInfo ftoti;

   278

		ftoti.res = FollowReservation(GetTileOwner(tile), rts, tile, trackdir, true);

   279

   280

		FindVehicleOnPos(ftoti.res.tile, &ftoti, FindTrainOnTrackEnum);

   281

		if (ftoti.best != NULL) return ftoti.best;

   282

   283

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

   284

		if (IsRailwayStationTile(ftoti.res.tile)) {

   285

			TileIndexDiff diff = TileOffsByDiagDir(TrackdirToExitdir(ReverseTrackdir(ftoti.res.trackdir)));

   286

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

   287

				FindVehicleOnPos(st_tile, &ftoti, FindTrainOnTrackEnum);

   288

				if (ftoti.best != NULL) return ftoti.best;

   289

			}

   290

		}

   291

   292

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

   293

		if (IsTileType(ftoti.res.tile, MP_TUNNELBRIDGE)) {

   294

			FindVehicleOnPos(GetOtherTunnelBridgeEnd(ftoti.res.tile), &ftoti, FindTrainOnTrackEnum);

   295

			if (ftoti.best != NULL) return ftoti.best;

   296

		}

   297

	}

   298

   299

	return NULL;

   300

}

   301

   302

/**

   303

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

   304

 *

   305

 * @param v the vehicle to test for

   306

 * @param tile The tile

   307

 * @param trackdir The trackdir to test

   308

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

   309

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

   310

 * @return True if it is a safe position

   311

 */

   312

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

   313

{

   314

	if (IsRailDepotTile(tile)) return true;

   315

   316

	if (IsTileType(tile, MP_RAILWAY)) {

   317

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

   318

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

   319

	}

   320

   321

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

   322

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

   323

   324

	/* End of track? */

   325

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

   326

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

   327

		if (include_line_end) return true;

   328

	}

   329

   330

	/* Check for reachable tracks. */

   331

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

   332

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

   333

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

   334

   335

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

   336

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

   337

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

   338

	}

   339

   340

	return false;

   341

}

   342

   343

/**

   344

 * Check if a safe position is free.

   345

 *

   346

 * @param v the vehicle to test for

   347

 * @param tile The tile

   348

 * @param trackdir The trackdir to test

   349

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

   350

 * @return True if the position is free

   351

 */

   352

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

   353

{

   354

	Track     track = TrackdirToTrack(trackdir);

   355

	TrackBits reserved = GetReservedTrackbits(tile);

   356

   357

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

   358

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

   359

   360

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

   361

	if (IsRailDepotTile(tile)) return true;

   362

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

   363

   364

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

   365

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

   366

   367

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

   368

   369

	/* Check for reachable tracks. */

   370

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

   371

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

   372

   373

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

   374

}