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"
#include <map>
#include <set>

typedef Pool<BaseStation, StationID, 32, 64000> StationPool;
extern StationPool _station_pool;

static const byte INITIAL_STATION_RATING = 175;

class FlowStat {
public:
  typedef std::map<uint32, 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,
  };

  GoodsEntry() :
    status(0),
    time_since_pickup(255),
    rating(INITIAL_STATION_RATING),
    last_speed(0),
    last_age(255),
    amount_fract(0),
    link_graph(INVALID_LINK_GRAPH),
    node(INVALID_NODE),
    max_waiting_cargo(0)
  {}

  byte status; 

  byte time_since_pickup;

  byte rating;            

  byte last_speed;

  byte last_age;

  byte amount_fract;      
  StationCargoList cargo; 

  LinkGraphID link_graph; 
  NodeID node;            
  FlowStatMap flows;      
  uint max_waiting_cargo; 

  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 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 IndustryCompare {
  bool operator() (const Industry *lhs, const Industry *rhs) const;
};

typedef std::set<Industry *, 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();
  static void RecomputeCatchmentForAll();

  uint GetCatchmentRadius() const;
  Rect GetCatchmentRect() const;
  bool CatchmentCoversTown(TownID t) const;
  void AddIndustryToDeliver(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 TileBelongsToAirport(TileIndex tile) const
  {
    return IsAirportTile(tile) && GetStationIndex(tile) == this->index;
  }

  uint32 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 ++()
  {
    (*this).OrthogonalTileIterator::operator++();
    while (this->tile != INVALID_TILE && !st->TileBelongsToAirport(this->tile)) {
      (*this).OrthogonalTileIterator::operator++();
    }
    return *this;
  }

  virtual TileIterator *Clone() const
  {
    return new AirportTileIterator(*this);
  }
};

void RebuildStationKdtree();

template<typename Func>
void ForAllStationsAroundTiles(const TileArea &ta, Func func)
{
  /* 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);
  TILE_AREA_LOOP(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 */
    TILE_AREA_LOOP(tile, ta) {
      if (st->TileIsInCatchment(tile)) {
        if (func(st, tile)) break;
      }
    }
  }
}

#endif /* STATION_BASE_H */