* @param engine_type The EngineID of the vehicle that is being replaced to

 * @param part_of_chain The vehicle is part of a train

 * @return The cargo type to replace to

 *    INVALID_CARGO is returned when both old and new vehicle got cargo capacity and refitting the new one to the old one's cargo type isn't possible

 */

static CargoID GetNewCargoTypeForReplace(Vehicle *v, EngineID engine_type, bool part_of_chain)

	CargoTypes available_cargo_types, union_mask;

	GetArticulatedRefitMasks(engine_type, true, &union_mask, &available_cargo_types);

	CargoID cargo_type;

	CargoTypes cargo_mask = GetCargoTypesOfArticulatedVehicle(v, &cargo_type);

	if (!HasAtMostOneBit(cargo_mask)) {

		CargoTypes new_engine_default_cargoes = GetCargoTypesOfArticulatedParts(engine_type);

		if ((cargo_mask & new_engine_default_cargoes) == cargo_mask) {

		}

		return INVALID_CARGO; // We cannot refit to mixed cargoes in an automated way

	}

	if (!IsValidCargoID(cargo_type)) {

		/* the old engine didn't have cargo capacity, but the new one does

		 * now we will figure out what cargo the train is carrying and refit to fit this */

			if (HasBit(available_cargo_types, v->cargo_type)) return v->cargo_type;

		}

	} else {

		if (!HasBit(available_cargo_types, cargo_type)) return INVALID_CARGO; // We can't refit the vehicle to carry the cargo we want

	*new_vehicle = new_veh;

	/* Refit the vehicle if needed */

		byte subtype = GetBestFittingSubType(old_veh, new_veh, refit_cargo);

		cost.AddCost(std::get<0>(Command<CMD_REFIT_VEHICLE>::Do(DC_EXEC, new_veh->index, refit_cargo, subtype, false, false, 0)));

	EndContainer(),

};

bool _engine_sort_direction; ///< \c false = descending, \c true = ascending.

byte _engine_sort_last_criteria[]       = {0, 0, 0, 0};                 ///< Last set sort criteria, for each vehicle type.

bool _engine_sort_last_order[]          = {false, false, false, false}; ///< Last set direction of the sort order, for each vehicle type.

bool _engine_sort_show_hidden_engines[] = {false, false, false, false}; ///< Last set 'show hidden engines' setting for each vehicle type.

/**

 * Determines order of engines by engineID

/** Filters vehicles by cargo and engine (in case of rail vehicle). */

static bool CDECL CargoAndEngineFilter(const GUIEngineListItem *item, const CargoID cid)

{

		return true;

		return Engine::Get(item->engine_id)->GetPower() != 0;

	} else {

		CargoTypes refit_mask = GetUnionOfArticulatedRefitMasks(item->engine_id, true) & _standard_cargo_mask;

	}

}

	{

		NWidgetCore *widget = this->GetWidget<NWidgetCore>(WID_BV_BUILD);

		if (refit) refit = Engine::Get(this->sel_engine)->GetDefaultCargoType() != this->cargo_filter_criteria;

		if (refit) {

	StringID GetCargoFilterLabel(CargoID cid) const

	{

		switch (cid) {

			default: return CargoSpec::Get(cid)->name;

		}

	}

	{

		/* Set the last cargo filter criteria. */

		this->cargo_filter_criteria = _engine_sort_last_cargo_criteria[this->vehicle_type];

		this->eng_list.SetFilterFuncs(_filter_funcs);

	}

	void SelectEngine(EngineID engine)

	{

		CargoID cargo = this->cargo_filter_criteria;

		this->sel_engine = engine;

		this->SetBuyVehicleText();

		DropDownList list;

		/* Add item for disabling filtering. */

		/* Specific filters for trains. */

		if (this->vehicle_type == VEH_TRAIN) {

			/* Add item for locomotives only in case of trains. */

			/* Add item for vehicles not carrying anything, e.g. train engines.

			 * This could also be useful for eyecandy vehicles of other types, but is likely too confusing for joe, */

		}

		/* Add cargos */

				EngineID sel_eng = this->sel_engine;

				if (sel_eng != INVALID_ENGINE) {

					CargoID cargo = this->cargo_filter_criteria;

					if (this->vehicle_type == VEH_TRAIN && RailVehInfo(sel_eng)->railveh_type == RAILVEH_WAGON) {

						Command<CMD_BUILD_VEHICLE>::Post(GetCmdBuildVehMsg(this->vehicle_type), CcBuildWagon, this->window_number, sel_eng, true, cargo, INVALID_CLIENT_ID);

					} else {

					this->cargo_filter_criteria = index;

					_engine_sort_last_cargo_criteria[this->vehicle_type] = this->cargo_filter_criteria;

					/* deactivate filter if criteria is 'Show All', activate it otherwise */

					this->eng_list.ForceRebuild();

					this->SelectEngine(this->sel_engine);

				}

	CT_PLASTIC      = 10,

	CT_FIZZY_DRINKS = 11,

	CT_INVALID      = 0xFF, ///< Invalid cargo type.

};

static const CargoID INVALID_CARGO = UINT8_MAX;

/** Test whether cargo type is not CT_INVALID */

inline bool IsValidCargoType(CargoType t) { return t != CT_INVALID; }

/** Test whether cargo type is not INVALID_CARGO */

	/* Remove old capacity from consist capacity and collect refit mask. */

	IterateVehicleParts(v_start, PrepareRefitAction(consist_capleft, refit_mask));

	if (is_auto_refit) {

		/* Get a refittable cargo type with waiting cargo for next_station or INVALID_STATION. */

		new_cid = v_start->cargo_type;

	Station *st = Station::Get(last_visited);

	StationIDStack next_station = front->GetNextStoppingStation();

	CargoArray consist_capleft{};

	if (_settings_game.order.improved_load && use_autorefit ?

			front->cargo_payment == nullptr : (front->current_order.GetLoadType() & OLFB_FULL_LOAD) != 0) {

typedef GUIList<const Industry *, const CargoID &, const std::pair<CargoID, CargoID> &> GUIIndustryList;

/** Cargo filter functions */

/**

 * Check whether an industry accepts and produces a certain cargo pair.

	bool accepted_cargo_matches;

	switch (accepted_cargo) {

			accepted_cargo_matches = true;

			break;

			accepted_cargo_matches = !(*industry)->IsCargoAccepted();

			break;

	bool produced_cargo_matches;

	switch (produced_cargo) {

			produced_cargo_matches = true;

			break;

			produced_cargo_matches = !(*industry)->IsCargoProduced();

			break;

		if (this->produced_cargo_filter_criteria != cid) {

			this->produced_cargo_filter_criteria = cid;

			/* deactivate filter if criteria is 'Show All', activate it otherwise */

			this->industries.SetFilterState(is_filtering_necessary);

			this->industries.SetFilterType(0);

		if (this->accepted_cargo_filter_criteria != cid) {

			this->accepted_cargo_filter_criteria = cid;

			/* deactivate filter if criteria is 'Show All', activate it otherwise */

			this->industries.SetFilterState(is_filtering_necessary);

			this->industries.SetFilterType(0);

	StringID GetCargoFilterLabel(CargoID cid) const

	{

		switch (cid) {

			default: return CargoSpec::Get(cid)->name;

		}

	}

	 */

	void SetCargoFilterArray()

	{

		this->industries.SetFilterFuncs(_filter_funcs);

		this->industries.SetFilterState(is_filtering_necessary);

	}

	static int GetCargoTransportedSortValue(const Industry *i)

	{

		CargoID filter = IndustryDirectoryWindow::produced_cargo_filter;

		int percentage = 0, produced_cargo_count = 0;

		for (const auto &p : i->produced) {

				int transported = GetCargoTransportedPercentsIfValid(p);

				if (transported != -1) {

					produced_cargo_count++;

	/** Sort industries by production and name */

	static bool IndustryProductionSorter(const Industry * const &a, const Industry * const &b, const CargoID &filter)

	{

		uint prod_a = 0, prod_b = 0;

			for (const auto &pa : a->produced) {

				if (IsValidCargoID(pa.cargo)) prod_a += pa.history[LAST_MONTH].production;

			}

		/* If the produced cargo filter is active then move the filtered cargo to the beginning of the list,

		 * because this is the one the player interested in, and that way it is not hidden in the 'n' more cargos */

		const CargoID cid = this->produced_cargo_filter_criteria;

			auto filtered_ci = std::find_if(cargos.begin(), cargos.end(), [cid](const CargoInfo &ci) -> bool {

				return ci.cargo_id == cid;

			});

				const CargoID acf_cid = this->accepted_cargo_filter_criteria;

				for (uint i = this->vscroll->GetPosition(); i < this->industries.size(); i++) {

					TextColour tc = TC_FROMSTRING;

						Industry *ind = const_cast<Industry *>(this->industries[i]);

						if (IndustryTemporarilyRefusesCargo(ind, acf_cid)) {

							tc = TC_GREY | TC_FORCED;

		DropDownList list;

		/* Add item for disabling filtering. */

		/* Add item for industries not producing anything, e.g. power plants */

		/* Add cargos */

		Dimension d = GetLargestCargoIconSize();

	INVALID_STRING_ID

};

/** Window definition of the industry directory gui */

public:

	Order *next;          ///< Pointer to next order. If nullptr, end of list

	~Order();

	Order(uint32_t packed);

	void Free();

	void MakeGoToStation(StationID destination);

	void MakeGoToWaypoint(StationID destination);

	void MakeLoading(bool ordered);

	void MakeLeaveStation();

	 * @pre IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION)

	 * @return true if a refit should happen.

	 */

	/**

	 * Is this order a auto-refit order.

	 * @pre IsType(OT_GOTO_DEPOT) || IsType(OT_GOTO_STATION)

	 * @return true if a auto-refit should happen.

	 */

	/**

	 * Get the cargo to to refit to.

	this->flags   = GB(packed,  8,  8);

	this->dest    = GB(packed, 16, 16);

	this->next    = nullptr;

	this->wait_time     = 0;

	this->travel_time   = 0;

	this->max_speed     = UINT16_MAX;

	if (ret.Failed()) return ret;

	/* Validate properties we don't want to have different from default as they are set by other commands. */

	/* Check if the inserted order is to the correct destination (owner, type),

	 * and has the correct flags if any */

			case MOF_NON_STOP:

				order->SetNonStopType((OrderNonStopFlags)data);

				if (data & ONSF_NO_STOP_AT_DESTINATION_STATION) {

					order->SetLoadType(OLF_LOAD_IF_POSSIBLE);

					order->SetUnloadType(OUF_UNLOAD_IF_POSSIBLE);

				}

			case MOF_LOAD:

				order->SetLoadType((OrderLoadFlags)data);

				break;

			case MOF_DEPOT_ACTION: {

					case DA_SERVICE:

						order->SetDepotOrderType((OrderDepotTypeFlags)(order->GetDepotOrderType() | ODTFB_SERVICE));

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

						break;

					case DA_STOP:

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

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

						break;

					default:

 */

CommandCost CmdOrderRefit(DoCommandFlag flags, VehicleID veh, VehicleOrderID order_number, CargoID cargo)

{

	const Vehicle *v = Vehicle::GetIfValid(veh);

	if (v == nullptr || !v->IsPrimaryVehicle()) return CMD_ERROR;

	if (order == nullptr) return CMD_ERROR;

	/* Automatic refit cargo is only supported for goto station orders. */

	if (order->GetLoadType() & OLFB_NO_LOAD) return CMD_ERROR;

		order->SetRefit(cargo);

		/* Make the depot order an 'always go' order. */

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

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

		}

	{

		if (_ctrl_pressed) {

			/* Cancel refitting */

		} else {

			if (i == 1) { // Auto-refit to available cargo type.

			} else {

				ShowVehicleRefitWindow(this->vehicle, this->OrderGetSel(), this, auto_refit);

			}

	/* Setting no refit flags to all orders in savegames from before refit in orders were added */

	if (IsSavegameVersionBefore(SLV_36)) {

		for (Order *order : Order::Iterate()) {

		}

		for (Vehicle *v : Vehicle::Iterate()) {

		}

	}

	 */

	enum SpecialCargoID {

		/* Note: these values represent part of the in-game CargoTypes enum */

		CT_INVALID    = ::INVALID_CARGO, ///< An invalid cargo type.

	};

/* static */ CargoID ScriptOrder::GetOrderRefit(VehicleID vehicle_id, OrderPosition order_position)

{

	const Order *order = ::ResolveOrder(vehicle_id, order_position);

}

/* static */ bool ScriptOrder::SetOrderJumpTo(VehicleID vehicle_id, OrderPosition order_position, OrderPosition jump_to)

{

	EnforceCompanyModeValid(false);

	EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, order_position));

	return ScriptObject::Command<CMD_ORDER_REFIT>::Do(0, vehicle_id, ScriptOrderPositionToRealOrderPosition(vehicle_id, ScriptOrder::ResolveOrderPosition(vehicle_id, order_position)), refit_cargo);

}

 */

static bool CargoFilterSingle(const Vehicle *v, const CargoID cid)

{

		return true;

		for (const Vehicle *w = v; w != nullptr; w = w->Next()) {

			if (w->cargo_cap > 0) {

				return false;

			}

		}

		return true;

		bool have_capacity = false;

		for (const Vehicle *w = v; w != nullptr; w = w->Next()) {

			if (w->cargo_cap > 0) {

	if (this->cargo_filter_criteria != cid) {

		this->cargo_filter_criteria = cid;

		/* Deactivate filter if criteria is 'Show All', activate it otherwise. */

		this->vehgroups.SetFilterType(0);

		this->vehgroups.ForceRebuild();

	}

 */

void BaseVehicleListWindow::SetCargoFilterArray()

{

	this->vehgroups.SetFilterFuncs(_filter_funcs);

}

/**

StringID BaseVehicleListWindow::GetCargoFilterLabel(CargoID cid) const

{

	switch (cid) {

		default: return CargoSpec::Get(cid)->name;

	}

}

	DropDownList list;

	/* Add item for disabling filtering. */

	/* Add item for freight (i.e. vehicles with cargo capacity and with no passenger capacity). */

	/* Add item for vehicles not carrying anything, e.g. train engines. */

	/* Add cargos */

	Dimension d = GetLargestCargoIconSize();

		GB_END,

	};

	GroupBy grouping;                           ///< How we want to group the list.

	VehicleList vehicles;                       ///< List of vehicles.  This is the buffer for `vehgroups` to point into; if this is structurally modified, `vehgroups` must be rebuilt.

	GUIVehicleGroupList vehgroups;              ///< List of (groups of) vehicles.  This stores iterators of `vehicles`, and should be rebuilt if `vehicles` is structurally changed.