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

Merge branch 'master' into counters-a

Browse Source
This commit is contained in:
Adonais Romero González 2016-10-13 22:57:24 -05:00
commit 53cd698b3a
20 changed files with 593 additions and 543 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
osu-framework

@ -1 +1 @@
Subproject commit 30ff0e1a99a10e735611bb3ffa35352061f52d8a Subproject commit 3629521379bea5d79cd41e35ad6c6dfe21b4f9e7

67
osu.Desktop/Beatmaps/IO/LegacyFilesystemReader.cs
View File

@ -1,38 +1,39 @@
using System; using System;
using System.IO; using System.IO;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using osu.Game.Beatmaps.Formats; using osu.Game.Beatmaps.Formats;
using osu.Game.Beatmaps.IO; using osu.Game.Beatmaps.IO;
using osu.Game.Beatmaps; using osu.Game.Beatmaps;
namespace osu.Desktop.Beatmaps.IO namespace osu.Desktop.Beatmaps.IO
{ {
/// <summary> /// <summary>
/// Reads an extracted legacy beatmap from disk. /// Reads an extracted legacy beatmap from disk.
/// </summary> /// </summary>
public class LegacyFilesystemReader : ArchiveReader public class LegacyFilesystemReader : ArchiveReader
{ {
static LegacyFilesystemReader() static LegacyFilesystemReader()
{ {
AddReader<LegacyFilesystemReader>((storage, path) => Directory.Exists(path)); AddReader<LegacyFilesystemReader>((storage, path) => Directory.Exists(path));
} }
private string basePath { get; set; } private string basePath { get; set; }
private string[] beatmaps { get; set; } private string[] beatmaps { get; set; }
private Beatmap firstMap { get; set; } private Beatmap firstMap { get; set; }
public LegacyFilesystemReader(string path) public LegacyFilesystemReader(string path)
{ {
basePath = path; basePath = path;
beatmaps = Directory.GetFiles(basePath, @"*.osu").Select(f => Path.GetFileName(f)).ToArray(); beatmaps = Directory.GetFiles(basePath, @"*.osu").Select(f => Path.GetFileName(f)).ToArray();
if (beatmaps.Length == 0) if (beatmaps.Length == 0)
throw new FileNotFoundException(@"This directory contains no beatmaps"); throw new FileNotFoundException(@"This directory contains no beatmaps");
using (var stream = new StreamReader(ReadFile(beatmaps[0]))) using (var stream = new StreamReader(ReadFile(beatmaps[0])))
{ {
var decoder = BeatmapDecoder.GetDecoder(stream); var decoder = BeatmapDecoder.GetDecoder(stream);
firstMap = decoder.Decode(stream); firstMap = new Beatmap();
} decoder.Decode(stream, firstMap);
}
} }
public override string[] ReadBeatmaps() public override string[] ReadBeatmaps()
@ -48,10 +49,10 @@ namespace osu.Desktop.Beatmaps.IO
public override BeatmapMetadata ReadMetadata() public override BeatmapMetadata ReadMetadata()
{ {
return firstMap.Metadata; return firstMap.Metadata;
} }
public override void Dispose() public override void Dispose()
{ {
// no-op // no-op
} } } }
} }

249
osu.Game.Tests/Beatmaps/Formats/OsuLegacyDecoderTest.cs
View File

@ -1,143 +1,150 @@
using System; using System;
using System.IO; using System.IO;
using NUnit.Framework; using NUnit.Framework;
using OpenTK; using OpenTK;
using OpenTK.Graphics; using OpenTK.Graphics;
using osu.Game.Beatmaps;
using osu.Game.Beatmaps.Formats; using osu.Game.Beatmaps.Formats;
using osu.Game.Beatmaps.Objects.Osu; using osu.Game.Beatmaps.Objects.Osu;
using osu.Game.Beatmaps.Samples; using osu.Game.Beatmaps.Samples;
using osu.Game.GameModes.Play; using osu.Game.GameModes.Play;
using osu.Game.Tests.Resources; using osu.Game.Tests.Resources;
namespace osu.Game.Tests.Beatmaps.Formats namespace osu.Game.Tests.Beatmaps.Formats
{ {
[TestFixture] [TestFixture]
public class OsuLegacyDecoderTest public class OsuLegacyDecoderTest
{ {
[TestFixtureSetUp] [TestFixtureSetUp]
public void SetUp() public void SetUp()
{ {
OsuLegacyDecoder.Register(); OsuLegacyDecoder.Register();
} }
[Test] [Test]
public void TestDecodeMetadata() public void TestDecodeMetadata()
{ {
var decoder = new OsuLegacyDecoder(); var decoder = new OsuLegacyDecoder();
using (var stream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu")) using (var stream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
{ {
var beatmap = decoder.Decode(new StreamReader(stream)); Beatmap beatmap = new Beatmap();
var meta = beatmap.Metadata; decoder.Decode(new StreamReader(stream), beatmap);
Assert.AreEqual(241526, meta.BeatmapSetID); var meta = beatmap.Metadata;
Assert.AreEqual("Soleily", meta.Artist); Assert.AreEqual(241526, meta.BeatmapSetID);
Assert.AreEqual("Soleily", meta.ArtistUnicode); Assert.AreEqual("Soleily", meta.Artist);
Assert.AreEqual("03. Renatus - Soleily 192kbps.mp3", meta.AudioFile); Assert.AreEqual("Soleily", meta.ArtistUnicode);
Assert.AreEqual("Gamu", meta.Author); Assert.AreEqual("03. Renatus - Soleily 192kbps.mp3", meta.AudioFile);
Assert.AreEqual("machinetop_background.jpg", meta.BackgroundFile); Assert.AreEqual("Gamu", meta.Author);
Assert.AreEqual(164471, meta.PreviewTime); Assert.AreEqual("machinetop_background.jpg", meta.BackgroundFile);
Assert.AreEqual(string.Empty, meta.Source); Assert.AreEqual(164471, meta.PreviewTime);
Assert.AreEqual("MBC7 Unisphere 地球ヤバイEP Chikyu Yabai", meta.Tags); Assert.AreEqual(string.Empty, meta.Source);
Assert.AreEqual("Renatus", meta.Title); Assert.AreEqual("MBC7 Unisphere 地球ヤバイEP Chikyu Yabai", meta.Tags);
Assert.AreEqual("Renatus", meta.TitleUnicode); Assert.AreEqual("Renatus", meta.Title);
} Assert.AreEqual("Renatus", meta.TitleUnicode);
}
} }
[Test] [Test]
public void TestDecodeGeneral() public void TestDecodeGeneral()
{ {
var decoder = new OsuLegacyDecoder(); var decoder = new OsuLegacyDecoder();
using (var stream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu")) using (var stream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
{ {
var beatmap = decoder.Decode(new StreamReader(stream)); Beatmap beatmap = new Beatmap();
Assert.AreEqual(0, beatmap.AudioLeadIn); decoder.Decode(new StreamReader(stream), beatmap);
Assert.AreEqual(false, beatmap.Countdown); Assert.AreEqual(0, beatmap.AudioLeadIn);
Assert.AreEqual(SampleSet.Soft, beatmap.SampleSet); Assert.AreEqual(false, beatmap.Countdown);
Assert.AreEqual(0.7f, beatmap.StackLeniency); Assert.AreEqual(SampleSet.Soft, beatmap.SampleSet);
Assert.AreEqual(false, beatmap.SpecialStyle); Assert.AreEqual(0.7f, beatmap.StackLeniency);
Assert.AreEqual(PlayMode.Osu, beatmap.Mode); Assert.AreEqual(false, beatmap.SpecialStyle);
Assert.AreEqual(false, beatmap.LetterboxInBreaks); Assert.AreEqual(PlayMode.Osu, beatmap.Mode);
Assert.AreEqual(false, beatmap.WidescreenStoryboard); Assert.AreEqual(false, beatmap.LetterboxInBreaks);
} Assert.AreEqual(false, beatmap.WidescreenStoryboard);
}
} }
[Test] [Test]
public void TestDecodeEditor() public void TestDecodeEditor()
{ {
var decoder = new OsuLegacyDecoder(); var decoder = new OsuLegacyDecoder();
using (var stream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu")) using (var stream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
{ {
var beatmap = decoder.Decode(new StreamReader(stream)); Beatmap beatmap = new Beatmap();
int[] expectedBookmarks = decoder.Decode(new StreamReader(stream), beatmap);
{ int[] expectedBookmarks =
11505, 22054, 32604, 43153, 53703, 64252, 74802, 85351, {
95901, 106450, 116999, 119637, 130186, 140735, 151285, 11505, 22054, 32604, 43153, 53703, 64252, 74802, 85351,
161834, 164471, 175020, 185570, 196119, 206669, 209306 95901, 106450, 116999, 119637, 130186, 140735, 151285,
}; 161834, 164471, 175020, 185570, 196119, 206669, 209306
Assert.AreEqual(expectedBookmarks.Length, beatmap.Bookmarks.Length); };
for (int i = 0; i < expectedBookmarks.Length; i++) Assert.AreEqual(expectedBookmarks.Length, beatmap.Bookmarks.Length);
Assert.AreEqual(expectedBookmarks[i], beatmap.Bookmarks[i]); for (int i = 0; i < expectedBookmarks.Length; i++)
Assert.AreEqual(1.8, beatmap.DistanceSpacing); Assert.AreEqual(expectedBookmarks[i], beatmap.Bookmarks[i]);
Assert.AreEqual(4, beatmap.BeatDivisor); Assert.AreEqual(1.8, beatmap.DistanceSpacing);
Assert.AreEqual(4, beatmap.GridSize); Assert.AreEqual(4, beatmap.BeatDivisor);
Assert.AreEqual(2, beatmap.TimelineZoom); Assert.AreEqual(4, beatmap.GridSize);
} Assert.AreEqual(2, beatmap.TimelineZoom);
}
} }
[Test] [Test]
public void TestDecodeDifficulty() public void TestDecodeDifficulty()
{ {
var decoder = new OsuLegacyDecoder(); var decoder = new OsuLegacyDecoder();
using (var stream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu")) using (var stream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
{ {
var beatmap = decoder.Decode(new StreamReader(stream)); Beatmap beatmap = new Beatmap();
var difficulty = beatmap.BaseDifficulty; decoder.Decode(new StreamReader(stream), beatmap);
Assert.AreEqual(6.5f, difficulty.DrainRate); var difficulty = beatmap.BaseDifficulty;
Assert.AreEqual(4, difficulty.CircleSize); Assert.AreEqual(6.5f, difficulty.DrainRate);
Assert.AreEqual(8, difficulty.OverallDifficulty); Assert.AreEqual(4, difficulty.CircleSize);
Assert.AreEqual(9, difficulty.ApproachRate); Assert.AreEqual(8, difficulty.OverallDifficulty);
Assert.AreEqual(1.8f, difficulty.SliderMultiplier); Assert.AreEqual(9, difficulty.ApproachRate);
Assert.AreEqual(2, difficulty.SliderTickRate); Assert.AreEqual(1.8f, difficulty.SliderMultiplier);
} Assert.AreEqual(2, difficulty.SliderTickRate);
}
} }
[Test] [Test]
public void TestDecodeColors() public void TestDecodeColors()
{ {
var decoder = new OsuLegacyDecoder(); var decoder = new OsuLegacyDecoder();
using (var stream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu")) using (var stream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
{ {
var beatmap = decoder.Decode(new StreamReader(stream)); Beatmap beatmap = new Beatmap();
decoder.Decode(new StreamReader(stream), beatmap);
Color4[] expected = Color4[] expected =
{ {
new Color4(142, 199, 255, 255), new Color4(142, 199, 255, 255),
new Color4(255, 128, 128, 255), new Color4(255, 128, 128, 255),
new Color4(128, 255, 255, 255), new Color4(128, 255, 255, 255),
new Color4(128, 255, 128, 255), new Color4(128, 255, 128, 255),
new Color4(255, 187, 255, 255), new Color4(255, 187, 255, 255),
new Color4(255, 177, 140, 255), new Color4(255, 177, 140, 255),
}; };
Assert.AreEqual(expected.Length, beatmap.ComboColors.Count); Assert.AreEqual(expected.Length, beatmap.ComboColors.Count);
for (int i = 0; i < expected.Length; i++) for (int i = 0; i < expected.Length; i++)
Assert.AreEqual(expected[i], beatmap.ComboColors[i]); Assert.AreEqual(expected[i], beatmap.ComboColors[i]);
} }
} }
[Test] public void TestDecodeHitObjects() [Test] public void TestDecodeHitObjects()
{ {
var decoder = new OsuLegacyDecoder(); var decoder = new OsuLegacyDecoder();
using (var stream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu")) using (var stream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
{ {
var beatmap = decoder.Decode(new StreamReader(stream)); Beatmap beatmap = new Beatmap();
var slider = beatmap.HitObjects[0] as Slider; decoder.Decode(new StreamReader(stream), beatmap);
Assert.IsNotNull(slider); var slider = beatmap.HitObjects[0] as Slider;
Assert.AreEqual(new Vector2(192, 168), slider.Position); Assert.IsNotNull(slider);
Assert.AreEqual(956, slider.StartTime); Assert.AreEqual(new Vector2(192, 168), slider.Position);
Assert.AreEqual(SampleType.None, slider.Sample.Type); Assert.AreEqual(956, slider.StartTime);
var circle = beatmap.HitObjects[1] as Circle; Assert.AreEqual(SampleType.None, slider.Sample.Type);
Assert.IsNotNull(circle); var circle = beatmap.HitObjects[1] as Circle;
Assert.AreEqual(new Vector2(304, 56), circle.Position); Assert.IsNotNull(circle);
Assert.AreEqual(1285, circle.StartTime); Assert.AreEqual(new Vector2(304, 56), circle.Position);
Assert.AreEqual(1285, circle.StartTime);
Assert.AreEqual(SampleType.Clap, circle.Sample.Type); Assert.AreEqual(SampleType.Clap, circle.Sample.Type);
} }
} }
} }
} }

144
osu.Game.Tests/Beatmaps/IO/OszArchiveReaderTest.cs
View File

@ -1,81 +1,81 @@
using System; using System;
using System.IO; using System.IO;
using NUnit.Framework; using NUnit.Framework;
using osu.Game.Beatmaps.IO; using osu.Game.Beatmaps.IO;
using osu.Game.GameModes.Play; using osu.Game.GameModes.Play;
using osu.Game.Tests.Resources; using osu.Game.Tests.Resources;
namespace osu.Game.Tests.Beatmaps.IO namespace osu.Game.Tests.Beatmaps.IO
{ {
[TestFixture] [TestFixture]
public class OszArchiveReaderTest public class OszArchiveReaderTest
{ {
[TestFixtureSetUp] [TestFixtureSetUp]
public void SetUp() public void SetUp()
{ {
OszArchiveReader.Register(); OszArchiveReader.Register();
} }
[Test] [Test]
public void TestReadBeatmaps() public void TestReadBeatmaps()
{ {
using (var osz = Resource.OpenResource("Beatmaps.241526 Soleily - Renatus.osz")) using (var osz = Resource.OpenResource("Beatmaps.241526 Soleily - Renatus.osz"))
{ {
var reader = new OszArchiveReader(osz); var reader = new OszArchiveReader(osz);
string[] expected = string[] expected =
{ {
"Soleily - Renatus (Deif) [Platter].osu", "Soleily - Renatus (Deif) [Platter].osu",
"Soleily - Renatus (Deif) [Rain].osu", "Soleily - Renatus (Deif) [Rain].osu",
"Soleily - Renatus (Deif) [Salad].osu", "Soleily - Renatus (Deif) [Salad].osu",
"Soleily - Renatus (ExPew) [Another].osu", "Soleily - Renatus (ExPew) [Another].osu",
"Soleily - Renatus (ExPew) [Hyper].osu", "Soleily - Renatus (ExPew) [Hyper].osu",
"Soleily - Renatus (ExPew) [Normal].osu", "Soleily - Renatus (ExPew) [Normal].osu",
"Soleily - Renatus (Gamu) [Hard].osu", "Soleily - Renatus (Gamu) [Hard].osu",
"Soleily - Renatus (Gamu) [Insane].osu", "Soleily - Renatus (Gamu) [Insane].osu",
"Soleily - Renatus (Gamu) [Normal].osu", "Soleily - Renatus (Gamu) [Normal].osu",
"Soleily - Renatus (MMzz) [Futsuu].osu", "Soleily - Renatus (MMzz) [Futsuu].osu",
"Soleily - Renatus (MMzz) [Muzukashii].osu", "Soleily - Renatus (MMzz) [Muzukashii].osu",
"Soleily - Renatus (MMzz) [Oni].osu" "Soleily - Renatus (MMzz) [Oni].osu"
}; };
var maps = reader.ReadBeatmaps(); var maps = reader.ReadBeatmaps();
foreach (var map in expected) foreach (var map in expected)
Assert.Contains(map, maps); Assert.Contains(map, maps);
} }
} }
[Test] [Test]
public void TestReadMetadata() public void TestReadMetadata()
{ {
using (var osz = Resource.OpenResource("Beatmaps.241526 Soleily - Renatus.osz")) using (var osz = Resource.OpenResource("Beatmaps.241526 Soleily - Renatus.osz"))
{ {
var reader = new OszArchiveReader(osz); var reader = new OszArchiveReader(osz);
var meta = reader.ReadMetadata(); var meta = reader.ReadMetadata();
Assert.AreEqual(241526, meta.BeatmapSetID); Assert.AreEqual(241526, meta.BeatmapSetID);
Assert.AreEqual("Soleily", meta.Artist); Assert.AreEqual("Soleily", meta.Artist);
Assert.AreEqual("Soleily", meta.ArtistUnicode); Assert.AreEqual("Soleily", meta.ArtistUnicode);
Assert.AreEqual("03. Renatus - Soleily 192kbps.mp3", meta.AudioFile); Assert.AreEqual("03. Renatus - Soleily 192kbps.mp3", meta.AudioFile);
Assert.AreEqual("Deif", meta.Author); Assert.AreEqual("Deif", meta.Author);
Assert.AreEqual("machinetop_background.jpg", meta.BackgroundFile); Assert.AreEqual("machinetop_background.jpg", meta.BackgroundFile);
Assert.AreEqual(164471, meta.PreviewTime); Assert.AreEqual(164471, meta.PreviewTime);
Assert.AreEqual(string.Empty, meta.Source); Assert.AreEqual(string.Empty, meta.Source);
Assert.AreEqual("MBC7 Unisphere 地球ヤバイEP Chikyu Yabai", meta.Tags); Assert.AreEqual("MBC7 Unisphere 地球ヤバイEP Chikyu Yabai", meta.Tags);
Assert.AreEqual("Renatus", meta.Title); Assert.AreEqual("Renatus", meta.Title);
Assert.AreEqual("Renatus", meta.TitleUnicode); Assert.AreEqual("Renatus", meta.TitleUnicode);
} }
} }
[Test] [Test]
public void TestReadFile() public void TestReadFile()
{ {
using (var osz = Resource.OpenResource("Beatmaps.241526 Soleily - Renatus.osz")) using (var osz = Resource.OpenResource("Beatmaps.241526 Soleily - Renatus.osz"))
{ {
var reader = new OszArchiveReader(osz); var reader = new OszArchiveReader(osz);
using (var stream = new StreamReader( using (var stream = new StreamReader(
reader.ReadFile("Soleily - Renatus (Deif) [Platter].osu"))) reader.ReadFile("Soleily - Renatus (Deif) [Platter].osu")))
{ {
Assert.AreEqual("osu file format v13", stream.ReadLine().Trim()); Assert.AreEqual("osu file format v13", stream.ReadLine().Trim());
} }
} }
} }
} }
} }

26
osu.Game.Tests/Resources/Resource.cs
View File

@ -1,17 +1,17 @@
using System; using System;
using System.IO; using System.IO;
using System.Reflection; using System.Reflection;
namespace osu.Game.Tests.Resources namespace osu.Game.Tests.Resources
{ {
public static class Resource public static class Resource
{ {
public static Stream OpenResource(string name) public static Stream OpenResource(string name)
{ {
return Assembly.GetExecutingAssembly().GetManifestResourceStream( return Assembly.GetExecutingAssembly().GetManifestResourceStream(
$@"osu.Game.Tests.Resources.{name}") ?? $@"osu.Game.Tests.Resources.{name}") ??
Assembly.LoadFrom("osu.Game.Resources.dll").GetManifestResourceStream( Assembly.LoadFrom("osu.Game.Resources.dll").GetManifestResourceStream(
$@"osu.Game.Resources.{name}"); $@"osu.Game.Resources.{name}");
} }
} }
} }

32
osu.Game/Beatmaps/BaseDifficulty.cs
View File

@ -1,18 +1,18 @@
using System; using System;
using SQLite; using SQLite;
namespace osu.Game.Beatmaps namespace osu.Game.Beatmaps
{ {
public class BaseDifficulty public class BaseDifficulty
{ {
[PrimaryKey, AutoIncrement] [PrimaryKey, AutoIncrement]
public int ID { get; set; } public int ID { get; set; }
public float DrainRate { get; set; } public float DrainRate { get; set; }
public float CircleSize { get; set; } public float CircleSize { get; set; }
public float OverallDifficulty { get; set; } public float OverallDifficulty { get; set; }
public float ApproachRate { get; set; } public float ApproachRate { get; set; }
public float SliderMultiplier { get; set; } public float SliderMultiplier { get; set; }
public float SliderTickRate { get; set; } public float SliderTickRate { get; set; }
} }
} }

4
osu.Game/Beatmaps/BeatmapSet.cs
View File

@ -17,10 +17,12 @@ namespace osu.Game.Beatmaps
[NotNull, Indexed] [NotNull, Indexed]
public int BeatmapMetadataID { get; set; } public int BeatmapMetadataID { get; set; }
[Ignore] [Ignore]
public List<Beatmap> Beatmaps { get; protected set; } public List<Beatmap> Beatmaps { get; protected set; } = new List<Beatmap>();
[Ignore] [Ignore]
public BeatmapMetadata Metadata { get; set; } public BeatmapMetadata Metadata { get; set; }
[Ignore] [Ignore]
public User Creator { get; set; } public User Creator { get; set; }
public string Hash { get; set; }
public string Path { get; set; }
} }
} }

26
osu.Game/Beatmaps/Events/EventType.cs
View File

@ -1,14 +1,14 @@
using System; using System;
namespace osu.Game.Beatmaps.Events namespace osu.Game.Beatmaps.Events
{ {
public enum EventType public enum EventType
{ {
Background = 0, Background = 0,
Video = 1, Video = 1,
Break = 2, Break = 2,
Colour = 3, Colour = 3,
Sprite = 4, Sprite = 4,
Sample = 5, Sample = 5,
Animation = 6 Animation = 6
} }
} }

44
osu.Game/Beatmaps/Formats/BeatmapDecoder.cs
View File

@ -1,25 +1,25 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
namespace osu.Game.Beatmaps.Formats namespace osu.Game.Beatmaps.Formats
{ {
public abstract class BeatmapDecoder public abstract class BeatmapDecoder
{ {
private static Dictionary<string, Type> decoders { get; } = new Dictionary<string, Type>(); private static Dictionary<string, Type> decoders { get; } = new Dictionary<string, Type>();
public static BeatmapDecoder GetDecoder(TextReader stream) public static BeatmapDecoder GetDecoder(TextReader stream)
{ {
var line = stream.ReadLine().Trim(); var line = stream.ReadLine().Trim();
if (!decoders.ContainsKey(line)) if (!decoders.ContainsKey(line))
throw new IOException(@"Unknown file format"); throw new IOException(@"Unknown file format");
return (BeatmapDecoder)Activator.CreateInstance(decoders[line]); return (BeatmapDecoder)Activator.CreateInstance(decoders[line]);
} }
protected static void AddDecoder<T>(string magic) where T : BeatmapDecoder protected static void AddDecoder<T>(string magic) where T : BeatmapDecoder
{ {
decoders[magic] = typeof(T); decoders[magic] = typeof(T);
} }
public abstract Beatmap Decode(TextReader stream); public abstract void Decode(TextReader stream, Beatmap beatmap);
} }
} }

19
osu.Game/Beatmaps/Formats/OsuLegacyDecoder.cs
View File

@ -202,16 +202,16 @@ namespace osu.Game.Beatmaps.Formats
}); });
} }
public override Beatmap Decode(TextReader stream) public override void Decode(TextReader stream, Beatmap beatmap)
{ {
var beatmap = new Beatmap // We don't overwrite these two because they're DB bound
{ if (beatmap.Metadata == null) beatmap.Metadata = new BeatmapMetadata();
Metadata = new BeatmapMetadata(), if (beatmap.BaseDifficulty == null) beatmap.BaseDifficulty = new BaseDifficulty();
BaseDifficulty = new BaseDifficulty(), // These are fine though
HitObjects = new List<HitObject>(), beatmap.HitObjects = new List<HitObject>();
ControlPoints = new List<ControlPoint>(), beatmap.ControlPoints = new List<ControlPoint>();
ComboColors = new List<Color4>(), beatmap.ComboColors = new List<Color4>();
};
var section = Section.None; var section = Section.None;
string line; string line;
while (true) while (true)
@ -266,7 +266,6 @@ namespace osu.Game.Beatmaps.Formats
break; break;
} }
} }
return beatmap;
} }
} }
} }

82
osu.Game/Beatmaps/IO/ArchiveReader.cs
View File

@ -1,48 +1,48 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
using osu.Framework.Platform; using osu.Framework.Platform;
namespace osu.Game.Beatmaps.IO namespace osu.Game.Beatmaps.IO
{ {
public abstract class ArchiveReader : IDisposable public abstract class ArchiveReader : IDisposable
{ {
private class Reader private class Reader
{ {
public Func<BasicStorage, string, bool> Test { get; set; } public Func<BasicStorage, string, bool> Test { get; set; }
public Type Type { get; set; } public Type Type { get; set; }
} }
private static List<Reader> readers { get; } = new List<Reader>(); private static List<Reader> readers { get; } = new List<Reader>();
public static ArchiveReader GetReader(BasicStorage storage, string path) public static ArchiveReader GetReader(BasicStorage storage, string path)
{ {
foreach (var reader in readers) foreach (var reader in readers)
{ {
if (reader.Test(storage, path)) if (reader.Test(storage, path))
return (ArchiveReader)Activator.CreateInstance(reader.Type, storage.GetStream(path)); return (ArchiveReader)Activator.CreateInstance(reader.Type, storage.GetStream(path));
} }
throw new IOException(@"Unknown file format"); throw new IOException(@"Unknown file format");
} }
protected static void AddReader<T>(Func<BasicStorage, string, bool> test) where T : ArchiveReader protected static void AddReader<T>(Func<BasicStorage, string, bool> test) where T : ArchiveReader
{ {
readers.Add(new Reader { Test = test, Type = typeof(T) }); readers.Add(new Reader { Test = test, Type = typeof(T) });
} }
/// <summary> /// <summary>
/// Reads the beatmap metadata from this archive. /// Reads the beatmap metadata from this archive.
/// </summary> /// </summary>
public abstract BeatmapMetadata ReadMetadata(); public abstract BeatmapMetadata ReadMetadata();
/// <summary> /// <summary>
/// Gets a list of beatmap file names. /// Gets a list of beatmap file names.
/// </summary> /// </summary>
public abstract string[] ReadBeatmaps(); public abstract string[] ReadBeatmaps();
/// <summary> /// <summary>
/// Opens a stream for reading a specific file from this archive. /// Opens a stream for reading a specific file from this archive.
/// </summary> /// </summary>
public abstract Stream ReadFile(string name); public abstract Stream ReadFile(string name);
public abstract void Dispose(); public abstract void Dispose();
} }
} }

74
osu.Game/Beatmaps/IO/OszArchiveReader.cs
View File

@ -1,39 +1,41 @@
using System; using System;
using System.IO; using System.IO;
using System.Linq; using System.Linq;
using System.Security.Cryptography;
using Ionic.Zip; using Ionic.Zip;
using osu.Game.Beatmaps.Formats; using osu.Game.Beatmaps.Formats;
namespace osu.Game.Beatmaps.IO namespace osu.Game.Beatmaps.IO
{ {
public sealed class OszArchiveReader : ArchiveReader public sealed class OszArchiveReader : ArchiveReader
{ {
public static void Register() public static void Register()
{ {
AddReader<OszArchiveReader>((storage, path) => AddReader<OszArchiveReader>((storage, path) =>
{ {
using (var stream = storage.GetStream(path)) using (var stream = storage.GetStream(path))
return ZipFile.IsZipFile(stream, false); return ZipFile.IsZipFile(stream, false);
}); });
OsuLegacyDecoder.Register(); OsuLegacyDecoder.Register();
} }
private ZipFile archive { get; set; } private ZipFile archive { get; set; }
private string[] beatmaps { get; set; } private string[] beatmaps { get; set; }
private Beatmap firstMap { get; set; } private Beatmap firstMap { get; set; }
public OszArchiveReader(Stream archiveStream) public OszArchiveReader(Stream archiveStream)
{ {
archive = ZipFile.Read(archiveStream); archive = ZipFile.Read(archiveStream);
beatmaps = archive.Entries.Where(e => e.FileName.EndsWith(@".osu")) beatmaps = archive.Entries.Where(e => e.FileName.EndsWith(@".osu"))
.Select(e => e.FileName).ToArray(); .Select(e => e.FileName).ToArray();
if (beatmaps.Length == 0) if (beatmaps.Length == 0)
throw new FileNotFoundException(@"This directory contains no beatmaps"); throw new FileNotFoundException(@"This directory contains no beatmaps");
using (var stream = new StreamReader(ReadFile(beatmaps[0]))) using (var stream = new StreamReader(ReadFile(beatmaps[0])))
{ {
var decoder = BeatmapDecoder.GetDecoder(stream); var decoder = BeatmapDecoder.GetDecoder(stream);
firstMap = decoder.Decode(stream); firstMap = new Beatmap();
} decoder.Decode(stream, firstMap);
}
} }
public override string[] ReadBeatmaps() public override string[] ReadBeatmaps()
@ -43,9 +45,9 @@ namespace osu.Game.Beatmaps.IO
public override Stream ReadFile(string name) public override Stream ReadFile(string name)
{ {
ZipEntry entry = archive.Entries.SingleOrDefault(e => e.FileName == name); ZipEntry entry = archive.Entries.SingleOrDefault(e => e.FileName == name);
if (entry == null) if (entry == null)
throw new FileNotFoundException(); throw new FileNotFoundException();
return entry.OpenReader(); return entry.OpenReader();
} }
@ -53,9 +55,9 @@ namespace osu.Game.Beatmaps.IO
{ {
return firstMap.Metadata; return firstMap.Metadata;
} }
public override void Dispose() public override void Dispose()
{ {
archive.Dispose(); archive.Dispose();
} }
} }
} }

128
osu.Game/Database/BeatmapDatabase.cs
View File

@ -1,50 +1,100 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
using System.Security.Cryptography;
using osu.Framework.Platform; using osu.Framework.Platform;
using osu.Game.Beatmaps; using osu.Game.Beatmaps;
using osu.Game.Beatmaps.Formats; using osu.Game.Beatmaps.Formats;
using osu.Game.Beatmaps.IO; using osu.Game.Beatmaps.IO;
using SQLite; using SQLite;
namespace osu.Game.Database namespace osu.Game.Database
{ {
public class BeatmapDatabase public class BeatmapDatabase
{ {
private static SQLiteConnection connection { get; set; } private static SQLiteConnection connection { get; set; }
private BasicStorage storage;
public BeatmapDatabase(BasicStorage storage)
{ public BeatmapDatabase(BasicStorage storage)
if (connection == null) {
{ this.storage = storage;
connection = storage.GetDatabase(@"beatmaps"); if (connection == null)
connection.CreateTable<BeatmapMetadata>(); {
connection.CreateTable<BaseDifficulty>(); connection = storage.GetDatabase(@"beatmaps");
connection.CreateTable<BeatmapSet>(); connection.CreateTable<BeatmapMetadata>();
connection.CreateTable<Beatmap>(); connection.CreateTable<BaseDifficulty>();
} connection.CreateTable<BeatmapSet>();
connection.CreateTable<Beatmap>();
}
} }
public void AddBeatmap(ArchiveReader input) public void AddBeatmap(string path)
{ {
var metadata = input.ReadMetadata(); string hash = null;
if (connection.Table<BeatmapSet>().Count(b => b.BeatmapSetID == metadata.BeatmapSetID) != 0) ArchiveReader reader;
return; if (File.Exists(path)) // Not always the case, i.e. for LegacyFilesystemReader
string[] mapNames = input.ReadBeatmaps(); {
var beatmapSet = new BeatmapSet { BeatmapSetID = metadata.BeatmapSetID }; using (var md5 = MD5.Create())
var maps = new List<Beatmap>(); using (var input = storage.GetStream(path))
foreach (var name in mapNames)
{
using (var stream = new StreamReader(input.ReadFile(name)))
{ {
var decoder = BeatmapDecoder.GetDecoder(stream); hash = BitConverter.ToString(md5.ComputeHash(input)).Replace("-", "").ToLowerInvariant();
var beatmap = decoder.Decode(stream); input.Seek(0, SeekOrigin.Begin);
maps.Add(beatmap); var outputPath = Path.Combine(@"beatmaps", hash.Remove(1), hash.Remove(2), hash);
beatmap.BaseDifficultyID = connection.Insert(beatmap.BaseDifficulty); using (var output = storage.GetStream(outputPath, FileAccess.Write))
} input.CopyTo(output);
} reader = ArchiveReader.GetReader(storage, path = outputPath);
beatmapSet.BeatmapMetadataID = connection.Insert(metadata); }
connection.Insert(beatmapSet); }
connection.InsertAll(maps); else
} reader = ArchiveReader.GetReader(storage, path);
} var metadata = reader.ReadMetadata();
if (connection.Table<BeatmapSet>().Count(b => b.BeatmapSetID == metadata.BeatmapSetID) != 0)
return; // TODO: Update this beatmap instead
string[] mapNames = reader.ReadBeatmaps();
var beatmapSet = new BeatmapSet
{
BeatmapSetID = metadata.BeatmapSetID,
Path = path,
Hash = hash,
};
var maps = new List<Beatmap>();
foreach (var name in mapNames)
{
using (var stream = new StreamReader(reader.ReadFile(name)))
{
var decoder = BeatmapDecoder.GetDecoder(stream);
Beatmap beatmap = new Beatmap();
decoder.Decode(stream, beatmap);
maps.Add(beatmap);
beatmap.BaseDifficultyID = connection.Insert(beatmap.BaseDifficulty);
}
}
beatmapSet.BeatmapMetadataID = connection.Insert(metadata);
connection.Insert(beatmapSet);
connection.InsertAll(maps);
}
public ArchiveReader GetReader(BeatmapSet beatmapSet)
{
return ArchiveReader.GetReader(storage, beatmapSet.Path);
}
/// <summary>
/// Given a BeatmapSet pulled from the database, loads the rest of its data from disk.
/// </summary> public void PopulateBeatmap(BeatmapSet beatmapSet)
{
using (var reader = GetReader(beatmapSet))
{
string[] mapNames = reader.ReadBeatmaps();
foreach (var name in mapNames)
{
using (var stream = new StreamReader(reader.ReadFile(name)))
{
var decoder = BeatmapDecoder.GetDecoder(stream);
Beatmap beatmap = new Beatmap();
decoder.Decode(stream, beatmap);
beatmapSet.Beatmaps.Add(beatmap);
}
}
}
}
}
} }

5
osu.Game/GameModes/Menu/MainMenu.cs
View File

@ -14,6 +14,7 @@ using osu.Game.GameModes.Play;
using osu.Game.Graphics.Containers; using osu.Game.Graphics.Containers;
using OpenTK; using OpenTK;
using osu.Framework; using osu.Framework;
using osu.Game.Overlays;
namespace osu.Game.GameModes.Menu namespace osu.Game.GameModes.Menu
{ {
@ -47,9 +48,7 @@ namespace osu.Game.GameModes.Menu
OnMulti = delegate { Push(new Lobby()); }, OnMulti = delegate { Push(new Lobby()); },
OnTest = delegate { Push(new TestBrowser()); }, OnTest = delegate { Push(new TestBrowser()); },
OnExit = delegate { Scheduler.AddDelayed(Exit, ButtonSystem.EXIT_DELAY); }, OnExit = delegate { Scheduler.AddDelayed(Exit, ButtonSystem.EXIT_DELAY); },
OnSettings = delegate { OnSettings = osu.Options.ToggleVisibility,
osu.Options.PoppedOut = !osu.Options.PoppedOut;
},
} }
} }
} }

32
osu.Game/OsuGame.cs
View File

@ -31,7 +31,7 @@ namespace osu.Game
{ {
public string Path; public string Path;
} }
public Toolbar Toolbar; public Toolbar Toolbar;
public ChatConsole Chat; public ChatConsole Chat;
public MainMenu MainMenu => intro?.ChildGameMode as MainMenu; public MainMenu MainMenu => intro?.ChildGameMode as MainMenu;
@ -40,7 +40,7 @@ namespace osu.Game
private IpcChannel<ImportBeatmap> BeatmapIPC; private IpcChannel<ImportBeatmap> BeatmapIPC;
public Bindable<PlayMode> PlayMode; public Bindable<PlayMode> PlayMode;
public OsuGame(string[] args) public OsuGame(string[] args)
{ {
this.args = args; this.args = args;
@ -56,7 +56,7 @@ namespace osu.Game
public override void Load(BaseGame game) public override void Load(BaseGame game)
{ {
BeatmapIPC = new IpcChannel<ImportBeatmap>(Host); BeatmapIPC = new IpcChannel<ImportBeatmap>(Host);
if (!Host.IsPrimaryInstance) if (!Host.IsPrimaryInstance)
{ {
if (args.Length == 1 && File.Exists(args[0])) if (args.Length == 1 && File.Exists(args[0]))
@ -73,8 +73,7 @@ namespace osu.Game
{ {
try try
{ {
var reader = ArchiveReader.GetReader(Host.Storage, message.Path); Beatmaps.AddBeatmap(message.Path);
Beatmaps.AddBeatmap(reader);
// TODO: Switch to beatmap list and select the new song // TODO: Switch to beatmap list and select the new song
} }
catch (Exception ex) catch (Exception ex)
@ -83,7 +82,7 @@ namespace osu.Game
Console.WriteLine($@"Failed to import beatmap: {ex}"); Console.WriteLine($@"Failed to import beatmap: {ex}");
} }
}; };
base.Load(game); base.Load(game);
//attach our bindables to the audio subsystem. //attach our bindables to the audio subsystem.
@ -96,9 +95,8 @@ namespace osu.Game
Toolbar = new Toolbar Toolbar = new Toolbar
{ {
OnHome = delegate { MainMenu?.MakeCurrent(); }, OnHome = delegate { MainMenu?.MakeCurrent(); },
OnSettings = delegate { Options.PoppedOut = !Options.PoppedOut; }, OnSettings = Options.ToggleVisibility,
OnPlayModeChange = delegate (PlayMode m) { PlayMode.Value = m; }, OnPlayModeChange = delegate (PlayMode m) { PlayMode.Value = m; },
Alpha = 0.001f,
}, },
Chat = new ChatConsole(API), Chat = new ChatConsole(API),
new VolumeControl new VolumeControl
@ -113,12 +111,6 @@ namespace osu.Game
} }
}); });
Toolbar.State = ToolbarState.Hidden;
Toolbar.Flush();
Chat.State = ChatConsoleState.Hidden;
Chat.Flush();
intro.ModePushed += modeAdded; intro.ModePushed += modeAdded;
intro.Exited += modeRemoved; intro.Exited += modeRemoved;
@ -134,10 +126,10 @@ namespace osu.Game
switch (args.Key) switch (args.Key)
{ {
case Key.F8: case Key.F8:
Chat.State = Chat.State == ChatConsoleState.Hidden ? ChatConsoleState.Visible : ChatConsoleState.Hidden; Chat.ToggleVisibility();
return true; return true;
} }
return base.OnKeyDown(state, args); return base.OnKeyDown(state, args);
} }
@ -152,12 +144,12 @@ namespace osu.Game
//central game mode change logic. //central game mode change logic.
if (newMode is Player || newMode is Intro) if (newMode is Player || newMode is Intro)
{ {
Toolbar.State = ToolbarState.Hidden; Toolbar.State = Visibility.Hidden;
Chat.State = ChatConsoleState.Hidden; Chat.State = Visibility.Hidden;
} }
else else
{ {
Toolbar.State = ToolbarState.Visible; Toolbar.State = Visibility.Visible;
} }
Cursor.FadeIn(100); Cursor.FadeIn(100);
@ -178,7 +170,7 @@ namespace osu.Game
}); });
return true; return true;
} }
return base.OnExiting(); return base.OnExiting();
} }

53
osu.Game/Overlays/ChatConsole.cs
View File

@ -1,12 +1,12 @@
//Copyright (c) 2007-2016 ppy Pty Ltd <contact@ppy.sh>. //Copyright (c) 2007-2016 ppy Pty Ltd <contact@ppy.sh>.
//Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE //Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Diagnostics; using System.Diagnostics;
using System.Linq; using System.Linq;
using System.Text; using OpenTK;
using System.Threading.Tasks; using OpenTK.Graphics;
using osu.Framework;
using osu.Framework.Graphics; using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers; using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Drawables; using osu.Framework.Graphics.Drawables;
@ -17,15 +17,10 @@ using osu.Game.Online.API;
using osu.Game.Online.API.Requests; using osu.Game.Online.API.Requests;
using osu.Game.Online.Chat; using osu.Game.Online.Chat;
using osu.Game.Online.Chat.Display; using osu.Game.Online.Chat.Display;
using OpenTK;
using OpenTK.Graphics;
using osu.Framework.Input;
using OpenTK.Input;
using osu.Framework;
namespace osu.Game.Overlays namespace osu.Game.Overlays
{ {
public class ChatConsole : Container, IStateful<ChatConsoleState> public class ChatConsole : Overlay
{ {
private ChannelDisplay channelDisplay; private ChannelDisplay channelDisplay;
@ -69,7 +64,7 @@ namespace osu.Game.Overlays
private long? lastMessageId; private long? lastMessageId;
List<Channel> careChannels; private List<Channel> careChannels;
private void initializeChannels() private void initializeChannels()
{ {
@ -112,7 +107,7 @@ namespace osu.Game.Overlays
careChannels.Add(channel); careChannels.Add(channel);
} }
GetMessagesRequest fetchReq; private GetMessagesRequest fetchReq;
public void FetchNewMessages(APIAccess api) public void FetchNewMessages(APIAccess api)
{ {
@ -140,36 +135,18 @@ namespace osu.Game.Overlays
api.Queue(fetchReq); api.Queue(fetchReq);
} }
private ChatConsoleState state; private const int transition_length = 500;
public ChatConsoleState State protected override void PopIn()
{ {
get { return state; } MoveToY(0, transition_length, EasingTypes.OutQuint);
FadeIn(transition_length, EasingTypes.OutQuint);
}
set protected override void PopOut()
{ {
state = value; MoveToY(-Size.Y, transition_length, EasingTypes.InQuint);
FadeOut(transition_length, EasingTypes.InQuint);
const int transition_length = 500;
switch (state)
{
case ChatConsoleState.Hidden:
MoveToY(-Size.Y, transition_length, EasingTypes.InQuint);
FadeOut(transition_length, EasingTypes.InQuint);
break;
case ChatConsoleState.Visible:
MoveToY(0, transition_length, EasingTypes.OutQuint);
FadeIn(transition_length, EasingTypes.OutQuint);
break;
}
}
} }
} }
public enum ChatConsoleState
{
Visible,
Hidden,
}
} }

43
osu.Game/Overlays/Options.cs
View File

@ -1,21 +1,20 @@
//Copyright (c) 2007-2016 ppy Pty Ltd <contact@ppy.sh>. //Copyright (c) 2007-2016 ppy Pty Ltd <contact@ppy.sh>.
//Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE //Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Drawables;
using osu.Framework.Graphics.Transformations;
using OpenTK; using OpenTK;
using OpenTK.Graphics; using OpenTK.Graphics;
using osu.Framework.Input;
using OpenTK.Input; using OpenTK.Input;
using osu.Framework; using osu.Framework;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Drawables;
using osu.Framework.Graphics.Transformations;
using osu.Framework.Input;
namespace osu.Game.Overlays namespace osu.Game.Overlays
{ {
public class Options : Container public class Options : Overlay
{ {
const float width = 300; private const float width = 300;
public override void Load(BaseGame game) public override void Load(BaseGame game)
{ {
@ -41,36 +40,22 @@ namespace osu.Game.Overlays
switch (args.Key) switch (args.Key)
{ {
case Key.Escape: case Key.Escape:
if (!poppedOut) return false; if (State == Visibility.Hidden) return false;
PoppedOut = false; State = Visibility.Hidden;
return true; return true;
} }
return base.OnKeyDown(state, args); return base.OnKeyDown(state, args);
} }
private bool poppedOut; protected override void PopIn()
public bool PoppedOut
{ {
get { return poppedOut; } MoveToX(0, 300, EasingTypes.Out);
}
set protected override void PopOut()
{ {
if (value == poppedOut) return; MoveToX(-width, 300, EasingTypes.Out);
poppedOut = value;
if (poppedOut)
{
MoveTo(new Vector2(0, 0), 300, EasingTypes.Out);
}
else
{
MoveTo(new Vector2(-width, 0), 300, EasingTypes.Out);
}
}
} }
} }
} }

53
osu.Game/Overlays/Overlay.cs Normal file
View File

@ -0,0 +1,53 @@
using osu.Framework;
using osu.Framework.Graphics.Containers;
namespace osu.Game.Overlays
{
/// <summary>
/// An element which starts hidden and can be toggled to visible.
/// </summary>
public abstract class Overlay : Container, IStateful<Visibility>
{
public override void Load(BaseGame game)
{
base.Load(game);
//TODO: init code using Alpha or IsVisible override to ensure we don't call Load on children before we first get unhidden.
PopOut();
Flush();
}
private Visibility state;
public Visibility State
{
get { return state; }
set
{
if (value == state) return;
state = value;
switch (value)
{
case Visibility.Hidden:
PopOut();
break;
case Visibility.Visible:
PopIn();
break;
}
}
}
protected abstract void PopIn();
protected abstract void PopOut();
public void ToggleVisibility() => State = (State == Visibility.Visible ? Visibility.Hidden : Visibility.Visible);
}
public enum Visibility
{
Hidden,
Visible
}
}

52
osu.Game/Overlays/Toolbar.cs
View File

@ -1,24 +1,23 @@
//Copyright (c) 2007-2016 ppy Pty Ltd <contact@ppy.sh>. //Copyright (c) 2007-2016 ppy Pty Ltd <contact@ppy.sh>.
//Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE //Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
using System;
using OpenTK;
using OpenTK.Graphics;
using osu.Framework;
using osu.Framework.Graphics; using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers; using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Drawables; using osu.Framework.Graphics.Drawables;
using OpenTK;
using OpenTK.Graphics;
using osu.Game.Graphics;
using osu.Game.Configuration;
using System;
using osu.Framework.Graphics.Transformations; using osu.Framework.Graphics.Transformations;
using osu.Framework.Timing; using osu.Game.Configuration;
using osu.Game.GameModes.Play; using osu.Game.GameModes.Play;
using osu.Framework; using osu.Game.Graphics;
namespace osu.Game.Overlays namespace osu.Game.Overlays
{ {
public class Toolbar : Container, IStateful<ToolbarState> public class Toolbar : Overlay
{ {
const float height = 50; private const float height = 50;
public Action OnSettings; public Action OnSettings;
public Action OnHome; public Action OnHome;
@ -26,29 +25,18 @@ namespace osu.Game.Overlays
private ToolbarModeSelector modeSelector; private ToolbarModeSelector modeSelector;
private ToolbarState state; private const int transition_time = 200;
public ToolbarState State protected override void PopIn()
{ {
get { return state; } MoveToY(0, transition_time, EasingTypes.OutQuint);
set FadeIn(transition_time, EasingTypes.OutQuint);
{ }
state = value;
const int transition_time = 200; protected override void PopOut()
{
switch (state) MoveToY(-Size.Y, transition_time, EasingTypes.InQuint);
{ FadeOut(transition_time, EasingTypes.InQuint);
case ToolbarState.Hidden:
MoveToY(-Size.Y, transition_time, EasingTypes.InQuint);
FadeOut(transition_time, EasingTypes.InQuint);
break;
case ToolbarState.Visible:
MoveToY(0, transition_time, EasingTypes.OutQuint);
FadeIn(transition_time, EasingTypes.OutQuint);
break;
}
}
} }
public override void Load(BaseGame game) public override void Load(BaseGame game)
@ -119,10 +107,4 @@ namespace osu.Game.Overlays
public void SetGameMode(PlayMode mode) => modeSelector.SetGameMode(mode); public void SetGameMode(PlayMode mode) => modeSelector.SetGameMode(mode);
} }
public enum ToolbarState
{
Visible,
Hidden,
}
} }

1
osu.Game/osu.Game.csproj
View File

@ -164,6 +164,7 @@
<Compile Include="OsuGameBase.cs" /> <Compile Include="OsuGameBase.cs" />
<Compile Include="Overlays\ChatConsole.cs" /> <Compile Include="Overlays\ChatConsole.cs" />
<Compile Include="Overlays\Options.cs" /> <Compile Include="Overlays\Options.cs" />
<Compile Include="Overlays\Overlay.cs" />
<Compile Include="Overlays\Toolbar.cs" /> <Compile Include="Overlays\Toolbar.cs" />
<Compile Include="Overlays\ToolbarButton.cs" /> <Compile Include="Overlays\ToolbarButton.cs" />
<Compile Include="Overlays\ToolbarModeButton.cs" /> <Compile Include="Overlays\ToolbarModeButton.cs" />