Checkpoint 9

Assets/GameMain/Scripts/Entity/EntityLogic/Weapon/AttackEffects/HandgunHitMarkerAttackEffect.cs

@@ -1,13 +1,23 @@
+using GameFramework.ObjectPool;
 using UnityEngine;
 
 namespace Entity.Weapon
 {
     public sealed class HandgunHitMarkerAttackEffect : IWeaponAttackEffect
     {
+        private const string PoolName = "Weapon.HandgunHitMarker";
+        private const float PoolAutoReleaseInterval = 60f;
+        private const int PoolCapacity = 128;
+        private const float PoolExpireTime = 120f;
+        private const int PoolPriority = 0;
+
+        private static IObjectPool<HandgunHitMarkerPoolObject> s_Pool;
+
         private readonly float _size;
         private readonly float _yOffset;
         private readonly float _duration;
         private readonly Color _color;
+        private Material _sharedMaterial;
 
         public HandgunHitMarkerAttackEffect(float size, float yOffset, float duration, Color color)
         {
@@ -20,35 +30,95 @@ namespace Entity.Weapon
         public void Play(WeaponBase weapon, Vector3 position, EntityBase target, float radius)
         {
             if (target == null) return;
+            if (!TrySpawnMarker(out HandgunHitMarkerPooledInstance markerInstance))
+            {
+                return;
+            }
 
-            GameObject marker = GameObject.CreatePrimitive(PrimitiveType.Sphere);
-            marker.name = "HandgunHitMarker";
+            Transform targetTransform = target.CachedTransform;
+            Vector3 worldPosition = targetTransform != null ? targetTransform.position : position;
+            markerInstance.transform.SetParent(null, false);
+            markerInstance.transform.position = worldPosition + Vector3.up * _yOffset;
+            markerInstance.transform.localScale = Vector3.one * Mathf.Max(0.01f, _size);
+            markerInstance.ApplyMaterial(GetSharedMaterial());
+            markerInstance.Activate(Mathf.Max(0.01f, _duration), s_Pool);
+        }
 
-            Collider collider = marker.GetComponent<Collider>();
+        private bool TrySpawnMarker(out HandgunHitMarkerPooledInstance markerInstance)
+        {
+            markerInstance = null;
+            IObjectPool<HandgunHitMarkerPoolObject> pool = EnsurePool();
+            if (pool == null)
+            {
+                return false;
+            }
+
+            HandgunHitMarkerPoolObject pooledObject = pool.Spawn();
+            if (pooledObject != null)
+            {
+                markerInstance = pooledObject.Target as HandgunHitMarkerPooledInstance;
+                if (markerInstance != null)
+                {
+                    return true;
+                }
+            }
+
+            GameObject markerGameObject = GameObject.CreatePrimitive(PrimitiveType.Sphere);
+            markerGameObject.name = "HandgunHitMarker";
+            Collider collider = markerGameObject.GetComponent<Collider>();
             if (collider != null)
             {
                 Object.Destroy(collider);
             }
 
-            marker.transform.SetParent(target.CachedTransform, false);
-            marker.transform.localPosition = new Vector3(0f, _yOffset, 0f);
-            marker.transform.localScale = Vector3.one * Mathf.Max(0.01f, _size);
+            markerInstance = markerGameObject.AddComponent<HandgunHitMarkerPooledInstance>();
+            markerGameObject.SetActive(false);
+            pool.Register(HandgunHitMarkerPoolObject.Create(markerInstance), true);
+            return true;
+        }
 
-            Renderer renderer = marker.GetComponent<Renderer>();
-            if (renderer != null)
+        private static IObjectPool<HandgunHitMarkerPoolObject> EnsurePool()
+        {
+            var poolComponent = GameEntry.ObjectPool;
+            if (poolComponent == null)
             {
-                Shader shader = Shader.Find("Sprites/Default");
-                if (shader == null)
-                {
-                    shader = Shader.Find("Unlit/Color");
-                }
-
-                Material material = new Material(shader);
-                material.color = _color;
-                renderer.material = material;
+                return null;
             }
 
-            Object.Destroy(marker, Mathf.Max(0.01f, _duration));
+            if (s_Pool != null && poolComponent.HasObjectPool<HandgunHitMarkerPoolObject>(PoolName))
+            {
+                return s_Pool;
+            }
+
+            s_Pool = poolComponent.HasObjectPool<HandgunHitMarkerPoolObject>(PoolName)
+                ? poolComponent.GetObjectPool<HandgunHitMarkerPoolObject>(PoolName)
+                : poolComponent.CreateSingleSpawnObjectPool<HandgunHitMarkerPoolObject>(
+                    PoolName,
+                    PoolAutoReleaseInterval,
+                    PoolCapacity,
+                    PoolExpireTime,
+                    PoolPriority);
+            return s_Pool;
+        }
+
+        private Material GetSharedMaterial()
+        {
+            if (_sharedMaterial != null)
+            {
+                return _sharedMaterial;
+            }
+
+            Shader shader = Shader.Find("Sprites/Default");
+            if (shader == null)
+            {
+                shader = Shader.Find("Unlit/Color");
+            }
+
+            _sharedMaterial = new Material(shader)
+            {
+                color = _color
+            };
+            return _sharedMaterial;
         }
     }
-}
+}

Assets/GameMain/Scripts/Entity/EntityLogic/Weapon/AttackEffects/HandgunHitMarkerPoolObject.cs

@@ -0,0 +1,27 @@
+using GameFramework;
+using GameFramework.ObjectPool;
+using UnityEngine;
+
+namespace Entity.Weapon
+{
+    public sealed class HandgunHitMarkerPoolObject : ObjectBase
+    {
+        public static HandgunHitMarkerPoolObject Create(object target)
+        {
+            HandgunHitMarkerPoolObject pooledObject = ReferencePool.Acquire<HandgunHitMarkerPoolObject>();
+            pooledObject.Initialize(target);
+            return pooledObject;
+        }
+
+        protected override void Release(bool isShutdown)
+        {
+            HandgunHitMarkerPooledInstance markerInstance = Target as HandgunHitMarkerPooledInstance;
+            if (markerInstance == null)
+            {
+                return;
+            }
+
+            Object.Destroy(markerInstance.gameObject);
+        }
+    }
+}

Assets/GameMain/Scripts/Entity/EntityLogic/Weapon/AttackEffects/HandgunHitMarkerPoolObject.cs.meta

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

Assets/GameMain/Scripts/Entity/EntityLogic/Weapon/AttackEffects/HandgunHitMarkerPooledInstance.cs

@@ -0,0 +1,78 @@
+using GameFramework.ObjectPool;
+using UnityEngine;
+
+namespace Entity.Weapon
+{
+    public sealed class HandgunHitMarkerPooledInstance : MonoBehaviour
+    {
+        private Renderer _renderer;
+        private IObjectPool<HandgunHitMarkerPoolObject> _ownerPool;
+        private float _expireTime;
+        private bool _isActive;
+
+        private void Awake()
+        {
+            _renderer = GetComponent<Renderer>();
+        }
+
+        private void Update()
+        {
+            if (!_isActive)
+            {
+                return;
+            }
+
+            if (Time.time < _expireTime)
+            {
+                return;
+            }
+
+            ReturnToPool();
+        }
+
+        public void ApplyMaterial(Material material)
+        {
+            if (_renderer == null)
+            {
+                _renderer = GetComponent<Renderer>();
+            }
+
+            if (_renderer == null)
+            {
+                return;
+            }
+
+            _renderer.sharedMaterial = material;
+        }
+
+        public void Activate(float duration, IObjectPool<HandgunHitMarkerPoolObject> pool)
+        {
+            _ownerPool = pool;
+            _expireTime = Time.time + Mathf.Max(0.01f, duration);
+            _isActive = true;
+            gameObject.SetActive(true);
+        }
+
+        private void OnDisable()
+        {
+            _isActive = false;
+            _ownerPool = null;
+        }
+
+        private void ReturnToPool()
+        {
+            _isActive = false;
+            IObjectPool<HandgunHitMarkerPoolObject> pool = _ownerPool;
+            _ownerPool = null;
+            transform.SetParent(null, false);
+
+            if (pool == null)
+            {
+                gameObject.SetActive(false);
+                return;
+            }
+
+            pool.Unspawn(this);
+        }
+    }
+}

Assets/GameMain/Scripts/Entity/EntityLogic/Weapon/AttackEffects/HandgunHitMarkerPooledInstance.cs.meta

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

Assets/GameMain/Scripts/Entity/EntityLogic/Weapon/TargetSelector/NearestTargetSelector.cs

@@ -44,7 +44,7 @@ namespace Entity.Weapon
             }
 
             var simulationWorld = GameEntry.SimulationWorld;
-            if (simulationWorld == null || !simulationWorld.UseSimulationMovement || !simulationWorld.UseJobSimulation)
+            if (simulationWorld == null || !simulationWorld.UseSimulationMovement)
             {
                 return false;
             }
@@ -65,4 +65,4 @@ namespace Entity.Weapon
             return true;
         }
     }
-}
+}

Assets/GameMain/Scripts/Entity/EntityLogic/Weapon/WeaponBase.cs

@@ -229,7 +229,7 @@ namespace Entity.Weapon
             }
 
             int ownerEntityId = WeaponData != null ? WeaponData.OwnerId : Id;
-            return simulationWorld.TryEnqueueAreaCollisionQuery(Id, ownerEntityId, in center, radius, maxTargets);
+            return simulationWorld.TryRequestAreaCollision(Id, ownerEntityId, in center, radius, maxTargets);
         }
 
         protected bool TryQueueSectorCollisionQuery(in Vector3 center, float radius, in Vector3 direction,
@@ -242,7 +242,7 @@ namespace Entity.Weapon
             }
 
             int ownerEntityId = WeaponData != null ? WeaponData.OwnerId : Id;
-            return simulationWorld.TryEnqueueSectorCollisionQuery(Id, ownerEntityId, in center, radius, in direction,
+            return simulationWorld.TryRequestSectorCollision(Id, ownerEntityId, in center, radius, in direction,
                 halfAngleDeg, maxTargets);
         }