(svn r11706) -Codechange: split vehicle.h and remove another bunch of useless includes.

1 files changed, 613 insertions, 0 deletions

diff --git a/src/vehicle_base.h b/src/vehicle_base.h
new file mode 100644
index 000000000..751c320f1
--- /dev/null
+++ b/src/vehicle_base.h
@@ -0,0 +1,613 @@
+/* $Id$ */
+
+/** @file  vehicle_base.h Base class for all vehicles. */
+
+#ifndef VEHICLE_BASE_H
+#define VEHICLE_BASE_H
+
+#include "vehicle_type.h"
+#include "track_type.h"
+#include "rail_type.h"
+#include "road_type.h"
+#include "cargo_type.h"
+#include "direction_type.h"
+#include "window_type.h"
+#include "gfx_type.h"
+#include "command_type.h"
+#include "date_type.h"
+#include "oldpool.h"
+#include "order.h"
+#include "cargopacket.h"
+#include "texteff.hpp"
+
+/** Road vehicle states */
+enum RoadVehicleStates {
+	/*
+	 * Lower 4 bits are used for vehicle track direction. (Trackdirs)
+	 * When in a road stop (bit 5 or bit 6 set) these bits give the
+	 * track direction of the entry to the road stop.
+	 * As the entry direction will always be a diagonal
+	 * direction (X_NE, Y_SE, X_SW or Y_NW) only bits 0 and 3
+	 * are needed to hold this direction. Bit 1 is then used to show
+	 * that the vehicle is using the second road stop bay.
+	 * Bit 2 is then used for drive-through stops to show the vehicle
+	 * is stopping at this road stop.
+	 */
+
+	/* Numeric values */
+	RVSB_IN_DEPOT                = 0xFE,                      ///< The vehicle is in a depot
+	RVSB_WORMHOLE                = 0xFF,                      ///< The vehicle is in a tunnel and/or bridge
+
+	/* Bit numbers */
+	RVS_USING_SECOND_BAY         =    1,                      ///< Only used while in a road stop
+	RVS_IS_STOPPING              =    2,                      ///< Only used for drive-through stops. Vehicle will stop here
+	RVS_DRIVE_SIDE               =    4,                      ///< Only used when retrieving move data
+	RVS_IN_ROAD_STOP             =    5,                      ///< The vehicle is in a road stop
+	RVS_IN_DT_ROAD_STOP          =    6,                      ///< The vehicle is in a drive-through road stop
+
+	/* Bit sets of the above specified bits */
+	RVSB_IN_ROAD_STOP            = 1 << RVS_IN_ROAD_STOP,     ///< The vehicle is in a road stop
+	RVSB_IN_ROAD_STOP_END        = RVSB_IN_ROAD_STOP + TRACKDIR_END,
+	RVSB_IN_DT_ROAD_STOP         = 1 << RVS_IN_DT_ROAD_STOP,  ///< The vehicle is in a drive-through road stop
+	RVSB_IN_DT_ROAD_STOP_END     = RVSB_IN_DT_ROAD_STOP + TRACKDIR_END,
+
+	RVSB_TRACKDIR_MASK           = 0x0F,                      ///< The mask used to extract track dirs
+	RVSB_ROAD_STOP_TRACKDIR_MASK = 0x09                       ///< Only bits 0 and 3 are used to encode the trackdir for road stops
+};
+
+enum VehStatus {
+	VS_HIDDEN          = 0x01,
+	VS_STOPPED         = 0x02,
+	VS_UNCLICKABLE     = 0x04,
+	VS_DEFPAL          = 0x08,
+	VS_TRAIN_SLOWING   = 0x10,
+	VS_SHADOW          = 0x20,
+	VS_AIRCRAFT_BROKEN = 0x40,
+	VS_CRASHED         = 0x80,
+};
+
+enum VehicleFlags {
+	VF_LOADING_FINISHED,
+	VF_CARGO_UNLOADING,
+	VF_BUILT_AS_PROTOTYPE,
+	VF_TIMETABLE_STARTED,  ///< Whether the vehicle has started running on the timetable yet.
+	VF_AUTOFILL_TIMETABLE, ///< Whether the vehicle should fill in the timetable automatically.
+};
+
+struct VehicleRail {
+	uint16 last_speed; // NOSAVE: only used in UI
+	uint16 crash_anim_pos;
+
+	/* cached values, recalculated on load and each time a vehicle is added to/removed from the consist. */
+	uint16 cached_max_speed;  // max speed of the consist. (minimum of the max speed of all vehicles in the consist)
+	uint32 cached_power;      // total power of the consist.
+	uint8 cached_veh_length;  // length of this vehicle in units of 1/8 of normal length, cached because this can be set by a callback
+	uint16 cached_total_length; ///< Length of the whole train, valid only for first engine.
+
+	/* cached values, recalculated when the cargo on a train changes (in addition to the conditions above) */
+	uint32 cached_weight;     // total weight of the consist.
+	uint32 cached_veh_weight; // weight of the vehicle.
+	uint32 cached_max_te;     // max tractive effort of consist
+	/**
+	 * Position/type of visual effect.
+	 * bit 0 - 3 = position of effect relative to vehicle. (0 = front, 8 = centre, 15 = rear)
+	 * bit 4 - 5 = type of effect. (0 = default for engine class, 1 = steam, 2 = diesel, 3 = electric)
+	 * bit     6 = disable visual effect.
+	 * bit     7 = disable powered wagons.
+	 */
+	byte cached_vis_effect;
+	byte user_def_data;
+
+	/* NOSAVE: for wagon override - id of the first engine in train
+	 * 0xffff == not in train */
+	EngineID first_engine;
+
+	TrackBitsByte track;
+	byte force_proceed;
+	RailTypeByte railtype;
+	RailTypeMask compatible_railtypes;
+
+	byte flags;
+
+	/* Link between the two ends of a multiheaded engine */
+	Vehicle *other_multiheaded_part;
+
+	/* Cached wagon override spritegroup */
+	const struct SpriteGroup *cached_override;
+};
+
+enum {
+	VRF_REVERSING         = 0,
+
+	/* used to calculate if train is going up or down */
+	VRF_GOINGUP           = 1,
+	VRF_GOINGDOWN         = 2,
+
+	/* used to store if a wagon is powered or not */
+	VRF_POWEREDWAGON      = 3,
+
+	/* used to reverse the visible direction of the vehicle */
+	VRF_REVERSE_DIRECTION = 4,
+
+	/* used to mark train as lost because PF can't find the route */
+	VRF_NO_PATH_TO_DESTINATION = 5,
+
+	/* used to mark that electric train engine is allowed to run on normal rail */
+	VRF_EL_ENGINE_ALLOWED_NORMAL_RAIL = 6,
+};
+
+struct VehicleAir {
+	uint16 crashed_counter;
+	uint16 cached_max_speed;
+	byte pos;
+	byte previous_pos;
+	StationID targetairport;
+	byte state;
+};
+
+struct VehicleRoad {
+	byte state;             ///< @see RoadVehicleStates
+	byte frame;
+	uint16 blocked_ctr;
+	byte overtaking;
+	byte overtaking_ctr;
+	uint16 crashed_ctr;
+	byte reverse_ctr;
+	struct RoadStop *slot;
+	byte slot_age;
+	EngineID first_engine;
+	byte cached_veh_length;
+
+	RoadType roadtype;
+	RoadTypes compatible_roadtypes;
+};
+
+struct VehicleSpecial {
+	uint16 animation_state;
+	byte animation_substate;
+};
+
+struct VehicleDisaster {
+	uint16 image_override;
+	VehicleID big_ufo_destroyer_target;
+};
+
+struct VehicleShip {
+	TrackBitsByte state;
+};
+
+DECLARE_OLD_POOL(Vehicle, Vehicle, 9, 125)
+
+/* Some declarations of functions, so we can make them friendly */
+struct SaveLoad;
+extern const SaveLoad *GetVehicleDescription(VehicleType vt);
+extern void AfterLoadVehicles();
+struct LoadgameState;
+extern bool LoadOldVehicle(LoadgameState *ls, int num);
+
+struct Vehicle : PoolItem<Vehicle, VehicleID, &_Vehicle_pool>, BaseVehicle {
+	byte subtype;            // subtype (Filled with values from EffectVehicles/TrainSubTypes/AircraftSubTypes)
+
+private:
+	Vehicle *next;           // pointer to the next vehicle in the chain
+	Vehicle *previous;       // NOSAVE: pointer to the previous vehicle in the chain
+	Vehicle *first;          // NOSAVE: pointer to the first vehicle in the chain
+public:
+	friend const SaveLoad *GetVehicleDescription(VehicleType vt); // So we can use private/protected variables in the saveload code
+	friend void AfterLoadVehicles();                              // So we can set the previous and first pointers while loading
+	friend bool LoadOldVehicle(LoadgameState *ls, int num);       // So we can set the proper next pointer while loading
+
+	Vehicle *depot_list;     // NOSAVE: linked list to tell what vehicles entered a depot during the last tick. Used by autoreplace
+
+	StringID string_id;      // Displayed string
+
+	UnitID unitnumber;       // unit number, for display purposes only
+	PlayerByte owner;        // which player owns the vehicle?
+
+	TileIndex tile;          // Current tile index
+	TileIndex dest_tile;     // Heading for this tile
+
+	int32 x_pos;             // coordinates
+	int32 y_pos;
+	byte z_pos;
+	DirectionByte direction; // facing
+
+	byte spritenum;          // currently displayed sprite index
+	                         // 0xfd == custom sprite, 0xfe == custom second head sprite
+	                         // 0xff == reserved for another custom sprite
+	uint16 cur_image;        // sprite number for this vehicle
+	byte sprite_width;       // width of vehicle sprite
+	byte sprite_height;      // height of vehicle sprite
+	byte z_height;           // z-height of vehicle sprite
+	int8 x_offs;             // x offset for vehicle sprite
+	int8 y_offs;             // y offset for vehicle sprite
+	EngineID engine_type;
+
+	TextEffectID fill_percent_te_id; // a text-effect id to a loading indicator object
+
+	/* for randomized variational spritegroups
+	 * bitmask used to resolve them; parts of it get reseeded when triggers
+	 * of corresponding spritegroups get matched */
+	byte random_bits;
+	byte waiting_triggers;   // triggers to be yet matched
+
+	uint16 max_speed;        // maximum speed
+	uint16 cur_speed;        // current speed
+	byte subspeed;           // fractional speed
+	byte acceleration;       // used by train & aircraft
+	byte progress;
+	uint32 motion_counter;
+
+	byte vehstatus;          // Status
+	StationID last_station_visited;
+
+	CargoID cargo_type;      // type of cargo this vehicle is carrying
+	uint16 cargo_cap;        // total capacity
+	byte cargo_subtype;      ///< Used for livery refits (NewGRF variations)
+	CargoList cargo;         ///< The cargo this vehicle is carrying
+
+
+	byte day_counter;        // increased by one for each day
+	byte tick_counter;       // increased by one for each tick
+
+	/* Begin Order-stuff */
+	Order current_order;     ///< The current order (+ status, like: loading)
+	VehicleOrderID cur_order_index; ///< The index to the current order
+
+	Order *orders;           ///< Pointer to the first order for this vehicle
+	VehicleOrderID num_orders;      ///< How many orders there are in the list
+
+	Vehicle *next_shared;    ///< If not NULL, this points to the next vehicle that shared the order
+	Vehicle *prev_shared;    ///< If not NULL, this points to the prev vehicle that shared the order
+	/* End Order-stuff */
+
+	/* Boundaries for the current position in the world and a next hash link.
+	 * NOSAVE: All of those can be updated with VehiclePositionChanged() */
+	int32 left_coord;
+	int32 top_coord;
+	int32 right_coord;
+	int32 bottom_coord;
+	Vehicle *next_hash;
+	Vehicle *next_new_hash;
+	Vehicle **old_new_hash;
+
+	/* Related to age and service time */
+	Date age;     // Age in days
+	Date max_age; // Maximum age
+	Date date_of_last_service;
+	Date service_interval;
+	uint16 reliability;
+	uint16 reliability_spd_dec;
+	byte breakdown_ctr;
+	byte breakdown_delay;
+	byte breakdowns_since_last_service;
+	byte breakdown_chance;
+	Year build_year;
+
+	bool leave_depot_instantly; // NOSAVE: stores if the vehicle needs to leave the depot it just entered. Used by autoreplace
+
+	uint16 load_unload_time_rem;
+	byte vehicle_flags;         // Used for gradual loading and other miscellaneous things (@see VehicleFlags enum)
+
+	Money profit_this_year;
+	Money profit_last_year;
+	Money value;
+
+	GroupID group_id;              ///< Index of group Pool array
+
+	/* Used for timetabling. */
+	uint32 current_order_time;     ///< How many ticks have passed since this order started.
+	int32 lateness_counter;        ///< How many ticks late (or early if negative) this vehicle is.
+
+	SpriteID colormap; // NOSAVE: cached color mapping
+
+	union {
+		VehicleRail rail;
+		VehicleAir air;
+		VehicleRoad road;
+		VehicleSpecial special;
+		VehicleDisaster disaster;
+		VehicleShip ship;
+	} u;
+
+
+	/**
+	 * Allocates a lot of vehicles.
+	 * @param vl pointer to an array of vehicles to get allocated. Can be NULL if the vehicles aren't needed (makes it test only)
+	 * @param num number of vehicles to allocate room for
+	 * @return true if there is room to allocate all the vehicles
+	 */
+	static bool AllocateList(Vehicle **vl, int num);
+
+	/** Create a new vehicle */
+	Vehicle();
+
+	/** Destroy all stuff that (still) needs the virtual functions to work properly */
+	void PreDestructor();
+	/** We want to 'destruct' the right class. */
+	virtual ~Vehicle();
+
+	void BeginLoading();
+	void LeaveStation();
+
+	/**
+	 * Handle the loading of the vehicle; when not it skips through dummy
+	 * orders and does nothing in all other cases.
+	 * @param mode is the non-first call for this vehicle in this tick?
+	 */
+	void HandleLoading(bool mode = false);
+
+	/**
+	 * Get a string 'representation' of the vehicle type.
+	 * @return the string representation.
+	 */
+	virtual const char* GetTypeString() const { return "base vehicle"; }
+
+	/**
+	 * Marks the vehicles to be redrawn and updates cached variables
+	 *
+	 * This method marks the area of the vehicle on the screen as dirty.
+	 * It can be use to repaint the vehicle.
+	 *
+	 * @ingroup dirty
+	 */
+	virtual void MarkDirty() {}
+
+	/**
+	 * Updates the x and y offsets and the size of the sprite used
+	 * for this vehicle.
+	 * @param direction the direction the vehicle is facing
+	 */
+	virtual void UpdateDeltaXY(Direction direction) {}
+
+	/**
+	 * Sets the expense type associated to this vehicle type
+	 * @param income whether this is income or (running) expenses of the vehicle
+	 */
+	virtual ExpensesType GetExpenseType(bool income) const { return EXPENSES_OTHER; }
+
+	/**
+	 * Invalidates the vehicle list window of this type of vehicle
+	 */
+	virtual WindowClass GetVehicleListWindowClass() const { return WC_NONE; }
+
+	/**
+	 * Play the sound associated with leaving the station
+	 */
+	virtual void PlayLeaveStationSound() const {}
+
+	/**
+	 * Whether this is the primary vehicle in the chain.
+	 */
+	virtual bool IsPrimaryVehicle() const { return false; }
+
+	/**
+	 * Gets the sprite to show for the given direction
+	 * @param direction the direction the vehicle is facing
+	 * @return the sprite for the given vehicle in the given direction
+	 */
+	virtual int GetImage(Direction direction) const { return 0; }
+
+	/**
+	 * Gets the speed in mph that can be sent into SetDParam for string processing.
+	 * @return the vehicle's speed
+	 */
+	virtual int GetDisplaySpeed() const { return 0; }
+
+	/**
+	 * Gets the maximum speed in mph that can be sent into SetDParam for string processing.
+	 * @return the vehicle's maximum speed
+	 */
+	virtual int GetDisplayMaxSpeed() const { return 0; }
+
+	/**
+	 * Gets the running cost of a vehicle
+	 * @return the vehicle's running cost
+	 */
+	virtual Money GetRunningCost() const { return 0; }
+
+	/**
+	 * Check whether the vehicle is in the depot.
+	 * @return true if and only if the vehicle is in the depot.
+	 */
+	virtual bool IsInDepot() const { return false; }
+
+	/**
+	 * Check whether the vehicle is in the depot *and* stopped.
+	 * @return true if and only if the vehicle is in the depot and stopped.
+	 */
+	virtual bool IsStoppedInDepot() const { return this->IsInDepot() && (this->vehstatus & VS_STOPPED) != 0; }
+
+	/**
+	 * Calls the tick handler of the vehicle
+	 */
+	virtual void Tick() {};
+
+	/**
+	 * Gets the running cost of a vehicle  that can be sent into SetDParam for string processing.
+	 * @return the vehicle's running cost
+	 */
+	Money GetDisplayRunningCost() const { return (this->GetRunningCost() >> 8); }
+
+	/**
+	 * Set the next vehicle of this vehicle.
+	 * @param next the next vehicle. NULL removes the next vehicle.
+	 */
+	void SetNext(Vehicle *next);
+
+	/**
+	 * Get the next vehicle of this vehicle.
+	 * @note articulated parts are also counted as vehicles.
+	 * @return the next vehicle or NULL when there isn't a next vehicle.
+	 */
+	inline Vehicle *Next() const { return this->next; }
+
+	/**
+	 * Get the previous vehicle of this vehicle.
+	 * @note articulated parts are also counted as vehicles.
+	 * @return the previous vehicle or NULL when there isn't a previous vehicle.
+	 */
+	inline Vehicle *Previous() const { return this->previous; }
+
+	/**
+	 * Get the first vehicle of this vehicle chain.
+	 * @return the first vehicle of the chain.
+	 */
+	inline Vehicle *First() const { return this->first; }
+};
+
+/**
+ * This class 'wraps' Vehicle; you do not actually instantiate this class.
+ * You create a Vehicle using AllocateVehicle, so it is added to the pool
+ * and you reinitialize that to a Train using:
+ *   v = new (v) Train();
+ *
+ * As side-effect the vehicle type is set correctly.
+ *
+ * A special vehicle is one of the following:
+ *  - smoke
+ *  - electric sparks for trains
+ *  - explosions
+ *  - bulldozer (road works)
+ *  - bubbles (industry)
+ */
+struct SpecialVehicle : public Vehicle {
+	/** Initializes the Vehicle to a special vehicle */
+	SpecialVehicle() { this->type = VEH_SPECIAL; }
+
+	/** We want to 'destruct' the right class. */
+	virtual ~SpecialVehicle() {}
+
+	const char *GetTypeString() const { return "special vehicle"; }
+	void UpdateDeltaXY(Direction direction);
+	void Tick();
+};
+
+/**
+ * This class 'wraps' Vehicle; you do not actually instantiate this class.
+ * You create a Vehicle using AllocateVehicle, so it is added to the pool
+ * and you reinitialize that to a Train using:
+ *   v = new (v) Train();
+ *
+ * As side-effect the vehicle type is set correctly.
+ */
+struct DisasterVehicle : public Vehicle {
+	/** Initializes the Vehicle to a disaster vehicle */
+	DisasterVehicle() { this->type = VEH_DISASTER; }
+
+	/** We want to 'destruct' the right class. */
+	virtual ~DisasterVehicle() {}
+
+	const char *GetTypeString() const { return "disaster vehicle"; }
+	void UpdateDeltaXY(Direction direction);
+	void Tick();
+};
+
+/**
+ * This class 'wraps' Vehicle; you do not actually instantiate this class.
+ * You create a Vehicle using AllocateVehicle, so it is added to the pool
+ * and you reinitialize that to a Train using:
+ *   v = new (v) Train();
+ *
+ * As side-effect the vehicle type is set correctly.
+ */
+struct InvalidVehicle : public Vehicle {
+	/** Initializes the Vehicle to a invalid vehicle */
+	InvalidVehicle() { this->type = VEH_INVALID; }
+
+	/** We want to 'destruct' the right class. */
+	virtual ~InvalidVehicle() {}
+
+	const char *GetTypeString() const { return "invalid vehicle"; }
+	void Tick() {}
+};
+
+#define BEGIN_ENUM_WAGONS(v) do {
+#define END_ENUM_WAGONS(v) } while ((v = v->Next()) != NULL);
+
+static inline VehicleID GetMaxVehicleIndex()
+{
+	/* TODO - This isn't the real content of the function, but
+	 *  with the new pool-system this will be replaced with one that
+	 *  _really_ returns the highest index. Now it just returns
+	 *  the next safe value we are sure about everything is below.
+	 */
+	return GetVehiclePoolSize() - 1;
+}
+
+static inline uint GetNumVehicles()
+{
+	return GetVehiclePoolSize();
+}
+
+#define FOR_ALL_VEHICLES_FROM(v, start) for (v = GetVehicle(start); v != NULL; v = (v->index + 1U < GetVehiclePoolSize()) ? GetVehicle(v->index + 1) : NULL) if (v->IsValid())
+#define FOR_ALL_VEHICLES(v) FOR_ALL_VEHICLES_FROM(v, 0)
+
+/**
+ * Check if an index is a vehicle-index (so between 0 and max-vehicles)
+ * @param index of the vehicle to query
+ * @return Returns true if the vehicle-id is in range
+ */
+static inline bool IsValidVehicleID(uint index)
+{
+	return index < GetVehiclePoolSize() && GetVehicle(index)->IsValid();
+}
+
+/* Returns order 'index' of a vehicle or NULL when it doesn't exists */
+static inline Order *GetVehicleOrder(const Vehicle *v, int index)
+{
+	Order *order = v->orders;
+
+	if (index < 0) return NULL;
+
+	while (order != NULL && index-- > 0)
+		order = order->next;
+
+	return order;
+}
+
+/**
+ * Returns the last order of a vehicle, or NULL if it doesn't exists
+ * @param v Vehicle to query
+ * @return last order of a vehicle, if available
+ */
+static inline Order *GetLastVehicleOrder(const Vehicle *v)
+{
+	Order *order = v->orders;
+
+	if (order == NULL) return NULL;
+
+	while (order->next != NULL)
+		order = order->next;
+
+	return order;
+}
+
+/** Get the first vehicle of a shared-list, so we only have to walk forwards
+ * @param v Vehicle to query
+ * @return first vehicle of a shared-list
+ */
+static inline Vehicle *GetFirstVehicleFromSharedList(const Vehicle *v)
+{
+	Vehicle *u = (Vehicle *)v;
+	while (u->prev_shared != NULL) u = u->prev_shared;
+
+	return u;
+}
+
+/**
+ * Returns the Trackdir on which the vehicle is currently located.
+ * Works for trains and ships.
+ * Currently works only sortof for road vehicles, since they have a fuzzy
+ * concept of being "on" a trackdir. Dunno really what it returns for a road
+ * vehicle that is halfway a tile, never really understood that part. For road
+ * vehicles that are at the beginning or end of the tile, should just return
+ * the diagonal trackdir on which they are driving. I _think_.
+ * For other vehicles types, or vehicles with no clear trackdir (such as those
+ * in depots), returns 0xFF.
+ */
+Trackdir GetVehicleTrackdir(const Vehicle* v);
+
+void CheckVehicle32Day(Vehicle *v);
+
+#endif /* VEHICLE_BASE_H */