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

 
#ifndef ROADSTOP_BASE_H
#define ROADSTOP_BASE_H
 
#include "station_type.h"
#include "core/pool_type.hpp"
#include "vehicle_type.h"
 
using RoadStopPool = Pool<RoadStop, RoadStopID, 32>;
extern RoadStopPool _roadstop_pool;

struct RoadStop : RoadStopPool::PoolItem<&_roadstop_pool> {
  enum class RoadStopStatusFlag : uint8_t {
    Bay0Free  = 0, 
    Bay1Free  = 1, 
    BaseEntry = 6, 
    EntryBusy = 7, 
  };

  using RoadStopStatusFlags = EnumBitSet<RoadStopStatusFlag, uint8_t>;

  struct Entry {
  private:
    uint16_t length = 0; 
    uint16_t occupied = 0; 
 
  public:
    friend struct RoadStop; 

    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);
  };

  struct Entries {
    Entry east{}; 
    Entry west{}; 
  };
 
  RoadStopStatusFlags status{RoadStopStatusFlag::Bay0Free, RoadStopStatusFlag::Bay1Free}; 
  TileIndex xy = INVALID_TILE; 
  RoadStop *next = nullptr; 

  inline RoadStop(RoadStopID index, TileIndex tile = INVALID_TILE) : RoadStopPool::PoolItem<&_roadstop_pool>(index), xy(tile) { }
 
  ~RoadStop();

  inline bool HasFreeBay() const
  {
    return this->status.Any({RoadStopStatusFlag::Bay0Free, RoadStopStatusFlag::Bay1Free});
  }

  inline bool IsFreeBay(uint nr) const
  {
    switch (nr) {
      case 0: return this->status.Test(RoadStopStatusFlag::Bay0Free);
      case 1: return this->status.Test(RoadStopStatusFlag::Bay1Free);
      default: NOT_REACHED();
    }
  }

  inline bool IsEntranceBusy() const
  {
    return this->status.Test(RoadStopStatusFlag::EntryBusy);
  }

  inline void SetEntranceBusy(bool busy)
  {
    this->status.Set(RoadStopStatusFlag::EntryBusy, busy);
  }

  inline const Entry &GetEntry(DiagDirection dir) const
  {
    return dir >= DiagDirection::SW ? this->entries->west : this->entries->east;
  }

  inline Entry &GetEntry(DiagDirection dir)
  {
    return dir >= DiagDirection::SW ? this->entries->west : this->entries->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:
  Entries *entries = nullptr; 

  inline uint AllocateBay()
  {
    assert(this->HasFreeBay());
 
    /* Find the first free bay. */
    uint bay_nr = 0;
    while (!this->IsFreeBay(bay_nr)) ++bay_nr;
 
    this->AllocateDriveThroughBay(bay_nr);
    return bay_nr;
  }

  inline void AllocateDriveThroughBay(uint nr)
  {
    switch (nr) {
      case 0: this->status.Reset(RoadStopStatusFlag::Bay0Free); break;
      case 1: this->status.Reset(RoadStopStatusFlag::Bay1Free); break;
      default: NOT_REACHED();
    }
  }

  inline void FreeBay(uint nr)
  {
    switch (nr) {
      case 0: this->status.Set(RoadStopStatusFlag::Bay0Free); break;
      case 1: this->status.Set(RoadStopStatusFlag::Bay1Free); break;
      default: NOT_REACHED();
    }
  }
};
 
#endif /* ROADSTOP_BASE_H */