/* Cost estimation is generally only done when the

	 * local user presses shift while doing somthing.

	 * However, in case of incoming network commands,

	 * map generation of the pause button we do want

	 * to execute. */

	bool estimate_only = _shift_pressed && IsLocalCompany() &&

			!IsGeneratingWorld() &&

			!(cmd & CMD_NETWORK_COMMAND) &&

			(cmd & CMD_ID_MASK) != CMD_PAUSE;

	/* We're only sending the command, so don't do

	 * fancy things for 'success'. */

	bool only_sending = _networking && !(cmd & CMD_NETWORK_COMMAND);

	/* Where to show the message? */

	CommandCost res = DoCommandPInternal(tile, p1, p2, cmd, callback, text, my_cmd, estimate_only);

	if (CmdFailed(res)) {

		res.SetGlobalErrorMessage();

		/* Only show the error when it's for us. */

		StringID error_part1 = GB(cmd, 16, 16);

		if (estimate_only || (IsLocalCompany() && error_part1 != 0 && my_cmd)) {

			ShowErrorMessage(error_part1, _error_message, x, y);

		}

	} else if (estimate_only) {

		ShowEstimatedCostOrIncome(res.GetCost(), x, y);

	} else if (!only_sending && res.GetCost() != 0 && tile != 0 && IsLocalCompany() && _game_mode != GM_EDITOR) {

		/* Only show the cost animation when we did actually

		 * execute the command, i.e. we're not sending it to

		 * the server, when it has cost the local company

		 * something. Furthermore in the editor there is no

		 * concept of cost, so don't show it there either. */

		ShowCostOrIncomeAnimation(x, y, GetSlopeZ(x, y), res.GetCost());

	}

	if (!estimate_only && !only_sending && callback != NULL) {

		callback(res, tile, p1, p2);

	}

	return CmdSucceeded(res);

}

/**

 * Helper to deduplicate the code for returning.

 * @param cmd   the command cost to return.

 * @param clear whether to keep the storage changes or not.

 */

#define return_dcpi(cmd, clear) { _docommand_recursive = 0; ClearStorageChanges(clear); return cmd; }

/*!

 * Helper function for the toplevel network safe docommand function for the current company.

 *

 * @param tile The tile to perform a command on (see #CommandProc)

 * @param p1 Additional data for the command (see #CommandProc)

 * @param p2 Additional data for the command (see #CommandProc)

 * @param cmd The command to execute (a CMD_* value)

 * @param callback A callback function to call after the command is finished

 * @param text The text to pass

 * @param my_cmd indicator if the command is from a company or server (to display error messages for a user)

 * @param estimate_only whether to give only the estimate or also execute the command

 * @return the command cost of this function.

 */

CommandCost DoCommandPInternal(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, CommandCallback *callback, const char *text, bool my_cmd, bool estimate_only)

{

	/* Prevent recursion; it gives a mess over the network */

	assert(_docommand_recursive == 0);

	_docommand_recursive = 1;

	/* Reset the state. */

	/* Get pointer to command handler */

	/* Shouldn't happen, but you never know when someone adds

	 * NULLs to the _command_proc_table. */

	assert(proc != NULL);

	if (tile != 0 && (tile >= MapSize() || (!IsValidTile(tile) && (cmd_flags & CMD_ALL_TILES) == 0))) return_dcpi(CMD_ERROR, false);

		return_dcpi(CMD_ERROR, false);

	bool test_and_exec_can_differ = (cmd_flags & CMD_NO_TEST) != 0;

	bool skip_test = _networking && (cmd & CMD_NO_TEST_IF_IN_NETWORK) != 0;

	/* Do we need to do a test run?

	 * Basically we need to always do this, except when

	 * the no-test-in-network flag is giving and we're

	 * in a network game (e.g. restoring orders would

	 * fail this test because the first order does not

	 * exist yet when inserting the second, giving that

	 * a wrong insert location and ignoring the command

	 * and thus breaking restoring). However, when we

	 * just want to do cost estimation we don't care

	 * because it's only done once anyway. */

	CommandCost res;

	if (estimate_only || !skip_test) {

		/* Test the command. */

		/* Make sure we're not messing things up here. */

		assert(cmd_id == CMD_COMPANY_CTRL || old_company == _current_company);

		/* If the command fails, we're doing an estimate

		 * or the player does not have enough money

		 * (unless it's a command where the test and

		 * execution phase might return different costs)

		 * we bail out here. */

		if (CmdFailed(res) || estimate_only ||

				(!test_and_exec_can_differ && !CheckCompanyHasMoney(res))) {

			return_dcpi(res, false);

		/* Don't return anything special here; no error, no costs.

		 * This way it's not handled by DoCommand and only the

		 * actual execution of the command causes messages. Also

		 * reset the storages as we've not executed the command. */

		return_dcpi(CommandCost(), false);

	/* Actually try and execute the command. If no cost-type is given

	 * use the construction one */

	CommandCost res2 = proc(tile, flags | DC_EXEC, p1, p2, text);

	/* Make sure nothing bad happened, like changing the current company. */

	assert(cmd_id == CMD_COMPANY_CTRL || old_company == _current_company);

	/* If the test and execution can differ, or we skipped the test

	 * we have to check the return of the command. Otherwise we can

	 * check whether the test and execution have yielded the same

	 * result, i.e. cost and error state are the same. */

	if (!test_and_exec_can_differ && !skip_test) {

		assert(res.GetCost() == res2.GetCost() && CmdFailed(res) == CmdFailed(res2)); // sanity check

	} else if (CmdFailed(res2)) {

		return_dcpi(res2, false);

	}

	/* If we're needing more money and we haven't done

	 * anything yet, ask for the money! */

	if (_additional_cash_required != 0 && res2.GetCost() == 0) {

		SetDParam(0, _additional_cash_required);

		return_dcpi(CommandCost(STR_ERROR_NOT_ENOUGH_CASH_REQUIRES_CURRENCY), false);

	}

	return_dcpi(res2, true);

#undef return_dcpi

/** Internal helper function for DoCommandP. Do not use. */

CommandCost DoCommandPInternal(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, CommandCallback *callback, const char *text, bool my_cmd, bool estimate_only);