public BeatmapGroup(BeatmapSetInfo beatmapSet, BeatmapDatabase database)
{
BeatmapSet = beatmapSet;
WorkingBeatmap beatmap = database.GetWorkingBeatmap(BeatmapSet.Beatmaps.FirstOrDefault());
foreach (var b in BeatmapSet.Beatmaps)
{
b.StarDifficulty = (float)(database.GetWorkingBeatmap(b).Beatmap?.CalculateStarDifficulty() ?? -1f);
}
Header = new BeatmapSetHeader(beatmap)
{
GainedSelection = headerGainedSelection,
RelativeSizeAxes = Axes.X,
};
BeatmapSet.Beatmaps = BeatmapSet.Beatmaps.OrderBy(b => b.StarDifficulty).ToList();
BeatmapPanels = BeatmapSet.Beatmaps.Select(b => new BeatmapPanel(b)
{
Alpha = 0,
GainedSelection = panelGainedSelection,
StartRequested = p => { StartRequested?.Invoke(p.Beatmap); },
RelativeSizeAxes = Axes.X,
}).ToList();
Header.AddDifficultyIcons(BeatmapPanels);
}
/// <summary>
/// selection has been changed as the result of interaction with the carousel.
/// </summary>
private void selectionChanged(BeatmapGroup group, BeatmapInfo beatmap)
{
if (!beatmap.Equals(Beatmap?.BeatmapInfo))
{
Beatmap = database.GetWorkingBeatmap(beatmap, Beatmap);
}
ensurePlayingSelected();
}
//get single osu beatmap
public WorkingBeatmap GetWorkingBeatmap(int rulesetID = 0, bool useFake = false, int beatmapIndex = 0, List <Mod> listMops = null)
{
WorkingBeatmap beatmap = null;
var beatmapInfo = db.Query <BeatmapInfo>().FirstOrDefault(b => b.RulesetID == rulesetID);
if (beatmapInfo != null)
{
beatmap = db.GetWorkingBeatmap(beatmapInfo);
}
//if cannot find any beatmap ,or use fake beatmap just create one
if (beatmap?.Track == null || useFake)
{
beatmap = new RpTestWorkingBeatmap(getFakeBeatmapByRulesetId(rulesetID));
}
//adding Mods
if (listMops != null)
{
beatmap.Mods.Value = listMops?.ToArray();
}
return(beatmap);
}
public override void Reset()
{
base.Reset();
WorkingBeatmap beatmap = null;
var beatmapInfo = db.Query <BeatmapInfo>().FirstOrDefault(b => b.Mode == PlayMode.Osu);
if (beatmapInfo != null)
{
beatmap = db.GetWorkingBeatmap(beatmapInfo);
}
if (beatmap?.Track == null)
{
var objects = new List <HitObject>();
int time = 1500;
for (int i = 0; i < 50; i++)
{
objects.Add(new HitCircle
{
StartTime = time,
Position = new Vector2(i % 4 == 0 || i % 4 == 2 ? 0 : 512,
i % 4 < 2 ? 0 : 384),
NewCombo = i % 4 == 0
});
time += 500;
}
Beatmap b = new Beatmap
{
HitObjects = objects,
BeatmapInfo = new BeatmapInfo
{
Difficulty = new BeatmapDifficulty(),
Metadata = new BeatmapMetadata
{
Artist = @"Unknown",
Title = @"Sample Beatmap",
Author = @"peppy",
}
}
};
beatmap = new TestWorkingBeatmap(b);
}
Add(new Box
{
RelativeSizeAxes = Framework.Graphics.Axes.Both,
Colour = Color4.Black,
});
Add(new PlayerLoader(Player = CreatePlayer(beatmap))
{
Beatmap = beatmap
});
}
protected void LoadScore(Score s)
{
scoreLoad?.Cancel();
var menu = intro.ChildScreen;
if (menu == null)
{
scoreLoad = Schedule(() => LoadScore(s));
return;
}
if (!menu.IsCurrentScreen)
{
menu.MakeCurrent();
Delay(500);
scoreLoad = Schedule(() => LoadScore(s));
return;
}
if (s.Beatmap == null)
{
notificationManager.Post(new SimpleNotification
{
Text = @"Tried to load a score for a beatmap we don't have!",
Icon = FontAwesome.fa_life_saver,
});
return;
}
Beatmap.Value = BeatmapDatabase.GetWorkingBeatmap(s.Beatmap);
menu.Push(new PlayerLoader(new ReplayPlayer(s.Replay)));
}
/// <summary>
/// selection has been changed as the result of interaction with the carousel.
/// </summary>
private void selectionChanged(BeatmapInfo beatmap)
{
selectionChangedDebounce?.Cancel();
if (beatmap.Equals(Beatmap?.BeatmapInfo))
{
return;
}
bool beatmapSetChange = false;
if (beatmap.BeatmapSetInfoID == selectionChangeNoBounce?.BeatmapSetInfoID)
{
sampleChangeDifficulty.Play();
}
else
{
sampleChangeBeatmap.Play();
beatmapSetChange = true;
}
selectionChangeNoBounce = beatmap;
selectionChangedDebounce = Scheduler.AddDelayed(delegate
{
Beatmap = database.GetWorkingBeatmap(beatmap, Beatmap);
ensurePlayingSelected(beatmapSetChange);
}, 100);
}
private void load(BeatmapDatabase db)
{
var beatmapInfo = db.Query <BeatmapInfo>().Where(b => b.Mode == PlayMode.Osu).FirstOrDefault();
if (beatmapInfo != null)
{
beatmap = db.GetWorkingBeatmap(beatmapInfo);
}
}
/// <summary>
/// selection has been changed as the result of interaction with the carousel.
/// </summary>
private void selectionChanged(BeatmapGroup group, BeatmapInfo beatmap)
{
if (!beatmap.Equals(Beatmap?.BeatmapInfo))
{
if (beatmap.BeatmapSetID == Beatmap?.BeatmapInfo.BeatmapSetID)
{
sampleChangeDifficulty.Play();
}
else
{
sampleChangeBeatmap.Play();
}
Beatmap = database.GetWorkingBeatmap(beatmap, Beatmap);
}
ensurePlayingSelected();
}
/// <summary>
/// selection has been changed as the result of interaction with the carousel.
/// </summary>
private void carouselSelectionChanged(BeatmapInfo beatmap)
{
Action performLoad = delegate
{
// We may be arriving here due to another component changing the bindable Beatmap.
// In these cases, the other component has already loaded the beatmap, so we don't need to do so again.
if (beatmap?.Equals(Beatmap.Value.BeatmapInfo) != true)
{
bool preview = beatmap?.BeatmapSetInfoID != Beatmap.Value.BeatmapInfo.BeatmapSetInfoID;
Beatmap.Value = database.GetWorkingBeatmap(beatmap, Beatmap);
ensurePlayingSelected(preview);
}
changeBackground(Beatmap.Value);
};
selectionChangedDebounce?.Cancel();
if (beatmap?.Equals(beatmapNoDebounce) == true)
{
return;
}
beatmapNoDebounce = beatmap;
if (beatmap == null)
{
if (!Beatmap.IsDefault)
{
performLoad();
}
}
else
{
ruleset.Value = beatmap.Ruleset;
if (beatmap.BeatmapSetInfoID == beatmapNoDebounce?.BeatmapSetInfoID)
{
sampleChangeDifficulty.Play();
}
else
{
sampleChangeBeatmap.Play();
}
if (beatmap == Beatmap.Value.BeatmapInfo)
{
performLoad();
}
else
{
selectionChangedDebounce = Scheduler.AddDelayed(performLoad, 100);
}
}
}
private void play(BeatmapInfo info, bool isNext)
{
current = database.GetWorkingBeatmap(info, current);
Task.Run(() =>
{
trackManager.SetExclusive(current.Track);
current.Track.Start();
beatmapSource.Value = current;
});
updateDisplay(current, isNext);
}
private void playSpecified(BeatmapInfo info)
{
beatmapBacking.Value = beatmaps.GetWorkingBeatmap(info, beatmapBacking);
Task.Run(() =>
{
var track = beatmapBacking.Value.Track;
trackManager.SetExclusive(track);
track.Start();
}).ContinueWith(task => Schedule(task.ThrowIfFaulted), TaskContinuationOptions.OnlyOnFaulted);
}
/// <summary>
/// selection has been changed as the result of interaction with the carousel.
/// </summary>
private void selectionChanged(BeatmapGroup group, BeatmapInfo beatmap)
{
selectedBeatmapInfo = beatmap;
if (!beatmap.Equals(Beatmap?.BeatmapInfo))
{
Beatmap = database.GetWorkingBeatmap(beatmap, Beatmap);
}
ensurePlayingSelected();
if (selectedBeatmapGroup == group)
{
return;
}
if (selectedBeatmapGroup != null)
{
selectedBeatmapGroup.State = BeatmapGroupState.Collapsed;
}
selectedBeatmapGroup = group;
}
/// <summary>
/// selection has been changed as the result of interaction with the carousel.
/// </summary>
private void carouselSelectionChanged(BeatmapInfo beatmap)
{
Action performLoad = delegate
{
bool preview = beatmap?.BeatmapSetInfoID != Beatmap.Value.BeatmapInfo.BeatmapSetInfoID;
Beatmap.Value = database.GetWorkingBeatmap(beatmap, Beatmap);
ensurePlayingSelected(preview);
changeBackground(Beatmap.Value);
};
if (beatmap == null)
{
if (!Beatmap.IsDefault)
{
performLoad();
}
}
else
{
selectionChangedDebounce?.Cancel();
if (beatmap.Equals(beatmapNoDebounce))
{
return;
}
if (beatmap.BeatmapSetInfoID == beatmapNoDebounce?.BeatmapSetInfoID)
{
sampleChangeDifficulty.Play();
}
else
{
sampleChangeBeatmap.Play();
}
beatmapNoDebounce = beatmap;
if (beatmap == Beatmap.Value.BeatmapInfo)
{
performLoad();
}
else
{
selectionChangedDebounce = Scheduler.AddDelayed(performLoad, 100);
}
}
}
private void load(AudioManager audio, OsuConfigManager config, BeatmapDatabase beatmaps, Framework.Game game)
{
menuVoice = config.GetBindable <bool>(OsuSetting.MenuVoice);
menuMusic = config.GetBindable <bool>(OsuSetting.MenuMusic);
var trackManager = audio.Track;
BeatmapSetInfo setInfo = null;
if (!menuMusic)
{
var query = beatmaps.Query <BeatmapSetInfo>().Where(b => !b.DeletePending);
int count = query.Count();
if (count > 0)
{
setInfo = query.ElementAt(RNG.Next(0, count - 1));
}
}
if (setInfo == null)
{
var query = beatmaps.Query <BeatmapSetInfo>().Where(b => b.Hash == MENU_MUSIC_BEATMAP_HASH);
setInfo = query.FirstOrDefault();
if (setInfo == null)
{
// we need to import the default menu background beatmap
beatmaps.Import(new OszArchiveReader(game.Resources.GetStream(@"Tracks/circles.osz")));
setInfo = query.First();
setInfo.DeletePending = true;
beatmaps.Update(setInfo, false);
}
}
beatmaps.GetChildren(setInfo);
Beatmap = beatmaps.GetWorkingBeatmap(setInfo.Beatmaps[0]);
track = Beatmap.Track;
trackManager.SetExclusive(track);
welcome = audio.Sample.Get(@"welcome");
seeya = audio.Sample.Get(@"seeya");
}
private void load(OsuGame game, OsuConfigManager config, BeatmapDatabase beatmaps)
{
menuMusic = config.GetBindable <bool>(OsuConfig.MenuMusic);
LoadComponentAsync(background);
if (!menuMusic)
{
trackManager = game.Audio.Track;
int choosableBeatmapsetAmmount = beatmaps.Query <BeatmapSetInfo>().Count();
if (choosableBeatmapsetAmmount > 0)
{
song = beatmaps.GetWorkingBeatmap(beatmaps.GetWithChildren <BeatmapSetInfo>(RNG.Next(1, choosableBeatmapsetAmmount)).Beatmaps[0]);
Beatmap = song;
}
}
buttons.OnSettings = game.ToggleOptions;
preloadSongSelect();
}
public override void Reset()
{
base.Reset();
if (beatmap == null)
{
var beatmapInfo = db.Query <BeatmapInfo>().FirstOrDefault(b => b.RulesetID == 0);
if (beatmapInfo != null)
{
beatmap = db.GetWorkingBeatmap(beatmapInfo);
}
}
base.Reset();
Add(new Results(new Score
{
TotalScore = 2845370,
Accuracy = 0.98,
MaxCombo = 123,
Rank = ScoreRank.A,
Date = DateTime.Now,
Statistics = new Dictionary <string, dynamic>()
{
{ "300", 50 },
{ "100", 20 },
{ "50", 50 },
{ "x", 1 }
},
User = new User
{
Username = "******",
}
})
{
Beatmap = beatmap
});
}
private void load(AudioManager audio, BeatmapDatabase beatmaps, OsuConfigManager config)
{
if (Beatmap.Beatmap.BeatmapInfo?.Mode > PlayMode.Taiko)
{
//we only support osu! mode for now because the hitobject parsing is crappy and needs a refactor.
Exit();
return;
}
dimLevel = config.GetBindable <int>(OsuConfig.DimLevel);
mouseWheelDisabled = config.GetBindable <bool>(OsuConfig.MouseDisableWheel);
try
{
if (Beatmap == null)
{
Beatmap = beatmaps.GetWorkingBeatmap(BeatmapInfo, withStoryboard: true);
}
if ((Beatmap?.Beatmap?.HitObjects.Count ?? 0) == 0)
{
throw new Exception("No valid objects were found!");
}
if (Beatmap == null)
{
throw new Exception("Beatmap was not loaded");
}
}
catch (Exception e)
{
Logger.Log($"Could not load this beatmap sucessfully ({e})!", LoggingTarget.Runtime, LogLevel.Error);
//couldn't load, hard abort!
Exit();
return;
}
Track track = Beatmap.Track;
if (track != null)
{
audio.Track.SetExclusive(track);
sourceClock = track;
}
sourceClock = (IAdjustableClock)track ?? new StopwatchClock();
interpolatedSourceClock = new InterpolatingFramedClock(sourceClock);
Schedule(() =>
{
sourceClock.Reset();
});
ruleset = Ruleset.GetRuleset(Beatmap.PlayMode);
HitRenderer = ruleset.CreateHitRendererWith(Beatmap);
scoreProcessor = HitRenderer.CreateScoreProcessor();
hudOverlay = new StandardHudOverlay()
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre
};
hudOverlay.KeyCounter.Add(ruleset.CreateGameplayKeys());
hudOverlay.BindProcessor(scoreProcessor);
hudOverlay.BindHitRenderer(HitRenderer);
hudOverlay.Progress.Objects = HitRenderer.Objects;
hudOverlay.Progress.AudioClock = interpolatedSourceClock;
//bind HitRenderer to ScoreProcessor and ourselves (for a pass situation)
HitRenderer.OnAllJudged += onCompletion;
//bind ScoreProcessor to ourselves (for a fail situation)
scoreProcessor.Failed += onFail;
Children = new Drawable[]
{
new Container
{
RelativeSizeAxes = Axes.Both,
Clock = interpolatedSourceClock,
Children = new Drawable[]
{
HitRenderer,
skipButton = new SkipButton
{
Alpha = 0
},
}
},
hudOverlay,
pauseOverlay = new PauseOverlay
{
OnResume = delegate
{
Delay(400);
Schedule(Resume);
},
OnRetry = Restart,
OnQuit = Exit,
},
failOverlay = new FailOverlay
{
OnRetry = Restart,
OnQuit = Exit,
},
new HotkeyRetryOverlay
{
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();
Restart();
},
}
};
}
private void load(AudioManager audio, BeatmapDatabase beatmaps, OsuGameBase game, OsuConfigManager config)
{
dimLevel = config.GetBindable <int>(OsuConfig.DimLevel);
try
{
if (Beatmap == null)
{
Beatmap = beatmaps.GetWorkingBeatmap(BeatmapInfo, withStoryboard: true);
}
if ((Beatmap?.Beatmap?.HitObjects.Count ?? 0) == 0)
{
throw new Exception("No valid objects were found!");
}
}
catch (Exception e)
{
Logger.Log($"Could not load this beatmap sucessfully ({e})!", LoggingTarget.Runtime, LogLevel.Error);
//couldn't load, hard abort!
Exit();
return;
}
AudioTrack track = Beatmap.Track;
if (track != null)
{
audio.Track.SetExclusive(track);
sourceClock = track;
}
sourceClock = (IAdjustableClock)track ?? new StopwatchClock();
Schedule(() =>
{
sourceClock.Reset();
});
var beatmap = Beatmap.Beatmap;
if (beatmap.BeatmapInfo?.Mode > PlayMode.Osu)
{
//we only support osu! mode for now because the hitobject parsing is crappy and needs a refactor.
Exit();
return;
}
PlayMode usablePlayMode = beatmap.BeatmapInfo?.Mode > PlayMode.Osu ? beatmap.BeatmapInfo.Mode : PreferredPlayMode;
ruleset = Ruleset.GetRuleset(usablePlayMode);
scoreOverlay = ruleset.CreateScoreOverlay();
scoreOverlay.BindProcessor(scoreProcessor = ruleset.CreateScoreProcessor(beatmap.HitObjects.Count));
pauseOverlay = new PauseOverlay
{
Depth = -1,
OnResume = delegate
{
Delay(400);
Schedule(Resume);
},
OnRetry = Restart,
OnQuit = Exit
};
hitRenderer = ruleset.CreateHitRendererWith(beatmap);
//bind HitRenderer to ScoreProcessor and ourselves (for a pass situation)
hitRenderer.OnJudgement += scoreProcessor.AddJudgement;
hitRenderer.OnAllJudged += onPass;
//bind ScoreProcessor to ourselves (for a fail situation)
scoreProcessor.Failed += onFail;
if (Autoplay)
{
hitRenderer.Schedule(() => hitRenderer.DrawableObjects.ForEach(h => h.State = ArmedState.Hit));
}
Children = new Drawable[]
{
playerInputManager = new PlayerInputManager(game.Host)
{
Clock = new InterpolatingFramedClock(sourceClock),
PassThrough = false,
Children = new Drawable[]
{
hitRenderer,
skipButton = new SkipButton {
Alpha = 0
},
}
},
scoreOverlay,
pauseOverlay
};
}
private void load(AudioManager audio, BeatmapDatabase beatmaps, OsuGameBase game)
{
dimLevel = game.Config.GetBindable<int>(OsuConfig.DimLevel);
try
{
if (Beatmap == null)
Beatmap = beatmaps.GetWorkingBeatmap(BeatmapInfo);
}
catch
{
//couldn't load, hard abort!
Exit();
return;
}
AudioTrack track = Beatmap.Track;
if (track != null)
{
audio.Track.SetExclusive(track);
sourceClock = track;
}
sourceClock = (IAdjustableClock)track ?? new StopwatchClock();
Schedule(() =>
{
sourceClock.Reset();
});
var beatmap = Beatmap.Beatmap;
if (beatmap.BeatmapInfo?.Mode > PlayMode.Osu)
{
//we only support osu! mode for now because the hitobject parsing is crappy and needs a refactor.
Exit();
return;
}
PlayMode usablePlayMode = beatmap.BeatmapInfo?.Mode > PlayMode.Osu ? beatmap.BeatmapInfo.Mode : PreferredPlayMode;
ruleset = Ruleset.GetRuleset(usablePlayMode);
var scoreOverlay = ruleset.CreateScoreOverlay();
scoreOverlay.BindProcessor(scoreProcessor = ruleset.CreateScoreProcessor());
hitRenderer = ruleset.CreateHitRendererWith(beatmap.HitObjects);
hitRenderer.OnJudgement += scoreProcessor.AddJudgement;
hitRenderer.OnAllJudged += hitRenderer_OnAllJudged;
if (Autoplay)
hitRenderer.Schedule(() => hitRenderer.DrawableObjects.ForEach(h => h.State = ArmedState.Hit));
Children = new Drawable[]
{
new PlayerInputManager(game.Host)
{
Clock = new InterpolatingFramedClock(sourceClock),
PassThrough = false,
Children = new Drawable[]
{
hitRenderer,
}
},
scoreOverlay,
};
}
private void load(AudioManager audio, BeatmapDatabase beatmaps, OsuGameBase game)
{
try
{
if (Beatmap == null)
{
Beatmap = beatmaps.GetWorkingBeatmap(BeatmapInfo);
}
}
catch
{
//couldn't load, hard abort!
Exit();
return;
}
AudioTrack track = Beatmap.Track;
if (track != null)
{
audio.Track.SetExclusive(track);
sourceClock = track;
}
sourceClock = (IAdjustableClock)track ?? new StopwatchClock();
Clock = new InterpolatingFramedClock(sourceClock);
Schedule(() =>
{
sourceClock.Reset();
sourceClock.Start();
});
var beatmap = Beatmap.Beatmap;
if (beatmap.BeatmapInfo?.Mode > PlayMode.Osu)
{
//we only support osu! mode for now because the hitobject parsing is crappy and needs a refactor.
Exit();
return;
}
PlayMode usablePlayMode = beatmap.BeatmapInfo?.Mode > PlayMode.Osu ? beatmap.BeatmapInfo.Mode : PreferredPlayMode;
ruleset = Ruleset.GetRuleset(usablePlayMode);
var scoreOverlay = ruleset.CreateScoreOverlay();
var hitRenderer = ruleset.CreateHitRendererWith(beatmap.HitObjects);
hitRenderer.OnHit += delegate(HitObject h) { scoreOverlay.OnHit(h); };
hitRenderer.OnMiss += delegate(HitObject h) { scoreOverlay.OnMiss(h); };
if (Autoplay)
{
hitRenderer.Schedule(() => hitRenderer.DrawableObjects.ForEach(h => h.State = ArmedState.Armed));
}
Children = new Drawable[]
{
new PlayerInputManager(game.Host)
{
PassThrough = false,
Children = new Drawable[]
{
hitRenderer,
}
},
scoreOverlay,
};
}
private void load(AudioManager audio, BeatmapDatabase beatmaps, OsuConfigManager config)
{
var beatmap = Beatmap.Beatmap;
if (beatmap.BeatmapInfo?.Mode > PlayMode.Osu)
{
//we only support osu! mode for now because the hitobject parsing is crappy and needs a refactor.
Exit();
return;
}
dimLevel = config.GetBindable <int>(OsuConfig.DimLevel);
mouseWheelDisabled = config.GetBindable <bool>(OsuConfig.MouseDisableWheel);
try
{
if (Beatmap == null)
{
Beatmap = beatmaps.GetWorkingBeatmap(BeatmapInfo, withStoryboard: true);
}
if ((Beatmap?.Beatmap?.HitObjects.Count ?? 0) == 0)
{
throw new Exception("No valid objects were found!");
}
if (Beatmap == null)
{
throw new Exception("Beatmap was not loaded");
}
}
catch (Exception e)
{
Logger.Log($"Could not load this beatmap sucessfully ({e})!", LoggingTarget.Runtime, LogLevel.Error);
//couldn't load, hard abort!
Exit();
return;
}
Track track = Beatmap.Track;
if (track != null)
{
audio.Track.SetExclusive(track);
sourceClock = track;
}
sourceClock = (IAdjustableClock)track ?? new StopwatchClock();
interpolatedSourceClock = new InterpolatingFramedClock(sourceClock);
Schedule(() =>
{
sourceClock.Reset();
});
ruleset = Ruleset.GetRuleset(Beatmap.PlayMode);
hudOverlay = new StandardHudOverlay();
hudOverlay.KeyCounter.Add(ruleset.CreateGameplayKeys());
hudOverlay.BindProcessor(scoreProcessor = ruleset.CreateScoreProcessor(beatmap.HitObjects.Count));
pauseOverlay = new PauseOverlay
{
Depth = -1,
OnResume = delegate
{
Delay(400);
Schedule(Resume);
},
OnRetry = Restart,
OnQuit = Exit
};
hitRenderer = ruleset.CreateHitRendererWith(Beatmap);
if (ReplayInputHandler != null)
{
hitRenderer.InputManager.ReplayInputHandler = ReplayInputHandler;
}
hudOverlay.BindHitRenderer(hitRenderer);
//bind HitRenderer to ScoreProcessor and ourselves (for a pass situation)
hitRenderer.OnJudgement += scoreProcessor.AddJudgement;
hitRenderer.OnAllJudged += onPass;
//bind ScoreProcessor to ourselves (for a fail situation)
scoreProcessor.Failed += onFail;
Children = new Drawable[]
{
new Container
{
RelativeSizeAxes = Axes.Both,
Clock = interpolatedSourceClock,
Children = new Drawable[]
{
hitRenderer,
skipButton = new SkipButton
{
Alpha = 0
},
}
},
hudOverlay,
pauseOverlay
};
}
private void load(BeatmapDatabase db)
{
beatmap = db.GetWorkingBeatmap(db.Query<BeatmapInfo>().Where(b => b.Mode == PlayMode.Osu).FirstOrDefault());
}
private void load(AudioManager audio, BeatmapDatabase beatmaps, OsuConfigManager config, OsuGame osu)
{
dimLevel = config.GetBindable <double>(OsuConfig.DimLevel);
mouseWheelDisabled = config.GetBindable <bool>(OsuConfig.MouseDisableWheel);
Ruleset rulesetInstance;
try
{
if (Beatmap == null)
{
Beatmap = beatmaps.GetWorkingBeatmap(BeatmapInfo, withStoryboard: true);
}
if (Beatmap?.Beatmap == null)
{
throw new Exception("Beatmap was not loaded");
}
ruleset = osu?.Ruleset.Value ?? Beatmap.BeatmapInfo.Ruleset;
rulesetInstance = ruleset.CreateInstance();
try
{
HitRenderer = rulesetInstance.CreateHitRendererWith(Beatmap);
}
catch (BeatmapInvalidForRulesetException)
{
// we may fail to create a HitRenderer 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);
}
if (!HitRenderer.Objects.Any())
{
throw new Exception("Beatmap contains no hit objects!");
}
}
catch (Exception e)
{
Logger.Log($"Could not load this beatmap sucessfully ({e})!", LoggingTarget.Runtime, LogLevel.Error);
//couldn't load, hard abort!
Exit();
return;
}
Track track = Beatmap.Track;
if (track != null)
{
audio.Track.SetExclusive(track);
adjustableSourceClock = track;
}
adjustableSourceClock = (IAdjustableClock)track ?? new StopwatchClock();
decoupledClock = new DecoupleableInterpolatingFramedClock {
IsCoupled = false
};
var firstObjectTime = HitRenderer.Objects.First().StartTime;
decoupledClock.Seek(Math.Min(0, firstObjectTime - Math.Max(Beatmap.Beatmap.TimingInfo.BeatLengthAt(firstObjectTime) * 4, Beatmap.BeatmapInfo.AudioLeadIn)));
decoupledClock.ProcessFrame();
offsetClock = new FramedOffsetClock(decoupledClock);
userAudioOffset = config.GetBindable <double>(OsuConfig.AudioOffset);
userAudioOffset.ValueChanged += v => offsetClock.Offset = v;
userAudioOffset.TriggerChange();
Schedule(() =>
{
adjustableSourceClock.Reset();
foreach (var mod in Beatmap.Mods.Value.OfType <IApplicableToClock>())
{
mod.ApplyToClock(adjustableSourceClock);
}
decoupledClock.ChangeSource(adjustableSourceClock);
});
scoreProcessor = HitRenderer.CreateScoreProcessor();
hudOverlay = new StandardHudOverlay()
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre
};
hudOverlay.KeyCounter.Add(rulesetInstance.CreateGameplayKeys());
hudOverlay.BindProcessor(scoreProcessor);
hudOverlay.BindHitRenderer(HitRenderer);
hudOverlay.Progress.Objects = HitRenderer.Objects;
hudOverlay.Progress.AudioClock = decoupledClock;
hudOverlay.Progress.AllowSeeking = HitRenderer.HasReplayLoaded;
hudOverlay.Progress.OnSeek = pos => decoupledClock.Seek(pos);
//bind HitRenderer to ScoreProcessor and ourselves (for a pass situation)
HitRenderer.OnAllJudged += onCompletion;
//bind ScoreProcessor to ourselves (for a fail situation)
scoreProcessor.Failed += onFail;
Children = new Drawable[]
{
hitRendererContainer = new Container
{
RelativeSizeAxes = Axes.Both,
Children = new Drawable[]
{
new Container
{
RelativeSizeAxes = Axes.Both,
Clock = offsetClock,
Children = new Drawable[]
{
HitRenderer,
skipButton = new SkipButton {
Alpha = 0
},
}
},
}
},
hudOverlay,
pauseOverlay = new PauseOverlay
{
OnResume = delegate
{
Delay(400);
Schedule(Resume);
},
OnRetry = Restart,
OnQuit = Exit,
},
failOverlay = new FailOverlay
{
OnRetry = Restart,
OnQuit = Exit,
},
new HotkeyRetryOverlay
{
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();
Restart();
},
}
};
}
private void playSpecified(BeatmapInfo info)
{
beatmapBacking.Value = beatmaps.GetWorkingBeatmap(info, beatmapBacking);
beatmapBacking.Value.Track.Start();
}
private void load(BeatmapDatabase db)
{
beatmap = db.GetWorkingBeatmap(db.Query <BeatmapInfo>().Where(b => b.Mode == PlayMode.Osu).FirstOrDefault());
}
