1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-25 04:12:53 +08:00
osu-lazer/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableTaikoHitObject.cs

182 lines
5.9 KiB
C#
Raw Normal View History

// 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 osu.Framework.Graphics;
using osu.Framework.Input.Bindings;
using osu.Game.Rulesets.Objects.Drawables;
2018-11-20 15:51:59 +08:00
using osuTK;
2018-04-13 17:19:50 +08:00
using System.Linq;
using osu.Game.Audio;
using System.Collections.Generic;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Primitives;
using osu.Game.Rulesets.Objects;
using osu.Game.Skinning;
2018-04-13 17:19:50 +08:00
namespace osu.Game.Rulesets.Taiko.Objects.Drawables
{
public abstract class DrawableTaikoHitObject : DrawableHitObject<TaikoHitObject>, IKeyBindingHandler<TaikoAction>
{
protected readonly Container Content;
2018-06-17 16:56:46 +08:00
private readonly Container proxiedContent;
private readonly Container nonProxiedContent;
protected DrawableTaikoHitObject(TaikoHitObject hitObject)
: base(hitObject)
{
AddRangeInternal(new[]
{
nonProxiedContent = new Container
{
RelativeSizeAxes = Axes.Both,
Child = Content = new Container { RelativeSizeAxes = Axes.Both }
},
proxiedContent = new ProxiedContentContainer { RelativeSizeAxes = Axes.Both }
});
}
/// <summary>
2018-06-17 16:56:46 +08:00
/// <see cref="proxiedContent"/> is proxied into an upper layer. We don't want to get masked away otherwise <see cref="proxiedContent"/> would too.
/// </summary>
protected override bool ComputeIsMaskedAway(RectangleF maskingBounds) => false;
2018-06-17 23:27:18 +08:00
private bool isProxied;
/// <summary>
/// Moves <see cref="Content"/> to a layer proxied above the playfield.
2020-04-15 12:00:38 +08:00
/// Does nothing if content is already proxied.
/// </summary>
protected void ProxyContent()
{
2018-06-17 23:27:18 +08:00
if (isProxied) return;
2019-02-28 12:31:40 +08:00
2018-06-17 23:27:18 +08:00
isProxied = true;
nonProxiedContent.Remove(Content);
2018-06-17 16:56:46 +08:00
proxiedContent.Add(Content);
}
/// <summary>
/// Moves <see cref="Content"/> to the normal hitobject layer.
2018-06-17 23:27:18 +08:00
/// Does nothing is content is not currently proxied.
/// </summary>
protected void UnproxyContent()
{
2018-06-17 23:27:18 +08:00
if (!isProxied) return;
2019-02-28 12:31:40 +08:00
2018-06-17 23:27:18 +08:00
isProxied = false;
2018-06-17 16:56:46 +08:00
proxiedContent.Remove(Content);
nonProxiedContent.Add(Content);
}
2018-06-17 16:56:46 +08:00
/// <summary>
/// Creates a proxy for the content of this <see cref="DrawableTaikoHitObject"/>.
/// </summary>
public Drawable CreateProxiedContent() => proxiedContent.CreateProxy();
public abstract bool OnPressed(TaikoAction action);
public virtual void OnReleased(TaikoAction action)
{
}
public override double LifetimeStart
{
get => base.LifetimeStart;
set
{
base.LifetimeStart = value;
proxiedContent.LifetimeStart = value;
}
}
public override double LifetimeEnd
{
get => base.LifetimeEnd;
set
{
base.LifetimeEnd = value;
proxiedContent.LifetimeEnd = value;
}
}
private class ProxiedContentContainer : Container
{
public override bool RemoveWhenNotAlive => false;
}
}
public abstract class DrawableTaikoHitObject<TObject> : DrawableTaikoHitObject
where TObject : TaikoHitObject
2018-04-13 17:19:50 +08:00
{
public override Vector2 OriginPosition => new Vector2(DrawHeight / 2);
public new TObject HitObject;
2018-04-13 17:19:50 +08:00
protected readonly Vector2 BaseSize;
protected readonly SkinnableDrawable MainPiece;
2018-04-13 17:19:50 +08:00
private readonly Container<DrawableStrongNestedHit> strongHitContainer;
2018-04-13 17:19:50 +08:00
protected DrawableTaikoHitObject(TObject hitObject)
2018-04-13 17:19:50 +08:00
: base(hitObject)
{
HitObject = hitObject;
Anchor = Anchor.CentreLeft;
Origin = Anchor.Custom;
RelativeSizeAxes = Axes.Both;
Size = BaseSize = new Vector2(HitObject.IsStrong ? TaikoHitObject.DEFAULT_STRONG_SIZE : TaikoHitObject.DEFAULT_SIZE);
Content.Add(MainPiece = CreateMainPiece());
AddInternal(strongHitContainer = new Container<DrawableStrongNestedHit>());
}
protected override void AddNestedHitObject(DrawableHitObject hitObject)
{
base.AddNestedHitObject(hitObject);
2019-04-01 11:16:05 +08:00
2019-10-17 11:53:54 +08:00
switch (hitObject)
{
case DrawableStrongNestedHit strong:
strongHitContainer.Add(strong);
break;
}
}
protected override void ClearNestedHitObjects()
{
base.ClearNestedHitObjects();
strongHitContainer.Clear();
}
2018-08-14 13:29:49 +08:00
protected override DrawableHitObject CreateNestedHitObject(HitObject hitObject)
{
switch (hitObject)
{
case StrongHitObject strong:
return CreateStrongHit(strong);
}
return base.CreateNestedHitObject(hitObject);
2018-04-13 17:19:50 +08:00
}
// Normal and clap samples are handled by the drum
2019-06-30 20:58:30 +08:00
protected override IEnumerable<HitSampleInfo> GetSamples() => HitObject.Samples.Where(s => s.Name != HitSampleInfo.HIT_NORMAL && s.Name != HitSampleInfo.HIT_CLAP);
2018-04-13 17:19:50 +08:00
protected abstract SkinnableDrawable CreateMainPiece();
2018-08-03 15:56:46 +08:00
/// <summary>
/// Creates the handler for this <see cref="DrawableHitObject"/>'s <see cref="StrongHitObject"/>.
/// This is only invoked if <see cref="TaikoHitObject.IsStrong"/> is true for <see cref="HitObject"/>.
/// </summary>
/// <param name="hitObject">The strong hitobject.</param>
/// <returns>The strong hitobject handler.</returns>
protected virtual DrawableStrongNestedHit CreateStrongHit(StrongHitObject hitObject) => null;
2018-04-13 17:19:50 +08:00
}
}