Example #1
0
        public static UI Create(Entity domain)
        {
            try
            {
                GameObject bundleGameObject = ((GameObject)ResourcesHelper.Load("KV")).Get <GameObject>(UIType.UILoading);
                GameObject go = UnityEngine.Object.Instantiate(bundleGameObject);
                go.layer = LayerMask.NameToLayer(LayerNames.UI);
                UI ui = EntityFactory.Create <UI, string, GameObject>(domain, UIType.UILoading, go);

                ui.AddComponent <UILoadingComponent>();
                return(ui);
            }
            catch (Exception e)
            {
                Log.Error(e);
                return(null);
            }
        }
Example #2
0
        public UI Get(string name)
        {
            UI child;

            if (this.nameChildren.TryGetValue(name, out child))
            {
                return(child);
            }
            GameObject childGameObject = this.GameObject.transform.Find(name)?.gameObject;

            if (childGameObject == null)
            {
                return(null);
            }
            child = EntityFactory.Create <UI, string, GameObject>(this.Domain, name, childGameObject);
            this.Add(child);
            return(child);
        }
Example #3
0
        public static UI Create()
        {
            try
            {
                ResourcesComponent resourcesComponent = Game.Scene.GetComponent <ResourcesComponent>();
                resourcesComponent.LoadBundle(UIType.UILobby.StringToAB());
                GameObject bundleGameObject = (GameObject)resourcesComponent.GetAsset(UIType.UILobby.StringToAB(), UIType.UILobby);
                GameObject gameObject       = UnityEngine.Object.Instantiate(bundleGameObject);
                UI         ui = EntityFactory.Create <UI, string, GameObject>(Game.Scene, UIType.UILobby, gameObject);

                ui.AddComponent <UILobbyComponent>();
                return(ui);
            }
            catch (Exception e)
            {
                Log.Error(e);
                return(null);
            }
        }
Example #4
0
        public static void Check(this ActorLocationSenderComponent self, bool isTimeOut)
        {
            using (ListComponent <long> list = EntityFactory.Create <ListComponent <long> >(self.Domain))
            {
                long timeNow = TimeHelper.Now();
                foreach ((long key, Entity value) in self.Children)
                {
                    ActorLocationSender actorLocationMessageSender = (ActorLocationSender)value;

                    if (timeNow > actorLocationMessageSender.LastSendOrRecvTime + ActorLocationSenderComponent.TIMEOUT_TIME)
                    {
                        list.List.Add(key);
                    }
                }

                foreach (long id in list.List)
                {
                    self.Remove(id);
                }
            }
        }
        protected override async ETTask Run(Session session, C2G_LoginGate request, G2C_LoginGate response, Action reply)
        {
            Scene  scene   = session.DomainScene();
            string account = scene.GetComponent <GateSessionKeyComponent>().Get(request.Key);

            if (account == null)
            {
                response.Error   = ErrorCode.ERR_ConnectGateKeyError;
                response.Message = "Gate key验证失败!";
                reply();
                return;
            }
            Player player = EntityFactory.Create <Player, string>(Game.Scene, account);

            scene.GetComponent <PlayerComponent>().Add(player);
            session.AddComponent <SessionPlayerComponent>().Player = player;
            session.AddComponent <MailBoxComponent, MailboxType>(MailboxType.GateSession);

            response.PlayerId = player.Id;
            reply();
            await ETTask.CompletedTask;
        }
Example #6
0
        public async ETVoid Lock(long key, long instanceId, int time = 0)
        {
            CoroutineLock coroutineLock = await CoroutineLockComponent.Instance.Wait(CoroutineLockType.Location, key);

            LockInfo lockInfo = EntityFactory.Create <LockInfo, long, CoroutineLock>(this.Domain, instanceId, coroutineLock);

            lockInfo.Parent = this;
            this.lockInfos.Add(key, lockInfo);

            Log.Info($"location lock key: {key} instanceId: {instanceId}");

            if (time > 0)
            {
                long lockInfoInstanceId = lockInfo.InstanceId;
                await TimerComponent.Instance.WaitAsync(time);

                if (lockInfo.InstanceId != lockInfoInstanceId)
                {
                    return;
                }
                UnLock(key, instanceId, instanceId);
            }
        }
Example #7
0
        public static async ETVoid MoveTo(this UnitPathComponent self, Vector3 target)
        {
            if ((self.Target - target).magnitude < 0.1f)
            {
                return;
            }

            self.Target = target;

            Unit unit = self.GetParent <Unit>();


            PathfindingComponent pathfindingComponent = self.Domain.GetComponent <PathfindingComponent>();

            self.ABPath = EntityFactory.Create <ABPathWrap, Vector3, Vector3>(self.Domain, unit.Position, new Vector3(target.x, target.y, target.z));
            pathfindingComponent.Search(self.ABPath);
            Log.Debug($"find result: {self.ABPath.Result.ListToString()}");

            self.CancellationToken?.Cancel();
            self.CancellationToken = new ETCancellationToken();
            await self.MoveAsync(self.ABPath.Result);

            self.CancellationToken = null;
        }
Example #8
0
 public static FGUITitleButton Create(Entity domain, GObject go)
 {
     return(EntityFactory.Create <FGUITitleButton, GObject>(domain, go));
 }
Example #9
0
        public async ETTask LoadOneBundleAsync(string assetBundleName)
        {
            ABInfo abInfo;

            if (this.bundles.TryGetValue(assetBundleName, out abInfo))
            {
                ++abInfo.RefCount;
                return;
            }

            //Log.Debug($"---------------load one bundle {assetBundleName}");
            if (!Define.IsAsync)
            {
                string[] realPath = null;
#if UNITY_EDITOR
                realPath = AssetDatabase.GetAssetPathsFromAssetBundle(assetBundleName);
                foreach (string s in realPath)
                {
                    string             assetName = Path.GetFileNameWithoutExtension(s);
                    UnityEngine.Object resource  = AssetDatabase.LoadAssetAtPath <UnityEngine.Object>(s);
                    AddResource(assetBundleName, assetName, resource);
                }

                abInfo = EntityFactory.CreateWithParent <ABInfo, string, AssetBundle>(this, assetBundleName, null);
                this.bundles[assetBundleName] = abInfo;
#endif
                return;
            }

            string      p           = Path.Combine(PathHelper.AppHotfixResPath, assetBundleName);
            AssetBundle assetBundle = null;
            if (!File.Exists(p))
            {
                p = Path.Combine(PathHelper.AppResPath, assetBundleName);
            }

            using (AssetsBundleLoaderAsync assetsBundleLoaderAsync = EntityFactory.Create <AssetsBundleLoaderAsync>(this.Domain))
            {
                assetBundle = await assetsBundleLoaderAsync.LoadAsync(p);
            }

            if (assetBundle == null)
            {
                throw new Exception($"assets bundle not found: {assetBundleName}");
            }

            if (!assetBundle.isStreamedSceneAssetBundle)
            {
                // 异步load资源到内存cache住
                UnityEngine.Object[] assets;
                using (AssetsLoaderAsync assetsLoaderAsync = EntityFactory.Create <AssetsLoaderAsync, AssetBundle>(this.Domain, assetBundle))
                {
                    assets = await assetsLoaderAsync.LoadAllAssetsAsync();
                }
                foreach (UnityEngine.Object asset in assets)
                {
                    AddResource(assetBundleName, asset.name, asset);
                }
            }

            abInfo = EntityFactory.CreateWithParent <ABInfo, string, AssetBundle>(this, assetBundleName, assetBundle);
            this.bundles[assetBundleName] = abInfo;
        }
Example #10
0
 public override void Awake(FGUIComponent self, Scene scene)
 {
     self.Root = EntityFactory.Create <FGUI, GObject>(scene, GRoot.inst);
     self.Awake(scene);
 }
Example #11
0
 public static FGUILogin Create(Entity domain, GObject go)
 {
     return(EntityFactory.Create <FGUILogin, GObject>(domain, go));
 }
        public async ETTask StartAsync(string url)
        {
            // 获取远程的Version.txt
            string versionUrl = "";

            try
            {
                using (UnityWebRequestAsync webRequestAsync = EntityFactory.Create <UnityWebRequestAsync>(this.Domain))
                {
                    versionUrl = url + "StreamingAssets/" + "Version.txt";
                    //Log.Debug(versionUrl);
                    await webRequestAsync.DownloadAsync(versionUrl);

                    remoteVersionConfig = JsonHelper.FromJson <VersionConfig>(webRequestAsync.Request.downloadHandler.text);
                    //Log.Debug(JsonHelper.ToJson(this.VersionConfig));
                }
            }
            catch (Exception e)
            {
                throw new Exception($"url: {versionUrl}", e);
            }

            // 获取streaming目录的Version.txt
            VersionConfig streamingVersionConfig;
            string        versionPath = Path.Combine(PathHelper.AppResPath4Web, "Version.txt");

            using (UnityWebRequestAsync request = EntityFactory.Create <UnityWebRequestAsync>(this.Domain))
            {
                await request.DownloadAsync(versionPath);

                streamingVersionConfig = JsonHelper.FromJson <VersionConfig>(request.Request.downloadHandler.text);
            }

            // 删掉远程不存在的文件
            DirectoryInfo directoryInfo = new DirectoryInfo(PathHelper.AppHotfixResPath);

            if (directoryInfo.Exists)
            {
                FileInfo[] fileInfos = directoryInfo.GetFiles();
                foreach (FileInfo fileInfo in fileInfos)
                {
                    if (remoteVersionConfig.FileInfoDict.ContainsKey(fileInfo.Name))
                    {
                        continue;
                    }

                    if (fileInfo.Name == "Version.txt")
                    {
                        continue;
                    }

                    fileInfo.Delete();
                }
            }
            else
            {
                directoryInfo.Create();
            }

            // 对比MD5
            foreach (FileVersionInfo fileVersionInfo in remoteVersionConfig.FileInfoDict.Values)
            {
                // 对比md5
                string localFileMD5 = BundleHelper.GetBundleMD5(streamingVersionConfig, fileVersionInfo.File);
                if (fileVersionInfo.MD5 == localFileMD5)
                {
                    continue;
                }
                this.bundles.Enqueue(fileVersionInfo.File);
                this.TotalSize += fileVersionInfo.Size;
            }
        }
Example #13
0
        public async ETTask DownloadAsync(string url)
        {
            if (this.bundles.Count == 0)
            {
                return;
            }
            try
            {
                //正在下载的文件个数
                int downloadingCount = 0;
                //下载单个文件
                async void downloadFile()
                {
                    if (this.bundles.Count == 0)
                    {
                        return;
                    }
                    downloadingCount++;
                    //取出一个进行下载
                    string downloading = this.bundles.Dequeue();

                    Log.Debug($"开始下载({downloadingCount}):{downloading}");
                    try
                    {
                        using (UnityWebRequestAsync webRequest = EntityFactory.Create <UnityWebRequestAsync>(this.Domain))
                        {
                            webRequests.Add(webRequest);
                            await webRequest.DownloadAsync(url + "StreamingAssets/" + downloading);

                            byte[] data = webRequest.Request.downloadHandler.data;
                            webRequests.Remove(webRequest);
                            string path = Path.Combine(PathHelper.AppHotfixResPath, downloading);
                            using (FileStream fs = new FileStream(path, FileMode.Create))
                            {
                                fs.Write(data, 0, data.Length);
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        //下载异常跳过
                        Log.Error($"download bundle error: {downloading}\n{e}");
                    }
                    finally
                    {
                        downloadingCount--;
                    }
                    //正常下载
                    this.downloadedBundles.Add(downloading);
                    Log.Debug($"download bundle Finish: {downloading}\n");
                }

                /*
                 * //最多同时下载n个文件 下载40M(400~500)个文件测试时间(ms)对比
                 * //等待n个任务同时完成再继续 1~61616 2~44796 3~34377 4~31918 5~27184 6~25564 7~22817 8~22719
                 * //完成1个补充1个最大n个任务 1~61309 8~11871 9~10843 10~10600 15~9309 20~9146 100~9195
                 */

                //最大任务数量20 速度从61秒提升到9秒
                int maxCount = 20;
                while (true)
                {
                    await TimerComponent.Instance.WaitAsync(10);

                    //需要下载队列取完 正在下载为0表示完成更新
                    if (this.bundles.Count == 0 && downloadingCount == 0)
                    {
                        break;
                    }
                    for (int i = downloadingCount; i < maxCount; i++)
                    {
                        downloadFile();
                    }
                }
            }
            catch (Exception e)
            {
                Log.Error(e);
            }
        }