newgrf_station.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_STATION_H
#define NEWGRF_STATION_H
 
#include "newgrf_animation_type.h"
#include "newgrf_callbacks.h"
#include "newgrf_class.h"
#include "newgrf_commons.h"
#include "cargo_type.h"
#include "station_type.h"
#include "rail_type.h"
#include "newgrf_spritegroup.h"
#include "newgrf_town.h"
 
struct StationScopeResolver : public ScopeResolver {
  TileIndex tile;                     
  struct BaseStation *st;             
  const struct StationSpec *statspec; 
  CargoID cargo_type;                 
  Axis axis;                          
 
  StationScopeResolver(ResolverObject &ro, const StationSpec *statspec, BaseStation *st, TileIndex tile)
    : ScopeResolver(ro), tile(tile), st(st), statspec(statspec), cargo_type(INVALID_CARGO), axis(INVALID_AXIS)
  {
  }
 
  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 StationResolverObject : public ResolverObject {
  StationScopeResolver station_scope; 
  TownScopeResolver *town_scope;      
 
  StationResolverObject(const StationSpec *statspec, BaseStation *st, TileIndex tile,
      CallbackID callback = CBID_NO_CALLBACK, uint32_t callback_param1 = 0, uint32_t callback_param2 = 0);
  ~StationResolverObject();
 
  TownScopeResolver *GetTown();
 
  ScopeResolver *GetScope(VarSpriteGroupScope scope = VSG_SCOPE_SELF, byte relative = 0) override
  {
    switch (scope) {
      case VSG_SCOPE_SELF:
        return &this->station_scope;
 
      case VSG_SCOPE_PARENT: {
        TownScopeResolver *tsr = this->GetTown();
        if (tsr != nullptr) return tsr;
        [[fallthrough]];
      }
 
      default:
        return ResolverObject::GetScope(scope, relative);
    }
  }
 
  const SpriteGroup *ResolveReal(const RealSpriteGroup *group) const override;
 
  GrfSpecFeature GetFeature() const override;
  uint32_t GetDebugID() const override;
};
 
enum StationClassID : byte {
  STAT_CLASS_BEGIN = 0,    
  STAT_CLASS_DFLT = 0,     
  STAT_CLASS_WAYP,         
  STAT_CLASS_MAX = 255,    
};
 
DECLARE_POSTFIX_INCREMENT(StationClassID)
 
enum StationSpecFlags {
  SSF_SEPARATE_GROUND,      
  SSF_DIV_BY_STATION_SIZE,  
  SSF_CB141_RANDOM_BITS,    
  SSF_CUSTOM_FOUNDATIONS,   
  SSF_EXTENDED_FOUNDATIONS, 
};
 
enum StationRandomTrigger {
  SRT_NEW_CARGO,        
  SRT_CARGO_TAKEN,      
  SRT_TRAIN_ARRIVES,    
  SRT_TRAIN_DEPARTS,    
  SRT_TRAIN_LOADS,      
  SRT_PATH_RESERVATION, 
};
 
struct StationSpec {
  StationSpec() : cls_id(STAT_CLASS_DFLT), name(0),
    disallowed_platforms(0), disallowed_lengths(0),
    cargo_threshold(0), cargo_triggers(0),
    callback_mask(0), flags(0), pylons(0), wires(0), blocked(0),
    animation({0, 0, 0, 0}) {}
  GRFFilePropsBase<NUM_CARGO + 3> grf_prop;
  StationClassID cls_id;     
  StringID name;             
 
  byte disallowed_platforms;
  byte disallowed_lengths;
 
  std::vector<NewGRFSpriteLayout> renderdata; 
 
  uint16_t cargo_threshold;
 
  CargoTypes cargo_triggers; 
 
  byte callback_mask; 
 
  byte flags; 
 
  byte pylons;  
  byte wires;   
  byte blocked; 
 
  AnimationInfo animation;
 
  std::vector<std::vector<std::vector<byte>>> layouts;
};
 
typedef NewGRFClass<StationSpec, StationClassID, STAT_CLASS_MAX> StationClass;
 
const StationSpec *GetStationSpec(TileIndex t);
 
/* Evaluate a tile's position within a station, and return the result a bitstuffed format. */
uint32_t GetPlatformInfo(Axis axis, byte tile, int platforms, int length, int x, int y, bool centred);
 
SpriteID GetCustomStationRelocation(const StationSpec *statspec, BaseStation *st, TileIndex tile, uint32_t var10 = 0);
SpriteID GetCustomStationFoundationRelocation(const StationSpec *statspec, BaseStation *st, TileIndex tile, uint layout, uint edge_info);
uint16_t GetStationCallback(CallbackID callback, uint32_t param1, uint32_t param2, const StationSpec *statspec, BaseStation *st, TileIndex tile);
CommandCost PerformStationTileSlopeCheck(TileIndex north_tile, TileIndex cur_tile, const StationSpec *statspec, Axis axis, byte plat_len, byte numtracks);
 
/* Allocate a StationSpec to a Station. This is called once per build operation. */
int AllocateSpecToStation(const StationSpec *statspec, BaseStation *st, bool exec);
 
/* Deallocate a StationSpec from a Station. Called when removing a single station tile. */
void DeallocateSpecFromStation(BaseStation *st, byte specindex);
 
/* Draw representation of a station tile for GUI purposes. */
bool DrawStationTile(int x, int y, RailType railtype, Axis axis, StationClassID sclass, uint station);
 
void AnimateStationTile(TileIndex tile);
void TriggerStationAnimation(BaseStation *st, TileIndex tile, StationAnimationTrigger trigger, CargoID cargo_type = INVALID_CARGO);
void TriggerStationRandomisation(Station *st, TileIndex tile, StationRandomTrigger trigger, CargoID cargo_type = INVALID_CARGO);
void StationUpdateCachedTriggers(BaseStation *st);
 
#endif /* NEWGRF_STATION_H */