public bool TestCondition(Condition condition, float param, FSMCounter counter)
    {
        switch (condition)
        {
        case Condition.TIMER:
        {
            if (counter.timer > param)
            {
                return(true);
            }
            break;
        }

        case Condition.FRAMES:
        {
            if (counter.frames >= (Mathf.CeilToInt(param)))
            {
                return(true);
            }
            break;
        }

        case Condition.TARGET_IN_RADIUS:
        {
            if (Vector3.Magnitude(goals.GetTargetPosition() - parentTransform.position) < param)
            {
                return(true);
            }
            break;
        }

        case Condition.TARGET_OUTSIDE_RADIUS:
        {
            if (Vector3.Magnitude(goals.GetTargetPosition() - parentTransform.position) > param)
            {
                return(true);
            }
            break;
        }

        case Condition.TARGET_IN_LOS:
        {
            if (raycastSensors.IsGameobjectInLOS(goals.GetTargetObject()))
            {
                return(true);
            }
            break;
        }

        case Condition.TARGET_IN_OCTANT_BELOW:
        {
            FindTargetOctant();
            if (horOctant == 0f && vertOctant < 0)
            {
                return(true);
            }
            break;
        }

        case Condition.TARGET_IN_OCTANT_ABOVE:
        {
            FindTargetOctant();
            if (horOctant == 0f && vertOctant > 0)
            {
                return(true);
            }
            break;
        }

        case Condition.TARGET_IN_HORIZONTAL_OCTANTS:
        {
            FindTargetOctant();
            if (horOctant != 0f && vertOctant == 0)
            {
                return(true);
            }
            break;
        }

        case Condition.TARGET_IN_FRONT_OCTANT:
        {
            FindTargetOctant();
            if (horOctant == goals.GetForwardDirection() && vertOctant == 0)
            {
                return(true);
            }
            break;
        }

        case Condition.TARGET_IN_FRONT_HORIZONTAL:
        {
            FindTargetDistances();
            if (Mathf.Sign(horDistance) == Mathf.Sign(goals.GetForwardDirection()))
            {
                if (Mathf.Abs(vertDistance) < verticalSpottingHeight)
                {
                    return(true);
                }
            }
            break;
        }

        case Condition.CLIFF_LEFT:
        {
            if (raycastSensors.GetLeftCliff())
            {
                return(true);
            }
            break;
        }

        case Condition.CLIFF_RIGHT:
        {
            if (raycastSensors.GetRightCliff())
            {
                return(true);
            }
            break;
        }

        case Condition.CLIFF_FORWARD:
        {
            if (contactSensor.GetContactState() != ContactState.AIRBORNE)                        //Don't look for cliffs if already airborne...
            {
                if (goals.GetForwardDirection() == 1)
                {
                    if (raycastSensors.GetRightCliff())
                    {
                        return(true);
                    }
                }
                else
                {
                    if (raycastSensors.GetLeftCliff())
                    {
                        return(true);
                    }
                }
            }
            break;
        }

        case Condition.ALWAYS:
        {
            return(true);

            break;
        }
        }
        return(false);
    }
    public void PerformAction(Action action)
    {
        switch (action)
        {
        case Action.IDLE:
        {
            ResetController();
            break;
        }

        case Action.MOVE_LEFT: {
            MoveTowardsDirection(-1);
            break;
        }

        case Action.MOVE_RIGHT: {
            MoveTowardsDirection(1);
            break;
        }

        case Action.MOVE_FORWARD:
        {
            MoveTowardsDirection(goals.GetForwardDirection());
            break;
        }

        case Action.CHANGE_DIRECTION:
        {
            goals.ToggleForwardDirection();
            break;
        }

        case Action.AIM_TARGET: {
            AimAtPoint(goals.GetTargetPosition());
            break;
        }

        case Action.RELEASE_FIRE_TARGET: {
            ReleaseFireAtPoint(goals.GetTargetPosition());
            break;
        }

        case Action.JUMP:
        {
            TapJump();
            break;
        }

        case Action.PRESS_JUMP:
        {
            PressJump();
            break;
        }

        case Action.RELEASE_JUMP:
        {
            ReleaseJump();
            break;
        }

        case Action.FIRE:
        {
            virtualController.TapFire();
            break;
        }

        case Action.PRESS_FIRE:
        {
            PressFire();
            break;
        }

        case Action.RELEASE_FIRE:
        {
            virtualController.ReleaseFire();
            break;
        }

        case Action.PICK_RANDOM_ROSE_DIRECTION:
        {
            goals.PickRandomRoseDirection();
            break;
        }

        case Action.PICK_RANDOM_ROSE_DIRECTION_TOWARDS_TARGET:
        {
            goals.PickRandomRoseDirection();
            Vector3 targetPosition = goals.GetTargetPosition();

            bool towardsTarget = false;
            if (targetPosition != null)
            {
                while (towardsTarget == false)
                {
                    goals.PickRandomRoseDirection();
                    AimRoseDirection();
                    Vector3 vecToTarget = targetPosition - this.transform.position;
                    if (Mathf.Sign(virtualController.GetHorAxis()) == Mathf.Sign(vecToTarget.x))
                    {
                        towardsTarget = true;
                    }
                    if (Mathf.Sign(virtualController.GetVertAxis()) == Mathf.Sign(vecToTarget.y))
                    {
                        towardsTarget = true;
                    }
                }
            }
            break;
        }

        case Action.MOVE_ROSE_DIRECTION:
        {
            AimRoseDirection();
            break;
        }

        default:
            ResetController();
            break;
        }
    }