fix：1、添加项目。2、基本箭头生成

Assets/ChillConnect/ToolKit/AnimationCurveData.cs

@@ -0,0 +1,24 @@
+
+using ChillConnect;
+using UnityEngine;
+
+public sealed class AnimationCurveData : ScriptableObject
+{
+    private static AnimationCurveData instance;
+
+    public static AnimationCurveData Instance
+    {
+        get
+        {
+            if (instance == null)
+            {
+                instance = LoadKit.Instance.LoadAsset<AnimationCurveData>("Data.ScriptableObjectData",
+                    "AnimationCurveData");
+            }
+
+            return instance;
+        }
+    }
+
+    public AnimationCurve LuckySpinAniCurve;
+}

Assets/ChillConnect/ToolKit/AnimationCurveData.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b0a921ff368c47588249df420aa52091
+timeCreated: 1704964086

Assets/ChillConnect/ToolKit/Base64EncodeUtil.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Text;
+
+namespace FutureCore
+{
+    public static class Base64EncodeUtil
+    {
+        public static string Base64Encode(string source)
+        {
+            return Base64Encode(Encoding.UTF8, source);
+        }
+
+        public static string Base64Decode(string result)
+        {
+            return Base64Decode(Encoding.UTF8, result);
+        }
+        
+        public static string Base64Encode(Encoding encoding, string source)
+        {
+            byte[] bytes = encoding.GetBytes(source);
+            string encode = Convert.ToBase64String(bytes);
+            return encode;
+        }
+        
+        public static string Base64Decode(Encoding encoding, string result)
+        {
+            byte[] bytes = Convert.FromBase64String(result);
+            string decode = encoding.GetString(bytes);
+            return decode;
+        }
+    }
+}

Assets/ChillConnect/ToolKit/Base64EncodeUtil.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7cb6f0cfcd844347bfe34d48a1f77555
+timeCreated: 1693215248

Assets/ChillConnect/ToolKit/ChillConnectConstant.cs

@@ -0,0 +1,18 @@
+using UnityEngine;
+
+namespace ChillConnect
+{
+    public static class ChillConnectConstant
+    {
+        public const string croas = "Assets/ChillConnectAssets/";
+        public const string setbun = ".assetbundle";
+        public static readonly string tbund = $"{Application.dataPath}/../AssetBundle/{undles}";
+        public static readonly string fgklpk = "|";
+        public const string undles = "AssetBundles";
+        public const string nifest = ".manifest";
+        public static readonly string lesest = $"{undles}{nifest}";
+        public const string zyzootx = "ChillConnectFile.txt";
+        public const string nifldg = "[ ChillConnect ]";
+        public const string admsie = "4s2f6ac15sa6ds45";
+    }
+}

Assets/ChillConnect/ToolKit/ChillConnectConstant.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 73ce1d7d9d7bd5245878994917b71208
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ChillConnect/ToolKit/ChillConnectInfo.cs

@@ -0,0 +1,205 @@
+using UnityEngine.Events;
+
+namespace ChillConnect
+{
+    using System;
+    using UnityEngine;
+    using System.Collections.Generic;
+
+    public delegate void onLoaded(AssetBundle param);
+
+    public class ChillConnectInfo
+    {
+        public string assetBundleName;
+
+        public List<string> parentABNameList = new();
+
+        public long assetBundleSize;
+
+
+        public AssetBundle assetBundle { get; internal set; }
+
+        public ChillConnectState assetBundleState;
+
+        public onLoaded ONLoaded;
+
+        public long waitUnloadCurrentTime;
+
+        public Action<Action<bool>> unloadAction;
+
+        public Action<bool> unloadCompletedAction;
+
+        public int waitUnloadTime;
+
+
+        public static List<string> StatisticsCacheAssetList = new List<string>();
+
+
+        private static bool isStatisticsCacheAssetList = false;
+
+
+        public int ReferencedCount { get; set; }
+
+
+        public float LastReferencedTimestamp { get; set; }
+
+        public ChillConnectInfo(string assetBundleName, UnityAction<AssetBundle> onCompletedLoaded)
+        {
+            this.assetBundleName = assetBundleName;
+            assetBundleState = ChillConnectState.STATE_LOADING;
+            Referenced(assetBundleName);
+            LastReferencedTimestamp = Time.realtimeSinceStartup;
+            if (onCompletedLoaded != null)
+            {
+                ONLoaded += a => onCompletedLoaded(a);
+            }
+        }
+
+        #region 引用关系
+
+        public int GetReferenced()
+        {
+            return ReferencedCount;
+        }
+
+
+        public void Referenced(string parentAbName)
+        {
+            parentAbName = parentAbName.ToLower();
+            if (!parentABNameList.Contains(parentAbName))
+            {
+                ReferencedCount++;
+                parentABNameList.Add(parentAbName);
+#if UNITY_EDITOR
+
+#endif
+            }
+        }
+
+        public void UnReferenced(string parentAbName)
+        {
+            if (parentABNameList.Contains(parentAbName))
+            {
+                ReferencedCount--;
+                parentABNameList.Remove(parentAbName);
+#if UNITY_EDITOR
+
+#endif
+            }
+        }
+
+        public void CleanReferenced()
+        {
+            ReferencedCount = 0;
+        }
+
+        #endregion
+
+        public void callRes(string parentAbName, UnityAction<AssetBundle> action)
+        {
+            switch (assetBundleState)
+            {
+                case ChillConnectState.STATE_NONE:
+                    break;
+                case ChillConnectState.STATE_LOADING:
+                    ONLoaded += a => { action(a); };
+                    break;
+                case ChillConnectState.STATE_LOADED:
+                    Referenced(parentAbName);
+                    action(this.assetBundle);
+                    break;
+            }
+        }
+
+        public void onLoaded(string parentAbName, AssetBundle assetBundle)
+        {
+            Referenced(parentAbName);
+            this.assetBundle = assetBundle;
+            this.assetBundleState = ChillConnectState.STATE_LOADED;
+            ONLoaded(assetBundle);
+            ONLoaded = null;
+            OnAddtStatisticsCacheAssetList(assetBundle.name);
+        }
+
+        public void Unload(bool isThorough)
+        {
+            CleanReferenced();
+            if (assetBundle != null)
+                assetBundle.Unload(isThorough);
+            assetBundle = null;
+        }
+
+
+        private void OnAddtStatisticsCacheAssetList(string assetBundleName)
+        {
+            if (!isStatisticsCacheAssetList) return;
+            if (!StatisticsCacheAssetList.Contains(assetBundleName))
+            {
+                StatisticsCacheAssetList.Add(assetBundleName);
+            }
+        }
+
+
+        public static void OnStartStatisticsCacheAssetList()
+        {
+            isStatisticsCacheAssetList = true;
+            StatisticsCacheAssetList.Clear();
+        }
+
+
+        public static string[] OnStopStatisticsCacheAssetList()
+        {
+            isStatisticsCacheAssetList = false;
+            string[] tempList = StatisticsCacheAssetList.GetRange(0, StatisticsCacheAssetList.Count).ToArray();
+            StatisticsCacheAssetList.Clear();
+            return tempList;
+        }
+
+
+        public void UpdateWaitUnloadCurrentTime()
+        {
+            waitUnloadCurrentTime = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds();
+        }
+
+
+        public long GetWaitUpdateTimeTD()
+        {
+            var tempTime = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds();
+            return tempTime - waitUnloadCurrentTime;
+        }
+
+        public void SetUnloadAction(Action<Action<bool>> action, Action<bool> onCompletedAction)
+        {
+            this.unloadAction = action;
+            this.unloadCompletedAction = onCompletedAction;
+        }
+
+        public void InvokeUnloadAction()
+        {
+            unloadAction?.Invoke(unloadCompletedAction);
+        }
+
+        public void SetWaitUnloadTime(int time)
+        {
+            waitUnloadTime = time;
+        }
+
+        public int GetWaitUnloadTime()
+        {
+            return waitUnloadTime;
+        }
+
+        public void SetAssetBundleSize(long size)
+        {
+            if (size > 0)
+            {
+                assetBundleSize = size;
+            }
+        }
+
+        public long GetSize()
+        {
+            return assetBundleSize;
+        }
+    }
+}

Assets/ChillConnect/ToolKit/ChillConnectInfo.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7f8e1bf1569620a45ba3a117072e9b57
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ChillConnect/ToolKit/ChillConnectKit.cs

@@ -0,0 +1,853 @@
+namespace ChillConnect
+{
+    using System;
+    using System.IO;
+    using UnityEngine;
+    using System.Linq;
+    using System.Text;
+    using UnityEngine.Events;
+    using System.Collections;
+    using System.Collections.Generic;
+    using Object = UnityEngine.Object;
+    using System.Security.Cryptography;
+
+    public class ChillConnectKit : Singleton<ChillConnectKit>, ILoadAsset
+    {
+        private const bool IsMD5Encrypt = false;
+
+
+        private string _assetBundleRootPath = ChillConnectFileKit.GetFilePath();
+
+
+        private static readonly Dictionary<string, ChillConnectInfo> _cacheAssetBundleInfoDict =
+            new Dictionary<string, ChillConnectInfo>();
+
+
+        private static readonly Dictionary<string, string[]> _cacheDependencyDict = new Dictionary<string, string[]>();
+
+        private static readonly List<ChillConnectInfo> _waitUnloadList = new List<ChillConnectInfo>();
+
+        private static AssetBundleManifest _manifest;
+
+        private static readonly Dictionary<string, string> decryptAssetBundleDict = new Dictionary<string, string>();
+
+
+        private const int UnloadWaitTime = 30;
+
+        #region 加载AssetBundle的基础方法
+
+        public IEnumerator LoadABFromFileAsync(string assetBundlePath, string bundlePassword,
+            UnityAction<AssetBundle> onCompleted)
+        {
+            yield return LoadDecryptAssetBundle(assetBundlePath, bundlePassword, onCompleted);
+        }
+
+        private IEnumerator LoadDecryptAssetBundle(string assetBundlePath, string bundlePassword,
+            UnityAction<AssetBundle> onCompleted)
+        {
+            string decryptPath;
+            if (decryptAssetBundleDict.TryGetValue(assetBundlePath, out var outPath) && File.Exists(outPath))
+            {
+                decryptPath = outPath;
+            }
+            else
+            {
+                var cachePath1 = Path.Combine(UnityEngine.Application.persistentDataPath, "Jarvis");
+                if (!Directory.Exists(cachePath1))
+                {
+                    Directory.CreateDirectory(cachePath1);
+                }
+
+                var cachePath = Path.Combine(cachePath1, $"decryptedBundle{Guid.NewGuid():N}");
+
+
+                using (Stream stream1 = File.OpenWrite(cachePath))
+                {
+                    var decryptedData = AESForFileKit.DecryptToBytes(assetBundlePath, bundlePassword, out var dataSize);
+                    yield return stream1.WriteAsync(decryptedData, 0, dataSize);
+                }
+
+                decryptPath = cachePath;
+                decryptAssetBundleDict.TryAdd(assetBundlePath, decryptPath);
+            }
+
+            var request = AssetBundle.LoadFromFileAsync(decryptPath);
+            yield return request;
+            onCompleted?.Invoke(request.assetBundle);
+        }
+
+        private AssetBundle LoadDecryptAssetBundleSync(string assetBundlePath, string bundlePassword)
+        {
+            string decryptPath;
+            if (decryptAssetBundleDict.TryGetValue(assetBundlePath, out var outPath) && File.Exists(outPath))
+            {
+                decryptPath = outPath;
+            }
+            else
+            {
+                var decryptedData = AESForFileKit.DecryptToBytes(assetBundlePath, bundlePassword, out var dataSize);
+                var cachePath1 = Path.Combine(UnityEngine.Application.persistentDataPath, "Jarvis");
+                if (!Directory.Exists(cachePath1))
+                {
+                    Directory.CreateDirectory(cachePath1);
+                }
+
+                var cachePath = Path.Combine(cachePath1, $"decryptedBundle{Guid.NewGuid():N}");
+                while (File.Exists(cachePath))
+                {
+                    File.Delete(cachePath);
+                    cachePath = Path.Combine(cachePath1, $"decryptedBundle{Guid.NewGuid():N}");
+                }
+
+                using (Stream stream = File.OpenWrite(cachePath))
+                {
+                    stream.Write(decryptedData, 0, dataSize);
+                    stream.Close();
+                }
+
+                decryptPath = cachePath;
+                decryptAssetBundleDict.TryAdd(assetBundlePath, decryptPath);
+            }
+
+            var assetBundle = AssetBundle.LoadFromFile(decryptPath);
+            return assetBundle;
+        }
+
+        private IEnumerator LoadAssetFromAssetBundle<T>(AssetBundle assetBundle, string assetName,
+            UnityAction<T> onLoadCompleted) where T : Object
+        {
+            T resultAsset = null;
+
+            if (typeof(T) == typeof(Sprite))
+            {
+                var texture2D = assetBundle.LoadAsset<Texture2D>(assetName);
+                if (texture2D != null)
+                {
+                    var sprite = Sprite.Create(texture2D,
+                        new Rect(0, 0, texture2D.width, texture2D.height), new Vector2(0.5f, 0.5f));
+
+                    resultAsset = sprite as T;
+                }
+                else
+                {
+                    string[] assetNameArray = assetName.Split('.');
+                    if (assetNameArray.Length > 1)
+                    {
+                        var resultAsset1 = assetBundle.LoadAssetWithSubAssets<T>(assetNameArray[0]);
+                        resultAsset = Array.Find(resultAsset1, item => item.name == assetNameArray[1]);
+                    }
+                    else
+                    {
+                    }
+                }
+            }
+            else
+            {
+                var assetLoadRequest = assetBundle.LoadAssetAsync<T>(assetName);
+                yield return assetLoadRequest;
+                var gameObject = assetLoadRequest.asset;
+                if (gameObject == null)
+                {
+                    var subAssetLoadRequest = assetBundle.LoadAssetWithSubAssetsAsync<T>(assetName);
+                    yield return subAssetLoadRequest;
+                    resultAsset = subAssetLoadRequest.asset as T;
+                }
+                else
+                {
+                    resultAsset = gameObject as T;
+                }
+            }
+
+            onLoadCompleted?.Invoke(resultAsset);
+        }
+
+        private void LoadAssetInternal(string assetBundleName, UnityAction<AssetBundle> onCompleted)
+        {
+            var assetBundlePath = GenerateAssetBundlePath(assetBundleName);
+
+            GetAssetBundle(assetBundlePath, assetBundleName, onCompleted);
+        }
+
+        public AssetBundle GetAssetBundle(string assetBundlePath, string assetBundleName)
+        {
+            assetBundleName = assetBundleName.ToLower();
+            CrazyAsyKit.StopAction(assetBundleName + "Unload");
+            UnWaitUnload(assetBundleName);
+            if (IsCacheAssetBundle(assetBundleName))
+            {
+                CacheDependency(assetBundleName, new[] { assetBundleName });
+
+                var ChillConnectInfo = GetCacheAssetBundle(assetBundleName);
+                return ChillConnectInfo?.assetBundle;
+            }
+            else
+            {
+                var ChillConnectInfo = new ChillConnectInfo(assetBundleName, null);
+                CacheAssetBundle(assetBundleName, ChillConnectInfo);
+                var isFileLoadType = File.Exists(assetBundlePath);
+                if (isFileLoadType)
+                {
+                    GetAssetBundleDependency(assetBundleName);
+                    var assetBundle =
+                        LoadDecryptAssetBundleSync(assetBundlePath, ChillConnectConstant.admsie);
+                    ChillConnectInfo.assetBundle = assetBundle;
+                    return assetBundle;
+                }
+            }
+
+            return null;
+        }
+
+        public void GetAssetBundle(string assetBundlePath, string assetBundleName, UnityAction<AssetBundle> onCompleted)
+        {
+            assetBundleName = assetBundleName.ToLower();
+            CrazyAsyKit.StopAction(assetBundleName + "Unload");
+            UnWaitUnload(assetBundleName);
+            if (IsCacheAssetBundle(assetBundleName))
+            {
+                CacheDependency(assetBundleName, new[] { assetBundleName });
+
+                var ChillConnectInfo = GetCacheAssetBundle(assetBundleName);
+                ChillConnectInfo?.callRes(assetBundleName, onCompleted);
+            }
+            else
+            {
+                var ChillConnectInfo = new ChillConnectInfo(assetBundleName, onCompleted);
+                CacheAssetBundle(assetBundleName, ChillConnectInfo);
+                var isFileLoadType = File.Exists(assetBundlePath);
+                CrazyAsyKit.StartCoroutine(GetAssetBundleDependency(assetBundleName, delegate
+                {
+                    if (isFileLoadType)
+                    {
+                        CrazyAsyKit.StartCoroutine(LoadABFromFileAsync(assetBundlePath,
+                            ChillConnectConstant.admsie, bundle =>
+                            {
+                                if (bundle == null)
+                                {
+                                    Debug.LogError("加载AssetBundle 失败：" + assetBundleName);
+                                    UnCacheAssetBundle(assetBundleName);
+                                }
+                                else
+                                {
+                                    ChillConnectInfo abInfo = GetCacheAssetBundle(assetBundleName);
+#if UNITY_EDITOR
+                                    FileInfo file = new FileInfo(assetBundlePath);
+
+                                    abInfo.SetAssetBundleSize(file.Length);
+#endif
+                                    abInfo.onLoaded(assetBundleName, bundle);
+                                }
+                            }));
+                    }
+                    else
+                    {
+                        CrazyAsyKit.StartCoroutine(LoadABFromFileAsync(assetBundlePath,
+                            ChillConnectConstant.admsie, delegate (AssetBundle bundle)
+                            {
+                                if (bundle == null)
+                                {
+                                    Debug.LogError("加载AssetBundle 失败：" + assetBundleName);
+                                    UnCacheAssetBundle(assetBundleName);
+                                }
+                                else
+                                {
+                                    var abInfoV = GetCacheAssetBundle(assetBundleName);
+                                    var file = new FileInfo(assetBundlePath);
+                                    abInfoV.SetAssetBundleSize(file.Length);
+                                    abInfoV.onLoaded(assetBundleName, bundle);
+                                }
+                            }));
+                    }
+                }));
+            }
+        }
+
+        #region AssetBundle 包的依赖相关
+
+        private IEnumerator GetAssetBundleDependency(string assetBundleName, Action action)
+        {
+            assetBundleName = assetBundleName.ToLower();
+
+            var allDependencies = new List<string>() { assetBundleName };
+            allDependencies.AddRange(GetABDependency(assetBundleName));
+            var index = 0;
+            CacheDependency(assetBundleName, allDependencies.ToArray());
+            var allDepends = allDependencies.Where(dependencyAbName => dependencyAbName != assetBundleName).ToList();
+
+            foreach (var dependencyAbName in allDepends)
+            {
+                yield return LoadDependencyAssetBundle(assetBundleName, dependencyAbName, delegate { index++; });
+            }
+
+            while (index != allDepends.Count)
+            {
+                yield return new WaitForEndOfFrame();
+            }
+
+            action?.Invoke();
+        }
+
+        private void GetAssetBundleDependency(string assetBundleName)
+        {
+            assetBundleName = assetBundleName.ToLower();
+
+            var allDependencies = new List<string>() { assetBundleName };
+            allDependencies.AddRange(GetABDependency(assetBundleName));
+            CacheDependency(assetBundleName, allDependencies.ToArray());
+            var allDepends = allDependencies.Where(dependencyAbName => dependencyAbName != assetBundleName).ToList();
+
+            foreach (var dependencyAbName in allDepends)
+            {
+                LoadDependencyAssetBundleSync(assetBundleName, dependencyAbName);
+            }
+        }
+
+        private IEnumerator LoadDependencyAssetBundle(string parentAssetBundleName, string assetBundleName,
+            UnityAction<AssetBundle> onCompleted)
+        {
+            assetBundleName = assetBundleName.ToLower();
+            var assetBundlePath = GenerateAssetBundlePath(assetBundleName, IsMD5Encrypt);
+
+            CrazyAsyKit.StopAction(assetBundleName + "Unload");
+            UnWaitUnload(assetBundleName);
+
+            if (IsCacheAssetBundle(assetBundleName))
+            {
+                CacheAssetBundle(assetBundleName, null, true);
+                var ChillConnectInfo = GetCacheAssetBundle(assetBundleName);
+                ChillConnectInfo?.callRes(parentAssetBundleName, onCompleted);
+            }
+            else
+            {
+                var ChillConnectInfo = new ChillConnectInfo(assetBundleName, onCompleted);
+                CacheAssetBundle(assetBundleName, ChillConnectInfo);
+                if (File.Exists(assetBundlePath))
+                {
+                    yield return LoadABFromFileAsync(assetBundlePath, ChillConnectConstant.admsie,
+                        delegate (AssetBundle bundle)
+                        {
+                            if (bundle == null)
+                            {
+                                Debug.LogError("加载AssetBundle 失败：" + assetBundleName);
+                                UnCacheAssetBundle(assetBundleName);
+                            }
+                            else
+                            {
+                                GetCacheAssetBundle(assetBundleName).onLoaded(parentAssetBundleName, bundle);
+                            }
+                        });
+                }
+                else
+                {
+                    CrazyAsyKit.StartCoroutine(LoadABFromFileAsync(assetBundlePath,
+                        ChillConnectConstant.admsie, delegate (AssetBundle bundle)
+                        {
+                            if (bundle == null)
+                            {
+                                Debug.LogError("加载AssetBundle 失败：" + assetBundleName);
+                                UnCacheAssetBundle(assetBundleName);
+                            }
+                            else
+                            {
+                                GetCacheAssetBundle(assetBundleName).onLoaded(parentAssetBundleName, bundle);
+                            }
+                        }));
+                }
+            }
+        }
+
+        private AssetBundle LoadDependencyAssetBundleSync(string parentAssetBundleName, string assetBundleName)
+        {
+            assetBundleName = assetBundleName.ToLower();
+            var assetBundlePath = GenerateAssetBundlePath(assetBundleName, IsMD5Encrypt);
+            CrazyAsyKit.StopAction(assetBundleName + "Unload");
+            UnWaitUnload(assetBundleName);
+
+            if (IsCacheAssetBundle(assetBundleName))
+            {
+                CacheAssetBundle(assetBundleName, null, true);
+                var assetBundleInfos = GetCacheAssetBundle(assetBundleName);
+                return assetBundleInfos?.assetBundle;
+            }
+
+            var ChillConnectInfo = new ChillConnectInfo(assetBundleName, null);
+            CacheAssetBundle(assetBundleName, ChillConnectInfo);
+            if (File.Exists(assetBundlePath))
+            {
+                GetAssetBundleDependency(assetBundleName);
+                var assetBundle =
+                    LoadDecryptAssetBundleSync(assetBundlePath, ChillConnectConstant.admsie);
+                ChillConnectInfo.assetBundle = assetBundle;
+                return assetBundle;
+            }
+
+            return null;
+        }
+
+
+        private string[] GetABDependency(string assetBundleName)
+        {
+            assetBundleName = assetBundleName.ToLower();
+            return GetManifest().GetDirectDependencies(assetBundleName);
+        }
+
+        #region 依赖关系相关
+
+        private bool IsCacheDependency(string assetBundleName)
+        {
+            if (_cacheDependencyDict == null || _cacheDependencyDict.Count == 0) return false;
+            assetBundleName = assetBundleName.ToLower();
+            var isDependency = _cacheDependencyDict.ContainsKey(assetBundleName);
+
+            return isDependency;
+        }
+
+
+        private bool IsOtherDependency(string assetBundleName)
+        {
+            assetBundleName = assetBundleName.ToLower();
+            var isDependency = false;
+            if (_cacheDependencyDict == null || _cacheDependencyDict.Count == 0) return false;
+            foreach (var keyValuePair in _cacheDependencyDict)
+            {
+                isDependency = keyValuePair.Value.Contains(assetBundleName);
+                if (isDependency)
+                {
+                    break;
+                }
+            }
+
+            return isDependency;
+        }
+
+        private void CacheDependency(string assetBundleName, string[] assetBundleNameArray)
+        {
+            assetBundleName = assetBundleName.ToLower();
+            if (!IsCacheDependency(assetBundleName))
+            {
+                for (int i = 0; i < assetBundleNameArray.Length; i++)
+                {
+                    assetBundleNameArray[i] = assetBundleNameArray[i].ToLower();
+                }
+
+                _cacheDependencyDict.Add(assetBundleName, assetBundleNameArray);
+            }
+        }
+
+
+        private void UnCacheDependency(string assetBundleName)
+        {
+            assetBundleName = assetBundleName.ToLower();
+            if (IsCacheDependency(assetBundleName))
+            {
+                _cacheDependencyDict.Remove(assetBundleName);
+            }
+        }
+
+
+        private string[] GetCacheDependency(string assetBundleName)
+        {
+            assetBundleName = assetBundleName.ToLower();
+            string[] dependencyList = { };
+            if (IsCacheDependency(assetBundleName))
+            {
+                dependencyList = _cacheDependencyDict[assetBundleName];
+            }
+
+            return dependencyList;
+        }
+
+        #endregion
+
+        #endregion
+
+        #region 管理已加载的AssetBundle文件
+
+        private void CacheAssetBundle(string assetBundleName, ChillConnectInfo assetBundleInfoV,
+            bool isDependency = false)
+        {
+            assetBundleName = assetBundleName.ToLower();
+            if (IsCacheAssetBundle(assetBundleName))
+            {
+                if (isDependency)
+                {
+                }
+                else
+                {
+                    return;
+                }
+            }
+            else
+            {
+                _cacheAssetBundleInfoDict.Add(assetBundleName, assetBundleInfoV);
+            }
+        }
+
+
+        private void UnCacheAssetBundle(string assetBundleName)
+        {
+            if (IsCacheAssetBundle(assetBundleName))
+            {
+                _cacheAssetBundleInfoDict.Remove(assetBundleName.ToLower());
+            }
+            else
+            {
+            }
+        }
+
+
+        private ChillConnectInfo GetCacheAssetBundle(string assetBundleName)
+        {
+            ChillConnectInfo assetBundle = null;
+            if (IsCacheAssetBundle(assetBundleName))
+            {
+                assetBundle = _cacheAssetBundleInfoDict[assetBundleName.ToLower()];
+            }
+            else
+            {
+            }
+
+            return assetBundle;
+        }
+
+
+        private bool IsCacheAssetBundle(string assetBundleName)
+        {
+            assetBundleName = assetBundleName.ToLower();
+            if (_cacheAssetBundleInfoDict == null)
+            {
+                return false;
+            }
+
+            return _cacheAssetBundleInfoDict.ContainsKey(assetBundleName);
+        }
+
+        #endregion
+
+        #region 卸载AssetBundle相关
+
+        #region 卸载AssetBundle相关信息管理
+
+        private bool WaitUnload(ChillConnectInfo assetBundleInfoV)
+        {
+            var isInWait = IsWaitUnload(assetBundleInfoV.assetBundleName);
+            if (isInWait) return true;
+            assetBundleInfoV.UpdateWaitUnloadCurrentTime();
+            _waitUnloadList.Add(assetBundleInfoV);
+            return false;
+        }
+
+
+        private bool IsWaitUnloadKey(string assetBundleName)
+        {
+            var isWaitUnload = false;
+            if (_waitUnloadList == null || _waitUnloadList.Count <= 0) return false;
+            foreach (var bundleInfo in _waitUnloadList)
+            {
+                if (bundleInfo == null || !string.IsNullOrEmpty(bundleInfo.assetBundleName)) continue;
+                if (!bundleInfo.assetBundleName.Equals(assetBundleName)) continue;
+                isWaitUnload = true;
+                break;
+            }
+
+            return isWaitUnload;
+        }
+
+
+        private bool IsWaitUnload(string assetBundleName)
+        {
+            var isWaitUnload = false;
+            if (_waitUnloadList == null || _waitUnloadList.Count == 0) return false;
+            if (!IsWaitUnloadKey(assetBundleName))
+            {
+                foreach (var waitUnloadAssetBundle in _waitUnloadList)
+                {
+                    if (waitUnloadAssetBundle == null ||
+                        !string.IsNullOrEmpty(waitUnloadAssetBundle.assetBundleName)) continue;
+                    isWaitUnload = GetABDependency(waitUnloadAssetBundle.assetBundleName).Contains(assetBundleName);
+                    if (isWaitUnload)
+                    {
+                        break;
+                    }
+                }
+            }
+            else
+            {
+                isWaitUnload = true;
+            }
+
+            return isWaitUnload;
+        }
+
+
+        private bool UnWaitUnload(string assetBundleName)
+        {
+            var isRemove = false;
+
+            foreach (var bundleInfo in _waitUnloadList)
+            {
+                if (bundleInfo == null) continue;
+                if (!bundleInfo.assetBundleName.Equals(assetBundleName)) continue;
+                isRemove = _waitUnloadList.Remove(bundleInfo);
+                break;
+            }
+
+            return isRemove;
+        }
+
+        #endregion
+
+
+        public void UnloadAssetBundle(string assetBundleName,
+            bool ignoreDependency = false,
+            int unloadWaitTime = 0,
+            Action<bool> onCompleted = null)
+        {
+            if (string.IsNullOrEmpty(assetBundleName))
+            {
+                onCompleted?.Invoke(false);
+                return;
+            }
+
+            bool unloadSucceed;
+            if (IsCacheAssetBundle(assetBundleName))
+            {
+                var abInfo = GetCacheAssetBundle(assetBundleName);
+                if (abInfo == null)
+                {
+                    onCompleted?.Invoke(false);
+                    return;
+                }
+
+
+                if (WaitUnload(abInfo) && !ignoreDependency)
+                {
+                    unloadSucceed = false;
+
+                    UnCacheDependency(assetBundleName);
+
+                    onCompleted?.Invoke(unloadSucceed);
+                }
+                else
+                {
+                    CrazyAsyKit.StopAction(assetBundleName + "Unload");
+                    CrazyAsyKit.StartAction(assetBundleName + "Unload", delegate
+                    {
+                        unloadSucceed = IsCacheAssetBundle(assetBundleName) &&
+                                        UnloadAssetBundleInternal(assetBundleName, ignoreDependency);
+
+                        UnWaitUnload(assetBundleName);
+
+#if UNITY_EDITOR
+
+#endif
+
+                        onCompleted?.Invoke(unloadSucceed);
+                    }, unloadWaitTime);
+                }
+            }
+            else
+            {
+                onCompleted?.Invoke(false);
+            }
+        }
+
+
+        private bool UnloadAssetBundleInternal(string assetBundleName, bool isIgnoreDependency = false,
+            bool isThorough = false)
+        {
+            var ChillConnectInfo = GetCacheAssetBundle(assetBundleName);
+            if (ChillConnectInfo == null)
+            {
+                return false;
+            }
+
+
+            var dependencyArray = GetCacheDependency(assetBundleName);
+
+
+            UnCacheDependency(assetBundleName);
+
+
+            if (!isIgnoreDependency)
+            {
+                if (IsOtherDependency(assetBundleName))
+                {
+                    return false;
+                }
+            }
+
+
+            UnCacheAssetBundle(assetBundleName);
+
+
+            ChillConnectInfo.Unload(isThorough);
+
+
+            foreach (var dependencyAssetBundleName in dependencyArray)
+            {
+                if (dependencyAssetBundleName == assetBundleName)
+                {
+                    continue;
+                }
+
+
+                if (!IsOtherDependency(dependencyAssetBundleName))
+                {
+                    UnloadAssetBundleInternal(dependencyAssetBundleName, false, isThorough);
+                }
+                else
+                {
+                }
+            }
+
+
+            return true;
+        }
+
+        #endregion
+
+        #endregion
+
+        #region 封装直接加载资源的方法
+
+        public T GetAsset<T>(string assetBundleName, string assetName) where T : Object
+        {
+            var assetBundlePath = GenerateAssetBundlePath(assetBundleName);
+            var assetBundle = GetAssetBundle(assetBundlePath, assetBundleName);
+
+            return assetBundle.LoadAsset<T>(assetName);
+        }
+
+
+        public void GetAsset<T>(string assetBundleName, string assetName, UnityAction<T> onCompleted) where T : Object
+        {
+            LoadAssetInternal(assetBundleName, delegate (AssetBundle bundle)
+            {
+                if (bundle == null)
+                {
+                    Debug.LogError("加载AssetBundle 失败：" + assetBundleName);
+                }
+                else
+                {
+                    CrazyAsyKit.StartCoroutine(LoadAssetFromAssetBundle(bundle, assetName, onCompleted));
+                }
+            });
+        }
+
+
+        public void InitManifest(string assetBundleManifestName, UnityAction<bool> onCompleted)
+        {
+            CrazyAsyKit.StopAction(assetBundleManifestName + "Unload");
+            if (UnWaitUnload(assetBundleManifestName))
+            {
+            }
+            var assetBundles =
+                AssetBundle.LoadFromFile($"{ChillConnectFileKit.GetFilePath()}{ChillConnectConstant.undles}");
+            var manifest = assetBundles.LoadAsset<AssetBundleManifest>("assetbundlemanifest");
+            _manifest = manifest;
+            onCompleted?.Invoke(manifest != null);
+        }
+
+        #endregion
+
+        public void RecycleAssetBundle(string assetBundleName, UnityAction onCompleted = null)
+        {
+            if (IsCacheAssetBundle(assetBundleName))
+            {
+                var abInfo = GetCacheAssetBundle(assetBundleName);
+                abInfo.UnReferenced(assetBundleName);
+
+                RecycleAssetBundleDependency(assetBundleName, UnloadWaitTime);
+
+                if (abInfo.GetReferenced() <= 0)
+                {
+                    UnloadAssetBundle(assetBundleName, false, UnloadWaitTime);
+                }
+            }
+
+            onCompleted?.Invoke();
+        }
+
+        private void RecycleAssetBundleDependency(string abName, int waitTime)
+        {
+            var otherAbName = GetCacheDependency(abName);
+            if (otherAbName.Length <= 0) return;
+            foreach (var dependAbName in otherAbName)
+            {
+                if (dependAbName == abName) continue;
+                var dependAbInfo = GetCacheAssetBundle(dependAbName);
+                if (dependAbInfo == null) continue;
+                dependAbInfo.UnReferenced(abName);
+
+
+                if (dependAbInfo.GetReferenced() <= 0)
+                {
+                    UnloadAssetBundle(dependAbName, false, waitTime);
+                }
+            }
+        }
+
+
+        #region 其他方法
+
+        private string GenerateAssetBundlePath(string assetBundleName, bool isMD5 = false, bool isManifest = false,
+            bool isAddABSuffix = true)
+        {
+            var fileName = assetBundleName.ToLower();
+            if (isMD5)
+            {
+                fileName = MD5String(fileName) + ".data";
+            }
+
+            var filePath = _assetBundleRootPath.Replace("file:///", "") + assetBundleName.ToLower();
+            if (isAddABSuffix)
+            {
+                filePath += ChillConnectConstant.setbun;
+            }
+
+            if (!isManifest)
+                return filePath;
+            if (File.Exists(filePath))
+            {
+                return filePath;
+            }
+
+            return filePath;
+        }
+
+        private static string MD5String(string str)
+        {
+            using var md5 = MD5.Create();
+            var hash = md5.ComputeHash(Encoding.GetEncoding("utf-8").GetBytes(str));
+            var tmp = new StringBuilder();
+            foreach (var i in hash)
+            {
+                tmp.Append(i.ToString("x2"));
+            }
+
+            return tmp.ToString();
+        }
+
+        #endregion
+
+        public void RecycleAsset(string assetUrl, UnityAction onCompleted)
+        {
+            RecycleAssetBundle(assetUrl, onCompleted);
+        }
+
+        private AssetBundleManifest GetManifest()
+        {
+            if (_manifest == null)
+            {
+                Debug.LogError("AssetBundleManifest is null");
+                var assetBundles =
+                    AssetBundle.LoadFromFile($"{ChillConnectFileKit.GetFilePath()}{ChillConnectConstant.undles}");
+                var manifest = assetBundles.LoadAsset<AssetBundleManifest>("assetbundlemanifest");
+                _manifest = manifest;
+            }
+
+            return _manifest;
+        }
+    }
+}

Assets/ChillConnect/ToolKit/ChillConnectKit.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0049894e09758c34fb23600e4571504e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ChillConnect/ToolKit/ChillConnectState.cs

@@ -0,0 +1,10 @@
+
+namespace ChillConnect
+{
+    public enum ChillConnectState
+    {
+        STATE_NONE,
+        STATE_LOADING,
+        STATE_LOADED,
+    }
+}

Assets/ChillConnect/ToolKit/ChillConnectState.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5e6f867b844a92f4e8799eeb338a9aa2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ChillConnect/ToolKit/CommonExpand.cs

@@ -0,0 +1,32 @@
+using System;
+using DG.Tweening;
+using FairyGUI;
+using ChillConnect;
+
+
+public static class CommonExpand
+{
+    public static GTweener FadeIn(this GObject obj, float duration = 0.3f, float delay = 0)
+    {
+        return CommonHelper.FadeIn(obj, duration, delay);
+    }
+
+    public static GTweener FadeOut(this GObject obj, float duration = 0.3f, float delay = 0)
+    {
+        return CommonHelper.FadeOut(obj, duration, delay);
+    }
+
+    public static void SetClick(this GObject button, Action action, bool isNetworkCheck = false,
+        bool isQuickClickCheck = true)
+    {
+        CommonHelper.InitGButton(button, action, isNetworkCheck, isQuickClickCheck);
+    }
+
+    public static void SafeKill(this Tween tween)
+    {
+        if (tween != null && tween.IsActive())
+        {
+            tween.Kill();
+        }
+    }
+}

Assets/ChillConnect/ToolKit/CommonExpand.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 774c7c1119b44f86819883ab6e9240ec
+timeCreated: 1681803724

Assets/ChillConnect/ToolKit/CountDownKit.cs

@@ -0,0 +1,207 @@
+using System;
+using System.Collections.Generic;
+using DG.Tweening;
+using FairyGUI;
+using UnityEngine.UI;
+
+namespace ChillConnect
+{
+    public enum CountDownType
+    {
+        Second,
+        Minute,
+        Hour,
+        Day
+    }
+
+    public class CountDownKit
+    {
+        private int countDownTime;
+        private int leftTime = 0;
+        private GTextField textGComponent;
+        private GProgressBar barGComponent;
+        private Text textComponent;
+        private CountDownType countDownType = CountDownType.Second;
+        private Dictionary<int, Action> onTriggerEventDict = new Dictionary<int, Action>();
+        private Tween timer;
+        private Action onCompletedEvent;
+        private long endTime;
+        private bool isDependenceServerTime = true;
+
+        public CountDownKit SetTime(int second)
+        {
+            countDownTime = second;
+            leftTime = countDownTime;
+            return this;
+        }
+
+        public CountDownKit SetCountDownType(CountDownType countDownType)
+        {
+            this.countDownType = countDownType;
+            return this;
+        }
+
+        public CountDownKit SetText(GTextField gText)
+        {
+            textComponent = null;
+            textGComponent = gText;
+            return this;
+        }
+
+        public CountDownKit SetBar(GProgressBar gProgressBar)
+        {
+            barGComponent = null;
+            barGComponent = gProgressBar;
+            return this;
+        }
+
+        public int interval = 1;
+
+        public void Start()
+        {
+            endTime = (int)(DateTimeManager.Instance.GetServerCurrTimestamp() / 1000) + leftTime;
+            UpdateView();
+            timer = DOVirtual.DelayedCall(interval, () =>
+            {
+                leftTime -= interval;
+                if (isDependenceServerTime)
+                {
+                    var current = DateTimeManager.Instance.GetServerCurrTimestamp() / 1000;
+                    if (endTime <= current)
+                    {
+                        leftTime = 0;
+                    }
+                }
+
+                UpdateView();
+                if (leftTime <= 0)
+                {
+                    Stop();
+                    OnCompleted();
+                }
+                else
+                {
+                    OnTrigger();
+                }
+            }, true).SetLoops(-1);
+        }
+
+        private void UpdateView()
+        {
+            UpdateText();
+            UpdateBar();
+        }
+
+        public void Pause()
+        {
+            if (timer != null)
+            {
+                timer.Pause();
+            }
+        }
+
+        public void Resume()
+        {
+            if (timer != null)
+            {
+                timer.Play();
+            }
+        }
+
+        public void Stop()
+        {
+            if (timer != null && timer.IsActive())
+            {
+                timer?.Kill();
+            }
+        }
+
+        public void OnDestroy()
+        {
+            Stop();
+            leftTime = 0;
+
+            textGComponent = null;
+
+            textComponent = null;
+            onTriggerEventDict = null;
+            onCompletedEvent = null;
+        }
+
+        public void ConsumeTime(int consumeTime)
+        {
+            leftTime -= consumeTime;
+            UpdateView();
+            if (leftTime <= 0)
+            {
+                Stop();
+                OnCompleted();
+            }
+            else
+            {
+                OnTrigger();
+            }
+        }
+
+        private void OnTrigger()
+        {
+            if (onTriggerEventDict.ContainsKey(leftTime))
+            {
+                onTriggerEventDict[leftTime]?.Invoke();
+            }
+        }
+
+        public void ClearTriggerEvent()
+        {
+            onTriggerEventDict.Clear();
+        }
+
+        public CountDownKit SetCompletedEvent(Action onCompleted)
+        {
+            onCompletedEvent = onCompleted;
+            return this;
+        }
+
+        private void OnCompleted()
+        {
+            onCompletedEvent?.Invoke();
+        }
+
+        private void UpdateText()
+        {
+            if (textGComponent != null)
+            {
+                textGComponent.text = CommonHelper.TimeFormat(leftTime, countDownType);
+            }
+
+            if (textComponent != null)
+            {
+                textComponent.text = CommonHelper.TimeFormat(leftTime, countDownType);
+            }
+        }
+
+        private void UpdateBar()
+        {
+            if (barGComponent != null)
+            {
+                if (barGComponent.max == 0)
+                {
+                    barGComponent.max = countDownTime;
+                }
+
+                barGComponent.TweenValue(leftTime, 1);
+            }
+        }
+
+        public int GetLeftTime()
+        {
+            return leftTime;
+        }
+
+        public CountDownKit SetServerTimeDependence(bool _isDependenceServerTime)
+        {
+            isDependenceServerTime = _isDependenceServerTime;
+            return this;
+        }
+    }
+}

Assets/ChillConnect/ToolKit/CountDownKit.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 34ed4a143324499ab1864f3c64019e16
+timeCreated: 1681804392

Assets/ChillConnect/ToolKit/FXPool.cs

@@ -0,0 +1,145 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+public class FXPool<T> : IDisposable where T : Enum
+{
+    private Dictionary<T, List<Object>> PoolDic;
+    private Dictionary<T, Transform> PollPar;
+    private List<T> temp;
+    private Transform objectPoolPar;
+    public Func<T, Object> NewObjFunc;
+    public Action<T, Object> RecObjFunc;
+    public Action<T, Object> GetObjFunc;
+
+    public FXPool(Transform _objectPoolPar = null)
+    {
+        objectPoolPar = _objectPoolPar;
+        if (objectPoolPar == null)
+        {
+            objectPoolPar = new GameObject("ObjectPool").transform;
+            objectPoolPar.localPosition = Vector3.zero;
+            objectPoolPar.localEulerAngles = Vector3.zero;
+        }
+
+        PoolDic = new Dictionary<T, List<Object>>();
+        PollPar = new Dictionary<T, Transform>();
+        temp = new List<T>();
+    }
+    
+    public Obj GetObject<Obj>(T key) where Obj : Object
+    {
+        Obj obj = null;
+        if (!PoolDic.ContainsKey(key))
+        {
+            AddKey(key);
+        }
+
+        if (PoolDic[key].Count > 0)
+        {
+            obj = PoolDic[key][0] as Obj;
+            PoolDic[key].RemoveAt(0);
+        }
+        else
+        {
+            obj = LoadObject<Obj>(key);
+        }
+
+        GetObjFunc?.Invoke(key, obj);
+        return obj;
+    }
+
+    private void AddKey(T key)
+    {
+        PoolDic.Add(key, new List<Object>());
+        Transform par = new GameObject(key.ToString()).transform;
+        par.SetParent(objectPoolPar);
+        par.localScale = Vector3.one;
+        par.localPosition = Vector3.zero;
+        par.localEulerAngles = Vector3.zero;
+        PollPar.Add(key, par.transform);
+    }
+
+    private Obj LoadObject<Obj>(T key) where Obj : UnityEngine.Object
+    {
+        Obj obj = NewObjFunc?.Invoke(key) as Obj;
+        if (obj != null)
+        {
+            GameObject go = obj as GameObject ?? (obj as Component).gameObject;
+
+            if (PollPar.TryGetValue(key, out Transform par) && go != null)
+            {
+                go.transform.SetParent(par);
+            }
+        }
+
+        return obj;
+    }
+
+    public void RecObject(T key, Object obj)
+    {
+        if (obj == null) return;
+        if (!PoolDic.ContainsKey(key))
+        {
+            PoolDic.Add(key, new List<Object>());
+        }
+
+        GameObject go = obj as GameObject ?? (obj as Component).gameObject;
+        if (PollPar.TryGetValue(key, out Transform par))
+        {
+            go.transform.parent = (par);
+        }
+
+        RecObjFunc?.Invoke(key, obj);
+        PoolDic[key].Add(obj);
+    }
+
+    public void RemoveKey(T key)
+    {
+        if (PoolDic.ContainsKey(key))
+        {
+            foreach (Object item in PoolDic[key])
+            {
+                if (item != null)
+                {
+                    GameObject go = item as GameObject;
+                    if (go == null)
+                    {
+                        Component cot = item as Component;
+                        go = cot.gameObject;
+                    }
+
+                    GameObject.Destroy(go);
+                }
+            }
+
+            PoolDic[key].Clear();
+            PoolDic.Remove(key);
+        }
+    }
+
+    public void RemoveAll()
+    {
+        temp.Clear();
+        foreach (var item in PoolDic)
+        {
+            temp.Add(item.Key);
+        }
+
+        foreach (var item in temp)
+        {
+            RemoveKey(item);
+        }
+
+        temp.Clear();
+    }
+
+    public void Dispose()
+    {
+        RemoveAll();
+        PoolDic = null;
+        PollPar = null;
+        temp = null;
+    }
+}

Assets/ChillConnect/ToolKit/FXPool.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3de141293f3240ffbdc26570a545e96c
+timeCreated: 1681806263

Assets/ChillConnect/ToolKit/MD5Kit.cs

@@ -0,0 +1,72 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Security.Cryptography;
+
+public class MD5Kit
+{
+
+    public static string GetFileMD5(string file)
+    {
+        try
+        {
+            var fs = new FileStream(file, FileMode.Open);
+            MD5 md5 = new MD5CryptoServiceProvider();
+            var retVal = md5.ComputeHash(fs);
+            fs.Close();
+
+            var sb = new StringBuilder();
+            foreach (var str in retVal)
+            {
+                sb.Append(str.ToString("X2"));
+            }
+
+            return sb.ToString();
+        }
+        catch (Exception ex)
+        {
+            throw new Exception("GetFileMD5 fail error: " + ex.Message);
+        }
+    }
+
+    /// <summary>
+    /// 获取字符串的MD5值
+    /// </summary>
+    public static string GetStringMD5(string str)
+    {
+        if (string.IsNullOrEmpty(str))
+        {
+            return null;
+        }
+
+        MD5 md5 = new MD5CryptoServiceProvider();
+        byte[] bytResult = md5.ComputeHash(Encoding.UTF8.GetBytes(str));
+        string strResult = BitConverter.ToString(bytResult);
+        strResult = strResult.Replace("-", string.Empty);
+        return strResult;
+    }
+
+
+    public static string MD5String1(string text)
+    {
+        var buffer = Encoding.Default.GetBytes(text);
+        var check = new MD5CryptoServiceProvider();
+        var somme = check.ComputeHash(buffer);
+        var result = new StringBuilder();
+        foreach (var a in somme)
+        {
+            var value = a.ToString("X");
+            if (a < 16)
+            {
+                result.Append(0);
+                result.Append(value);
+            }
+            else
+            {
+                result.Append(value);
+            }
+        }
+
+        return result.ToString().ToLower();
+    }
+}

Assets/ChillConnect/ToolKit/MD5Kit.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a5697bf9fd10d9548977711311a96a00
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: