diff --git a/src/base_station_base.h b/src/base_station_base.h new file mode 100644 --- /dev/null +++ b/src/base_station_base.h @@ -0,0 +1,192 @@ +/* $Id$ */ + +/** @file base_station_base.h Base classes/functions for base stations. */ + +#ifndef BASE_STATION_BASE_H +#define BASE_STATION_BASE_H + +#include "station_type.h" +#include "core/pool_type.hpp" +#include "town_type.h" +#include "strings_type.h" +#include "date_type.h" +#include "company_type.h" +#include "viewport_type.h" +#include "station_map.h" + +typedef Pool StationPool; +extern StationPool _station_pool; + +struct StationSpecList { + const StationSpec *spec; + uint32 grfid; ///< GRF ID of this custom station + uint8 localidx; ///< Station ID within GRF of station +}; + +/** Represents the covered area */ +struct TileArea { + TileIndex tile; ///< The base tile of the area + uint8 w; ///< The width of the area + uint8 h; ///< The height of the area +}; + +/** Base class for all station-ish types */ +struct BaseStation : StationPool::PoolItem<&_station_pool> { + TileIndex xy; ///< Base tile of the station + ViewportSign sign; ///< NOSAVE: Dimensions of sign + byte delete_ctr; ///< Delete counter. If greater than 0 then it is decremented until it reaches 0; the waypoint is then is deleted. + + char *name; ///< Custom name + StringID string_id; ///< Default name (town area) of station + + Town *town; ///< The town this station is associated with + OwnerByte owner; ///< The owner of this station + StationFacilityByte facilities; ///< The facilities that this station has + + uint8 num_specs; ///< Number of specs in the speclist + StationSpecList *speclist; ///< List of station specs of this station + + Date build_date; ///< Date of construction + + uint16 random_bits; ///< Random bits assigned to this station + byte waiting_triggers; ///< Waiting triggers (NewGRF) for this station + uint8 cached_anim_triggers; ///< NOSAVE: Combined animation trigger bitmask, used to determine if trigger processing should happen. + + BaseStation(TileIndex tile) : xy(tile) { } + + virtual ~BaseStation(); + + /** + * Check whether a specific tile belongs to this station. + * @param tile the tile to check + * @return true if the tile belongs to this station + */ + virtual bool TileBelongsToRailStation(TileIndex tile) const = 0; + + /** + * Helper function to get a NewGRF variable that isn't implemented by the base class. + * @param object the resolver object related to this query + * @param variable that is queried + * @param parameter parameter for that variable + * @param available will return false if ever the variable asked for does not exist + * @return the value stored in the corresponding variable + */ + virtual uint32 GetNewGRFVariable(const struct ResolverObject *object, byte variable, byte parameter, bool *available) const = 0; + + /** + * Update the coordinated of the sign (as shown in the viewport). + */ + virtual void UpdateVirtCoord() = 0; + + /** + * Get the tile area for a given station type. + * @param ta tile area to fill. + * @param type the type of the area + */ + virtual void GetTileArea(TileArea *ta, StationType type) const = 0; + + /** + * Get the base station belonging to a specific tile. + * @param tile The tile to get the base station from. + * @return the station associated with that tile. + */ + static FORCEINLINE BaseStation *GetByTile(TileIndex tile) + { + return BaseStation::Get(GetStationIndex(tile)); + } +}; + +#define FOR_ALL_BASE_STATIONS(var) FOR_ALL_ITEMS_FROM(BaseStation, station_index, var, 0) + +/** + * Class defining several overloaded accessors so we don't + * have to cast base stations that often + */ +template +struct SpecializedStation : public BaseStation { + static const StationFacility EXPECTED_FACIL = Tis_waypoint ? FACIL_WAYPOINT : FACIL_NONE; ///< Specialized type + + /** + * Set station type correctly + * @param tile The base tile of the station. + */ + FORCEINLINE SpecializedStation(TileIndex tile) : + BaseStation(tile) + { + this->facilities = EXPECTED_FACIL; + } + + /** + * Helper for checking whether the given station is of this type. + * @param st the station to check. + * @return true if the station is the type we expect it to be. + */ + static FORCEINLINE bool IsExpected(const BaseStation *st) + { + return (st->facilities & FACIL_WAYPOINT) == EXPECTED_FACIL; + } + + /** + * Tests whether given index is a valid index for station of this type + * @param index tested index + * @return is this index valid index of T? + */ + static FORCEINLINE bool IsValidID(size_t index) + { + return BaseStation::IsValidID(index) && IsExpected(BaseStation::Get(index)); + } + + /** + * Gets station with given index + * @return pointer to station with given index casted to T * + */ + static FORCEINLINE T *Get(size_t index) + { + return (T *)BaseStation::Get(index); + } + + /** + * Returns station if the index is a valid index for this station type + * @return pointer to station with given index if it's a station of this type + */ + static FORCEINLINE T *GetIfValid(size_t index) + { + return IsValidID(index) ? Get(index) : NULL ; + } + + /** + * Get the station belonging to a specific tile. + * @param tile The tile to get the station from. + * @return the station associated with that tile. + */ + static FORCEINLINE T *GetByTile(TileIndex tile) + { + return GetIfValid(GetStationIndex(tile)); + } + + /** + * Converts a BaseStation to SpecializedStation with type checking. + * @param st BaseStation pointer + * @return pointer to SpecializedStation + */ + static FORCEINLINE T *From(BaseStation *st) + { + assert(IsExpected(st)); + return (T *)st; + } + + /** + * Converts a const BaseStation to const SpecializedStation with type checking. + * @param st BaseStation pointer + * @return pointer to SpecializedStation + */ + static FORCEINLINE const T *From(const BaseStation *st) + { + assert(IsExpected(st)); + return (const T *)st; + } +}; + +#define FOR_ALL_BASE_STATIONS_OF_TYPE(name, var) FOR_ALL_ITEMS_FROM(name, station_index, var, 0) if (name::IsExpected(var)) + +#endif /* STATION_BASE_H */