public static void GenerateFilesInfoFile() { if (!Directory.Exists(Path.Combine(Application.dataPath, "Resources"))) { Directory.CreateDirectory(Path.Combine(Application.dataPath, "Resources")); } var FilePath = Path.Combine(Application.dataPath, "Resources", FilesInfoFileName); var FileList = PathHelper.GetFileList(Application.streamingAssetsPath, (Path) => PathHelper.GetFileExt(Path) != ".meta"); if (File.Exists(FilePath)) { File.Delete(FilePath); } using (var OutStream = new StreamWriter(FilePath, false, Encoding.ASCII)) { foreach (var File in FileList) { var RelativePath = File.Substring(Application.streamingAssetsPath.Length + 1); OutStream.WriteLine(RelativePath); } OutStream.Close(); } LLogger.LWarning($"Generate FilesInfo Succeed -> {FilePath}"); }
public static bool CacheStreamingAssets(Action <int, int, int> Callback) { var Files = Resources.Load <TextAsset>(PathHelper.GetFileNameWithoutExt(FilesInfoFileName)); if (Files == null || string.IsNullOrWhiteSpace(Files.text)) { LLogger.LWarning("version.txt is empty"); return(false); } var FileList = Files.text.Split(new char[] { '\r', '\n' }); var FileListTrim = new List <string>(); foreach (var FileName in FileList) { if (string.IsNullOrWhiteSpace(FileName)) { continue; } FileListTrim.Add(FileName); } TaskManager.AddTask(CacheStreamingAssets(FileListTrim.ToArray(), Callback)); return(true); }
public T[,] ReadArray2 <T>(string Key, T[,] Default) where T : IArchiveInfo, new() { if (!CacheList_.ContainsKey(Key)) { return(Default); } if (CacheList_[Key] is object[,] ArrayObj) { var Width = ArrayObj.GetLength(0); var Height = ArrayObj.GetLength(1); var OutputArray = new T[Width, Height]; for (var X = 0; X < Width; ++X) { for (var Y = 0; Y < Height; ++Y) { OutputArray[X, Y] = (T)ArrayObj[X, Y]; } } return(OutputArray); } LLogger.LWarning($"archive type error : {Key} - {typeof(T)}"); return(Default); }
public static void DeleteStreamingAssets() { Directory.Delete(Application.streamingAssetsPath, true); Directory.CreateDirectory(Application.streamingAssetsPath); AssetDatabase.Refresh(); LLogger.LWarning("StreamingAssets Remove"); }
public T[] ReadSubArray <T>(string Key, T[] Default) where T : IArchiveInfo, new() { if (!CacheList_.ContainsKey(Key)) { return(Default); } if (CacheList_[Key] is object[] ArrayObj) { var Len = Default?.Length ?? ArrayObj.Length; var OutputArray = new T[Len]; for (var Index = 0; Index < Len; ++Index) { if (Index < ArrayObj.Length) { OutputArray[Index] = (T)ArrayObj[Index]; } else { OutputArray[Index] = Default[Index]; } } return(OutputArray); } LLogger.LWarning($"archive type error : {Key} - {typeof(T)}"); return(Default); }
private static void BindNode(BaseUI UI) { var FieldList = UI.GetType().GetFields(CustomFlags); foreach (var Field in FieldList) { if (Field.FieldType != TransformType) { continue; } var Attr = Field.GetCustomAttribute <LiteUINodeAttribute>(false); if (Attr != null) { var NodeValue = UI.FindChild(Attr.Path); if (NodeValue == null) { LLogger.LWarning($"can't bind node : {Attr.Path}"); continue; } Field.SetValue(UI, NodeValue); } } }
private static void BindEvent(BaseUI UI) { var MethodList = UI.GetType().GetMethods(CustomFlags); foreach (var Method in MethodList) { var Attr = Method.GetCustomAttribute <LiteUIEventAttribute>(false); if (Attr != null) { try { if (Method.GetParameters().Length == 0) { UI.AddEventToChild(Attr.Path, Delegate.CreateDelegate(typeof(UnityAction), UI, Method) as UnityAction, Attr.EventType); } else { UI.AddEventToChild(Attr.Path, Delegate.CreateDelegate(typeof(Action <EventSystemData>), UI, Method) as UnityAction, Attr.EventType); } } catch (Exception Ex) { LLogger.LWarning(Ex.Message); LLogger.LWarning($"can't bind component : {Attr.Path}"); } } } }
private static void BindComponent(BaseUI UI) { var FieldList = UI.GetType().GetFields(CustomFlags); foreach (var Field in FieldList) { if (!Field.FieldType.IsSubclassOf(ComponentType)) { continue; } var Attr = Field.GetCustomAttribute <LiteUIComponentAttribute>(false); if (Attr != null) { var ComponentValue = UI.GetComponent(Attr.Path, Field.FieldType); if (ComponentValue == null) { LLogger.LWarning($"can't bind component : {Attr.Path}"); continue; } Field.SetValue(UI, ComponentValue); } } }
public override IEnumerator LoadAsync() { if (IsLoad) { yield break; } IsLoad = false; Request_ = CreateBundleRequestAsync(AssetPath); yield return(Request_); if (Request_ == null || !Request_.isDone) { LLogger.LWarning($"Load AssetBundle : {AssetPath} Failed"); } else { RefCount_ = 0; IsLoad = true; Bundle_ = Request_.assetBundle; OnLoad(); Request_ = null; } yield break; }
/// <summary> /// only support (Boolean, Int32, BigInteger, String) /// </summary> public T[] ReadArray <T>(string Key, T[] Default) { if (!CacheList_.ContainsKey(Key)) { return(Default); } if (CacheList_[Key] is T[] Value) { if (Default != null && Value.Length < Default.Length) { var NewValue = new T[Default.Length]; for (var Index = 0; Index < NewValue.Length; ++Index) { if (Index < Value.Length) { NewValue[Index] = Value[Index]; } else { NewValue[Index] = Default[Index]; } } return(NewValue); } return(Value); } LLogger.LWarning($"archive type error : {Key} - {typeof(T)}"); return(Default); }
void Update() { try { LiteManager.Tick(Time.deltaTime); } catch (System.Exception Ex) { LLogger.LError($"{Ex.Message}\n{Ex.StackTrace}"); } #if UNITY_EDITOR if (Input.GetKeyDown(KeyCode.F1)) { LiteManager.TimeScale = 0.5f; LLogger.LWarning($"TimeScale = {LiteManager.TimeScale}"); } else if (Input.GetKeyDown(KeyCode.F2)) { LiteManager.TimeScale = 1.0f; LLogger.LWarning($"TimeScale = {LiteManager.TimeScale}"); } else if (Input.GetKeyDown(KeyCode.F3)) { LiteManager.TimeScale = 5.0f; LLogger.LWarning($"TimeScale = {LiteManager.TimeScale}"); } else if (Input.GetKeyDown(KeyCode.PageUp)) { LiteManager.TimeScale--; LLogger.LWarning($"TimeScale = {LiteManager.TimeScale}"); } else if (Input.GetKeyDown(KeyCode.PageDown)) { LiteManager.TimeScale++; LLogger.LWarning($"TimeScale = {LiteManager.TimeScale}"); } if (Input.GetKeyDown(KeyCode.F5)) { LiteManager.Restart(); } else if (Input.GetKeyDown(KeyCode.F6)) { LiteManager.Shutdown(); } else if (Input.GetKeyDown(KeyCode.F9)) { EnableGizmos_ = !EnableGizmos_; } else if (Input.GetKeyDown(KeyCode.F12)) { OnApplicationPause(!LiteManager.IsPause); } #endif }
public void WriteSub <T>(string Key, T Value) where T : IArchiveInfo, new() { if (CacheList_.ContainsKey(Key)) { LLogger.LWarning($"archive repeat key : {Key}"); CacheList_[Key] = Value; return; } CacheList_.Add(Key, Value); }
public override void Check() { if (OnEvent != null) { var CallbackList = OnEvent.GetInvocationList(); foreach (var Callback in CallbackList) { LLogger.LWarning($"{Callback.Method.ReflectedType.Name} : {Callback.Method.Name} UnRegister"); } } }
public static bool CreateDirectory(string DirectoryPath) { DirectoryPath = UnifyPath(DirectoryPath); if (!Directory.Exists(DirectoryPath)) { if (!Directory.CreateDirectory(DirectoryPath).Exists) { LLogger.LWarning($"can't create directory : {DirectoryPath}"); return(false); } } return(true); }
/// <summary> /// support type see : ArchiveDataType /// </summary> public T Read <T>(string Key, T Default) { if (!CacheList_.ContainsKey(Key)) { return(Default); } if (CacheList_[Key] is T TValue) { return(TValue); } LLogger.LWarning($"archive type error : {Key} - {typeof(T)}"); return(Default); }
public T ReadSub <T>(string Key) where T : IArchiveInfo, new() { if (!CacheList_.ContainsKey(Key)) { return(new T()); } if (CacheList_[Key] is T Info) { return(Info); } LLogger.LWarning($"archive type error : {Key} - {typeof(T)}"); return(new T()); }
/// <summary> /// only support (Int32, BigInteger) /// </summary> public void WriteArray2 <T>(string Key, T[,] Value) { if (Value == null) { return; } if (CacheList_.ContainsKey(Key)) { LLogger.LWarning($"archive repeat key : {Key}"); CacheList_[Key] = Value; return; } CacheList_.Add(Key, Value); }
public T CreateAssetSync <T>(AssetUri Uri) where T : UnityEngine.Object { var AssetType = GetAssetTypeWithName <T>(Uri.AssetPath); T Asset = null; var AssetName = Uri.AssetName; if (AssetType == AssetCacheType.Asset) { AssetName = $"{AssetName}_{typeof(T).Name.ToLower()}"; } BaseAssetCache Cache = null; if (!AssetCacheList_.ContainsKey(Uri.AssetPath)) { Cache = LoadAssetSync <UnityEngine.Object>(AssetType, Uri.AssetPath); } else { Cache = AssetCacheList_[Uri.AssetPath]; if (!Cache.IsLoad) { Cache.ForeCompleteAsync(); } } if (Cache != null) { Asset = Cache.CreateAsset(AssetName) as T; if (Asset != null) { if (!AssetPathCacheList_.ContainsKey(Asset.GetInstanceID())) { AssetPathCacheList_.Add(Asset.GetInstanceID(), Uri.AssetPath); } } else { LLogger.LWarning($"Can't Create Asset : {Uri}"); } } return(Asset); }
private static uint PlayAudio(AudioType Type, Transform Parent, AssetUri Uri, bool IsLoop = false, float Volume = 1.0f) { if (Uri == null) { return(0); } var Entity = new AudioEntity(Type); AudioList_.Add(Entity.SerialID, Entity); AssetManager.CreateAssetAsync <AudioClip>(Uri, (Clip) => { if (Clip == null) { LLogger.LWarning($"can't play audio : {Uri}"); RemoveList_.Add(Entity); return; } Entity.LoadAudio(Parent, Clip, IsLoop, Volume, false); switch (Type) { case AudioType.Sound: if (MuteSound) { Entity.Mute(MuteSound); } break; case AudioType.Music: if (MuteMusic) { Entity.Mute(MuteMusic); } break; default: break; } Entity.Play(); }); return(Entity.SerialID); }
public override void LoadSync() { IsLoad = false; var Request = CreateInternalRequestSync(AssetPath); if (Request == null) { LLogger.LWarning($"Load AssetInternal : {AssetPath} Failed"); } else { RefCount_ = 0; IsLoad = true; Bundle = Request; OnLoad(); } }
protected override void OnLoad() { IsLoad = false; var FullPath = GetInternalAssetPath(); if (!File.Exists(FullPath)) { LLogger.LWarning($"Load AssetInternal : {FullPath} Failed"); } else { RefCount_ = 0; IsLoad = true; Buffer = File.ReadAllBytes(FullPath); Asset_ = new AssetInternalTextAsset(Buffer); } }
public override void LoadSync() { IsLoad = false; var Request = CreateBundleRequestSync(AssetPath); if (!Request) { LLogger.LWarning($"Load AssetBundle : {AssetPath} Failed"); } else { RefCount_ = 0; IsLoad = true; Bundle_ = Request; OnLoad(); } }
public void UseSkill(SkillArgs Args) { if (Args == null || Args.Skill == null) { LLogger.LWarning("Npc UseSkill, Args or Args.Skill is null"); return; } if (!CanUseSkill(Args.Skill.SkillID)) { return; } var Evt = new NpcSkillEvent(Master, Args.Skill.SkillID, Args); EventManager.Send(Evt); }
public static void ReplaceSprite(SpriteRenderer Master, AssetUri Uri) { if (Master == null || Uri == null) { return; } AssetManager.CreateAssetAsync <Sprite>(Uri, (Spr) => { if (Spr == null) { LLogger.LWarning($"can't load {Uri}"); return; } Master.sprite = Spr; }); }
public override void LoadSync() { IsLoad = false; var Bundle = Request_ != null ? Request_.assetBundle : CreateBundleRequestSync(AssetPath); if (!Bundle) { LLogger.LWarning($"Load AssetBundle : {AssetPath} Failed"); } else { RefCount_ = 0; IsLoad = true; Bundle_ = Bundle; OnLoad(); Request_ = null; } }
public static NpcSkill AddNpcSkill(SkillDescriptor Desc, BaseNpc Master) { if (Desc == null || Master == null) { return(null); } if (Desc.Type == SkillType.Passive) { LLogger.LWarning($"need not passive desc, current is {Desc.Type}"); return(null); } var Entity = new NpcSkill(Desc, Master); AddSkill(Entity); return(Entity); }
protected override void OnLoad() { var AssetList = Bundle_.LoadAllAssets <UnityEngine.GameObject>(); if (AssetList != null) { foreach (var Asset in AssetList) { var Name = Asset.name.ToLower(); if (AssetList_.ContainsKey(Name)) { LLogger.LWarning($"Repeat Asset : {Name}"); continue; } AssetList_.Add(Name, Asset); } } }
protected override void OnLoad() { var AssetList = Bundle_.LoadAllAssets <T>(); if (AssetList != null) { foreach (var Asset in AssetList) { var Name = $"{Asset.name.ToLower()}_{Asset.GetType().Name.ToLower()}"; if (AssetList_.ContainsKey(Name)) { LLogger.LWarning($"Repeat Asset : {Name}"); continue; } AssetList_.Add(Name, Asset); AssetInstanceIDList_.Add(Asset.GetInstanceID()); } } }
public static PassiveSkill AddPassiveSkill(SkillDescriptor Desc, BaseNpc Master, float SustainTime) { if (Desc == null || Master == null) { return(null); } if (Desc.Type != SkillType.Passive) { LLogger.LWarning($"need passive desc, current is {Desc.Type}"); return(null); } var Entity = new PassiveSkill(Desc, Master, SustainTime); AddSkill(Entity); Entity.Use(new SkillArgs(Entity)); return(Entity); }
/// <summary> /// only support (Int32, BigInteger) /// </summary> public T[,] ReadArray2 <T>(string Key, T[,] Default) { if (!CacheList_.ContainsKey(Key)) { return(Default); } if (CacheList_[Key] is T[,] Value) { var Len1 = Value.GetLength(0); var Len2 = Value.GetLength(1); var NewLen1 = Default?.GetLength(0) ?? Len1; var NewLen2 = Default?.GetLength(1) ?? Len2; if (Len1 < NewLen1 || Len2 < NewLen2) { var NewValue = new T[NewLen1, NewLen2]; for (var X = 0; X < NewLen1; ++X) { for (var Y = 0; Y < NewLen2; ++Y) { if (X < Len1 && Y < Len2) { NewValue[X, Y] = Value[X, Y]; } else { NewValue[X, Y] = Default[X, Y]; } } } return(NewValue); } return(Value); } LLogger.LWarning($"archive type error : {Key} - {typeof(T)}"); return(Default); }