[+] 接入ET8服务端

[+] 接入ET8服务端

Assets/GameScripts/DotNet/Core/Entity/ComponentView.cs

@@ -0,0 +1,15 @@
+#if ENABLE_VIEW && UNITY_EDITOR
+using UnityEngine;
+
+namespace ET
+{
+    public class ComponentView: MonoBehaviour
+    {
+        public Entity Component
+        {
+            get;
+            set;
+        }
+    }
+}
+#endif

Assets/GameScripts/DotNet/Core/Entity/ComponentView.cs.meta

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

Assets/GameScripts/DotNet/Core/Entity/Entity.cs.meta

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

Assets/GameScripts/DotNet/Core/Entity/EntityHelper.cs

@@ -0,0 +1,30 @@
+namespace ET
+{
+    public static class EntityHelper
+    {
+        public static int Zone(this Entity entity)
+        {
+            return entity.IScene.Fiber.Zone;
+        }
+
+        public static Scene Scene(this Entity entity)
+        {
+            return entity.IScene as Scene;
+        }
+        
+        public static T Scene<T>(this Entity entity) where T: class, IScene 
+        {
+            return entity.IScene as T;
+        }
+        
+        public static Scene Root(this Entity entity)
+        {
+            return entity.IScene.Fiber.Root;
+        }
+        
+        public static Fiber Fiber(this Entity entity)
+        {
+            return entity.IScene.Fiber;
+        }
+    }
+}

Assets/GameScripts/DotNet/Core/Entity/EntityHelper.cs.meta

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

Assets/GameScripts/DotNet/Core/Entity/EntityRef.cs

@@ -0,0 +1,103 @@
+using System;
+
+namespace ET
+{
+    public readonly struct EntityRef<T> where T: Entity
+    {
+        private readonly long instanceId;
+        private readonly T entity;
+
+        private EntityRef(T t)
+        {
+            if (t == null)
+            {
+                this.instanceId = 0;
+                this.entity = null;
+                return;
+            }
+            this.instanceId = t.InstanceId;
+            this.entity = t;
+        }
+        
+        private T UnWrap
+        {
+            get
+            {
+                if (this.entity == null)
+                {
+                    return null;
+                }
+                if (this.entity.InstanceId != this.instanceId)
+                {
+                    return null;
+                }
+                return this.entity;
+            }
+        }
+        
+        public static implicit operator EntityRef<T>(T t)
+        {
+            return new EntityRef<T>(t);
+        }
+
+        public static implicit operator T(EntityRef<T> v)
+        {
+            return v.UnWrap;
+        }
+    }
+    
+    
+    public struct EntityWeakRef<T> where T: Entity
+    {
+        private long instanceId;
+        // 使用WeakReference，这样不会导致entity dispose了却无法gc的问题
+        // 不过暂时没有测试WeakReference的性能
+        private readonly WeakReference<T> weakRef;
+
+        private EntityWeakRef(T t)
+        {
+            if (t != null)
+            {
+                this.instanceId = 0;
+                this.weakRef = null;
+                return;
+            }
+            this.instanceId = t.InstanceId;
+            this.weakRef = new WeakReference<T>(t);
+        }
+        
+        private T UnWrap
+        {
+            get
+            {
+                if (this.instanceId == 0)
+                {
+                    return null;
+                }
+
+                if (!this.weakRef.TryGetTarget(out T entity))
+                {
+                    this.instanceId = 0;
+                    return null;
+                }
+
+                if (entity.InstanceId != this.instanceId)
+                {
+                    this.instanceId = 0;
+                    return null;
+                }
+                return entity;
+            }
+        }
+        
+        public static implicit operator EntityWeakRef<T>(T t)
+        {
+            return new EntityWeakRef<T>(t);
+        }
+
+        public static implicit operator T(EntityWeakRef<T> v)
+        {
+            return v.UnWrap;
+        }
+    }
+}

Assets/GameScripts/DotNet/Core/Entity/EntityRef.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ef22211834964fd8aced938aa4307f76
+timeCreated: 1683206917

Assets/GameScripts/DotNet/Core/Entity/EntitySceneFactory.cs

@@ -0,0 +1,12 @@
+namespace ET
+{
+    public static class EntitySceneFactory
+    {
+        public static Scene CreateScene(Entity parent, long id, long instanceId, SceneType sceneType, string name)
+        {
+            Scene scene = new(parent.Fiber(), id, instanceId, sceneType, name);
+            parent?.AddChild(scene);
+            return scene;
+        }
+    }
+}

Assets/GameScripts/DotNet/Core/Entity/EntitySceneFactory.cs.meta

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

Assets/GameScripts/DotNet/Core/Entity/EntitySystemAttribute.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace ET
+{
+	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
+	public class EntitySystemAttribute: BaseAttribute
+	{
+	}
+}

Assets/GameScripts/DotNet/Core/Entity/EntitySystemAttribute.cs.meta

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

Assets/GameScripts/DotNet/Core/Entity/EntitySystemSingleton.cs

@@ -0,0 +1,302 @@
+using System;
+using System.Collections.Generic;
+
+namespace ET
+{
+    public class EntitySystemSingleton: SingletonLock<EntitySystemSingleton>, ISingletonAwake
+    {
+        public TypeSystems TypeSystems { get; private set; }
+        
+        public void Awake()
+        {
+            this.TypeSystems = new TypeSystems(InstanceQueueIndex.Max);
+
+            foreach (Type type in EventSystem.Instance.GetTypes(typeof (EntitySystemAttribute)))
+            {
+                object obj = Activator.CreateInstance(type);
+
+                if (obj is ISystemType iSystemType)
+                {
+                    TypeSystems.OneTypeSystems oneTypeSystems = this.TypeSystems.GetOrCreateOneTypeSystems(iSystemType.Type());
+                    oneTypeSystems.Map.Add(iSystemType.SystemType(), obj);
+                    int index = iSystemType.GetInstanceQueueIndex();
+                    if (index > InstanceQueueIndex.None && index < InstanceQueueIndex.Max)
+                    {
+                        oneTypeSystems.QueueFlag[index] = true;
+                    }
+                }
+            }
+        }
+        
+        public override void Load()
+        {
+            World.Instance.AddSingleton<EntitySystemSingleton>(true);
+        }
+        
+        public void Serialize(Entity component)
+        {
+            if (component is not ISerialize)
+            {
+                return;
+            }
+            
+            List<object> iSerializeSystems = this.TypeSystems.GetSystems(component.GetType(), typeof (ISerializeSystem));
+            if (iSerializeSystems == null)
+            {
+                return;
+            }
+
+            foreach (ISerializeSystem serializeSystem in iSerializeSystems)
+            {
+                if (serializeSystem == null)
+                {
+                    continue;
+                }
+
+                try
+                {
+                    serializeSystem.Run(component);
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e);
+                }
+            }
+        }
+        
+        public void Deserialize(Entity component)
+        {
+            if (component is not IDeserialize)
+            {
+                return;
+            }
+            
+            List<object> iDeserializeSystems = this.TypeSystems.GetSystems(component.GetType(), typeof (IDeserializeSystem));
+            if (iDeserializeSystems == null)
+            {
+                return;
+            }
+
+            foreach (IDeserializeSystem deserializeSystem in iDeserializeSystems)
+            {
+                if (deserializeSystem == null)
+                {
+                    continue;
+                }
+
+                try
+                {
+                    deserializeSystem.Run(component);
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e);
+                }
+            }
+        }
+        
+        // GetComponentSystem
+        public void GetComponent(Entity entity, Entity component)
+        {
+            List<object> iGetSystem = this.TypeSystems.GetSystems(entity.GetType(), typeof (IGetComponentSystem));
+            if (iGetSystem == null)
+            {
+                return;
+            }
+
+            foreach (IGetComponentSystem getSystem in iGetSystem)
+            {
+                if (getSystem == null)
+                {
+                    continue;
+                }
+
+                try
+                {
+                    getSystem.Run(entity, component);
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e);
+                }
+            }
+        }
+        
+        // AddComponentSystem
+        public void AddComponent(Entity entity, Entity component)
+        {
+            List<object> iAddSystem = this.TypeSystems.GetSystems(entity.GetType(), typeof (IAddComponentSystem));
+            if (iAddSystem == null)
+            {
+                return;
+            }
+
+            foreach (IAddComponentSystem addComponentSystem in iAddSystem)
+            {
+                if (addComponentSystem == null)
+                {
+                    continue;
+                }
+
+                try
+                {
+                    addComponentSystem.Run(entity, component);
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e);
+                }
+            }
+        }
+
+        public void Awake(Entity component)
+        {
+            List<object> iAwakeSystems = this.TypeSystems.GetSystems(component.GetType(), typeof (IAwakeSystem));
+            if (iAwakeSystems == null)
+            {
+                return;
+            }
+
+            foreach (IAwakeSystem aAwakeSystem in iAwakeSystems)
+            {
+                if (aAwakeSystem == null)
+                {
+                    continue;
+                }
+
+                try
+                {
+                    aAwakeSystem.Run(component);
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e);
+                }
+            }
+        }
+
+        public void Awake<P1>(Entity component, P1 p1)
+        {
+            if (component is not IAwake<P1>)
+            {
+                return;
+            }
+            
+            List<object> iAwakeSystems = this.TypeSystems.GetSystems(component.GetType(), typeof (IAwakeSystem<P1>));
+            if (iAwakeSystems == null)
+            {
+                return;
+            }
+
+            foreach (IAwakeSystem<P1> aAwakeSystem in iAwakeSystems)
+            {
+                if (aAwakeSystem == null)
+                {
+                    continue;
+                }
+
+                try
+                {
+                    aAwakeSystem.Run(component, p1);
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e);
+                }
+            }
+        }
+
+        public void Awake<P1, P2>(Entity component, P1 p1, P2 p2)
+        {
+            if (component is not IAwake<P1, P2>)
+            {
+                return;
+            }
+            
+            List<object> iAwakeSystems = this.TypeSystems.GetSystems(component.GetType(), typeof (IAwakeSystem<P1, P2>));
+            if (iAwakeSystems == null)
+            {
+                return;
+            }
+
+            foreach (IAwakeSystem<P1, P2> aAwakeSystem in iAwakeSystems)
+            {
+                if (aAwakeSystem == null)
+                {
+                    continue;
+                }
+
+                try
+                {
+                    aAwakeSystem.Run(component, p1, p2);
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e);
+                }
+            }
+        }
+
+        public void Awake<P1, P2, P3>(Entity component, P1 p1, P2 p2, P3 p3)
+        {
+            if (component is not IAwake<P1, P2, P3>)
+            {
+                return;
+            }
+            
+            List<object> iAwakeSystems = this.TypeSystems.GetSystems(component.GetType(), typeof (IAwakeSystem<P1, P2, P3>));
+            if (iAwakeSystems == null)
+            {
+                return;
+            }
+
+            foreach (IAwakeSystem<P1, P2, P3> aAwakeSystem in iAwakeSystems)
+            {
+                if (aAwakeSystem == null)
+                {
+                    continue;
+                }
+
+                try
+                {
+                    aAwakeSystem.Run(component, p1, p2, p3);
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e);
+                }
+            }
+        }
+
+        public void Destroy(Entity component)
+        {
+            if (component is not IDestroy)
+            {
+                return;
+            }
+            
+            List<object> iDestroySystems = this.TypeSystems.GetSystems(component.GetType(), typeof (IDestroySystem));
+            if (iDestroySystems == null)
+            {
+                return;
+            }
+
+            foreach (IDestroySystem iDestroySystem in iDestroySystems)
+            {
+                if (iDestroySystem == null)
+                {
+                    continue;
+                }
+
+                try
+                {
+                    iDestroySystem.Run(component);
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e);
+                }
+            }
+        }
+    }
+}

Assets/GameScripts/DotNet/Core/Entity/EntitySystemSingleton.cs.meta

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

Assets/GameScripts/DotNet/Core/Entity/IAddComponentSystem.cs

@@ -0,0 +1,39 @@
+using System;
+
+namespace ET
+{
+	public interface IAddComponent
+	{
+	}
+	
+	public interface IAddComponentSystem: ISystemType
+	{
+		void Run(Entity o, Entity component);
+	}
+
+	[EntitySystem]
+	public abstract class AddComponentSystem<T> : IAddComponentSystem where T: Entity, IAddComponent
+	{
+		void IAddComponentSystem.Run(Entity o, Entity component)
+		{
+			this.AddComponent((T)o, component);
+		}
+
+		Type ISystemType.SystemType()
+		{
+			return typeof(IAddComponentSystem);
+		}
+
+		int ISystemType.GetInstanceQueueIndex()
+		{
+			return InstanceQueueIndex.None;
+		}
+
+		Type ISystemType.Type()
+		{
+			return typeof(T);
+		}
+
+		protected abstract void AddComponent(T self, Entity component);
+	}
+}

Assets/GameScripts/DotNet/Core/Entity/IAddComponentSystem.cs.meta

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

Assets/GameScripts/DotNet/Core/Entity/IAwakeSystem.cs

@@ -0,0 +1,179 @@
+using System;
+
+namespace ET
+{
+    public interface IAwake
+    {
+    }
+
+    public interface IAwake<A>
+    {
+    }
+	
+    public interface IAwake<A, B>
+    {
+    }
+	
+    public interface IAwake<A, B, C>
+    {
+    }
+	
+    public interface IAwake<A, B, C, D>
+    {
+    }
+    
+    public interface IAwakeSystem: ISystemType
+    {
+        void Run(Entity o);
+    }
+	
+    public interface IAwakeSystem<A>: ISystemType
+    {
+        void Run(Entity o, A a);
+    }
+	
+    public interface IAwakeSystem<A, B>: ISystemType
+    {
+        void Run(Entity o, A a, B b);
+    }
+	
+    public interface IAwakeSystem<A, B, C>: ISystemType
+    {
+        void Run(Entity o, A a, B b, C c);
+    }
+	
+    public interface IAwakeSystem<A, B, C, D>: ISystemType
+    {
+        void Run(Entity o, A a, B b, C c, D d);
+    }
+
+    [EntitySystem]
+    public abstract class AwakeSystem<T> : IAwakeSystem where T: Entity, IAwake
+    {
+        Type ISystemType.Type()
+        {
+            return typeof(T);
+        }
+
+        Type ISystemType.SystemType()
+        {
+            return typeof(IAwakeSystem);
+        }
+
+        int ISystemType.GetInstanceQueueIndex()
+        {
+            return InstanceQueueIndex.None;
+        }
+
+        void IAwakeSystem.Run(Entity o)
+        {
+            this.Awake((T)o);
+        }
+
+        protected abstract void Awake(T self);
+    }
+    
+    [EntitySystem]
+    public abstract class AwakeSystem<T, A> : IAwakeSystem<A> where T: Entity, IAwake<A>
+    {
+        Type ISystemType.Type()
+        {
+            return typeof(T);
+        }
+
+        Type ISystemType.SystemType()
+        {
+            return typeof(IAwakeSystem<A>);
+        }
+
+        int ISystemType.GetInstanceQueueIndex()
+        {
+            return InstanceQueueIndex.None;
+        }
+
+        void IAwakeSystem<A>.Run(Entity o, A a)
+        {
+            this.Awake((T)o, a);
+        }
+
+        protected abstract void Awake(T self, A a);
+    }
+
+    [EntitySystem]
+    public abstract class AwakeSystem<T, A, B> : IAwakeSystem<A, B> where T: Entity, IAwake<A, B>
+    {
+        Type ISystemType.Type()
+        {
+            return typeof(T);
+        }
+
+        Type ISystemType.SystemType()
+        {
+            return typeof(IAwakeSystem<A, B>);
+        }
+
+        int ISystemType.GetInstanceQueueIndex()
+        {
+            return InstanceQueueIndex.None;
+        }
+
+        void IAwakeSystem<A, B>.Run(Entity o, A a, B b)
+        {
+            this.Awake((T)o, a, b);
+        }
+
+        protected abstract void Awake(T self, A a, B b);
+    }
+
+    [EntitySystem]
+    public abstract class AwakeSystem<T, A, B, C> : IAwakeSystem<A, B, C> where T: Entity, IAwake<A, B, C>
+    {
+        Type ISystemType.Type()
+        {
+            return typeof(T);
+        }
+
+        Type ISystemType.SystemType()
+        {
+            return typeof(IAwakeSystem<A, B, C>);
+        }
+
+        int ISystemType.GetInstanceQueueIndex()
+        {
+            return InstanceQueueIndex.None;
+        }
+
+        void IAwakeSystem<A, B, C>.Run(Entity o, A a, B b, C c)
+        {
+            this.Awake((T)o, a, b, c);
+        }
+
+        protected abstract void Awake(T self, A a, B b, C c);
+    }
+    
+    [EntitySystem]
+    public abstract class AwakeSystem<T, A, B, C, D> : IAwakeSystem<A, B, C, D> where T: Entity, IAwake<A, B, C, D>
+    {
+        Type ISystemType.Type()
+        {
+            return typeof(T);
+        }
+
+        Type ISystemType.SystemType()
+        {
+            return typeof(IAwakeSystem<A, B, C, D>);
+        }
+
+        int ISystemType.GetInstanceQueueIndex()
+        {
+            return InstanceQueueIndex.None;
+        }
+
+        void IAwakeSystem<A, B, C, D>.Run(Entity o, A a, B b, C c, D d)
+        {
+            this.Awake((T)o, a, b, c, d);
+        }
+
+        protected abstract void Awake(T self, A a, B b, C c, D d);
+    }
+}

Assets/GameScripts/DotNet/Core/Entity/IAwakeSystem.cs.meta

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

Assets/GameScripts/DotNet/Core/Entity/IDeserializeSystem.cs

@@ -0,0 +1,43 @@
+using System;
+
+namespace ET
+{
+	public interface IDeserialize
+	{
+	}
+	
+	public interface IDeserializeSystem: ISystemType
+	{
+		void Run(Entity o);
+	}
+
+	/// <summary>
+	/// 反序列化后执行的System
+	/// </summary>
+	/// <typeparam name="T"></typeparam>
+	[EntitySystem]
+	public abstract class DeserializeSystem<T> : IDeserializeSystem where T: Entity, IDeserialize
+	{
+		void IDeserializeSystem.Run(Entity o)
+		{
+			this.Deserialize((T)o);
+		}
+
+		Type ISystemType.SystemType()
+		{
+			return typeof(IDeserializeSystem);
+		}
+
+		int ISystemType.GetInstanceQueueIndex()
+		{
+			return InstanceQueueIndex.None;
+		}
+
+		Type ISystemType.Type()
+		{
+			return typeof(T);
+		}
+
+		protected abstract void Deserialize(T self);
+	}
+}

Assets/GameScripts/DotNet/Core/Entity/IDeserializeSystem.cs.meta

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

Assets/GameScripts/DotNet/Core/Entity/IDestroySystem.cs

@@ -0,0 +1,39 @@
+using System;
+
+namespace ET
+{
+	public interface IDestroy
+	{
+	}
+	
+	public interface IDestroySystem: ISystemType
+	{
+		void Run(Entity o);
+	}
+
+	[EntitySystem]
+	public abstract class DestroySystem<T> : IDestroySystem where T: Entity, IDestroy
+	{
+		void IDestroySystem.Run(Entity o)
+		{
+			this.Destroy((T)o);
+		}
+
+		Type ISystemType.SystemType()
+		{
+			return typeof(IDestroySystem);
+		}
+
+		int ISystemType.GetInstanceQueueIndex()
+		{
+			return InstanceQueueIndex.None;
+		}
+
+		Type ISystemType.Type()
+		{
+			return typeof(T);
+		}
+
+		protected abstract void Destroy(T self);
+	}
+}

Assets/GameScripts/DotNet/Core/Entity/IDestroySystem.cs.meta

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

Assets/GameScripts/DotNet/Core/Entity/IGetComponentSystem.cs

@@ -0,0 +1,43 @@
+using System;
+
+namespace ET
+{
+	// GetComponentSystem有巨大作用，比如每次保存Unit的数据不需要所有组件都保存，只需要保存Unit变化过的组件
+	// 是否变化可以通过判断该组件是否GetComponent，Get了就记录该组件
+	// 这样可以只保存Unit变化过的组件
+	// 再比如传送也可以做此类优化
+	public interface IGetComponent
+	{
+	}
+	
+	public interface IGetComponentSystem: ISystemType
+	{
+		void Run(Entity o, Entity component);
+	}
+
+	[EntitySystem]
+	public abstract class GetComponentSystem<T> : IGetComponentSystem where T: Entity, IGetComponent
+	{
+		void IGetComponentSystem.Run(Entity o, Entity component)
+		{
+			this.GetComponent((T)o, component);
+		}
+
+		Type ISystemType.SystemType()
+		{
+			return typeof(IGetComponentSystem);
+		}
+
+		int ISystemType.GetInstanceQueueIndex()
+		{
+			return InstanceQueueIndex.None;
+		}
+
+		Type ISystemType.Type()
+		{
+			return typeof(T);
+		}
+
+		protected abstract void GetComponent(T self, Entity component);
+	}
+}

Assets/GameScripts/DotNet/Core/Entity/IGetComponentSystem.cs.meta

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

Assets/GameScripts/DotNet/Core/Entity/ILateUpdateSystem.cs

@@ -0,0 +1,39 @@
+using System;
+
+namespace ET
+{
+	public interface ILateUpdate
+	{
+	}
+	
+	public interface ILateUpdateSystem: ISystemType
+	{
+		void Run(Entity o);
+	}
+
+	[EntitySystem]
+	public abstract class LateUpdateSystem<T> : ILateUpdateSystem where T: Entity, ILateUpdate
+	{
+		void ILateUpdateSystem.Run(Entity o)
+		{
+			this.LateUpdate((T)o);
+		}
+
+		Type ISystemType.Type()
+		{
+			return typeof(T);
+		}
+
+		Type ISystemType.SystemType()
+		{
+			return typeof(ILateUpdateSystem);
+		}
+
+		int ISystemType.GetInstanceQueueIndex()
+		{
+			return InstanceQueueIndex.LateUpdate;
+		}
+
+		protected abstract void LateUpdate(T self);
+	}
+}

Assets/GameScripts/DotNet/Core/Entity/ILateUpdateSystem.cs.meta

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

Assets/GameScripts/DotNet/Core/Entity/IScene.cs

@@ -0,0 +1,8 @@
+namespace ET
+{
+    public interface IScene
+    {
+        Fiber Fiber { get; set; }
+        SceneType SceneType { get; set; }
+    }
+}

Assets/GameScripts/DotNet/Core/Entity/IScene.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 18e1047315ac4b4e9d873d9056514569
+timeCreated: 1687171102

Assets/GameScripts/DotNet/Core/Entity/ISerializeSystem.cs

@@ -0,0 +1,43 @@
+using System;
+
+namespace ET
+{
+	public interface ISerialize
+	{
+	}
+	
+	public interface ISerializeSystem: ISystemType
+	{
+		void Run(Entity o);
+	}
+
+	/// <summary>
+	/// 序列化前执行的System
+	/// </summary>
+	/// <typeparam name="T"></typeparam>
+	[EntitySystem]
+	public abstract class SerializeSystem<T> : ISerializeSystem where T: Entity, ISerialize
+	{
+		void ISerializeSystem.Run(Entity o)
+		{
+			this.Serialize((T)o);
+		}
+
+		Type ISystemType.SystemType()
+		{
+			return typeof(ISerializeSystem);
+		}
+
+		int ISystemType.GetInstanceQueueIndex()
+		{
+			return InstanceQueueIndex.None;
+		}
+
+		Type ISystemType.Type()
+		{
+			return typeof(T);
+		}
+
+		protected abstract void Serialize(T self);
+	}
+}

Assets/GameScripts/DotNet/Core/Entity/ISerializeSystem.cs.meta

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

Assets/GameScripts/DotNet/Core/Entity/ISerializeToEntity.cs

@@ -0,0 +1,6 @@
+namespace ET
+{
+	public interface ISerializeToEntity
+	{
+	}
+}

Assets/GameScripts/DotNet/Core/Entity/ISerializeToEntity.cs.meta

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

Assets/GameScripts/DotNet/Core/Entity/ISystemType.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace ET
+{
+    public interface ISystemType
+    {
+        Type Type();
+        Type SystemType();
+        int GetInstanceQueueIndex();
+    }
+}

Assets/GameScripts/DotNet/Core/Entity/ISystemType.cs.meta

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

Assets/GameScripts/DotNet/Core/Entity/ITransfer.cs

@@ -0,0 +1,8 @@
+namespace ET
+{
+    // Unit的组件有这个接口说明需要传送
+    public interface ITransfer
+    {
+        
+    }
+}

Assets/GameScripts/DotNet/Core/Entity/ITransfer.cs.meta

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

Assets/GameScripts/DotNet/Core/Entity/IUpdateSystem.cs

@@ -0,0 +1,39 @@
+using System;
+
+namespace ET
+{
+	public interface IUpdate
+	{
+	}
+	
+	public interface IUpdateSystem: ISystemType
+	{
+		void Run(Entity o);
+	}
+
+	[EntitySystem]
+	public abstract class UpdateSystem<T> : IUpdateSystem where T: Entity, IUpdate
+	{
+		void IUpdateSystem.Run(Entity o)
+		{
+			this.Update((T)o);
+		}
+
+		Type ISystemType.Type()
+		{
+			return typeof(T);
+		}
+
+		Type ISystemType.SystemType()
+		{
+			return typeof(IUpdateSystem);
+		}
+
+		int ISystemType.GetInstanceQueueIndex()
+		{
+			return InstanceQueueIndex.Update;
+		}
+
+		protected abstract void Update(T self);
+	}
+}

Assets/GameScripts/DotNet/Core/Entity/IUpdateSystem.cs.meta

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

Assets/GameScripts/DotNet/Core/Entity/InstanceQueueIndex.cs

@@ -0,0 +1,11 @@
+namespace ET
+{
+    public static class InstanceQueueIndex
+    {
+        public const int None = -1;
+        public const int Update = 0;
+        public const int LateUpdate = 1;
+        public const int Load = 2;
+        public const int Max = 3;
+    }
+}

Assets/GameScripts/DotNet/Core/Entity/InstanceQueueIndex.cs.meta

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

Assets/GameScripts/DotNet/Core/Entity/Scene.cs

@@ -0,0 +1,54 @@
+using System.Diagnostics;
+using MongoDB.Bson.Serialization.Attributes;
+
+namespace ET
+{
+    [EnableMethod]
+    [ChildOf]
+    public class Scene: Entity, IScene
+    {
+        [BsonIgnore]
+        public Fiber Fiber { get; set; }
+        
+        public string Name { get; }
+        
+        public SceneType SceneType
+        {
+            get;
+            set;
+        }
+
+        public Scene()
+        {
+        }
+
+        public Scene(Fiber fiber, long id, long instanceId, SceneType sceneType, string name)
+        {
+            this.Id = id;
+            this.Name = name;
+            this.InstanceId = instanceId;
+            this.SceneType = sceneType;
+            this.IsCreated = true;
+            this.IsNew = true;
+            this.Fiber = fiber;
+            this.IScene = this;
+            this.IsRegister = true;
+            Log.Info($"scene create: {this.SceneType} {this.Id} {this.InstanceId}");
+        }
+
+        public override void Dispose()
+        {
+            base.Dispose();
+            
+            Log.Info($"scene dispose: {this.SceneType} {this.Id} {this.InstanceId}");
+        }
+        
+        protected override string ViewName
+        {
+            get
+            {
+                return $"{this.GetType().Name} ({this.SceneType})";
+            }
+        }
+    }
+}

Assets/GameScripts/DotNet/Core/Entity/Scene.cs.meta

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

Assets/GameScripts/DotNet/Core/Entity/SceneType.cs

@@ -0,0 +1,51 @@
+using System;
+
+namespace ET
+{
+	[Flags]
+	public enum SceneType: long
+	{
+		None = 0,
+		Main = 1, // 主纤程,一个进程一个, 初始化从这里开始
+		NetInner = 1 << 2, // 负责进程间消息通信
+		Realm = 1 << 3,
+		Gate = 1 << 4,
+		Http = 1 << 5,
+		Location = 1 << 6,
+		Map = 1 << 7,
+		Router = 1 << 8,
+		RouterManager = 1 << 9,
+		Robot = 1 << 10,
+		BenchmarkClient = 1 << 11,
+		BenchmarkServer = 1 << 12,
+		Benchmark = 1 << 13,
+		Match = 1 << 14,
+		Room = 1 << 15,
+		LockStepClient = 1 << 16,
+		LockStepServer = 1 << 17,
+		RoomRoot = 1 << 18,
+		Watcher = 1 << 19,
+
+		// 客户端
+		Demo = 1 << 30,
+		Current = 1L << 31,
+		LockStep = 1L << 32,
+		LockStepView = 1L << 33,
+		DemoView = 1L << 34,
+		NetClient = 1L << 35,
+
+		All = long.MaxValue,
+	}
+
+	public static class SceneTypeHelper
+	{
+		public static bool HasSameFlag(this SceneType a, SceneType b)
+		{
+			if (((ulong) a & (ulong) b) == 0)
+			{
+				return false;
+			}
+			return true;
+		}
+	}
+}

Assets/GameScripts/DotNet/Core/Entity/SceneType.cs.meta

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