Gameplay System

public abstract partial class Player : ScreenWithBeatmapBackground
{
    // Core gameplay components
    protected DrawableRuleset DrawableRuleset { get; private set; }
    protected ScoreProcessor ScoreProcessor { get; private set; }
    protected HealthProcessor HealthProcessor { get; private set; }
    protected HUDOverlay HUDOverlay { get; private set; }
    protected GameplayClockContainer GameplayClockContainer { get; private set; }
    
    // Gameplay state
    public GameplayState GameplayState { get; private set; }
    public Score Score { get; private set; }
    
    // Configuration
    public readonly PlayerConfiguration Configuration;
    
    // Events
    public event Action OnGameplayStarted;
    public event Action OnShowingResults;
}

[BackgroundDependencyLoader]
private void load(OsuConfigManager config, OsuGameBase game, CancellationToken cancellationToken)
{
    // 1. Clone mods for this gameplay session
    var gameplayMods = Mods.Value.Select(m => m.DeepClone()).ToArray();
    
    // 2. Get playable beatmap with mods applied
    IBeatmap playableBeatmap = loadPlayableBeatmap(gameplayMods, cancellationToken);
    
    // 3. Create the drawable ruleset (game-mode specific visualization)
    DrawableRuleset = ruleset.CreateDrawableRulesetWith(playableBeatmap, gameplayMods);
    dependencies.CacheAs(DrawableRuleset);
    
    // 4. Create score and health processors
    ScoreProcessor = ruleset.CreateScoreProcessor();
    ScoreProcessor.ApplyBeatmap(playableBeatmap);
    
    HealthProcessor = ruleset.CreateHealthProcessor(playableBeatmap.HitObjects[0].StartTime);
    HealthProcessor.ApplyBeatmap(playableBeatmap);
    
    // 5. Create gameplay clock container (handles time and frame stability)
    GameplayClockContainer = CreateGameplayClockContainer(Beatmap.Value, DrawableRuleset.GameplayStartTime);
    
    // 6. Create score object
    Score = CreateScore(playableBeatmap);
    
    // 7. Create gameplay state (shared state object)
    GameplayState = new GameplayState(
        playableBeatmap, ruleset, gameplayMods, 
        Score, ScoreProcessor, HealthProcessor, 
        Beatmap.Value.Storyboard, PlayingState
    );
}

public abstract partial class DrawableRuleset<TObject> : DrawableRuleset
    where TObject : HitObject
{
    // The playfield where hit objects are displayed
    public override Playfield Playfield { get; }
    
    // The converted beatmap
    public readonly Beatmap<TObject> Beatmap;
    
    // Applied mods
    public sealed override IReadOnlyList<Mod> Mods { get; }
    
    // Frame stability for consistent gameplay
    public override IFrameStableClock FrameStableClock { get; }
    
    // Hit object collection
    public override IEnumerable<HitObject> Objects => Beatmap.HitObjects;
    
    // Events for judgements
    public override event Action<JudgementResult> NewResult;
    public override event Action<JudgementResult> RevertResult;
}

DrawableRuleset
└── FrameStabilityContainer
    └── AudioContainer
        └── KeyBindingInputManager
            └── PlayfieldAdjustmentContainer
                └── Playfield
                    └── HitObjectContainer
                        └── DrawableHitObjects

public class GameplayState
{
    // The final beatmap after conversion and mods
    public readonly IBeatmap Beatmap;
    
    // Active ruleset
    public readonly Ruleset Ruleset;
    
    // Applied mods
    public readonly IReadOnlyList<Mod> Mods;
    
    // Score tracking
    public readonly Score Score;
    public readonly ScoreProcessor ScoreProcessor;
    public readonly HealthProcessor HealthProcessor;
    
    // Visual elements
    public readonly Storyboard Storyboard;
    
    // Completion state
    public bool HasPassed { get; set; }
    public bool HasFailed { get; set; }
    public bool HasQuit { get; set; }
    public bool HasCompleted => HasPassed || HasFailed || HasQuit;
    
    // Last judgement tracking
    public IBindable<JudgementResult> LastJudgementResult { get; }
    
    // Playing state (playing, paused, watching)
    public IBindable<LocalUserPlayingState> PlayingState { get; }
}

public class ScoreProcessor
{
    // Current score values
    public BindableLong TotalScore { get; }
    public BindableDouble Accuracy { get; }
    public BindableInt Combo { get; }
    public BindableInt HighestCombo { get; }
    
    // Judgement tracking
    public IReadOnlyDictionary<HitResult, int> Statistics { get; }
    
    // Apply judgement result
    public void ApplyResult(JudgementResult result);
    
    // Revert judgement (for replay seeking)
    public void RevertResult(JudgementResult result);
    
    // Populate score info
    public void PopulateScore(ScoreInfo score);
}

public class HealthProcessor
{
    // Current health (0.0 - 1.0)
    public BindableDouble Health { get; }
    
    // Fail state
    public bool HasFailed { get; }
    
    // Apply health change from judgement
    public void ApplyResult(JudgementResult result);
}

public class FrameStabilityContainer : Container
{
    // Provides stable clock for gameplay
    public IFrameStableClock FrameStableClock { get; }
    
    // Enable/disable frame stability
    public bool FrameStablePlayback { get; set; }
}

// Pause gameplay
public void Pause()
{
    if (!CanPause) return;
    
    GameplayClockContainer.Stop();
    PauseOverlay.Show();
    localUserPlaying.Value = false;
}

// Resume gameplay
public void Resume()
{
    // Show resume overlay (countdown)
    ResumeOverlay.Show();
    
    // Resume after countdown completes
    GameplayClockContainer.Start();
    localUserPlaying.Value = true;
}

public class MyCustomPlayer : SoloPlayer
{
    protected override void LoadComplete()
    {
        base.LoadComplete();
        
        // Subscribe to score changes
        ScoreProcessor.TotalScore.ValueChanged += e => 
            Console.WriteLine($"Score: {e.NewValue}");
        
        // Subscribe to judgements
        ScoreProcessor.NewJudgement += result => 
            Console.WriteLine($"Hit: {result.Type}");
        
        // Subscribe to health changes
        HealthProcessor.Health.ValueChanged += e => 
            Console.WriteLine($"Health: {e.NewValue:P0}");
    }
    
    protected override bool CheckModsAllowFailure()
    {
        // Custom fail logic
        return base.CheckModsAllowFailure();
    }
}