使用基于C#的EOS SDK

void* Allocate(size_t InSizeInBytes, size_t InAlignment)
{
}

void* Reallocate(void* InPointer, size_t InSizeInBytes, size_t InAlignment)
{
}

void Release(void* InPointer)
{
}

typedef void* (*AllocateFunctionPointer)(size_t InSizeInBytes, size_t InAlignment);
extern "C" __declspec(dllexport) AllocateFunctionPointer GetAllocateFunctionPointer();
{
    return Allocate;
}

typedef void* (*ReallocateFunctionPointer)(void* InPointer, size_t InSizeInBytes, size_t InAlignment);
extern "C" __declspec(dllexport) ReallocateFunctionPointer GetReallocateFunctionPointer()
{
    return Reallocate;
}

typedef void (*ReleaseFunctionPointer)(void* InPointer);
extern "C" __declspec(dllexport) ReleaseFunctionPointer GetReleaseFunctionPointer()
{
    return Release;
}

[DllImport("MyNativeLibrary.dll")]
private static extern IntPtr GetAllocateFunctionPointer();

[DllImport("MyNativeLibrary.dll")]
private static extern IntPtr GetReallocateFunctionPointer();

[DllImport("MyNativeLibrary.dll")]
private static extern IntPtr GetReleaseFunctionPointer();

[DllImport("Kernel32.dll")]
private static extern IntPtr LoadLibrary(string lpLibFileName);

[DllImport("Kernel32.dll")]
private static extern int FreeLibrary(IntPtr hLibModule);

[DllImport("Kernel32.dll")]
private static extern IntPtr GetProcAddress(IntPtr hModule, string lpProcName);

var libraryPath = $"Assets/{Config.LibraryName}";

var libraryPointer = LoadLibrary(libraryPath);
if (libraryPointer == IntPtr.Zero)
{
    throw new Exception($"Failed to load library {libraryPath}");
}

Bindings.Hook(libraryPointer, GetProcAddress);

Bindings.Unhook();
FreeLibrary(libraryPointer);

    // 根据需要设置这些值。有关更多信息，参见开发人员门户文档。
    string productName = "MyCSharpApplication";
    string productVersion = "1.0";
    string productId = "";
    string sandboxId = "";
    string deploymentId = "";
    string clientId = "";
    string clientSecret = "";

    var initializeOptions = new Epic.OnlineServices.Platform.InitializeOptions()
    {
        ProductName = productName,
        ProductVersion = productVersion
    };

    var initializeResult = Epic.OnlineServices.Platform.PlatformInterface.Initialize(initializeOptions);
    if (initializeResult != Epic.OnlineServices.Result.Success)
    {
        throw new System.Exception("Failed to initialize platform: " + initializeResult);
    }

    // SDK输出很多用于调试的信息。
    // 确保尽早设置日志记录界面：在初始化之后。
    Epic.OnlineServices.Logging.LoggingInterface.SetLogLevel(Epic.OnlineServices.Logging.LogCategory.AllCategories, Epic.OnlineServices.Logging.LogLevel.VeryVerbose);
    Epic.OnlineServices.Logging.LoggingInterface.SetCallback((Epic.OnlineServices.Logging.LogMessage logMessage) =>
    {
        System.Console.WriteLine(logMessage.Message);
    });

    var options = new Epic.OnlineServices.Platform.Options()
    {
        ProductId = productId,
        SandboxId = sandboxId,
        DeploymentId = deploymentId,
        ClientCredentials = new Epic.OnlineServices.Platform.ClientCredentials()
        {
            ClientId = clientId,
            ClientSecret = clientSecret
        }
    };

    var platformInterface = Epic.OnlineServices.Platform.PlatformInterface.Create(options);
    if (platformInterface == null)
    {
        throw new System.Exception("Failed to create platform");
    }

    var loginCredentialType = Epic.OnlineServices.Auth.LoginCredentialType.AccountPortal;
    /// 这些字段对应于<see cref="Epic.OnlineServices.Auth.Credentials.Id" />和<see cref="Epic.OnlineServices.Auth.Credentials.Token" />,
    /// 它们的用途因登录类型而异。有关更多信息，参见<see cref="Epic.OnlineServices.Auth.Credentials" />
    /// 和身份验证界面文档。
    string loginCredentialId = null;
    string loginCredentialToken = null;

    var authInterface = platformInterface.GetAuthInterface();
    if (authInterface == null)
    {
        throw new System.Exception("Failed to get auth interface");
    }

    var loginOptions = new Epic.OnlineServices.Auth.LoginOptions()
    {
        Credentials = new Epic.OnlineServices.Auth.Credentials()
        {
            Type = loginCredentialType,
            Id = loginCredentialId,
            Token = loginCredentialToken
        }
    };

    // 确保按一定间隔调用平台更新函数，否则以下调用将永远不会回调。
    authInterface.Login(loginOptions, null, (Epic.OnlineServices.Auth.LoginCallbackInfo loginCallbackInfo) =>
    {
        if (loginCallbackInfo.ResultCode == Epic.OnlineServices.Result.Success)
        {
            System.Console.WriteLine("Login succeeded");
        }
        else if (Epic.OnlineServices.Common.IsOperationComplete(loginCallbackInfo.ResultCode))
        {
            System.Console.WriteLine("Login failed: " + loginCallbackInfo.ResultCode);
        }
    });

    // 此代码用于演示目的，并不代表理想实践。
    using Epic.OnlineServices;
    using Epic.OnlineServices.Auth;
    using Epic.OnlineServices.Logging;
    using Epic.OnlineServices.Platform;
    using System;
    using System.Runtime.InteropServices;
    using UnityEngine;

    public class EOSSDKComponent : MonoBehaviour
    {
        // 根据需要设置这些值。有关更多信息，参见开发人员门户文档。
        public string m_ProductName = "MyUnityApplication";
        public string m_ProductVersion = "1.0";
        public string m_ProductId = "";
        public string m_SandboxId = "";
        public string m_DeploymentId = "";
        public string m_ClientId = "";
        public string m_ClientSecret = "";
        public LoginCredentialType m_LoginCredentialType = LoginCredentialType.AccountPortal;
        /// 这些字段对应于<see cref="Credentials.Id" />和<see cref="Credentials.Token" />,
        /// 它们的用途因登录类型而异。有关更多信息，参见<see cref="Credentials" />
        /// 和身份验证界面文档。
        public string m_LoginCredentialId = null;
        public string m_LoginCredentialToken = null;

        private static PlatformInterface s_PlatformInterface;
        private const float c_PlatformTickInterval = 0.1f;
        private float m_PlatformTickTimer = 0f;

        // 如果我们处于编辑器中，我们应该在运行会话之间动态加载和卸载SDK。
        // 这样每次在编辑器中运行游戏时我们就可以初始化SDK。
    #if UNITY_EDITOR
        [DllImport("Kernel32.dll")]
        private static extern IntPtr LoadLibrary(string lpLibFileName);

        [DllImport("Kernel32.dll")]
        private static extern int FreeLibrary(IntPtr hLibModule);

        [DllImport("Kernel32.dll")]
        private static extern IntPtr GetProcAddress(IntPtr hModule, string lpProcName);

        private IntPtr m_LibraryPointer;
    #endif

        private void Awake()
        {
    #if UNITY_EDITOR
            var libraryPath = "Assets/" + Config.LibraryName;

            m_LibraryPointer = LoadLibrary(libraryPath);
            if (m_LibraryPointer == IntPtr.Zero)
            {
                throw new Exception("Failed to load library" + libraryPath);
            }

            Bindings.Hook(m_LibraryPointer, GetProcAddress);
    #endif
        }

        private void OnApplicationQuit()
        {
            if (s_PlatformInterface != null)
            {
                s_PlatformInterface.Release();
                s_PlatformInterface = null;
                PlatformInterface.Shutdown();
            }

    #if UNITY_EDITOR
            if (m_LibraryPointer != IntPtr.Zero)
            {
                            Bindings.Unhook();

                                        // 闲置，直到模块ref计数为0
                while (FreeLibrary(m_LibraryPointer) != 0) { }
                m_LibraryPointer = IntPtr.Zero;
            }
    #endif
        }

        void Start()
        {
            var initializeOptions = new InitializeOptions()
            {
                ProductName = m_ProductName,
                ProductVersion = m_ProductVersion
            };

            var initializeResult = PlatformInterface.Initialize(initializeOptions);
            if (initializeResult != Result.Success)
            {
                throw new Exception("Failed to initialize platform: " + initializeResult);
            }

            // SDK输出很多用于调试的信息。
            // 确保尽早设置日志记录界面：在初始化之后。
            LoggingInterface.SetLogLevel(LogCategory.AllCategories, LogLevel.VeryVerbose);
            LoggingInterface.SetCallback((LogMessage logMessage) => Debug.Log(logMessage.Message));

            var options = new Options()
            {
                ProductId = m_ProductId,
                SandboxId = m_SandboxId,
                DeploymentId = m_DeploymentId,
                ClientCredentials = new ClientCredentials()
                {
                    ClientId = m_ClientId,
                    ClientSecret = m_ClientSecret
                }
            };

            s_PlatformInterface = PlatformInterface.Create(options);
            if (s_PlatformInterface == null)
            {
                throw new Exception("Failed to create platform");
            }

            var loginOptions = new LoginOptions()
            {
                Credentials = new Credentials()
                {
                    Type = m_LoginCredentialType,
                    Id = m_LoginCredentialId,
                    Token = m_LoginCredentialToken
                }
            };

            // 确保按一定间隔调用平台更新函数，否则不会回调此内容。
            s_PlatformInterface.GetAuthInterface().Login(loginOptions, null, (LoginCallbackInfo loginCallbackInfo) =>
            {
                if (loginCallbackInfo.ResultCode == Result.Success)
                {
                    Debug.Log("Login succeeded");
                }
                else if (Common.IsOperationComplete(loginCallbackInfo.ResultCode))
                {
                    Debug.Log("Login failed: " + loginCallbackInfo.ResultCode);
                }
            });
        }

        // 回调运行需要按一定间隔调用更新函数。
        private void Update()
        {
            if (s_PlatformInterface != null)
            {
                m_PlatformTickTimer += Time.deltaTime;

                if (m_PlatformTickTimer >= c_PlatformTickInterval)
                {
                    m_PlatformTickTimer = 0;
                    s_PlatformInterface.Tick();
                }
            }
        }
    }