protected override void UpdateState(ArmedState state) { if (!IsLoaded) return; Flush(); UpdateInitialState(); Delay(HitObject.StartTime - Time.Current - TIME_PREEMPT + Judgement.TimeOffset, true); UpdatePreemptState(); Delay(TIME_PREEMPT, true); }
/// <summary> /// Apply transforms based on the current <see cref="ArmedState"/>. Previous states are automatically cleared. /// In the case of a non-idle <see cref="ArmedState"/>, and if <see cref="Drawable.LifetimeEnd"/> was not set during this call, <see cref="Drawable.Expire"/> will be invoked. /// </summary> /// <param name="state">The new armed state.</param> protected virtual void UpdateStateTransforms(ArmedState state) { }
protected override void UpdateState(ArmedState state) { }
protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state) { base.ApplyIncreasedVisibilityState(hitObject, state); applyState(hitObject, true); }
protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyTransform(hitObject, state);
protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) => drawableOnApplyCustomUpdateState(hitObject, state);
protected override void UpdateHitStateTransforms(ArmedState state) { base.UpdateHitStateTransforms(state); Expire(); }
protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) { base.ApplyNormalVisibilityState(hitObject, state); if (!(hitObject is DrawableCatchHitObject catchDrawable)) { return; } if (catchDrawable.NestedHitObjects.Any()) { foreach (var nestedDrawable in catchDrawable.NestedHitObjects) { if (nestedDrawable is DrawableCatchHitObject nestedCatchDrawable) { fadeOutHitObject(nestedCatchDrawable); } } } else { fadeOutHitObject(catchDrawable); } }
protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) { }
protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) { switch (hitObject) { case DrawableDrumRollTick _: case DrawableHit _: double preempt = 10000 / MultiplierAt(hitObject.HitObject.StartTime); double start = hitObject.HitObject.StartTime - preempt * 0.6; double duration = preempt * 0.3; using (hitObject.BeginAbsoluteSequence(start)) { hitObject.FadeOut(duration); // DrawableHitObject sets LifetimeEnd to LatestTransformEndTime if it isn't manually changed. // in order for the object to not be killed before its actual end time (as the latest transform ends earlier), set lifetime end explicitly. hitObject.LifetimeEnd = state == ArmedState.Idle || !hitObject.AllJudged ? hitObject.HitObject.GetEndTime() + hitObject.HitObject.HitWindows.WindowFor(HitResult.Miss) : hitObject.HitStateUpdateTime; } break; } }
protected override void ApplyNormalVisibilityState(DrawableHitObject drawable, ArmedState state) { if (!(drawable is DrawableHitCircle circle)) { return; } double startTime = circle.HitObject.StartTime; double preempt = circle.HitObject.TimePreempt; using (circle.BeginAbsoluteSequence(startTime - preempt)) { // initial state circle.ScaleTo(0.5f) .FadeColour(OsuColour.Gray(0.5f)); // scale to final size circle.ScaleTo(1f, preempt); // Remove approach circles circle.ApproachCircle.Hide(); } using (circle.BeginAbsoluteSequence(startTime - controlPointInfo.TimingPointAt(startTime).BeatLength - undim_duration)) circle.FadeColour(Color4.White, undim_duration); }
private void updateState(DrawableHitObject hitObject, ArmedState state) { if (state == ArmedState.Idle || hitAnimations.Value) { return; } if (hitObject is DrawableHitCircle circle) { using (circle.BeginAbsoluteSequence(circle.HitStateUpdateTime)) { circle.ApproachCircle .FadeOutFromOne(EDITOR_HIT_OBJECT_FADE_OUT_EXTENSION * 4) .Expire(); circle.ApproachCircle.ScaleTo(1.1f, 300, Easing.OutQuint); } } if (hitObject is IHasMainCirclePiece mainPieceContainer) { // clear any explode animation logic. // this is scheduled after children to ensure that the clear happens after invocations of ApplyCustomUpdateState on the circle piece's nested skinnables. ScheduleAfterChildren(() => { if (hitObject.HitObject == null) { return; } mainPieceContainer.CirclePiece.ApplyTransformsAt(hitObject.StateUpdateTime, true); mainPieceContainer.CirclePiece.ClearTransformsAfter(hitObject.StateUpdateTime, true); }); } if (hitObject is DrawableSliderRepeat repeat) { repeat.Arrow.ApplyTransformsAt(hitObject.StateUpdateTime, true); repeat.Arrow.ClearTransformsAfter(hitObject.StateUpdateTime, true); } // adjust the visuals of top-level object types to make them stay on screen for longer than usual. switch (hitObject) { case DrawableSlider _: case DrawableHitCircle _: // Get the existing fade out transform var existing = hitObject.Transforms.LastOrDefault(t => t.TargetMember == nameof(Alpha)); if (existing == null) { return; } hitObject.RemoveTransform(existing); using (hitObject.BeginAbsoluteSequence(hitObject.HitStateUpdateTime)) hitObject.FadeOut(EDITOR_HIT_OBJECT_FADE_OUT_EXTENSION).Expire(); break; } }
[Obsolete("Use ApplyNormalVisibilityState() instead.")] // Can be removed 20210506 protected virtual void ApplyHiddenState(DrawableHitObject hitObject, ArmedState state) { }
[Obsolete("Use ApplyIncreasedVisibilityState() instead.")] // Can be removed 20210506 protected virtual void ApplyFirstObjectIncreaseVisibilityState(DrawableHitObject hitObject, ArmedState state) { }
protected abstract void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state);
protected override void UpdateState(ArmedState state) { base.UpdateState(state); ball.FadeIn(); Delay(HitObject.Duration, true); body.FadeOut(160); ball.FadeOut(160); FadeOut(800); }
protected override void UpdateState(ArmedState state) { // The holdnote keeps scrolling through, so having the tail disappear looks weird }
protected void ApplyHiddenState(DrawableHitObject drawable, ArmedState state) { if (!(drawable is DrawableOsuHitObject d)) { return; } var fadeOutStartTime = d.HitObject.StartTime - preEmpt + d.FadeInDuration; var fadeOutDuration = preEmpt * fade_out_duration_multiplier; // new duration from completed fade in to end (before fading out) var longFadeDuration = ((d.HitObject as IHasEndTime)?.EndTime ?? d.HitObject.StartTime) - fadeOutStartTime; switch (drawable) { case DrawableHitCircle circle: // we don't want to see the approach circle circle.ApproachCircle.Hide(); // fade out immediately after fade in. using (drawable.BeginAbsoluteSequence(fadeOutStartTime, true)) circle.FadeOut(fadeOutDuration); break; case DrawableSlider slider: using (slider.BeginAbsoluteSequence(fadeOutStartTime, true)) { slider.Body.FadeOut(longFadeDuration, Easing.Out); // delay a bit less to let the sliderball fade out peacefully instead of having a hard cut using (slider.BeginDelayedSequence(longFadeDuration - fadeOutDuration, true)) slider.Ball.FadeOut(fadeOutDuration); } break; case DrawableSpinner spinner: // hide elements we don't care about. spinner.Disc.Hide(); spinner.Ticks.Hide(); spinner.Background.Hide(); using (spinner.BeginAbsoluteSequence(fadeOutStartTime + longFadeDuration, true)) { spinner.FadeOut(fadeOutDuration); // speed up the end sequence accordingly switch (state) { case ArmedState.Hit: spinner.ScaleTo(spinner.Scale * 1.2f, fadeOutDuration * 2, Easing.Out); break; case ArmedState.Miss: spinner.ScaleTo(spinner.Scale * 0.8f, fadeOutDuration * 2, Easing.In); break; } spinner.Expire(); } break; } }
protected override void UpdateStateTransforms(ArmedState state) => this.FadeOut(150);
protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state) { }
protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) { if (hitObject is DrawableTilePoint tile) { using (tile.BeginAbsoluteSequence(tile.TilePoint.HitTime - 700)) { tile.FadeOut(300); } } else if (hitObject is DrawableHoldTile hold) { using (hold.BeginAbsoluteSequence(hold.Tile.StartPoint.HitTime - 500)) { hold.FadeOut(300); } } }
protected override void UpdateStateTransforms(ArmedState state) { using (BeginDelayedSequence(HitObject.Duration, true)) base.UpdateStateTransforms(state); }
protected virtual void UpdateCurrentState(ArmedState state) { }
protected abstract void UpdateState(ArmedState state);
protected override void UpdateHitStateTransforms(ArmedState state) { using (BeginAbsoluteSequence(HitObject.StartTime)) this.FadeOutFromOne(150).Expire(); }
protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) { base.ApplyNormalVisibilityState(hitObject, state); applyState(hitObject, false); }
[Obsolete("Use UpdateInitialTransforms()/UpdateStateTransforms() instead")] // can be removed 20200227 protected virtual void UpdateState(ArmedState state) { }
protected override void UpdateStateTransforms(DrawableHitObject drawableHitObject, ArmedState state) { base.UpdateStateTransforms(drawableHitObject, state); if (!(drawableHitObject is DrawableSpinner d)) { return; } Spinner spinner = d.HitObject; using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimePreempt)) this.FadeOut(); using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimeFadeIn / 2)) this.FadeInFromZero(spinner.TimeFadeIn / 2); }
private void onApplyCustomUpdateState(DrawableHitObject drawableHitObject, ArmedState state) => ApplyCustomUpdateState?.Invoke(drawableHitObject, state);
protected abstract void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state);
protected virtual void UpdateStateTransforms(DrawableHitObject drawableHitObject, ArmedState state) { switch (drawableHitObject) { case DrawableSpinner d: double fadeOutLength = Math.Min(400, d.HitObject.Duration); using (BeginAbsoluteSequence(drawableHitObject.HitStateUpdateTime - fadeOutLength, true)) spin.FadeOutFromOne(fadeOutLength); break; case DrawableSpinnerTick d: if (state == ArmedState.Hit) { using (BeginAbsoluteSequence(d.HitStateUpdateTime, true)) spin.FadeOut(300); } break; } }
protected override void UpdateStateTransforms(DrawableHitObject drawableHitObject, ArmedState state) { base.UpdateStateTransforms(drawableHitObject, state); switch (drawableHitObject) { case DrawableSpinner d: Spinner spinner = d.HitObject; using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimePreempt, true)) this.FadeOut(); using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimeFadeIn / 2, true)) this.FadeInFromZero(spinner.TimeFadeIn / 2); using (BeginAbsoluteSequence(spinner.StartTime - spinner.TimePreempt, true)) { fixedMiddle.FadeColour(Color4.White); using (BeginDelayedSequence(spinner.TimePreempt, true)) fixedMiddle.FadeColour(Color4.Red, spinner.Duration); } if (state == ArmedState.Hit) { using (BeginAbsoluteSequence(d.HitStateUpdateTime)) glow.FadeOut(300); } break; case DrawableSpinnerBonusTick _: if (state == ArmedState.Hit) { glow.FlashColour(Color4.White, 200); } break; } }
protected override void UpdateState(ArmedState state) { if (!IsLoaded) return; base.UpdateState(state); ApproachCircle.FadeOut(); glow.FadeOut(400); switch (state) { case ArmedState.Idle: Delay(osuObject.Duration + TIME_PREEMPT); FadeOut(TIME_FADEOUT); break; case ArmedState.Miss: FadeOut(TIME_FADEOUT / 5); break; case ArmedState.Hit: const double flash_in = 40; flash.FadeTo(0.8f, flash_in); flash.Delay(flash_in); flash.FadeOut(100); explode.FadeIn(flash_in); Delay(flash_in, true); //after the flash, we can hide some elements that were behind it ring.FadeOut(); circle.FadeOut(); number.FadeOut(); FadeOut(800); ScaleTo(Scale * 1.5f, 400, EasingTypes.OutQuad); break; } }