order_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 ORDER_BASE_H
00013 #define ORDER_BASE_H
00014 
00015 #include "order_type.h"
00016 #include "core/pool_type.hpp"
00017 #include "core/bitmath_func.hpp"
00018 #include "cargo_type.h"
00019 #include "depot_type.h"
00020 #include "station_type.h"
00021 #include "vehicle_type.h"
00022 #include "date_type.h"
00023 
00024 typedef Pool<Order, OrderID, 256, 64000> OrderPool;
00025 typedef Pool<OrderList, OrderListID, 128, 64000> OrderListPool;
00026 extern OrderPool _order_pool;
00027 extern OrderListPool _orderlist_pool;
00028 
00029 /* If you change this, keep in mind that it is saved on 3 places:
00030  * - Load_ORDR, all the global orders
00031  * - Vehicle -> current_order
00032  * - REF_ORDER (all REFs are currently limited to 16 bits!!)
00033  */
00034 struct Order : OrderPool::PoolItem<&_order_pool> {
00035 private:
00036   friend const struct SaveLoad *GetVehicleDescription(VehicleType vt); 
00037   friend void Load_VEHS();                                             
00038   friend const struct SaveLoad *GetOrderDescription();                 
00039 
00040   uint8 type;           
00041   uint8 flags;          
00042   DestinationID dest;   
00043 
00044   CargoID refit_cargo;  
00045   byte refit_subtype;   
00046 
00047 public:
00048   Order *next;          
00049 
00050   uint16 wait_time;    
00051   uint16 travel_time;  
00052 
00053   Order() : refit_cargo(CT_NO_REFIT) {}
00054   ~Order() {}
00055 
00056   Order(uint32 packed);
00057 
00063   inline bool IsType(OrderType type) const { return this->GetType() == type; }
00064 
00069   inline OrderType GetType() const { return (OrderType)GB(this->type, 0, 4); }
00070 
00071   void Free();
00072 
00073   void MakeGoToStation(StationID destination);
00074   void MakeGoToDepot(DepotID destination, OrderDepotTypeFlags order, OrderNonStopFlags non_stop_type = ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS, OrderDepotActionFlags action = ODATF_SERVICE_ONLY, CargoID cargo = CT_NO_REFIT, byte subtype = 0);
00075   void MakeGoToWaypoint(StationID destination);
00076   void MakeLoading(bool ordered);
00077   void MakeLeaveStation();
00078   void MakeDummy();
00079   void MakeConditional(VehicleOrderID order);
00080   void MakeAutomatic(StationID destination);
00081 
00087   inline DestinationID GetDestination() const { return this->dest; }
00088 
00094   inline void SetDestination(DestinationID destination) { this->dest = destination; }
00095 
00101   inline bool IsRefit() const { return this->refit_cargo < NUM_CARGO; }
00102 
00108   inline CargoID GetRefitCargo() const { return this->refit_cargo; }
00109 
00115   inline byte GetRefitSubtype() const { return this->refit_subtype; }
00116 
00117   void SetRefit(CargoID cargo, byte subtype = 0);
00118 
00120   inline OrderLoadFlags GetLoadType() const { return (OrderLoadFlags)GB(this->flags, 4, 4); }
00122   inline OrderUnloadFlags GetUnloadType() const { return (OrderUnloadFlags)GB(this->flags, 0, 4); }
00124   inline OrderNonStopFlags GetNonStopType() const { return (OrderNonStopFlags)GB(this->type, 6, 2); }
00126   inline OrderStopLocation GetStopLocation() const { return (OrderStopLocation)GB(this->type, 4, 2); }
00128   inline OrderDepotTypeFlags GetDepotOrderType() const { return (OrderDepotTypeFlags)GB(this->flags, 0, 4); }
00130   inline OrderDepotActionFlags GetDepotActionType() const { return (OrderDepotActionFlags)GB(this->flags, 4, 4); }
00132   inline OrderConditionVariable GetConditionVariable() const { return (OrderConditionVariable)GB(this->dest, 11, 5); }
00134   inline OrderConditionComparator GetConditionComparator() const { return (OrderConditionComparator)GB(this->type, 5, 3); }
00136   inline VehicleOrderID GetConditionSkipToOrder() const { return this->flags; }
00138   inline uint16 GetConditionValue() const { return GB(this->dest, 0, 11); }
00139 
00141   inline void SetLoadType(OrderLoadFlags load_type) { SB(this->flags, 4, 4, load_type); }
00143   inline void SetUnloadType(OrderUnloadFlags unload_type) { SB(this->flags, 0, 4, unload_type); }
00145   inline void SetNonStopType(OrderNonStopFlags non_stop_type) { SB(this->type, 6, 2, non_stop_type); }
00147   inline void SetStopLocation(OrderStopLocation stop_location) { SB(this->type, 4, 2, stop_location); }
00149   inline void SetDepotOrderType(OrderDepotTypeFlags depot_order_type) { SB(this->flags, 0, 4, depot_order_type); }
00151   inline void SetDepotActionType(OrderDepotActionFlags depot_service_type) { SB(this->flags, 4, 4, depot_service_type); }
00153   inline void SetConditionVariable(OrderConditionVariable condition_variable) { SB(this->dest, 11, 5, condition_variable); }
00155   inline void SetConditionComparator(OrderConditionComparator condition_comparator) { SB(this->type, 5, 3, condition_comparator); }
00157   inline void SetConditionSkipToOrder(VehicleOrderID order_id) { this->flags = order_id; }
00159   inline void SetConditionValue(uint16 value) { SB(this->dest, 0, 11, value); }
00160 
00161   bool ShouldStopAtStation(const Vehicle *v, StationID station) const;
00162   TileIndex GetLocation(const Vehicle *v) const;
00163 
00165   inline bool IsCompletelyTimetabled() const
00166   {
00167     if (this->travel_time == 0 && !this->IsType(OT_CONDITIONAL)) return false;
00168     if (this->wait_time == 0 && this->IsType(OT_GOTO_STATION) && !(this->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION)) return false;
00169     return true;
00170   }
00171 
00172   void AssignOrder(const Order &other);
00173   bool Equals(const Order &other) const;
00174 
00175   uint32 Pack() const;
00176   uint16 MapOldOrder() const;
00177   void ConvertFromOldSavegame();
00178 
00179   static void PostDestructor(size_t index);
00180 };
00181 
00182 void InsertOrder(Vehicle *v, Order *new_o, VehicleOrderID sel_ord);
00183 void DeleteOrder(Vehicle *v, VehicleOrderID sel_ord);
00184 
00189 struct OrderList : OrderListPool::PoolItem<&_orderlist_pool> {
00190 private:
00191   friend void AfterLoadVehicles(bool part_of_load); 
00192   friend const struct SaveLoad *GetOrderListDescription(); 
00193 
00194   Order *first;                     
00195   VehicleOrderID num_orders;        
00196   VehicleOrderID num_manual_orders; 
00197   uint num_vehicles;                
00198   Vehicle *first_shared;            
00199 
00200   Ticks timetable_duration;         
00201 
00202 public:
00204   OrderList(VehicleOrderID num_orders = INVALID_VEH_ORDER_ID)
00205     : first(NULL), num_orders(num_orders), num_manual_orders(0), num_vehicles(0), first_shared(NULL),
00206       timetable_duration(0) { }
00207 
00213   OrderList(Order *chain, Vehicle *v) { this->Initialize(chain, v); }
00214 
00216   ~OrderList() {}
00217 
00218   void Initialize(Order *chain, Vehicle *v);
00219 
00224   inline Order *GetFirstOrder() const { return this->first; }
00225 
00226   Order *GetOrderAt(int index) const;
00227 
00232   inline Order *GetLastOrder() const { return this->GetOrderAt(this->num_orders - 1); }
00233 
00238   inline VehicleOrderID GetNumOrders() const { return this->num_orders; }
00239 
00244   inline VehicleOrderID GetNumManualOrders() const { return this->num_manual_orders; }
00245 
00246   void InsertOrderAt(Order *new_order, int index);
00247   void DeleteOrderAt(int index);
00248   void MoveOrder(int from, int to);
00249 
00254   inline bool IsShared() const { return this->num_vehicles > 1; };
00255 
00260   inline Vehicle *GetFirstSharedVehicle() const { return this->first_shared; }
00261 
00266   inline uint GetNumVehicles() const { return this->num_vehicles; }
00267 
00268   bool IsVehicleInSharedOrdersList(const Vehicle *v) const;
00269   int GetPositionInSharedOrderList(const Vehicle *v) const;
00270 
00277   inline void AddVehicle(Vehicle *v) { ++this->num_vehicles; }
00278 
00279   void RemoveVehicle(Vehicle *v);
00280 
00281   bool IsCompleteTimetable() const;
00282 
00287   inline Ticks GetTimetableTotalDuration() const { return this->IsCompleteTimetable() ? this->timetable_duration : INVALID_TICKS; }
00288 
00293   inline Ticks GetTimetableDurationIncomplete() const { return this->timetable_duration; }
00294 
00299   void UpdateOrderTimetable(Ticks delta) { this->timetable_duration += delta; }
00300 
00301   void FreeChain(bool keep_orderlist = false);
00302 
00303   void DebugCheckSanity() const;
00304 };
00305 
00306 #define FOR_ALL_ORDERS_FROM(var, start) FOR_ALL_ITEMS_FROM(Order, order_index, var, start)
00307 #define FOR_ALL_ORDERS(var) FOR_ALL_ORDERS_FROM(var, 0)
00308 
00309 
00310 #define FOR_VEHICLE_ORDERS(v, order) for (order = (v->orders.list == NULL) ? NULL : v->orders.list->GetFirstOrder(); order != NULL; order = order->next)
00311 
00312 
00313 #define FOR_ALL_ORDER_LISTS_FROM(var, start) FOR_ALL_ITEMS_FROM(OrderList, orderlist_index, var, start)
00314 #define FOR_ALL_ORDER_LISTS(var) FOR_ALL_ORDER_LISTS_FROM(var, 0)
00315 
00316 #endif /* ORDER_BASE_H */

Generated on Mon May 9 05:18:57 2011 for OpenTTD by  doxygen 1.6.1