// Update is called once per frame void Update() { if (MovementAxis == MovementAxis.None || isStoped) { return; } var movementBeforeStop = MovementDirection; var newPositionInfo = MovementUtils.GetPosition(transform, MovementDirection, EnemySpeed, positionOnPreviousFrame); if (newPositionInfo.nextTile?.TileType == TileType.Wall) { isStoped = true; var animationSequence = MovementUtils.DoWallCollisionAnimation(MovementDirection, transform, wallCollisionAnimationSpeed); animationSequence[0].AppendCallback(() => isStoped = false); WallCollisionEvent(gameObject); ChooseNextDirection(movementBeforeStop); } else { transform.position = newPositionInfo.newPosition; } positionOnPreviousFrame = transform.position; }
public void SerializeToStream(ref IBitStream stream) { sbyte triggeringMoverActorIndex = (sbyte)m_triggeringMover.ActorIndex; stream.Serialize(ref triggeringMoverActorIndex); MovementUtils.SerializeLightweightPath(m_triggeringPath, stream); AbilityResultsUtils.SerializeSequenceStartDataListToStream(ref stream, m_seqStartDataList); if (m_effectResults != null) { sbyte responseType = (sbyte)MovementResults_GameplayResponseType.Effect; stream.Serialize(ref responseType); m_effectResults.SerializeToStream(ref stream); } else if (m_barrierResults != null) { sbyte responseType = (sbyte)MovementResults_GameplayResponseType.Barrier; stream.Serialize(ref responseType); m_barrierResults.SerializeToStream(ref stream); } else if (m_powerupResults != null) { sbyte responseType = (sbyte)MovementResults_GameplayResponseType.Powerup; stream.Serialize(ref responseType); m_powerupResults.SerializeToStream(ref stream); } else if (m_gameModeResults != null) { sbyte responseType = (sbyte)MovementResults_GameplayResponseType.GameMode; stream.Serialize(ref responseType); m_gameModeResults.SerializeToStream(ref stream); } }
Vector3 CalculateMovementVector(Vector2 normalizedRawInput) { inputRelativeToWorldPlane = MovementUtils.MovementRelativeToCamera(normalizedRawInput, mainCamera); inputRelativeToSlope = _groundDetection.InputAdjustedForCurrentSlope(inputRelativeToWorldPlane); correctedMovement = _obstacleAvoidance.AvoidObstacles(inputRelativeToSlope, _groundDetection.GroundRelationship_.groundNormal); return(correctedMovement); }
public void Move() { move = false; BoulderMovement movement = movements[currMovement]; Vector3 endPos = transform.position + movement.offset; Coroutine rotation = null; rotation = StartCoroutine(MovementUtils.SmoothRotationConst(boulder, Vector3.back, movement.rotSpeed)); StartCoroutine(MovementUtils.SmoothMovement((bool done) => { if (rotation != null) { StopCoroutine(rotation); } if (!movement.onGround) { PlaySoundInterval(impactAudio, 0, 0.5f); } currMovement++; move = true; }, gameObject, endPos, movement.speed)); //Play or dust ps if (movement.onGround) { rollingAudio.Play(); dust.Play(); } else { rollingAudio.Stop(); dust.Stop(); } }
public void ResolveMovement() { Dictionary <int, BoardSquarePathInfo> paths = new Dictionary <int, BoardSquarePathInfo>(); foreach (ActorData actor in GameFlowData.Get().GetActors()) { paths.Add(actor.ActorIndex, ResolveMovement(actor)); } Dictionary <int, BoardSquarePathInfo> nodes = new Dictionary <int, BoardSquarePathInfo>(paths); bool finished = false; for (float time = 0; !finished; time += RESOLUTION_STEP) { if (!ResolveSubstep(nodes, time, out finished)) { // TODO optimize time = -RESOLUTION_STEP; nodes = new Dictionary <int, BoardSquarePathInfo>(paths); Log.Info("Restarting movement resolution loop"); } } var movementActions = ArtemisServerBarrierManager.Get().OnMovement(paths); ArtemisServerResolutionManager.Get().SendMovementActions(movementActions); // TODO ClientMovementManager.MsgServerMovementStarting foreach (ActorData actor in GameFlowData.Get().GetActors()) { BoardSquarePathInfo start = paths[actor.ActorIndex]; BoardSquarePathInfo end = start; while (end.next != null) { end = end.next; } ActorTeamSensitiveData atsd = actor.TeamSensitiveData_authority; // TODO GetPathEndpoint everywhere // TODO movement camera bounds actor.MoveFromBoardSquare = end.square; actor.InitialMoveStartSquare = end.square; atsd.CallRpcMovement( GameEventManager.EventType.Invalid, GridPosProp.FromGridPos(start.square.GetGridPosition()), GridPosProp.FromGridPos(end.square.GetGridPosition()), MovementUtils.SerializePath(start), ActorData.MovementType.Normal, false, false); atsd.MovementLine?.m_positions.Clear(); } Log.Info("Movement resolved"); }
public bool TriggerMatchesMovement(ActorData mover, BoardSquarePathInfo curPath) { if (m_alreadyReacted || mover != m_triggeringMover) { return(false); } return(MovementUtils.ArePathSegmentsEquivalent_FromBeginning(m_triggeringPath, curPath)); }
public void Set() { StartCoroutine(MovementUtils.SmoothMovement((bool done) => { trigger.SetActive(true); GameSound.Stop("ElevatorMovement"); }, gameObject, setPosition, speed)); GameSound.Play("ElevatorMovement"); }
public void Move() { move = false; PlatformMovement movement = movements[currMovement]; Vector3 endPos = transform.position + movement.offset; StartCoroutine(MovementUtils.SmoothMovement((bool done) => { move = true; }, gameObject, endPos, movement.speed)); }
private void MovementWithChangeDirection() { var movementDirectionFromInput = SwipeDetector.GetDirectionFromSwipes(); if (movementDirectionFromInput != Vector3.zero) { if (MovementDirection != Vector3.zero) { transform.position = new Vector3(Mathf.Round(transform.position.x), Mathf.Round(transform.position.y), Mathf.Round(transform.position.z)); } MovementDirection = movementDirectionFromInput; } if (MovementDirection == Vector3.zero) { return; } if (animationSequence.Any()) { animationSequence.ForEach(a => a.Kill()); animationSequence.Clear(); transform.localScale = Vector3.one; transform.position = new Vector3(Mathf.Round(transform.position.x), Mathf.Round(transform.position.y), Mathf.Round(transform.position.z)); } var newPositionInfo = MovementUtils.GetPosition(transform, MovementDirection, PlayerSpeed, positionOnPreviousFrame); transform.position = newPositionInfo.newPosition; if (newPositionInfo.nextTile?.TileType == TileType.Wall) { if (MovementUtils.CheckSpikesCollision(newPositionInfo.nextTile, MovementDirection)) { //var camera = GamePlayPrefabsSettings.Prefabs.MainCamera; //camera.transform.SetParent(null); GameplaySettings.MainCamera.transform.SetParent(null); Destroy(transform.gameObject); } else { animationSequence = MovementUtils.DoWallCollisionAnimation(MovementDirection, transform, wallCollisionAnimationSpeed); animationSequence[0].AppendCallback(() => animationSequence.Clear()); MovementDirection = Vector3.zero; WallCollisionEvent(gameObject); } } positionOnPreviousFrame = transform.position; }
public override void ExitAction() { if (movement != null) { StopCoroutine(movement); } movement = StartCoroutine(MovementUtils.SmoothMovement((bool done) => { GameSound.Stop("ElevatorMovement"); movement = null; }, platform, setPosition, speed)); GameSound.Play("ElevatorMovement"); }
public void WallGoUp() { Vector3 targetPos = initPos + offset; if (movement != null) { StopCoroutine(movement); } movement = MovementUtils.SmoothMovement((bool end) => { movement = null; }, wallToRemove, targetPos, movementSpeed); StartCoroutine(movement); }
public override void ExitAction() { if (movement != null) { StopCoroutine(movement); } movement = MovementUtils.SmoothMovement((bool end) => { //Reset gem shader gemRend.material.shader = initGemShader; gemRend.material.SetColor("_EmissionColor", initGemEmissionColor); movement = null; }, gameObject, initPos, movementSpeed); StartCoroutine(movement); }
public override Transform SimulateMovement(Vector3 direction, GameObject objectClone, int playerSide) { Transform pieceCloneTransform = null; bool isCurrentSimulationInProgress = true; while (isCurrentSimulationInProgress) { bool possible = false; Quaternion startRotation = objectClone.transform.rotation; do { possible = AiUtils.IsLineGapPossible(objectClone, AiUtils.GetBottomPiecePositions(playerSide, objectClone), playerSide); if (possible) { if (MovementUtils.IsRotationPossible(objectClone)) { MovementGeneratorUtils.SimulateNextRotation(objectClone, true); } else { break; } } else { break; } }while (objectClone.transform.rotation.eulerAngles.y != startRotation.eulerAngles.y); if (possible) { bool isMovePossible = MovementUtils.IsMovementPossible(direction, objectClone); if (isMovePossible) { MovementGeneratorUtils.SimulateNextTranslation(objectClone, direction); } else { return(null); } } else { return(objectClone.transform); } } return(pieceCloneTransform); }
public override void Deserialize(NetworkReader reader, GameObject context) { var board = context.GameManager.Board; EventType = (GameEventManager.EventType)reader.ReadInt32(); Start = GeneratedNetworkCode._ReadGridPosProp_None(reader); EndGridPos = GeneratedNetworkCode._ReadGridPosProp_None(reader); EndSquare = board.GetBoardSquare(GridPos.FromGridPosProp(EndGridPos)); var pathBytes = reader.ReadBytesAndSize(); Path = MovementUtils.DeSerializePath(board, pathBytes); MovementType = (ActorData.MovementType)reader.ReadInt32(); DisappearAfterMovement = reader.ReadBoolean(); Respawning = reader.ReadBoolean(); }
public override void Action() { Vector3 targetPos = initPos + offset; //Make gem glow gemRend.material.shader = glowGemShader; gemRend.material.SetColor("_EmissionColor", gemEmissionColor); if (movement != null) { StopCoroutine(movement); } movement = MovementUtils.SmoothMovement((bool end) => { movement = null; }, gameObject, targetPos, movementSpeed); StartCoroutine(movement); }
public override Transform SimulateMovement(Vector3 direction, GameObject objectClone, int playerSide) { Transform pieceCloneTransform = null; Quaternion startRotation = objectClone.transform.rotation; Vector3 startPosition = objectClone.transform.position; do { while (true) { bool isGapPossible = AiUtils.IsLineGapPossible(objectClone, AiUtils.GetBottomPiecePositions(playerSide, objectClone), playerSide); if (!isGapPossible) { this.UpdateValidPositionCriteriaList(objectClone, playerSide); } if (!MovementUtils.IsMovementPossible(direction, objectClone)) { break; } else { MovementGeneratorUtils.SimulateNextTranslation(objectClone, direction); } } objectClone.transform.SetPositionAndRotation(startPosition, objectClone.transform.rotation); if (MovementUtils.IsRotationPossible(objectClone)) { MovementGeneratorUtils.SimulateNextRotation(objectClone, true); startPosition = objectClone.transform.position; } else { break; } }while (objectClone.transform.rotation.eulerAngles.y != startRotation.eulerAngles.y); return(pieceCloneTransform); }
private bool IsMoveForbiden(KeyCode keyPushed) { Vector3 movementDirection = new Vector3(); switch (keyPushed) { case KeyCode.RightArrow: movementDirection = Vector3.right; break; case KeyCode.LeftArrow: movementDirection = Vector3.left; break; default: break; } return(!MovementUtils.IsMovementPossible(movementDirection, this.gameObject)); }
public override IaData CalculateAction(GameObject currentSimulatedObject, int sideId) { GameObject simulatedObjectClone = PieceUtils.ClonePieceObject(currentSimulatedObject); IaData iaInformations = new IaData(); Vector3 finalCalculatedPosition; Quaternion finalCalculatedRotation; this.SimulateMovement(Vector3.right, simulatedObjectClone, sideId); simulatedObjectClone.transform.SetPositionAndRotation(currentSimulatedObject.transform.position, currentSimulatedObject.transform.rotation); bool isMovePossible = MovementUtils.IsMovementPossible(Vector3.left, simulatedObjectClone); if (isMovePossible) { MovementGeneratorUtils.SimulateNextTranslation(simulatedObjectClone, Vector3.left); } this.SimulateMovement(Vector3.left, simulatedObjectClone, sideId); if (ValidPositionCriteriaList.Count != 0) { //Order position criterias by distance descending then take the one with the highest distance property(which mean the one with less peace on ground) PositionCriteria positionCriteria = ValidPositionCriteriaList.OrderByDescending(criteria => criteria.Distance).First(); finalCalculatedPosition = positionCriteria.ValidPosition; finalCalculatedRotation = positionCriteria.ValidRotation; } else { finalCalculatedPosition = currentSimulatedObject.transform.position; finalCalculatedRotation = currentSimulatedObject.transform.rotation; } iaInformations.TargetPosition = finalCalculatedPosition; iaInformations.TargetRotation = finalCalculatedRotation; Destroy(simulatedObjectClone); return(iaInformations); }
// Update is called once per frame void Update() { if (!active) { return; } if (ready && down) { ready = false; down = false; //Activate StartCoroutine(MovementUtils.SmoothMovement((bool done) => { StartCoroutine(Deactivate()); }, spikes, upPos, speed)); spikeRisingAudio.Play(); StartCoroutine(WaitCoolDown()); } }
public static ClientMovementResults DeSerializeClientMovementResultsFromStream(Component context, ref IBitStream stream) { sbyte invalidActorIndex = (sbyte)ActorData.s_invalidActorIndex; stream.Serialize(ref invalidActorIndex); var triggeringPath = MovementUtils.DeSerializeLightweightPath(context, stream); var seqStartDataList = DeSerializeSequenceStartDataListFromStream(ref stream); sbyte num = 0; stream.Serialize(ref num); var gameplayResponseType = (MovementResults_GameplayResponseType)num; ClientEffectResults effectResults = null; ClientBarrierResults barrierResults = null; ClientAbilityResults powerupResults = null; ClientAbilityResults gameModeResults = null; switch (gameplayResponseType) { case MovementResults_GameplayResponseType.Effect: effectResults = DeSerializeClientEffectResultsFromStream(context, ref stream); break; case MovementResults_GameplayResponseType.Barrier: barrierResults = DeSerializeClientBarrierResultsFromStream(context, ref stream); break; case MovementResults_GameplayResponseType.Powerup: powerupResults = DeSerializeClientAbilityResultsFromStream(context, ref stream); break; case MovementResults_GameplayResponseType.GameMode: gameModeResults = DeSerializeClientAbilityResultsFromStream(context, ref stream); break; } return(new ClientMovementResults(context.GameFlowData.FindActorByActorIndex(invalidActorIndex), triggeringPath, seqStartDataList, effectResults, barrierResults, powerupResults, gameModeResults)); }
void Update() { moveRight = MovementUtils.Move(ShouldMove(), moveRight, transform, initialX, moveAmplitude, platformMoveSpeed); }
protected IEnumerator SmoothRotation(System.Action <bool> done, Quaternion end, float inverseRotationTime) { return(MovementUtils.SmoothRotation(done, gameObject, end, inverseRotationTime)); }
protected IEnumerator SmoothMovement(System.Action <bool> done, Vector3 end, float inverseMoveTime) { return(MovementUtils.SmoothMovement(done, gameObject, end, inverseMoveTime)); }
// Update is called once per frame void FixedUpdate() { if (IsMoving) { elapsedTime += Time.deltaTime; float verticalMove = -1f; Vector3 newGameObjectVelocity = new Vector3(); Vector3 newPosition = new Vector3(); if (Input.GetKey(DetectPlayerMovement(DirectionEnum.Direction.RIGHT))) { if (!this.IsMoveForbiden(KeyCode.RightArrow)) { newPosition = this.transform.position + Vector3.right; this.MoveObjectToNewPosition(newPosition); } } else if (Input.GetKey(DetectPlayerMovement(DirectionEnum.Direction.LEFT))) { if (!this.IsMoveForbiden(KeyCode.LeftArrow)) { newPosition = this.transform.position + Vector3.left; this.MoveObjectToNewPosition(newPosition); } } if (Input.GetKey(DetectPlayerRotation(DirectionEnum.Direction.RIGHT)) && !this.IsRotationLocked) { bool isClockwise = true; if (MovementUtils.IsRotationPossible(this.gameObject)) { this.RotateObject(isClockwise); } this.IsRotationLocked = true; } else if (Input.GetKey(DetectPlayerRotation(DirectionEnum.Direction.LEFT)) && !this.IsRotationLocked) { bool isClockwise = false; if (MovementUtils.IsRotationPossible(this.gameObject)) { this.RotateObject(isClockwise); } this.IsRotationLocked = true; } if ((Input.GetKeyUp(DetectPlayerRotation(DirectionEnum.Direction.LEFT)) || Input.GetKeyUp(DetectPlayerRotation(DirectionEnum.Direction.RIGHT))) && this.IsRotationLocked) { this.IsRotationLocked = false; } if (Input.GetKey(DetectPlayerMovement(DirectionEnum.Direction.DOWN))) { newGameObjectVelocity = new Vector3(gameObJectRigidBody.velocity.x, gameObJectRigidBody.velocity.y, verticalMove * GameUtils.FetchPlayerPieceSpeed(OwnerId)); } else { newGameObjectVelocity = new Vector3(this.gameObJectRigidBody.velocity.x, this.gameObJectRigidBody.velocity.y, -0.5f * GameUtils.FetchPlayerPieceSpeed(OwnerId)); } this.gameObJectRigidBody.velocity = newGameObjectVelocity; } }
private bool IsRotateForbiden() { return(!MovementUtils.IsRotationPossible(this.gameObject)); }
public void Open() { Vector3 targetPos = initPos + offset; StartCoroutine(MovementUtils.SmoothMovement((bool end) => {}, gameObject, targetPos, movementSpeed)); }
public static void Draw(SpriteBatch spriteBatch, GameTime gameTime, MovingEntity movingEntity) { var livingEntityType = LivingEntityType.lookup[movingEntity.LivingEntityType]; WalkingDirection newWalkingDirection = MovementUtils.GetWalkingDirectionFromVector(movingEntity.Direction); movingEntity.RendererInformation.Update(gameTime, newWalkingDirection); if (!movingEntity.IsWalking) { movingEntity.RendererInformation.currentAnimation.Reset(); } var adjustedYPosition = movingEntity.Position.Y + movingEntity.YPositionDepthOffset; if (movingEntity.IsDead()) { movingEntity.RendererInformation.Update(gameTime, WalkingDirection.Left); movingEntity.RendererInformation.currentAnimation.Reset(); spriteBatch.Draw(movingEntity.RendererInformation.currentAnimation, new Vector2((int)movingEntity.Position.X, (int)movingEntity.Position.Y), rotation: MathHelper.Pi / 2, color: Color.White, layerDepth: GeometryUtils.GetLayerDepthFromPosition(movingEntity.Position.X, adjustedYPosition)); } else { spriteBatch.Draw(movingEntity.RendererInformation.currentAnimation, new Vector2((int)movingEntity.Position.X, (int)movingEntity.Position.Y), color: Color.White, layerDepth: GeometryUtils.GetLayerDepthFromPosition(movingEntity.Position.X, adjustedYPosition)); } // Draw Speech Bubble if (movingEntity.RendererInformation.SpeechLine != null) { var depth = GeometryUtils.GetLayerDepthFromPosition(movingEntity.Position.X, adjustedYPosition); var depth2 = GeometryUtils.GetLayerDepthFromPosition(movingEntity.Position.X + 1, adjustedYPosition); var bubbleYOffset = (int)movingEntity.Position.Y - livingEntityType.SpriteBounds.Y - 20; var stringWidth = font.MeasureString(movingEntity.RendererInformation.SpeechLine).X; var bubbleWidth = stringWidth - 8; var bubbleStartPos = new Vector2((int)movingEntity.Position.X - 10 - bubbleWidth, bubbleYOffset); var bubbleContentPos = new Vector2((int)movingEntity.Position.X - bubbleWidth, bubbleYOffset); var bubbleEndPos = new Vector2((int)movingEntity.Position.X - 10, bubbleYOffset); // Draw bubble start spriteBatch.Draw(SimulationGame.ContentManager.Load <Texture2D>(@"GUI\SpeechBubble"), bubbleStartPos, new Rectangle(0, 0, 10, 27), Color.White, 0.0f, Vector2.Zero, 1.0f, SpriteEffects.None, depth); // Draw bubble content spriteBatch.Draw(SimulationGame.ContentManager.Load <Texture2D>(@"GUI\SpeechBubble"), bubbleContentPos, new Rectangle(10, 0, 20, 27), Color.White, 0.0f, Vector2.Zero, new Vector2((stringWidth - 18) / 20.0f, 1.0f), SpriteEffects.None, depth); // Draw string spriteBatch.DrawString(font, movingEntity.RendererInformation.SpeechLine, new Vector2(bubbleContentPos.X, bubbleYOffset + 5), Color.White, 0.0f, Vector2.Zero, 1.0f, SpriteEffects.None, depth2); // Draw bubble end spriteBatch.Draw(SimulationGame.ContentManager.Load <Texture2D>(@"GUI\SpeechBubble"), bubbleEndPos, new Rectangle(110, 0, 27, 27), Color.White, 0.0f, Vector2.Zero, 1.0f, SpriteEffects.None, depth); } // Draw Health if (movingEntity.CurrentLife < movingEntity.MaximumLife) { spriteBatch.Draw(healthTexture, new Vector2(movingEntity.Position.X - livingEntityType.SpriteBounds.X / 2, movingEntity.Position.Y - livingEntityType.SpriteBounds.Y), new Rectangle(0, 0, 1, 1), Color.Red, 0.0f, Vector2.Zero, new Vector2(((float)movingEntity.CurrentLife / (float)movingEntity.MaximumLife) * livingEntityType.SpriteBounds.X, 2.0f), SpriteEffects.None, GeometryUtils.GetLayerDepthFromPosition(movingEntity.Position.X, adjustedYPosition)); } if (SimulationGame.IsDebug) { if (movingEntity.IsBlocking()) { SimulationGame.PrimitiveDrawer.Rectangle(movingEntity.UnionBounds.ToXnaRectangle(), Color.Red); } else if (movingEntity.IsHitable()) { SimulationGame.PrimitiveDrawer.Rectangle(movingEntity.HitBoxBounds.ToXnaRectangle(), Color.White); SimulationGame.PrimitiveDrawer.Rectangle(movingEntity.BlockingBounds.ToXnaRectangle(), Color.Red); } } }
private bool IsMoveForbiden(Vector3 movementDirection) { return(!MovementUtils.IsMovementPossible(movementDirection, this.gameObject)); }
IEnumerator Deactivate() { yield return(new WaitForSeconds(upTime)); StartCoroutine(MovementUtils.SmoothMovement((bool done) => { down = true; }, spikes, downPos, speed)); }
private void MovementUpdate(float deltaTime, out Vector3 nextPosition, out Quaternion nextRotation) { m_LastDeltatime = deltaTime; float currentAcceleration = MaxAcceleration; if (currentAcceleration < 0) { currentAcceleration *= -MaxSpeed; } if (UpdatePosition) { m_SimulatedPosition = transform.position; } if (UpdateRotation) { m_SimulatedRotation = transform.rotation; } var currentPosition = m_SimulatedPosition; interpolator.MoveToCircleIntersection(currentPosition, LookAheadDis); var dir = (SteerPosition - currentPosition); float distanceToEnd = dir.magnitude + Mathf.Max(0, interpolator.RemainingDistance); var prevTargetReached = ReachedEndOfPath; ReachedEndOfPath = distanceToEnd <= EndReachedDis && interpolator.Valid; if (!prevTargetReached && ReachedEndOfPath) { OnTargetReached(); } float slowDown; var forward = m_SimulatedRotation * Vector3.forward; if (interpolator.Valid && !IsStopped) { slowDown = distanceToEnd < SlowDownDis?Mathf.Sqrt(distanceToEnd / SlowDownDis) : 1; //Todo: Get end of path mode if (ReachedEndOfPath) { Velocity -= Vector3.ClampMagnitude(Velocity, currentAcceleration * deltaTime); } else { Velocity += MovementUtils.CalculateAccelerationToReachPoint(dir, dir.normalized * MaxSpeed, Velocity, currentAcceleration, RotationSpeed, MaxSpeed, forward) * deltaTime; } } else { slowDown = 1; Velocity -= Vector3.ClampMagnitude(Velocity, currentAcceleration * deltaTime); } Velocity = MovementUtils.ClampVelocity(Velocity, MaxSpeed, slowDown, SlowWhenNotFacingTarget, forward); //Todo: RVO Controller var delta = m_LastDeltaPosition = CalculateDeltaToMoveThisFrame(distanceToEnd, deltaTime); nextPosition = currentPosition + delta; CalculateNextRotation(slowDown, out nextRotation); }