Esempio n. 1
0
        /// <summary>
        /// Gets the distance.
        /// </summary>
        /// <param name="erp">The erp.</param>
        /// <param name="haat">The haat.</param>
        /// <param name="fieldInDb">The field in database.</param>
        /// <param name="channel">The channel.</param>
        /// <param name="isDigital">if set to <c>true</c> [is digital].</param>
        /// <returns>returns System.Single.</returns>
        public float GetDistance(float erp, float haat, float fieldInDb, int channel, bool isDigital)
        {
            CurveCalculator curveCalculator = new CurveCalculator();
            float           distance        = curveCalculator.CalculateCurveValue(erp, haat, channel, fieldInDb, 0.0f, 2, isDigital);

            return(distance);
        }
Esempio n. 2
0
    public override void Initialize()
    {
        this.m_Config.SpriteAnimator.Play(AnimationNameConstants.MIDDLE);
        this.m_CurrentPosition = this.Behavior.transform.position;
        this.m_TargetPosition  = this.Behavior.DestinationObject.GetDestinationPosition(this.m_CurrentPosition);
        this.m_Criterion       = new InfinityCriterion();

        int frames = Mathf.CeilToInt(Vector2.Distance(((Vector2)this.m_TargetPosition), ((Vector2)this.m_CurrentPosition)) / this.Behavior.Velocity);

        this.m_CurveCalculator = new CurveCalculator(this.m_Config.CurveG, frames);
    }
    public override void Initialize()
    {
        /*
         * this.m_Criterion = new AnimationCriterion(this.Behavior.MoveAnimation);
         *
         * this.Behavior.MoveAnimation.clip.ClearCurves();
         *
         * Vector3 sourcePosition = this.Behavior.SourceObject.transform.position;
         * Vector3 destinationPosition = this.Behavior.DestinationObject.transform.position;
         *
         * float distance = Vector2.Distance(sourcePosition, destinationPosition);
         *
         * float moveTime = distance / this.Behavior.Velocity;
         *
         * AnimationCurve moveXCurve = AnimationCurve.Linear(0, sourcePosition.x, moveTime, destinationPosition.x);
         * AnimationCurve moveYCurve = AnimationCurve.Linear(0, sourcePosition.y, moveTime, destinationPosition.y);
         * AnimationCurve moveZCurve = AnimationCurve.Linear(0, sourcePosition.z, moveTime, destinationPosition.z);
         *
         * this.Behavior.MoveAnimation.clip.SetCurve("",typeof(Transform),"localPosition.x",moveXCurve);
         * this.Behavior.MoveAnimation.clip.SetCurve("",typeof(Transform),"localPosition.y",moveYCurve);
         * this.Behavior.MoveAnimation.clip.SetCurve("",typeof(Transform),"localPosition.z",moveZCurve);
         */

        Vector3 sourcePosition      = this.Behavior.transform.position;
        Vector3 destinationPosition = this.Behavior.DestinationObject.GetDestinationPosition(this.m_Behavior.transform.position);

        float distance     = Vector2.Distance(new Vector2(destinationPosition.x, destinationPosition.y), new Vector2(sourcePosition.x, sourcePosition.y));
        int   middleFrames = Mathf.CeilToInt(distance / this.Behavior.Velocity);

        this.m_MoveVector = (destinationPosition - this.Behavior.transform.position) / middleFrames;


        this.m_Criterion = new FrameRelatedCriterion(middleFrames);
        if (this.m_Config.SpriteAnimator.GetClipByName(AnimationNameConstants.MIDDLE) != null)
        {
            this.m_Config.SpriteAnimator.Play(AnimationNameConstants.MIDDLE);
        }
        else
        {
            CharacterDirection direction = DirectionHelper.GetDirectionFormVector(destinationPosition - this.Behavior.transform.position);

            switch (direction)
            {
            case CharacterDirection.Up:
            {
                this.m_Config.SpriteAnimator.Play(AnimationNameConstants.MIDDLE_UP);
            }
            break;

            case CharacterDirection.Down:
            {
                this.m_Config.SpriteAnimator.Play(AnimationNameConstants.MIDDLE_DOWN);
            }
            break;

            case CharacterDirection.Left:
            {
                this.m_Config.SpriteAnimator.Play(AnimationNameConstants.MIDDLE_LEFT);
            }
            break;

            case CharacterDirection.Right:
            {
                this.m_Config.SpriteAnimator.Play(AnimationNameConstants.MIDDLE_RIGHT);
            }
            break;

            case CharacterDirection.LeftUp:
            {
                this.m_Config.SpriteAnimator.Play(AnimationNameConstants.MIDDLE_LEFT_UP);
            }
            break;

            case CharacterDirection.LeftDown:
            {
                this.m_Config.SpriteAnimator.Play(AnimationNameConstants.MIDDLE_LEFT_DOWN);
            }
            break;

            case CharacterDirection.RightUp:
            {
                this.m_Config.SpriteAnimator.Play(AnimationNameConstants.MIDDLE_RIGHT_UP);
            }
            break;

            case CharacterDirection.RightDown:
            {
                this.m_Config.SpriteAnimator.Play(AnimationNameConstants.MIDDLE_RIGHT_DOWN);
            }
            break;
            }
        }

        this.m_CurveCalculator = new CurveCalculator(this.m_Config.CurveG, middleFrames);
        this.m_CurrentPosition = this.Behavior.transform.position;
        base.Initialize();
    }