}

	VehicleServiceInDepot(v);

	SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos);

	InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);

	SetWindowClassesDirty(WC_AIRCRAFT_LIST);

		return;

	}

	if (!v->current_order.IsType(OT_GOTO_STATION) &&

			!v->current_order.IsType(OT_GOTO_DEPOT))

		return;

	}

	if (HasBit(src->vehicle_flags, VF_SERVINT_IS_CUSTOM)) SetBit(this->vehicle_flags, VF_SERVINT_IS_CUSTOM);

}

	TimerGameTick::Ticks lateness_counter;      ///< How many ticks late (or early if negative) this vehicle is.

	TimerGameTick::TickCounter timetable_start; ///< At what tick of TimerGameTick::counter the vehicle should start its timetable.

	uint16_t service_interval;            ///< The interval for (automatic) servicing; either in days or %.

	VehicleOrderID cur_real_order_index;///< The index to the current real (non-implicit) order

	virtual ~BaseConsist() = default;

	void CopyConsistPropertiesFrom(const BaseConsist *src);

};

#endif /* BASE_CONSIST_H */

# Messages in the start stop button in the vehicle view

STR_VEHICLE_STATUS_LOADING_UNLOADING                            :{LTBLUE}Loading / Unloading

STR_VEHICLE_STATUS_LEAVING                                      :{LTBLUE}Leaving

STR_VEHICLE_STATUS_CRASHED                                      :{RED}Crashed!

STR_VEHICLE_STATUS_BROKEN_DOWN                                  :{RED}Broken down

STR_VEHICLE_STATUS_STOPPED                                      :{RED}Stopped

STR_VEHICLE_STATUS_HEADING_FOR_WAYPOINT_VEL                     :{LTBLUE}Heading for {WAYPOINT}, {VELOCITY}

STR_VEHICLE_STATUS_HEADING_FOR_DEPOT_VEL                        :{ORANGE}Heading for {DEPOT}, {VELOCITY}

STR_VEHICLE_STATUS_HEADING_FOR_DEPOT_SERVICE_VEL                :{LTBLUE}Service at {DEPOT}, {VELOCITY}

STR_VEHICLE_STATUS_CANNOT_REACH_STATION_VEL                     :{LTBLUE}Cannot reach {STATION}, {VELOCITY}

STR_VEHICLE_STATUS_CANNOT_REACH_WAYPOINT_VEL                    :{LTBLUE}Cannot reach {WAYPOINT}, {VELOCITY}

STR_ORDERS_LIST_TOOLTIP                                         :{BLACK}Order list - click on an order to highlight it. Ctrl+Click to scroll to the order's destination

STR_ORDER_INDEX                                                 :{COMMA}:{NBSP}

STR_ORDERS_END_OF_ORDERS                                        :- - End of Orders - -

STR_ORDERS_END_OF_SHARED_ORDERS                                 :- - End of Shared Orders - -

STR_ORDER_DROP_REFIT_AUTO                                       :Fixed cargo

STR_ORDER_DROP_REFIT_AUTO_ANY                                   :Available cargo

STR_ORDER_DROP_GO_ALWAYS_DEPOT                                  :Always go

STR_ORDER_DROP_SERVICE_DEPOT                                    :Service if needed

STR_ORDER_DROP_HALT_DEPOT                                       :Stop

STR_ORDER_CONDITIONAL_VARIABLE_TOOLTIP                          :{BLACK}Vehicle data to base jumping on

STR_ORDER_REFIT_STOP_ORDER                                      :(Refit to {STRING} and stop)

STR_ORDER_STOP_ORDER                                            :(Stop)

STR_ORDER_GO_TO_STATION                                         :{STRING} {STATION} {STRING1}

STR_ORDER_GO_TO_STATION_CAN_T_USE_STATION                       :{PUSH_COLOUR}{RED}(Can't use station){POP_COLOUR} {STRING} {STATION} {STRING1}

STR_ERROR_DEPOT_WRONG_DEPOT_TYPE                                :Wrong depot type

# Autoreplace related errors

STR_ERROR_TRAIN_TOO_LONG_AFTER_REPLACEMENT                      :{WHITE}{VEHICLE} is too long after replacement

STR_ERROR_AUTOREPLACE_NOTHING_TO_DO                             :{WHITE}No autoreplace/renew rules applied

	/** What caused us going to the depot? */

	inline OrderDepotTypeFlags GetDepotOrderType() const { return (OrderDepotTypeFlags)GB(this->flags, 0, 3); }

	/** What are we going to do when in the depot. */

	/** What variable do we have to compare? */

	inline OrderConditionVariable GetConditionVariable() const { return (OrderConditionVariable)GB(this->dest, 11, 5); }

	/** What is the comparator to use? */

	/** Set the cause to go to the depot. */

	inline void SetDepotOrderType(OrderDepotTypeFlags depot_order_type) { SB(this->flags, 0, 3, depot_order_type); }

	/** Set what we are going to do in the depot. */

	/** Set variable we have to compare. */

	inline void SetConditionVariable(OrderConditionVariable condition_variable) { SB(this->dest, 11, 5, condition_variable); }

	/** Set the comparator to use. */

			/* Filter invalid load/unload types. */

			switch (new_order.GetLoadType()) {

			}

			switch (new_order.GetUnloadType()) {

				case OUF_UNLOAD_IF_POSSIBLE: case OUFB_UNLOAD: case OUFB_TRANSFER: case OUFB_NO_UNLOAD: break;

			VehicleOrderID skip_to = new_order.GetConditionSkipToOrder();

			if (skip_to != 0 && skip_to >= v->GetNumOrders()) return CMD_ERROR; // Always allow jumping to the first (even when there is no order).

			if (new_order.GetConditionVariable() >= OCV_END) return CMD_ERROR;

			OrderConditionComparator occ = new_order.GetConditionComparator();

			if (occ >= OCC_END) return CMD_ERROR;

				u->cur_implicit_order_index = cur;

			}

		}

		/* Update any possible open window of the vehicle */

		InvalidateVehicleOrder(u, INVALID_VEH_ORDER_ID | (sel_ord << 8));

	}

				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));

		v->cur_implicit_order_index = v->cur_real_order_index = sel_ord;

		v->UpdateRealOrderIndex();

		InvalidateVehicleOrder(v, VIWD_MODIFY_ORDERS);

		/* We have an aircraft/ship, they have a mini-schedule, so update them all */

			} else if (u->cur_implicit_order_index < moving_order && u->cur_implicit_order_index >= target_order) {

				u->cur_implicit_order_index++;

			}

			assert(v->orders == u->orders);

			/* Update any possible open window of the vehicle */

			if (order->GetNonStopType() & ONSF_NO_STOP_AT_DESTINATION_STATION) return CMD_ERROR;

			if (data > OLFB_NO_LOAD || data == 1) return CMD_ERROR;

			if (data == order->GetLoadType()) return CMD_ERROR;

			break;

		case MOF_DEPOT_ACTION:

			if (data >= DA_END) return CMD_ERROR;

			break;

		case MOF_COND_VARIABLE:

					case DA_ALWAYS_GO:

						order->SetDepotOrderType((OrderDepotTypeFlags)(order->GetDepotOrderType() & ~ODTFB_SERVICE));

						order->SetDepotActionType((OrderDepotActionFlags)(order->GetDepotActionType() & ~ODATFB_HALT));

						break;

					case DA_SERVICE:

					case DA_STOP:

						order->SetDepotOrderType((OrderDepotTypeFlags)(order->GetDepotOrderType() & ~ODTFB_SERVICE));

						order->SetDepotActionType((OrderDepotActionFlags)(order->GetDepotActionType() | ODATFB_HALT));

						order->SetRefit(CARGO_NO_REFIT);

						break;

					default:

						NOT_REACHED();

				}

					u->current_order.GetLoadType() != order->GetLoadType()) {

				u->current_order.SetLoadType(order->GetLoadType());

			}

			InvalidateVehicleOrder(u, VIWD_MODIFY_ORDERS);

		}

	}

		if (!keep_orderlist) v->orders = nullptr;

	}

	if (reset_order_indices) {

		v->cur_implicit_order_index = v->cur_real_order_index = 0;

		if (v->current_order.IsType(OT_LOADING)) {

	STR_ORDER_DROP_GO_ALWAYS_DEPOT,

	STR_ORDER_DROP_SERVICE_DEPOT,

	STR_ORDER_DROP_HALT_DEPOT,

	INVALID_STRING_ID

};

	SetDParam(5, STR_EMPTY);

	SetDParam(8, STR_EMPTY);

	/* Check range for aircraft. */

	if (v->type == VEH_AIRCRAFT && Aircraft::From(v)->GetRange() > 0 && order->IsGotoOrder()) {

		const Order *next = order->next != nullptr ? order->next : v->GetFirstOrder();

	}

	switch (order->GetType()) {

				SetDParam(5, (order->GetDepotActionType() & ODATFB_HALT) ? STR_ORDER_REFIT_STOP_ORDER : STR_ORDER_REFIT_ORDER);

				SetDParam(6, CargoSpec::Get(order->GetRefitCargo())->name);

			}

			break;

		case OT_GOTO_WAYPOINT:

		/* First row. */

		this->RaiseWidget(WID_O_FULL_LOAD);

		this->RaiseWidget(WID_O_UNLOAD);

		/* Selection widgets. */

		/* Train or road vehicle. */

					this->SetWidgetDisabledState(WID_O_REFIT,

							(order->GetDepotOrderType() & ODTFB_SERVICE) || (order->GetDepotActionType() & ODATFB_HALT) ||

							(!this->can_do_refit && !order->IsRefit()));

					break;

				case OT_CONDITIONAL: {

			case WID_O_CAPTION:

				SetDParam(0, this->vehicle->index);

				break;

		}

	}

				this->OrderClick_Refit(0, false);

				break;

				break;

			case WID_O_REFIT_DROPDOWN:

				}

				break;

				this->OrderClick_Service(index);

				break;

				NWidget(NWID_SELECTION, INVALID_COLOUR, WID_O_SEL_TOP_MIDDLE),

					NWidget(NWID_BUTTON_DROPDOWN, COLOUR_GREY, WID_O_UNLOAD), SetMinimalSize(93, 12), SetFill(1, 0),

															SetDataTip(STR_ORDER_TOGGLE_UNLOAD, STR_ORDER_TOOLTIP_UNLOAD), SetResize(1, 0),

				EndContainer(),

				NWidget(NWID_SELECTION, INVALID_COLOUR, WID_O_SEL_TOP_RIGHT),

					NWidget(WWT_PANEL, COLOUR_GREY), SetMinimalSize(93, 12), SetFill(1, 0), SetResize(1, 0), EndContainer(),

			NWidget(NWID_HORIZONTAL, NC_EQUALSIZE),

				NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_O_REFIT), SetMinimalSize(186, 12), SetFill(1, 0),

													SetDataTip(STR_ORDER_REFIT, STR_ORDER_REFIT_TOOLTIP), SetResize(1, 0),

			EndContainer(),

			/* Buttons for setting a condition. */

	ODATF_SERVICE_ONLY   = 0,      ///< Only service the vehicle.

	ODATFB_HALT          = 1 << 0, ///< Service the vehicle and then halt it.

	ODATFB_NEAREST_DEPOT = 1 << 1, ///< Send the vehicle to the nearest depot.

};

DECLARE_ENUM_AS_BIT_SET(OrderDepotActionFlags)

	DA_ALWAYS_GO, ///< Always go to the depot

	DA_SERVICE,   ///< Service only if needed

	DA_STOP,      ///< Go to the depot and stop there

	DA_END

};

	if (IsTileType(v->tile, MP_TUNNELBRIDGE) && DirToDiagDir(v->direction) == GetTunnelBridgeDirection(v->tile)) return CMD_ERROR;

	return CommandCost();

}

		if (RoadVehFindCloseTo(v, x, y, v->direction, false) != nullptr) return true;

		VehicleServiceInDepot(v);

		StartRoadVehSound(v);

	if (v->current_order.IsType(OT_LOADING)) return true;

	v->ShowVisualEffect();

				v->current_order.SetLoadType(OLFB_NO_LOAD);

			}

		}

	}

	/* The water class was moved/unified. */

	SLV_SHIP_ACCELERATION,                  ///< 329  PR#10734 Start using Vehicle's acceleration field for ships too.

	SLV_MAX_LOAN_FOR_COMPANY,               ///< 330  PR#11224 Separate max loan for each company.

	SL_MAX_VERSION,                         ///< Highest possible saveload version

};

		SLE_CONDVAR(Vehicle, current_order_time,    SLE_INT32,                   SLV_TIMETABLE_TICKS_TYPE, SL_MAX_VERSION),

		SLE_CONDVAR(Vehicle, last_loading_tick,     SLE_UINT64,                   SLV_LAST_LOADING_TICK, SL_MAX_VERSION),

		SLE_CONDVAR(Vehicle, lateness_counter,      SLE_INT32,                   SLV_67, SL_MAX_VERSION),

	};

#if defined(_MSC_VER) && (_MSC_VER == 1915 || _MSC_VER == 1916)

		return description;

{

	if (!v->IsChainInDepot()) return false;

	/* We are leaving a depot, but have to go to the exact same one; re-enter */

	if (v->current_order.IsType(OT_GOTO_DEPOT) &&

			IsShipDepotTile(v->tile) && GetDepotIndex(v->tile) == v->current_order.GetDestination()) {

	v->UpdateViewport(true, true);

	SetWindowDirty(WC_VEHICLE_DEPOT, v->tile);

	v->PlayLeaveStationSound();

	InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);

	SetWindowClassesDirty(WC_SHIPS_LIST);

			default:

				break;

		}

	}

	return CommandCost();

				if (u->lateness_counter > most_late) {

					most_late = u->lateness_counter;

				}

			}

			if (most_late > 0) {

				for (Vehicle *u = v->FirstShared(); u != nullptr; u = u->NextShared()) {

			}

		} else {

			v->lateness_counter = 0;

			SetWindowDirty(WC_VEHICLE_TIMETABLE, v->index);

		}

	}

		int idx = 0;

		for (Vehicle *w : vehs) {

			w->lateness_counter = 0;

			ClrBit(w->vehicle_flags, VF_TIMETABLE_STARTED);

			/* Do multiplication, then division to reduce rounding errors. */

			w->timetable_start = start_tick + (idx * total_duration / num_vehs);

			SetWindowDirty(WC_VEHICLE_TIMETABLE, w->index);

			++idx;

		}

				HideFillingPercent(&v->fill_percent_te_id);

				ReverseTrainDirection(v);

			}

		}

	}

	return CommandCost();

		 * next signal we encounter. */

		t->force_proceed = t->force_proceed == TFP_SIGNAL ? TFP_NONE : HasBit(t->flags, VRF_TRAIN_STUCK) || t->IsChainInDepot() ? TFP_STUCK : TFP_SIGNAL;

		SetWindowDirty(WC_VEHICLE_VIEW, t->index);

	}

	return CommandCost();

		return true;

	}

	SigSegState seg_state;

	if (v->force_proceed == TFP_NONE) {

	if (_settings_client.gui.show_track_reservation) MarkTileDirtyByTile(v->tile);

	VehicleServiceInDepot(v);

	SetWindowClassesDirty(WC_TRAINS_LIST);

	v->track = TRACK_BIT_X;

	if (v->direction & 2) v->track = TRACK_BIT_Y;

	SetBit(this->vehicle_flags, VF_PATHFINDER_LOST);

	SetWindowWidgetDirty(WC_VEHICLE_VIEW, this->index, WID_VV_START_STOP);

	InvalidateWindowClassesData(GetWindowClassForVehicleType(this->type));

	/* Notify user about the event. */

	AI::NewEvent(this->owner, new ScriptEventVehicleLost(this->index));

	if (_settings_client.gui.lost_vehicle_warn && this->owner == _local_company) {

			 * before the stop to the station after the stop can't be predicted

			 * we shouldn't construct it when the vehicle visits the next stop. */

			v->last_loading_station = INVALID_STATION;

			if (v->owner == _local_company) {

				SetDParam(0, v->index);

				AddVehicleAdviceNewsItem(STR_NEWS_TRAIN_IS_WAITING + v->type, v->index);

			}

			AI::NewEvent(v->owner, new ScriptEventVehicleWaitingInDepot(v->index));

		}

		v->current_order.MakeDummy();

	}

}

}

/**