protected override void UpdateHitStateTransforms(ArmedState state)
{
base.UpdateHitStateTransforms(state);
this.FadeOut(160);
// skin change does a rewind of transforms, which will stop the spinning sound from playing if it's currently in playback.
isSpinning?.TriggerChange();
}
protected override void UpdateStateTransforms(ArmedState state)
{
base.UpdateStateTransforms(state);
using (BeginDelayedSequence(Spinner.Duration, true))
this.FadeOut(160);
// skin change does a rewind of transforms, which will stop the spinning sound from playing if it's currently in playback.
isSpinning?.TriggerChange();
}
protected override void UpdateHitStateTransforms(ArmedState state)
{
base.UpdateHitStateTransforms(state);
this.FadeOut(fade_out_duration).OnComplete(_ =>
{
// looping sample should be stopped here as it is safer than running in the OnComplete
// of the volume transition above.
spinningSample.Stop();
});
Expire();
// skin change does a rewind of transforms, which will stop the spinning sound from playing if it's currently in playback.
isSpinning?.TriggerChange();
}
private void load(OsuConfigManager osuConfig, FrameworkConfigManager config)
{
var configSensitivity = config.GetBindable <double>(FrameworkSetting.CursorSensitivity);
// use local bindable to avoid changing enabled state of game host's bindable.
sensitivityBindable = configSensitivity.GetUnboundCopy();
configSensitivity.BindValueChanged(val => sensitivityBindable.Value = val.NewValue);
sensitivityBindable.BindValueChanged(val => configSensitivity.Value = val.NewValue);
Children = new Drawable[]
{
new SettingsCheckbox
{
LabelText = "Raw input",
Current = rawInputToggle
},
new SensitivitySetting
{
LabelText = "Cursor sensitivity",
Current = sensitivityBindable
},
new SettingsCheckbox
{
LabelText = "Map absolute input to window",
Current = config.GetBindable <bool>(FrameworkSetting.MapAbsoluteInputToWindow)
},
new SettingsEnumDropdown <OsuConfineMouseMode>
{
LabelText = "Confine mouse cursor to window",
Current = osuConfig.GetBindable <OsuConfineMouseMode>(OsuSetting.ConfineMouseMode)
},
new SettingsCheckbox
{
LabelText = "Disable mouse wheel during gameplay",
Current = osuConfig.GetBindable <bool>(OsuSetting.MouseDisableWheel)
},
new SettingsCheckbox
{
LabelText = "Disable mouse buttons during gameplay",
Current = osuConfig.GetBindable <bool>(OsuSetting.MouseDisableButtons)
},
};
if (RuntimeInfo.OS != RuntimeInfo.Platform.Windows)
{
rawInputToggle.Disabled = true;
sensitivityBindable.Disabled = true;
}
else
{
rawInputToggle.ValueChanged += enabled =>
{
// this is temporary until we support per-handler settings.
const string raw_mouse_handler = @"OsuTKRawMouseHandler";
const string standard_mouse_handler = @"OsuTKMouseHandler";
ignoredInputHandler.Value = enabled.NewValue ? standard_mouse_handler : raw_mouse_handler;
};
ignoredInputHandler = config.GetBindable <string>(FrameworkSetting.IgnoredInputHandlers);
ignoredInputHandler.ValueChanged += handler =>
{
bool raw = !handler.NewValue.Contains("Raw");
rawInputToggle.Value = raw;
sensitivityBindable.Disabled = !raw;
};
ignoredInputHandler.TriggerChange();
}
}
private void load(FrameworkConfigManager config)
{
enabled = config.GetBindable <bool>(FrameworkSetting.ShowLogOverlay);
enabled.ValueChanged += val => State = val ? Visibility.Visible : Visibility.Hidden;
enabled.TriggerChange();
}
public void AddLanguage(string language, IResourceStore <string> storage)
{
storages.Add(language, storage);
locale.TriggerChange();
}
public MarginPaddingControl(SafeAreaContainer safeAreaBackground, SafeAreaContainer safeAreaGrid, string title, Bindable <float> bindable, Edges edge)
{
SpriteText valueText;
BasicCheckbox overrideCheckbox;
BasicCheckbox safeCheckbox;
Direction = FillDirection.Horizontal;
Spacing = new Vector2(20, 0);
AutoSizeAxes = Axes.Both;
Children = new Drawable[]
{
new SpriteText
{
Text = title,
Width = 60,
Origin = Anchor.CentreLeft,
Anchor = Anchor.CentreLeft,
},
valueText = new SpriteText
{
Width = 50,
Origin = Anchor.CentreLeft,
Anchor = Anchor.CentreLeft,
},
new BasicSliderBar <float>
{
Current = bindable,
Size = new Vector2(100, 20),
Origin = Anchor.CentreLeft,
Anchor = Anchor.CentreLeft,
},
new SpriteText
{
Text = "Background Override",
Origin = Anchor.CentreLeft,
Anchor = Anchor.CentreLeft,
},
overrideCheckbox = new BasicCheckbox(),
new SpriteText
{
Text = "Grid Override",
Origin = Anchor.CentreLeft,
Anchor = Anchor.CentreLeft,
},
safeCheckbox = new BasicCheckbox()
};
overrideCheckbox.Current.ValueChanged += e =>
{
if (e.NewValue)
{
safeAreaBackground.SafeAreaOverrideEdges |= edge;
}
else
{
safeAreaBackground.SafeAreaOverrideEdges &= ~edge;
}
};
safeCheckbox.Current.ValueChanged += e =>
{
if (e.NewValue)
{
safeAreaGrid.SafeAreaOverrideEdges |= edge;
}
else
{
safeAreaGrid.SafeAreaOverrideEdges &= ~edge;
}
};
bindable.ValueChanged += e => valueText.Text = $"{e.NewValue:F1}";
bindable.TriggerChange();
}
protected override void LoadComplete()
{
base.LoadComplete();
Status.TriggerChange();
}
protected override void LoadComplete()
{
base.LoadComplete();
visualisation.AccentColour = Color4.White;
showVisualisation.TriggerChange();
}
private void load()
{
dependencies.CacheAs(this);
dependencies.Cache(SentryLogger);
dependencies.Cache(osuLogo = new OsuLogo {
Alpha = 0
});
// bind config int to database RulesetInfo
configRuleset = LocalConfig.GetBindable <int>(OsuSetting.Ruleset);
uiScale = LocalConfig.GetBindable <float>(OsuSetting.UIScale);
var preferredRuleset = RulesetStore.GetRuleset(configRuleset.Value);
try
{
Ruleset.Value = preferredRuleset ?? RulesetStore.AvailableRulesets.First();
}
catch (Exception e)
{
// on startup, a ruleset may be selected which has compatibility issues.
Logger.Error(e, $@"Failed to switch to preferred ruleset {preferredRuleset}.");
Ruleset.Value = RulesetStore.AvailableRulesets.First();
}
Ruleset.ValueChanged += r => configRuleset.Value = r.NewValue.ID ?? 0;
// bind config int to database SkinInfo
configSkin = LocalConfig.GetBindable <int>(OsuSetting.Skin);
SkinManager.CurrentSkinInfo.ValueChanged += skin => configSkin.Value = skin.NewValue.ID;
configSkin.ValueChanged += skinId =>
{
var skinInfo = SkinManager.Query(s => s.ID == skinId.NewValue);
if (skinInfo == null)
{
switch (skinId.NewValue)
{
case -1:
skinInfo = DefaultLegacySkin.Info;
break;
default:
skinInfo = SkinInfo.Default;
break;
}
}
SkinManager.CurrentSkinInfo.Value = skinInfo;
};
configSkin.TriggerChange();
IsActive.BindValueChanged(active => updateActiveState(active.NewValue), true);
Audio.AddAdjustment(AdjustableProperty.Volume, inactiveVolumeFade);
SelectedMods.BindValueChanged(modsChanged);
Beatmap.BindValueChanged(beatmapChanged, true);
}
private void load(AudioManager audio, APIAccess api, OsuConfigManager config)
{
this.api = api;
sampleRestart = audio.Sample.Get(@"Gameplay/restart");
mouseWheelDisabled = config.GetBindable <bool>(OsuSetting.MouseDisableWheel);
userAudioOffset = config.GetBindable <double>(OsuSetting.AudioOffset);
WorkingBeatmap working = Beatmap.Value;
Beatmap beatmap;
try
{
beatmap = working.Beatmap;
if (beatmap == null)
{
throw new InvalidOperationException("Beatmap was not loaded");
}
ruleset = Ruleset.Value ?? beatmap.BeatmapInfo.Ruleset;
var rulesetInstance = ruleset.CreateInstance();
try
{
RulesetContainer = rulesetInstance.CreateRulesetContainerWith(working, ruleset.ID == beatmap.BeatmapInfo.Ruleset.ID);
}
catch (BeatmapInvalidForRulesetException)
{
// 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();
RulesetContainer = rulesetInstance.CreateRulesetContainerWith(Beatmap, true);
}
if (!RulesetContainer.Objects.Any())
{
throw new InvalidOperationException("Beatmap contains no hit objects!");
}
}
catch (Exception e)
{
Logger.Error(e, "Could not load beatmap sucessfully!");
//couldn't load, hard abort!
Exit();
return;
}
sourceClock = (IAdjustableClock)working.Track ?? new StopwatchClock();
adjustableClock = new DecoupleableInterpolatingFramedClock {
IsCoupled = false
};
var firstObjectTime = RulesetContainer.Objects.First().StartTime;
adjustableClock.Seek(AllowLeadIn
? Math.Min(0, firstObjectTime - Math.Max(beatmap.ControlPointInfo.TimingPointAt(firstObjectTime).BeatLength * 4, beatmap.BeatmapInfo.AudioLeadIn))
: firstObjectTime);
adjustableClock.ProcessFrame();
// the final usable gameplay clock with user-set offsets applied.
var offsetClock = new FramedOffsetClock(adjustableClock);
userAudioOffset.ValueChanged += v => offsetClock.Offset = v;
userAudioOffset.TriggerChange();
scoreProcessor = RulesetContainer.CreateScoreProcessor();
Children = new Drawable[]
{
pauseContainer = new PauseContainer(offsetClock, adjustableClock)
{
OnRetry = Restart,
OnQuit = Exit,
CheckCanPause = () => AllowPause && ValidForResume && !HasFailed && !RulesetContainer.HasReplayLoaded,
OnPause = () =>
{
pauseContainer.Retries = RestartCount;
hudOverlay.KeyCounter.IsCounting = pauseContainer.IsPaused;
},
OnResume = () => hudOverlay.KeyCounter.IsCounting = true,
Children = new Drawable[]
{
storyboardContainer = new Container
{
RelativeSizeAxes = Axes.Both,
Alpha = 0,
},
RulesetContainer,
new SkipButton(firstObjectTime)
{
Clock = Clock, // skip button doesn't want to use the audio clock directly
ProcessCustomClock = false,
AdjustableClock = adjustableClock,
FramedClock = offsetClock,
},
hudOverlay = new HUDOverlay(scoreProcessor, RulesetContainer, working, offsetClock, adjustableClock)
{
Clock = Clock, // hud overlay doesn't want to use the audio clock directly
ProcessCustomClock = false,
Anchor = Anchor.Centre,
Origin = Anchor.Centre
},
new BreakOverlay(beatmap.BeatmapInfo.LetterboxInBreaks, scoreProcessor)
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
ProcessCustomClock = false,
Breaks = beatmap.Breaks
}
}
},
failOverlay = new FailOverlay
{
OnRetry = Restart,
OnQuit = Exit,
},
new HotkeyRetryOverlay
{
Action = () =>
{
if (!IsCurrentScreen)
{
return;
}
//we want to hide the hitrenderer immediately (looks better).
//we may be able to remove this once the mouse cursor trail is improved.
RulesetContainer?.Hide();
Restart();
},
}
};
if (ShowStoryboard)
{
initializeStoryboard(false);
}
// Bind ScoreProcessor to ourselves
scoreProcessor.AllJudged += onCompletion;
scoreProcessor.Failed += onFail;
foreach (var mod in Beatmap.Value.Mods.Value.OfType <IApplicableToScoreProcessor>())
{
mod.ApplyToScoreProcessor(scoreProcessor);
}
}
private void load(AudioManager audio, APIAccess api, OsuConfigManager config)
{
this.api = api;
WorkingBeatmap working = Beatmap.Value;
if (working is DummyWorkingBeatmap)
{
return;
}
sampleRestart = audio.Sample.Get(@"Gameplay/restart");
mouseWheelDisabled = config.GetBindable <bool>(OsuSetting.MouseDisableWheel);
userAudioOffset = config.GetBindable <double>(OsuSetting.AudioOffset);
IBeatmap beatmap;
try
{
beatmap = working.Beatmap;
if (beatmap == null)
{
throw new InvalidOperationException("Beatmap was not loaded");
}
ruleset = Ruleset.Value ?? beatmap.BeatmapInfo.Ruleset;
var rulesetInstance = ruleset.CreateInstance();
try
{
RulesetContainer = rulesetInstance.CreateRulesetContainerWith(working);
}
catch (BeatmapInvalidForRulesetException)
{
// 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();
RulesetContainer = rulesetInstance.CreateRulesetContainerWith(Beatmap.Value);
}
if (!RulesetContainer.Objects.Any())
{
Logger.Error(new InvalidOperationException("Beatmap contains no hit objects!"), "Beatmap contains no hit objects!");
return;
}
}
catch (Exception e)
{
Logger.Error(e, "Could not load beatmap sucessfully!");
//couldn't load, hard abort!
return;
}
sourceClock = (IAdjustableClock)working.Track ?? new StopwatchClock();
adjustableClock = new DecoupleableInterpolatingFramedClock {
IsCoupled = false
};
adjustableClock.Seek(AllowLeadIn
? Math.Min(RulesetContainer.GameplayStartTime, beatmap.HitObjects.First().StartTime - beatmap.BeatmapInfo.AudioLeadIn)
: RulesetContainer.GameplayStartTime);
adjustableClock.ProcessFrame();
// Lazer's audio timings in general doesn't match stable. This is the result of user testing, albeit limited.
// This only seems to be required on windows. We need to eventually figure out why, with a bit of luck.
var platformOffsetClock = new FramedOffsetClock(adjustableClock)
{
Offset = RuntimeInfo.OS == RuntimeInfo.Platform.Windows ? 22 : 0
};
// the final usable gameplay clock with user-set offsets applied.
var offsetClock = new FramedOffsetClock(platformOffsetClock);
userAudioOffset.ValueChanged += v => offsetClock.Offset = v;
userAudioOffset.TriggerChange();
ScoreProcessor = RulesetContainer.CreateScoreProcessor();
if (!ScoreProcessor.Mode.Disabled)
{
config.BindWith(OsuSetting.ScoreDisplayMode, ScoreProcessor.Mode);
}
Children = new Drawable[]
{
pauseContainer = new PauseContainer(offsetClock, adjustableClock)
{
Retries = RestartCount,
OnRetry = Restart,
OnQuit = Exit,
CheckCanPause = () => AllowPause && ValidForResume && !HasFailed && !RulesetContainer.HasReplayLoaded,
Children = new[]
{
storyboardContainer = new Container
{
RelativeSizeAxes = Axes.Both,
Alpha = 0,
},
new LocalSkinOverrideContainer(working.Skin)
{
RelativeSizeAxes = Axes.Both,
Child = RulesetContainer
},
new BreakOverlay(beatmap.BeatmapInfo.LetterboxInBreaks, ScoreProcessor)
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
ProcessCustomClock = false,
Breaks = beatmap.Breaks
},
RulesetContainer.Cursor?.CreateProxy() ?? new Container(),
hudOverlay = new HUDOverlay(ScoreProcessor, RulesetContainer, working, offsetClock, adjustableClock)
{
Clock = Clock, // hud overlay doesn't want to use the audio clock directly
ProcessCustomClock = false,
Anchor = Anchor.Centre,
Origin = Anchor.Centre
},
new SkipOverlay(RulesetContainer.GameplayStartTime)
{
Clock = Clock, // skip button doesn't want to use the audio clock directly
ProcessCustomClock = false,
AdjustableClock = adjustableClock,
FramedClock = offsetClock,
},
}
},
failOverlay = new FailOverlay
{
OnRetry = Restart,
OnQuit = Exit,
},
new HotkeyRetryOverlay
{
Action = () =>
{
if (!IsCurrentScreen)
{
return;
}
pauseContainer.Hide();
Restart();
},
}
};
hudOverlay.HoldToQuit.Action = Exit;
hudOverlay.KeyCounter.Visible.BindTo(RulesetContainer.HasReplayLoaded);
RulesetContainer.IsPaused.BindTo(pauseContainer.IsPaused);
if (ShowStoryboard)
{
initializeStoryboard(false);
}
// Bind ScoreProcessor to ourselves
ScoreProcessor.AllJudged += onCompletion;
ScoreProcessor.Failed += onFail;
foreach (var mod in Beatmap.Value.Mods.Value.OfType <IApplicableToScoreProcessor>())
{
mod.ApplyToScoreProcessor(ScoreProcessor);
}
}
protected override void LoadComplete()
{
base.LoadComplete();
Add(new Drawable[] {
new VolumeControlReceptor
{
RelativeSizeAxes = Axes.Both,
ActionRequested = delegate(InputState state) { volume.Adjust(state); }
},
mainContent = new Container
{
RelativeSizeAxes = Axes.Both,
},
volume = new VolumeControl(),
overlayContent = new Container {
RelativeSizeAxes = Axes.Both
},
new GlobalHotkeys //exists because UserInputManager is at a level below us.
{
Handler = globalHotkeyPressed
}
});
(screenStack = new Loader()).LoadAsync(this, d =>
{
screenStack.ModePushed += screenAdded;
screenStack.Exited += screenRemoved;
mainContent.Add(screenStack);
});
//overlay elements
(chat = new ChatOverlay {
Depth = 0
}).LoadAsync(this, overlayContent.Add);
(options = new OptionsOverlay {
Depth = -1
}).LoadAsync(this, overlayContent.Add);
(musicController = new MusicController
{
Depth = -2,
Position = new Vector2(0, Toolbar.HEIGHT),
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
}).LoadAsync(this, overlayContent.Add);
(notificationManager = new NotificationManager
{
Depth = -2,
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
}).LoadAsync(this, overlayContent.Add);
(dialogOverlay = new DialogOverlay
{
Depth = -4,
}).LoadAsync(this, overlayContent.Add);
Logger.NewEntry += entry =>
{
if (entry.Level < LogLevel.Important)
{
return;
}
notificationManager.Post(new SimpleNotification
{
Text = $@"{entry.Level}: {entry.Message}"
});
};
Dependencies.Cache(options);
Dependencies.Cache(musicController);
Dependencies.Cache(notificationManager);
Dependencies.Cache(dialogOverlay);
(Toolbar = new Toolbar
{
Depth = -3,
OnHome = delegate { intro?.ChildScreen?.MakeCurrent(); },
OnPlayModeChange = m => PlayMode.Value = m,
}).LoadAsync(this, t =>
{
PlayMode.ValueChanged += delegate { Toolbar.SetGameMode(PlayMode.Value); };
PlayMode.TriggerChange();
overlayContent.Add(Toolbar);
});
options.StateChanged += delegate
{
switch (options.State)
{
case Visibility.Hidden:
intro.MoveToX(0, OptionsOverlay.TRANSITION_LENGTH, EasingTypes.OutQuint);
break;
case Visibility.Visible:
intro.MoveToX(OptionsOverlay.SIDEBAR_WIDTH / 2, OptionsOverlay.TRANSITION_LENGTH, EasingTypes.OutQuint);
break;
}
};
Cursor.State = Visibility.Hidden;
}
private void load(OsuConfigManager config, OsuColour colours, ChannelManager channelManager)
{
const float padding = 5;
Children = new Drawable[]
{
channelSelectionContainer = new Container
{
RelativeSizeAxes = Axes.Both,
Height = 1f - DEFAULT_HEIGHT,
Masking = true,
Children = new[]
{
ChannelSelectionOverlay = new ChannelSelectionOverlay
{
RelativeSizeAxes = Axes.Both,
},
},
},
chatContainer = new Container
{
Name = @"chat container",
Anchor = Anchor.BottomLeft,
Origin = Anchor.BottomLeft,
RelativeSizeAxes = Axes.Both,
Height = DEFAULT_HEIGHT,
Children = new[]
{
new Container
{
Name = @"chat area",
RelativeSizeAxes = Axes.Both,
Padding = new MarginPadding {
Top = TAB_AREA_HEIGHT
},
Children = new Drawable[]
{
chatBackground = new Box
{
RelativeSizeAxes = Axes.Both,
},
currentChannelContainer = new Container <DrawableChannel>
{
RelativeSizeAxes = Axes.Both,
Padding = new MarginPadding
{
Bottom = textbox_height
},
},
new Container
{
Anchor = Anchor.BottomLeft,
Origin = Anchor.BottomLeft,
RelativeSizeAxes = Axes.X,
Height = textbox_height,
Padding = new MarginPadding
{
Top = padding * 2,
Bottom = padding * 2,
Left = ChatLine.LEFT_PADDING + padding * 2,
Right = padding * 2,
},
Children = new Drawable[]
{
textbox = new FocusedTextBox
{
RelativeSizeAxes = Axes.Both,
Height = 1,
PlaceholderText = "type your message",
Exit = Hide,
OnCommit = postMessage,
ReleaseFocusOnCommit = false,
HoldFocus = true,
}
}
},
loading = new LoadingAnimation(),
}
},
tabsArea = new TabsArea
{
Children = new Drawable[]
{
tabBackground = new Box
{
RelativeSizeAxes = Axes.Both,
Colour = Color4.Black,
},
ChannelTabControl = CreateChannelTabControl().With(d =>
{
d.Anchor = Anchor.BottomLeft;
d.Origin = Anchor.BottomLeft;
d.RelativeSizeAxes = Axes.Both;
d.OnRequestLeave = channelManager.LeaveChannel;
}),
}
},
},
},
};
ChannelTabControl.Current.ValueChanged += current => channelManager.CurrentChannel.Value = current.NewValue;
ChannelTabControl.ChannelSelectorActive.ValueChanged += active => ChannelSelectionOverlay.State.Value = active.NewValue ? Visibility.Visible : Visibility.Hidden;
ChannelSelectionOverlay.State.ValueChanged += state =>
{
// Propagate the visibility state to ChannelSelectorActive
ChannelTabControl.ChannelSelectorActive.Value = state.NewValue == Visibility.Visible;
if (state.NewValue == Visibility.Visible)
{
textbox.HoldFocus = false;
if (1f - ChatHeight.Value < channel_selection_min_height)
{
this.TransformBindableTo(ChatHeight, 1f - channel_selection_min_height, 800, Easing.OutQuint);
}
}
else
{
textbox.HoldFocus = true;
}
};
ChannelSelectionOverlay.OnRequestJoin = channel => channelManager.JoinChannel(channel);
ChannelSelectionOverlay.OnRequestLeave = channelManager.LeaveChannel;
ChatHeight = config.GetBindable <double>(OsuSetting.ChatDisplayHeight);
ChatHeight.ValueChanged += height =>
{
chatContainer.Height = (float)height.NewValue;
channelSelectionContainer.Height = 1f - (float)height.NewValue;
tabBackground.FadeTo(height.NewValue == 1 ? 1 : 0.8f, 200);
};
ChatHeight.TriggerChange();
chatBackground.Colour = colours.ChatBlue;
this.channelManager = channelManager;
loading.Show();
// This is a relatively expensive (and blocking) operation.
// Scheduling it ensures that it won't be performed unless the user decides to open chat.
// TODO: Refactor OsuFocusedOverlayContainer / OverlayContainer to support delayed content loading.
Schedule(() =>
{
// TODO: consider scheduling bindable callbacks to not perform when overlay is not present.
channelManager.JoinedChannels.ItemsAdded += onChannelAddedToJoinedChannels;
channelManager.JoinedChannels.ItemsRemoved += onChannelRemovedFromJoinedChannels;
foreach (Channel channel in channelManager.JoinedChannels)
{
ChannelTabControl.AddChannel(channel);
}
channelManager.AvailableChannels.ItemsAdded += availableChannelsChanged;
channelManager.AvailableChannels.ItemsRemoved += availableChannelsChanged;
ChannelSelectionOverlay.UpdateAvailableChannels(channelManager.AvailableChannels);
currentChannel = channelManager.CurrentChannel.GetBoundCopy();
currentChannel.BindValueChanged(currentChannelChanged, true);
});
}
protected override void LoadComplete()
{
base.LoadComplete();
Add(new Drawable[] {
new VolumeControlReceptor
{
RelativeSizeAxes = Axes.Both,
ActionRequested = delegate(InputState state) { volume.Adjust(state); }
},
mainContent = new Container
{
RelativeSizeAxes = Axes.Both,
},
volume = new VolumeControl(),
overlayContent = new Container {
RelativeSizeAxes = Axes.Both
},
new GlobalHotkeys //exists because UserInputManager is at a level below us.
{
Handler = globalHotkeyPressed
}
});
(modeStack = new Intro()).Preload(this, d =>
{
mainContent.Add(d);
modeStack.ModePushed += modeAdded;
modeStack.Exited += modeRemoved;
modeStack.DisplayAsRoot();
});
//overlay elements
(chat = new ChatOverlay {
Depth = 0
}).Preload(this, overlayContent.Add);
(options = new OptionsOverlay {
Depth = -1
}).Preload(this, overlayContent.Add);
(musicController = new MusicController()
{
Depth = -3
}).Preload(this, overlayContent.Add);
Dependencies.Cache(options);
Dependencies.Cache(musicController);
(Toolbar = new Toolbar
{
Depth = -2,
OnHome = delegate { mainMenu?.MakeCurrent(); },
OnPlayModeChange = delegate(PlayMode m) { PlayMode.Value = m; },
}).Preload(this, t =>
{
PlayMode.ValueChanged += delegate { Toolbar.SetGameMode(PlayMode.Value); };
PlayMode.TriggerChange();
overlayContent.Add(Toolbar);
});
options.StateChanged += delegate
{
switch (options.State)
{
case Visibility.Hidden:
intro.MoveToX(0, OptionsOverlay.TRANSITION_LENGTH, EasingTypes.OutQuint);
break;
case Visibility.Visible:
intro.MoveToX(OptionsOverlay.SIDEBAR_WIDTH / 2, OptionsOverlay.TRANSITION_LENGTH, EasingTypes.OutQuint);
break;
}
};
Cursor.Alpha = 0;
}
protected override void LoadComplete()
{
NoteStartIndicators.TriggerChange();
this.FadeTo(RingOpacity.Value, 1000, Easing.OutElasticQuarter).ScaleTo(1, 1000, Easing.OutElasticQuarter);
}
public TestSceneBorderless()
{
Child = new Container
{
RelativeSizeAxes = Axes.Both,
Children = new Drawable[]
{
new Container
{
RelativeSizeAxes = Axes.Both,
Padding = new MarginPadding(100),
Child = paddedContainer = new Container
{
RelativeSizeAxes = Axes.Both,
Child = screenContainer = new Container
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Child = windowContainer = new Container
{
BorderColour = window_stroke,
BorderThickness = 20,
Masking = true,
Children = new Drawable[]
{
new Box
{
RelativeSizeAxes = Axes.Both,
Colour = window_fill
},
windowCaption = new TextFlowContainer(sprite =>
{
sprite.Font = sprite.Font.With(size: 150);
sprite.Colour = Color4.White;
})
{
RelativeSizeAxes = Axes.Both,
Padding = new MarginPadding(50),
Colour = Color4.White
}
}
}
}
}
},
new FillFlowContainer
{
Padding = new MarginPadding(10),
Children = new[]
{
currentActualSize,
currentClientSize,
currentWindowMode,
currentDisplay
},
}
}
};
windowMode.ValueChanged += newMode => currentWindowMode.Text = $"Window Mode: {newMode}";
windowMode.TriggerChange();
}
private void load(FrameworkConfigManager config, OsuConfigManager osuConfig, OsuGameBase game, GameHost host)
{
this.game = game;
scalingMode = osuConfig.GetBindable <ScalingMode>(OsuSetting.Scaling);
sizeFullscreen = config.GetBindable <Size>(FrameworkSetting.SizeFullscreen);
scalingSizeX = osuConfig.GetBindable <float>(OsuSetting.ScalingSizeX);
scalingSizeY = osuConfig.GetBindable <float>(OsuSetting.ScalingSizeY);
scalingPositionX = osuConfig.GetBindable <float>(OsuSetting.ScalingPositionX);
scalingPositionY = osuConfig.GetBindable <float>(OsuSetting.ScalingPositionY);
if (host.Window != null)
{
windowModes.BindTo(host.Window.SupportedWindowModes);
}
Container resolutionSettingsContainer;
Children = new Drawable[]
{
windowModeDropdown = new SettingsDropdown <WindowMode>
{
LabelText = "Screen mode",
Bindable = config.GetBindable <WindowMode>(FrameworkSetting.WindowMode),
ItemSource = windowModes,
},
resolutionSettingsContainer = new Container
{
RelativeSizeAxes = Axes.X,
AutoSizeAxes = Axes.Y
},
new SettingsSlider <float, UIScaleSlider>
{
LabelText = "UI Scaling",
TransferValueOnCommit = true,
Bindable = osuConfig.GetBindable <float>(OsuSetting.UIScale),
KeyboardStep = 0.01f
},
new SettingsEnumDropdown <ScalingMode>
{
LabelText = "Screen Scaling",
Bindable = osuConfig.GetBindable <ScalingMode>(OsuSetting.Scaling),
},
scalingSettings = new FillFlowContainer <SettingsSlider <float> >
{
Direction = FillDirection.Vertical,
RelativeSizeAxes = Axes.X,
AutoSizeAxes = Axes.Y,
AutoSizeDuration = transition_duration,
AutoSizeEasing = Easing.OutQuint,
Masking = true,
Children = new[]
{
new SettingsSlider <float>
{
LabelText = "Horizontal position",
Bindable = scalingPositionX,
KeyboardStep = 0.01f
},
new SettingsSlider <float>
{
LabelText = "Vertical position",
Bindable = scalingPositionY,
KeyboardStep = 0.01f
},
new SettingsSlider <float>
{
LabelText = "Horizontal scale",
Bindable = scalingSizeX,
KeyboardStep = 0.01f
},
new SettingsSlider <float>
{
LabelText = "Vertical scale",
Bindable = scalingSizeY,
KeyboardStep = 0.01f
},
}
},
};
scalingSettings.ForEach(s => bindPreviewEvent(s.Bindable));
var resolutions = getResolutions();
if (resolutions.Count > 1)
{
resolutionSettingsContainer.Child = resolutionDropdown = new ResolutionSettingsDropdown
{
LabelText = "Resolution",
ShowsDefaultIndicator = false,
Items = resolutions,
Bindable = sizeFullscreen
};
windowModeDropdown.Bindable.BindValueChanged(mode =>
{
if (mode.NewValue == WindowMode.Fullscreen)
{
resolutionDropdown.Show();
sizeFullscreen.TriggerChange();
}
else
{
resolutionDropdown.Hide();
}
}, true);
}
scalingMode.BindValueChanged(mode =>
{
scalingSettings.ClearTransforms();
scalingSettings.AutoSizeAxes = mode.NewValue != ScalingMode.Off ? Axes.Y : Axes.None;
if (mode.NewValue == ScalingMode.Off)
{
scalingSettings.ResizeHeightTo(0, transition_duration, Easing.OutQuint);
}
scalingSettings.ForEach(s => s.TransferValueOnCommit = mode.NewValue == ScalingMode.Everything);
}, true);
windowModes.ItemsAdded += _ => windowModesChanged();
windowModes.ItemsRemoved += _ => windowModesChanged();
windowModesChanged();
}
private void load(OsuConfigManager config)
{
showKeyCounter = config.GetBindable <bool>(OsuConfig.KeyOverlay);
showKeyCounter.ValueChanged += visibilityChanged;
showKeyCounter.TriggerChange();
}
private void load(AudioManager audio, OsuConfigManager config, OsuGame osu)
{
dimLevel = config.GetBindable <double>(OsuSetting.DimLevel);
mouseWheelDisabled = config.GetBindable <bool>(OsuSetting.MouseDisableWheel);
sampleRestart = audio.Sample.Get(@"Gameplay/restart");
Ruleset rulesetInstance;
try
{
if (Beatmap.Value.Beatmap == null)
{
throw new InvalidOperationException("Beatmap was not loaded");
}
ruleset = osu?.Ruleset.Value ?? Beatmap.Value.BeatmapInfo.Ruleset;
rulesetInstance = ruleset.CreateInstance();
try
{
HitRenderer = rulesetInstance.CreateHitRendererWith(Beatmap, ruleset.ID == Beatmap.Value.BeatmapInfo.Ruleset.ID);
}
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.Value.BeatmapInfo.Ruleset;
rulesetInstance = ruleset.CreateInstance();
HitRenderer = rulesetInstance.CreateHitRendererWith(Beatmap, true);
}
if (!HitRenderer.Objects.Any())
{
throw new InvalidOperationException("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;
}
adjustableSourceClock = (IAdjustableClock)Beatmap.Value.Track ?? new StopwatchClock();
decoupledClock = new DecoupleableInterpolatingFramedClock {
IsCoupled = false
};
var firstObjectTime = HitRenderer.Objects.First().StartTime;
decoupledClock.Seek(Math.Min(0, firstObjectTime - Math.Max(Beatmap.Value.Beatmap.ControlPointInfo.TimingPointAt(firstObjectTime).BeatLength * 4, Beatmap.Value.BeatmapInfo.AudioLeadIn)));
decoupledClock.ProcessFrame();
offsetClock = new FramedOffsetClock(decoupledClock);
userAudioOffset = config.GetBindable <double>(OsuSetting.AudioOffset);
userAudioOffset.ValueChanged += v => offsetClock.Offset = v;
userAudioOffset.TriggerChange();
Schedule(() =>
{
adjustableSourceClock.Reset();
foreach (var mod in Beatmap.Value.Mods.Value.OfType <IApplicableToClock>())
{
mod.ApplyToClock(adjustableSourceClock);
}
decoupledClock.ChangeSource(adjustableSourceClock);
});
Children = new Drawable[]
{
pauseContainer = new PauseContainer
{
AudioClock = decoupledClock,
FramedClock = offsetClock,
OnRetry = Restart,
OnQuit = Exit,
CheckCanPause = () => ValidForResume && !HasFailed && !HitRenderer.HasReplayLoaded,
Retries = RestartCount,
OnPause = () => {
hudOverlay.KeyCounter.IsCounting = pauseContainer.IsPaused;
},
OnResume = () => {
hudOverlay.KeyCounter.IsCounting = true;
},
Children = new Drawable[]
{
new SkipButton(firstObjectTime)
{
AudioClock = decoupledClock
},
new Container
{
RelativeSizeAxes = Axes.Both,
Clock = offsetClock,
Children = new Drawable[]
{
HitRenderer,
}
},
hudOverlay = new HUDOverlay
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre
},
}
},
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();
},
}
};
scoreProcessor = HitRenderer.CreateScoreProcessor();
hudOverlay.KeyCounter.AddRange(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);
hudOverlay.ModDisplay.Current.BindTo(Beatmap.Value.Mods);
//bind HitRenderer to ScoreProcessor and ourselves (for a pass situation)
HitRenderer.OnAllJudged += onCompletion;
//bind ScoreProcessor to ourselves (for a fail situation)
scoreProcessor.Failed += onFail;
}
protected override void UpdateWindowMode(WindowMode mode)
{
base.UpdateWindowMode(mode);
ConfineMouseMode.TriggerChange();
}
private void load()
{
if (!Host.IsPrimaryInstance && !DebugUtils.IsDebugBuild)
{
Logger.Log(@"osu! does not support multiple running instances.", LoggingTarget.Runtime, LogLevel.Error);
Environment.Exit(0);
}
if (args?.Length > 0)
{
var paths = args.Where(a => !a.StartsWith('-')).ToArray();
if (paths.Length > 0)
{
Task.Run(() => Import(paths));
}
}
dependencies.CacheAs(this);
dependencies.Cache(SentryLogger);
dependencies.Cache(osuLogo = new OsuLogo {
Alpha = 0
});
// bind config int to database RulesetInfo
configRuleset = LocalConfig.GetBindable <int>(OsuSetting.Ruleset);
Ruleset.Value = RulesetStore.GetRuleset(configRuleset.Value) ?? RulesetStore.AvailableRulesets.First();
Ruleset.ValueChanged += r => configRuleset.Value = r.NewValue.ID ?? 0;
// bind config int to database SkinInfo
configSkin = LocalConfig.GetBindable <int>(OsuSetting.Skin);
SkinManager.CurrentSkinInfo.ValueChanged += skin => configSkin.Value = skin.NewValue.ID;
configSkin.ValueChanged += skinId =>
{
var skinInfo = SkinManager.Query(s => s.ID == skinId.NewValue);
if (skinInfo == null)
{
switch (skinId.NewValue)
{
case -1:
skinInfo = DefaultLegacySkin.Info;
break;
default:
skinInfo = SkinInfo.Default;
break;
}
}
SkinManager.CurrentSkinInfo.Value = skinInfo;
};
configSkin.TriggerChange();
IsActive.BindValueChanged(active => updateActiveState(active.NewValue), true);
Audio.AddAdjustment(AdjustableProperty.Volume, inactiveVolumeFade);
SelectedMods.BindValueChanged(modsChanged);
Beatmap.BindValueChanged(beatmapChanged, true);
}
protected override void LoadComplete()
{
base.LoadComplete();
visualisation.AccentColour = ACCENT_COLOR.Opacity(0.5f);
showVisualisation.TriggerChange();
}
public new void Add(Drawable drawable)
{
Current.Add(drawable);
AbstractionLevel.TriggerChange();
}
private void load(OsuConfigManager config)
{
showKeyCounter = config.GetBindable <bool>(OsuSetting.KeyOverlay);
showKeyCounter.ValueChanged += keyCounterVisibility => this.FadeTo(keyCounterVisibility ? 1 : 0, duration);
showKeyCounter.TriggerChange();
}
public AbstractionField(Bindable <int> abstraction = null)
{
if (abstraction == null)
{
abstraction = new Bindable <int> {
Value = 0
}
}
;
AbstractionLevel = abstraction;
RelativeSizeAxes = Axes.Both;
Name = "AbstractionField";
Children = new Drawable[]
{
FullAbstraction.WithEffect(new GlowEffect
{
Strength = 8f,
BlurSigma = new Vector2(16)
}),
HalfAbstraction.WithEffect(new GlowEffect
{
Strength = 4f,
BlurSigma = new Vector2(8)
}),
QuarterAbstraction.WithEffect(new GlowEffect
{
Strength = 2f,
BlurSigma = new Vector2(4)
}),
Current
};
AbstractionLevel.ValueChanged += value =>
{
List <Drawable> q = new List <Drawable>();
List <Drawable> h = new List <Drawable>();
List <Drawable> f = new List <Drawable>();
foreach (Drawable draw in QuarterAbstraction)
{
q.Add(draw);
}
foreach (Drawable draw in HalfAbstraction)
{
h.Add(draw);
}
foreach (Drawable draw in FullAbstraction)
{
f.Add(draw);
}
foreach (Drawable draw in q)
{
QuarterAbstraction.Remove(draw);
Current.Add(draw);
}
foreach (Drawable draw in h)
{
HalfAbstraction.Remove(draw);
Current.Add(draw);
}
foreach (Drawable draw in f)
{
FullAbstraction.Remove(draw);
Current.Add(draw);
}
if (value >= 1)
{
List <Drawable> quarter = new List <Drawable>();
foreach (Drawable draw in Current)
{
//if (draw is DrawableBullet bullet && bullet.Bullet.Abstraction < value)
//quarter.Add(bullet);
if (draw is DrawableTHSharpPlayer player && player.Abstraction < value)
{
quarter.Add(player);
}
if (draw is Enemy enemy && enemy.Abstraction < value)
{
quarter.Add(enemy);
}
}
foreach (Drawable draw in quarter)
{
Current.Remove(draw);
QuarterAbstraction.Add(draw);
}
}
if (value >= 2)
{
List <Drawable> half = new List <Drawable>();
foreach (Drawable draw in QuarterAbstraction)
{
//if (draw is DrawableBullet bullet && bullet.Bullet.Abstraction < value - 1)
//half.Add(bullet);
if (draw is DrawableTHSharpPlayer player && player.Abstraction < value - 1)
{
half.Add(player);
}
if (draw is Enemy enemy && enemy.Abstraction < value - 1)
{
half.Add(enemy);
}
}
foreach (Drawable draw in half)
{
QuarterAbstraction.Remove(draw);
HalfAbstraction.Add(draw);
}
}
if (value >= 3)
{
List <Drawable> full = new List <Drawable>();
foreach (Drawable draw in HalfAbstraction)
{
//if (draw is DrawableBullet bullet && bullet.Bullet.Abstraction < value - 2)
//full.Add(bullet);
if (draw is DrawableTHSharpPlayer player && player.Abstraction < value - 2)
{
full.Add(player);
}
if (draw is Enemy enemy && enemy.Abstraction < value - 2)
{
full.Add(enemy);
}
}
foreach (Drawable draw in full)
{
HalfAbstraction.Remove(draw);
FullAbstraction.Add(draw);
}
}
};
AbstractionLevel.TriggerChange();
}
protected override void LoadComplete()
{
base.LoadComplete();
Add(new Drawable[] {
new VolumeControlReceptor
{
RelativeSizeAxes = Axes.Both,
ActionRequested = delegate(InputState state) { volume.Adjust(state); }
},
mainContent = new Container
{
RelativeSizeAxes = Axes.Both,
},
volume = new VolumeControl(),
overlayContent = new Container {
RelativeSizeAxes = Axes.Both
},
new GlobalHotkeys //exists because UserInputManager is at a level below us.
{
Handler = globalHotkeyPressed
}
});
(modeStack = new Intro()).Preload(this, d =>
{
mainContent.Add(d);
modeStack.ModePushed += modeAdded;
modeStack.Exited += modeRemoved;
modeStack.DisplayAsRoot();
});
//overlay elements
(chat = new ChatConsole(API)
{
Depth = 0
}).Preload(this, overlayContent.Add);
(Options = new OptionsOverlay {
Depth = 1
}).Preload(this, overlayContent.Add);
(musicController = new MusicController()
{
Depth = 3
}).Preload(this, overlayContent.Add);
(Toolbar = new Toolbar
{
Depth = 2,
OnHome = delegate { mainMenu?.MakeCurrent(); },
OnSettings = Options.ToggleVisibility,
OnPlayModeChange = delegate(PlayMode m) { PlayMode.Value = m; },
OnMusicController = musicController.ToggleVisibility
}).Preload(this, t =>
{
PlayMode.ValueChanged += delegate { Toolbar.SetGameMode(PlayMode.Value); };
PlayMode.TriggerChange();
overlayContent.Add(Toolbar);
});
Cursor.Alpha = 0;
}
public void ApplyCurrentLayoutChange(Action <LyricLayout> action)
{
action?.Invoke(EditLayout.Value);
EditLayout.TriggerChange();
}
protected override void LoadComplete()
{
base.LoadComplete();
beatmapBacking.ValueChanged += b => list.SelectedItem = b?.BeatmapSetInfo;
beatmapBacking.TriggerChange();
}
private void setupConfig()
{
Dependencies.Cache(debugConfig = new FrameworkDebugConfigManager());
Dependencies.Cache(config = new FrameworkConfigManager(Storage));
Dependencies.Cache(Localisation = new LocalisationEngine(config));
activeGCMode = debugConfig.GetBindable <GCLatencyMode>(DebugSetting.ActiveGCMode);
activeGCMode.ValueChanged += newMode =>
{
GCSettings.LatencyMode = IsActive ? newMode : GCLatencyMode.Interactive;
};
frameSyncMode = config.GetBindable <FrameSync>(FrameworkSetting.FrameSync);
frameSyncMode.ValueChanged += newMode =>
{
float refreshRate = DisplayDevice.Default.RefreshRate;
// For invalid refresh rates let's assume 60 Hz as it is most common.
if (refreshRate <= 0)
{
refreshRate = 60;
}
float drawLimiter = refreshRate;
float updateLimiter = drawLimiter * 2;
setVSyncMode();
switch (newMode)
{
case FrameSync.VSync:
drawLimiter = int.MaxValue;
updateLimiter *= 2;
break;
case FrameSync.Limit2x:
drawLimiter *= 2;
updateLimiter *= 2;
break;
case FrameSync.Limit4x:
drawLimiter *= 4;
updateLimiter *= 4;
break;
case FrameSync.Limit8x:
drawLimiter *= 8;
updateLimiter *= 8;
break;
case FrameSync.Unlimited:
drawLimiter = updateLimiter = int.MaxValue;
break;
}
if (DrawThread != null)
{
DrawThread.ActiveHz = drawLimiter;
}
if (UpdateThread != null)
{
UpdateThread.ActiveHz = updateLimiter;
}
};
ignoredInputHandlers = config.GetBindable <string>(FrameworkSetting.IgnoredInputHandlers);
ignoredInputHandlers.ValueChanged += ignoredString =>
{
var configIgnores = ignoredString.Split(' ').Where(s => !string.IsNullOrWhiteSpace(s));
// for now, we always want at least one handler disabled (don't want raw and non-raw mouse at once).
bool restoreDefaults = !configIgnores.Any();
if (restoreDefaults)
{
resetInputHandlers();
ignoredInputHandlers.Value = string.Join(" ", AvailableInputHandlers.Where(h => !h.Enabled).Select(h => h.ToString()));
}
else
{
foreach (var handler in AvailableInputHandlers)
{
var handlerType = handler.ToString();
handler.Enabled.Value = configIgnores.All(ch => ch != handlerType);
}
}
};
cursorSensitivity = config.GetBindable <double>(FrameworkSetting.CursorSensitivity);
performanceLogging = config.GetBindable <bool>(FrameworkSetting.PerformanceLogging);
performanceLogging.ValueChanged += enabled => threads.ForEach(t => t.Monitor.EnablePerformanceProfiling = enabled);
performanceLogging.TriggerChange();
}
