diff --git a/src/autoreplace_cmd.cpp b/src/autoreplace_cmd.cpp index 5bdf8d0e59..eba804788e 100644 --- a/src/autoreplace_cmd.cpp +++ b/src/autoreplace_cmd.cpp @@ -211,7 +211,7 @@ static int GetIncompatibleRefitOrderIdForAutoreplace(const Vehicle *v, EngineID const Order *o; const Vehicle *u = (v->type == VEH_TRAIN) ? v->First() : v; - const OrderList *orders = u->orders.list; + const OrderList *orders = u->orders; if (orders == nullptr) return -1; for (VehicleOrderID i = 0; i < orders->GetNumOrders(); i++) { o = orders->GetOrderAt(i); diff --git a/src/economy.cpp b/src/economy.cpp index f2e70f34f2..e915653efd 100644 --- a/src/economy.cpp +++ b/src/economy.cpp @@ -1268,7 +1268,7 @@ void PrepareUnload(Vehicle *front_v) front_v->cargo_payment = new CargoPayment(front_v); StationIDStack next_station = front_v->GetNextStoppingStation(); - if (front_v->orders.list == nullptr || (front_v->current_order.GetUnloadType() & OUFB_NO_UNLOAD) == 0) { + if (front_v->orders == nullptr || (front_v->current_order.GetUnloadType() & OUFB_NO_UNLOAD) == 0) { Station *st = Station::Get(front_v->last_station_visited); for (Vehicle *v = front_v; v != nullptr; v = v->Next()) { const GoodsEntry *ge = &st->goods[v->cargo_type]; diff --git a/src/linkgraph/refresh.cpp b/src/linkgraph/refresh.cpp index 78fdd1643e..2665f92a9f 100644 --- a/src/linkgraph/refresh.cpp +++ b/src/linkgraph/refresh.cpp @@ -26,10 +26,10 @@ /* static */ void LinkRefresher::Run(Vehicle *v, bool allow_merge, bool is_full_loading) { /* If there are no orders we can't predict anything.*/ - if (v->orders.list == nullptr) return; + if (v->orders == nullptr) return; /* Make sure the first order is a useful order. */ - const Order *first = v->orders.list->GetNextDecisionNode(v->GetOrder(v->cur_implicit_order_index), 0); + const Order *first = v->orders->GetNextDecisionNode(v->GetOrder(v->cur_implicit_order_index), 0); if (first == nullptr) return; HopSet seen_hops; @@ -173,9 +173,9 @@ const Order *LinkRefresher::PredictNextOrder(const Order *cur, const Order *next SetBit(flags, USE_NEXT); if (next->IsType(OT_CONDITIONAL)) { - const Order *skip_to = this->vehicle->orders.list->GetNextDecisionNode( - this->vehicle->orders.list->GetOrderAt(next->GetConditionSkipToOrder()), num_hops); - if (skip_to != nullptr && num_hops < this->vehicle->orders.list->GetNumOrders()) { + const Order *skip_to = this->vehicle->orders->GetNextDecisionNode( + this->vehicle->orders->GetOrderAt(next->GetConditionSkipToOrder()), num_hops); + if (skip_to != nullptr && num_hops < this->vehicle->orders->GetNumOrders()) { /* Make copies of capacity tracking lists. There is potential * for optimization here: If the vehicle never refits we don't * need to copy anything. Also, if we've seen the branched link @@ -187,8 +187,8 @@ const Order *LinkRefresher::PredictNextOrder(const Order *cur, const Order *next /* Reassign next with the following stop. This can be a station or a * depot.*/ - next = this->vehicle->orders.list->GetNextDecisionNode( - this->vehicle->orders.list->GetNext(next), num_hops++); + next = this->vehicle->orders->GetNextDecisionNode( + this->vehicle->orders->GetNext(next), num_hops++); } return next; } @@ -230,16 +230,16 @@ void LinkRefresher::RefreshStats(const Order *cur, const Order *next) * loading. Don't do that if the vehicle has been waiting for longer than the entire * order list is supposed to take, though. If that is the case the total duration is * probably far off and we'd greatly overestimate the capacity by increasing.*/ - if (this->is_full_loading && this->vehicle->orders.list != nullptr && + if (this->is_full_loading && this->vehicle->orders != nullptr && st->index == vehicle->last_station_visited && - this->vehicle->orders.list->GetTotalDuration() > + this->vehicle->orders->GetTotalDuration() > (Ticks)this->vehicle->current_order_time) { uint effective_capacity = cargo_quantity * this->vehicle->load_unload_ticks; - if (effective_capacity > (uint)this->vehicle->orders.list->GetTotalDuration()) { + if (effective_capacity > (uint)this->vehicle->orders->GetTotalDuration()) { IncreaseStats(st, c, next_station, effective_capacity / - this->vehicle->orders.list->GetTotalDuration(), 0, 0, + this->vehicle->orders->GetTotalDuration(), 0, 0, EUM_INCREASE | restricted_mode); - } else if (RandomRange(this->vehicle->orders.list->GetTotalDuration()) < effective_capacity) { + } else if (RandomRange(this->vehicle->orders->GetTotalDuration()) < effective_capacity) { IncreaseStats(st, c, next_station, 1, 0, 0, EUM_INCREASE | restricted_mode); } else { IncreaseStats(st, c, next_station, cargo_quantity, 0, time_estimate, EUM_REFRESH | restricted_mode); diff --git a/src/order_backup.cpp b/src/order_backup.cpp index 4e21130c2a..be4d7180ca 100644 --- a/src/order_backup.cpp +++ b/src/order_backup.cpp @@ -77,7 +77,7 @@ void OrderBackup::DoRestore(Vehicle *v) if (this->clone != nullptr) { Command::Do(DC_EXEC, CO_SHARE, v->index, this->clone->index); } else if (this->orders != nullptr && OrderList::CanAllocateItem()) { - v->orders.list = new OrderList(this->orders, v); + v->orders = new OrderList(this->orders, v); this->orders = nullptr; /* Make sure buoys/oil rigs are updated in the station list. */ InvalidateWindowClassesData(WC_STATION_LIST, 0); diff --git a/src/order_cmd.cpp b/src/order_cmd.cpp index 9c6b1a3fcd..42cad82ad3 100644 --- a/src/order_cmd.cpp +++ b/src/order_cmd.cpp @@ -637,7 +637,7 @@ void OrderList::DebugCheckSanity() const for (const Vehicle *v = this->first_shared; v != nullptr; v = v->NextShared()) { ++check_num_vehicles; - assert(v->orders.list == this); + assert(v->orders == this); } assert(this->num_vehicles == check_num_vehicles); Debug(misc, 6, "... detected {} orders ({} manual), {} vehicles, {} timetabled, {} total", @@ -715,7 +715,7 @@ uint GetOrderDistance(const Order *prev, const Order *cur, const Vehicle *v, int conditional_depth++; int dist1 = GetOrderDistance(prev, v->GetOrder(cur->GetConditionSkipToOrder()), v, conditional_depth); - int dist2 = GetOrderDistance(prev, cur->next == nullptr ? v->orders.list->GetFirstOrder() : cur->next, v, conditional_depth); + int dist2 = GetOrderDistance(prev, cur->next == nullptr ? v->orders->GetFirstOrder() : cur->next, v, conditional_depth); return std::max(dist1, dist2); } @@ -906,7 +906,7 @@ CommandCost CmdInsertOrder(DoCommandFlag flags, VehicleID veh, VehicleOrderID se if (v->GetNumOrders() >= MAX_VEH_ORDER_ID) return_cmd_error(STR_ERROR_TOO_MANY_ORDERS); if (!Order::CanAllocateItem()) return_cmd_error(STR_ERROR_NO_MORE_SPACE_FOR_ORDERS); - if (v->orders.list == nullptr && !OrderList::CanAllocateItem()) return_cmd_error(STR_ERROR_NO_MORE_SPACE_FOR_ORDERS); + if (v->orders == nullptr && !OrderList::CanAllocateItem()) return_cmd_error(STR_ERROR_NO_MORE_SPACE_FOR_ORDERS); if (flags & DC_EXEC) { Order *new_o = new Order(); @@ -926,16 +926,16 @@ CommandCost CmdInsertOrder(DoCommandFlag flags, VehicleID veh, VehicleOrderID se void InsertOrder(Vehicle *v, Order *new_o, VehicleOrderID sel_ord) { /* Create new order and link in list */ - if (v->orders.list == nullptr) { - v->orders.list = new OrderList(new_o, v); + if (v->orders == nullptr) { + v->orders = new OrderList(new_o, v); } else { - v->orders.list->InsertOrderAt(new_o, sel_ord); + v->orders->InsertOrderAt(new_o, sel_ord); } Vehicle *u = v->FirstShared(); DeleteOrderWarnings(u); for (; u != nullptr; u = u->NextShared()) { - assert(v->orders.list == u->orders.list); + assert(v->orders == u->orders); /* If there is added an order before the current one, we need * to update the selected order. We do not change implicit/real order indices though. @@ -1047,12 +1047,12 @@ static void CancelLoadingDueToDeletedOrder(Vehicle *v) */ void DeleteOrder(Vehicle *v, VehicleOrderID sel_ord) { - v->orders.list->DeleteOrderAt(sel_ord); + v->orders->DeleteOrderAt(sel_ord); Vehicle *u = v->FirstShared(); DeleteOrderWarnings(u); for (; u != nullptr; u = u->NextShared()) { - assert(v->orders.list == u->orders.list); + assert(v->orders == u->orders); if (sel_ord == u->cur_real_order_index && u->current_order.IsType(OT_LOADING)) { CancelLoadingDueToDeletedOrder(u); @@ -1159,7 +1159,7 @@ CommandCost CmdMoveOrder(DoCommandFlag flags, VehicleID veh, VehicleOrderID movi if (moving_one == nullptr) return CMD_ERROR; if (flags & DC_EXEC) { - v->orders.list->MoveOrder(moving_order, target_order); + v->orders->MoveOrder(moving_order, target_order); /* Update shared list */ Vehicle *u = v->FirstShared(); @@ -1199,7 +1199,7 @@ CommandCost CmdMoveOrder(DoCommandFlag flags, VehicleID veh, VehicleOrderID movi u->cur_implicit_order_index++; } - assert(v->orders.list == u->orders.list); + assert(v->orders == u->orders); /* Update any possible open window of the vehicle */ InvalidateVehicleOrder(u, moving_order | (target_order << 8)); } @@ -1541,7 +1541,7 @@ CommandCost CmdCloneOrder(DoCommandFlag flags, CloneOptions action, VehicleID ve return_cmd_error(STR_ERROR_AIRCRAFT_NOT_ENOUGH_RANGE); } - if (src->orders.list == nullptr && !OrderList::CanAllocateItem()) { + if (src->orders == nullptr && !OrderList::CanAllocateItem()) { return_cmd_error(STR_ERROR_NO_MORE_SPACE_FOR_ORDERS); } @@ -1551,7 +1551,7 @@ CommandCost CmdCloneOrder(DoCommandFlag flags, CloneOptions action, VehicleID ve * (We mainly do this to keep the order indices valid and in range.) */ DeleteVehicleOrders(dst, false, dst->GetNumOrders() != src->GetNumOrders()); - dst->orders.list = src->orders.list; + dst->orders = src->orders; /* Link this vehicle in the shared-list */ dst->AddToShared(src); @@ -1607,14 +1607,14 @@ CommandCost CmdCloneOrder(DoCommandFlag flags, CloneOptions action, VehicleID ve (*order_dst)->AssignOrder(*order); order_dst = &(*order_dst)->next; } - if (dst->orders.list == nullptr) { - dst->orders.list = new OrderList(first, dst); + if (dst->orders == nullptr) { + dst->orders = new OrderList(first, dst); } else { - assert(dst->orders.list->GetFirstOrder() == nullptr); - assert(!dst->orders.list->IsShared()); - delete dst->orders.list; + assert(dst->orders->GetFirstOrder() == nullptr); + assert(!dst->orders->IsShared()); + delete dst->orders; assert(OrderList::CanAllocateItem()); - dst->orders.list = new OrderList(first, dst); + dst->orders = new OrderList(first, dst); } InvalidateVehicleOrder(dst, VIWD_REMOVE_ALL_ORDERS); @@ -1734,7 +1734,7 @@ void CheckOrders(const Vehicle *v) if (v->GetNumOrders() > 1) { const Order *last = v->GetLastOrder(); - if (v->orders.list->GetFirstOrder()->Equals(*last)) { + if (v->orders->GetFirstOrder()->Equals(*last)) { message = STR_NEWS_VEHICLE_HAS_DUPLICATE_ENTRY; } } @@ -1743,7 +1743,7 @@ void CheckOrders(const Vehicle *v) if (n_st < 2 && message == INVALID_STRING_ID) message = STR_NEWS_VEHICLE_HAS_TOO_FEW_ORDERS; #ifdef WITH_ASSERT - if (v->orders.list != nullptr) v->orders.list->DebugCheckSanity(); + if (v->orders != nullptr) v->orders->DebugCheckSanity(); #endif /* We don't have a problem */ @@ -1801,9 +1801,9 @@ restart: } /* Clear wait time */ - v->orders.list->UpdateTotalDuration(-order->GetWaitTime()); + v->orders->UpdateTotalDuration(-order->GetWaitTime()); if (order->IsWaitTimetabled()) { - v->orders.list->UpdateTimetableDuration(-order->GetTimetabledWait()); + v->orders->UpdateTimetableDuration(-order->GetTimetabledWait()); order->SetWaitTimetabled(false); } order->SetWaitTime(0); @@ -1854,11 +1854,11 @@ void DeleteVehicleOrders(Vehicle *v, bool keep_orderlist, bool reset_order_indic if (v->IsOrderListShared()) { /* Remove ourself from the shared order list. */ v->RemoveFromShared(); - v->orders.list = nullptr; - } else if (v->orders.list != nullptr) { + v->orders = nullptr; + } else if (v->orders != nullptr) { /* Remove the orders */ - v->orders.list->FreeChain(keep_orderlist); - if (!keep_orderlist) v->orders.list = nullptr; + v->orders->FreeChain(keep_orderlist); + if (!keep_orderlist) v->orders = nullptr; } if (reset_order_indices) { diff --git a/src/saveload/afterload.cpp b/src/saveload/afterload.cpp index bc8ffd2474..ce26c1f5b2 100644 --- a/src/saveload/afterload.cpp +++ b/src/saveload/afterload.cpp @@ -1720,9 +1720,9 @@ bool AfterLoadGame() for (Order *order : Order::Iterate()) order->ConvertFromOldSavegame(); for (Vehicle *v : Vehicle::Iterate()) { - if (v->orders.list != nullptr && v->orders.list->GetFirstOrder() != nullptr && v->orders.list->GetFirstOrder()->IsType(OT_NOTHING)) { - v->orders.list->FreeChain(); - v->orders.list = nullptr; + if (v->orders != nullptr && v->orders->GetFirstOrder() != nullptr && v->orders->GetFirstOrder()->IsType(OT_NOTHING)) { + v->orders->FreeChain(); + v->orders = nullptr; } v->current_order.ConvertFromOldSavegame(); diff --git a/src/saveload/oldloader_sl.cpp b/src/saveload/oldloader_sl.cpp index cfcc6bd37f..bab302dc8d 100644 --- a/src/saveload/oldloader_sl.cpp +++ b/src/saveload/oldloader_sl.cpp @@ -1335,7 +1335,7 @@ bool LoadOldVehicle(LoadgameState *ls, int num) if (_old_order_ptr != 0 && _old_order_ptr != 0xFFFFFFFF) { uint max = _savegame_type == SGT_TTO ? 3000 : 5000; uint old_id = RemapOrderIndex(_old_order_ptr); - if (old_id < max) v->orders.old = Order::Get(old_id); // don't accept orders > max number of orders + if (old_id < max) v->old_orders = Order::Get(old_id); // don't accept orders > max number of orders } v->current_order.AssignOrder(UnpackOldOrder(_old_order)); diff --git a/src/saveload/vehicle_sl.cpp b/src/saveload/vehicle_sl.cpp index 85df6efcec..178275f54a 100644 --- a/src/saveload/vehicle_sl.cpp +++ b/src/saveload/vehicle_sl.cpp @@ -263,26 +263,26 @@ void AfterLoadVehicles(bool part_of_load) std::map mapping; for (Vehicle *v : Vehicle::Iterate()) { - if (v->orders.old != nullptr) { + if (v->old_orders != nullptr) { if (IsSavegameVersionBefore(SLV_105)) { // Pre-105 didn't save an OrderList - if (mapping[v->orders.old] == nullptr) { + if (mapping[v->old_orders] == nullptr) { /* This adds the whole shared vehicle chain for case b */ /* Creating an OrderList here is safe because the number of vehicles * allowed in these savegames matches the number of OrderLists. As * such each vehicle can get an OrderList and it will (still) fit. */ assert(OrderList::CanAllocateItem()); - v->orders.list = mapping[v->orders.old] = new OrderList(v->orders.old, v); + v->orders = mapping[v->old_orders] = new OrderList(v->old_orders, v); } else { - v->orders.list = mapping[v->orders.old]; + v->orders = mapping[v->old_orders]; /* For old games (case a) we must create the shared vehicle chain */ if (IsSavegameVersionBefore(SLV_5, 2)) { - v->AddToShared(v->orders.list->GetFirstSharedVehicle()); + v->AddToShared(v->orders->GetFirstSharedVehicle()); } } } else { // OrderList was saved as such, only recalculate not saved values if (v->PreviousShared() == nullptr) { - v->orders.list->Initialize(v->orders.list->first, v); + v->orders->Initialize(v->orders->first, v); } } } @@ -302,13 +302,13 @@ void AfterLoadVehicles(bool part_of_load) if (IsSavegameVersionBefore(SLV_105)) { /* Before 105 there was no order for shared orders, thus it messed up horribly */ for (Vehicle *v : Vehicle::Iterate()) { - if (v->First() != v || v->orders.list != nullptr || v->previous_shared != nullptr || v->next_shared == nullptr) continue; + if (v->First() != v || v->orders != nullptr || v->previous_shared != nullptr || v->next_shared == nullptr) continue; /* As above, allocating OrderList here is safe. */ assert(OrderList::CanAllocateItem()); - v->orders.list = new OrderList(nullptr, v); + v->orders = new OrderList(nullptr, v); for (Vehicle *u = v; u != nullptr; u = u->next_shared) { - u->orders.list = v->orders.list; + u->orders = v->orders; } } } diff --git a/src/script/api/script_order.cpp b/src/script/api/script_order.cpp index e2ee1e6085..c127d11e3c 100644 --- a/src/script/api/script_order.cpp +++ b/src/script/api/script_order.cpp @@ -91,7 +91,7 @@ static int ScriptOrderPositionToRealOrderPosition(VehicleID vehicle_id, ScriptOr assert(ScriptOrder::IsValidVehicleOrder(vehicle_id, order_position)); int res = (int)order_position; - const Order *order = v->orders.list->GetFirstOrder(); + const Order *order = v->orders->GetFirstOrder(); for (; order->GetType() == OT_IMPLICIT; order = order->next) res++; while (order_position > 0) { order_position = (ScriptOrder::OrderPosition)(order_position - 1); diff --git a/src/script/api/script_vehicle.cpp b/src/script/api/script_vehicle.cpp index b7b5fd9503..82db2dfce8 100644 --- a/src/script/api/script_vehicle.cpp +++ b/src/script/api/script_vehicle.cpp @@ -454,7 +454,7 @@ if (!IsValidVehicle(vehicle_id)) return false; Vehicle *v = ::Vehicle::Get(vehicle_id); - return v->orders.list != nullptr && v->orders.list->GetNumVehicles() > 1; + return v->orders != nullptr && v->orders->GetNumVehicles() > 1; } /* static */ int ScriptVehicle::GetReliability(VehicleID vehicle_id) diff --git a/src/timetable_cmd.cpp b/src/timetable_cmd.cpp index fa8ecf51e3..b717f8224c 100644 --- a/src/timetable_cmd.cpp +++ b/src/timetable_cmd.cpp @@ -55,8 +55,8 @@ static void ChangeTimetable(Vehicle *v, VehicleOrderID order_number, uint16 val, default: NOT_REACHED(); } - v->orders.list->UpdateTotalDuration(total_delta); - v->orders.list->UpdateTimetableDuration(timetable_delta); + v->orders->UpdateTotalDuration(total_delta); + v->orders->UpdateTimetableDuration(timetable_delta); for (v = v->FirstShared(); v != nullptr; v = v->NextShared()) { if (v->cur_real_order_index == order_number && v->current_order.Equals(*order)) { @@ -182,7 +182,7 @@ CommandCost CmdChangeTimetable(DoCommandFlag flags, VehicleID veh, VehicleOrderI CommandCost CmdSetVehicleOnTime(DoCommandFlag flags, VehicleID veh) { Vehicle *v = Vehicle::GetIfValid(veh); - if (v == nullptr || !v->IsPrimaryVehicle() || v->orders.list == nullptr) return CMD_ERROR; + if (v == nullptr || !v->IsPrimaryVehicle() || v->orders == nullptr) return CMD_ERROR; CommandCost ret = CheckOwnership(v->owner); if (ret.Failed()) return ret; @@ -244,7 +244,7 @@ static bool VehicleTimetableSorter(Vehicle * const &a, Vehicle * const &b) CommandCost CmdSetTimetableStart(DoCommandFlag flags, VehicleID veh_id, bool timetable_all, Date start_date) { Vehicle *v = Vehicle::GetIfValid(veh_id); - if (v == nullptr || !v->IsPrimaryVehicle() || v->orders.list == nullptr) return CMD_ERROR; + if (v == nullptr || !v->IsPrimaryVehicle() || v->orders == nullptr) return CMD_ERROR; CommandCost ret = CheckOwnership(v->owner); if (ret.Failed()) return ret; @@ -253,20 +253,20 @@ CommandCost CmdSetTimetableStart(DoCommandFlag flags, VehicleID veh_id, bool tim if (start_date < 0 || start_date > MAX_DAY) return CMD_ERROR; if (start_date - _date > 15 * DAYS_IN_LEAP_YEAR) return CMD_ERROR; if (_date - start_date > DAYS_IN_LEAP_YEAR) return CMD_ERROR; - if (timetable_all && !v->orders.list->IsCompleteTimetable()) return CMD_ERROR; + if (timetable_all && !v->orders->IsCompleteTimetable()) return CMD_ERROR; if (flags & DC_EXEC) { std::vector vehs; if (timetable_all) { - for (Vehicle *w = v->orders.list->GetFirstSharedVehicle(); w != nullptr; w = w->NextShared()) { + for (Vehicle *w = v->orders->GetFirstSharedVehicle(); w != nullptr; w = w->NextShared()) { vehs.push_back(w); } } else { vehs.push_back(v); } - int total_duration = v->orders.list->GetTimetableTotalDuration(); + int total_duration = v->orders->GetTimetableTotalDuration(); int num_vehs = (uint)vehs.size(); if (num_vehs >= 2) { @@ -304,7 +304,7 @@ CommandCost CmdSetTimetableStart(DoCommandFlag flags, VehicleID veh_id, bool tim CommandCost CmdAutofillTimetable(DoCommandFlag flags, VehicleID veh, bool autofill, bool preserve_wait_time) { Vehicle *v = Vehicle::GetIfValid(veh); - if (v == nullptr || !v->IsPrimaryVehicle() || v->orders.list == nullptr) return CMD_ERROR; + if (v == nullptr || !v->IsPrimaryVehicle() || v->orders == nullptr) return CMD_ERROR; CommandCost ret = CheckOwnership(v->owner); if (ret.Failed()) return ret; @@ -441,7 +441,7 @@ void UpdateVehicleTimetable(Vehicle *v, bool travelling) * length of a full cycle till lateness is less than the length of a timetable * cycle. When the timetable isn't fully filled the cycle will be INVALID_TICKS. */ if (v->lateness_counter > (int)timetabled) { - Ticks cycle = v->orders.list->GetTimetableTotalDuration(); + Ticks cycle = v->orders->GetTimetableTotalDuration(); if (cycle != INVALID_TICKS && v->lateness_counter > cycle) { v->lateness_counter %= cycle; } diff --git a/src/timetable_gui.cpp b/src/timetable_gui.cpp index 9a09bce365..662919829f 100644 --- a/src/timetable_gui.cpp +++ b/src/timetable_gui.cpp @@ -123,7 +123,7 @@ static void FillTimetableArrivalDepartureTable(const Vehicle *v, VehicleOrderID if (i >= v->GetNumOrders()) { i = 0; assert(order == nullptr); - order = v->orders.list->GetFirstOrder(); + order = v->orders->GetFirstOrder(); } } while (i != start); @@ -322,9 +322,9 @@ struct TimetableWindow : Window { this->SetWidgetDisabledState(WID_VT_CLEAR_SPEED, disable_speed); this->SetWidgetDisabledState(WID_VT_SHARED_ORDER_LIST, !v->IsOrderListShared()); - this->SetWidgetDisabledState(WID_VT_START_DATE, v->orders.list == nullptr); - this->SetWidgetDisabledState(WID_VT_RESET_LATENESS, v->orders.list == nullptr); - this->SetWidgetDisabledState(WID_VT_AUTOFILL, v->orders.list == nullptr); + this->SetWidgetDisabledState(WID_VT_START_DATE, v->orders == nullptr); + this->SetWidgetDisabledState(WID_VT_RESET_LATENESS, v->orders == nullptr); + this->SetWidgetDisabledState(WID_VT_AUTOFILL, v->orders == nullptr); } else { this->DisableWidget(WID_VT_START_DATE); this->DisableWidget(WID_VT_CHANGE_TIME); @@ -424,7 +424,7 @@ struct TimetableWindow : Window { * i.e. are only shown if we can calculate all times. * Excluding order lists with only one order makes some things easier. */ - Ticks total_time = v->orders.list != nullptr ? v->orders.list->GetTimetableDurationIncomplete() : 0; + Ticks total_time = v->orders != nullptr ? v->orders->GetTimetableDurationIncomplete() : 0; if (total_time <= 0 || v->GetNumOrders() <= 1 || !HasBit(v->vehicle_flags, VF_TIMETABLE_STARTED)) break; TimetableArrivalDeparture *arr_dep = AllocaM(TimetableArrivalDeparture, v->GetNumOrders()); @@ -475,10 +475,10 @@ struct TimetableWindow : Window { case WID_VT_SUMMARY_PANEL: { int y = r.top + WD_FRAMERECT_TOP; - Ticks total_time = v->orders.list != nullptr ? v->orders.list->GetTimetableDurationIncomplete() : 0; + Ticks total_time = v->orders != nullptr ? v->orders->GetTimetableDurationIncomplete() : 0; if (total_time != 0) { SetTimetableParams(0, 1, total_time); - DrawString(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, y, v->orders.list->IsCompleteTimetable() ? STR_TIMETABLE_TOTAL_TIME : STR_TIMETABLE_TOTAL_TIME_INCOMPLETE); + DrawString(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, y, v->orders->IsCompleteTimetable() ? STR_TIMETABLE_TOTAL_TIME : STR_TIMETABLE_TOTAL_TIME_INCOMPLETE); } y += FONT_HEIGHT_NORMAL; @@ -531,7 +531,7 @@ struct TimetableWindow : Window { } case WID_VT_START_DATE: // Change the date that the timetable starts. - ShowSetDateWindow(this, v->index, _date, _cur_year, _cur_year + 15, ChangeTimetableStartCallback, reinterpret_cast(static_cast(v->orders.list->IsCompleteTimetable() && _ctrl_pressed))); + ShowSetDateWindow(this, v->index, _date, _cur_year, _cur_year + 15, ChangeTimetableStartCallback, reinterpret_cast(static_cast(v->orders->IsCompleteTimetable() && _ctrl_pressed))); break; case WID_VT_CHANGE_TIME: { // "Wait For" button. diff --git a/src/train_cmd.cpp b/src/train_cmd.cpp index 2fd081898e..2af665a4a6 100644 --- a/src/train_cmd.cpp +++ b/src/train_cmd.cpp @@ -1382,7 +1382,7 @@ CommandCost CmdSellRailWagon(DoCommandFlag flags, Vehicle *t, bool sell_chain, b return ret; } - if (first->orders.list == nullptr && !OrderList::CanAllocateItem()) { + if (first->orders == nullptr && !OrderList::CanAllocateItem()) { /* Restore the train we had. */ RestoreTrainBackup(original); return_cmd_error(STR_ERROR_NO_MORE_SPACE_FOR_ORDERS); @@ -1399,7 +1399,7 @@ CommandCost CmdSellRailWagon(DoCommandFlag flags, Vehicle *t, bool sell_chain, b if (v == first && v->IsEngine() && !sell_chain && new_head != nullptr && new_head->IsFrontEngine()) { /* We are selling the front engine. In this case we want to * 'give' the order, unit number and such to the new head. */ - new_head->orders.list = first->orders.list; + new_head->orders = first->orders; new_head->AddToShared(first); DeleteVehicleOrders(first); diff --git a/src/vehicle.cpp b/src/vehicle.cpp index 120c4a259f..b2c92d7db3 100644 --- a/src/vehicle.cpp +++ b/src/vehicle.cpp @@ -2161,7 +2161,7 @@ void Vehicle::BeginLoading() break; } target_index++; - if (target_index >= this->orders.list->GetNumOrders()) { + if (target_index >= this->orders->GetNumOrders()) { if (this->GetNumManualOrders() == 0 && this->GetNumOrders() < IMPLICIT_ORDER_ONLY_CAP) { break; @@ -2199,7 +2199,7 @@ void Vehicle::BeginLoading() } } } else if (!suppress_implicit_orders && - ((this->orders.list == nullptr ? OrderList::CanAllocateItem() : this->orders.list->GetNumOrders() < MAX_VEH_ORDER_ID)) && + ((this->orders == nullptr ? OrderList::CanAllocateItem() : this->orders->GetNumOrders() < MAX_VEH_ORDER_ID)) && Order::CanAllocateItem()) { /* Insert new implicit order */ Order *implicit_order = new Order(); @@ -2770,10 +2770,10 @@ void Vehicle::AddToShared(Vehicle *shared_chain) { assert(this->previous_shared == nullptr && this->next_shared == nullptr); - if (shared_chain->orders.list == nullptr) { + if (shared_chain->orders == nullptr) { assert(shared_chain->previous_shared == nullptr); assert(shared_chain->next_shared == nullptr); - this->orders.list = shared_chain->orders.list = new OrderList(nullptr, shared_chain); + this->orders = shared_chain->orders = new OrderList(nullptr, shared_chain); } this->next_shared = shared_chain->next_shared; @@ -2783,7 +2783,7 @@ void Vehicle::AddToShared(Vehicle *shared_chain) if (this->next_shared != nullptr) this->next_shared->previous_shared = this; - shared_chain->orders.list->AddVehicle(this); + shared_chain->orders->AddVehicle(this); } /** @@ -2796,7 +2796,7 @@ void Vehicle::RemoveFromShared() bool were_first = (this->FirstShared() == this); VehicleListIdentifier vli(VL_SHARED_ORDERS, this->type, this->owner, this->FirstShared()->index); - this->orders.list->RemoveVehicle(this); + this->orders->RemoveVehicle(this); if (!were_first) { /* We are not the first shared one, so only relink our previous one. */ @@ -2806,7 +2806,7 @@ void Vehicle::RemoveFromShared() if (this->next_shared != nullptr) this->next_shared->previous_shared = this->previous_shared; - if (this->orders.list->GetNumVehicles() == 1) { + if (this->orders->GetNumVehicles() == 1) { /* When there is only one vehicle, remove the shared order list window. */ CloseWindowById(GetWindowClassForVehicleType(this->type), vli.Pack()); InvalidateVehicleOrder(this->FirstShared(), VIWD_MODIFY_ORDERS); diff --git a/src/vehicle_base.h b/src/vehicle_base.h index a5ab42989c..7a19727ff8 100644 --- a/src/vehicle_base.h +++ b/src/vehicle_base.h @@ -332,9 +332,9 @@ public: Order current_order; ///< The current order (+ status, like: loading) union { - OrderList *list; ///< Pointer to the order list for this vehicle - Order *old; ///< Only used during conversion of old save games - } orders; ///< The orders currently assigned to the vehicle. + OrderList *orders; ///< Pointer to the order list for this vehicle + Order *old_orders; ///< Only used during conversion of old save games + }; uint16 load_unload_ticks; ///< Ticks to wait before starting next cycle. GroupID group_id; ///< Index of group Pool array @@ -669,7 +669,7 @@ public: * Get the first order of the vehicles order list. * @return first order of order list. */ - inline Order *GetFirstOrder() const { return (this->orders.list == nullptr) ? nullptr : this->orders.list->GetFirstOrder(); } + inline Order *GetFirstOrder() const { return (this->orders == nullptr) ? nullptr : this->orders->GetFirstOrder(); } void AddToShared(Vehicle *shared_chain); void RemoveFromShared(); @@ -690,25 +690,25 @@ public: * Get the first vehicle of this vehicle chain. * @return the first vehicle of the chain. */ - inline Vehicle *FirstShared() const { return (this->orders.list == nullptr) ? this->First() : this->orders.list->GetFirstSharedVehicle(); } + inline Vehicle *FirstShared() const { return (this->orders == nullptr) ? this->First() : this->orders->GetFirstSharedVehicle(); } /** * Check if we share our orders with another vehicle. * @return true if there are other vehicles sharing the same order */ - inline bool IsOrderListShared() const { return this->orders.list != nullptr && this->orders.list->IsShared(); } + inline bool IsOrderListShared() const { return this->orders != nullptr && this->orders->IsShared(); } /** * Get the number of orders this vehicle has. * @return the number of orders this vehicle has. */ - inline VehicleOrderID GetNumOrders() const { return (this->orders.list == nullptr) ? 0 : this->orders.list->GetNumOrders(); } + inline VehicleOrderID GetNumOrders() const { return (this->orders == nullptr) ? 0 : this->orders->GetNumOrders(); } /** * Get the number of manually added orders this vehicle has. * @return the number of manually added orders this vehicle has. */ - inline VehicleOrderID GetNumManualOrders() const { return (this->orders.list == nullptr) ? 0 : this->orders.list->GetNumManualOrders(); } + inline VehicleOrderID GetNumManualOrders() const { return (this->orders == nullptr) ? 0 : this->orders->GetNumManualOrders(); } /** * Get the next station the vehicle will stop at. @@ -716,7 +716,7 @@ public: */ inline StationIDStack GetNextStoppingStation() const { - return (this->orders.list == nullptr) ? INVALID_STATION : this->orders.list->GetNextStoppingStation(this); + return (this->orders == nullptr) ? INVALID_STATION : this->orders->GetNextStoppingStation(this); } void ResetRefitCaps(); @@ -878,7 +878,7 @@ public: */ inline Order *GetOrder(int index) const { - return (this->orders.list == nullptr) ? nullptr : this->orders.list->GetOrderAt(index); + return (this->orders == nullptr) ? nullptr : this->orders->GetOrderAt(index); } /** @@ -887,7 +887,7 @@ public: */ inline Order *GetLastOrder() const { - return (this->orders.list == nullptr) ? nullptr : this->orders.list->GetLastOrder(); + return (this->orders == nullptr) ? nullptr : this->orders->GetLastOrder(); } bool IsEngineCountable() const; @@ -1038,7 +1038,7 @@ public: * Returns an iterable ensemble of orders of a vehicle * @return an iterable ensemble of orders of a vehicle */ - IterateWrapper Orders() const { return IterateWrapper(this->orders.list); } + IterateWrapper Orders() const { return IterateWrapper(this->orders); } }; /** diff --git a/src/vehicle_cmd.cpp b/src/vehicle_cmd.cpp index 11b8d9508b..2261456a33 100644 --- a/src/vehicle_cmd.cpp +++ b/src/vehicle_cmd.cpp @@ -219,9 +219,9 @@ CommandCost CmdSellVehicle(DoCommandFlag flags, VehicleID v_id, bool sell_chain, /* Can we actually make the order backup, i.e. are there enough orders? */ if (backup_order && - front->orders.list != nullptr && - !front->orders.list->IsShared() && - !Order::CanAllocateItem(front->orders.list->GetNumOrders())) { + front->orders != nullptr && + !front->orders->IsShared() && + !Order::CanAllocateItem(front->orders->GetNumOrders())) { /* Only happens in exceptional cases when there aren't enough orders anyhow. * Thus it should be safe to just drop the orders in that case. */ backup_order = false; diff --git a/src/vehicle_gui.cpp b/src/vehicle_gui.cpp index 70ac8ca86e..2fe403391b 100644 --- a/src/vehicle_gui.cpp +++ b/src/vehicle_gui.cpp @@ -1444,7 +1444,7 @@ static void DrawSmallOrderList(const Vehicle *v, int left, int right, int y, uin oid++; order = order->next; if (order == nullptr) { - order = v->orders.list->GetFirstOrder(); + order = v->orders->GetFirstOrder(); oid = 0; } } while (oid != start);