Example #1
0
        /// <summary>
        /// The <see cref="SteeringBehaviour.ResultDirection"/> is the direction to the desired <see
        /// cref="AIMArrive.Target"/>. The <see cref="SteeringBehaviour.ResultMagnitude"/> is obtained by mapping the
        /// current position of the agent to the two given radii.
        /// <para/>
        /// Note, with an inverse <see cref="RadiusSteeringBehaviour.RadiusMapping"/> the following holds true: the
        /// closer the agent is to the target, the greater the velocity increases.
        /// </summary>
        /// <returns>Returns always <c>true</c>.</returns>
        protected override bool StartSteering()
        {
            ResultDirection = percept.Position - self.Position;
            sqrOuterRadius  = OuterRadius * OuterRadius;
            sqrInnerRadius  = InnerRadius * InnerRadius;

            // If true, then agent is within the radius
            if (ResultDirection.sqrMagnitude < sqrOuterRadius)
            {
                // If true, then decreasing
                if (RadiusMapping == MappingType.Linear || RadiusMapping == MappingType.Quadratic ||
                    RadiusMapping == MappingType.SquareRoot)
                {
                    ResultMagnitude = Mathf2.MapLinear(0f, BaseMagnitude, 0f, 1f,
                                                       MapSpecialSqr(RadiusMapping, sqrInnerRadius, sqrOuterRadius, ResultDirection.sqrMagnitude));
                }
                else
                {
                    ResultMagnitude = Mathf2.MapLinear(BaseMagnitude, 1f, 0f, 1f,
                                                       MapSpecialSqr(RadiusMapping, sqrInnerRadius, sqrOuterRadius, ResultDirection.sqrMagnitude));
                }
            }
            else
            {
                ResultMagnitude = BaseMagnitude;
            }

            return(true);
        }
Example #2
0
        /// <summary>
        /// Maps a <paramref name="value"/> lying between <paramref name="min"/> and <paramref name="max"/> to a
        /// resulting value between 0 and 1.
        /// <para/>
        /// The function used for the mapping is specified via the <paramref name="mapping"/> parameter, see <see
        /// cref="MappingType"/>.
        /// </summary>
        /// <param name="mapping">Specifies the applied type of the mapping function.</param>
        /// <param name="min">The minimum of the function argument interval.</param>
        /// <param name="max">The maximum of the function argument interval.</param>
        /// <param name="value">The argument value to be mapped.</param>
        /// <returns>The mapped function value.</returns>
        public static float MapSpecial(MappingType mapping, float min, float max, float value)
        {
            if (mapping == MappingType.Constant)
            {
                return(1f);
            }

            // Clamp if value is outside of the min/max interval
            if (value < min + Mathf2.Epsilon)
            {
                return((int)mapping % 2 != 0 ? 0f : 1f);
            }
            else if (value > max - Mathf2.Epsilon)
            {
                return((int)mapping % 2 != 0 ? 1f : 0f);
            }

            // Map according to the specified mapping type
            float result;

            switch (mapping)
            {
            case MappingType.Linear:
                result = Mathf2.MapLinear(0f, 1f, min, max, value);
                break;

            case MappingType.InverseLinear:
                result = 1f - Mathf2.MapLinear(0f, 1f, min, max, value);
                break;

            case MappingType.Quadratic:
                result  = Mathf2.MapLinear(0f, 1f, min, max, value);
                result *= result;
                break;

            case MappingType.InverseQuadratic:
                result  = Mathf2.MapLinear(0f, 1f, min, max, value);
                result *= result;
                result  = 1f - result;
                break;

            case MappingType.SquareRoot:
                result = Mathf.Sqrt(Mathf2.MapLinear(0f, 1f, min, max, value));
                break;

            case MappingType.InverseSquareRoot:
                result = 1f - Mathf.Sqrt(Mathf2.MapLinear(0f, 1f, min, max, value));
                break;

            default:     // MappingType.Constant
                result = 1f;
                break;
            }

            return(result);
        }