petern/OpenTTD
1
0
Fork 0
forked from mirror/OpenTTD
Code Pull Requests Activity

(svn r22473) -Codechange: Automatic orders are better called implicit orders as no real order influencing path finding is added

Browse Source
This commit is contained in:
planetmaker
2011-05-18 12:19:58 +00:00
parent bc6b348e7a
commit 43c8cd1d5e
65 changed files with 207 additions and 207 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
src/order_cmd.cpp
View File

@@ -134,12 +134,12 @@ void Order::MakeConditional(VehicleOrderID order)
}
/**
* Makes this order an automatic order.
* Makes this order an implicit order.
* @param destination the station to go to.
*/
void Order::MakeAutomatic(StationID destination)
void Order::MakeImplicit(StationID destination)
{
this->type = OT_AUTOMATIC;
this->type = OT_IMPLICIT;
this->dest = destination;
}
@@ -288,7 +288,7 @@ void OrderList::Initialize(Order *chain, Vehicle *v)
for (Order *o = this->first; o != NULL; o = o->next) {
++this->num_orders;
if (!o->IsType(OT_AUTOMATIC)) ++this->num_manual_orders;
if (!o->IsType(OT_IMPLICIT)) ++this->num_manual_orders;
this->timetable_duration += o->wait_time + o->travel_time;
}
@@ -365,7 +365,7 @@ void OrderList::InsertOrderAt(Order *new_order, int index)
}
}
++this->num_orders;
if (!new_order->IsType(OT_AUTOMATIC)) ++this->num_manual_orders;
if (!new_order->IsType(OT_IMPLICIT)) ++this->num_manual_orders;
this->timetable_duration += new_order->wait_time + new_order->travel_time;
}
@@ -389,7 +389,7 @@ void OrderList::DeleteOrderAt(int index)
prev->next = to_remove->next;
}
--this->num_orders;
if (!to_remove->IsType(OT_AUTOMATIC)) --this->num_manual_orders;
if (!to_remove->IsType(OT_IMPLICIT)) --this->num_manual_orders;
this->timetable_duration -= (to_remove->wait_time + to_remove->travel_time);
delete to_remove;
}
@@ -469,8 +469,8 @@ int OrderList::GetPositionInSharedOrderList(const Vehicle *v) const
bool OrderList::IsCompleteTimetable() const
{
for (Order *o = this->first; o != NULL; o = o->next) {
/* Automatic orders are, by definition, not timetabled. */
if (o->IsType(OT_AUTOMATIC)) continue;
/* Implicit orders are, by definition, not timetabled. */
if (o->IsType(OT_IMPLICIT)) continue;
if (!o->IsCompletelyTimetabled()) return false;
}
return true;
@@ -490,7 +490,7 @@ void OrderList::DebugCheckSanity() const
for (const Order *o = this->first; o != NULL; o = o->next) {
++check_num_orders;
if (!o->IsType(OT_AUTOMATIC)) ++check_num_manual_orders;
if (!o->IsType(OT_IMPLICIT)) ++check_num_manual_orders;
check_timetable_duration += o->wait_time + o->travel_time;
}
assert(this->num_orders == check_num_orders);
@@ -544,7 +544,7 @@ TileIndex Order::GetLocation(const Vehicle *v) const
switch (this->GetType()) {
case OT_GOTO_WAYPOINT:
case OT_GOTO_STATION:
case OT_AUTOMATIC:
case OT_IMPLICIT:
return BaseStation::Get(this->GetDestination())->xy;
case OT_GOTO_DEPOT:
@@ -820,8 +820,8 @@ void InsertOrder(Vehicle *v, Order *new_o, VehicleOrderID sel_ord)
assert(v->orders.list == u->orders.list);
/* If there is added an order before the current one, we need
* to update the selected order. We do not change automatic/real order indices though.
* If the new order is between the current auto order and real order, the auto order will
* to update the selected order. We do not change implicit/real order indices though.
* If the new order is between the current implicit order and real order, the implicit order will
* later skip the inserted order. */
if (sel_ord <= u->cur_real_order_index) {
uint cur = u->cur_real_order_index + 1;
@@ -830,18 +830,18 @@ void InsertOrder(Vehicle *v, Order *new_o, VehicleOrderID sel_ord)
u->cur_real_order_index = cur;
}
}
if (sel_ord == u->cur_auto_order_index && u->IsGroundVehicle()) {
/* We are inserting an order just before the current automatic order.
* We do not know whether we will reach current automatic or the newly inserted order first.
* So, disable creation of automatic orders until we are on track again. */
if (sel_ord == u->cur_implicit_order_index && u->IsGroundVehicle()) {
/* We are inserting an order just before the current implicit order.
* We do not know whether we will reach current implicit or the newly inserted order first.
* So, disable creation of implicit orders until we are on track again. */
uint16 &gv_flags = u->GetGroundVehicleFlags();
SetBit(gv_flags, GVF_SUPPRESS_AUTOMATIC_ORDERS);
SetBit(gv_flags, GVF_SUPPRESS_IMPLICIT_ORDERS);
}
if (sel_ord <= u->cur_auto_order_index) {
uint cur = u->cur_auto_order_index + 1;
if (sel_ord <= u->cur_implicit_order_index) {
uint cur = u->cur_implicit_order_index + 1;
/* Check if we don't go out of bound */
if (cur < u->GetNumOrders()) {
u->cur_auto_order_index = cur;
u->cur_implicit_order_index = cur;
}
}
/* Update any possible open window of the vehicle */
@@ -952,16 +952,16 @@ void DeleteOrder(Vehicle *v, VehicleOrderID sel_ord)
u->UpdateRealOrderIndex();
}
if (sel_ord < u->cur_auto_order_index) {
u->cur_auto_order_index--;
} else if (sel_ord == u->cur_auto_order_index) {
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_auto_order_index >= u->GetNumOrders()) u->cur_auto_order_index = 0;
if (u->cur_implicit_order_index >= u->GetNumOrders()) u->cur_implicit_order_index = 0;
/* Skip non-automatic orders for the auto-order-index (e.g. if the current auto order was deleted */
while (u->cur_auto_order_index != u->cur_real_order_index && !u->GetOrder(u->cur_auto_order_index)->IsType(OT_AUTOMATIC)) {
u->cur_auto_order_index++;
if (u->cur_auto_order_index >= u->GetNumOrders()) u->cur_auto_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;
}
}
@@ -1005,13 +1005,13 @@ CommandCost CmdSkipToOrder(TileIndex tile, DoCommandFlag flags, uint32 p1, uint3
Vehicle *v = Vehicle::GetIfValid(veh_id);
if (v == NULL || !v->IsPrimaryVehicle() || sel_ord == v->cur_auto_order_index || sel_ord >= v->GetNumOrders() || v->GetNumOrders() < 2) return CMD_ERROR;
if (v == NULL || !v->IsPrimaryVehicle() || sel_ord == v->cur_implicit_order_index || sel_ord >= v->GetNumOrders() || v->GetNumOrders() < 2) return CMD_ERROR;
CommandCost ret = CheckOwnership(v->owner);
if (ret.Failed()) return ret;
if (flags & DC_EXEC) {
v->cur_auto_order_index = v->cur_real_order_index = sel_ord;
v->cur_implicit_order_index = v->cur_real_order_index = sel_ord;
v->UpdateRealOrderIndex();
if (v->current_order.IsType(OT_LOADING)) v->LeaveStation();
@@ -1069,7 +1069,7 @@ CommandCost CmdMoveOrder(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32
for (; u != NULL; u = u->NextShared()) {
/* Update the current order.
* There are multiple ways to move orders, which result in cur_auto_order_index
* There are multiple ways to move orders, which result in cur_implicit_order_index
* and cur_real_order_index to not longer make any sense. E.g. moving another
* real order between them.
*
@@ -1079,10 +1079,10 @@ CommandCost CmdMoveOrder(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32
* However, from an AI point of view, preserving cur_real_order_index is the most
* predictable and transparent behaviour.
*
* With that decision it basically does not matter what we do to cur_auto_order_index.
* If we change orders between the auto- and real-index, the auto orders are mostly likely
* completely out-dated anyway. So, keep it simple and just keep cur_auto_order_index as well.
* The worst which can happen is that a lot of automatic orders are removed when reaching current_order.
* With that decision it basically does not matter what we do to cur_implicit_order_index.
* If we change orders between the implict- and real-index, the implicit orders are mostly likely
* completely out-dated anyway. So, keep it simple and just keep cur_implicit_order_index as well.
* The worst which can happen is that a lot of implicit orders are removed when reaching current_order.
*/
if (u->cur_real_order_index == moving_order) {
u->cur_real_order_index = target_order;
@@ -1092,12 +1092,12 @@ CommandCost CmdMoveOrder(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32
u->cur_real_order_index++;
}
if (u->cur_auto_order_index == moving_order) {
u->cur_auto_order_index = target_order;
} else if (u->cur_auto_order_index > moving_order && u->cur_auto_order_index <= target_order) {
u->cur_auto_order_index--;
} else if (u->cur_auto_order_index < moving_order && u->cur_auto_order_index >= target_order) {
u->cur_auto_order_index++;
if (u->cur_implicit_order_index == moving_order) {
u->cur_implicit_order_index = target_order;
} else if (u->cur_implicit_order_index > moving_order && u->cur_implicit_order_index <= target_order) {
u->cur_implicit_order_index--;
} else if (u->cur_implicit_order_index < moving_order && u->cur_implicit_order_index >= target_order) {
u->cur_implicit_order_index++;
}
assert(v->orders.list == u->orders.list);
@@ -1650,12 +1650,12 @@ restart:
OrderType ot = order->GetType();
if (ot == OT_GOTO_DEPOT && (order->GetDepotActionType() & ODATFB_NEAREST_DEPOT) != 0) continue;
if (ot == OT_AUTOMATIC || (v->type == VEH_AIRCRAFT && ot == OT_GOTO_DEPOT)) ot = OT_GOTO_STATION;
if (ot == OT_IMPLICIT || (v->type == VEH_AIRCRAFT && ot == OT_GOTO_DEPOT)) ot = OT_GOTO_STATION;
if (ot == type && order->GetDestination() == destination) {
/* We want to clear automatic orders, but we don't want to make them
/* We want to clear implicit orders, but we don't want to make them
* dummy orders. They should just vanish. Also check the actual order
* type as ot is currently OT_GOTO_STATION. */
if (order->IsType(OT_AUTOMATIC)) {
if (order->IsType(OT_IMPLICIT)) {
order = order->next; // DeleteOrder() invalidates current order
DeleteOrder(v, id);
if (order != NULL) goto restart;
@@ -1692,7 +1692,7 @@ bool Vehicle::HasDepotOrder() const
* Delete all orders from a vehicle
* @param v Vehicle whose orders to reset
* @param keep_orderlist If true, do not free the order list, only empty it.
* @param reset_order_indices If true, reset cur_auto_order_index and cur_real_order_index
* @param reset_order_indices If true, reset cur_implicit_order_index and cur_real_order_index
* and cancel the current full load order (if the vehicle is loading).
* If false, _you_ have to make sure the order indices are valid after
* your messing with them!
@@ -1712,7 +1712,7 @@ void DeleteVehicleOrders(Vehicle *v, bool keep_orderlist, bool reset_order_indic
}
if (reset_order_indices) {
v->cur_auto_order_index = v->cur_real_order_index = 0;
v->cur_implicit_order_index = v->cur_real_order_index = 0;
if (v->current_order.IsType(OT_LOADING)) {
CancelLoadingDueToDeletedOrder(v);
}
@@ -1866,18 +1866,18 @@ bool UpdateOrderDest(Vehicle *v, const Order *order, int conditional_depth)
case OT_CONDITIONAL: {
VehicleOrderID next_order = ProcessConditionalOrder(order, v);
if (next_order != INVALID_VEH_ORDER_ID) {
/* Jump to next_order. cur_auto_order_index becomes exactly that order,
/* Jump to next_order. cur_implicit_order_index becomes exactly that order,
* cur_real_order_index might come after next_order. */
UpdateVehicleTimetable(v, false);
v->cur_auto_order_index = v->cur_real_order_index = next_order;
v->cur_implicit_order_index = v->cur_real_order_index = next_order;
v->UpdateRealOrderIndex();
v->current_order_time += v->GetOrder(v->cur_real_order_index)->travel_time;
/* Disable creation of automatic orders.
/* Disable creation of implicit orders.
* When inserting them we do not know that we would have to make the conditional orders point to them. */
if (v->IsGroundVehicle()) {
uint16 &gv_flags = v->GetGroundVehicleFlags();
SetBit(gv_flags, GVF_SUPPRESS_AUTOMATIC_ORDERS);
SetBit(gv_flags, GVF_SUPPRESS_IMPLICIT_ORDERS);
}
} else {
UpdateVehicleTimetable(v, true);
@@ -1891,12 +1891,12 @@ bool UpdateOrderDest(Vehicle *v, const Order *order, int conditional_depth)
return false;
}
assert(v->cur_auto_order_index < v->GetNumOrders());
assert(v->cur_implicit_order_index < v->GetNumOrders());
assert(v->cur_real_order_index < v->GetNumOrders());
/* Get the current order */
order = v->GetOrder(v->cur_real_order_index);
if (order != NULL && order->IsType(OT_AUTOMATIC)) {
if (order != NULL && order->IsType(OT_IMPLICIT)) {
assert(v->GetNumManualOrders() == 0);
order = NULL;
}
@@ -1949,22 +1949,22 @@ bool ProcessOrders(Vehicle *v)
if (((v->current_order.IsType(OT_GOTO_STATION) && (v->current_order.GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION)) || v->current_order.IsType(OT_GOTO_WAYPOINT)) &&
IsTileType(v->tile, MP_STATION) &&
v->current_order.GetDestination() == GetStationIndex(v->tile)) {
v->DeleteUnreachedAutoOrders();
v->DeleteUnreachedImplicitOrders();
/* We set the last visited station here because we do not want
* the train to stop at this 'via' station if the next order
* is a no-non-stop order; in that case not setting the last
* visited station will cause the vehicle to still stop. */
v->last_station_visited = v->current_order.GetDestination();
UpdateVehicleTimetable(v, true);
v->IncrementAutoOrderIndex();
v->IncrementImplicitOrderIndex();
}
/* Get the current order */
assert(v->cur_auto_order_index == 0 || v->cur_auto_order_index < v->GetNumOrders());
assert(v->cur_implicit_order_index == 0 || v->cur_implicit_order_index < v->GetNumOrders());
v->UpdateRealOrderIndex();
const Order *order = v->GetOrder(v->cur_real_order_index);
if (order != NULL && order->IsType(OT_AUTOMATIC)) {
if (order != NULL && order->IsType(OT_IMPLICIT)) {
assert(v->GetNumManualOrders() == 0);
order = NULL;
}