1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-16 20:13:21 +08:00
osu-lazer/osu.Game/OsuGame.cs

334 lines
10 KiB
C#
Raw Normal View History

// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
2016-08-26 11:28:23 +08:00
using System;
using osu.Framework.Configuration;
2017-02-17 17:59:30 +08:00
using osu.Framework.Screens;
2016-08-26 11:28:23 +08:00
using osu.Game.Configuration;
2016-09-01 18:06:09 +08:00
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
2016-10-01 17:01:52 +08:00
using osu.Game.Overlays;
using osu.Framework.Input;
using osu.Game.Input;
using OpenTK.Input;
using osu.Framework.Logging;
using osu.Game.Graphics.UserInterface.Volume;
2016-11-09 07:13:20 +08:00
using osu.Framework.Allocation;
using osu.Framework.Timing;
2016-11-14 17:03:20 +08:00
using osu.Game.Modes;
2016-12-01 13:22:29 +08:00
using osu.Game.Overlays.Toolbar;
2016-11-14 16:23:33 +08:00
using osu.Game.Screens;
using osu.Game.Screens.Menu;
using OpenTK;
2017-02-05 05:03:39 +08:00
using System.Linq;
2017-02-08 18:32:55 +08:00
using osu.Framework.Graphics.Primitives;
2017-02-24 17:10:37 +08:00
using System.Threading.Tasks;
using osu.Framework.Threading;
2017-03-04 18:02:36 +08:00
using osu.Game.Graphics;
using osu.Game.Modes.Scoring;
using osu.Game.Overlays.Notifications;
2017-03-04 18:02:36 +08:00
using osu.Game.Screens.Play;
2016-08-26 11:28:23 +08:00
namespace osu.Game
{
public class OsuGame : OsuGameBase
2016-08-26 11:28:23 +08:00
{
2016-10-01 17:01:52 +08:00
public Toolbar Toolbar;
private ChatOverlay chat;
private MusicController musicController;
2017-02-10 15:26:43 +08:00
private NotificationManager notificationManager;
private DialogOverlay dialogOverlay;
private Intro intro
{
get
{
Screen s = screenStack;
while (s != null && !(s is Intro))
s = s.ChildScreen;
return s as Intro;
}
}
2017-02-17 17:59:30 +08:00
private OsuScreen screenStack;
private VolumeControl volume;
public Bindable<PlayMode> PlayMode;
2016-10-13 22:21:15 +08:00
private readonly string[] args;
private OptionsOverlay options;
2016-11-08 18:26:12 +08:00
public OsuGame(string[] args = null)
{
this.args = args;
}
2016-10-01 17:01:52 +08:00
public void ToggleOptions() => options.ToggleVisibility();
[BackgroundDependencyLoader]
private void load()
2016-08-26 11:28:23 +08:00
{
if (!Host.IsPrimaryInstance)
{
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(@"-"));
Task.Run(() => BeatmapDatabase.Import(paths));
}
2016-11-11 06:40:42 +08:00
Dependencies.Cache(this);
PlayMode = LocalConfig.GetBindable<PlayMode>(OsuConfig.PlayMode);
}
private ScheduledDelegate scoreLoad;
2017-03-04 18:02:36 +08:00
protected void LoadScore(Score s)
{
scoreLoad?.Cancel();
2017-03-04 18:02:36 +08:00
var menu = intro.ChildScreen;
if (menu == null)
{
scoreLoad = Schedule(() => LoadScore(s));
2017-03-04 18:02:36 +08:00
return;
}
if (!menu.IsCurrentScreen)
{
menu.MakeCurrent();
Delay(500);
scoreLoad = Schedule(() => LoadScore(s));
2017-03-04 18:02:36 +08:00
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)));
2017-03-04 18:02:36 +08:00
}
protected override void LoadComplete()
{
base.LoadComplete();
2016-11-01 22:24:14 +08:00
2016-09-30 17:45:55 +08:00
Add(new Drawable[] {
new VolumeControlReceptor
{
RelativeSizeAxes = Axes.Both,
ActionRequested = delegate(InputState state) { volume.Adjust(state); }
},
2016-11-01 22:24:14 +08:00
mainContent = new Container
{
2016-11-01 22:24:14 +08:00
RelativeSizeAxes = Axes.Both,
},
2016-11-23 19:26:46 +08:00
volume = new VolumeControl(),
overlayContent = new Container{ RelativeSizeAxes = Axes.Both },
new GlobalHotkeys //exists because UserInputManager is at a level below us.
{
Handler = globalHotkeyPressed
}
2016-09-30 17:45:55 +08:00
});
2017-04-02 14:56:12 +08:00
LoadComponentAsync(screenStack = new Loader(), d =>
2016-11-01 22:24:14 +08:00
{
2017-02-17 17:59:30 +08:00
screenStack.ModePushed += screenAdded;
screenStack.Exited += screenRemoved;
mainContent.Add(screenStack);
2016-11-01 22:24:14 +08:00
});
//overlay elements
2017-04-02 14:56:12 +08:00
LoadComponentAsync(chat = new ChatOverlay { Depth = 0 }, overlayContent.Add);
LoadComponentAsync(options = new OptionsOverlay { Depth = -1 }, overlayContent.Add);
LoadComponentAsync(musicController = new MusicController
{
2017-01-31 16:05:54 +08:00
Depth = -2,
Position = new Vector2(0, Toolbar.HEIGHT),
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
2017-04-02 14:56:12 +08:00
}, overlayContent.Add);
2017-04-02 14:56:12 +08:00
LoadComponentAsync(notificationManager = new NotificationManager
2017-02-10 15:26:43 +08:00
{
Depth = -2,
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
2017-04-02 14:56:12 +08:00
}, overlayContent.Add);
2017-02-10 15:26:43 +08:00
2017-04-02 14:56:12 +08:00
LoadComponentAsync(dialogOverlay = new DialogOverlay
{
Depth = -4,
2017-04-02 14:56:12 +08:00
}, 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);
2017-02-10 15:26:43 +08:00
Dependencies.Cache(notificationManager);
Dependencies.Cache(dialogOverlay);
2017-04-02 14:56:12 +08:00
LoadComponentAsync(Toolbar = new Toolbar
2016-11-01 22:24:14 +08:00
{
2017-01-31 16:05:54 +08:00
Depth = -3,
OnHome = delegate { intro?.ChildScreen?.MakeCurrent(); },
OnPlayModeChange = m => PlayMode.Value = m,
2017-04-02 14:56:12 +08:00
}, t =>
2016-11-01 22:24:14 +08:00
{
PlayMode.ValueChanged += delegate { Toolbar.SetGameMode(PlayMode.Value); };
PlayMode.TriggerChange();
overlayContent.Add(Toolbar);
2016-11-01 22:24:14 +08:00
});
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;
}
};
2017-03-16 22:58:36 +08:00
Cursor.State = Visibility.Hidden;
}
private bool globalHotkeyPressed(InputState state, KeyDownEventArgs args)
{
if (args.Repeat || intro == null) return false;
switch (args.Key)
{
case Key.F8:
chat.ToggleVisibility();
return true;
case Key.PageUp:
case Key.PageDown:
2017-03-07 09:59:19 +08:00
var swClock = (Clock as ThrottledFrameClock)?.Source as StopwatchClock;
if (swClock == null) return false;
swClock.Rate *= args.Key == Key.PageUp ? 1.1f : 0.9f;
Logger.Log($@"Adjusting game clock to {swClock.Rate}", LoggingTarget.Debug);
return true;
}
2016-10-13 22:21:15 +08:00
2016-11-08 18:27:37 +08:00
if (state.Keyboard.ControlPressed)
{
switch (args.Key)
{
2017-02-08 18:28:18 +08:00
case Key.T:
Toolbar.ToggleVisibility();
return true;
2016-11-08 18:27:37 +08:00
case Key.O:
options.ToggleVisibility();
2016-11-08 18:27:37 +08:00
return true;
}
}
2017-02-27 23:18:12 +08:00
return false;
}
2017-03-14 07:22:46 +08:00
public event Action<Screen> ScreenChanged;
2016-11-01 22:24:14 +08:00
private Container mainContent;
private Container overlayContent;
2017-03-16 22:58:36 +08:00
private OsuScreen currentScreen;
2017-03-14 07:22:46 +08:00
private void screenChanged(Screen newScreen)
{
2017-03-16 22:58:36 +08:00
currentScreen = newScreen as OsuScreen;
if (currentScreen == null)
{
Exit();
return;
}
//central game mode change logic.
2017-03-18 01:03:44 +08:00
if (!currentScreen.ShowOverlays)
2016-10-06 22:32:56 +08:00
{
2017-03-21 23:20:15 +08:00
options.State = Visibility.Hidden;
2016-10-13 22:21:15 +08:00
Toolbar.State = Visibility.Hidden;
musicController.State = Visibility.Hidden;
chat.State = Visibility.Hidden;
2016-10-06 22:32:56 +08:00
}
else
2016-10-06 22:32:56 +08:00
{
2016-10-13 22:21:15 +08:00
Toolbar.State = Visibility.Visible;
2016-10-06 22:32:56 +08:00
}
2017-03-14 07:22:46 +08:00
ScreenChanged?.Invoke(newScreen);
}
protected override bool OnExiting()
{
2017-02-18 13:16:46 +08:00
if (screenStack.ChildScreen == null) return false;
if (intro == null) return true;
2017-02-17 17:59:30 +08:00
if (!intro.DidLoadMenu || intro.ChildScreen != null)
{
2017-02-17 14:33:08 +08:00
Scheduler.Add(intro.MakeCurrent);
return true;
}
2016-10-13 22:21:15 +08:00
return base.OnExiting();
}
2017-02-08 18:32:55 +08:00
protected override void UpdateAfterChildren()
{
base.UpdateAfterChildren();
if (intro?.ChildScreen != null)
intro.ChildScreen.Padding = new MarginPadding { Top = Toolbar.Position.Y + Toolbar.DrawHeight };
2017-03-16 22:58:36 +08:00
Cursor.State = currentScreen == null || currentScreen.HasLocalCursorDisplayed ? Visibility.Hidden : Visibility.Visible;
2017-02-08 18:32:55 +08:00
}
2017-02-17 17:59:30 +08:00
private void screenAdded(Screen newScreen)
{
2017-02-17 17:59:30 +08:00
newScreen.ModePushed += screenAdded;
newScreen.Exited += screenRemoved;
2017-03-14 07:22:46 +08:00
screenChanged(newScreen);
}
2017-02-17 17:59:30 +08:00
private void screenRemoved(Screen newScreen)
{
2017-03-14 07:22:46 +08:00
screenChanged(newScreen);
2016-08-26 11:28:23 +08:00
}
}
}