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 <http://www.gnu.org/licenses/>.
 */
 
#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, 64000> StationPool;
extern StationPool _station_pool;
 
template <typename T>
struct SpecMapping {
  const T *spec; 
  uint32_t grfid; 
  uint16_t localidx; 
};
 
struct RoadStopTileData {
  TileIndex tile;
  uint8_t random_bits;
  uint8_t animation_frame;
};
 
struct StationRect : public Rect {
  enum StationRectMode
  {
    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;                   
  TrackedViewportSign sign;       
  uint8_t delete_ctr;                
 
  std::string name;               
  StringID string_id;             
  mutable std::string cached_name; 
 
  Town *town;                     
  Owner owner;                    
  StationFacility facilities;     
 
  std::vector<SpecMapping<StationSpec>> speclist;           
  std::vector<SpecMapping<RoadStopSpec>> roadstop_speclist; 
 
  TimerGameCalendar::Date build_date; 
 
  uint16_t random_bits;             
  uint8_t waiting_triggers;          
  uint8_t cached_anim_triggers;                
  uint8_t cached_roadstop_anim_triggers;       
  CargoTypes cached_cargo_triggers;          
  CargoTypes cached_roadstop_cargo_triggers; 
 
  TileArea train_station;         
  StationRect rect;               
 
  std::vector<RoadStopTileData> custom_roadstop_tile_data; 
 
  BaseStation(TileIndex tile) :
    xy(tile),
    train_station(INVALID_TILE, 0, 0)
  {
  }
 
  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 void GetTileArea(TileArea *ta, 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 & ~FACIL_WAYPOINT) != 0;
  }
 
  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 const StationFacility EXPECTED_FACIL = Tis_waypoint ? FACIL_WAYPOINT : FACIL_NONE; 
 
  inline SpecializedStation(TileIndex tile) :
      BaseStation(tile)
  {
    this->facilities = EXPECTED_FACIL;
  }
 
  static inline bool IsExpected(const BaseStation *st)
  {
    return (st->facilities & FACIL_WAYPOINT) == EXPECTED_FACIL;
  }
 
  static inline bool IsValidID(size_t index)
  {
    return BaseStation::IsValidID(index) && IsExpected(BaseStation::Get(index));
  }
 
  static inline T *Get(size_t index)
  {
    return (T *)BaseStation::Get(index);
  }
 
  static inline T *GetIfValid(size_t index)
  {
    return IsValidID(index) ? Get(index) : nullptr;
  }
 
  static inline T *GetByTile(TileIndex tile)
  {
    return GetIfValid(GetStationIndex(tile));
  }
 
  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 */