2019-01-24 16:43:03 +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
using System ;
using System.Collections.Generic ;
using System.Linq ;
2019-10-21 16:56:39 +08:00
using JetBrains.Annotations ;
2018-04-13 17:19:50 +08:00
using osu.Framework.Allocation ;
2019-02-21 18:04:31 +08:00
using osu.Framework.Bindables ;
2018-08-06 10:07:05 +08:00
using osu.Framework.Extensions.TypeExtensions ;
2019-08-28 17:12:47 +08:00
using osu.Framework.Graphics ;
2018-09-12 14:09:10 +08:00
using osu.Framework.Graphics.Primitives ;
2020-10-01 11:28:33 +08:00
using osu.Framework.Logging ;
2019-09-02 14:02:16 +08:00
using osu.Framework.Threading ;
2018-04-13 17:19:50 +08:00
using osu.Game.Audio ;
using osu.Game.Rulesets.Judgements ;
using osu.Game.Rulesets.Objects.Types ;
using osu.Game.Rulesets.Scoring ;
using osu.Game.Skinning ;
2020-04-10 00:12:15 +08:00
using osu.Game.Configuration ;
2018-11-20 15:51:59 +08:00
using osuTK.Graphics ;
2018-04-13 17:19:50 +08:00
namespace osu.Game.Rulesets.Objects.Drawables
{
2019-07-19 18:12:41 +08:00
[Cached(typeof(DrawableHitObject))]
2019-07-22 13:45:25 +08:00
public abstract class DrawableHitObject : SkinReloadableDrawable
2018-04-13 17:19:50 +08:00
{
2020-05-08 17:49:58 +08:00
public event Action < DrawableHitObject > DefaultsApplied ;
2018-04-13 17:19:50 +08:00
public readonly HitObject HitObject ;
/// <summary>
/// The colour used for various elements of this DrawableHitObject.
/// </summary>
2019-07-22 13:45:25 +08:00
public readonly Bindable < Color4 > AccentColour = new Bindable < Color4 > ( Color4 . Gray ) ;
2018-04-13 17:19:50 +08:00
2020-09-30 14:45:14 +08:00
protected PausableSkinnableSound Samples { get ; private set ; }
2018-04-13 17:19:50 +08:00
2020-05-19 22:28:13 +08:00
public virtual IEnumerable < HitSampleInfo > GetSamples ( ) = > HitObject . Samples ;
2018-04-13 17:19:50 +08:00
private readonly Lazy < List < DrawableHitObject > > nestedHitObjects = new Lazy < List < DrawableHitObject > > ( ) ;
2019-10-16 21:10:50 +08:00
public IReadOnlyList < DrawableHitObject > NestedHitObjects = > nestedHitObjects . IsValueCreated ? nestedHitObjects . Value : ( IReadOnlyList < DrawableHitObject > ) Array . Empty < DrawableHitObject > ( ) ;
2018-04-13 17:19:50 +08:00
2020-03-29 13:30:45 +08:00
/// <summary>
/// Whether this object should handle any user input events.
/// </summary>
public bool HandleUserInput { get ; set ; } = true ;
public override bool PropagatePositionalInputSubTree = > HandleUserInput ;
public override bool PropagateNonPositionalInputSubTree = > HandleUserInput ;
2018-08-06 09:54:16 +08:00
/// <summary>
2020-10-01 20:54:43 +08:00
/// Invoked by this or a nested <see cref="DrawableHitObject"/> after a <see cref="JudgementResult"/> has been applied.
2018-08-06 09:54:16 +08:00
/// </summary>
public event Action < DrawableHitObject , JudgementResult > OnNewResult ;
/// <summary>
2020-10-01 20:54:43 +08:00
/// Invoked by this or a nested <see cref="DrawableHitObject"/> prior to a <see cref="JudgementResult"/> being reverted.
2018-08-06 09:54:16 +08:00
/// </summary>
2018-08-06 11:29:22 +08:00
public event Action < DrawableHitObject , JudgementResult > OnRevertResult ;
2018-04-13 17:19:50 +08:00
/// <summary>
2018-08-06 10:31:54 +08:00
/// Whether a visual indicator should be displayed when a scoring result occurs.
2018-04-13 17:19:50 +08:00
/// </summary>
2018-08-06 10:31:46 +08:00
public virtual bool DisplayResult = > true ;
2018-04-13 17:19:50 +08:00
/// <summary>
2018-08-03 15:07:20 +08:00
/// Whether this <see cref="DrawableHitObject"/> and all of its nested <see cref="DrawableHitObject"/>s have been judged.
2018-04-13 17:19:50 +08:00
/// </summary>
2018-08-03 15:07:20 +08:00
public bool AllJudged = > Judged & & NestedHitObjects . All ( h = > h . AllJudged ) ;
2018-04-13 17:19:50 +08:00
/// <summary>
2019-04-25 16:36:17 +08:00
/// Whether this <see cref="DrawableHitObject"/> has been hit. This occurs if <see cref="Result"/> is hit.
2018-08-03 15:07:20 +08:00
/// Note: This does NOT include nested hitobjects.
2018-04-13 17:19:50 +08:00
/// </summary>
2018-08-03 15:07:20 +08:00
public bool IsHit = > Result ? . IsHit ? ? false ;
2018-04-13 17:19:50 +08:00
/// <summary>
2018-08-01 20:04:03 +08:00
/// Whether this <see cref="DrawableHitObject"/> has been judged.
/// Note: This does NOT include nested hitobjects.
2018-04-13 17:19:50 +08:00
/// </summary>
2018-08-03 14:38:48 +08:00
public bool Judged = > Result ? . HasResult ? ? true ;
2018-08-02 19:35:54 +08:00
2018-08-06 09:55:38 +08:00
/// <summary>
/// The scoring result of this <see cref="DrawableHitObject"/>.
/// </summary>
2018-08-06 10:07:05 +08:00
public JudgementResult Result { get ; private set ; }
2018-08-02 20:07:31 +08:00
2020-04-10 00:12:15 +08:00
/// <summary>
2020-04-13 12:00:03 +08:00
/// The relative X position of this hit object for sample playback balance adjustment.
2020-04-10 00:12:15 +08:00
/// </summary>
2020-04-13 12:00:03 +08:00
/// <remarks>
/// This is a range of 0..1 (0 for far-left, 0.5 for centre, 1 for far-right).
/// Dampening is post-applied to ensure the effect is not too intense.
/// </remarks>
protected virtual float SamplePlaybackPosition = > 0.5f ;
2020-04-12 07:33:25 +08:00
2019-11-08 13:59:47 +08:00
private BindableList < HitSampleInfo > samplesBindable ;
2019-10-18 12:18:41 +08:00
private Bindable < double > startTimeBindable ;
2020-04-10 00:12:15 +08:00
private Bindable < bool > userPositionalHitSounds ;
2019-09-26 16:04:38 +08:00
private Bindable < int > comboIndexBindable ;
2018-04-13 17:19:50 +08:00
public override bool RemoveWhenNotAlive = > false ;
public override bool RemoveCompletedTransforms = > false ;
protected override bool RequiresChildrenUpdate = > true ;
2019-07-23 20:08:41 +08:00
public override bool IsPresent = > base . IsPresent | | ( State . Value = = ArmedState . Idle & & Clock ? . CurrentTime > = LifetimeStart ) ;
2018-04-13 17:19:50 +08:00
2019-07-22 14:05:56 +08:00
private readonly Bindable < ArmedState > state = new Bindable < ArmedState > ( ) ;
2019-07-23 20:08:41 +08:00
public IBindable < ArmedState > State = > state ;
2019-10-21 16:56:39 +08:00
protected DrawableHitObject ( [ NotNull ] HitObject hitObject )
2018-04-13 17:19:50 +08:00
{
2019-10-21 16:56:39 +08:00
HitObject = hitObject ? ? throw new ArgumentNullException ( nameof ( hitObject ) ) ;
2018-04-13 17:19:50 +08:00
}
[BackgroundDependencyLoader]
2020-04-10 00:12:15 +08:00
private void load ( OsuConfigManager config )
2018-04-13 17:19:50 +08:00
{
2020-04-12 07:33:25 +08:00
userPositionalHitSounds = config . GetBindable < bool > ( OsuSetting . PositionalHitSounds ) ;
2018-08-06 10:50:18 +08:00
var judgement = HitObject . CreateJudgement ( ) ;
2019-04-01 11:16:05 +08:00
2020-02-23 13:30:08 +08:00
Result = CreateResult ( judgement ) ;
if ( Result = = null )
throw new InvalidOperationException ( $"{GetType().ReadableName()} must provide a {nameof(JudgementResult)} through {nameof(CreateResult)}." ) ;
2018-08-06 10:07:05 +08:00
2020-09-24 12:28:29 +08:00
LoadSamples ( ) ;
2018-04-13 17:19:50 +08:00
}
2020-07-24 17:16:36 +08:00
protected override void LoadAsyncComplete ( )
2018-04-13 17:19:50 +08:00
{
2020-07-24 17:16:36 +08:00
base . LoadAsyncComplete ( ) ;
2019-09-26 16:04:38 +08:00
2019-10-18 12:18:41 +08:00
HitObject . DefaultsApplied + = onDefaultsApplied ;
startTimeBindable = HitObject . StartTimeBindable . GetBoundCopy ( ) ;
2020-02-12 18:02:25 +08:00
startTimeBindable . BindValueChanged ( _ = > updateState ( State . Value , true ) ) ;
2019-10-16 21:10:50 +08:00
2019-09-26 16:04:38 +08:00
if ( HitObject is IHasComboInformation combo )
{
comboIndexBindable = combo . ComboIndexBindable . GetBoundCopy ( ) ;
2020-02-19 14:05:04 +08:00
comboIndexBindable . BindValueChanged ( _ = > updateComboColour ( ) , true ) ;
2019-09-26 16:04:38 +08:00
}
2019-11-08 13:59:47 +08:00
samplesBindable = HitObject . SamplesBindable . GetBoundCopy ( ) ;
2020-09-24 12:28:29 +08:00
samplesBindable . CollectionChanged + = ( _ , __ ) = > LoadSamples ( ) ;
2019-11-08 13:59:47 +08:00
2020-05-08 17:49:19 +08:00
apply ( HitObject ) ;
2020-07-24 17:16:36 +08:00
}
protected override void LoadComplete ( )
{
base . LoadComplete ( ) ;
2020-07-15 15:53:27 +08:00
updateState ( ArmedState . Idle , true ) ;
2019-07-22 14:05:56 +08:00
}
2020-09-23 17:09:40 +08:00
/// <summary>
2020-09-23 17:12:07 +08:00
/// Invoked by the base <see cref="DrawableHitObject"/> to populate samples, once on initial load and potentially again on any change to the samples collection.
2020-09-23 17:09:40 +08:00
/// </summary>
2020-09-24 12:28:29 +08:00
protected virtual void LoadSamples ( )
2019-11-08 13:59:47 +08:00
{
2019-11-08 15:19:55 +08:00
if ( Samples ! = null )
{
RemoveInternal ( Samples ) ;
Samples = null ;
}
2019-11-08 13:59:47 +08:00
var samples = GetSamples ( ) . ToArray ( ) ;
if ( samples . Length < = 0 )
return ;
if ( HitObject . SampleControlPoint = = null )
2019-11-12 12:41:54 +08:00
{
2019-11-28 22:21:21 +08:00
throw new InvalidOperationException ( $"{nameof(HitObject)}s must always have an attached {nameof(HitObject.SampleControlPoint)}."
+ $" This is an indication that {nameof(HitObject.ApplyDefaults)} has not been invoked on {this}." ) ;
2019-11-12 12:41:54 +08:00
}
2019-11-08 13:59:47 +08:00
2020-09-30 14:45:14 +08:00
Samples = new PausableSkinnableSound ( samples . Select ( s = > HitObject . SampleControlPoint . ApplyTo ( s ) ) ) ;
2020-04-12 07:33:25 +08:00
AddInternal ( Samples ) ;
2019-11-08 13:59:47 +08:00
}
2020-05-08 17:49:19 +08:00
private void onDefaultsApplied ( HitObject hitObject )
{
apply ( hitObject ) ;
2020-09-25 17:26:54 +08:00
updateState ( state . Value , true ) ;
2020-05-08 17:49:58 +08:00
DefaultsApplied ? . Invoke ( this ) ;
2020-05-08 17:49:19 +08:00
}
2019-10-18 12:18:41 +08:00
private void apply ( HitObject hitObject )
2019-10-16 21:10:50 +08:00
{
if ( nestedHitObjects . IsValueCreated )
{
nestedHitObjects . Value . Clear ( ) ;
2019-10-17 12:52:21 +08:00
ClearNestedHitObjects ( ) ;
2019-10-16 21:10:50 +08:00
}
foreach ( var h in hitObject . NestedHitObjects )
{
2019-10-17 12:52:21 +08:00
var drawableNested = CreateNestedHitObject ( h ) ? ? throw new InvalidOperationException ( $"{nameof(CreateNestedHitObject)} returned null for {h.GetType().ReadableName()}." ) ;
2020-04-22 17:32:59 +08:00
drawableNested . OnNewResult + = ( d , r ) = > OnNewResult ? . Invoke ( d , r ) ;
drawableNested . OnRevertResult + = ( d , r ) = > OnRevertResult ? . Invoke ( d , r ) ;
drawableNested . ApplyCustomUpdateState + = ( d , j ) = > ApplyCustomUpdateState ? . Invoke ( d , j ) ;
nestedHitObjects . Value . Add ( drawableNested ) ;
2019-10-17 12:52:21 +08:00
AddNestedHitObject ( drawableNested ) ;
2019-10-16 21:10:50 +08:00
}
}
2019-10-17 12:52:21 +08:00
/// <summary>
/// Invoked by the base <see cref="DrawableHitObject"/> to add nested <see cref="DrawableHitObject"/>s to the hierarchy.
/// </summary>
/// <param name="hitObject">The <see cref="DrawableHitObject"/> to be added.</param>
protected virtual void AddNestedHitObject ( DrawableHitObject hitObject )
2019-10-16 21:10:50 +08:00
{
}
2019-10-17 12:52:21 +08:00
/// <summary>
/// Invoked by the base <see cref="DrawableHitObject"/> to remove all previously-added nested <see cref="DrawableHitObject"/>s.
/// </summary>
protected virtual void ClearNestedHitObjects ( )
{
}
/// <summary>
/// Creates the drawable representation for a nested <see cref="HitObject"/>.
/// </summary>
/// <param name="hitObject">The <see cref="HitObject"/>.</param>
/// <returns>The drawable representation for <paramref name="hitObject"/>.</returns>
protected virtual DrawableHitObject CreateNestedHitObject ( HitObject hitObject ) = > null ;
2019-10-16 21:10:50 +08:00
2019-07-22 14:33:12 +08:00
#region State / Transform Management
2019-07-22 15:08:38 +08:00
/// <summary>
2020-10-01 20:54:43 +08:00
/// Invoked by this or a nested <see cref="DrawableHitObject"/> to apply a custom state that can override the default implementation.
2019-07-22 15:08:38 +08:00
/// </summary>
public event Action < DrawableHitObject , ArmedState > ApplyCustomUpdateState ;
2019-07-22 14:33:12 +08:00
protected override void ClearInternal ( bool disposeChildren = true ) = > throw new InvalidOperationException ( $"Should never clear a {nameof(DrawableHitObject)}" ) ;
2019-07-23 20:08:41 +08:00
private void updateState ( ArmedState newState , bool force = false )
2019-07-22 14:05:56 +08:00
{
2019-07-23 20:08:41 +08:00
if ( State . Value = = newState & & ! force )
return ;
2020-02-27 10:28:29 +08:00
LifetimeEnd = double . MaxValue ;
2019-09-07 13:44:44 +08:00
2020-02-27 10:28:29 +08:00
double transformTime = HitObject . StartTime - InitialLifetimeOffset ;
2019-07-22 14:05:56 +08:00
2020-02-27 10:28:29 +08:00
base . ApplyTransformsAt ( double . MinValue , true ) ;
base . ClearTransformsAfter ( double . MinValue , true ) ;
2019-07-22 14:05:56 +08:00
2020-02-27 10:28:29 +08:00
using ( BeginAbsoluteSequence ( transformTime , true ) )
{
UpdateInitialTransforms ( ) ;
2018-04-13 17:19:50 +08:00
2020-02-27 10:28:29 +08:00
var judgementOffset = Result ? . TimeOffset ? ? 0 ;
2019-07-22 14:05:56 +08:00
2020-02-27 10:28:29 +08:00
using ( BeginDelayedSequence ( InitialLifetimeOffset + judgementOffset , true ) )
{
UpdateStateTransforms ( newState ) ;
state . Value = newState ;
2019-07-22 14:05:56 +08:00
}
}
2020-05-22 11:45:37 +08:00
if ( LifetimeEnd = = double . MaxValue & & ( state . Value ! = ArmedState . Idle | | HitObject . HitWindows = = null ) )
2020-02-27 10:28:29 +08:00
Expire ( ) ;
2019-07-27 05:22:40 +08:00
// apply any custom state overrides
ApplyCustomUpdateState ? . Invoke ( this , newState ) ;
2020-10-07 17:18:01 +08:00
if ( ! force & & newState = = ArmedState . Hit )
2019-07-27 05:22:40 +08:00
PlaySamples ( ) ;
2018-04-13 17:19:50 +08:00
}
2019-07-22 15:08:38 +08:00
/// <summary>
2019-07-23 20:15:55 +08:00
/// Apply (generally fade-in) transforms leading into the <see cref="HitObject"/> start time.
2019-07-22 15:08:38 +08:00
/// The local drawable hierarchy is recursively delayed to <see cref="LifetimeStart"/> for convenience.
2019-08-28 17:12:47 +08:00
///
/// By default this will fade in the object from zero with no duration.
2019-07-22 15:08:38 +08:00
/// </summary>
/// <remarks>
/// This is called once before every <see cref="UpdateStateTransforms"/>. This is to ensure a good state in the case
/// the <see cref="JudgementResult.TimeOffset"/> was negative and potentially altered the pre-hit transforms.
/// </remarks>
2019-07-22 14:33:12 +08:00
protected virtual void UpdateInitialTransforms ( )
2019-07-22 14:05:56 +08:00
{
2019-08-28 17:12:47 +08:00
this . FadeInFromZero ( ) ;
2019-07-22 14:05:56 +08:00
}
2019-07-22 15:08:38 +08:00
/// <summary>
/// Apply transforms based on the current <see cref="ArmedState"/>. Previous states are automatically cleared.
2019-09-12 18:29:08 +08:00
/// 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.
2019-07-22 15:08:38 +08:00
/// </summary>
/// <param name="state">The new armed state.</param>
2019-07-22 14:33:12 +08:00
protected virtual void UpdateStateTransforms ( ArmedState state )
2019-07-22 14:05:56 +08:00
{
}
public override void ClearTransformsAfter ( double time , bool propagateChildren = false , string targetMember = null )
{
2020-02-27 10:28:29 +08:00
// Parent calls to this should be blocked for safety, as we are manually handling this in updateState.
2019-07-22 14:05:56 +08:00
}
public override void ApplyTransformsAt ( double time , bool propagateChildren = false )
{
2020-02-27 10:28:29 +08:00
// Parent calls to this should be blocked for safety, as we are manually handling this in updateState.
2019-07-22 14:05:56 +08:00
}
2019-07-22 14:33:12 +08:00
#endregion
2019-09-18 19:19:57 +08:00
protected sealed override void SkinChanged ( ISkinSource skin , bool allowFallback )
2019-07-22 14:33:12 +08:00
{
base . SkinChanged ( skin , allowFallback ) ;
2020-02-19 14:05:04 +08:00
updateComboColour ( ) ;
2019-09-18 19:19:57 +08:00
ApplySkin ( skin , allowFallback ) ;
2019-09-19 13:15:06 +08:00
if ( IsLoaded )
updateState ( State . Value , true ) ;
2019-09-18 19:19:57 +08:00
}
2020-02-19 14:05:04 +08:00
private void updateComboColour ( )
2019-09-26 16:04:38 +08:00
{
2020-02-20 14:14:40 +08:00
if ( ! ( HitObject is IHasComboInformation ) ) return ;
var comboColours = CurrentSkin . GetConfig < GlobalSkinColours , IReadOnlyList < Color4 > > ( GlobalSkinColours . ComboColours ) ? . Value ;
AccentColour . Value = GetComboColour ( comboColours ) ;
2019-09-26 16:04:38 +08:00
}
2020-02-19 14:05:04 +08:00
/// <summary>
2020-02-20 14:14:40 +08:00
/// Called to retrieve the combo colour. Automatically assigned to <see cref="AccentColour"/>.
/// Defaults to using <see cref="IHasComboInformation.ComboIndex"/> to decide on a colour.
2020-02-19 14:05:04 +08:00
/// </summary>
2020-02-20 14:14:40 +08:00
/// <remarks>
/// This will only be called if the <see cref="HitObject"/> implements <see cref="IHasComboInformation"/>.
/// </remarks>
2020-02-19 14:05:04 +08:00
/// <param name="comboColours">A list of combo colours provided by the beatmap or skin. Can be null if not available.</param>
2020-02-20 14:14:40 +08:00
protected virtual Color4 GetComboColour ( IReadOnlyList < Color4 > comboColours )
2020-02-19 14:05:04 +08:00
{
2020-02-20 14:14:40 +08:00
if ( ! ( HitObject is IHasComboInformation combo ) )
throw new InvalidOperationException ( $"{nameof(HitObject)} must implement {nameof(IHasComboInformation)}" ) ;
return comboColours ? . Count > 0 ? comboColours [ combo . ComboIndex % comboColours . Count ] : Color4 . White ;
2020-02-19 14:05:04 +08:00
}
2019-09-18 19:19:57 +08:00
/// <summary>
/// Called when a change is made to the skin.
/// </summary>
/// <param name="skin">The new skin.</param>
/// <param name="allowFallback">Whether fallback to default skin should be allowed if the custom skin is missing this resource.</param>
protected virtual void ApplySkin ( ISkinSource skin , bool allowFallback )
{
2019-07-22 14:33:12 +08:00
}
2020-07-22 15:37:24 +08:00
/// <summary>
/// Calculate the position to be used for sample playback at a specified X position (0..1).
/// </summary>
/// <param name="position">The lookup X position. Generally should be <see cref="SamplePlaybackPosition"/>.</param>
/// <returns></returns>
protected double CalculateSamplePlaybackBalance ( double position )
{
const float balance_adjust_amount = 0.4f ;
return balance_adjust_amount * ( userPositionalHitSounds . Value ? position - 0.5f : 0 ) ;
}
2018-04-13 17:19:50 +08:00
/// <summary>
2018-09-15 22:30:11 +08:00
/// Plays all the hit sounds for this <see cref="DrawableHitObject"/>.
2018-12-03 16:21:27 +08:00
/// This is invoked automatically when this <see cref="DrawableHitObject"/> is hit.
2018-04-13 17:19:50 +08:00
/// </summary>
2020-04-10 06:01:35 +08:00
public virtual void PlaySamples ( )
{
2020-09-29 11:45:20 +08:00
if ( Samples ! = null )
2020-05-20 19:49:01 +08:00
{
2020-07-22 15:37:24 +08:00
Samples . Balance . Value = CalculateSamplePlaybackBalance ( SamplePlaybackPosition ) ;
2020-05-20 19:49:01 +08:00
Samples . Play ( ) ;
}
2020-04-10 06:01:35 +08:00
}
2018-04-13 17:19:50 +08:00
2020-09-29 14:07:55 +08:00
/// <summary>
2020-10-05 15:24:02 +08:00
/// Stops playback of all relevant samples. Generally only looping samples should be stopped by this, and the rest let to play out.
/// Automatically called when <see cref="DrawableHitObject{TObject}"/>'s lifetime has been exceeded.
2020-09-29 14:07:55 +08:00
/// </summary>
2020-10-05 15:24:02 +08:00
public virtual void StopAllSamples ( )
2020-10-05 14:07:46 +08:00
{
if ( Samples ? . Looping = = true )
Samples . Stop ( ) ;
2020-10-05 14:12:34 +08:00
}
2020-09-29 14:07:55 +08:00
2018-04-13 17:19:50 +08:00
protected override void Update ( )
{
base . Update ( ) ;
2018-08-14 17:31:32 +08:00
if ( Result ! = null & & Result . HasResult )
2018-04-13 17:19:50 +08:00
{
2019-11-25 18:01:24 +08:00
var endTime = HitObject . GetEndTime ( ) ;
2018-04-13 17:19:50 +08:00
2018-08-14 17:31:32 +08:00
if ( Result . TimeOffset + endTime > Time . Current )
2018-08-01 20:04:03 +08:00
{
2018-08-06 11:29:22 +08:00
OnRevertResult ? . Invoke ( this , Result ) ;
2018-08-01 20:04:03 +08:00
2019-06-13 13:55:52 +08:00
Result . TimeOffset = 0 ;
2018-08-03 14:38:48 +08:00
Result . Type = HitResult . None ;
2019-07-23 20:08:41 +08:00
updateState ( ArmedState . Idle ) ;
2018-08-01 20:04:03 +08:00
}
2018-04-13 17:19:50 +08:00
}
}
2020-04-20 19:48:35 +08:00
public override bool UpdateSubTreeMasking ( Drawable source , RectangleF maskingBounds ) = > false ;
2018-09-12 14:09:10 +08:00
2018-04-13 17:19:50 +08:00
protected override void UpdateAfterChildren ( )
{
base . UpdateAfterChildren ( ) ;
2018-08-06 10:31:46 +08:00
UpdateResult ( false ) ;
2018-04-13 17:19:50 +08:00
}
2019-09-02 14:02:16 +08:00
/// <summary>
/// Schedules an <see cref="Action"/> to this <see cref="DrawableHitObject"/>.
/// </summary>
/// <remarks>
/// Only provided temporarily until hitobject pooling is implemented.
/// </remarks>
protected internal new ScheduledDelegate Schedule ( Action action ) = > base . Schedule ( action ) ;
2019-07-16 12:45:59 +08:00
private double? lifetimeStart ;
public override double LifetimeStart
{
get = > lifetimeStart ? ? ( HitObject . StartTime - InitialLifetimeOffset ) ;
set
{
lifetimeStart = value ;
2019-09-24 15:47:34 +08:00
base . LifetimeStart = value ;
2019-07-16 12:45:59 +08:00
}
}
/// <summary>
/// A safe offset prior to the start time of <see cref="HitObject"/> at which this <see cref="DrawableHitObject"/> may begin displaying contents.
/// By default, <see cref="DrawableHitObject"/>s are assumed to display their contents within 10 seconds prior to the start time of <see cref="HitObject"/>.
/// </summary>
/// <remarks>
/// This is only used as an optimisation to delay the initial update of this <see cref="DrawableHitObject"/> and may be tuned more aggressively if required.
2019-07-22 15:08:38 +08:00
/// It is indirectly used to decide the automatic transform offset provided to <see cref="UpdateInitialTransforms"/>.
2019-09-12 18:30:27 +08:00
/// A more accurate <see cref="LifetimeStart"/> should be set for further optimisation (in <see cref="LoadComplete"/>, for example).
2019-07-16 12:45:59 +08:00
/// </remarks>
protected virtual double InitialLifetimeOffset = > 10000 ;
/// <summary>
2019-07-16 17:19:13 +08:00
/// Will be called at least once after this <see cref="DrawableHitObject"/> has become not alive.
2019-07-16 12:45:59 +08:00
/// </summary>
2019-07-16 17:19:13 +08:00
public virtual void OnKilled ( )
2019-07-16 12:45:59 +08:00
{
foreach ( var nested in NestedHitObjects )
2019-07-16 17:19:13 +08:00
nested . OnKilled ( ) ;
2020-10-05 14:07:46 +08:00
// failsafe to ensure looping samples don't get stuck in a playing state.
// this could occur in a non-frame-stable context where DrawableHitObjects get killed before a SkinnableSound has the chance to be stopped.
2020-10-05 15:24:02 +08:00
StopAllSamples ( ) ;
2020-09-29 14:07:55 +08:00
2019-07-16 12:45:59 +08:00
UpdateResult ( false ) ;
}
2018-04-13 17:19:50 +08:00
/// <summary>
2018-08-06 09:55:38 +08:00
/// Applies the <see cref="Result"/> of this <see cref="DrawableHitObject"/>, notifying responders such as
/// the <see cref="ScoreProcessor"/> of the <see cref="JudgementResult"/>.
2018-04-13 17:19:50 +08:00
/// </summary>
2018-08-06 09:55:38 +08:00
/// <param name="application">The callback that applies changes to the <see cref="JudgementResult"/>.</param>
2018-08-03 14:38:48 +08:00
protected void ApplyResult ( Action < JudgementResult > application )
2018-04-13 17:19:50 +08:00
{
2020-10-01 20:33:54 +08:00
if ( Result . HasResult )
2020-10-01 20:48:45 +08:00
throw new InvalidOperationException ( "Cannot apply result on a hitobject that already has a result." ) ;
2020-10-01 20:33:54 +08:00
2018-08-03 14:38:48 +08:00
application ? . Invoke ( Result ) ;
2018-08-02 19:35:54 +08:00
2018-08-06 10:07:05 +08:00
if ( ! Result . HasResult )
throw new InvalidOperationException ( $"{GetType().ReadableName()} applied a {nameof(JudgementResult)} but did not update {nameof(JudgementResult.Type)}." ) ;
2020-09-29 14:14:03 +08:00
// Some (especially older) rulesets use scorable judgements instead of the newer ignorehit/ignoremiss judgements.
2020-10-01 11:28:33 +08:00
// Can be removed 20210328
2020-09-29 14:14:03 +08:00
if ( Result . Judgement . MaxResult = = HitResult . IgnoreHit )
{
2020-10-01 11:28:33 +08:00
HitResult originalType = Result . Type ;
2020-09-29 14:14:03 +08:00
if ( Result . Type = = HitResult . Miss )
Result . Type = HitResult . IgnoreMiss ;
else if ( Result . Type > = HitResult . Meh & & Result . Type < = HitResult . Perfect )
Result . Type = HitResult . IgnoreHit ;
2020-10-01 11:28:33 +08:00
if ( Result . Type ! = originalType )
{
Logger . Log ( $"{GetType().ReadableName()} applied an invalid hit result ({originalType}) when {nameof(HitResult.IgnoreMiss)} or {nameof(HitResult.IgnoreHit)} is expected.\n"
+ $"This has been automatically adjusted to {Result.Type}, and support will be removed from 2020-03-28 onwards." , level : LogLevel . Important ) ;
}
2020-09-29 14:14:03 +08:00
}
if ( ! Result . Type . IsValidHitResult ( Result . Judgement . MinResult , Result . Judgement . MaxResult ) )
{
throw new InvalidOperationException (
$"{GetType().ReadableName()} applied an invalid hit result (was: {Result.Type}, expected: [{Result.Judgement.MinResult} ... {Result.Judgement.MaxResult}])." ) ;
}
2018-04-13 17:19:50 +08:00
// Ensure that the judgement is given a valid time offset, because this may not get set by the caller
2019-11-25 18:01:24 +08:00
var endTime = HitObject . GetEndTime ( ) ;
2019-10-09 18:08:55 +08:00
Result . TimeOffset = Math . Min ( HitObject . HitWindows . WindowFor ( HitResult . Miss ) , Time . Current - endTime ) ;
2018-04-13 17:19:50 +08:00
2020-10-03 14:09:10 +08:00
if ( Result . HasResult )
updateState ( Result . IsHit ? ArmedState . Hit : ArmedState . Miss ) ;
2018-04-13 17:19:50 +08:00
2018-08-06 09:54:16 +08:00
OnNewResult ? . Invoke ( this , Result ) ;
2018-04-13 17:19:50 +08:00
}
/// <summary>
2018-08-06 10:31:54 +08:00
/// Processes this <see cref="DrawableHitObject"/>, checking if a scoring result has occurred.
2018-04-13 17:19:50 +08:00
/// </summary>
/// <param name="userTriggered">Whether the user triggered this process.</param>
2018-08-06 10:31:54 +08:00
/// <returns>Whether a scoring result has occurred from this <see cref="DrawableHitObject"/> or any nested <see cref="DrawableHitObject"/>.</returns>
2018-08-06 10:31:46 +08:00
protected bool UpdateResult ( bool userTriggered )
2018-04-13 17:19:50 +08:00
{
2019-06-13 11:21:49 +08:00
// It's possible for input to get into a bad state when rewinding gameplay, so results should not be processed
if ( Time . Elapsed < 0 )
return false ;
2019-09-04 17:14:55 +08:00
if ( Judged )
2018-04-13 17:19:50 +08:00
return false ;
2019-11-25 18:01:24 +08:00
var endTime = HitObject . GetEndTime ( ) ;
2018-08-06 10:31:46 +08:00
CheckForResult ( userTriggered , Time . Current - endTime ) ;
2018-04-13 17:19:50 +08:00
2019-09-04 17:14:55 +08:00
return Judged ;
2018-04-13 17:19:50 +08:00
}
/// <summary>
2018-08-06 10:31:54 +08:00
/// Checks if a scoring result has occurred for this <see cref="DrawableHitObject"/>.
2018-04-13 17:19:50 +08:00
/// </summary>
2018-08-06 10:31:54 +08:00
/// <remarks>
/// If a scoring result has occurred, this method must invoke <see cref="ApplyResult"/> to update the result and notify responders.
/// </remarks>
2018-04-13 17:19:50 +08:00
/// <param name="userTriggered">Whether the user triggered this check.</param>
2018-08-06 10:31:54 +08:00
/// <param name="timeOffset">The offset from the end time of the <see cref="HitObject"/> at which this check occurred.
/// A <paramref name="timeOffset"/> > 0 implies that this check occurred after the end time of the <see cref="HitObject"/>. </param>
2018-08-06 10:31:46 +08:00
protected virtual void CheckForResult ( bool userTriggered , double timeOffset )
2018-04-13 17:19:50 +08:00
{
}
2018-08-02 19:35:54 +08:00
2018-08-06 09:55:38 +08:00
/// <summary>
/// Creates the <see cref="JudgementResult"/> that represents the scoring result for this <see cref="DrawableHitObject"/>.
/// </summary>
/// <param name="judgement">The <see cref="Judgement"/> that provides the scoring information.</param>
2019-09-02 16:14:40 +08:00
protected virtual JudgementResult CreateResult ( Judgement judgement ) = > new JudgementResult ( HitObject , judgement ) ;
2019-10-18 12:18:41 +08:00
protected override void Dispose ( bool isDisposing )
{
base . Dispose ( isDisposing ) ;
HitObject . DefaultsApplied - = onDefaultsApplied ;
}
2018-04-13 17:19:50 +08:00
}
public abstract class DrawableHitObject < TObject > : DrawableHitObject
where TObject : HitObject
{
public new readonly TObject HitObject ;
protected DrawableHitObject ( TObject hitObject )
: base ( hitObject )
{
HitObject = hitObject ;
}
}
}