|
@@ -692,49 +692,49 @@ TileIndex Order::GetLocation(const Vehic
|
|
|
|
|
|
default:
|
|
|
return INVALID_TILE;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Get the distance between two orders of a vehicle. Conditional orders are resolved
|
|
|
* and the bigger distance of the two order branches is returned.
|
|
|
* @param prev Origin order.
|
|
|
* @param cur Destination order.
|
|
|
* @param v The vehicle to get the distance for.
|
|
|
* @param conditional_depth Internal param for resolving conditional orders.
|
|
|
* @return Maximum distance between the two orders.
|
|
|
*/
|
|
|
uint GetOrderDistance(const Order *prev, const Order *cur, const Vehicle *v, int conditional_depth)
|
|
|
{
|
|
|
if (cur->IsType(OT_CONDITIONAL)) {
|
|
|
if (conditional_depth > v->GetNumOrders()) return 0;
|
|
|
|
|
|
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);
|
|
|
return max(dist1, dist2);
|
|
|
return std::max(dist1, dist2);
|
|
|
}
|
|
|
|
|
|
TileIndex prev_tile = prev->GetLocation(v, true);
|
|
|
TileIndex cur_tile = cur->GetLocation(v, true);
|
|
|
if (prev_tile == INVALID_TILE || cur_tile == INVALID_TILE) return 0;
|
|
|
return v->type == VEH_AIRCRAFT ? DistanceSquare(prev_tile, cur_tile) : DistanceManhattan(prev_tile, cur_tile);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Add an order to the orderlist of a vehicle.
|
|
|
* @param tile unused
|
|
|
* @param flags operation to perform
|
|
|
* @param p1 various bitstuffed elements
|
|
|
* - p1 = (bit 0 - 19) - ID of the vehicle
|
|
|
* - p1 = (bit 24 - 31) - the selected order (if any). If the last order is given,
|
|
|
* the order will be inserted before that one
|
|
|
* the maximum vehicle order id is 254.
|
|
|
* @param p2 packed order to insert
|
|
|
* @param text unused
|
|
|
* @return the cost of this operation or an error
|
|
|
*/
|
|
|
CommandCost CmdInsertOrder(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
|
|
|
{
|
|
|
VehicleID veh = GB(p1, 0, 20);
|
|
@@ -1072,49 +1072,49 @@ void DeleteOrder(Vehicle *v, VehicleOrde
|
|
|
|
|
|
if (sel_ord < u->cur_implicit_order_index) {
|
|
|
u->cur_implicit_order_index--;
|
|
|
} else if (sel_ord == u->cur_implicit_order_index) {
|
|
|
/* Make sure the index is valid */
|
|
|
if (u->cur_implicit_order_index >= u->GetNumOrders()) u->cur_implicit_order_index = 0;
|
|
|
|
|
|
/* Skip non-implicit orders for the implicit-order-index (e.g. if the current implicit order was deleted */
|
|
|
while (u->cur_implicit_order_index != u->cur_real_order_index && !u->GetOrder(u->cur_implicit_order_index)->IsType(OT_IMPLICIT)) {
|
|
|
u->cur_implicit_order_index++;
|
|
|
if (u->cur_implicit_order_index >= u->GetNumOrders()) u->cur_implicit_order_index = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* Update any possible open window of the vehicle */
|
|
|
InvalidateVehicleOrder(u, sel_ord | (INVALID_VEH_ORDER_ID << 8));
|
|
|
}
|
|
|
|
|
|
/* As we delete an order, the order to skip to will be 'wrong'. */
|
|
|
VehicleOrderID cur_order_id = 0;
|
|
|
for (Order *order : v->Orders()) {
|
|
|
if (order->IsType(OT_CONDITIONAL)) {
|
|
|
VehicleOrderID order_id = order->GetConditionSkipToOrder();
|
|
|
if (order_id >= sel_ord) {
|
|
|
order_id = max(order_id - 1, 0);
|
|
|
order_id = std::max(order_id - 1, 0);
|
|
|
}
|
|
|
if (order_id == cur_order_id) {
|
|
|
order_id = (order_id + 1) % v->GetNumOrders();
|
|
|
}
|
|
|
order->SetConditionSkipToOrder(order_id);
|
|
|
}
|
|
|
cur_order_id++;
|
|
|
}
|
|
|
|
|
|
InvalidateWindowClassesData(GetWindowClassForVehicleType(v->type), 0);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Goto order of order-list.
|
|
|
* @param tile unused
|
|
|
* @param flags operation to perform
|
|
|
* @param p1 The ID of the vehicle which order is skipped
|
|
|
* @param p2 the selected order to which we want to skip
|
|
|
* @param text unused
|
|
|
* @return the cost of this operation or an error
|
|
|
*/
|
|
|
CommandCost CmdSkipToOrder(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
|
|
|
{
|
|
|
VehicleID veh_id = GB(p1, 0, 20);
|
|
@@ -1964,49 +1964,49 @@ static bool OrderConditionCompare(OrderC
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Process a conditional order and determine the next order.
|
|
|
* @param order the order the vehicle currently has
|
|
|
* @param v the vehicle to update
|
|
|
* @return index of next order to jump to, or INVALID_VEH_ORDER_ID to use the next order
|
|
|
*/
|
|
|
VehicleOrderID ProcessConditionalOrder(const Order *order, const Vehicle *v)
|
|
|
{
|
|
|
if (order->GetType() != OT_CONDITIONAL) return INVALID_VEH_ORDER_ID;
|
|
|
|
|
|
bool skip_order = false;
|
|
|
OrderConditionComparator occ = order->GetConditionComparator();
|
|
|
uint16 value = order->GetConditionValue();
|
|
|
|
|
|
switch (order->GetConditionVariable()) {
|
|
|
case OCV_LOAD_PERCENTAGE: skip_order = OrderConditionCompare(occ, CalcPercentVehicleFilled(v, nullptr), value); break;
|
|
|
case OCV_RELIABILITY: skip_order = OrderConditionCompare(occ, ToPercent16(v->reliability), value); break;
|
|
|
case OCV_MAX_RELIABILITY: skip_order = OrderConditionCompare(occ, ToPercent16(v->GetEngine()->reliability), value); break;
|
|
|
case OCV_MAX_SPEED: skip_order = OrderConditionCompare(occ, v->GetDisplayMaxSpeed() * 10 / 16, value); break;
|
|
|
case OCV_AGE: skip_order = OrderConditionCompare(occ, v->age / DAYS_IN_LEAP_YEAR, value); break;
|
|
|
case OCV_REQUIRES_SERVICE: skip_order = OrderConditionCompare(occ, v->NeedsServicing(), value); break;
|
|
|
case OCV_UNCONDITIONALLY: skip_order = true; break;
|
|
|
case OCV_REMAINING_LIFETIME: skip_order = OrderConditionCompare(occ, max(v->max_age - v->age + DAYS_IN_LEAP_YEAR - 1, 0) / DAYS_IN_LEAP_YEAR, value); break;
|
|
|
case OCV_REMAINING_LIFETIME: skip_order = OrderConditionCompare(occ, std::max(v->max_age - v->age + DAYS_IN_LEAP_YEAR - 1, 0) / DAYS_IN_LEAP_YEAR, value); break;
|
|
|
default: NOT_REACHED();
|
|
|
}
|
|
|
|
|
|
return skip_order ? order->GetConditionSkipToOrder() : (VehicleOrderID)INVALID_VEH_ORDER_ID;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Update the vehicle's destination tile from an order.
|
|
|
* @param order the order the vehicle currently has
|
|
|
* @param v the vehicle to update
|
|
|
* @param conditional_depth the depth (amount of steps) to go with conditional orders. This to prevent infinite loops.
|
|
|
* @param pbs_look_ahead Whether we are forecasting orders for pbs reservations in advance. If true, the order indices must not be modified.
|
|
|
*/
|
|
|
bool UpdateOrderDest(Vehicle *v, const Order *order, int conditional_depth, bool pbs_look_ahead)
|
|
|
{
|
|
|
if (conditional_depth > v->GetNumOrders()) {
|
|
|
v->current_order.Free();
|
|
|
v->SetDestTile(0);
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
switch (order->GetType()) {
|
|
|
case OT_GOTO_STATION:
|
|
|
v->SetDestTile(v->GetOrderStationLocation(order->GetDestination()));
|