mirror of
https://github.com/JGRennison/OpenTTD-patches.git
synced 2024-10-31 15:20:10 +00:00
7ce06e22b8
See: 735abfe1
893 lines
37 KiB
C++
893 lines
37 KiB
C++
/*
|
|
* This file is part of OpenTTD.
|
|
* 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.
|
|
* 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.
|
|
* 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/>.
|
|
*/
|
|
|
|
/** @file departures.cpp Scheduled departures from a station. */
|
|
|
|
#include "stdafx.h"
|
|
#include "debug.h"
|
|
#include "gui.h"
|
|
#include "textbuf_gui.h"
|
|
#include "strings_func.h"
|
|
#include "window_func.h"
|
|
#include "vehicle_func.h"
|
|
#include "string_func.h"
|
|
#include "window_gui.h"
|
|
#include "timetable.h"
|
|
#include "vehiclelist.h"
|
|
#include "company_base.h"
|
|
#include "date_func.h"
|
|
#include "departures_gui.h"
|
|
#include "station_base.h"
|
|
#include "vehicle_gui_base.h"
|
|
#include "vehicle_base.h"
|
|
#include "vehicle_gui.h"
|
|
#include "order_base.h"
|
|
#include "settings_type.h"
|
|
#include "date_type.h"
|
|
#include "company_type.h"
|
|
#include "cargo_type.h"
|
|
#include "departures_func.h"
|
|
#include "departures_type.h"
|
|
#include "tracerestrict.h"
|
|
#include "3rdparty/cpp-btree/btree_set.h"
|
|
#include "3rdparty/cpp-btree/btree_map.h"
|
|
|
|
#include <vector>
|
|
#include <algorithm>
|
|
|
|
/* A cache of used departure time for scheduled dispatch in departure time calculation */
|
|
typedef btree::btree_map<const DispatchSchedule *, btree::btree_set<StateTicks>> schdispatch_cache_t;
|
|
|
|
/** A scheduled order. */
|
|
struct OrderDate {
|
|
const Order *order; ///< The order
|
|
const Vehicle *v; ///< The vehicle carrying out the order
|
|
Ticks expected_tick; ///< The tick on which the order is expected to complete
|
|
Ticks lateness; ///< How late this order is expected to finish
|
|
DepartureStatus status; ///< Whether the vehicle has arrived to carry out the order yet
|
|
Ticks scheduled_waiting_time; ///< Scheduled waiting time if scheduled dispatch is used
|
|
|
|
inline Ticks EffectiveWaitingTime() const
|
|
{
|
|
if (this->scheduled_waiting_time > 0) {
|
|
return this->scheduled_waiting_time;
|
|
} else {
|
|
return this->order->GetWaitTime();
|
|
}
|
|
}
|
|
};
|
|
|
|
static bool IsDeparture(const Order *order, StationID station) {
|
|
return (order->GetType() == OT_GOTO_STATION &&
|
|
(StationID)order->GetDestination() == station &&
|
|
(order->GetLoadType() != OLFB_NO_LOAD ||
|
|
_settings_client.gui.departure_show_all_stops) &&
|
|
(order->GetWaitTime() != 0 || order->IsWaitTimetabled()) &&
|
|
!(order->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION));
|
|
}
|
|
|
|
static bool IsVia(const Order *order, StationID station) {
|
|
return ((order->GetType() == OT_GOTO_STATION ||
|
|
order->GetType() == OT_GOTO_WAYPOINT) &&
|
|
(StationID)order->GetDestination() == station &&
|
|
(order->GetNonStopType() == ONSF_NO_STOP_AT_ANY_STATION ||
|
|
order->GetNonStopType() == ONSF_NO_STOP_AT_DESTINATION_STATION));
|
|
}
|
|
|
|
static bool IsArrival(const Order *order, StationID station) {
|
|
return (order->GetType() == OT_GOTO_STATION &&
|
|
(StationID)order->GetDestination() == station &&
|
|
(order->GetUnloadType() != OUFB_NO_UNLOAD ||
|
|
_settings_client.gui.departure_show_all_stops) &&
|
|
(order->GetWaitTime() != 0 || order->IsWaitTimetabled()) &&
|
|
!(order->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION));
|
|
}
|
|
|
|
static uint8_t GetDepartureConditionalOrderMode(const Order *order, const Vehicle *v, StateTicks eval_tick)
|
|
{
|
|
if (order->GetConditionVariable() == OCV_UNCONDITIONALLY) return 1;
|
|
if (order->GetConditionVariable() == OCV_TIME_DATE) {
|
|
int value = GetTraceRestrictTimeDateValueFromStateTicks(static_cast<TraceRestrictTimeDateValueField>(order->GetConditionValue()), eval_tick);
|
|
return OrderConditionCompare(order->GetConditionComparator(), value, order->GetXData()) ? 1 : 2;
|
|
}
|
|
if (order->GetConditionVariable() == OCV_DISPATCH_SLOT) {
|
|
extern bool EvaluateDispatchSlotConditionalOrder(const Order *order, const Vehicle *v, StateTicks state_ticks, bool *predicted);
|
|
return EvaluateDispatchSlotConditionalOrder(order, v, eval_tick, nullptr) ? 1 : 2;
|
|
}
|
|
return _settings_client.gui.departure_conditionals;
|
|
}
|
|
|
|
static bool VehicleSetNextDepartureTime(Ticks *previous_departure, Ticks *waiting_time, const StateTicks state_ticks_base, const Vehicle *v, const Order *order, bool arrived_at_timing_point, schdispatch_cache_t &dept_schedule_last)
|
|
{
|
|
if (HasBit(v->vehicle_flags, VF_SCHEDULED_DISPATCH)) {
|
|
auto is_current_implicit_order = [&v](const Order *o) -> bool {
|
|
if (v->cur_implicit_order_index >= v->orders->GetNumOrders()) return false;
|
|
return v->orders->GetOrderAt(v->cur_implicit_order_index) == o;
|
|
};
|
|
|
|
/* This condition means that we want departure time for the dispatch order */
|
|
/* but not if the vehicle has arrived at the dispatch order because the timetable is already shifted */
|
|
if (order->IsScheduledDispatchOrder(true) && !(arrived_at_timing_point && is_current_implicit_order(order))) {
|
|
const DispatchSchedule &ds = v->orders->GetDispatchScheduleByIndex(order->GetDispatchScheduleIndex());
|
|
|
|
StateTicks actual_departure = -1;
|
|
const StateTicks begin_time = ds.GetScheduledDispatchStartTick();
|
|
const uint32_t dispatch_duration = ds.GetScheduledDispatchDuration();
|
|
const int32_t max_delay = ds.GetScheduledDispatchDelay();
|
|
|
|
/* Earliest possible departure according to schedue */
|
|
StateTicks earliest_departure = begin_time + ds.GetScheduledDispatchLastDispatch();
|
|
|
|
/* Earliest possible departure according to vehicle current timetable */
|
|
const StateTicks ready_to_depart_time = state_ticks_base + *previous_departure + order->GetTravelTime() + order->GetTimetabledWait();
|
|
if (earliest_departure + max_delay < ready_to_depart_time) {
|
|
earliest_departure = ready_to_depart_time - max_delay - 1;
|
|
/* -1 because this number is actually a moment before actual departure */
|
|
}
|
|
|
|
btree::btree_set<StateTicks> &slot_cache = dept_schedule_last[&ds];
|
|
|
|
/* Find next available slots */
|
|
for (const DispatchSlot &slot : ds.GetScheduledDispatch()) {
|
|
if (slot.offset >= dispatch_duration) continue;
|
|
StateTicks current_departure = begin_time + slot.offset;
|
|
while (current_departure <= earliest_departure) {
|
|
current_departure += dispatch_duration;
|
|
}
|
|
|
|
/* Make sure the slots has not already been used previously in this departure board calculation */
|
|
while (slot_cache.count(current_departure) > 0) {
|
|
if (HasBit(slot.flags, DispatchSlot::SDSF_REUSE_SLOT)) {
|
|
/* Allow re-use of this slot if it's the last seen */
|
|
if (*slot_cache.rbegin() == current_departure) break;
|
|
}
|
|
current_departure += dispatch_duration;
|
|
}
|
|
|
|
if (actual_departure == -1 || actual_departure > current_departure) {
|
|
actual_departure = current_departure;
|
|
}
|
|
}
|
|
|
|
*waiting_time = (actual_departure - state_ticks_base).AsTicks() - *previous_departure - order->GetTravelTime();
|
|
*previous_departure = (actual_departure - state_ticks_base).AsTicks();
|
|
if (!ds.GetScheduledDispatchReuseSlots()) {
|
|
slot_cache.insert(actual_departure);
|
|
}
|
|
|
|
/* Return true means that vehicle lateness should be clear from this point onward */
|
|
return true;
|
|
}
|
|
|
|
/* This is special case for proper calculation of arrival time. */
|
|
if (arrived_at_timing_point && v->cur_implicit_order_index < v->orders->GetNumOrders() && v->orders->GetOrderAt(v->cur_implicit_order_index)->IsScheduledDispatchOrder(true)) {
|
|
*previous_departure += order->GetTravelTime() + order->GetWaitTime();
|
|
*waiting_time = -v->lateness_counter + order->GetWaitTime();
|
|
return false;
|
|
}
|
|
} /* if vehicle is on scheduled dispatch */
|
|
|
|
/* Not using schedule for this departure time */
|
|
*previous_departure += order->GetTravelTime() + order->GetWaitTime();
|
|
*waiting_time = 0;
|
|
return false;
|
|
}
|
|
|
|
static void ScheduledDispatchDepartureLocalFix(DepartureList *departure_list)
|
|
{
|
|
/* Seperate departure by each shared order group */
|
|
btree::btree_map<uint32_t, std::vector<Departure*>> separated_departure;
|
|
for (Departure* departure : *departure_list) {
|
|
separated_departure[departure->vehicle->orders->index].push_back(departure);
|
|
}
|
|
|
|
for (auto& pair : separated_departure) {
|
|
auto d_list = pair.second;
|
|
|
|
/* If the group is scheduled dispatch, then */
|
|
if (HasBit(d_list[0]->vehicle->vehicle_flags, VF_SCHEDULED_DISPATCH)) {
|
|
/* Separate departure time and sort them ascendently */
|
|
std::vector<StateTicks> departure_time_list;
|
|
for (const auto& d : d_list) {
|
|
departure_time_list.push_back(d->scheduled_tick);
|
|
}
|
|
std::sort(departure_time_list.begin(), departure_time_list.end());
|
|
|
|
/* Sort the departure list by arrival time */
|
|
std::sort(d_list.begin(), d_list.end(), [](const Departure * const &a, const Departure * const &b) -> bool {
|
|
StateTicks arr_a = a->scheduled_tick - a->EffectiveWaitingTime();
|
|
StateTicks arr_b = b->scheduled_tick - b->EffectiveWaitingTime();
|
|
return arr_a < arr_b;
|
|
});
|
|
|
|
/* Re-assign them sequentially */
|
|
for (size_t i = 0; i < d_list.size(); i++) {
|
|
const StateTicks arrival = d_list[i]->scheduled_tick - d_list[i]->EffectiveWaitingTime();
|
|
d_list[i]->scheduled_waiting_time = (departure_time_list[i] - arrival).AsTicks();
|
|
d_list[i]->scheduled_tick = departure_time_list[i];
|
|
|
|
if (d_list[i]->scheduled_waiting_time == (Ticks)d_list[i]->order->GetWaitTime()) {
|
|
d_list[i]->scheduled_waiting_time = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Re-sort the departure list */
|
|
std::sort(departure_list->begin(), departure_list->end(), [](Departure * const &a, Departure * const &b) -> bool {
|
|
return a->scheduled_tick < b->scheduled_tick;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Compute an up-to-date list of departures for a station.
|
|
* @param station the station to compute the departures of
|
|
* @param vehicles set of all the vehicles stopping at this station, of all vehicles types that we are interested in
|
|
* @param type the type of departures to get (departures or arrivals)
|
|
* @param show_vehicles_via whether to include vehicles that have this station in their orders but do not stop at it
|
|
* @param show_pax whether to include passenger vehicles
|
|
* @param show_freight whether to include freight vehicles
|
|
* @return a list of departures, which is empty if an error occurred
|
|
*/
|
|
DepartureList* MakeDepartureList(StationID station, const std::vector<const Vehicle *> &vehicles, DepartureType type, bool show_vehicles_via, bool show_pax, bool show_freight)
|
|
{
|
|
/* This function is the meat of the departure boards functionality. */
|
|
/* As an overview, it works by repeatedly considering the best possible next departure to show. */
|
|
/* By best possible we mean the one expected to arrive at the station first. */
|
|
/* However, we do not consider departures whose scheduled time is too far in the future, even if they are expected before some delayed ones. */
|
|
/* This code can probably be made more efficient. I haven't done so in order to keep both its (relative) simplicity and my (relative) sanity. */
|
|
/* Having written that, it's not exactly slow at the moment. */
|
|
|
|
/* The list of departures which will be returned as a result. */
|
|
std::vector<Departure*> *result = new std::vector<Departure*>();
|
|
|
|
if (!show_pax && !show_freight) return result;
|
|
|
|
/* A list of the next scheduled orders to be considered for inclusion in the departure list. */
|
|
std::vector<OrderDate*> next_orders;
|
|
|
|
/* The maximum possible date for departures to be scheduled to occur. */
|
|
const Ticks max_ticks = GetDeparturesMaxTicksAhead();
|
|
|
|
const StateTicks state_ticks_base = _state_ticks;
|
|
|
|
/* The scheduled order in next_orders with the earliest expected_tick field. */
|
|
OrderDate *least_order = nullptr;
|
|
|
|
/* Cache for scheduled departure time */
|
|
schdispatch_cache_t schdispatch_last_planned_dispatch;
|
|
|
|
{
|
|
/* Get the first order for each vehicle for the station we're interested in that doesn't have No Loading set. */
|
|
/* We find the least order while we're at it. */
|
|
for (const Vehicle *v : vehicles) {
|
|
if (v->GetNumOrders() == 0) continue;
|
|
if (show_pax != show_freight) {
|
|
bool carries_passengers = false;
|
|
|
|
const Vehicle *u = v;
|
|
while (u != nullptr) {
|
|
if (u->cargo_cap > 0 && IsCargoInClass(u->cargo_type, CC_PASSENGERS)) {
|
|
carries_passengers = true;
|
|
break;
|
|
}
|
|
u = u->Next();
|
|
}
|
|
|
|
if (carries_passengers != show_pax) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
const Order *order = v->GetOrder(v->cur_implicit_order_index % v->GetNumOrders());
|
|
if (order == nullptr) continue;
|
|
Ticks start_ticks = -((Ticks)v->current_order_time);
|
|
if (v->cur_timetable_order_index != INVALID_VEH_ORDER_ID && v->cur_timetable_order_index != v->cur_real_order_index) {
|
|
/* vehicle is taking a conditional order branch, adjust start time to compensate */
|
|
const Order *real_current_order = v->GetOrder(v->cur_real_order_index);
|
|
const Order *real_timetable_order = v->GetOrder(v->cur_timetable_order_index);
|
|
if (real_timetable_order->IsType(OT_CONDITIONAL)) {
|
|
start_ticks += (real_timetable_order->GetWaitTime() - real_current_order->GetTravelTime());
|
|
} else {
|
|
/* This can also occur with implicit orders, when there are no real orders, do nothing */
|
|
}
|
|
}
|
|
DepartureStatus status = D_TRAVELLING;
|
|
bool should_reset_lateness = false;
|
|
Ticks waiting_time = 0;
|
|
|
|
/* If the vehicle is stopped in a depot, ignore it. */
|
|
if (v->IsStoppedInDepot()) {
|
|
continue;
|
|
}
|
|
|
|
/* If the vehicle is heading for a depot to stop there, then its departures are cancelled. */
|
|
if (v->current_order.IsType(OT_GOTO_DEPOT) && v->current_order.GetDepotActionType() & ODATFB_HALT) {
|
|
status = D_CANCELLED;
|
|
}
|
|
|
|
bool require_travel_time = true;
|
|
if (v->current_order.IsAnyLoadingType() || v->current_order.IsType(OT_WAITING)) {
|
|
/* Account for the vehicle having reached the current order and being in the loading phase. */
|
|
status = D_ARRIVED;
|
|
start_ticks -= order->GetTravelTime() + ((v->lateness_counter < 0) ? v->lateness_counter : 0);
|
|
require_travel_time = false;
|
|
}
|
|
|
|
/* Loop through the vehicle's orders until we've found a suitable order or we've determined that no such order exists. */
|
|
/* We only need to consider each order at most once. */
|
|
for (int i = v->GetNumOrders(); i > 0; --i) {
|
|
if (VehicleSetNextDepartureTime(&start_ticks, &waiting_time, state_ticks_base, v, order, status == D_ARRIVED, schdispatch_last_planned_dispatch)) {
|
|
should_reset_lateness = true;
|
|
}
|
|
|
|
/* If the order is a conditional branch, handle it. */
|
|
if (order->IsType(OT_CONDITIONAL)) {
|
|
switch(GetDepartureConditionalOrderMode(order, v, state_ticks_base + start_ticks)) {
|
|
case 0: {
|
|
/* Give up */
|
|
break;
|
|
}
|
|
case 1: {
|
|
/* Take the branch */
|
|
if (status != D_CANCELLED) {
|
|
status = D_TRAVELLING;
|
|
}
|
|
order = v->GetOrder(order->GetConditionSkipToOrder());
|
|
if (order == nullptr) {
|
|
break;
|
|
}
|
|
|
|
start_ticks -= order->GetTravelTime();
|
|
require_travel_time = false;
|
|
continue;
|
|
}
|
|
case 2: {
|
|
/* Do not take the branch */
|
|
if (status != D_CANCELLED) {
|
|
status = D_TRAVELLING;
|
|
}
|
|
start_ticks -= order->GetWaitTime(); /* Added previously in VehicleSetNextDepartureTime */
|
|
order = (order->next == nullptr) ? v->GetFirstOrder() : order->next;
|
|
require_travel_time = true;
|
|
continue;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
/* If the scheduled departure date is too far in the future, stop. */
|
|
if (start_ticks - v->lateness_counter > max_ticks) {
|
|
break;
|
|
}
|
|
|
|
/* If an order has a 0 travel time, and it's not explictly set, then stop. */
|
|
if (require_travel_time && order->GetTravelTime() == 0 && !order->IsTravelTimetabled() && !order->IsType(OT_IMPLICIT)) {
|
|
break;
|
|
}
|
|
|
|
/* If the vehicle will be stopping at and loading from this station, and its wait time is not zero, then it is a departure. */
|
|
/* If the vehicle will be stopping at and unloading at this station, and its wait time is not zero, then it is an arrival. */
|
|
if ((type == D_DEPARTURE && IsDeparture(order, station)) ||
|
|
(type == D_DEPARTURE && show_vehicles_via && IsVia(order, station)) ||
|
|
(type == D_ARRIVAL && IsArrival(order, station))) {
|
|
/* If the departure was scheduled to have already begun and has been cancelled, do not show it. */
|
|
if (start_ticks < 0 && status == D_CANCELLED) {
|
|
break;
|
|
}
|
|
|
|
OrderDate *od = new OrderDate();
|
|
od->order = order;
|
|
od->v = v;
|
|
/* We store the expected date for now, so that vehicles will be shown in order of expected time. */
|
|
od->expected_tick = start_ticks;
|
|
od->lateness = v->lateness_counter > 0 ? v->lateness_counter : 0;
|
|
od->status = status;
|
|
od->scheduled_waiting_time = waiting_time;
|
|
|
|
/* Reset lateness if timing is from scheduled dispatch */
|
|
if (should_reset_lateness) {
|
|
od->lateness = 0;
|
|
}
|
|
|
|
/* If we are early, use the scheduled date as the expected date. We also take lateness to be zero. */
|
|
if (!should_reset_lateness && v->lateness_counter < 0 && !(v->current_order.IsAnyLoadingType() || v->current_order.IsType(OT_WAITING))) {
|
|
od->expected_tick -= v->lateness_counter;
|
|
}
|
|
|
|
/* Update least_order if this is the current least order. */
|
|
if (least_order == nullptr) {
|
|
least_order = od;
|
|
} else if (type == D_ARRIVAL) {
|
|
if ((least_order->expected_tick - least_order->lateness - least_order->EffectiveWaitingTime()) > (od->expected_tick - od->lateness - od->EffectiveWaitingTime())) {
|
|
least_order = od;
|
|
}
|
|
} else {
|
|
if ((least_order->expected_tick - least_order->lateness) > (od->expected_tick - od->lateness)) {
|
|
least_order = od;
|
|
}
|
|
}
|
|
|
|
next_orders.push_back(od);
|
|
|
|
/* We're done with this vehicle. */
|
|
break;
|
|
} else {
|
|
/* Go to the next order in the list. */
|
|
if (status != D_CANCELLED) {
|
|
status = D_TRAVELLING;
|
|
}
|
|
order = (order->next == nullptr) ? v->GetFirstOrder() : order->next;
|
|
require_travel_time = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* No suitable orders found? Then stop. */
|
|
if (next_orders.size() == 0) {
|
|
return result;
|
|
}
|
|
|
|
/* We now find as many departures as we can. It's a little involved so I'll try to explain each major step. */
|
|
/* The countdown from 10000 is a safeguard just in case something nasty happens. 10000 seemed large enough. */
|
|
for(int i = 10000; i > 0; --i) {
|
|
/* I should probably try to convince you that this loop always terminates regardless of the safeguard. */
|
|
/* 1. next_orders contains at least one element. */
|
|
/* 2. The loop terminates if result->size() exceeds a fixed (for this loop) value, or if the least order's scheduled date is later than max_ticks. */
|
|
/* (We ignore the case that the least order's scheduled date has overflown, as it is a relative rather than absolute date.) */
|
|
/* 3. Every time we loop round, either result->size() will have increased -OR- we will have increased the expected_tick of one of the elements of next_orders. */
|
|
/* 4. Therefore the loop must eventually terminate. */
|
|
|
|
/* least_order is the best candidate for the next departure. */
|
|
|
|
/* First, we check if we can stop looking for departures yet. */
|
|
if (result->size() >= _settings_client.gui.max_departures ||
|
|
least_order->expected_tick - least_order->lateness > max_ticks) {
|
|
break;
|
|
}
|
|
|
|
/* We already know the least order and that it's a suitable departure, so make it into a departure. */
|
|
Departure *d = new Departure();
|
|
d->scheduled_tick = state_ticks_base + least_order->expected_tick - least_order->lateness;
|
|
d->lateness = least_order->lateness;
|
|
d->status = least_order->status;
|
|
d->vehicle = least_order->v;
|
|
d->type = type;
|
|
d->order = least_order->order;
|
|
d->scheduled_waiting_time = least_order->scheduled_waiting_time;
|
|
|
|
/* We'll be going through the order list later, so we need a separate variable for it. */
|
|
const Order *order = least_order->order;
|
|
|
|
if (type == D_DEPARTURE) {
|
|
/* Computing departures: */
|
|
/* We want to find out where it will terminate, making a list of the stations it calls at along the way. */
|
|
/* We only count stations where unloading happens as being called at - i.e. pickup-only stations are ignored. */
|
|
/* Where the vehicle terminates is defined as the last unique station called at by the vehicle from the current order. */
|
|
|
|
/* If the vehicle loops round to the current order without a terminus being found, then it terminates upon reaching its current order again. */
|
|
|
|
/* We also determine which station this departure is going via, if any. */
|
|
/* A departure goes via a station if it is the first station for which the vehicle has an order to go via or non-stop via. */
|
|
/* Multiple departures on the same journey may go via different stations. That a departure can go via at most one station is intentional. */
|
|
|
|
/* We keep track of potential via stations along the way. If we call at a station immediately after going via it, then it is the via station. */
|
|
StationID candidate_via = INVALID_STATION;
|
|
StationID pending_via = INVALID_STATION;
|
|
StationID pending_via2 = INVALID_STATION;
|
|
|
|
/* Go through the order list, looping if necessary, to find a terminus. */
|
|
/* Get the next order, which may be the vehicle's first order. */
|
|
order = (order->next == nullptr) ? least_order->v->GetFirstOrder() : order->next;
|
|
/* We only need to consider each order at most once. */
|
|
bool found_terminus = false;
|
|
CallAt c = CallAt((StationID)order->GetDestination(), d->scheduled_tick);
|
|
for (int i = least_order->v->GetNumOrders(); i > 0; --i) {
|
|
/* If we reach the order at which the departure occurs again, then use the departure station as the terminus. */
|
|
if (order == least_order->order) {
|
|
/* If we're not calling anywhere, then skip this departure. */
|
|
found_terminus = (d->calling_at.size() > 0);
|
|
break;
|
|
}
|
|
|
|
/* If the order is a conditional branch, handle it. */
|
|
if (order->IsType(OT_CONDITIONAL)) {
|
|
switch (GetDepartureConditionalOrderMode(order, least_order->v, c.scheduled_tick != 0 ? c.scheduled_tick : _state_ticks)) {
|
|
case 0: {
|
|
/* Give up */
|
|
break;
|
|
}
|
|
case 1: {
|
|
/* Take the branch */
|
|
if (c.scheduled_tick != 0 && (order->GetWaitTime() != 0 || order->IsWaitTimetabled())) {
|
|
c.scheduled_tick += order->GetWaitTime();
|
|
} else {
|
|
c.scheduled_tick = 0;
|
|
}
|
|
order = least_order->v->GetOrder(order->GetConditionSkipToOrder());
|
|
if (order == nullptr) {
|
|
break;
|
|
}
|
|
if (c.scheduled_tick != 0) c.scheduled_tick -= order->GetTravelTime();
|
|
continue;
|
|
}
|
|
case 2: {
|
|
/* Do not take the branch */
|
|
order = (order->next == nullptr) ? least_order->v->GetFirstOrder() : order->next;
|
|
continue;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
/* If we reach the original station again, then use it as the terminus. */
|
|
if (order->GetType() == OT_GOTO_STATION &&
|
|
(StationID)order->GetDestination() == station &&
|
|
(order->GetUnloadType() != OUFB_NO_UNLOAD ||
|
|
_settings_client.gui.departure_show_all_stops) &&
|
|
(((order->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION) == 0) || ((least_order->order->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION) != 0))) {
|
|
/* If we're not calling anywhere, then skip this departure. */
|
|
found_terminus = (d->calling_at.size() > 0);
|
|
break;
|
|
} else if (order->GetType() == OT_GOTO_WAYPOINT &&
|
|
(StationID)order->GetDestination() == station) {
|
|
/* If we're not calling anywhere, then skip this departure. */
|
|
found_terminus = (d->calling_at.size() > 0);
|
|
break;
|
|
}
|
|
|
|
/* Check if we're going via this station. */
|
|
if ((order->GetNonStopType() == ONSF_NO_STOP_AT_ANY_STATION ||
|
|
order->GetNonStopType() == ONSF_NO_STOP_AT_DESTINATION_STATION) &&
|
|
order->GetType() == OT_GOTO_STATION &&
|
|
d->via == INVALID_STATION) {
|
|
candidate_via = (StationID)order->GetDestination();
|
|
}
|
|
|
|
if (order->GetType() == OT_LABEL && order->GetLabelSubType() == OLST_DEPARTURES_VIA && d->via == INVALID_STATION && pending_via == INVALID_STATION) {
|
|
pending_via = (StationID)order->GetDestination();
|
|
const Order *next = (order->next == nullptr) ? least_order->v->GetFirstOrder() : order->next;
|
|
if (next->GetType() == OT_LABEL && next->GetLabelSubType() == OLST_DEPARTURES_VIA && (StationID)next->GetDestination() != pending_via) {
|
|
pending_via2 = (StationID)next->GetDestination();
|
|
}
|
|
}
|
|
|
|
if (order->GetType() == OT_LABEL && order->GetLabelSubType() == OLST_DEPARTURES_REMOVE_VIA && !d->calling_at.empty()) {
|
|
d->remove_vias.push_back({ (StationID)order->GetDestination(), (uint)(d->calling_at.size() - 1) });
|
|
}
|
|
|
|
if (c.scheduled_tick != 0 && (order->GetTravelTime() != 0 || order->IsTravelTimetabled())) {
|
|
c.scheduled_tick += order->GetTravelTime(); /* TODO smart terminal may not work correctly */
|
|
} else {
|
|
c.scheduled_tick = 0;
|
|
}
|
|
|
|
c.station = (StationID)order->GetDestination();
|
|
|
|
/* We're not interested in this order any further if we're not calling at it. */
|
|
if ((order->GetUnloadType() == OUFB_NO_UNLOAD &&
|
|
!_settings_client.gui.departure_show_all_stops) ||
|
|
(order->GetType() != OT_GOTO_STATION &&
|
|
order->GetType() != OT_IMPLICIT) ||
|
|
order->GetNonStopType() == ONSF_NO_STOP_AT_ANY_STATION ||
|
|
order->GetNonStopType() == ONSF_NO_STOP_AT_DESTINATION_STATION) {
|
|
if (c.scheduled_tick != 0) c.scheduled_tick += order->GetWaitTime();
|
|
order = (order->next == nullptr) ? least_order->v->GetFirstOrder() : order->next;
|
|
continue;
|
|
}
|
|
|
|
/* If this order's station is already in the calling, then the previous called at station is the terminus. */
|
|
if (std::find(d->calling_at.begin(), d->calling_at.end(), c) != d->calling_at.end()) {
|
|
found_terminus = true;
|
|
break;
|
|
}
|
|
|
|
/* If appropriate, add the station to the calling at list and make it the candidate terminus. */
|
|
if ((order->GetType() == OT_GOTO_STATION ||
|
|
order->GetType() == OT_IMPLICIT) &&
|
|
order->GetNonStopType() != ONSF_NO_STOP_AT_ANY_STATION &&
|
|
order->GetNonStopType() != ONSF_NO_STOP_AT_DESTINATION_STATION) {
|
|
if (d->via == INVALID_STATION && pending_via != INVALID_STATION) {
|
|
d->via = pending_via;
|
|
d->via2 = pending_via2;
|
|
}
|
|
if (d->via == INVALID_STATION && candidate_via == (StationID)order->GetDestination()) {
|
|
d->via = (StationID)order->GetDestination();
|
|
}
|
|
d->terminus = c;
|
|
d->calling_at.push_back(c);
|
|
}
|
|
|
|
/* If we unload all at this station, then it is the terminus. */
|
|
if (order->GetType() == OT_GOTO_STATION &&
|
|
order->GetUnloadType() == OUFB_UNLOAD) {
|
|
if (d->calling_at.size() > 0) {
|
|
found_terminus = true;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (c.scheduled_tick != 0) c.scheduled_tick += order->GetWaitTime();
|
|
|
|
/* Get the next order, which may be the vehicle's first order. */
|
|
order = (order->next == nullptr) ? least_order->v->GetFirstOrder() : order->next;
|
|
}
|
|
|
|
if (found_terminus) {
|
|
/* Add the departure to the result list. */
|
|
bool duplicate = false;
|
|
|
|
if (_settings_client.gui.departure_merge_identical) {
|
|
for (uint i = 0; i < result->size(); ++i) {
|
|
if (*d == *((*result)[i])) {
|
|
duplicate = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!duplicate) {
|
|
result->push_back(d);
|
|
|
|
if (_settings_client.gui.departure_smart_terminus && type == D_DEPARTURE) {
|
|
for (uint i = 0; i < result->size() - 1; ++i) {
|
|
Departure *d_first = (*result)[i];
|
|
uint k = (uint)d_first->calling_at.size() - 2;
|
|
uint j = (uint)d->calling_at.size();
|
|
while (j > 0) {
|
|
CallAt c = CallAt(d->calling_at[j - 1]);
|
|
|
|
if (d_first->terminus >= c && d_first->calling_at.size() >= 2) {
|
|
d_first->terminus = CallAt(d_first->calling_at[k]);
|
|
auto remove_via = [&](StationID st) {
|
|
if (d_first->via2 == st) d_first->via2 = INVALID_STATION;
|
|
if (d_first->via == st) {
|
|
d_first->via = d_first->via2;
|
|
d_first->via2 = INVALID_STATION;
|
|
}
|
|
};
|
|
remove_via(d_first->terminus.station);
|
|
for (const RemoveVia &rv : d_first->remove_vias) {
|
|
if (rv.calling_at_offset == k) {
|
|
remove_via(rv.via);
|
|
}
|
|
}
|
|
|
|
if (k == 0) break;
|
|
|
|
k--;
|
|
j = (uint)d->calling_at.size();
|
|
} else {
|
|
j--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* If the vehicle is expected to be late, we want to know what time it will arrive rather than depart. */
|
|
/* This is done because it looked silly to me to have a vehicle not be expected for another few days, yet it be at the same time pulling into the station. */
|
|
if (d->status != D_ARRIVED &&
|
|
d->lateness > 0) {
|
|
d->lateness -= least_order->order->GetWaitTime();
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
/* Computing arrivals: */
|
|
/* First we need to find the origin of the order. This is somewhat like finding a terminus, but a little more involved since order lists are singly linked. */
|
|
/* The next stage is simpler. We just need to add all the stations called at on the way to the current station. */
|
|
/* Again, we define a station as being called at if the vehicle loads from it. */
|
|
|
|
/* However, the very first thing we do is use the arrival time as the scheduled time instead of the departure time. */
|
|
d->scheduled_tick -= d->scheduled_waiting_time > 0 ? d->scheduled_waiting_time : order->GetWaitTime();
|
|
|
|
const Order *candidate_origin = (order->next == nullptr) ? least_order->v->GetFirstOrder() : order->next;
|
|
bool found_origin = false;
|
|
|
|
while (candidate_origin != least_order->order) {
|
|
if ((candidate_origin->GetLoadType() != OLFB_NO_LOAD ||
|
|
_settings_client.gui.departure_show_all_stops) &&
|
|
(candidate_origin->GetType() == OT_GOTO_STATION ||
|
|
candidate_origin->GetType() == OT_IMPLICIT) &&
|
|
candidate_origin->GetDestination() != station &&
|
|
(candidate_origin->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION) == 0) {
|
|
const Order *o = (candidate_origin->next == nullptr) ? least_order->v->GetFirstOrder() : candidate_origin->next;
|
|
bool found_collision = false;
|
|
|
|
/* Check if the candidate origin's destination appears again before the original order or the station does. */
|
|
while (o != least_order->order) {
|
|
if (o->GetUnloadType() == OUFB_UNLOAD) {
|
|
found_collision = true;
|
|
break;
|
|
}
|
|
|
|
if ((o->GetType() == OT_GOTO_STATION ||
|
|
o->GetType() == OT_IMPLICIT) &&
|
|
(o->GetDestination() == candidate_origin->GetDestination() ||
|
|
o->GetDestination() == station) &&
|
|
(o->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION) == 0) {
|
|
found_collision = true;
|
|
break;
|
|
}
|
|
|
|
o = (o->next == nullptr) ? least_order->v->GetFirstOrder() : o->next;
|
|
}
|
|
|
|
/* If it doesn't, then we have found the origin. */
|
|
if (!found_collision) {
|
|
found_origin = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
candidate_origin = (candidate_origin->next == nullptr) ? least_order->v->GetFirstOrder() : candidate_origin->next;
|
|
}
|
|
|
|
order = (candidate_origin->next == nullptr) ? least_order->v->GetFirstOrder() : candidate_origin->next;
|
|
|
|
while (order != least_order->order) {
|
|
if (order->GetType() == OT_GOTO_STATION &&
|
|
(order->GetLoadType() != OLFB_NO_LOAD ||
|
|
_settings_client.gui.departure_show_all_stops) &&
|
|
(order->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION) == 0) {
|
|
d->calling_at.push_back(CallAt((StationID)order->GetDestination()));
|
|
}
|
|
|
|
order = (order->next == nullptr) ? least_order->v->GetFirstOrder() : order->next;
|
|
}
|
|
|
|
d->terminus = CallAt((StationID)candidate_origin->GetDestination());
|
|
|
|
if (found_origin) {
|
|
bool duplicate = false;
|
|
|
|
if (_settings_client.gui.departure_merge_identical) {
|
|
for (uint i = 0; i < result->size(); ++i) {
|
|
if (*d == *((*result)[i])) {
|
|
duplicate = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!duplicate) {
|
|
result->push_back(d);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Save on pointer dereferences in the coming loop. */
|
|
order = least_order->order;
|
|
|
|
/* Now we find the next suitable order for being a departure for this vehicle. */
|
|
/* We do this in a similar way to finding the first suitable order for the vehicle. */
|
|
|
|
/* Go to the next order so we don't add the current order again. */
|
|
order = (order->next == nullptr) ? least_order->v->GetFirstOrder() : order->next;
|
|
if (VehicleSetNextDepartureTime(&least_order->expected_tick, &least_order->scheduled_waiting_time, state_ticks_base, least_order->v, order, false, schdispatch_last_planned_dispatch)) {
|
|
least_order->lateness = 0;
|
|
}
|
|
|
|
/* Go through the order list to find the next candidate departure. */
|
|
/* We only need to consider each order at most once. */
|
|
bool found_next_order = false;
|
|
bool require_travel_time = true;
|
|
for (int i = least_order->v->GetNumOrders(); i > 0; --i) {
|
|
/* If the order is a conditional branch, handle it. */
|
|
if (order->IsType(OT_CONDITIONAL)) {
|
|
switch(GetDepartureConditionalOrderMode(order, least_order->v, least_order->expected_tick)) {
|
|
case 0: {
|
|
/* Give up */
|
|
break;
|
|
}
|
|
case 1: {
|
|
/* Take the branch */
|
|
order = least_order->v->GetOrder(order->GetConditionSkipToOrder());
|
|
if (order == nullptr) {
|
|
break;
|
|
}
|
|
|
|
least_order->expected_tick -= order->GetTravelTime(); /* Added in next VehicleSetNextDepartureTime */
|
|
if (VehicleSetNextDepartureTime(&least_order->expected_tick, &least_order->scheduled_waiting_time, state_ticks_base, least_order->v, order, false, schdispatch_last_planned_dispatch)) {
|
|
least_order->lateness = 0;
|
|
}
|
|
require_travel_time = false;
|
|
continue;
|
|
}
|
|
case 2: {
|
|
/* Do not take the branch */
|
|
least_order->expected_tick -= order->GetWaitTime(); /* Added previously in VehicleSetNextDepartureTime */
|
|
order = (order->next == nullptr) ? least_order->v->GetFirstOrder() : order->next;
|
|
if (VehicleSetNextDepartureTime(&least_order->expected_tick, &least_order->scheduled_waiting_time, state_ticks_base, least_order->v, order, false, schdispatch_last_planned_dispatch)) {
|
|
least_order->lateness = 0;
|
|
}
|
|
require_travel_time = true;
|
|
continue;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
/* If an order has a 0 travel time, and it's not explictly set, then stop. */
|
|
if (require_travel_time && order->GetTravelTime() == 0 && !order->IsTravelTimetabled() && !order->IsType(OT_IMPLICIT)) {
|
|
break;
|
|
}
|
|
|
|
/* If the departure is scheduled to be too late, then stop. */
|
|
if (least_order->expected_tick - least_order->lateness > max_ticks) {
|
|
break;
|
|
}
|
|
|
|
/* If the order loads from this station (or unloads if we're computing arrivals) and has a wait time set, then it is suitable for being a departure. */
|
|
if ((type == D_DEPARTURE && IsDeparture(order, station)) ||
|
|
(type == D_DEPARTURE && show_vehicles_via && IsVia(order, station)) ||
|
|
(type == D_ARRIVAL && IsArrival(order, station))) {
|
|
least_order->order = order;
|
|
found_next_order = true;
|
|
break;
|
|
}
|
|
|
|
order = (order->next == nullptr) ? least_order->v->GetFirstOrder() : order->next;
|
|
if (VehicleSetNextDepartureTime(&least_order->expected_tick, &least_order->scheduled_waiting_time, state_ticks_base, least_order->v, order, false, schdispatch_last_planned_dispatch)) {
|
|
least_order->lateness = 0;
|
|
}
|
|
require_travel_time = true;
|
|
}
|
|
|
|
/* If we didn't find a suitable order for being a departure, then we can ignore this vehicle from now on. */
|
|
if (!found_next_order) {
|
|
/* Make sure we don't try to get departures out of this order. */
|
|
/* This is cheaper than deleting it from next_orders. */
|
|
/* If we ever get to a state where _date * DAY_TICKS is close to INT_MAX, then we'll have other problems anyway as departures' scheduled dates will wrap around. */
|
|
least_order->expected_tick = INT32_MAX;
|
|
}
|
|
|
|
/* The vehicle can't possibly have arrived at its next candidate departure yet. */
|
|
if (least_order->status == D_ARRIVED) {
|
|
least_order->status = D_TRAVELLING;
|
|
}
|
|
|
|
/* Find the new least order. */
|
|
for (uint i = 0; i < next_orders.size(); ++i) {
|
|
OrderDate *od = next_orders[i];
|
|
|
|
Ticks lod = least_order->expected_tick - least_order->lateness;
|
|
Ticks odd = od->expected_tick - od->lateness;
|
|
|
|
if (type == D_ARRIVAL) {
|
|
lod -= least_order->scheduled_waiting_time > 0 ? least_order->scheduled_waiting_time : least_order->order->GetWaitTime();
|
|
odd -= od->scheduled_waiting_time > 0 ? od->scheduled_waiting_time : od->order->GetWaitTime();
|
|
}
|
|
|
|
if (lod > odd && od->expected_tick - od->lateness < max_ticks) {
|
|
least_order = od;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Avoid leaking OrderDate structs */
|
|
for (uint i = 0; i < next_orders.size(); ++i) {
|
|
OrderDate *od = next_orders[i];
|
|
delete od;
|
|
}
|
|
|
|
if (type == D_DEPARTURE) ScheduledDispatchDepartureLocalFix(result);
|
|
|
|
/* Done. Phew! */
|
|
return result;
|
|
}
|
|
|
|
Ticks GetDeparturesMaxTicksAhead()
|
|
{
|
|
if (_settings_time.time_in_minutes) {
|
|
return _settings_client.gui.max_departure_time_minutes * _settings_time.ticks_per_minute;
|
|
} else {
|
|
return _settings_client.gui.max_departure_time * DAY_TICKS * DayLengthFactor();
|
|
}
|
|
}
|