Untitled

using UnityEngine;

namespace Cleanup
{
    internal class Program
    {
        private const double TargetChangeTime = 1;

        private double _previousTargetSetTime;
        private dynamic _lockedCandidateTarget;
        private dynamic _lockedTarget;
        private dynamic _target;
        private dynamic _previousTarget;
        private dynamic _activeTarget;
        private dynamic _targetInRangeContainer;

        public void CleanupTest(Frame frame)
        {
            try
            {
                CheckAndResetLockedTargets();
				
                TrySetActiveTargetFromQuantum(frame);

                bool isCurrentTargetValid = IsTargetAvailable(_target) && IsWithinTargetChangeTime();

                if (isCurrentTargetValid == false)
                {
                    _previousTarget = _target;
                    _target = null;

                    if (TrySetValidTarget(_lockedTarget) == false &&
                        TrySetValidTarget(_activeTarget) == false)
                    {
                        _target = _targetInRangeContainer.GetTarget();

                        if (IsTargetAvailable(_target) == false)
                        {
                            _target = null;
                        }
                    }
                }
            }
            finally
            {
                if (_target != null)
                {
                    UpdatePreviousTargetSetTime();
                }

                TargetableEntity.Selected = _target;
            }
        }

        private void CheckAndResetLockedTargets()
        {
            if (IsTargetAvailable(_lockedCandidateTarget) == false)
            {
                _lockedCandidateTarget = null;
            }

            if (IsTargetAvailable(_lockedTarget) == false)
            {
                _lockedTarget = null;
            }
        }

        private bool IsWithinTargetChangeTime()
        {
            return Time.time - _previousTargetSetTime < TargetChangeTime;
        }

        private bool IsTargetAvailable(dynamic target)
        {
            return target != null && target.CanBeTarget;
        }

        private bool TrySetValidTarget(dynamic target)
        {
            if (IsTargetAvailable(target))
            {
                _target = target;
                return true;
            }
			
            return false;
        }

        private void UpdatePreviousTargetSetTime()
        {
            if (_previousTarget != _target)
            {
                _previousTargetSetTime = Time.time;
            }
        }
    }
}