newgrf_roadstop.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 NEWGRF_ROADSTATION_H
#define NEWGRF_ROADSTATION_H
 
#include "bridge_type.h"
#include "newgrf_animation_type.h"
#include "newgrf_spritegroup.h"
#include "newgrf_badge_type.h"
#include "newgrf_callbacks.h"
#include "newgrf_class.h"
#include "newgrf_commons.h"
#include "newgrf_town.h"
#include "road.h"
 
struct TileInfo;
 
static const int NUM_ROADSTOPS_PER_GRF = UINT16_MAX - 1;
 
static const uint32_t ROADSTOP_CLASS_LABEL_DEFAULT = 'DFLT';
static const uint32_t ROADSTOP_CLASS_LABEL_WAYPOINT = 'WAYP';
 
enum RoadStopClassID : uint16_t {
  ROADSTOP_CLASS_BEGIN = 0, 
  ROADSTOP_CLASS_DFLT = 0, 
  ROADSTOP_CLASS_WAYP, 
  ROADSTOP_CLASS_MAX = UINT16_MAX, 
};
DECLARE_INCREMENT_DECREMENT_OPERATORS(RoadStopClassID)
 
 
enum RoadStopAvailabilityType : uint8_t {
  ROADSTOPTYPE_PASSENGER,    
  ROADSTOPTYPE_FREIGHT,      
  ROADSTOPTYPE_ALL,          
 
  ROADSTOPTYPE_END,
};
 
enum class RoadStopDrawMode : uint8_t {
  Road = 0, 
  Overlay = 1, 
  WaypGround = 2, 
};
using RoadStopDrawModes = EnumBitSet<RoadStopDrawMode, uint8_t>;
 
enum class RoadStopSpecFlag : uint8_t {
  Cb141RandomBits = 0, 
  NoCatenary = 2, 
  DriveThroughOnly = 3, 
  NoAutoRoadConnection = 4, 
  RoadOnly = 5, 
  TramOnly = 6, 
  DrawModeRegister = 8, 
};
using RoadStopSpecFlags = EnumBitSet<RoadStopSpecFlag, uint8_t>;
 
enum RoadStopView : uint8_t {
  RSV_BAY_NE                  = 0, 
  RSV_BAY_SE                  = 1, 
  RSV_BAY_SW                  = 2, 
  RSV_BAY_NW                  = 3, 
  RSV_DRIVE_THROUGH_X         = 4, 
  RSV_DRIVE_THROUGH_Y         = 5, 
};
 
struct RoadStopScopeResolver : public ScopeResolver {
  TileIndex tile{}; 
  struct BaseStation *st = nullptr; 
  const struct RoadStopSpec *roadstopspec = nullptr; 
  CargoType cargo_type{}; 
  StationType type{}; 
  uint8_t view = 0; 
  RoadType roadtype{}; 
 
  RoadStopScopeResolver(ResolverObject &ro, BaseStation *st, const RoadStopSpec *roadstopspec, TileIndex tile, RoadType roadtype, StationType type, uint8_t view = 0)
    : ScopeResolver(ro), tile(tile), st(st), roadstopspec(roadstopspec), type(type), view(view), roadtype(roadtype)
  {
  }
 
  uint32_t GetRandomBits() const override;
  uint32_t GetRandomTriggers() const override;
 
  uint32_t GetVariable(uint8_t variable, [[maybe_unused]] uint32_t parameter, bool &available) const override;
};
 
struct RoadStopResolverObject : public SpecializedResolverObject<StationRandomTriggers> {
  RoadStopScopeResolver roadstop_scope; 
  std::optional<TownScopeResolver> town_scope = std::nullopt; 
 
  RoadStopResolverObject(const RoadStopSpec *roadstopspec, BaseStation *st, TileIndex tile, RoadType roadtype, StationType type, uint8_t view, CallbackID callback = CBID_NO_CALLBACK, uint32_t param1 = 0, uint32_t param2 = 0);
 
  ScopeResolver *GetScope(VarSpriteGroupScope scope = VSG_SCOPE_SELF, uint8_t relative = 0) override
  {
    switch (scope) {
      case VSG_SCOPE_SELF: return &this->roadstop_scope;
      case VSG_SCOPE_PARENT: {
        TownScopeResolver *tsr = this->GetTown();
        if (tsr != nullptr) return tsr;
        [[fallthrough]];
      }
      default: return ResolverObject::GetScope(scope, relative);
    }
  }
 
  TownScopeResolver *GetTown();
};
 
struct RoadStopSpec : NewGRFSpecBase<RoadStopClassID> {
  CargoGRFFileProps grf_prop; 
  StringID name;              
 
  RoadStopAvailabilityType stop_type = ROADSTOPTYPE_ALL;
  RoadStopDrawModes draw_mode = {RoadStopDrawMode::Road, RoadStopDrawMode::Overlay};
  RoadStopCallbackMasks callback_mask{};
  RoadStopSpecFlags flags{};
 
  CargoTypes cargo_triggers = 0; 
 
  AnimationInfo<StationAnimationTriggers> animation;
 
  uint8_t build_cost_multiplier = 16;  
  uint8_t clear_cost_multiplier = 16;  
 
  std::array<BridgeableTileInfo, 6> bridgeable_info{}; 
  std::vector<BadgeID> badges;
 
  Money GetBuildCost(Price category) const { return GetPrice(category, this->build_cost_multiplier, this->grf_prop.grffile, -4); }
 
  Money GetClearCost(Price category) const { return GetPrice(category, this->clear_cost_multiplier, this->grf_prop.grffile, -4); }
 
  static const RoadStopSpec *Get(uint16_t index);
};
 
using RoadStopClass = NewGRFClass<RoadStopSpec, RoadStopClassID, ROADSTOP_CLASS_MAX>;
 
std::optional<SpriteLayoutProcessor> GetRoadStopLayout(TileInfo *ti, const RoadStopSpec *spec, BaseStation *st, StationType type, int view, std::span<int32_t> regs100 = {});
void DrawRoadStopTile(int x, int y, RoadType roadtype, const RoadStopSpec *spec, StationType type, int view);
 
uint16_t GetRoadStopCallback(CallbackID callback, uint32_t param1, uint32_t param2, const RoadStopSpec *roadstopspec, BaseStation *st, TileIndex tile, RoadType roadtype, StationType type, uint8_t view, std::span<int32_t> regs100 = {});
 
void AnimateRoadStopTile(TileIndex tile);
uint8_t GetRoadStopTileAnimationSpeed(TileIndex tile);
void TriggerRoadStopAnimation(BaseStation *st, TileIndex tile, StationAnimationTrigger trigger, CargoType cargo_type = INVALID_CARGO);
void TriggerRoadStopRandomisation(BaseStation *st, TileIndex tile, StationRandomTrigger trigger, CargoType cargo_type = INVALID_CARGO);
 
bool GetIfNewStopsByType(RoadStopType rs, RoadType roadtype);
bool GetIfClassHasNewStopsByType(const RoadStopClass *roadstopclass, RoadStopType rs, RoadType roadtype);
bool GetIfStopIsForType(const RoadStopSpec *roadstopspec, RoadStopType rs, RoadType roadtype);
 
const RoadStopSpec *GetRoadStopSpec(TileIndex t);
std::optional<uint8_t> AllocateSpecToRoadStop(const RoadStopSpec *statspec, BaseStation *st, bool exec);
void DeallocateSpecFromRoadStop(BaseStation *st, uint8_t specindex);
void RoadStopUpdateCachedTriggers(BaseStation *st);
 
inline bool IsWaypointClass(const RoadStopClass &cls)
{
  return cls.global_id == ROADSTOP_CLASS_LABEL_WAYPOINT || GB(cls.global_id, 24, 8) == UINT8_MAX;
}
 
#endif /* NEWGRF_ROADSTATION_H */