XiuXianProject/GameClient/Assets/Game/HotUpdate/ETCodes/Hotfix/App/Login/LoginHelper.cs

using System;
using GFGGame;
using UnityEngine;

namespace ET
{
    public static class LoginHelper
    {
        public static async ETTask<(int, long)> H5Login(Scene zoneScene, string address, Action<int> callback)
        {
            A2C_LoginAccount a2CLoginAccount = null;
            Session accountSession = null;
            try
            {
                Debug.Log($"address:{address}");
                accountSession = zoneScene.GetComponent<NetWSComponent>()
                    .Create(null, address);

                a2CLoginAccount = (A2C_LoginAccount)await accountSession.Call(new C2A_H5Login()
                {
                    user_id = QDJGameManager.Instance.UserId,
                    user_name = QDJGameManager.Instance.UserName,
                    uuid = QDJGameManager.Instance.Uuid,
                    sign = QDJGameManager.Instance.Sign,
                    timestamp = QDJGameManager.Instance.Timestamp,
                    cp_ext = QDJGameManager.Instance.CpExt,
                    Version = GameConst.SERVER_VERSION,
                    PlatformId = LauncherConfig.platformId,
                    ChannelId = LauncherConfig.ChannelId,
                    CancelDelete = false,
                });
            }
            catch (Exception e)
            {
                Log.Debug("打印报错:" + e.ToString());
                return (ErrorCode.ERR_NetWorkError, 0);
            }

            if (a2CLoginAccount.Error != ErrorCode.ERR_Success)
            {
                return (a2CLoginAccount.Error, a2CLoginAccount.DeleteTime);
            }

            OnLoginSuccess(zoneScene, a2CLoginAccount, accountSession, QDJGameManager.Instance.UserId);
            callback?.Invoke(a2CLoginAccount.Error);
            return (ErrorCode.ERR_Success, 0);
        }

        public static async ETTask<(int, long)> Login(Scene zoneScene, string address, string account, string password,
            bool isMD5, bool cancelDelete)
        {
            A2C_LoginAccount a2CLoginAccount = null;
            Session accountSession = null;
            try
            {
                accountSession = zoneScene.GetComponent<NetWSComponent>()
                    .Create(null, address);
                var passwordMD5 = password;
                //密码禁止明文传输
                if (!isMD5)
                {
                    passwordMD5 = MD5Helper.stringMD5(password);
                }

                a2CLoginAccount = (A2C_LoginAccount)await accountSession.Call(new C2A_LoginAccount()
                {
                    Account = account,
                    Password = passwordMD5,
                    Version = GameConst.SERVER_VERSION,
                    PlatformId = LauncherConfig.platformId,
                    ChannelId = LauncherConfig.ChannelId,
                    CancelDelete = cancelDelete
                });
            }
            catch (Exception e)
            {
                //accountSession?.Dispose();
                Log.Debug(e.ToString());
                return (ErrorCode.ERR_NetWorkError, 0);
            }

            if (a2CLoginAccount.Error != ErrorCode.ERR_Success)
            {
                //accountSession?.Dispose();
                return (a2CLoginAccount.Error, a2CLoginAccount.DeleteTime);
            }

            OnLoginSuccess(zoneScene, a2CLoginAccount, accountSession, account);

            return (ErrorCode.ERR_Success, 0);
        }

        public static void OnLoginSuccess(Scene zoneScene, A2C_LoginAccount a2CLoginAccount, Session accountSession,
            string account)
        {
            zoneScene.GetComponent<SessionComponent>().AccountSession = accountSession;
            accountSession.AddComponent<PingComponent>();
            accountSession.AddComponent<DisConnectedCompnent>().SessionState = SessionState.Login;
            zoneScene.GetComponent<SessionComponent>().SessionState = SessionState.Login;
            AccountInfoComponent accountInfoComponent = zoneScene.GetComponent<AccountInfoComponent>();
            accountInfoComponent.Token = a2CLoginAccount.Token;
            accountInfoComponent.AccountId = a2CLoginAccount.AccountId;
            accountInfoComponent.Account = account;
            accountInfoComponent.Age = a2CLoginAccount.Age;
            GameGlobal.userAge =  a2CLoginAccount.Age;
        }

        public static async ETTask<int> Register(Scene zoneScene, string address, string account, string password,
            string name, string identityNum, string code)
        {
            A2C_Register r2C_Register = null;
            Session session = null;
            try
            {
                session = zoneScene.GetComponent<NetWSComponent>().Create(null, address);
                {
                    //密码禁止明文传输
                    var passwordMD5 = MD5Helper.stringMD5(password);
                    r2C_Register = (A2C_Register)await session.Call(new C2A_Register()
                    {
                        Account = account,
                        Password = passwordMD5,
                        Name = name,
                        IdentityNum = identityNum,
                        Code = code,
                        PlatformId = LauncherConfig.platformId,
                        ChannelId = LauncherConfig.ChannelId
                    });
                    if (r2C_Register.Error != ErrorCode.ERR_Success)
                    {
                        return r2C_Register.Error;
                    }
                }
            }
            catch (Exception e)
            {
                //session?.Dispose();
                Log.Debug(e.ToString());
                return ErrorCode.ERR_NetWorkError;
            }

            return ErrorCode.ERR_Success;
        }

        public static async ETTask<int> GetServerInfos(Scene zoneScene)
        {
            A2C_GetServerInfos a2C_GetServerInfos = null;

            try
            {
                a2C_GetServerInfos = (A2C_GetServerInfos)await zoneScene.GetComponent<SessionComponent>().AccountSession
                    ?.Call(new C2A_GetServerInfos()
                    {
                        AccountId = zoneScene.GetComponent<AccountInfoComponent>().AccountId,
                        Token = zoneScene.GetComponent<AccountInfoComponent>().Token
                    });
            }
            catch (Exception e)
            {
                Log.Debug(e.ToString());
                return ErrorCode.ERR_NetWorkError;
            }

            if (a2C_GetServerInfos.Error != ErrorCode.ERR_Success)
            {
                return a2C_GetServerInfos.Error;
            }

            zoneScene.GetComponent<ServerInfosComponent>()?.ServerInfoList?.Clear();
            foreach (var serverInfoProto in a2C_GetServerInfos.ServerInfosList)
            {
                ServerInfo serverInfo = zoneScene.GetComponent<ServerInfosComponent>().AddChild<ServerInfo>();
                serverInfo.FromMessage(serverInfoProto);
                zoneScene.GetComponent<ServerInfosComponent>().Add(serverInfo);
            }

            zoneScene.GetComponent<ServerInfosComponent>().SetRecentlyServerInfo(a2C_GetServerInfos.RecentId);

            await ETTask.CompletedTask;
            return ErrorCode.ERR_Success;
        }

        public static async ETTask<int> GetRoles(Scene zoneScene)
        {
            A2C_GetRoles a2C_GetRoles = null;

            try
            {
                a2C_GetRoles = (A2C_GetRoles)await zoneScene.GetComponent<SessionComponent>().AccountSession.Call(
                    new C2A_GetRoles()
                    {
                        AccountId = zoneScene.GetComponent<AccountInfoComponent>().AccountId,
                        Token = zoneScene.GetComponent<AccountInfoComponent>().Token,
                        ServerId = zoneScene.GetComponent<ServerInfosComponent>().CurrentServerId,
                    });
            }
            catch (Exception e)
            {
                Log.Debug(e.ToString());
                return ErrorCode.ERR_NetWorkError;
            }

            if (a2C_GetRoles.Error != ErrorCode.ERR_Success)
            {
                //Log.Error(a2C_GetRoles.Error.ToString());
                return a2C_GetRoles.Error;
            }

            zoneScene.GetComponent<RoleInfosComponent>().RoleInfos.Clear();
            foreach (var roleInfoProto in a2C_GetRoles.RoleInfos)
            {
                RoleInfo roleInfo = zoneScene.GetComponent<RoleInfosComponent>().AddChild<RoleInfo>();
                roleInfo.FromMessage(roleInfoProto);
                zoneScene.GetComponent<RoleInfosComponent>().RoleInfos.Add(roleInfo);
            }

            return ErrorCode.ERR_Success;
        }

        public static async ETTask<int> CreateRole(Scene zoneScene, string name)
        {
            A2C_CreateRole a2C_CreateRole = null;
            try
            {
                a2C_CreateRole = (A2C_CreateRole)await zoneScene.GetComponent<SessionComponent>().AccountSession?.Call(
                    new C2A_CreateRole
                    {
                        AccountId = zoneScene.GetComponent<AccountInfoComponent>().AccountId,
                        Token = zoneScene.GetComponent<AccountInfoComponent>().Token,
                        Name = name,
                        ServerId = zoneScene.GetComponent<ServerInfosComponent>().CurrentServerId,
                    });
            }
            catch (Exception e)
            {
                Log.Debug(e.ToString());
                return ErrorCode.ERR_NetWorkError;
            }

            if (a2C_CreateRole.Error != ErrorCode.ERR_Success)
            {
                //Log.Error(a2C_CreateRole.Error.ToString());
                return a2C_CreateRole.Error;
            }

            RoleInfo newRoleInfo = zoneScene.GetComponent<RoleInfosComponent>().AddChild<RoleInfo>();
            newRoleInfo.FromMessage(a2C_CreateRole.RoleInfo);
            zoneScene.GetComponent<RoleInfosComponent>().RoleInfos.Add(newRoleInfo);

            return ErrorCode.ERR_Success;
        }

        public static async ETTask<int> DeleteRole(Scene zoneScene, long roleId)
        {
            A2C_DeleteRole a2C_DeleteRole = null;

            try
            {
                a2C_DeleteRole = (A2C_DeleteRole)await zoneScene.GetComponent<SessionComponent>().AccountSession?.Call(
                    new C2A_DeleteRole()
                    {
                        AccountId = zoneScene.GetComponent<AccountInfoComponent>().AccountId,
                        Token = zoneScene.GetComponent<AccountInfoComponent>().Token,
                        RoleInfoId = roleId,
                        ServerId = zoneScene.GetComponent<ServerInfosComponent>().CurrentServerId,
                    });
            }
            catch (Exception e)
            {
                Log.Debug(e.ToString());
                return ErrorCode.ERR_NetWorkError;
            }

            if (a2C_DeleteRole.Error != ErrorCode.ERR_Success)
            {
                //Log.Error(a2C_DeleteRole.Error.ToString());
                return a2C_DeleteRole.Error;
            }

            int index = zoneScene.GetComponent<RoleInfosComponent>().RoleInfos.FindIndex((info) =>
            {
                return info.Id == a2C_DeleteRole.DeleteRoleInfoId;
            });
            zoneScene.GetComponent<RoleInfosComponent>().RoleInfos.RemoveAt(index);

            await ETTask.CompletedTask;
            return ErrorCode.ERR_Success;
        }

        public static async ETTask<int> GetRealmKey(Scene zoneScene)
        {
            A2C_GetRealmKey a2C_GetRealmKey = null;

            try
            {
                a2C_GetRealmKey = (A2C_GetRealmKey)await zoneScene.GetComponent<SessionComponent>().AccountSession
                    ?.Call(new C2A_GetRealmKey()
                    {
                        AccountId = zoneScene.GetComponent<AccountInfoComponent>().AccountId,
                        Token = zoneScene.GetComponent<AccountInfoComponent>().Token,
                        ServerId = zoneScene.GetComponent<ServerInfosComponent>().CurrentServerId,
                    });
            }
            catch (Exception e)
            {
                Log.Debug(e.ToString());
                return ErrorCode.ERR_NetWorkError;
            }

            if (a2C_GetRealmKey.Error != ErrorCode.ERR_Success)
            {
                //Log.Error(a2C_GetRealmKey.Error.ToString());
                return a2C_GetRealmKey.Error;
            }

            zoneScene.GetComponent<AccountInfoComponent>().RealmKey = a2C_GetRealmKey.RealmKey;
            zoneScene.GetComponent<AccountInfoComponent>().RealmAddress = a2C_GetRealmKey.RealmAddress;
            //zoneScene.GetComponent<SessionComponent>().DisconnectAccount();

            await ETTask.CompletedTask;
            return ErrorCode.ERR_Success;
        }

        public static async ETTask<int> EnterGame(Scene zoneScene)
        {
            string realmAddress = zoneScene.GetComponent<AccountInfoComponent>().RealmAddress;
            //1.连接Realm，获取分配的Gate
            R2C_LoginRealm r2C_LoginRealm = null;

            Session session = zoneScene.GetComponent<NetWSComponent>()
                .Create(null, realmAddress);
            try
            {
                r2C_LoginRealm = (R2C_LoginRealm)await session.Call(new C2R_LoginRealm()
                {
                    AccountId = zoneScene.GetComponent<AccountInfoComponent>().AccountId,
                    RealmTokenKey = zoneScene.GetComponent<AccountInfoComponent>().RealmKey
                });
            }
            catch (Exception e)
            {
                Log.Debug(e.ToString());
                //session?.Dispose();
                return ErrorCode.ERR_NetWorkError;
            }

            //session?.Dispose();

            if (r2C_LoginRealm.Error != ErrorCode.ERR_Success)
            {
                return r2C_LoginRealm.Error;
            }

            LogUtil.LogDev($"GateAddress : {r2C_LoginRealm.GateAddress}");
            Session gateSession = zoneScene.GetComponent<NetWSComponent>()
                .Create(null, r2C_LoginRealm.GateAddress);
            gateSession.AddComponent<PingComponent>();
            gateSession.AddComponent<DisConnectedCompnent>().SessionState = SessionState.Gate;
            zoneScene.GetComponent<SessionComponent>().GateSession = gateSession;
            zoneScene.GetComponent<SessionComponent>().SessionState = SessionState.Gate;

            //2.开始连接Gate
            long currentRoleId = zoneScene.GetComponent<RoleInfosComponent>().CurrentRoleId;
            G2C_LoginGate g2C_LoginGate = null;
            try
            {
                long accountId = zoneScene.GetComponent<AccountInfoComponent>().AccountId;
                g2C_LoginGate = (G2C_LoginGate)await gateSession.Call(new C2G_LoginGate()
                {
                    Key = r2C_LoginRealm.GateSessionKey,
                    AccountId = accountId,
                    RoleId = currentRoleId
                });
            }
            catch (Exception e)
            {
                Log.Debug(e.ToString());
                //zoneScene.GetComponent<SessionComponent>().GateSession?.Dispose();
                return ErrorCode.ERR_NetWorkError;
            }

            if (g2C_LoginGate.Error != ErrorCode.ERR_Success)
            {
                //zoneScene.GetComponent<SessionComponent>().GateSession?.Dispose();
                return g2C_LoginGate.Error;
            }

            LogUtil.LogDev("登陆gate成功！");

            //3.角色正式请求进入游戏逻辑服
            G2C_EnterGame g2C_EnterGame = null;
            try
            {
                g2C_EnterGame = (G2C_EnterGame)await gateSession.Call(new C2G_EnterGame() { });
            }
            catch (Exception e)
            {
                Log.Debug(e.ToString());
                //zoneScene.GetComponent<SessionComponent>().GateSession.Dispose();
                return ErrorCode.ERR_NetWorkError;
            }

            if (g2C_EnterGame.Error != ErrorCode.ERR_Success)
            {
                //Log.Error(g2C_EnterGame.Error.ToString());
                return g2C_EnterGame.Error;
            }

            zoneScene.GetComponent<PlayerComponent>().MyId = g2C_EnterGame.MyId;
            var result = await GameGlobal.zoneScene.GetComponent<ObjectWait>()
                .Wait<ET.WaitType.Wait_SceneChangeStart>();
            if (result.Error == WaitTypeError.Cancel)
            {
                return ErrorCode.ERR_Cancel;
            }

            LogUtil.LogDev("角色进入游戏成功！");
            return ErrorCode.ERR_Success;
        }

        public static async ETTask<int> ReqGetLatestNotice()
        {
            A2C_GetLatestNotice response = null;
            try
            {
                response = (A2C_GetLatestNotice)await GameGlobal.zoneScene.GetComponent<SessionComponent>()
                    .AccountSession?.Call(new C2A_GetLatestNotice());
            }
            catch (Exception e)
            {
                Log.Debug(e.ToString());
                return ErrorCode.ERR_NetWorkError;
            }

            if (response.Error != ErrorCode.ERR_Success)
            {
                //Log.Error(response.Error.ToString());
                return response.Error;
            }

            NoticeInfo noticeInfo = new NoticeInfo();
            noticeInfo.noticeId = response.NoticeId;
            noticeInfo.title = response.Title;
            noticeInfo.time = response.TimeSec * 1000;
            noticeInfo.content = response.Content;

            NoticeDataManager.Instance.LastNoticeInfo = noticeInfo;

            return ErrorCode.ERR_Success;
        }

        public static async ETTask<(int, string)> ReqRandomRoleName()
        {
            A2C_GetRandomRoleName response = null;
            bool notLogin = false;
            Session accountSession = GameGlobal.zoneScene.GetComponent<SessionComponent>().AccountSession;
            if (accountSession == null || accountSession.IsDisposed)
            {
                notLogin = true;
                accountSession = GameGlobal.zoneScene.GetComponent<NetWSComponent>()
                    .Create(null, GameConfig.LoginAddress);
            }

            try
            {
                response = (A2C_GetRandomRoleName)await accountSession?.Call(new C2A_GetRandomRoleName()
                {
                    ServerId = GameGlobal.zoneScene.GetComponent<ServerInfosComponent>().CurrentServerId
                });
            }
            catch (Exception e)
            {
                Log.Debug(e.ToString());
                if (notLogin)
                {
                    // accountSession?.Dispose();
                }

                return (ErrorCode.ERR_NetWorkError, "");
            }

            if (response.Error != ErrorCode.ERR_Success)
            {
                //Log.Error(response.Error.ToString());
                if (notLogin)
                {
                    //accountSession?.Dispose();
                }

                return (ErrorCode.ERR_NetWorkError, "");
            }

            if (notLogin)
            {
                //accountSession?.Dispose();
            }

            return (ErrorCode.ERR_Success, response.Name);
        }

        //玩家信息登记
        public static async ETTask<int> RegisterRoleInfo(Scene zoneScene, string account,
            string password,
            string name, string identityNum, string code, string phoneNumber)
        {
            var passwordMD5 = MD5Helper.stringMD5(password);
            M2C_RegisterRoleInfo response = (M2C_RegisterRoleInfo)await MessageHelper.SendToServer(
                new C2M_RegisterRoleInfo
                {
                    PhoneNumber = phoneNumber,
                    VerificationCode = code,
                    Account = account,
                    Password = passwordMD5,
                    IdCard = identityNum,
                    CardName = name
                });
            if (response.Error != ErrorCode.ERR_Success)
            {
                return response.Error;
            }
            else
            {
                BonusController.TryShowBonusList(ItemUtil.CreateItemDataList(response.RewardList));
            }

            return ErrorCode.ERR_Success;
        }
    }
}