openttd-ottdgrfs: comparison src/order

equal deleted inserted replaced

-:3998f2e73dda
+:6404afe43575
 #include "functions.h"
 #include "window_func.h"
 #include "settings_type.h"
 #include "string_func.h"
 #include "newgrf_cargo.h"
+#include "timetable.h"
+#include "vehicle_func.h"
 #include "table/strings.h"
 /* DestinationID must be at least as large as every these below, because it can
 * be any of them
 TileIndex _backup_orders_tile;
 BackuppedOrders _backup_orders_data;
 DEFINE_OLD_POOL_GENERIC(Order, Order)
+void Order::Free()
+{
+	this->type  = OT_NOTHING;
+	this->flags = 0;
+	this->dest  = 0;
+	this->next  = NULL;
+}
+void Order::MakeGoToStation(StationID destination)
+{
+	this->type = OT_GOTO_STATION;
+	this->flags = 0;
+	this->dest = destination;
+}
+void Order::MakeGoToDepot(DepotID destination, bool order, CargoID cargo, byte subtype)
+{
+	this->type = OT_GOTO_DEPOT;
+	this->flags = order ? OFB_PART_OF_ORDERS : OFB_NON_STOP;
+	this->dest = destination;
+	this->SetRefit(cargo, subtype);
+}
+void Order::MakeGoToWaypoint(WaypointID destination)
+{
+	this->type = OT_GOTO_WAYPOINT;
+	this->flags = 0;
+	this->dest = destination;
+}
+void Order::MakeLoading(bool ordered)
+{
+	this->type = OT_LOADING;
+	if (!ordered) this->flags = 0;
+}
+void Order::MakeLeaveStation()
+{
+	this->type = OT_LEAVESTATION;
+	this->flags = 0;
+}
+void Order::MakeDummy()
+{
+	this->type = OT_DUMMY;
+	this->flags = 0;
+}
+void Order::SetRefit(CargoID cargo, byte subtype)
+{
+	this->refit_cargo = cargo;
+	this->refit_subtype = subtype;
+}
+void Order::FreeChain()
+{
+	if (next != NULL) next->FreeChain();
+	delete this;
+}
+bool Order::Equals(const Order &other) const
+{
+	return
+			this->type  == other.type &&
+			this->flags == other.flags &&
+			this->dest  == other.dest;
+}
+static bool HasOrderPoolFree(uint amount)
+{
+	const Order *order;
+	/* There is always room if not all blocks in the pool are reserved */
+	if (_Order_pool.CanAllocateMoreBlocks()) return true;
+	FOR_ALL_ORDERS(order) if (!order->IsValid() && --amount == 0) return true;
+	return false;
+}
+uint32 Order::Pack() const
+{
+	return this->dest << 16 | this->flags << 8 | this->type;
+}
+Order::Order(uint32 packed)
+{
+	this->type    = (OrderType)GB(packed,  0,  8);
+	this->flags   = GB(packed,  8,  8);
+	this->dest    = GB(packed, 16, 16);
+	this->next    = NULL;
+	this->index   = 0; // avoid compiler warning
+	this->refit_cargo   = CT_NO_REFIT;
+	this->refit_subtype = 0;
+	this->wait_time     = 0;
+	this->travel_time   = 0;
+}
+/**
+*
+* Unpacks a order from savegames with version 4 and lower
+*
+*/
+static Order UnpackVersion4Order(uint16 packed)
+{
+	return Order(GB(packed, 8, 8) << 16 | GB(packed, 4, 4) << 8 | GB(packed, 0, 4));
+}
 /**
 *
 * Unpacks a order from savegames made with TTD(Patch)
 *
 */
 Order UnpackOldOrder(uint16 packed)
 {
-	Order order;
+	Order order = UnpackVersion4Order(packed);
-	order.type    = (OrderType)GB(packed, 0, 4);
-	order.flags   = GB(packed, 4, 4);
+	/*
-	order.dest    = GB(packed, 8, 8);
+	 * Sanity check
-	order.next    = NULL;
+	 * TTD stores invalid orders as OT_NOTHING with non-zero flags/station
+	 */
-	order.refit_cargo   = CT_NO_REFIT;
+	if (!order.IsValid() && (order.GetLoadType() != 0 || order.GetUnloadType() != 0 || order.GetDestination() != 0)) {
-	order.refit_subtype = 0;
+		order.MakeDummy();
-	order.wait_time     = 0;
+	}
-	order.travel_time   = 0;
-	order.index = 0; // avoid compiler warning
-	// Sanity check
-	// TTD stores invalid orders as OT_NOTHING with non-zero flags/station
-	if (!order.IsValid() && (order.flags != 0 || order.dest != 0)) {
-		order.type = OT_DUMMY;
-		order.flags = 0;
-	}
-	return order;
-}
-/**
-*
-* Unpacks a order from savegames with version 4 and lower
-*
-*/
-static Order UnpackVersion4Order(uint16 packed)
-{
-	Order order;
-	order.type  = (OrderType)GB(packed, 0, 4);
-	order.flags = GB(packed, 4, 4);
-	order.dest  = GB(packed, 8, 8);
-	order.next  = NULL;
-	order.index = 0; // avoid compiler warning
-	order.refit_cargo   = CT_NO_REFIT;
-	order.refit_subtype = 0;
-	order.wait_time     = 0;
-	order.travel_time   = 0;
 	return order;
 }
 /**
 *
 static void SwapOrders(Order *order1, Order *order2)
 {
 	Order temp_order;
 	temp_order = *order1;
-	AssignOrder(order1, *order2);
+	order1->AssignOrder(*order2);
 	order1->next = order2->next;
-	AssignOrder(order2, temp_order);
+	order2->AssignOrder(temp_order);
 	order2->next = temp_order.next;
 }
 /**
 *
 * Assign data to an order (from an other order)
 *   This function makes sure that the index is maintained correctly
 *
 */
-void AssignOrder(Order *order, Order data)
+void Order::AssignOrder(const Order &other)
 {
-	order->type  = data.type;
+	this->type  = other.type;
-	order->flags = data.flags;
+	this->flags = other.flags;
-	order->dest  = data.dest;
+	this->dest  = other.dest;
-	order->refit_cargo   = data.refit_cargo;
+	this->refit_cargo   = other.refit_cargo;
-	order->refit_subtype = data.refit_subtype;
+	this->refit_subtype = other.refit_subtype;
-	order->wait_time   = data.wait_time;
+	this->wait_time   = other.wait_time;
-	order->travel_time = data.travel_time;
+	this->travel_time = other.travel_time;
 }
 /**
 * Delete all news items regarding defective orders about a vehicle
 }
 static TileIndex GetOrderLocation(const Order& o)
 {
-	switch (o.type) {
+	switch (o.GetType()) {
 		default: NOT_REACHED();
-		case OT_GOTO_STATION: return GetStation(o.dest)->xy;
+		case OT_GOTO_STATION: return GetStation(o.GetDestination())->xy;
-		case OT_GOTO_DEPOT:   return GetDepot(o.dest)->xy;
+		case OT_GOTO_DEPOT:   return GetDepot(o.GetDestination())->xy;
 	}
 }
 /** Add an order to the orderlist of a vehicle.
 CommandCost CmdInsertOrder(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	Vehicle *v;
 	VehicleID veh   = GB(p1,  0, 16);
 	VehicleOrderID sel_ord = GB(p1, 16, 16);
-	Order new_order = UnpackOrder(p2);
+	Order new_order(p2);
 	if (!IsValidVehicleID(veh)) return CMD_ERROR;
 	v = GetVehicle(veh);
 	if (!CheckOwnership(v->owner)) return CMD_ERROR;
 	/* Check if the inserted order is to the correct destination (owner, type),
 	 * and has the correct flags if any */
-	switch (new_order.type) {
+	switch (new_order.GetType()) {
 		case OT_GOTO_STATION: {
-			const Station *st;
+			if (!IsValidStationID(new_order.GetDestination())) return CMD_ERROR;
-			if (!IsValidStationID(new_order.dest)) return CMD_ERROR;
+			const Station *st = GetStation(new_order.GetDestination());
-			st = GetStation(new_order.dest);
 			if (st->owner != OWNER_NONE && !CheckOwnership(st->owner)) {
 				return CMD_ERROR;
 			}
 					break;
 				default: return CMD_ERROR;
 			}
+			if (new_order.GetNonStopType() != OFB_NO_NON_STOP && v->type != VEH_TRAIN) return CMD_ERROR;
 			/* Order flags can be any of the following for stations:
 			 * [full-load | unload] [+ transfer] [+ non-stop]
 			 * non-stop orders (if any) are only valid for trains */
-			switch (new_order.flags) {
+			switch (new_order.GetLoadType() | new_order.GetUnloadType()) {
 				case 0:
 				case OFB_FULL_LOAD:
 				case OFB_FULL_LOAD | OFB_TRANSFER:
 				case OFB_UNLOAD:
 				case OFB_UNLOAD | OFB_TRANSFER:
 				case OFB_TRANSFER:
 					break;
-				case OFB_NON_STOP:
-				case OFB_NON_STOP | OFB_FULL_LOAD:
-				case OFB_NON_STOP | OFB_FULL_LOAD | OFB_TRANSFER:
-				case OFB_NON_STOP | OFB_UNLOAD:
-				case OFB_NON_STOP | OFB_UNLOAD | OFB_TRANSFER:
-				case OFB_NON_STOP | OFB_TRANSFER:
-					if (v->type != VEH_TRAIN) return CMD_ERROR;
-					break;
 				default: return CMD_ERROR;
 			}
 			break;
 		}
 		case OT_GOTO_DEPOT: {
 			if (v->type == VEH_AIRCRAFT) {
-				const Station* st;
+				if (!IsValidStationID(new_order.GetDestination())) return CMD_ERROR;
-				if (!IsValidStationID(new_order.dest)) return CMD_ERROR;
+				const Station *st = GetStation(new_order.GetDestination());
-				st = GetStation(new_order.dest);
 				if (!CheckOwnership(st->owner) ||
 						!(st->facilities & FACIL_AIRPORT) ||
 						st->Airport()->nof_depots == 0 ||
 						!CanAircraftUseStation(v->engine_type, st)) {
 					return CMD_ERROR;
 				}
 			} else {
-				const Depot* dp;
+				if (!IsValidDepotID(new_order.GetDestination())) return CMD_ERROR;
-				if (!IsValidDepotID(new_order.dest)) return CMD_ERROR;
+				const Depot *dp = GetDepot(new_order.GetDestination());
-				dp = GetDepot(new_order.dest);
 				if (!CheckOwnership(GetTileOwner(dp->xy))) return CMD_ERROR;
 				switch (v->type) {
 					case VEH_TRAIN:
 					default: return CMD_ERROR;
 				}
 			}
+			if (new_order.GetNonStopType() != OFB_NO_NON_STOP && v->type != VEH_TRAIN) return CMD_ERROR;
 			/* Order flags can be any of the following for depots:
 			 * order [+ halt] [+ non-stop]
 			 * non-stop orders (if any) are only valid for trains */
-			switch (new_order.flags) {
+			switch (new_order.GetDepotOrderType() | new_order.GetDepotActionType()) {
 				case OFB_PART_OF_ORDERS:
 				case OFB_PART_OF_ORDERS | OFB_HALT_IN_DEPOT:
 					break;
-				case OFB_NON_STOP | OFB_PART_OF_ORDERS:
-				case OFB_NON_STOP | OFB_PART_OF_ORDERS | OFB_HALT_IN_DEPOT:
-					if (v->type != VEH_TRAIN) return CMD_ERROR;
-					break;
 				default: return CMD_ERROR;
 			}
 			break;
 		}
 		case OT_GOTO_WAYPOINT: {
-			const Waypoint* wp;
 			if (v->type != VEH_TRAIN) return CMD_ERROR;
-			if (!IsValidWaypointID(new_order.dest)) return CMD_ERROR;
+			if (!IsValidWaypointID(new_order.GetDestination())) return CMD_ERROR;
-			wp = GetWaypoint(new_order.dest);
+			const Waypoint *wp = GetWaypoint(new_order.GetDestination());
 			if (!CheckOwnership(GetTileOwner(wp->xy))) return CMD_ERROR;
 			/* Order flags can be any of the following for waypoints:
 			 * [non-stop]
 			 * non-stop orders (if any) are only valid for trains */
-			switch (new_order.flags) {
+			switch (new_order.GetNonStopType()) {
-				case 0: break;
+				case OFB_NO_NON_STOP: break;
 				case OFB_NON_STOP:
 					if (v->type != VEH_TRAIN) return CMD_ERROR;
 					break;
 		/* Find the last goto station or depot order before the insert location.
 		 * If the order is to be inserted at the beginning of the order list this
 		 * finds the last order in the list. */
 		for (const Order *o = v->orders; o != NULL; o = o->next) {
-			if (o->type == OT_GOTO_STATION || o->type == OT_GOTO_DEPOT) prev = o;
+			if (o->IsType(OT_GOTO_STATION) || o->IsType(OT_GOTO_DEPOT)) prev = o;
 			if (++n == sel_ord && prev != NULL) break;
 		}
 		if (prev != NULL) {
 			uint dist = DistanceManhattan(
 				GetOrderLocation(*prev),
 	}
 	if (flags & DC_EXEC) {
 		Vehicle *u;
 		Order *new_o = new Order();
-		AssignOrder(new_o, new_order);
+		new_o->AssignOrder(new_order);
 		/* Create new order and link in list */
 		if (v->orders == NULL) {
 			v->orders = new_o;
 		} else {
 			assert(v->orders == u->orders);
 			/* NON-stop flag is misused to see if a train is in a station that is
 			 * on his order list or not */
-			if (sel_ord == u->cur_order_index && u->current_order.type == OT_LOADING &&
+			if (sel_ord == u->cur_order_index && u->current_order.IsType(OT_LOADING)) {
-					HasBit(u->current_order.flags, OF_NON_STOP)) {
+				u->current_order.SetNonStopType(OFB_NO_NON_STOP);
-				u->current_order.flags = 0;
 			}
 			/* Update any possible open window of the vehicle */
 			InvalidateVehicleOrder(u);
 		}
 	if (flags & DC_EXEC) {
 		v->cur_order_index = sel_ord;
 		if (v->type == VEH_ROAD) ClearSlot(v);
-		if (v->current_order.type == OT_LOADING) {
+		if (v->current_order.IsType(OT_LOADING)) v->LeaveStation();
-			v->LeaveStation();
-			/* NON-stop flag is misused to see if a train is in a station that is
-			 * on his order list or not */
-			if (HasBit(v->current_order.flags, OF_NON_STOP)) v->current_order.flags = 0;
-		}
 		InvalidateVehicleOrder(v);
 	}
 	/* We have an aircraft/ship, they have a mini-schedule, so update them all */
 	/* Is it a valid order? */
 	if (sel_ord >= v->num_orders) return CMD_ERROR;
 	order = GetVehicleOrder(v, sel_ord);
-	if ((order->type != OT_GOTO_STATION  || GetStation(order->dest)->IsBuoy()) &&
+	if ((!order->IsType(OT_GOTO_STATION)  || GetStation(order->GetDestination())->IsBuoy()) &&
-			(order->type != OT_GOTO_DEPOT    || p2 == OF_UNLOAD) &&
+			(!order->IsType(OT_GOTO_DEPOT)    || p2 == OF_UNLOAD) &&
-			(order->type != OT_GOTO_WAYPOINT || p2 != OF_NON_STOP)) {
+			(!order->IsType(OT_GOTO_WAYPOINT) || p2 != OF_NON_STOP)) {
 		return CMD_ERROR;
 	}
 	if (flags & DC_EXEC) {
 		switch (p2) {
-		case OF_FULL_LOAD:
+			case OF_FULL_LOAD:
-			ToggleBit(order->flags, OF_FULL_LOAD);
+				if (order->IsType(OT_GOTO_DEPOT)) {
-			if (order->type != OT_GOTO_DEPOT) ClrBit(order->flags, OF_UNLOAD);
+					order->SetDepotOrderType(order->GetDepotOrderType() ^ OFB_SERVICE_IF_NEEDED);
-			break;
+				} else {
-		case OF_UNLOAD:
+					order->SetLoadType(order->GetUnloadType() ^ OFB_FULL_LOAD);
-			ToggleBit(order->flags, OF_UNLOAD);
+					order->SetUnloadType(order->GetUnloadType() & ~OFB_UNLOAD);
-			ClrBit(order->flags, OF_FULL_LOAD);
+				}
-			break;
+				break;
-		case OF_NON_STOP:
+			case OF_UNLOAD:
-			ToggleBit(order->flags, OF_NON_STOP);
+				order->SetUnloadType(order->GetUnloadType() ^ OFB_UNLOAD);
-			break;
+				order->SetLoadType(0);
-		case OF_TRANSFER:
+				break;
-			ToggleBit(order->flags, OF_TRANSFER);
+			case OF_NON_STOP:
-			break;
+				order->SetNonStopType(order->GetNonStopType() ^ OFB_NON_STOP);
-		default: NOT_REACHED();
+				break;
+			case OF_TRANSFER:
+				order->SetUnloadType(order->GetUnloadType() ^ OFB_TRANSFER);
+				break;
+			default: NOT_REACHED();
 		}
 		/* Update the windows and full load flags, also for vehicles that share the same order list */
 		{
 			Vehicle* u;
 				 * other cases for the OrderTypeByte the flags are not used,
 				 * so do not care and those orders should not be active
 				 * when this function is called.
 				 */
 				if (sel_ord == u->cur_order_index &&
-						u->current_order.type != OT_GOTO_DEPOT &&
+						!u->current_order.IsType(OT_GOTO_DEPOT) &&
-						HasBit(u->current_order.flags, OF_FULL_LOAD) != HasBit(order->flags, OF_FULL_LOAD)) {
+						u->current_order.GetLoadType() != order->GetLoadType()) {
-					ToggleBit(u->current_order.flags, OF_FULL_LOAD);
+					u->current_order.SetLoadType(order->GetLoadType());
 				}
 				InvalidateVehicleOrder(u);
 			}
 		}
 	}
 			if (src->type == VEH_ROAD) {
 				const Order *order;
 				TileIndex required_dst = INVALID_TILE;
 				FOR_VEHICLE_ORDERS(src, order) {
-					if (order->type == OT_GOTO_STATION) {
+					if (order->IsType(OT_GOTO_STATION)) {
-						const Station *st = GetStation(order->dest);
+						const Station *st = GetStation(order->GetDestination());
 						if (IsCargoInClass(dst->cargo_type, CC_PASSENGERS)) {
 							if (st->bus_stops != NULL) required_dst = st->bus_stops->xy;
 						} else {
 							if (st->truck_stops != NULL) required_dst = st->truck_stops->xy;
 						}
 				DeleteVehicleOrders(dst);
 				order_dst = &dst->orders;
 				FOR_VEHICLE_ORDERS(src, order) {
 					*order_dst = new Order();
-					AssignOrder(*order_dst, *order);
+					(*order_dst)->AssignOrder(*order);
 					order_dst = &(*order_dst)->next;
 				}
 				dst->num_orders = src->num_orders;
 	if (order == NULL) return CMD_ERROR;
 	if (flags & DC_EXEC) {
 		Vehicle *u;
-		order->refit_cargo = cargo;
+		order->SetRefit(cargo, subtype);
-		order->refit_subtype = subtype;
 		u = GetFirstVehicleFromSharedList(v);
 		for (; u != NULL; u = u->next_shared) {
 			/* Update any possible open window of the vehicle */
 			InvalidateVehicleOrder(u);
 			/* If the vehicle already got the current depot set as current order, then update current order as well */
-			if (u->cur_order_index == order_number && HasBit(u->current_order.flags, OF_PART_OF_ORDERS)) {
+			if (u->cur_order_index == order_number && HasBit(u->current_order.GetDepotOrderType(), OF_PART_OF_ORDERS)) {
-				u->current_order.refit_cargo = cargo;
+				u->current_order.SetRefit(cargo, subtype);
-				u->current_order.refit_subtype = subtype;
 			}
 		}
 	}
 	return CommandCost();
 		/* CMD_NO_TEST_IF_IN_NETWORK is used here, because CMD_INSERT_ORDER checks if the
 		 *  order number is one more than the current amount of orders, and because
 		 *  in network the commands are queued before send, the second insert always
 		 *  fails in test mode. By bypassing the test-mode, that no longer is a problem. */
 		for (uint i = 0; bak->order[i].IsValid(); i++) {
-			if (!DoCommandP(0, v->index + (i << 16), PackOrder(&bak->order[i]), NULL,
+			if (!DoCommandP(0, v->index + (i << 16), bak->order[i].Pack(), NULL,
 					CMD_INSERT_ORDER | CMD_NO_TEST_IF_IN_NETWORK)) {
 				break;
 			}
 			/* Copy timetable if enabled */
 		/* Check the order list */
 		n_st = 0;
 		FOR_VEHICLE_ORDERS(v, order) {
 			/* Dummy order? */
-			if (order->type == OT_DUMMY) {
+			if (order->IsType(OT_DUMMY)) {
 				problem_type = 1;
 				break;
 			}
 			/* Does station have a load-bay for this vehicle? */
-			if (order->type == OT_GOTO_STATION) {
+			if (order->IsType(OT_GOTO_STATION)) {
-				const Station* st = GetStation(order->dest);
+				const Station* st = GetStation(order->GetDestination());
 				TileIndex required_tile = GetStationTileForVehicle(v, st);
 				n_st++;
 				if (required_tile == 0) problem_type = 3;
 			}
 		/* Check if the last and the first order are the same */
 		if (v->num_orders > 1) {
 			const Order* last = GetLastVehicleOrder(v);
-			if (v->orders->type  == last->type &&
+			if (v->orders->Equals(*last)) {
-					v->orders->flags == last->flags &&
-					v->orders->dest  == last->dest) {
 				problem_type = 2;
 			}
 		}
 		/* Do we only have 1 station in our order list? */
 		if (v->last_station_visited == destination && type == OT_GOTO_STATION) {
 			v->last_station_visited = INVALID_STATION;
 		}
 		order = &v->current_order;
-		if ((v->type == VEH_AIRCRAFT && order->type == OT_GOTO_DEPOT ? OT_GOTO_STATION : order->type) == type &&
+		if ((v->type == VEH_AIRCRAFT && order->IsType(OT_GOTO_DEPOT) ? OT_GOTO_STATION : order->GetType()) == type &&
-				v->current_order.dest == destination) {
+				v->current_order.GetDestination() == destination) {
-			order->type = OT_DUMMY;
+			order->MakeDummy();
-			order->flags = 0;
 			InvalidateWindow(WC_VEHICLE_VIEW, v->index);
 		}
 		/* Clear the order from the order-list */
 		invalidate = false;
 		FOR_VEHICLE_ORDERS(v, order) {
-			if ((v->type == VEH_AIRCRAFT && order->type == OT_GOTO_DEPOT ? OT_GOTO_STATION : order->type) == type &&
+			if ((v->type == VEH_AIRCRAFT && order->IsType(OT_GOTO_DEPOT) ? OT_GOTO_STATION : order->GetType()) == type &&
-					order->dest == destination) {
+					order->GetDestination() == destination) {
-				order->type = OT_DUMMY;
+				order->MakeDummy();
-				order->flags = 0;
 				invalidate = true;
 			}
 		}
 		/* Only invalidate once, and if needed */
 bool VehicleHasDepotOrders(const Vehicle *v)
 {
 	const Order *order;
 	FOR_VEHICLE_ORDERS(v, order) {
-		if (order->type == OT_GOTO_DEPOT)
+		if (order->IsType(OT_GOTO_DEPOT))
 			return true;
 	}
 	return false;
 }
 Date GetServiceIntervalClamped(uint index)
 {
 	return (_patches.servint_ispercent) ? Clamp(index, MIN_SERVINT_PERCENT, MAX_SERVINT_PERCENT) : Clamp(index, MIN_SERVINT_DAYS, MAX_SERVINT_DAYS);
 }
 /**
 *
 * Check if a vehicle has any valid orders
 *
 * @return false if there are no valid orders
 *
 */
-bool CheckForValidOrders(const Vehicle* v)
+static bool CheckForValidOrders(const Vehicle *v)
 {
 	const Order *order;
-	FOR_VEHICLE_ORDERS(v, order) if (order->type != OT_DUMMY) return true;
+	FOR_VEHICLE_ORDERS(v, order) if (!order->IsType(OT_DUMMY)) return true;
 	return false;
+}
+/**
+* Handle the orders of a vehicle and determine the next place
+* to go to if needed.
+* @param v the vehicle to do this for.
+* @return true *if* the vehicle is eligible for reversing
+*              (basically only when leaving a station).
+*/
+bool ProcessOrders(Vehicle *v)
+{
+	switch (v->current_order.GetType()) {
+		case OT_GOTO_DEPOT:
+			/* Let a depot order in the orderlist interrupt. */
+			if (!(v->current_order.GetDepotOrderType() & OFB_PART_OF_ORDERS)) return false;
+			if ((v->current_order.GetDepotOrderType() & OFB_SERVICE_IF_NEEDED) && !VehicleNeedsService(v)) {
+				UpdateVehicleTimetable(v, true);
+				v->cur_order_index++;
+			}
+			break;
+		case OT_LOADING:
+			return false;
+		case OT_LEAVESTATION:
+			if (v->type != VEH_AIRCRAFT) return false;
+			break;
+		default: break;
+	}
+	/**
+	 * Reversing because of order change is allowed only just after leaving a
+	 * station (and the difficulty setting to allowed, of course)
+	 * this can be detected because only after OT_LEAVESTATION, current_order
+	 * will be reset to nothing. (That also happens if no order, but in that case
+	 * it won't hit the point in code where may_reverse is checked)
+	 */
+	bool may_reverse = v->current_order.IsType(OT_NOTHING);
+	/* Check if we've reached the waypoint? */
+	if (v->current_order.IsType(OT_GOTO_WAYPOINT) && v->tile == v->dest_tile) {
+		UpdateVehicleTimetable(v, true);
+		v->cur_order_index++;
+	}
+	/* Check if we've reached a non-stop station while TTDPatch nonstop is enabled.. */
+	if (_patches.new_nonstop &&
+			v->current_order.GetNonStopType() & OFB_NON_STOP &&
+			IsTileType(v->tile, MP_STATION) &&
+			v->current_order.GetDestination() == GetStationIndex(v->tile)) {
+		v->last_station_visited = v->current_order.GetDestination();
+		UpdateVehicleTimetable(v, true);
+		v->cur_order_index++;
+	}
+	/* Get the current order */
+	if (v->cur_order_index >= v->num_orders) v->cur_order_index = 0;
+	const Order *order = GetVehicleOrder(v, v->cur_order_index);
+	/* If no order, do nothing. */
+	if (order == NULL || (v->type == VEH_AIRCRAFT && order->IsType(OT_DUMMY) && !CheckForValidOrders(v))) {
+		if (v->type == VEH_AIRCRAFT) {
+			/* Aircraft do something vastly different here, so handle separately */
+			extern void HandleMissingAircraftOrders(Vehicle *v);
+			HandleMissingAircraftOrders(v);
+			return false;
+		}
+		v->current_order.Free();
+		v->dest_tile = 0;
+		if (v->type == VEH_ROAD) ClearSlot(v);
+		return false;
+	}
+	/* If it is unchanged, keep it. */
+	if (order->Equals(v->current_order) &&
+			(v->type != VEH_SHIP || !order->IsType(OT_GOTO_STATION) || GetStation(order->GetDestination())->dock_tile != 0)) {
+		return false;
+	}
+	/* Otherwise set it, and determine the destination tile. */
+	v->current_order = *order;
+	InvalidateVehicleOrder(v);
+	switch (v->type) {
+		default:
+			NOT_REACHED();
+		case VEH_ROAD:
+		case VEH_TRAIN:
+			break;
+		case VEH_AIRCRAFT:
+		case VEH_SHIP:
+			InvalidateWindowClasses(v->GetVehicleListWindowClass());
+			break;
+	}
+	switch (order->GetType()) {
+		case OT_GOTO_STATION:
+			v->dest_tile = v->GetOrderStationLocation(order->GetDestination());
+			break;
+		case OT_GOTO_DEPOT:
+			if (v->type != VEH_AIRCRAFT) v->dest_tile = GetDepot(order->GetDestination())->xy;
+			break;
+		case OT_GOTO_WAYPOINT:
+			v->dest_tile = GetWaypoint(order->GetDestination())->xy;
+			break;
+		default:
+			v->dest_tile = 0;
+			return false;
+	}
+	return may_reverse;
+}
+/**
+* Check whether the given vehicle should stop at the given station
+* based on this order and the non-stop settings.
+* @param v       the vehicle that might be stopping.
+* @param station the station to stop at.
+* @return true if the vehicle should stop.
+*/
+bool Order::ShouldStopAtStation(const Vehicle *v, StationID station) const
+{
+	return
+			v->last_station_visited != station && // Do stop only when we've not just been there
+			type == OT_GOTO_STATION &&            // Do stop only when going to a station
+			/* Finally do stop when the non-stop flag is not set, or when we should stop at
+			 * this station according to the new_nonstop setting. */
+			(!(this->flags & OFB_NON_STOP) || ((this->dest != station) == _patches.new_nonstop));
 }
 void InitializeOrders()
 {
 	_Order_pool.CleanPool();
 	_Order_pool.AddBlockToPool();
 	_backup_orders_tile = 0;
 }
+const SaveLoad *GetOrderDescription() {
 static const SaveLoad _order_desc[] = {
 	SLE_VAR(Order, type,  SLE_UINT8),
 	SLE_VAR(Order, flags, SLE_UINT8),
 	SLE_VAR(Order, dest,  SLE_UINT16),
 	SLE_REF(Order, next,  REF_ORDER),
 	/* Leftover from the minor savegame version stuff
 	 * We will never use those free bytes, but we have to keep this line to allow loading of old savegames */
 	SLE_CONDNULL(10, 5, 35),
 	SLE_END()
 };
+	return _order_desc;
+}
 static void Save_ORDR()
 {
 	Order *order;
 	FOR_ALL_ORDERS(order) {
 		SlSetArrayIndex(order->index);
-		SlObject(order, _order_desc);
+		SlObject(order, GetOrderDescription());
 	}
 }
 static void Load_ORDR()
 {
 			SlArray(orders, len, SLE_UINT16);
 			for (i = 0; i < len; ++i) {
 				Order *order = new (i) Order();
-				AssignOrder(order, UnpackVersion4Order(orders[i]));
+				order->AssignOrder(UnpackVersion4Order(orders[i]));
 			}
 			free(orders);
 		} else if (CheckSavegameVersionOldStyle(5, 2)) {
 			len /= sizeof(uint16);
 			uint16 *orders = MallocT<uint16>(len + 1);
 			SlArray(orders, len, SLE_UINT32);
 			for (i = 0; i < len; ++i) {
-				Order *order = new (i) Order();
+				new (i) Order(orders[i]);
-				AssignOrder(order, UnpackOrder(orders[i]));
 			}
 			free(orders);
 		}
 	} else {
 		int index;
 		while ((index = SlIterateArray()) != -1) {
 			Order *order = new (index) Order();
-			SlObject(order, _order_desc);
+			SlObject(order, GetOrderDescription());
 		}
 	}
 }
 extern const ChunkHandler _order_chunk_handlers[] = {

branch	noai
changeset 9869	6404afe43575
parent 9837	c9ec4f82e0d0
child 10142	56ee7da4ad56