OpenTTD-patches/src/departures.cpp

/*
 * 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         = INT64_MAX;
			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 the schedule */
			StateTicks earliest_departure = begin_time;
			if (ds.GetScheduledDispatchLastDispatch() != INVALID_SCHEDULED_DISPATCH_OFFSET) {
				earliest_departure += ds.GetScheduledDispatchLastDispatch();
			} else {
				earliest_departure--;
			}

			/* 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 > current_departure) {
					actual_departure = current_departure;
				}
			}

			if (actual_departure == INT64_MAX) {
				/* Failed to find a dispatch slot for this departure at all, the schedule is invalid/empty.
				 * Just treat it as a non-dispatch order. */
				*previous_departure += order->GetTravelTime() + order->GetWaitTime();
				*waiting_time = 0;
				return false;
			}

			*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();
	}
}