RelativePath=".\..\src\base_station_base.h"

				>

			</File>

			<File

				RelativePath=".\..\src\base_station_base.h"

				>

			</File>

			<File

base_station_base.h

/* $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<BaseStation, StationID, 32, 64000> 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 <class T, bool Tis_waypoint>

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<T, Tis_waypoint>(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 */

#include "station_base.h"

#include "vehicle_type.h"

#include "company_type.h"

#include "tile_type.h"

#include "company_type.h"

#include "strings_type.h"

#include "station_base.h"

#include "base_station_base.h"

#include "base_station_base.h"

#include "base_station_base.h"

#include "waypoint_type.h"