public static Vector2 GetPositionOfNearestEnemy(this Vector2 startPosition, bool canTargetNonRoomClear, bool targetSprite = false, List <AIActor> excludedActors = null)
        {
            List <AIActor> exclude = new List <AIActor>();

            if (excludedActors != null && excludedActors.Count > 0)
            {
                exclude.AddRange(excludedActors);
            }
            Func <AIActor, bool> isValid           = (AIActor a) => a && a.HasBeenEngaged && a.healthHaver && a.healthHaver.IsVulnerable && a.healthHaver.IsAlive && !a.IsGone && !exclude.Contains(a) && a.IsWorthShootingAt && a.isActiveAndEnabled && a.CanTargetPlayers && a.GetComponent <CompanionController>() == null;
            IntVector2           intVectorStartPos = startPosition.ToIntVector2();

            RoomHandler.ActiveEnemyType enemyType = RoomHandler.ActiveEnemyType.RoomClear;
            if (canTargetNonRoomClear)
            {
                enemyType = RoomHandler.ActiveEnemyType.All;
            }
            AIActor closestToPosition = BraveUtility.GetClosestToPosition <AIActor>(GameManager.Instance.Dungeon.data.GetAbsoluteRoomFromPosition(intVectorStartPos).GetActiveEnemies(enemyType), startPosition, isValid, new AIActor[] { });

            if (closestToPosition == null)
            {
                return(Vector2.zero);
            }
            if (targetSprite && closestToPosition.sprite)
            {
                return(closestToPosition.sprite.WorldCenter);
            }
            else
            {
                return(closestToPosition.specRigidbody.UnitCenter);
            }
        }
        public static List <AIActor> GetXEnemiesInRoom(this RoomHandler room, int numOfEnemiesToReturn, bool reqForRoomClear = true, bool canReturnBosses = true)
        {
            if (numOfEnemiesToReturn <= 0)
            {
                return(null);
            }
            RoomHandler.ActiveEnemyType type = RoomHandler.ActiveEnemyType.All;
            if (reqForRoomClear)
            {
                type = RoomHandler.ActiveEnemyType.RoomClear;
            }
            List <AIActor> activeEnemies = room.GetActiveEnemies(type);

            if (activeEnemies != null)
            {
                if (!canReturnBosses)
                {
                    for (int i = 0; i < activeEnemies.Count; i++)
                    {
                        if (activeEnemies[i].IsBoss())
                        {
                            activeEnemies.RemoveAt(i);
                        }
                    }
                }
                if (activeEnemies.Count > numOfEnemiesToReturn)
                {
                    List <AIActor> pickedEnemies = new List <AIActor>();
                    for (int i = 0; i < numOfEnemiesToReturn; i++)
                    {
                        AIActor actor = BraveUtility.RandomElement(activeEnemies);
                        pickedEnemies.Add(actor);
                        activeEnemies.Remove(actor);
                    }
                    return(pickedEnemies);
                }
                else
                {
                    return(activeEnemies);
                }
            }
            else
            {
                return(null);
            }
        }
        public static AIActor GetNearestEnemyToPosition(this Vector2 position, bool checkIsWorthShootingAt = true, RoomHandler.ActiveEnemyType type = RoomHandler.ActiveEnemyType.RoomClear, Func <AIActor, bool> overrideValidityCheck = null)
        {
            Func <AIActor, bool> isValid = (AIActor a) => a && a.HasBeenEngaged && a.healthHaver && a.healthHaver.IsVulnerable && a.healthHaver.IsAlive && ((checkIsWorthShootingAt && a.IsWorthShootingAt) || !checkIsWorthShootingAt);

            if (overrideValidityCheck != null)
            {
                isValid = overrideValidityCheck;
            }
            AIActor closestToPosition = BraveUtility.GetClosestToPosition <AIActor>(GameManager.Instance.Dungeon.data.GetAbsoluteRoomFromPosition(position.ToIntVector2()).GetActiveEnemies(type), position, isValid, new AIActor[] { });

            if (closestToPosition)
            {
                return(closestToPosition);
            }
            else
            {
                return(null);
            }
        }