# vehicle_base.h

Go to the documentation of this file.

    00001 /* $Id$ */
    00002
    00003 /*
    00004  * This file is part of OpenTTD.
    00005  * 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.
    00006  * 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.
    00007  * 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 <http://www.gnu.org/licenses/>.
    00008  */
    00009
    00012 #ifndef VEHICLE_BASE_H
    00013 #define VEHICLE_BASE_H
    00014
    00015 #include "track_type.h"
    00016 #include "command_type.h"
    00017 #include "order_base.h"
    00018 #include "cargopacket.h"
    00019 #include "texteff.hpp"
    00020 #include "engine_type.h"
    00021 #include "order_func.h"
    00022 #include "transport_type.h"
    00023 #include "group_type.h"
    00024 #include "timetable.h"
    00025
    00027 enum VehStatus {
    00028   VS_HIDDEN          = 0x01,
    00029   VS_STOPPED         = 0x02,
    00030   VS_UNCLICKABLE     = 0x04,
    00031   VS_DEFPAL          = 0x08,
    00032   VS_TRAIN_SLOWING   = 0x10,
    00033   VS_SHADOW          = 0x20,
    00034   VS_AIRCRAFT_BROKEN = 0x40,
    00035   VS_CRASHED         = 0x80,
    00036 };
    00037
    00039 enum VehicleFlags {
    00040   VF_LOADING_FINISHED,
    00041   VF_CARGO_UNLOADING,
    00042   VF_BUILT_AS_PROTOTYPE,
    00043   VF_TIMETABLE_STARTED,
    00044   VF_AUTOFILL_TIMETABLE,
    00045   VF_AUTOFILL_PRES_WAIT_TIME,
    00046   VF_STOP_LOADING,
    00047   VF_AUTOMATE_TIMETABLE,
    00048   VF_PATHFINDER_LOST,
    00049 };
    00050
    00052 enum NewGRFCacheValidValues {
    00053   NCVV_POSITION_CONSIST_LENGTH   = 0,
    00054   NCVV_POSITION_SAME_ID_LENGTH   = 1,
    00055   NCVV_CONSIST_CARGO_INFORMATION = 2,
    00056   NCVV_COMPANY_INFORMATION       = 3,
    00057   NCVV_END,
    00058 };
    00059
    00061 struct NewGRFCache {
    00062   /* Values calculated when they are requested for the first time after invalidating the NewGRF cache. */
    00063   uint32 position_consist_length;
    00064   uint32 position_same_id_length;
    00065   uint32 consist_cargo_information;
    00066   uint32 company_information;
    00067   uint8  cache_valid;
    00068 };
    00069
    00071 enum VisualEffect {
    00072   VE_OFFSET_START        = 0,
    00073   VE_OFFSET_COUNT        = 4,
    00074   VE_OFFSET_CENTRE       = 8,
    00075
    00076   VE_TYPE_START          = 4,
    00077   VE_TYPE_COUNT          = 2,
    00078   VE_TYPE_DEFAULT        = 0,
    00079   VE_TYPE_STEAM          = 1,
    00080   VE_TYPE_DIESEL         = 2,
    00081   VE_TYPE_ELECTRIC       = 3,
    00082
    00083   VE_DISABLE_EFFECT      = 6,
    00084   VE_DISABLE_WAGON_POWER = 7,
    00085
    00086   VE_DEFAULT = 0xFF,
    00087 };
    00088
    00094 enum GroundVehicleSubtypeFlags {
    00095   GVSF_FRONT            = 0,
    00096   GVSF_ARTICULATED_PART = 1,
    00097   GVSF_WAGON            = 2,
    00098   GVSF_ENGINE           = 3,
    00099   GVSF_FREE_WAGON       = 4,
    00100   GVSF_MULTIHEADED      = 5,
    00101 };
    00102
    00104 struct VehicleCache {
    00105   uint16 cached_max_speed;
    00106
    00107   byte cached_vis_effect;
    00108 };
    00109
    00111 typedef Pool<Vehicle, VehicleID, 512, 0xFF000> VehiclePool;
    00112 extern VehiclePool _vehicle_pool;
    00113
    00114 /* Some declarations of functions, so we can make them friendly */
    00115 struct SaveLoad;
    00116 struct GroundVehicleCache;
    00117 extern const SaveLoad *GetVehicleDescription(VehicleType vt);
    00118 struct LoadgameState;
    00119 extern bool LoadOldVehicle(LoadgameState *ls, int num);
    00120 extern void FixOldVehicles();
    00121
    00123 struct Vehicle : VehiclePool::PoolItem<&_vehicle_pool>, BaseVehicle {
    00124 private:
    00125   Vehicle *next;
    00126   Vehicle *previous;
    00127   Vehicle *first;
    00128
    00129   Vehicle *next_shared;
    00130   Vehicle *previous_shared;
    00131
    00132   Vehicle *ahead_separation;
    00133   Vehicle *behind_separation;
    00134
    00135   bool CanLeaveWithCargo();
    00136 public:
    00137   friend const SaveLoad *GetVehicleDescription(VehicleType vt);
    00138   friend void FixOldVehicles();
    00139   friend void AfterLoadVehicles(bool part_of_load);
    00140   friend bool LoadOldVehicle(LoadgameState *ls, int num);
    00141
    00142   char *name;
    00143
    00144   TileIndex tile;
    00145
    00151   TileIndex dest_tile;
    00152
    00153   Money profit_this_year;
    00154   Money profit_last_year;
    00155   Money value;
    00156
    00157   CargoPayment *cargo_payment;
    00158
    00159   /* Used for timetabling. */
    00160   uint32 current_order_time;
    00161   uint32 current_loading_time;
    00162   int32 lateness_counter;
    00163 #if WALLCLOCK_NETWORK_COMPATIBLE
    00164   Date timetable_start;
    00165 #else
    00166   DateTicks timetable_start;
    00167 #endif
    00168
    00169   Rect coord;
    00170
    00171   Vehicle *next_hash;
    00172   Vehicle **prev_hash;
    00173
    00174   Vehicle *next_new_hash;
    00175   Vehicle **prev_new_hash;
    00176   Vehicle **old_new_hash;
    00177
    00178   byte breakdown_severity;
    00179   BreakdownType breakdown_type;
    00180
    00181   SpriteID colourmap;
    00182
    00183   /* Related to age and service time */
    00184   Year build_year;
    00185   Date age;
    00186   Date max_age;
    00187   Date date_of_last_service;
    00188   Date service_interval;
    00189   uint16 reliability;
    00190   uint16 reliability_spd_dec;
    00191   byte breakdown_ctr;
    00192   byte breakdown_delay;
    00193   byte breakdowns_since_last_service;
    00194   byte breakdown_chance;
    00195
    00196   int32 x_pos;
    00197   int32 y_pos;
    00198   int32 z_pos;
    00199   DirectionByte direction;
    00200
    00201   OwnerByte owner;
    00202   byte spritenum;
    00203
    00204
    00205   SpriteID cur_image;
    00206   byte x_extent;
    00207   byte y_extent;
    00208   byte z_extent;
    00209   int8 x_offs;
    00210   int8 y_offs;
    00211   EngineID engine_type;
    00212
    00213   TextEffectID fill_percent_te_id;
    00214   UnitID unitnumber;
    00215
    00216   uint16 cur_speed;
    00217   byte subspeed;
    00218   byte acceleration;
    00219   uint32 motion_counter;
    00220   byte progress;
    00221
    00222   byte random_bits;
    00223   byte waiting_triggers;
    00224
    00225   StationID last_station_visited;
    00226   StationID last_loading_station;
    00227
    00228   CargoID cargo_type;
    00229   byte cargo_subtype;
    00230   uint16 cargo_cap;
    00231   VehicleCargoList cargo;
    00232
    00233   byte day_counter;
    00234   byte tick_counter;
    00235   uint16 running_ticks;
    00236
    00237   byte vehstatus;
    00238   Order current_order;
    00239   VehicleOrderID cur_real_order_index;
    00240   VehicleOrderID cur_implicit_order_index;
    00241
    00242   union {
    00243     OrderList *list;
    00244     Order     *old;
    00245   } orders;
    00246
    00247   byte vehicle_flags;
    00248
    00249   uint16 load_unload_ticks;
    00250   GroupID group_id;
    00251   byte subtype;
    00252
    00253   NewGRFCache grf_cache;
    00254   VehicleCache vcache;
    00255
    00256   Vehicle(VehicleType type = VEH_INVALID);
    00257
    00258   void PreDestructor();
    00260   virtual ~Vehicle();
    00261
    00262   void BeginLoading();
    00263   void CancelReservation(StationID next, Station *st);
    00264   void LeaveStation();
    00265
    00266   GroundVehicleCache *GetGroundVehicleCache();
    00267   const GroundVehicleCache *GetGroundVehicleCache() const;
    00268
    00269   uint16 &GetGroundVehicleFlags();
    00270   const uint16 &GetGroundVehicleFlags() const;
    00271
    00272   void DeleteUnreachedImplicitOrders();
    00273
    00274   void HandleLoading(bool mode = false);
    00275
    00280   bool IsDrawn() const;
    00281
    00290   virtual void MarkDirty() {}
    00291
    00297   virtual void UpdateDeltaXY(Direction direction) {}
    00298
    00312   FORCEINLINE uint GetOldAdvanceSpeed(uint speed)
    00313   {
    00314     return (this->direction & 1) ? speed : speed * 3 / 4;
    00315   }
    00316
    00329   static FORCEINLINE uint GetAdvanceSpeed(uint speed)
    00330   {
    00331     return speed * 3 / 4;
    00332   }
    00333
    00341   FORCEINLINE uint GetAdvanceDistance()
    00342   {
    00343     return (this->direction & 1) ? 192 : 256;
    00344   }
    00345
    00350   virtual ExpensesType GetExpenseType(bool income) const { return EXPENSES_OTHER; }
    00351
    00355   virtual void PlayLeaveStationSound() const {}
    00356
    00360   virtual bool IsPrimaryVehicle() const { return false; }
    00361
    00367   virtual SpriteID GetImage(Direction direction) const { return 0; }
    00368
    00373   FORCEINLINE void InvalidateNewGRFCache()
    00374   {
    00375     this->grf_cache.cache_valid = 0;
    00376   }
    00377
    00382   FORCEINLINE void InvalidateNewGRFCacheOfChain()
    00383   {
    00384     for (Vehicle *u = this; u != NULL; u = u->Next()) {
    00385       u->InvalidateNewGRFCache();
    00386     }
    00387   }
    00388
    00393   FORCEINLINE bool IsGroundVehicle() const
    00394   {
    00395     return this->type == VEH_TRAIN || this->type == VEH_ROAD;
    00396   }
    00397
    00402   virtual int GetDisplaySpeed() const { return 0; }
    00403
    00408   virtual int GetDisplayMaxSpeed() const { return 0; }
    00409
    00414   virtual Money GetRunningCost() const { return 0; }
    00415
    00420   virtual bool IsInDepot() const { return false; }
    00421
    00426   virtual bool IsStoppedInDepot() const { return this->IsInDepot() && (this->vehstatus & VS_STOPPED) != 0; }
    00427
    00432   virtual bool Tick() { return true; };
    00433
    00437   virtual void OnNewDay() {};
    00438
    00444   virtual uint Crash(bool flooded = false);
    00445
    00458   virtual Trackdir GetVehicleTrackdir() const { return INVALID_TRACKDIR; }
    00459
    00464   Money GetDisplayRunningCost() const { return (this->GetRunningCost() >> 8); }
    00465
    00470   Money GetDisplayProfitThisYear() const { return (this->profit_this_year >> 8); }
    00471
    00476   Money GetDisplayProfitLastYear() const { return (this->profit_last_year >> 8); }
    00477
    00478   void SetNext(Vehicle *next);
    00479
    00485   inline Vehicle *Next() const { return this->next; }
    00486
    00492   inline Vehicle *Previous() const { return this->previous; }
    00493
    00498   inline Vehicle *First() const { return this->first; }
    00499
    00504   inline Vehicle *Last()
    00505   {
    00506     Vehicle *v = this;
    00507     while (v->Next() != NULL) v = v->Next();
    00508     return v;
    00509   }
    00510
    00515   inline const Vehicle *Last() const
    00516   {
    00517     const Vehicle *v = this;
    00518     while (v->Next() != NULL) v = v->Next();
    00519     return v;
    00520   }
    00521
    00526   inline Order *GetFirstOrder() const { return (this->orders.list == NULL) ? NULL : this->orders.list->GetFirstOrder(); }
    00527
    00532   inline Vehicle *AheadSeparation() const { return this->ahead_separation; }
    00533
    00538   inline Vehicle *BehindSeparation() const { return this->behind_separation; }
    00539
    00540   void ClearSeparation();
    00541
    00542   void InitSeparation();
    00543
    00544   void AddToSeparationBehind(Vehicle *v_other);
    00545
    00546   void AddToShared(Vehicle *shared_chain);
    00547   void RemoveFromShared();
    00548
    00553   inline Vehicle *NextShared() const { return this->next_shared; }
    00554
    00559   inline Vehicle *PreviousShared() const { return this->previous_shared; }
    00560
    00565   inline Vehicle *FirstShared() const { return (this->orders.list == NULL) ? this->First() : this->orders.list->GetFirstSharedVehicle(); }
    00566
    00571   inline bool IsOrderListShared() const { return this->orders.list != NULL && this->orders.list->IsShared(); }
    00572
    00577   inline VehicleOrderID GetNumOrders() const { return (this->orders.list == NULL) ? 0 : this->orders.list->GetNumOrders(); }
    00578
    00583   inline VehicleOrderID GetNumManualOrders() const { return (this->orders.list == NULL) ? 0 : this->orders.list->GetNumManualOrders(); }
    00584
    00591   inline void CopyVehicleConfigAndStatistics(const Vehicle *src)
    00592   {
    00593     this->unitnumber = src->unitnumber;
    00594
    00595     this->cur_real_order_index = src->cur_real_order_index;
    00596     this->cur_implicit_order_index = src->cur_implicit_order_index;
    00597     this->current_order = src->current_order;
    00598     this->dest_tile  = src->dest_tile;
    00599
    00600     this->profit_this_year = src->profit_this_year;
    00601     this->profit_last_year = src->profit_last_year;
    00602
    00603     this->current_order_time = src->current_order_time;
    00604     this->current_loading_time = src->current_loading_time;
    00605     this->lateness_counter = src->lateness_counter;
    00606     this->timetable_start = src->timetable_start;
    00607
    00608     if (HasBit(src->vehicle_flags, VF_TIMETABLE_STARTED)) SetBit(this->vehicle_flags, VF_TIMETABLE_STARTED);
    00609     if (HasBit(src->vehicle_flags, VF_AUTOFILL_TIMETABLE)) SetBit(this->vehicle_flags, VF_AUTOFILL_TIMETABLE);
    00610     if (HasBit(src->vehicle_flags, VF_AUTOFILL_PRES_WAIT_TIME)) SetBit(this->vehicle_flags, VF_AUTOFILL_PRES_WAIT_TIME);
    00611
    00612     this->service_interval = src->service_interval;
    00613   }
    00614
    00615
    00616   bool HandleBreakdown();
    00617
    00618   bool NeedsAutorenewing(const Company *c) const;
    00619
    00620   bool NeedsServicing() const;
    00621   bool NeedsAutomaticServicing() const;
    00622
    00630   virtual TileIndex GetOrderStationLocation(StationID station) { return INVALID_TILE; }
    00631
    00640   virtual bool FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse) { return false; }
    00641
    00642   CommandCost SendToDepot(DoCommandFlag flags, DepotCommand command);
    00643
    00644   void UpdateVisualEffect(bool allow_power_change = true);
    00645   void ShowVisualEffect() const;
    00646
    00647 private:
    00652   void SkipToNextRealOrderIndex()
    00653   {
    00654     if (this->GetNumManualOrders() > 0) {
    00655       /* Advance to next real order */
    00656       do {
    00657         this->cur_real_order_index++;
    00658         if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
    00659       } while (this->GetOrder(this->cur_real_order_index)->IsType(OT_IMPLICIT));
    00660     } else {
    00661       this->cur_real_order_index = 0;
    00662     }
    00663   }
    00664
    00665 public:
    00671   void IncrementImplicitOrderIndex()
    00672   {
    00673     if (this->cur_implicit_order_index == this->cur_real_order_index) {
    00674       /* Increment real order index as well */
    00675       this->SkipToNextRealOrderIndex();
    00676     }
    00677
    00678     assert(this->cur_real_order_index == 0 || this->cur_real_order_index < this->GetNumOrders());
    00679
    00680     /* Advance to next implicit order */
    00681     do {
    00682       this->cur_implicit_order_index++;
    00683       if (this->cur_implicit_order_index >= this->GetNumOrders()) this->cur_implicit_order_index = 0;
    00684     } while (this->cur_implicit_order_index != this->cur_real_order_index && !this->GetOrder(this->cur_implicit_order_index)->IsType(OT_IMPLICIT));
    00685
    00686     InvalidateVehicleOrder(this, 0);
    00687   }
    00688
    00695   void IncrementRealOrderIndex()
    00696   {
    00697     if (this->cur_implicit_order_index == this->cur_real_order_index) {
    00698       /* Increment both real and implicit order */
    00699       this->IncrementImplicitOrderIndex();
    00700     } else {
    00701       /* Increment real order only */
    00702       this->SkipToNextRealOrderIndex();
    00703       InvalidateVehicleOrder(this, 0);
    00704     }
    00705   }
    00706
    00710   void UpdateRealOrderIndex()
    00711   {
    00712     /* Make sure the index is valid */
    00713     if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
    00714
    00715     if (this->GetNumManualOrders() > 0) {
    00716       /* Advance to next real order */
    00717       while (this->GetOrder(this->cur_real_order_index)->IsType(OT_IMPLICIT)) {
    00718         this->cur_real_order_index++;
    00719         if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
    00720       }
    00721     } else {
    00722       this->cur_real_order_index = 0;
    00723     }
    00724   }
    00725
    00731   inline Order *GetOrder(int index) const
    00732   {
    00733     return (this->orders.list == NULL) ? NULL : this->orders.list->GetOrderAt(index);
    00734   }
    00735
    00740   inline Order *GetLastOrder() const
    00741   {
    00742     return (this->orders.list == NULL) ? NULL : this->orders.list->GetLastOrder();
    00743   }
    00744
    00745   bool IsEngineCountable() const;
    00746   bool HasDepotOrder() const;
    00747   void HandlePathfindingResult(bool path_found);
    00748
    00753   FORCEINLINE bool IsFrontEngine() const
    00754   {
    00755     return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_FRONT);
    00756   }
    00757
    00762   FORCEINLINE bool IsArticulatedPart() const
    00763   {
    00764     return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_ARTICULATED_PART);
    00765   }
    00766
    00771   FORCEINLINE bool HasArticulatedPart() const
    00772   {
    00773     return this->Next() != NULL && this->Next()->IsArticulatedPart();
    00774   }
    00775
    00781   FORCEINLINE Vehicle *GetNextArticulatedPart() const
    00782   {
    00783     assert(this->HasArticulatedPart());
    00784     return this->Next();
    00785   }
    00786
    00791   FORCEINLINE Vehicle *GetFirstEnginePart()
    00792   {
    00793     Vehicle *v = this;
    00794     while (v->IsArticulatedPart()) v = v->Previous();
    00795     return v;
    00796   }
    00797
    00802   FORCEINLINE const Vehicle *GetFirstEnginePart() const
    00803   {
    00804     const Vehicle *v = this;
    00805     while (v->IsArticulatedPart()) v = v->Previous();
    00806     return v;
    00807   }
    00808
    00813   FORCEINLINE Vehicle *GetLastEnginePart()
    00814   {
    00815     Vehicle *v = this;
    00816     while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart();
    00817     return v;
    00818   }
    00819
    00824   FORCEINLINE Vehicle *GetNextVehicle() const
    00825   {
    00826     const Vehicle *v = this;
    00827     while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart();
    00828
    00829     /* v now contains the last articulated part in the engine */
    00830     return v->Next();
    00831   }
    00832
    00837   FORCEINLINE Vehicle *GetPrevVehicle() const
    00838   {
    00839     Vehicle *v = this->Previous();
    00840     while (v != NULL && v->IsArticulatedPart()) v = v->Previous();
    00841
    00842     return v;
    00843   }
    00844 };
    00845
    00851 #define FOR_ALL_VEHICLES_FROM(var, start) FOR_ALL_ITEMS_FROM(Vehicle, vehicle_index, var, start)
    00852
    00857 #define FOR_ALL_VEHICLES(var) FOR_ALL_VEHICLES_FROM(var, 0)
    00858
    00863 template <class T, VehicleType Type>
    00864 struct SpecializedVehicle : public Vehicle {
    00865   static const VehicleType EXPECTED_TYPE = Type;
    00866
    00867   typedef SpecializedVehicle<T, Type> SpecializedVehicleBase;
    00868
    00872   FORCEINLINE SpecializedVehicle<T, Type>() : Vehicle(Type) { }
    00873
    00878   FORCEINLINE T *First() const { return (T *)this->Vehicle::First(); }
    00879
    00884   FORCEINLINE T *Last() { return (T *)this->Vehicle::Last(); }
    00885
    00890   FORCEINLINE const T *Last() const { return (const T *)this->Vehicle::Last(); }
    00891
    00896   FORCEINLINE T *Next() const { return (T *)this->Vehicle::Next(); }
    00897
    00902   FORCEINLINE T *Previous() const { return (T *)this->Vehicle::Previous(); }
    00903
    00909   FORCEINLINE T *GetNextArticulatedPart() { return (T *)this->Vehicle::GetNextArticulatedPart(); }
    00910
    00916   FORCEINLINE T *GetNextArticulatedPart() const { return (T *)this->Vehicle::GetNextArticulatedPart(); }
    00917
    00922   FORCEINLINE T *GetFirstEnginePart() { return (T *)this->Vehicle::GetFirstEnginePart(); }
    00923
    00928   FORCEINLINE const T *GetFirstEnginePart() const { return (const T *)this->Vehicle::GetFirstEnginePart(); }
    00929
    00934   FORCEINLINE T *GetLastEnginePart() { return (T *)this->Vehicle::GetLastEnginePart(); }
    00935
    00940   FORCEINLINE T *GetNextVehicle() const { return (T *)this->Vehicle::GetNextVehicle(); }
    00941
    00946   FORCEINLINE T *GetPrevVehicle() const { return (T *)this->Vehicle::GetPrevVehicle(); }
    00947
    00953   static FORCEINLINE bool IsValidID(size_t index)
    00954   {
    00955     return Vehicle::IsValidID(index) && Vehicle::Get(index)->type == Type;
    00956   }
    00957
    00962   static FORCEINLINE T *Get(size_t index)
    00963   {
    00964     return (T *)Vehicle::Get(index);
    00965   }
    00966
    00971   static FORCEINLINE T *GetIfValid(size_t index)
    00972   {
    00973     return IsValidID(index) ? Get(index) : NULL;
    00974   }
    00975
    00981   static FORCEINLINE T *From(Vehicle *v)
    00982   {
    00983     assert(v->type == Type);
    00984     return (T *)v;
    00985   }
    00986
    00992   static FORCEINLINE const T *From(const Vehicle *v)
    00993   {
    00994     assert(v->type == Type);
    00995     return (const T *)v;
    00996   }
    00997
    01003   FORCEINLINE void UpdateViewport(bool moved, bool turned)
    01004   {
    01005     extern void VehicleMove(Vehicle *v, bool update_viewport);
    01006
    01007     /* Explicitly choose method to call to prevent vtable dereference -
    01008      * it gives ~3% runtime improvements in games with many vehicles */
    01009     if (turned) ((T *)this)->T::UpdateDeltaXY(this->direction);
    01010     SpriteID old_image = this->cur_image;
    01011     this->cur_image = ((T *)this)->T::GetImage(this->direction);
    01012     if (moved || this->cur_image != old_image) VehicleMove(this, true);
    01013   }
    01014 };
    01015
    01021 #define FOR_ALL_VEHICLES_OF_TYPE(name, var) FOR_ALL_ITEMS_FROM(name, vehicle_index, var, 0) if (var->type == name::EXPECTED_TYPE)
    01022
    01026 struct DisasterVehicle : public SpecializedVehicle<DisasterVehicle, VEH_DISASTER> {
    01027   SpriteID image_override;
    01028   VehicleID big_ufo_destroyer_target;
    01029
    01030   /* @see in_min/max_height_correction in aircraft.h */
    01031   bool in_max_height_correction;
    01032   bool in_min_height_correction;
    01033
    01035   DisasterVehicle() : SpecializedVehicleBase() {}
    01037   virtual ~DisasterVehicle() {}
    01038
    01039   void UpdateDeltaXY(Direction direction);
    01040   bool Tick();
    01041 };
    01042
    01047 #define FOR_ALL_DISASTERVEHICLES(var) FOR_ALL_VEHICLES_OF_TYPE(DisasterVehicle, var)
    01048
    01050 struct FreeUnitIDGenerator {
    01051   bool *cache;
    01052   UnitID maxid;
    01053   UnitID curid;
    01054
    01055   FreeUnitIDGenerator(VehicleType type, CompanyID owner);
    01056   UnitID NextID();
    01057
    01059   ~FreeUnitIDGenerator() { free(this->cache); }
    01060 };
    01061
    01063 static const int32 INVALID_COORD = 0x7fffffff;
    01064
    01065 #endif /* VEHICLE_BASE_H */