h1or4dme8/osu-lazer
1
0
Fork 0
mirror of https://github.com/ppy/osu.git synced 2024-09-21 22:07:25 +08:00
Code Issues Releases Wiki Activity

Merge branch 'master' into mania-notes

Browse Source 
# Conflicts:
#	osu.Desktop.VisualTests/osu.Desktop.VisualTests.csproj
This commit is contained in:
smoogipooo 2017-05-08 12:12:40 +09:00
commit e3b01e7b8c
83 changed files with 1089 additions and 1210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
.vscode/launch.json vendored
View File

@ -2,46 +2,60 @@
"version": "0.2.0",
"configurations": [
{
"name": "Launch VisualTests",
"name": "VisualTests (debug)",
"windows": {
"type": "clr"
},
"type": "mono",
"request": "launch",
"program": "${workspaceRoot}/osu.Desktop.VisualTests/bin/Debug/osu!.exe",
"args": [],
"cwd": "${workspaceRoot}",
"preLaunchTask": "build",
"preLaunchTask": "Build (Debug)",
"runtimeExecutable": null,
"env": {},
"console": "internalConsole"
},
{
"name": "Launch Desktop",
"name": "VisualTests (release)",
"windows": {
"type": "clr"
},
"type": "mono",
"request": "launch",
"program": "${workspaceRoot}/osu.Desktop.VisualTests/bin/Release/osu!.exe",
"cwd": "${workspaceRoot}",
"preLaunchTask": "Build (Release)",
"runtimeExecutable": null,
"env": {},
"console": "internalConsole"
},
{
"name": "osu! (debug)",
"windows": {
"type": "clr"
},
"type": "mono",
"request": "launch",
"program": "${workspaceRoot}/osu.Desktop/bin/Debug/osu!.exe",
"args": [],
"cwd": "${workspaceRoot}",
"preLaunchTask": "build",
"preLaunchTask": "Build (Debug)",
"runtimeExecutable": null,
"env": {},
"console": "internalConsole"
},
{
"name": "Attach",
"name": "osu! (release)",
"windows": {
"type": "clr",
"request": "attach",
"processName": "osu!"
"type": "clr"
},
"type": "mono",
"request": "attach",
"address": "localhost",
"port": 55555
"request": "launch",
"program": "${workspaceRoot}/osu.Desktop/bin/Release/osu!.exe",
"cwd": "${workspaceRoot}",
"preLaunchTask": "Build (Release)",
"runtimeExecutable": null,
"env": {},
"console": "internalConsole"
}
]
}

77
.vscode/tasks.json vendored
View File

@ -1,51 +1,50 @@
{
// See https://go.microsoft.com/fwlink/?LinkId=733558
// for the documentation about the tasks.json format
"version": "0.1.0",
"taskSelector": "/t:",
"version": "2.0.0",
"problemMatcher": "$msCompile",
"isShellCommand": true,
"command": "msbuild",
"suppressTaskName": true,
"showOutput": "silent",
"args": [
"/property:GenerateFullPaths=true",
"/property:DebugType=portable"
],
"windows": {
"args": [
"/property:GenerateFullPaths=true",
"/property:DebugType=portable",
"/m" //parallel compiling support. doesn't work well with mono atm
]
},
"tasks": [
{
"taskName": "build",
"isShellCommand": true,
"showOutput": "silent",
"command": "msbuild",
"args": [
"/property:GenerateFullPaths=true",
"/property:DebugType=portable"
],
"windows": {
"args": [
"/property:GenerateFullPaths=true",
"/property:DebugType=portable",
"/m" //parallel compiling support. doesn't work well with mono atm
]
},
// Use the standard MS compiler pattern to detect errors, warnings and infos
"problemMatcher": "$msCompile",
"taskName": "Build (Debug)",
"isBuildCommand": true
},
{
"taskName": "rebuild",
"isShellCommand": true,
"showOutput": "silent",
"command": "msbuild",
"taskName": "Build (Release)",
"args": [
// Ask msbuild to generate full paths for file names.
"/property:GenerateFullPaths=true",
"/property:DebugType=portable",
"/target:Clean,Build"
],
"windows": {
"args": [
"/property:GenerateFullPaths=true",
"/property:DebugType=portable",
"/target:Clean,Build",
"/m" //parallel compiling support. doesn't work well with mono atm
]
},
// Use the standard MS compiler pattern to detect errors, warnings and infos
"problemMatcher": "$msCompile",
"isBuildCommand": true
"/property:Configuration=Release"
]
},
{
"taskName": "Clean All",
"dependsOn": ["Clean (Debug)", "Clean (Release)"]
},
{
"taskName": "Clean (Debug)",
"args": [
"/target:Clean"
]
},
{
"taskName": "Clean (Release)",
"args": [
"/target:Clean",
"/property:Configuration=Release"
]
}
]
}

2
osu-framework

@ -1 +1 @@
Subproject commit 72525837cf68aa9967cfede6fbe95489ed3b05ec
Subproject commit cebdfb1bbb260e5aaca0a01e06d7128b3d1faae4

70
osu.Desktop.VisualTests/Tests/TestCaseManiaPlayfield.cs Normal file
View File

@ -0,0 +1,70 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using osu.Framework.Extensions.IEnumerableExtensions;
using osu.Framework.Input;
using osu.Framework.Testing;
using osu.Framework.Graphics;
using osu.Game.Rulesets.Mania.UI;
using System.Linq;
using System;
namespace osu.Desktop.VisualTests.Tests
{
internal class TestCaseManiaPlayfield : TestCase
{
public override string Description => @"Mania playfield";
protected override double TimePerAction => 200;
public override void Reset()
{
base.Reset();
const int max_columns = 10;
Action<int, SpecialColumnPosition> createPlayfield = (cols, pos) =>
{
Clear();
Add(new ManiaPlayfield(cols)
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
SpecialColumnPosition = pos
});
};
for (int i = 1; i <= max_columns; i++)
{
int tempI = i;
AddStep($"{i} column" + (i > 1 ? "s" : ""), () => createPlayfield(tempI, SpecialColumnPosition.Normal));
AddStep("Trigger keys down", () => ((ManiaPlayfield)Children.First()).Columns.Children.ForEach(triggerKeyDown));
AddStep("Trigger keys up", () => ((ManiaPlayfield)Children.First()).Columns.Children.ForEach(triggerKeyUp));
AddStep("Left special style", () => createPlayfield(tempI, SpecialColumnPosition.Left));
AddStep("Right special style", () => createPlayfield(tempI, SpecialColumnPosition.Right));
}
AddStep("Normal special style", () => createPlayfield(max_columns, SpecialColumnPosition.Normal));
}
private void triggerKeyDown(Column column)
{
column.TriggerKeyDown(new InputState(), new KeyDownEventArgs
{
Key = column.Key,
Repeat = false
});
}
private void triggerKeyUp(Column column)
{
column.TriggerKeyUp(new InputState(), new KeyUpEventArgs
{
Key = column.Key
});
}
}
}

19
osu.Desktop.VisualTests/Tests/TestCaseModSelectOverlay.cs → osu.Desktop.VisualTests/Tests/TestCaseMods.cs
View File

@ -6,16 +6,21 @@ using osu.Framework.Graphics;
using osu.Game.Overlays.Mods;
using osu.Framework.Testing;
using osu.Game.Database;
using osu.Game.Screens.Play.HUD;
using OpenTK;
namespace osu.Desktop.VisualTests.Tests
{
internal class TestCaseModSelectOverlay : TestCase
internal class TestCaseMods : TestCase
{
public override string Description => @"Tests the mod select overlay";
public override string Description => @"Mod select overlay and in-game display";
private ModSelectOverlay modSelect;
private ModDisplay modDisplay;
private RulesetDatabase rulesets;
[BackgroundDependencyLoader]
private void load(RulesetDatabase rulesets)
{
@ -33,6 +38,16 @@ namespace osu.Desktop.VisualTests.Tests
Anchor = Anchor.BottomCentre,
});
Add(modDisplay = new ModDisplay
{
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
AutoSizeAxes = Axes.Both,
Position = new Vector2(0, 25),
});
modDisplay.Current.BindTo(modSelect.SelectedMods);
AddStep("Toggle", modSelect.ToggleVisibility);
foreach (var ruleset in rulesets.AllRulesets)

2
osu.Desktop.VisualTests/Tests/TestCaseScoreCounter.cs
View File

@ -8,7 +8,7 @@ using osu.Framework.Graphics.Sprites;
using osu.Framework.MathUtils;
using osu.Framework.Testing;
using osu.Game.Graphics.UserInterface;
using osu.Game.Rulesets.UI;
using osu.Game.Screens.Play.HUD;
namespace osu.Desktop.VisualTests.Tests
{

2
osu.Desktop.VisualTests/VisualTestGame.cs
View File

@ -29,7 +29,7 @@ namespace osu.Desktop.VisualTests
host.DrawThread.InactiveHz = host.DrawThread.ActiveHz;
host.InputThread.InactiveHz = host.InputThread.ActiveHz;
host.Window.CursorState = CursorState.Hidden;
host.Window.CursorState |= CursorState.Hidden;
}
}
}

3
osu.Desktop.VisualTests/osu.Desktop.VisualTests.csproj
View File

@ -191,6 +191,7 @@
<Compile Include="Tests\TestCaseGamefield.cs" />
<Compile Include="Tests\TestCaseGraph.cs" />
<Compile Include="Tests\TestCaseManiaHitObjects.cs" />
<Compile Include="Tests\TestCaseManiaPlayfield.cs" />
<Compile Include="Tests\TestCaseMenuOverlays.cs" />
<Compile Include="Tests\TestCaseMusicController.cs" />
<Compile Include="Tests\TestCaseNotificationManager.cs" />
@ -212,7 +213,7 @@
<Compile Include="Platform\TestStorage.cs" />
<Compile Include="Tests\TestCaseOptions.cs" />
<Compile Include="Tests\TestCaseSongProgress.cs" />
<Compile Include="Tests\TestCaseModSelectOverlay.cs" />
<Compile Include="Tests\TestCaseMods.cs" />
<Compile Include="Tests\TestCaseDialogOverlay.cs" />
<Compile Include="Tests\TestCaseBeatmapOptionsOverlay.cs" />
<Compile Include="Tests\TestCaseLeaderboard.cs" />

2
osu.Desktop/OsuGameDesktop.cs
View File

@ -43,7 +43,7 @@ namespace osu.Desktop
var desktopWindow = host.Window as DesktopGameWindow;
if (desktopWindow != null)
{
desktopWindow.CursorState = CursorState.Hidden;
desktopWindow.CursorState |= CursorState.Hidden;
desktopWindow.Icon = Icon.ExtractAssociatedIcon(Assembly.GetExecutingAssembly().Location);
desktopWindow.Title = Name;

1
osu.Game.Rulesets.Mania/Mods/ManiaMod.cs
View File

@ -64,6 +64,7 @@ namespace osu.Game.Rulesets.Mania.Mods
{
public override string Name => "FadeIn";
public override FontAwesome Icon => FontAwesome.fa_osu_mod_hidden;
public override ModType Type => ModType.DifficultyIncrease;
public override double ScoreMultiplier => 1;
public override bool Ranked => true;
public override Type[] IncompatibleMods => new[] { typeof(ModFlashlight) };

202
osu.Game.Rulesets.Mania/UI/Column.cs Normal file
View File

@ -0,0 +1,202 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using OpenTK;
using OpenTK.Graphics;
using OpenTK.Input;
using osu.Framework.Extensions.Color4Extensions;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Sprites;
using osu.Framework.Graphics.Colour;
using osu.Framework.Input;
using osu.Game.Graphics;
namespace osu.Game.Rulesets.Mania.UI
{
public class Column : Container, IHasAccentColour
{
private const float key_size = 50;
private const float key_icon_size = 10;
private const float key_icon_corner_radius = 3;
private const float key_icon_border_radius = 2;
private const float hit_target_height = 10;
private const float hit_target_bar_height = 2;
private const float column_width = 45;
private const float special_column_width = 70;
public Key Key;
private readonly Box background;
private readonly Container hitTargetBar;
private readonly Container keyIcon;
public Column()
{
RelativeSizeAxes = Axes.Y;
Width = column_width;
Children = new Drawable[]
{
background = new Box
{
Name = "Foreground",
RelativeSizeAxes = Axes.Both,
Alpha = 0.2f
},
new FillFlowContainer
{
Name = "Key + hit target",
Anchor = Anchor.BottomCentre,
Origin = Anchor.BottomCentre,
RelativeSizeAxes = Axes.X,
AutoSizeAxes = Axes.Y,
Direction = FillDirection.Vertical,
Children = new[]
{
new Container
{
Name = "Key",
Anchor = Anchor.BottomCentre,
Origin = Anchor.BottomCentre,
RelativeSizeAxes = Axes.X,
Height = key_size,
Children = new Drawable[]
{
new Box
{
Name = "Key gradient",
RelativeSizeAxes = Axes.Both,
ColourInfo = ColourInfo.GradientVertical(Color4.Black, Color4.Black.Opacity(0)),
Alpha = 0.5f
},
keyIcon = new Container
{
Name = "Key icon",
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Size = new Vector2(key_icon_size),
Masking = true,
CornerRadius = key_icon_corner_radius,
BorderThickness = 2,
BorderColour = Color4.White, // Not true
Children = new[]
{
new Box
{
RelativeSizeAxes = Axes.Both,
Alpha = 0,
AlwaysPresent = true
}
}
}
}
},
new Container
{
Name = "Hit target",
Anchor = Anchor.BottomCentre,
Origin = Anchor.BottomCentre,
RelativeSizeAxes = Axes.X,
Height = hit_target_height,
Children = new Drawable[]
{
new Box
{
Name = "Background",
RelativeSizeAxes = Axes.Both,
Colour = Color4.Black
},
hitTargetBar = new Container
{
Name = "Bar",
Anchor = Anchor.BottomCentre,
Origin = Anchor.BottomCentre,
RelativeSizeAxes = Axes.X,
Height = hit_target_bar_height,
Masking = true,
Children = new[]
{
new Box
{
RelativeSizeAxes = Axes.Both
}
}
}
}
}
}
}
};
}
private bool isSpecial;
public bool IsSpecial
{
get { return isSpecial; }
set
{
if (isSpecial == value)
return;
isSpecial = value;
Width = isSpecial ? special_column_width : column_width;
}
}
private Color4 accentColour;
public Color4 AccentColour
{
get { return accentColour; }
set
{
if (accentColour == value)
return;
accentColour = value;
background.Colour = accentColour;
hitTargetBar.EdgeEffect = new EdgeEffect
{
Type = EdgeEffectType.Glow,
Radius = 5,
Colour = accentColour.Opacity(0.5f),
};
keyIcon.EdgeEffect = new EdgeEffect
{
Type = EdgeEffectType.Glow,
Radius = 5,
Colour = accentColour.Opacity(0.5f),
};
}
}
protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
{
if (args.Key == Key && !args.Repeat)
{
background.FadeTo(background.Alpha + 0.2f, 50, EasingTypes.OutQuint);
keyIcon.ScaleTo(1.4f, 50, EasingTypes.OutQuint);
}
return false;
}
protected override bool OnKeyUp(InputState state, KeyUpEventArgs args)
{
if (args.Key == Key)
{
background.FadeTo(0.2f, 800, EasingTypes.OutQuart);
keyIcon.ScaleTo(1f, 400, EasingTypes.OutQuart);
}
return false;
}
}
}

152
osu.Game.Rulesets.Mania/UI/ManiaPlayfield.cs
View File

@ -8,29 +8,153 @@ using osu.Game.Rulesets.UI;
using OpenTK;
using OpenTK.Graphics;
using osu.Game.Rulesets.Mania.Judgements;
using osu.Framework.Graphics.Containers;
using System;
using osu.Framework.Graphics.Primitives;
using osu.Game.Graphics;
using osu.Framework.Allocation;
using OpenTK.Input;
using System.Linq;
using System.Collections.Generic;
namespace osu.Game.Rulesets.Mania.UI
{
public class ManiaPlayfield : Playfield<ManiaHitObject, ManiaJudgement>
{
public ManiaPlayfield(int columns)
/// <summary>
/// Default column keys, expanding outwards from the middle as more column are added.
/// E.g. 2 columns use FJ, 4 columns use DFJK, 6 use SDFJKL, etc...
/// </summary>
private static readonly Key[] default_keys = { Key.A, Key.S, Key.D, Key.F, Key.J, Key.K, Key.L, Key.Semicolon };
private SpecialColumnPosition specialColumnPosition;
/// <summary>
/// The style to use for the special column.
/// </summary>
public SpecialColumnPosition SpecialColumnPosition
{
Size = new Vector2(0.8f, 1f);
Anchor = Anchor.BottomCentre;
Origin = Anchor.BottomCentre;
get { return specialColumnPosition; }
set
{
if (IsLoaded)
throw new InvalidOperationException($"Setting {nameof(SpecialColumnPosition)} after the playfield is loaded requires re-creating the playfield.");
specialColumnPosition = value;
}
}
Add(new Box { RelativeSizeAxes = Axes.Both, Alpha = 0.5f });
public readonly FlowContainer<Column> Columns;
for (int i = 0; i < columns; i++)
Add(new Box
private List<Color4> normalColumnColours = new List<Color4>();
private Color4 specialColumnColour;
private readonly int columnCount;
public ManiaPlayfield(int columnCount)
{
this.columnCount = columnCount;
if (columnCount <= 0)
throw new ArgumentException("Can't have zero or fewer columns.");
Children = new Drawable[]
{
new Container
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.Y,
Size = new Vector2(2, 1),
RelativePositionAxes = Axes.Both,
Position = new Vector2((float)i / columns, 0),
Alpha = 0.5f,
Colour = Color4.Black
});
AutoSizeAxes = Axes.X,
Children = new Drawable[]
{
new Box
{
RelativeSizeAxes = Axes.Both,
Colour = Color4.Black
},
Columns = new FillFlowContainer<Column>
{
RelativeSizeAxes = Axes.Y,
AutoSizeAxes = Axes.X,
Direction = FillDirection.Horizontal,
Padding = new MarginPadding { Left = 1, Right = 1 },
Spacing = new Vector2(1, 0)
}
}
}
};
for (int i = 0; i < columnCount; i++)
Columns.Add(new Column());
}
[BackgroundDependencyLoader]
private void load(OsuColour colours)
{
normalColumnColours = new List<Color4>
{
colours.RedDark,
colours.GreenDark
};
specialColumnColour = colours.BlueDark;
// Set the special column + colour + key
for (int i = 0; i < columnCount; i++)
{
Column column = Columns.Children.ElementAt(i);
column.IsSpecial = isSpecialColumn(i);
if (!column.IsSpecial)
continue;
column.Key = Key.Space;
column.AccentColour = specialColumnColour;
}
var nonSpecialColumns = Columns.Children.Where(c => !c.IsSpecial).ToList();
// We'll set the colours of the non-special columns in a separate loop, because the non-special
// column colours are mirrored across their centre and special styles mess with this
for (int i = 0; i < Math.Ceiling(nonSpecialColumns.Count / 2f); i++)
{
Color4 colour = normalColumnColours[i % normalColumnColours.Count];
nonSpecialColumns[i].AccentColour = colour;
nonSpecialColumns[nonSpecialColumns.Count - 1 - i].AccentColour = colour;
}
// We'll set the keys for non-special columns in another separate loop because it's not mirrored like the above colours
// Todo: This needs to go when we get to bindings and use Button1, ..., ButtonN instead
for (int i = 0; i < nonSpecialColumns.Count; i++)
{
Column column = nonSpecialColumns[i];
int keyOffset = default_keys.Length / 2 - nonSpecialColumns.Count / 2 + i;
if (keyOffset >= 0 && keyOffset < default_keys.Length)
column.Key = default_keys[keyOffset];
else
// There is no default key defined for this column. Let's set this to Unknown for now
// however note that this will be gone after bindings are in place
column.Key = Key.Unknown;
}
}
/// <summary>
/// Whether the column index is a special column for this playfield.
/// </summary>
/// <param name="column">The 0-based column index.</param>
/// <returns>Whether the column is a special column.</returns>
private bool isSpecialColumn(int column)
{
switch (SpecialColumnPosition)
{
default:
case SpecialColumnPosition.Normal:
return columnCount % 2 == 1 && column == columnCount / 2;
case SpecialColumnPosition.Left:
return column == 0;
case SpecialColumnPosition.Right:
return column == columnCount - 1;
}
}
}
}
}

21
osu.Game.Rulesets.Mania/UI/SpecialColumnPosition.cs Normal file
View File

@ -0,0 +1,21 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
namespace osu.Game.Rulesets.Mania.UI
{
public enum SpecialColumnPosition
{
/// <summary>
/// The special column will lie in the center of the columns.
/// </summary>
Normal,
/// <summary>
/// The special column will lie to the left of the columns.
/// </summary>
Left,
/// <summary>
/// The special column will lie to the right of the columns.
/// </summary>
Right
}
}

2
osu.Game.Rulesets.Mania/osu.Game.Rulesets.Mania.csproj
View File

@ -62,10 +62,12 @@
<Compile Include="Objects\ManiaHitObject.cs" />
<Compile Include="Objects\Note.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="UI\Column.cs" />
<Compile Include="UI\ManiaHitRenderer.cs" />
<Compile Include="UI\ManiaPlayfield.cs" />
<Compile Include="ManiaRuleset.cs" />
<Compile Include="Mods\ManiaMod.cs" />
<Compile Include="UI\SpecialColumnPosition.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\osu-framework\osu.Framework\osu.Framework.csproj">

2
osu.Game.Rulesets.Taiko/Mods/TaikoMod.cs
View File

@ -72,7 +72,7 @@ namespace osu.Game.Rulesets.Taiko.Mods
protected override Score CreateReplayScore(Beatmap<TaikoHitObject> beatmap) => new Score
{
User = new User { Username = "mekkadosu!" },
Replay = new TaikoAutoReplay(beatmap).Generate(),
Replay = new TaikoAutoGenerator(beatmap).Generate(),
};
}
}

12
osu.Game.Rulesets.Taiko/Replays/TaikoAutoReplay.cs → osu.Game.Rulesets.Taiko/Replays/TaikoAutoGenerator.cs
View File

@ -7,16 +7,24 @@ using osu.Game.Beatmaps;
using osu.Game.Rulesets.Objects.Types;
using osu.Game.Rulesets.Taiko.Objects;
using osu.Game.Rulesets.Replays;
using osu.Game.Users;
namespace osu.Game.Rulesets.Taiko.Replays
{
public class TaikoAutoReplay : AutoGenerator<TaikoHitObject>
public class TaikoAutoGenerator : AutoGenerator<TaikoHitObject>
{
private const double swell_hit_speed = 50;
public TaikoAutoReplay(Beatmap<TaikoHitObject> beatmap)
public TaikoAutoGenerator(Beatmap<TaikoHitObject> beatmap)
: base(beatmap)
{
Replay = new Replay
{
User = new User
{
Username = @"Autoplay",
}
};
}
protected Replay Replay;

2
osu.Game.Rulesets.Taiko/osu.Game.Rulesets.Taiko.csproj
View File

@ -79,7 +79,7 @@
<Compile Include="Objects\RimHit.cs" />
<Compile Include="Objects\Swell.cs" />
<Compile Include="Replays\TaikoFramedReplayInputHandler.cs" />
<Compile Include="Replays\TaikoAutoReplay.cs" />
<Compile Include="Replays\TaikoAutoGenerator.cs" />
<Compile Include="Objects\TaikoHitObject.cs" />
<Compile Include="Objects\TaikoHitObjectDifficulty.cs" />
<Compile Include="TaikoDifficultyCalculator.cs" />

12
osu.Game/Configuration/ConfineMouseMode.cs
View File

@ -1,12 +0,0 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
namespace osu.Game.Configuration
{
public enum ConfineMouseMode
{
Never,
Fullscreen,
Always
}
}

327
osu.Game/Configuration/OsuConfigManager.cs
View File

@ -1,7 +1,6 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using System;
using osu.Framework.Configuration;
using osu.Framework.Platform;
using osu.Game.Screens.Select;
@ -12,172 +11,65 @@ namespace osu.Game.Configuration
{
protected override void InitialiseDefaults()
{
#pragma warning disable CS0612 // Type or member is obsolete
// UI/selection defaults
Set(OsuConfig.Ruleset, 0, 0, int.MaxValue);
Set(OsuConfig.BeatmapDetailTab, BeatmapDetailTab.Details);
Set(OsuConfig.DisplayStarsMinimum, 0.0, 0, 10);
Set(OsuConfig.DisplayStarsMaximum, 10.0, 0, 10);
// Online settings
Set(OsuConfig.Username, string.Empty);
Set(OsuConfig.Token, string.Empty);
Set(OsuConfig.Ruleset, 0, 0, int.MaxValue);
Set(OsuConfig.SavePassword, false).ValueChanged += val =>
{
if (val) Set(OsuConfig.SaveUsername, true);
};
Set(OsuConfig.SaveUsername, true).ValueChanged += val =>
{
if (!val) Set(OsuConfig.SavePassword, false);
};
// Audio
Set(OsuConfig.AudioDevice, string.Empty);
Set(OsuConfig.SavePassword, false);
Set(OsuConfig.SaveUsername, true);
Set(OsuConfig.MenuCursorSize, 1.0, 0.5f, 2);
Set(OsuConfig.GameplayCursorSize, 1.0, 0.5f, 2);
Set(OsuConfig.DimLevel, 0.3, 0, 1);
Set(OsuConfig.MouseDisableButtons, false);
Set(OsuConfig.MouseDisableWheel, false);
Set(OsuConfig.SnakingInSliders, true);
Set(OsuConfig.SnakingOutSliders, true);
Set(OsuConfig.MenuParallax, true);
Set(OsuConfig.MenuVoice, true);
Set(OsuConfig.MenuMusic, true);
Set(OsuConfig.BeatmapDetailTab, BeatmapDetailTab.Details);
Set(OsuConfig.AudioOffset, 0, -500.0, 500.0);
// Input
Set(OsuConfig.MenuCursorSize, 1.0, 0.5f, 2);
Set(OsuConfig.GameplayCursorSize, 1.0, 0.5f, 2);
Set(OsuConfig.MouseDisableButtons, false);
Set(OsuConfig.MouseDisableWheel, false);
// Graphics
Set(OsuConfig.ShowFpsDisplay, false);
Set(OsuConfig.MenuParallax, true);
Set(OsuConfig.SnakingInSliders, true);
Set(OsuConfig.SnakingOutSliders, true);
// Gameplay
Set(OsuConfig.DimLevel, 0.3, 0, 1);
Set(OsuConfig.ShowInterface, true);
Set(OsuConfig.KeyOverlay, false);
//todo: implement all settings below this line (remove the Disabled set when doing so).
Set(OsuConfig.AudioOffset, 0, -500.0, 500.0);
// Update
Set(OsuConfig.MouseSpeed, 1.0).Disabled = true;
Set(OsuConfig.BeatmapDirectory, @"Songs").Disabled = true; // TODO: use thi.Disabled = trues
Set(OsuConfig.AllowPublicInvites, true).Disabled = true;
Set(OsuConfig.AutoChatHide, true).Disabled = true;
Set(OsuConfig.AutomaticDownload, true).Disabled = true;
Set(OsuConfig.AutomaticDownloadNoVideo, false).Disabled = true;
Set(OsuConfig.BlockNonFriendPM, false).Disabled = true;
Set(OsuConfig.Bloom, false).Disabled = true;
Set(OsuConfig.BloomSoftening, false).Disabled = true;
Set(OsuConfig.BossKeyFirstActivation, true).Disabled = true;
Set(OsuConfig.ChatAudibleHighlight, true).Disabled = true;
Set(OsuConfig.ChatChannels, string.Empty).Disabled = true;
Set(OsuConfig.ChatFilter, false).Disabled = true;
Set(OsuConfig.ChatHighlightName, true).Disabled = true;
Set(OsuConfig.ChatMessageNotification, true).Disabled = true;
Set(OsuConfig.ChatLastChannel, string.Empty).Disabled = true;
Set(OsuConfig.ChatRemoveForeign, false).Disabled = true;
//Set(OsuConfig.ChatSortMode, UserSortMode.Rank).Disabled = true;
Set(OsuConfig.ComboBurst, true).Disabled = true;
Set(OsuConfig.ComboFire, false).Disabled = true;
Set(OsuConfig.ComboFireHeight, 3).Disabled = true;
Set(OsuConfig.ConfirmExit, false).Disabled = true;
Set(OsuConfig.AutoSendNowPlaying, true).Disabled = true;
Set(OsuConfig.AutomaticCursorSizing, false).Disabled = true;
Set(OsuConfig.Display, 1).Disabled = true;
Set(OsuConfig.DisplayCityLocation, false).Disabled = true;
Set(OsuConfig.DistanceSpacingEnabled, true).Disabled = true;
Set(OsuConfig.EditorTip, 0).Disabled = true;
Set(OsuConfig.VideoEditor, true).Disabled = true;
Set(OsuConfig.EditorDefaultSkin, false).Disabled = true;
Set(OsuConfig.EditorSnakingSliders, true).Disabled = true;
Set(OsuConfig.EditorHitAnimations, false).Disabled = true;
Set(OsuConfig.EditorFollowPoints, true).Disabled = true;
Set(OsuConfig.EditorStacking, true).Disabled = true;
Set(OsuConfig.ForceSliderRendering, false).Disabled = true;
Set(OsuConfig.FpsCounter, false).Disabled = true;
Set(OsuConfig.FrameTimeDisplay, false).Disabled = true;
Set(OsuConfig.GuideTips, @"").Disabled = true;
Set(OsuConfig.CursorRipple, false).Disabled = true;
Set(OsuConfig.HighlightWords, string.Empty).Disabled = true;
Set(OsuConfig.HighResolution, false).Disabled = true;
Set(OsuConfig.HitLighting, true).Disabled = true;
Set(OsuConfig.IgnoreBarline, false).Disabled = true;
Set(OsuConfig.IgnoreBeatmapSamples, false).Disabled = true;
Set(OsuConfig.IgnoreBeatmapSkins, false).Disabled = true;
Set(OsuConfig.IgnoreList, string.Empty).Disabled = true;
Set(OsuConfig.AllowNowPlayingHighlights, false).Disabled = true;
Set(OsuConfig.LastVersion, string.Empty).Disabled = true;
Set(OsuConfig.LastVersionPermissionsFailed, string.Empty).Disabled = true;
Set(OsuConfig.LoadSubmittedThread, true).Disabled = true;
Set(OsuConfig.LobbyPlayMode, -1).Disabled = true;
Set(OsuConfig.ShowInterfaceDuringRelax, false).Disabled = true;
Set(OsuConfig.LobbyShowExistingOnly, false).Disabled = true;
Set(OsuConfig.LobbyShowFriendsOnly, false).Disabled = true;
Set(OsuConfig.LobbyShowFull, false).Disabled = true;
Set(OsuConfig.LobbyShowInProgress, true).Disabled = true;
Set(OsuConfig.LobbyShowPassworded, true).Disabled = true;
Set(OsuConfig.LogPrivateMessages, false).Disabled = true;
Set(OsuConfig.LowResolution, false).Disabled = true;
//Set(OsuConfig.ManiaSpeed, SpeedMania.SPEED_DEFAULT, SpeedMania.SPEED_MIN, SpeedMania.SPEED_MAX).Disabled = true;
Set(OsuConfig.UsePerBeatmapManiaSpeed, true).Disabled = true;
Set(OsuConfig.ManiaSpeedBPMScale, true).Disabled = true;
Set(OsuConfig.MenuTip, 0).Disabled = true;
Set(OsuConfig.MouseSpeed, 1, 0.4, 6).Disabled = true;
Set(OsuConfig.ScoreMeterScale, 1, 0.5, 2).Disabled = true;
//Set(OsuConfig.ScoreMeterScale, 1, 0.5, OsuGame.Tournament ? 10 : 2).Disabled = true;
Set(OsuConfig.DistanceSpacing, 0.8, 0.1, 6).Disabled = true;
Set(OsuConfig.EditorBeatDivisor, 1, 1, 16).Disabled = true;
Set(OsuConfig.EditorGridSize, 32, 4, 32).Disabled = true;
Set(OsuConfig.EditorGridSizeDesign, 32, 4, 32).Disabled = true;
Set(OsuConfig.CustomFrameLimit, 240, 240, 999).Disabled = true;
Set(OsuConfig.MsnIntegration, false).Disabled = true;
Set(OsuConfig.MyPcSucks, false).Disabled = true;
Set(OsuConfig.NotifyFriends, true).Disabled = true;
Set(OsuConfig.NotifySubmittedThread, true).Disabled = true;
Set(OsuConfig.PopupDuringGameplay, true).Disabled = true;
Set(OsuConfig.ProgressBarType, ProgressBarType.Pie).Disabled = true;
Set(OsuConfig.RankType, RankingType.Top).Disabled = true;
Set(OsuConfig.RefreshRate, 60).Disabled = true;
Set(OsuConfig.OverrideRefreshRate, Get<int>(OsuConfig.RefreshRate) != 60).Disabled = true;
//Set(OsuConfig.ScaleMode, ScaleMode.WidescreenConservative).Disabled = true;
Set(OsuConfig.ScoreboardVisible, true).Disabled = true;
Set(OsuConfig.ScoreMeter, ScoreMeterType.Error).Disabled = true;
//Set(OsuConfig.ScoreMeter, OsuGame.Tournament ? ScoreMeterType.Colour : ScoreMeterType.Error).Disabled = true;
Set(OsuConfig.ScreenshotId, 0).Disabled = true;
Set(OsuConfig.MenuSnow, false).Disabled = true;
Set(OsuConfig.MenuTriangles, true).Disabled = true;
Set(OsuConfig.SongSelectThumbnails, true).Disabled = true;
Set(OsuConfig.ScreenshotFormat, ScreenshotFormat.Jpg).Disabled = true;
Set(OsuConfig.ShowReplayComments, true).Disabled = true;
Set(OsuConfig.ShowSpectators, true).Disabled = true;
Set(OsuConfig.ShowStoryboard, true).Disabled = true;
//Set(OsuConfig.Skin, SkinManager.DEFAULT_SKIN).Disabled = true;
Set(OsuConfig.SkinSamples, true).Disabled = true;
Set(OsuConfig.SkipTablet, false).Disabled = true;
Set(OsuConfig.Tablet, false).Disabled = true;
Set(OsuConfig.UpdatePending, false).Disabled = true;
Set(OsuConfig.UseSkinCursor, false).Disabled = true;
Set(OsuConfig.UseTaikoSkin, false).Disabled = true;
Set(OsuConfig.Video, true).Disabled = true;
Set(OsuConfig.Wiimote, false).Disabled = true;
Set(OsuConfig.YahooIntegration, false).Disabled = true;
Set(OsuConfig.ForceFrameFlush, false).Disabled = true;
Set(OsuConfig.DetectPerformanceIssues, true).Disabled = true;
Set(OsuConfig.RawInput, false).Disabled = true;
Set(OsuConfig.AbsoluteToOsuWindow, Get<bool>(OsuConfig.RawInput)).Disabled = true;
Set(OsuConfig.ShowMenuTips, true).Disabled = true;
Set(OsuConfig.HiddenShowFirstApproach, true).Disabled = true;
Set(OsuConfig.ComboColourSliderBall, true).Disabled = true;
Set(OsuConfig.AlternativeChatFont, false).Disabled = true;
Set(OsuConfig.DisplayStarsMaximum, 10.0, 0.0, 10.0).Disabled = true;
Set(OsuConfig.DisplayStarsMinimum, 0.0, 0.0, 10.0).Disabled = true;
Set(OsuConfig.ReleaseStream, ReleaseStream.Lazer).Disabled = true;
Set(OsuConfig.UpdateFailCount, 0).Disabled = true;
//Set(OsuConfig.TreeSortMode, TreeGroupMode.Show_All).Disabled = true;
//Set(OsuConfig.TreeSortMode2, TreeSortMode.Title).Disabled = true;
Set(OsuConfig.PermanentSongInfo, false).Disabled = true;
Set(OsuConfig.Ticker, false).Disabled = true;
Set(OsuConfig.CompatibilityContext, false).Disabled = true;
Set(OsuConfig.CanForceOptimusCompatibility, true).Disabled = true;
Set(OsuConfig.ConfineMouse, Get<bool>(OsuConfig.ConfineMouseToFullscreen) ?
ConfineMouseMode.Fullscreen : ConfineMouseMode.Never).Disabled = true;
GetOriginalBindable<bool>(OsuConfig.SavePassword).ValueChanged += delegate
{
if (Get<bool>(OsuConfig.SavePassword)) Set(OsuConfig.SaveUsername, true);
};
GetOriginalBindable<bool>(OsuConfig.SaveUsername).ValueChanged += delegate
{
if (!Get<bool>(OsuConfig.SaveUsername)) Set(OsuConfig.SavePassword, false);
};
#pragma warning restore CS0612 // Type or member is obsolete
Set(OsuConfig.ReleaseStream, ReleaseStream.Lazer);
}
public OsuConfigManager(Storage storage) : base(storage)
@ -187,150 +79,29 @@ namespace osu.Game.Configuration
public enum OsuConfig
{
// New osu:
Ruleset,
Token,
// Imported from old osu:
BeatmapDirectory,
AllowPublicInvites,
AutoChatHide,
AutomaticDownload,
AutomaticDownloadNoVideo,
BlockNonFriendPM,
Bloom,
BloomSoftening,
BossKeyFirstActivation,
ChatAudibleHighlight,
ChatChannels,
ChatFilter,
ChatHighlightName,
ChatMessageNotification,
ChatLastChannel,
ChatRemoveForeign,
ChatSortMode,
ComboBurst,
ComboFire,
ComboFireHeight,
ConfirmExit,
AutoSendNowPlaying,
MenuCursorSize,
GameplayCursorSize,
AutomaticCursorSizing,
DimLevel,
Display,
DisplayCityLocation,
DistanceSpacingEnabled,
EditorTip,
VideoEditor,
EditorDefaultSkin,
EditorSnakingSliders,
EditorHitAnimations,
EditorFollowPoints,
EditorStacking,
ForceSliderRendering,
FpsCounter,
FrameTimeDisplay,
GuideTips,
CursorRipple,
HighlightWords,
HighResolution,
HitLighting,
IgnoreBarline,
IgnoreBeatmapSamples,
IgnoreBeatmapSkins,
IgnoreList,
KeyOverlay,
Language,
LastPlayMode,
AllowNowPlayingHighlights,
LastVersion,
LastVersionPermissionsFailed,
LoadSubmittedThread,
LobbyPlayMode,
ShowInterface,
ShowInterfaceDuringRelax,
LobbyShowExistingOnly,
LobbyShowFriendsOnly,
LobbyShowFull,
LobbyShowInProgress,
LobbyShowPassworded,
LogPrivateMessages,
LowResolution,
ManiaSpeed,
UsePerBeatmapManiaSpeed,
ManiaSpeedBPMScale,
MenuTip,
MouseDisableButtons,
MouseDisableWheel,
MouseSpeed,
AudioOffset,
ScoreMeterScale,
DistanceSpacing,
EditorBeatDivisor,
EditorGridSize,
EditorGridSizeDesign,
CustomFrameLimit,
MsnIntegration,
MyPcSucks,
NotifyFriends,
NotifySubmittedThread,
PopupDuringGameplay,
ProgressBarType,
RankType,
RefreshRate,
OverrideRefreshRate,
ScaleMode,
ScoreboardVisible,
ScoreMeter,
ScreenshotId,
MenuSnow,
MenuTriangles,
SongSelectThumbnails,
ScreenshotFormat,
ShowReplayComments,
ShowSpectators,
ShowStoryboard,
Skin,
SkinSamples,
SkipTablet,
SnakingInSliders,
SnakingOutSliders,
Tablet,
UpdatePending,
UserFilter,
UseSkinCursor,
UseTaikoSkin,
Video,
Wiimote,
YahooIntegration,
ForceFrameFlush,
DetectPerformanceIssues,
MenuMusic,
MenuVoice,
MenuParallax,
BeatmapDetailTab,
RawInput,
AbsoluteToOsuWindow,
ConfineMouse,
[Obsolete]
ConfineMouseToFullscreen,
ShowMenuTips,
HiddenShowFirstApproach,
ComboColourSliderBall,
AlternativeChatFont,
Username,
DisplayStarsMaximum,
DisplayStarsMinimum,
AudioDevice,
ReleaseStream,
UpdateFailCount,
SavePassword,
SaveUsername,
TreeSortMode,
TreeSortMode2,
PermanentSongInfo,
Ticker,
CompatibilityContext,
CanForceOptimusCompatibility,
DisplayStarsMinimum,
DisplayStarsMaximum,
SnakingInSliders,
SnakingOutSliders,
ShowFpsDisplay
}
}

18
osu.Game/Configuration/ProgressBarType.cs
View File

@ -1,18 +0,0 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using System.ComponentModel;
namespace osu.Game.Configuration
{
public enum ProgressBarType
{
Off,
Pie,
[Description("Top Right")]
TopRight,
[Description("Bottom Right")]
BottomRight,
Bottom
}
}

12
osu.Game/OsuGameBase.cs
View File

@ -19,6 +19,7 @@ using osu.Game.Graphics.Cursor;
using osu.Game.Graphics.Processing;
using osu.Game.Online.API;
using SQLite.Net;
using osu.Framework.Graphics.Performance;
namespace osu.Game
{
@ -44,6 +45,8 @@ namespace osu.Game
public readonly Bindable<WorkingBeatmap> Beatmap = new Bindable<WorkingBeatmap>();
private Bindable<bool> fpsDisplayVisible;
protected AssemblyName AssemblyName => Assembly.GetEntryAssembly()?.GetName() ?? new AssemblyName { Version = new Version() };
public bool IsDeployedBuild => AssemblyName.Version.Major > 0;
@ -160,6 +163,15 @@ namespace osu.Game
},
}
});
// TODO: This is temporary until we reimplement the local FPS display.
// It's just to allow end-users to access the framework FPS display without knowing the shortcut key.
fpsDisplayVisible = LocalConfig.GetBindable<bool>(OsuConfig.ShowFpsDisplay);
fpsDisplayVisible.ValueChanged += val =>
{
FrameStatisticsMode = val ? FrameStatisticsMode.Minimal : FrameStatisticsMode.None;
};
fpsDisplayVisible.TriggerChange();
}
public override void SetHost(GameHost host)

1
osu.Game/Overlays/Mods/AssistedSection.cs
View File

@ -16,7 +16,6 @@ namespace osu.Game.Overlays.Mods
[BackgroundDependencyLoader]
private void load(OsuColour colours)
{
ButtonColour = colours.Blue;
SelectedColour = colours.BlueLight;
}

1
osu.Game/Overlays/Mods/DifficultyIncreaseSection.cs
View File

@ -16,7 +16,6 @@ namespace osu.Game.Overlays.Mods
[BackgroundDependencyLoader]
private void load(OsuColour colours)
{
ButtonColour = colours.Yellow;
SelectedColour = colours.YellowLight;
}

1
osu.Game/Overlays/Mods/DifficultyReductionSection.cs
View File

@ -16,7 +16,6 @@ namespace osu.Game.Overlays.Mods
[BackgroundDependencyLoader]
private void load(OsuColour colours)
{
ButtonColour = colours.Green;
SelectedColour = colours.GreenLight;
}

53
osu.Game/Overlays/Mods/ModButton.cs
View File

@ -19,7 +19,11 @@ using System.Linq;
namespace osu.Game.Overlays.Mods
{
public class ModButton : FillFlowContainer
/// <summary>
/// Represents a clickable button which can cycle through one of more mods.
/// </summary>
public class ModButton : ModButtonEmpty
{
private ModIcon foregroundIcon { get; set; }
private readonly SpriteText text;
@ -51,7 +55,7 @@ namespace osu.Game.Overlays.Mods
iconsContainer.RotateTo(Selected ? 5f : 0f, 300, EasingTypes.OutElastic);
iconsContainer.ScaleTo(Selected ? 1.1f : 1f, 300, EasingTypes.OutElastic);
foregroundIcon.Colour = Selected ? SelectedColour : ButtonColour;
foregroundIcon.Highlighted = Selected;
if (mod != null)
displayMod(SelectedMod ?? Mods[0]);
@ -60,23 +64,6 @@ namespace osu.Game.Overlays.Mods
public bool Selected => selectedIndex != -1;
private Color4 buttonColour;
public Color4 ButtonColour
{
get
{
return buttonColour;
}
set
{
if (value == buttonColour) return;
buttonColour = value;
foreach (ModIcon icon in iconsContainer.Children)
{
icon.Colour = value;
}
}
}
private Color4 selectedColour;
public Color4 SelectedColour
@ -127,7 +114,7 @@ namespace osu.Game.Overlays.Mods
// the mods from Mod, only multiple if Mod is a MultiMod
public Mod SelectedMod => Mods.ElementAtOrDefault(selectedIndex);
public override Mod SelectedMod => Mods.ElementAtOrDefault(selectedIndex);
[BackgroundDependencyLoader]
private void load(AudioManager audio)
@ -180,50 +167,35 @@ namespace osu.Game.Overlays.Mods
{
iconsContainer.Add(new[]
{
new ModIcon
new ModIcon(Mods[0])
{
Origin = Anchor.Centre,
Anchor = Anchor.Centre,
AutoSizeAxes = Axes.Both,
Position = new Vector2(1.5f),
Colour = ButtonColour
},
foregroundIcon = new ModIcon
foregroundIcon = new ModIcon(Mods[0])
{
Origin = Anchor.Centre,
Anchor = Anchor.Centre,
AutoSizeAxes = Axes.Both,
Position = new Vector2(-1.5f),
Colour = ButtonColour
},
});
}
else
{
iconsContainer.Add(foregroundIcon = new ModIcon
iconsContainer.Add(foregroundIcon = new ModIcon(Mod)
{
Origin = Anchor.Centre,
Anchor = Anchor.Centre,
AutoSizeAxes = Axes.Both,
Colour = ButtonColour
});
}
}
protected override void LoadComplete()
public ModButton(Mod mod)
{
base.LoadComplete();
foreach (ModIcon icon in iconsContainer.Children)
icon.Colour = ButtonColour;
}
public ModButton(Mod m)
{
Direction = FillDirection.Vertical;
Spacing = new Vector2(0f, -5f);
Size = new Vector2(100f);
AlwaysPresent = true;
Children = new Drawable[]
{
new Container
@ -243,13 +215,14 @@ namespace osu.Game.Overlays.Mods
},
text = new OsuSpriteText
{
Y = 75,
Origin = Anchor.TopCentre,
Anchor = Anchor.TopCentre,
TextSize = 18,
},
};
Mod = m;
Mod = mod;
}
}
}

23
osu.Game/Overlays/Mods/ModButtonEmpty.cs Normal file
View File

@ -0,0 +1,23 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using OpenTK;
using osu.Framework.Graphics.Containers;
using osu.Game.Rulesets.Mods;
namespace osu.Game.Overlays.Mods
{
/// <summary>
/// A mod button used exclusively for providing an empty space the size of a mod button.
/// </summary>
public class ModButtonEmpty : Container
{
public virtual Mod SelectedMod => null;
public ModButtonEmpty()
{
Size = new Vector2(100f);
AlwaysPresent = true;
}
}
}

87
osu.Game/Overlays/Mods/ModSection.cs
View File

@ -11,6 +11,8 @@ using osu.Framework.Input;
using osu.Game.Graphics.Sprites;
using osu.Game.Rulesets.Mods;
using System;
using System.Linq;
using System.Collections.Generic;
namespace osu.Game.Overlays.Mods
{
@ -18,7 +20,7 @@ namespace osu.Game.Overlays.Mods
{
private readonly OsuSpriteText headerLabel;
public FillFlowContainer<ModButton> ButtonsContainer { get; }
public FillFlowContainer<ModButtonEmpty> ButtonsContainer { get; }
public Action<Mod> Action;
protected abstract Key[] ToggleKeys { get; }
@ -36,47 +38,30 @@ namespace osu.Game.Overlays.Mods
}
}
public IEnumerable<Mod> SelectedMods => buttons.Select(b => b.SelectedMod).Where(m => m != null);
public IEnumerable<Mod> Mods
{
set
{
var modContainers = value.Select(m =>
{
if (m == null)
return new ModButtonEmpty();
else
return new ModButton(m)
{
SelectedColour = selectedColour,
Action = Action,
};
}).ToArray();
ButtonsContainer.Children = modContainers;
buttons = modContainers.OfType<ModButton>().ToArray();
}
}
private ModButton[] buttons = { };
public ModButton[] Buttons
{
get
{
return buttons;
}
set
{
if (value == buttons) return;
buttons = value;
foreach (ModButton button in value)
{
button.ButtonColour = ButtonColour;
button.SelectedColour = selectedColour;
button.Action = Action;
}
ButtonsContainer.Children = value;
}
}
private Color4 buttonsBolour = Color4.White;
public Color4 ButtonColour
{
get
{
return buttonsBolour;
}
set
{
if (value == buttonsBolour) return;
buttonsBolour = value;
foreach (ModButton button in buttons)
{
button.ButtonColour = value;
}
}
}
private Color4 selectedColour = Color4.White;
public Color4 SelectedColour
@ -91,17 +76,15 @@ namespace osu.Game.Overlays.Mods
selectedColour = value;
foreach (ModButton button in buttons)
{
button.SelectedColour = value;
}
}
}
protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
{
var index = Array.IndexOf(ToggleKeys, args.Key);
if (index > -1 && index < Buttons.Length)
Buttons[index].SelectNext();
if (index > -1 && index < buttons.Length)
buttons[index].SelectNext();
return base.OnKeyDown(state, args);
}
@ -109,8 +92,18 @@ namespace osu.Game.Overlays.Mods
public void DeselectAll()
{
foreach (ModButton button in buttons)
{
button.Deselect();
}
public void DeselectTypes(Type[] modTypes)
{
foreach (var button in buttons)
{
Mod selected = button.SelectedMod;
if (selected == null) continue;
foreach (Type type in modTypes)
if (type.IsInstanceOfType(selected))
button.Deselect();
}
}
@ -127,7 +120,7 @@ namespace osu.Game.Overlays.Mods
Position = new Vector2(0f, 0f),
Font = @"Exo2.0-Bold"
},
ButtonsContainer = new FillFlowContainer<ModButton>
ButtonsContainer = new FillFlowContainer<ModButtonEmpty>
{
AutoSizeAxes = Axes.Both,
Origin = Anchor.BottomLeft,

13
osu.Game/Overlays/Mods/ModSelectOverlay.cs
View File

@ -44,7 +44,7 @@ namespace osu.Game.Overlays.Mods
var instance = newRuleset.CreateInstance();
foreach (ModSection section in modSectionsContainer.Children)
section.Buttons = instance.GetModsFor(section.ModType).Select(m => new ModButton(m)).ToArray();
section.Mods = instance.GetModsFor(section.ModType);
refreshSelectedMods();
}
@ -103,14 +103,7 @@ namespace osu.Game.Overlays.Mods
{
if (modTypes.Length == 0) return;
foreach (ModSection section in modSectionsContainer.Children)
foreach (ModButton button in section.Buttons)
{
Mod selected = button.SelectedMod;
if (selected == null) continue;
foreach (Type type in modTypes)
if (type.IsInstanceOfType(selected))
button.Deselect();
}
section.DeselectTypes(modTypes);
}
private void modButtonPressed(Mod selectedMod)
@ -122,7 +115,7 @@ namespace osu.Game.Overlays.Mods
private void refreshSelectedMods()
{
SelectedMods.Value = modSectionsContainer.Children.SelectMany(s => s.Buttons.Select(x => x.SelectedMod).Where(x => x != null)).ToArray();
SelectedMods.Value = modSectionsContainer.Children.SelectMany(s => s.SelectedMods).ToArray();
double multiplier = 1.0;
bool ranked = true;

21
osu.Game/Overlays/Options/OptionCheckbox.cs Normal file
View File

@ -0,0 +1,21 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using osu.Framework.Graphics;
using osu.Game.Graphics.UserInterface;
namespace osu.Game.Overlays.Options
{
public class OptionCheckbox : OptionItem<bool>
{
private OsuCheckbox checkbox;
protected override Drawable CreateControl() => checkbox = new OsuCheckbox();
public override string LabelText
{
get { return checkbox.LabelText; }
set { checkbox.LabelText = value; }
}
}
}

61
osu.Game/Overlays/Options/OptionDropdown.cs
View File

@ -2,44 +2,18 @@
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using System.Collections.Generic;
using osu.Framework.Configuration;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Primitives;
using osu.Framework.Graphics.Sprites;
using osu.Framework.Graphics.UserInterface;
using osu.Game.Graphics.Sprites;
using osu.Game.Graphics.UserInterface;
namespace osu.Game.Overlays.Options
{
public class OptionDropdown<T> : FillFlowContainer
public class OptionDropdown<T> : OptionItem<T>
{
private readonly Dropdown<T> dropdown;
private readonly SpriteText text;
private Dropdown<T> dropdown;
public string LabelText
{
get { return text.Text; }
set
{
text.Text = value;
}
}
public Bindable<T> Bindable
{
get { return bindable; }
set
{
bindable = value;
dropdown.Current.BindTo(bindable);
}
}
private Bindable<T> bindable;
private IEnumerable<KeyValuePair<string, T>> items;
private IEnumerable<KeyValuePair<string, T>> items = new KeyValuePair<string, T>[] { };
public IEnumerable<KeyValuePair<string, T>> Items
{
get
@ -54,30 +28,11 @@ namespace osu.Game.Overlays.Options
}
}
public OptionDropdown()
protected override Drawable CreateControl() => dropdown = new OsuDropdown<T>
{
Items = new KeyValuePair<string, T>[0];
Direction = FillDirection.Vertical;
RelativeSizeAxes = Axes.X;
AutoSizeAxes = Axes.Y;
Children = new Drawable[]
{
text = new OsuSpriteText {
Alpha = 0,
},
dropdown = new OsuDropdown<T>
{
Margin = new MarginPadding { Top = 5 },
RelativeSizeAxes = Axes.X,
Items = Items,
}
};
dropdown.Current.DisabledChanged += disabled =>
{
Alpha = disabled ? 0.3f : 1;
};
}
Margin = new MarginPadding { Top = 5 },
RelativeSizeAxes = Axes.X,
Items = Items,
};
}
}

82
osu.Game/Overlays/Options/OptionItem.cs Normal file
View File

@ -0,0 +1,82 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using OpenTK.Graphics;
using osu.Framework.Configuration;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Primitives;
using osu.Framework.Graphics.Sprites;
using osu.Framework.Graphics.UserInterface;
using osu.Game.Graphics.Sprites;
namespace osu.Game.Overlays.Options
{
public abstract class OptionItem<T> : FillFlowContainer, IFilterable
{
protected abstract Drawable CreateControl();
protected Drawable Control { get; }
private IHasCurrentValue<T> controlWithCurrent => Control as IHasCurrentValue<T>;
private SpriteText text;
public virtual string LabelText
{
get { return text?.Text ?? string.Empty; }
set
{
if (text == null)
{
// construct lazily for cases where the label is not needed (may be provided by the Control).
Add(text = new OsuSpriteText() { Depth = 1 });
}
text.Text = value;
}
}
// hold a reference to the provided bindable so we don't have to in every options section.
private Bindable<T> bindable;
public Bindable<T> Bindable
{
get
{
return bindable;
}
set
{
bindable = value;
controlWithCurrent?.Current.BindTo(bindable);
}
}
public string[] FilterTerms => new[] { LabelText };
public bool MatchingCurrentFilter
{
set
{
// probably needs a better transition.
FadeTo(value ? 1 : 0);
}
}
protected OptionItem()
{
RelativeSizeAxes = Axes.X;
AutoSizeAxes = Axes.Y;
Padding = new MarginPadding { Right = 5 };
if ((Control = CreateControl()) != null)
{
if (controlWithCurrent != null)
controlWithCurrent.Current.DisabledChanged += disabled => { Colour = disabled ? Color4.Gray : Color4.White; };
Add(Control);
}
}
}
}

6
osu.Game/Overlays/Options/OptionLabel.cs
View File

@ -2,13 +2,15 @@
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Game.Graphics;
using osu.Game.Graphics.Sprites;
namespace osu.Game.Overlays.Options
{
internal class OptionLabel : OsuSpriteText
internal class OptionLabel : OptionItem<string>
{
protected override Drawable CreateControl() => null;
[BackgroundDependencyLoader]
private void load(OsuColour colour)
{

57
osu.Game/Overlays/Options/OptionSlider.cs
View File

@ -1,65 +1,26 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using osu.Framework.Configuration;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Primitives;
using osu.Framework.Graphics.Sprites;
using osu.Framework.Graphics.UserInterface;
using osu.Game.Graphics.Sprites;
using osu.Game.Graphics.UserInterface;
namespace osu.Game.Overlays.Options
{
public class OptionSlider<T> : OptionSlider<T, OsuSliderBar<T>> where T: struct
public class OptionSlider<T> : OptionSlider<T, OsuSliderBar<T>>
where T : struct
{
}
public class OptionSlider<T, U> : FillFlowContainer where T : struct where U : SliderBar<T>, new()
public class OptionSlider<T, U> : OptionItem<T>
where T : struct
where U : SliderBar<T>, new()
{
private readonly SliderBar<T> slider;
private readonly SpriteText text;
public string LabelText
protected override Drawable CreateControl() => new U()
{
get { return text.Text; }
set
{
text.Text = value;
text.Alpha = string.IsNullOrEmpty(value) ? 0 : 1;
}
}
private Bindable<T> bindable;
public Bindable<T> Bindable
{
set
{
bindable = value;
slider.Current.BindTo(bindable);
}
}
public OptionSlider()
{
RelativeSizeAxes = Axes.X;
AutoSizeAxes = Axes.Y;
Padding = new MarginPadding { Right = 5 };
Children = new Drawable[]
{
text = new OsuSpriteText
{
Alpha = 0,
},
slider = new U()
{
Margin = new MarginPadding { Top = 5, Bottom = 5 },
RelativeSizeAxes = Axes.X
}
};
}
Margin = new MarginPadding { Top = 5, Bottom = 5 },
RelativeSizeAxes = Axes.X
};
}
}

15
osu.Game/Overlays/Options/OptionTextBox.cs
View File

@ -1,22 +1,13 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using osu.Framework.Configuration;
using osu.Framework.Graphics;
using osu.Game.Graphics.UserInterface;
namespace osu.Game.Overlays.Options
{
public class OptionTextBox : OsuTextBox
public class OptionTextBox : OptionItem<string>
{
private Bindable<string> bindable;
public Bindable<string> Bindable
{
set
{
bindable = value;
Current.BindTo(bindable);
}
}
protected override Drawable CreateControl() => new OsuTextBox();
}
}

23
osu.Game/Overlays/Options/Sections/Input/OtherInputOptions.cs → osu.Game/Overlays/Options/Sections/Audio/MainMenuOptions.cs
View File

@ -2,33 +2,30 @@
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Game.Configuration;
using osu.Game.Graphics.UserInterface;
namespace osu.Game.Overlays.Options.Sections.Input
namespace osu.Game.Overlays.Options.Sections.Audio
{
public class OtherInputOptions : OptionsSubsection
public class MainMenuOptions : OptionsSubsection
{
protected override string Header => "Other";
protected override string Header => "Main Menu";
[BackgroundDependencyLoader]
private void load(OsuConfigManager config)
{
Children = new Drawable[]
Children = new[]
{
new OsuCheckbox
new OptionCheckbox
{
LabelText = "OS TabletPC support",
Bindable = config.GetBindable<bool>(OsuConfig.Tablet)
LabelText = "Interface voices",
Bindable = config.GetBindable<bool>(OsuConfig.MenuVoice)
},
new OsuCheckbox
new OptionCheckbox
{
LabelText = "Wiimote/TaTaCon Drum Support",
Bindable = config.GetBindable<bool>(OsuConfig.Wiimote)
LabelText = "osu! music theme",
Bindable = config.GetBindable<bool>(OsuConfig.MenuMusic)
},
};
}
}
}

9
osu.Game/Overlays/Options/Sections/Audio/VolumeOptions.cs
View File

@ -4,8 +4,6 @@
using osu.Framework.Allocation;
using osu.Framework.Audio;
using osu.Framework.Graphics;
using osu.Game.Configuration;
using osu.Game.Graphics.UserInterface;
namespace osu.Game.Overlays.Options.Sections.Audio
{
@ -14,18 +12,13 @@ namespace osu.Game.Overlays.Options.Sections.Audio
protected override string Header => "Volume";
[BackgroundDependencyLoader]
private void load(OsuConfigManager config, AudioManager audio)
private void load(AudioManager audio)
{
Children = new Drawable[]
{
new OptionSlider<double> { LabelText = "Master", Bindable = audio.Volume },
new OptionSlider<double> { LabelText = "Effect", Bindable = audio.VolumeSample },
new OptionSlider<double> { LabelText = "Music", Bindable = audio.VolumeTrack },
new OsuCheckbox
{
LabelText = "Ignore beatmap hitsounds",
Bindable = config.GetBindable<bool>(OsuConfig.IgnoreBeatmapSamples)
}
};
}
}

4
osu.Game/Overlays/Options/Sections/AudioSection.cs
View File

@ -1,7 +1,6 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using osu.Framework;
using osu.Framework.Graphics;
using osu.Game.Graphics;
using osu.Game.Overlays.Options.Sections.Audio;
@ -17,9 +16,10 @@ namespace osu.Game.Overlays.Options.Sections
{
Children = new Drawable[]
{
new AudioDevicesOptions { Alpha = RuntimeInfo.IsWindows ? 1 : 0 },
new AudioDevicesOptions(),
new VolumeOptions(),
new OffsetOptions(),
new MainMenuOptions(),
};
}
}

3
osu.Game/Overlays/Options/Sections/Debug/GeneralOptions.cs
View File

@ -4,7 +4,6 @@
using osu.Framework.Allocation;
using osu.Framework.Configuration;
using osu.Framework.Graphics;
using osu.Game.Graphics.UserInterface;
namespace osu.Game.Overlays.Options.Sections.Debug
{
@ -17,7 +16,7 @@ namespace osu.Game.Overlays.Options.Sections.Debug
{
Children = new Drawable[]
{
new OsuCheckbox
new OptionCheckbox
{
LabelText = "Bypass caching",
Bindable = config.GetBindable<bool>(FrameworkDebugConfig.BypassCaching)

58
osu.Game/Overlays/Options/Sections/EditorSection.cs
View File

@ -1,58 +0,0 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Game.Configuration;
using osu.Game.Graphics;
using osu.Game.Graphics.UserInterface;
using OpenTK;
namespace osu.Game.Overlays.Options.Sections
{
public class EditorSection : OptionsSection
{
public override string Header => "Editor";
public override FontAwesome Icon => FontAwesome.fa_pencil;
[BackgroundDependencyLoader]
private void load(OsuConfigManager config)
{
FlowContent.Spacing = new Vector2(0, 5);
Children = new Drawable[]
{
new OsuCheckbox
{
LabelText = "Background video",
Bindable = config.GetBindable<bool>(OsuConfig.VideoEditor)
},
new OsuCheckbox
{
LabelText = "Always use default skin",
Bindable = config.GetBindable<bool>(OsuConfig.EditorDefaultSkin)
},
new OsuCheckbox
{
LabelText = "Snaking sliders",
Bindable = config.GetBindable<bool>(OsuConfig.EditorSnakingSliders)
},
new OsuCheckbox
{
LabelText = "Hit animations",
Bindable = config.GetBindable<bool>(OsuConfig.EditorHitAnimations)
},
new OsuCheckbox
{
LabelText = "Follow points",
Bindable = config.GetBindable<bool>(OsuConfig.EditorFollowPoints)
},
new OsuCheckbox
{
LabelText = "Stacking",
Bindable = config.GetBindable<bool>(OsuConfig.EditorStacking)
},
};
}
}
}

35
osu.Game/Overlays/Options/Sections/Gameplay/GeneralOptions.cs
View File

@ -4,7 +4,6 @@
using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Game.Configuration;
using osu.Game.Graphics.UserInterface;
namespace osu.Game.Overlays.Options.Sections.Gameplay
{
@ -22,46 +21,16 @@ namespace osu.Game.Overlays.Options.Sections.Gameplay
LabelText = "Background dim",
Bindable = config.GetBindable<double>(OsuConfig.DimLevel)
},
new OptionEnumDropdown<ProgressBarType>
{
LabelText = "Progress display",
Bindable = config.GetBindable<ProgressBarType>(OsuConfig.ProgressBarType)
},
new OptionEnumDropdown<ScoreMeterType>
{
LabelText = "Score meter type",
Bindable = config.GetBindable<ScoreMeterType>(OsuConfig.ScoreMeter)
},
new OptionSlider<double>
{
LabelText = "Score meter size",
Bindable = config.GetBindable<double>(OsuConfig.ScoreMeterScale)
},
new OsuCheckbox
new OptionCheckbox
{
LabelText = "Show score overlay",
Bindable = config.GetBindable<bool>(OsuConfig.ShowInterface)
},
new OsuCheckbox
new OptionCheckbox
{
LabelText = "Always show key overlay",
Bindable = config.GetBindable<bool>(OsuConfig.KeyOverlay)
},
new OsuCheckbox
{
LabelText = "Show approach circle on first \"Hidden\" object",
Bindable = config.GetBindable<bool>(OsuConfig.HiddenShowFirstApproach)
},
new OsuCheckbox
{
LabelText = "Scale osu!mania scroll speed with BPM",
Bindable = config.GetBindable<bool>(OsuConfig.ManiaSpeedBPMScale)
},
new OsuCheckbox
{
LabelText = "Remember osu!mania scroll speed per beatmap",
Bindable = config.GetBindable<bool>(OsuConfig.UsePerBeatmapManiaSpeed)
},
};
}
}

12
osu.Game/Overlays/Options/Sections/General/LanguageOptions.cs
View File

@ -4,8 +4,6 @@
using osu.Framework.Allocation;
using osu.Framework.Configuration;
using osu.Framework.Graphics;
using osu.Game.Configuration;
using osu.Game.Graphics.UserInterface;
namespace osu.Game.Overlays.Options.Sections.General
{
@ -14,21 +12,15 @@ namespace osu.Game.Overlays.Options.Sections.General
protected override string Header => "Language";
[BackgroundDependencyLoader]
private void load(OsuConfigManager osuConfig, FrameworkConfigManager frameworkConfig)
private void load(FrameworkConfigManager frameworkConfig)
{
Children = new Drawable[]
{
new OptionLabel { Text = "TODO: Dropdown" },
new OsuCheckbox
new OptionCheckbox
{
LabelText = "Prefer metadata in original language",
Bindable = frameworkConfig.GetBindable<bool>(FrameworkConfig.ShowUnicode)
},
new OsuCheckbox
{
LabelText = "Use alternative font for chat display",
Bindable = osuConfig.GetBindable<bool>(OsuConfig.AlternativeChatFont)
},
};
}
}

4
osu.Game/Overlays/Options/Sections/General/LoginOptions.cs
View File

@ -132,12 +132,12 @@ namespace osu.Game.Overlays.Options.Sections.General
TabbableContentContainer = this,
OnCommit = (sender, newText) => performLogin()
},
new OsuCheckbox
new OptionCheckbox
{
LabelText = "Remember username",
Bindable = config.GetBindable<bool>(OsuConfig.SaveUsername),
},
new OsuCheckbox
new OptionCheckbox
{
LabelText = "Stay logged in",
Bindable = config.GetBindable<bool>(OsuConfig.SavePassword),

1
osu.Game/Overlays/Options/Sections/General/UpdateOptions.cs
View File

@ -23,7 +23,6 @@ namespace osu.Game.Overlays.Options.Sections.General
LabelText = "Release stream",
Bindable = config.GetBindable<ReleaseStream>(OsuConfig.ReleaseStream),
},
new OptionLabel { Text = "Your osu! is up to date" }, // TODO: map this to reality
new OsuButton
{
RelativeSizeAxes = Axes.X,

42
osu.Game/Overlays/Options/Sections/Graphics/DetailOptions.cs
View File

@ -4,7 +4,6 @@
using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Game.Configuration;
using osu.Game.Graphics.UserInterface;
namespace osu.Game.Overlays.Options.Sections.Graphics
{
@ -17,52 +16,17 @@ namespace osu.Game.Overlays.Options.Sections.Graphics
{
Children = new Drawable[]
{
new OsuCheckbox
new OptionCheckbox
{
LabelText = "Snaking in sliders",
Bindable = config.GetBindable<bool>(OsuConfig.SnakingInSliders)
},
new OsuCheckbox
new OptionCheckbox
{
LabelText = "Snaking out sliders",
Bindable = config.GetBindable<bool>(OsuConfig.SnakingOutSliders)
},
new OsuCheckbox
{
LabelText = "Background video",
Bindable = config.GetBindable<bool>(OsuConfig.Video)
},
new OsuCheckbox
{
LabelText = "Storyboards",
Bindable = config.GetBindable<bool>(OsuConfig.ShowStoryboard)
},
new OsuCheckbox
{
LabelText = "Combo bursts",
Bindable = config.GetBindable<bool>(OsuConfig.ComboBurst)
},
new OsuCheckbox
{
LabelText = "Hit lighting",
Bindable = config.GetBindable<bool>(OsuConfig.HitLighting)
},
new OsuCheckbox
{
LabelText = "Shaders",
Bindable = config.GetBindable<bool>(OsuConfig.Bloom)
},
new OsuCheckbox
{
LabelText = "Softening filter",
Bindable = config.GetBindable<bool>(OsuConfig.BloomSoftening)
},
new OptionEnumDropdown<ScreenshotFormat>
{
LabelText = "Screenshot",
Bindable = config.GetBindable<ScreenshotFormat>(OsuConfig.ScreenshotFormat)
}
};
}
}
}
}

6
osu.Game/Overlays/Options/Sections/Graphics/LayoutOptions.cs
View File

@ -4,7 +4,6 @@
using osu.Framework.Allocation;
using osu.Framework.Configuration;
using osu.Framework.Graphics;
using osu.Game.Graphics.UserInterface;
namespace osu.Game.Overlays.Options.Sections.Graphics
{
@ -24,13 +23,12 @@ namespace osu.Game.Overlays.Options.Sections.Graphics
Children = new Drawable[]
{
new OptionLabel { Text = "Resolution: TODO dropdown" },
new OptionEnumDropdown<WindowMode>
{
LabelText = "Screen mode",
Bindable = config.GetBindable<WindowMode>(FrameworkConfig.WindowMode),
},
new OsuCheckbox
new OptionCheckbox
{
LabelText = "Letterboxing",
Bindable = letterboxing,
@ -65,4 +63,4 @@ namespace osu.Game.Overlays.Options.Sections.Graphics
}
}
}
}
}

27
osu.Game/Overlays/Options/Sections/Graphics/MainMenuOptions.cs
View File

@ -3,45 +3,24 @@
using osu.Framework.Allocation;
using osu.Game.Configuration;
using osu.Game.Graphics.UserInterface;
namespace osu.Game.Overlays.Options.Sections.Graphics
{
public class MainMenuOptions : OptionsSubsection
{
protected override string Header => "Main Menu";
protected override string Header => "User Interface";
[BackgroundDependencyLoader]
private void load(OsuConfigManager config)
{
Children = new[]
{
new OsuCheckbox
{
LabelText = "Snow",
Bindable = config.GetBindable<bool>(OsuConfig.MenuSnow)
},
new OsuCheckbox
new OptionCheckbox
{
LabelText = "Parallax",
Bindable = config.GetBindable<bool>(OsuConfig.MenuParallax)
},
new OsuCheckbox
{
LabelText = "Menu tips",
Bindable = config.GetBindable<bool>(OsuConfig.ShowMenuTips)
},
new OsuCheckbox
{
LabelText = "Interface voices",
Bindable = config.GetBindable<bool>(OsuConfig.MenuVoice)
},
new OsuCheckbox
{
LabelText = "osu! music theme",
Bindable = config.GetBindable<bool>(OsuConfig.MenuMusic)
},
};
}
}
}
}

21
osu.Game/Overlays/Options/Sections/Graphics/RendererOptions.cs
View File

@ -5,7 +5,6 @@ using osu.Framework.Allocation;
using osu.Framework.Configuration;
using osu.Framework.Graphics;
using osu.Game.Configuration;
using osu.Game.Graphics.UserInterface;
namespace osu.Game.Overlays.Options.Sections.Graphics
{
@ -14,7 +13,7 @@ namespace osu.Game.Overlays.Options.Sections.Graphics
protected override string Header => "Renderer";
[BackgroundDependencyLoader]
private void load(OsuConfigManager osuConfig, FrameworkConfigManager config)
private void load(FrameworkConfigManager config, OsuConfigManager osuConfig)
{
// NOTE: Compatability mode omitted
Children = new Drawable[]
@ -25,22 +24,12 @@ namespace osu.Game.Overlays.Options.Sections.Graphics
LabelText = "Frame limiter",
Bindable = config.GetBindable<FrameSync>(FrameworkConfig.FrameSync)
},
new OsuCheckbox
new OptionCheckbox
{
LabelText = "Show FPS counter",
Bindable = osuConfig.GetBindable<bool>(OsuConfig.FpsCounter),
},
new OsuCheckbox
{
LabelText = "Reduce dropped frames",
Bindable = osuConfig.GetBindable<bool>(OsuConfig.ForceFrameFlush),
},
new OsuCheckbox
{
LabelText = "Detect performance issues",
Bindable = osuConfig.GetBindable<bool>(OsuConfig.DetectPerformanceIssues),
LabelText = "Show FPS",
Bindable = osuConfig.GetBindable<bool>(OsuConfig.ShowFpsDisplay)
},
};
}
}
}
}

27
osu.Game/Overlays/Options/Sections/Graphics/SongSelectGraphicsOptions.cs
View File

@ -1,27 +0,0 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using osu.Framework.Allocation;
using osu.Game.Configuration;
using osu.Game.Graphics.UserInterface;
namespace osu.Game.Overlays.Options.Sections.Graphics
{
public class SongSelectGraphicsOptions : OptionsSubsection
{
protected override string Header => "Song Select";
[BackgroundDependencyLoader]
private void load(OsuConfigManager config)
{
Children = new[]
{
new OsuCheckbox
{
LabelText = "Show thumbnails",
Bindable = config.GetBindable<bool>(OsuConfig.SongSelectThumbnails)
}
};
}
}
}

1
osu.Game/Overlays/Options/Sections/GraphicsSection.cs
View File

@ -20,7 +20,6 @@ namespace osu.Game.Overlays.Options.Sections
new LayoutOptions(),
new DetailOptions(),
new MainMenuOptions(),
new SongSelectGraphicsOptions(),
};
}
}

7
osu.Game/Overlays/Options/Sections/Input/KeyboardOptions.cs
View File

@ -17,13 +17,8 @@ namespace osu.Game.Overlays.Options.Sections.Input
new OsuButton
{
RelativeSizeAxes = Axes.X,
Text = "Change keyboard bindings"
Text = "Key Configuration"
},
new OsuButton
{
RelativeSizeAxes = Axes.X,
Text = "osu!mania layout"
}
};
}
}

38
osu.Game/Overlays/Options/Sections/Input/MouseOptions.cs
View File

@ -2,7 +2,9 @@
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using osu.Framework.Allocation;
using osu.Framework.Configuration;
using osu.Framework.Graphics;
using osu.Framework.Input;
using osu.Game.Configuration;
using osu.Game.Graphics.UserInterface;
@ -13,44 +15,24 @@ namespace osu.Game.Overlays.Options.Sections.Input
protected override string Header => "Mouse";
[BackgroundDependencyLoader]
private void load(OsuConfigManager config)
private void load(OsuConfigManager osuConfig, FrameworkConfigManager config)
{
Children = new Drawable[]
{
new OptionSlider<double, SensitivitySlider>
{
LabelText = "Sensitivity",
Bindable = config.GetBindable<double>(OsuConfig.MouseSpeed)
},
new OsuCheckbox
{
LabelText = "Raw input",
Bindable = config.GetBindable<bool>(OsuConfig.RawInput)
},
new OsuCheckbox
{
LabelText = "Map absolute raw input to the osu! window",
Bindable = config.GetBindable<bool>(OsuConfig.AbsoluteToOsuWindow)
},
new OptionEnumDropdown<ConfineMouseMode>
{
LabelText = "Confine mouse cursor",
Bindable = config.GetBindable<ConfineMouseMode>(OsuConfig.ConfineMouse),
Bindable = config.GetBindable<ConfineMouseMode>(FrameworkConfig.ConfineMouseMode),
},
new OsuCheckbox
new OptionCheckbox
{
LabelText = "Disable mouse wheel in play mode",
Bindable = config.GetBindable<bool>(OsuConfig.MouseDisableWheel)
LabelText = "Disable mouse wheel during gameplay",
Bindable = osuConfig.GetBindable<bool>(OsuConfig.MouseDisableWheel)
},
new OsuCheckbox
new OptionCheckbox
{
LabelText = "Disable mouse buttons in play mode",
Bindable = config.GetBindable<bool>(OsuConfig.MouseDisableButtons)
},
new OsuCheckbox
{
LabelText = "Cursor ripples",
Bindable = config.GetBindable<bool>(OsuConfig.CursorRipple)
LabelText = "Disable mouse buttons during gameplay",
Bindable = osuConfig.GetBindable<bool>(OsuConfig.MouseDisableButtons)
},
};
}

1
osu.Game/Overlays/Options/Sections/InputSection.cs
View File

@ -18,7 +18,6 @@ namespace osu.Game.Overlays.Options.Sections
{
new MouseOptions(),
new KeyboardOptions(),
new OtherInputOptions(),
};
}
}

23
osu.Game/Overlays/Options/Sections/MaintenanceSection.cs
View File

@ -3,7 +3,6 @@
using osu.Framework.Graphics;
using osu.Game.Graphics;
using osu.Game.Graphics.UserInterface;
using OpenTK;
namespace osu.Game.Overlays.Options.Sections
@ -18,27 +17,7 @@ namespace osu.Game.Overlays.Options.Sections
FlowContent.Spacing = new Vector2(0, 5);
Children = new Drawable[]
{
new OsuButton
{
RelativeSizeAxes = Axes.X,
Text = "Delete all unranked maps",
},
new OsuButton
{
RelativeSizeAxes = Axes.X,
Text = "Repair folder permissions",
},
new OsuButton
{
RelativeSizeAxes = Axes.X,
Text = "Mark all maps as played",
},
new OsuButton
{
RelativeSizeAxes = Axes.X,
Text = "Run osu! updater",
},
};
}
}
}
}

53
osu.Game/Overlays/Options/Sections/Online/InGameChatOptions.cs
View File

@ -1,53 +0,0 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Game.Configuration;
using osu.Game.Graphics.UserInterface;
namespace osu.Game.Overlays.Options.Sections.Online
{
public class InGameChatOptions : OptionsSubsection
{
protected override string Header => "Chat";
[BackgroundDependencyLoader]
private void load(OsuConfigManager config)
{
Children = new Drawable[]
{
new OsuCheckbox
{
LabelText = "Filter offensive words",
Bindable = config.GetBindable<bool>(OsuConfig.ChatFilter)
},
new OsuCheckbox
{
LabelText = "Filter foreign characters",
Bindable = config.GetBindable<bool>(OsuConfig.ChatRemoveForeign)
},
new OsuCheckbox
{
LabelText = "Log private messages",
Bindable = config.GetBindable<bool>(OsuConfig.LogPrivateMessages)
},
new OsuCheckbox
{
LabelText = "Block private messages from non-friends",
Bindable = config.GetBindable<bool>(OsuConfig.BlockNonFriendPM)
},
new OptionLabel { Text = "Chat ignore list (space-seperated list)" },
new OptionTextBox {
RelativeSizeAxes = Axes.X,
Bindable = config.GetBindable<string>(OsuConfig.IgnoreList)
},
new OptionLabel { Text = "Chat highlight words (space-seperated list)" },
new OptionTextBox {
RelativeSizeAxes = Axes.X,
Bindable = config.GetBindable<string>(OsuConfig.HighlightWords)
},
};
}
}
}

43
osu.Game/Overlays/Options/Sections/Online/IntegrationOptions.cs
View File

@ -1,43 +0,0 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Game.Configuration;
using osu.Game.Graphics.UserInterface;
namespace osu.Game.Overlays.Options.Sections.Online
{
public class IntegrationOptions : OptionsSubsection
{
protected override string Header => "Integration";
[BackgroundDependencyLoader]
private void load(OsuConfigManager config)
{
Children = new Drawable[]
{
new OsuCheckbox
{
LabelText = "Integrate with Yahoo! status display",
Bindable = config.GetBindable<bool>(OsuConfig.YahooIntegration)
},
new OsuCheckbox
{
LabelText = "Integrate with MSN Live status display",
Bindable = config.GetBindable<bool>(OsuConfig.MsnIntegration)
},
new OsuCheckbox
{
LabelText = "Automatically start osu!direct downloads",
Bindable = config.GetBindable<bool>(OsuConfig.AutomaticDownload)
},
new OsuCheckbox
{
LabelText = "Prefer no-video downloads",
Bindable = config.GetBindable<bool>(OsuConfig.AutomaticDownloadNoVideo)
},
};
}
}
}

53
osu.Game/Overlays/Options/Sections/Online/NotificationsOptions.cs
View File

@ -1,53 +0,0 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Game.Configuration;
using osu.Game.Graphics.UserInterface;
namespace osu.Game.Overlays.Options.Sections.Online
{
public class NotificationsOptions : OptionsSubsection
{
protected override string Header => "Notifications";
[BackgroundDependencyLoader]
private void load(OsuConfigManager config)
{
Children = new Drawable[]
{
new OsuCheckbox
{
LabelText = "Enable chat ticker",
Bindable = config.GetBindable<bool>(OsuConfig.Ticker)
},
new OsuCheckbox
{
LabelText = "Show a notification popup when someone says your name",
Bindable = config.GetBindable<bool>(OsuConfig.ChatHighlightName)
},
new OsuCheckbox
{
LabelText = "Show chat message notifications",
Bindable = config.GetBindable<bool>(OsuConfig.ChatMessageNotification)
},
new OsuCheckbox
{
LabelText = "Play a sound when someone says your name",
Bindable = config.GetBindable<bool>(OsuConfig.ChatAudibleHighlight)
},
new OsuCheckbox
{
LabelText = "Show notification popups instantly during gameplay",
Bindable = config.GetBindable<bool>(OsuConfig.PopupDuringGameplay)
},
new OsuCheckbox
{
LabelText = "Show notification popups when friends change status",
Bindable = config.GetBindable<bool>(OsuConfig.NotifyFriends)
},
};
}
}
}

33
osu.Game/Overlays/Options/Sections/Online/PrivacyOptions.cs
View File

@ -1,33 +0,0 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Game.Configuration;
using osu.Game.Graphics.UserInterface;
namespace osu.Game.Overlays.Options.Sections.Online
{
public class PrivacyOptions : OptionsSubsection
{
protected override string Header => "Privacy";
[BackgroundDependencyLoader]
private void load(OsuConfigManager config)
{
Children = new Drawable[]
{
new OsuCheckbox
{
LabelText = "Share your city location with others",
Bindable = config.GetBindable<bool>(OsuConfig.DisplayCityLocation)
},
new OsuCheckbox
{
LabelText = "Allow multiplayer game invites from all users",
Bindable = config.GetBindable<bool>(OsuConfig.AllowPublicInvites)
},
};
}
}
}

5
osu.Game/Overlays/Options/Sections/OnlineSection.cs
View File

@ -3,7 +3,6 @@
using osu.Framework.Graphics;
using osu.Game.Graphics;
using osu.Game.Overlays.Options.Sections.Online;
namespace osu.Game.Overlays.Options.Sections
{
@ -16,10 +15,6 @@ namespace osu.Game.Overlays.Options.Sections
{
Children = new Drawable[]
{
new InGameChatOptions(),
new PrivacyOptions(),
new NotificationsOptions(),
new IntegrationOptions(),
};
}
}

42
osu.Game/Overlays/Options/Sections/SkinSection.cs
View File

@ -21,43 +21,6 @@ namespace osu.Game.Overlays.Options.Sections
FlowContent.Spacing = new Vector2(0, 5);
Children = new Drawable[]
{
new OptionLabel { Text = "TODO: Skin preview textures" },
new OptionLabel { Text = "Current skin: TODO dropdown" },
new OsuButton
{
RelativeSizeAxes = Axes.X,
Text = "Preview gameplay",
},
new OsuButton
{
RelativeSizeAxes = Axes.X,
Text = "Open skin folder",
},
new OsuButton
{
RelativeSizeAxes = Axes.X,
Text = "Export as .osk",
},
new OsuCheckbox
{
LabelText = "Ignore all beatmap skins",
Bindable = config.GetBindable<bool>(OsuConfig.IgnoreBeatmapSkins)
},
new OsuCheckbox
{
LabelText = "Use skin's sound samples",
Bindable = config.GetBindable<bool>(OsuConfig.SkinSamples)
},
new OsuCheckbox
{
LabelText = "Use Taiko skin for Taiko mode",
Bindable = config.GetBindable<bool>(OsuConfig.UseTaikoSkin)
},
new OsuCheckbox
{
LabelText = "Always use skin cursor",
Bindable = config.GetBindable<bool>(OsuConfig.UseSkinCursor)
},
new OptionSlider<double, SizeSlider>
{
LabelText = "Menu cursor size",
@ -68,11 +31,6 @@ namespace osu.Game.Overlays.Options.Sections
LabelText = "Gameplay cursor size",
Bindable = config.GetBindable<double>(OsuConfig.GameplayCursorSize)
},
new OsuCheckbox
{
LabelText = "Automatic cursor size",
Bindable = config.GetBindable<bool>(OsuConfig.AutomaticCursorSizing)
},
};
}

1
osu.Game/Overlays/OptionsOverlay.cs
View File

@ -51,7 +51,6 @@ namespace osu.Game.Overlays
new AudioSection(),
new SkinSection(),
new InputSection(),
new EditorSection(),
new OnlineSection(),
new MaintenanceSection(),
new DebugSection(),

5
osu.Game/Rulesets/Mods/Mod.cs
View File

@ -21,6 +21,11 @@ namespace osu.Game.Rulesets.Mods
/// </summary>
public virtual FontAwesome Icon => FontAwesome.fa_question;
/// <summary>
/// The type of this mod.
/// </summary>
public virtual ModType Type => ModType.Special;
/// <summary>
/// The user readable description of this mod.
/// </summary>

1
osu.Game/Rulesets/Mods/ModDoubleTime.cs
View File

@ -11,6 +11,7 @@ namespace osu.Game.Rulesets.Mods
{
public override string Name => "Double Time";
public override FontAwesome Icon => FontAwesome.fa_osu_mod_doubletime;
public override ModType Type => ModType.DifficultyIncrease;
public override string Description => "Zoooooooooom";
public override bool Ranked => true;
public override Type[] IncompatibleMods => new[] { typeof(ModHalfTime) };

1
osu.Game/Rulesets/Mods/ModEasy.cs
View File

@ -10,6 +10,7 @@ namespace osu.Game.Rulesets.Mods
{
public override string Name => "Easy";
public override FontAwesome Icon => FontAwesome.fa_osu_mod_easy;
public override ModType Type => ModType.DifficultyReduction;
public override string Description => "Reduces overall difficulty - larger circles, more forgiving HP drain, less accuracy required.";
public override double ScoreMultiplier => 0.5;
public override bool Ranked => true;

1
osu.Game/Rulesets/Mods/ModFlashlight.cs
View File

@ -9,6 +9,7 @@ namespace osu.Game.Rulesets.Mods
{
public override string Name => "Flashlight";
public override FontAwesome Icon => FontAwesome.fa_osu_mod_flashlight;
public override ModType Type => ModType.DifficultyIncrease;
public override string Description => "Restricted view area.";
public override bool Ranked => true;
}

1
osu.Game/Rulesets/Mods/ModHalfTime.cs
View File

@ -11,6 +11,7 @@ namespace osu.Game.Rulesets.Mods
{
public override string Name => "Half Time";
public override FontAwesome Icon => FontAwesome.fa_osu_mod_halftime;
public override ModType Type => ModType.DifficultyReduction;
public override string Description => "Less zoom";
public override bool Ranked => true;
public override Type[] IncompatibleMods => new[] { typeof(ModDoubleTime) };

1
osu.Game/Rulesets/Mods/ModHardRock.cs
View File

@ -10,6 +10,7 @@ namespace osu.Game.Rulesets.Mods
{
public override string Name => "Hard Rock";
public override FontAwesome Icon => FontAwesome.fa_osu_mod_hardrock;
public override ModType Type => ModType.DifficultyIncrease;
public override string Description => "Everything just got a bit harder...";
public override Type[] IncompatibleMods => new[] { typeof(ModEasy) };
}

1
osu.Game/Rulesets/Mods/ModHidden.cs
View File

@ -9,6 +9,7 @@ namespace osu.Game.Rulesets.Mods
{
public override string Name => "Hidden";
public override FontAwesome Icon => FontAwesome.fa_osu_mod_hidden;
public override ModType Type => ModType.DifficultyIncrease;
public override bool Ranked => true;
}
}

1
osu.Game/Rulesets/Mods/ModNoFail.cs
View File

@ -10,6 +10,7 @@ namespace osu.Game.Rulesets.Mods
{
public override string Name => "NoFail";
public override FontAwesome Icon => FontAwesome.fa_osu_mod_nofail;
public override ModType Type => ModType.DifficultyReduction;
public override string Description => "You can't fail, no matter what.";
public override double ScoreMultiplier => 0.5;
public override bool Ranked => true;

1
osu.Game/Rulesets/Mods/ModSuddenDeath.cs
View File

@ -10,6 +10,7 @@ namespace osu.Game.Rulesets.Mods
{
public override string Name => "Sudden Death";
public override FontAwesome Icon => FontAwesome.fa_osu_mod_suddendeath;
public override ModType Type => ModType.DifficultyIncrease;
public override string Description => "Miss a note and fail.";
public override double ScoreMultiplier => 1;
public override bool Ranked => true;

4
osu.Game/Rulesets/UI/HitRenderer.cs
View File

@ -202,8 +202,6 @@ namespace osu.Game.Rulesets.UI
protected HitRenderer(WorkingBeatmap beatmap)
: base(beatmap)
{
KeyConversionInputManager.Add(Playfield = CreatePlayfield());
InputManager.Add(content = new Container
{
RelativeSizeAxes = Axes.Both,
@ -216,6 +214,8 @@ namespace osu.Game.Rulesets.UI
[BackgroundDependencyLoader]
private void load()
{
KeyConversionInputManager.Add(Playfield = CreatePlayfield());
loadObjects();
if (InputManager?.ReplayInputHandler != null)

105
osu.Game/Rulesets/UI/ModIcon.cs
View File

@ -1,10 +1,13 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using System;
using OpenTK.Graphics;
using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Game.Graphics;
using osu.Game.Rulesets.Mods;
namespace osu.Game.Rulesets.UI
{
@ -13,72 +16,88 @@ namespace osu.Game.Rulesets.UI
private readonly TextAwesome modIcon;
private readonly TextAwesome background;
private float iconSize = 80;
public float IconSize
{
get
{
return iconSize;
}
set
{
iconSize = value;
reapplySize();
}
}
public new Color4 Colour
{
get
{
return background.Colour;
}
set
{
background.Colour = value;
}
}
private const float icon_size = 80;
public FontAwesome Icon
{
get
{
return modIcon.Icon;
}
set
{
modIcon.Icon = value;
}
get { return modIcon.Icon; }
set { modIcon.Icon = value; }
}
private void reapplySize()
{
background.TextSize = iconSize;
modIcon.TextSize = iconSize - 35;
}
private readonly ModType type;
public ModIcon()
public ModIcon(Mod mod)
{
if (mod == null) throw new ArgumentNullException(nameof(mod));
type = mod.Type;
Children = new Drawable[]
{
background = new TextAwesome
{
Origin = Anchor.Centre,
Anchor = Anchor.Centre,
TextSize = icon_size,
Icon = FontAwesome.fa_osu_mod_bg,
Shadow = true,
TextSize = 20
},
modIcon = new TextAwesome
{
Origin = Anchor.Centre,
Anchor = Anchor.Centre,
Colour = OsuColour.Gray(84),
TextSize = 20
TextSize = icon_size - 35,
Icon = mod.Icon
},
};
}
reapplySize();
private Color4 backgroundColour;
private Color4 highlightedColour;
[BackgroundDependencyLoader]
private void load(OsuColour colours)
{
switch (type)
{
default:
case ModType.DifficultyIncrease:
backgroundColour = colours.Yellow;
highlightedColour = colours.YellowLight;
break;
case ModType.DifficultyReduction:
backgroundColour = colours.Green;
highlightedColour = colours.GreenLight;
break;
case ModType.Special:
backgroundColour = colours.Blue;
highlightedColour = colours.BlueLight;
break;
}
applyStyle();
}
private bool highlighted;
public bool Highlighted
{
get
{
return highlighted;
}
set
{
highlighted = value;
applyStyle();
}
}
private void applyStyle()
{
background.Colour = highlighted ? highlightedColour : backgroundColour;
}
}
}
}

2
osu.Game/Rulesets/UI/ComboCounter.cs → osu.Game/Screens/Play/HUD/ComboCounter.cs
View File

@ -10,7 +10,7 @@ using osu.Framework.Graphics.Transforms;
using osu.Framework.MathUtils;
using osu.Game.Graphics.Sprites;
namespace osu.Game.Rulesets.UI
namespace osu.Game.Screens.Play.HUD
{
public abstract class ComboCounter : Container
{

4
osu.Game/Rulesets/UI/ComboResultCounter.cs → osu.Game/Screens/Play/HUD/ComboResultCounter.cs
View File

@ -1,13 +1,13 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using System;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Transforms;
using osu.Framework.MathUtils;
using osu.Game.Graphics.UserInterface;
using System;
namespace osu.Game.Rulesets.UI
namespace osu.Game.Screens.Play.HUD
{
/// <summary>
/// Used to display combo with a roll-up animation in results screen.

2
osu.Game/Rulesets/UI/HealthDisplay.cs → osu.Game/Screens/Play/HUD/HealthDisplay.cs
View File

@ -4,7 +4,7 @@
using osu.Framework.Configuration;
using osu.Framework.Graphics.Containers;
namespace osu.Game.Rulesets.UI
namespace osu.Game.Screens.Play.HUD
{
public abstract class HealthDisplay : Container
{

105
osu.Game/Screens/Play/HUD/ModDisplay.cs Normal file
View File

@ -0,0 +1,105 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using System.Collections.Generic;
using System.Linq;
using osu.Framework.Configuration;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Primitives;
using osu.Framework.Graphics.UserInterface;
using osu.Game.Graphics.Sprites;
using osu.Game.Rulesets.Mods;
using osu.Game.Rulesets.UI;
using OpenTK;
using osu.Framework.Input;
namespace osu.Game.Screens.Play.HUD
{
public class ModDisplay : Container, IHasCurrentValue<IEnumerable<Mod>>
{
private readonly Bindable<IEnumerable<Mod>> mods = new Bindable<IEnumerable<Mod>>();
public Bindable<IEnumerable<Mod>> Current => mods;
private readonly FillFlowContainer<ModIcon> iconsContainer;
public ModDisplay()
{
Children = new Drawable[]
{
iconsContainer = new IconFlow
{
Anchor = Anchor.TopCentre,
Origin = Anchor.TopCentre,
AutoSizeAxes = Axes.Both,
Direction = FillDirection.Horizontal,
Margin = new MarginPadding { Left = 10, Right = 10 },
},
new OsuSpriteText
{
Anchor = Anchor.BottomCentre,
Origin = Anchor.TopCentre,
Text = @"/ UNRANKED /",
Font = @"Venera",
TextSize = 12,
}
};
mods.ValueChanged += mods =>
{
iconsContainer.Clear();
foreach (Mod mod in mods)
{
iconsContainer.Add(new ModIcon(mod)
{
AutoSizeAxes = Axes.Both,
Scale = new Vector2(0.6f),
});
}
if (IsLoaded)
appearTransform();
};
}
protected override void LoadComplete()
{
base.LoadComplete();
appearTransform();
}
private void appearTransform()
{
iconsContainer.Flush();
iconsContainer.FadeInFromZero(1000, EasingTypes.OutQuint);
expand();
using (iconsContainer.BeginDelayedSequence(1200))
contract();
}
private void expand() => iconsContainer.TransformSpacingTo(new Vector2(5, 0), 500, EasingTypes.OutQuint);
private void contract() => iconsContainer.TransformSpacingTo(new Vector2(-25, 0), 500, EasingTypes.OutQuint);
protected override bool OnHover(InputState state)
{
expand();
return base.OnHover(state);
}
protected override void OnHoverLost(InputState state)
{
contract();
base.OnHoverLost(state);
}
private class IconFlow : FillFlowContainer<ModIcon>
{
// just reverses the depth of flow contents.
protected override IComparer<Drawable> DepthComparer => new ReverseCreationOrderDepthComparer();
protected override IEnumerable<ModIcon> FlowingChildren => base.FlowingChildren.Reverse();
}
}
}

2
osu.Game/Rulesets/UI/StandardComboCounter.cs → osu.Game/Screens/Play/HUD/StandardComboCounter.cs
View File

@ -3,7 +3,7 @@
using OpenTK;
namespace osu.Game.Rulesets.UI
namespace osu.Game.Screens.Play.HUD
{
/// <summary>
/// Uses the 'x' symbol and has a pop-out effect while rolling over.

8
osu.Game/Rulesets/UI/StandardHealthDisplay.cs → osu.Game/Screens/Play/HUD/StandardHealthDisplay.cs
View File

@ -1,8 +1,7 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using OpenTK;
using OpenTK.Graphics;
using System;
using osu.Framework.Extensions.Color4Extensions;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
@ -10,9 +9,10 @@ using osu.Framework.Graphics.Sprites;
using osu.Game.Graphics;
using osu.Game.Rulesets.Judgements;
using osu.Game.Rulesets.Objects.Drawables;
using System;
using OpenTK;
using OpenTK.Graphics;
namespace osu.Game.Rulesets.UI
namespace osu.Game.Screens.Play.HUD
{
public class StandardHealthDisplay : HealthDisplay, IHasAccentColour
{

23
osu.Game/Rulesets/UI/HudOverlay.cs → osu.Game/Screens/Play/HUDOverlay.cs
View File

@ -5,18 +5,19 @@ using osu.Framework.Allocation;
using osu.Framework.Configuration;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Input;
using osu.Game.Configuration;
using osu.Game.Graphics.UserInterface;
using osu.Game.Screens.Play;
using osu.Game.Rulesets.Scoring;
using osu.Framework.Input;
using OpenTK.Input;
using osu.Game.Overlays;
using osu.Game.Overlays.Notifications;
using osu.Game.Rulesets.Scoring;
using osu.Game.Rulesets.UI;
using osu.Game.Screens.Play.HUD;
using OpenTK.Input;
namespace osu.Game.Rulesets.UI
namespace osu.Game.Screens.Play
{
public abstract class HudOverlay : Container
public abstract class HUDOverlay : Container
{
private const int duration = 100;
@ -27,6 +28,7 @@ namespace osu.Game.Rulesets.UI
public readonly RollingCounter<double> AccuracyCounter;
public readonly HealthDisplay HealthDisplay;
public readonly SongProgress Progress;
public readonly ModDisplay ModDisplay;
private Bindable<bool> showKeyCounter;
private Bindable<bool> showHud;
@ -39,8 +41,9 @@ namespace osu.Game.Rulesets.UI
protected abstract ScoreCounter CreateScoreCounter();
protected abstract HealthDisplay CreateHealthDisplay();
protected abstract SongProgress CreateProgress();
protected abstract ModDisplay CreateModsContainer();
protected HudOverlay()
protected HUDOverlay()
{
RelativeSizeAxes = Axes.Both;
@ -56,6 +59,7 @@ namespace osu.Game.Rulesets.UI
AccuracyCounter = CreateAccuracyCounter(),
HealthDisplay = CreateHealthDisplay(),
Progress = CreateProgress(),
ModDisplay = CreateModsContainer(),
}
});
}
@ -105,6 +109,11 @@ namespace osu.Game.Rulesets.UI
public virtual void BindHitRenderer(HitRenderer hitRenderer)
{
hitRenderer.InputManager.Add(KeyCounter.GetReceptor());
// in the case a replay isn't loaded, we want some elements to only appear briefly.
if (!hitRenderer.HasReplayLoaded)
using (ModDisplay.BeginDelayedSequence(2000))
ModDisplay.FadeOut(200);
}
protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)

6
osu.Game/Screens/Play/Player.cs
View File

@ -72,7 +72,7 @@ namespace osu.Game.Screens.Play
private Container hitRendererContainer;
private HudOverlay hudOverlay;
private HUDOverlay hudOverlay;
private PauseOverlay pauseOverlay;
private FailOverlay failOverlay;
@ -154,7 +154,7 @@ namespace osu.Game.Screens.Play
scoreProcessor = HitRenderer.CreateScoreProcessor();
hudOverlay = new StandardHudOverlay()
hudOverlay = new StandardHUDOverlay()
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre
@ -169,6 +169,8 @@ namespace osu.Game.Screens.Play
hudOverlay.Progress.AllowSeeking = HitRenderer.HasReplayLoaded;
hudOverlay.Progress.OnSeek = pos => decoupledClock.Seek(pos);
hudOverlay.ModDisplay.Current.BindTo(Beatmap.Mods);
//bind HitRenderer to ScoreProcessor and ourselves (for a pass situation)
HitRenderer.OnAllJudged += onCompletion;

16
osu.Game/Rulesets/UI/StandardHudOverlay.cs → osu.Game/Screens/Play/StandardHUDOverlay.cs
View File

@ -1,18 +1,18 @@
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using OpenTK;
using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Primitives;
using osu.Game.Graphics;
using osu.Game.Graphics.UserInterface;
using osu.Game.Rulesets.Scoring;
using osu.Game.Screens.Play;
using osu.Game.Screens.Play.HUD;
using OpenTK;
namespace osu.Game.Rulesets.UI
namespace osu.Game.Screens.Play
{
public class StandardHudOverlay : HudOverlay
public class StandardHUDOverlay : HUDOverlay
{
protected override RollingCounter<double> CreateAccuracyCounter() => new PercentageCounter
{
@ -64,6 +64,14 @@ namespace osu.Game.Rulesets.UI
RelativeSizeAxes = Axes.X,
};
protected override ModDisplay CreateModsContainer() => new ModDisplay
{
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
AutoSizeAxes = Axes.Both,
Margin = new MarginPadding { Top = 20, Right = 10 },
};
[BackgroundDependencyLoader]
private void load(OsuColour colours)
{

7
osu.Game/Screens/Select/PlaySongSelect.cs
View File

@ -69,6 +69,13 @@ namespace osu.Game.Screens.Select
base.OnResuming(last);
}
protected override void OnSuspending(Screen next)
{
modSelect.Hide();
base.OnSuspending(next);
}
protected override bool OnExiting(Screen next)
{
if (modSelect.State == Visibility.Visible)

28
osu.Game/osu.Game.csproj
View File

@ -78,6 +78,7 @@
<Compile Include="Overlays\Music\FilterControl.cs" />
<Compile Include="Overlays\Music\PlaylistItem.cs" />
<Compile Include="Overlays\Music\PlaylistList.cs" />
<Compile Include="Overlays\Options\Sections\Audio\MainMenuOptions.cs" />
<Compile Include="Overlays\Toolbar\ToolbarChatButton.cs" />
<Compile Include="Rulesets\Beatmaps\BeatmapConverter.cs" />
<Compile Include="Rulesets\Beatmaps\BeatmapProcessor.cs" />
@ -177,10 +178,9 @@
<Compile Include="Database\RulesetDatabase.cs" />
<Compile Include="Rulesets\Scoring\Score.cs" />
<Compile Include="Rulesets\Scoring\ScoreProcessor.cs" />
<Compile Include="Rulesets\UI\HealthDisplay.cs" />
<Compile Include="Rulesets\UI\HudOverlay.cs" />
<Compile Include="Rulesets\UI\StandardHealthDisplay.cs" />
<Compile Include="Rulesets\UI\StandardHudOverlay.cs" />
<Compile Include="Screens\Play\HUD\HealthDisplay.cs" />
<Compile Include="Screens\Play\HUDOverlay.cs" />
<Compile Include="Screens\Play\HUD\StandardHealthDisplay.cs" />
<Compile Include="Online\API\IOnlineComponent.cs" />
<Compile Include="Online\API\Requests\GetScoresRequest.cs" />
<Compile Include="Online\API\Requests\GetBeatmapDetailsRequest.cs" />
@ -227,7 +227,9 @@
<Compile Include="Screens\Charts\ChartInfo.cs" />
<Compile Include="Screens\Edit\Editor.cs" />
<Compile Include="Screens\Play\HotkeyRetryOverlay.cs" />
<Compile Include="Screens\Play\HUD\ModDisplay.cs" />
<Compile Include="Screens\Play\SquareGraph.cs" />
<Compile Include="Screens\Play\StandardHUDOverlay.cs" />
<Compile Include="Screens\Ranking\ResultsPage.cs" />
<Compile Include="Screens\Ranking\ResultsPageRanking.cs" />
<Compile Include="Screens\Ranking\ResultsPageScore.cs" />
@ -253,7 +255,7 @@
<Compile Include="Screens\Play\PlayerLoader.cs" />
<Compile Include="Screens\Play\ReplayPlayer.cs" />
<Compile Include="Screens\Play\SkipButton.cs" />
<Compile Include="Rulesets\UI\StandardComboCounter.cs" />
<Compile Include="Screens\Play\HUD\StandardComboCounter.cs" />
<Compile Include="Screens\Ranking\AspectContainer.cs" />
<Compile Include="Screens\Ranking\ResultMode.cs" />
<Compile Include="Screens\Ranking\ResultModeButton.cs" />
@ -278,8 +280,8 @@
<Compile Include="Rulesets\UI\HitRenderer.cs" />
<Compile Include="Rulesets\UI\Playfield.cs" />
<Compile Include="Screens\Select\EditSongSelect.cs" />
<Compile Include="Rulesets\UI\ComboCounter.cs" />
<Compile Include="Rulesets\UI\ComboResultCounter.cs" />
<Compile Include="Screens\Play\HUD\ComboCounter.cs" />
<Compile Include="Screens\Play\HUD\ComboResultCounter.cs" />
<Compile Include="Graphics\UserInterface\RollingCounter.cs" />
<Compile Include="Graphics\UserInterface\Volume\VolumeControlReceptor.cs" />
<Compile Include="Input\GlobalHotkeys.cs" />
@ -356,7 +358,6 @@
<Compile Include="Overlays\Options\Sections\Graphics\LayoutOptions.cs" />
<Compile Include="Overlays\Options\Sections\Graphics\DetailOptions.cs" />
<Compile Include="Overlays\Options\Sections\Graphics\MainMenuOptions.cs" />
<Compile Include="Overlays\Options\Sections\Graphics\SongSelectGraphicsOptions.cs" />
<Compile Include="Overlays\Options\Sections\GameplaySection.cs" />
<Compile Include="Overlays\Options\Sections\Gameplay\GeneralOptions.cs" />
<Compile Include="Overlays\Options\Sections\Gameplay\SongSelectOptions.cs" />
@ -367,25 +368,19 @@
<Compile Include="Overlays\Options\Sections\InputSection.cs" />
<Compile Include="Overlays\Options\Sections\Input\MouseOptions.cs" />
<Compile Include="Overlays\Options\Sections\Input\KeyboardOptions.cs" />
<Compile Include="Overlays\Options\Sections\Input\OtherInputOptions.cs" />
<Compile Include="Overlays\Options\Sections\OnlineSection.cs" />
<Compile Include="Overlays\Options\Sections\Online\IntegrationOptions.cs" />
<Compile Include="Overlays\Options\Sections\Online\InGameChatOptions.cs" />
<Compile Include="Overlays\Options\Sections\EditorSection.cs" />
<Compile Include="Overlays\Options\Sections\SkinSection.cs" />
<Compile Include="Overlays\Options\Sections\Online\PrivacyOptions.cs" />
<Compile Include="Overlays\Options\Sections\Online\NotificationsOptions.cs" />
<Compile Include="Graphics\UserInterface\OsuCheckbox.cs" />
<Compile Include="Overlays\Options\SidebarButton.cs" />
<Compile Include="Overlays\Options\OptionCheckbox.cs" />
<Compile Include="Overlays\Options\OptionTextBox.cs" />
<Compile Include="Overlays\Options\OptionSlider.cs" />
<Compile Include="Configuration\ProgressBarType.cs" />
<Compile Include="Overlays\Options\OptionItem.cs" />
<Compile Include="Overlays\Options\OptionEnumDropdown.cs" />
<Compile Include="Configuration\RankingType.cs" />
<Compile Include="Configuration\ScoreMeterType.cs" />
<Compile Include="Configuration\ReleaseStream.cs" />
<Compile Include="Configuration\ScreenshotFormat.cs" />
<Compile Include="Configuration\ConfineMouseMode.cs" />
<Compile Include="Graphics\OsuColour.cs" />
<Compile Include="Screens\Select\FilterControl.cs" />
<Compile Include="Screens\Select\SearchTextBox.cs" />
@ -398,6 +393,7 @@
<Compile Include="Screens\Play\Pause\PauseProgressGraph.cs" />
<Compile Include="Overlays\Mods\ModSelectOverlay.cs" />
<Compile Include="Rulesets\Mods\Mod.cs" />
<Compile Include="Overlays\Mods\ModButtonEmpty.cs" />
<Compile Include="Overlays\Mods\ModButton.cs" />
<Compile Include="Rulesets\UI\ModIcon.cs" />
<Compile Include="Overlays\Mods\ModSection.cs" />

1
osu.sln.DotSettings
View File

@ -182,6 +182,7 @@
<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=GL/@EntryIndexedValue">GL</s:String>
<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=GLSL/@EntryIndexedValue">GLSL</s:String>
<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=HID/@EntryIndexedValue">HID</s:String>
<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=HUD/@EntryIndexedValue">HUD</s:String>
<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=ID/@EntryIndexedValue">ID</s:String>
<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=IP/@EntryIndexedValue">IP</s:String>
<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=IPC/@EntryIndexedValue">IPC</s:String>