调整目录结构

Assets/Scripts/Model/Module/ObjectWait/ObjectWait.cs

@@ -0,0 +1,144 @@
+using System;
+using System.Collections.Generic;
+using NBC;
+using NBC.Entitas;
+using NBC.Entitas.Interface;
+
+namespace NBF.Fishing2
+{
+    public static class WaitTypeError
+    {
+        public const int Success = 0;
+        public const int Destroy = 1;
+        public const int Cancel = 2;
+        public const int Timeout = 3;
+    }
+
+    public interface IWaitType
+    {
+        int Error { get; set; }
+    }
+
+
+    public class ObjectWait : Entity
+    {
+        public Dictionary<Type, List<object>> tcsDict = new();
+    }
+
+
+    public static class ObjectWaitSystem
+    {
+        public class ObjectWaitAwakeSystem : AwakeSystem<ObjectWait>
+        {
+            protected override void Awake(ObjectWait self)
+            {
+                self.tcsDict.Clear();
+            }
+        }
+
+        public class ObjectWaitDestroySystem : DestroySystem<ObjectWait>
+        {
+            protected override void Destroy(ObjectWait self)
+            {
+                foreach (var p in self.tcsDict)
+                {
+                    foreach (object v in p.Value)
+                    {
+                        ((IDestroyRun)v).SetResult();
+                    }
+                }
+
+                self.tcsDict.Clear();
+            }
+        }
+
+        private interface IDestroyRun
+        {
+            void SetResult();
+        }
+
+        private class ResultCallback<K> : IDestroyRun where K : struct, IWaitType
+        {
+            private FTask<K> tcs;
+
+            public ResultCallback()
+            {
+                this.tcs = FTask<K>.Create(true);
+            }
+
+            public bool IsDisposed
+            {
+                get { return this.tcs == null; }
+            }
+
+            public FTask<K> Task => this.tcs;
+
+            public void SetResult(K k)
+            {
+                var t = tcs;
+                this.tcs = null;
+                t.SetResult(k);
+            }
+
+            public void SetResult()
+            {
+                var t = tcs;
+                this.tcs = null;
+                t.SetResult(new K() { Error = WaitTypeError.Destroy });
+            }
+        }
+
+        public static async FTask<T> Wait<T>(this ObjectWait self) where T : struct, IWaitType
+        {
+            ResultCallback<T> tcs = new ResultCallback<T>();
+            FCancellationToken cancellationToken = FCancellationToken.ToKen;
+            self.Add(typeof(T), tcs);
+
+            T ret;
+            try
+            {
+                cancellationToken?.Add(CancelAction);
+                ret = await tcs.Task;
+            }
+            finally
+            {
+                cancellationToken?.Remove(CancelAction);
+            }
+
+            return ret;
+
+            void CancelAction()
+            {
+                self.Notify(new T() { Error = WaitTypeError.Cancel });
+            }
+        }
+
+        public static void Notify<T>(this ObjectWait self, T obj) where T : struct, IWaitType
+        {
+            Type type = typeof(T);
+            if (!self.tcsDict.TryGetValue(type, out var tcsList) || tcsList.Count == 0)
+            {
+                return;
+            }
+
+            foreach (var tcs in tcsList)
+            {
+                ((ResultCallback<T>)tcs).SetResult(obj);
+            }
+
+            tcsList.Clear();
+        }
+
+        private static void Add(this ObjectWait self, Type type, object obj)
+        {
+            if (self.tcsDict.TryGetValue(type, out var list))
+            {
+                list.Add(obj);
+            }
+            else
+            {
+                self.tcsDict.Add(type, new List<object> { obj });
+            }
+        }
+    }
+}