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);
}
}
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);
}
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);
}
}
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;
}
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);
}
}
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;
}
public static FGUITitleButton Create(Entity domain, GObject go)
{
return(EntityFactory.Create <FGUITitleButton, GObject>(domain, go));
}
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;
}
public override void Awake(FGUIComponent self, Scene scene)
{
self.Root = EntityFactory.Create <FGUI, GObject>(scene, GRoot.inst);
self.Awake(scene);
}
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;
}
}
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);
}
}