整理武器配置和重构

Assets/GameMain/Scripts/Runtime/EntityLogic/Weapon/WeaponLance/WeaponLance.cs

@@ -9,15 +9,8 @@ using UnityGameFramework.Runtime;
 
 namespace SepCore.Entity
 {
-    public partial class WeaponLance : WeaponBase
+    public class WeaponLance : WeaponBase
     {
-        // 长枪专用数据，包含强类型 ParamsData。
-        [SerializeField] private WeaponLanceData _weaponData;
-
-        private Quaternion _cachedRotation;
-        // 朝向目标时的旋转速度，可被 ParamsData.RotateSpeed 覆盖。
-        [SerializeField] private float _rotateSpeed = 5f;
-
         private Sequence _attackSequence;
         private Transform _attackParent;
 
@@ -26,57 +19,46 @@ namespace SepCore.Entity
         // 收枪返回耗时。
         [SerializeField] private float _returnDuration = 0.18f;
 
-        [SerializeField] private LayerMask _hitMask = ~0;
         [SerializeField] private int _maxHitColliders = 32;
 
         private IWeaponAttackEffect _attackEffect;
         private Collider[] _hitResults;
         private readonly HashSet<int> _hitEntityIds = new();
 
-        // 前戳矩形判定的横向半宽。
-        private float _hitHalfWidth;
-        // 前戳矩形判定盒体的总高度。
-        private float _hitHeight;
-        // 盒体中心相对战斗平面的高度偏移。
-        private float _hitCenterYOffset;
-        // 从判定起点向前延伸的有效刺击长度。
-        private float _pierceLength;
-        // 判定起点相对武器当前位置的前移量。
-        private float _forwardOffset;
+        public float HitHalfWidth => WeaponData.GetParamFloat(ParamType.HitHalfWidth);
+        public float HitHeight => WeaponData.GetParamFloat(ParamType.HitHeight);
+        public float PierceLength => WeaponData.GetParamFloat(ParamType.PierceLength);
+        public Vector3 StrikeDirection => _strikeDirection;
+
         // 本次攻击锁定的前戳方向，避免受位移动画中的武器位置影响。
         private Vector3 _strikeDirection = Vector3.forward;
         // 本次攻击锁定的矩形判定中心。
         private Vector3 _strikeCenter;
 
-        public override ImpactData GetImpactData()
-        {
-            return new ImpactData(_weaponData.OwnerCamp, _weaponData.Attack, AttackStat);
-        }
-
         protected override void BuildStates()
         {
-            RegisterState(new IdleState());
-            RegisterState(new CheckInRangeState());
-            RegisterState(new CheckOutRangeState());
-            RegisterState(new AttackState());
+            RegisterState(new WeaponLanceIdleState());
+            RegisterState(new WeaponLanceAimState());
+            RegisterState(new WeaponLanceSeekState());
+            RegisterState(new WeaponLanceAttackState());
         }
 
-        protected override void Attack()
+        public override void Attack()
         {
             StopAttackTween(false);
             FaceTargetImmediately();
+            _attackParent = CachedTransform.parent;
             CacheStrikeSnapshot();
 
             _isAttacking = true;
-            _attackParent = CachedTransform.parent;
             CachedTransform.SetParent(null);
 
-            Vector3 targetPos = CachedTransform.position + _strikeDirection * _pierceLength;
+            Vector3 targetPos = CachedTransform.position + _strikeDirection * PierceLength;
             _attackSequence = DOTween.Sequence();
             _attackSequence.Append(CachedTransform.DOMove(targetPos, _attackDuration).SetEase(Ease.OutQuad));
             _attackSequence.AppendCallback(() =>
             {
-                _attackEffect?.Play(this, _strikeCenter, _target, _hitHalfWidth);
+                _attackEffect.Play(this, _strikeCenter, _target, HitHalfWidth);
                 ApplyPierceDamage();
 
                 if (_attackParent != null)
@@ -93,49 +75,12 @@ namespace SepCore.Entity
             });
         }
 
-        protected override void Check()
-        {
-            _target = SelectTarget(_sqrRange);
-        }
-
-        private void RotateToTarget(float elapseSeconds)
-        {
-            if (_target == null || !_target.Available) return;
-
-            Vector3 directionToTarget = _target.CachedTransform.position - CachedTransform.position;
-            directionToTarget.y = 0f;
-            if (directionToTarget.sqrMagnitude <= Mathf.Epsilon) return;
-
-            Quaternion targetRotation = Quaternion.LookRotation(directionToTarget.normalized, Vector3.up);
-            CachedTransform.rotation =
-                Quaternion.Slerp(CachedTransform.rotation, targetRotation, _rotateSpeed * elapseSeconds);
-        }
-
-        private void RotateToOrigin(float elapseSeconds)
-        {
-            CachedTransform.rotation =
-                Quaternion.Slerp(CachedTransform.rotation, _cachedRotation, _rotateSpeed * elapseSeconds);
-        }
-
-        private void FaceTargetImmediately()
-        {
-            if (_target == null || !_target.Available) return;
-
-            Vector3 directionToTarget = _target.CachedTransform.position - CachedTransform.position;
-            directionToTarget.y = 0f;
-            if (directionToTarget.sqrMagnitude <= Mathf.Epsilon) return;
-
-            CachedTransform.rotation = Quaternion.LookRotation(directionToTarget.normalized, Vector3.up);
-        }
-
         private void CacheStrikeSnapshot()
         {
             _strikeDirection = ResolvePlanarForward();
             Vector3 strikeStart = CachedTransform.position;
             strikeStart.y = ResolveStrikePlaneY();
-            strikeStart += _strikeDirection * _forwardOffset;
-            _strikeCenter = strikeStart + _strikeDirection * (_pierceLength * 0.5f);
-            _strikeCenter.y += _hitCenterYOffset;
+            _strikeCenter = strikeStart + _strikeDirection * (PierceLength * 0.5f);
         }
 
         private Vector3 ResolvePlanarForward()
@@ -153,7 +98,7 @@ namespace SepCore.Entity
 
         private void ApplyPierceDamage()
         {
-            if (_hitHalfWidth <= 0f || _pierceLength <= 0f) return;
+            if (HitHalfWidth <= 0f || PierceLength <= 0f) return;
 
             Vector3 strikeDirection = _strikeDirection;
             if (strikeDirection.sqrMagnitude <= Mathf.Epsilon) return;
@@ -161,20 +106,15 @@ namespace SepCore.Entity
             Vector3 broadPhaseCenter = _strikeCenter;
             Quaternion broadPhaseRotation = Quaternion.LookRotation(strikeDirection, Vector3.up);
 
-            if (TryQueueRectangleCollisionQuery(broadPhaseCenter, _hitHalfWidth, _pierceLength * 0.5f,
+            if (TryQueueRectangleCollisionQuery(broadPhaseCenter, HitHalfWidth, PierceLength * 0.5f,
                     strikeDirection, Mathf.Max(1, _maxHitColliders)))
             {
-                _hitEntityIds.Clear();
                 return;
             }
 
-            int capacity = Mathf.Max(1, _maxHitColliders);
-            if (_hitResults == null || _hitResults.Length != capacity)
-            {
-                _hitResults = new Collider[capacity];
-            }
+            if (_hitResults == null || _hitResults.Length == 0) return;
 
-            Vector3 halfExtents = new(_hitHalfWidth, _hitHeight * 0.5f, _pierceLength * 0.5f);
+            Vector3 halfExtents = new(HitHalfWidth, HitHeight * 0.5f, PierceLength * 0.5f);
             int hitCount = Physics.OverlapBoxNonAlloc(broadPhaseCenter, halfExtents, _hitResults, broadPhaseRotation,
                 _hitMask, QueryTriggerInteraction.Collide);
             _hitEntityIds.Clear();
@@ -203,8 +143,8 @@ namespace SepCore.Entity
             float lateralDistance = Vector3.Dot(delta, right);
             float targetRadius = ResolveTargetCollisionRadius(targetable);
 
-            return Mathf.Abs(forwardDistance) <= _pierceLength * 0.5f + targetRadius &&
-                   Mathf.Abs(lateralDistance) <= _hitHalfWidth + targetRadius;
+            return Mathf.Abs(forwardDistance) <= PierceLength * 0.5f + targetRadius &&
+                   Mathf.Abs(lateralDistance) <= HitHalfWidth + targetRadius;
         }
 
         private static float ResolveTargetCollisionRadius(TargetableObject targetable)
@@ -225,64 +165,11 @@ namespace SepCore.Entity
                 return _target.CachedTransform.position.y;
             }
 
-            if (_attackParent != null)
-            {
-                return _attackParent.position.y;
-            }
-
-            if (CachedTransform.parent != null)
-            {
-                return CachedTransform.parent.position.y;
-            }
-
-            return CachedTransform.position.y;
+            return _attackParent != null ? _attackParent.position.y : CachedTransform.position.y;
         }
 
         protected override bool OnWeaponShow(object userData)
         {
-            _weaponData = RequireWeaponData<WeaponLanceData>(userData);
-            if (_weaponData == null) return false;
-            WeaponData = _weaponData;
-
-            StartAttackCooldown(_weaponData.Cooldown);
-            _sqrRange = _weaponData.AttackRange * _weaponData.AttackRange;
-            _cachedRotation = CachedTransform.rotation;
-
-            WeaponLanceParamsData paramsData = _weaponData.ParamsData;
-            float configuredHalfWidth = paramsData != null && paramsData.HitHalfWidth > 0f
-                ? paramsData.HitHalfWidth
-                : paramsData != null && paramsData.HitRadius > 0f
-                    ? paramsData.HitRadius
-                    : 0.45f;
-            _hitHalfWidth = Mathf.Max(0.1f, configuredHalfWidth);
-            _hitHeight = paramsData != null && paramsData.HitHeight > 0f
-                ? Mathf.Max(0.2f, paramsData.HitHeight)
-                : 4f;
-            _hitCenterYOffset = paramsData != null ? paramsData.HitCenterYOffset : 0f;
-            _pierceLength = paramsData != null && paramsData.PierceLength > 0f
-                ? paramsData.PierceLength
-                : paramsData != null && paramsData.ThrustDistance > 0f
-                    ? paramsData.ThrustDistance
-                    : _weaponData.AttackRange;
-            _forwardOffset = paramsData != null && paramsData.ForwardOffset > 0f
-                ? paramsData.ForwardOffset
-                : 0f;
-
-            if (paramsData != null && paramsData.RotateSpeed > 0f)
-            {
-                _rotateSpeed = paramsData.RotateSpeed;
-            }
-
-            if (paramsData != null && paramsData.AttackDuration > 0f)
-            {
-                _attackDuration = paramsData.AttackDuration;
-            }
-
-            if (paramsData != null && paramsData.ReturnDuration > 0f)
-            {
-                _returnDuration = paramsData.ReturnDuration;
-            }
-
             int colliderCapacity = Mathf.Max(1, _maxHitColliders);
             if (_hitResults == null || _hitResults.Length != colliderCapacity)
             {
@@ -290,37 +177,19 @@ namespace SepCore.Entity
             }
 
             _attackEffect = new LanceThrustAttackEffect();
-
-            if (_weaponData.OwnerCamp == CampType.Player)
-            {
-                gameObject.layer = LayerMask.NameToLayer("PlayerWeapon");
-                _hitMask = LayerMask.GetMask("Enemy");
-            }
-            else if (_weaponData.OwnerCamp == CampType.Enemy)
-            {
-                gameObject.layer = LayerMask.NameToLayer("EnemyWeapon");
-                _hitMask = LayerMask.GetMask("Player");
-            }
-
             return true;
         }
 
         protected override void OnWeaponHide(object userData)
         {
             StopAttackTween(true);
-            CancelAttackCooldown();
             _attackEffect = null;
         }
 
-        protected override void OnWeaponAttach(EntityLogic parentEntity, Transform parentTransform, object userData)
-        {
-            BindAttackStatFromOwner(parentEntity);
-        }
-
         protected override void OnWeaponDetach(EntityLogic parentEntity, object userData)
         {
             StopAttackTween(true);
-            ReleaseAttackStatSubscription();
+            base.OnWeaponDetach(parentEntity, userData);
         }
 
         protected override void OnEnabledChanged(bool enabled)
@@ -351,9 +220,5 @@ namespace SepCore.Entity
             _attackParent = null;
             _hitEntityIds.Clear();
         }
-
-        public float HitHalfWidth => _hitHalfWidth;
-        public float PierceLength => _pierceLength;
-        public Vector3 StrikeDirection => _strikeDirection;
     }
 }