00001
00002
00003
00004
00005
00006
00007
00008
00009
00012 #include "../stdafx.h"
00013 #include "../order_backup.h"
00014 #include "../settings_type.h"
00015 #include "../network/network.h"
00016
00017 #include "saveload_internal.h"
00018
00023 void Order::ConvertFromOldSavegame()
00024 {
00025 uint8 old_flags = this->flags;
00026 this->flags = 0;
00027
00028
00029 if (_settings_client.gui.sg_new_nonstop || (IsSavegameVersionBefore(22) && _savegame_type != SGT_TTO && _savegame_type != SGT_TTD && _settings_client.gui.new_nonstop)) {
00030
00031 this->SetNonStopType((old_flags & 8) ? ONSF_NO_STOP_AT_ANY_STATION : ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS);
00032 } else {
00033 this->SetNonStopType((old_flags & 8) ? ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS : ONSF_STOP_EVERYWHERE);
00034 }
00035
00036 switch (this->GetType()) {
00037
00038 case OT_GOTO_DEPOT: case OT_GOTO_STATION: case OT_LOADING: break;
00039 default: return;
00040 }
00041
00042 if (this->GetType() != OT_GOTO_DEPOT) {
00043
00044 if ((old_flags & 2) != 0) {
00045 this->SetLoadType(OLFB_NO_LOAD);
00046 } else if ((old_flags & 4) == 0) {
00047 this->SetLoadType(OLF_LOAD_IF_POSSIBLE);
00048 } else {
00049
00050 this->SetLoadType(_settings_client.gui.sg_full_load_any || IsSavegameVersionBefore(22) ? OLF_FULL_LOAD_ANY : OLFB_FULL_LOAD);
00051 }
00052
00053 if (this->IsType(OT_GOTO_STATION)) this->SetStopLocation(OSL_PLATFORM_FAR_END);
00054
00055
00056 if ((old_flags & 1) != 0) {
00057 this->SetUnloadType(OUFB_TRANSFER);
00058 } else if ((old_flags & 2) != 0) {
00059 this->SetUnloadType(OUFB_UNLOAD);
00060 } else {
00061 this->SetUnloadType(OUF_UNLOAD_IF_POSSIBLE);
00062 }
00063 } else {
00064
00065 this->SetDepotActionType(((old_flags & 6) == 4) ? ODATFB_HALT : ODATF_SERVICE_ONLY);
00066
00067
00068 uint t = ((old_flags & 6) == 6) ? ODTFB_SERVICE : ODTF_MANUAL;
00069 if ((old_flags & 2) != 0) t |= ODTFB_PART_OF_ORDERS;
00070 this->SetDepotOrderType((OrderDepotTypeFlags)t);
00071 }
00072 }
00073
00079 static Order UnpackVersion4Order(uint16 packed)
00080 {
00081 return Order(GB(packed, 8, 8) << 16 | GB(packed, 4, 4) << 8 | GB(packed, 0, 4));
00082 }
00083
00089 Order UnpackOldOrder(uint16 packed)
00090 {
00091 Order order = UnpackVersion4Order(packed);
00092
00093
00094
00095
00096
00097 if (order.IsType(OT_NOTHING) && packed != 0) order.MakeDummy();
00098
00099 return order;
00100 }
00101
00102 const SaveLoad *GetOrderDescription()
00103 {
00104 static const SaveLoad _order_desc[] = {
00105 SLE_VAR(Order, type, SLE_UINT8),
00106 SLE_VAR(Order, flags, SLE_UINT8),
00107 SLE_VAR(Order, dest, SLE_UINT16),
00108 SLE_REF(Order, next, REF_ORDER),
00109 SLE_CONDVAR(Order, refit_cargo, SLE_UINT8, 36, SL_MAX_VERSION),
00110 SLE_CONDVAR(Order, refit_subtype, SLE_UINT8, 36, SL_MAX_VERSION),
00111 SLE_CONDVAR(Order, wait_time, SLE_UINT16, 67, SL_MAX_VERSION),
00112 SLE_CONDVAR(Order, travel_time, SLE_UINT16, 67, SL_MAX_VERSION),
00113 SLE_CONDVAR(Order, max_speed, SLE_UINT16, 172, SL_MAX_VERSION),
00114
00115
00116
00117 SLE_CONDNULL(10, 5, 35),
00118 SLE_END()
00119 };
00120
00121 return _order_desc;
00122 }
00123
00124 static void Save_ORDR()
00125 {
00126 Order *order;
00127
00128 FOR_ALL_ORDERS(order) {
00129 SlSetArrayIndex(order->index);
00130 SlObject(order, GetOrderDescription());
00131 }
00132 }
00133
00134 static void Load_ORDR()
00135 {
00136 if (IsSavegameVersionBefore(5, 2)) {
00137
00138
00139 size_t len = SlGetFieldLength();
00140
00141 if (IsSavegameVersionBefore(5)) {
00142
00143
00144 len /= sizeof(uint16);
00145 uint16 *orders = MallocT<uint16>(len + 1);
00146
00147 SlArray(orders, len, SLE_UINT16);
00148
00149 for (size_t i = 0; i < len; ++i) {
00150 Order *o = new (i) Order();
00151 o->AssignOrder(UnpackVersion4Order(orders[i]));
00152 }
00153
00154 free(orders);
00155 } else if (IsSavegameVersionBefore(5, 2)) {
00156 len /= sizeof(uint32);
00157 uint32 *orders = MallocT<uint32>(len + 1);
00158
00159 SlArray(orders, len, SLE_UINT32);
00160
00161 for (size_t i = 0; i < len; ++i) {
00162 new (i) Order(orders[i]);
00163 }
00164
00165 free(orders);
00166 }
00167
00168
00169 Order *o;
00170 FOR_ALL_ORDERS(o) {
00171
00172 if (o->IsType(OT_NOTHING)) {
00173 delete o;
00174 continue;
00175 }
00176
00177
00178 Order *prev = Order::GetIfValid(order_index - 1);
00179 if (prev != NULL) prev->next = o;
00180 }
00181 } else {
00182 int index;
00183
00184 while ((index = SlIterateArray()) != -1) {
00185 Order *order = new (index) Order();
00186 SlObject(order, GetOrderDescription());
00187 }
00188 }
00189 }
00190
00191 static void Ptrs_ORDR()
00192 {
00193
00194 if (IsSavegameVersionBefore(5, 2)) return;
00195
00196 Order *o;
00197
00198 FOR_ALL_ORDERS(o) {
00199 SlObject(o, GetOrderDescription());
00200 }
00201 }
00202
00203 const SaveLoad *GetOrderListDescription()
00204 {
00205 static const SaveLoad _orderlist_desc[] = {
00206 SLE_REF(OrderList, first, REF_ORDER),
00207 SLE_END()
00208 };
00209
00210 return _orderlist_desc;
00211 }
00212
00213 static void Save_ORDL()
00214 {
00215 OrderList *list;
00216
00217 FOR_ALL_ORDER_LISTS(list) {
00218 SlSetArrayIndex(list->index);
00219 SlObject(list, GetOrderListDescription());
00220 }
00221 }
00222
00223 static void Load_ORDL()
00224 {
00225 int index;
00226
00227 while ((index = SlIterateArray()) != -1) {
00228
00229 OrderList *list = new (index) OrderList(0);
00230 SlObject(list, GetOrderListDescription());
00231 }
00232
00233 }
00234
00235 static void Ptrs_ORDL()
00236 {
00237 OrderList *list;
00238
00239 FOR_ALL_ORDER_LISTS(list) {
00240 SlObject(list, GetOrderListDescription());
00241 }
00242 }
00243
00244 const SaveLoad *GetOrderBackupDescription()
00245 {
00246 static const SaveLoad _order_backup_desc[] = {
00247 SLE_VAR(OrderBackup, user, SLE_UINT32),
00248 SLE_VAR(OrderBackup, tile, SLE_UINT32),
00249 SLE_VAR(OrderBackup, group, SLE_UINT16),
00250 SLE_VAR(OrderBackup, service_interval, SLE_UINT32),
00251 SLE_STR(OrderBackup, name, SLE_STR, 0),
00252 SLE_VAR(OrderBackup, clone, SLE_UINT16),
00253 SLE_VAR(OrderBackup, cur_real_order_index, SLE_UINT8),
00254 SLE_CONDVAR(OrderBackup, cur_implicit_order_index, SLE_UINT8, 176, SL_MAX_VERSION),
00255 SLE_CONDVAR(OrderBackup, current_order_time, SLE_UINT32, 176, SL_MAX_VERSION),
00256 SLE_CONDVAR(OrderBackup, lateness_counter, SLE_INT32, 176, SL_MAX_VERSION),
00257 SLE_CONDVAR(OrderBackup, timetable_start, SLE_INT32, 176, SL_MAX_VERSION),
00258 SLE_CONDVAR(OrderBackup, vehicle_flags, SLE_FILE_U8 | SLE_VAR_U16, 176, 179),
00259 SLE_CONDVAR(OrderBackup, vehicle_flags, SLE_UINT16, 180, SL_MAX_VERSION),
00260 SLE_REF(OrderBackup, orders, REF_ORDER),
00261 SLE_END()
00262 };
00263
00264 return _order_backup_desc;
00265 }
00266
00267 static void Save_BKOR()
00268 {
00269
00270
00271
00272 if (!_networking || !_network_server) return;
00273
00274 OrderBackup *ob;
00275 FOR_ALL_ORDER_BACKUPS(ob) {
00276 SlSetArrayIndex(ob->index);
00277 SlObject(ob, GetOrderBackupDescription());
00278 }
00279 }
00280
00281 void Load_BKOR()
00282 {
00283 int index;
00284
00285 while ((index = SlIterateArray()) != -1) {
00286
00287 OrderBackup *ob = new (index) OrderBackup();
00288 SlObject(ob, GetOrderBackupDescription());
00289 }
00290
00291
00292
00293
00294
00295 if (!_networking || _network_server) {
00296 _order_backup_pool.CleanPool();
00297 }
00298 }
00299
00300 static void Ptrs_BKOR()
00301 {
00302 OrderBackup *ob;
00303 FOR_ALL_ORDER_BACKUPS(ob) {
00304 SlObject(ob, GetOrderBackupDescription());
00305 }
00306 }
00307
00308 extern const ChunkHandler _order_chunk_handlers[] = {
00309 { 'BKOR', Save_BKOR, Load_BKOR, Ptrs_BKOR, NULL, CH_ARRAY},
00310 { 'ORDR', Save_ORDR, Load_ORDR, Ptrs_ORDR, NULL, CH_ARRAY},
00311 { 'ORDL', Save_ORDL, Load_ORDL, Ptrs_ORDL, NULL, CH_ARRAY | CH_LAST},
00312 };