18 #include "saveload.h" |
18 #include "saveload.h" |
19 #include "vehicle_gui.h" |
19 #include "vehicle_gui.h" |
20 #include "cargotype.h" |
20 #include "cargotype.h" |
21 #include "strings.h" |
21 #include "strings.h" |
22 |
22 |
23 /** |
23 DEFINE_OLD_POOL_GENERIC(Order, Order) |
24 * Called if a new block is added to the order-pool |
|
25 */ |
|
26 static void OrderPoolNewBlock(uint start_item) |
|
27 { |
|
28 Order *order; |
|
29 |
|
30 /* We don't use FOR_ALL here, because FOR_ALL skips invalid items. |
|
31 * TODO - This is just a temporary stage, this will be removed. */ |
|
32 for (order = GetOrder(start_item); order != NULL; order = (order->index + 1U < GetOrderPoolSize()) ? GetOrder(order->index + 1U) : NULL) order->index = start_item++; |
|
33 } |
|
34 |
|
35 DEFINE_OLD_POOL(Order, Order, OrderPoolNewBlock, NULL) |
|
36 |
24 |
37 /** |
25 /** |
38 * |
26 * |
39 * Unpacks a order from savegames made with TTD(Patch) |
27 * Unpacks a order from savegames made with TTD(Patch) |
40 * |
28 * |
111 order2->next = temp_order.next; |
99 order2->next = temp_order.next; |
112 } |
100 } |
113 |
101 |
114 /** |
102 /** |
115 * |
103 * |
116 * Allocate a new order |
|
117 * |
|
118 * @return Order* if a free space is found, else NULL. |
|
119 * |
|
120 */ |
|
121 static Order *AllocateOrder() |
|
122 { |
|
123 Order *order; |
|
124 |
|
125 /* We don't use FOR_ALL here, because FOR_ALL skips invalid items. |
|
126 * TODO - This is just a temporary stage, this will be removed. */ |
|
127 for (order = GetOrder(0); order != NULL; order = (order->index + 1U < GetOrderPoolSize()) ? GetOrder(order->index + 1U) : NULL) { |
|
128 if (!order->IsValid()) { |
|
129 OrderID index = order->index; |
|
130 |
|
131 memset(order, 0, sizeof(*order)); |
|
132 order->index = index; |
|
133 order->next = NULL; |
|
134 order->refit_cargo = CT_NO_REFIT; |
|
135 order->refit_subtype = 0; |
|
136 order->wait_time = 0; |
|
137 order->travel_time = 0; |
|
138 |
|
139 return order; |
|
140 } |
|
141 } |
|
142 |
|
143 /* Check if we can add a block to the pool */ |
|
144 if (AddBlockToPool(&_Order_pool)) return AllocateOrder(); |
|
145 |
|
146 return NULL; |
|
147 } |
|
148 |
|
149 /** |
|
150 * |
|
151 * Assign data to an order (from an other order) |
104 * Assign data to an order (from an other order) |
152 * This function makes sure that the index is maintained correctly |
105 * This function makes sure that the index is maintained correctly |
153 * |
106 * |
154 */ |
107 */ |
155 void AssignOrder(Order *order, Order data) |
108 void AssignOrder(Order *order, Order data) |
393 } |
346 } |
394 } |
347 } |
395 |
348 |
396 if (flags & DC_EXEC) { |
349 if (flags & DC_EXEC) { |
397 Vehicle *u; |
350 Vehicle *u; |
398 Order *new_o = AllocateOrder(); |
351 Order *new_o = new Order(); |
399 AssignOrder(new_o, new_order); |
352 AssignOrder(new_o, new_order); |
400 |
353 |
401 /* Create new order and link in list */ |
354 /* Create new order and link in list */ |
402 if (v->orders == NULL) { |
355 if (v->orders == NULL) { |
403 v->orders = new_o; |
356 v->orders = new_o; |
888 /* If the destination vehicle had a OrderList, destroy it */ |
841 /* If the destination vehicle had a OrderList, destroy it */ |
889 DeleteVehicleOrders(dst); |
842 DeleteVehicleOrders(dst); |
890 |
843 |
891 order_dst = &dst->orders; |
844 order_dst = &dst->orders; |
892 FOR_VEHICLE_ORDERS(src, order) { |
845 FOR_VEHICLE_ORDERS(src, order) { |
893 *order_dst = AllocateOrder(); |
846 *order_dst = new Order(); |
894 AssignOrder(*order_dst, *order); |
847 AssignOrder(*order_dst, *order); |
895 order_dst = &(*order_dst)->next; |
848 order_dst = &(*order_dst)->next; |
896 } |
849 } |
897 |
850 |
898 dst->num_orders = src->num_orders; |
851 dst->num_orders = src->num_orders; |
1365 assert (len <= lengthof(orders)); |
1318 assert (len <= lengthof(orders)); |
1366 |
1319 |
1367 SlArray(orders, len, SLE_UINT16); |
1320 SlArray(orders, len, SLE_UINT16); |
1368 |
1321 |
1369 for (i = 0; i < len; ++i) { |
1322 for (i = 0; i < len; ++i) { |
1370 if (!AddBlockIfNeeded(&_Order_pool, i)) |
1323 Order *order = new (i) Order(); |
1371 error("Orders: failed loading savegame: too many orders"); |
1324 AssignOrder(order, UnpackVersion4Order(orders[i])); |
1372 |
|
1373 AssignOrder(GetOrder(i), UnpackVersion4Order(orders[i])); |
|
1374 } |
1325 } |
1375 } else if (CheckSavegameVersionOldStyle(5, 2)) { |
1326 } else if (CheckSavegameVersionOldStyle(5, 2)) { |
1376 uint32 orders[5000]; |
1327 uint32 orders[5000]; |
1377 |
1328 |
1378 len /= sizeof(uint32); |
1329 len /= sizeof(uint32); |
1379 assert (len <= lengthof(orders)); |
1330 assert (len <= lengthof(orders)); |
1380 |
1331 |
1381 SlArray(orders, len, SLE_UINT32); |
1332 SlArray(orders, len, SLE_UINT32); |
1382 |
1333 |
1383 for (i = 0; i < len; ++i) { |
1334 for (i = 0; i < len; ++i) { |
1384 if (!AddBlockIfNeeded(&_Order_pool, i)) |
1335 Order *order = new (i) Order(); |
1385 error("Orders: failed loading savegame: too many orders"); |
1336 AssignOrder(order, UnpackOrder(orders[i])); |
1386 |
|
1387 AssignOrder(GetOrder(i), UnpackOrder(orders[i])); |
|
1388 } |
1337 } |
1389 } |
1338 } |
1390 |
1339 |
1391 /* Update all the next pointer */ |
1340 /* Update all the next pointer */ |
1392 for (i = 1; i < len; ++i) { |
1341 for (i = 1; i < len; ++i) { |