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 "newgrf_animation_type.h"
#include "newgrf_spritegroup.h"
#include "newgrf_class.h"
#include "newgrf_commons.h"
#include "newgrf_town.h"
#include "road.h"
 
static const int NUM_ROADSTOPS_PER_GRF = UINT16_MAX - 1;
 
enum RoadStopClassID : byte {
  ROADSTOP_CLASS_BEGIN = 0,    
  ROADSTOP_CLASS_DFLT = 0,     
  ROADSTOP_CLASS_WAYP,         
  ROADSTOP_CLASS_MAX = 255,    
};
DECLARE_POSTFIX_INCREMENT(RoadStopClassID)
 
/* Some Triggers etc. */
enum RoadStopRandomTrigger {
  RSRT_NEW_CARGO,       
  RSRT_CARGO_TAKEN,     
  RSRT_VEH_ARRIVES,     
  RSRT_VEH_DEPARTS,     
  RSRT_VEH_LOADS,       
};
 
enum RoadStopAvailabilityType : byte {
  ROADSTOPTYPE_PASSENGER,    
  ROADSTOPTYPE_FREIGHT,      
  ROADSTOPTYPE_ALL,          
 
  ROADSTOPTYPE_END,
};
 
enum RoadStopDrawMode : byte {
  ROADSTOP_DRAW_MODE_NONE        = 0,
  ROADSTOP_DRAW_MODE_ROAD        = 1 << 0, 
  ROADSTOP_DRAW_MODE_OVERLAY     = 1 << 1, 
};
DECLARE_ENUM_AS_BIT_SET(RoadStopDrawMode)
 
enum RoadStopSpecFlags {
  RSF_CB141_RANDOM_BITS       = 0, 
  RSF_NO_CATENARY             = 2, 
  RSF_DRIVE_THROUGH_ONLY      = 3, 
  RSF_NO_AUTO_ROAD_CONNECTION = 4, 
  RSF_BUILD_MENU_ROAD_ONLY    = 5, 
  RSF_BUILD_MENU_TRAM_ONLY    = 6, 
};
 
struct RoadStopScopeResolver : public ScopeResolver {
  TileIndex tile;                             
  struct BaseStation *st;                     
  const struct RoadStopSpec *roadstopspec;    
  CargoID cargo_type;                         
  StationType type;                           
  uint8_t view;                                 
  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 GetTriggers() const override;
 
  uint32_t GetVariable(byte variable, [[maybe_unused]] uint32_t parameter, bool *available) const override;
};
 
struct RoadStopResolverObject : public ResolverObject {
  RoadStopScopeResolver roadstop_scope; 
  TownScopeResolver *town_scope;        
 
  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);
  ~RoadStopResolverObject();
 
  ScopeResolver *GetScope(VarSpriteGroupScope scope = VSG_SCOPE_SELF, byte 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();
 
  const SpriteGroup *ResolveReal(const RealSpriteGroup *group) const override;
};
 
struct RoadStopSpec {
  GRFFilePropsBase<NUM_CARGO + 3> grf_prop;
  RoadStopClassID cls_id;     
  int spec_id;                
  StringID name;              
 
  RoadStopAvailabilityType stop_type = ROADSTOPTYPE_ALL;
  RoadStopDrawMode draw_mode = ROADSTOP_DRAW_MODE_ROAD | ROADSTOP_DRAW_MODE_OVERLAY;
  uint8_t callback_mask = 0;
  uint8_t flags = 0;
 
  CargoTypes cargo_triggers = 0; 
 
  AnimationInfo animation;
 
  byte bridge_height[6];             
  byte bridge_disallowed_pillars[6]; 
 
  uint8_t build_cost_multiplier = 16;  
  uint8_t clear_cost_multiplier = 16;  
 
  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);
};
 
typedef NewGRFClass<RoadStopSpec, RoadStopClassID, ROADSTOP_CLASS_MAX> RoadStopClass;
 
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);
 
void AnimateRoadStopTile(TileIndex tile);
uint8_t GetRoadStopTileAnimationSpeed(TileIndex tile);
void TriggerRoadStopAnimation(BaseStation *st, TileIndex tile, StationAnimationTrigger trigger, CargoID cargo_type = INVALID_CARGO);
void TriggerRoadStopRandomisation(Station *st, TileIndex tile, RoadStopRandomTrigger trigger, CargoID cargo_type = INVALID_CARGO);
 
bool GetIfNewStopsByType(RoadStopType rs, RoadType roadtype);
bool GetIfClassHasNewStopsByType(RoadStopClass *roadstopclass, RoadStopType rs, RoadType roadtype);
bool GetIfStopIsForType(const RoadStopSpec *roadstopspec, RoadStopType rs, RoadType roadtype);
 
uint GetCountOfCompatibleStopsByType(RoadStopClass *roadstopclass, RoadStopType rs);
 
const RoadStopSpec *GetRoadStopSpec(TileIndex t);
int AllocateSpecToRoadStop(const RoadStopSpec *statspec, BaseStation *st, bool exec);
void DeallocateSpecFromRoadStop(BaseStation *st, byte specindex);
void RoadStopUpdateCachedTriggers(BaseStation *st);
 
#endif /* NEWGRF_ROADSTATION_H */