Esempio n. 1
0
        /// <summary>
        /// Generate the next new point but not the same as last point.
        /// </summary>
        private void GetNextPoint()
        {
            if (mRandom)
            {
                int len      = mPoints.Count;
                int newIndex = JCS_Random.RangeInclude(0, len - 1);

                if (newIndex == mTargetPointIndex && len != 1)
                {
                    GetNextPoint();
                }
                else
                {
                    mTargetPointIndex = newIndex;
                }
            }
            else
            {
                ++mTargetPointIndex;

                if (mTargetPointIndex >= mPoints.Count)
                {
                    mTargetPointIndex = 0;
                }
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Get a random vector as unit vector. (direction)
        /// </summary>
        /// <returns>
        /// Random unit vector.
        /// </returns>
        private Vector3 GetRandomVec()
        {
            float xVec = JCS_Random.RangeInclude(-1.0f, 1.0f);
            float yVec = 0.0f;  // no direction on y axis.
            float zVec = JCS_Random.RangeInclude(-1.0f, 1.0f);

            return(new Vector3(xVec, yVec, zVec).normalized);
        }
Esempio n. 3
0
        /// <summary>
        /// Add the off distance.
        /// </summary>
        /// <param name="targetPos"> Target position use to calculate. </param>
        /// <returns>
        /// Return new position with off distance added.
        /// </returns>
        private Vector3 AddOffDistance(Vector3 targetPos)
        {
            Vector3 randVec = GetRandomVec();

            float magnitude = JCS_Random.RangeInclude(mMinOffDistance, mMaxOffDistance);

            randVec *= magnitude;

            return(targetPos + randVec);
        }
Esempio n. 4
0
        /// <summary>
        /// Do the actual shake job.
        /// </summary>
        private void DoEffect()
        {
            if (!mEffect)
            {
                return;
            }

            RevertShakeByTransformType(mShakeDelta);

            mShakeDelta = Vector3.zero;

            mShakeTimer += Time.deltaTime;

            if (mShakeTimer < mShakeTime)
            {
                // shake randomly
                if (mShakeOnX)
                {
                    mShakeDelta.x = (JCS_Random.RangeInclude(-1.0f, 1.0f)) * mShakeMargin * (mShakeTime / mShakeTimer) / mShakeSteps;
                }
                if (mShakeOnY)
                {
                    mShakeDelta.y = (JCS_Random.RangeInclude(-1.0f, 1.0f)) * mShakeMargin * (mShakeTime / mShakeTimer) / mShakeSteps;
                }
                if (mShakeOnZ)
                {
                    mShakeDelta.z = (JCS_Random.RangeInclude(-1.0f, 1.0f)) * mShakeMargin * (mShakeTime / mShakeTimer) / mShakeSteps;
                }

                ApplyShakeByTransformType(mShakeDelta);
            }
            else
            {
                mShakeTimer = 0.0f;
                mEffect     = false;
            }
        }
        /// <summary>
        /// Generate the next new point but not the same as last point.
        /// </summary>
        private void GetNextPoint()
        {
            switch (mPathActionType)
            {
            case JCS_PathActionType.INCREMENT:
            {
                ++mTargetPointIndex;

                if (mTargetPointIndex >= mPoints.Count)
                {
                    mTargetPointIndex = 0;
                }
            }
            break;

            case JCS_PathActionType.DECREMENT:
            {
                --mTargetPointIndex;

                if (mTargetPointIndex < 0)
                {
                    mTargetPointIndex = mPoints.Count - 1;
                }
            }
            break;

            case JCS_PathActionType.INC_OR_DEC:
            {
                int incOrDec = JCS_Random.RangeInclude(0, 1);

                if (incOrDec == 0)
                {
                    mPathActionType = JCS_PathActionType.INCREMENT;
                }
                else
                {
                    mPathActionType = JCS_PathActionType.DECREMENT;
                }

                GetNextPoint();

                mPathActionType = JCS_PathActionType.INC_OR_DEC;
            }
            break;

            case JCS_PathActionType.RANDOM_ALL:
            {
                int len      = mPoints.Count;
                int newIndex = JCS_Random.RangeInclude(0, len - 1);

                if (newIndex == mTargetPointIndex && len != 1)
                {
                    GetNextPoint();
                }
                else
                {
                    mTargetPointIndex = newIndex;
                }
            }
            break;
            }
        }