static bool CheckShipLeaveDepot(Ship *v)
{
if (!v->IsChainInDepot()) return false;
/* We are leaving a depot, but have to go to the exact same one; re-enter */
if (v->current_order.IsType(OT_GOTO_DEPOT) &&
IsShipDepotTile(v->tile) && GetDepotIndex(v->tile) == v->current_order.GetDestination()) {
VehicleEnterDepot(v);
return true;
}
TileIndex tile = v->tile;
Axis axis = GetShipDepotAxis(tile);
DiagDirection north_dir = ReverseDiagDir(AxisToDiagDir(axis));
TileIndex north_neighbour = TILE_ADD(tile, TileOffsByDiagDir(north_dir));
DiagDirection south_dir = AxisToDiagDir(axis);
TileIndex south_neighbour = TILE_ADD(tile, 2 * TileOffsByDiagDir(south_dir));
TrackBits north_tracks = DiagdirReachesTracks(north_dir) & GetTileShipTrackStatus(north_neighbour);
TrackBits south_tracks = DiagdirReachesTracks(south_dir) & GetTileShipTrackStatus(south_neighbour);
if (north_tracks && south_tracks) {
/* Ask pathfinder for best direction */
bool reverse = false;
bool path_found;
switch (_settings_game.pf.pathfinder_for_ships) {
case VPF_OPF: reverse = OPFShipChooseTrack(v, north_neighbour, north_dir, north_tracks, path_found) == INVALID_TRACK; break; // OPF always allows reversing
case VPF_NPF: reverse = NPFShipCheckReverse(v); break;
case VPF_YAPF: reverse = YapfShipCheckReverse(v); break;
default: NOT_REACHED();
}
if (reverse) north_tracks = TRACK_BIT_NONE;
}
if (north_tracks) {
/* Leave towards north */
v->direction = DiagDirToDir(north_dir);
} else if (south_tracks) {
/* Leave towards south */
v->direction = DiagDirToDir(south_dir);
} else {
/* Both ways blocked */
return false;
}
v->state = AxisToTrackBits(axis);
v->vehstatus &= ~VS_HIDDEN;
v->cur_speed = 0;
v->UpdateViewport(true, true);
SetWindowDirty(WC_VEHICLE_DEPOT, v->tile);
PlayShipSound(v);
VehicleServiceInDepot(v);
InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
SetWindowClassesDirty(WC_SHIPS_LIST);
return false;
}
/**
* Is there a Chunnel in the way in the given direction?
* Only between height level 0 and 1.
* Used to avoid building bridge or tunnel between existing chunnel.
* @param tile the tile to search from.
* @param dir the direction to start searching to.
* @return true if and only if there is a chunnel.
*/
bool IsBetweenChunnelPortals(TileIndex tile, DiagDirection dir)
{
uint h = 0;
TileIndexDiff delta = TileOffsByDiagDir(dir);
if (GetTileZ(tile) > 0) return false;
do {
if (dir == DIAGDIR_NE || dir == DIAGDIR_NW) {
do {
tile += delta;
if (!IsValidTile(tile)) return false;
} while (TileHeight(tile) != h);
} else {
tile += delta;
do {
tile += delta;
if (!IsValidTile(tile)) return false;
} while (TileHeight(tile) != h);
tile -= delta;
}
(h == 0) ? h = 1 : h = 0;
} while (!IsTunnelTile(tile));
if (GetTunnelBridgeDirection(tile) != ReverseDiagDir(dir)) return false;
return true;
}
/**
* Remove a lock.
* @param tile Central tile of the lock.
* @param flags Operation to perform.
* @return The cost in case of success, or an error code if it failed.
*/
static CommandCost RemoveLock(TileIndex tile, DoCommandFlag flags)
{
if (GetTileOwner(tile) != OWNER_NONE) {
CommandCost ret = CheckTileOwnership(tile);
if (ret.Failed()) return ret;
}
TileIndexDiff delta = TileOffsByDiagDir(GetLockDirection(tile));
/* make sure no vehicle is on the tile. */
CommandCost ret = EnsureNoVehicleOnGround(tile);
if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile + delta);
if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile - delta);
if (ret.Failed()) return ret;
if (flags & DC_EXEC) {
DoClearSquare(tile);
MakeWaterKeepingClass(tile + delta, GetTileOwner(tile + delta));
MakeWaterKeepingClass(tile - delta, GetTileOwner(tile - delta));
MarkCanalsAndRiversAroundDirty(tile - delta);
MarkCanalsAndRiversAroundDirty(tile + delta);
}
return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_LOCK]);
}
inline bool MaskReservedTracks()
{
if (!DoTrackMasking()) return true;
if (m_is_station) {
/* Check skipped station tiles as well. */
TileIndexDiff diff = TileOffsByDiagDir(m_exitdir);
for (TileIndex tile = m_new_tile - diff * m_tiles_skipped; tile != m_new_tile; tile += diff) {
if (HasStationReservation(tile)) {
m_new_td_bits = TRACKDIR_BIT_NONE;
m_err = EC_RESERVED;
return false;
}
}
}
TrackBits reserved = GetReservedTrackbits(m_new_tile);
/* Mask already reserved trackdirs. */
m_new_td_bits &= ~TrackBitsToTrackdirBits(reserved);
/* Mask out all trackdirs that conflict with the reservation. */
Track t;
FOR_EACH_SET_TRACK(t, TrackdirBitsToTrackBits(m_new_td_bits)) {
if (TracksOverlap(reserved | TrackToTrackBits(t))) m_new_td_bits &= ~TrackToTrackdirBits(t);
}
if (m_new_td_bits == TRACKDIR_BIT_NONE) {
m_err = EC_RESERVED;
return false;
}
return true;
}
/**
* Gets the other end of the aqueduct, if possible.
* @param tile_from The begin tile for the aqueduct.
* @param [out] tile_to The tile till where to show a selection for the aqueduct.
* @return The other end of the aqueduct, or otherwise a tile in line with the aqueduct to cause the right error message.
*/
static TileIndex GetOtherAqueductEnd(TileIndex tile_from, TileIndex *tile_to = NULL)
{
int z;
DiagDirection dir = GetInclinedSlopeDirection(GetTileSlope(tile_from, &z));
/* If the direction isn't right, just return the next tile so the command
* complains about the wrong slope instead of the ends not matching up.
* Make sure the coordinate is always a valid tile within the map, so we
* don't go "off" the map. That would cause the wrong error message. */
if (!IsValidDiagDirection(dir)) return TILE_ADDXY(tile_from, TileX(tile_from) > 2 ? -1 : 1, 0);
/* Direction the aqueduct is built to. */
TileIndexDiff offset = TileOffsByDiagDir(ReverseDiagDir(dir));
/* The maximum length of the aqueduct. */
int max_length = min(_settings_game.construction.max_bridge_length, DistanceFromEdgeDir(tile_from, ReverseDiagDir(dir)) - 1);
TileIndex endtile = tile_from;
for (int length = 0; IsValidTile(endtile) && TileX(endtile) != 0 && TileY(endtile) != 0; length++) {
endtile = TILE_ADD(endtile, offset);
if (length > max_length) break;
if (GetTileMaxZ(endtile) > z) {
if (tile_to != NULL) *tile_to = endtile;
break;
}
}
return endtile;
}
static uint NPFSlopeCost(AyStarNode *current)
{
TileIndex next = current->tile + TileOffsByDiagDir(TrackdirToExitdir(current->direction));
/* Get center of tiles */
int x1 = TileX(current->tile) * TILE_SIZE + TILE_SIZE / 2;
int y1 = TileY(current->tile) * TILE_SIZE + TILE_SIZE / 2;
int x2 = TileX(next) * TILE_SIZE + TILE_SIZE / 2;
int y2 = TileY(next) * TILE_SIZE + TILE_SIZE / 2;
int dx4 = (x2 - x1) / 4;
int dy4 = (y2 - y1) / 4;
/* Get the height on both sides of the tile edge.
* Avoid testing the height on the tile-center. This will fail for halftile-foundations.
*/
int z1 = GetSlopeZ(x1 + dx4, y1 + dy4);
int z2 = GetSlopeZ(x2 - dx4, y2 - dy4);
if (z2 - z1 > 1) {
/* Slope up */
return _settings_game.pf.npf.npf_rail_slope_penalty;
}
return 0;
/* Should we give a bonus for slope down? Probably not, we
* could just substract that bonus from the penalty, because
* there is only one level of steepness... */
}
ETileArea(const BaseStation *st, TileIndex tile, TriggerArea ta)
{
switch (ta) {
default: NOT_REACHED();
case TA_TILE:
this->tile = tile;
this->w = 1;
this->h = 1;
break;
case TA_PLATFORM: {
TileIndex start, end;
Axis axis = GetRailStationAxis(tile);
TileIndexDiff delta = TileOffsByDiagDir(AxisToDiagDir(axis));
for (end = tile; IsRailStationTile(end + delta) && IsCompatibleTrainStationTile(end + delta, tile); end += delta) { /* Nothing */ }
for (start = tile; IsRailStationTile(start - delta) && IsCompatibleTrainStationTile(start - delta, tile); start -= delta) { /* Nothing */ }
this->tile = start;
this->w = TileX(end) - TileX(start) + 1;
this->h = TileY(end) - TileY(start) + 1;
break;
}
case TA_WHOLE:
st->GetTileArea(this, Station::IsExpected(st) ? STATION_RAIL : STATION_WAYPOINT);
break;
}
}
/**
* Builds a lock.
* @param tile Central tile of the lock.
* @param dir Uphill direction.
* @param flags Operation to perform.
* @return The cost in case of success, or an error code if it failed.
*/
static CommandCost DoBuildLock(TileIndex tile, DiagDirection dir, DoCommandFlag flags)
{
CommandCost cost(EXPENSES_CONSTRUCTION);
int delta = TileOffsByDiagDir(dir);
CommandCost ret = EnsureNoVehicleOnGround(tile);
if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile + delta);
if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile - delta);
if (ret.Failed()) return ret;
/* middle tile */
ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (ret.Failed()) return ret;
cost.AddCost(ret);
/* lower tile */
WaterClass wc_lower = IsWaterTile(tile - delta) ? GetWaterClass(tile - delta) : WATER_CLASS_CANAL;
if (!IsWaterTile(tile - delta)) {
ret = DoCommand(tile - delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (ret.Failed()) return ret;
cost.AddCost(ret);
cost.AddCost(_price[PR_BUILD_CANAL]);
}
if (GetTileSlope(tile - delta, NULL) != SLOPE_FLAT) {
return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
}
/* upper tile */
WaterClass wc_upper = IsWaterTile(tile + delta) ? GetWaterClass(tile + delta) : WATER_CLASS_CANAL;
if (!IsWaterTile(tile + delta)) {
ret = DoCommand(tile + delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (ret.Failed()) return ret;
cost.AddCost(ret);
cost.AddCost(_price[PR_BUILD_CANAL]);
}
if (GetTileSlope(tile + delta, NULL) != SLOPE_FLAT) {
return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
}
if ((MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) ||
(MayHaveBridgeAbove(tile - delta) && IsBridgeAbove(tile - delta)) ||
(MayHaveBridgeAbove(tile + delta) && IsBridgeAbove(tile + delta))) {
return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
}
if (flags & DC_EXEC) {
MakeLock(tile, _current_company, dir, wc_lower, wc_upper);
MarkTileDirtyByTile(tile);
MarkTileDirtyByTile(tile - delta);
MarkTileDirtyByTile(tile + delta);
MarkCanalsAndRiversAroundDirty(tile - delta);
MarkCanalsAndRiversAroundDirty(tile + delta);
}
cost.AddCost(_price[PR_BUILD_LOCK]);
return cost;
}
/** Check for a reserved station platform. */
inline bool IsAnyStationTileReserved(TileIndex tile, Trackdir trackdir, int skipped)
{
TileIndexDiff diff = TileOffsByDiagDir(TrackdirToExitdir(ReverseTrackdir(trackdir)));
for (; skipped >= 0; skipped--, tile += diff) {
if (HasStationReservation(tile)) return true;
}
return false;
}
/* Determine the cost of this node, for road tracks */
static int32 NPFRoadPathCost(AyStar *as, AyStarNode *current, OpenListNode *parent)
{
TileIndex tile = current->tile;
int32 cost = 0;
/* Determine base length */
switch (GetTileType(tile)) {
case MP_TUNNELBRIDGE:
cost = IsTunnel(tile) ? NPFTunnelCost(current) : NPFBridgeCost(current);
break;
case MP_ROAD:
cost = NPF_TILE_LENGTH;
/* Increase the cost for level crossings */
if (IsLevelCrossing(tile)) cost += _settings_game.pf.npf.npf_crossing_penalty;
break;
case MP_STATION: {
cost = NPF_TILE_LENGTH;
const RoadStop *rs = RoadStop::GetByTile(tile, GetRoadStopType(tile));
if (IsDriveThroughStopTile(tile)) {
/* Increase the cost for drive-through road stops */
cost += _settings_game.pf.npf.npf_road_drive_through_penalty;
DiagDirection dir = TrackdirToExitdir(current->direction);
if (!RoadStop::IsDriveThroughRoadStopContinuation(tile, tile - TileOffsByDiagDir(dir))) {
/* When we're the first road stop in a 'queue' of them we increase
* cost based on the fill percentage of the whole queue. */
const RoadStop::Entry *entry = rs->GetEntry(dir);
cost += entry->GetOccupied() * _settings_game.pf.npf.npf_road_dt_occupied_penalty / entry->GetLength();
}
} else {
/* Increase cost for filled road stops */
cost += _settings_game.pf.npf.npf_road_bay_occupied_penalty * (!rs->IsFreeBay(0) + !rs->IsFreeBay(1)) / 2;
}
break;
}
default:
break;
}
/* Determine extra costs */
/* Check for slope */
cost += NPFSlopeCost(current);
/* Check for turns. Road vehicles only really drive diagonal, turns are
* represented by non-diagonal tracks */
if (!IsDiagonalTrackdir(current->direction)) {
cost += _settings_game.pf.npf.npf_road_curve_penalty;
}
NPFMarkTile(tile);
DEBUG(npf, 4, "Calculating G for: (%d, %d). Result: %d", TileX(current->tile), TileY(current->tile), cost);
return cost;
}
static void TPFModeShip(TrackPathFinder *tpf, TileIndex tile, DiagDirection direction)
{
if (IsTileType(tile, MP_TUNNELBRIDGE)) {
/* wrong track type */
if (GetTunnelBridgeTransportType(tile) != TRANSPORT_WATER) return;
DiagDirection dir = GetTunnelBridgeDirection(tile);
/* entering tunnel / bridge? */
if (dir == direction) {
TileIndex endtile = GetOtherTunnelBridgeEnd(tile);
tpf->rd.cur_length += GetTunnelBridgeLength(tile, endtile) + 1;
tile = endtile;
} else {
/* leaving tunnel / bridge? */
if (ReverseDiagDir(dir) != direction) return;
}
}
/* This addition will sometimes overflow by a single tile.
* The use of TILE_MASK here makes sure that we still point at a valid
* tile, and then this tile will be in the sentinel row/col, so GetTileTrackStatus will fail. */
tile = TILE_MASK(tile + TileOffsByDiagDir(direction));
if (++tpf->rd.cur_length > 50) return;
TrackBits bits = TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_WATER, 0)) & DiagdirReachesTracks(direction);
if (bits == TRACK_BIT_NONE) return;
assert(TileX(tile) != MapMaxX() && TileY(tile) != MapMaxY());
bool only_one_track = true;
do {
Track track = RemoveFirstTrack(&bits);
if (bits != TRACK_BIT_NONE) only_one_track = false;
RememberData rd = tpf->rd;
/* Change direction 4 times only */
if (!only_one_track && track != tpf->rd.last_choosen_track) {
if (++tpf->rd.depth > 4) {
tpf->rd = rd;
return;
}
tpf->rd.last_choosen_track = track;
}
tpf->the_dir = TrackEnterdirToTrackdir(track, direction);
if (!ShipTrackFollower(tile, tpf, tpf->rd.cur_length)) {
TPFModeShip(tpf, tile, TrackdirToExitdir(tpf->the_dir));
}
tpf->rd = rd;
} while (bits != TRACK_BIT_NONE);
}
/**
* If required, connects a new structure to an existing road or tram by building the missing roadbit.
* @param tile Tile containing the structure to connect.
* @param direction Direction to check.
*/
void ConnectRoadToStructure(TileIndex tile, DiagDirection direction)
{
tile += TileOffsByDiagDir(direction);
/* if there is a roadpiece just outside of the station entrance, build a connecting route */
if (IsNormalRoadTile(tile)) {
if (GetRoadBits(tile, _cur_roadtype) != ROAD_NONE) {
DoCommandP(tile, _cur_roadtype << 4 | DiagDirToRoadBits(ReverseDiagDir(direction)), 0, CMD_BUILD_ROAD);
}
}
}
/**
* Tests if at least one surrounding tile is non-desert
* @param tile tile to check
* @return does this tile have at least one non-desert tile around?
*/
static inline bool NeighbourIsNormal(TileIndex tile)
{
for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
TileIndex t = tile + TileOffsByDiagDir(dir);
if (!IsValidTile(t)) continue;
if (GetTropicZone(t) != TROPICZONE_DESERT) return true;
if (HasTileWaterClass(t) && GetWaterClass(t) == WATER_CLASS_SEA) return true;
}
return false;
}
/**
* Check the integrity of the data in this struct.
* @param rs the roadstop this entry is part of
*/
void RoadStop::Entry::CheckIntegrity(const RoadStop *rs) const
{
if (!HasBit(rs->status, RSSFB_BASE_ENTRY)) return;
/* The tile 'before' the road stop must not be part of this 'line' */
assert(!IsDriveThroughRoadStopContinuation(rs->xy, rs->xy - abs(TileOffsByDiagDir(GetRoadStopDir(rs->xy)))));
Entry temp;
temp.Rebuild(rs, rs->east == this);
if (temp.length != this->length || temp.occupied != this->occupied) NOT_REACHED();
}
/**
* Finds the end of a bridge in the specified direction starting at a middle tile
* @param tile the bridge tile to find the bridge ramp for
* @param dir the direction to search in
*/
static TileIndex GetBridgeEnd(TileIndex tile, DiagDirection dir)
{
TileIndexDiff delta = TileOffsByDiagDir(dir);
dir = ReverseDiagDir(dir);
do {
tile += delta;
} while (!IsBridgeTile(tile) || GetTunnelBridgeDirection(tile) != dir);
return tile;
}
/* virtual */ uint Station::GetPlatformLength(TileIndex tile, DiagDirection dir) const
{
TileIndex start_tile = tile;
uint length = 0;
assert(IsRailStationTile(tile));
assert(dir < DIAGDIR_END);
do {
length++;
tile += TileOffsByDiagDir(dir);
} while (IsCompatibleTrainStationTile(tile, start_tile));
return length;
}
static Trackdir ChooseShipTrack(const Ship *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool &path_found)
{
/* handle special case - when next tile is destination tile */
if (tile == v->dest_tile) {
/* convert tracks to trackdirs */
TrackdirBits trackdirs = (TrackdirBits)(tracks | ((int)tracks << 8));
/* limit to trackdirs reachable from enterdir */
trackdirs &= DiagdirReachesTrackdirs(enterdir);
/* use vehicle's current direction if that's possible, otherwise use first usable one. */
Trackdir veh_dir = v->GetVehicleTrackdir();
return ((trackdirs & TrackdirToTrackdirBits(veh_dir)) != 0) ? veh_dir : (Trackdir)FindFirstBit2x64(trackdirs);
}
/* move back to the old tile/trackdir (where ship is coming from) */
TileIndex src_tile = TILE_ADD(tile, TileOffsByDiagDir(ReverseDiagDir(enterdir)));
Trackdir trackdir = v->GetVehicleTrackdir();
assert(IsValidTrackdir(trackdir));
/* convert origin trackdir to TrackdirBits */
TrackdirBits trackdirs = TrackdirToTrackdirBits(trackdir);
/* get available trackdirs on the destination tile */
TrackdirBits dest_trackdirs = TrackStatusToTrackdirBits(GetTileTrackStatus(v->dest_tile, TRANSPORT_WATER, 0));
/* create pathfinder instance */
Tpf pf;
/* set origin and destination nodes */
pf.SetOrigin(src_tile, trackdirs);
pf.SetDestination(v->dest_tile, dest_trackdirs);
/* find best path */
path_found = pf.FindPath(v);
Trackdir next_trackdir = INVALID_TRACKDIR; // this would mean "path not found"
Node *pNode = pf.GetBestNode();
if (pNode != NULL) {
/* walk through the path back to the origin */
Node *pPrevNode = NULL;
while (pNode->m_parent != NULL) {
pPrevNode = pNode;
pNode = pNode->m_parent;
}
/* return trackdir from the best next node (direct child of origin) */
Node& best_next_node = *pPrevNode;
assert(best_next_node.GetTile() == tile);
next_trackdir = best_next_node.GetTrackdir();
}
return next_trackdir;
}
/**
* Is there a tunnel in the way in the given direction?
* Between level 0 and 1 terraforming is allowed. (No search)
* @param tile the tile to search from.
* @param z the 'z' to search on.
* @param dir the direction to start searching to.
* @return true if and only if there is a tunnel.
*/
bool IsTunnelInWayDir(TileIndex tile, int z, DiagDirection dir)
{
/* Between level 0 and 1 terraforming is allowed. */
if (GetTileZ(tile) <= 1) return false;
TileIndexDiff delta = TileOffsByDiagDir(dir);
int height;
do {
tile -= delta;
if (!IsValidTile(tile)) return false;
height = GetTileZ(tile);
} while (z < height);
return z == height && IsTunnelTile(tile) && GetTunnelBridgeDirection(tile) == dir;
}
/** build a shiplift */
static CommandCost DoBuildShiplift(TileIndex tile, DiagDirection dir, DoCommandFlag flags)
{
CommandCost ret;
int delta;
/* middle tile */
ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return CMD_ERROR;
delta = TileOffsByDiagDir(dir);
/* lower tile */
WaterClass wc_lower = IsWaterTile(tile - delta) ? GetWaterClass(tile - delta) : WATER_CLASS_CANAL;
ret = DoCommand(tile - delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return CMD_ERROR;
if (GetTileSlope(tile - delta, NULL) != SLOPE_FLAT) {
return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
}
/* upper tile */
WaterClass wc_upper = IsWaterTile(tile + delta) ? GetWaterClass(tile + delta) : WATER_CLASS_CANAL;
ret = DoCommand(tile + delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
if (CmdFailed(ret)) return CMD_ERROR;
if (GetTileSlope(tile + delta, NULL) != SLOPE_FLAT) {
return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
}
if ((MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) ||
(MayHaveBridgeAbove(tile - delta) && IsBridgeAbove(tile - delta)) ||
(MayHaveBridgeAbove(tile + delta) && IsBridgeAbove(tile + delta))) {
return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
}
if (flags & DC_EXEC) {
MakeLock(tile, _current_company, dir, wc_lower, wc_upper);
MarkTileDirtyByTile(tile);
MarkTileDirtyByTile(tile - delta);
MarkTileDirtyByTile(tile + delta);
MarkCanalsAndRiversAroundDirty(tile - delta);
MarkCanalsAndRiversAroundDirty(tile + delta);
}
return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_WATER] * 22 >> 3);
}
/** return one tile cost */
inline int OneTileCost(TileIndex tile, Trackdir trackdir)
{
int cost = 0;
/* set base cost */
if (IsDiagonalTrackdir(trackdir)) {
cost += YAPF_TILE_LENGTH;
switch (GetTileType(tile)) {
case MP_ROAD:
/* Increase the cost for level crossings */
if (IsLevelCrossing(tile)) {
cost += Yapf().PfGetSettings().road_crossing_penalty;
}
break;
case MP_STATION: {
const RoadStop *rs = RoadStop::GetByTile(tile, GetRoadStopType(tile));
if (IsDriveThroughStopTile(tile)) {
/* Increase the cost for drive-through road stops */
cost += Yapf().PfGetSettings().road_stop_penalty;
DiagDirection dir = TrackdirToExitdir(trackdir);
if (!RoadStop::IsDriveThroughRoadStopContinuation(tile, tile - TileOffsByDiagDir(dir))) {
/* When we're the first road stop in a 'queue' of them we increase
* cost based on the fill percentage of the whole queue. */
const RoadStop::Entry *entry = rs->GetEntry(dir);
cost += entry->GetOccupied() * Yapf().PfGetSettings().road_stop_occupied_penalty / entry->GetLength();
}
} else {
/* Increase cost for filled road stops */
cost += Yapf().PfGetSettings().road_stop_bay_occupied_penalty * (!rs->IsFreeBay(0) + !rs->IsFreeBay(1)) / 2;
}
break;
}
default:
break;
}
} else {
/* non-diagonal trackdir */
cost = YAPF_TILE_CORNER_LENGTH + Yapf().PfGetSettings().road_curve_penalty;
}
return cost;
}
/**
* To be called when @p current contains the (shortest route to) the target node.
* Will fill the contents of the NPFFoundTargetData using
* AyStarNode[NPF_TRACKDIR_CHOICE]. If requested, path reservation
* is done here.
*/
static void NPFSaveTargetData(AyStar *as, OpenListNode *current)
{
NPFFoundTargetData *ftd = (NPFFoundTargetData*)as->user_path;
ftd->best_trackdir = (Trackdir)current->path.node.user_data[NPF_TRACKDIR_CHOICE];
ftd->best_path_dist = current->g;
ftd->best_bird_dist = 0;
ftd->node = current->path.node;
ftd->res_okay = false;
if (as->user_target != NULL && ((NPFFindStationOrTileData*)as->user_target)->reserve_path && as->user_data[NPF_TYPE] == TRANSPORT_RAIL) {
/* Path reservation is requested. */
const Train *v = Train::From(((NPFFindStationOrTileData *)as->user_target)->v);
const PathNode *target = FindSafePosition(¤t->path, v);
ftd->node = target->node;
/* If the target is a station skip to platform end. */
if (IsRailStationTile(target->node.tile)) {
DiagDirection dir = TrackdirToExitdir(target->node.direction);
uint len = Station::GetByTile(target->node.tile)->GetPlatformLength(target->node.tile, dir);
TileIndex end_tile = TILE_ADD(target->node.tile, (len - 1) * TileOffsByDiagDir(dir));
/* Update only end tile, trackdir of a station stays the same. */
ftd->node.tile = end_tile;
if (!IsWaitingPositionFree(v, end_tile, target->node.direction, _settings_game.pf.forbid_90_deg)) return;
SetRailStationPlatformReservation(target->node.tile, dir, true);
SetRailStationReservation(target->node.tile, false);
} else {
if (!IsWaitingPositionFree(v, target->node.tile, target->node.direction, _settings_game.pf.forbid_90_deg)) return;
}
for (const PathNode *cur = target; cur->parent != NULL; cur = cur->parent) {
if (!TryReserveRailTrack(cur->node.tile, TrackdirToTrack(cur->node.direction))) {
/* Reservation failed, undo. */
ClearPathReservation(target, cur);
return;
}
}
ftd->res_okay = true;
}
}
void GenerateClearTile()
{
uint i, gi;
TileIndex tile;
/* add rough tiles */
i = ScaleByMapSize(GB(Random(), 0, 10) + 0x400);
gi = ScaleByMapSize(GB(Random(), 0, 7) + 0x80);
SetGeneratingWorldProgress(GWP_ROUGH_ROCKY, gi + i);
do {
IncreaseGeneratingWorldProgress(GWP_ROUGH_ROCKY);
tile = RandomTile();
if (IsTileType(tile, MP_CLEAR) && !IsClearGround(tile, CLEAR_DESERT)) SetClearGroundDensity(tile, CLEAR_ROUGH, 3);
} while (--i);
/* add rocky tiles */
i = gi;
do {
uint32 r = Random();
tile = RandomTileSeed(r);
IncreaseGeneratingWorldProgress(GWP_ROUGH_ROCKY);
if (IsTileType(tile, MP_CLEAR) && !IsClearGround(tile, CLEAR_DESERT)) {
uint j = GB(r, 16, 4) + 5;
for (;;) {
TileIndex tile_new;
SetClearGroundDensity(tile, CLEAR_ROCKS, 3);
do {
if (--j == 0) goto get_out;
tile_new = tile + TileOffsByDiagDir((DiagDirection)GB(Random(), 0, 2));
} while (!IsTileType(tile_new, MP_CLEAR) || IsClearGround(tile_new, CLEAR_DESERT));
tile = tile_new;
}
get_out:;
}
} while (--i);
}
static CommandCost RemoveShiplift(TileIndex tile, DoCommandFlag flags)
{
TileIndexDiff delta = TileOffsByDiagDir(GetLockDirection(tile));
if (!CheckTileOwnership(tile) && GetTileOwner(tile) != OWNER_NONE) return CMD_ERROR;
/* make sure no vehicle is on the tile. */
if (!EnsureNoVehicleOnGround(tile) || !EnsureNoVehicleOnGround(tile + delta) || !EnsureNoVehicleOnGround(tile - delta))
return CMD_ERROR;
if (flags & DC_EXEC) {
DoClearSquare(tile);
MakeWaterKeepingClass(tile + delta, GetTileOwner(tile));
MakeWaterKeepingClass(tile - delta, GetTileOwner(tile));
MarkTileDirtyByTile(tile - delta);
MarkTileDirtyByTile(tile + delta);
MarkCanalsAndRiversAroundDirty(tile - delta);
MarkCanalsAndRiversAroundDirty(tile + delta);
}
return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_WATER] * 2);
}
/**
* Rebuild, from scratch, the vehicles and other metadata on this stop.
* @param rs the roadstop this entry is part of
* @param side the side of the road stop to look at
*/
void RoadStop::Entry::Rebuild(const RoadStop *rs, int side)
{
assert(HasBit(rs->status, RSSFB_BASE_ENTRY));
DiagDirection dir = GetRoadStopDir(rs->xy);
if (side == -1) side = (rs->east == this);
RoadStopEntryRebuilderHelper rserh;
rserh.dir = side ? dir : ReverseDiagDir(dir);
this->length = 0;
TileIndexDiff offset = abs(TileOffsByDiagDir(dir));
for (TileIndex tile = rs->xy; IsDriveThroughRoadStopContinuation(rs->xy, tile); tile += offset) {
this->length += TILE_SIZE;
FindVehicleOnPos(tile, &rserh, FindVehiclesInRoadStop);
}
this->occupied = 0;
for (RVList::iterator it = rserh.vehicles.begin(); it != rserh.vehicles.end(); it++) {
this->occupied += (*it)->gcache.cached_total_length;
}
}
/**
* Remove a lock.
* @param tile Central tile of the lock.
* @param flags Operation to perform.
* @return The cost in case of success, or an error code if it failed.
*/
static CommandCost RemoveLock(TileIndex tile, DoCommandFlag flags)
{
if (GetTileOwner(tile) != OWNER_NONE) {
CommandCost ret = CheckTileOwnership(tile);
if (ret.Failed()) return ret;
}
TileIndexDiff delta = TileOffsByDiagDir(GetLockDirection(tile));
/* make sure no vehicle is on the tile. */
CommandCost ret = EnsureNoVehicleOnGround(tile);
if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile + delta);
if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile - delta);
if (ret.Failed()) return ret;
if (flags & DC_EXEC) {
/* Remove middle part from company infrastructure count. */
Company *c = Company::GetIfValid(GetTileOwner(tile));
if (c != NULL) {
c->infrastructure.water -= 3 * LOCK_DEPOT_TILE_FACTOR; // three parts of the lock.
DirtyCompanyInfrastructureWindows(c->index);
}
if (GetWaterClass(tile) == WATER_CLASS_RIVER) {
MakeRiver(tile, Random());
} else {
DoClearSquare(tile);
}
MakeWaterKeepingClass(tile + delta, GetTileOwner(tile + delta));
MakeWaterKeepingClass(tile - delta, GetTileOwner(tile - delta));
MarkCanalsAndRiversAroundDirty(tile);
MarkCanalsAndRiversAroundDirty(tile - delta);
MarkCanalsAndRiversAroundDirty(tile + delta);
}
return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_LOCK]);
}
/**
* returns the track to choose on the next tile, or -1 when it's better to
* reverse. The tile given is the tile we are about to enter, enterdir is the
* direction in which we are entering the tile
*/
Track OPFShipChooseTrack(const Ship *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool &path_found)
{
assert(IsValidDiagDirection(enterdir));
TileIndex tile2 = TILE_ADD(tile, -TileOffsByDiagDir(enterdir));
Track track;
/* Let's find out how far it would be if we would reverse first */
TrackBits b = TrackStatusToTrackBits(GetTileTrackStatus(tile2, TRANSPORT_WATER, 0)) & DiagdirReachesTracks(ReverseDiagDir(enterdir)) & v->state;
uint distr = UINT_MAX; // distance if we reversed
if (b != 0) {
distr = FindShipTrack(v, tile2, ReverseDiagDir(enterdir), b, tile, &track);
if (distr != UINT_MAX) distr++; // penalty for reversing
}
/* And if we would not reverse? */
uint dist = FindShipTrack(v, tile, enterdir, tracks, 0, &track);
/* Due to the way this pathfinder works we cannot determine whether we're lost or not. */
path_found = true;
if (dist <= distr) return track;
return INVALID_TRACK; // We could better reverse
}
/* Will just follow the results of GetTileTrackStatus concerning where we can
* go and where not. Uses AyStar.user_data[NPF_TYPE] as the transport type and
* an argument to GetTileTrackStatus. Will skip tunnels, meaning that the
* entry and exit are neighbours. Will fill
* AyStarNode.user_data[NPF_TRACKDIR_CHOICE] with an appropriate value, and
* copy AyStarNode.user_data[NPF_NODE_FLAGS] from the parent */
static void NPFFollowTrack(AyStar *aystar, OpenListNode *current)
{
/* We leave src_tile on track src_trackdir in direction src_exitdir */
Trackdir src_trackdir = current->path.node.direction;
TileIndex src_tile = current->path.node.tile;
DiagDirection src_exitdir = TrackdirToExitdir(src_trackdir);
/* Is src_tile valid, and can be used?
* When choosing track on a junction src_tile is the tile neighboured to the junction wrt. exitdir.
* But we must not check the validity of this move, as src_tile is totally unrelated to the move, if a roadvehicle reversed on a junction. */
bool ignore_src_tile = (current->path.parent == NULL && NPFGetFlag(¤t->path.node, NPF_FLAG_IGNORE_START_TILE));
/* Information about the vehicle: TransportType (road/rail/water) and SubType (compatible rail/road types) */
TransportType type = (TransportType)aystar->user_data[NPF_TYPE];
uint subtype = aystar->user_data[NPF_SUB_TYPE];
/* Initialize to 0, so we can jump out (return) somewhere an have no neighbours */
aystar->num_neighbours = 0;
DEBUG(npf, 4, "Expanding: (%d, %d, %d) [%d]", TileX(src_tile), TileY(src_tile), src_trackdir, src_tile);
/* We want to determine the tile we arrive, and which choices we have there */
TileIndex dst_tile;
TrackdirBits trackdirbits;
/* Find dest tile */
if (ignore_src_tile) {
/* Do not perform any checks that involve src_tile */
dst_tile = src_tile + TileOffsByDiagDir(src_exitdir);
trackdirbits = GetDriveableTrackdirBits(dst_tile, src_trackdir, type, subtype);
} else if (IsTileType(src_tile, MP_TUNNELBRIDGE) && GetTunnelBridgeDirection(src_tile) == src_exitdir) {
/* We drive through the wormhole and arrive on the other side */
dst_tile = GetOtherTunnelBridgeEnd(src_tile);
trackdirbits = TrackdirToTrackdirBits(src_trackdir);
} else if (ForceReverse(src_tile, src_exitdir, type, subtype)) {
/* We can only reverse on this tile */
dst_tile = src_tile;
src_trackdir = ReverseTrackdir(src_trackdir);
trackdirbits = TrackdirToTrackdirBits(src_trackdir);
} else {
/* We leave src_tile in src_exitdir and reach dst_tile */
dst_tile = AddTileIndexDiffCWrap(src_tile, TileIndexDiffCByDiagDir(src_exitdir));
if (dst_tile != INVALID_TILE && !CanEnterTile(dst_tile, src_exitdir, type, subtype, (RailTypes)aystar->user_data[NPF_RAILTYPES], (Owner)aystar->user_data[NPF_OWNER])) dst_tile = INVALID_TILE;
if (dst_tile == INVALID_TILE) {
/* We cannot enter the next tile. Road vehicles can reverse, others reach dead end */
if (type != TRANSPORT_ROAD || HasBit(subtype, ROADTYPE_TRAM)) return;
dst_tile = src_tile;
src_trackdir = ReverseTrackdir(src_trackdir);
}
trackdirbits = GetDriveableTrackdirBits(dst_tile, src_trackdir, type, subtype);
if (trackdirbits == 0) {
/* We cannot enter the next tile. Road vehicles can reverse, others reach dead end */
if (type != TRANSPORT_ROAD || HasBit(subtype, ROADTYPE_TRAM)) return;
dst_tile = src_tile;
src_trackdir = ReverseTrackdir(src_trackdir);
trackdirbits = GetDriveableTrackdirBits(dst_tile, src_trackdir, type, subtype);
}
}
if (NPFGetFlag(¤t->path.node, NPF_FLAG_IGNORE_RESERVED)) {
/* Mask out any reserved tracks. */
TrackBits reserved = GetReservedTrackbits(dst_tile);
trackdirbits &= ~TrackBitsToTrackdirBits(reserved);
uint bits = TrackdirBitsToTrackBits(trackdirbits);
int i;
FOR_EACH_SET_BIT(i, bits) {
if (TracksOverlap(reserved | TrackToTrackBits((Track)i))) trackdirbits &= ~TrackToTrackdirBits((Track)i);
}
}
/**
* Join this road stop to another 'base' road stop if possible;
* fill all necessary data to become an actual drive through road stop.
* Also update the length etc.
*/
void RoadStop::MakeDriveThrough()
{
assert(this->east == NULL && this->west == NULL);
RoadStopType rst = GetRoadStopType(this->xy);
DiagDirection dir = GetRoadStopDir(this->xy);
/* Use absolute so we always go towards the nortern tile */
TileIndexDiff offset = abs(TileOffsByDiagDir(dir));
/* Information about the tile north of us */
TileIndex north_tile = this->xy - offset;
bool north = IsDriveThroughRoadStopContinuation(this->xy, north_tile);
RoadStop *rs_north = north ? RoadStop::GetByTile(north_tile, rst) : NULL;
/* Information about the tile south of us */
TileIndex south_tile = this->xy + offset;
bool south = IsDriveThroughRoadStopContinuation(this->xy, south_tile);
RoadStop *rs_south = south ? RoadStop::GetByTile(south_tile, rst) : NULL;
/* Amount of road stops that will be added to the 'northern' head */
int added = 1;
if (north && rs_north->east != NULL) { // (east != NULL) == (west != NULL)
/* There is a more nothern one, so this can join them */
this->east = rs_north->east;
this->west = rs_north->west;
if (south && rs_south->east != NULL) { // (east != NULL) == (west != NULL)
/* There more southern tiles too, they must 'join' us too */
ClrBit(rs_south->status, RSSFB_BASE_ENTRY);
this->east->occupied += rs_south->east->occupied;
this->west->occupied += rs_south->west->occupied;
/* Free the now unneeded entry structs */
delete rs_south->east;
delete rs_south->west;
/* Make all 'children' of the southern tile take the new master */
for (; IsDriveThroughRoadStopContinuation(this->xy, south_tile); south_tile += offset) {
rs_south = RoadStop::GetByTile(south_tile, rst);
if (rs_south->east == NULL) break;
rs_south->east = rs_north->east;
rs_south->west = rs_north->west;
added++;
}
}
} else if (south && rs_south->east != NULL) { // (east != NULL) == (west != NULL)
/* There is one to the south, but not to the north... so we become 'parent' */
this->east = rs_south->east;
this->west = rs_south->west;
SetBit(this->status, RSSFB_BASE_ENTRY);
ClrBit(rs_south->status, RSSFB_BASE_ENTRY);
} else {
/* We are the only... so we are automatically the master */
this->east = new Entry();
this->west = new Entry();
SetBit(this->status, RSSFB_BASE_ENTRY);
}
/* Now update the lengths */
added *= TILE_SIZE;
this->east->length += added;
this->west->length += added;
}
/**
* Prepare for removal of this stop; update other neighbouring stops
* if needed. Also update the length etc.
*/
void RoadStop::ClearDriveThrough()
{
assert(this->east != NULL && this->west != NULL);
RoadStopType rst = GetRoadStopType(this->xy);
DiagDirection dir = GetRoadStopDir(this->xy);
/* Use absolute so we always go towards the nortern tile */
TileIndexDiff offset = abs(TileOffsByDiagDir(dir));
/* Information about the tile north of us */
TileIndex north_tile = this->xy - offset;
bool north = IsDriveThroughRoadStopContinuation(this->xy, north_tile);
RoadStop *rs_north = north ? RoadStop::GetByTile(north_tile, rst) : NULL;
/* Information about the tile south of us */
TileIndex south_tile = this->xy + offset;
bool south = IsDriveThroughRoadStopContinuation(this->xy, south_tile);
RoadStop *rs_south = south ? RoadStop::GetByTile(south_tile, rst) : NULL;
/* Must only be cleared after we determined which neighbours are
* part of our little entry 'queue' */
DoClearSquare(this->xy);
if (north) {
/* There is a tile to the north, so we can't clear ourselves. */
if (south) {
/* There are more southern tiles too, they must be split;
* first make the new southern 'base' */
SetBit(rs_south->status, RSSFB_BASE_ENTRY);
rs_south->east = new Entry();
rs_south->west = new Entry();
/* Keep track of the base because we need it later on */
RoadStop *rs_south_base = rs_south;
TileIndex base_tile = south_tile;
/* Make all (even more) southern stops part of the new entry queue */
for (south_tile += offset; IsDriveThroughRoadStopContinuation(base_tile, south_tile); south_tile += offset) {
rs_south = RoadStop::GetByTile(south_tile, rst);
rs_south->east = rs_south_base->east;
rs_south->west = rs_south_base->west;
}
/* Find the other end; the northern most tile */
for (; IsDriveThroughRoadStopContinuation(base_tile, north_tile); north_tile -= offset) {
rs_north = RoadStop::GetByTile(north_tile, rst);
}
/* We have to rebuild the entries because we cannot easily determine
* how full each part is. So instead of keeping and maintaining a list
* of vehicles and using that to 'rebuild' the occupied state we just
* rebuild it from scratch as that removes lots of maintainance code
* for the vehicle list and it's faster in real games as long as you
* do not keep split and merge road stop every tick by the millions. */
rs_south_base->east->Rebuild(rs_south_base);
rs_south_base->west->Rebuild(rs_south_base);
assert(HasBit(rs_north->status, RSSFB_BASE_ENTRY));
rs_north->east->Rebuild(rs_north);
rs_north->west->Rebuild(rs_north);
} else {
/* Only we left, so simple update the length. */
rs_north->east->length -= TILE_SIZE;
rs_north->west->length -= TILE_SIZE;
}
} else if (south) {
/* There is only something to the south. Hand over the base entry */
SetBit(rs_south->status, RSSFB_BASE_ENTRY);
rs_south->east->length -= TILE_SIZE;
rs_south->west->length -= TILE_SIZE;
} else {
/* We were the last */
delete this->east;
delete this->west;
}
/* Make sure we don't get used for something 'incorrect' */
ClrBit(this->status, RSSFB_BASE_ENTRY);
this->east = NULL;
this->west = NULL;
}
/**
* Convert existing rail to waypoint. Eg build a waypoint station over
* piece of rail
* @param start_tile northern most tile where waypoint will be built
* @param flags type of operation
* @param p1 various bitstuffed elements
* - p1 = (bit 4) - orientation (Axis)
* - p1 = (bit 8-15) - width of waypoint
* - p1 = (bit 16-23) - height of waypoint
* - p1 = (bit 24) - allow waypoints directly adjacent to other waypoints.
* @param p2 various bitstuffed elements
* - p2 = (bit 0- 7) - custom station class
* - p2 = (bit 8-15) - custom station id
* @param text unused
* @return the cost of this operation or an error
*/
CommandCost CmdBuildRailWaypoint(TileIndex start_tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
/* Unpack parameters */
Axis axis = Extract<Axis, 4, 1>(p1);
byte width = GB(p1, 8, 8);
byte height = GB(p1, 16, 8);
bool adjacent = HasBit(p1, 24);
StationClassID spec_class = Extract<StationClassID, 0, 8>(p2);
byte spec_index = GB(p2, 8, 8);
StationID station_to_join = GB(p2, 16, 16);
/* Check if the given station class is valid */
if (spec_class != STAT_CLASS_WAYP) return CMD_ERROR;
if (spec_index >= StationClass::Get(spec_class)->GetSpecCount()) return CMD_ERROR;
/* The number of parts to build */
byte count = axis == AXIS_X ? height : width;
if ((axis == AXIS_X ? width : height) != 1) return CMD_ERROR;
if (count == 0 || count > _settings_game.station.station_spread) return CMD_ERROR;
bool reuse = (station_to_join != NEW_STATION);
if (!reuse) station_to_join = INVALID_STATION;
bool distant_join = (station_to_join != INVALID_STATION);
if (distant_join && (!_settings_game.station.distant_join_stations || !Waypoint::IsValidID(station_to_join))) return CMD_ERROR;
/* Make sure the area below consists of clear tiles. (OR tiles belonging to a certain rail station) */
StationID est = INVALID_STATION;
/* Check whether the tiles we're building on are valid rail or not. */
TileIndexDiff offset = TileOffsByDiagDir(AxisToDiagDir(OtherAxis(axis)));
for (int i = 0; i < count; i++) {
TileIndex tile = start_tile + i * offset;
CommandCost ret = IsValidTileForWaypoint(tile, axis, &est);
if (ret.Failed()) return ret;
}
Waypoint *wp = NULL;
TileArea new_location(TileArea(start_tile, width, height));
CommandCost ret = FindJoiningWaypoint(est, station_to_join, adjacent, new_location, &wp);
if (ret.Failed()) return ret;
/* Check if there is an already existing, deleted, waypoint close to us that we can reuse. */
TileIndex center_tile = start_tile + (count / 2) * offset;
if (wp == NULL && reuse) wp = FindDeletedWaypointCloseTo(center_tile, STR_SV_STNAME_WAYPOINT, _current_company);
if (wp != NULL) {
/* Reuse an existing waypoint. */
if (wp->owner != _current_company) return_cmd_error(STR_ERROR_TOO_CLOSE_TO_ANOTHER_WAYPOINT);
/* check if we want to expand an already existing waypoint? */
if (wp->train_station.tile != INVALID_TILE) {
CommandCost ret = CanExpandRailStation(wp, new_location, axis);
if (ret.Failed()) return ret;
}
CommandCost ret = wp->rect.BeforeAddRect(start_tile, width, height, StationRect::ADD_TEST);
if (ret.Failed()) return ret;
} else {
/* allocate and initialize new waypoint */
if (!Waypoint::CanAllocateItem()) return_cmd_error(STR_ERROR_TOO_MANY_STATIONS_LOADING);
}
if (flags & DC_EXEC) {
if (wp == NULL) {
wp = new Waypoint(start_tile);
} else if (!wp->IsInUse()) {
/* Move existing (recently deleted) waypoint to the new location */
wp->xy = start_tile;
}
wp->owner = GetTileOwner(start_tile);
wp->rect.BeforeAddRect(start_tile, width, height, StationRect::ADD_TRY);
wp->delete_ctr = 0;
wp->facilities |= FACIL_TRAIN;
wp->build_date = _date;
wp->string_id = STR_SV_STNAME_WAYPOINT;
wp->train_station = new_location;
if (wp->town == NULL) MakeDefaultName(wp);
wp->UpdateVirtCoord();
const StationSpec *spec = StationClass::Get(spec_class)->GetSpec(spec_index);
byte *layout_ptr = AllocaM(byte, count);
if (spec == NULL) {
/* The layout must be 0 for the 'normal' waypoints by design. */
memset(layout_ptr, 0, count);
} else {
/* But for NewGRF waypoints we like to have their style. */
GetStationLayout(layout_ptr, count, 1, spec);
}
byte map_spec_index = AllocateSpecToStation(spec, wp, true);
Company *c = Company::Get(wp->owner);
for (int i = 0; i < count; i++) {
TileIndex tile = start_tile + i * offset;
byte old_specindex = HasStationTileRail(tile) ? GetCustomStationSpecIndex(tile) : 0;
if (!HasStationTileRail(tile)) c->infrastructure.station++;
bool reserved = IsTileType(tile, MP_RAILWAY) ?
HasBit(GetRailReservationTrackBits(tile), AxisToTrack(axis)) :
HasStationReservation(tile);
MakeRailWaypoint(tile, wp->owner, wp->index, axis, layout_ptr[i], GetRailType(tile));
SetCustomStationSpecIndex(tile, map_spec_index);
SetRailStationReservation(tile, reserved);
MarkTileDirtyByTile(tile);
DeallocateSpecFromStation(wp, old_specindex);
YapfNotifyTrackLayoutChange(tile, AxisToTrack(axis));
}
DirtyCompanyInfrastructureWindows(wp->owner);
}
return CommandCost(EXPENSES_CONSTRUCTION, count * _price[PR_BUILD_WAYPOINT_RAIL]);
}