vehicle_base.h

Go to the documentation of this file.
00001 /* $Id: vehicle_base.h 24998 2013-02-14 17:24:55Z rubidium $ */
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 "base_consist.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_PATHFINDER_LOST,         
00048   VF_SERVINT_IS_CUSTOM,       
00049   VF_SERVINT_IS_PERCENT,      
00050 };
00051 
00053 enum NewGRFCacheValidValues {
00054   NCVV_POSITION_CONSIST_LENGTH   = 0, 
00055   NCVV_POSITION_SAME_ID_LENGTH   = 1, 
00056   NCVV_CONSIST_CARGO_INFORMATION = 2, 
00057   NCVV_COMPANY_INFORMATION       = 3, 
00058   NCVV_END,                           
00059 };
00060 
00062 struct NewGRFCache {
00063   /* Values calculated when they are requested for the first time after invalidating the NewGRF cache. */
00064   uint32 position_consist_length;   
00065   uint32 position_same_id_length;   
00066   uint32 consist_cargo_information; 
00067   uint32 company_information;       
00068   uint8  cache_valid;               
00069 };
00070 
00072 enum VisualEffect {
00073   VE_OFFSET_START        = 0, 
00074   VE_OFFSET_COUNT        = 4, 
00075   VE_OFFSET_CENTRE       = 8, 
00076 
00077   VE_TYPE_START          = 4, 
00078   VE_TYPE_COUNT          = 2, 
00079   VE_TYPE_DEFAULT        = 0, 
00080   VE_TYPE_STEAM          = 1, 
00081   VE_TYPE_DIESEL         = 2, 
00082   VE_TYPE_ELECTRIC       = 3, 
00083 
00084   VE_DISABLE_EFFECT      = 6, 
00085   VE_DISABLE_WAGON_POWER = 7, 
00086 
00087   VE_DEFAULT = 0xFF,          
00088 };
00089 
00095 enum GroundVehicleSubtypeFlags {
00096   GVSF_FRONT            = 0, 
00097   GVSF_ARTICULATED_PART = 1, 
00098   GVSF_WAGON            = 2, 
00099   GVSF_ENGINE           = 3, 
00100   GVSF_FREE_WAGON       = 4, 
00101   GVSF_MULTIHEADED      = 5, 
00102 };
00103 
00105 struct VehicleCache {
00106   uint16 cached_max_speed;        
00107   uint16 cached_cargo_age_period; 
00108 
00109   byte cached_vis_effect;  
00110 };
00111 
00113 typedef Pool<Vehicle, VehicleID, 512, 0xFF000> VehiclePool;
00114 extern VehiclePool _vehicle_pool;
00115 
00116 /* Some declarations of functions, so we can make them friendly */
00117 struct SaveLoad;
00118 struct GroundVehicleCache;
00119 extern const SaveLoad *GetVehicleDescription(VehicleType vt);
00120 struct LoadgameState;
00121 extern bool LoadOldVehicle(LoadgameState *ls, int num);
00122 extern void FixOldVehicles();
00123 
00124 struct GRFFile;
00125 
00127 struct Vehicle : VehiclePool::PoolItem<&_vehicle_pool>, BaseVehicle, BaseConsist {
00128 private:
00129   Vehicle *next;                      
00130   Vehicle *previous;                  
00131   Vehicle *first;                     
00132 
00133   Vehicle *next_shared;               
00134   Vehicle *previous_shared;           
00135 public:
00136   friend const SaveLoad *GetVehicleDescription(VehicleType vt); 
00137   friend void FixOldVehicles();
00138   friend void AfterLoadVehicles(bool part_of_load);             
00139   friend bool LoadOldVehicle(LoadgameState *ls, int num);       
00140 
00141   TileIndex tile;                     
00142 
00148   TileIndex dest_tile;
00149 
00150   Money profit_this_year;             
00151   Money profit_last_year;             
00152   Money value;                        
00153 
00154   CargoPayment *cargo_payment;        
00155 
00156   Rect coord;                         
00157 
00158   Vehicle *hash_viewport_next;        
00159   Vehicle **hash_viewport_prev;       
00160 
00161   Vehicle *hash_tile_next;            
00162   Vehicle **hash_tile_prev;           
00163   Vehicle **hash_tile_current;        
00164 
00165   SpriteID colourmap;                 
00166 
00167   /* Related to age and service time */
00168   Year build_year;                    
00169   Date age;                           
00170   Date max_age;                       
00171   Date date_of_last_service;          
00172   uint16 reliability;                 
00173   uint16 reliability_spd_dec;         
00174   byte breakdown_ctr;                 
00175   byte breakdown_delay;               
00176   byte breakdowns_since_last_service; 
00177   byte breakdown_chance;              
00178 
00179   int32 x_pos;                        
00180   int32 y_pos;                        
00181   int32 z_pos;                        
00182   DirectionByte direction;            
00183 
00184   OwnerByte owner;                    
00185 
00190   byte spritenum;
00191   SpriteID cur_image;                 
00192   byte x_extent;                      
00193   byte y_extent;                      
00194   byte z_extent;                      
00195   int8 x_bb_offs;                     
00196   int8 y_bb_offs;                     
00197   int8 x_offs;                        
00198   int8 y_offs;                        
00199   EngineID engine_type;               
00200 
00201   TextEffectID fill_percent_te_id;    
00202   UnitID unitnumber;                  
00203 
00204   uint16 cur_speed;                   
00205   byte subspeed;                      
00206   byte acceleration;                  
00207   uint32 motion_counter;              
00208   byte progress;                      
00209 
00210   byte random_bits;                   
00211   byte waiting_triggers;              
00212 
00213   StationID last_station_visited;     
00214 
00215   CargoID cargo_type;                 
00216   byte cargo_subtype;                 
00217   uint16 cargo_cap;                   
00218   VehicleCargoList cargo;             
00219   uint16 cargo_age_counter;           
00220 
00221   byte day_counter;                   
00222   byte tick_counter;                  
00223   byte running_ticks;                 
00224 
00225   byte vehstatus;                     
00226   Order current_order;                
00227 
00228   union {
00229     OrderList *list;            
00230     Order     *old;             
00231   } orders;                           
00232 
00233   uint16 load_unload_ticks;           
00234   GroupID group_id;                   
00235   byte subtype;                       
00236 
00237   NewGRFCache grf_cache;              
00238   VehicleCache vcache;                
00239 
00240   Vehicle(VehicleType type = VEH_INVALID);
00241 
00242   void PreDestructor();
00244   virtual ~Vehicle();
00245 
00246   void BeginLoading();
00247   void LeaveStation();
00248 
00249   GroundVehicleCache *GetGroundVehicleCache();
00250   const GroundVehicleCache *GetGroundVehicleCache() const;
00251 
00252   uint16 &GetGroundVehicleFlags();
00253   const uint16 &GetGroundVehicleFlags() const;
00254 
00255   void DeleteUnreachedImplicitOrders();
00256 
00257   void HandleLoading(bool mode = false);
00258 
00267   virtual void MarkDirty() {}
00268 
00274   virtual void UpdateDeltaXY(Direction direction) {}
00275 
00289   inline uint GetOldAdvanceSpeed(uint speed)
00290   {
00291     return (this->direction & 1) ? speed : speed * 3 / 4;
00292   }
00293 
00306   static inline uint GetAdvanceSpeed(uint speed)
00307   {
00308     return speed * 3 / 4;
00309   }
00310 
00318   inline uint GetAdvanceDistance()
00319   {
00320     return (this->direction & 1) ? 192 : 256;
00321   }
00322 
00327   virtual ExpensesType GetExpenseType(bool income) const { return EXPENSES_OTHER; }
00328 
00332   virtual void PlayLeaveStationSound() const {}
00333 
00337   virtual bool IsPrimaryVehicle() const { return false; }
00338 
00339   const Engine *GetEngine() const;
00340 
00346   virtual SpriteID GetImage(Direction direction, EngineImageType image_type) const { return 0; }
00347 
00348   const GRFFile *GetGRF() const;
00349   uint32 GetGRFID() const;
00350 
00355   inline void InvalidateNewGRFCache()
00356   {
00357     this->grf_cache.cache_valid = 0;
00358   }
00359 
00364   inline void InvalidateNewGRFCacheOfChain()
00365   {
00366     for (Vehicle *u = this; u != NULL; u = u->Next()) {
00367       u->InvalidateNewGRFCache();
00368     }
00369   }
00370 
00375   inline bool IsGroundVehicle() const
00376   {
00377     return this->type == VEH_TRAIN || this->type == VEH_ROAD;
00378   }
00379 
00384   virtual int GetDisplaySpeed() const { return 0; }
00385 
00390   virtual int GetDisplayMaxSpeed() const { return 0; }
00391 
00396   virtual int GetCurrentMaxSpeed() const { return 0; }
00397 
00402   virtual Money GetRunningCost() const { return 0; }
00403 
00408   virtual bool IsInDepot() const { return false; }
00409 
00414   virtual bool IsChainInDepot() const { return this->IsInDepot(); }
00415 
00420   bool IsStoppedInDepot() const
00421   {
00422     assert(this == this->First());
00423     /* Free wagons have no VS_STOPPED state */
00424     if (this->IsPrimaryVehicle() && !(this->vehstatus & VS_STOPPED)) return false;
00425     return this->IsChainInDepot();
00426   }
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 
00527   inline Vehicle *Move(int n)
00528   {
00529     Vehicle *v = this;
00530     if (n < 0) {
00531       for (int i = 0; i != n && v != NULL; i--) v = v->Previous();
00532     } else {
00533       for (int i = 0; i != n && v != NULL; i++) v = v->Next();
00534     }
00535     return v;
00536   }
00537 
00543   inline const Vehicle *Move(int n) const
00544   {
00545     const Vehicle *v = this;
00546     if (n < 0) {
00547       for (int i = 0; i != n && v != NULL; i--) v = v->Previous();
00548     } else {
00549       for (int i = 0; i != n && v != NULL; i++) v = v->Next();
00550     }
00551     return v;
00552   }
00553 
00558   inline Order *GetFirstOrder() const { return (this->orders.list == NULL) ? NULL : this->orders.list->GetFirstOrder(); }
00559 
00560   void AddToShared(Vehicle *shared_chain);
00561   void RemoveFromShared();
00562 
00567   inline Vehicle *NextShared() const { return this->next_shared; }
00568 
00573   inline Vehicle *PreviousShared() const { return this->previous_shared; }
00574 
00579   inline Vehicle *FirstShared() const { return (this->orders.list == NULL) ? this->First() : this->orders.list->GetFirstSharedVehicle(); }
00580 
00585   inline bool IsOrderListShared() const { return this->orders.list != NULL && this->orders.list->IsShared(); }
00586 
00591   inline VehicleOrderID GetNumOrders() const { return (this->orders.list == NULL) ? 0 : this->orders.list->GetNumOrders(); }
00592 
00597   inline VehicleOrderID GetNumManualOrders() const { return (this->orders.list == NULL) ? 0 : this->orders.list->GetNumManualOrders(); }
00598 
00605   inline void CopyVehicleConfigAndStatistics(const Vehicle *src)
00606   {
00607     this->CopyConsistPropertiesFrom(src);
00608 
00609     this->unitnumber = src->unitnumber;
00610 
00611     this->current_order = src->current_order;
00612     this->dest_tile  = src->dest_tile;
00613 
00614     this->profit_this_year = src->profit_this_year;
00615     this->profit_last_year = src->profit_last_year;
00616   }
00617 
00618 
00619   bool HandleBreakdown();
00620 
00621   bool NeedsAutorenewing(const Company *c, bool use_renew_setting = true) const;
00622 
00623   bool NeedsServicing() const;
00624   bool NeedsAutomaticServicing() const;
00625 
00633   virtual TileIndex GetOrderStationLocation(StationID station) { return INVALID_TILE; }
00634 
00643   virtual bool FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse) { return false; }
00644 
00645   CommandCost SendToDepot(DoCommandFlag flags, DepotCommand command);
00646 
00647   void UpdateVisualEffect(bool allow_power_change = true);
00648   void ShowVisualEffect() const;
00649 
00650   inline uint16 GetServiceInterval() const { return this->service_interval; }
00651 
00652   inline void SetServiceInterval(uint16 interval) { this->service_interval = interval; }
00653 
00654   inline bool ServiceIntervalIsCustom() const { return HasBit(this->vehicle_flags, VF_SERVINT_IS_CUSTOM); }
00655 
00656   inline bool ServiceIntervalIsPercent() const { return HasBit(this->vehicle_flags, VF_SERVINT_IS_PERCENT); }
00657 
00658   inline void SetServiceIntervalIsCustom(bool on) { SB(this->vehicle_flags, VF_SERVINT_IS_CUSTOM, 1, on); }
00659 
00660   inline void SetServiceIntervalIsPercent(bool on) { SB(this->vehicle_flags, VF_SERVINT_IS_PERCENT, 1, on); }
00661 
00662 private:
00667   void SkipToNextRealOrderIndex()
00668   {
00669     if (this->GetNumManualOrders() > 0) {
00670       /* Advance to next real order */
00671       do {
00672         this->cur_real_order_index++;
00673         if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
00674       } while (this->GetOrder(this->cur_real_order_index)->IsType(OT_IMPLICIT));
00675     } else {
00676       this->cur_real_order_index = 0;
00677     }
00678   }
00679 
00680 public:
00686   void IncrementImplicitOrderIndex()
00687   {
00688     if (this->cur_implicit_order_index == this->cur_real_order_index) {
00689       /* Increment real order index as well */
00690       this->SkipToNextRealOrderIndex();
00691     }
00692 
00693     assert(this->cur_real_order_index == 0 || this->cur_real_order_index < this->GetNumOrders());
00694 
00695     /* Advance to next implicit order */
00696     do {
00697       this->cur_implicit_order_index++;
00698       if (this->cur_implicit_order_index >= this->GetNumOrders()) this->cur_implicit_order_index = 0;
00699     } while (this->cur_implicit_order_index != this->cur_real_order_index && !this->GetOrder(this->cur_implicit_order_index)->IsType(OT_IMPLICIT));
00700 
00701     InvalidateVehicleOrder(this, 0);
00702   }
00703 
00710   void IncrementRealOrderIndex()
00711   {
00712     if (this->cur_implicit_order_index == this->cur_real_order_index) {
00713       /* Increment both real and implicit order */
00714       this->IncrementImplicitOrderIndex();
00715     } else {
00716       /* Increment real order only */
00717       this->SkipToNextRealOrderIndex();
00718       InvalidateVehicleOrder(this, 0);
00719     }
00720   }
00721 
00725   void UpdateRealOrderIndex()
00726   {
00727     /* Make sure the index is valid */
00728     if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
00729 
00730     if (this->GetNumManualOrders() > 0) {
00731       /* Advance to next real order */
00732       while (this->GetOrder(this->cur_real_order_index)->IsType(OT_IMPLICIT)) {
00733         this->cur_real_order_index++;
00734         if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
00735       }
00736     } else {
00737       this->cur_real_order_index = 0;
00738     }
00739   }
00740 
00746   inline Order *GetOrder(int index) const
00747   {
00748     return (this->orders.list == NULL) ? NULL : this->orders.list->GetOrderAt(index);
00749   }
00750 
00755   inline Order *GetLastOrder() const
00756   {
00757     return (this->orders.list == NULL) ? NULL : this->orders.list->GetLastOrder();
00758   }
00759 
00760   bool IsEngineCountable() const;
00761   bool HasEngineType() const;
00762   bool HasDepotOrder() const;
00763   void HandlePathfindingResult(bool path_found);
00764 
00769   inline bool IsFrontEngine() const
00770   {
00771     return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_FRONT);
00772   }
00773 
00778   inline bool IsArticulatedPart() const
00779   {
00780     return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_ARTICULATED_PART);
00781   }
00782 
00787   inline bool HasArticulatedPart() const
00788   {
00789     return this->Next() != NULL && this->Next()->IsArticulatedPart();
00790   }
00791 
00797   inline Vehicle *GetNextArticulatedPart() const
00798   {
00799     assert(this->HasArticulatedPart());
00800     return this->Next();
00801   }
00802 
00807   inline Vehicle *GetFirstEnginePart()
00808   {
00809     Vehicle *v = this;
00810     while (v->IsArticulatedPart()) v = v->Previous();
00811     return v;
00812   }
00813 
00818   inline const Vehicle *GetFirstEnginePart() const
00819   {
00820     const Vehicle *v = this;
00821     while (v->IsArticulatedPart()) v = v->Previous();
00822     return v;
00823   }
00824 
00829   inline Vehicle *GetLastEnginePart()
00830   {
00831     Vehicle *v = this;
00832     while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart();
00833     return v;
00834   }
00835 
00840   inline Vehicle *GetNextVehicle() const
00841   {
00842     const Vehicle *v = this;
00843     while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart();
00844 
00845     /* v now contains the last articulated part in the engine */
00846     return v->Next();
00847   }
00848 
00853   inline Vehicle *GetPrevVehicle() const
00854   {
00855     Vehicle *v = this->Previous();
00856     while (v != NULL && v->IsArticulatedPart()) v = v->Previous();
00857 
00858     return v;
00859   }
00860 };
00861 
00867 #define FOR_ALL_VEHICLES_FROM(var, start) FOR_ALL_ITEMS_FROM(Vehicle, vehicle_index, var, start)
00868 
00873 #define FOR_ALL_VEHICLES(var) FOR_ALL_VEHICLES_FROM(var, 0)
00874 
00879 template <class T, VehicleType Type>
00880 struct SpecializedVehicle : public Vehicle {
00881   static const VehicleType EXPECTED_TYPE = Type; 
00882 
00883   typedef SpecializedVehicle<T, Type> SpecializedVehicleBase; 
00884 
00888   inline SpecializedVehicle<T, Type>() : Vehicle(Type) { }
00889 
00894   inline T *First() const { return (T *)this->Vehicle::First(); }
00895 
00900   inline T *Last() { return (T *)this->Vehicle::Last(); }
00901 
00906   inline const T *Last() const { return (const T *)this->Vehicle::Last(); }
00907 
00912   inline T *Next() const { return (T *)this->Vehicle::Next(); }
00913 
00918   inline T *Previous() const { return (T *)this->Vehicle::Previous(); }
00919 
00925   inline T *GetNextArticulatedPart() { return (T *)this->Vehicle::GetNextArticulatedPart(); }
00926 
00932   inline T *GetNextArticulatedPart() const { return (T *)this->Vehicle::GetNextArticulatedPart(); }
00933 
00938   inline T *GetFirstEnginePart() { return (T *)this->Vehicle::GetFirstEnginePart(); }
00939 
00944   inline const T *GetFirstEnginePart() const { return (const T *)this->Vehicle::GetFirstEnginePart(); }
00945 
00950   inline T *GetLastEnginePart() { return (T *)this->Vehicle::GetLastEnginePart(); }
00951 
00956   inline T *GetNextVehicle() const { return (T *)this->Vehicle::GetNextVehicle(); }
00957 
00962   inline T *GetPrevVehicle() const { return (T *)this->Vehicle::GetPrevVehicle(); }
00963 
00969   static inline bool IsValidID(size_t index)
00970   {
00971     return Vehicle::IsValidID(index) && Vehicle::Get(index)->type == Type;
00972   }
00973 
00978   static inline T *Get(size_t index)
00979   {
00980     return (T *)Vehicle::Get(index);
00981   }
00982 
00987   static inline T *GetIfValid(size_t index)
00988   {
00989     return IsValidID(index) ? Get(index) : NULL;
00990   }
00991 
00997   static inline T *From(Vehicle *v)
00998   {
00999     assert(v->type == Type);
01000     return (T *)v;
01001   }
01002 
01008   static inline const T *From(const Vehicle *v)
01009   {
01010     assert(v->type == Type);
01011     return (const T *)v;
01012   }
01013 
01019   inline void UpdateViewport(bool force_update, bool update_delta)
01020   {
01021     extern void VehicleUpdateViewport(Vehicle *v, bool dirty);
01022 
01023     /* Explicitly choose method to call to prevent vtable dereference -
01024      * it gives ~3% runtime improvements in games with many vehicles */
01025     if (update_delta) ((T *)this)->T::UpdateDeltaXY(this->direction);
01026     SpriteID old_image = this->cur_image;
01027     this->cur_image = ((T *)this)->T::GetImage(this->direction, EIT_ON_MAP);
01028     if (force_update || this->cur_image != old_image) VehicleUpdateViewport(this, true);
01029   }
01030 };
01031 
01037 #define FOR_ALL_VEHICLES_OF_TYPE(name, var) FOR_ALL_ITEMS_FROM(name, vehicle_index, var, 0) if (var->type == name::EXPECTED_TYPE)
01038 
01042 struct DisasterVehicle FINAL : public SpecializedVehicle<DisasterVehicle, VEH_DISASTER> {
01043   SpriteID image_override;            
01044   VehicleID big_ufo_destroyer_target; 
01045 
01047   DisasterVehicle() : SpecializedVehicleBase() {}
01049   virtual ~DisasterVehicle() {}
01050 
01051   void UpdateDeltaXY(Direction direction);
01052   bool Tick();
01053 };
01054 
01059 #define FOR_ALL_DISASTERVEHICLES(var) FOR_ALL_VEHICLES_OF_TYPE(DisasterVehicle, var)
01060 
01062 struct FreeUnitIDGenerator {
01063   bool *cache;  
01064   UnitID maxid; 
01065   UnitID curid; 
01066 
01067   FreeUnitIDGenerator(VehicleType type, CompanyID owner);
01068   UnitID NextID();
01069 
01071   ~FreeUnitIDGenerator() { free(this->cache); }
01072 };
01073 
01075 static const int32 INVALID_COORD = 0x7fffffff;
01076 
01077 #endif /* VEHICLE_BASE_H */