# vehicle_base.h

Go to the documentation of this file.

    00001 /* $Id: vehicle_base.h 22993 2011-10-04 20:15:50Z 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
    00026 enum VehStatus {
    00027   VS_HIDDEN          = 0x01,
    00028   VS_STOPPED         = 0x02,
    00029   VS_UNCLICKABLE     = 0x04,
    00030   VS_DEFPAL          = 0x08,
    00031   VS_TRAIN_SLOWING   = 0x10,
    00032   VS_SHADOW          = 0x20,
    00033   VS_AIRCRAFT_BROKEN = 0x40,
    00034   VS_CRASHED         = 0x80,
    00035 };
    00036
    00038 enum VehicleFlags {
    00039   VF_LOADING_FINISHED,
    00040   VF_CARGO_UNLOADING,
    00041   VF_BUILT_AS_PROTOTYPE,
    00042   VF_TIMETABLE_STARTED,
    00043   VF_AUTOFILL_TIMETABLE,
    00044   VF_AUTOFILL_PRES_WAIT_TIME,
    00045   VF_STOP_LOADING,
    00046   VF_PATHFINDER_LOST,
    00047 };
    00048
    00050 enum NewGRFCacheValidValues {
    00051   NCVV_POSITION_CONSIST_LENGTH   = 0,
    00052   NCVV_POSITION_SAME_ID_LENGTH   = 1,
    00053   NCVV_CONSIST_CARGO_INFORMATION = 2,
    00054   NCVV_COMPANY_INFORMATION       = 3,
    00055   NCVV_END,
    00056 };
    00057
    00059 struct NewGRFCache {
    00060   /* Values calculated when they are requested for the first time after invalidating the NewGRF cache. */
    00061   uint32 position_consist_length;
    00062   uint32 position_same_id_length;
    00063   uint32 consist_cargo_information;
    00064   uint32 company_information;
    00065   uint8  cache_valid;
    00066 };
    00067
    00069 enum VisualEffect {
    00070   VE_OFFSET_START        = 0,
    00071   VE_OFFSET_COUNT        = 4,
    00072   VE_OFFSET_CENTRE       = 8,
    00073
    00074   VE_TYPE_START          = 4,
    00075   VE_TYPE_COUNT          = 2,
    00076   VE_TYPE_DEFAULT        = 0,
    00077   VE_TYPE_STEAM          = 1,
    00078   VE_TYPE_DIESEL         = 2,
    00079   VE_TYPE_ELECTRIC       = 3,
    00080
    00081   VE_DISABLE_EFFECT      = 6,
    00082   VE_DISABLE_WAGON_POWER = 7,
    00083
    00084   VE_DEFAULT = 0xFF,
    00085 };
    00086
    00092 enum GroundVehicleSubtypeFlags {
    00093   GVSF_FRONT            = 0,
    00094   GVSF_ARTICULATED_PART = 1,
    00095   GVSF_WAGON            = 2,
    00096   GVSF_ENGINE           = 3,
    00097   GVSF_FREE_WAGON       = 4,
    00098   GVSF_MULTIHEADED      = 5,
    00099 };
    00100
    00102 struct VehicleCache {
    00103   uint16 cached_max_speed;
    00104
    00105   byte cached_vis_effect;
    00106 };
    00107
    00109 typedef Pool<Vehicle, VehicleID, 512, 0xFF000> VehiclePool;
    00110 extern VehiclePool _vehicle_pool;
    00111
    00112 /* Some declarations of functions, so we can make them friendly */
    00113 struct SaveLoad;
    00114 struct GroundVehicleCache;
    00115 extern const SaveLoad *GetVehicleDescription(VehicleType vt);
    00116 struct LoadgameState;
    00117 extern bool LoadOldVehicle(LoadgameState *ls, int num);
    00118 extern void FixOldVehicles();
    00119
    00121 struct Vehicle : VehiclePool::PoolItem<&_vehicle_pool>, BaseVehicle {
    00122 private:
    00123   Vehicle *next;
    00124   Vehicle *previous;
    00125   Vehicle *first;
    00126
    00127   Vehicle *next_shared;
    00128   Vehicle *previous_shared;
    00129 public:
    00130   friend const SaveLoad *GetVehicleDescription(VehicleType vt);
    00131   friend void FixOldVehicles();
    00132   friend void AfterLoadVehicles(bool part_of_load);
    00133   friend bool LoadOldVehicle(LoadgameState *ls, int num);
    00134
    00135   char *name;
    00136
    00137   TileIndex tile;
    00138
    00144   TileIndex dest_tile;
    00145
    00146   Money profit_this_year;
    00147   Money profit_last_year;
    00148   Money value;
    00149
    00150   CargoPayment *cargo_payment;
    00151
    00152   /* Used for timetabling. */
    00153   uint32 current_order_time;
    00154   int32 lateness_counter;
    00155   Date timetable_start;
    00156
    00157   Rect coord;
    00158
    00159   Vehicle *next_hash;
    00160   Vehicle **prev_hash;
    00161
    00162   Vehicle *next_new_hash;
    00163   Vehicle **prev_new_hash;
    00164   Vehicle **old_new_hash;
    00165
    00166   SpriteID colourmap;
    00167
    00168   /* Related to age and service time */
    00169   Year build_year;
    00170   Date age;
    00171   Date max_age;
    00172   Date date_of_last_service;
    00173   Date service_interval;
    00174   uint16 reliability;
    00175   uint16 reliability_spd_dec;
    00176   byte breakdown_ctr;
    00177   byte breakdown_delay;
    00178   byte breakdowns_since_last_service;
    00179   byte breakdown_chance;
    00180
    00181   int32 x_pos;
    00182   int32 y_pos;
    00183   byte z_pos;
    00184   DirectionByte direction;
    00185
    00186   OwnerByte owner;
    00187   byte spritenum;
    00188
    00189
    00190   SpriteID cur_image;
    00191   byte x_extent;
    00192   byte y_extent;
    00193   byte z_extent;
    00194   int8 x_offs;
    00195   int8 y_offs;
    00196   EngineID engine_type;
    00197
    00198   TextEffectID fill_percent_te_id;
    00199   UnitID unitnumber;
    00200
    00201   uint16 cur_speed;
    00202   byte subspeed;
    00203   byte acceleration;
    00204   uint32 motion_counter;
    00205   byte progress;
    00206
    00207   byte random_bits;
    00208   byte waiting_triggers;
    00209
    00210   StationID last_station_visited;
    00211
    00212   CargoID cargo_type;
    00213   byte cargo_subtype;
    00214   uint16 cargo_cap;
    00215   VehicleCargoList cargo;
    00216
    00217   byte day_counter;
    00218   byte tick_counter;
    00219   byte running_ticks;
    00220
    00221   byte vehstatus;
    00222   Order current_order;
    00223   VehicleOrderID cur_real_order_index;
    00224   VehicleOrderID cur_implicit_order_index;
    00225
    00226   union {
    00227     OrderList *list;
    00228     Order     *old;
    00229   } orders;
    00230
    00231   byte vehicle_flags;
    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   FORCEINLINE uint GetOldAdvanceSpeed(uint speed)
    00290   {
    00291     return (this->direction & 1) ? speed : speed * 3 / 4;
    00292   }
    00293
    00306   static FORCEINLINE uint GetAdvanceSpeed(uint speed)
    00307   {
    00308     return speed * 3 / 4;
    00309   }
    00310
    00318   FORCEINLINE 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
    00344   virtual SpriteID GetImage(Direction direction) const { return 0; }
    00345
    00350   FORCEINLINE void InvalidateNewGRFCache()
    00351   {
    00352     this->grf_cache.cache_valid = 0;
    00353   }
    00354
    00359   FORCEINLINE void InvalidateNewGRFCacheOfChain()
    00360   {
    00361     for (Vehicle *u = this; u != NULL; u = u->Next()) {
    00362       u->InvalidateNewGRFCache();
    00363     }
    00364   }
    00365
    00370   FORCEINLINE bool IsGroundVehicle() const
    00371   {
    00372     return this->type == VEH_TRAIN || this->type == VEH_ROAD;
    00373   }
    00374
    00379   virtual int GetDisplaySpeed() const { return 0; }
    00380
    00385   virtual int GetDisplayMaxSpeed() const { return 0; }
    00386
    00391   virtual Money GetRunningCost() const { return 0; }
    00392
    00397   virtual bool IsInDepot() const { return false; }
    00398
    00403   virtual bool IsStoppedInDepot() const { return this->IsInDepot() && (this->vehstatus & VS_STOPPED) != 0; }
    00404
    00409   virtual bool Tick() { return true; };
    00410
    00414   virtual void OnNewDay() {};
    00415
    00421   virtual uint Crash(bool flooded = false);
    00422
    00435   virtual Trackdir GetVehicleTrackdir() const { return INVALID_TRACKDIR; }
    00436
    00441   Money GetDisplayRunningCost() const { return (this->GetRunningCost() >> 8); }
    00442
    00447   Money GetDisplayProfitThisYear() const { return (this->profit_this_year >> 8); }
    00448
    00453   Money GetDisplayProfitLastYear() const { return (this->profit_last_year >> 8); }
    00454
    00455   void SetNext(Vehicle *next);
    00456
    00462   inline Vehicle *Next() const { return this->next; }
    00463
    00469   inline Vehicle *Previous() const { return this->previous; }
    00470
    00475   inline Vehicle *First() const { return this->first; }
    00476
    00481   inline Vehicle *Last()
    00482   {
    00483     Vehicle *v = this;
    00484     while (v->Next() != NULL) v = v->Next();
    00485     return v;
    00486   }
    00487
    00492   inline const Vehicle *Last() const
    00493   {
    00494     const Vehicle *v = this;
    00495     while (v->Next() != NULL) v = v->Next();
    00496     return v;
    00497   }
    00498
    00503   inline Order *GetFirstOrder() const { return (this->orders.list == NULL) ? NULL : this->orders.list->GetFirstOrder(); }
    00504
    00505   void AddToShared(Vehicle *shared_chain);
    00506   void RemoveFromShared();
    00507
    00512   inline Vehicle *NextShared() const { return this->next_shared; }
    00513
    00518   inline Vehicle *PreviousShared() const { return this->previous_shared; }
    00519
    00524   inline Vehicle *FirstShared() const { return (this->orders.list == NULL) ? this->First() : this->orders.list->GetFirstSharedVehicle(); }
    00525
    00530   inline bool IsOrderListShared() const { return this->orders.list != NULL && this->orders.list->IsShared(); }
    00531
    00536   inline VehicleOrderID GetNumOrders() const { return (this->orders.list == NULL) ? 0 : this->orders.list->GetNumOrders(); }
    00537
    00542   inline VehicleOrderID GetNumManualOrders() const { return (this->orders.list == NULL) ? 0 : this->orders.list->GetNumManualOrders(); }
    00543
    00550   inline void CopyVehicleConfigAndStatistics(const Vehicle *src)
    00551   {
    00552     this->unitnumber = src->unitnumber;
    00553
    00554     this->cur_real_order_index = src->cur_real_order_index;
    00555     this->cur_implicit_order_index = src->cur_implicit_order_index;
    00556     this->current_order = src->current_order;
    00557     this->dest_tile  = src->dest_tile;
    00558
    00559     this->profit_this_year = src->profit_this_year;
    00560     this->profit_last_year = src->profit_last_year;
    00561
    00562     this->current_order_time = src->current_order_time;
    00563     this->lateness_counter = src->lateness_counter;
    00564     this->timetable_start = src->timetable_start;
    00565
    00566     if (HasBit(src->vehicle_flags, VF_TIMETABLE_STARTED)) SetBit(this->vehicle_flags, VF_TIMETABLE_STARTED);
    00567     if (HasBit(src->vehicle_flags, VF_AUTOFILL_TIMETABLE)) SetBit(this->vehicle_flags, VF_AUTOFILL_TIMETABLE);
    00568     if (HasBit(src->vehicle_flags, VF_AUTOFILL_PRES_WAIT_TIME)) SetBit(this->vehicle_flags, VF_AUTOFILL_PRES_WAIT_TIME);
    00569
    00570     this->service_interval = src->service_interval;
    00571   }
    00572
    00573
    00574   bool HandleBreakdown();
    00575
    00576   bool NeedsAutorenewing(const Company *c) const;
    00577
    00578   bool NeedsServicing() const;
    00579   bool NeedsAutomaticServicing() const;
    00580
    00588   virtual TileIndex GetOrderStationLocation(StationID station) { return INVALID_TILE; }
    00589
    00598   virtual bool FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse) { return false; }
    00599
    00600   CommandCost SendToDepot(DoCommandFlag flags, DepotCommand command);
    00601
    00602   void UpdateVisualEffect(bool allow_power_change = true);
    00603   void ShowVisualEffect() const;
    00604
    00605 private:
    00610   void SkipToNextRealOrderIndex()
    00611   {
    00612     if (this->GetNumManualOrders() > 0) {
    00613       /* Advance to next real order */
    00614       do {
    00615         this->cur_real_order_index++;
    00616         if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
    00617       } while (this->GetOrder(this->cur_real_order_index)->IsType(OT_IMPLICIT));
    00618     } else {
    00619       this->cur_real_order_index = 0;
    00620     }
    00621   }
    00622
    00623 public:
    00629   void IncrementImplicitOrderIndex()
    00630   {
    00631     if (this->cur_implicit_order_index == this->cur_real_order_index) {
    00632       /* Increment real order index as well */
    00633       this->SkipToNextRealOrderIndex();
    00634     }
    00635
    00636     assert(this->cur_real_order_index == 0 || this->cur_real_order_index < this->GetNumOrders());
    00637
    00638     /* Advance to next implicit order */
    00639     do {
    00640       this->cur_implicit_order_index++;
    00641       if (this->cur_implicit_order_index >= this->GetNumOrders()) this->cur_implicit_order_index = 0;
    00642     } while (this->cur_implicit_order_index != this->cur_real_order_index && !this->GetOrder(this->cur_implicit_order_index)->IsType(OT_IMPLICIT));
    00643
    00644     InvalidateVehicleOrder(this, 0);
    00645   }
    00646
    00653   void IncrementRealOrderIndex()
    00654   {
    00655     if (this->cur_implicit_order_index == this->cur_real_order_index) {
    00656       /* Increment both real and implicit order */
    00657       this->IncrementImplicitOrderIndex();
    00658     } else {
    00659       /* Increment real order only */
    00660       this->SkipToNextRealOrderIndex();
    00661       InvalidateVehicleOrder(this, 0);
    00662     }
    00663   }
    00664
    00668   void UpdateRealOrderIndex()
    00669   {
    00670     /* Make sure the index is valid */
    00671     if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
    00672
    00673     if (this->GetNumManualOrders() > 0) {
    00674       /* Advance to next real order */
    00675       while (this->GetOrder(this->cur_real_order_index)->IsType(OT_IMPLICIT)) {
    00676         this->cur_real_order_index++;
    00677         if (this->cur_real_order_index >= this->GetNumOrders()) this->cur_real_order_index = 0;
    00678       }
    00679     } else {
    00680       this->cur_real_order_index = 0;
    00681     }
    00682   }
    00683
    00689   inline Order *GetOrder(int index) const
    00690   {
    00691     return (this->orders.list == NULL) ? NULL : this->orders.list->GetOrderAt(index);
    00692   }
    00693
    00698   inline Order *GetLastOrder() const
    00699   {
    00700     return (this->orders.list == NULL) ? NULL : this->orders.list->GetLastOrder();
    00701   }
    00702
    00703   bool IsEngineCountable() const;
    00704   bool HasEngineType() const;
    00705   bool HasDepotOrder() const;
    00706   void HandlePathfindingResult(bool path_found);
    00707
    00712   FORCEINLINE bool IsFrontEngine() const
    00713   {
    00714     return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_FRONT);
    00715   }
    00716
    00721   FORCEINLINE bool IsArticulatedPart() const
    00722   {
    00723     return this->IsGroundVehicle() && HasBit(this->subtype, GVSF_ARTICULATED_PART);
    00724   }
    00725
    00730   FORCEINLINE bool HasArticulatedPart() const
    00731   {
    00732     return this->Next() != NULL && this->Next()->IsArticulatedPart();
    00733   }
    00734
    00740   FORCEINLINE Vehicle *GetNextArticulatedPart() const
    00741   {
    00742     assert(this->HasArticulatedPart());
    00743     return this->Next();
    00744   }
    00745
    00750   FORCEINLINE Vehicle *GetFirstEnginePart()
    00751   {
    00752     Vehicle *v = this;
    00753     while (v->IsArticulatedPart()) v = v->Previous();
    00754     return v;
    00755   }
    00756
    00761   FORCEINLINE const Vehicle *GetFirstEnginePart() const
    00762   {
    00763     const Vehicle *v = this;
    00764     while (v->IsArticulatedPart()) v = v->Previous();
    00765     return v;
    00766   }
    00767
    00772   FORCEINLINE Vehicle *GetLastEnginePart()
    00773   {
    00774     Vehicle *v = this;
    00775     while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart();
    00776     return v;
    00777   }
    00778
    00783   FORCEINLINE Vehicle *GetNextVehicle() const
    00784   {
    00785     const Vehicle *v = this;
    00786     while (v->HasArticulatedPart()) v = v->GetNextArticulatedPart();
    00787
    00788     /* v now contains the last articulated part in the engine */
    00789     return v->Next();
    00790   }
    00791
    00796   FORCEINLINE Vehicle *GetPrevVehicle() const
    00797   {
    00798     Vehicle *v = this->Previous();
    00799     while (v != NULL && v->IsArticulatedPart()) v = v->Previous();
    00800
    00801     return v;
    00802   }
    00803 };
    00804
    00810 #define FOR_ALL_VEHICLES_FROM(var, start) FOR_ALL_ITEMS_FROM(Vehicle, vehicle_index, var, start)
    00811
    00816 #define FOR_ALL_VEHICLES(var) FOR_ALL_VEHICLES_FROM(var, 0)
    00817
    00822 template <class T, VehicleType Type>
    00823 struct SpecializedVehicle : public Vehicle {
    00824   static const VehicleType EXPECTED_TYPE = Type;
    00825
    00826   typedef SpecializedVehicle<T, Type> SpecializedVehicleBase;
    00827
    00831   FORCEINLINE SpecializedVehicle<T, Type>() : Vehicle(Type) { }
    00832
    00837   FORCEINLINE T *First() const { return (T *)this->Vehicle::First(); }
    00838
    00843   FORCEINLINE T *Last() { return (T *)this->Vehicle::Last(); }
    00844
    00849   FORCEINLINE const T *Last() const { return (const T *)this->Vehicle::Last(); }
    00850
    00855   FORCEINLINE T *Next() const { return (T *)this->Vehicle::Next(); }
    00856
    00861   FORCEINLINE T *Previous() const { return (T *)this->Vehicle::Previous(); }
    00862
    00868   FORCEINLINE T *GetNextArticulatedPart() { return (T *)this->Vehicle::GetNextArticulatedPart(); }
    00869
    00875   FORCEINLINE T *GetNextArticulatedPart() const { return (T *)this->Vehicle::GetNextArticulatedPart(); }
    00876
    00881   FORCEINLINE T *GetFirstEnginePart() { return (T *)this->Vehicle::GetFirstEnginePart(); }
    00882
    00887   FORCEINLINE const T *GetFirstEnginePart() const { return (const T *)this->Vehicle::GetFirstEnginePart(); }
    00888
    00893   FORCEINLINE T *GetLastEnginePart() { return (T *)this->Vehicle::GetLastEnginePart(); }
    00894
    00899   FORCEINLINE T *GetNextVehicle() const { return (T *)this->Vehicle::GetNextVehicle(); }
    00900
    00905   FORCEINLINE T *GetPrevVehicle() const { return (T *)this->Vehicle::GetPrevVehicle(); }
    00906
    00912   static FORCEINLINE bool IsValidID(size_t index)
    00913   {
    00914     return Vehicle::IsValidID(index) && Vehicle::Get(index)->type == Type;
    00915   }
    00916
    00921   static FORCEINLINE T *Get(size_t index)
    00922   {
    00923     return (T *)Vehicle::Get(index);
    00924   }
    00925
    00930   static FORCEINLINE T *GetIfValid(size_t index)
    00931   {
    00932     return IsValidID(index) ? Get(index) : NULL;
    00933   }
    00934
    00940   static FORCEINLINE T *From(Vehicle *v)
    00941   {
    00942     assert(v->type == Type);
    00943     return (T *)v;
    00944   }
    00945
    00951   static FORCEINLINE const T *From(const Vehicle *v)
    00952   {
    00953     assert(v->type == Type);
    00954     return (const T *)v;
    00955   }
    00956
    00962   FORCEINLINE void UpdateViewport(bool moved, bool turned)
    00963   {
    00964     extern void VehicleMove(Vehicle *v, bool update_viewport);
    00965
    00966     /* Explicitly choose method to call to prevent vtable dereference -
    00967      * it gives ~3% runtime improvements in games with many vehicles */
    00968     if (turned) ((T *)this)->T::UpdateDeltaXY(this->direction);
    00969     SpriteID old_image = this->cur_image;
    00970     this->cur_image = ((T *)this)->T::GetImage(this->direction);
    00971     if (moved || this->cur_image != old_image) VehicleMove(this, true);
    00972   }
    00973 };
    00974
    00980 #define FOR_ALL_VEHICLES_OF_TYPE(name, var) FOR_ALL_ITEMS_FROM(name, vehicle_index, var, 0) if (var->type == name::EXPECTED_TYPE)
    00981
    00985 struct DisasterVehicle : public SpecializedVehicle<DisasterVehicle, VEH_DISASTER> {
    00986   SpriteID image_override;
    00987   VehicleID big_ufo_destroyer_target;
    00988
    00990   DisasterVehicle() : SpecializedVehicleBase() {}
    00992   virtual ~DisasterVehicle() {}
    00993
    00994   void UpdateDeltaXY(Direction direction);
    00995   bool Tick();
    00996 };
    00997
    01002 #define FOR_ALL_DISASTERVEHICLES(var) FOR_ALL_VEHICLES_OF_TYPE(DisasterVehicle, var)
    01003
    01005 struct FreeUnitIDGenerator {
    01006   bool *cache;
    01007   UnitID maxid;
    01008   UnitID curid;
    01009
    01010   FreeUnitIDGenerator(VehicleType type, CompanyID owner);
    01011   UnitID NextID();
    01012
    01014   ~FreeUnitIDGenerator() { free(this->cache); }
    01015 };
    01016
    01018 static const int32 INVALID_COORD = 0x7fffffff;
    01019
    01020 #endif /* VEHICLE_BASE_H */