示例#1
0
 public void Pause(LevelEntityMovementStep step = null)
 {
     step = step ?? movementSteps[0];
     lock (InstanceMutationLock) {
         pausedStep = step;
         Transform  = step.Transform;
         if (step == movementSteps[0])
         {
             initialDelayTimeRemaining = initialDelay;
         }
     }
 }
示例#2
0
 public void Unpause()
 {
     lock (InstanceMutationLock) {
         if (pausedStep == null)
         {
             return;
         }
         targetStepIndex = movementSteps.IndexOf(pausedStep) + 1;
         if (targetStepIndex == movementSteps.Length)
         {
             targetStepIndex = 0;
         }
         startingStepIndex = targetStepIndex - 1;
         if (startingStepIndex < 0)
         {
             startingStepIndex = movementSteps.Length - 1;
         }
         timeInToCurrentStep = 0f;
         pausedStep          = null;
     }
 }
示例#3
0
        public void AdvanceMovement(float deltaTime)
        {
            lock (InstanceMutationLock) {
                if (pausedStep != null)
                {
                    return;
                }

                if (initialDelayTimeRemaining > 0f)
                {
                    if (initialDelayTimeRemaining >= deltaTime)
                    {
                        initialDelayTimeRemaining -= deltaTime;
                        return;
                    }
                    else
                    {
                        deltaTime -= initialDelayTimeRemaining;
                        initialDelayTimeRemaining = 0f;
                    }
                }

                timeInToCurrentStep += deltaTime;

                LevelEntityMovementStep targetStep = movementSteps[targetStepIndex];
                while (timeInToCurrentStep > targetStep.TravelTime)
                {
                    timeInToCurrentStep -= targetStep.TravelTime;
                    startingStepIndex    = targetStepIndex;

                    if (alternateMovementDirection)
                    {
                        if (currentlyInReverse)
                        {
                            targetStepIndex = --targetStepIndex;
                            if (targetStepIndex == -1)
                            {
                                targetStepIndex    = 1;
                                currentlyInReverse = false;
                            }
                        }
                        else
                        {
                            targetStepIndex = ++targetStepIndex;
                            if (targetStepIndex == movementSteps.Length)
                            {
                                targetStepIndex    = movementSteps.Length - 2;
                                currentlyInReverse = true;
                            }
                        }
                    }
                    else
                    {
                        targetStepIndex = ++targetStepIndex % movementSteps.Length;
                    }

                    targetStep = movementSteps[targetStepIndex];
                }

                if (targetStep.SmoothTransition)
                {
                    Transform = Transform.Slerp(
                        tiltedTransforms[startingStepIndex],
                        tiltedTransforms[targetStepIndex],
                        (float)Math.Atan((timeInToCurrentStep / targetStep.TravelTime - 0.5f) * X_AXIS_SMOOTHING_EXPANSION_FACTOR) / (MathUtils.PI - ASYMPTOTIC_CORRECTION) + 0.5f
                        );
                }
                else
                {
                    Transform = Transform.Lerp(
                        tiltedTransforms[startingStepIndex],
                        tiltedTransforms[targetStepIndex],
                        timeInToCurrentStep / targetStep.TravelTime
                        );
                }
            }
        }