test/Assets/PerfectWorld/Scripts/Network/UnityGameSession.cs

using BrewMonster;
using BrewMonster.Common;
using CSNetwork;
using CSNetwork.C2SCommand;
using CSNetwork.Protocols;
using CSNetwork.Protocols.RPCData;
using CSNetwork.Security;
using ModelRenderer.Scripts.Common;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using BrewMonster.Scripts.Task;
using UnityEngine;
using UnityEngine.SceneManagement;

namespace BrewMonster.Network
{
    // How to connect to the server: 
    // 1. Set the connection info
    // 2. Login
    public class UnityGameSession : MonoSingleton<UnityGameSession>
    {
        private GameSession _gameSession;

        private bool _isInitialized = false;
        private string _ip = "";
        private int _port = 0;
        private string _username = "";
        private string _password = "";

        CECStubbornFactionInfoSender m_stubbornFactionInfoSender;

#if UNITY_EDITOR
        public bool isDebg;
        private bool lastDebug;
        public void OnValidate()
        {
            if (isDebg != lastDebug)
            {
                _gameSession.IsDebug = isDebg;
                lastDebug =  isDebg;
            }
        }
#endif
        
        protected override void Awake()
        {
            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
            base.Awake();
        }
        private void Start()
        {
            CECNPC.InitStaticRes();
        }
        /// <summary>
        /// Send a 
        /// </summary>
        /// <param name="protocol"></param>
        /// <param name="complete"></param>
        public static void SendProtocol(Protocol protocol, Action complete = null)
        {
            if (!Instance._isInitialized)
            {
                return;
            }
            Instance._gameSession.SendProtocol(protocol, complete);
        }

        /// <summary>Set the connection info. This MUST be called call before login</summary>
        public static void SetConnectionInfo(string ip, int port)
        {
            BMLogger.Log($"Set connection info {ip} {port}");
            Instance._ip = ip;
            Instance._port = port;
        }
        public static void c2s_CmdCastSkill(int idSkill, byte byPVPMask, int iNumTarget, int aTargets)
        {
            Instance._gameSession.c2s_CmdCastSkill(idSkill, byPVPMask, iNumTarget, aTargets);
        }
        public static async Task Login(string username, string password, Action<bool> onLoginComplete = null)
        {
            Instance._username = username;
            Instance._password = password;

            if (Instance._ip == "" || Instance._port == 0)
            {
                BMLogger.LogError($"IP or port is not set {Instance._ip} {Instance._port}");
                onLoginComplete?.Invoke(false);
                return;
            }

            await Instance.ConnectAsync(Instance._ip, Instance._port);

            if (!Instance._gameSession.IsConnected)
            {
                BMLogger.LogError($"Failed to connect to {Instance._ip} {Instance._port}");
                onLoginComplete?.Invoke(false);
                return;
            }

            Instance._gameSession.LoginAsync(username, password, onLoginComplete);
        }
        public void c2s_SendCmdStopMove(in Vector3 vDest, float fSpeed, int iMoveMode,
                           byte byDir, ushort wStamp, int iTime)
        {
            Debug.LogWarning("HoangDev : c2s_SendCmdStopMove");
            Instance._gameSession.c2s_SendCmdStopMove(EC_Utility.ToNumerics(vDest), fSpeed, iMoveMode, byDir, wStamp, iTime);
        }
        public void c2s_CmdPlayerMove(in Vector3 vCurPos, in Vector3 vDest,
                             int iTime, float fSpeed, int iMoveMode, ushort wStamp)
        {
            Instance._gameSession.c2s_CmdPlayerMove(EC_Utility.ToNumerics(vCurPos), EC_Utility.ToNumerics(vDest), iTime, fSpeed, iMoveMode, wStamp);
        }
        protected override void Initialize()
        {
            BaseSecurity.Initizalize();
            ProtocolFactory.RegisterAllProtocols();
            _gameSession = new GameSession();
            #if UNITY_EDITOR
            var path = Application.dataPath.Substring(0, Application.dataPath.LastIndexOf("Assets"));
            #else
            var path = Application.persistentDataPath;
            #endif
            _gameSession.SetLogPath(Path.Combine(path, "Logs", "GameSession.log"));
            _isInitialized = true;

            DontDestroyOnLoad(gameObject);
        }
        public RoleInfo GetRoleInfo()
        {
            return _gameSession.GetRoleInfo();
        }
        /// <summary>Make sure username and password is set before calling this method</summary>
        private async Task ConnectAsync(string ip, int port)
        {
            if (!Instance._isInitialized)
            {
                BMLogger.LogError("GameSession is not initialized");
                return;
            }
            await Instance._gameSession.ConnectAsync(ip, port);
        }

        /// <summary>Get the list of created characters</summary>
        public static void GetRoleListAsync(Action<List<RoleInfo>> callback = null)
        {
            Instance._gameSession.GetRoleListAsync(callback);
        }

        public static void SelectRoleAsync(RoleInfo roleInfo, Action<RoleInfo> callback = null)
        {
            Instance._gameSession.SelectRoleAsync(roleInfo, callback);
        }
        public static void EnterWorldAsync(RoleInfo roleInfo, Action callback = null)
        {
            Debug.Log("EnterWorldAsync !!!!! nay ");
            Instance._gameSession.EnterWorldAsync(roleInfo, callback);
        }
        public static void SendChatData(byte cChannel, in string szMsg, int iPack, int iSlot)
        {

            Instance._gameSession.SendChatData(cChannel, szMsg, iPack, iSlot);
        }
        public static void RequestInventoryAsync(byte byPackage, Action callback = null)
        {
            Instance._gameSession.RequestInventoryAsync(byPackage, callback);
        }
        public static void RequesrQueryPlayerCash()
        {
            Instance._gameSession.RequestQueryPlayerCash();
        }
        public static void RequestDropEquipItem(byte index)
        {
            Instance._gameSession.RequestDropEquipItem(index);
        }
        public static void RequestEquipItemAsync(byte iIvtrIdx, byte iEquipIdx, Action callback = null)
        {
            Instance._gameSession.RequestEquipItem(iIvtrIdx, iEquipIdx, callback);
        }
        public static void RequestPickupItem(int idItem, int tid)
        {
            Instance._gameSession.RequestPickupItem(idItem, tid);
        }
        public static void RequestDropIvrtItem(byte index, int amount)
        {
            Instance._gameSession.RequestDropIvtrItem(index, amount);
        }
        public static void RequestCheckSecurityPassWd(string password)
        {
            Instance._gameSession.RequestCheckSecurityPassWd(password);
        } 
        public static void RequestReviveBase()
        {
            Instance._gameSession.RequestReviveBase();
        }
        public static void RequestReviveItem()
        {
            Instance._gameSession.RequestReviveItem();
        }
        public static void RequestReviveByPlayer()
        {
            Instance._gameSession.RequestReviveByPlayer();
        }

        public void RequestMallShopping(uint count, int good_id, int good_index, int good_pos)
        {
            var goods = new CMD_MallShopping.goods[]
            {
                new CMD_MallShopping.goods
                {
                    goods_id = good_id,
                    goods_index = good_index,
                    goods_pos = good_pos
                }
            };
            Instance._gameSession.RequestMallShopping(count, goods);
        }
        public static void RequestAllInventoriesAsync(Action callback = null, params byte[] packages)
        {
            if (packages == null || packages.Length == 0)
            {
                packages = new byte[] { 0, 1, 2 };
            }

            int remaining = packages.Length;
            Action onOneDone = () =>
            {
                remaining--;
                if (remaining <= 0)
                {
                    callback?.Invoke();
                }
            };

            foreach (var p in packages)
            {
                RequestInventoryAsync(p, onOneDone);
            }
        }

        public static void c2s_CmdNPCSevHello(int nid)
        {
            Instance._gameSession.c2s_SendCmdNPCSevHello(nid);
        }

        public static void c2s_CmdNormalAttack(byte byPVPMask)
        {
            Instance._gameSession.c2s_CmdNormalAttack(byPVPMask);
        }

        public static void c2s_CmdCancelAction()
        {
            Instance._gameSession.c2s_CmdCancelAction();
        }

        public static void c2s_CmdUnselect()
        {
            Instance._gameSession.c2s_CmdUnselect();
        }

        public static void c2s_CmdSelectTarget(int idTarget)
        {
            Instance._gameSession.c2s_CmdSelectTarget(idTarget);
        }
        public static void c2s_CmdNPCSevWaypoint()
        {
            Instance._gameSession.c2s_SendCmdNPCSevWaypoint();
        }

        public void GetFactionInfo(int iNumFaction, int[] aFactinoIDs)
        {
            m_stubbornFactionInfoSender.Add(iNumFaction, aFactinoIDs);
        }
        public static void c2s_CmdSendEnterPKPrecinct()
        {
            Instance._gameSession.c2s_CmdSendEnterPKPrecinctint();
        }

        public static void c2s_CmdNPCSevHeal()
        {

        }
        public static void c2s_CmdNPCSevAcceptTask(int idTask,int idStorage,int idRefreshItem)
        {
            Instance._gameSession.c2s_CmdNPCSevAcceptTask(idTask, idStorage, idRefreshItem);
        }

        public static void c2s_CmdNPCSevReturnTask(int idTask, int iChoice)
        {
            Instance._gameSession.c2s_SendCmdNPCSevReturnTask(idTask, iChoice);
        }

        public static void c2s_CmdNPCSevTaskMatter(int idTask)
        {
            Instance._gameSession.c2s_SendCmdNPCSevTaskMatter(idTask);
        }
        #region Task
        public static void c2s_CmdGetAllData(bool byPack, bool byEquip, bool byTask)
        {
            //Debug.Log("[Dat]- SendCmdGetAllData");
            Instance._gameSession.c2s_SendCmdGetAllData(byPack, byEquip, byTask);
        }

        public static void c2s_CmdTaskNotify( byte[] pBuf, uint sz)
        {
            Instance._gameSession.c2s_SendCmdTaskNotify( pBuf, sz);
        }
        
        #endregion

        public static void GetRoleBaseInfo(int iNumRole, List<int> aRoleIDs)
        {
            Instance._gameSession.GetRoleBaseInfo(iNumRole, aRoleIDs);
        }

        public static void GetRoleCustomizeData(int iNumRole, List<int> aRoleIDs)
        {
            Instance._gameSession.GetRoleCustomizeData(iNumRole, aRoleIDs);
        }

        public void LoadScene(string sceneName, LoadSceneMode mode, Action<bool> actDone)
        {
            StartCoroutine(LoadSceneCoroutine(sceneName, mode, actDone));
        }

        private IEnumerator LoadSceneCoroutine(string sceneName, LoadSceneMode mode, Action<bool> actDone)
        {
            AsyncOperation asyncLoad = SceneManager.LoadSceneAsync(sceneName, mode);
            asyncLoad.allowSceneActivation = false;
            while (!asyncLoad.isDone)
            {
                if (asyncLoad.progress >= 0.9f)
                {
                    asyncLoad.allowSceneActivation = true;
                }
                yield return null;
            }
            actDone?.Invoke(true);
        }

        void OnDestroy()
        {
            _gameSession.Disconnect();
            _gameSession.Dispose();
            CECNPC.ReleaseStaticRes();
        }
    }
}