refactor(UnityAdapter): Update namespaces and types to use Lunar.Core.Base and Lunar.Core.ECS

Bli-AIk · Bli-AIk · commit 5d285e3c0fa5 · 2025-09-08T13:36:53.000+08:00
diff --git a/Runtime/Adapters/DebugLogAdapter.cs b/Runtime/Adapters/DebugLogAdapter.cs
@@ -1,6 +1,6 @@
 using System;
 using UnityEngine;
-using ILogger = Lunar.Interfaces.ILogger;
+using ILogger = Lunar.Core.Base.Interfaces.ILogger;
 using Object = UnityEngine.Object;
 
 namespace Lunar.Adapters.Unity
diff --git a/Runtime/Adapters/InputAdapter.cs b/Runtime/Adapters/InputAdapter.cs
@@ -1,42 +1,43 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using Lunar.Interfaces;
+using Lunar.Core.Base.Interfaces;
 using UnityEngine;
 using System.Linq;
+using Lunar.Core.Base;
 
 namespace Lunar.Adapters.Unity
 {
     public class InputAdapter : IInput
     {
-        public bool GetKeyDown(KeyCode keycode)
+        public bool GetKeyDown(KeyCodeBase keycode)
         {
             return Input.GetKeyDown(keycode.ToUnity());
         }
 
-        public bool GetKey(KeyCode keycode)
+        public bool GetKey(KeyCodeBase keycode)
         {
             return Input.GetKey(keycode.ToUnity());
         }
 
-        public bool GetKeyUp(KeyCode keycode)
+        public bool GetKeyUp(KeyCodeBase keycode)
         {
             return Input.GetKeyUp(keycode.ToUnity());
         }
     }
 
     public static class KeyCodeConverter
     {
-        private static readonly ConcurrentDictionary<KeyCode, UnityEngine.KeyCode> Cache = new();
+        private static readonly ConcurrentDictionary<KeyCodeBase, UnityEngine.KeyCode> Cache = new();
 
         // If some key names are inconsistent on both sides, they can be overwritten here uniformly
-        private static readonly Dictionary<KeyCode, UnityEngine.KeyCode> Overrides
+        private static readonly Dictionary<KeyCodeBase, UnityEngine.KeyCode> Overrides
             = new()
             {
                 // [KeyCode.SomeLunarName] = UnityEngine.KeyCode.SomeDifferentUnityName,
             };
 
-        public static UnityEngine.KeyCode ToUnity(this KeyCode key)
+        public static UnityEngine.KeyCode ToUnity(this KeyCodeBase key)
         {
             if (Overrides.TryGetValue(key, out var overridden))
             {
@@ -60,16 +61,16 @@ public static UnityEngine.KeyCode ToUnity(this KeyCode key)
     }
     public class InputActionsAdapter : IInputActions
     {
-        public Dictionary<string, KeyCode[]> Bindings { get; }
+        public Dictionary<string, KeyCodeBase[]> Bindings { get; }
         public IInput Input { get; }
 
-        public InputActionsAdapter(IInput input, Dictionary<string, KeyCode[]> bindings)
+        public InputActionsAdapter(IInput input, Dictionary<string, KeyCodeBase[]> bindings)
         {
             Input = input;
             Bindings = bindings;
         }
 
-        public bool SetBinding(string action, params KeyCode[] keys)
+        public bool SetBinding(string action, params KeyCodeBase[] keys)
         {
             if (string.IsNullOrWhiteSpace(action))
             {
@@ -81,7 +82,7 @@ public bool SetBinding(string action, params KeyCode[] keys)
                 return false;
             }
 
-            if (keys.Any(key => !Enum.IsDefined(typeof(KeyCode), key)))
+            if (keys.Any(key => !Enum.IsDefined(typeof(KeyCodeBase), key)))
             {
                 return false;
             }
diff --git a/Runtime/Adapters/ResourcesAdapter.cs b/Runtime/Adapters/ResourcesAdapter.cs
@@ -3,7 +3,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using Lunar.Interfaces;
+using Lunar.Core.Base.Interfaces;
 using UnityEngine;
 using Object = UnityEngine.Object;
 
diff --git a/Runtime/GameController.cs b/Runtime/GameController.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Lunar.Core.Base;
 using UnityEngine;
 using UnityEngine.Pool;
 
@@ -66,12 +67,12 @@ public static ServiceRegistry DefaultServicesFactory()
                 ResourcesAsync = new ResourcesAdapter(),
                 InputActions = new InputActionsAdapter(
                     new InputAdapter(),
-                    new Dictionary<string, KeyCode[]>
+                    new Dictionary<string, KeyCodeBase[]>
                     {
-                        ["Play"] = new[] { KeyCode.Space },
-                        ["Pause"] = new[] { KeyCode.P },
-                        ["Resume"] = new[] { KeyCode.R },
-                        ["Cancel"] = new[] { KeyCode.C }
+                        ["Play"] = new[] { KeyCodeBase.Space },
+                        ["Pause"] = new[] { KeyCodeBase.P },
+                        ["Resume"] = new[] { KeyCodeBase.R },
+                        ["Cancel"] = new[] { KeyCodeBase.C }
                     }),
                 Logger = new DebugLogAdapter()
             };
diff --git a/Runtime/GameControllerImplementation.cs b/Runtime/GameControllerImplementation.cs
@@ -3,7 +3,9 @@
 using Arch.System;
 using Lunar.Adapters.Unity.Systems;
 using Lunar.Adapters.Unity.Utils;
-using Lunar.Components;
+using Lunar.Core.Base;
+using Lunar.Core.ECS;
+using Lunar.Core.ECS.Components;
 using UnityEngine;
 using UnityEngine.Pool;
 
@@ -45,14 +47,14 @@ protected override void SetEvents(World world)
                     entity.Add(new TransformComponent());
                 }
 
-                if (gameObjectComponent.GameObject != null)
+                if (gameObjectComponent.GameObjectBase != null)
                 {
                     return;
                 }
 
                 var unityGameObject = _gameObjectPool.Get();
                 unityGameObject.transform.SetParent(_parent);
-                entity.Set(new GameObjectComponent(new GameObject(unityGameObject)));
+                entity.Set(new GameObjectComponent(new GameObjectBase(unityGameObject)));
             });
 
 
@@ -72,19 +74,19 @@ protected override void SetEvents(World world)
                 if (unityGameObject.TryGetComponent<SpriteRenderer>(out var spriteRenderer))
                 {
                     spriteRenderer.enabled = true;
-                    spriteComponent.Sprite = new Sprite(spriteRenderer);
+                    spriteComponent.Sprite = new SpriteBase(spriteRenderer);
                 }
                 else
                 {
-                    spriteComponent.Sprite = new Sprite(unityGameObject.AddComponent<SpriteRenderer>());
+                    spriteComponent.Sprite = new SpriteBase(unityGameObject.AddComponent<SpriteRenderer>());
                 }
             });
 
             world.SubscribeComponentRemoved((in Entity entity, ref GameObjectComponent gameObjectComponent) =>
             {
-                if (gameObjectComponent.GameObject != null)
+                if (gameObjectComponent.GameObjectBase != null)
                 {
-                    _gameObjectPool.Release(gameObjectComponent.GameObject.BaseGameObject as UnityEngine.GameObject);
+                    _gameObjectPool.Release(gameObjectComponent.GameObjectBase.BaseGameObject as UnityEngine.GameObject);
                 }
             });
         }
diff --git a/Runtime/ServiceRegistry.cs b/Runtime/ServiceRegistry.cs
@@ -1,4 +1,4 @@
-using Lunar.Interfaces;
+using Lunar.Core.Base.Interfaces;
 
 namespace Lunar.Adapters.Unity
 {
diff --git a/Runtime/Systems/DebugCreateObjectSystem.cs b/Runtime/Systems/DebugCreateObjectSystem.cs
@@ -1,7 +1,8 @@
 using Arch.Core;
 using Arch.Core.Extensions;
 using Arch.System;
-using Lunar.Components;
+
+using Lunar.Core.ECS.Components;
 using UnityEngine;
 
 namespace Lunar.Adapters.Unity.Systems
diff --git a/Runtime/Systems/GameObjectSyncSystem.cs b/Runtime/Systems/GameObjectSyncSystem.cs
@@ -1,8 +1,8 @@
 using System;
 using Arch.Core;
 using Lunar.Adapters.Unity.Utils;
-using Lunar.Components;
-using Lunar.Systems;
+using Lunar.Core.ECS.Components;
+using Lunar.Core.ECS.Systems;
 using UnityEngine;
 
 namespace Lunar.Adapters.Unity.Systems
diff --git a/Runtime/Systems/SpriteCleanSystem.cs b/Runtime/Systems/SpriteCleanSystem.cs
@@ -1,7 +1,9 @@
 using Arch.Core;
 using Lunar.Adapters.Unity.Utils;
-using Lunar.Components;
-using Lunar.Systems;
+
+using Lunar.Core.ECS.Components;
+using Lunar.Core.ECS.Systems;
+
 using UnityEngine;
 
 namespace Lunar.Adapters.Unity.Systems
diff --git a/Runtime/Systems/SpriteSyncSystem.cs b/Runtime/Systems/SpriteSyncSystem.cs
@@ -3,9 +3,11 @@
 using System.Threading.Tasks;
 using Arch.Core;
 using Lunar.Adapters.Unity.Utils;
-using Lunar.Components;
-using Lunar.Interfaces;
-using Lunar.Systems;
+
+using Lunar.Core.Base.Interfaces;
+using Lunar.Core.ECS.Components;
+using Lunar.Core.ECS.Systems;
+
 
 namespace Lunar.Adapters.Unity.Systems
 {
diff --git a/Runtime/Utils/UnityConversionUtils.cs b/Runtime/Utils/UnityConversionUtils.cs
@@ -1,4 +1,4 @@
-using Lunar.Components;
+using Lunar.Core.ECS.Components;
 
 namespace Lunar.Adapters.Unity.Utils
 {
@@ -7,7 +7,7 @@ public static class UnityConversionUtils
         public static bool TryParseToUnity(this GameObjectComponent gameObject,
             out UnityEngine.GameObject unityGameObject)
         {
-            unityGameObject = gameObject.GameObject.BaseGameObject as UnityEngine.GameObject;
+            unityGameObject = gameObject.GameObjectBase.BaseGameObject as UnityEngine.GameObject;
 
             return unityGameObject;
 
diff --git a/Runtime/com.bliaik.lunar.runtime.asmdef b/Runtime/com.bliaik.lunar.runtime.asmdef
@@ -7,7 +7,9 @@
     "allowUnsafeCode": false,
     "overrideReferences": true,
     "precompiledReferences": [
-        "Lunar.dll",
+        
+        "Lunar.Core.Base.dll",
+        "Lunar.Core.ECS.dll",
         "Arch.dll",
         "Arch.System.dll"
     ],
diff --git a/Tests/KeyCodeConverterTests.cs b/Tests/KeyCodeConverterTests.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Lunar.Core.Base;
 using NUnit.Framework;
 
 namespace Lunar.Adapters.Unity.Tests
@@ -12,7 +13,7 @@ public void All_LunarKeyCodes_MapTo_UnityEngineKeyCode()
         {
             var failed = new List<string>();
 
-            foreach (KeyCode lunarKey in Enum.GetValues(typeof(KeyCode)))
+            foreach (KeyCodeBase lunarKey in Enum.GetValues(typeof(KeyCodeBase)))
             {
                 try
                 {
diff --git a/Tests/com.bliaik.lunar.tests.asmdef b/Tests/com.bliaik.lunar.tests.asmdef
@@ -11,7 +11,9 @@
     "allowUnsafeCode": false,
     "overrideReferences": true,
     "precompiledReferences": [
-        "Lunar.dll",
+        
+        "Lunar.Core.Base.dll",
+        "Lunar.Core.ECS.dll",
         "nunit.framework.dll"
     ],
     "autoReferenced": true,

Original file line number	Diff line number	Diff line change
`@@ -1,42 +1,43 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Concurrent;`
`3`	`3`	`using System.Collections.Generic;`
`4`		`-using Lunar.Interfaces;`
	`4`	`+using Lunar.Core.Base.Interfaces;`
`5`	`5`	`using UnityEngine;`
`6`	`6`	`using System.Linq;`
	`7`	`+using Lunar.Core.Base;`
`7`	`8`
`8`	`9`	`namespace Lunar.Adapters.Unity`
`9`	`10`	`{`
`10`	`11`	`public class InputAdapter : IInput`
`11`	`12`	`{`
`12`		`- public bool GetKeyDown(KeyCode keycode)`
	`13`	`+ public bool GetKeyDown(KeyCodeBase keycode)`
`13`	`14`	`{`
`14`	`15`	`return Input.GetKeyDown(keycode.ToUnity());`
`15`	`16`	`}`
`16`	`17`
`17`		`- public bool GetKey(KeyCode keycode)`
	`18`	`+ public bool GetKey(KeyCodeBase keycode)`
`18`	`19`	`{`
`19`	`20`	`return Input.GetKey(keycode.ToUnity());`
`20`	`21`	`}`
`21`	`22`
`22`		`- public bool GetKeyUp(KeyCode keycode)`
	`23`	`+ public bool GetKeyUp(KeyCodeBase keycode)`
`23`	`24`	`{`
`24`	`25`	`return Input.GetKeyUp(keycode.ToUnity());`
`25`	`26`	`}`
`26`	`27`	`}`
`27`	`28`
`28`	`29`	`public static class KeyCodeConverter`
`29`	`30`	`{`
`30`		`- private static readonly ConcurrentDictionary<KeyCode, UnityEngine.KeyCode> Cache = new();`
	`31`	`+ private static readonly ConcurrentDictionary<KeyCodeBase, UnityEngine.KeyCode> Cache = new();`
`31`	`32`
`32`	`33`	`// If some key names are inconsistent on both sides, they can be overwritten here uniformly`
`33`		`- private static readonly Dictionary<KeyCode, UnityEngine.KeyCode> Overrides`
	`34`	`+ private static readonly Dictionary<KeyCodeBase, UnityEngine.KeyCode> Overrides`
`34`	`35`	`= new()`
`35`	`36`	`{`
`36`	`37`	`// [KeyCode.SomeLunarName] = UnityEngine.KeyCode.SomeDifferentUnityName,`
`37`	`38`	`};`
`38`	`39`
`39`		`- public static UnityEngine.KeyCode ToUnity(this KeyCode key)`
	`40`	`+ public static UnityEngine.KeyCode ToUnity(this KeyCodeBase key)`
`40`	`41`	`{`
`41`	`42`	`if (Overrides.TryGetValue(key, out var overridden))`
`42`	`43`	`{`
`@@ -60,16 +61,16 @@ public static UnityEngine.KeyCode ToUnity(this KeyCode key)`
`60`	`61`	`}`
`61`	`62`	`public class InputActionsAdapter : IInputActions`
`62`	`63`	`{`
`63`		`- public Dictionary<string, KeyCode[]> Bindings { get; }`
	`64`	`+ public Dictionary<string, KeyCodeBase[]> Bindings { get; }`
`64`	`65`	`public IInput Input { get; }`
`65`	`66`
`66`		`- public InputActionsAdapter(IInput input, Dictionary<string, KeyCode[]> bindings)`
	`67`	`+ public InputActionsAdapter(IInput input, Dictionary<string, KeyCodeBase[]> bindings)`
`67`	`68`	`{`
`68`	`69`	`Input = input;`
`69`	`70`	`Bindings = bindings;`
`70`	`71`	`}`
`71`	`72`
`72`		`- public bool SetBinding(string action, params KeyCode[] keys)`
	`73`	`+ public bool SetBinding(string action, params KeyCodeBase[] keys)`
`73`	`74`	`{`
`74`	`75`	`if (string.IsNullOrWhiteSpace(action))`
`75`	`76`	`{`
`@@ -81,7 +82,7 @@ public bool SetBinding(string action, params KeyCode[] keys)`
`81`	`82`	`return false;`
`82`	`83`	`}`
`83`	`84`
`84`		`- if (keys.Any(key => !Enum.IsDefined(typeof(KeyCode), key)))`
	`85`	`+ if (keys.Any(key => !Enum.IsDefined(typeof(KeyCodeBase), key)))`
`85`	`86`	`{`
`86`	`87`	`return false;`
`87`	`88`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,9 @@`
`3`	`3`	`using Arch.System;`
`4`	`4`	`using Lunar.Adapters.Unity.Systems;`
`5`	`5`	`using Lunar.Adapters.Unity.Utils;`
`6`		`-using Lunar.Components;`
	`6`	`+using Lunar.Core.Base;`
	`7`	`+using Lunar.Core.ECS;`
	`8`	`+using Lunar.Core.ECS.Components;`
`7`	`9`	`using UnityEngine;`
`8`	`10`	`using UnityEngine.Pool;`
`9`	`11`
`@@ -45,14 +47,14 @@ protected override void SetEvents(World world)`
`45`	`47`	`entity.Add(new TransformComponent());`
`46`	`48`	`}`
`47`	`49`
`48`		`- if (gameObjectComponent.GameObject != null)`
	`50`	`+ if (gameObjectComponent.GameObjectBase != null)`
`49`	`51`	`{`
`50`	`52`	`return;`
`51`	`53`	`}`
`52`	`54`
`53`	`55`	`var unityGameObject = _gameObjectPool.Get();`
`54`	`56`	`unityGameObject.transform.SetParent(_parent);`
`55`		`- entity.Set(new GameObjectComponent(new GameObject(unityGameObject)));`
	`57`	`+ entity.Set(new GameObjectComponent(new GameObjectBase(unityGameObject)));`
`56`	`58`	`});`
`57`	`59`
`58`	`60`
`@@ -72,19 +74,19 @@ protected override void SetEvents(World world)`
`72`	`74`	`if (unityGameObject.TryGetComponent<SpriteRenderer>(out var spriteRenderer))`
`73`	`75`	`{`
`74`	`76`	`spriteRenderer.enabled = true;`
`75`		`- spriteComponent.Sprite = new Sprite(spriteRenderer);`
	`77`	`+ spriteComponent.Sprite = new SpriteBase(spriteRenderer);`
`76`	`78`	`}`
`77`	`79`	`else`
`78`	`80`	`{`
`79`		`- spriteComponent.Sprite = new Sprite(unityGameObject.AddComponent<SpriteRenderer>());`
	`81`	`+ spriteComponent.Sprite = new SpriteBase(unityGameObject.AddComponent<SpriteRenderer>());`
`80`	`82`	`}`
`81`	`83`	`});`
`82`	`84`
`83`	`85`	`world.SubscribeComponentRemoved((in Entity entity, ref GameObjectComponent gameObjectComponent) =>`
`84`	`86`	`{`
`85`		`- if (gameObjectComponent.GameObject != null)`
	`87`	`+ if (gameObjectComponent.GameObjectBase != null)`
`86`	`88`	`{`
`87`		`- _gameObjectPool.Release(gameObjectComponent.GameObject.BaseGameObject as UnityEngine.GameObject);`
	`89`	`+ _gameObjectPool.Release(gameObjectComponent.GameObjectBase.BaseGameObject as UnityEngine.GameObject);`
`88`	`90`	`}`
`89`	`91`	`});`
`90`	`92`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-using Lunar.Interfaces;`
	`1`	`+using Lunar.Core.Base.Interfaces;`
`2`	`2`
`3`	`3`	`namespace Lunar.Adapters.Unity`
`4`	`4`	`{`