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);
    std::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 :
        StationID::Invalid();
  }
 
  StationID GetVia(StationID excluded, StationID excluded2 = StationID::Invalid()) const;
 
  void Invalidate();
 
private:
  SharesMap shares{}; 
  uint unrestricted = 0; 
};
 
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 class State : uint8_t {
    Acceptance = 0,
 
    Rating = 1,
 
    EverAccepted = 2,
 
    LastMonth = 3,
 
    CurrentMonth = 4,
 
    AcceptedBigtick = 5,
  };
  using States = EnumBitSet<State, uint8_t>;
 
  struct GoodsEntryData {
    StationCargoList cargo{}; 
    FlowStatMap flows{}; 
 
    bool IsEmpty() const
    {
      return this->cargo.TotalCount() == 0 && this->flows.empty();
    }
  };
 
  uint max_waiting_cargo = 0; 
  NodeID node = INVALID_NODE; 
  LinkGraphID link_graph = LinkGraphID::Invalid(); 
 
  States status{}; 
 
  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 this->status.Test(GoodsEntry::State::Rating);
  }
 
  inline StationID GetVia(StationID source) const
  {
    if (!this->HasData()) return StationID::Invalid();
 
    FlowStatMap::const_iterator flow_it(this->GetData().flows.find(source));
    return flow_it != this->GetData().flows.end() ? flow_it->second.GetVia() : StationID::Invalid();
  }
 
  inline StationID GetVia(StationID source, StationID excluded, StationID excluded2 = StationID::Invalid()) const
  {
    if (!this->HasData()) return StationID::Invalid();
 
    FlowStatMap::const_iterator flow_it(this->GetData().flows.find(source));
    return flow_it != this->GetData().flows.end() ? flow_it->second.GetVia(excluded, excluded2) : StationID::Invalid();
  }
 
  debug_inline bool HasData() const { return this->data != nullptr; }
 
  void ClearData() { this->data.reset(); }
 
  debug_inline const GoodsEntryData &GetData() const
  {
    assert(this->HasData());
    return *this->data;
  }
 
  debug_inline GoodsEntryData &GetData()
  {
    assert(this->HasData());
    return *this->data;
  }
 
  inline GoodsEntryData &GetOrCreateData()
  {
    if (!this->HasData()) this->data = std::make_unique<GoodsEntryData>();
    return *this->data;
  }
 
  uint8_t ConvertState() const;
 
private:
  std::unique_ptr<GoodsEntryData> data = nullptr; 
};
 
struct Airport : public TileArea {
  Airport() : TileArea(INVALID_TILE, 0, 0) {}
 
  AirportBlocks blocks{}; 
  uint8_t type = 0; 
  uint8_t layout = 0; 
  Direction rotation = INVALID_DIR; 
 
  PersistentStorage *psa = nullptr; 
 
  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()->depots.empty();
  }
 
  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
  {
    for (const auto &depot : this->GetSpec()->depots) {
      if (depot.hangar_num == hangar_num) {
        return this->GetRotatedTileFromOffset(depot.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->layouts[0].rotation));
  }
 
  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;
    for (const auto &depot : this->GetSpec()->depots) {
      if (!HasBit(counted, depot.hangar_num)) {
        num++;
        SetBit(counted, depot.hangar_num);
      }
    }
    return num;
  }
 
private:
  inline const HangarTileTable *GetHangarDataByTile(TileIndex tile) const
  {
    for (const auto &depot : this->GetSpec()->depots) {
      if (this->GetRotatedTileFromOffset(depot.ti) == tile) {
        return &depot;
      }
    }
    NOT_REACHED();
  }
};
 
struct IndustryListEntry {
  uint distance = 0;
  Industry *industry = nullptr;
 
  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 == RoadStopType::Bus ? bus_stops : truck_stops;
  }
 
  RoadStop *GetPrimaryRoadStop(const struct RoadVehicle *v) const;
 
  RoadStop *bus_stops = nullptr; 
  TileArea bus_station{}; 
  RoadStop *truck_stops = nullptr; 
  TileArea truck_station{}; 
 
  Airport airport{}; 
  TileArea ship_station{}; 
  TileArea docking_station{}; 
 
  IndustryType indtype = IT_INVALID; 
 
  BitmapTileArea catchment_tiles{}; 
 
  StationHadVehicleOfType had_vehicle_of_type{};
 
  uint8_t time_since_load = 0;
  uint8_t time_since_unload = 0;
 
  uint8_t last_vehicle_type = 0;
  std::list<Vehicle *> loading_vehicles{};
  std::array<GoodsEntry, NUM_CARGO> goods; 
  CargoTypes always_accepted{}; 
 
  IndustryList industries_near{}; 
  Industry *industry = nullptr; 
 
  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 IsStationRoadStopTile(tile) && GetStationIndex(tile) == this->index;
  }
 
  inline bool TileBelongsToAirport(TileIndex tile) const
  {
    return IsAirportTile(tile) && GetStationIndex(tile) == this->index;
  }
 
  uint32_t GetNewGRFVariable(const ResolverObject &object, uint8_t variable, uint8_t parameter, bool &available) const override;
 
  void GetTileArea(TileArea *ta, StationType type) const override;
};
 
class AirportTileIterator : public OrthogonalTileIterator {
private:
  const Station *st = nullptr; 
 
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 */