iFactory.Cutting.Unity/Assets/BITKit/Unity/Scripts/Sensor/RangeSensor.cs

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Linq;
using Cysharp.Threading.Tasks;
using UnityEngine.Jobs;
using UnityEngine.Pool;
using UnityEngine.Profiling;
using Physics=UnityEngine.Physics;

namespace BITKit.Sensors
{
    public class RangeSensor : Sensor
    {
        [Header(Constant.Header.Settings)] public float radius;
        public int fov;
        public bool requireSight;

        [Header(Constant.Header.Settings)] public LayerMask blockLayer;

        [Header(Constant.Header.Debug)] [Header(Constant.Header.InternalVariables)]
        private FrameUpdate frameUpdater;

        private readonly Collider[] colliders = new Collider[32];
        private RaycastHit[] hits = new RaycastHit[32];
        private readonly HashSet<int> tempHashSet = new();

        public override IEnumerable<Transform> Get()
        {
            if (!_detectedDoubleBuffer.TryGetRelease(out var newRelease)) return _detectedBuffer;
            Profiler.BeginSample("Release Detected Buffer");
            _detectedBuffer = newRelease;
            Profiler.EndSample();
            return _detectedBuffer;
        }

        private readonly DoubleBuffer<IEnumerable<Transform>> _detectedDoubleBuffer = new();
        private IEnumerable<Transform> _detectedBuffer=Array.Empty<Transform>();

        public override UniTask Execute(float delta)
        {
            tempHashSet.Clear();
            var length = Physics.OverlapSphereNonAlloc(Transform.position, radius, colliders, detectLayer);
            Profiler.BeginSample("Filter Detected Colliders");
            var _newDetected = from x in colliders.Take(length) where IsValid(x) select x.transform;
            Profiler.EndSample();
            _detectedDoubleBuffer.Release(_newDetected);
            return UniTask.CompletedTask;
        }

        public override bool IsValid(Collider _collider)
        {
            switch (_collider)
            {
                case var _ when ignoreColliders.Contains(_collider):
                    return false;
                case var _ when fov > 0 && CheckFov(ref _collider) is false:
                case var _ when requireSight && CheckSight(ref _collider) is false:
                    return false;
                default:
                    return true;
            }
        }

        public override float GetDistance() => radius;

        private bool CheckFov(ref Collider _collider)
        {
            var _dir = _collider.bounds.center - transform.position;
            if (_dir.sqrMagnitude <= 0) return false;
            var dir = Quaternion.LookRotation(_dir);
            return Vector3.Dot(transform.forward, _dir) > 0 && fov > Quaternion.Angle(transform.rotation, dir);
        }

        private bool CheckSight(ref Collider _collider)
        {
            if (!requireSight) return false;
            var position = _collider.bounds.center;
            //是检测bounds的顶部
            position.y += _collider.bounds.extents.y;
            var location = new Location(Transform);
            var length = Physics.RaycastNonAlloc(
                location.position,
                position - location,
                hits,
                Vector3.Distance(location, position),
                blockLayer
            );

            switch (length)
            {
                case 0:
                    Debug.DrawLine(location, position, Color.green, 1);
                    return true;
                case 1:
                    return hits[0].collider == _collider;
                default:
                    var collider1 = _collider;
                    if (hits.Take(length).Any(Predicate))
                    {
                        return false;
                    }
                    break;
                    bool Predicate(RaycastHit x)
                    {
                        var result = ignoreColliders.Contains(x.collider) is false && x.collider != collider1;
                        if (result)
                        {
                            Debug.DrawLine(location, x.point, Color.red, 1);
                        }
                        return result;
                    }
            }

            return true;
        }
    }
}