base_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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef BASE_STATION_BASE_H
#define BASE_STATION_BASE_H
 
#include "core/pool_type.hpp"
#include "command_type.h"
#include "viewport_type.h"
#include "station_map.h"
#include "timer/timer_game_calendar.h"
 
typedef Pool<BaseStation, StationID, 32> StationPool;
extern StationPool _station_pool;
 
template <typename T>
struct SpecMapping {
  const T *spec = nullptr; 
  uint32_t grfid = 0; 
  uint16_t localidx = 0; 
};
 
struct RoadStopTileData {
  TileIndex tile = INVALID_TILE;
  uint8_t random_bits = 0;
  uint8_t animation_frame = 0;
};

struct StationRect : public Rect {
  enum StationRectMode : uint8_t {
    ADD_TEST = 0,
    ADD_TRY,
    ADD_FORCE
  };
 
  StationRect();
  void MakeEmpty();
  bool PtInExtendedRect(int x, int y, int distance = 0) const;
  bool IsEmpty() const;
  CommandCost BeforeAddTile(TileIndex tile, StationRectMode mode);
  CommandCost BeforeAddRect(TileIndex tile, int w, int h, StationRectMode mode);
  bool AfterRemoveTile(BaseStation *st, TileIndex tile);
  bool AfterRemoveRect(BaseStation *st, TileArea ta);
 
  static bool ScanForStationTiles(StationID st_id, int left_a, int top_a, int right_a, int bottom_a);
 
  StationRect& operator = (const Rect &src);
};

struct BaseStation : StationPool::PoolItem<&_station_pool> {
  TileIndex xy = INVALID_TILE; 
  TrackedViewportSign sign{}; 
  uint8_t delete_ctr = 0; 
 
  std::string name{}; 
  StringID string_id = INVALID_STRING_ID; 
  mutable std::string cached_name; 
 
  Town *town = nullptr; 
  Owner owner = INVALID_OWNER; 
  StationFacilities facilities{}; 
 
  std::vector<SpecMapping<StationSpec>> speclist{}; 
  std::vector<SpecMapping<RoadStopSpec>> roadstop_speclist{}; 
 
  TimerGameCalendar::Date build_date{}; 
 
  uint16_t random_bits = 0; 
  std::unordered_map<TileIndex, StationRandomTriggers> tile_waiting_random_triggers;
  StationRandomTriggers waiting_random_triggers; 
  StationAnimationTriggers cached_anim_triggers; 
  StationAnimationTriggers cached_roadstop_anim_triggers; 
  CargoTypes cached_cargo_triggers{}; 
  CargoTypes cached_roadstop_cargo_triggers{}; 
 
  TileArea train_station{INVALID_TILE, 0, 0}; 
  StationRect rect{}; 
 
  std::vector<RoadStopTileData> custom_roadstop_tile_data{}; 

  BaseStation(StationID index, TileIndex tile) : StationPool::PoolItem<&_station_pool>(index), xy(tile) {}
 
  virtual ~BaseStation();

  virtual bool TileBelongsToRailStation(TileIndex tile) const = 0;

  virtual uint32_t GetNewGRFVariable(const struct ResolverObject &object, uint8_t variable, uint8_t parameter, bool &available) const = 0;

  virtual void UpdateVirtCoord() = 0;
 
  inline const std::string &GetCachedName() const
  {
    if (!this->name.empty()) return this->name;
    if (this->cached_name.empty()) this->FillCachedName();
    return this->cached_name;
  }

  virtual void MoveSign(TileIndex new_xy)
  {
    this->xy = new_xy;
    this->UpdateVirtCoord();
  }

  virtual TileArea GetTileArea(StationType type) const = 0;

  virtual uint GetPlatformLength(TileIndex tile) const = 0;

  virtual uint GetPlatformLength(TileIndex tile, DiagDirection dir) const = 0;

  static inline BaseStation *GetByTile(TileIndex tile)
  {
    return BaseStation::Get(GetStationIndex(tile));
  }

  inline bool IsInUse() const
  {
    return this->facilities.Any({StationFacility::Train, StationFacility::TruckStop, StationFacility::BusStop, StationFacility::Airport, StationFacility::Dock});
  }
 
  inline uint8_t GetRoadStopRandomBits(TileIndex tile) const
  {
    for (const RoadStopTileData &tile_data : this->custom_roadstop_tile_data) {
      if (tile_data.tile == tile) return tile_data.random_bits;
    }
    return 0;
  }
 
  inline uint8_t GetRoadStopAnimationFrame(TileIndex tile) const
  {
    for (const RoadStopTileData &tile_data : this->custom_roadstop_tile_data) {
      if (tile_data.tile == tile) return tile_data.animation_frame;
    }
    return 0;
  }
 
private:
  bool SetRoadStopTileData(TileIndex tile, uint8_t data, bool animation);
 
public:
  inline void SetRoadStopRandomBits(TileIndex tile, uint8_t random_bits) { this->SetRoadStopTileData(tile, random_bits, false); }
  inline bool SetRoadStopAnimationFrame(TileIndex tile, uint8_t frame) { return this->SetRoadStopTileData(tile, frame, true); }
  void RemoveRoadStopTileData(TileIndex tile);
 
  static void PostDestructor(size_t index);
 
private:
  void FillCachedName() const;
};

template <class T, bool Tis_waypoint>
struct SpecializedStation : public BaseStation {
  static constexpr StationFacilities EXPECTED_FACIL = Tis_waypoint ? StationFacility::Waypoint : StationFacilities{}; 

  inline SpecializedStation(StationID index, TileIndex tile) :
      BaseStation(index, tile)
  {
    this->facilities = EXPECTED_FACIL;
  }

  static inline bool IsExpected(const BaseStation *st)
  {
    return st->facilities.Test(StationFacility::Waypoint) == Tis_waypoint;
  }

  static inline bool IsValidID(auto index)
  {
    return BaseStation::IsValidID(index) && IsExpected(BaseStation::Get(index));
  }

  static inline T *Get(auto index)
  {
    return (T *)BaseStation::Get(index);
  }

  static inline T *GetIfValid(auto index)
  {
    return IsValidID(index) ? Get(index) : nullptr;
  }

  static inline T *GetByTile(TileIndex tile)
  {
    return GetIfValid(GetStationIndex(tile));
  }

  template <typename... Targs>
  static inline T *Create(Targs &&... args)
  {
    return BaseStation::Create<T>(std::forward<Targs&&>(args)...);
  }

  template <typename... Targs>
  static inline T *CreateAtIndex(StationID index, Targs &&... args)
  {
    return BaseStation::CreateAtIndex<T>(index, std::forward<Targs&&>(args)...);
  }

  static inline T *From(BaseStation *st)
  {
    assert(IsExpected(st));
    return (T *)st;
  }

  static inline const T *From(const BaseStation *st)
  {
    assert(IsExpected(st));
    return (const T *)st;
  }

  static Pool::IterateWrapper<T> Iterate(size_t from = 0) { return Pool::IterateWrapper<T>(from); }
};

template <class T> std::vector<SpecMapping<T>> &GetStationSpecList(BaseStation *bst);
template <> inline std::vector<SpecMapping<StationSpec>> &GetStationSpecList<StationSpec>(BaseStation *bst) { return bst->speclist; }
template <> inline std::vector<SpecMapping<RoadStopSpec>> &GetStationSpecList<RoadStopSpec>(BaseStation *bst) { return bst->roadstop_speclist; }
 
#endif /* BASE_STATION_BASE_H */