32 template <
typename Tspec,
typename T
id, T
id Tmax>
36 classes[0].global_id =
'DFLT';
37 classes[0].name = STR_STATION_CLASS_DFLT;
38 classes[0].Insert(NULL);
40 classes[1].global_id =
'WAYP';
41 classes[1].name = STR_STATION_CLASS_WAYP;
42 classes[1].Insert(NULL);
45 template <
typename Tspec,
typename T
id, T
id Tmax>
65 default: NOT_REACHED();
112 Swap(platforms, length);
121 SB(retval, 0, 4, y & 0xF);
122 SB(retval, 4, 4, x & 0xF);
124 SB(retval, 0, 4,
min(15, y));
125 SB(retval, 4, 4,
min(15, length - y - 1));
126 SB(retval, 8, 4,
min(15, x));
127 SB(retval, 12, 4,
min(15, platforms - x - 1));
129 SB(retval, 16, 4,
min(15, length));
130 SB(retval, 20, 4,
min(15, platforms));
131 SB(retval, 24, 4, tile);
168 static uint32 GetPlatformInfoHelper(
TileIndex tile,
bool check_type,
bool check_axis,
bool centred)
170 int tx =
TileX(tile);
171 int ty =
TileY(tile);
184 static uint32 GetRailContinuationInfo(
TileIndex tile)
203 for (i = 0; i <
lengthof(x_dir); i++, dir++, diagdir++) {
234 return this->st == NULL ? 0 : this->st->waiting_triggers;
260 if (this->town_scope == NULL) {
262 if (this->station_scope.st != NULL) {
263 t = this->station_scope.st->town;
267 if (t == NULL)
return NULL;
268 this->town_scope =
new TownScopeResolver(*
this, t, this->station_scope.st == NULL);
270 return this->town_scope;
275 if (this->st == NULL) {
282 case 0x49:
return 0x2110000;
289 if (parameter != 0) tile =
GetNearbyTile(parameter, tile,
true, this->axis);
292 bool swap = (this->axis ==
AXIS_Y &&
HasBit(tileh, CORNER_W) !=
HasBit(tileh, CORNER_E));
308 if (!
HasBit(
_svc.valid, 0)) {
_svc.v40 = GetPlatformInfoHelper(this->tile,
false,
false,
false);
SetBit(
_svc.valid, 0); }
312 if (!
HasBit(
_svc.valid, 1)) {
_svc.v41 = GetPlatformInfoHelper(this->tile,
true,
false,
false);
SetBit(
_svc.valid, 1); }
323 if (!
HasBit(
_svc.valid, 3)) {
_svc.v46 = GetPlatformInfoHelper(this->tile,
false,
false,
true);
SetBit(
_svc.valid, 3); }
327 if (!
HasBit(
_svc.valid, 4)) {
_svc.v47 = GetPlatformInfoHelper(this->tile,
true,
false,
true);
SetBit(
_svc.valid, 4); }
331 if (!
HasBit(
_svc.valid, 5)) {
_svc.v49 = GetPlatformInfoHelper(this->tile,
false,
true,
false);
SetBit(
_svc.valid, 5); }
342 return this->st->TileBelongsToRailStation(tile) ?
GetAnimationFrame(tile) : UINT_MAX;
363 bool same_station = this->st->TileBelongsToRailStation(nearby_tile);
364 uint32 res =
GB(
GetStationGfx(nearby_tile), 1, 2) << 12 | !!perpendicular << 11 | !!same_station << 10;
374 case 0x82:
return 50;
375 case 0x84:
return this->st->string_id;
377 case 0xF0:
return this->st->facilities;
381 return this->st->GetNewGRFVariable(this->ro, variable, parameter, available);
384 uint32 Station::GetNewGRFVariable(
const ResolverObject &
object, byte variable, byte parameter,
bool *available)
const 391 for (cargo_type = 0; cargo_type <
NUM_CARGO; cargo_type++) {
397 case 0x8A:
return this->had_vehicle_of_type;
399 case 0xF2:
return (this->truck_stops != NULL) ? this->truck_stops->status : 0;
400 case 0xF3:
return (this->bus_stops != NULL) ? this->bus_stops->status : 0;
401 case 0xF6:
return this->airport.flags;
402 case 0xF7:
return GB(this->airport.flags, 8, 8);
406 if ((variable >= 0x60 && variable <= 0x65) || variable == 0x69) {
411 case 0x62:
return 0xFFFFFFFF;
412 case 0x64:
return 0xFF00;
435 if (variable >= 0x8C && variable <= 0xEC) {
436 const GoodsEntry *g = &this->goods[
GB(variable - 0x8C, 3, 4)];
437 switch (
GB(variable - 0x8C, 0, 3)) {
449 DEBUG(grf, 1,
"Unhandled station variable 0x%X", variable);
468 if (variable >= 0x60 && variable <= 0x65) {
473 if (variable >= 0x8C && variable <= 0xEC) {
474 switch (
GB(variable - 0x8C, 0, 3)) {
475 case 3:
return INITIAL_STATION_RATING;
476 case 4:
return INVALID_STATION;
481 DEBUG(grf, 1,
"Unhandled station variable 0x%X", variable);
489 if (this->station_scope.st == NULL || this->station_scope.statspec->cls_id ==
STAT_CLASS_WAYP) {
496 switch (this->station_scope.cargo_type) {
515 cargo =
min(0xfff, cargo);
517 if (cargo > this->station_scope.statspec->cargo_threshold) {
519 uint
set = ((cargo - this->station_scope.statspec->cargo_threshold) * group->
num_loading) / (4096 - this->station_scope.statspec->cargo_threshold);
524 uint
set = (cargo * group->
num_loaded) / (this->station_scope.statspec->cargo_threshold + 1);
525 return group->
loaded[
set];
542 CallbackID callback, uint32 callback_param1, uint32 callback_param2)
543 :
ResolverObject(statspec->grf_prop.grffile, callback, callback_param1, callback_param2),
544 station_scope(*this, statspec, st, tile), town_scope(NULL)
558 FOR_ALL_CARGOSPECS(cs) {
576 StationResolverObject::~StationResolverObject()
593 if (group == NULL || group->type != SGT_RESULT)
return 0;
594 return group->GetResult() - 0x42D;
612 if (group == NULL || group->type != SGT_RESULT)
return 0;
622 return object.ResolveCallback();
643 object.station_scope.axis = axis;
645 uint16 cb_res =
object.ResolveCallback();
667 if (statspec == NULL || st == NULL)
return 0;
673 if (i == NUM_STATIONSSPECS_PER_STATION) {
680 if (st->
speclist[i].spec == statspec)
return i;
719 if (specindex == 0)
return;
730 st->
speclist[specindex].spec = NULL;
771 if (statspec == NULL)
return false;
779 uint32 relocation = 0;
780 uint32 ground_relocation = 0;
785 sprites = GetStationTileLayout(STATION_RAIL, tile + axis);
787 layout = &statspec->
renderdata[(tile < statspec->
tiles) ? tile + axis : (uint)axis];
794 if (layout != NULL) {
805 sprites = &tmp_rail_layout;
822 DrawSprite(ground + overlay_offset, PAL_NONE, x, y);
853 const StationSpec *statspec = GetStationSpec(tile);
866 const StationSpec *statspec = GetStationSpec(tile);
869 return statspec != NULL ?
HasBit(statspec->
pylons, gfx) : gfx < 4;
880 const StationSpec *statspec = GetStationSpec(tile);
887 return GetStationCallback(callback, param1, param2, statspec, st, tile);
902 if (ss == NULL)
return;
910 static const TriggerArea tas[] = {
911 TA_TILE, TA_WHOLE, TA_WHOLE, TA_PLATFORM, TA_PLATFORM, TA_PLATFORM, TA_WHOLE
921 uint16 random_bits = Random();
951 static const TriggerArea tas[] = {
952 TA_WHOLE, TA_WHOLE, TA_PLATFORM, TA_PLATFORM, TA_PLATFORM, TA_PLATFORM
963 uint32 whole_reseed = 0;
966 uint32 empty_mask = 0;
984 if (ss == NULL)
continue;
997 if (group == NULL)
continue;
999 used_triggers |=
object.used_triggers;
1001 uint32
reseed =
object.GetReseedSum();
1008 random_bits &= ~reseed;
1009 random_bits |= Random() &
reseed;
1020 if ((whole_reseed & 0xFFFF) != 0) {
1037 for (uint i = 0; i < st->
num_specs; i++) {
Implementation of the NewGRF class' functions.
void TriggerStationRandomisation(Station *st, TileIndex tile, StationRandomTrigger trigger, CargoID cargo_type)
Trigger station randomisation.
static void Swap(T &a, T &b)
Type safe swap operation.
uint32 PaletteID
The number of the palette.
Callback 141 needs random bits.
Trigger station when cargo is completely taken.
Use callback to select a sprite layout to use.
NewGRF handling of rail types.
static const RailtypeInfo * GetRailTypeInfo(RailType railtype)
Returns a pointer to the Railtype information for a given railtype.
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
static bool IsCustomStationSpecIndex(TileIndex t)
Is there a custom rail station spec on this tile?
void DeallocateSpecFromStation(BaseStation *st, byte specindex)
Deallocate a StationSpec from a Station.
RailType
Enumeration for all possible railtypes.
Base class for roadstops.
bool HasVehicleEverTriedLoading() const
Reports whether a vehicle has ever tried to load the cargo at this station.
uint16 triggers
The triggers that trigger animation.
StationScopeResolver station_scope
The station scope resolver.
#define DAYS_TILL_ORIGINAL_BASE_YEAR
The offset in days from the '_date == 0' till 'ConvertYMDToDate(ORIGINAL_BASE_YEAR, 0, 1)'.
bool DrawStationTile(int x, int y, RailType railtype, Axis axis, StationClassID sclass, uint station)
Draw representation of a station tile for GUI purposes.
uint8 num_specs
Number of specs in the speclist.
int32 TileIndexDiff
An offset value between to tiles.
TownScopeResolver * GetTown()
Get the town scope associated with a station, if it exists.
static T ToggleBit(T &x, const uint8 y)
Toggles a bit in a variable.
static byte GetAnimationFrame(TileIndex t)
Get the current animation frame.
Functions related to debugging.
static T SetBit(T &x, const uint8 y)
Set a bit in a variable.
bool SplitGroundSpriteForOverlay(const TileInfo *ti, SpriteID *ground, RailTrackOffset *overlay_offset)
Check whether a sprite is a track sprite, which can be replaced by a non-track ground sprite and a ra...
bool CanStationTileHaveWires(TileIndex tile)
Check if a rail station tile shall have wires when electrified.
CargoID GetCargoTranslation(uint8 cargo, const GRFFile *grffile, bool usebit)
Translate a GRF-local cargo slot/bitnum into a CargoID.
Interface for SpriteGroup-s to access the gamestate.
uint32 GetTerrainType(TileIndex tile, TileContext context)
Function used by houses (and soon industries) to get information on type of "terrain" the tile it is ...
Set when cargo was delivered for final delivery during the current STATION_ACCEPTANCE_TICKS interval...
Specification of a cargo type.
Set when cargo was delivered for final delivery this month.
uint TotalCount() const
Returns total count of cargo at the station, including cargo which is already reserved for loading...
static uint TileX(TileIndex tile)
Get the X component of a tile.
TileArea train_station
Tile area the train 'station' part covers.
static bool IsExpected(const BaseStation *st)
Helper for checking whether the given station is of this type.
uint32 cargo_triggers
Bitmask of cargo types which cause trigger re-randomizing.
uint DaysInTransit() const
Returns average number of days in transit for a cargo entity.
Set when using the callback resolve system, but not to resolve a callback.
Stores station stats for a single cargo.
#define INSTANTIATE_NEWGRF_CLASS_METHODS(name, Tspec, Tid, Tmax)
Force instantiation of the methods so we don't get linker errors.
Northeast, upper right on your monitor.
const DrawTileSeqStruct * GetLayout(PalSpriteID *ground) const
Returns the result spritelayout after preprocessing.
virtual void GetTileArea(TileArea *ta, StationType type) const =0
Get the tile area for a given station type.
byte num_loaded
Number of loaded groups.
#define FOR_EACH_SET_BIT(bitpos_var, bitset_value)
Do an operation for each set set bit in a value.
Common return value for all commands.
uint32 reseed[VSG_END]
Collects bits to rerandomise while triggering triggers.
static void ChangeAnimationFrame(CallbackID cb, const StationSpec *spec, BaseStation *obj, TileIndex tile, uint32 random_bits, uint32 trigger, int extra_data=0)
Check a callback to determine what the next animation step is and execute that step.
bool IsUIAvailable(uint index) const
Check whether the spec will be available to the user at some point in time.
StationCargoList cargo
The cargo packets of cargo waiting in this station.
bool HasRating() const
Does this cargo have a rating at this station?
uint tiles
Number of tile layouts.
uint16 w
The width of the area.
Use a custom next frame callback.
uint32 GetVariable(byte variable, uint32 parameter, bool *available) const
Get a variable value.
void StationUpdateCachedTriggers(BaseStation *st)
Update the cached animation trigger bitmask for a station.
CommandCost GetErrorMessageFromLocationCallbackResult(uint16 cb_res, const GRFFile *grffile, StringID default_error)
Get the error message from a shape/location/slope check callback result.
GoodsEntry goods[NUM_CARGO]
Goods at this station.
static void AnimateTile(const StationSpec *spec, BaseStation *obj, TileIndex tile, bool random_animation, int extra_data=0)
Animate a single tile.
Direction
Defines the 8 directions on the map.
static T SB(T &x, const uint8 s, const uint8 n, const U d)
Set n bits in x starting at bit s to d.
static uint GetCustomStationSpecIndex(TileIndex t)
Get the custom station spec for this tile.
const DrawTileSeqStruct * seq
Array of child sprites. Terminated with a terminator entry.
Station is a waypoint (NewGRF only!)
static Station * From(BaseStation *st)
Converts a BaseStation to SpecializedStation with type checking.
This struct contains all the info that is needed to draw and construct tracks.
CompanyByte _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Callback done for each tile of a station to check the slope.
const SpriteGroup * root_spritegroup
Root SpriteGroup to use for resolving.
static bool HasStationRail(TileIndex t)
Has this station tile a rail? In other words, is this station tile a rail station or rail waypoint...
Set when cargo was delivered for final delivery last month.
Slope GetTileSlope(TileIndex tile, int *h)
Return the slope of a given tile inside the map.
static bool IsCompatibleTrainStationTile(TileIndex test_tile, TileIndex station_tile)
Check if a tile is a valid continuation to a railstation tile.
TrackBits
Bitfield corresponding to Track.
Town * ClosestTownFromTile(TileIndex tile, uint threshold)
Return the town closest (in distance or ownership) to a given tile, within a given threshold...
static void DrawRailTileSeqInGUI(int x, int y, const DrawTileSprites *dts, int32 total_offset, uint32 newgrf_offset, PaletteID default_palette)
Draw tile sprite sequence in GUI with railroad specifics.
Struct containing information relating to NewGRF classes for stations and airports.
byte pylons
Bitmask of base tiles (0 - 7) which should contain elrail pylons.
SpriteID GetCustomRailSprite(const RailtypeInfo *rti, TileIndex tile, RailTypeSpriteGroup rtsg, TileContext context, uint *num_results)
Get the sprite to draw for the given tile.
SpriteID GetCustomStationRelocation(const StationSpec *statspec, BaseStation *st, TileIndex tile, uint32 var10)
Resolve sprites for drawing a station tile.
static uint32 GetRegister(uint i)
Gets the value of a so-called newgrf "register".
byte rating
Station rating for this cargo.
static TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
virtual const SpriteGroup * Resolve(ResolverObject &object) const
Base sprite group resolver.
uint32 GetNewGRFVariable(const struct ResolverObject &object, byte variable, byte parameter, bool *available) const
Helper function to get a NewGRF variable that isn't implemented by the base class.
uint8 valid
Bits indicating what variable is valid (for each bit, 0 is invalid, 1 is valid).
static void SetStationTileRandomBits(TileIndex t, byte random_bits)
Set the random bits for a station tile.
TileIndex GetNearbyTile(byte parameter, TileIndex tile, bool signed_offsets, Axis axis)
Get the tile at the given offset.
static bool IsTileType(TileIndex tile, TileType type)
Checks if a tile is a give tiletype.
const SpriteGroup ** loaded
List of loaded groups (can be SpriteIDs or Callback results)
uint32 PrepareLayout(uint32 orig_offset, uint32 newgrf_ground_offset, uint32 newgrf_offset, uint constr_stage, bool separate_ground) const
Prepares a sprite layout before resolving action-1-2-3 chains.
Called to indicate how long the current animation frame should last.
static struct @31 _svc
Station variable cache This caches 'expensive' station variable lookups which iterate over several ti...
Customize the animation speed of the station.
uint32 GetRandomBits() const
Get a few random bits.
static bool HasStationReservation(TileIndex t)
Get the reservation state of the rail station.
static bool IsRailStationTile(TileIndex t)
Is this tile a station tile and a rail station?
Ground palette sprite of a tile, together with its sprite layout.
GRFFilePropsBase< NUM_CARGO+3 > grf_prop
Properties related the the grf file.
byte status
Status of this cargo, see GoodsEntryStatus.
static bool HasStationTileRail(TileIndex t)
Has this station tile a rail? In other words, is this station tile a rail station or rail waypoint...
#define TILE_AREA_LOOP(var, ta)
A loop which iterates over the tiles of a TileArea.
int AllocateSpecToStation(const StationSpec *statspec, BaseStation *st, bool exec)
Allocate a StationSpec to a Station.
Definition of base types and functions in a cross-platform compatible way.
Function implementations related to NewGRF animation.
A number of safeguards to prevent using unsafe methods.
Scope resolver for a town.
static PaletteID GroundSpritePaletteTransform(SpriteID image, PaletteID pal, PaletteID default_pal)
Applies PALETTE_MODIFIER_COLOUR to a palette entry of a ground sprite.
static Axis GetRailStationAxis(TileIndex t)
Get the rail direction of a rail station.
Called for periodically starting or stopping the animation.
uint32 used_triggers
Subset of cur_triggers, which actually triggered some rerandomisation. (scope independent) ...
void ProcessRegisters(uint8 resolved_var10, uint32 resolved_sprite, bool separate_ground) const
Evaluates the register modifiers and integrates them into the preprocessed sprite layout...
static TileIndex FindRailStationEnd(TileIndex tile, TileIndexDiff delta, bool check_type, bool check_axis)
Find the end of a railway station, from the tile, in the direction of delta.
Represents the covered area of e.g.
static T * ReallocT(T *t_ptr, size_t num_elements)
Simplified reallocation function that allocates the specified number of elements of the given type...
Set when a sprite originates from an Action 1.
StationSpecList * speclist
List of station specs of this station.
StationCallbackMask
Callback masks for stations.
const SpriteGroup * ResolveReal(const RealSpriteGroup *group) const
Get the real sprites of the grf.
byte wires
Bitmask of base tiles (0 - 7) which should contain elrail wires.
const SpriteGroup ** loading
List of loading groups (can be SpriteIDs or Callback results)
TownScopeResolver * town_scope
The town scope resolver (created on the first call).
uint8 cargo_map[NUM_CARGO]
Inverse cargo translation table (CargoID -> local ID)
DiagDirection
Enumeration for diagonal directions.
#define lengthof(x)
Return the length of an fixed size array.
byte last_speed
Maximum speed (up to 255) of the last vehicle that tried to load this cargo.
uint8 cached_anim_triggers
NOSAVE: Combined animation trigger bitmask, used to determine if trigger processing should happen...
static T min(const T a, const T b)
Returns the minimum of two values.
uint32 cached_cargo_triggers
NOSAVE: Combined cargo trigger bitmask.
NewGRF supplied spritelayout.
static DiagDirection GetTunnelBridgeDirection(TileIndex t)
Get the direction pointing to the other end.
byte last_age
Age in years (up to 255) of the last vehicle that tried to load this cargo.
const struct SpriteGroup * spritegroup[Tcnt]
pointer to the different sprites of the entity
static StationGfx GetStationGfx(TileIndex t)
Get the station graphics of this tile.
east and west corner are raised
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
static T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
static TrackBits DiagdirReachesTracks(DiagDirection diagdir)
Returns all tracks that can be reached when entering a tile from a given (diagonal) direction...
#define DEBUG(name, level,...)
Output a line of debugging information.
Maximal number of cargo types in a game.
TileIndex tile
The base tile of the area.
byte flags
Bitmask of flags, bit 0: use different sprite set; bit 1: divide cargo about by station size...
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset)
Mark a tile given by its index dirty for repaint.
SpriteID GetCustomStationFoundationRelocation(const StationSpec *statspec, BaseStation *st, TileIndex tile, uint layout, uint edge_info)
Resolve the sprites for custom station foundations.
StationAnimationTrigger
Animation triggers for station.
byte num_loading
Number of loading groups.
Set when a vehicle ever delivered cargo to the station for final delivery.
static BaseStation * GetByTile(TileIndex tile)
Get the base station belonging to a specific tile.
CargoID cargo_type
Type of cargo of the station.
Functions related to companies.
const struct StationSpec * statspec
Station (type) specification.
static StationID GetStationIndex(TileIndex t)
Get StationID from a tile.
PalSpriteID ground
Palette and sprite for the ground.
Header file for NewGRF stations.
struct BaseStation * st
Instance of the station.
StationID Source() const
Returns source of the first cargo packet in this list.
bool IsStationTileBlocked(TileIndex tile)
Check whether a rail station tile is NOT traversable.
CommandCost PerformStationTileSlopeCheck(TileIndex north_tile, TileIndex cur_tile, const StationSpec *statspec, Axis axis, byte plat_len, byte numtracks)
Check the slope of a tile of a new station.
Tunnel entry/exit and bridge heads.
bool NeedsPreprocessing() const
Tests whether this spritelayout needs preprocessing by PrepareLayout() and ProcessRegisters(), or whether it can be used directly.
uint32 SpriteID
The number of a sprite, without mapping bits and colourtables.
uint32 GetNearbyTileInformation(TileIndex tile, bool grf_version8)
Common part of station var 0x67, house var 0x62, indtile var 0x60, industry var 0x62.
CompanyByte _current_company
Company currently doing an action.
uint32 TileIndex
The index/ID of a Tile.
Use different sprite set for ground sprites.
Helper class for a unified approach to NewGRF animation.
uint32 GetPlatformInfo(Axis axis, byte tile, int platforms, int length, int x, int y, bool centred)
Evaluate a tile's position within a station, and return the result in a bit-stuffed format...
virtual bool TileBelongsToRailStation(TileIndex tile) const =0
Check whether a specific tile belongs to this station.
Cargo support for NewGRFs.
byte fallback_railtype
Original railtype number to use when drawing non-newgrf railtypes, or when drawing stations...
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Called to determine station tile next animation frame.
CallbackID callback
Callback being resolved.
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
uint16 GetAnimStationCallback(CallbackID callback, uint32 param1, uint32 param2, const StationSpec *statspec, BaseStation *st, TileIndex tile, int extra_data)
Wrapper for animation control, see #GetStationCallback.
bool TileBelongsToRailStation(TileIndex tile) const
Check whether a specific tile belongs to this station.
Slope
Enumeration for the slope-type.
uint32 GetCompanyInfo(CompanyID owner, const Livery *l)
Returns company information like in vehicle var 43 or station var 43.
static Station * GetByTile(TileIndex tile)
Get the station belonging to a specific tile.
static TrackBits TrackStatusToTrackBits(TrackStatus ts)
Returns the present-track-information of a TrackStatus.
bool CanStationTileHavePylons(TileIndex tile)
Check if a rail station tile shall have pylons when electrified.
Main group of ground images.
static NewGRFClass * Get(Tid cls_id)
Get a particular class.
uint8 GetReverseRailTypeTranslation(RailType railtype, const GRFFile *grffile)
Perform a reverse railtype lookup to get the GRF internal ID.
uint GetRailtypeSpriteOffset() const
Offset between the current railtype and normal rail.
static TileIndexDiff TileOffsByDir(Direction dir)
Convert a Direction to a TileIndexDiff.
CargoID Index() const
Determines index of this cargospec.
uint8 localidx
Station ID within GRF of station.
uint16 local_id
id defined by the grf file for this entity
Maximum number of classes.
static void InsertDefaults()
Initialise the defaults.
Functions that have tunnels and bridges in common.
static TileIndexDiff TileDiffXY(int x, int y)
Calculates an offset for the given coordinate(-offset).
uint16 random_bits
Random bits assigned to this station.
static void free(const void *ptr)
Version of the standard free that accepts const pointers.
StationRandomTrigger
Randomisation triggers for stations.
RailTrackOffset
Offsets for sprites within an overlay/underlay set.
const struct GRFFile * grffile
grf file that introduced this entity
CallbackID
List of implemented NewGRF callbacks.
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Functions related to NewGRF provided sounds.
Set when calling a randomizing trigger (almost undocumented).
byte callback_mask
Bitmask of station callbacks that have to be called.
static const TileIndex INVALID_TILE
The very nice invalid tile marker.
StationResolverObject(const StationSpec *statspec, BaseStation *st, TileIndex tile, CallbackID callback=CBID_NO_CALLBACK, uint32 callback_param1=0, uint32 callback_param2=0)
Resolver for stations.
Functions to handle the town part of NewGRF towns.
Choose a sprite layout to draw, instead of the standard 0-7 range.
byte CargoID
Cargo slots to indicate a cargo type within a game.
NewGRFSpriteLayout * renderdata
Array of tile layouts.
byte waiting_triggers
Waiting triggers (NewGRF) for this station.
Divide cargo amount by station size.
byte time_since_pickup
Number of rating-intervals (up to 255) since the last vehicle tried to load this cargo.
static DiagDirection AxisToDiagDir(Axis a)
Converts an Axis to a DiagDirection.
#define TILE_ADD(x, y)
Adds to tiles together.
Flag for an invalid Axis.
SpriteID sprite
The 'real' sprite.
static const uint NUM_STATIONSSPECS_PER_STATION
Maximum number of parts per station.
Base classes/functions for stations.
Date _date
Current date in days (day counter)
Helper class for animation control.
uint16 h
The height of the area.
static byte GetStationTileRandomBits(TileIndex t)
Get the random bits of a station tile.
Base class for all station-ish types.
Axis
Allow incrementing of DiagDirDiff variables.
Set when the station accepts the cargo currently for final deliveries.
uint32 GetTriggers() const
Get the triggers.
void DrawSprite(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub, ZoomLevel zoom)
Draw a sprite, not in a viewport.
static RailType GetRailType(TileIndex t)
Gets the rail type of the given tile.
byte blocked
Bitmask of base tiles (0 - 7) which are blocked to trains.
uint32 grfid
GRF ID of this custom station.
PaletteID pal
The palette (use PAL_NONE) if not needed)