Exemple #1
0
        void sensorDetectionEvents()
        {
            var detectedEnumerator = DetectedObjects.GetEnumerator();

            while (detectedEnumerator.MoveNext())
            {
                var go = detectedEnumerator.Current;
                if (previousDetectedObjects.Contains(go))
                {
                    previousDetectedObjects.Remove(go);
                }
                else
                {
                    // This is a newly detected object
                    OnDetected.Invoke(go);
                }
            }

            // Any object still in previousDetectedObjects is no longer detected
            var previousDetectedEnumerator = previousDetectedObjects.GetEnumerator();

            while (previousDetectedEnumerator.MoveNext())
            {
                var go = previousDetectedEnumerator.Current;
                OnLostDetection.Invoke(go);
            }

            previousDetectedObjects.Clear();
            detectedEnumerator = DetectedObjects.GetEnumerator();
            while (detectedEnumerator.MoveNext())
            {
                previousDetectedObjects.Add(detectedEnumerator.Current);
            }
        }
Exemple #2
0
        void testSensor()
        {
            prepareCollidersBuffer();

            var numberDetected = Physics.OverlapSphereNonAlloc(transform.position, SensorRange, collidersBuffer, DetectsOnLayers);

            if (numberDetected == CurrentBufferSize)
            {
                if (DynamicallyIncreaseBufferSize)
                {
                    CurrentBufferSize *= 2;
                    testSensor();
                    return;
                }
                else
                {
                    logInsufficientBufferSize();
                }
            }

            clearColliders();

            for (int i = 0; i < numberDetected; i++)
            {
                var newDetection = addCollider(collidersBuffer[i]);
                if (newDetection != null)
                {
                    if (previousDetectedObjects.Contains(newDetection))
                    {
                        previousDetectedObjects.Remove(newDetection);
                    }
                    else
                    {
                        OnDetected.Invoke(newDetection, this);
                    }
                }
            }

            // Any entries still in previousDetectedObjects are no longer detected
            var previousDetectedEnumerator = previousDetectedObjects.GetEnumerator();

            while (previousDetectedEnumerator.MoveNext())
            {
                var lostDetection = previousDetectedEnumerator.Current;
                OnLostDetection.Invoke(lostDetection, this);
            }

            previousDetectedObjects.Clear();
            var detectedEnumerator = DetectedObjects.GetEnumerator();

            while (detectedEnumerator.MoveNext())
            {
                previousDetectedObjects.Add(detectedEnumerator.Current);
            }

            if (OnSensorUpdate != null)
            {
                OnSensorUpdate();
            }
        }
        new void removeCollider(Collider other)
        {
            isColliderStale.Remove(other);
            var detectionLost = base.removeCollider(other);

            if (detectionLost != null)
            {
                OnLostDetection.Invoke(detectionLost, this);
                previousDetectedObjects.Remove(detectionLost);
            }
            if (OnSensorUpdate != null)
            {
                OnSensorUpdate();
            }
        }
Exemple #4
0
        new void removeCollider(Collider2D other)
        {
            triggerStayLag.Remove(other);
            var detectionLost = base.removeCollider(other);

            if (detectionLost != null)
            {
                OnLostDetection.Invoke(detectionLost);
                previousDetectedObjects.Remove(detectionLost);
            }
            if (OnSensorUpdate != null)
            {
                OnSensorUpdate();
            }
        }
Exemple #5
0
        void detectionEvents()
        {
            // Any GameObjects still in previousDetectedObjects are no longer detected
            var lostDetectionEnumerator = previousDetectedObjects.GetEnumerator();

            while (lostDetectionEnumerator.MoveNext())
            {
                OnLostDetection.Invoke(lostDetectionEnumerator.Current, this);
            }

            previousDetectedObjects.Clear();
            for (int i = 0; i < detectedObjectsInternal.Count; i++)
            {
                previousDetectedObjects.Add(detectedObjectsInternal[i]);
            }
        }
        void testSensor()
        {
            clearColliders();
            var sensedColliders = Physics2D.OverlapCircleAll(transform.position, SensorRange, DetectsOnLayers);

            for (int i = 0; i < sensedColliders.Length; i++)
            {
                var newDetection = addCollider(sensedColliders[i]);
                if (newDetection != null)
                {
                    if (previousDetectedObjects.Contains(newDetection))
                    {
                        previousDetectedObjects.Remove(newDetection);
                    }
                    else
                    {
                        OnDetected.Invoke(newDetection);
                    }
                }
            }

            // Any entries still in previousDetectedObjects are no longer detected
            var previousDetectedEnumerator = previousDetectedObjects.GetEnumerator();

            while (previousDetectedEnumerator.MoveNext())
            {
                var lostDetection = previousDetectedEnumerator.Current;
                OnLostDetection.Invoke(lostDetection);
            }

            previousDetectedObjects.Clear();
            var detectedEnumerator = DetectedObjects.GetEnumerator();

            while (detectedEnumerator.MoveNext())
            {
                previousDetectedObjects.Add(detectedEnumerator.Current);
            }

            if (OnSensorUpdate != null)
            {
                OnSensorUpdate();
            }
        }
        void sensorDetectionEvents()
        {
            // User may call 'DetectedObjects' while enumerating, so we want to copy list of detected objects
            // out first. or we'll get an exception that enumeration is modified.
            tempGOList.Clear();
            tempGOList.AddRange(DetectedObjects);
            var detectedEnumerator = tempGOList.GetEnumerator();

            while (detectedEnumerator.MoveNext())
            {
                var go = detectedEnumerator.Current;
                if (previousDetectedObjects.Contains(go))
                {
                    previousDetectedObjects.Remove(go);
                }
                else
                {
                    // This is a newly detected object
                    OnDetected.Invoke(go, this);
                }
            }

            // Any object still in previousDetectedObjects is no longer detected
            var previousDetectedEnumerator = previousDetectedObjects.GetEnumerator();

            while (previousDetectedEnumerator.MoveNext())
            {
                var go = previousDetectedEnumerator.Current;
                OnLostDetection.Invoke(go, this);
            }

            previousDetectedObjects.Clear();
            detectedEnumerator = DetectedObjects.GetEnumerator();
            while (detectedEnumerator.MoveNext())
            {
                previousDetectedObjects.Add(detectedEnumerator.Current);
            }
        }