v->reliability_spd_dec = e->reliability_spd_dec;

		v->max_age = e->GetLifeLengthInDays();

		v->pos = GetVehiclePosOnBuild(tile);

		v->state = HANGAR;

	}

	/* Build the new vehicle */

	if (cost.Failed()) return cost;

	*new_vehicle = new_veh;

	/* Refit the vehicle if needed */

	if (refit_cargo != CT_NO_REFIT) {

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

		assert(cost.Succeeded()); // This should be ensured by GetNewCargoTypeForReplace()

	}

		if (!this->listview_mode) {

			/* Query for cost and refitted capacity */

			if (ret.Succeeded()) {

				this->te.cost          = ret.GetCost() - e->GetCost();

				this->te.cargo         = (cargo == CT_INVALID) ? e->GetDefaultCargoType() : cargo;

				return;

			}

			case WID_BV_BUILD: {

				EngineID sel_eng = this->sel_engine;

				if (sel_eng != INVALID_ENGINE) {

					CargoID cargo = this->cargo_filter[this->cargo_filter_criteria];

					if (cargo == CF_ANY || cargo == CF_ENGINES) cargo = CF_NONE;

				}

				break;

			}

DEF_CMD_TRAIT(CMD_RENAME_DEPOT, CmdRenameDepot, 0, CMDT_OTHER_MANAGEMENT)

#endif /* DEPOT_CMD_H */

 * This is the Callback method after the cloning attempt of a vehicle

 * @param cmd unused

 * @param result the result of the cloning command

 */

{

	if (result.Failed()) return;

	ShowVehicleViewWindow(v);

}

			if (st->goods[cid].cargo.HasCargoFor(next_station)) {

				/* Try to find out if auto-refitting would succeed. In case the refit is allowed,

				 * the returned refit capacity will be greater than zero. */

				/* Try to balance different loadable cargoes between parts of the consist, so that

				 * all of them can be loaded. Avoid a situation where all vehicles suddenly switch

				 * to the first loadable cargo for which there is only one packet. If the capacities

				 * are equal refit to the cargo of which most is available. This is important for

				 * consists of only a single vehicle as those will generally have a consist_capleft

				 * of 0 for all cargoes. */

						(consist_capleft[cid] == consist_capleft[new_cid] &&

						st->goods[cid].cargo.AvailableCount() > st->goods[new_cid].cargo.AvailableCount()))) {

					new_cid = cid;

		 * "via any station" before reserving. We rather produce some more "any station" cargo than

		 * misrouting it. */

		IterateVehicleParts(v_start, ReturnCargoAction(st, INVALID_STATION));

		if (cost.Succeeded()) v->First()->profit_this_year -= cost.GetCost() << 8;

	}

		v->reliability = e->reliability;

		v->reliability_spd_dec = e->reliability_spd_dec;

		v->max_age = e->GetLifeLengthInDays();

		v->SetServiceInterval(Company::Get(v->owner)->settings.vehicle.servint_roadveh);

/* static */ void ScriptObject::SetLastCommandRes(bool res)

{

	GetStorage()->last_command_res = res;

}

/* static */ bool ScriptObject::GetLastCommandRes()

	return GetStorage()->last_cmd_ret;

}

/* static */ void ScriptObject::SetAllowDoCommand(bool allow)

{

	GetStorage()->allow_do_command = allow;

	static const CommandDataBuffer &GetLastCommandResData();

	/**

	 * Store a allow_do_command per company.

	 * @param allow The new allow.

	 */

	static char *GetString(StringID string);

private:

	/* Helper functions for DoCommand. */

	static std::tuple<bool, bool, bool> DoCommandPrep();

	static bool DoCommandProcessResult(const CommandCost &res, Script_SuspendCallbackProc *callback, bool estimate_only);

	if (!ScriptEngine::IsBuildable(engine_id)) return -1;

	if (!ScriptCargo::IsValidCargo(cargo)) return -1;

}

/* static */ VehicleID ScriptVehicle::CloneVehicle(TileIndex depot, VehicleID vehicle_id, bool share_orders)

	if (!IsValidVehicle(vehicle_id)) return -1;

	if (!ScriptCargo::IsValidCargo(cargo)) return -1;

}

/* static */ bool ScriptVehicle::RefitVehicle(VehicleID vehicle_id, CargoID cargo)

/* static */ void ScriptInstance::DoCommandReturnVehicleID(ScriptInstance *instance)

{

}

/* static */ void ScriptInstance::DoCommandReturnSignID(ScriptInstance *instance)

	Commands last_cmd;               ///< The last cmd passed to a command.

	CommandDataBuffer last_cmd_ret;  ///< The extra data returned by the last command.

	std::vector<int> callback_value; ///< The values which need to survive a callback.

	RoadType road_type;              ///< The current roadtype we build.

		last_command_res  (true),

		last_tile         (INVALID_TILE),

		last_cmd          (CMD_END),

		/* calback_value (can't be set) */

		road_type         (INVALID_ROADTYPE),

		rail_type         (INVALID_RAILTYPE),

		v->reliability = e->reliability;

		v->reliability_spd_dec = e->reliability_spd_dec;

		v->max_age = e->GetLifeLengthInDays();

		v->state = TRACK_BIT_DEPOT;

		AddArticulatedParts(v);

		v->UpdatePosition();

		v->First()->ConsistChanged(CCF_ARRANGE);

		UpdateTrainGroupID(v->First());

		v->max_age = e->GetLifeLengthInDays();

		v->railtype = rvi->railtype;

		v->SetServiceInterval(Company::Get(_current_company)->settings.vehicle.servint_trains);

		v->date_of_last_service = _date;

DEF_CMD_TRAIT(CMD_FORCE_TRAIN_PROCEED,     CmdForceTrainProceed,     0, CMDT_VEHICLE_MANAGEMENT)

DEF_CMD_TRAIT(CMD_REVERSE_TRAIN_DIRECTION, CmdReverseTrainDirection, 0, CMDT_VEHICLE_MANAGEMENT)

#endif /* TRAIN_CMD_H */

 * Callback for building wagons.

 * @param cmd Unused.

 * @param result The result of the command.

 * @param tile   The tile the command was executed on.

 */

{

	if (result.Failed()) return;

	if (found != nullptr) {

		found = found->Last();

		/* put the new wagon at the end of the loco. */

		InvalidateWindowClassesData(WC_TRAINS_LIST, 0);

	}

}

static const uint GEN_HASHX_MASK =  (1 << GEN_HASHX_BITS) - 1;

static const uint GEN_HASHY_MASK = ((1 << GEN_HASHY_BITS) - 1) << GEN_HASHX_BITS;

/** The pool with all our precious vehicles. */

VehiclePool _vehicle_pool("Vehicle");

		if (v->current_order.IsRefit()) {

			Backup<CompanyID> cur_company(_current_company, v->owner, FILE_LINE);

			cur_company.Restore();

			if (cost.Failed()) {

 * @param use_free_vehicles use free vehicles when building the vehicle.

 * @param cargo refit cargo type.

 * @param client_id User

 */

{

	/* Elementary check for valid location. */

	VehicleType type = GetDepotVehicleType(tile);

	/* Validate the engine type. */

	/* Validate the cargo type. */

	const Engine *e = Engine::Get(eid);

	CommandCost value(EXPENSES_NEW_VEHICLES, e->GetCost());

	/* Engines without valid cargo should not be available */

	CargoID default_cargo = e->GetDefaultCargoType();

	bool refitting = cargo != CT_INVALID && cargo != default_cargo;

		case VEH_AIRCRAFT: num_vehicles = e->u.air.subtype & AIR_CTOL ? 2 : 3; break;

		default: NOT_REACHED(); // Safe due to IsDepotTile()

	}

	/* Check whether we can allocate a unit number. Autoreplace does not allocate

	 * an unit number as it will (always) reuse the one of the replaced vehicle

	 * and (train) wagons don't have an unit number in any scenario. */

	UnitID unit_num = (flags & DC_QUERY_COST || flags & DC_AUTOREPLACE || (type == VEH_TRAIN && e->u.rail.railveh_type == RAILVEH_WAGON)) ? 0 : GetFreeUnitNumber(type);

	/* If we are refitting we need to temporarily purchase the vehicle to be able to

	 * test it. */

		default: NOT_REACHED(); // Safe due to IsDepotTile()

	}

	if (value.Succeeded()) {

		if (subflags & DC_EXEC) {

			v->unitnumber = unit_num;

			v->value      = value.GetCost();

		}

		if (refitting) {

			/* Refit only one vehicle. If we purchased an engine, it may have gained free wagons. */

		} else {

			/* Fill in non-refitted capacities */

		}

		if (flags & DC_EXEC) {

	/* Only restore if we actually did some refitting */

	if (flags != subflags) RestoreRandomSeeds(saved_seeds);

}

/**

 * @param new_subtype  Cargo subtype to refit to. 0xFF means to try keeping the same subtype according to GetBestFittingSubType().

 * @param flags        Command flags

 * @param auto_refit   Refitting is done as automatic refitting outside a depot.

 */

{

	CommandCost cost(v->GetExpenseType(false));

	uint total_capacity = 0;

	}

	refit_result.clear();

}

/**

 *                     Only used if "refit only this vehicle" is false.

 * @return the cost of this operation or an error

 */

{

	Vehicle *v = Vehicle::GetIfValid(veh_id);

	/* Don't allow disasters and sparks and such to be refitted.

	 * We cannot check for IsPrimaryVehicle as autoreplace also refits in free wagon chains. */

	Vehicle *front = v->First();

	CommandCost ret = CheckOwnership(front->owner);

	bool free_wagon = v->type == VEH_TRAIN && Train::From(front)->IsFreeWagon(); // used by autoreplace/renew

	/* Don't allow shadows and such to be refitted. */

	/* Allow auto-refitting only during loading and normal refitting only in a depot. */

	if ((flags & DC_QUERY_COST) == 0 && // used by the refit GUI, including the order refit GUI.

			!free_wagon && // used by autoreplace/renew

			(!auto_refit || !front->current_order.IsType(OT_LOADING)) && // refit inside stations

			!front->IsStoppedInDepot()) { // refit inside depots

	}

	/* Check cargo */

	/* For ships and aircraft there is always only one. */

	only_this |= front->type == VEH_SHIP || front->type == VEH_AIRCRAFT;

	if (flags & DC_EXEC) {

		/* Update the cached variables */

		v->InvalidateNewGRFCacheOfChain();

	}

}

/**

 * @param tile tile of the depot where the cloned vehicle is build

 * @param veh_id the original vehicle's index

 * @param share_orders shared orders, else copied orders

 */

{

	CommandCost total_cost(EXPENSES_NEW_VEHICLES);

	Vehicle *v = Vehicle::GetIfValid(veh_id);

	Vehicle *v_front = v;

	Vehicle *w = nullptr;

	Vehicle *w_front = nullptr;

	 */

	CommandCost ret = CheckOwnership(v->owner);

	/* check that we can allocate enough vehicles */

	if (!(flags & DC_EXEC)) {

		} while ((v = v->Next()) != nullptr);

		if (!Vehicle::CanAllocateItem(veh_counter)) {

		}

	}

	v = v_front;

	do {

		if (v->type == VEH_TRAIN && Train::From(v)->IsRearDualheaded()) {

			/* we build the rear ends of multiheaded trains with the front ones */

		DoCommandFlag build_flags = flags;

		if ((flags & DC_EXEC) && !v->IsPrimaryVehicle()) build_flags |= DC_AUTOREPLACE;

		if (cost.Failed()) {

			/* Can't build a part, then sell the stuff we already made; clear up the mess */

			if (w_front != nullptr) Command<CMD_SELL_VEHICLE>::Do(flags, w_front->index, true, false, INVALID_CLIENT_ID);

		}

		total_cost.AddCost(cost);

		if (flags & DC_EXEC) {

			if (v->type == VEH_TRAIN && HasBit(Train::From(v)->flags, VRF_REVERSE_DIRECTION)) {

				SetBit(Train::From(w)->flags, VRF_REVERSE_DIRECTION);

					 * Sell what we already made (clean up) and return an error.           */

					Command<CMD_SELL_VEHICLE>::Do(flags, w_front->index, true, false, INVALID_CLIENT_ID);

					Command<CMD_SELL_VEHICLE>::Do(flags, w->index,       true, false, INVALID_CLIENT_ID);

				}

			} else {

				/* this is a front engine or not a train. */

	if ((flags & DC_EXEC) && v_front->type == VEH_TRAIN) {

		/* for trains this needs to be the front engine due to the callback function */

	}

	if (flags & DC_EXEC) {

				/* Find out what's the best sub type */

				byte subtype = GetBestFittingSubType(v, w, v->cargo_type);

				if (w->cargo_type != v->cargo_type || w->cargo_subtype != subtype) {

					if (cost.Succeeded()) total_cost.AddCost(cost);

				}

		if (result.Failed()) {

			/* The vehicle has already been bought, so now it must be sold again. */

			Command<CMD_SELL_VEHICLE>::Do(flags, w_front->index, true, false, INVALID_CLIENT_ID);

		}

		/* Now clone the vehicle's name, if it has one. */

		if (!CheckCompanyHasMoney(total_cost)) {

			/* The vehicle has already been bought, so now it must be sold again. */

			Command<CMD_SELL_VEHICLE>::Do(flags, w_front->index, true, false, INVALID_CLIENT_ID);

		}

	}

}

/**

#include "vehicle_type.h"

#include "vehiclelist.h"

CommandCost CmdSellVehicle(DoCommandFlag flags, VehicleID v_id, bool sell_chain, bool backup_order, ClientID client_id);

CommandCost CmdSendVehicleToDepot(DoCommandFlag flags, VehicleID veh_id, DepotCommand depot_cmd, const VehicleListIdentifier &vli);

CommandCost CmdChangeServiceInt(DoCommandFlag flags, VehicleID veh_id, uint16 serv_int, bool is_custom, bool is_percent);

CommandCost CmdRenameVehicle(DoCommandFlag flags, VehicleID veh_id, const std::string &text);

CommandCost CmdStartStopVehicle(DoCommandFlag flags, VehicleID veh_id, bool evaluate_startstop_cb);

CommandCost CmdMassStartStopVehicle(DoCommandFlag flags, TileIndex tile, bool do_start, bool vehicle_list_window, const VehicleListIdentifier &vli);

CommandCost CmdDepotSellAllVehicles(DoCommandFlag flags, TileIndex tile, VehicleType vehicle_type);

DEF_CMD_TRAIT(CMD_DEPOT_SELL_ALL_VEHICLES, CmdDepotSellAllVehicles, 0,             CMDT_VEHICLE_CONSTRUCTION)

DEF_CMD_TRAIT(CMD_DEPOT_MASS_AUTOREPLACE,  CmdDepotMassAutoReplace, 0,             CMDT_VEHICLE_CONSTRUCTION)

void CcStartStopVehicle(Commands cmd, const CommandCost &result, VehicleID veh_id, bool);

template <typename Tcont, typename Titer>

CommandCost EnsureNoVehicleOnGround(TileIndex tile);

CommandCost EnsureNoTrainOnTrackBits(TileIndex tile, TrackBits track_bits);

bool CanVehicleUseStation(EngineID engine_type, const struct Station *st);

bool CanVehicleUseStation(const Vehicle *v, const struct Station *st);

	StringID GetCapacityString(RefitOption *option) const

	{

		assert(_current_company == _local_company);

		if (cost.Failed()) return INVALID_STRING_ID;

		SetDParam(0, option->cargo);

		Money money = cost.GetCost();

			SetDParam(2, CT_MAIL);

			if (this->order != INVALID_VEH_ORDER_ID) {

				/* No predictable cost */

				return STR_PURCHASE_INFO_AIRCRAFT_CAPACITY;

/**

 * This is the Callback method after the construction attempt of a primary vehicle

 * @param result indicates completion (or not) of the operation

 */

{

	if (result.Failed()) return;

	ShowVehicleViewWindow(v);

}