/* $Id$ */
/*
* 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 .
*/
/** @file station_base.h Base classes/functions for stations. */
#ifndef STATION_BASE_H
#define STATION_BASE_H
#include "base_station_base.h"
#include "newgrf_airport.h"
#include "cargopacket.h"
#include "industry_type.h"
#include "newgrf_storage.h"
typedef Pool StationPool;
extern StationPool _station_pool;
static const byte INITIAL_STATION_RATING = 175;
/**
* Stores station stats for a single cargo.
*/
struct GoodsEntry {
/** Status of this cargo for the station. */
enum GoodsEntryStatus {
/**
* Set when the station accepts the cargo currently for final deliveries.
* It is updated every STATION_ACCEPTANCE_TICKS ticks by checking surrounding tiles for acceptance >= 8/8.
*/
GES_ACCEPTANCE,
/**
* Set when the cargo was ever waiting at the station.
* It is set when cargo supplied by surrounding tiles is moved to the station, or when
* arriving vehicles unload/transfer cargo without it being a final delivery.
* This also indicates, whether a cargo has a rating at the station.
* This flag is never cleared.
*/
GES_PICKUP,
/**
* Set when a vehicle ever delivered cargo to the station for final delivery.
* This flag is never cleared.
*/
GES_EVER_ACCEPTED,
/**
* Set when cargo was delivered for final delivery last month.
* This flag is set to the value of GES_CURRENT_MONTH at the start of each month.
*/
GES_LAST_MONTH,
/**
* Set when cargo was delivered for final delivery this month.
* This flag is reset on the beginning of every month.
*/
GES_CURRENT_MONTH,
/**
* Set when cargo was delivered for final delivery during the current STATION_ACCEPTANCE_TICKS interval.
* This flag is reset every STATION_ACCEPTANCE_TICKS ticks.
*/
GES_ACCEPTED_BIGTICK,
};
GoodsEntry() :
acceptance_pickup(0),
time_since_pickup(255),
rating(INITIAL_STATION_RATING),
last_speed(0),
last_age(255)
{}
byte acceptance_pickup; ///< Status of this cargo, see #GoodsEntryStatus.
/**
* Number of rating-intervals (up to 255) since the last vehicle tried to load this cargo.
* The unit used is STATION_RATING_TICKS.
* This does not imply there was any cargo to load.
*/
byte time_since_pickup;
byte rating; ///< %Station rating for this cargo.
/**
* Maximum speed (up to 255) of the last vehicle that tried to load this cargo.
* This does not imply there was any cargo to load.
* The unit used is a special vehicle-specific speed unit for station ratings.
* - Trains: km-ish/h
* - RV: km-ish/h
* - Ships: 0.5 * km-ish/h
* - Aircraft: 8 * mph
*/
byte last_speed;
/**
* Age in years (up to 255) of the last vehicle that tried to load this cargo.
* This does not imply there was any cargo to load.
*/
byte last_age;
byte amount_fract; ///< Fractional part of the amount in the cargo list
StationCargoList cargo; ///< The cargo packets of cargo waiting in this station
/**
* Reports whether a vehicle has ever tried to load the cargo at this station.
* This does not imply that there was cargo available for loading. Refer to GES_PICKUP for that.
* @return true if vehicle tried to load.
*/
bool HasVehicleEverTriedLoading() const { return this->last_speed != 0; }
/**
* Does this cargo have a rating at this station?
* @return true if the cargo has a rating, i.e. pickup has been attempted.
*/
inline bool HasRating() const
{
return HasBit(this->acceptance_pickup, GES_PICKUP);
}
};
/** All airport-related information. Only valid if tile != INVALID_TILE. */
struct Airport : public TileArea {
Airport() : TileArea(INVALID_TILE, 0, 0) {}
uint64 flags; ///< stores which blocks on the airport are taken. was 16 bit earlier on, then 32
byte type; ///< Type of this airport, @see AirportTypes
byte layout; ///< Airport layout number.
Direction rotation; ///< How this airport is rotated.
PersistentStorage *psa; ///< Persistent storage for NewGRF airports.
/**
* Get the AirportSpec that from the airport type of this airport. If there
* is no airport (\c tile == INVALID_TILE) then return the dummy AirportSpec.
* @return The AirportSpec for this airport.
*/
const AirportSpec *GetSpec() const
{
if (this->tile == INVALID_TILE) return &AirportSpec::dummy;
return AirportSpec::Get(this->type);
}
/**
* Get the finite-state machine for this airport or the finite-state machine
* for the dummy airport in case this isn't an airport.
* @pre this->type < NEW_AIRPORT_OFFSET.
* @return The state machine for this airport.
*/
const AirportFTAClass *GetFTA() const
{
return this->GetSpec()->fsm;
}
/** Check if this airport has at least one hangar. */
inline bool HasHangar() const
{
return this->GetSpec()->nof_depots > 0;
}
/**
* Add the tileoffset to the base tile of this airport but rotate it first.
* The base tile is the northernmost tile of this airport. This function
* helps to make sure that getting the tile of a hangar works even for
* rotated airport layouts without requiring a rotated array of hangar tiles.
* @param tidc The tilediff to add to the airport tile.
* @return The tile of this airport plus the rotated offset.
*/
inline TileIndex GetRotatedTileFromOffset(TileIndexDiffC tidc) const
{
const AirportSpec *as = this->GetSpec();
switch (this->rotation) {
case DIR_N: return this->tile + ToTileIndexDiff(tidc);
case DIR_E: return this->tile + TileDiffXY(tidc.y, as->size_x - 1 - tidc.x);
case DIR_S: return this->tile + TileDiffXY(as->size_x - 1 - tidc.x, as->size_y - 1 - tidc.y);
case DIR_W: return this->tile + TileDiffXY(as->size_y - 1 - tidc.y, tidc.x);
default: NOT_REACHED();
}
}
/**
* Get the first tile of the given hangar.
* @param hangar_num The hangar to get the location of.
* @pre hangar_num < GetNumHangars().
* @return A tile with the given hangar.
*/
inline TileIndex GetHangarTile(uint hangar_num) const
{
const AirportSpec *as = this->GetSpec();
for (uint i = 0; i < as->nof_depots; i++) {
if (as->depot_table[i].hangar_num == hangar_num) {
return this->GetRotatedTileFromOffset(as->depot_table[i].ti);
}
}
NOT_REACHED();
}
/**
* Get the exit direction of the hangar at a specific tile.
* @param tile The tile to query.
* @pre IsHangarTile(tile).
* @return The exit direction of the hangar, taking airport rotation into account.
*/
inline Direction GetHangarExitDirection(TileIndex tile) const
{
const AirportSpec *as = this->GetSpec();
const HangarTileTable *htt = GetHangarDataByTile(tile);
return ChangeDir(htt->dir, DirDifference(this->rotation, as->rotation[0]));
}
/**
* Get the hangar number of the hangar at a specific tile.
* @param tile The tile to query.
* @pre IsHangarTile(tile).
* @return The hangar number of the hangar at the given tile.
*/
inline uint GetHangarNum(TileIndex tile) const
{
const HangarTileTable *htt = GetHangarDataByTile(tile);
return htt->hangar_num;
}
/** Get the number of hangars on this airport. */
inline uint GetNumHangars() const
{
uint num = 0;
uint counted = 0;
const AirportSpec *as = this->GetSpec();
for (uint i = 0; i < as->nof_depots; i++) {
if (!HasBit(counted, as->depot_table[i].hangar_num)) {
num++;
SetBit(counted, as->depot_table[i].hangar_num);
}
}
return num;
}
private:
/**
* Retrieve hangar information of a hangar at a given tile.
* @param tile %Tile containing the hangar.
* @return The requested hangar information.
* @pre The \a tile must be at a hangar tile at an airport.
*/
inline const HangarTileTable *GetHangarDataByTile(TileIndex tile) const
{
const AirportSpec *as = this->GetSpec();
for (uint i = 0; i < as->nof_depots; i++) {
if (this->GetRotatedTileFromOffset(as->depot_table[i].ti) == tile) {
return as->depot_table + i;
}
}
NOT_REACHED();
}
};
typedef SmallVector IndustryVector;
/** Station data structure */
struct Station FINAL : SpecializedStation {
public:
RoadStop *GetPrimaryRoadStop(RoadStopType type) const
{
return type == ROADSTOP_BUS ? bus_stops : truck_stops;
}
RoadStop *GetPrimaryRoadStop(const struct RoadVehicle *v) const;
RoadStop *bus_stops; ///< All the road stops
TileArea bus_station; ///< Tile area the bus 'station' part covers
RoadStop *truck_stops; ///< All the truck stops
TileArea truck_station; ///< Tile area the truck 'station' part covers
Airport airport; ///< Tile area the airport covers
TileIndex dock_tile; ///< The location of the dock
IndustryType indtype; ///< Industry type to get the name from
StationHadVehicleOfTypeByte had_vehicle_of_type;
byte time_since_load;
byte time_since_unload;
byte last_vehicle_type;
std::list loading_vehicles;
GoodsEntry goods[NUM_CARGO]; ///< Goods at this station
uint32 always_accepted; ///< Bitmask of always accepted cargo types (by houses, HQs, industry tiles when industry doesn't accept cargo)
IndustryVector industries_near; ///< Cached list of industries near the station that can accept cargo, @see DeliverGoodsToIndustry()
Station(TileIndex tile = INVALID_TILE);
~Station();
void AddFacility(StationFacility new_facility_bit, TileIndex facil_xy);
void MarkTilesDirty(bool cargo_change) const;
void UpdateVirtCoord();
/* virtual */ uint GetPlatformLength(TileIndex tile, DiagDirection dir) const;
/* virtual */ uint GetPlatformLength(TileIndex tile) const;
void RecomputeIndustriesNear();
static void RecomputeIndustriesNearForAll();
uint GetCatchmentRadius() const;
Rect GetCatchmentRect() const;
/* virtual */ inline bool TileBelongsToRailStation(TileIndex tile) const
{
return IsRailStationTile(tile) && GetStationIndex(tile) == this->index;
}
inline bool TileBelongsToAirport(TileIndex tile) const
{
return IsAirportTile(tile) && GetStationIndex(tile) == this->index;
}
/* virtual */ uint32 GetNewGRFVariable(const ResolverObject *object, byte variable, byte parameter, bool *available) const;
/* virtual */ void GetTileArea(TileArea *ta, StationType type) const;
};
#define FOR_ALL_STATIONS(var) FOR_ALL_BASE_STATIONS_OF_TYPE(Station, var)
/** Iterator to iterate over all tiles belonging to an airport. */
class AirportTileIterator : public OrthogonalTileIterator {
private:
const Station *st; ///< The station the airport is a part of.
public:
/**
* Construct the iterator.
* @param ta Area, i.e. begin point and width/height of to-be-iterated area.
*/
AirportTileIterator(const Station *st) : OrthogonalTileIterator(st->airport), st(st)
{
if (!st->TileBelongsToAirport(this->tile)) ++(*this);
}
inline TileIterator& operator ++()
{
(*this).OrthogonalTileIterator::operator++();
while (this->tile != INVALID_TILE && !st->TileBelongsToAirport(this->tile)) {
(*this).OrthogonalTileIterator::operator++();
}
return *this;
}
virtual TileIterator *Clone() const
{
return new AirportTileIterator(*this);
}
};
#endif /* STATION_BASE_H */