57 #include "table/strings.h" 
  109       if (!T::IsValidID(t)) 
continue;
 
  111       if (closest_station == INVALID_STATION) {
 
  113       } 
else if (closest_station != t) {
 
  118   *st = (closest_station == INVALID_STATION) ? NULL : T::Get(closest_station);
 
  139   for (
int dx = -3; dx <= 3; dx++) {
 
  140     for (
int dy = -3; dy <= 3; dy++) {
 
  196 #define M(x) ((x) - STR_SV_STNAME) 
  201   STATIONNAMING_AIRPORT,
 
  202   STATIONNAMING_OILRIG,
 
  204   STATIONNAMING_HELIPORT,
 
  229   if (
GetIndustrySpec(indtype)->station_name == STR_UNDEFINED) 
return false;
 
  233   sni->
free_names &= ~(1 << M(STR_SV_STNAME_OILFIELD) | 1 << M(STR_SV_STNAME_MINES));
 
  239   static const uint32 _gen_station_name_bits[] = {
 
  242     1U << M(STR_SV_STNAME_AIRPORT),          
 
  243     1U << M(STR_SV_STNAME_OILFIELD),         
 
  244     1U << M(STR_SV_STNAME_DOCKS),            
 
  245     1U << M(STR_SV_STNAME_HELIPORT),         
 
  249   uint32 free_names = UINT32_MAX;
 
  252   memset(indtypes, 0, 
sizeof(indtypes));
 
  255   FOR_ALL_STATIONS(s) {
 
  256     if (s != st && s->
town == t) {
 
  257       if (s->
indtype != IT_INVALID) {
 
  260         if (name != STR_UNDEFINED) {
 
  271         if (str == M(STR_SV_STNAME_FOREST)) {
 
  272           str = M(STR_SV_STNAME_WOODS);
 
  288       return STR_SV_STNAME_FALLBACK;
 
  296   uint32 tmp = free_names & _gen_station_name_bits[name_class];
 
  300   if (
HasBit(free_names, M(STR_SV_STNAME_MINES))) {
 
  302       return STR_SV_STNAME_MINES;
 
  308     if (
HasBit(free_names, M(STR_SV_STNAME))) 
return STR_SV_STNAME;
 
  310     if (
HasBit(free_names, M(STR_SV_STNAME_CENTRAL))) 
return STR_SV_STNAME_CENTRAL;
 
  314   if (
HasBit(free_names, M(STR_SV_STNAME_LAKESIDE)) &&
 
  317     return STR_SV_STNAME_LAKESIDE;
 
  321   if (
HasBit(free_names, M(STR_SV_STNAME_WOODS)) && (
 
  332     if (
HasBit(free_names, M(STR_SV_STNAME_VALLEY))) 
return STR_SV_STNAME_VALLEY;
 
  334     if (
HasBit(free_names, M(STR_SV_STNAME_HEIGHTS))) 
return STR_SV_STNAME_HEIGHTS;
 
  338   static const int8 _direction_and_table[] = {
 
  339     ~( (1 << M(STR_SV_STNAME_WEST))  | (1 << M(STR_SV_STNAME_EAST)) | (1 << M(STR_SV_STNAME_NORTH)) ),
 
  340     ~( (1 << M(STR_SV_STNAME_SOUTH)) | (1 << M(STR_SV_STNAME_WEST)) | (1 << M(STR_SV_STNAME_NORTH)) ),
 
  341     ~( (1 << M(STR_SV_STNAME_SOUTH)) | (1 << M(STR_SV_STNAME_EAST)) | (1 << M(STR_SV_STNAME_NORTH)) ),
 
  342     ~( (1 << M(STR_SV_STNAME_SOUTH)) | (1 << M(STR_SV_STNAME_WEST)) | (1 << M(STR_SV_STNAME_EAST)) ),
 
  345   free_names &= _direction_and_table[
 
  349   tmp = free_names & ((1 << 1) | (1 << 2) | (1 << 3) | (1 << 4) | (1 << 6) | (1 << 7) | (1 << 12) | (1 << 26) | (1 << 27) | (1 << 28) | (1 << 29) | (1 << 30));
 
  350   return (tmp == 0) ? STR_SV_STNAME_FALLBACK : (STR_SV_STNAME + 
FindFirstBit(tmp));
 
  365   FOR_ALL_STATIONS(st) {
 
  369       if (cur_dist < threshold) {
 
  370         threshold = cur_dist;
 
  387     case STATION_AIRPORT:
 
  404     default: NOT_REACHED();
 
  418   pt.y -= 32 * ZOOM_LVL_BASE;
 
  433   FOR_ALL_BASE_STATIONS(st) {
 
  459   for (uint i = 0; i < num_items; i++) {
 
  484   int x1 = 
max(x - rad, 0);
 
  487   int y1 = 
max(y - rad, 0);
 
  507   FOR_ALL_INDUSTRIES(i) {
 
  530   if (always_accepted != NULL) *always_accepted = 0;
 
  539   int x1 = 
max(x - rad, 0);
 
  540   int y1 = 
max(y - rad, 0);
 
  547   for (
int yc = y1; yc != y2; yc++) {
 
  548     for (
int xc = x1; xc != x2; xc++) {
 
  550       AddAcceptedCargo(tile, acceptance, always_accepted);
 
  569   if (!st->
rect.IsEmpty()) {
 
  581     uint amt = acceptance[i];
 
  599   if (old_acc == new_acc) 
return;
 
  605     static const StringID accept_msg[] = {
 
  606       STR_NEWS_STATION_NOW_ACCEPTS_CARGO,
 
  607       STR_NEWS_STATION_NOW_ACCEPTS_CARGO_AND_CARGO,
 
  609     static const StringID reject_msg[] = {
 
  610       STR_NEWS_STATION_NO_LONGER_ACCEPTS_CARGO,
 
  611       STR_NEWS_STATION_NO_LONGER_ACCEPTS_CARGO_OR_CARGO,
 
  625           accepts[num_acc++] = i;
 
  630           rejects[num_rej++] = i;
 
  644 static void UpdateStationSignCoord(
BaseStation *st)
 
  648   if (r->IsEmpty()) 
return; 
 
  682     CommandCost ret = (*st)->rect.BeforeAddRect(area.
tile, area.
w, area.
h, StationRect::ADD_TEST);
 
  683     if (ret.
Failed()) 
return ret;
 
  692       (*st)->string_id = GenerateStationName(*st, area.
tile, name_class);
 
  715   UpdateStationSignCoord(st);
 
  736   if (ret.
Failed()) 
return ret;
 
  759     cost.
AddCost(_price[PR_BUILD_FOUNDATION]);
 
  766   } 
else if (allowed_z != flat_z) {
 
  786     if (ret.
Failed()) 
return ret;
 
  790     if (ret.
Failed()) 
return ret;
 
  811 static CommandCost CheckFlatLandRailStation(
TileArea tile_area, 
DoCommandFlag flags, 
Axis axis, StationID *station, 
RailType rt, 
SmallVector<Train *, 4> &affected_vehicles, 
StationClassID spec_class, byte spec_index, byte plat_len, byte numtracks)
 
  815   uint invalid_dirs = 5 << axis;
 
  822     if (ret.
Failed()) 
return ret;
 
  828       if (ret.
Failed()) 
return ret;
 
  839         if (*station == INVALID_STATION) {
 
  841         } 
else if (*station != st) {
 
  866               *affected_vehicles.
Append() = v;
 
  870           if (ret.
Failed()) 
return ret;
 
  877       if (ret.
Failed()) 
return ret;
 
  904     if (ret.
Failed()) 
return ret;
 
  923         if (*station == INVALID_STATION) {
 
  925         } 
else if (*station != st) {
 
  949       uint num_roadbits = 0;
 
  950       if (build_over_road) {
 
  958             if (ret.
Failed()) 
return ret;
 
  972             if (ret.
Failed()) 
return ret;
 
  981         if (ret.
Failed()) 
return ret;
 
  985       uint roadbits_to_build = 
CountBits(rts) * 2 - num_roadbits;
 
  986       cost.
AddCost(_price[PR_BUILD_ROAD] * roadbits_to_build);
 
 1019 static inline byte *CreateSingle(byte *layout, 
int n)
 
 1022   do *layout++ = 0; 
while (--i);
 
 1023   layout[((n - 1) >> 1) - n] = 2;
 
 1027 static inline byte *CreateMulti(byte *layout, 
int n, byte b)
 
 1030   do *layout++ = b; 
while (--i);
 
 1033     layout[n - 1 - n] = 0;
 
 1047   if (statspec != NULL && statspec->lengths >= plat_len &&
 
 1048       statspec->platforms[plat_len - 1] >= numtracks &&
 
 1049       statspec->layouts[plat_len - 1][numtracks - 1]) {
 
 1051     memcpy(layout, statspec->layouts[plat_len - 1][numtracks - 1],
 
 1052       plat_len * numtracks);
 
 1056   if (plat_len == 1) {
 
 1057     CreateSingle(layout, numtracks);
 
 1059     if (numtracks & 1) layout = CreateSingle(layout, plat_len);
 
 1062     while (--numtracks >= 0) {
 
 1063       layout = CreateMulti(layout, plat_len, 4);
 
 1064       layout = CreateMulti(layout, plat_len, 6);
 
 1080 template <
class T, StringID error_message>
 
 1083   assert(*st == NULL);
 
 1084   bool check_surrounding = 
true;
 
 1087     if (existing_station != INVALID_STATION) {
 
 1088       if (adjacent && existing_station != station_to_join) {
 
 1095         *st = T::GetIfValid(existing_station);
 
 1096         check_surrounding = (*st == NULL);
 
 1101       if (adjacent) check_surrounding = 
false;
 
 1105   if (check_surrounding) {
 
 1108     if (ret.
Failed()) 
return ret;
 
 1112   if (*st == NULL && station_to_join != INVALID_STATION) *st = T::GetIfValid(station_to_join);
 
 1128   return FindJoiningBaseStation<Station, STR_ERROR_MUST_REMOVE_RAILWAY_STATION_FIRST>(existing_station, station_to_join, adjacent, ta, st);
 
 1142   return FindJoiningBaseStation<Waypoint, STR_ERROR_MUST_REMOVE_RAILWAYPOINT_FIRST>(existing_waypoint, waypoint_to_join, adjacent, ta, wp);
 
 1165   RailType rt    = Extract<RailType, 0, 4>(p1);
 
 1166   Axis axis      = Extract<Axis, 4, 1>(p1);
 
 1167   byte numtracks = 
GB(p1,  8, 8);
 
 1168   byte plat_len  = 
GB(p1, 16, 8);
 
 1169   bool adjacent  = 
HasBit(p1, 24);
 
 1172   byte spec_index           = 
GB(p2, 8, 8);
 
 1173   StationID station_to_join = 
GB(p2, 16, 16);
 
 1177   if (ret.
Failed()) 
return ret;
 
 1184   if (plat_len == 0 || numtracks == 0) 
return CMD_ERROR;
 
 1195   bool reuse = (station_to_join != NEW_STATION);
 
 1196   if (!reuse) station_to_join = INVALID_STATION;
 
 1197   bool distant_join = (station_to_join != INVALID_STATION);
 
 1204   TileArea new_location(tile_org, w_org, h_org);
 
 1207   StationID est = INVALID_STATION;
 
 1211   if (cost.
Failed()) 
return cost;
 
 1213   cost.
AddCost((numtracks * _price[PR_BUILD_STATION_RAIL] + _price[PR_BUILD_STATION_RAIL_LENGTH]) * plat_len);
 
 1218   if (ret.
Failed()) 
return ret;
 
 1220   ret = 
BuildStationPart(&st, flags, reuse, new_location, STATIONNAMING_RAIL);
 
 1221   if (ret.
Failed()) 
return ret;
 
 1225     if (ret.
Failed()) 
return ret;
 
 1233   if (statspec != NULL) {
 
 1248   if (flags & DC_EXEC) {
 
 1251     byte numtracks_orig;
 
 1257     st->
rect.BeforeAddRect(tile_org, w_org, h_org, StationRect::ADD_TRY);
 
 1259     if (statspec != NULL) {
 
 1268     layout_ptr = 
AllocaM(byte, numtracks * plat_len);
 
 1271     numtracks_orig = numtracks;
 
 1279         byte layout = *layout_ptr++;
 
 1285             *affected_vehicles.
Append() = v;
 
 1287             for (; v->
Next() != NULL; v = v->
Next()) { }
 
 1312         if (statspec != NULL) {
 
 1327           TriggerStationAnimation(st, tile, 
SAT_BUILT);
 
 1335     } 
while (--numtracks);
 
 1337     for (uint i = 0; i < affected_vehicles.
Length(); ++i) {
 
 1339       Train *v = affected_vehicles[i];
 
 1342       for (; v->
Next() != NULL; v = v->
Next()) { }
 
 1349       update_reservation_area = 
TileArea(tile_org, 1, numtracks_orig);
 
 1351       update_reservation_area = 
TileArea(tile_org, numtracks_orig, 1);
 
 1365         platform_begin = next_tile;
 
 1368         platform_end = next_tile;
 
 1372       bool reservation = 
false;
 
 1373       for (
TileIndex t = platform_begin; !reservation && t <= platform_end; t += tile_offset) {
 
 1395 static void MakeRailStationAreaSmaller(
BaseStation *st)
 
 1402   if (ta.
w != 0 && ta.
h != 0) {
 
 1476     if (ret.
Failed()) 
continue;
 
 1479     T *st = T::GetByTile(tile);
 
 1480     if (st == NULL) 
continue;
 
 1485       if (ret.
Failed()) 
continue;
 
 1494       total_cost.
AddCost(-_price[PR_CLEAR_RAIL]);
 
 1512           for (; temp->
Next() != NULL; temp = temp->
Next()) { }
 
 1520       DoClearSquare(tile);
 
 1526       st->rect.AfterRemoveTile(st, tile);
 
 1532       affected_stations.
Include(st);
 
 1538         for (; v->
Next() != NULL; v = v->
Next()) { }
 
 1544   if (quantity == 0) 
return error.
Failed() ? error : 
CommandCost(STR_ERROR_THERE_IS_NO_STATION);
 
 1546   for (T **stp = affected_stations.
Begin(); stp != affected_stations.
End(); stp++) {
 
 1552     MakeRailStationAreaSmaller(st);
 
 1553     UpdateStationSignCoord(st);
 
 1559       st->UpdateVirtCoord();
 
 1564   total_cost.
AddCost(quantity * removal_cost);
 
 1588   if (ret.
Failed()) 
return ret;
 
 1591   for (
Station **stp = affected_stations.
Begin(); stp != affected_stations.
End(); stp++) {
 
 1640     if (ret.
Failed()) 
return ret;
 
 1646   assert(ta.
w != 0 && ta.
h != 0);
 
 1652     if (st->TileBelongsToRailStation(tile)) {
 
 1655       if (ret.
Failed()) 
return ret;
 
 1710   if (*primary_stop == NULL) {
 
 1712     return primary_stop;
 
 1716     while (stop->
next != NULL) stop = stop->
next;
 
 1734   return FindJoiningBaseStation<Station, STR_ERROR_MUST_REMOVE_ROAD_STOP_FIRST>(existing_stop, station_to_join, adjacent, ta, st);
 
 1755   bool type = 
HasBit(p2, 0);
 
 1756   bool is_drive_through = 
HasBit(p2, 1);
 
 1757   RoadTypes rts = Extract<RoadTypes, 2, 2>(p2);
 
 1758   StationID station_to_join = 
GB(p2, 16, 16);
 
 1759   bool reuse = (station_to_join != NEW_STATION);
 
 1760   if (!reuse) station_to_join = INVALID_STATION;
 
 1761   bool distant_join = (station_to_join != INVALID_STATION);
 
 1763   uint8 width = (uint8)
GB(p1, 0, 8);
 
 1764   uint8 lenght = (uint8)
GB(p1, 8, 8);
 
 1769   if (width == 0 || lenght == 0) 
return CMD_ERROR;
 
 1773   TileArea roadstop_area(tile, width, lenght);
 
 1784   if (is_drive_through) {
 
 1786     axis = Extract<Axis, 6, 1>(p2);
 
 1790     ddir = Extract<DiagDirection, 6, 2>(p2);
 
 1795   if (ret.
Failed()) 
return ret;
 
 1799   StationID est = INVALID_STATION;
 
 1800   ret = 
CheckFlatLandRoadStop(roadstop_area, flags, is_drive_through ? 5 << axis : 1 << ddir, is_drive_through, type, axis, &est, rts);
 
 1801   if (ret.
Failed()) 
return ret;
 
 1806   if (ret.
Failed()) 
return ret;
 
 1811   ret = 
BuildStationPart(&st, flags, reuse, roadstop_area, STATIONNAMING_ROAD);
 
 1812   if (ret.
Failed()) 
return ret;
 
 1828       *currstop = road_stop;
 
 1839       st->
rect.BeforeAddTile(cur_tile, StationRect::ADD_TRY);
 
 1842       if (is_drive_through) {
 
 1909     if (ret.
Failed()) 
return ret;
 
 1924   assert(cur_stop != NULL);
 
 1932     if (ret.
Failed()) 
return ret;
 
 1936     if (*primary_stop == cur_stop) {
 
 1938       *primary_stop = cur_stop->
next;
 
 1940       if (*primary_stop == NULL) {
 
 1946       while (pred->
next != cur_stop) pred = pred->
next;
 
 1966       DoClearSquare(tile);
 
 1974     FOR_ALL_ROADVEHICLES(v) {
 
 1981     st->
rect.AfterRemoveTile(st, tile);
 
 2013   uint8 width = (uint8)
GB(p1, 0, 8);
 
 2014   uint8 height = (uint8)
GB(p1, 8, 8);
 
 2015   bool keep_drive_through_roads = !
HasBit(p2, 1);
 
 2018   if (width == 0 || height == 0) 
return CMD_ERROR;
 
 2024   TileArea roadstop_area(tile, width, height);
 
 2027   CommandCost last_error(STR_ERROR_THERE_IS_NO_STATION);
 
 2028   bool had_success = 
false;
 
 2074   return had_success ? cost : last_error;
 
 2085   uint mindist = UINT_MAX;
 
 2119   uint noise_reduction = distance / town_tolerance_distance;
 
 2135   Town *t, *nearest = NULL;
 
 2137   uint mindist = UINT_MAX - add; 
 
 2143       if (dist < mindist) {
 
 2162   FOR_ALL_STATIONS(st) {
 
 2187   StationID station_to_join = 
GB(p2, 16, 16);
 
 2188   bool reuse = (station_to_join != NEW_STATION);
 
 2189   if (!reuse) station_to_join = INVALID_STATION;
 
 2190   bool distant_join = (station_to_join != INVALID_STATION);
 
 2191   byte airport_type = 
GB(p1, 0, 8);
 
 2192   byte layout = 
GB(p1, 8, 8);
 
 2199   if (ret.
Failed()) 
return ret;
 
 2216   if (cost.
Failed()) 
return cost;
 
 2224   StringID authority_refuse_message = STR_NULL;
 
 2225   Town *authority_refuse_town = NULL;
 
 2230       authority_refuse_message = STR_ERROR_LOCAL_AUTHORITY_REFUSES_NOISE;
 
 2231       authority_refuse_town = nearest;
 
 2237     FOR_ALL_STATIONS(st) {
 
 2241       authority_refuse_message = STR_ERROR_LOCAL_AUTHORITY_REFUSES_AIRPORT;
 
 2242       authority_refuse_town = t;
 
 2246   if (authority_refuse_message != STR_NULL) {
 
 2253   if (ret.
Failed()) 
return ret;
 
 2259   if (ret.
Failed()) 
return ret;
 
 2266     cost.
AddCost(_price[PR_BUILD_STATION_AIRPORT]);
 
 2279     st->
rect.BeforeAddRect(tile, w, h, StationRect::ADD_TRY);
 
 2291       AirportTileAnimationTrigger(st, iter, 
AAT_BUILT);
 
 2326     if (ret.
Failed()) 
return ret;
 
 2350     if (!st->TileBelongsToAirport(tile_cur)) 
continue;
 
 2353     if (ret.
Failed()) 
return ret;
 
 2355     cost.
AddCost(_price[PR_CLEAR_STATION_AIRPORT]);
 
 2357     if (flags & DC_EXEC) {
 
 2360       DoClearSquare(tile_cur);
 
 2365   if (flags & DC_EXEC) {
 
 2415   if (ret.
Failed()) 
return ret;
 
 2434     if ((v->
owner == company) == include_company) {
 
 2436       FOR_VEHICLE_ORDERS(v, order) {
 
 2452 static const byte _dock_w_chk[4] = { 2, 1, 2, 1 };
 
 2453 static const byte _dock_h_chk[4] = { 1, 2, 1, 2 };
 
 2466   StationID station_to_join = 
GB(p2, 16, 16);
 
 2467   bool reuse = (station_to_join != NEW_STATION);
 
 2468   if (!reuse) station_to_join = INVALID_STATION;
 
 2469   bool distant_join = (station_to_join != INVALID_STATION);
 
 2481   if (ret.
Failed()) 
return ret;
 
 2486   if (ret.
Failed()) 
return ret;
 
 2500   if (ret.
Failed()) 
return ret;
 
 2508       _dock_w_chk[direction], _dock_h_chk[direction]);
 
 2513   if (ret.
Failed()) 
return ret;
 
 2519   if (ret.
Failed()) 
return ret;
 
 2527     st->
rect.BeforeAddRect(dock_area.
tile, dock_area.
w, dock_area.
h, StationRect::ADD_TRY);
 
 2560   if (ret.
Failed()) 
return ret;
 
 2569   if (ret.
Failed()) 
return ret;
 
 2572     DoClearSquare(tile1);
 
 2574     MakeWaterKeepingClass(tile2, st->
owner);
 
 2576     st->
rect.AfterRemoveTile(st, tile1);
 
 2577     st->
rect.AfterRemoveTile(st, tile2);
 
 2614   return &_station_display_datas[st][gfx];
 
 2630     case SPR_RAIL_TRACK_X:
 
 2631       snow_desert = 
false;
 
 2632       *overlay_offset = 
RTO_X;
 
 2635     case SPR_RAIL_TRACK_Y:
 
 2636       snow_desert = 
false;
 
 2637       *overlay_offset = 
RTO_Y;
 
 2640     case SPR_RAIL_TRACK_X_SNOW:
 
 2642       *overlay_offset = 
RTO_X;
 
 2645     case SPR_RAIL_TRACK_Y_SNOW:
 
 2647       *overlay_offset = 
RTO_Y;
 
 2670   *ground = snow_desert ? SPR_FLAT_SNOW_DESERT_TILE : SPR_FLAT_GRASS_TILE;
 
 2674 static void DrawTile_Station(
TileInfo *ti)
 
 2682   uint32 relocation = 0;
 
 2683   uint32 ground_relocation = 0;
 
 2686   uint tile_layout = 0;
 
 2698       if (statspec != NULL) {
 
 2735       case APT_RADAR_GRASS_FENCE_SW:
 
 2738       case APT_GRASS_FENCE_NE_FLAG:
 
 2741       case APT_RADAR_FENCE_SW:
 
 2744       case APT_RADAR_FENCE_NE:
 
 2747       case APT_GRASS_FENCE_NE_FLAG_2:
 
 2757     palette = COMPANY_SPRITE_COLOUR(owner);
 
 2760     palette = PALETTE_TO_GREY;
 
 2763   if (layout == NULL && (t == NULL || t->
seq == NULL)) t = GetStationTileLayout(
GetStationType(ti->
tile), gfx);
 
 2773       if (!HasFoundationNW(ti->
tile, slope, z)) 
SetBit(edge_info, 0);
 
 2774       if (!HasFoundationNE(ti->
tile, slope, z)) 
SetBit(edge_info, 1);
 
 2776       if (image == 0) 
goto draw_default_foundation;
 
 2781         static const uint8 foundation_parts[] = {
 
 2794         static const uint8 composite_foundation_parts[] = {
 
 2796              0x00,                0xD1,                 0xE4,                 0xE0,
 
 2798              0xCA,                0xC9,                 0xC4,                 0xC0,
 
 2800              0xD2,                0x91,                 0xE4,                 0xA0,
 
 2805         uint8 parts = composite_foundation_parts[ti->
tileh];
 
 2816           goto draw_default_foundation;
 
 2820         for (
int i = 0; i < 8; i++) {
 
 2831 draw_default_foundation:
 
 2837     DrawWaterClassGround(ti);
 
 2839     if (sprite != 0) total_offset = sprite - SPR_IMG_BUOY;
 
 2842       DrawWaterClassGround(ti);
 
 2848         DrawShoreTile(ti->
tileh);
 
 2850         DrawClearLandTile(ti, 3);
 
 2854     if (layout != NULL) {
 
 2864       t = &tmp_rail_layout;
 
 2866     } 
else if (statspec != NULL) {
 
 2918   int32 total_offset = 0;
 
 2933     DrawSprite(ground + overlay_offset, PAL_NONE, x, y);
 
 2946 static int GetSlopePixelZ_Station(
TileIndex tile, uint x, uint y)
 
 2971         td->
owner_type[i] = STR_LAND_AREA_INFORMATION_ROAD_OWNER;
 
 2972         td->
owner[i] = road_owner;
 
 2976         td->
owner_type[i] = STR_LAND_AREA_INFORMATION_TRAM_OWNER;
 
 2977         td->
owner[i] = tram_owner;
 
 3020     default: NOT_REACHED();
 
 3021     case STATION_RAIL:     str = STR_LAI_STATION_DESCRIPTION_RAILROAD_STATION; 
break;
 
 3022     case STATION_AIRPORT:
 
 3023       str = (
IsHangar(tile) ? STR_LAI_STATION_DESCRIPTION_AIRCRAFT_HANGAR : STR_LAI_STATION_DESCRIPTION_AIRPORT);
 
 3025     case STATION_TRUCK:    str = STR_LAI_STATION_DESCRIPTION_TRUCK_LOADING_AREA; 
break;
 
 3026     case STATION_BUS:      str = STR_LAI_STATION_DESCRIPTION_BUS_STATION; 
break;
 
 3027     case STATION_OILRIG:   str = STR_INDUSTRY_NAME_OIL_RIG; 
break;
 
 3028     case STATION_DOCK:     str = STR_LAI_STATION_DESCRIPTION_SHIP_DOCK; 
break;
 
 3029     case STATION_BUOY:     str = STR_LAI_STATION_DESCRIPTION_BUOY; 
break;
 
 3030     case STATION_WAYPOINT: str = STR_LAI_STATION_DESCRIPTION_WAYPOINT; 
break;
 
 3079 static void TileLoop_Station(
TileIndex tile)
 
 3084     case STATION_AIRPORT:
 
 3091     case STATION_OILRIG: 
 
 3101 static void AnimateTile_Station(
TileIndex tile)
 
 3104     AnimateStationTile(tile);
 
 3109     AnimateAirportTile(tile);
 
 3114 static bool ClickTile_Station(
TileIndex tile)
 
 3158       } 
else if (x < stop) {
 
 3160         uint16 spd = 
max(0, (stop - x) * 20 - 15);
 
 3161         if (spd < v->cur_speed) v->
cur_speed = spd;
 
 3190   if (cargoes == 0) 
return;
 
 3229 static inline void byte_inc_sat(byte *p)
 
 3246   StationCargoAmountMap waiting_per_source;
 
 3248   for (StationCargoAmountMap::iterator i(waiting_per_source.begin()); i != waiting_per_source.end(); ++i) {
 
 3250     if (source_station == NULL) 
continue;
 
 3257 static void UpdateStationRating(
Station *st)
 
 3259   bool waiting_changed = 
false;
 
 3261   byte_inc_sat(&st->time_since_load);
 
 3262   byte_inc_sat(&st->time_since_unload);
 
 3265   FOR_ALL_CARGOSPECS(cs) {
 
 3281         waiting_changed = 
true;
 
 3300       uint waiting_avg = waiting / (num_dests + 1);
 
 3311         uint32 var10 = (st->last_vehicle_type == 
VEH_INVALID) ? 0x0 : (st->last_vehicle_type + 0x10);
 
 3315           rating = 
GB(callback, 0, 14);
 
 3318           if (
HasBit(callback, 14)) rating -= 0x4000;
 
 3324         if (b >= 0) rating += b >> 2;
 
 3327         if (st->last_vehicle_type == 
VEH_SHIP) waittime >>= 2;
 
 3329         (rating += 25, waittime > 12) ||
 
 3330         (rating += 25, waittime > 6) ||
 
 3331         (rating += 45, waittime > 3) ||
 
 3332         (rating += 35, 
true);
 
 3339         (rating += 10, 
true);
 
 3346       (rating += 10, age >= 2) ||
 
 3347       (rating += 10, age >= 1) ||
 
 3348       (rating += 13, 
true);
 
 3358         if (rating <= 64 && waiting_avg >= 100) {
 
 3359           int dec = Random() & 0x1F;
 
 3360           if (waiting_avg < 200) dec &= 7;
 
 3361           waiting -= (dec + 1) * num_dests;
 
 3362           waiting_changed = 
true;
 
 3366         if (rating <= 127 && waiting != 0) {
 
 3367           uint32 r = Random();
 
 3368           if (rating <= (
int)
GB(r, 0, 7)) {
 
 3370             waiting = 
max((
int)waiting - (
int)((
GB(r, 8, 2) - 1) * num_dests), 0);
 
 3371             waiting_changed = 
true;
 
 3378         static const uint WAITING_CARGO_THRESHOLD  = 1 << 12;
 
 3379         static const uint WAITING_CARGO_CUT_FACTOR = 1 <<  6;
 
 3380         static const uint MAX_WAITING_CARGO        = 1 << 15;
 
 3382         if (waiting > WAITING_CARGO_THRESHOLD) {
 
 3383           uint difference = waiting - WAITING_CARGO_THRESHOLD;
 
 3384           waiting -= (difference / WAITING_CARGO_CUT_FACTOR);
 
 3386           waiting = 
min(waiting, MAX_WAITING_CARGO);
 
 3387           waiting_changed = 
true;
 
 3392         if (waiting_changed && waiting < ge->cargo.AvailableCount()) {
 
 3406   StationID index = st->
index;
 
 3407   if (waiting_changed) {
 
 3430   for (std::list<Vehicle *>::iterator it(st->loading_vehicles.begin()); it != st->loading_vehicles.end(); ++it) {
 
 3431     for (
Vehicle *v = *it; v != NULL; v = v->
Next()) {
 
 3452     if (lg == NULL) 
continue;
 
 3455       Edge edge = it->second;
 
 3462         bool updated = 
false;
 
 3464         if (auto_distributed) {
 
 3469           FOR_ALL_ORDER_LISTS(l) {
 
 3470             bool found_from = 
false;
 
 3471             bool found_to = 
false;
 
 3473               if (!order->IsType(OT_GOTO_STATION) && !order->IsType(OT_IMPLICIT)) 
continue;
 
 3474               if (order->GetDestination() == from->
index) {
 
 3476                 if (found_to) 
break;
 
 3477               } 
else if (order->GetDestination() == to->
index) {
 
 3479                 if (found_from) 
break;
 
 3482             if (!found_to || !found_from) 
continue;
 
 3487           while (iter != vehicles.
End()) {
 
 3498               *iter = next_shared;
 
 3501               vehicles.
Erase(iter);
 
 3504             if (iter == vehicles.
End()) iter = vehicles.
Begin();
 
 3552         DEBUG(misc, 0, 
"Can't allocate link graph");
 
 3561   } 
else if (ge2.
link_graph == INVALID_LINK_GRAPH) {
 
 3580     (*lg)[ge1.
node].UpdateEdge(ge2.
node, capacity, usage, mode);
 
 3592   for (
const Vehicle *v = front; v != NULL; v = v->
Next()) {
 
 3607 static void StationHandleSmallTick(
BaseStation *st)
 
 3618 void OnTick_Station()
 
 3620   if (_game_mode == GM_EDITOR) 
return;
 
 3623   FOR_ALL_BASE_STATIONS(st) {
 
 3624     StationHandleSmallTick(st);
 
 3648   FOR_ALL_STATIONS(st) {
 
 3658 void ModifyStationRatingAround(
TileIndex tile, 
Owner owner, 
int amount, uint radius)
 
 3662   FOR_ALL_STATIONS(st) {
 
 3663     if (st->
owner == owner &&
 
 3688   if (amount == 0) 
return 0;
 
 3700       DEBUG(misc, 0, 
"Can't allocate link graph");
 
 3705   if (lg != NULL) (*lg)[ge.
node].UpdateSupply(amount);
 
 3721 static bool IsUniqueStationName(
const char *name)
 
 3725   FOR_ALL_STATIONS(st) {
 
 3726     if (st->
name != NULL && strcmp(st->
name, name) == 0) 
return false;
 
 3747   if (ret.
Failed()) 
return ret;
 
 3753     if (!IsUniqueStationName(text)) 
return_cmd_error(STR_ERROR_NAME_MUST_BE_UNIQUE);
 
 3781   uint min_x = (x > max_rad) ? x - max_rad : 0;
 
 3782   uint max_x = x + location.
w + max_rad;
 
 3783   uint min_y = (y > max_rad) ? y - max_rad : 0;
 
 3784   uint max_y = y + location.
h + max_rad;
 
 3791   for (uint cy = min_y; cy < max_y; cy++) {
 
 3792     for (uint cx = min_x; cx < max_x; cx++) {
 
 3798       if (st == NULL) 
continue;
 
 3805         if (rad_x < -rad || rad_x >= rad + location.
w) 
continue;
 
 3806         if (rad_y < -rad || rad_y >= rad + location.
h) 
continue;
 
 3833   if (amount == 0) 
return 0;
 
 3837   uint best_rating1 = 0; 
 
 3838   uint best_rating2 = 0; 
 
 3840   for (
Station * 
const *st_iter = all_stations->
Begin(); st_iter != all_stations->
End(); ++st_iter) {
 
 3857     if (st1 == NULL || st->
goods[type].
rating >= best_rating1) {
 
 3858       st2 = st1; best_rating2 = best_rating1; st1 = st; best_rating1 = st->
goods[type].
rating;
 
 3859     } 
else if (st2 == NULL || st->
goods[type].
rating >= best_rating2) {
 
 3865   if (st1 == NULL) 
return 0;
 
 3869   amount *= best_rating1 + 1;
 
 3873     return UpdateStationWaiting(st1, type, amount, source_type, source_id);
 
 3877   assert(st1 != NULL);
 
 3878   assert(st2 != NULL);
 
 3879   assert(best_rating1 != 0 || best_rating2 != 0);
 
 3886   uint worst_cargo = amount * best_rating2 / (best_rating1 + best_rating2);
 
 3887   assert(worst_cargo <= (amount - worst_cargo));
 
 3890   uint moved = UpdateStationWaiting(st1, type, amount - worst_cargo, source_type, source_id);
 
 3893   return moved + UpdateStationWaiting(st2, type, worst_cargo, source_type, source_id);
 
 3899     DEBUG(misc, 0, 
"Can't allocate station for oilrig at 0x%X, reverting to oilrig only", tile);
 
 3906   st->
string_id = GenerateStationName(st, tile, STATIONNAMING_OILRIG);
 
 3919   st->
rect.BeforeAddTile(tile, StationRect::ADD_FORCE);
 
 3937   st->
rect.AfterRemoveTile(st, tile);
 
 3941   if (!st->
IsInUse()) 
delete st;
 
 3973       case STATION_WAYPOINT:
 
 4065       case STATION_WAYPOINT: 
return_cmd_error(STR_ERROR_BUILDING_MUST_BE_DEMOLISHED);
 
 4066       case STATION_AIRPORT:  
return_cmd_error(STR_ERROR_MUST_DEMOLISH_AIRPORT_FIRST);
 
 4071       case STATION_OILRIG:
 
 4072         SetDParam(1, STR_INDUSTRY_NAME_OIL_RIG);
 
 4091     case STATION_BUOY:     
return RemoveBuoy(tile, flags);
 
 4092     case STATION_DOCK:     
return RemoveDock(tile, flags);
 
 4107         case STATION_WAYPOINT:
 
 4108         case STATION_RAIL: {
 
 4115         case STATION_AIRPORT:
 
 4143   for (SharesMap::const_iterator it = this->
shares.begin(); it != this->
shares.end(); ++it) {
 
 4144     if (it->second == st) {
 
 4145       return it->first - prev;
 
 4162   assert(!this->
shares.empty());
 
 4165   if (it->second != excluded && it->second != excluded2) 
return it->second;
 
 4170   uint end = it->first;
 
 4171   uint begin = (it == this->
shares.begin() ? 0 : (--it)->first);
 
 4172   uint interval = end - begin;
 
 4173   if (interval >= this->
unrestricted) 
return INVALID_STATION; 
 
 4176   SharesMap::const_iterator it2 = (rand < begin) ? this->
shares.upper_bound(rand) :
 
 4177       this->
shares.upper_bound(rand + interval);
 
 4179   if (it2->second != excluded && it2->second != excluded2) 
return it2->second;
 
 4184   uint end2 = it2->first;
 
 4185   uint begin2 = (it2 == this->
shares.begin() ? 0 : (--it2)->first);
 
 4186   uint interval2 = end2 - begin2;
 
 4187   if (interval2 >= new_max) 
return INVALID_STATION; 
 
 4188   new_max -= interval2;
 
 4189   if (begin > begin2) {
 
 4190     Swap(begin, begin2);
 
 4192     Swap(interval, interval2);
 
 4197     it3 = this->
shares.upper_bound(rand);
 
 4198   } 
else if (rand < begin2 - interval) {
 
 4199     it3 = this->
shares.upper_bound(rand + interval);
 
 4201     it3 = this->
shares.upper_bound(rand + interval + interval2);
 
 4214   assert(!this->
shares.empty());
 
 4215   SharesMap new_shares;
 
 4217   for (SharesMap::iterator it(this->
shares.begin()); it != this->
shares.end(); ++it) {
 
 4218     new_shares[++i] = it->second;
 
 4219     if (it->first == this->unrestricted) this->
unrestricted = i;
 
 4221   this->
shares.swap(new_shares);
 
 4235   assert(!this->
shares.empty());
 
 4237   uint removed_shares = 0;
 
 4238   uint added_shares = 0;
 
 4239   uint last_share = 0;
 
 4240   SharesMap new_shares;
 
 4241   for (SharesMap::iterator it(this->
shares.begin()); it != this->
shares.end(); ++it) {
 
 4242     if (it->second == st) {
 
 4244         uint share = it->first - last_share;
 
 4245         if (flow == INT_MIN || (uint)(-flow) >= share) {
 
 4246           removed_shares += share;
 
 4247           if (it->first <= this->unrestricted) this->
unrestricted -= share;
 
 4248           if (flow != INT_MIN) flow += share;
 
 4249           last_share = it->first;
 
 4252         removed_shares += (uint)(-flow);
 
 4254         added_shares += (uint)(flow);
 
 4256       if (it->first <= this->unrestricted) this->
unrestricted += flow;
 
 4262     new_shares[it->first + added_shares - removed_shares] = it->second;
 
 4263     last_share = it->first;
 
 4266     new_shares[last_share + (uint)flow] = st;
 
 4273   this->
shares.swap(new_shares);
 
 4283   assert(!this->
shares.empty());
 
 4285   uint last_share = 0;
 
 4286   SharesMap new_shares;
 
 4287   for (SharesMap::iterator it(this->
shares.begin()); it != this->
shares.end(); ++it) {
 
 4289       if (it->first > this->unrestricted) 
return; 
 
 4290       if (it->second == st) {
 
 4291         flow = it->first - last_share;
 
 4294         new_shares[it->first] = it->second;
 
 4297       new_shares[it->first - flow] = it->second;
 
 4299     last_share = it->first;
 
 4301   if (flow == 0) 
return;
 
 4302   new_shares[last_share + flow] = st;
 
 4303   this->
shares.swap(new_shares);
 
 4304   assert(!this->
shares.empty());
 
 4314   assert(!this->
shares.empty());
 
 4316   uint next_share = 0;
 
 4318   for (SharesMap::reverse_iterator it(this->
shares.rbegin()); it != this->
shares.rend(); ++it) {
 
 4319     if (it->first < this->unrestricted) 
return; 
 
 4321       flow = next_share - it->first;
 
 4325       if (it->first == this->unrestricted) 
return; 
 
 4326       if (it->second == st) found = 
true;
 
 4328     next_share = it->first;
 
 4330   if (flow == 0) 
return;
 
 4331   SharesMap new_shares;
 
 4332   new_shares[flow] = st;
 
 4333   for (SharesMap::iterator it(this->
shares.begin()); it != this->
shares.end(); ++it) {
 
 4334     if (it->second != st) {
 
 4335       new_shares[flow + it->first] = it->second;
 
 4340   this->
shares.swap(new_shares);
 
 4341   assert(!this->
shares.empty());
 
 4351   assert(runtime > 0);
 
 4352   SharesMap new_shares;
 
 4354   for (SharesMap::iterator i = this->
shares.begin(); i != this->
shares.end(); ++i) {
 
 4355     share = 
max(share + 1, i->first * 30 / runtime);
 
 4356     new_shares[share] = i->second;
 
 4359   this->
shares.swap(new_shares);
 
 4370   FlowStatMap::iterator origin_it = this->find(origin);
 
 4371   if (origin_it == this->end()) {
 
 4372     this->insert(std::make_pair(origin, 
FlowStat(via, flow)));
 
 4374     origin_it->second.ChangeShare(via, flow);
 
 4375     assert(!origin_it->second.GetShares()->empty());
 
 4389   FlowStatMap::iterator prev_it = this->find(origin);
 
 4390   if (prev_it == this->end()) {
 
 4393     this->insert(std::make_pair(origin, fs));
 
 4395     prev_it->second.ChangeShare(via, flow);
 
 4396     prev_it->second.ChangeShare(INVALID_STATION, flow);
 
 4397     assert(!prev_it->second.GetShares()->empty());
 
 4407   for (FlowStatMap::iterator i = this->begin(); i != this->end(); ++i) {
 
 4409     uint local = fs.
GetShare(INVALID_STATION);
 
 4410     if (local > INT_MAX) { 
 
 4433   for (FlowStatMap::iterator f_it = this->begin(); f_it != this->end();) {
 
 4437       ret.
Push(f_it->first);
 
 4438       this->erase(f_it++);
 
 4452   for (FlowStatMap::iterator it = this->begin(); it != this->end(); ++it) {
 
 4453     it->second.RestrictShare(via);
 
 4463   for (FlowStatMap::iterator it = this->begin(); it != this->end(); ++it) {
 
 4464     it->second.ReleaseShare(via);
 
 4475   for (FlowStatMap::const_iterator i = this->begin(); i != this->end(); ++i) {
 
 4476     ret += (--(i->second.GetShares()->end()))->first;
 
 4489   for (FlowStatMap::const_iterator i = this->begin(); i != this->end(); ++i) {
 
 4490     ret += i->second.GetShare(via);
 
 4502   FlowStatMap::const_iterator i = this->find(from);
 
 4503   if (i == this->end()) 
return 0;
 
 4504   return (--(i->second.GetShares()->end()))->first;
 
 4515   FlowStatMap::const_iterator i = this->find(from);
 
 4516   if (i == this->end()) 
return 0;
 
 4517   return i->second.GetShare(via);
 
 4522   GetSlopePixelZ_Station,     
 
 4525   GetTileDesc_Station,        
 
 4526   GetTileTrackStatus_Station, 
 
 4528   AnimateTile_Station,        
 
 4530   ChangeTileOwner_Station,    
 
 4532   VehicleEnter_Station,       
 
 4533   GetFoundation_Station,      
 
 4534   TerraformTile_Station,