00001
00002
00003
00004
00005
00006
00007
00008
00009
00012 #include "../stdafx.h"
00013 #include "../order_base.h"
00014 #include "../settings_type.h"
00015
00016 #include "saveload.h"
00017
00018 void Order::ConvertFromOldSavegame()
00019 {
00020 uint8 old_flags = this->flags;
00021 this->flags = 0;
00022
00023
00024 if (_settings_client.gui.sg_new_nonstop || (CheckSavegameVersion(22) && _settings_client.gui.new_nonstop)) {
00025
00026 this->SetNonStopType((old_flags & 8) ? ONSF_NO_STOP_AT_ANY_STATION : ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS);
00027 } else {
00028 this->SetNonStopType((old_flags & 8) ? ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS : ONSF_STOP_EVERYWHERE);
00029 }
00030
00031 switch (this->GetType()) {
00032
00033 case OT_GOTO_DEPOT: case OT_GOTO_STATION: case OT_LOADING: break;
00034 default: return;
00035 }
00036
00037 if (this->GetType() != OT_GOTO_DEPOT) {
00038
00039 if ((old_flags & 2) != 0) {
00040 this->SetLoadType(OLFB_NO_LOAD);
00041 } else if ((old_flags & 4) == 0) {
00042 this->SetLoadType(OLF_LOAD_IF_POSSIBLE);
00043 } else {
00044
00045 this->SetLoadType(_settings_client.gui.sg_full_load_any || CheckSavegameVersion(22) ? OLF_FULL_LOAD_ANY : OLFB_FULL_LOAD);
00046 }
00047
00048 if (this->IsType(OT_GOTO_STATION)) this->SetStopLocation(OSL_PLATFORM_FAR_END);
00049
00050
00051 if ((old_flags & 1) != 0) {
00052 this->SetUnloadType(OUFB_TRANSFER);
00053 } else if ((old_flags & 2) != 0) {
00054 this->SetUnloadType(OUFB_UNLOAD);
00055 } else {
00056 this->SetUnloadType(OUF_UNLOAD_IF_POSSIBLE);
00057 }
00058 } else {
00059
00060 this->SetDepotActionType(((old_flags & 6) == 4) ? ODATFB_HALT : ODATF_SERVICE_ONLY);
00061
00062
00063 uint t = ((old_flags & 6) == 6) ? ODTFB_SERVICE : ODTF_MANUAL;
00064 if ((old_flags & 2) != 0) t |= ODTFB_PART_OF_ORDERS;
00065 this->SetDepotOrderType((OrderDepotTypeFlags)t);
00066 }
00067 }
00068
00073 static Order UnpackVersion4Order(uint16 packed)
00074 {
00075 return Order(GB(packed, 8, 8) << 16 | GB(packed, 4, 4) << 8 | GB(packed, 0, 4));
00076 }
00077
00082 Order UnpackOldOrder(uint16 packed)
00083 {
00084 Order order = UnpackVersion4Order(packed);
00085
00086
00087
00088
00089
00090 if (order.IsType(OT_NOTHING) && packed != 0) order.MakeDummy();
00091
00092 return order;
00093 }
00094
00095 const SaveLoad *GetOrderDescription()
00096 {
00097 static const SaveLoad _order_desc[] = {
00098 SLE_VAR(Order, type, SLE_UINT8),
00099 SLE_VAR(Order, flags, SLE_UINT8),
00100 SLE_VAR(Order, dest, SLE_UINT16),
00101 SLE_REF(Order, next, REF_ORDER),
00102 SLE_CONDVAR(Order, refit_cargo, SLE_UINT8, 36, SL_MAX_VERSION),
00103 SLE_CONDVAR(Order, refit_subtype, SLE_UINT8, 36, SL_MAX_VERSION),
00104 SLE_CONDVAR(Order, wait_time, SLE_UINT16, 67, SL_MAX_VERSION),
00105 SLE_CONDVAR(Order, travel_time, SLE_UINT16, 67, SL_MAX_VERSION),
00106
00107
00108
00109 SLE_CONDNULL(10, 5, 35),
00110 SLE_END()
00111 };
00112
00113 return _order_desc;
00114 }
00115
00116 static void Save_ORDR()
00117 {
00118 Order *order;
00119
00120 FOR_ALL_ORDERS(order) {
00121 SlSetArrayIndex(order->index);
00122 SlObject(order, GetOrderDescription());
00123 }
00124 }
00125
00126 static void Load_ORDR()
00127 {
00128 if (CheckSavegameVersionOldStyle(5, 2)) {
00129
00130
00131 size_t len = SlGetFieldLength();
00132
00133 if (CheckSavegameVersion(5)) {
00134
00135
00136 len /= sizeof(uint16);
00137 uint16 *orders = MallocT<uint16>(len + 1);
00138
00139 SlArray(orders, len, SLE_UINT16);
00140
00141 for (size_t i = 0; i < len; ++i) {
00142 Order *o = new (i) Order();
00143 o->AssignOrder(UnpackVersion4Order(orders[i]));
00144 }
00145
00146 free(orders);
00147 } else if (CheckSavegameVersionOldStyle(5, 2)) {
00148 len /= sizeof(uint32);
00149 uint32 *orders = MallocT<uint32>(len + 1);
00150
00151 SlArray(orders, len, SLE_UINT32);
00152
00153 for (size_t i = 0; i < len; ++i) {
00154 new (i) Order(orders[i]);
00155 }
00156
00157 free(orders);
00158 }
00159
00160
00161 Order *o;
00162 FOR_ALL_ORDERS(o) {
00163
00164 if (o->IsType(OT_NOTHING)) {
00165 delete o;
00166 continue;
00167 }
00168
00169
00170 Order *prev = Order::GetIfValid(order_index - 1);
00171 if (prev != NULL) prev->next = o;
00172 }
00173 } else {
00174 int index;
00175
00176 while ((index = SlIterateArray()) != -1) {
00177 Order *order = new (index) Order();
00178 SlObject(order, GetOrderDescription());
00179 }
00180 }
00181 }
00182
00183 static void Ptrs_ORDR()
00184 {
00185
00186 if (CheckSavegameVersionOldStyle(5, 2)) return;
00187
00188 Order *o;
00189
00190 FOR_ALL_ORDERS(o) {
00191 SlObject(o, GetOrderDescription());
00192 }
00193 }
00194
00195 const SaveLoad *GetOrderListDescription()
00196 {
00197 static const SaveLoad _orderlist_desc[] = {
00198 SLE_REF(OrderList, first, REF_ORDER),
00199 SLE_END()
00200 };
00201
00202 return _orderlist_desc;
00203 }
00204
00205 static void Save_ORDL()
00206 {
00207 OrderList *list;
00208
00209 FOR_ALL_ORDER_LISTS(list) {
00210 SlSetArrayIndex(list->index);
00211 SlObject(list, GetOrderListDescription());
00212 }
00213 }
00214
00215 static void Load_ORDL()
00216 {
00217 int index;
00218
00219 while ((index = SlIterateArray()) != -1) {
00220
00221 OrderList *list = new (index) OrderList(0);
00222 SlObject(list, GetOrderListDescription());
00223 }
00224
00225 }
00226
00227 static void Ptrs_ORDL()
00228 {
00229 OrderList *list;
00230
00231 FOR_ALL_ORDER_LISTS(list) {
00232 SlObject(list, GetOrderListDescription());
00233 }
00234 }
00235
00236 extern const ChunkHandler _order_chunk_handlers[] = {
00237 { 'ORDR', Save_ORDR, Load_ORDR, Ptrs_ORDR, CH_ARRAY},
00238 { 'ORDL', Save_ORDL, Load_ORDL, Ptrs_ORDL, CH_ARRAY | CH_LAST},
00239 };