roadstop_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 ROADSTOP_BASE_H
#define ROADSTOP_BASE_H
 
#include "station_type.h"
#include "core/pool_type.hpp"
#include "core/bitmath_func.hpp"
#include "vehicle_type.h"
 
using RoadStopPool = Pool<RoadStop, RoadStopID, 32>;
extern RoadStopPool _roadstop_pool;
 
struct RoadStop : RoadStopPool::PoolItem<&_roadstop_pool> {
  enum RoadStopStatusFlags : uint8_t {
    RSSFB_BAY0_FREE  = 0, 
    RSSFB_BAY1_FREE  = 1, 
    RSSFB_BASE_ENTRY = 6, 
    RSSFB_ENTRY_BUSY = 7, 
  };
 
  static constexpr uint8_t BAY_COUNT = 2; 
 
  struct Entry {
  private:
    int length = 0; 
    int occupied = 0; 
 
  public:
    friend struct RoadStop; 
 
    Entry() {}
 
    inline int GetLength() const
    {
      return this->length;
    }
 
    inline int GetOccupied() const
    {
      return this->occupied;
    }
 
    void Leave(const RoadVehicle *rv);
    void Enter(const RoadVehicle *rv);
    void CheckIntegrity(const RoadStop *rs) const;
    void Rebuild(const RoadStop *rs, int side = -1);
  };
 
  uint8_t status = 0; 
  TileIndex xy = INVALID_TILE; 
  RoadStop *next = nullptr; 
 
  inline RoadStop(TileIndex tile = INVALID_TILE) :
    status((1 << BAY_COUNT) - 1),
    xy(tile)
  { }
 
  ~RoadStop();
 
  inline bool HasFreeBay() const
  {
    return GB(this->status, 0, BAY_COUNT) != 0;
  }
 
  inline bool IsFreeBay(uint nr) const
  {
    assert(nr < BAY_COUNT);
    return HasBit(this->status, nr);
  }
 
  inline bool IsEntranceBusy() const
  {
    return HasBit(this->status, RSSFB_ENTRY_BUSY);
  }
 
  inline void SetEntranceBusy(bool busy)
  {
    SB(this->status, RSSFB_ENTRY_BUSY, 1, busy);
  }
 
  inline const Entry *GetEntry(DiagDirection dir) const
  {
    return HasBit((int)dir, 1) ? this->west : this->east;
  }
 
  inline Entry *GetEntry(DiagDirection dir)
  {
    return HasBit((int)dir, 1) ? this->west : this->east;
  }
 
  void MakeDriveThrough();
  void ClearDriveThrough();
 
  void Leave(RoadVehicle *rv);
  bool Enter(RoadVehicle *rv);
 
  RoadStop *GetNextRoadStop(const struct RoadVehicle *v) const;
 
  static RoadStop *GetByTile(TileIndex tile, RoadStopType type);
 
  static bool IsDriveThroughRoadStopContinuation(TileIndex rs, TileIndex next);
 
private:
  Entry *east = nullptr; 
  Entry *west = nullptr; 
 
  inline uint AllocateBay()
  {
    assert(this->HasFreeBay());
 
    /* Find the first free bay. If the bit is set, the bay is free. */
    uint bay_nr = 0;
    while (!HasBit(this->status, bay_nr)) bay_nr++;
 
    ClrBit(this->status, bay_nr);
    return bay_nr;
  }
 
  inline void AllocateDriveThroughBay(uint nr)
  {
    assert(nr < BAY_COUNT);
    ClrBit(this->status, nr);
  }
 
  inline void FreeBay(uint nr)
  {
    assert(nr < BAY_COUNT);
    SetBit(this->status, nr);
  }
};
 
#endif /* ROADSTOP_BASE_H */