@@ -2359,1556 +2359,1553 @@ static CommandCost RemoveAirport(TileInd
st->rect.AfterRemoveRect(st, st->airport);
st->airport.Clear();
st->facilities &= ~FACIL_AIRPORT;
InvalidateWindowData(WC_STATION_VIEW, st->index, -1);
if (_settings_game.economy.station_noise_level) {
SetWindowDirty(WC_TOWN_VIEW, st->town->index);
}
Company::Get(st->owner)->infrastructure.airport--;
DirtyCompanyInfrastructureWindows(st->owner);
st->UpdateVirtCoord();
st->RecomputeIndustriesNear();
DeleteStationIfEmpty(st);
DeleteNewGRFInspectWindow(GSF_AIRPORTS, st->index);
return cost;
/**
* Open/close an airport to incoming aircraft.
* @param tile Unused.
* @param flags Operation to perform.
* @param p1 Station ID of the airport.
* @param p2 Unused.
* @param text unused
* @return the cost of this operation or an error
*/
CommandCost CmdOpenCloseAirport(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
if (!Station::IsValidID(p1)) return CMD_ERROR;
Station *st = Station::Get(p1);
if (!(st->facilities & FACIL_AIRPORT) || st->owner == OWNER_NONE) return CMD_ERROR;
CommandCost ret = CheckOwnership(st->owner);
if (ret.Failed()) return ret;
if (flags & DC_EXEC) {
st->airport.flags ^= AIRPORT_CLOSED_block;
SetWindowWidgetDirty(WC_STATION_VIEW, st->index, WID_SV_CLOSE_AIRPORT);
return CommandCost();
* Tests whether the company's vehicles have this station in orders
* @param station station ID
* @param include_company If true only check vehicles of \a company, if false only check vehicles of other companies
* @param company company ID
bool HasStationInUse(StationID station, bool include_company, CompanyID company)
const Vehicle *v;
FOR_ALL_VEHICLES(v) {
if ((v->owner == company) == include_company) {
const Order *order;
FOR_VEHICLE_ORDERS(v, order) {
if ((order->IsType(OT_GOTO_STATION) || order->IsType(OT_GOTO_WAYPOINT)) && order->GetDestination() == station) {
return true;
return false;
static const TileIndexDiffC _dock_tileoffs_chkaround[] = {
{-1, 0},
{ 0, 0},
{ 0, -1}
};
static const byte _dock_w_chk[4] = { 2, 1, 2, 1 };
static const byte _dock_h_chk[4] = { 1, 2, 1, 2 };
* Build a dock/haven.
* @param tile tile where dock will be built
* @param flags operation to perform
* @param p1 (bit 0) - allow docks directly adjacent to other docks.
* @param p2 bit 16-31: station ID to join (NEW_STATION if build new one)
CommandCost CmdBuildDock(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
StationID station_to_join = GB(p2, 16, 16);
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 || !Station::IsValidID(station_to_join))) return CMD_ERROR;
DiagDirection direction = GetInclinedSlopeDirection(GetTileSlope(tile));
if (direction == INVALID_DIAGDIR) return_cmd_error(STR_ERROR_SITE_UNSUITABLE);
direction = ReverseDiagDir(direction);
/* Docks cannot be placed on rapids */
if (HasTileWaterGround(tile)) return_cmd_error(STR_ERROR_SITE_UNSUITABLE);
CommandCost ret = CheckIfAuthorityAllowsNewStation(tile, flags);
if (MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
TileIndex tile_cur = tile + TileOffsByDiagDir(direction);
if (!IsTileType(tile_cur, MP_WATER) || GetTileSlope(tile_cur) != SLOPE_FLAT) {
return_cmd_error(STR_ERROR_SITE_UNSUITABLE);
if (MayHaveBridgeAbove(tile_cur) && IsBridgeAbove(tile_cur)) return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
/* Get the water class of the water tile before it is cleared.*/
WaterClass wc = GetWaterClass(tile_cur);
ret = DoCommand(tile_cur, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
tile_cur += TileOffsByDiagDir(direction);
TileArea dock_area = TileArea(tile + ToTileIndexDiff(_dock_tileoffs_chkaround[direction]),
_dock_w_chk[direction], _dock_h_chk[direction]);
/* middle */
Station *st = NULL;
ret = FindJoiningStation(INVALID_STATION, station_to_join, HasBit(p1, 0), dock_area, &st);
/* Distant join */
if (st == NULL && distant_join) st = Station::GetIfValid(station_to_join);
ret = BuildStationPart(&st, flags, reuse, dock_area, STATIONNAMING_DOCK);
if (st != NULL && st->dock_tile != INVALID_TILE) return_cmd_error(STR_ERROR_TOO_CLOSE_TO_ANOTHER_DOCK);
st->dock_tile = tile;
st->AddFacility(FACIL_DOCK, tile);
st->rect.BeforeAddRect(dock_area.tile, dock_area.w, dock_area.h, StationRect::ADD_TRY);
/* If the water part of the dock is on a canal, update infrastructure counts.
* This is needed as we've unconditionally cleared that tile before. */
if (wc == WATER_CLASS_CANAL) {
Company::Get(st->owner)->infrastructure.water++;
Company::Get(st->owner)->infrastructure.station += 2;
MakeDock(tile, st->owner, st->index, direction, wc);
UpdateStationAcceptance(st, false);
InvalidateWindowData(WC_SELECT_STATION, 0, 0);
InvalidateWindowData(WC_STATION_LIST, st->owner, 0);
SetWindowWidgetDirty(WC_STATION_VIEW, st->index, WID_SV_SHIPS);
return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_STATION_DOCK]);
* Remove a dock
* @param tile TileIndex been queried
* @return cost or failure of operation
static CommandCost RemoveDock(TileIndex tile, DoCommandFlag flags)
Station *st = Station::GetByTile(tile);
TileIndex docking_location = TILE_ADD(st->dock_tile, ToTileIndexDiff(GetDockOffset(st->dock_tile)));
TileIndex tile1 = st->dock_tile;
TileIndex tile2 = tile1 + TileOffsByDiagDir(GetDockDirection(tile1));
ret = EnsureNoVehicleOnGround(tile1);
if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile2);
DoClearSquare(tile1);
MarkTileDirtyByTile(tile1);
MakeWaterKeepingClass(tile2, st->owner);
st->rect.AfterRemoveTile(st, tile1);
st->rect.AfterRemoveTile(st, tile2);
st->dock_tile = INVALID_TILE;
st->facilities &= ~FACIL_DOCK;
Company::Get(st->owner)->infrastructure.station -= 2;
/* All ships that were going to our station, can't go to it anymore.
* Just clear the order, then automatically the next appropriate order
* will be selected and in case of no appropriate order it will just
* wander around the world. */
Ship *s;
FOR_ALL_SHIPS(s) {
if (s->current_order.IsType(OT_LOADING) && s->tile == docking_location) {
s->LeaveStation();
if (s->dest_tile == docking_location) {
s->dest_tile = 0;
s->current_order.Free();
return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_STATION_DOCK]);
#include "table/station_land.h"
const DrawTileSprites *GetStationTileLayout(StationType st, byte gfx)
return &_station_display_datas[st][gfx];
* Check whether a sprite is a track sprite, which can be replaced by a non-track ground sprite and a rail overlay.
* If the ground sprite is suitable, \a ground is replaced with the new non-track ground sprite, and \a overlay_offset
* is set to the overlay to draw.
* @param ti Positional info for the tile to decide snowyness etc. May be NULL.
* @param [in,out] ground Groundsprite to draw.
* @param [out] overlay_offset Overlay to draw.
* @return true if overlay can be drawn.
bool SplitGroundSpriteForOverlay(const TileInfo *ti, SpriteID *ground, RailTrackOffset *overlay_offset)
bool snow_desert;
switch (*ground) {
case SPR_RAIL_TRACK_X:
snow_desert = false;
*overlay_offset = RTO_X;
break;
case SPR_RAIL_TRACK_Y:
*overlay_offset = RTO_Y;
case SPR_RAIL_TRACK_X_SNOW:
snow_desert = true;
case SPR_RAIL_TRACK_Y_SNOW:
default:
if (ti != NULL) {
/* Decide snow/desert from tile */
switch (_settings_game.game_creation.landscape) {
case LT_ARCTIC:
snow_desert = (uint)ti->z > GetSnowLine() * TILE_HEIGHT;
case LT_TROPIC:
snow_desert = GetTropicZone(ti->tile) == TROPICZONE_DESERT;
*ground = snow_desert ? SPR_FLAT_SNOW_DESERT_TILE : SPR_FLAT_GRASS_TILE;
static void DrawTile_Station(TileInfo *ti)
const NewGRFSpriteLayout *layout = NULL;
DrawTileSprites tmp_rail_layout;
const DrawTileSprites *t = NULL;
RoadTypes roadtypes;
int32 total_offset;
const RailtypeInfo *rti = NULL;
uint32 relocation = 0;
uint32 ground_relocation = 0;
BaseStation *st = NULL;
const StationSpec *statspec = NULL;
uint tile_layout = 0;
if (HasStationRail(ti->tile)) {
rti = GetRailTypeInfo(GetRailType(ti->tile));
roadtypes = ROADTYPES_NONE;
total_offset = rti->GetRailtypeSpriteOffset();
if (IsCustomStationSpecIndex(ti->tile)) {
/* look for customization */
st = BaseStation::GetByTile(ti->tile);
statspec = st->speclist[GetCustomStationSpecIndex(ti->tile)].spec;
if (statspec != NULL) {
tile_layout = GetStationGfx(ti->tile);
if (HasBit(statspec->callback_mask, CBM_STATION_SPRITE_LAYOUT)) {
uint16 callback = GetStationCallback(CBID_STATION_SPRITE_LAYOUT, 0, 0, statspec, st, ti->tile);
if (callback != CALLBACK_FAILED) tile_layout = (callback & ~1) + GetRailStationAxis(ti->tile);
/* Ensure the chosen tile layout is valid for this custom station */
if (statspec->renderdata != NULL) {
layout = &statspec->renderdata[tile_layout < statspec->tiles ? tile_layout : (uint)GetRailStationAxis(ti->tile)];
if (!layout->NeedsPreprocessing()) {
t = layout;
layout = NULL;
} else {
roadtypes = IsRoadStop(ti->tile) ? GetRoadTypes(ti->tile) : ROADTYPES_NONE;
total_offset = 0;
StationGfx gfx = GetStationGfx(ti->tile);
if (IsAirport(ti->tile)) {
gfx = GetAirportGfx(ti->tile);
if (gfx >= NEW_AIRPORTTILE_OFFSET) {
const AirportTileSpec *ats = AirportTileSpec::Get(gfx);
if (ats->grf_prop.spritegroup[0] != NULL && DrawNewAirportTile(ti, Station::GetByTile(ti->tile), gfx, ats)) {
return;
/* No sprite group (or no valid one) found, meaning no graphics associated.
* Use the substitute one instead */
assert(ats->grf_prop.subst_id != INVALID_AIRPORTTILE);
gfx = ats->grf_prop.subst_id;
switch (gfx) {
case APT_RADAR_GRASS_FENCE_SW:
t = &_station_display_datas_airport_radar_grass_fence_sw[GetAnimationFrame(ti->tile)];
case APT_GRASS_FENCE_NE_FLAG:
t = &_station_display_datas_airport_flag_grass_fence_ne[GetAnimationFrame(ti->tile)];
case APT_RADAR_FENCE_SW:
t = &_station_display_datas_airport_radar_fence_sw[GetAnimationFrame(ti->tile)];
case APT_RADAR_FENCE_NE:
t = &_station_display_datas_airport_radar_fence_ne[GetAnimationFrame(ti->tile)];
case APT_GRASS_FENCE_NE_FLAG_2:
t = &_station_display_datas_airport_flag_grass_fence_ne_2[GetAnimationFrame(ti->tile)];
Owner owner = GetTileOwner(ti->tile);
PaletteID palette;
if (Company::IsValidID(owner)) {
palette = COMPANY_SPRITE_COLOUR(owner);
/* Some stations are not owner by a company, namely oil rigs */
palette = PALETTE_TO_GREY;
if (layout == NULL && (t == NULL || t->seq == NULL)) t = GetStationTileLayout(GetStationType(ti->tile), gfx);
/* don't show foundation for docks */
if (ti->tileh != SLOPE_FLAT && !IsDock(ti->tile)) {
if (statspec != NULL && HasBit(statspec->flags, SSF_CUSTOM_FOUNDATIONS)) {
/* Station has custom foundations.
* Check whether the foundation continues beyond the tile's upper sides. */
uint edge_info = 0;
int z;
Slope slope = GetFoundationPixelSlope(ti->tile, &z);
if (!HasFoundationNW(ti->tile, slope, z)) SetBit(edge_info, 0);
if (!HasFoundationNE(ti->tile, slope, z)) SetBit(edge_info, 1);
SpriteID image = GetCustomStationFoundationRelocation(statspec, st, ti->tile, tile_layout, edge_info);
if (image == 0) goto draw_default_foundation;
if (HasBit(statspec->flags, SSF_EXTENDED_FOUNDATIONS)) {
/* Station provides extended foundations. */
static const uint8 foundation_parts[] = {
0, 0, 0, 0, // Invalid, Invalid, Invalid, SLOPE_SW
0, 1, 2, 3, // Invalid, SLOPE_EW, SLOPE_SE, SLOPE_WSE
0, 4, 5, 6, // Invalid, SLOPE_NW, SLOPE_NS, SLOPE_NWS
7, 8, 9 // SLOPE_NE, SLOPE_ENW, SLOPE_SEN
AddSortableSpriteToDraw(image + foundation_parts[ti->tileh], PAL_NONE, ti->x, ti->y, 16, 16, 7, ti->z);
/* Draw simple foundations, built up from 8 possible foundation sprites. */
/* Each set bit represents one of the eight composite sprites to be drawn.
* 'Invalid' entries will not drawn but are included for completeness. */
static const uint8 composite_foundation_parts[] = {
/* Invalid (00000000), Invalid (11010001), Invalid (11100100), SLOPE_SW (11100000) */
0x00, 0xD1, 0xE4, 0xE0,
/* Invalid (11001010), SLOPE_EW (11001001), SLOPE_SE (11000100), SLOPE_WSE (11000000) */
0xCA, 0xC9, 0xC4, 0xC0,
/* Invalid (11010010), SLOPE_NW (10010001), SLOPE_NS (11100100), SLOPE_NWS (10100000) */
0xD2, 0x91, 0xE4, 0xA0,
/* SLOPE_NE (01001010), SLOPE_ENW (00001001), SLOPE_SEN (01000100) */
0x4A, 0x09, 0x44
uint8 parts = composite_foundation_parts[ti->tileh];
/* If foundations continue beyond the tile's upper sides then
* mask out the last two pieces. */
if (HasBit(edge_info, 0)) ClrBit(parts, 6);
if (HasBit(edge_info, 1)) ClrBit(parts, 7);
if (parts == 0) {
/* We always have to draw at least one sprite to make sure there is a boundingbox and a sprite with the
* correct offset for the childsprites.
* So, draw the (completely empty) sprite of the default foundations. */
goto draw_default_foundation;
StartSpriteCombine();
for (int i = 0; i < 8; i++) {
if (HasBit(parts, i)) {
AddSortableSpriteToDraw(image + i, PAL_NONE, ti->x, ti->y, 16, 16, 7, ti->z);
EndSpriteCombine();
OffsetGroundSprite(31, 1);
ti->z += ApplyPixelFoundationToSlope(FOUNDATION_LEVELED, &ti->tileh);
draw_default_foundation:
DrawFoundation(ti, FOUNDATION_LEVELED);
if (IsBuoy(ti->tile)) {
DrawWaterClassGround(ti);
SpriteID sprite = GetCanalSprite(CF_BUOY, ti->tile);
if (sprite != 0) total_offset = sprite - SPR_IMG_BUOY;
} else if (IsDock(ti->tile) || (IsOilRig(ti->tile) && IsTileOnWater(ti->tile))) {
if (ti->tileh == SLOPE_FLAT) {
assert(IsDock(ti->tile));
TileIndex water_tile = ti->tile + TileOffsByDiagDir(GetDockDirection(ti->tile));
WaterClass wc = GetWaterClass(water_tile);
if (wc == WATER_CLASS_SEA) {
DrawShoreTile(ti->tileh);
DrawClearLandTile(ti, 3);
if (layout != NULL) {
/* Sprite layout which needs preprocessing */
bool separate_ground = HasBit(statspec->flags, SSF_SEPARATE_GROUND);
uint32 var10_values = layout->PrepareLayout(total_offset, rti->fallback_railtype, 0, 0, separate_ground);
uint8 var10;
FOR_EACH_SET_BIT(var10, var10_values) {
uint32 var10_relocation = GetCustomStationRelocation(statspec, st, ti->tile, var10);
layout->ProcessRegisters(var10, var10_relocation, separate_ground);
tmp_rail_layout.seq = layout->GetLayout(&tmp_rail_layout.ground);
t = &tmp_rail_layout;
} else if (statspec != NULL) {
/* Simple sprite layout */
ground_relocation = relocation = GetCustomStationRelocation(statspec, st, ti->tile, 0);
if (HasBit(statspec->flags, SSF_SEPARATE_GROUND)) {
ground_relocation = GetCustomStationRelocation(statspec, st, ti->tile, 1);
ground_relocation += rti->fallback_railtype;
SpriteID image = t->ground.sprite;
PaletteID pal = t->ground.pal;
RailTrackOffset overlay_offset;
if (rti != NULL && rti->UsesOverlay() && SplitGroundSpriteForOverlay(ti, &image, &overlay_offset)) {
SpriteID ground = GetCustomRailSprite(rti, ti->tile, RTSG_GROUND);
DrawGroundSprite(image, PAL_NONE);
DrawGroundSprite(ground + overlay_offset, PAL_NONE);
if (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation && HasStationReservation(ti->tile)) {
SpriteID overlay = GetCustomRailSprite(rti, ti->tile, RTSG_OVERLAY);
DrawGroundSprite(overlay + overlay_offset, PALETTE_CRASH);
image += HasBit(image, SPRITE_MODIFIER_CUSTOM_SPRITE) ? ground_relocation : total_offset;
if (HasBit(pal, SPRITE_MODIFIER_CUSTOM_SPRITE)) pal += ground_relocation;
DrawGroundSprite(image, GroundSpritePaletteTransform(image, pal, palette));
/* PBS debugging, draw reserved tracks darker */
if (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation && HasStationRail(ti->tile) && HasStationReservation(ti->tile)) {
const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile));
DrawGroundSprite(GetRailStationAxis(ti->tile) == AXIS_X ? rti->base_sprites.single_x : rti->base_sprites.single_y, PALETTE_CRASH);
if (HasStationRail(ti->tile) && HasCatenaryDrawn(GetRailType(ti->tile))) DrawCatenary(ti);
if (HasBit(roadtypes, ROADTYPE_TRAM)) {
Axis axis = GetRoadStopDir(ti->tile) == DIAGDIR_NE ? AXIS_X : AXIS_Y;
DrawGroundSprite((HasBit(roadtypes, ROADTYPE_ROAD) ? SPR_TRAMWAY_OVERLAY : SPR_TRAMWAY_TRAM) + (axis ^ 1), PAL_NONE);
DrawTramCatenary(ti, axis == AXIS_X ? ROAD_X : ROAD_Y);
if (IsRailWaypoint(ti->tile)) {
/* Don't offset the waypoint graphics; they're always the same. */
DrawRailTileSeq(ti, t, TO_BUILDINGS, total_offset, relocation, palette);
void StationPickerDrawSprite(int x, int y, StationType st, RailType railtype, RoadType roadtype, int image)
int32 total_offset = 0;
PaletteID pal = COMPANY_SPRITE_COLOUR(_local_company);
const DrawTileSprites *t = GetStationTileLayout(st, image);
if (railtype != INVALID_RAILTYPE) {
rti = GetRailTypeInfo(railtype);
SpriteID img = t->ground.sprite;
if (rti != NULL && rti->UsesOverlay() && SplitGroundSpriteForOverlay(NULL, &img, &overlay_offset)) {
SpriteID ground = GetCustomRailSprite(rti, INVALID_TILE, RTSG_GROUND);
DrawSprite(img, PAL_NONE, x, y);
DrawSprite(ground + overlay_offset, PAL_NONE, x, y);
DrawSprite(img + total_offset, HasBit(img, PALETTE_MODIFIER_COLOUR) ? pal : PAL_NONE, x, y);
if (roadtype == ROADTYPE_TRAM) {
DrawSprite(SPR_TRAMWAY_TRAM + (t->ground.sprite == SPR_ROAD_PAVED_STRAIGHT_X ? 1 : 0), PAL_NONE, x, y);
/* Default waypoint has no railtype specific sprites */
DrawRailTileSeqInGUI(x, y, t, st == STATION_WAYPOINT ? 0 : total_offset, 0, pal);
static int GetSlopePixelZ_Station(TileIndex tile, uint x, uint y)
return GetTileMaxPixelZ(tile);
static Foundation GetFoundation_Station(TileIndex tile, Slope tileh)
return FlatteningFoundation(tileh);
static void GetTileDesc_Station(TileIndex tile, TileDesc *td)
td->owner[0] = GetTileOwner(tile);
if (IsDriveThroughStopTile(tile)) {
Owner road_owner = INVALID_OWNER;
Owner tram_owner = INVALID_OWNER;
RoadTypes rts = GetRoadTypes(tile);
if (HasBit(rts, ROADTYPE_ROAD)) road_owner = GetRoadOwner(tile, ROADTYPE_ROAD);
if (HasBit(rts, ROADTYPE_TRAM)) tram_owner = GetRoadOwner(tile, ROADTYPE_TRAM);
/* Is there a mix of owners? */
if ((tram_owner != INVALID_OWNER && tram_owner != td->owner[0]) ||
(road_owner != INVALID_OWNER && road_owner != td->owner[0])) {
uint i = 1;
if (road_owner != INVALID_OWNER) {
td->owner_type[i] = STR_LAND_AREA_INFORMATION_ROAD_OWNER;
td->owner[i] = road_owner;
i++;
if (tram_owner != INVALID_OWNER) {
td->owner_type[i] = STR_LAND_AREA_INFORMATION_TRAM_OWNER;
td->owner[i] = tram_owner;
td->build_date = BaseStation::GetByTile(tile)->build_date;
if (HasStationTileRail(tile)) {
const StationSpec *spec = GetStationSpec(tile);
if (spec != NULL) {
td->station_class = StationClass::Get(spec->cls_id)->name;
td->station_name = spec->name;
if (spec->grf_prop.grffile != NULL) {
const GRFConfig *gc = GetGRFConfig(spec->grf_prop.grffile->grfid);
td->grf = gc->GetName();
const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(tile));
td->rail_speed = rti->max_speed;
if (IsAirport(tile)) {
const AirportSpec *as = Station::GetByTile(tile)->airport.GetSpec();
td->airport_class = AirportClass::Get(as->cls_id)->name;
td->airport_name = as->name;
const AirportTileSpec *ats = AirportTileSpec::GetByTile(tile);
td->airport_tile_name = ats->name;
if (as->grf_prop.grffile != NULL) {
const GRFConfig *gc = GetGRFConfig(as->grf_prop.grffile->grfid);
} else if (ats->grf_prop.grffile != NULL) {
const GRFConfig *gc = GetGRFConfig(ats->grf_prop.grffile->grfid);
StringID str;
switch (GetStationType(tile)) {
default: NOT_REACHED();
case STATION_RAIL: str = STR_LAI_STATION_DESCRIPTION_RAILROAD_STATION; break;
case STATION_AIRPORT:
str = (IsHangar(tile) ? STR_LAI_STATION_DESCRIPTION_AIRCRAFT_HANGAR : STR_LAI_STATION_DESCRIPTION_AIRPORT);
case STATION_TRUCK: str = STR_LAI_STATION_DESCRIPTION_TRUCK_LOADING_AREA; break;
case STATION_BUS: str = STR_LAI_STATION_DESCRIPTION_BUS_STATION; break;
case STATION_OILRIG: str = STR_INDUSTRY_NAME_OIL_RIG; break;
case STATION_DOCK: str = STR_LAI_STATION_DESCRIPTION_SHIP_DOCK; break;
case STATION_BUOY: str = STR_LAI_STATION_DESCRIPTION_BUOY; break;
case STATION_WAYPOINT: str = STR_LAI_STATION_DESCRIPTION_WAYPOINT; break;
td->str = str;
static TrackStatus GetTileTrackStatus_Station(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
TrackBits trackbits = TRACK_BIT_NONE;
switch (mode) {
case TRANSPORT_RAIL:
if (HasStationRail(tile) && !IsStationTileBlocked(tile)) {
trackbits = TrackToTrackBits(GetRailStationTrack(tile));
case TRANSPORT_WATER:
/* buoy is coded as a station, it is always on open water */
if (IsBuoy(tile)) {
trackbits = TRACK_BIT_ALL;
/* remove tracks that connect NE map edge */
if (TileX(tile) == 0) trackbits &= ~(TRACK_BIT_X | TRACK_BIT_UPPER | TRACK_BIT_RIGHT);
/* remove tracks that connect NW map edge */
if (TileY(tile) == 0) trackbits &= ~(TRACK_BIT_Y | TRACK_BIT_LEFT | TRACK_BIT_UPPER);
case TRANSPORT_ROAD:
if ((GetRoadTypes(tile) & sub_mode) != 0 && IsRoadStop(tile)) {
DiagDirection dir = GetRoadStopDir(tile);
Axis axis = DiagDirToAxis(dir);
if (side != INVALID_DIAGDIR) {
if (axis != DiagDirToAxis(side) || (IsStandardRoadStopTile(tile) && dir != side)) break;
trackbits = AxisToTrackBits(axis);
return CombineTrackStatus(TrackBitsToTrackdirBits(trackbits), TRACKDIR_BIT_NONE);
static void TileLoop_Station(TileIndex tile)
/* FIXME -- GetTileTrackStatus_Station -> animated stationtiles
* hardcoded.....not good */
AirportTileAnimationTrigger(Station::GetByTile(tile), tile, AAT_TILELOOP);
case STATION_DOCK:
if (GetTileSlope(tile) != SLOPE_FLAT) break; // only handle water part
/* FALL THROUGH */
case STATION_OILRIG: //(station part)
case STATION_BUOY:
TileLoop_Water(tile);
default: break;
static void AnimateTile_Station(TileIndex tile)
if (HasStationRail(tile)) {
AnimateStationTile(tile);
AnimateAirportTile(tile);
static bool ClickTile_Station(TileIndex tile)
const BaseStation *bst = BaseStation::GetByTile(tile);
if (bst->facilities & FACIL_WAYPOINT) {
ShowWaypointWindow(Waypoint::From(bst));
} else if (IsHangar(tile)) {
const Station *st = Station::From(bst);
ShowDepotWindow(st->airport.GetHangarTile(st->airport.GetHangarNum(tile)), VEH_AIRCRAFT);
ShowStationViewWindow(bst->index);
static VehicleEnterTileStatus VehicleEnter_Station(Vehicle *v, TileIndex tile, int x, int y)
if (v->type == VEH_TRAIN) {
StationID station_id = GetStationIndex(tile);
if (!v->current_order.ShouldStopAtStation(v, station_id)) return VETSB_CONTINUE;
if (!IsRailStation(tile) || !v->IsFrontEngine()) return VETSB_CONTINUE;
int station_ahead;
int station_length;
int stop = GetTrainStopLocation(station_id, tile, Train::From(v), &station_ahead, &station_length);
/* Stop whenever that amount of station ahead + the distance from the
* begin of the platform to the stop location is longer than the length
* of the platform. Station ahead 'includes' the current tile where the
* vehicle is on, so we need to subtract that. */
if (!IsInsideBS(stop + station_ahead, station_length, TILE_SIZE)) return VETSB_CONTINUE;
if (stop + station_ahead - (int)TILE_SIZE >= station_length) return VETSB_CONTINUE;
DiagDirection dir = DirToDiagDir(v->direction);
x &= 0xF;
y &= 0xF;
if (DiagDirToAxis(dir) != AXIS_X) Swap(x, y);
if (y == TILE_SIZE / 2) {
if (dir != DIAGDIR_SE && dir != DIAGDIR_SW) x = TILE_SIZE - 1 - x;
stop &= TILE_SIZE - 1;
if (x == stop) return VETSB_ENTERED_STATION | (VehicleEnterTileStatus)(station_id << VETS_STATION_ID_OFFSET); // enter station
if (x < stop) {
uint16 spd;
v->vehstatus |= VS_TRAIN_SLOWING;
spd = max(0, (stop - x) * 20 - 15);
if (spd < v->cur_speed) v->cur_speed = spd;
if (x >= stop) return VETSB_ENTERED_STATION | (VehicleEnterTileStatus)(station_id << VETS_STATION_ID_OFFSET); // enter station
uint16 spd = max(0, (stop - x) * 20 - 15);
} else if (v->type == VEH_ROAD) {
RoadVehicle *rv = RoadVehicle::From(v);
if (rv->state < RVSB_IN_ROAD_STOP && !IsReversingRoadTrackdir((Trackdir)rv->state) && rv->frame == 0) {
if (IsRoadStop(tile) && rv->IsFrontEngine()) {
/* Attempt to allocate a parking bay in a road stop */
return RoadStop::GetByTile(tile, GetRoadStopType(tile))->Enter(rv) ? VETSB_CONTINUE : VETSB_CANNOT_ENTER;
return VETSB_CONTINUE;
* Run the watched cargo callback for all houses in the catchment area.
* @param st Station.
void TriggerWatchedCargoCallbacks(Station *st)
/* Collect cargoes accepted since the last big tick. */
uint cargoes = 0;
for (CargoID cid = 0; cid < NUM_CARGO; cid++) {
if (HasBit(st->goods[cid].acceptance_pickup, GoodsEntry::GES_ACCEPTED_BIGTICK)) SetBit(cargoes, cid);
/* Anything to do? */
if (cargoes == 0) return;
/* Loop over all houses in the catchment. */
Rect r = st->GetCatchmentRect();
TileArea ta(TileXY(r.left, r.top), TileXY(r.right, r.bottom));
TILE_AREA_LOOP(tile, ta) {
if (IsTileType(tile, MP_HOUSE)) {
WatchedCargoCallback(tile, cargoes);
* This function is called for each station once every 250 ticks.
* Not all stations will get the tick at the same time.
* @param st the station receiving the tick.
* @return true if the station is still valid (wasn't deleted)
static bool StationHandleBigTick(BaseStation *st)
if (!st->IsInUse()) {
if (++st->delete_ctr >= 8) delete st;
if (Station::IsExpected(st)) {
TriggerWatchedCargoCallbacks(Station::From(st));
for (CargoID i = 0; i < NUM_CARGO; i++) {
ClrBit(Station::From(st)->goods[i].acceptance_pickup, GoodsEntry::GES_ACCEPTED_BIGTICK);
if ((st->facilities & FACIL_WAYPOINT) == 0) UpdateStationAcceptance(Station::From(st), true);
static inline void byte_inc_sat(byte *p)
byte b = *p + 1;
if (b != 0) *p = b;
static void UpdateStationRating(Station *st)
bool waiting_changed = false;
byte_inc_sat(&st->time_since_load);
byte_inc_sat(&st->time_since_unload);
const CargoSpec *cs;
FOR_ALL_CARGOSPECS(cs) {
GoodsEntry *ge = &st->goods[cs->Index()];
/* Slowly increase the rating back to his original level in the case we
* didn't deliver cargo yet to this station. This happens when a bribe
* failed while you didn't moved that cargo yet to a station. */
if (!ge->HasRating() && ge->rating < INITIAL_STATION_RATING) {
ge->rating++;
/* Only change the rating if we are moving this cargo */
if (ge->HasRating()) {
byte_inc_sat(&ge->time_since_pickup);
bool skip = false;
int rating = 0;
uint waiting = ge->cargo.TotalCount();
/* num_dests is at least 1 if there is any cargo as
* INVALID_STATION is also a destination.
uint num_dests = (uint)ge->cargo.Packets()->MapSize();
/* Average amount of cargo per next hop, but prefer solitary stations
* with only one or two next hops. They are allowed to have more
* cargo waiting per next hop.
* With manual cargo distribution waiting_avg = waiting / 2 as then
* INVALID_STATION is the only destination.
uint waiting_avg = waiting / (num_dests + 1);
if (HasBit(cs->callback_mask, CBM_CARGO_STATION_RATING_CALC)) {
/* Perform custom station rating. If it succeeds the speed, days in transit and
* waiting cargo ratings must not be executed. */
/* NewGRFs expect last speed to be 0xFF when no vehicle has arrived yet. */
uint last_speed = ge->HasVehicleEverTriedLoading() ? ge->last_speed : 0xFF;
uint32 var18 = min(ge->time_since_pickup, 0xFF) | (min(ge->max_waiting_cargo, 0xFFFF) << 8) | (min(last_speed, 0xFF) << 24);
/* Convert to the 'old' vehicle types */
uint32 var10 = (st->last_vehicle_type == VEH_INVALID) ? 0x0 : (st->last_vehicle_type + 0x10);
uint16 callback = GetCargoCallback(CBID_CARGO_STATION_RATING_CALC, var10, var18, cs);
if (callback != CALLBACK_FAILED) {
skip = true;
rating = GB(callback, 0, 14);
/* Simulate a 15 bit signed value */
if (HasBit(callback, 14)) rating -= 0x4000;
if (!skip) {
int b = ge->last_speed - 85;
if (b >= 0) rating += b >> 2;
byte waittime = ge->time_since_pickup;
if (st->last_vehicle_type == VEH_SHIP) waittime >>= 2;
(waittime > 21) ||
(rating += 25, waittime > 12) ||
(rating += 25, waittime > 6) ||
(rating += 45, waittime > 3) ||
(rating += 35, true);
(rating -= 90, ge->max_waiting_cargo > 1500) ||
(rating += 55, ge->max_waiting_cargo > 1000) ||
(rating += 35, ge->max_waiting_cargo > 600) ||
(rating += 10, ge->max_waiting_cargo > 300) ||
(rating += 20, ge->max_waiting_cargo > 100) ||
(rating += 10, true);
if (Company::IsValidID(st->owner) && HasBit(st->town->statues, st->owner)) rating += 26;
byte age = ge->last_age;
(age >= 3) ||
(rating += 10, age >= 2) ||
(rating += 10, age >= 1) ||
(rating += 13, true);
int or_ = ge->rating; // old rating
/* only modify rating in steps of -2, -1, 0, 1 or 2 */
ge->rating = rating = or_ + Clamp(Clamp(rating, 0, 255) - or_, -2, 2);
/* if rating is <= 64 and more than 100 items waiting on average per destination,
* remove some random amount of goods from the station */
if (rating <= 64 && waiting_avg >= 100) {
int dec = Random() & 0x1F;
if (waiting_avg < 200) dec &= 7;
waiting -= (dec + 1) * num_dests;
waiting_changed = true;
/* if rating is <= 127 and there are any items waiting, maybe remove some goods. */
if (rating <= 127 && waiting != 0) {
uint32 r = Random();
if (rating <= (int)GB(r, 0, 7)) {
/* Need to have int, otherwise it will just overflow etc. */
waiting = max((int)waiting - (int)((GB(r, 8, 2) - 1) * num_dests), 0);
/* At some point we really must cap the cargo. Previously this
* was a strict 4095, but now we'll have a less strict, but
* increasingly aggressive truncation of the amount of cargo. */
static const uint WAITING_CARGO_THRESHOLD = 1 << 12;
static const uint WAITING_CARGO_CUT_FACTOR = 1 << 6;
static const uint MAX_WAITING_CARGO = 1 << 15;
if (waiting > WAITING_CARGO_THRESHOLD) {
uint difference = waiting - WAITING_CARGO_THRESHOLD;
waiting -= (difference / WAITING_CARGO_CUT_FACTOR);
waiting = min(waiting, MAX_WAITING_CARGO);
/* We can't truncate cargo that's already reserved for loading.
* Thus StoredCount() here. */
if (waiting_changed && waiting < ge->cargo.AvailableCount()) {
/* Feed back the exact own waiting cargo at this station for the
* next rating calculation. */
ge->max_waiting_cargo = 0;
/* If truncating also punish the source stations' ratings to
* decrease the flow of incoming cargo. */
StationCargoAmountMap waiting_per_source;
ge->cargo.Truncate(ge->cargo.AvailableCount() - waiting, &waiting_per_source);
for (StationCargoAmountMap::iterator i(waiting_per_source.begin()); i != waiting_per_source.end(); ++i) {
Station *source_station = Station::GetIfValid(i->first);
if (source_station == NULL) continue;
GoodsEntry &source_ge = source_station->goods[cs->Index()];
source_ge.max_waiting_cargo = max(source_ge.max_waiting_cargo, i->second);
/* If the average number per next hop is low, be more forgiving. */
ge->max_waiting_cargo = waiting_avg;
StationID index = st->index;
if (waiting_changed) {
SetWindowDirty(WC_STATION_VIEW, index); // update whole window
SetWindowWidgetDirty(WC_STATION_VIEW, index, WID_SV_ACCEPT_RATING_LIST); // update only ratings list
* Reroute cargo of type c at station st or in any vehicles unloading there.
* Make sure the cargo's new next hop is neither "avoid" nor "avoid2".
* @param st Station to be rerouted at.
* @param c Type of cargo.
* @param avoid Original next hop of cargo, avoid this.
* @param avoid2 Another station to be avoided when rerouting.
void RerouteCargo(Station *st, CargoID c, StationID avoid, StationID avoid2)
GoodsEntry &ge = st->goods[c];
/* Reroute cargo in station. */
ge.cargo.Reroute(UINT_MAX, &ge.cargo, avoid, avoid2, &ge);
/* Reroute cargo staged to be transfered. */
for (std::list<Vehicle *>::iterator it(st->loading_vehicles.begin()); it != st->loading_vehicles.end(); ++it) {
for (Vehicle *v = *it; v != NULL; v = v->Next()) {
if (v->cargo_type != c) continue;
v->cargo.Reroute(UINT_MAX, &v->cargo, avoid, avoid2, &ge);
* Check all next hops of cargo packets in this station for existance of a
* a valid link they may use to travel on. Reroute any cargo not having a valid
* link and remove timed out links found like this from the linkgraph. We're
* not all links here as that is expensive and useless. A link no one is using
* doesn't hurt either.
* @param from Station to check.
void DeleteStaleLinks(Station *from)
for (CargoID c = 0; c < NUM_CARGO; ++c) {
GoodsEntry &ge = from->goods[c];
LinkGraph *lg = LinkGraph::GetIfValid(ge.link_graph);
if (lg == NULL) continue;
Node node = (*lg)[ge.node];
for (EdgeIterator it(node.Begin()); it != node.End();) {
Edge edge = it->second;
Station *to = Station::Get((*lg)[it->first].Station());
assert(to->goods[c].node == it->first);
++it; // Do that before removing the node. Anything else may crash.
assert(_date >= edge.LastUpdate());
if ((uint)(_date - edge.LastUpdate()) > LinkGraph::MIN_TIMEOUT_DISTANCE +
(DistanceManhattan(from->xy, to->xy) >> 2)) {
node.RemoveEdge(to->goods[c].node);
ge.flows.DeleteFlows(to->index);
RerouteCargo(from, c, to->index, from->index);
assert(_date >= lg->LastCompression());
if ((uint)(_date - lg->LastCompression()) > LinkGraph::COMPRESSION_INTERVAL) {
lg->Compress();
* Increase capacity for a link stat given by station cargo and next hop.
* @param st Station to get the link stats from.
* @param cargo Cargo to increase stat for.
* @param next_station_id Station the consist will be travelling to next.
* @param capacity Capacity to add to link stat.
* @param usage Usage to add to link stat. If UINT_MAX refresh the link instead of increasing.
void IncreaseStats(Station *st, CargoID cargo, StationID next_station_id, uint capacity, uint usage)
GoodsEntry &ge1 = st->goods[cargo];
Station *st2 = Station::Get(next_station_id);
GoodsEntry &ge2 = st2->goods[cargo];
LinkGraph *lg = NULL;
if (ge1.link_graph == INVALID_LINK_GRAPH) {
if (ge2.link_graph == INVALID_LINK_GRAPH) {
if (LinkGraph::CanAllocateItem()) {
lg = new LinkGraph(cargo);
LinkGraphSchedule::Instance()->Queue(lg);
ge2.link_graph = lg->index;
ge2.node = lg->AddNode(st2);
DEBUG(misc, 0, "Can't allocate link graph");
lg = LinkGraph::Get(ge2.link_graph);
if (lg) {
ge1.link_graph = lg->index;
ge1.node = lg->AddNode(st);
} else if (ge2.link_graph == INVALID_LINK_GRAPH) {
lg = LinkGraph::Get(ge1.link_graph);
if (ge1.link_graph != ge2.link_graph) {
LinkGraph *lg2 = LinkGraph::Get(ge2.link_graph);
if (lg->Size() < lg2->Size()) {
LinkGraphSchedule::Instance()->Unqueue(lg);
lg2->Merge(lg); // Updates GoodsEntries of lg
lg = lg2;
LinkGraphSchedule::Instance()->Unqueue(lg2);
lg->Merge(lg2); // Updates GoodsEntries of lg2
if (lg != NULL) {
(*lg)[ge1.node].UpdateEdge(ge2.node, capacity, usage);
* Increase capacity for all link stats associated with vehicles in the given consist.
* @param front First vehicle in the consist.
void IncreaseStats(Station *st, const Vehicle *front, StationID next_station_id)
for (const Vehicle *v = front; v != NULL; v = v->Next()) {
if (v->refit_cap > 0) {
/* The cargo count can indeed be higher than the refit_cap if
* wagons have been auto-replaced and subsequently auto-
* refitted to a higher capacity. The cargo gets redistributed
* among the wagons in that case.
* As usage is not such an important figure anyway we just
* ignore the additional cargo then.*/
IncreaseStats(st, v->cargo_type, next_station_id, v->refit_cap,
min(v->refit_cap, v->cargo.StoredCount()));
/* called for every station each tick */
static void StationHandleSmallTick(BaseStation *st)
if ((st->facilities & FACIL_WAYPOINT) != 0 || !st->IsInUse()) return;
byte b = st->delete_ctr + 1;
if (b >= STATION_RATING_TICKS) b = 0;
st->delete_ctr = b;
if (b == 0) UpdateStationRating(Station::From(st));
void OnTick_Station()
if (_game_mode == GM_EDITOR) return;
BaseStation *st;
FOR_ALL_BASE_STATIONS(st) {
StationHandleSmallTick(st);
/* Clean up the link graph about once a week. */
if (Station::IsExpected(st) && (_tick_counter + st->index) % STATION_LINKGRAPH_TICKS == 0) {
DeleteStaleLinks(Station::From(st));
/* Run STATION_ACCEPTANCE_TICKS = 250 tick interval trigger for station animation.
* Station index is included so that triggers are not all done
* at the same time. */
if ((_tick_counter + st->index) % STATION_ACCEPTANCE_TICKS == 0) {
/* Stop processing this station if it was deleted */
if (!StationHandleBigTick(st)) continue;
TriggerStationAnimation(st, st->xy, SAT_250_TICKS);
if (Station::IsExpected(st)) AirportAnimationTrigger(Station::From(st), AAT_STATION_250_TICKS);
/** Monthly loop for stations. */
void StationMonthlyLoop()
Station *st;
FOR_ALL_STATIONS(st) {
GoodsEntry *ge = &st->goods[i];
SB(ge->acceptance_pickup, GoodsEntry::GES_LAST_MONTH, 1, GB(ge->acceptance_pickup, GoodsEntry::GES_CURRENT_MONTH, 1));
ClrBit(ge->acceptance_pickup, GoodsEntry::GES_CURRENT_MONTH);
void ModifyStationRatingAround(TileIndex tile, Owner owner, int amount, uint radius)
if (st->owner == owner &&
DistanceManhattan(tile, st->xy) <= radius) {
if (ge->acceptance_pickup != 0) {
ge->rating = Clamp(ge->rating + amount, 0, 255);
static uint UpdateStationWaiting(Station *st, CargoID type, uint amount, SourceType source_type, SourceID source_id)
/* We can't allocate a CargoPacket? Then don't do anything
* at all; i.e. just discard the incoming cargo. */
if (!CargoPacket::CanAllocateItem()) return 0;
GoodsEntry &ge = st->goods[type];
amount += ge.amount_fract;
ge.amount_fract = GB(amount, 0, 8);
amount >>= 8;
/* No new "real" cargo item yet. */
if (amount == 0) return 0;
StationID next = ge.GetVia(st->index);
ge.cargo.Append(new CargoPacket(st->index, st->xy, amount, source_type, source_id), next);
if (ge.link_graph == INVALID_LINK_GRAPH) {
lg = new LinkGraph(type);
ge.link_graph = lg->index;
ge.node = lg->AddNode(st);
lg = LinkGraph::Get(ge.link_graph);
if (lg != NULL) (*lg)[ge.node].UpdateSupply(amount);
if (!ge.HasRating()) {
InvalidateWindowData(WC_STATION_LIST, st->index);
SetBit(ge.acceptance_pickup, GoodsEntry::GES_PICKUP);
TriggerStationRandomisation(st, st->xy, SRT_NEW_CARGO, type);
TriggerStationAnimation(st, st->xy, SAT_NEW_CARGO, type);
AirportAnimationTrigger(st, AAT_STATION_NEW_CARGO, type);
SetWindowDirty(WC_STATION_VIEW, st->index);
st->MarkTilesDirty(true);
return amount;
static bool IsUniqueStationName(const char *name)
const Station *st;
if (st->name != NULL && strcmp(st->name, name) == 0) return false;
* Rename a station
* @param tile unused
* @param p1 station ID that is to be renamed
* @param p2 unused
* @param text the new name or an empty string when resetting to the default
CommandCost CmdRenameStation(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
Station *st = Station::GetIfValid(p1);
if (st == NULL) return CMD_ERROR;
bool reset = StrEmpty(text);
if (!reset) {
if (Utf8StringLength(text) >= MAX_LENGTH_STATION_NAME_CHARS) return CMD_ERROR;
if (!IsUniqueStationName(text)) return_cmd_error(STR_ERROR_NAME_MUST_BE_UNIQUE);
free(st->name);
st->name = reset ? NULL : strdup(text);
InvalidateWindowData(WC_STATION_LIST, st->owner, 1);
* Find all stations around a rectangular producer (industry, house, headquarter, ...)
*
* @param location The location/area of the producer
* @param stations The list to store the stations in
void FindStationsAroundTiles(const TileArea &location, StationList *stations)
/* area to search = producer plus station catchment radius */
uint max_rad = (_settings_game.station.modified_catchment ? MAX_CATCHMENT : CA_UNMODIFIED);
uint x = TileX(location.tile);
uint y = TileY(location.tile);
uint min_x = (x > max_rad) ? x - max_rad : 0;
uint max_x = x + location.w + max_rad;
uint min_y = (y > max_rad) ? y - max_rad : 0;
uint max_y = y + location.h + max_rad;
if (min_x == 0 && _settings_game.construction.freeform_edges) min_x = 1;
if (min_y == 0 && _settings_game.construction.freeform_edges) min_y = 1;
if (max_x >= MapSizeX()) max_x = MapSizeX() - 1;
if (max_y >= MapSizeY()) max_y = MapSizeY() - 1;
for (uint cy = min_y; cy < max_y; cy++) {
for (uint cx = min_x; cx < max_x; cx++) {
TileIndex cur_tile = TileXY(cx, cy);
if (!IsTileType(cur_tile, MP_STATION)) continue;
Station *st = Station::GetByTile(cur_tile);
/* st can be NULL in case of waypoints */
if (st == NULL) continue;
if (_settings_game.station.modified_catchment) {
int rad = st->GetCatchmentRadius();
int rad_x = cx - x;
int rad_y = cy - y;
if (rad_x < -rad || rad_x >= rad + location.w) continue;
if (rad_y < -rad || rad_y >= rad + location.h) continue;
/* Insert the station in the set. This will fail if it has
* already been added.
stations->Include(st);
* Run a tile loop to find stations around a tile, on demand. Cache the result for further requests
* @return pointer to a StationList containing all stations found
const StationList *StationFinder::GetStations()
if (this->tile != INVALID_TILE) {
FindStationsAroundTiles(*this, &this->stations);
this->tile = INVALID_TILE;
return &this->stations;
uint MoveGoodsToStation(CargoID type, uint amount, SourceType source_type, SourceID source_id, const StationList *all_stations)
/* Return if nothing to do. Also the rounding below fails for 0. */
Station *st1 = NULL; // Station with best rating
Station *st2 = NULL; // Second best station
uint best_rating1 = 0; // rating of st1
uint best_rating2 = 0; // rating of st2
for (Station * const *st_iter = all_stations->Begin(); st_iter != all_stations->End(); ++st_iter) {
Station *st = *st_iter;
/* Is the station reserved exclusively for somebody else? */
if (st->town->exclusive_counter > 0 && st->town->exclusivity != st->owner) continue;
if (st->goods[type].rating == 0) continue; // Lowest possible rating, better not to give cargo anymore
if (_settings_game.order.selectgoods && !st->goods[type].HasVehicleEverTriedLoading()) continue; // Selectively servicing stations, and not this one
if (IsCargoInClass(type, CC_PASSENGERS)) {
if (st->facilities == FACIL_TRUCK_STOP) continue; // passengers are never served by just a truck stop
if (st->facilities == FACIL_BUS_STOP) continue; // non-passengers are never served by just a bus stop
/* This station can be used, add it to st1/st2 */
if (st1 == NULL || st->goods[type].rating >= best_rating1) {
st2 = st1; best_rating2 = best_rating1; st1 = st; best_rating1 = st->goods[type].rating;
} else if (st2 == NULL || st->goods[type].rating >= best_rating2) {
st2 = st; best_rating2 = st->goods[type].rating;
/* no stations around at all? */
if (st1 == NULL) return 0;
/* From now we'll calculate with fractal cargo amounts.
* First determine how much cargo we really have. */
amount *= best_rating1 + 1;
if (st2 == NULL) {
/* only one station around */
return UpdateStationWaiting(st1, type, amount, source_type, source_id);
/* several stations around, the best two (highest rating) are in st1 and st2 */
assert(st1 != NULL);
assert(st2 != NULL);
assert(best_rating1 != 0 || best_rating2 != 0);
/* Then determine the amount the worst station gets. We do it this way as the
* best should get a bonus, which in this case is the rounding difference from
* this calculation. In reality that will mean the bonus will be pretty low.
* Nevertheless, the best station should always get the most cargo regardless
* of rounding issues. */
uint worst_cargo = amount * best_rating2 / (best_rating1 + best_rating2);
assert(worst_cargo <= (amount - worst_cargo));
/* And then send the cargo to the stations! */
uint moved = UpdateStationWaiting(st1, type, amount - worst_cargo, source_type, source_id);
/* These two UpdateStationWaiting's can't be in the statement as then the order
* of execution would be undefined and that could cause desyncs with callbacks. */
return moved + UpdateStationWaiting(st2, type, worst_cargo, source_type, source_id);
void BuildOilRig(TileIndex tile)
if (!Station::CanAllocateItem()) {
DEBUG(misc, 0, "Can't allocate station for oilrig at 0x%X, reverting to oilrig only", tile);
Station *st = new Station(tile);
st->town = ClosestTownFromTile(tile, UINT_MAX);
st->string_id = GenerateStationName(st, tile, STATIONNAMING_OILRIG);
assert(IsTileType(tile, MP_INDUSTRY));
DeleteAnimatedTile(tile);
MakeOilrig(tile, st->index, GetWaterClass(tile));
st->owner = OWNER_NONE;
st->airport.type = AT_OILRIG;
st->airport.Add(tile);
st->facilities = FACIL_AIRPORT | FACIL_DOCK;
st->build_date = _date;
st->rect.BeforeAddTile(tile, StationRect::ADD_FORCE);
void DeleteOilRig(TileIndex tile)
MakeWaterKeepingClass(tile, OWNER_NONE);
st->facilities &= ~(FACIL_AIRPORT | FACIL_DOCK);
st->airport.flags = 0;
st->rect.AfterRemoveTile(st, tile);
if (!st->IsInUse()) delete st;
static void ChangeTileOwner_Station(TileIndex tile, Owner old_owner, Owner new_owner)
if (IsRoadStopTile(tile)) {
for (RoadType rt = ROADTYPE_ROAD; rt < ROADTYPE_END; rt++) {
/* Update all roadtypes, no matter if they are present */
if (GetRoadOwner(tile, rt) == old_owner) {
if (HasTileRoadType(tile, rt)) {
/* A drive-through road-stop has always two road bits. No need to dirty windows here, we'll redraw the whole screen anyway. */
Company::Get(old_owner)->infrastructure.road[rt] -= 2;
if (new_owner != INVALID_OWNER) Company::Get(new_owner)->infrastructure.road[rt] += 2;
SetRoadOwner(tile, rt, new_owner == INVALID_OWNER ? OWNER_NONE : new_owner);
if (!IsTileOwner(tile, old_owner)) return;
if (new_owner != INVALID_OWNER) {
/* Update company infrastructure counts. Only do it here
* if the new owner is valid as otherwise the clear
* command will do it for us. No need to dirty windows
* here, we'll redraw the whole screen anyway.*/
Company *old_company = Company::Get(old_owner);
Company *new_company = Company::Get(new_owner);
/* Update counts for underlying infrastructure. */
case STATION_RAIL:
case STATION_WAYPOINT:
if (!IsStationTileBlocked(tile)) {
old_company->infrastructure.rail[GetRailType(tile)]--;
new_company->infrastructure.rail[GetRailType(tile)]++;
case STATION_BUS:
case STATION_TRUCK:
/* Road stops were already handled above. */
if (GetWaterClass(tile) == WATER_CLASS_CANAL) {
old_company->infrastructure.water--;
new_company->infrastructure.water++;
/* Update station tile count. */
if (!IsBuoy(tile) && !IsAirport(tile)) {
old_company->infrastructure.station--;
new_company->infrastructure.station++;
/* for buoys, owner of tile is owner of water, st->owner == OWNER_NONE */
SetTileOwner(tile, new_owner);
InvalidateWindowClassesData(WC_STATION_LIST, 0);
Status change: