station_base.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef STATION_BASE_H
#define STATION_BASE_H
 
#include "core/random_func.hpp"
#include "base_station_base.h"
#include "newgrf_airport.h"
#include "cargopacket.h"
#include "industry_type.h"
#include "linkgraph/linkgraph_type.h"
#include "newgrf_storage.h"
#include "bitmap_type.h"
 
static const uint8_t INITIAL_STATION_RATING = 175;
static const uint8_t MAX_STATION_RATING = 255;
 
class FlowStat {
public:
  typedef std::map<uint32_t, StationID> SharesMap;
 
  static const SharesMap empty_sharesmap;
 
  inline FlowStat() {NOT_REACHED();}
 
  inline FlowStat(StationID st, uint flow, bool restricted = false)
  {
    assert(flow > 0);
    this->shares[flow] = st;
    this->unrestricted = restricted ? 0 : flow;
  }
 
  inline void AppendShare(StationID st, uint flow, bool restricted = false)
  {
    assert(flow > 0);
    this->shares[(--this->shares.end())->first + flow] = st;
    if (!restricted) this->unrestricted += flow;
  }
 
  uint GetShare(StationID st) const;
 
  void ChangeShare(StationID st, int flow);
 
  void RestrictShare(StationID st);
 
  void ReleaseShare(StationID st);
 
  void ScaleToMonthly(uint runtime);
 
  inline const SharesMap *GetShares() const { return &this->shares; }
 
  inline uint GetUnrestricted() const { return this->unrestricted; }
 
  inline void SwapShares(FlowStat &other)
  {
    this->shares.swap(other.shares);
    Swap(this->unrestricted, other.unrestricted);
  }
 
  inline StationID GetViaWithRestricted(bool &is_restricted) const
  {
    assert(!this->shares.empty());
    uint rand = RandomRange((--this->shares.end())->first);
    is_restricted = rand >= this->unrestricted;
    return this->shares.upper_bound(rand)->second;
  }
 
  inline StationID GetVia() const
  {
    assert(!this->shares.empty());
    return this->unrestricted > 0 ?
        this->shares.upper_bound(RandomRange(this->unrestricted))->second :
        INVALID_STATION;
  }
 
  StationID GetVia(StationID excluded, StationID excluded2 = INVALID_STATION) const;
 
  void Invalidate();
 
private:
  SharesMap shares;  
  uint unrestricted; 
};
 
class FlowStatMap : public std::map<StationID, FlowStat> {
public:
  uint GetFlow() const;
  uint GetFlowVia(StationID via) const;
  uint GetFlowFrom(StationID from) const;
  uint GetFlowFromVia(StationID from, StationID via) const;
 
  void AddFlow(StationID origin, StationID via, uint amount);
  void PassOnFlow(StationID origin, StationID via, uint amount);
  StationIDStack DeleteFlows(StationID via);
  void RestrictFlows(StationID via);
  void ReleaseFlows(StationID via);
  void FinalizeLocalConsumption(StationID self);
};
 
struct GoodsEntry {
  enum GoodsEntryStatus {
    GES_ACCEPTANCE,
 
    GES_RATING,
 
    GES_EVER_ACCEPTED,
 
    GES_LAST_MONTH,
 
    GES_CURRENT_MONTH,
 
    GES_ACCEPTED_BIGTICK,
  };
 
  StationCargoList cargo{}; 
  FlowStatMap flows{}; 
 
  uint max_waiting_cargo{0}; 
  NodeID node{INVALID_NODE}; 
  LinkGraphID link_graph{INVALID_LINK_GRAPH}; 
 
  byte status{0}; 
 
  uint8_t time_since_pickup{255};
 
  uint8_t rating{INITIAL_STATION_RATING}; 
 
  uint8_t last_speed{0};
 
  uint8_t last_age{255};
 
  uint8_t amount_fract{0}; 
 
  bool HasVehicleEverTriedLoading() const { return this->last_speed != 0; }
 
  inline bool HasRating() const
  {
    return HasBit(this->status, GES_RATING);
  }
 
  inline StationID GetVia(StationID source) const
  {
    FlowStatMap::const_iterator flow_it(this->flows.find(source));
    return flow_it != this->flows.end() ? flow_it->second.GetVia() : INVALID_STATION;
  }
 
  inline StationID GetVia(StationID source, StationID excluded, StationID excluded2 = INVALID_STATION) const
  {
    FlowStatMap::const_iterator flow_it(this->flows.find(source));
    return flow_it != this->flows.end() ? flow_it->second.GetVia(excluded, excluded2) : INVALID_STATION;
  }
};
 
struct Airport : public TileArea {
  Airport() : TileArea(INVALID_TILE, 0, 0) {}
 
  uint64_t flags;       
  byte type;          
  byte layout;        
  Direction rotation; 
 
  PersistentStorage *psa; 
 
  const AirportSpec *GetSpec() const
  {
    if (this->tile == INVALID_TILE) return &AirportSpec::dummy;
    return AirportSpec::Get(this->type);
  }
 
  const AirportFTAClass *GetFTA() const
  {
    return this->GetSpec()->fsm;
  }
 
  inline bool HasHangar() const
  {
    return this->GetSpec()->nof_depots > 0;
  }
 
  inline TileIndex GetRotatedTileFromOffset(TileIndexDiffC tidc) const
  {
    const AirportSpec *as = this->GetSpec();
    switch (this->rotation) {
      case DIR_N: return this->tile + ToTileIndexDiff(tidc);
 
      case DIR_E: return this->tile + TileDiffXY(tidc.y, as->size_x - 1 - tidc.x);
 
      case DIR_S: return this->tile + TileDiffXY(as->size_x - 1 - tidc.x, as->size_y - 1 - tidc.y);
 
      case DIR_W: return this->tile + TileDiffXY(as->size_y - 1 - tidc.y, tidc.x);
 
      default: NOT_REACHED();
    }
  }
 
  inline TileIndex GetHangarTile(uint hangar_num) const
  {
    const AirportSpec *as = this->GetSpec();
    for (uint i = 0; i < as->nof_depots; i++) {
      if (as->depot_table[i].hangar_num == hangar_num) {
        return this->GetRotatedTileFromOffset(as->depot_table[i].ti);
      }
    }
    NOT_REACHED();
  }
 
  inline Direction GetHangarExitDirection(TileIndex tile) const
  {
    const AirportSpec *as = this->GetSpec();
    const HangarTileTable *htt = GetHangarDataByTile(tile);
    return ChangeDir(htt->dir, DirDifference(this->rotation, as->rotation[0]));
  }
 
  inline uint GetHangarNum(TileIndex tile) const
  {
    const HangarTileTable *htt = GetHangarDataByTile(tile);
    return htt->hangar_num;
  }
 
  inline uint GetNumHangars() const
  {
    uint num = 0;
    uint counted = 0;
    const AirportSpec *as = this->GetSpec();
    for (uint i = 0; i < as->nof_depots; i++) {
      if (!HasBit(counted, as->depot_table[i].hangar_num)) {
        num++;
        SetBit(counted, as->depot_table[i].hangar_num);
      }
    }
    return num;
  }
 
private:
  inline const HangarTileTable *GetHangarDataByTile(TileIndex tile) const
  {
    const AirportSpec *as = this->GetSpec();
    for (uint i = 0; i < as->nof_depots; i++) {
      if (this->GetRotatedTileFromOffset(as->depot_table[i].ti) == tile) {
        return as->depot_table + i;
      }
    }
    NOT_REACHED();
  }
};
 
struct IndustryListEntry {
  uint distance;
  Industry *industry;
 
  bool operator== (const IndustryListEntry &other) const { return this->distance == other.distance && this->industry == other.industry; };
};
 
struct IndustryCompare {
  bool operator() (const IndustryListEntry &lhs, const IndustryListEntry &rhs) const;
};
 
typedef std::set<IndustryListEntry, IndustryCompare> IndustryList;
 
struct Station final : SpecializedStation<Station, false> {
public:
  RoadStop *GetPrimaryRoadStop(RoadStopType type) const
  {
    return type == ROADSTOP_BUS ? bus_stops : truck_stops;
  }
 
  RoadStop *GetPrimaryRoadStop(const struct RoadVehicle *v) const;
 
  RoadStop *bus_stops;    
  TileArea bus_station;   
  RoadStop *truck_stops;  
  TileArea truck_station; 
 
  Airport airport;          
  TileArea ship_station;    
  TileArea docking_station; 
 
  IndustryType indtype;   
 
  BitmapTileArea catchment_tiles; 
 
  StationHadVehicleOfType had_vehicle_of_type;
 
  byte time_since_load;
  byte time_since_unload;
 
  byte last_vehicle_type;
  std::list<Vehicle *> loading_vehicles;
  GoodsEntry goods[NUM_CARGO];  
  CargoTypes always_accepted;       
 
  IndustryList industries_near; 
  Industry *industry;           
 
  Station(TileIndex tile = INVALID_TILE);
  ~Station();
 
  void AddFacility(StationFacility new_facility_bit, TileIndex facil_xy);
 
  void MarkTilesDirty(bool cargo_change) const;
 
  void UpdateVirtCoord() override;
 
  void MoveSign(TileIndex new_xy) override;
 
  void AfterStationTileSetChange(bool adding, StationType type);
 
  uint GetPlatformLength(TileIndex tile, DiagDirection dir) const override;
  uint GetPlatformLength(TileIndex tile) const override;
  void RecomputeCatchment(bool no_clear_nearby_lists = false);
  static void RecomputeCatchmentForAll();
 
  uint GetCatchmentRadius() const;
  Rect GetCatchmentRect() const;
  bool CatchmentCoversTown(TownID t) const;
  void AddIndustryToDeliver(Industry *ind, TileIndex tile);
  void RemoveIndustryToDeliver(Industry *ind);
  void RemoveFromAllNearbyLists();
 
  inline bool TileIsInCatchment(TileIndex tile) const
  {
    return this->catchment_tiles.HasTile(tile);
  }
 
  inline bool TileBelongsToRailStation(TileIndex tile) const override
  {
    return IsRailStationTile(tile) && GetStationIndex(tile) == this->index;
  }
 
  inline bool TileBelongsToRoadStop(TileIndex tile) const
  {
    return IsRoadStopTile(tile) && GetStationIndex(tile) == this->index;
  }
 
  inline bool TileBelongsToAirport(TileIndex tile) const
  {
    return IsAirportTile(tile) && GetStationIndex(tile) == this->index;
  }
 
  uint32_t GetNewGRFVariable(const ResolverObject &object, byte variable, byte parameter, bool *available) const override;
 
  void GetTileArea(TileArea *ta, StationType type) const override;
};
 
class AirportTileIterator : public OrthogonalTileIterator {
private:
  const Station *st; 
 
public:
  AirportTileIterator(const Station *st) : OrthogonalTileIterator(st->airport), st(st)
  {
    if (!st->TileBelongsToAirport(this->tile)) ++(*this);
  }
 
  inline TileIterator& operator ++() override
  {
    (*this).OrthogonalTileIterator::operator++();
    while (this->tile != INVALID_TILE && !st->TileBelongsToAirport(this->tile)) {
      (*this).OrthogonalTileIterator::operator++();
    }
    return *this;
  }
 
  std::unique_ptr<TileIterator> Clone() const override
  {
    return std::make_unique<AirportTileIterator>(*this);
  }
};
 
void RebuildStationKdtree();
 
template<typename Func>
void ForAllStationsAroundTiles(const TileArea &ta, Func func)
{
  /* There are no stations, so we will never find anything. */
  if (Station::GetNumItems() == 0) return;
 
  /* Not using, or don't have a nearby stations list, so we need to scan. */
  std::set<StationID> seen_stations;
 
  /* Scan an area around the building covering the maximum possible station
   * to find the possible nearby stations. */
  uint max_c = _settings_game.station.modified_catchment ? MAX_CATCHMENT : CA_UNMODIFIED;
  TileArea ta_ext = TileArea(ta).Expand(max_c);
  for (TileIndex tile : ta_ext) {
    if (IsTileType(tile, MP_STATION)) seen_stations.insert(GetStationIndex(tile));
  }
 
  for (StationID stationid : seen_stations) {
    Station *st = Station::GetIfValid(stationid);
    if (st == nullptr) continue; /* Waypoint */
 
    /* Check if station is attached to an industry */
    if (!_settings_game.station.serve_neutral_industries && st->industry != nullptr) continue;
 
    /* Test if the tile is within the station's catchment */
    for (TileIndex tile : ta) {
      if (st->TileIsInCatchment(tile)) {
        if (func(st, tile)) break;
      }
    }
  }
}
 
#endif /* STATION_BASE_H */