// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence. // See the LICENCE file in the repository root for full licence text. using System; using System.Collections.Generic; using System.Linq; using osu.Framework.Graphics; using osu.Framework.Graphics.Sprites; using osu.Framework.Input.Bindings; using osu.Framework.IO.Stores; using osu.Game.Beatmaps; using osu.Game.Overlays.Settings; using osu.Game.Rulesets.Edit; using osu.Game.Rulesets.Mods; using osu.Game.Rulesets.Replays.Types; using osu.Game.Rulesets.UI; using osu.Game.Beatmaps.Legacy; using osu.Game.Configuration; using osu.Game.Rulesets.Configuration; using osu.Game.Rulesets.Difficulty; using osu.Game.Rulesets.Scoring; using osu.Game.Scoring; using osu.Game.Skinning; using osu.Game.Users; using JetBrains.Annotations; using osu.Framework.Extensions; using osu.Framework.Extensions.EnumExtensions; using osu.Framework.Testing; using osu.Game.Rulesets.Filter; using osu.Game.Screens.Ranking.Statistics; namespace osu.Game.Rulesets { [ExcludeFromDynamicCompile] public abstract class Ruleset { public RulesetInfo RulesetInfo { get; internal set; } public IEnumerable GetAllMods() => Enum.GetValues(typeof(ModType)).Cast() // Confine all mods of each mod type into a single IEnumerable .SelectMany(GetModsFor) // Filter out all null mods .Where(mod => mod != null) // Resolve MultiMods as their .Mods property .SelectMany(mod => (mod as MultiMod)?.Mods ?? new[] { mod }); public abstract IEnumerable GetModsFor(ModType type); /// /// Converts mods from legacy enum values. Do not override if you're not a legacy ruleset. /// /// The legacy enum which will be converted. /// An enumerable of constructed s. public virtual IEnumerable ConvertFromLegacyMods(LegacyMods mods) => Array.Empty(); /// /// Converts mods to legacy enum values. Do not override if you're not a legacy ruleset. /// /// The mods which will be converted. /// A single bitwise enumerable value representing (to the best of our ability) the mods. public virtual LegacyMods ConvertToLegacyMods(Mod[] mods) { var value = LegacyMods.None; foreach (var mod in mods) { switch (mod) { case ModNoFail _: value |= LegacyMods.NoFail; break; case ModEasy _: value |= LegacyMods.Easy; break; case ModHidden _: value |= LegacyMods.Hidden; break; case ModHardRock _: value |= LegacyMods.HardRock; break; case ModPerfect _: value |= LegacyMods.Perfect; break; case ModSuddenDeath _: value |= LegacyMods.SuddenDeath; break; case ModNightcore _: value |= LegacyMods.Nightcore; break; case ModDoubleTime _: value |= LegacyMods.DoubleTime; break; case ModRelax _: value |= LegacyMods.Relax; break; case ModHalfTime _: value |= LegacyMods.HalfTime; break; case ModFlashlight _: value |= LegacyMods.Flashlight; break; case ModCinema _: value |= LegacyMods.Cinema; break; case ModAutoplay _: value |= LegacyMods.Autoplay; break; } } return value; } [CanBeNull] public ModAutoplay GetAutoplayMod() => GetAllMods().OfType().FirstOrDefault(); public virtual ISkin CreateLegacySkinProvider(ISkinSource source, IBeatmap beatmap) => null; protected Ruleset() { RulesetInfo = new RulesetInfo { Name = Description, ShortName = ShortName, ID = (this as ILegacyRuleset)?.LegacyID, InstantiationInfo = GetType().AssemblyQualifiedName, Available = true, }; } /// /// Attempt to create a hit renderer for a beatmap /// /// The beatmap to create the hit renderer for. /// The s to apply. /// Unable to successfully load the beatmap to be usable with this ruleset. /// public abstract DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList mods = null); /// /// Creates a for this . /// /// The score processor. public virtual ScoreProcessor CreateScoreProcessor() => new ScoreProcessor(); /// /// Creates a for this . /// /// The health processor. public virtual HealthProcessor CreateHealthProcessor(double drainStartTime) => new DrainingHealthProcessor(drainStartTime); /// /// Creates a to convert a to one that is applicable for this . /// /// The to be converted. /// The . public abstract IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap); /// /// Optionally creates a to alter a after it has been converted. /// /// The to be processed. /// The . public virtual IBeatmapProcessor CreateBeatmapProcessor(IBeatmap beatmap) => null; public abstract DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap); /// /// Optionally creates a to generate performance data from the provided score. /// /// Difficulty attributes for the beatmap related to the provided score. /// The score to be processed. /// A performance calculator instance for the provided score. [CanBeNull] public virtual PerformanceCalculator CreatePerformanceCalculator(DifficultyAttributes attributes, ScoreInfo score) => null; /// /// Optionally creates a to generate performance data from the provided score. /// /// The beatmap to use as a source for generating . /// The score to be processed. /// A performance calculator instance for the provided score. [CanBeNull] public PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, ScoreInfo score) { var difficultyCalculator = CreateDifficultyCalculator(beatmap); var difficultyAttributes = difficultyCalculator.Calculate(score.Mods); return CreatePerformanceCalculator(difficultyAttributes, score); } public virtual HitObjectComposer CreateHitObjectComposer() => null; public virtual Checker CreateChecker() => null; public virtual Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.Solid.QuestionCircle }; public virtual IResourceStore CreateResourceStore() => new NamespacedResourceStore(new DllResourceStore(GetType().Assembly), @"Resources"); public abstract string Description { get; } public virtual RulesetSettingsSubsection CreateSettings() => null; /// /// Creates the for this . /// /// The to store the settings. public virtual IRulesetConfigManager CreateConfig(SettingsStore settings) => null; /// /// A unique short name to reference this ruleset in online requests. /// public abstract string ShortName { get; } /// /// The playing verb to be shown in the . /// public virtual string PlayingVerb => "Playing solo"; /// /// A list of available variant ids. /// public virtual IEnumerable AvailableVariants => new[] { 0 }; /// /// Get a list of default keys for the specified variant. /// /// A variant. /// A list of valid s. public virtual IEnumerable GetDefaultKeyBindings(int variant = 0) => Array.Empty(); /// /// Gets the name for a key binding variant. This is used for display in the settings overlay. /// /// The variant. /// A descriptive name of the variant. public virtual string GetVariantName(int variant) => string.Empty; /// /// For rulesets which support legacy (osu-stable) replay conversion, this method will create an empty replay frame /// for conversion use. /// /// An empty frame for the current ruleset, or null if unsupported. public virtual IConvertibleReplayFrame CreateConvertibleReplayFrame() => null; /// /// Creates the statistics for a to be displayed in the results screen. /// /// The to create the statistics for. The score is guaranteed to have populated. /// The , converted for this with all relevant s applied. /// The s to display. Each may contain 0 or more . [NotNull] public virtual StatisticRow[] CreateStatisticsForScore(ScoreInfo score, IBeatmap playableBeatmap) => Array.Empty(); /// /// Get all valid s for this ruleset. /// Generally used for results display purposes, where it can't be determined if zero-count means the user has not achieved any or the type is not used by this ruleset. /// /// /// All valid s along with a display-friendly name. /// public IEnumerable<(HitResult result, string displayName)> GetHitResults() { var validResults = GetValidHitResults(); // enumerate over ordered list to guarantee return order is stable. foreach (var result in EnumExtensions.GetValuesInOrder()) { switch (result) { // hard blocked types, should never be displayed even if the ruleset tells us to. case HitResult.None: case HitResult.IgnoreHit: case HitResult.IgnoreMiss: // display is handled as a completion count with corresponding "hit" type. case HitResult.LargeTickMiss: case HitResult.SmallTickMiss: continue; } if (result == HitResult.Miss || validResults.Contains(result)) yield return (result, GetDisplayNameForHitResult(result)); } } /// /// Get all valid s for this ruleset. /// Generally used for results display purposes, where it can't be determined if zero-count means the user has not achieved any or the type is not used by this ruleset. /// /// /// is implicitly included. Special types like are ignored even when specified. /// protected virtual IEnumerable GetValidHitResults() => EnumExtensions.GetValuesInOrder(); /// /// Get a display friendly name for the specified result type. /// /// The result type to get the name for. /// The display name. public virtual string GetDisplayNameForHitResult(HitResult result) => result.GetDescription(); /// /// Creates ruleset-specific beatmap filter criteria to be used on the song select screen. /// [CanBeNull] public virtual IRulesetFilterCriteria CreateRulesetFilterCriteria() => null; } }