#include "stdafx.h"

#include "openttd.h"

#include "player_func.h"

#include "debug.h"

#include "vehicle_gui.h"

#include "train.h"

#include "rail.h"

#include "command_func.h"

#include "engine_base.h"

#include "engine_func.h"

#include "vehicle_func.h"

#include "functions.h"

	return EnginesGotCargoInCommon(from, to, type);

}

/** Transfer cargo from a single (articulated )old vehicle to the new vehicle chain

 * @param old_veh Old vehicle that will be sold

 * @param new_head Head of the completely constructed new vehicle chain

 */

{

	/* Loop through source parts */

	for (Vehicle *src = old_veh; src != NULL; src = src->Next()) {

		if (src->cargo_type >= NUM_CARGO || src->cargo.Count() == 0) continue;

		/* Find free space in the new chain */

		for (Vehicle *dest = new_head; dest != NULL && src->cargo.Count() > 0; dest = dest->Next()) {

			if (dest->cargo_type != src->cargo_type) continue;

			uint amount = min(src->cargo.Count(), dest->cargo_cap - dest->cargo.Count());

			if (amount <= 0) continue;

			src->cargo.MoveTo(&dest->cargo, amount);

		}

	}

	/* Update train weight etc., the old vehicle will be sold anyway */

}

/**

 * Tests whether refit orders that applied to v will also apply to the new vehicle type

 * @param v The vehicle to be replaced

 * @param engine_type The type we want to replace with

}

/**

 * Function to find what type of cargo to refit to when autoreplacing

 * @param *v Original vehicle, that is being replaced

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

 * @return The cargo type to replace to

 *    CT_NO_REFIT is returned if no refit is needed

 *    CT_INVALID 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

 */

{

	CargoID cargo_type;

	if (GetUnionOfArticulatedRefitMasks(engine_type, v->type, true) == 0) return CT_NO_REFIT; // Don't try to refit an engine with no cargo capacity

	if (IsArticulatedVehicleCarryingDifferentCargos(v, &cargo_type)) return CT_INVALID; // We cannot refit to mixed cargos in an automated way

	uint32 available_cargo_types = GetIntersectionOfArticulatedRefitMasks(engine_type, v->type, true);

	if (cargo_type == CT_INVALID) {

		if (v->type != VEH_TRAIN) return CT_NO_REFIT; // If the vehicle does not carry anything at all, every replacement is fine.

		/* 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 */

		for (v = v->First(); v != NULL; v = v->Next()) {

			if (v->cargo_cap == 0) continue;

			/* Now we found a cargo type being carried on the train and we will see if it is possible to carry to this one */

		}

		return CT_NO_REFIT; // We failed to find a cargo type on the old vehicle and we will not refit the new one

	} else {

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

		/* Do we have to refit the vehicle, or is it already carrying the right cargo? */

		uint16 *default_capacity = GetCapacityOfArticulatedParts(engine_type, v->type);

		for (CargoID cid = 0; cid < NUM_CARGO; cid++) {

			if (cid != cargo_type && default_capacity[cid] > 0) return cargo_type;

		}

}

/** Builds and refits a replacement vehicle

 * Important: The old vehicle is still in the original vehicle chain (used for determining the cargo when the old vehicle did not carry anything, but the new one does)

 * @param old_veh A single (articulated/multiheaded) vehicle that shall be replaced.

 * @param new_vehicle Returns the newly build and refittet vehicle

 * @return cost or error

 */

{

	*new_vehicle = NULL;

	/* Shall the vehicle be replaced? */

	const Player *p = GetPlayer(_current_player);

	EngineID e = GetNewEngineType(old_veh, p);

	if (e == INVALID_ENGINE) return CommandCost(); // neither autoreplace is set, nor autorenew is triggered

	/* Does it need to be refitted */

	if (refit_cargo == CT_INVALID) return CommandCost(); // incompatible cargos

	/* Build the new vehicle */

	CommandCost cost = DoCommand(old_veh->tile, e, 0, DC_EXEC | DC_AUTOREPLACE, GetCmdBuildVeh(old_veh));

	if (cost.Failed()) return cost;

		ChangeVehicleViewWindow(old_head->index, new_head->index);

	}

	return cost;

}

/** Replace a whole vehicle chain

 * @param chain vehicle chain to let autoreplace/renew operator on

 * @param flags command flags

 * @param wagon_removal remove wagons when the resulting chain occupies more tiles than the old did

 * @param nothing_to_do is set to 'false' when something was done (only valid when not failed)

 * @return cost or error

 */

static CommandCost ReplaceChain(Vehicle **chain, uint32 flags, bool wagon_removal, bool *nothing_to_do)

{

	Vehicle *old_head = *chain;

	CommandCost cost = CommandCost(EXPENSES_NEW_VEHICLES, 0);

	if (old_head->type == VEH_TRAIN) {

		/* Store the length of the old vehicle chain, rounded up to whole tiles */

		uint16 old_total_length = (old_head->u.rail.cached_total_length + TILE_SIZE - 1) / TILE_SIZE * TILE_SIZE;

		int i;

		Vehicle *w;

		for (w = old_head, i = 0; w != NULL; w = GetNextUnit(w), i++) {

			assert(i < num_units);

			old_vehs[i] = w;

			cost.AddCost(ret);

			if (cost.Failed()) break;

			new_costs[i] = ret.GetCost();

			if (new_vehs[i] != NULL) *nothing_to_do = false;

		}

				for (int i = 0; i < num_units; i++) {

					Vehicle *w = old_vehs[i];

					/* Is the vehicle again part of the new chain?

					 * Note: We cannot test 'new_vehs[i] != NULL' as wagon removal might cause to remove both */

					if (w->First() == new_head) continue;

					cost.AddCost(DoCommand(0, w->index, 0, flags, GetCmdSellVeh(w)));

					if ((flags & DC_EXEC) != 0) {

						old_vehs[i] = NULL;

						if (i == 0) old_head = NULL;

					}

		free(old_vehs);

		free(new_vehs);

		free(new_costs);

	} else {

		/* Build and refit replacement vehicle */

		Vehicle *new_head = NULL;

		/* Was a new vehicle constructed? */

		if (cost.Succeeded() && new_head != NULL) {

			*nothing_to_do = false;

			/* The new vehicle is constructed, now take over orders and everything... */

			cost.AddCost(CopyHeadSpecificThings(old_head, new_head, flags));

			if (cost.Succeeded()) {

				/* The new vehicle is constructed, now take over cargo */

				if ((flags & DC_EXEC) != 0) {

					*chain = new_head;

				}

				/* Sell the old vehicle */

				cost.AddCost(DoCommand(0, old_head->index, 0, flags, GetCmdSellVeh(old_head)));

			}

		}

	}

	return cost;

}

 * @param tile not used

 * @param flags type of operation

 * @param p1 Index of vehicle

 * @param p2 not used

 */

CommandCost CmdAutoreplaceVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

	if (!IsValidVehicleID(p1)) return CMD_ERROR;

	Vehicle *v = GetVehicle(p1);

	if (!CheckOwnership(v->owner)) return CMD_ERROR;

	if (!v->IsInDepot()) return CMD_ERROR;

	if (HASBITS(v->vehstatus, VS_CRASHED)) return CMD_ERROR;

	const Player *p = GetPlayer(_current_player);

	bool wagon_removal = p->renew_keep_length;

	/* Test whether any replacement is set, before issuing a whole lot of commands that would end in nothing changed */

	Vehicle *w = v;

	bool any_replacements = false;

	while (w != NULL && !any_replacements) {

		any_replacements = (GetNewEngineType(w, p) != INVALID_ENGINE);

	}

	if (any_replacements) {

		/* Stop the vehicle */

		if (!was_stopped) cost.AddCost(StartStopVehicle(v, true));

		if (cost.Failed()) return cost;

		assert(v->IsStoppedInDepot());

		/* We have to construct the new vehicle chain to test whether it is valid.

		 * Vehicle construction needs random bits, so we have to save the random seeds

		 * to prevent desyncs and to replay newgrf callbacks during DC_EXEC */

		SavedRandomSeeds saved_seeds;

		SaveRandomSeeds(&saved_seeds);

		RestoreRandomSeeds(saved_seeds);

		if (cost.Succeeded() && (flags & DC_EXEC) != 0) {

			assert(ret.Succeeded() && ret.GetCost() == cost.GetCost());

		}

		/* Restart the vehicle */

		if (!was_stopped) cost.AddCost(StartStopVehicle(v, false));

	}