52 { |
52 { |
53 if (next != NULL) next->FreeChain(); |
53 if (next != NULL) next->FreeChain(); |
54 delete this; |
54 delete this; |
55 } |
55 } |
56 |
56 |
|
57 bool Order::Equals(const Order &other) const |
|
58 { |
|
59 return |
|
60 this->type == other.type && |
|
61 this->flags == other.flags && |
|
62 this->dest == other.dest; |
|
63 } |
|
64 |
57 static bool HasOrderPoolFree(uint amount) |
65 static bool HasOrderPoolFree(uint amount) |
58 { |
66 { |
59 const Order *order; |
67 const Order *order; |
60 |
68 |
61 /* There is always room if not all blocks in the pool are reserved */ |
69 /* There is always room if not all blocks in the pool are reserved */ |
155 static void SwapOrders(Order *order1, Order *order2) |
163 static void SwapOrders(Order *order1, Order *order2) |
156 { |
164 { |
157 Order temp_order; |
165 Order temp_order; |
158 |
166 |
159 temp_order = *order1; |
167 temp_order = *order1; |
160 AssignOrder(order1, *order2); |
168 order1->AssignOrder(*order2); |
161 order1->next = order2->next; |
169 order1->next = order2->next; |
162 AssignOrder(order2, temp_order); |
170 order2->AssignOrder(temp_order); |
163 order2->next = temp_order.next; |
171 order2->next = temp_order.next; |
164 } |
172 } |
165 |
173 |
166 /** |
174 /** |
167 * |
175 * |
168 * Assign data to an order (from an other order) |
176 * Assign data to an order (from an other order) |
169 * This function makes sure that the index is maintained correctly |
177 * This function makes sure that the index is maintained correctly |
170 * |
178 * |
171 */ |
179 */ |
172 void AssignOrder(Order *order, Order data) |
180 void Order::AssignOrder(const Order &other) |
173 { |
181 { |
174 order->type = data.type; |
182 this->type = other.type; |
175 order->flags = data.flags; |
183 this->flags = other.flags; |
176 order->dest = data.dest; |
184 this->dest = other.dest; |
177 |
185 |
178 order->refit_cargo = data.refit_cargo; |
186 this->refit_cargo = other.refit_cargo; |
179 order->refit_subtype = data.refit_subtype; |
187 this->refit_subtype = other.refit_subtype; |
180 |
188 |
181 order->wait_time = data.wait_time; |
189 this->wait_time = other.wait_time; |
182 order->travel_time = data.travel_time; |
190 this->travel_time = other.travel_time; |
183 } |
191 } |
184 |
192 |
185 |
193 |
186 /** |
194 /** |
187 * Delete all news items regarding defective orders about a vehicle |
195 * Delete all news items regarding defective orders about a vehicle |
408 } |
416 } |
409 |
417 |
410 if (flags & DC_EXEC) { |
418 if (flags & DC_EXEC) { |
411 Vehicle *u; |
419 Vehicle *u; |
412 Order *new_o = new Order(); |
420 Order *new_o = new Order(); |
413 AssignOrder(new_o, new_order); |
421 new_o->AssignOrder(new_order); |
414 |
422 |
415 /* Create new order and link in list */ |
423 /* Create new order and link in list */ |
416 if (v->orders == NULL) { |
424 if (v->orders == NULL) { |
417 v->orders = new_o; |
425 v->orders = new_o; |
418 } else { |
426 } else { |
903 DeleteVehicleOrders(dst); |
911 DeleteVehicleOrders(dst); |
904 |
912 |
905 order_dst = &dst->orders; |
913 order_dst = &dst->orders; |
906 FOR_VEHICLE_ORDERS(src, order) { |
914 FOR_VEHICLE_ORDERS(src, order) { |
907 *order_dst = new Order(); |
915 *order_dst = new Order(); |
908 AssignOrder(*order_dst, *order); |
916 (*order_dst)->AssignOrder(*order); |
909 order_dst = &(*order_dst)->next; |
917 order_dst = &(*order_dst)->next; |
910 } |
918 } |
911 |
919 |
912 dst->num_orders = src->num_orders; |
920 dst->num_orders = src->num_orders; |
913 |
921 |
1170 |
1178 |
1171 /* Check if the last and the first order are the same */ |
1179 /* Check if the last and the first order are the same */ |
1172 if (v->num_orders > 1) { |
1180 if (v->num_orders > 1) { |
1173 const Order* last = GetLastVehicleOrder(v); |
1181 const Order* last = GetLastVehicleOrder(v); |
1174 |
1182 |
1175 if (v->orders->type == last->type && |
1183 if (v->orders->Equals(*last)) { |
1176 v->orders->flags == last->flags && |
|
1177 v->orders->dest == last->dest) { |
|
1178 problem_type = 2; |
1184 problem_type = 2; |
1179 } |
1185 } |
1180 } |
1186 } |
1181 |
1187 |
1182 /* Do we only have 1 station in our order list? */ |
1188 /* Do we only have 1 station in our order list? */ |
1413 if (v->type == VEH_ROAD) ClearSlot(v); |
1419 if (v->type == VEH_ROAD) ClearSlot(v); |
1414 return false; |
1420 return false; |
1415 } |
1421 } |
1416 |
1422 |
1417 /* If it is unchanged, keep it. */ |
1423 /* If it is unchanged, keep it. */ |
1418 if (order->type == v->current_order.type && |
1424 if (order->Equals(v->current_order) && |
1419 order->flags == v->current_order.flags && |
|
1420 order->dest == v->current_order.dest && |
|
1421 (v->type != VEH_SHIP || order->type != OT_GOTO_STATION || GetStation(order->dest)->dock_tile != 0)) { |
1425 (v->type != VEH_SHIP || order->type != OT_GOTO_STATION || GetStation(order->dest)->dock_tile != 0)) { |
1422 return false; |
1426 return false; |
1423 } |
1427 } |
1424 |
1428 |
1425 /* Otherwise set it, and determine the destination tile. */ |
1429 /* Otherwise set it, and determine the destination tile. */ |
1528 |
1532 |
1529 SlArray(orders, len, SLE_UINT16); |
1533 SlArray(orders, len, SLE_UINT16); |
1530 |
1534 |
1531 for (i = 0; i < len; ++i) { |
1535 for (i = 0; i < len; ++i) { |
1532 Order *order = new (i) Order(); |
1536 Order *order = new (i) Order(); |
1533 AssignOrder(order, UnpackVersion4Order(orders[i])); |
1537 order->AssignOrder(UnpackVersion4Order(orders[i])); |
1534 } |
1538 } |
1535 |
1539 |
1536 free(orders); |
1540 free(orders); |
1537 } else if (CheckSavegameVersionOldStyle(5, 2)) { |
1541 } else if (CheckSavegameVersionOldStyle(5, 2)) { |
1538 len /= sizeof(uint16); |
1542 len /= sizeof(uint16); |