50static const uint NUM_ROADSTOPSPECS_PER_STATION = 63;
54 if (this->
st ==
nullptr)
return 0;
70 auto get_road_type_variable = [&](RoadTramType rtt) -> uint32_t {
75 rt = GetRoadType(this->
tile, rtt);
86 case 0x40:
return this->
view;
90 if (this->
type == StationType::Bus)
return 0;
91 if (this->
type == StationType::Truck)
return 1;
98 case 0x43:
return get_road_type_variable(RTT_ROAD);
101 case 0x44:
return get_road_type_variable(RTT_TRAM);
161 uint32_t res =
GetStationGfx(nearby_tile) << 12 | !same_orientation << 11 | !!same_station << 10;
163 if (
type == StationType::Truck) res |= (1 << 16);
164 if (
type == StationType::RoadWaypoint) res |= (2 << 16);
169 res |= 1 << (sm.grfid != grfid ? 9 : 8) | ClampTo<uint8_t>(sm.localidx);
197 if (sm.grfid == grfid) {
219 if (group ==
nullptr)
return nullptr;
225 CallbackID callback, uint32_t param1, uint32_t param2)
226 :
ResolverObject(roadstopspec->grf_prop.grffile, callback, param1, param2), roadstop_scope(*this, st, roadstopspec, tile, roadtype, type, view)
237 for (
const auto &[cargo, spritegroup] : roadstopspec->grf_prop.spritegroups) {
269 if (t ==
nullptr)
return nullptr;
278 return object.ResolveCallback();
293 assert(spec !=
nullptr);
298 if (group ==
nullptr || group->type != SGT_TILELAYOUT)
return;
310 draw_mode = spec->draw_mode;
313 if (type == StationType::RoadWaypoint) {
314 DrawSprite(SPR_ROAD_PAVED_STRAIGHT_X, PAL_NONE, x, y);
324 uint sprite_offset = 5 - view;
328 if (rti->UsesOverlay()) {
330 DrawSprite(ground + sprite_offset, PAL_NONE, x, y);
333 if (overlay)
DrawSprite(overlay + sprite_offset, PAL_NONE, x, y);
334 }
else if (RoadTypeIsTram(roadtype)) {
335 DrawSprite(SPR_TRAMWAY_TRAM + sprite_offset, PAL_NONE, x, y);
356 static uint8_t Get(
BaseStation *st,
TileIndex tile) {
return st->GetRoadStopAnimationFrame(tile); }
357 static bool Set(
BaseStation *st,
TileIndex tile, uint8_t frame) {
return st->SetRoadStopAnimationFrame(tile, frame); }
372 if (ss ==
nullptr)
return;
386 uint16_t random_bits =
Random();
387 auto process_tile = [&](
TileIndex cur_tile) {
392 cargo = INVALID_CARGO;
402 process_tile(tile_data.tile);
405 process_tile(trigger_tile);
428 uint32_t whole_reseed = 0;
433 uint32_t used_triggers = 0;
434 auto process_tile = [&](
TileIndex cur_tile) {
436 if (ss ==
nullptr)
return;
449 if (group ==
nullptr)
return;
451 used_triggers |=
object.used_triggers;
453 uint32_t reseed =
object.GetReseedSum();
455 whole_reseed |= reseed;
459 uint8_t random_bits = st->GetRoadStopRandomBits(cur_tile);
460 random_bits &= ~reseed;
461 random_bits |=
Random() & reseed;
462 st->SetRoadStopRandomBits(cur_tile, random_bits);
470 process_tile(tile_data.tile);
478 if ((whole_reseed & 0xFFFF) != 0) {
497 if (GetIfClassHasNewStopsByType(&cls, rs, roadtype))
return true;
511 for (
const auto spec : roadstopclass->
Specs()) {
512 if (GetIfStopIsForType(spec, rs, roadtype))
return true;
527 if (roadstopspec ==
nullptr)
return true;
562 if (statspec ==
nullptr || st ==
nullptr)
return 0;
565 for (i = 1; i < st->
roadstop_speclist.size() && i < NUM_ROADSTOPSPECS_PER_STATION; i++) {
570 for (i = 1; i < st->
roadstop_speclist.size() && i < NUM_ROADSTOPSPECS_PER_STATION; i++) {
574 if (i == NUM_ROADSTOPSPECS_PER_STATION) {
585 RoadStopUpdateCachedTriggers(st);
591void DeallocateSpecFromRoadStop(
BaseStation *st, uint8_t specindex)
594 if (specindex == 0)
return;
625 RoadStopUpdateCachedTriggers(st);
639 for (
const auto &sm : GetStationSpecList<RoadStopSpec>(st)) {
640 if (sm.spec ==
nullptr)
continue;
debug_inline constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
constexpr T SetBit(T &x, const uint8_t y)
Set a bit in a variable.
debug_inline static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
uint8_t CargoType
Cargo slots to indicate a cargo type within a game.
bool IsValidCargoType(CargoType t)
Test whether cargo type is not INVALID_CARGO.
constexpr bool Test(Tvalue_type value) const
Test if the value-th bit is set.
constexpr Tstorage base() const noexcept
Retrieve the raw value behind this bit set.
Struct containing information relating to NewGRF classes for stations and airports.
static std::span< NewGRFClass< Tspec, Tindex, Tmax > const > Classes()
Get read-only span of all classes of this type.
StringID name
Name of this class.
bool IsUIAvailable(uint index) const
Check whether the spec will be available to the user at some point in time.
void Insert(Tspec *spec)
Insert a spec into the class, and update its index.
std::span< Tspec *const > Specs() const
Get read-only span of specs of this class.
static NewGRFClass * Get(Tindex class_index)
Get a particular class.
static Tindex Allocate(uint32_t global_id)
Allocate a class with a given global class ID.
static void InsertDefaults()
Initialise the defaults.
uint TotalCount() const
Returns total count of cargo at the station, including cargo which is already reserved for loading.
static Date date
Current date in days (day counter).
static constexpr TimerGame< struct Calendar >::Date DAYS_TILL_ORIGINAL_BASE_YEAR
The date of the first day of the original base year.
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
CompanyID _current_company
Company currently doing an action.
Functions related to companies.
Functions related to debugging.
void DrawSprite(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub, ZoomLevel zoom)
Draw a sprite, not in a viewport.
Types related to the graphics and/or input devices.
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
uint32_t PaletteID
The number of the palette.
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
@ Random
Randomise borders.
uint DistanceSquare(TileIndex t0, TileIndex t1)
Gets the 'Square' distance between the two given tiles.
uint DistanceManhattan(TileIndex t0, TileIndex t1)
Gets the Manhattan distance between the two given tiles.
static constexpr CargoType SG_PURCHASE
Used in purchase lists before an item exists.
static constexpr CargoType SG_DEFAULT
Default type used when no more-specific cargo matches.
static constexpr CargoType SG_DEFAULT_NA
Used only by stations and roads when no more-specific cargo matches.
Function implementations related to NewGRF animation.
StationAnimationTrigger
Animation triggers for station.
@ SAT_CARGO_TAKEN
Trigger station when cargo is completely taken.
@ SAT_NEW_CARGO
Trigger station on new cargo arrival.
@ SAT_250_TICKS
Trigger station every 250 ticks.
uint32_t GetBadgeVariableResult(const GRFFile &grffile, std::span< const BadgeID > badges, uint32_t parameter)
Test for a matching badge in a list of badges, returning the number of matching bits.
Functions related to NewGRF badges.
CallbackID
List of implemented NewGRF callbacks.
@ CBID_STATION_ANIMATION_SPEED
Called to indicate how long the current animation frame should last.
@ CBID_STATION_ANIM_START_STOP
Called for periodically starting or stopping the animation.
@ CBID_STATION_ANIM_NEXT_FRAME
Called to determine station tile next animation frame.
RoadStopCallbackMask
Callback masks for road stops.
@ AnimationNextFrame
Use a custom next frame callback.
@ AnimationSpeed
Customize the animation speed of the road stop.
Cargo support for NewGRFs.
Implementation of the NewGRF class' functions.
uint32_t GetCompanyInfo(CompanyID owner, const Livery *l)
Returns company information like in vehicle var 43 or station var 43.
uint32_t GetNearbyTileInformation(TileIndex tile, bool grf_version8)
Common part of station var 0x67, house var 0x62, indtile var 0x60, industry var 0x62.
uint32_t GetTerrainType(TileIndex tile, TileContext context)
Function used by houses (and soon industries) to get information on type of "terrain" the tile it is ...
TileIndex GetNearbyTile(uint8_t parameter, TileIndex tile, bool signed_offsets, Axis axis)
Get the tile at the given offset.
@ TCX_NORMAL
Nothing special.
NewGRF definitions and structures for road stops.
RoadStopDrawMode
Different draw modes to disallow rendering of some parts of the stop or road.
@ Overlay
Drive-through stops: Draw the road overlay, e.g. pavement.
@ WaypGround
Waypoints: Draw the sprite layout ground tile (on top of the road)
@ Road
Bay stops: Draw the road itself.
bool IsWaypointClass(const RoadStopClass &cls)
Test if a RoadStopClass is the waypoint class.
@ RSRT_CARGO_TAKEN
Trigger roadstop when cargo is completely taken.
@ RSRT_NEW_CARGO
Trigger roadstop on arrival of new cargo.
@ ROADSTOP_CLASS_DFLT
Default road stop class.
@ ROADSTOPTYPE_FREIGHT
This RoadStop is for freight (truck) stops.
@ ROADSTOPTYPE_ALL
This RoadStop is for both types of station road stops.
@ ROADSTOPTYPE_PASSENGER
This RoadStop is for passenger (bus) stops.
@ RoadOnly
Only show in the road build menu (not tram).
@ Cb141RandomBits
Callback 141 needs random bits.
@ TramOnly
Only show in the tram build menu (not road).
@ DrawModeRegister
Read draw mode from register 0x100.
SpriteID GetCustomRoadSprite(const RoadTypeInfo *rti, TileIndex tile, RoadTypeSpriteGroup rtsg, TileContext context, uint *num_results)
Get the sprite to draw for the given tile.
uint8_t GetReverseRoadTypeTranslation(RoadType roadtype, const GRFFile *grffile)
Perform a reverse roadtype lookup to get the GRF internal ID.
NewGRF handling of road types.
Functions related to NewGRF provided sounds.
uint32_t GetRegister(uint i)
Gets the value of a so-called newgrf "register".
const RoadTypeInfo * GetRoadTypeInfo(RoadType roadtype)
Returns a pointer to the Roadtype information for a given roadtype.
@ ROTSG_OVERLAY
Optional: Images for overlaying track.
@ ROTSG_ROADSTOP
Required: Bay stop surface.
@ ROTSG_GROUND
Required: Main group of ground images.
RoadType
The different roadtypes we support.
@ INVALID_ROADTYPE
flag for invalid roadtype
Base class for roadstops.
A number of safeguards to prevent using unsafe methods.
void DrawCommonTileSeqInGUI(int x, int y, const DrawTileSprites *dts, int32_t orig_offset, uint32_t newgrf_offset, PaletteID default_palette, bool child_offset_is_unsigned)
Draws a tile sprite sequence in the GUI.
PaletteID GroundSpritePaletteTransform(SpriteID image, PaletteID pal, PaletteID default_pal)
Applies PALETTE_MODIFIER_COLOUR to a palette entry of a ground sprite.
static constexpr uint8_t SPRITE_WIDTH
number of bits for the sprite number
Base classes/functions for stations.
CargoTypes GetEmptyMask(const Station *st)
Get a mask of the cargo types that are empty at the station.
StationType GetStationType(Tile t)
Get the station type of this tile.
StationGfx GetStationGfx(Tile t)
Get the station graphics of this tile.
uint GetCustomRoadStopSpecIndex(Tile t)
Get the custom road stop spec for this tile.
StationID GetStationIndex(Tile t)
Get StationID from a tile.
bool IsCustomRoadStopSpecIndex(Tile t)
Is there a custom road stop spec on this tile?
bool IsAnyRoadStopTile(Tile t)
Is tile t a road stop station?
RoadStopType
Types of RoadStops.
@ Bus
A standard stop for buses.
@ Truck
A standard stop for trucks.
StationType
Station types.
Definition of base types and functions in a cross-platform compatible way.
Helper class for a unified approach to NewGRF animation.
static void AnimateTile(const RoadStopSpec *spec, BaseStation *obj, TileIndex tile, bool random_animation, int extra_data=0)
Animate a single tile.
static void ChangeAnimationFrame(CallbackID cb, const RoadStopSpec *spec, BaseStation *obj, TileIndex tile, uint32_t random_bits, uint32_t trigger, int extra_data=0)
Check a callback to determine what the next animation step is and execute that step.
uint16_t triggers
The triggers that trigger animation.
Base class for all station-ish types.
virtual uint32_t GetNewGRFVariable(const struct ResolverObject &object, uint8_t variable, uint8_t parameter, bool &available) const =0
Helper function to get a NewGRF variable that isn't implemented by the base class.
std::vector< SpecMapping< RoadStopSpec > > roadstop_speclist
List of road stop specs of this station.
StationFacilities facilities
The facilities that this station has.
uint8_t cached_roadstop_anim_triggers
NOSAVE: Combined animation trigger bitmask for road stops, used to determine if trigger processing sh...
Owner owner
The owner of this station.
Town * town
The town this station is associated with.
static BaseStation * GetByTile(TileIndex tile)
Get the base station belonging to a specific tile.
CargoTypes cached_roadstop_cargo_triggers
NOSAVE: Combined cargo trigger bitmask for road stops.
uint16_t random_bits
Random bits assigned to this station.
std::vector< RoadStopTileData > custom_roadstop_tile_data
List of custom road stop tile data.
uint8_t waiting_triggers
Waiting triggers (NewGRF) for this station.
TimerGameCalendar::Date build_date
Date of construction.
Ground palette sprite of a tile, together with its sprite layout.
PalSpriteID ground
Palette and sprite for the ground.
const struct GRFFile * grffile
grf file that introduced this entity
uint16_t local_id
id defined by the grf file for this entity
uint32_t grfid
grfid that introduced this entity.
std::array< uint8_t, NUM_CARGO > cargo_map
Inverse cargo translation table (CargoType -> local ID)
StationCargoList cargo
The cargo packets of cargo waiting in this station.
debug_inline const GoodsEntryData & GetData() const
Get optional cargo packet/flow data.
SpriteID sprite
The 'real' sprite.
PaletteID pal
The palette (use PAL_NONE) if not needed)
Tindex index
Index of this pool item.
std::vector< const SpriteGroup * > loading
List of loading groups (can be SpriteIDs or Callback results)
Interface for SpriteGroup-s to access the gamestate.
const GRFFile * grffile
GRFFile the resolved SpriteGroup belongs to.
const SpriteGroup * root_spritegroup
Root SpriteGroup to use for resolving.
Helper class for animation control.
const SpriteGroup * ResolveReal(const RealSpriteGroup *group) const override
Get the real sprites of the grf.
std::optional< TownScopeResolver > town_scope
The town scope resolver (created on the first call).
RoadStopScopeResolver roadstop_scope
The stop scope resolver.
uint8_t view
Station axis.
uint32_t GetTriggers() const override
Get the triggers.
RoadType roadtype
Road type (used when no tile)
uint32_t GetVariable(uint8_t variable, uint32_t parameter, bool &available) const override
Get a variable value.
StationType type
Station type.
const struct RoadStopSpec * roadstopspec
Station (type) specification.
struct BaseStation * st
Instance of the station.
CargoType cargo_type
Type of cargo of the station.
TileIndex tile
Tile of the station.
uint32_t GetRandomBits() const override
Get a few random bits.
CargoTypes cargo_triggers
Bitmask of cargo types which cause trigger re-randomizing.
VariableGRFFileProps grf_prop
Properties related the the grf file.
ResolverObject & ro
Surrounding resolver object.
static bool IsExpected(const BaseStation *st)
Helper for checking whether the given station is of this type.
static Station * From(BaseStation *st)
Converts a BaseStation to SpecializedStation with type checking.
virtual const SpriteGroup * Resolve(ResolverObject &object) const
Base sprite group resolver.
GoodsEntry goods[NUM_CARGO]
Goods at this station.
Action 2 sprite layout for houses, industry tiles, objects and airport tiles.
Scope resolver for a town.
TileIndex xy
town center tile
const struct SpriteGroup * GetSpriteGroup(size_t index) const
Get the SpriteGroup at the specified index.
Slope GetTileSlope(TileIndex tile)
Return the slope of a given tile inside the map.
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition of the game-calendar-timer.
HouseZonesBits GetTownRadiusGroup(const Town *t, TileIndex tile)
Returns the bit corresponding to the town zone of the specified tile.
Town * ClosestTownFromTile(TileIndex tile, uint threshold)
Return the town closest (in distance or ownership) to a given tile, within a given threshold.
Functions related to (drawing on) viewports.
Types related to windows.