private IEnumerator MoveLeft(AnimatablePaper paper, int index) { paper.SetIsAnimating(true); LerpValue <Vector3> rotateToMiddle = paper.RotateToMiddle; while (rotateToMiddle.Continue()) { paper.transform.localEulerAngles = Vector2.Lerp(rotateToMiddle.start, rotateToMiddle.end, rotateToMiddle.perc); yield return(null); } Audio.MusicPlayer.Instance.PlaySFXSound(Audio.SFXSound.TurningPage); paper.SetOrderInLayer(startSortingOrder + index); paper.SetIsOnBack(true); LerpValue <Vector3> rotateToOutside = paper.RotateToOutside; while (rotateToOutside.Continue()) { paper.transform.localEulerAngles = Vector2.Lerp(rotateToOutside.start, rotateToOutside.end, rotateToOutside.perc); yield return(null); } paper.SetIsLeft(true); paper.SetIsAnimating(false); }
/// <summary>Returns an enumerator that notifies the player by showing a small screen on top of the screen and then hiding it after a delay</summary> private IEnumerator NotifyEnumerator(float stayTime) { isNotifying = true; float offset = notificationTransform.rect.height; LerpValue <float> movedownward = new LerpValue <float>(offset, -notificationTopSpacing, notifySpeed, LerpSettings.Cosine); while (movedownward.Continue()) { Vector2 position = new Vector2(notificationTransform.anchoredPosition.x, Mathf.Lerp(movedownward.start, movedownward.end, movedownward.perc)); notificationTransform.anchoredPosition = position; yield return(null); } yield return(new WaitForSeconds(stayTime + 4f)); LerpValue <float> moveup = new LerpValue <float>(-notificationTopSpacing, offset, notifySpeed, LerpSettings.Cosine); while (moveup.Continue()) { Vector2 position = new Vector2(notificationTransform.anchoredPosition.x, Mathf.Lerp(moveup.start, moveup.end, moveup.perc)); notificationTransform.anchoredPosition = position; yield return(null); } if (notificationQueue.Count != 0) { StartNofication(notificationQueue.Dequeue()); } else { isNotifying = false; } }
private void Update() { crosshair.gameObject.SetActive(!UIManager.instance.pause); cursorAlpha = crosshair.color; cursorAlpha.a = LerpValue.SmoothRealtime(cursorAlpha.a, alphaTo, 12f); crosshair.color = cursorAlpha; if (target._run) { alphaTo = 0f; return; } else { alphaTo = 1f; } crosshair.transform.position = Input.mousePosition; crosshair.transform.eulerAngles += Vector3.forward * 32f * Time.deltaTime; float inputFactor = (new Vector3(inputs.h, inputs.v, 0)).magnitude / 2; crosshair.transform.localScale = new Vector3(1 + inputFactor, 1 + inputFactor, 0); }
private void Start() { movement = GetComponent <Movement2D>(); shape = GetComponent <Shape>(); mouthAngle = new LerpValue(ChangeMouthAnimationDirection, 40f); }
public SpinningWheel(IUIStyle style) : base(style) { fadeInAnim = new SmoothValue(0, 1, FadeDuration, FadeDelay, AnimationLoop.NoLoop); rotationValue = new LerpValue(0, MathHelper.Pi, 1, AnimationLoop.Loop); FadeIn = true; Style.ValueChanged += OnStyleChanged; }
public ProgressBar(IUIStyle style) : base(style) { lerpValue = new LerpValue(0, 0, 0.5f, AnimationLoop.NoLoop); Min = 0; Max = 100; Value = 0; Direction = ProgressBarDirection.LeftToRight; }
private void AddLerpValue(float distance, LerpValue lerpValue, ref float weight, ref float3 right, ref float3 up) { var other = GetTransform(distance + lerpValue.sampleDistance); right += other.right * lerpValue.scale; up += other.up * lerpValue.scale; weight += lerpValue.scale; }
private LerpValue sizeLerp; // Grows and Shrinks the value for the pellet size. private void Start() { sizeLerp = new LerpValue(ChangeSizeDirection, sizeRange.x, InterpolationMethod.Cosine) { Speed = animationSpeed }; transform.localScale = Vector2.one * sizeLerp.Current; }
/// <summary>Returns an enumerator that linearly interpolates the alpha of the canvasgroup from 1 to 0</summary> public IEnumerator Intro() { LerpValue <float> alphaLerp = new LerpValue <float>(1, 0, transitionTime); while (alphaLerp.Continue()) { group.alpha = Mathf.Lerp(alphaLerp.start, alphaLerp.end, alphaLerp.perc); yield return(null); } }
/// <summary>Returns an enumerator that changes the given source's volume of time towards targetVolume</summary> private IEnumerator ChangeSourceVolumeOverTime(AudioSource source, float targetVolume) { LerpValue <float> change = new LerpValue <float>(source.volume, targetVolume, themeTransitionFadeInTime); while (change.Continue()) { source.volume = Mathf.Lerp(change.start, change.end, change.perc); yield return(null); } }
private IEnumerator MoveTowardsPlacementWithResult(PlacementResult result) { LerpValue<Vector3> move = new LerpValue<Vector3>(paperToPlace.transform.position, placement.transform.position, placeTime, LerpSettings.Cosine); LerpValue<Vector3> popdown = new LerpValue<Vector3>(paperToPlace.transform.localScale, Vector3.one, placeTime); while (move.Continue() && popdown.Continue()) { paperToPlace.transform.position = Vector3.Lerp(move.start, move.end, move.perc); paperToPlace.transform.localScale = Vector3.Lerp(popdown.start, popdown.end, popdown.perc); yield return null; } OnPlacement(result); }
private IEnumerator PopupPaper(float time) { if (time == 0.0f) { yield break; } LerpValue<Vector3> popup = new LerpValue<Vector3>(Vector3.one, popupScale, time); while (popup.Continue()) { paperToPlace.transform.localScale = Vector3.Lerp(popup.start, popup.end, popup.perc); yield return null; } }
private IEnumerator ConveyerBeltAnimation() { SetEnabledStateOfGroceries(false); LerpValue <Vector3> drag = new LerpValue <Vector3>(tfGroceries.position, tfAnimationEnd.position, animationTime); while (drag.Continue()) { tfGroceries.position = Vector3.Lerp(drag.start, drag.end, drag.perc); yield return(null); } MusicPlayer.Instance.PlaySFXSound(SFXSound.PinTransactionStart); SetEnabledStateOfGroceries(true); }
/// <summary>Returns an enumerator that sets up by 2 characters by moving them towards the middle of the screen</summary> private IEnumerator SetupMonologue() { RectTransform rectTransform = (RectTransform)display.transform; float x = -rectTransform.sizeDelta.x; const int HighResWidth = 1920; LerpValue <float> moveToMiddle = new LerpValue <float>(x, (x * 0.5f) + (HighResWidth * 0.5f), setupTime); while (moveToMiddle.Continue()) { Vector3 towardsMiddle = new Vector3(Mathf.Lerp(moveToMiddle.start, moveToMiddle.end, moveToMiddle.perc), 0); rectTransform.anchoredPosition = towardsMiddle; yield return(null); } }
public Scrollbar(IUIStyle style) : base(style) { scrollbarPositionChangedSupport = new EventSupport <EventArgs>(); scrollbarStyle = StyleSystem.StylesFor <ScrollbarStyleDefinition>(); ScrollUnit = 50 / 120f; lerpOffset = new LerpValue(0, 0, 0.5f, AnimationLoop.NoLoop); MouseDragged += OnMouseDragged; MouseWheel += OnMouseWheel; MouseUp += OnMouseUp; MouseDown += OnMouseDown; MouseClicked += OnMouseClick; Thumb = new ScrollbarThumb(UIStyle); }
/// <summary>Shifts this game object and its children towards given new shape over </summary> private IEnumerator ShiftShape(Shape newShape, float time) { shifting = true; LerpValue <Shape> shift = new LerpValue <Shape>(currentShape, newShape, time); Shape output = new Shape(currentShape); while (shift.Continue()) { Shape.Shift(shift.start, shift.end, output, shift.perc).AssignValues(transform); yield return(null); } SetShape(newShape); shifting = false; }
/// <summary> /// Returns an IEnumerator so that a MonoBehavior-derived class /// can run this function as a coroutine. Animates the value /// between startValue and endValue using the lerpValue and applyValue /// delegates. /// </summary> /// <param name="startValue"> /// The value to start at. /// </param> /// <param name="endValue"> /// The value to end at. /// </param> /// <param name="lerpValue"> /// A delegate that lerps the value. /// </param> /// <param name="applyValue"> /// A delegate that does something with the value as it animates. /// </param> /// <returns>An IEnumerator for use in coroutines.</returns> public IEnumerator Animate(T startValue, T endValue, LerpValue lerpValue, ApplyValue applyValue) { float progress = 0f; T value; while (progress < 1f) { value = lerpValue(startValue, endValue, progress); applyValue(value); progress += Time.deltaTime * _speed; yield return(null); } applyValue(endValue); }
/// <summary>Returns an enumerator that eases the slider towards given position</summary> private IEnumerator EaseTowardsPosition(Vector3 position) { isEasing = true; LerpValue <Vector3> ease = new LerpValue <Vector3>(rectTransform.anchoredPosition, position, easeTime); while (ease.Continue()) { rectTransform.anchoredPosition = Vector3.Lerp(ease.start, ease.end, ease.perc); yield return(null); } //save x offset so the user can start sliding from this position offsetX = startX - rectTransform.position.x; isEasing = false; }
/// <summary>Returns an enumerator that toggles the size of the display</summary> private IEnumerator ToggleRoutine(int buttonCount) { isToggling = true; targetWidth = defaultWidth + (EXPAND_PER_BUTTON * buttonCount); float startWidth = hasFocus ? defaultWidth : targetWidth; float endWidth = hasFocus ? targetWidth : defaultWidth; LerpValue <float> changeSize = new LerpValue <float>(startWidth, endWidth, toggleTime); while (changeSize.Continue()) { Vector2 sizeDelta = new Vector2(Mathf.Lerp(changeSize.start, changeSize.end, changeSize.perc), rectTransform.sizeDelta.y); rectTransform.sizeDelta = sizeDelta; yield return(null); } isToggling = false; }
private void Update() { bool duck = Input.GetKeyDown(key); bool stand = Input.GetKeyUp(key); if (duck || stand) { //start new lerp movement when ducking is started on stopped duckOffsetStart = duckTransform.localPosition; move = new LerpValue <Vector3>(duckOffsetStart, duck ? duckOffsetVector : startLocalPosition, duckTime, duckSetting); canDuck = true; } if (!updateInFixedFrames) { Duck(); } }
public override void Start() { randomSource = new Random(); mushroomAnim = new SmoothValue(1f, 0f, 0.3f); mushroomOpacityAnim = new SmoothValue(0f, 1f, 0.3f); logoAnim = new LerpValue(0f, 1f, 0.3f, 0.3f); titleAnim = new SmoothValue(0f, 10f, 3f, 0.1f); mushroomTex = Content.Load <Texture2D>("Sprites/Mushroom"); titleTex = Content.Load <Texture2D>("Sprites/NuclearWinterTitle"); logoTex = Content.Load <Texture2D>("Sprites/NuclearWinterLogo"); sparklinLabsTex = Content.Load <Texture2D>("Sprites/SparklinLabs"); switchTimer = new LerpValue(0f, 1f, 1f, 1.5f); base.Start(); }
/// <summary>Returns a routine that translates the credit card in insertion position</summary> private IEnumerator MoveToPositionRoutine() { LerpValue <Vector3> move = new LerpValue <Vector3>(debitCardTransform.anchoredPosition, insertStart, moveToPositionTime); LerpValue <Vector3> rotate = new LerpValue <Vector3>(Vector3.zero, new Vector3(0, 0, CARD_Z_ANGLE), moveToPositionTime); while (move.Continue() && rotate.Continue()) { debitCardTransform.anchoredPosition = Vector3.Lerp(move.start, move.end, move.perc); debitCardTransform.eulerAngles = Vector3.Lerp(rotate.start, rotate.end, rotate.perc); yield return(null); } SetMask(true); SetOutline(true); SetCardDraggability(true); SetInsertConstrained(true); isInserting = true; }
/// <summary>Returns an Enumerator that toggles the notification screen its state over time</summary> private IEnumerator NotificationScreenToggleEnumerator() { isToggling = true; float startScale = isScreenVisible ? 1.0f : 0.0f; float endScale = isScreenVisible ? 0.0f : 1.0f; isScreenVisible = !isScreenVisible; LerpValue <Vector3> scale = new LerpValue <Vector3>(new Vector3(startScale, startScale), new Vector3(endScale, endScale), toggleTime); while (scale.Continue()) { screenTransform.localScale = Vector3.Lerp(scale.start, scale.end, scale.perc); yield return(null); } isToggling = false; }
/// <summary>Returns an enumerator that sets up by 2 characters by moving them towards the middle of the screen</summary> private IEnumerator SetupDialogue() { RectTransform leftTransform = (RectTransform)leftCharacterDisplay.transform; RectTransform rightTransform = (RectTransform)rightCharacterDisplay.transform; float leftX = -leftTransform.sizeDelta.x; float rightX = rightTransform.sizeDelta.x; LerpValue <float> moveLeftDisplay = new LerpValue <float>(leftX, 0, setupTime); LerpValue <float> moveRightDisplay = new LerpValue <float>(rightX, 0, setupTime); while (moveLeftDisplay.Continue() && moveRightDisplay.Continue()) { Vector3 newLeft = new Vector3(Mathf.Lerp(moveLeftDisplay.start, moveLeftDisplay.end, moveLeftDisplay.perc), 0); leftTransform.anchoredPosition = newLeft; Vector3 newRight = new Vector3(Mathf.Lerp(moveRightDisplay.start, moveRightDisplay.end, moveRightDisplay.perc), 0); rightTransform.anchoredPosition = newRight; yield return(null); } }
private IEnumerator MagnifyEnumerator() { float offsetStretch; float offsetMoveUp; switch (Screen.height) { case 1440: { offsetStretch = Screen.height * 0.25f; offsetMoveUp = Screen.height * 0.01f; } break; default: { offsetStretch = 450; offsetMoveUp = 50; } break; } LerpValue <float> stretch = new LerpValue <float>(0, offsetStretch, 1.1f, LerpSettings.Cosine); LerpValue <float> moveup = new LerpValue <float>(0, offsetMoveUp, 1.1f, LerpSettings.Cosine); while (stretch.Continue() && moveup.Continue()) { Vector2 size = new Vector2(Mathf.Lerp(stretch.start, stretch.end, stretch.perc), Mathf.Lerp(stretch.start, stretch.end, stretch.perc)); documentTransform.sizeDelta = size; Vector2 position = new Vector2(documentTransform.anchoredPosition.x, Mathf.Lerp(moveup.start, moveup.end, moveup.perc)); documentTransform.anchoredPosition = position; yield return(null); } }
/// <summary>Returns an enumerator that either shows or hides the cellphone based on its current state</summary> private IEnumerator ToggleEnumerator() { isToggling = true; Vector3 position = rectTransform.anchoredPosition; float newYPosition = hasFocus ? -rectTransform.sizeDelta.y : 0; LerpValue <float> moveYAxis = new LerpValue <float>(position.y, newYPosition, toggleTime); hasFocus = !hasFocus; if (!hasFocus) { ResetPinLoginPin(); } while (moveYAxis.Continue()) { Vector2 newPosition = new Vector2(position.x, Mathf.Lerp(moveYAxis.start, moveYAxis.end, moveYAxis.perc)); rectTransform.anchoredPosition = newPosition; yield return(null); } isToggling = false; }
private float ChangeSizeDirection(LerpValue _lerpValue) { return((_lerpValue.Current == sizeRange.y) ? sizeRange.x : sizeRange.y); }
protected GameStateFadeTransition(IBatchedDrawingService drawingService) { Transition = new LerpValue(0, 1, TransitionDuration); DrawingService = drawingService ?? throw new ArgumentNullException(nameof(drawingService)); }
private float ChangeMouthAnimationDirection(LerpValue _lerpValue) { return((Mathf.Approximately(_lerpValue.Current, maxMouthAngle)) ? MOUTH_CLOSED_ANGLE : maxMouthAngle); }
public Wind() { lerpSpeed = new LerpValue(changeDuration, () => speed.RandomValue()); lerpSwivel = new LerpValue(changeDuration, () => Random.Range(-swivel, swivel) * 180, true); }