Как сделать Автологин Интерлюдия?

если окно не в фокусе. после логина что происходит норм?
 
LifeGame32 написал(а):
если окно не в фокусе. после логина что происходит норм?
Нажмите, чтобы раскрыть...
Всё работает нормально проверял, независимо от того, находится ли окно в фокусе или нет. Можно открыть сколько угодно окон, главное — не забывать менять логин и пароль в файле AutoLogin.ini".
 

это на каждое окно под разных чаров надо каждый раз вбивать логин и пароль?
 
CommandLineManager.h
C++: 
#pragma once

struct CommandLineConstants
{
    /** Auth login/password set from launcher params (Format: String - e.g. "-authdata login,password") */
    static constexpr wchar_t AuthData[] = L"authdata";
};

class CommandLineManager
{
    public:
        /**
        * No copying or copy assignment allowed for this class.
        */
        CommandLineManager(CommandLineManager const&) = delete;
        CommandLineManager& operator=(CommandLineManager const&) = delete;

        /**
        * Initialization using a string containing all params
        */
        void Init(const wchar_t* lp_cmd_line);

        /**
        * Initialization using a collection of params
        */
        void Init(const std::vector<std::wstring>& cmd_line_params);

        /**
        * Checks command line arguments for a matching param
        *
        * @param param - Parameter to look for in command line arguments
        *
        * @return True if param is found in command line arguments
        */
        bool HasParam(const std::wstring& param);

        /**
        * Retrieves value associated with given command line parameter
        *
        * @param param - Parameter to look for in command line arguments
        *
        * @return Value associated with command line parameter
        */
        std::wstring GetParamValue(const std::wstring& param);

        /**
        * Checks command line arguments for a matching flag param
        *
        * @param param - Parameter to look for in command line arguments
        *
        * @return True if param is found in command line arguments and it is a flag param value
        */
        bool HasFlagParam(const std::wstring& param);

        std::map<std::wstring, std::wstring> GetCommandLineArgs()
        {
            return command_line_args_;
        }

        /**
        * Singleton
        */
        static CommandLineManager& Get();

    private:
        CommandLineManager() = default;

        /** True if command line parser initialized */
        static bool IsInitialized;

        /** Gets a collection of sub-arguments from a string of one or two arguments */
        std::vector<std::wstring> GetSubArguments(const std::wstring& sub_arg_list);

        /** Add commandline params from a collection of arguments */
        void AddArguments(const std::vector<std::wstring>& arg_list);

        /**
         * Adds parameter name to collection of command line parameters
         *
         * @param param_name - Parameter name to add
         */
        void AddParam(const std::wstring& param_name);

        /** Collections of command line arguments */
        std::map<std::wstring, std::wstring> command_line_args_;
};

CommandLineManager.cpp
C++: 
#include <pch.h>
#include "CommandLineManager.h"

namespace
{
    const std::wstring FlagParamValue = L"__FLAG__";
    const std::wstring UnusedParamValue = L"unused";
}

bool CommandLineManager::IsInitialized = false;

CommandLineManager& CommandLineManager::Get()
{
    static CommandLineManager command_line_manager;
    if(!IsInitialized)
    {
        // Support for DLL's
        int arg_count = 0;
        const LPWSTR *arg_list = CommandLineToArgvW(GetCommandLine(), &arg_count);
       
        std::vector<std::wstring> output;
        output.reserve(arg_count);
        for(int i = 0; i < arg_count; i++)
        {
            output.emplace_back(arg_list[i]);
        }
        command_line_manager.Init(output);
    }
    return command_line_manager;
}

void CommandLineManager::Init(const std::vector<std::wstring>& cmd_line_params)
{
    if (!IsInitialized)
    {
        std::vector<std::wstring> args;
        for (std::wstring cmd_line_param : cmd_line_params)
        {
            for (const std::wstring& arg : GetSubArguments(cmd_line_param))
            {
                args.push_back(arg);
            }
        }
       
        AddArguments(args);
        IsInitialized = true;
    }
}

std::vector<std::wstring> CommandLineManager::GetSubArguments(const std::wstring& sub_arg_list)
{
    std::vector<std::wstring> args;
    if (const std::wstring::size_type sub_arg_equals_pos = sub_arg_list.find_first_of(L'='); sub_arg_equals_pos != std::wstring::npos)
    {
        // Add both args
        args.push_back(sub_arg_list.substr(0, sub_arg_equals_pos));
        args.push_back(sub_arg_list.substr(sub_arg_equals_pos + 1, sub_arg_list.length() - 1));
    }
    else
    {
        // Add single arg
        args.push_back(sub_arg_list);
    }
    return args;
}

void CommandLineManager::AddArguments(const std::vector<std::wstring>& arg_list)
{
    if (!arg_list.empty())
    {
        const std::wstring delimiters(L"-,;\\");
        std::wstring param_name;
        bool bPrevWasParamName = false;

        const int num_args = static_cast<int>(arg_list.size());

        for (int i = 0; i < num_args; i++)
        {
            std::wstring command_line_arg = arg_list[i];

            // Do we have a param name
            if (const std::wstring::size_type pos = command_line_arg.find_first_not_of(delimiters); pos > 0 && pos != std::wstring::npos)
            {
                if (bPrevWasParamName)
                {
                    // We have another param name so previous was a flag (no param value)
                    // Add a value to signify we have a flag param
                    AddParam(param_name);
                }

                param_name = command_line_arg;

                // strip out first part so we're left with just the param name
                param_name.erase(0, pos);

                if (i == num_args - 1)
                {
                    // Add final flag param
                    AddParam(param_name);
                }

                bPrevWasParamName = true;
                continue;
            }
           
            bPrevWasParamName = false;

            // Make sure we're not adding a duplicate
            if (auto it = command_line_args_.find({ param_name }); it == command_line_args_.end())
            {
                if (command_line_arg.empty())
                {
                    // Treat empty param value as a flag
                    command_line_args_.insert({ param_name, FlagParamValue });
                }
                else
                {
                    command_line_args_.insert({ param_name, command_line_arg });
                }
            }

            // Clear for next param
            param_name.clear();
        }
    }
}

void CommandLineManager::AddParam(const std::wstring& param_name)
{
    // Make sure we're not adding a duplicate
    if (const auto it = command_line_args_.find({ param_name }); it == command_line_args_.end())
    {
        command_line_args_.insert({ param_name, FlagParamValue });
    }
}

bool CommandLineManager::HasParam(const std::wstring& param)
{
    if (const auto itr = command_line_args_.find({ param }); itr != command_line_args_.end())
    {
        if (itr->second != UnusedParamValue)
        {
            return true;
        }
    }

    return false;
}

std::wstring CommandLineManager::GetParamValue(const std::wstring& param)
{
    if (const auto itr = command_line_args_.find({ param }); itr != command_line_args_.end())
    {
        return itr->second;
    }

    return std::wstring();
}

bool CommandLineManager::HasFlagParam(const std::wstring& param)
{
    if (const auto itr = command_line_args_.find({ param }); itr != command_line_args_.end())
    {
        return itr->second == FlagParamValue;
    }

    return false;
}

Пример использования:
C++: 
std::wstring AutoLogin_Login;
std::wstring AutoLogin_Password;
if (CommandLineManager::Get().HasParam(CommandLineConstants::AuthData))
{
     const std::wstring auth_string = CommandLineManager::Get().GetParamValue(CommandLineConstants::AuthData);
     if (std::vector<std::wstring> auth_data = StringUtils::Split(auth_string, ','); auth_data.size() >= 2)
     {
         AutoLogin_Login = auth_data[0];
         AutoLogin_Password = auth_data[1];
     }
}

Могут быть некоторые внешние зависимости, но я думаю вы там поймете что к чему.
 
LifeGame32 написал(а):
если окно не в фокусе. после логина что происходит норм?
Нажмите, чтобы раскрыть...
Я увидел твой пост в друг теме и понял о чем ты, но этот код для интерлюдии и HF подойдет, для выше хроник все можно сделать через интерфейс и UGX и будет работать стабильно.

 
есть ли способ импортировать функцию RequestLogin внутрь интерфейса, чтобы мы могли использовать ее там?
Таким образом, мы можем записывать/считывать файл автологина внутри интерфейса, и мы можем использовать его для нескольких учетных записей, а не только для одной.
 
Возможно, в будущем я планирую заниматься этим только под заказ. Или же, если кто-то из ребят захочет помочь, они могут это сделать, но не бесплатно.

Поскольку код уже опубликован, каждый желающий может попробовать самостоятельно разобраться, как это сделать. Я думаю, что в интернете нет более подробной информации по этому вопросу.

Пример для High Five, а также можно и для Interlude : Дизайн окон можно сделать любой!

 
решил попробовать - но не работает, вроде как бы и пишет что пароль не подходит, но акк и пароль я точно вписал верно))
мб длинна пароля 4 нуля ему не подходит?
 
Я проверил: ввёл логин из четырёх нулей и пароль — и успешно вошёл в систему.
 
AlhimN1 написал(а):
+
Нажмите, чтобы раскрыть...

В файле AutoLogin.ini должно быть указано следующее: если ваш логин и пароль — 0000, то введите их именно так, а если нет, то укажите свои данные.
Код: 
[AutoLogin]
Login=0000
Password=0000
 
 
ага, значит когда я его отредачил он загнулся

вот без редактирования
 
незнаю почему но при любом редактировании хоть нотпадом хоть чем - ломается он, какая там кодировка символов?
 
ставлю вот так
Код: 
[AutoLogin]

Login=admin

Password=0000

и всё-поломка)
 
Последнее редактирование:
ну ладно, чёто не хотит

мне вот интересно то что для автологина он используется библиотеку енти.длл т.е. как бы есть команда автозаполнения формы логин пароль


я вот делал батник
Код: 
l2 -login:<admin> -password:<0000>
но не работает в таком виде, мб есть вариант впихнуть сюда что то другое что бы акк и пароль уже были заполнены но не нажата кнопка логин
 
Войдите или зарегистрируйтесь для ответа.
Меню
Вход
Регистрация