|
@@ -3347,52 +3347,24 @@ static byte AfterSetTrainPos(Vehicle *v,
|
|
|
/* For some reason tunnel tiles are always given as sloped :(
|
|
|
* But they are not sloped... */
|
|
|
if (middle_z != v->z_pos && !IsTunnelTile(TileVirtXY(v->x_pos, v->y_pos))) {
|
|
|
SetBit(v->u.rail.flags, (middle_z > old_z) ? VRF_GOINGUP : VRF_GOINGDOWN);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
VehicleMove(v, true);
|
|
|
return old_z;
|
|
|
}
|
|
|
|
|
|
static const Direction _new_vehicle_direction_table[11] = {
|
|
|
DIR_N , DIR_NW, DIR_W , INVALID_DIR,
|
|
|
DIR_NE, DIR_N , DIR_SW, INVALID_DIR,
|
|
|
DIR_E , DIR_SE, DIR_S
|
|
|
};
|
|
|
|
|
|
static inline int GetDirectionToVehicle(const Vehicle *v, int x, int y)
|
|
|
{
|
|
|
byte offs;
|
|
|
|
|
|
x -= v->x_pos;
|
|
|
if (x >= 0) {
|
|
|
offs = (x > 2) ? 0 : 1;
|
|
|
} else {
|
|
|
offs = (x < -2) ? 2 : 1;
|
|
|
}
|
|
|
|
|
|
y -= v->y_pos;
|
|
|
if (y >= 0) {
|
|
|
offs += ((y > 2) ? 0 : 1) * 4;
|
|
|
} else {
|
|
|
offs += ((y < -2) ? 2 : 1) * 4;
|
|
|
}
|
|
|
|
|
|
assert(offs < 11);
|
|
|
return _new_vehicle_direction_table[offs];
|
|
|
}
|
|
|
|
|
|
/* Check if the vehicle is compatible with the specified tile */
|
|
|
static inline bool CheckCompatibleRail(const Vehicle *v, TileIndex tile)
|
|
|
{
|
|
|
return
|
|
|
IsTileOwner(tile, v->owner) && (
|
|
|
!IsFrontEngine(v) ||
|
|
|
HasBit(v->u.rail.compatible_railtypes, GetRailType(tile))
|
|
|
);
|
|
|
}
|
|
|
|
|
|
struct RailtypeSlowdownParams {
|
|
|
byte small_turn, large_turn;
|
|
@@ -3717,33 +3689,48 @@ static void TrainController(Vehicle *v,
|
|
|
|
|
|
/* If we would reverse but are currently in a PBS block and
|
|
|
* reversing of stuck trains is disabled, don't reverse. */
|
|
|
if (_settings_game.pf.wait_for_pbs_path == 255 && UpdateSignalsOnSegment(v->tile, enterdir, v->owner) == SIGSEG_PBS) {
|
|
|
v->load_unload_time_rem = 0;
|
|
|
return;
|
|
|
}
|
|
|
goto reverse_train_direction;
|
|
|
} else {
|
|
|
TryReserveRailTrack(gp.new_tile, TrackBitsToTrack(chosen_track));
|
|
|
}
|
|
|
} else {
|
|
|
static const TrackBits _matching_tracks[8] = {
|
|
|
TRACK_BIT_LEFT | TRACK_BIT_RIGHT, TRACK_BIT_X,
|
|
|
TRACK_BIT_UPPER | TRACK_BIT_LOWER, TRACK_BIT_Y,
|
|
|
TRACK_BIT_LEFT | TRACK_BIT_RIGHT, TRACK_BIT_X,
|
|
|
TRACK_BIT_UPPER | TRACK_BIT_LOWER, TRACK_BIT_Y
|
|
|
};
|
|
|
|
|
|
/* The wagon is active, simply follow the prev vehicle. */
|
|
|
chosen_track = (TrackBits)(byte)(_matching_tracks[GetDirectionToVehicle(prev, gp.x, gp.y)] & bits);
|
|
|
if (prev->tile == gp.new_tile) {
|
|
|
/* Choose the same track as prev */
|
|
|
if (prev->u.rail.track == TRACK_BIT_WORMHOLE) {
|
|
|
/* Vehicles entering tunnels enter the wormhole earlier than for bridges.
|
|
|
* However, just choose the track into the wormhole. */
|
|
|
assert(IsTunnel(prev->tile));
|
|
|
chosen_track = bits;
|
|
|
} else {
|
|
|
chosen_track = prev->u.rail.track;
|
|
|
}
|
|
|
} else {
|
|
|
/* Choose the track that leads to the tile where prev is. */
|
|
|
static const TrackBits _connecting_track[DIAGDIR_END][DIAGDIR_END] = {
|
|
|
{TRACK_BIT_Y, TRACK_BIT_LOWER, TRACK_BIT_NONE, TRACK_BIT_LEFT },
|
|
|
{TRACK_BIT_UPPER, TRACK_BIT_X, TRACK_BIT_LEFT, TRACK_BIT_NONE },
|
|
|
{TRACK_BIT_NONE, TRACK_BIT_RIGHT, TRACK_BIT_Y, TRACK_BIT_UPPER},
|
|
|
{TRACK_BIT_RIGHT, TRACK_BIT_NONE, TRACK_BIT_LOWER, TRACK_BIT_X }
|
|
|
};
|
|
|
DiagDirection exitdir = DiagdirBetweenTiles(gp.new_tile, prev->tile);
|
|
|
assert(IsValidDiagDirection(exitdir));
|
|
|
chosen_track = _connecting_track[enterdir][exitdir];
|
|
|
}
|
|
|
chosen_track &= bits;
|
|
|
}
|
|
|
|
|
|
/* Make sure chosen track is a valid track */
|
|
|
assert(
|
|
|
chosen_track == TRACK_BIT_X || chosen_track == TRACK_BIT_Y ||
|
|
|
chosen_track == TRACK_BIT_UPPER || chosen_track == TRACK_BIT_LOWER ||
|
|
|
chosen_track == TRACK_BIT_LEFT || chosen_track == TRACK_BIT_RIGHT);
|
|
|
|
|
|
/* Update XY to reflect the entrance to the new tile, and select the direction to use */
|
|
|
const byte *b = _initial_tile_subcoord[FIND_FIRST_BIT(chosen_track)][enterdir];
|
|
|
gp.x = (gp.x & ~0xF) | b[0];
|
|
|
gp.y = (gp.y & ~0xF) | b[1];
|