h1or4dme8/osu-lazer
1
0
Fork 0
mirror of https://github.com/ppy/osu.git synced 2024-09-21 18:47:27 +08:00
Code Issues Releases Wiki Activity

HitRenderer -> RulesetContainer

Browse Source
This commit is contained in:
Dean Herbert 2017-08-09 13:28:29 +09:00
parent f21b370f4e
commit 723e27353c
32 changed files with 110 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
osu.Desktop.Tests/Visual/TestCaseGamefield.cs
View File

@ -88,25 +88,25 @@ namespace osu.Desktop.Tests.Visual
Clock = new FramedClock(),
Children = new Drawable[]
{
new OsuHitRenderer(new OsuRuleset(new RulesetInfo()), beatmap, false)
new OsuRulesetContainer(new OsuRuleset(new RulesetInfo()), beatmap, false)
{
Scale = new Vector2(0.5f),
Anchor = Anchor.TopLeft,
Origin = Anchor.TopLeft
},
new TaikoHitRenderer(new TaikoRuleset(new RulesetInfo()),beatmap, false)
new TaikoRulesetContainer(new TaikoRuleset(new RulesetInfo()),beatmap, false)
{
Scale = new Vector2(0.5f),
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight
},
new CatchHitRenderer(new CatchRuleset(new RulesetInfo()),beatmap, false)
new CatchRulesetContainer(new CatchRuleset(new RulesetInfo()),beatmap, false)
{
Scale = new Vector2(0.5f),
Anchor = Anchor.BottomLeft,
Origin = Anchor.BottomLeft
},
new ManiaHitRenderer(new ManiaRuleset(new RulesetInfo()),beatmap, false)
new ManiaRulesetContainer(new ManiaRuleset(new RulesetInfo()),beatmap, false)
{
Scale = new Vector2(0.5f),
Anchor = Anchor.BottomRight,

10
osu.Desktop.Tests/Visual/TestCaseScrollingPlayfield.cs
View File

@ -50,15 +50,15 @@ namespace osu.Desktop.Tests.Visual
WorkingBeatmap beatmap = new TestWorkingBeatmap(b);
TestHitRenderer hitRenderer;
Add(hitRenderer = new TestHitRenderer(beatmap, true));
TestRulesetContainer rulesetContainer;
Add(rulesetContainer = new TestRulesetContainer(beatmap, true));
AddStep("Reverse direction", () => hitRenderer.Playfield.Reversed.Value = !hitRenderer.Playfield.Reversed);
AddStep("Reverse direction", () => rulesetContainer.Playfield.Reversed.Value = !rulesetContainer.Playfield.Reversed);
}
private class TestHitRenderer : ScrollingHitRenderer<TestPlayfield, TestHitObject, TestJudgement>
private class TestRulesetContainer : ScrollingRulesetContainer<TestPlayfield, TestHitObject, TestJudgement>
{
public TestHitRenderer(WorkingBeatmap beatmap, bool isForCurrentRuleset)
public TestRulesetContainer(WorkingBeatmap beatmap, bool isForCurrentRuleset)
: base(null, beatmap, isForCurrentRuleset)
{
}

2
osu.Game.Rulesets.Catch/CatchRuleset.cs
View File

@ -18,7 +18,7 @@ namespace osu.Game.Rulesets.Catch
{
public class CatchRuleset : Ruleset
{
public override HitRenderer CreateHitRendererWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new CatchHitRenderer(this, beatmap, isForCurrentRuleset);
public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new CatchRulesetContainer(this, beatmap, isForCurrentRuleset);
public override IEnumerable<Mod> GetModsFor(ModType type)
{

4
osu.Game.Rulesets.Catch/Scoring/CatchScoreProcessor.cs
View File

@ -14,8 +14,8 @@ namespace osu.Game.Rulesets.Catch.Scoring
{
}
public CatchScoreProcessor(HitRenderer<CatchBaseHit, CatchJudgement> hitRenderer)
: base(hitRenderer)
public CatchScoreProcessor(RulesetContainer<CatchBaseHit, CatchJudgement> rulesetContainer)
: base(rulesetContainer)
{
}

4
osu.Game.Rulesets.Catch/UI/CatchHitRenderer.cs → osu.Game.Rulesets.Catch/UI/CatchRulesetContainer.cs
View File

@ -15,9 +15,9 @@ using osu.Game.Rulesets.UI;
namespace osu.Game.Rulesets.Catch.UI
{
public class CatchHitRenderer : ScrollingHitRenderer<CatchPlayfield, CatchBaseHit, CatchJudgement>
public class CatchRulesetContainer : ScrollingRulesetContainer<CatchPlayfield, CatchBaseHit, CatchJudgement>
{
public CatchHitRenderer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
public CatchRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
: base(ruleset, beatmap, isForCurrentRuleset)
{
}

2
osu.Game.Rulesets.Catch/osu.Game.Rulesets.Catch.csproj
View File

@ -60,7 +60,7 @@
<Compile Include="Objects\Fruit.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="UI\CatcherArea.cs" />
<Compile Include="UI\CatchHitRenderer.cs" />
<Compile Include="UI\CatchRulesetContainer.cs" />
<Compile Include="UI\CatchPlayfield.cs" />
<Compile Include="CatchRuleset.cs" />
<Compile Include="Mods\CatchMod.cs" />

2
osu.Game.Rulesets.Mania/ManiaRuleset.cs
View File

@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Mania
{
public class ManiaRuleset : Ruleset
{
public override HitRenderer CreateHitRendererWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new ManiaHitRenderer(this, beatmap, isForCurrentRuleset);
public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new ManiaRulesetContainer(this, beatmap, isForCurrentRuleset);
public override IEnumerable<Mod> GetModsFor(ModType type)
{

4
osu.Game.Rulesets.Mania/Mods/IGenerateSpeedAdjustments.cs
View File

@ -15,9 +15,9 @@ namespace osu.Game.Rulesets.Mania.Mods
/// <summary>
/// Applies this mod to a hit renderer.
/// </summary>
/// <param name="hitRenderer">The hit renderer to apply to.</param>
/// <param name="rulesetContainer">The hit renderer to apply to.</param>
/// <param name="hitObjectTimingChanges">The per-column list of speed adjustments for hit objects.</param>
/// <param name="barlineTimingChanges">The list of speed adjustments for bar lines.</param>
void ApplyToHitRenderer(ManiaHitRenderer hitRenderer, ref List<SpeedAdjustmentContainer>[] hitObjectTimingChanges, ref List<SpeedAdjustmentContainer> barlineTimingChanges);
void ApplyToRulesetContainer(ManiaRulesetContainer rulesetContainer, ref List<SpeedAdjustmentContainer>[] hitObjectTimingChanges, ref List<SpeedAdjustmentContainer> barlineTimingChanges);
}
}

10
osu.Game.Rulesets.Mania/Mods/ManiaModGravity.cs
View File

@ -20,12 +20,12 @@ namespace osu.Game.Rulesets.Mania.Mods
public override FontAwesome Icon => FontAwesome.fa_sort_desc;
public void ApplyToHitRenderer(ManiaHitRenderer hitRenderer, ref List<SpeedAdjustmentContainer>[] hitObjectTimingChanges, ref List<SpeedAdjustmentContainer> barlineTimingChanges)
public void ApplyToRulesetContainer(ManiaRulesetContainer rulesetContainer, ref List<SpeedAdjustmentContainer>[] hitObjectTimingChanges, ref List<SpeedAdjustmentContainer> barlineTimingChanges)
{
// We have to generate one speed adjustment per hit object for gravity
foreach (ManiaHitObject obj in hitRenderer.Objects)
foreach (ManiaHitObject obj in rulesetContainer.Objects)
{
MultiplierControlPoint controlPoint = hitRenderer.CreateControlPointAt(obj.StartTime);
MultiplierControlPoint controlPoint = rulesetContainer.CreateControlPointAt(obj.StartTime);
// Beat length has too large of an effect for gravity, so we'll force it to a constant value for now
controlPoint.TimingPoint.BeatLength = 1000;
@ -33,9 +33,9 @@ namespace osu.Game.Rulesets.Mania.Mods
}
// Like with hit objects, we need to generate one speed adjustment per bar line
foreach (DrawableBarLine barLine in hitRenderer.BarLines)
foreach (DrawableBarLine barLine in rulesetContainer.BarLines)
{
var controlPoint = hitRenderer.CreateControlPointAt(barLine.HitObject.StartTime);
var controlPoint = rulesetContainer.CreateControlPointAt(barLine.HitObject.StartTime);
// Beat length has too large of an effect for gravity, so we'll force it to a constant value for now
controlPoint.TimingPoint.BeatLength = 1000;

4
osu.Game.Rulesets.Mania/Scoring/ManiaScoreProcessor.cs
View File

@ -155,8 +155,8 @@ namespace osu.Game.Rulesets.Mania.Scoring
{
}
public ManiaScoreProcessor(HitRenderer<ManiaHitObject, ManiaJudgement> hitRenderer)
: base(hitRenderer)
public ManiaScoreProcessor(RulesetContainer<ManiaHitObject, ManiaJudgement> rulesetContainer)
: base(rulesetContainer)
{
}

4
osu.Game.Rulesets.Mania/UI/ManiaHitRenderer.cs → osu.Game.Rulesets.Mania/UI/ManiaRulesetContainer.cs
View File

@ -29,7 +29,7 @@ using osu.Game.Rulesets.UI;
namespace osu.Game.Rulesets.Mania.UI
{
public class ManiaHitRenderer : ScrollingHitRenderer<ManiaPlayfield, ManiaHitObject, ManiaJudgement>
public class ManiaRulesetContainer : ScrollingRulesetContainer<ManiaPlayfield, ManiaHitObject, ManiaJudgement>
{
/// <summary>
/// Preferred column count. This will only have an effect during the initialization of the play field.
@ -38,7 +38,7 @@ namespace osu.Game.Rulesets.Mania.UI
public IEnumerable<DrawableBarLine> BarLines;
public ManiaHitRenderer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
public ManiaRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
: base(ruleset, beatmap, isForCurrentRuleset)
{
// Generate the bar lines

2
osu.Game.Rulesets.Mania/osu.Game.Rulesets.Mania.csproj
View File

@ -82,7 +82,7 @@
<Compile Include="Timing\GravityScrollingContainer.cs" />
<Compile Include="Timing\ScrollingAlgorithm.cs" />
<Compile Include="UI\Column.cs" />
<Compile Include="UI\ManiaHitRenderer.cs" />
<Compile Include="UI\ManiaRulesetContainer.cs" />
<Compile Include="UI\ManiaPlayfield.cs" />
<Compile Include="ManiaRuleset.cs" />
<Compile Include="Mods\ManiaMod.cs" />

2
osu.Game.Rulesets.Osu/OsuRuleset.cs
View File

@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Osu
{
public class OsuRuleset : Ruleset
{
public override HitRenderer CreateHitRendererWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new OsuHitRenderer(this, beatmap, isForCurrentRuleset);
public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new OsuRulesetContainer(this, beatmap, isForCurrentRuleset);
public override IEnumerable<BeatmapStatistic> GetBeatmapStatistics(WorkingBeatmap beatmap) => new[]
{

4
osu.Game.Rulesets.Osu/Scoring/OsuScoreProcessor.cs
View File

@ -18,8 +18,8 @@ namespace osu.Game.Rulesets.Osu.Scoring
{
}
public OsuScoreProcessor(HitRenderer<OsuHitObject, OsuJudgement> hitRenderer)
: base(hitRenderer)
public OsuScoreProcessor(RulesetContainer<OsuHitObject, OsuJudgement> rulesetContainer)
: base(rulesetContainer)
{
}

4
osu.Game.Rulesets.Osu/UI/OsuHitRenderer.cs → osu.Game.Rulesets.Osu/UI/OsuRulesetContainer.cs
View File

@ -16,9 +16,9 @@ using osu.Game.Rulesets.UI;
namespace osu.Game.Rulesets.Osu.UI
{
public class OsuHitRenderer : HitRenderer<OsuHitObject, OsuJudgement>
public class OsuRulesetContainer : RulesetContainer<OsuHitObject, OsuJudgement>
{
public OsuHitRenderer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
public OsuRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
: base(ruleset, beatmap, isForCurrentRuleset)
{
}

2
osu.Game.Rulesets.Osu/osu.Game.Rulesets.Osu.csproj
View File

@ -80,7 +80,7 @@
<Compile Include="OsuKeyConversionInputManager.cs" />
<Compile Include="UI\OsuSettings.cs" />
<Compile Include="Scoring\OsuScoreProcessor.cs" />
<Compile Include="UI\OsuHitRenderer.cs" />
<Compile Include="UI\OsuRulesetContainer.cs" />
<Compile Include="UI\OsuPlayfield.cs" />
<Compile Include="OsuRuleset.cs" />
<Compile Include="Objects\HitCircle.cs" />

4
osu.Game.Rulesets.Taiko/Scoring/TaikoScoreProcessor.cs
View File

@ -113,8 +113,8 @@ namespace osu.Game.Rulesets.Taiko.Scoring
{
}
public TaikoScoreProcessor(HitRenderer<TaikoHitObject, TaikoJudgement> hitRenderer)
: base(hitRenderer)
public TaikoScoreProcessor(RulesetContainer<TaikoHitObject, TaikoJudgement> rulesetContainer)
: base(rulesetContainer)
{
}

2
osu.Game.Rulesets.Taiko/TaikoRuleset.cs
View File

@ -18,7 +18,7 @@ namespace osu.Game.Rulesets.Taiko
{
public class TaikoRuleset : Ruleset
{
public override HitRenderer CreateHitRendererWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new TaikoHitRenderer(this, beatmap, isForCurrentRuleset);
public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset) => new TaikoRulesetContainer(this, beatmap, isForCurrentRuleset);
public override IEnumerable<Mod> GetModsFor(ModType type)
{

2
osu.Game.Rulesets.Taiko/UI/TaikoPlayfield.cs
View File

@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Taiko.UI
public class TaikoPlayfield : Playfield<TaikoHitObject, TaikoJudgement>
{
/// <summary>
/// Default height of a <see cref="TaikoPlayfield"/> when inside a <see cref="TaikoHitRenderer"/>.
/// Default height of a <see cref="TaikoPlayfield"/> when inside a <see cref="TaikoRulesetContainer"/>.
/// </summary>
public const float DEFAULT_HEIGHT = 178;

4
osu.Game.Rulesets.Taiko/UI/TaikoHitRenderer.cs → osu.Game.Rulesets.Taiko/UI/TaikoRulesetContainer.cs
View File

@ -21,9 +21,9 @@ using System.Linq;
namespace osu.Game.Rulesets.Taiko.UI
{
public class TaikoHitRenderer : HitRenderer<TaikoHitObject, TaikoJudgement>
public class TaikoRulesetContainer : RulesetContainer<TaikoHitObject, TaikoJudgement>
{
public TaikoHitRenderer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
public TaikoRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
: base(ruleset, beatmap, isForCurrentRuleset)
{
}

2
osu.Game.Rulesets.Taiko/osu.Game.Rulesets.Taiko.csproj
View File

@ -91,7 +91,7 @@
<Compile Include="UI\KiaiHitExplosion.cs" />
<Compile Include="UI\DrawableTaikoJudgement.cs" />
<Compile Include="UI\HitExplosion.cs" />
<Compile Include="UI\TaikoHitRenderer.cs" />
<Compile Include="UI\TaikoRulesetContainer.cs" />
<Compile Include="UI\TaikoPlayfield.cs" />
<Compile Include="TaikoRuleset.cs" />
<Compile Include="Mods\TaikoMod.cs" />

2
osu.Game/Beatmaps/DummyWorkingBeatmap.cs
View File

@ -62,7 +62,7 @@ namespace osu.Game.Beatmaps
public override Mod GetAutoplayMod() => new ModAutoplay();
public override HitRenderer CreateHitRendererWith(WorkingBeatmap beatmap, bool isForCurrentRuleset)
public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset)
{
throw new NotImplementedException();
}

10
osu.Game/Rulesets/Mods/IApplicableMod.cs
View File

@ -7,16 +7,16 @@ using osu.Game.Rulesets.UI;
namespace osu.Game.Rulesets.Mods
{
/// <summary>
/// An interface for mods that are applied to a HitRenderer.
/// An interface for mods that are applied to a RulesetContainer.
/// </summary>
/// <typeparam name="TObject">The type of HitObject the HitRenderer contains.</typeparam>
/// <typeparam name="TObject">The type of HitObject the RulesetContainer contains.</typeparam>
public interface IApplicableMod<TObject>
where TObject : HitObject
{
/// <summary>
/// Applies the mod to a HitRenderer.
/// Applies the mod to a RulesetContainer.
/// </summary>
/// <param name="hitRenderer">The HitRenderer to apply the mod to.</param>
void ApplyToHitRenderer(HitRenderer<TObject> hitRenderer);
/// <param name="rulesetContainer">The RulesetContainer to apply the mod to.</param>
void ApplyToRulesetContainer(RulesetContainer<TObject> rulesetContainer);
}
}

4
osu.Game/Rulesets/Mods/ModAutoplay.cs
View File

@ -15,9 +15,9 @@ namespace osu.Game.Rulesets.Mods
{
protected abstract Score CreateReplayScore(Beatmap<T> beatmap);
public void ApplyToHitRenderer(HitRenderer<T> hitRenderer)
public void ApplyToRulesetContainer(RulesetContainer<T> rulesetContainer)
{
hitRenderer.SetReplay(CreateReplayScore(hitRenderer.Beatmap)?.Replay);
rulesetContainer.SetReplay(CreateReplayScore(rulesetContainer.Beatmap)?.Replay);
}
}

2
osu.Game/Rulesets/Ruleset.cs
View File

@ -35,7 +35,7 @@ namespace osu.Game.Rulesets
/// <param name="isForCurrentRuleset">Whether the hit renderer should assume the beatmap is for the current ruleset.</param>
/// <exception cref="BeatmapInvalidForRulesetException">Unable to successfully load the beatmap to be usable with this ruleset.</exception>
/// <returns></returns>
public abstract HitRenderer CreateHitRendererWith(WorkingBeatmap beatmap, bool isForCurrentRuleset);
public abstract RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap, bool isForCurrentRuleset);
public abstract DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap);

8
osu.Game/Rulesets/Scoring/ScoreProcessor.cs
View File

@ -150,13 +150,13 @@ namespace osu.Game.Rulesets.Scoring
{
}
protected ScoreProcessor(HitRenderer<TObject, TJudgement> hitRenderer)
protected ScoreProcessor(RulesetContainer<TObject, TJudgement> rulesetContainer)
{
Judgements.Capacity = hitRenderer.Beatmap.HitObjects.Count;
Judgements.Capacity = rulesetContainer.Beatmap.HitObjects.Count;
hitRenderer.OnJudgement += AddJudgement;
rulesetContainer.OnJudgement += AddJudgement;
ComputeTargets(hitRenderer.Beatmap);
ComputeTargets(rulesetContainer.Beatmap);
Reset();
}

50
osu.Game/Rulesets/UI/HitRenderer.cs → osu.Game/Rulesets/UI/RulesetContainer.cs
View File

@ -23,12 +23,12 @@ using osu.Game.Rulesets.Beatmaps;
namespace osu.Game.Rulesets.UI
{
/// <summary>
/// Base HitRenderer. Doesn't hold objects.
/// Base RulesetContainer. Doesn't hold objects.
/// <para>
/// Should not be derived - derive <see cref="HitRenderer{TObject, TJudgement}"/> instead.
/// Should not be derived - derive <see cref="RulesetContainer{TObject,TJudgement}"/> instead.
/// </para>
/// </summary>
public abstract class HitRenderer : Container
public abstract class RulesetContainer : Container
{
/// <summary>
/// Invoked when all the judgeable HitObjects have been judged.
@ -41,12 +41,12 @@ namespace osu.Game.Rulesets.UI
public bool AspectAdjust = true;
/// <summary>
/// The input manager for this HitRenderer.
/// The input manager for this RulesetContainer.
/// </summary>
internal readonly PlayerInputManager InputManager = new PlayerInputManager();
/// <summary>
/// The key conversion input manager for this HitRenderer.
/// The key conversion input manager for this RulesetContainer.
/// </summary>
protected readonly PassThroughInputManager KeyConversionInputManager;
@ -73,7 +73,7 @@ namespace osu.Game.Rulesets.UI
/// A visual representation of a <see cref="Rulesets.Ruleset"/>.
/// </summary>
/// <param name="ruleset">The ruleset being repesented.</param>
internal HitRenderer(Ruleset ruleset)
internal RulesetContainer(Ruleset ruleset)
{
Ruleset = ruleset;
KeyConversionInputManager = CreateActionMappingInputManager();
@ -113,14 +113,14 @@ namespace osu.Game.Rulesets.UI
}
/// <summary>
/// HitRenderer that applies conversion to Beatmaps. Does not contain a Playfield
/// RulesetContainer that applies conversion to Beatmaps. Does not contain a Playfield
/// and does not load drawable hit objects.
/// <para>
/// Should not be derived - derive <see cref="HitRenderer{TObject, TJudgement}"/> instead.
/// Should not be derived - derive <see cref="RulesetContainer{TObject,TJudgement}"/> instead.
/// </para>
/// </summary>
/// <typeparam name="TObject">The type of HitObject contained by this HitRenderer.</typeparam>
public abstract class HitRenderer<TObject> : HitRenderer
/// <typeparam name="TObject">The type of HitObject contained by this RulesetContainer.</typeparam>
public abstract class RulesetContainer<TObject> : RulesetContainer
where TObject : HitObject
{
/// <summary>
@ -144,9 +144,9 @@ namespace osu.Game.Rulesets.UI
/// <param name="ruleset">The ruleset being repesented.</param>
/// <param name="beatmap">The beatmap to create the hit renderer for.</param>
/// <param name="isForCurrentRuleset">Whether to assume the beatmap is for the current ruleset.</param>
internal HitRenderer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset) : base(ruleset)
internal RulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset) : base(ruleset)
{
Debug.Assert(beatmap != null, "HitRenderer initialized with a null beatmap.");
Debug.Assert(beatmap != null, "RulesetContainer initialized with a null beatmap.");
Mods = beatmap.Mods.Value;
@ -180,7 +180,7 @@ namespace osu.Game.Rulesets.UI
}
/// <summary>
/// Applies the active mods to this HitRenderer.
/// Applies the active mods to this RulesetContainer.
/// </summary>
/// <param name="mods"></param>
private void applyMods(IEnumerable<Mod> mods)
@ -189,7 +189,7 @@ namespace osu.Game.Rulesets.UI
return;
foreach (var mod in mods.OfType<IApplicableMod<TObject>>())
mod.ApplyToHitRenderer(this);
mod.ApplyToRulesetContainer(this);
}
/// <summary>
@ -212,11 +212,11 @@ namespace osu.Game.Rulesets.UI
}
/// <summary>
/// A derivable HitRenderer that manages the Playfield and HitObjects.
/// A derivable RulesetContainer that manages the Playfield and HitObjects.
/// </summary>
/// <typeparam name="TObject">The type of HitObject contained by this HitRenderer.</typeparam>
/// <typeparam name="TJudgement">The type of Judgement of DrawableHitObjects contained by this HitRenderer.</typeparam>
public abstract class HitRenderer<TObject, TJudgement> : HitRenderer<TObject>
/// <typeparam name="TObject">The type of HitObject contained by this RulesetContainer.</typeparam>
/// <typeparam name="TJudgement">The type of Judgement of DrawableHitObjects contained by this RulesetContainer.</typeparam>
public abstract class RulesetContainer<TObject, TJudgement> : RulesetContainer<TObject>
where TObject : HitObject
where TJudgement : Judgement
{
@ -247,7 +247,7 @@ namespace osu.Game.Rulesets.UI
/// <param name="ruleset">The ruleset being repesented.</param>
/// <param name="beatmap">The beatmap to create the hit renderer for.</param>
/// <param name="isForCurrentRuleset">Whether to assume the beatmap is for the current ruleset.</param>
protected HitRenderer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
protected RulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
: base(ruleset, beatmap, isForCurrentRuleset)
{
InputManager.Add(content = new Container
@ -334,12 +334,12 @@ namespace osu.Game.Rulesets.UI
}
/// <summary>
/// A derivable HitRenderer that manages the Playfield and HitObjects.
/// A derivable RulesetContainer that manages the Playfield and HitObjects.
/// </summary>
/// <typeparam name="TPlayfield">The type of Playfield contained by this HitRenderer.</typeparam>
/// <typeparam name="TObject">The type of HitObject contained by this HitRenderer.</typeparam>
/// <typeparam name="TJudgement">The type of Judgement of DrawableHitObjects contained by this HitRenderer.</typeparam>
public abstract class HitRenderer<TPlayfield, TObject, TJudgement> : HitRenderer<TObject, TJudgement>
/// <typeparam name="TPlayfield">The type of Playfield contained by this RulesetContainer.</typeparam>
/// <typeparam name="TObject">The type of HitObject contained by this RulesetContainer.</typeparam>
/// <typeparam name="TJudgement">The type of Judgement of DrawableHitObjects contained by this RulesetContainer.</typeparam>
public abstract class RulesetContainer<TPlayfield, TObject, TJudgement> : RulesetContainer<TObject, TJudgement>
where TObject : HitObject
where TJudgement : Judgement
where TPlayfield : Playfield<TObject, TJudgement>
@ -355,7 +355,7 @@ namespace osu.Game.Rulesets.UI
/// <param name="ruleset">The ruleset being repesented.</param>
/// <param name="beatmap">The beatmap to create the hit renderer for.</param>
/// <param name="isForCurrentRuleset">Whether to assume the beatmap is for the current ruleset.</param>
protected HitRenderer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
protected RulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
: base(ruleset, beatmap, isForCurrentRuleset)
{
}

10
osu.Game/Rulesets/UI/ScrollingHitRenderer.cs → osu.Game/Rulesets/UI/ScrollingRulesetContainer.cs
View File

@ -17,22 +17,22 @@ using osu.Game.Rulesets.Timing;
namespace osu.Game.Rulesets.UI
{
/// <summary>
/// A type of <see cref="HitRenderer{TPlayfield, TObject, TJudgement}"/> that supports a <see cref="ScrollingPlayfield{TObject, TJudgement}"/>.
/// <see cref="HitObject"/>s inside this <see cref="HitRenderer{TPlayfield, TObject, TJudgement}"/> will scroll within the playfield.
/// A type of <see cref="RulesetContainer{TPlayfield,TObject,TJudgement}"/> that supports a <see cref="ScrollingPlayfield{TObject, TJudgement}"/>.
/// <see cref="HitObject"/>s inside this <see cref="RulesetContainer{TPlayfield,TObject,TJudgement}"/> will scroll within the playfield.
/// </summary>
public abstract class ScrollingHitRenderer<TPlayfield, TObject, TJudgement> : HitRenderer<TPlayfield, TObject, TJudgement>
public abstract class ScrollingRulesetContainer<TPlayfield, TObject, TJudgement> : RulesetContainer<TPlayfield, TObject, TJudgement>
where TObject : HitObject
where TJudgement : Judgement
where TPlayfield : ScrollingPlayfield<TObject, TJudgement>
{
/// <summary>
/// Provides the default <see cref="MultiplierControlPoint"/>s that adjust the scrolling rate of <see cref="HitObject"/>s
/// inside this <see cref="HitRenderer{TPlayfield, TObject, TJudgement}"/>.
/// inside this <see cref="RulesetContainer{TPlayfield,TObject,TJudgement}"/>.
/// </summary>
/// <returns></returns>
protected readonly SortedList<MultiplierControlPoint> DefaultControlPoints = new SortedList<MultiplierControlPoint>(Comparer<MultiplierControlPoint>.Default);
protected ScrollingHitRenderer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
protected ScrollingRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
: base(ruleset, beatmap, isForCurrentRuleset)
{
}

6
osu.Game/Screens/Play/HUDOverlay.cs
View File

@ -90,11 +90,11 @@ namespace osu.Game.Screens.Play
}
}
public virtual void BindHitRenderer(HitRenderer hitRenderer)
public virtual void BindRulesetContainer(RulesetContainer rulesetContainer)
{
hitRenderer.InputManager.Add(KeyCounter.GetReceptor());
rulesetContainer.InputManager.Add(KeyCounter.GetReceptor());
replayLoaded = hitRenderer.HasReplayLoaded;
replayLoaded = rulesetContainer.HasReplayLoaded;
// in the case a replay isn't loaded, we want some elements to only appear briefly.
if (!replayLoaded)

40
osu.Game/Screens/Play/Player.cs
View File

@ -32,7 +32,7 @@ namespace osu.Game.Screens.Play
internal override bool ShowOverlays => false;
internal override bool HasLocalCursorDisplayed => !pauseContainer.IsPaused && !HasFailed && HitRenderer.ProvidingUserCursor;
internal override bool HasLocalCursorDisplayed => !pauseContainer.IsPaused && !HasFailed && RulesetContainer.ProvidingUserCursor;
public Action RestartRequested;
@ -51,7 +51,7 @@ namespace osu.Game.Screens.Play
private RulesetInfo ruleset;
private ScoreProcessor scoreProcessor;
protected HitRenderer HitRenderer;
protected RulesetContainer RulesetContainer;
#region User Settings
@ -66,7 +66,7 @@ namespace osu.Game.Screens.Play
private HUDOverlay hudOverlay;
private FailOverlay failOverlay;
private bool loadedSuccessfully => HitRenderer?.Objects.Any() == true;
private bool loadedSuccessfully => RulesetContainer?.Objects.Any() == true;
[BackgroundDependencyLoader(permitNulls: true)]
private void load(AudioManager audio, OsuConfigManager config, OsuGame osu)
@ -93,18 +93,18 @@ namespace osu.Game.Screens.Play
try
{
HitRenderer = rulesetInstance.CreateHitRendererWith(working, ruleset.ID == beatmap.BeatmapInfo.Ruleset.ID);
RulesetContainer = rulesetInstance.CreateRulesetContainerWith(working, ruleset.ID == beatmap.BeatmapInfo.Ruleset.ID);
}
catch (BeatmapInvalidForRulesetException)
{
// we may fail to create a HitRenderer if the beatmap cannot be loaded with the user's preferred ruleset
// we may fail to create a RulesetContainer if the beatmap cannot be loaded with the user's preferred ruleset
// let's try again forcing the beatmap's ruleset.
ruleset = beatmap.BeatmapInfo.Ruleset;
rulesetInstance = ruleset.CreateInstance();
HitRenderer = rulesetInstance.CreateHitRendererWith(Beatmap, true);
RulesetContainer = rulesetInstance.CreateRulesetContainerWith(Beatmap, true);
}
if (!HitRenderer.Objects.Any())
if (!RulesetContainer.Objects.Any())
throw new InvalidOperationException("Beatmap contains no hit objects!");
}
catch (Exception e)
@ -119,7 +119,7 @@ namespace osu.Game.Screens.Play
adjustableSourceClock = (IAdjustableClock)working.Track ?? new StopwatchClock();
decoupledClock = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
var firstObjectTime = HitRenderer.Objects.First().StartTime;
var firstObjectTime = RulesetContainer.Objects.First().StartTime;
decoupledClock.Seek(Math.Min(0, firstObjectTime - Math.Max(beatmap.ControlPointInfo.TimingPointAt(firstObjectTime).BeatLength * 4, beatmap.BeatmapInfo.AudioLeadIn)));
decoupledClock.ProcessFrame();
@ -147,7 +147,7 @@ namespace osu.Game.Screens.Play
FramedClock = offsetClock,
OnRetry = Restart,
OnQuit = Exit,
CheckCanPause = () => ValidForResume && !HasFailed && !HitRenderer.HasReplayLoaded,
CheckCanPause = () => ValidForResume && !HasFailed && !RulesetContainer.HasReplayLoaded,
Retries = RestartCount,
OnPause = () => {
hudOverlay.KeyCounter.IsCounting = pauseContainer.IsPaused;
@ -164,7 +164,7 @@ namespace osu.Game.Screens.Play
Clock = offsetClock,
Children = new Drawable[]
{
HitRenderer,
RulesetContainer,
}
},
hudOverlay = new HUDOverlay
@ -184,27 +184,27 @@ namespace osu.Game.Screens.Play
Action = () => {
//we want to hide the hitrenderer immediately (looks better).
//we may be able to remove this once the mouse cursor trail is improved.
HitRenderer?.Hide();
RulesetContainer?.Hide();
Restart();
},
}
};
scoreProcessor = HitRenderer.CreateScoreProcessor();
scoreProcessor = RulesetContainer.CreateScoreProcessor();
hudOverlay.KeyCounter.AddRange(rulesetInstance.CreateGameplayKeys());
hudOverlay.BindProcessor(scoreProcessor);
hudOverlay.BindHitRenderer(HitRenderer);
hudOverlay.BindRulesetContainer(RulesetContainer);
hudOverlay.Progress.Objects = HitRenderer.Objects;
hudOverlay.Progress.Objects = RulesetContainer.Objects;
hudOverlay.Progress.AudioClock = decoupledClock;
hudOverlay.Progress.AllowSeeking = HitRenderer.HasReplayLoaded;
hudOverlay.Progress.AllowSeeking = RulesetContainer.HasReplayLoaded;
hudOverlay.Progress.OnSeek = pos => decoupledClock.Seek(pos);
hudOverlay.ModDisplay.Current.BindTo(working.Mods);
//bind HitRenderer to ScoreProcessor and ourselves (for a pass situation)
HitRenderer.OnAllJudged += onCompletion;
//bind RulesetContainer to ScoreProcessor and ourselves (for a pass situation)
RulesetContainer.OnAllJudged += onCompletion;
//bind ScoreProcessor to ourselves (for a fail situation)
scoreProcessor.Failed += onFail;
@ -238,7 +238,7 @@ namespace osu.Game.Screens.Play
Ruleset = ruleset
};
scoreProcessor.PopulateScore(score);
score.User = HitRenderer.Replay?.User ?? (Game as OsuGame)?.API?.LocalUser?.Value;
score.User = RulesetContainer.Replay?.User ?? (Game as OsuGame)?.API?.LocalUser?.Value;
Push(new Results(score));
});
}
@ -295,7 +295,7 @@ namespace osu.Game.Screens.Play
protected override bool OnExiting(Screen next)
{
if (HasFailed || !ValidForResume || pauseContainer?.AllowExit != false || HitRenderer?.HasReplayLoaded != false)
if (HasFailed || !ValidForResume || pauseContainer?.AllowExit != false || RulesetContainer?.HasReplayLoaded != false)
{
fadeOut();
return base.OnExiting(next);
@ -313,7 +313,7 @@ namespace osu.Game.Screens.Play
{
const float fade_out_duration = 250;
HitRenderer?.FadeOut(fade_out_duration);
RulesetContainer?.FadeOut(fade_out_duration);
Content.FadeOut(fade_out_duration);
hudOverlay?.ScaleTo(0.7f, fade_out_duration * 3, Easing.In);

2
osu.Game/Screens/Play/ReplayPlayer.cs
View File

@ -17,7 +17,7 @@ namespace osu.Game.Screens.Play
protected override void LoadComplete()
{
base.LoadComplete();
HitRenderer.SetReplay(Replay);
RulesetContainer.SetReplay(Replay);
}
}
}

4
osu.Game/osu.Game.csproj
View File

@ -338,9 +338,9 @@
<Compile Include="Screens\Select\Options\BeatmapOptionsOverlay.cs" />
<Compile Include="Screens\Select\PlaySongSelect.cs" />
<Compile Include="Screens\Select\SongSelect.cs" />
<Compile Include="Rulesets\UI\HitRenderer.cs" />
<Compile Include="Rulesets\UI\RulesetContainer.cs" />
<Compile Include="Rulesets\UI\Playfield.cs" />
<Compile Include="Rulesets\UI\ScrollingHitRenderer.cs" />
<Compile Include="Rulesets\UI\ScrollingRulesetContainer.cs" />
<Compile Include="Rulesets\UI\ScrollingPlayfield.cs" />
<Compile Include="Screens\Select\EditSongSelect.cs" />
<Compile Include="Screens\Play\HUD\ComboCounter.cs" />