* DoCommand callback function for all commands executed by AIs.

 * @param cmd cmd as given to DoCommandPInternal.

 * @param result The result of the command.

 * @param data Command data as given to Command<>::Post.

 * @param result_data Additional returned data from the command.

 */

{

	/*

	 * The company might not exist anymore. Check for this.

	const Company *c = Company::GetIfValid(_current_company);

	if (c == nullptr || c->ai_instance == nullptr) return;

		c->ai_instance->Continue();

	}

}

 */

#define return_cmd_error(errcode) return CommandCost(errcode);

bool IsValidCommand(Commands cmd);

CommandFlags GetCommandFlags(Commands cmd);

	 * @param err_message Message prefix to show on error

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

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

	 * @param args Parameters for the command

	 * @return \c true if the command succeeded, else \c false.

	 */

	template <typename Tcallback>

	{

	}

	/**

	{

		auto args_tuple = std::forward_as_tuple(args...);

	}

	/**

			} else if constexpr (std::is_same_v<Tcallback, CommandCallbackData>) {

				/* Generic callback that takes packed arguments as a buffer. */

				if constexpr (std::is_same_v<Tret, CommandCost>) {

				} else {

				}

			} else if constexpr (!std::is_same_v<Tret, CommandCost> && std::is_same_v<Tcallback *, typename CommandTraits<Tcmd>::RetCallbackProc>) {

				std::apply(callback, std::tuple_cat(std::make_tuple(Tcmd), res));

		/* If we are in network, and the command is not from the network

		 * send it to the command-queue and abort execution. */

		if (send_net) {

			cur_company.Restore();

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

template <Commands Tcmd, typename Tret, typename... Targs>

struct CommandHelper<Tcmd, Tret(*)(DoCommandFlag, Targs...), false> : CommandHelper<Tcmd, Tret(*)(DoCommandFlag, Targs...), true>

{

	/**

	 * Shortcut for Post when not using a callback.

	 * commands that don't take a TileIndex by themselves.

	 * @param err_message Message prefix to show on error

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

	 * @param args Parameters for the command

	 * @return \c true if the command succeeded, else \c false.

	 */

#endif

template <Commands Tcmd>

#endif /* COMMAND_FUNC_H */

	CMD_DEITY     = 0x100, ///< the command may be executed by COMPANY_DEITY

	CMD_STR_CTRL  = 0x200, ///< the command's string may contain control strings

	CMD_NO_EST    = 0x400, ///< the command is never estimated.

};

DECLARE_ENUM_AS_BIT_SET(CommandFlags)

 * @param result_data Additional returned data from the command

 * @see CommandProc

 */

#endif /* COMMAND_TYPE_H */

 * DoCommand callback function for all commands executed by Game Scripts.

 * @param cmd cmd as given to DoCommandPInternal.

 * @param result The result of the command.

 * @param data Command data as given to Command<>::Post.

 * @param result_data Additional returned data from the command.

 */

{

		Game::GetGameInstance()->Continue();

	}

}

				uint id_g = this->group_sb->GetScrolledRowFromWidget(pt.y, this, WID_GL_LIST_GROUP);

				GroupID new_g = id_g >= this->groups.size() ? NEW_GROUP : this->groups[id_g]->index;

				break;

			}

 * @param err_message Message prefix to show on error

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

 * @param company The company that wants to send the command

 * @param cmd_data The command proc arguments.

 */

{

	CommandPacket c;

	c.company  = company;

	c.cmd      = cmd;

	c.err_msg  = err_message;

	c.callback = callback;

	c.data     = cmd_data;

	if (_network_server) {

	if (!IsValidCommand(cp->cmd))               return "invalid command";

	if (GetCommandFlags(cp->cmd) & CMD_OFFLINE) return "single-player only command";

	cp->err_msg = p->Recv_uint16();

	cp->data    = _cmd_dispatch[cp->cmd].Sanitize(p->Recv_buffer());

	byte callback = p->Recv_uint8();

	p->Send_uint8(cp->company);

	p->Send_uint16(cp->cmd);

	p->Send_uint16(cp->err_msg);

	p->Send_buffer(cp->data);

	size_t callback = FindCallbackIndex(cp->callback);

void UnpackNetworkCommand(const CommandPacket* cp)

{

	auto args = EndianBufferReader::ToValue<typename CommandTraits<Tcmd>::Args>(cp->data);

}

 */

struct CommandPacket {

	/** Make sure the pointer is nullptr. */

	CommandPacket *next; ///< the next command packet (if in queue)

	CompanyID company;   ///< company that is executing the command

	uint32 frame;        ///< the frame in which this packet is executed

	Commands cmd;              ///< command being executed.

	StringID err_msg;          ///< string ID of error message to use.

	CommandCallback *callback; ///< any callback function executed upon successful completion of the command.

	CommandDataBuffer data;    ///< command parameters.

};

CommandCost CmdMoveOrder(DoCommandFlag flags, VehicleID veh, VehicleOrderID moving_order, VehicleOrderID target_order);

CommandCost CmdClearOrderBackup(DoCommandFlag flags, TileIndex tile, ClientID user_id);

DEF_CMD_TRAIT(CMD_CLEAR_ORDER_BACKUP, CmdClearOrderBackup,  CMD_CLIENT_ID, CMDT_SERVER_SETTING)

template <typename Tcont, typename Titer>

CommandCost CmdTurnRoadVeh(DoCommandFlag flags, VehicleID veh_id);

#endif /* ROADVEH_CMD_H */

	return GetStorage()->mode_instance;

}

{

	ScriptStorage *s = GetStorage();

	s->last_data = data;

	s->last_cmd = cmd;

}

{

	ScriptStorage *s = GetStorage();

	if (s->last_cmd != cmd) return false;

	if (s->last_data != data) return false;

	return true;

	/**

	 * Store the latest command executed by the script.

	 */

	/**

	 * Check if it's the latest command executed by the script.

	 */

	/**

	 * Sets the DoCommand costs counter to a value.

	if constexpr ((::GetCommandFlags<Tcmd>() & CMD_CLIENT_ID) != 0) ScriptObjectInternal::SetClientIds(args, std::index_sequence_for<Targs...>{});

	/* Store the command for command callback validation. */

	/* Try to perform the command. */

	Tret res = ::Command<Tcmd>::Unsafe((StringID)0, networking ? ScriptObject::GetDoCommandCallback() : nullptr, false, estimate_only, tile, args);

	return this->engine->GetOpsTillSuspend();

}

{

	ScriptObject::ActiveInstance active(this);

		Debug(script, 1, "DoCommandCallback terminating a script, last command does not match expected command");

		return false;

	}

		ScriptObject::SetLastCost(result.GetCost());

	}

	return true;

}

	 * @param cmd cmd as given to DoCommandPInternal.

	 * @return true if we handled result.

	 */

	/**

	 * Insert an event for this script.

	uint last_error;                 ///< The last error of the command.

	bool last_command_res;           ///< The last result of the command.

	CommandDataBuffer last_data;     ///< The last data passed to a command.

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

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

		last_cost         (0),

		last_error        (STR_NULL),

		last_command_res  (true),

		last_cmd          (CMD_END),

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

		road_type         (INVALID_ROADTYPE),

DEF_CMD_TRAIT(CMD_FOUND_TOWN,       CmdFoundTown,      CMD_DEITY | CMD_NO_TEST,  CMDT_LANDSCAPE_CONSTRUCTION) // founding random town can fail only in exec run

DEF_CMD_TRAIT(CMD_RENAME_TOWN,      CmdRenameTown,     CMD_DEITY | CMD_SERVER,   CMDT_OTHER_MANAGEMENT)

DEF_CMD_TRAIT(CMD_TOWN_CARGO_GOAL,  CmdTownCargoGoal,  CMD_DEITY,                CMDT_OTHER_MANAGEMENT)

DEF_CMD_TRAIT(CMD_TOWN_GROWTH_RATE, CmdTownGrowthRate, CMD_DEITY,                CMDT_OTHER_MANAGEMENT)

DEF_CMD_TRAIT(CMD_TOWN_RATING,      CmdTownRating,     CMD_DEITY,                CMDT_OTHER_MANAGEMENT)

CommandCost CmdForceTrainProceed(DoCommandFlag flags, VehicleID veh_id);

CommandCost CmdReverseTrainDirection(DoCommandFlag flags, VehicleID veh_id, bool reverse_single_veh);

void CcBuildWagon(Commands cmd, const CommandCost &result, VehicleID new_veh_id, uint, uint16, CargoArray, TileIndex tile, EngineID, bool, CargoID, ClientID);

	if (found != nullptr) {

		found = found->Last();

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

		InvalidateWindowClassesData(WC_TRAINS_LIST, 0);

	}

}

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

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

void CcBuildPrimaryVehicle(Commands cmd, const CommandCost &result, VehicleID new_veh_id, uint, uint16, CargoArray);

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