1
0
mirror of https://github.com/ppy/osu.git synced 2024-11-18 15:32:55 +08:00
osu-lazer/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderBall.cs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

202 lines
8.0 KiB
C#
Raw Normal View History

2020-02-02 21:34:06 +08:00
// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
2018-04-13 17:19:50 +08:00
2022-06-17 15:37:17 +08:00
#nullable disable
2019-01-21 09:57:14 +08:00
using System;
using System.Collections.Generic;
using System.Linq;
using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Input;
2018-10-02 11:02:47 +08:00
using osu.Framework.Input.Events;
using osu.Game.Rulesets.Objects.Drawables;
using osu.Game.Rulesets.Objects.Types;
using osu.Game.Rulesets.Osu.Skinning.Default;
using osu.Game.Skinning;
2018-11-20 15:51:59 +08:00
using osuTK;
2018-04-13 17:19:50 +08:00
namespace osu.Game.Rulesets.Osu.Objects.Drawables
{
public class DrawableSliderBall : CircularContainer, ISliderProgress, IRequireHighFrequencyMousePosition
{
public const float FOLLOW_AREA = 2.4f;
2019-01-21 09:57:14 +08:00
public Func<OsuAction?> GetInitialHitAction;
private Drawable followCircleReceptor;
private DrawableSlider drawableSlider;
private Drawable ball;
2018-04-13 17:19:50 +08:00
[BackgroundDependencyLoader]
private void load(DrawableHitObject drawableSlider)
{
this.drawableSlider = (DrawableSlider)drawableSlider;
Origin = Anchor.Centre;
2018-04-13 17:19:50 +08:00
Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
Children = new[]
{
new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.SliderFollowCircle), _ => new DefaultFollowCircle())
{
Origin = Anchor.Centre,
Anchor = Anchor.Centre,
RelativeSizeAxes = Axes.Both,
},
followCircleReceptor = new CircularContainer
2022-06-21 17:09:23 +08:00
{
Origin = Anchor.Centre,
Anchor = Anchor.Centre,
RelativeSizeAxes = Axes.Both,
Masking = true
},
ball = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.SliderBall), _ => new DefaultSliderBall())
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
},
};
}
2018-04-13 17:19:50 +08:00
private Vector2? lastScreenSpaceMousePosition;
2018-04-13 17:19:50 +08:00
2018-10-02 11:02:47 +08:00
protected override bool OnMouseMove(MouseMoveEvent e)
{
lastScreenSpaceMousePosition = e.ScreenSpaceMousePosition;
2018-10-02 11:02:47 +08:00
return base.OnMouseMove(e);
}
2018-04-13 17:19:50 +08:00
2018-01-03 20:55:24 +08:00
public override void ClearTransformsAfter(double time, bool propagateChildren = false, string targetMember = null)
{
// Consider the case of rewinding - children's transforms are handled internally, so propagating down
// any further will cause weirdness with the Tracking bool below. Let's not propagate further at this point.
base.ClearTransformsAfter(time, false, targetMember);
}
2018-04-13 17:19:50 +08:00
public override void ApplyTransformsAt(double time, bool propagateChildren = false)
{
// For the same reasons as above w.r.t rewinding, we shouldn't propagate to children here either.
// ReSharper disable once RedundantArgumentDefaultValue
base.ApplyTransformsAt(time, false);
}
2017-03-07 09:59:19 +08:00
private bool tracking;
2018-07-31 15:13:52 +08:00
2016-12-08 18:54:22 +08:00
public bool Tracking
{
get => tracking;
private set
{
if (value == tracking)
return;
tracking = value;
2018-04-13 17:19:50 +08:00
followCircleReceptor.Scale = new Vector2(tracking ? FOLLOW_AREA : 1f);
}
}
2018-04-13 17:19:50 +08:00
2019-01-21 09:57:14 +08:00
/// <summary>
2019-01-21 14:46:49 +08:00
/// If the cursor moves out of the ball's radius we still need to be able to receive positional updates to stop tracking.
2019-01-21 09:57:14 +08:00
/// </summary>
2019-01-21 14:46:49 +08:00
public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
/// <summary>
/// The point in time after which we can accept any key for tracking. Before this time, we may need to restrict tracking to the key used to hit the head circle.
///
/// This is a requirement to stop the case where a player holds down one key (from before the slider) and taps the second key while maintaining full scoring (tracking) of sliders.
/// Visually, this special case can be seen below (time increasing from left to right):
2019-01-21 14:46:49 +08:00
///
/// Z Z+X Z
/// o========o
///
/// Without this logic, tracking would continue through the entire slider even though no key hold action is directly attributing to it.
///
/// In all other cases, no special handling is required (either key being pressed is allowable as valid tracking).
2019-01-21 14:46:49 +08:00
///
/// The reason for storing this as a time value (rather than a bool) is to correctly handle rewind scenarios.
2019-01-21 14:46:49 +08:00
/// </summary>
private double? timeToAcceptAnyKeyAfter;
2018-04-13 17:19:50 +08:00
/// <summary>
/// The actions that were pressed in the previous frame.
/// </summary>
private readonly List<OsuAction> lastPressedActions = new List<OsuAction>();
protected override void Update()
{
base.Update();
2018-04-13 17:19:50 +08:00
2019-01-21 14:46:49 +08:00
// from the point at which the head circle is hit, this will be non-null.
// it may be null if the head circle was missed.
var headCircleHitAction = GetInitialHitAction();
2019-01-21 09:57:14 +08:00
2019-01-21 14:46:49 +08:00
if (headCircleHitAction == null)
timeToAcceptAnyKeyAfter = null;
2019-01-21 09:57:14 +08:00
var actions = drawableSlider.OsuActionInputManager?.PressedActions;
2019-01-21 14:46:49 +08:00
// if the head circle was hit with a specific key, tracking should only occur while that key is pressed.
if (headCircleHitAction != null && timeToAcceptAnyKeyAfter == null)
2019-01-21 09:57:14 +08:00
{
var otherKey = headCircleHitAction == OsuAction.RightButton ? OsuAction.LeftButton : OsuAction.RightButton;
// we can start accepting any key once all other keys have been released in the previous frame.
if (!lastPressedActions.Contains(otherKey))
timeToAcceptAnyKeyAfter = Time.Current;
}
Tracking =
// in valid time range
Time.Current >= drawableSlider.HitObject.StartTime && Time.Current < drawableSlider.HitObject.EndTime &&
// in valid position range
lastScreenSpaceMousePosition.HasValue && followCircleReceptor.ReceivePositionalInputAt(lastScreenSpaceMousePosition.Value) &&
// valid action
(actions?.Any(isValidTrackingAction) ?? false);
lastPressedActions.Clear();
2021-04-26 14:35:08 +08:00
if (actions != null)
lastPressedActions.AddRange(actions);
}
2018-04-13 17:19:50 +08:00
2019-01-21 14:46:49 +08:00
/// <summary>
/// Check whether a given user input is a valid tracking action.
/// </summary>
private bool isValidTrackingAction(OsuAction action)
{
bool headCircleHit = GetInitialHitAction().HasValue;
// if the head circle was hit, we may not yet be allowed to accept any key, so we must use the initial hit action.
if (headCircleHit && (!timeToAcceptAnyKeyAfter.HasValue || Time.Current <= timeToAcceptAnyKeyAfter.Value))
return action == GetInitialHitAction();
return action == OsuAction.LeftButton || action == OsuAction.RightButton;
}
2019-08-19 18:52:53 +08:00
private Vector2? lastPosition;
private bool rewinding;
public void UpdateProgress(double completionProgress)
{
Position = drawableSlider.HitObject.CurvePositionAt(completionProgress);
2019-08-19 18:52:53 +08:00
var diff = lastPosition.HasValue ? lastPosition.Value - Position : Position - drawableSlider.HitObject.CurvePositionAt(completionProgress + 0.01f);
if (Clock.ElapsedFrameTime != 0)
rewinding = Clock.ElapsedFrameTime < 0;
// Ensure the value is substantially high enough to allow for Atan2 to get a valid angle.
if (diff.LengthFast < 0.01f)
return;
2019-08-19 18:52:53 +08:00
ball.Rotation = -90 + (float)(-Math.Atan2(diff.X, diff.Y) * 180 / Math.PI) + (rewinding ? 180 : 0);
lastPosition = Position;
}
}
}