OpenTTD Source: src/order_cmd.cpp Source File

OpenTTD Source 13.1

order_cmd.cpp
Go to the documentation of this file.
1 /*
2 * This file is part of OpenTTD.
3 * 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.
4 * 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.
5 * 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/>.
6 */
7
10 #include "stdafx.h"
11 #include "debug.h"
12 #include "command_func.h"
13 #include "company_func.h"
14 #include "news_func.h"
15 #include "strings_func.h"
16 #include "timetable.h"
17 #include "vehicle_func.h"
18 #include "depot_base.h"
19 #include "core/pool_func.hpp"
20 #include "core/random_func.hpp"
21 #include "aircraft.h"
22 #include "roadveh.h"
23 #include "station_base.h"
24 #include "waypoint_base.h"
25 #include "company_base.h"
26 #include "order_backup.h"
27 #include "cheat_type.h"
28 #include "order_cmd.h"
29 #include "train_cmd.h"
30
31 #include "table/strings.h"
32
33 #include "safeguards.h"
34
35 /* DestinationID must be at least as large as every these below, because it can
36 * be any of them
37 */
38 static_assert(sizeof(DestinationID) >= sizeof(DepotID));
39 static_assert(sizeof(DestinationID) >= sizeof(StationID));
40
41 OrderPool _order_pool("Order");
42 INSTANTIATE_POOL_METHODS(Order)
43 OrderListPool _orderlist_pool("OrderList");
44 INSTANTIATE_POOL_METHODS(OrderList)
45
46
47 Order::~Order()
48 {
49 if (CleaningPool()) return;
50
51 /* We can visit oil rigs and buoys that are not our own. They will be shown in
52 * the list of stations. So, we need to invalidate that window if needed. */
53 if (this->IsType(OT_GOTO_STATION) || this->IsType(OT_GOTO_WAYPOINT)) {
54 BaseStation *bs = BaseStation::GetIfValid(this->GetDestination());
55 if (bs != nullptr && bs->owner == OWNER_NONE) InvalidateWindowClassesData(WC_STATION_LIST, 0);
56 }
57 }
58
63 void Order::Free()
64 {
65 this->type = OT_NOTHING;
66 this->flags = 0;
67 this->dest = 0;
68 this->next = nullptr;
69 }
70
75 void Order::MakeGoToStation(StationID destination)
76 {
77 this->type = OT_GOTO_STATION;
78 this->flags = 0;
79 this->dest = destination;
80 }
81
90 void Order::MakeGoToDepot(DepotID destination, OrderDepotTypeFlags order, OrderNonStopFlags non_stop_type, OrderDepotActionFlags action, CargoID cargo)
91 {
92 this->type = OT_GOTO_DEPOT;
93 this->SetDepotOrderType(order);
94 this->SetDepotActionType(action);
95 this->SetNonStopType(non_stop_type);
96 this->dest = destination;
97 this->SetRefit(cargo);
98 }
99
104 void Order::MakeGoToWaypoint(StationID destination)
105 {
106 this->type = OT_GOTO_WAYPOINT;
107 this->flags = 0;
108 this->dest = destination;
109 }
110
115 void Order::MakeLoading(bool ordered)
116 {
117 this->type = OT_LOADING;
118 if (!ordered) this->flags = 0;
119 }
120
124 void Order::MakeLeaveStation()
125 {
126 this->type = OT_LEAVESTATION;
127 this->flags = 0;
128 }
129
133 void Order::MakeDummy()
134 {
135 this->type = OT_DUMMY;
136 this->flags = 0;
137 }
138
143 void Order::MakeConditional(VehicleOrderID order)
144 {
145 this->type = OT_CONDITIONAL;
146 this->flags = order;
147 this->dest = 0;
148 }
149
154 void Order::MakeImplicit(StationID destination)
155 {
156 this->type = OT_IMPLICIT;
157 this->dest = destination;
158 }
159
165 void Order::SetRefit(CargoID cargo)
166 {
167 this->refit_cargo = cargo;
168 }
169
175 bool Order::Equals(const Order &other) const
176 {
177 /* In case of go to nearest depot orders we need "only" compare the flags
178 * with the other and not the nearest depot order bit or the actual
179 * destination because those get clear/filled in during the order
180 * evaluation. If we do not do this the order will continuously be seen as
181 * a different order and it will try to find a "nearest depot" every tick. */
182 if ((this->IsType(OT_GOTO_DEPOT) && this->type == other.type) &&
183 ((this->GetDepotActionType() & ODATFB_NEAREST_DEPOT) != 0 ||
184 (other.GetDepotActionType() & ODATFB_NEAREST_DEPOT) != 0)) {
185 return this->GetDepotOrderType() == other.GetDepotOrderType() &&
186 (this->GetDepotActionType() & ~ODATFB_NEAREST_DEPOT) == (other.GetDepotActionType() & ~ODATFB_NEAREST_DEPOT);
187 }
188
189 return this->type == other.type && this->flags == other.flags && this->dest == other.dest;
190 }
191
198 uint32 Order::Pack() const
199 {
200 return this->dest << 16 | this->flags << 8 | this->type;
201 }
202
208 uint16 Order::MapOldOrder() const
209 {
210 uint16 order = this->GetType();
211 switch (this->type) {
212 case OT_GOTO_STATION:
213 if (this->GetUnloadType() & OUFB_UNLOAD) SetBit(order, 5);
214 if (this->GetLoadType() & OLFB_FULL_LOAD) SetBit(order, 6);
215 if (this->GetNonStopType() & ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS) SetBit(order, 7);
216 order |= GB(this->GetDestination(), 0, 8) << 8;
217 break;
218 case OT_GOTO_DEPOT:
219 if (!(this->GetDepotOrderType() & ODTFB_PART_OF_ORDERS)) SetBit(order, 6);
220 SetBit(order, 7);
221 order |= GB(this->GetDestination(), 0, 8) << 8;
222 break;
223 case OT_LOADING:
224 if (this->GetLoadType() & OLFB_FULL_LOAD) SetBit(order, 6);
225 break;
226 }
227 return order;
228 }
229
234 Order::Order(uint32 packed)
235 {
236 this->type = (OrderType)GB(packed, 0, 8);
237 this->flags = GB(packed, 8, 8);
238 this->dest = GB(packed, 16, 16);
239 this->next = nullptr;
240 this->refit_cargo = CT_NO_REFIT;
241 this->wait_time = 0;
242 this->travel_time = 0;
243 this->max_speed = UINT16_MAX;
244 }
245
251 void InvalidateVehicleOrder(const Vehicle *v, int data)
252 {
253 SetWindowDirty(WC_VEHICLE_VIEW, v->index);
254
255 if (data != 0) {
256 /* Calls SetDirty() too */
257 InvalidateWindowData(WC_VEHICLE_ORDERS, v->index, data);
258 InvalidateWindowData(WC_VEHICLE_TIMETABLE, v->index, data);
259 return;
260 }
261
262 SetWindowDirty(WC_VEHICLE_ORDERS, v->index);
263 SetWindowDirty(WC_VEHICLE_TIMETABLE, v->index);
264 }
265
273 void Order::AssignOrder(const Order &other)
274 {
275 this->type = other.type;
276 this->flags = other.flags;
277 this->dest = other.dest;
278
279 this->refit_cargo = other.refit_cargo;
280
281 this->wait_time = other.wait_time;
282 this->travel_time = other.travel_time;
283 this->max_speed = other.max_speed;
284 }
285
291 void OrderList::Initialize(Order *chain, Vehicle *v)
292 {
293 this->first = chain;
294 this->first_shared = v;
295
296 this->num_orders = 0;
297 this->num_manual_orders = 0;
298 this->num_vehicles = 1;
299 this->timetable_duration = 0;
300
301 for (Order *o = this->first; o != nullptr; o = o->next) {
302 ++this->num_orders;
303 if (!o->IsType(OT_IMPLICIT)) ++this->num_manual_orders;
304 this->total_duration += o->GetWaitTime() + o->GetTravelTime();
305 }
306
307 this->RecalculateTimetableDuration();
308
309 for (Vehicle *u = this->first_shared->PreviousShared(); u != nullptr; u = u->PreviousShared()) {
310 ++this->num_vehicles;
311 this->first_shared = u;
312 }
313
314 for (const Vehicle *u = v->NextShared(); u != nullptr; u = u->NextShared()) ++this->num_vehicles;
315 }
316
321 void OrderList::RecalculateTimetableDuration()
322 {
323 this->timetable_duration = 0;
324 for (Order *o = this->first; o != nullptr; o = o->next) {
325 this->timetable_duration += o->GetTimetabledWait() + o->GetTimetabledTravel();
326 }
327 }
328
334 void OrderList::FreeChain(bool keep_orderlist)
335 {
336 Order *next;
337 for (Order *o = this->first; o != nullptr; o = next) {
338 next = o->next;
339 delete o;
340 }
341
342 if (keep_orderlist) {
343 this->first = nullptr;
344 this->num_orders = 0;
345 this->num_manual_orders = 0;
346 this->timetable_duration = 0;
347 } else {
348 delete this;
349 }
350 }
351
357 Order *OrderList::GetOrderAt(int index) const
358 {
359 if (index < 0) return nullptr;
360
361 Order *order = this->first;
362
363 while (order != nullptr && index-- > 0) {
364 order = order->next;
365 }
366 return order;
367 }
368
380 const Order *OrderList::GetNextDecisionNode(const Order *next, uint hops) const
381 {
382 if (hops > this->GetNumOrders() || next == nullptr) return nullptr;
383
384 if (next->IsType(OT_CONDITIONAL)) {
385 if (next->GetConditionVariable() != OCV_UNCONDITIONALLY) return next;
386
387 /* We can evaluate trivial conditions right away. They're conceptually
388 * the same as regular order progression. */
389 return this->GetNextDecisionNode(
390 this->GetOrderAt(next->GetConditionSkipToOrder()),
391 hops + 1);
392 }
393
394 if (next->IsType(OT_GOTO_DEPOT)) {
395 if (next->GetDepotActionType() == ODATFB_HALT) return nullptr;
396 if (next->IsRefit()) return next;
397 }
398
399 if (!next->CanLoadOrUnload()) {
400 return this->GetNextDecisionNode(this->GetNext(next), hops + 1);
401 }
402
403 return next;
404 }
405
415 StationIDStack OrderList::GetNextStoppingStation(const Vehicle *v, const Order *first, uint hops) const
416 {
417
418 const Order *next = first;
419 if (first == nullptr) {
420 next = this->GetOrderAt(v->cur_implicit_order_index);
421 if (next == nullptr) {
422 next = this->GetFirstOrder();
423 if (next == nullptr) return INVALID_STATION;
424 } else {
425 /* GetNext never returns nullptr if there is a valid station in the list.
426 * As the given "next" is already valid and a station in the list, we
427 * don't have to check for nullptr here. */
428 next = this->GetNext(next);
429 assert(next != nullptr);
430 }
431 }
432
433 do {
434 next = this->GetNextDecisionNode(next, ++hops);
435
436 /* Resolve possibly nested conditionals by estimation. */
437 while (next != nullptr && next->IsType(OT_CONDITIONAL)) {
438 /* We return both options of conditional orders. */
439 const Order *skip_to = this->GetNextDecisionNode(
440 this->GetOrderAt(next->GetConditionSkipToOrder()), hops);
441 const Order *advance = this->GetNextDecisionNode(
442 this->GetNext(next), hops);
443 if (advance == nullptr || advance == first || skip_to == advance) {
444 next = (skip_to == first) ? nullptr : skip_to;
445 } else if (skip_to == nullptr || skip_to == first) {
446 next = (advance == first) ? nullptr : advance;
447 } else {
448 StationIDStack st1 = this->GetNextStoppingStation(v, skip_to, hops);
449 StationIDStack st2 = this->GetNextStoppingStation(v, advance, hops);
450 while (!st2.IsEmpty()) st1.Push(st2.Pop());
451 return st1;
452 }
453 ++hops;
454 }
455
456 /* Don't return a next stop if the vehicle has to unload everything. */
457 if (next == nullptr || ((next->IsType(OT_GOTO_STATION) || next->IsType(OT_IMPLICIT)) &&
458 next->GetDestination() == v->last_station_visited &&
459 (next->GetUnloadType() & (OUFB_TRANSFER | OUFB_UNLOAD)) != 0)) {
460 return INVALID_STATION;
461 }
462 } while (next->IsType(OT_GOTO_DEPOT) || next->GetDestination() == v->last_station_visited);
463
464 return next->GetDestination();
465 }
466
472 void OrderList::InsertOrderAt(Order *new_order, int index)
473 {
474 if (this->first == nullptr) {
475 this->first = new_order;
476 } else {
477 if (index == 0) {
478 /* Insert as first or only order */
479 new_order->next = this->first;
480 this->first = new_order;
481 } else if (index >= this->num_orders) {
482 /* index is after the last order, add it to the end */
483 this->GetLastOrder()->next = new_order;
484 } else {
485 /* Put the new order in between */
486 Order *order = this->GetOrderAt(index - 1);
487 new_order->next = order->next;
488 order->next = new_order;
489 }
490 }
491 ++this->num_orders;
492 if (!new_order->IsType(OT_IMPLICIT)) ++this->num_manual_orders;
493 this->timetable_duration += new_order->GetTimetabledWait() + new_order->GetTimetabledTravel();
494 this->total_duration += new_order->GetWaitTime() + new_order->GetTravelTime();
495
496 /* We can visit oil rigs and buoys that are not our own. They will be shown in
497 * the list of stations. So, we need to invalidate that window if needed. */
498 if (new_order->IsType(OT_GOTO_STATION) || new_order->IsType(OT_GOTO_WAYPOINT)) {
499 BaseStation *bs = BaseStation::Get(new_order->GetDestination());
500 if (bs->owner == OWNER_NONE) InvalidateWindowClassesData(WC_STATION_LIST, 0);
501 }
502
503 }
504
505
510 void OrderList::DeleteOrderAt(int index)
511 {
512 if (index >= this->num_orders) return;
513
514 Order *to_remove;
515
516 if (index == 0) {
517 to_remove = this->first;
518 this->first = to_remove->next;
519 } else {
520 Order *prev = GetOrderAt(index - 1);
521 to_remove = prev->next;
522 prev->next = to_remove->next;
523 }
524 --this->num_orders;
525 if (!to_remove->IsType(OT_IMPLICIT)) --this->num_manual_orders;
526 this->timetable_duration -= (to_remove->GetTimetabledWait() + to_remove->GetTimetabledTravel());
527 this->total_duration -= (to_remove->GetWaitTime() + to_remove->GetTravelTime());
528 delete to_remove;
529 }
530
536 void OrderList::MoveOrder(int from, int to)
537 {
538 if (from >= this->num_orders || to >= this->num_orders || from == to) return;
539
540 Order *moving_one;
541
542 /* Take the moving order out of the pointer-chain */
543 if (from == 0) {
544 moving_one = this->first;
545 this->first = moving_one->next;
546 } else {
547 Order *one_before = GetOrderAt(from - 1);
548 moving_one = one_before->next;
549 one_before->next = moving_one->next;
550 }
551
552 /* Insert the moving_order again in the pointer-chain */
553 if (to == 0) {
554 moving_one->next = this->first;
555 this->first = moving_one;
556 } else {
557 Order *one_before = GetOrderAt(to - 1);
558 moving_one->next = one_before->next;
559 one_before->next = moving_one;
560 }
561 }
562
568 void OrderList::RemoveVehicle(Vehicle *v)
569 {
570 --this->num_vehicles;
571 if (v == this->first_shared) this->first_shared = v->NextShared();
572 }
573
578 bool OrderList::IsVehicleInSharedOrdersList(const Vehicle *v) const
579 {
580 for (const Vehicle *v_shared = this->first_shared; v_shared != nullptr; v_shared = v_shared->NextShared()) {
581 if (v_shared == v) return true;
582 }
583
584 return false;
585 }
586
592 int OrderList::GetPositionInSharedOrderList(const Vehicle *v) const
593 {
594 int count = 0;
595 for (const Vehicle *v_shared = v->PreviousShared(); v_shared != nullptr; v_shared = v_shared->PreviousShared()) count++;
596 return count;
597 }
598
603 bool OrderList::IsCompleteTimetable() const
604 {
605 for (Order *o = this->first; o != nullptr; o = o->next) {
606 /* Implicit orders are, by definition, not timetabled. */
607 if (o->IsType(OT_IMPLICIT)) continue;
608 if (!o->IsCompletelyTimetabled()) return false;
609 }
610 return true;
611 }
612
613 #ifdef WITH_ASSERT
614
617 void OrderList::DebugCheckSanity() const
618 {
619 VehicleOrderID check_num_orders = 0;
620 VehicleOrderID check_num_manual_orders = 0;
621 uint check_num_vehicles = 0;
622 Ticks check_timetable_duration = 0;
623 Ticks check_total_duration = 0;
624
625 Debug(misc, 6, "Checking OrderList {} for sanity...", this->index);
626
627 for (const Order *o = this->first; o != nullptr; o = o->next) {
628 ++check_num_orders;
629 if (!o->IsType(OT_IMPLICIT)) ++check_num_manual_orders;
630 check_timetable_duration += o->GetTimetabledWait() + o->GetTimetabledTravel();
631 check_total_duration += o->GetWaitTime() + o->GetTravelTime();
632 }
633 assert(this->num_orders == check_num_orders);
634 assert(this->num_manual_orders == check_num_manual_orders);
635 assert(this->timetable_duration == check_timetable_duration);
636 assert(this->total_duration == check_total_duration);
637
638 for (const Vehicle *v = this->first_shared; v != nullptr; v = v->NextShared()) {
639 ++check_num_vehicles;
640 assert(v->orders == this);
641 }
642 assert(this->num_vehicles == check_num_vehicles);
643 Debug(misc, 6, "... detected {} orders ({} manual), {} vehicles, {} timetabled, {} total",
644 (uint)this->num_orders, (uint)this->num_manual_orders,
645 this->num_vehicles, this->timetable_duration, this->total_duration);
646 }
647 #endif
648
656 static inline bool OrderGoesToStation(const Vehicle *v, const Order *o)
657 {
658 return o->IsType(OT_GOTO_STATION) ||
659 (v->type == VEH_AIRCRAFT && o->IsType(OT_GOTO_DEPOT) && o->GetDestination() != INVALID_STATION);
660 }
661
668 static void DeleteOrderWarnings(const Vehicle *v)
669 {
670 DeleteVehicleNews(v->index, STR_NEWS_VEHICLE_HAS_TOO_FEW_ORDERS);
671 DeleteVehicleNews(v->index, STR_NEWS_VEHICLE_HAS_VOID_ORDER);
672 DeleteVehicleNews(v->index, STR_NEWS_VEHICLE_HAS_DUPLICATE_ENTRY);
673 DeleteVehicleNews(v->index, STR_NEWS_VEHICLE_HAS_INVALID_ENTRY);
674 DeleteVehicleNews(v->index, STR_NEWS_PLANE_USES_TOO_SHORT_RUNWAY);
675 }
676
683 TileIndex Order::GetLocation(const Vehicle *v, bool airport) const
684 {
685 switch (this->GetType()) {
686 case OT_GOTO_WAYPOINT:
687 case OT_GOTO_STATION:
688 case OT_IMPLICIT:
689 if (airport && v->type == VEH_AIRCRAFT) return Station::Get(this->GetDestination())->airport.tile;
690 return BaseStation::Get(this->GetDestination())->xy;
691
692 case OT_GOTO_DEPOT:
693 if (this->GetDestination() == INVALID_DEPOT) return INVALID_TILE;
694 return (v->type == VEH_AIRCRAFT) ? Station::Get(this->GetDestination())->xy : Depot::Get(this->GetDestination())->xy;
695
696 default:
697 return INVALID_TILE;
698 }
699 }
700
710 uint GetOrderDistance(const Order *prev, const Order *cur, const Vehicle *v, int conditional_depth)
711 {
712 if (cur->IsType(OT_CONDITIONAL)) {
713 if (conditional_depth > v->GetNumOrders()) return 0;
714
715 conditional_depth++;
716
717 int dist1 = GetOrderDistance(prev, v->GetOrder(cur->GetConditionSkipToOrder()), v, conditional_depth);
718 int dist2 = GetOrderDistance(prev, cur->next == nullptr ? v->orders->GetFirstOrder() : cur->next, v, conditional_depth);
719 return std::max(dist1, dist2);
720 }
721
722 TileIndex prev_tile = prev->GetLocation(v, true);
723 TileIndex cur_tile = cur->GetLocation(v, true);
724 if (prev_tile == INVALID_TILE || cur_tile == INVALID_TILE) return 0;
725 return v->type == VEH_AIRCRAFT ? DistanceSquare(prev_tile, cur_tile) : DistanceManhattan(prev_tile, cur_tile);
726 }
727
738 CommandCost CmdInsertOrder(DoCommandFlag flags, VehicleID veh, VehicleOrderID sel_ord, const Order &new_order)
739 {
740 Vehicle *v = Vehicle::GetIfValid(veh);
741 if (v == nullptr || !v->IsPrimaryVehicle()) return CMD_ERROR;
742
743 CommandCost ret = CheckOwnership(v->owner);
744 if (ret.Failed()) return ret;
745
746 /* Validate properties we don't want to have different from default as they are set by other commands. */
747 if (new_order.GetRefitCargo() != CT_NO_REFIT || new_order.GetWaitTime() != 0 || new_order.GetTravelTime() != 0 || new_order.GetMaxSpeed() != UINT16_MAX) return CMD_ERROR;
748
749 /* Check if the inserted order is to the correct destination (owner, type),
750 * and has the correct flags if any */
751 switch (new_order.GetType()) {
752 case OT_GOTO_STATION: {
753 const Station *st = Station::GetIfValid(new_order.GetDestination());
754 if (st == nullptr) return CMD_ERROR;
755
756 if (st->owner != OWNER_NONE) {
757 CommandCost ret = CheckOwnership(st->owner);
758 if (ret.Failed()) return ret;
759 }
760
761 if (!CanVehicleUseStation(v, st)) return_cmd_error(STR_ERROR_CAN_T_ADD_ORDER);
762 for (Vehicle *u = v->FirstShared(); u != nullptr; u = u->NextShared()) {
763 if (!CanVehicleUseStation(u, st)) return_cmd_error(STR_ERROR_CAN_T_ADD_ORDER_SHARED);
764 }
765
766 /* Non stop only allowed for ground vehicles. */
767 if (new_order.GetNonStopType() != ONSF_STOP_EVERYWHERE && !v->IsGroundVehicle()) return CMD_ERROR;
768
769 /* Filter invalid load/unload types. */
770 switch (new_order.GetLoadType()) {
771 case OLF_LOAD_IF_POSSIBLE: case OLFB_FULL_LOAD: case OLF_FULL_LOAD_ANY: case OLFB_NO_LOAD: break;
772 default: return CMD_ERROR;
773 }
774 switch (new_order.GetUnloadType()) {
775 case OUF_UNLOAD_IF_POSSIBLE: case OUFB_UNLOAD: case OUFB_TRANSFER: case OUFB_NO_UNLOAD: break;
776 default: return CMD_ERROR;
777 }
778
779 /* Filter invalid stop locations */
780 switch (new_order.GetStopLocation()) {
781 case OSL_PLATFORM_NEAR_END:
782 case OSL_PLATFORM_MIDDLE:
783 if (v->type != VEH_TRAIN) return CMD_ERROR;
784 FALLTHROUGH;
785
786 case OSL_PLATFORM_FAR_END:
787 break;
788
789 default:
790 return CMD_ERROR;
791 }
792
793 break;
794 }
795
796 case OT_GOTO_DEPOT: {
797 if ((new_order.GetDepotActionType() & ODATFB_NEAREST_DEPOT) == 0) {
798 if (v->type == VEH_AIRCRAFT) {
799 const Station *st = Station::GetIfValid(new_order.GetDestination());
800
801 if (st == nullptr) return CMD_ERROR;
802
803 CommandCost ret = CheckOwnership(st->owner);
804 if (ret.Failed()) return ret;
805
806 if (!CanVehicleUseStation(v, st) || !st->airport.HasHangar()) {
807 return CMD_ERROR;
808 }
809 } else {
810 const Depot *dp = Depot::GetIfValid(new_order.GetDestination());
811
812 if (dp == nullptr) return CMD_ERROR;
813
814 CommandCost ret = CheckOwnership(GetTileOwner(dp->xy));
815 if (ret.Failed()) return ret;
816
817 switch (v->type) {
818 case VEH_TRAIN:
819 if (!IsRailDepotTile(dp->xy)) return CMD_ERROR;
820 break;
821
822 case VEH_ROAD:
823 if (!IsRoadDepotTile(dp->xy)) return CMD_ERROR;
824 break;
825
826 case VEH_SHIP:
827 if (!IsShipDepotTile(dp->xy)) return CMD_ERROR;
828 break;
829
830 default: return CMD_ERROR;
831 }
832 }
833 }
834
835 if (new_order.GetNonStopType() != ONSF_STOP_EVERYWHERE && !v->IsGroundVehicle()) return CMD_ERROR;
836 if (new_order.GetDepotOrderType() & ~(ODTFB_PART_OF_ORDERS | ((new_order.GetDepotOrderType() & ODTFB_PART_OF_ORDERS) != 0 ? ODTFB_SERVICE : 0))) return CMD_ERROR;
837 if (new_order.GetDepotActionType() & ~(ODATFB_HALT | ODATFB_NEAREST_DEPOT)) return CMD_ERROR;
838 if ((new_order.GetDepotOrderType() & ODTFB_SERVICE) && (new_order.GetDepotActionType() & ODATFB_HALT)) return CMD_ERROR;
839 break;
840 }
841
842 case OT_GOTO_WAYPOINT: {
843 const Waypoint *wp = Waypoint::GetIfValid(new_order.GetDestination());
844 if (wp == nullptr) return CMD_ERROR;
845
846 switch (v->type) {
847 default: return CMD_ERROR;
848
849 case VEH_TRAIN: {
850 if (!(wp->facilities & FACIL_TRAIN)) return_cmd_error(STR_ERROR_CAN_T_ADD_ORDER);
851
852 CommandCost ret = CheckOwnership(wp->owner);
853 if (ret.Failed()) return ret;
854 break;
855 }
856
857 case VEH_SHIP:
858 if (!(wp->facilities & FACIL_DOCK)) return_cmd_error(STR_ERROR_CAN_T_ADD_ORDER);
859 if (wp->owner != OWNER_NONE) {
860 CommandCost ret = CheckOwnership(wp->owner);
861 if (ret.Failed()) return ret;
862 }
863 break;
864 }
865
866 /* Order flags can be any of the following for waypoints:
867 * [non-stop]
868 * non-stop orders (if any) are only valid for trains */
869 if (new_order.GetNonStopType() != ONSF_STOP_EVERYWHERE && v->type != VEH_TRAIN) return CMD_ERROR;
870 break;
871 }
872
873 case OT_CONDITIONAL: {
874 VehicleOrderID skip_to = new_order.GetConditionSkipToOrder();
875 if (skip_to != 0 && skip_to >= v->GetNumOrders()) return CMD_ERROR; // Always allow jumping to the first (even when there is no order).
876 if (new_order.GetConditionVariable() >= OCV_END) return CMD_ERROR;
877
878 OrderConditionComparator occ = new_order.GetConditionComparator();
879 if (occ >= OCC_END) return CMD_ERROR;
880 switch (new_order.GetConditionVariable()) {
881 case OCV_REQUIRES_SERVICE:
882 if (occ != OCC_IS_TRUE && occ != OCC_IS_FALSE) return CMD_ERROR;
883 break;
884
885 case OCV_UNCONDITIONALLY:
886 if (occ != OCC_EQUALS) return CMD_ERROR;
887 if (new_order.GetConditionValue() != 0) return CMD_ERROR;
888 break;
889
890 case OCV_LOAD_PERCENTAGE:
891 case OCV_RELIABILITY:
892 if (new_order.GetConditionValue() > 100) return CMD_ERROR;
893 FALLTHROUGH;
894
895 default:
896 if (occ == OCC_IS_TRUE || occ == OCC_IS_FALSE) return CMD_ERROR;
897 break;
898 }
899 break;
900 }
901
902 default: return CMD_ERROR;
903 }
904
905 if (sel_ord > v->GetNumOrders()) return CMD_ERROR;
906
907 if (v->GetNumOrders() >= MAX_VEH_ORDER_ID) return_cmd_error(STR_ERROR_TOO_MANY_ORDERS);
908 if (!Order::CanAllocateItem()) return_cmd_error(STR_ERROR_NO_MORE_SPACE_FOR_ORDERS);
909 if (v->orders == nullptr && !OrderList::CanAllocateItem()) return_cmd_error(STR_ERROR_NO_MORE_SPACE_FOR_ORDERS);
910
911 if (flags & DC_EXEC) {
912 Order *new_o = new Order();
913 new_o->AssignOrder(new_order);
914 InsertOrder(v, new_o, sel_ord);
915 }
916
917 return CommandCost();
918 }
919
926 void InsertOrder(Vehicle *v, Order *new_o, VehicleOrderID sel_ord)
927 {
928 /* Create new order and link in list */
929 if (v->orders == nullptr) {
930 v->orders = new OrderList(new_o, v);
931 } else {
932 v->orders->InsertOrderAt(new_o, sel_ord);
933 }
934
935 Vehicle *u = v->FirstShared();
936 DeleteOrderWarnings(u);
937 for (; u != nullptr; u = u->NextShared()) {
938 assert(v->orders == u->orders);
939
940 /* If there is added an order before the current one, we need
941 * to update the selected order. We do not change implicit/real order indices though.
942 * If the new order is between the current implicit order and real order, the implicit order will
943 * later skip the inserted order. */
944 if (sel_ord <= u->cur_real_order_index) {
945 uint cur = u->cur_real_order_index + 1;
946 /* Check if we don't go out of bound */
947 if (cur < u->GetNumOrders()) {
948 u->cur_real_order_index = cur;
949 }
950 }
951 if (sel_ord == u->cur_implicit_order_index && u->IsGroundVehicle()) {
952 /* We are inserting an order just before the current implicit order.
953 * We do not know whether we will reach current implicit or the newly inserted order first.
954 * So, disable creation of implicit orders until we are on track again. */
955 uint16 &gv_flags = u->GetGroundVehicleFlags();
956 SetBit(gv_flags, GVF_SUPPRESS_IMPLICIT_ORDERS);
957 }
958 if (sel_ord <= u->cur_implicit_order_index) {
959 uint cur = u->cur_implicit_order_index + 1;
960 /* Check if we don't go out of bound */
961 if (cur < u->GetNumOrders()) {
962 u->cur_implicit_order_index = cur;
963 }
964 }
965 /* Update any possible open window of the vehicle */
966 InvalidateVehicleOrder(u, INVALID_VEH_ORDER_ID | (sel_ord << 8));
967 }
968
969 /* As we insert an order, the order to skip to will be 'wrong'. */
970 VehicleOrderID cur_order_id = 0;
971 for (Order *order : v->Orders()) {
972 if (order->IsType(OT_CONDITIONAL)) {
973 VehicleOrderID order_id = order->GetConditionSkipToOrder();
974 if (order_id >= sel_ord) {
975 order->SetConditionSkipToOrder(order_id + 1);
976 }
977 if (order_id == cur_order_id) {
978 order->SetConditionSkipToOrder((order_id + 1) % v->GetNumOrders());
979 }
980 }
981 cur_order_id++;
982 }
983
984 /* Make sure to rebuild the whole list */
985 InvalidateWindowClassesData(GetWindowClassForVehicleType(v->type), 0);
986 }
987
993 static CommandCost DecloneOrder(Vehicle *dst, DoCommandFlag flags)
994 {
995 if (flags & DC_EXEC) {
996 DeleteVehicleOrders(dst);
997 InvalidateVehicleOrder(dst, VIWD_REMOVE_ALL_ORDERS);
998 InvalidateWindowClassesData(GetWindowClassForVehicleType(dst->type), 0);
999 }
1000 return CommandCost();
1001 }
1002
1010 CommandCost CmdDeleteOrder(DoCommandFlag flags, VehicleID veh_id, VehicleOrderID sel_ord)
1011 {
1012 Vehicle *v = Vehicle::GetIfValid(veh_id);
1013
1014 if (v == nullptr || !v->IsPrimaryVehicle()) return CMD_ERROR;
1015
1016 CommandCost ret = CheckOwnership(v->owner);
1017 if (ret.Failed()) return ret;
1018
1019 /* If we did not select an order, we maybe want to de-clone the orders */
1020 if (sel_ord >= v->GetNumOrders()) return DecloneOrder(v, flags);
1021
1022 if (v->GetOrder(sel_ord) == nullptr) return CMD_ERROR;
1023
1024 if (flags & DC_EXEC) DeleteOrder(v, sel_ord);
1025 return CommandCost();
1026 }
1027
1032 static void CancelLoadingDueToDeletedOrder(Vehicle *v)
1033 {
1034 assert(v->current_order.IsType(OT_LOADING));
1035 /* NON-stop flag is misused to see if a train is in a station that is
1036 * on its order list or not */
1037 v->current_order.SetNonStopType(ONSF_STOP_EVERYWHERE);
1038 /* When full loading, "cancel" that order so the vehicle doesn't
1039 * stay indefinitely at this station anymore. */
1040 if (v->current_order.GetLoadType() & OLFB_FULL_LOAD) v->current_order.SetLoadType(OLF_LOAD_IF_POSSIBLE);
1041 }
1042
1048 void DeleteOrder(Vehicle *v, VehicleOrderID sel_ord)
1049 {
1050 v->orders->DeleteOrderAt(sel_ord);
1051
1052 Vehicle *u = v->FirstShared();
1053 DeleteOrderWarnings(u);
1054 for (; u != nullptr; u = u->NextShared()) {
1055 assert(v->orders == u->orders);
1056
1057 if (sel_ord == u->cur_real_order_index && u->current_order.IsType(OT_LOADING)) {
1058 CancelLoadingDueToDeletedOrder(u);
1059 }
1060
1061 if (sel_ord < u->cur_real_order_index) {
1062 u->cur_real_order_index--;
1063 } else if (sel_ord == u->cur_real_order_index) {
1064 u->UpdateRealOrderIndex();
1065 }
1066
1067 if (sel_ord < u->cur_implicit_order_index) {
1068 u->cur_implicit_order_index--;
1069 } else if (sel_ord == u->cur_implicit_order_index) {
1070 /* Make sure the index is valid */
1071 if (u->cur_implicit_order_index >= u->GetNumOrders()) u->cur_implicit_order_index = 0;
1072
1073 /* Skip non-implicit orders for the implicit-order-index (e.g. if the current implicit order was deleted */
1074 while (u->cur_implicit_order_index != u->cur_real_order_index && !u->GetOrder(u->cur_implicit_order_index)->IsType(OT_IMPLICIT)) {
1075 u->cur_implicit_order_index++;
1076 if (u->cur_implicit_order_index >= u->GetNumOrders()) u->cur_implicit_order_index = 0;
1077 }
1078 }
1079
1080 /* Update any possible open window of the vehicle */
1081 InvalidateVehicleOrder(u, sel_ord | (INVALID_VEH_ORDER_ID << 8));
1082 }
1083
1084 /* As we delete an order, the order to skip to will be 'wrong'. */
1085 VehicleOrderID cur_order_id = 0;
1086 for (Order *order : v->Orders()) {
1087 if (order->IsType(OT_CONDITIONAL)) {
1088 VehicleOrderID order_id = order->GetConditionSkipToOrder();
1089 if (order_id >= sel_ord) {
1090 order_id = std::max(order_id - 1, 0);
1091 }
1092 if (order_id == cur_order_id) {
1093 order_id = (order_id + 1) % v->GetNumOrders();
1094 }
1095 order->SetConditionSkipToOrder(order_id);
1096 }
1097 cur_order_id++;
1098 }
1099
1100 InvalidateWindowClassesData(GetWindowClassForVehicleType(v->type), 0);
1101 }
1102
1110 CommandCost CmdSkipToOrder(DoCommandFlag flags, VehicleID veh_id, VehicleOrderID sel_ord)
1111 {
1112 Vehicle *v = Vehicle::GetIfValid(veh_id);
1113
1114 if (v == nullptr || !v->IsPrimaryVehicle() || sel_ord == v->cur_implicit_order_index || sel_ord >= v->GetNumOrders() || v->GetNumOrders() < 2) return CMD_ERROR;
1115
1116 CommandCost ret = CheckOwnership(v->owner);
1117 if (ret.Failed()) return ret;
1118
1119 if (flags & DC_EXEC) {
1120 if (v->current_order.IsType(OT_LOADING)) v->LeaveStation();
1121
1122 v->cur_implicit_order_index = v->cur_real_order_index = sel_ord;
1123 v->UpdateRealOrderIndex();
1124
1125 InvalidateVehicleOrder(v, VIWD_MODIFY_ORDERS);
1126
1127 /* We have an aircraft/ship, they have a mini-schedule, so update them all */
1128 if (v->type == VEH_AIRCRAFT) SetWindowClassesDirty(WC_AIRCRAFT_LIST);
1129 if (v->type == VEH_SHIP) SetWindowClassesDirty(WC_SHIPS_LIST);
1130 }
1131
1132 return CommandCost();
1133 }
1134
1145 CommandCost CmdMoveOrder(DoCommandFlag flags, VehicleID veh, VehicleOrderID moving_order, VehicleOrderID target_order)
1146 {
1147 Vehicle *v = Vehicle::GetIfValid(veh);
1148 if (v == nullptr || !v->IsPrimaryVehicle()) return CMD_ERROR;
1149
1150 CommandCost ret = CheckOwnership(v->owner);
1151 if (ret.Failed()) return ret;
1152
1153 /* Don't make senseless movements */
1154 if (moving_order >= v->GetNumOrders() || target_order >= v->GetNumOrders() ||
1155 moving_order == target_order || v->GetNumOrders() <= 1) return CMD_ERROR;
1156
1157 Order *moving_one = v->GetOrder(moving_order);
1158 /* Don't move an empty order */
1159 if (moving_one == nullptr) return CMD_ERROR;
1160
1161 if (flags & DC_EXEC) {
1162 v->orders->MoveOrder(moving_order, target_order);
1163
1164 /* Update shared list */
1165 Vehicle *u = v->FirstShared();
1166
1167 DeleteOrderWarnings(u);
1168
1169 for (; u != nullptr; u = u->NextShared()) {
1170 /* Update the current order.
1171 * There are multiple ways to move orders, which result in cur_implicit_order_index
1172 * and cur_real_order_index to not longer make any sense. E.g. moving another
1173 * real order between them.
1174 *
1175 * Basically one could choose to preserve either of them, but not both.
1176 * While both ways are suitable in this or that case from a human point of view, neither
1177 * of them makes really sense.
1178 * However, from an AI point of view, preserving cur_real_order_index is the most
1179 * predictable and transparent behaviour.
1180 *
1181 * With that decision it basically does not matter what we do to cur_implicit_order_index.
1182 * If we change orders between the implicit- and real-index, the implicit orders are mostly likely
1183 * completely out-dated anyway. So, keep it simple and just keep cur_implicit_order_index as well.
1184 * The worst which can happen is that a lot of implicit orders are removed when reaching current_order.
1185 */
1186 if (u->cur_real_order_index == moving_order) {
1187 u->cur_real_order_index = target_order;
1188 } else if (u->cur_real_order_index > moving_order && u->cur_real_order_index <= target_order) {
1189 u->cur_real_order_index--;
1190 } else if (u->cur_real_order_index < moving_order && u->cur_real_order_index >= target_order) {
1191 u->cur_real_order_index++;
1192 }
1193
1194 if (u->cur_implicit_order_index == moving_order) {
1195 u->cur_implicit_order_index = target_order;
1196 } else if (u->cur_implicit_order_index > moving_order && u->cur_implicit_order_index <= target_order) {
1197 u->cur_implicit_order_index--;
1198 } else if (u->cur_implicit_order_index < moving_order && u->cur_implicit_order_index >= target_order) {
1199 u->cur_implicit_order_index++;
1200 }
1201
1202 assert(v->orders == u->orders);
1203 /* Update any possible open window of the vehicle */
1204 InvalidateVehicleOrder(u, moving_order | (target_order << 8));
1205 }
1206
1207 /* As we move an order, the order to skip to will be 'wrong'. */
1208 for (Order *order : v->Orders()) {
1209 if (order->IsType(OT_CONDITIONAL)) {
1210 VehicleOrderID order_id = order->GetConditionSkipToOrder();
1211 if (order_id == moving_order) {
1212 order_id = target_order;
1213 } else if (order_id > moving_order && order_id <= target_order) {
1214 order_id--;
1215 } else if (order_id < moving_order && order_id >= target_order) {
1216 order_id++;
1217 }
1218 order->SetConditionSkipToOrder(order_id);
1219 }
1220 }
1221
1222 /* Make sure to rebuild the whole list */
1223 InvalidateWindowClassesData(GetWindowClassForVehicleType(v->type), 0);
1224 }
1225
1226 return CommandCost();
1227 }
1228
1240 CommandCost CmdModifyOrder(DoCommandFlag flags, VehicleID veh, VehicleOrderID sel_ord, ModifyOrderFlags mof, uint16 data)
1241 {
1242 if (mof >= MOF_END) return CMD_ERROR;
1243
1244 Vehicle *v = Vehicle::GetIfValid(veh);
1245 if (v == nullptr || !v->IsPrimaryVehicle()) return CMD_ERROR;
1246
1247 CommandCost ret = CheckOwnership(v->owner);
1248 if (ret.Failed()) return ret;
1249
1250 /* Is it a valid order? */
1251 if (sel_ord >= v->GetNumOrders()) return CMD_ERROR;
1252
1253 Order *order = v->GetOrder(sel_ord);
1254 switch (order->GetType()) {
1255 case OT_GOTO_STATION:
1256 if (mof != MOF_NON_STOP && mof != MOF_STOP_LOCATION && mof != MOF_UNLOAD && mof != MOF_LOAD) return CMD_ERROR;
1257 break;
1258
1259 case OT_GOTO_DEPOT:
1260 if (mof != MOF_NON_STOP && mof != MOF_DEPOT_ACTION) return CMD_ERROR;
1261 break;
1262
1263 case OT_GOTO_WAYPOINT:
1264 if (mof != MOF_NON_STOP) return CMD_ERROR;
1265 break;
1266
1267 case OT_CONDITIONAL:
1268 if (mof != MOF_COND_VARIABLE && mof != MOF_COND_COMPARATOR && mof != MOF_COND_VALUE && mof != MOF_COND_DESTINATION) return CMD_ERROR;
1269 break;
1270
1271 default:
1272 return CMD_ERROR;
1273 }
1274
1275 switch (mof) {
1276 default: NOT_REACHED();
1277
1278 case MOF_NON_STOP:
1279 if (!v->IsGroundVehicle()) return CMD_ERROR;
1280 if (data >= ONSF_END) return CMD_ERROR;
1281 if (data == order->GetNonStopType()) return CMD_ERROR;
1282 break;
1283
1284 case MOF_STOP_LOCATION:
1285 if (v->type != VEH_TRAIN) return CMD_ERROR;
1286 if (data >= OSL_END) return CMD_ERROR;
1287 break;
1288
1289 case MOF_UNLOAD:
1290 if (order->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION) return CMD_ERROR;
1291 if ((data & ~(OUFB_UNLOAD | OUFB_TRANSFER | OUFB_NO_UNLOAD)) != 0) return CMD_ERROR;
1292 /* Unload and no-unload are mutual exclusive and so are transfer and no unload. */
1293 if (data != 0 && ((data & (OUFB_UNLOAD | OUFB_TRANSFER)) != 0) == ((data & OUFB_NO_UNLOAD) != 0)) return CMD_ERROR;
1294 if (data == order->GetUnloadType()) return CMD_ERROR;
1295 break;
1296
1297 case MOF_LOAD:
1298 if (order->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION) return CMD_ERROR;
1299 if (data > OLFB_NO_LOAD || data == 1) return CMD_ERROR;
1300 if (data == order->GetLoadType()) return CMD_ERROR;
1301 break;
1302
1303 case MOF_DEPOT_ACTION:
1304 if (data >= DA_END) return CMD_ERROR;
1305 break;
1306
1307 case MOF_COND_VARIABLE:
1308 if (data >= OCV_END) return CMD_ERROR;
1309 break;
1310
1311 case MOF_COND_COMPARATOR:
1312 if (data >= OCC_END) return CMD_ERROR;
1313 switch (order->GetConditionVariable()) {
1314 case OCV_UNCONDITIONALLY: return CMD_ERROR;
1315
1316 case OCV_REQUIRES_SERVICE:
1317 if (data != OCC_IS_TRUE && data != OCC_IS_FALSE) return CMD_ERROR;
1318 break;
1319
1320 default:
1321 if (data == OCC_IS_TRUE || data == OCC_IS_FALSE) return CMD_ERROR;
1322 break;
1323 }
1324 break;
1325
1326 case MOF_COND_VALUE:
1327 switch (order->GetConditionVariable()) {
1328 case OCV_UNCONDITIONALLY:
1329 case OCV_REQUIRES_SERVICE:
1330 return CMD_ERROR;
1331
1332 case OCV_LOAD_PERCENTAGE:
1333 case OCV_RELIABILITY:
1334 if (data > 100) return CMD_ERROR;
1335 break;
1336
1337 default:
1338 if (data > 2047) return CMD_ERROR;
1339 break;
1340 }
1341 break;
1342
1343 case MOF_COND_DESTINATION:
1344 if (data >= v->GetNumOrders()) return CMD_ERROR;
1345 break;
1346 }
1347
1348 if (flags & DC_EXEC) {
1349 switch (mof) {
1350 case MOF_NON_STOP:
1351 order->SetNonStopType((OrderNonStopFlags)data);
1352 if (data & ONSF_NO_STOP_AT_DESTINATION_STATION) {
1353 order->SetRefit(CT_NO_REFIT);
1354 order->SetLoadType(OLF_LOAD_IF_POSSIBLE);
1355 order->SetUnloadType(OUF_UNLOAD_IF_POSSIBLE);
1356 }
1357 break;
1358
1359 case MOF_STOP_LOCATION:
1360 order->SetStopLocation((OrderStopLocation)data);
1361 break;
1362
1363 case MOF_UNLOAD:
1364 order->SetUnloadType((OrderUnloadFlags)data);
1365 break;
1366
1367 case MOF_LOAD:
1368 order->SetLoadType((OrderLoadFlags)data);
1369 if (data & OLFB_NO_LOAD) order->SetRefit(CT_NO_REFIT);
1370 break;
1371
1372 case MOF_DEPOT_ACTION: {
1373 switch (data) {
1374 case DA_ALWAYS_GO:
1375 order->SetDepotOrderType((OrderDepotTypeFlags)(order->GetDepotOrderType() & ~ODTFB_SERVICE));
1376 order->SetDepotActionType((OrderDepotActionFlags)(order->GetDepotActionType() & ~ODATFB_HALT));
1377 break;
1378
1379 case DA_SERVICE:
1380 order->SetDepotOrderType((OrderDepotTypeFlags)(order->GetDepotOrderType() | ODTFB_SERVICE));
1381 order->SetDepotActionType((OrderDepotActionFlags)(order->GetDepotActionType() & ~ODATFB_HALT));
1382 order->SetRefit(CT_NO_REFIT);
1383 break;
1384
1385 case DA_STOP:
1386 order->SetDepotOrderType((OrderDepotTypeFlags)(order->GetDepotOrderType() & ~ODTFB_SERVICE));
1387 order->SetDepotActionType((OrderDepotActionFlags)(order->GetDepotActionType() | ODATFB_HALT));
1388 order->SetRefit(CT_NO_REFIT);
1389 break;
1390
1391 default:
1392 NOT_REACHED();
1393 }
1394 break;
1395 }
1396
1397 case MOF_COND_VARIABLE: {
1398 order->SetConditionVariable((OrderConditionVariable)data);
1399
1400 OrderConditionComparator occ = order->GetConditionComparator();
1401 switch (order->GetConditionVariable()) {
1402 case OCV_UNCONDITIONALLY:
1403 order->SetConditionComparator(OCC_EQUALS);
1404 order->SetConditionValue(0);
1405 break;
1406
1407 case OCV_REQUIRES_SERVICE:
1408 if (occ != OCC_IS_TRUE && occ != OCC_IS_FALSE) order->SetConditionComparator(OCC_IS_TRUE);
1409 order->SetConditionValue(0);
1410 break;
1411
1412 case OCV_LOAD_PERCENTAGE:
1413 case OCV_RELIABILITY:
1414 if (order->GetConditionValue() > 100) order->SetConditionValue(100);
1415 FALLTHROUGH;
1416
1417 default:
1418 if (occ == OCC_IS_TRUE || occ == OCC_IS_FALSE) order->SetConditionComparator(OCC_EQUALS);
1419 break;
1420 }
1421 break;
1422 }
1423
1424 case MOF_COND_COMPARATOR:
1425 order->SetConditionComparator((OrderConditionComparator)data);
1426 break;
1427
1428 case MOF_COND_VALUE:
1429 order->SetConditionValue(data);
1430 break;
1431
1432 case MOF_COND_DESTINATION:
1433 order->SetConditionSkipToOrder(data);
1434 break;
1435
1436 default: NOT_REACHED();
1437 }
1438
1439 /* Update the windows and full load flags, also for vehicles that share the same order list */
1440 Vehicle *u = v->FirstShared();
1441 DeleteOrderWarnings(u);
1442 for (; u != nullptr; u = u->NextShared()) {
1443 /* Toggle u->current_order "Full load" flag if it changed.
1444 * However, as the same flag is used for depot orders, check
1445 * whether we are not going to a depot as there are three
1446 * cases where the full load flag can be active and only
1447 * one case where the flag is used for depot orders. In the
1448 * other cases for the OrderType the flags are not used,
1449 * so do not care and those orders should not be active
1450 * when this function is called.
1451 */
1452 if (sel_ord == u->cur_real_order_index &&
1453 (u->current_order.IsType(OT_GOTO_STATION) || u->current_order.IsType(OT_LOADING)) &&
1454 u->current_order.GetLoadType() != order->GetLoadType()) {
1455 u->current_order.SetLoadType(order->GetLoadType());
1456 }
1457 InvalidateVehicleOrder(u, VIWD_MODIFY_ORDERS);
1458 }
1459 }
1460
1461 return CommandCost();
1462 }
1463
1471 static bool CheckAircraftOrderDistance(const Aircraft *v_new, const Vehicle *v_order, const Order *first)
1472 {
1473 if (first == nullptr || v_new->acache.cached_max_range == 0) return true;
1474
1475 /* Iterate over all orders to check the distance between all
1476 * 'goto' orders and their respective next order (of any type). */
1477 for (const Order *o = first; o != nullptr; o = o->next) {
1478 switch (o->GetType()) {
1479 case OT_GOTO_STATION:
1480 case OT_GOTO_DEPOT:
1481 case OT_GOTO_WAYPOINT:
1482 /* If we don't have a next order, we've reached the end and must check the first order instead. */
1483 if (GetOrderDistance(o, o->next != nullptr ? o->next : first, v_order) > v_new->acache.cached_max_range_sqr) return false;
1484 break;
1485
1486 default: break;
1487 }
1488 }
1489
1490 return true;
1491 }
1492
1501 CommandCost CmdCloneOrder(DoCommandFlag flags, CloneOptions action, VehicleID veh_dst, VehicleID veh_src)
1502 {
1503 Vehicle *dst = Vehicle::GetIfValid(veh_dst);
1504 if (dst == nullptr || !dst->IsPrimaryVehicle()) return CMD_ERROR;
1505
1506 CommandCost ret = CheckOwnership(dst->owner);
1507 if (ret.Failed()) return ret;
1508
1509 switch (action) {
1510 case CO_SHARE: {
1511 Vehicle *src = Vehicle::GetIfValid(veh_src);
1512
1513 /* Sanity checks */
1514 if (src == nullptr || !src->IsPrimaryVehicle() || dst->type != src->type || dst == src) return CMD_ERROR;
1515
1516 CommandCost ret = CheckOwnership(src->owner);
1517 if (ret.Failed()) return ret;
1518
1519 /* Trucks can't share orders with busses (and visa versa) */
1520 if (src->type == VEH_ROAD && RoadVehicle::From(src)->IsBus() != RoadVehicle::From(dst)->IsBus()) {
1521 return CMD_ERROR;
1522 }
1523
1524 /* Is the vehicle already in the shared list? */
1525 if (src->FirstShared() == dst->FirstShared()) return CMD_ERROR;
1526
1527 for (const Order *order : src->Orders()) {
1528 if (!OrderGoesToStation(dst, order)) continue;
1529
1530 /* Allow copying unreachable destinations if they were already unreachable for the source.
1531 * This is basically to allow cloning / autorenewing / autoreplacing vehicles, while the stations
1532 * are temporarily invalid due to reconstruction. */
1533 const Station *st = Station::Get(order->GetDestination());
1534 if (CanVehicleUseStation(src, st) && !CanVehicleUseStation(dst, st)) {
1535 return_cmd_error(STR_ERROR_CAN_T_COPY_SHARE_ORDER);
1536 }
1537 }
1538
1539 /* Check for aircraft range limits. */
1540 if (dst->type == VEH_AIRCRAFT && !CheckAircraftOrderDistance(Aircraft::From(dst), src, src->GetFirstOrder())) {
1541 return_cmd_error(STR_ERROR_AIRCRAFT_NOT_ENOUGH_RANGE);
1542 }
1543
1544 if (src->orders == nullptr && !OrderList::CanAllocateItem()) {
1545 return_cmd_error(STR_ERROR_NO_MORE_SPACE_FOR_ORDERS);
1546 }
1547
1548 if (flags & DC_EXEC) {
1549 /* If the destination vehicle had a OrderList, destroy it.
1550 * We only reset the order indices, if the new orders are obviously different.
1551 * (We mainly do this to keep the order indices valid and in range.) */
1552 DeleteVehicleOrders(dst, false, dst->GetNumOrders() != src->GetNumOrders());
1553
1554 dst->orders = src->orders;
1555
1556 /* Link this vehicle in the shared-list */
1557 dst->AddToShared(src);
1558
1559 InvalidateVehicleOrder(dst, VIWD_REMOVE_ALL_ORDERS);
1560 InvalidateVehicleOrder(src, VIWD_MODIFY_ORDERS);
1561
1562 InvalidateWindowClassesData(GetWindowClassForVehicleType(dst->type), 0);
1563 }
1564 break;
1565 }
1566
1567 case CO_COPY: {
1568 Vehicle *src = Vehicle::GetIfValid(veh_src);
1569
1570 /* Sanity checks */
1571 if (src == nullptr || !src->IsPrimaryVehicle() || dst->type != src->type || dst == src) return CMD_ERROR;
1572
1573 CommandCost ret = CheckOwnership(src->owner);
1574 if (ret.Failed()) return ret;
1575
1576 /* Trucks can't copy all the orders from busses (and visa versa),
1577 * and neither can helicopters and aircraft. */
1578 for (const Order *order : src->Orders()) {
1579 if (OrderGoesToStation(dst, order) &&
1580 !CanVehicleUseStation(dst, Station::Get(order->GetDestination()))) {
1581 return_cmd_error(STR_ERROR_CAN_T_COPY_SHARE_ORDER);
1582 }
1583 }
1584
1585 /* Check for aircraft range limits. */
1586 if (dst->type == VEH_AIRCRAFT && !CheckAircraftOrderDistance(Aircraft::From(dst), src, src->GetFirstOrder())) {
1587 return_cmd_error(STR_ERROR_AIRCRAFT_NOT_ENOUGH_RANGE);
1588 }
1589
1590 /* make sure there are orders available */
1591 if (!Order::CanAllocateItem(src->GetNumOrders()) || !OrderList::CanAllocateItem()) {
1592 return_cmd_error(STR_ERROR_NO_MORE_SPACE_FOR_ORDERS);
1593 }
1594
1595 if (flags & DC_EXEC) {
1596 Order *first = nullptr;
1597 Order **order_dst;
1598
1599 /* If the destination vehicle had an order list, destroy the chain but keep the OrderList.
1600 * We only reset the order indices, if the new orders are obviously different.
1601 * (We mainly do this to keep the order indices valid and in range.) */
1602 DeleteVehicleOrders(dst, true, dst->GetNumOrders() != src->GetNumOrders());
1603
1604 order_dst = &first;
1605 for (const Order *order : src->Orders()) {
1606 *order_dst = new Order();
1607 (*order_dst)->AssignOrder(*order);
1608 order_dst = &(*order_dst)->next;
1609 }
1610 if (dst->orders == nullptr) {
1611 dst->orders = new OrderList(first, dst);
1612 } else {
1613 assert(dst->orders->GetFirstOrder() == nullptr);
1614 assert(!dst->orders->IsShared());
1615 delete dst->orders;
1616 assert(OrderList::CanAllocateItem());
1617 dst->orders = new OrderList(first, dst);
1618 }
1619
1620 InvalidateVehicleOrder(dst, VIWD_REMOVE_ALL_ORDERS);
1621
1622 InvalidateWindowClassesData(GetWindowClassForVehicleType(dst->type), 0);
1623 }
1624 break;
1625 }
1626
1627 case CO_UNSHARE: return DecloneOrder(dst, flags);
1628 default: return CMD_ERROR;
1629 }
1630
1631 return CommandCost();
1632 }
1633
1642 CommandCost CmdOrderRefit(DoCommandFlag flags, VehicleID veh, VehicleOrderID order_number, CargoID cargo)
1643 {
1644 if (cargo >= NUM_CARGO && cargo != CT_NO_REFIT && cargo != CT_AUTO_REFIT) return CMD_ERROR;
1645
1646 const Vehicle *v = Vehicle::GetIfValid(veh);
1647 if (v == nullptr || !v->IsPrimaryVehicle()) return CMD_ERROR;
1648
1649 CommandCost ret = CheckOwnership(v->owner);
1650 if (ret.Failed()) return ret;
1651
1652 Order *order = v->GetOrder(order_number);
1653 if (order == nullptr) return CMD_ERROR;
1654
1655 /* Automatic refit cargo is only supported for goto station orders. */
1656 if (cargo == CT_AUTO_REFIT && !order->IsType(OT_GOTO_STATION)) return CMD_ERROR;
1657
1658 if (order->GetLoadType() & OLFB_NO_LOAD) return CMD_ERROR;
1659
1660 if (flags & DC_EXEC) {
1661 order->SetRefit(cargo);
1662
1663 /* Make the depot order an 'always go' order. */
1664 if (cargo != CT_NO_REFIT && order->IsType(OT_GOTO_DEPOT)) {
1665 order->SetDepotOrderType((OrderDepotTypeFlags)(order->GetDepotOrderType() & ~ODTFB_SERVICE));
1666 order->SetDepotActionType((OrderDepotActionFlags)(order->GetDepotActionType() & ~ODATFB_HALT));
1667 }
1668
1669 for (Vehicle *u = v->FirstShared(); u != nullptr; u = u->NextShared()) {
1670 /* Update any possible open window of the vehicle */
1671 InvalidateVehicleOrder(u, VIWD_MODIFY_ORDERS);
1672
1673 /* If the vehicle already got the current depot set as current order, then update current order as well */
1674 if (u->cur_real_order_index == order_number && (u->current_order.GetDepotOrderType() & ODTFB_PART_OF_ORDERS)) {
1675 u->current_order.SetRefit(cargo);
1676 }
1677 }
1678 }
1679
1680 return CommandCost();
1681 }
1682
1683
1689 void CheckOrders(const Vehicle *v)
1690 {
1691 /* Does the user wants us to check things? */
1692 if (_settings_client.gui.order_review_system == 0) return;
1693
1694 /* Do nothing for crashed vehicles */
1695 if (v->vehstatus & VS_CRASHED) return;
1696
1697 /* Do nothing for stopped vehicles if setting is '1' */
1698 if (_settings_client.gui.order_review_system == 1 && (v->vehstatus & VS_STOPPED)) return;
1699
1700 /* do nothing we we're not the first vehicle in a share-chain */
1701 if (v->FirstShared() != v) return;
1702
1703 /* Only check every 20 days, so that we don't flood the message log */
1704 if (v->owner == _local_company && v->day_counter % 20 == 0) {
1705 StringID message = INVALID_STRING_ID;
1706
1707 /* Check the order list */
1708 int n_st = 0;
1709
1710 for (const Order *order : v->Orders()) {
1711 /* Dummy order? */
1712 if (order->IsType(OT_DUMMY)) {
1713 message = STR_NEWS_VEHICLE_HAS_VOID_ORDER;
1714 break;
1715 }
1716 /* Does station have a load-bay for this vehicle? */
1717 if (order->IsType(OT_GOTO_STATION)) {
1718 const Station *st = Station::Get(order->GetDestination());
1719
1720 n_st++;
1721 if (!CanVehicleUseStation(v, st)) {
1722 message = STR_NEWS_VEHICLE_HAS_INVALID_ENTRY;
1723 } else if (v->type == VEH_AIRCRAFT &&
1724 (AircraftVehInfo(v->engine_type)->subtype & AIR_FAST) &&
1725 (st->airport.GetFTA()->flags & AirportFTAClass::SHORT_STRIP) &&
1726 !_cheats.no_jetcrash.value &&
1727 message == INVALID_STRING_ID) {
1728 message = STR_NEWS_PLANE_USES_TOO_SHORT_RUNWAY;
1729 }
1730 }
1731 }
1732
1733 /* Check if the last and the first order are the same */
1734 if (v->GetNumOrders() > 1) {
1735 const Order *last = v->GetLastOrder();
1736
1737 if (v->orders->GetFirstOrder()->Equals(*last)) {
1738 message = STR_NEWS_VEHICLE_HAS_DUPLICATE_ENTRY;
1739 }
1740 }
1741
1742 /* Do we only have 1 station in our order list? */
1743 if (n_st < 2 && message == INVALID_STRING_ID) message = STR_NEWS_VEHICLE_HAS_TOO_FEW_ORDERS;
1744
1745 #ifdef WITH_ASSERT
1746 if (v->orders != nullptr) v->orders->DebugCheckSanity();
1747 #endif
1748
1749 /* We don't have a problem */
1750 if (message == INVALID_STRING_ID) return;
1751
1752 SetDParam(0, v->index);
1753 AddVehicleAdviceNewsItem(message, v->index);
1754 }
1755 }
1756
1765 void RemoveOrderFromAllVehicles(OrderType type, DestinationID destination, bool hangar)
1766 {
1767 /* Aircraft have StationIDs for depot orders and never use DepotIDs
1768 * This fact is handled specially below
1769 */
1770
1771 /* Go through all vehicles */
1772 for (Vehicle *v : Vehicle::Iterate()) {
1773 Order *order;
1774
1775 order = &v->current_order;
1776 if ((v->type == VEH_AIRCRAFT && order->IsType(OT_GOTO_DEPOT) && !hangar ? OT_GOTO_STATION : order->GetType()) == type &&
1777 (!hangar || v->type == VEH_AIRCRAFT) && v->current_order.GetDestination() == destination) {
1778 order->MakeDummy();
1779 SetWindowDirty(WC_VEHICLE_VIEW, v->index);
1780 }
1781
1782 /* Clear the order from the order-list */
1783 int id = -1;
1784 for (Order *order : v->Orders()) {
1785 id++;
1786 restart:
1787
1788 OrderType ot = order->GetType();
1789 if (ot == OT_GOTO_DEPOT && (order->GetDepotActionType() & ODATFB_NEAREST_DEPOT) != 0) continue;
1790 if (ot == OT_GOTO_DEPOT && hangar && v->type != VEH_AIRCRAFT) continue; // Not an aircraft? Can't have a hangar order.
1791 if (ot == OT_IMPLICIT || (v->type == VEH_AIRCRAFT && ot == OT_GOTO_DEPOT && !hangar)) ot = OT_GOTO_STATION;
1792 if (ot == type && order->GetDestination() == destination) {
1793 /* We want to clear implicit orders, but we don't want to make them
1794 * dummy orders. They should just vanish. Also check the actual order
1795 * type as ot is currently OT_GOTO_STATION. */
1796 if (order->IsType(OT_IMPLICIT)) {
1797 order = order->next; // DeleteOrder() invalidates current order
1798 DeleteOrder(v, id);
1799 if (order != nullptr) goto restart;
1800 break;
1801 }
1802
1803 /* Clear wait time */
1804 v->orders->UpdateTotalDuration(-order->GetWaitTime());
1805 if (order->IsWaitTimetabled()) {
1806 v->orders->UpdateTimetableDuration(-order->GetTimetabledWait());
1807 order->SetWaitTimetabled(false);
1808 }
1809 order->SetWaitTime(0);
1810
1811 /* Clear order, preserving travel time */
1812 bool travel_timetabled = order->IsTravelTimetabled();
1813 order->MakeDummy();
1814 order->SetTravelTimetabled(travel_timetabled);
1815
1816 for (const Vehicle *w = v->FirstShared(); w != nullptr; w = w->NextShared()) {
1817 /* In GUI, simulate by removing the order and adding it back */
1818 InvalidateVehicleOrder(w, id | (INVALID_VEH_ORDER_ID << 8));
1819 InvalidateVehicleOrder(w, (INVALID_VEH_ORDER_ID << 8) | id);
1820 }
1821 }
1822 }
1823 }
1824
1825 OrderBackup::RemoveOrder(type, destination, hangar);
1826 }
1827
1832 bool Vehicle::HasDepotOrder() const
1833 {
1834 for (const Order *order : this->Orders()) {
1835 if (order->IsType(OT_GOTO_DEPOT)) return true;
1836 }
1837
1838 return false;
1839 }
1840
1850 void DeleteVehicleOrders(Vehicle *v, bool keep_orderlist, bool reset_order_indices)
1851 {
1852 DeleteOrderWarnings(v);
1853
1854 if (v->IsOrderListShared()) {
1855 /* Remove ourself from the shared order list. */
1856 v->RemoveFromShared();
1857 v->orders = nullptr;
1858 } else if (v->orders != nullptr) {
1859 /* Remove the orders */
1860 v->orders->FreeChain(keep_orderlist);
1861 if (!keep_orderlist) v->orders = nullptr;
1862 }
1863
1864 if (reset_order_indices) {
1865 v->cur_implicit_order_index = v->cur_real_order_index = 0;
1866 if (v->current_order.IsType(OT_LOADING)) {
1867 CancelLoadingDueToDeletedOrder(v);
1868 }
1869 }
1870 }
1871
1878 uint16 GetServiceIntervalClamped(uint interval, bool ispercent)
1879 {
1880 return ispercent ? Clamp(interval, MIN_SERVINT_PERCENT, MAX_SERVINT_PERCENT) : Clamp(interval, MIN_SERVINT_DAYS, MAX_SERVINT_DAYS);
1881 }
1882
1891 static bool CheckForValidOrders(const Vehicle *v)
1892 {
1893 for (const Order *order : v->Orders()) {
1894 switch (order->GetType()) {
1895 case OT_GOTO_STATION:
1896 case OT_GOTO_DEPOT:
1897 case OT_GOTO_WAYPOINT:
1898 return true;
1899
1900 default:
1901 break;
1902 }
1903 }
1904
1905 return false;
1906 }
1907
1911 static bool OrderConditionCompare(OrderConditionComparator occ, int variable, int value)
1912 {
1913 switch (occ) {
1914 case OCC_EQUALS: return variable == value;
1915 case OCC_NOT_EQUALS: return variable != value;
1916 case OCC_LESS_THAN: return variable < value;
1917 case OCC_LESS_EQUALS: return variable <= value;
1918 case OCC_MORE_THAN: return variable > value;
1919 case OCC_MORE_EQUALS: return variable >= value;
1920 case OCC_IS_TRUE: return variable != 0;
1921 case OCC_IS_FALSE: return variable == 0;
1922 default: NOT_REACHED();
1923 }
1924 }
1925
1932 VehicleOrderID ProcessConditionalOrder(const Order *order, const Vehicle *v)
1933 {
1934 if (order->GetType() != OT_CONDITIONAL) return INVALID_VEH_ORDER_ID;
1935
1936 bool skip_order = false;
1937 OrderConditionComparator occ = order->GetConditionComparator();
1938 uint16 value = order->GetConditionValue();
1939
1940 switch (order->GetConditionVariable()) {
1941 case OCV_LOAD_PERCENTAGE: skip_order = OrderConditionCompare(occ, CalcPercentVehicleFilled(v, nullptr), value); break;
1942 case OCV_RELIABILITY: skip_order = OrderConditionCompare(occ, ToPercent16(v->reliability), value); break;
1943 case OCV_MAX_RELIABILITY: skip_order = OrderConditionCompare(occ, ToPercent16(v->GetEngine()->reliability), value); break;
1944 case OCV_MAX_SPEED: skip_order = OrderConditionCompare(occ, v->GetDisplayMaxSpeed() * 10 / 16, value); break;
1945 case OCV_AGE: skip_order = OrderConditionCompare(occ, v->age / DAYS_IN_LEAP_YEAR, value); break;
1946 case OCV_REQUIRES_SERVICE: skip_order = OrderConditionCompare(occ, v->NeedsServicing(), value); break;
1947 case OCV_UNCONDITIONALLY: skip_order = true; break;
1948 case OCV_REMAINING_LIFETIME: skip_order = OrderConditionCompare(occ, std::max(v->max_age - v->age + DAYS_IN_LEAP_YEAR - 1, 0) / DAYS_IN_LEAP_YEAR, value); break;
1949 default: NOT_REACHED();
1950 }
1951
1952 return skip_order ? order->GetConditionSkipToOrder() : (VehicleOrderID)INVALID_VEH_ORDER_ID;
1953 }
1954
1962 bool UpdateOrderDest(Vehicle *v, const Order *order, int conditional_depth, bool pbs_look_ahead)
1963 {
1964 if (conditional_depth > v->GetNumOrders()) {
1965 v->current_order.Free();
1966 v->SetDestTile(0);
1967 return false;
1968 }
1969
1970 switch (order->GetType()) {
1971 case OT_GOTO_STATION:
1972 v->SetDestTile(v->GetOrderStationLocation(order->GetDestination()));
1973 return true;
1974
1975 case OT_GOTO_DEPOT:
1976 if ((order->GetDepotOrderType() & ODTFB_SERVICE) && !v->NeedsServicing()) {
1977 assert(!pbs_look_ahead);
1978 UpdateVehicleTimetable(v, true);
1979 v->IncrementRealOrderIndex();
1980 break;
1981 }
1982
1983 if (v->current_order.GetDepotActionType() & ODATFB_NEAREST_DEPOT) {
1984 /* We need to search for the nearest depot (hangar). */
1985 TileIndex location;
1986 DestinationID destination;
1987 bool reverse;
1988
1989 if (v->FindClosestDepot(&location, &destination, &reverse)) {
1990 /* PBS reservations cannot reverse */
1991 if (pbs_look_ahead && reverse) return false;
1992
1993 v->SetDestTile(location);
1994 v->current_order.SetDestination(destination);
1995
1996 /* If there is no depot in front, reverse automatically (trains only) */
1997 if (v->type == VEH_TRAIN && reverse) Command<CMD_REVERSE_TRAIN_DIRECTION>::Do(DC_EXEC, v->index, false);
1998
1999 if (v->type == VEH_AIRCRAFT) {
2000 Aircraft *a = Aircraft::From(v);
2001 if (a->state == FLYING && a->targetairport != destination) {
2002 /* The aircraft is now heading for a different hangar than the next in the orders */
2003 extern void AircraftNextAirportPos_and_Order(Aircraft *a);
2004 AircraftNextAirportPos_and_Order(a);
2005 }
2006 }
2007 return true;
2008 }
2009
2010 /* If there is no depot, we cannot help PBS either. */
2011 if (pbs_look_ahead) return false;
2012
2013 UpdateVehicleTimetable(v, true);
2014 v->IncrementRealOrderIndex();
2015 } else {
2016 if (v->type != VEH_AIRCRAFT) {
2017 v->SetDestTile(Depot::Get(order->GetDestination())->xy);
2018 } else {
2019 Aircraft *a = Aircraft::From(v);
2020 DestinationID destination = a->current_order.GetDestination();
2021 if (a->targetairport != destination) {
2022 /* The aircraft is now heading for a different hangar than the next in the orders */
2023 a->SetDestTile(a->GetOrderStationLocation(destination));
2024 }
2025 }
2026 return true;
2027 }
2028 break;
2029
2030 case OT_GOTO_WAYPOINT:
2031 v->SetDestTile(Waypoint::Get(order->GetDestination())->xy);
2032 return true;
2033
2034 case OT_CONDITIONAL: {
2035 assert(!pbs_look_ahead);
2036 VehicleOrderID next_order = ProcessConditionalOrder(order, v);
2037 if (next_order != INVALID_VEH_ORDER_ID) {
2038 /* Jump to next_order. cur_implicit_order_index becomes exactly that order,
2039 * cur_real_order_index might come after next_order. */
2040 UpdateVehicleTimetable(v, false);
2041 v->cur_implicit_order_index = v->cur_real_order_index = next_order;
2042 v->UpdateRealOrderIndex();
2043 v->current_order_time += v->GetOrder(v->cur_real_order_index)->GetTimetabledTravel();
2044
2045 /* Disable creation of implicit orders.
2046 * When inserting them we do not know that we would have to make the conditional orders point to them. */
2047 if (v->IsGroundVehicle()) {
2048 uint16 &gv_flags = v->GetGroundVehicleFlags();
2049 SetBit(gv_flags, GVF_SUPPRESS_IMPLICIT_ORDERS);
2050 }
2051 } else {
2052 UpdateVehicleTimetable(v, true);
2053 v->IncrementRealOrderIndex();
2054 }
2055 break;
2056 }
2057
2058 default:
2059 v->SetDestTile(0);
2060 return false;
2061 }
2062
2063 assert(v->cur_implicit_order_index < v->GetNumOrders());
2064 assert(v->cur_real_order_index < v->GetNumOrders());
2065
2066 /* Get the current order */
2067 order = v->GetOrder(v->cur_real_order_index);
2068 if (order != nullptr && order->IsType(OT_IMPLICIT)) {
2069 assert(v->GetNumManualOrders() == 0);
2070 order = nullptr;
2071 }
2072
2073 if (order == nullptr) {
2074 v->current_order.Free();
2075 v->SetDestTile(0);
2076 return false;
2077 }
2078
2079 v->current_order = *order;
2080 return UpdateOrderDest(v, order, conditional_depth + 1, pbs_look_ahead);
2081 }
2082
2090 bool ProcessOrders(Vehicle *v)
2091 {
2092 switch (v->current_order.GetType()) {
2093 case OT_GOTO_DEPOT:
2094 /* Let a depot order in the orderlist interrupt. */
2095 if (!(v->current_order.GetDepotOrderType() & ODTFB_PART_OF_ORDERS)) return false;
2096 break;
2097
2098 case OT_LOADING:
2099 return false;
2100
2101 case OT_LEAVESTATION:
2102 if (v->type != VEH_AIRCRAFT) return false;
2103 break;
2104
2105 default: break;
2106 }
2107
2115 bool may_reverse = v->current_order.IsType(OT_NOTHING);
2116
2117 /* Check if we've reached a 'via' destination. */
2118 if (((v->current_order.IsType(OT_GOTO_STATION) && (v->current_order.GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION)) || v->current_order.IsType(OT_GOTO_WAYPOINT)) &&
2119 IsTileType(v->tile, MP_STATION) &&
2120 v->current_order.GetDestination() == GetStationIndex(v->tile)) {
2121 v->DeleteUnreachedImplicitOrders();
2122 /* We set the last visited station here because we do not want
2123 * the train to stop at this 'via' station if the next order
2124 * is a no-non-stop order; in that case not setting the last
2125 * visited station will cause the vehicle to still stop. */
2126 v->last_station_visited = v->current_order.GetDestination();
2127 UpdateVehicleTimetable(v, true);
2128 v->IncrementImplicitOrderIndex();
2129 }
2130
2131 /* Get the current order */
2132 assert(v->cur_implicit_order_index == 0 || v->cur_implicit_order_index < v->GetNumOrders());
2133 v->UpdateRealOrderIndex();
2134
2135 const Order *order = v->GetOrder(v->cur_real_order_index);
2136 if (order != nullptr && order->IsType(OT_IMPLICIT)) {
2137 assert(v->GetNumManualOrders() == 0);
2138 order = nullptr;
2139 }
2140
2141 /* If no order, do nothing. */
2142 if (order == nullptr || (v->type == VEH_AIRCRAFT && !CheckForValidOrders(v))) {
2143 if (v->type == VEH_AIRCRAFT) {
2144 /* Aircraft do something vastly different here, so handle separately */
2145 extern void HandleMissingAircraftOrders(Aircraft *v);
2146 HandleMissingAircraftOrders(Aircraft::From(v));
2147 return false;
2148 }
2149
2150 v->current_order.Free();
2151 v->SetDestTile(0);
2152 return false;
2153 }
2154
2155 /* If it is unchanged, keep it. */
2156 if (order->Equals(v->current_order) && (v->type == VEH_AIRCRAFT || v->dest_tile != 0) &&
2157 (v->type != VEH_SHIP || !order->IsType(OT_GOTO_STATION) || Station::Get(order->GetDestination())->ship_station.tile != INVALID_TILE)) {
2158 return false;
2159 }
2160
2161 /* Otherwise set it, and determine the destination tile. */
2162 v->current_order = *order;
2163
2164 InvalidateVehicleOrder(v, VIWD_MODIFY_ORDERS);
2165 switch (v->type) {
2166 default:
2167 NOT_REACHED();
2168
2169 case VEH_ROAD:
2170 case VEH_TRAIN:
2171 break;
2172
2173 case VEH_AIRCRAFT:
2174 case VEH_SHIP:
2175 SetWindowClassesDirty(GetWindowClassForVehicleType(v->type));
2176 break;
2177 }
2178
2179 return UpdateOrderDest(v, order) && may_reverse;
2180 }
2181
2189 bool Order::ShouldStopAtStation(const Vehicle *v, StationID station) const
2190 {
2191 bool is_dest_station = this->IsType(OT_GOTO_STATION) && this->dest == station;
2192
2193 return (!this->IsType(OT_GOTO_DEPOT) || (this->GetDepotOrderType() & ODTFB_PART_OF_ORDERS) != 0) &&
2194 v->last_station_visited != station && // Do stop only when we've not just been there
2195 /* Finally do stop when there is no non-stop flag set for this type of station. */
2196 !(this->GetNonStopType() & (is_dest_station ? ONSF_NO_STOP_AT_DESTINATION_STATION : ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS));
2197 }
2198
2199 bool Order::CanLoadOrUnload() const
2200 {
2201 return (this->IsType(OT_GOTO_STATION) || this->IsType(OT_IMPLICIT)) &&
2202 (this->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION) == 0 &&
2203 ((this->GetLoadType() & OLFB_NO_LOAD) == 0 ||
2204 (this->GetUnloadType() & OUFB_NO_UNLOAD) == 0);
2205 }
2206
2213 bool Order::CanLeaveWithCargo(bool has_cargo) const
2214 {
2215 return (this->GetLoadType() & OLFB_NO_LOAD) == 0 || (has_cargo &&
2216 (this->GetUnloadType() & (OUFB_UNLOAD | OUFB_TRANSFER)) == 0);
2217 }
VEH_AIRCRAFT
@ VEH_AIRCRAFT
Aircraft vehicle type.
Definition: vehicle_type.h:27
OrderList::first_shared
Vehicle * first_shared
NOSAVE: pointer to the first vehicle in the shared order chain.
Definition: order_base.h:271
DA_STOP
@ DA_STOP
Go to the depot and stop there.
Definition: order_type.h:163
BaseStation::facilities
StationFacility facilities
The facilities that this station has.
Definition: base_station_base.h:63
Aircraft::targetairport
StationID targetairport
Airport to go to next.
Definition: aircraft.h:78
BaseConsist::cur_implicit_order_index
VehicleOrderID cur_implicit_order_index
The index to the current implicit order.
Definition: base_consist.h:29
VehicleOrderID
byte VehicleOrderID
The index of an order within its current vehicle (not pool related)
Definition: order_type.h:15
Order::IsRefit
bool IsRefit() const
Is this order a refit order.
Definition: order_base.h:118
Cheats::no_jetcrash
Cheat no_jetcrash
no jet will crash on small airports anymore
Definition: cheat_type.h:31
DeleteOrder
void DeleteOrder(Vehicle *v, VehicleOrderID sel_ord)
Delete an order but skip the parameter validation.
Definition: order_cmd.cpp:1048
InvalidateWindowData
void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
Mark window data of the window of a given class and specific window number as invalid (in need of re-...
Definition: window.cpp:3252
Order::GetWaitTime
uint16 GetWaitTime() const
Get the time in ticks a vehicle will probably wait at the destination (timetabled or not).
Definition: order_base.h:193
Order::MakeDummy
void MakeDummy()
Makes this order a Dummy order.
Definition: order_cmd.cpp:133
SmallStack
Minimal stack that uses a pool to avoid pointers.
Definition: smallstack_type.hpp:136
UpdateVehicleTimetable
void UpdateVehicleTimetable(Vehicle *v, bool travelling)
Update the timetable for the vehicle.
Definition: timetable_cmd.cpp:383
SmallStack::Pop
Titem Pop()
Pop an item from the stack.
Definition: smallstack_type.hpp:213
AircraftNextAirportPos_and_Order
void AircraftNextAirportPos_and_Order(Aircraft *v)
set the right pos when heading to other airports after takeoff
Definition: aircraft_cmd.cpp:1435
OUFB_UNLOAD
@ OUFB_UNLOAD
Force unloading all cargo onto the platform, possibly not getting paid.
Definition: order_type.h:54
Order::IsType
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition: order_base.h:71
order_cmd.h
Pool::PoolItem<&_station_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:337
Order::GetTimetabledWait
uint16 GetTimetabledWait() const
Get the time in ticks a vehicle should wait at the destination or 0 if it's not timetabled.
Definition: order_base.h:189
SetWindowDirty
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition: window.cpp:3154
Vehicle::PreviousShared
Vehicle * PreviousShared() const
Get the previous vehicle of the shared vehicle chain.
Definition: vehicle_base.h:698
Order::SetLoadType
void SetLoadType(OrderLoadFlags load_type)
Set how the consist must be loaded.
Definition: order_base.h:158
GetServiceIntervalClamped
uint16 GetServiceIntervalClamped(uint interval, bool ispercent)
Clamp the service interval to the correct min/max.
Definition: order_cmd.cpp:1878
GB
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
Definition: bitmath_func.hpp:32
Vehicle::GetNumManualOrders
VehicleOrderID GetNumManualOrders() const
Get the number of manually added orders this vehicle has.
Definition: vehicle_base.h:722
CloneOptions
CloneOptions
Clone actions.
Definition: order_type.h:180
OCC_NOT_EQUALS
@ OCC_NOT_EQUALS
Skip if both values are not equal.
Definition: order_type.h:129
command_func.h
SmallStack::Push
void Push(const Titem &item)
Pushes a new item onto the stack if there is still space in the underlying pool.
Definition: smallstack_type.hpp:193
Pool::PoolItem<&_station_pool >::GetIfValid
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:348
ODTFB_SERVICE
@ ODTFB_SERVICE
This depot order is because of the servicing limit.
Definition: order_type.h:95
CMD_ERROR
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
Definition: command_func.h:28
Vehicle::GetGroundVehicleFlags
uint16 & GetGroundVehicleFlags()
Access the ground vehicle flags of the vehicle.
Definition: vehicle.cpp:2936
MOF_COND_VARIABLE
@ MOF_COND_VARIABLE
A conditional variable changes.
Definition: order_type.h:149
CheckOrders
void CheckOrders(const Vehicle *v)
Check the orders of a vehicle, to see if there are invalid orders and stuff.
Definition: order_cmd.cpp:1689
GVF_SUPPRESS_IMPLICIT_ORDERS
@ GVF_SUPPRESS_IMPLICIT_ORDERS
Disable insertion and removal of automatic orders until the vehicle completes the real order.
Definition: ground_vehicle.hpp:54
OrderLoadFlags
OrderLoadFlags
Flags related to the loading order.
Definition: order_type.h:62
Order::MakeLoading
void MakeLoading(bool ordered)
Makes this order a Loading order.
Definition: order_cmd.cpp:115
Order::MakeLeaveStation
void MakeLeaveStation()
Makes this order a Leave Station order.
Definition: order_cmd.cpp:124
ModifyOrderFlags
ModifyOrderFlags
Enumeration for the data to set in CmdModifyOrder.
Definition: order_type.h:143
Vehicle::LeaveStation
void LeaveStation()
Perform all actions when leaving a station.
Definition: vehicle.cpp:2261
company_base.h
OUFB_TRANSFER
@ OUFB_TRANSFER
Transfer all cargo onto the platform.
Definition: order_type.h:55
Vehicle::GetDisplayMaxSpeed
virtual int GetDisplayMaxSpeed() const
Gets the maximum speed in km-ish/h that can be sent into SetDParam for string processing.
Definition: vehicle_base.h:513
OLFB_FULL_LOAD
@ OLFB_FULL_LOAD
Full load all cargoes of the consist.
Definition: order_type.h:64
Station
Station data structure.
Definition: station_base.h:454
Order::GetDestination
DestinationID GetDestination() const
Gets the destination of this order.
Definition: order_base.h:104
ProcessConditionalOrder
VehicleOrderID ProcessConditionalOrder(const Order *order, const Vehicle *v)
Process a conditional order and determine the next order.
Definition: order_cmd.cpp:1932
InsertOrder
void InsertOrder(Vehicle *v, Order *new_o, VehicleOrderID sel_ord)
Insert a new order but skip the validation.
Definition: order_cmd.cpp:926
OrderList::total_duration
Ticks total_duration
NOSAVE: Total (timetabled or not) duration of the order list.
Definition: order_base.h:274
Order::GetTimetabledTravel
uint16 GetTimetabledTravel() const
Get the time in ticks a vehicle should take to reach the destination or 0 if it's not timetabled.
Definition: order_base.h:191
Order::GetConditionValue
uint16 GetConditionValue() const
Get the value to base the skip on.
Definition: order_base.h:155
IsRoadDepotTile
static bool IsRoadDepotTile(TileIndex t)
Return whether a tile is a road depot tile.
Definition: road_map.h:116
Vehicle::vehstatus
byte vehstatus
Status.
Definition: vehicle_base.h:332
OrderList::MoveOrder
void MoveOrder(int from, int to)
Move an order to another position within the order list.
Definition: order_cmd.cpp:536
DepotID
uint16 DepotID
Type for the unique identifier of depots.
Definition: depot_type.h:15
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:235
AirportFTAClass::SHORT_STRIP
@ SHORT_STRIP
This airport has a short landing strip, dangerous for fast aircraft.
Definition: airport.h:150
Order::wait_time
uint16 wait_time
How long in ticks to wait at the destination.
Definition: order_base.h:54
OSL_PLATFORM_MIDDLE
@ OSL_PLATFORM_MIDDLE
Stop at the middle of the platform.
Definition: order_type.h:85
Order::Free
void Free()
'Free' the order
Definition: order_cmd.cpp:63
CmdMoveOrder
CommandCost CmdMoveOrder(DoCommandFlag flags, VehicleID veh, VehicleOrderID moving_order, VehicleOrderID target_order)
Move an order inside the orderlist.
Definition: order_cmd.cpp:1145
DeleteVehicleNews
void DeleteVehicleNews(VehicleID vid, StringID news)
Delete a news item type about a vehicle.
Definition: news_gui.cpp:919
MOF_STOP_LOCATION
@ MOF_STOP_LOCATION
Passes an OrderStopLocation.
Definition: order_type.h:145
INVALID_TILE
static constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:108
Order::SetTravelTimetabled
void SetTravelTimetabled(bool timetabled)
Set if the travel time is explicitly timetabled (unless the order is conditional).
Definition: order_base.h:207
Order::GetUnloadType
OrderUnloadFlags GetUnloadType() const
How must the consist be unloaded?
Definition: order_base.h:139
TileIndex
The index/ID of a Tile.
Definition: tile_type.h:85
Waypoint
Representation of a waypoint.
Definition: waypoint_base.h:16
aircraft.h
OrderDepotTypeFlags
OrderDepotTypeFlags
Reasons that could cause us to go to the depot.
Definition: order_type.h:93
OCC_MORE_THAN
@ OCC_MORE_THAN
Skip if the value is more than the limit.
Definition: order_type.h:132
SpecializedStation< Station, false >::Get
static Station * Get(size_t index)
Gets station with given index.
Definition: base_station_base.h:218
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:53
Order::AssignOrder
void AssignOrder(const Order &other)
Assign data to an order (from another order) This function makes sure that the index is maintained co...
Definition: order_cmd.cpp:273
OrderList::IsCompleteTimetable
bool IsCompleteTimetable() const
Checks whether all orders of the list have a filled timetable.
Definition: order_cmd.cpp:603
WC_VEHICLE_TIMETABLE
@ WC_VEHICLE_TIMETABLE
Vehicle timetable; Window numbers:
Definition: window_type.h:217
VEH_ROAD
@ VEH_ROAD
Road vehicle type.
Definition: vehicle_type.h:25
Vehicle
Vehicle data structure.
Definition: vehicle_base.h:224
Vehicle::IsPrimaryVehicle
virtual bool IsPrimaryVehicle() const
Whether this is the primary vehicle in the chain.
Definition: vehicle_base.h:460
Vehicle::IsGroundVehicle
bool IsGroundVehicle() const
Check if the vehicle is a ground vehicle.
Definition: vehicle_base.h:498
OrderList::IsShared
bool IsShared() const
Is this a shared order list?
Definition: order_base.h:341
Vehicle::owner
Owner owner
Which company owns the vehicle?
Definition: vehicle_base.h:288
DC_EXEC
@ DC_EXEC
execute the given command
Definition: command_type.h:357
BaseStation::owner
Owner owner
The owner of this station.
Definition: base_station_base.h:62
MOF_NON_STOP
@ MOF_NON_STOP
Passes an OrderNonStopFlags.
Definition: order_type.h:144
DecloneOrder
static CommandCost DecloneOrder(Vehicle *dst, DoCommandFlag flags)
Declone an order-list.
Definition: order_cmd.cpp:993
OrderList::RemoveVehicle
void RemoveVehicle(Vehicle *v)
Removes the vehicle from the shared order list.
Definition: order_cmd.cpp:568
DeleteVehicleOrders
void DeleteVehicleOrders(Vehicle *v, bool keep_orderlist, bool reset_order_indices)
Delete all orders from a vehicle.
Definition: order_cmd.cpp:1850
SetDParam
static void SetDParam(uint n, uint64 v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings_func.h:196
OrderStopLocation
OrderStopLocation
Where to stop the trains.
Definition: order_type.h:83
DoCommandFlag
DoCommandFlag
List of flags for a command.
Definition: command_type.h:355
CmdCloneOrder
CommandCost CmdCloneOrder(DoCommandFlag flags, CloneOptions action, VehicleID veh_dst, VehicleID veh_src)
Clone/share/copy an order-list of another vehicle.
Definition: order_cmd.cpp:1501
Vehicle::UpdateRealOrderIndex
void UpdateRealOrderIndex()
Skip implicit orders until cur_real_order_index is a non-implicit order.
Definition: vehicle_base.h:869
OrderList::GetNextDecisionNode
const Order * GetNextDecisionNode(const Order *next, uint hops) const
Get the next order which will make the given vehicle stop at a station or refit at a depot or evaluat...
Definition: order_cmd.cpp:380
train_cmd.h
Order::Pack
uint32 Pack() const
Pack this order into a 32 bits integer, or actually only the type, flags and destination.
Definition: order_cmd.cpp:198
Airport::GetFTA
const AirportFTAClass * GetFTA() const
Get the finite-state machine for this airport or the finite-state machine for the dummy airport in ca...
Definition: station_base.h:329
OrderList::timetable_duration
Ticks timetable_duration
NOSAVE: Total timetabled duration of the order list.
Definition: order_base.h:273
Order::MakeGoToDepot
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)
Makes this order a Go To Depot order.
Definition: order_cmd.cpp:90
Order::GetType
OrderType GetType() const
Get the type of order of this order.
Definition: order_base.h:77
Aircraft
Aircraft, helicopters, rotors and their shadows belong to this class.
Definition: aircraft.h:74
Order::GetMaxSpeed
uint16 GetMaxSpeed() const
Get the maxmimum speed in km-ish/h a vehicle is allowed to reach on the way to the destination.
Definition: order_base.h:202
Order::GetStopLocation
OrderStopLocation GetStopLocation() const
Where must we stop at the platform?
Definition: order_base.h:143
GetOrderDistance
uint GetOrderDistance(const Order *prev, const Order *cur, const Vehicle *v, int conditional_depth)
Get the distance between two orders of a vehicle.
Definition: order_cmd.cpp:710
ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS
@ ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS
The vehicle will not stop at any stations it passes except the destination.
Definition: order_type.h:74
Order::GetNonStopType
OrderNonStopFlags GetNonStopType() const
At which stations must we stop?
Definition: order_base.h:141
Vehicle::Orders
IterateWrapper Orders() const
Returns an iterable ensemble of orders of a vehicle.
Definition: vehicle_base.h:1052
Airport::HasHangar
bool HasHangar() const
Check if this airport has at least one hangar.
Definition: station_base.h:335
UpdateOrderDest
bool UpdateOrderDest(Vehicle *v, const Order *order, int conditional_depth, bool pbs_look_ahead)
Update the vehicle's destination tile from an order.
Definition: order_cmd.cpp:1962
DistanceManhattan
uint DistanceManhattan(TileIndex t0, TileIndex t1)
Gets the Manhattan distance between the two given tiles.
Definition: map.cpp:157
depot_base.h
OrderConditionCompare
static bool OrderConditionCompare(OrderConditionComparator occ, int variable, int value)
Compare the variable and value based on the given comparator.
Definition: order_cmd.cpp:1911
CheckOwnership
CommandCost CheckOwnership(Owner owner, TileIndex tile)
Check whether the current owner owns something.
Definition: company_cmd.cpp:316
OLF_FULL_LOAD_ANY
@ OLF_FULL_LOAD_ANY
Full load a single cargo of the consist.
Definition: order_type.h:65
Vehicle::dest_tile
TileIndex dest_tile
Heading for this tile.
Definition: vehicle_base.h:252
return_cmd_error
#define return_cmd_error(errcode)
Returns from a function with a specific StringID as error.
Definition: command_func.h:38
Order::GetRefitCargo
CargoID GetRefitCargo() const
Get the cargo to to refit to.
Definition: order_base.h:132
timetable.h
CalcPercentVehicleFilled
uint8 CalcPercentVehicleFilled(const Vehicle *front, StringID *colour)
Calculates how full a vehicle is.
Definition: vehicle.cpp:1428
CommandCost
Common return value for all commands.
Definition: command_type.h:24
ONSF_STOP_EVERYWHERE
@ ONSF_STOP_EVERYWHERE
The vehicle will stop at any station it passes and the destination.
Definition: order_type.h:73
WC_VEHICLE_VIEW
@ WC_VEHICLE_VIEW
Vehicle view; Window numbers:
Definition: window_type.h:332
Vehicle::AddToShared
void AddToShared(Vehicle *shared_chain)
Adds this vehicle to a shared vehicle chain.
Definition: vehicle.cpp:2770
INVALID_VEH_ORDER_ID
static const VehicleOrderID INVALID_VEH_ORDER_ID
Invalid vehicle order index (sentinel)
Definition: order_type.h:21
Vehicle::RemoveFromShared
void RemoveFromShared()
Removes the vehicle from the shared order list.
Definition: vehicle.cpp:2793
Vehicle::tile
TileIndex tile
Current tile index.
Definition: vehicle_base.h:245
MOF_COND_COMPARATOR
@ MOF_COND_COMPARATOR
A comparator changes.
Definition: order_type.h:150
CancelLoadingDueToDeletedOrder
static void CancelLoadingDueToDeletedOrder(Vehicle *v)
Cancel the current loading order of the vehicle as the order was deleted.
Definition: order_cmd.cpp:1032
Order::MakeGoToWaypoint
void MakeGoToWaypoint(StationID destination)
Makes this order a Go To Waypoint order.
Definition: order_cmd.cpp:104
Vehicle::engine_type
EngineID engine_type
The type of engine used for this vehicle.
Definition: vehicle_base.h:302
VS_CRASHED
@ VS_CRASHED
Vehicle is crashed.
Definition: vehicle_base.h:41
OUF_UNLOAD_IF_POSSIBLE
@ OUF_UNLOAD_IF_POSSIBLE
Unload all cargo that the station accepts.
Definition: order_type.h:53
_cheats
Cheats _cheats
All the cheats.
Definition: cheat.cpp:16
Vehicle::last_station_visited
StationID last_station_visited
The last station we stopped at.
Definition: vehicle_base.h:316
CheckForValidOrders
static bool CheckForValidOrders(const Vehicle *v)
Check if a vehicle has any valid orders.
Definition: order_cmd.cpp:1891
Order::GetTravelTime
uint16 GetTravelTime() const
Get the time in ticks a vehicle will probably take to reach the destination (timetabled or not).
Definition: order_base.h:195
Order::SetDestination
void SetDestination(DestinationID destination)
Sets the destination of this order.
Definition: order_base.h:111
CommandCost::Failed
bool Failed() const
Did this command fail?
Definition: command_type.h:160
Vehicle::current_order
Order current_order
The current order (+ status, like: loading)
Definition: vehicle_base.h:333
Vehicle::max_age
Date max_age
Maximum age.
Definition: vehicle_base.h:274
Station::airport
Airport airport
Tile area the airport covers.
Definition: station_base.h:468
DeleteOrderWarnings
static void DeleteOrderWarnings(const Vehicle *v)
Delete all news items regarding defective orders about a vehicle This could kill still valid warnings...
Definition: order_cmd.cpp:668
AirportFTAClass::flags
Flags flags
Flags for this airport type.
Definition: airport.h:180
Vehicle::GetLastOrder
Order * GetLastOrder() const
Returns the last order of a vehicle, or nullptr if it doesn't exists.
Definition: vehicle_base.h:899
ODATFB_NEAREST_DEPOT
@ ODATFB_NEAREST_DEPOT
Send the vehicle to the nearest depot.
Definition: order_type.h:105
OrderList::DeleteOrderAt
void DeleteOrderAt(int index)
Remove an order from the order list and delete it.
Definition: order_cmd.cpp:510
OCC_IS_TRUE
@ OCC_IS_TRUE
Skip if the variable is true.
Definition: order_type.h:134
VS_STOPPED
@ VS_STOPPED
Vehicle is stopped by the player.
Definition: vehicle_base.h:35
_local_company
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:46
Vehicle::GetEngine
const Engine * GetEngine() const
Retrieves the engine of the vehicle.
Definition: vehicle.cpp:741
safeguards.h
IsRailDepotTile
static bool IsRailDepotTile(TileIndex t)
Is this tile rail tile and a rail depot?
Definition: rail_map.h:105
OCC_LESS_EQUALS
@ OCC_LESS_EQUALS
Skip if the value is less or equal to the limit.
Definition: order_type.h:131
DA_ALWAYS_GO
@ DA_ALWAYS_GO
Always go to the depot.
Definition: order_type.h:161
WC_SHIPS_LIST
@ WC_SHIPS_LIST
Ships list; Window numbers:
Definition: window_type.h:313
OrderList::Initialize
void Initialize(Order *chain, Vehicle *v)
Recomputes everything.
Definition: order_cmd.cpp:291
OrderList::num_manual_orders
VehicleOrderID num_manual_orders
NOSAVE: How many manually added orders are there in the list.
Definition: order_base.h:269
ODTFB_PART_OF_ORDERS
@ ODTFB_PART_OF_ORDERS
This depot order is because of a regular order.
Definition: order_type.h:96
Ticks
int32 Ticks
The type to store ticks in.
Definition: date_type.h:16
Order::GetConditionComparator
OrderConditionComparator GetConditionComparator() const
What is the comparator to use?
Definition: order_base.h:151
OrderList::FreeChain
void FreeChain(bool keep_orderlist=false)
Free a complete order chain.
Definition: order_cmd.cpp:334
OrderList::GetPositionInSharedOrderList
int GetPositionInSharedOrderList(const Vehicle *v) const
Gets the position of the given vehicle within the shared order vehicle list.
Definition: order_cmd.cpp:592
CmdModifyOrder
CommandCost CmdModifyOrder(DoCommandFlag flags, VehicleID veh, VehicleOrderID sel_ord, ModifyOrderFlags mof, uint16 data)
Modify an order in the orderlist of a vehicle.
Definition: order_cmd.cpp:1240
Order::SetConditionValue
void SetConditionValue(uint16 value)
Set the value to base the skip on.
Definition: order_base.h:176
OCC_MORE_EQUALS
@ OCC_MORE_EQUALS
Skip if the value is more or equal to the limit.
Definition: order_type.h:133
Vehicle::FindClosestDepot
virtual bool FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse)
Find the closest depot for this vehicle and tell us the location, DestinationID and whether we should...
Definition: vehicle_base.h:779
CmdDeleteOrder
CommandCost CmdDeleteOrder(DoCommandFlag flags, VehicleID veh_id, VehicleOrderID sel_ord)
Delete an order from the orderlist of a vehicle.
Definition: order_cmd.cpp:1010
MOF_COND_DESTINATION
@ MOF_COND_DESTINATION
Change the destination of a conditional order.
Definition: order_type.h:152
FACIL_DOCK
@ FACIL_DOCK
Station with a dock.
Definition: station_type.h:57
Vehicle::HasDepotOrder
bool HasDepotOrder() const
Checks if a vehicle has a depot in its order list.
Definition: order_cmd.cpp:1832
Order::MakeGoToStation
void MakeGoToStation(StationID destination)
Makes this order a Go To Station order.
Definition: order_cmd.cpp:75
DAYS_IN_LEAP_YEAR
static const int DAYS_IN_LEAP_YEAR
sometimes, you need one day more...
Definition: date_type.h:30
OrderList::GetNextStoppingStation
StationIDStack GetNextStoppingStation(const Vehicle *v, const Order *first=nullptr, uint hops=0) const
Recursively determine the next deterministic station to stop at.
Definition: order_cmd.cpp:415
Order::GetConditionSkipToOrder
VehicleOrderID GetConditionSkipToOrder() const
Get the order to skip to.
Definition: order_base.h:153
stdafx.h
Order::max_speed
uint16 max_speed
How fast the vehicle may go on the way to the destination.
Definition: order_base.h:56
Vehicle::IsOrderListShared
bool IsOrderListShared() const
Check if we share our orders with another vehicle.
Definition: vehicle_base.h:710
Cheat::value
bool value
tells if the bool cheat is active or not
Definition: cheat_type.h:18
OLF_LOAD_IF_POSSIBLE
@ OLF_LOAD_IF_POSSIBLE
Load as long as there is cargo that fits in the train.
Definition: order_type.h:63
Order::SetStopLocation
void SetStopLocation(OrderStopLocation stop_location)
Set where we must stop at the platform.
Definition: order_base.h:164
OSL_PLATFORM_NEAR_END
@ OSL_PLATFORM_NEAR_END
Stop at the near end of the platform.
Definition: order_type.h:84
OrderList::GetOrderAt
Order * GetOrderAt(int index) const
Get a certain order of the order chain.
Definition: order_cmd.cpp:357
IsTileType
static bool IsTileType(TileIndex tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
ODATFB_HALT
@ ODATFB_HALT
Service the vehicle and then halt it.
Definition: order_type.h:104
Vehicle::IncrementRealOrderIndex
void IncrementRealOrderIndex()
Advanced cur_real_order_index to the next real order, keeps care of the wrap-around and invalidates t...
Definition: vehicle_base.h:854
GetTileOwner
static Owner GetTileOwner(TileIndex tile)
Returns the owner of a tile.
Definition: tile_map.h:178
Order::IsTravelTimetabled
bool IsTravelTimetabled() const
Does this order have an explicit travel time set?
Definition: order_base.h:186
DistanceSquare
uint DistanceSquare(TileIndex t0, TileIndex t1)
Gets the 'Square' distance between the two given tiles.
Definition: map.cpp:174
BaseConsist::cur_real_order_index
VehicleOrderID cur_real_order_index
The index to the current real (non-implicit) order.
Definition: base_consist.h:28
ONSF_NO_STOP_AT_DESTINATION_STATION
@ ONSF_NO_STOP_AT_DESTINATION_STATION
The vehicle will stop at any station it passes except the destination.
Definition: order_type.h:75
Aircraft::GetOrderStationLocation
TileIndex GetOrderStationLocation(StationID station)
Determine the location for the station where the vehicle goes to next.
Definition: aircraft_cmd.cpp:1286
GetWindowClassForVehicleType
static WindowClass GetWindowClassForVehicleType(VehicleType vt)
Get WindowClass for vehicle list of given vehicle type.
Definition: vehicle_gui.h:96
ProcessOrders
bool ProcessOrders(Vehicle *v)
Handle the orders of a vehicle and determine the next place to go to if needed.
Definition: order_cmd.cpp:2090
Vehicle::FirstShared
Vehicle * FirstShared() const
Get the first vehicle of this vehicle chain.
Definition: vehicle_base.h:704
StringID
uint32 StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
Order::SetRefit
void SetRefit(CargoID cargo)
Make this depot/station order also a refit order.
Definition: order_cmd.cpp:165
OrderUnloadFlags
OrderUnloadFlags
Flags related to the unloading order.
Definition: order_type.h:52
OrderNonStopFlags
OrderNonStopFlags
Non-stop order flags.
Definition: order_type.h:72
vehicle_func.h
station_base.h
AircraftCache::cached_max_range_sqr
uint32 cached_max_range_sqr
Cached squared maximum range.
Definition: aircraft.h:67
Clamp
static T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition: math_func.hpp:77
Pool::PoolItem<&_vehicle_pool >::Iterate
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:386
strings_func.h
Pool
Base class for all pools.
Definition: pool_type.hpp:81
Order::SetConditionVariable
void SetConditionVariable(OrderConditionVariable condition_variable)
Set variable we have to compare.
Definition: order_base.h:170
OCC_EQUALS
@ OCC_EQUALS
Skip if both values are equal.
Definition: order_type.h:128
OCV_MAX_SPEED
@ OCV_MAX_SPEED
Skip based on the maximum speed.
Definition: order_type.h:115
OSL_PLATFORM_FAR_END
@ OSL_PLATFORM_FAR_END
Stop at the far end of the platform.
Definition: order_type.h:86
MOF_UNLOAD
@ MOF_UNLOAD
Passes an OrderUnloadType.
Definition: order_type.h:146
Order::refit_cargo
CargoID refit_cargo
Refit CargoID.
Definition: order_base.h:52
Vehicle::IncrementImplicitOrderIndex
void IncrementImplicitOrderIndex()
Increments cur_implicit_order_index, keeps care of the wrap-around and invalidates the GUI.
Definition: vehicle_base.h:830
OCV_RELIABILITY
@ OCV_RELIABILITY
Skip based on the reliability.
Definition: order_type.h:114
FACIL_TRAIN
@ FACIL_TRAIN
Station with train station.
Definition: station_type.h:53
Vehicle::GetFirstOrder
Order * GetFirstOrder() const
Get the first order of the vehicles order list.
Definition: vehicle_base.h:683
SpecializedVehicle< RoadVehicle, Type >::From
static RoadVehicle * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
Definition: vehicle_base.h:1183
OrderList::RecalculateTimetableDuration
void RecalculateTimetableDuration()
Recomputes Timetable duration.
Definition: order_cmd.cpp:321
OCV_REMAINING_LIFETIME
@ OCV_REMAINING_LIFETIME
Skip based on the remaining lifetime.
Definition: order_type.h:119
OUFB_NO_UNLOAD
@ OUFB_NO_UNLOAD
Totally no unloading will be done.
Definition: order_type.h:56
OrthogonalTileArea::tile
TileIndex tile
The base tile of the area.
Definition: tilearea_type.h:19
RemoveOrderFromAllVehicles
void RemoveOrderFromAllVehicles(OrderType type, DestinationID destination, bool hangar)
Removes an order from all vehicles.
Definition: order_cmd.cpp:1765
InvalidateWindowClassesData
void InvalidateWindowClassesData(WindowClass cls, int data, bool gui_scope)
Mark window data of all windows of a given class as invalid (in need of re-computing) Note that by de...
Definition: window.cpp:3269
Order::MapOldOrder
uint16 MapOldOrder() const
Pack this order into a 16 bits integer as close to the TTD representation as possible.
Definition: order_cmd.cpp:208
OrderList
Shared order list linking together the linked list of orders and the list of vehicles sharing this or...
Definition: order_base.h:260
cheat_type.h
BaseConsist::current_order_time
uint32 current_order_time
How many ticks have passed since this order started.
Definition: base_consist.h:22
Order::SetConditionSkipToOrder
void SetConditionSkipToOrder(VehicleOrderID order_id)
Get the order to skip to.
Definition: order_base.h:174
Vehicle::NextShared
Vehicle * NextShared() const
Get the next vehicle of the shared vehicle chain.
Definition: vehicle_base.h:692
OWNER_NONE
@ OWNER_NONE
The tile has no ownership.
Definition: company_type.h:25
MOF_COND_VALUE
@ MOF_COND_VALUE
The value to set the condition to.
Definition: order_type.h:151
CT_AUTO_REFIT
@ CT_AUTO_REFIT
Automatically choose cargo type when doing auto refitting.
Definition: cargo_type.h:67
OrderList::GetLastOrder
Order * GetLastOrder() const
Get the last order of the order chain.
Definition: order_base.h:308
MP_STATION
@ MP_STATION
A tile of a station.
Definition: tile_type.h:53
Vehicle::age
Date age
Age in days.
Definition: vehicle_base.h:273
NUM_CARGO
@ NUM_CARGO
Maximal number of cargo types in a game.
Definition: cargo_type.h:65
GetStationIndex
static StationID GetStationIndex(TileIndex t)
Get StationID from a tile.
Definition: station_map.h:28
waypoint_base.h
Pool::PoolItem<&_order_pool >::CanAllocateItem
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
Definition: pool_type.hpp:307
Order::SetWaitTime
void SetWaitTime(uint16 time)
Set the time in ticks to wait at the destination.
Definition: order_base.h:213
Order::SetDepotOrderType
void SetDepotOrderType(OrderDepotTypeFlags depot_order_type)
Set the cause to go to the depot.
Definition: order_base.h:166
BaseStation::xy
TileIndex xy
Base tile of the station.
Definition: base_station_base.h:53
OrderList::first
Order * first
First order of the order list.
Definition: order_base.h:267
OrderBackup::RemoveOrder
static void RemoveOrder(OrderType type, DestinationID destination, bool hangar)
Removes an order from all vehicles.
Definition: order_backup.cpp:249
BaseStation
Base class for all station-ish types.
Definition: base_station_base.h:52
MAX_VEH_ORDER_ID
static const VehicleOrderID MAX_VEH_ORDER_ID
Last valid VehicleOrderID.
Definition: order_type.h:23
GUISettings::order_review_system
uint8 order_review_system
perform order reviews on vehicles
Definition: settings_type.h:110
Order::SetDepotActionType
void SetDepotActionType(OrderDepotActionFlags depot_service_type)
Set what we are going to do in the depot.
Definition: order_base.h:168
company_func.h
OCV_LOAD_PERCENTAGE
@ OCV_LOAD_PERCENTAGE
Skip based on the amount of load.
Definition: order_type.h:113
INSTANTIATE_POOL_METHODS
#define INSTANTIATE_POOL_METHODS(name)
Force instantiation of pool methods so we don't get linker errors.
Definition: pool_func.hpp:224
Order::MakeConditional
void MakeConditional(VehicleOrderID order)
Makes this order an conditional order.
Definition: order_cmd.cpp:143
Order::ShouldStopAtStation
bool ShouldStopAtStation(const Vehicle *v, StationID station) const
Check whether the given vehicle should stop at the given station based on this order and the non-stop...
Definition: order_cmd.cpp:2189
VehicleID
uint32 VehicleID
The type all our vehicle IDs have.
Definition: vehicle_type.h:16
OrderType
OrderType
Order types.
Definition: order_type.h:35
Vehicle::NeedsServicing
bool NeedsServicing() const
Check if the vehicle needs to go to a depot in near future (if a opportunity presents itself) for ser...
Definition: vehicle.cpp:184
Order::GetDepotOrderType
OrderDepotTypeFlags GetDepotOrderType() const
What caused us going to the depot?
Definition: order_base.h:145
OrderList::GetNext
const Order * GetNext(const Order *curr) const
Get the order after the given one or the first one, if the given one is the last one.
Definition: order_base.h:316
AddVehicleAdviceNewsItem
static void AddVehicleAdviceNewsItem(StringID string, VehicleID vehicle)
Adds a vehicle-advice news item.
Definition: news_func.h:40
OrderList::GetFirstOrder
Order * GetFirstOrder() const
Get the first order of the order chain.
Definition: order_base.h:300
CommandHelper
Definition: command_func.h:94
Vehicle::day_counter
byte day_counter
Increased by one for each day.
Definition: vehicle_base.h:328
Order::GetConditionVariable
OrderConditionVariable GetConditionVariable() const
What variable do we have to compare?
Definition: order_base.h:149
Debug
#define Debug(name, level, format_string,...)
Ouptut a line of debugging information.
Definition: debug.h:37
Depot
Definition: depot_base.h:19
SetBit
static T SetBit(T &x, const uint8 y)
Set a bit in a variable.
Definition: bitmath_func.hpp:121
OrderList::num_vehicles
uint num_vehicles
NOSAVE: Number of vehicles that share this order list.
Definition: order_base.h:270
random_func.hpp
SmallStack::IsEmpty
bool IsEmpty() const
Check if the stack is empty.
Definition: smallstack_type.hpp:244
SpecializedStation< Station, false >::GetIfValid
static Station * GetIfValid(size_t index)
Returns station if the index is a valid index for this station type.
Definition: base_station_base.h:227
CmdOrderRefit
CommandCost CmdOrderRefit(DoCommandFlag flags, VehicleID veh, VehicleOrderID order_number, CargoID cargo)
Add/remove refit orders from an order.
Definition: order_cmd.cpp:1642
Order::SetConditionComparator
void SetConditionComparator(OrderConditionComparator condition_comparator)
Set the comparator to use.
Definition: order_base.h:172
CargoID
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:20
OrderConditionVariable
OrderConditionVariable
Variables (of a vehicle) to 'cause' skipping on.
Definition: order_type.h:112
ToPercent16
static uint ToPercent16(uint i)
Converts a "fract" value 0..65535 to "percent" value 0..100.
Definition: math_func.hpp:238
RoadVehicle::IsBus
bool IsBus() const
Check whether a roadvehicle is a bus.
Definition: roadveh_cmd.cpp:81
Order::GetLocation
TileIndex GetLocation(const Vehicle *v, bool airport=false) const
Returns a tile somewhat representing the order destination (not suitable for pathfinding).
Definition: order_cmd.cpp:683
AircraftCache::cached_max_range
uint16 cached_max_range
Cached maximum range.
Definition: aircraft.h:68
Aircraft::state
byte state
State of the airport.
Definition: aircraft.h:79
Order::SetUnloadType
void SetUnloadType(OrderUnloadFlags unload_type)
Set how the consist must be unloaded.
Definition: order_base.h:160
OCV_REQUIRES_SERVICE
@ OCV_REQUIRES_SERVICE
Skip when the vehicle requires service.
Definition: order_type.h:117
VEH_TRAIN
@ VEH_TRAIN
Train vehicle type.
Definition: vehicle_type.h:24
OrderList::IsVehicleInSharedOrdersList
bool IsVehicleInSharedOrdersList(const Vehicle *v) const
Checks whether a vehicle is part of the shared vehicle chain.
Definition: order_cmd.cpp:578
Vehicle::GetOrder
Order * GetOrder(int index) const
Returns order 'index' of a vehicle or nullptr when it doesn't exists.
Definition: vehicle_base.h:890
BaseVehicle::type
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:52
Vehicle::reliability
uint16 reliability
Reliability.
Definition: vehicle_base.h:276
CmdSkipToOrder
CommandCost CmdSkipToOrder(DoCommandFlag flags, VehicleID veh_id, VehicleOrderID sel_ord)
Goto order of order-list.
Definition: order_cmd.cpp:1110
VIWD_MODIFY_ORDERS
@ VIWD_MODIFY_ORDERS
Other order modifications.
Definition: vehicle_gui.h:35
CheckAircraftOrderDistance
static bool CheckAircraftOrderDistance(const Aircraft *v_new, const Vehicle *v_order, const Order *first)
Check if an aircraft has enough range for an order list.
Definition: order_cmd.cpp:1471
CanVehicleUseStation
bool CanVehicleUseStation(EngineID engine_type, const Station *st)
Can this station be used by the given engine type?
Definition: vehicle.cpp:2861
pool_func.hpp
order_backup.h
OrderGoesToStation
static bool OrderGoesToStation(const Vehicle *v, const Order *o)
Checks whether the order goes to a station or not, i.e.
Definition: order_cmd.cpp:656
Order::travel_time
uint16 travel_time
How long in ticks the journey to this destination should take.
Definition: order_base.h:55
Order::CanLeaveWithCargo
bool CanLeaveWithCargo(bool has_cargo) const
A vehicle can leave the current station with cargo if:
Definition: order_cmd.cpp:2213
VEH_SHIP
@ VEH_SHIP
Ship vehicle type.
Definition: vehicle_type.h:26
OCV_MAX_RELIABILITY
@ OCV_MAX_RELIABILITY
Skip based on the maximum reliability.
Definition: order_type.h:120
IsShipDepotTile
static bool IsShipDepotTile(TileIndex t)
Is it a ship depot tile?
Definition: water_map.h:237
MOF_LOAD
@ MOF_LOAD
Passes an OrderLoadType.
Definition: order_type.h:147
OCC_IS_FALSE
@ OCC_IS_FALSE
Skip if the variable is false.
Definition: order_type.h:135
Vehicle::GetNumOrders
VehicleOrderID GetNumOrders() const
Get the number of orders this vehicle has.
Definition: vehicle_base.h:716
InvalidateVehicleOrder
void InvalidateVehicleOrder(const Vehicle *v, int data)
Updates the widgets of a vehicle which contains the order-data.
Definition: order_cmd.cpp:251
OrderDepotActionFlags
OrderDepotActionFlags
Actions that can be performed when the vehicle enters the depot.
Definition: order_type.h:102
VIWD_REMOVE_ALL_ORDERS
@ VIWD_REMOVE_ALL_ORDERS
Removed / replaced all orders (after deleting / sharing).
Definition: vehicle_gui.h:34
Vehicle::orders
OrderList * orders
Pointer to the order list for this vehicle.
Definition: vehicle_base.h:336
CT_NO_REFIT
@ CT_NO_REFIT
Do not refit cargo of a vehicle (used in vehicle orders and auto-replace/auto-new).
Definition: cargo_type.h:68
SetWindowClassesDirty
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
Definition: window.cpp:3180
Order::GetDepotActionType
OrderDepotActionFlags GetDepotActionType() const
What are we going to do when in the depot.
Definition: order_base.h:147
WC_AIRCRAFT_LIST
@ WC_AIRCRAFT_LIST
Aircraft list; Window numbers:
Definition: window_type.h:319
Vehicle::DeleteUnreachedImplicitOrders
void DeleteUnreachedImplicitOrders()
Delete all implicit orders which were not reached.
Definition: vehicle.cpp:2074
WC_STATION_LIST
@ WC_STATION_LIST
Station list; Window numbers:
Definition: window_type.h:295
Order::next
Order * next
Pointer to next order. If nullptr, end of list.
Definition: order_base.h:59
MOF_DEPOT_ACTION
@ MOF_DEPOT_ACTION
Selects the OrderDepotAction.
Definition: order_type.h:148
Order::flags
uint8 flags
Load/unload types, depot order/action types.
Definition: order_base.h:49
Order
Definition: order_base.h:36
CmdInsertOrder
CommandCost CmdInsertOrder(DoCommandFlag flags, VehicleID veh, VehicleOrderID sel_ord, const Order &new_order)
Add an order to the orderlist of a vehicle.
Definition: order_cmd.cpp:738
DA_SERVICE
@ DA_SERVICE
Service only if needed.
Definition: order_type.h:162
Order::type
uint8 type
The type of order + non-stop flags.
Definition: order_base.h:48
OrderList::GetNumOrders
VehicleOrderID GetNumOrders() const
Get number of orders in the order list.
Definition: order_base.h:322
Station::ship_station
TileArea ship_station
Tile area the ship 'station' part covers.
Definition: station_base.h:469
Order::Equals
bool Equals(const Order &other) const
Does this order have the same type, flags and destination?
Definition: order_cmd.cpp:175
OCV_AGE
@ OCV_AGE
Skip based on the age.
Definition: order_type.h:116
OrderList::InsertOrderAt
void InsertOrderAt(Order *new_order, int index)
Insert a new order into the order chain.
Definition: order_cmd.cpp:472
Order::IsWaitTimetabled
bool IsWaitTimetabled() const
Does this order have an explicit wait time set?
Definition: order_base.h:184
Order::SetNonStopType
void SetNonStopType(OrderNonStopFlags non_stop_type)
Set whether we must stop at stations or not.
Definition: order_base.h:162
Order::dest
DestinationID dest
The destination of the order.
Definition: order_base.h:50
Order::MakeImplicit
void MakeImplicit(StationID destination)
Makes this order an implicit order.
Definition: order_cmd.cpp:154
FLYING
@ FLYING
Vehicle is flying in the air.
Definition: airport.h:75
OrderConditionComparator
OrderConditionComparator
Comparator for the skip reasoning.
Definition: order_type.h:127
Vehicle::GetOrderStationLocation
virtual TileIndex GetOrderStationLocation(StationID station)
Determine the location for the station where the vehicle goes to next.
Definition: vehicle_base.h:769
INVALID_STRING_ID
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
Definition: strings_type.h:17
WC_VEHICLE_ORDERS
@ WC_VEHICLE_ORDERS
Vehicle orders; Window numbers:
Definition: window_type.h:205
ClientSettings::gui
GUISettings gui
settings related to the GUI
Definition: settings_type.h:604
Engine::reliability
uint16 reliability
Current reliability of the engine.
Definition: engine_base.h:40
OCC_LESS_THAN
@ OCC_LESS_THAN
Skip if the value is less than the limit.
Definition: order_type.h:130
debug.h
OCV_UNCONDITIONALLY
@ OCV_UNCONDITIONALLY
Always skip.
Definition: order_type.h:118
OLFB_NO_LOAD
@ OLFB_NO_LOAD
Do not load anything.
Definition: order_type.h:66
OrderList::num_orders
VehicleOrderID num_orders
NOSAVE: How many orders there are in the list.
Definition: order_base.h:268
Order::GetLoadType
OrderLoadFlags GetLoadType() const
How must the consist be loaded?
Definition: order_base.h:137
news_func.h
roadveh.h
Order::SetWaitTimetabled
void SetWaitTimetabled(bool timetabled)
Set if the wait time is explicitly timetabled (unless the order is conditional).
Definition: order_base.h:205