diff options
author | rubidium <rubidium@openttd.org> | 2007-12-27 13:35:39 +0000 |
---|---|---|
committer | rubidium <rubidium@openttd.org> | 2007-12-27 13:35:39 +0000 |
commit | 384503e7d37f4b68c1480f6e6ca81adf84ef137d (patch) | |
tree | 7262db82a9e80413b5783b88be96602fdd29a485 /src/vehicle_base.h | |
parent | 4e66f5a04b3b1393a13fa81edfdd10243aaf13a4 (diff) | |
download | openttd-384503e7d37f4b68c1480f6e6ca81adf84ef137d.tar.xz |
(svn r11706) -Codechange: split vehicle.h and remove another bunch of useless includes.
Diffstat (limited to 'src/vehicle_base.h')
-rw-r--r-- | src/vehicle_base.h | 613 |
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 */ |