h1or4dme8/osu-lazer
1
0
Fork 0
mirror of https://github.com/ppy/osu.git synced 2025-01-13 12:53:11 +08:00
Code Issues Releases Wiki Activity

Converted all .cs files to use CRLF line endings.

Browse Source
This commit is contained in:
John Leuenhagen 2016-10-13 23:33:58 -04:00
parent b425d14ea1
commit fedfb8a22a
No known key found for this signature in database
GPG Key ID: 907086AC94B52427
10 changed files with 454 additions and 454 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,39 +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 = new Beatmap(); firstMap = new Beatmap();
decoder.Decode(stream, firstMap); decoder.Decode(stream, firstMap);
} }
} }
public override string[] ReadBeatmaps() public override string[] ReadBeatmaps()
@ -49,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
} } } }
} }

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

@ -1,6 +1,6 @@
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;
@ -10,141 +10,141 @@ 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"))
{ {
Beatmap beatmap = new Beatmap(); Beatmap beatmap = new Beatmap();
decoder.Decode(new StreamReader(stream), beatmap); decoder.Decode(new StreamReader(stream), beatmap);
var meta = beatmap.Metadata; var meta = beatmap.Metadata;
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("Gamu", meta.Author); Assert.AreEqual("Gamu", 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 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"))
{ {
Beatmap beatmap = new Beatmap(); Beatmap beatmap = new Beatmap();
decoder.Decode(new StreamReader(stream), beatmap); decoder.Decode(new StreamReader(stream), beatmap);
Assert.AreEqual(0, beatmap.AudioLeadIn); Assert.AreEqual(0, beatmap.AudioLeadIn);
Assert.AreEqual(false, beatmap.Countdown); Assert.AreEqual(false, beatmap.Countdown);
Assert.AreEqual(SampleSet.Soft, beatmap.SampleSet); Assert.AreEqual(SampleSet.Soft, beatmap.SampleSet);
Assert.AreEqual(0.7f, beatmap.StackLeniency); Assert.AreEqual(0.7f, beatmap.StackLeniency);
Assert.AreEqual(false, beatmap.SpecialStyle); Assert.AreEqual(false, beatmap.SpecialStyle);
Assert.AreEqual(PlayMode.Osu, beatmap.Mode); Assert.AreEqual(PlayMode.Osu, beatmap.Mode);
Assert.AreEqual(false, beatmap.LetterboxInBreaks); Assert.AreEqual(false, beatmap.LetterboxInBreaks);
Assert.AreEqual(false, beatmap.WidescreenStoryboard); 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"))
{ {
Beatmap beatmap = new Beatmap(); Beatmap beatmap = new Beatmap();
decoder.Decode(new StreamReader(stream), beatmap); decoder.Decode(new StreamReader(stream), beatmap);
int[] expectedBookmarks = int[] expectedBookmarks =
{ {
11505, 22054, 32604, 43153, 53703, 64252, 74802, 85351, 11505, 22054, 32604, 43153, 53703, 64252, 74802, 85351,
95901, 106450, 116999, 119637, 130186, 140735, 151285, 95901, 106450, 116999, 119637, 130186, 140735, 151285,
161834, 164471, 175020, 185570, 196119, 206669, 209306 161834, 164471, 175020, 185570, 196119, 206669, 209306
}; };
Assert.AreEqual(expectedBookmarks.Length, beatmap.Bookmarks.Length); Assert.AreEqual(expectedBookmarks.Length, beatmap.Bookmarks.Length);
for (int i = 0; i < expectedBookmarks.Length; i++) for (int i = 0; i < expectedBookmarks.Length; i++)
Assert.AreEqual(expectedBookmarks[i], beatmap.Bookmarks[i]); Assert.AreEqual(expectedBookmarks[i], beatmap.Bookmarks[i]);
Assert.AreEqual(1.8, beatmap.DistanceSpacing); Assert.AreEqual(1.8, beatmap.DistanceSpacing);
Assert.AreEqual(4, beatmap.BeatDivisor); Assert.AreEqual(4, beatmap.BeatDivisor);
Assert.AreEqual(4, beatmap.GridSize); Assert.AreEqual(4, beatmap.GridSize);
Assert.AreEqual(2, beatmap.TimelineZoom); 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"))
{ {
Beatmap beatmap = new Beatmap(); Beatmap beatmap = new Beatmap();
decoder.Decode(new StreamReader(stream), beatmap); decoder.Decode(new StreamReader(stream), beatmap);
var difficulty = beatmap.BaseDifficulty; var difficulty = beatmap.BaseDifficulty;
Assert.AreEqual(6.5f, difficulty.DrainRate); Assert.AreEqual(6.5f, difficulty.DrainRate);
Assert.AreEqual(4, difficulty.CircleSize); Assert.AreEqual(4, difficulty.CircleSize);
Assert.AreEqual(8, difficulty.OverallDifficulty); Assert.AreEqual(8, difficulty.OverallDifficulty);
Assert.AreEqual(9, difficulty.ApproachRate); Assert.AreEqual(9, difficulty.ApproachRate);
Assert.AreEqual(1.8f, difficulty.SliderMultiplier); Assert.AreEqual(1.8f, difficulty.SliderMultiplier);
Assert.AreEqual(2, difficulty.SliderTickRate); 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"))
{ {
Beatmap beatmap = new Beatmap(); Beatmap beatmap = new Beatmap();
decoder.Decode(new StreamReader(stream), 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"))
{ {
Beatmap beatmap = new Beatmap(); Beatmap beatmap = new Beatmap();
decoder.Decode(new StreamReader(stream), beatmap); decoder.Decode(new StreamReader(stream), beatmap);
var slider = beatmap.HitObjects[0] as Slider; var slider = beatmap.HitObjects[0] as Slider;
Assert.IsNotNull(slider); Assert.IsNotNull(slider);
Assert.AreEqual(new Vector2(192, 168), slider.Position); Assert.AreEqual(new Vector2(192, 168), slider.Position);
Assert.AreEqual(956, slider.StartTime); Assert.AreEqual(956, slider.StartTime);
Assert.AreEqual(SampleType.None, slider.Sample.Type); Assert.AreEqual(SampleType.None, slider.Sample.Type);
var circle = beatmap.HitObjects[1] as Circle; var circle = beatmap.HitObjects[1] as Circle;
Assert.IsNotNull(circle); Assert.IsNotNull(circle);
Assert.AreEqual(new Vector2(304, 56), circle.Position); Assert.AreEqual(new Vector2(304, 56), circle.Position);
Assert.AreEqual(1285, circle.StartTime); 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; }
} }
} }

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 void Decode(TextReader stream, Beatmap beatmap); public abstract void Decode(TextReader stream, Beatmap 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();
} }
} }

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

@ -1,41 +1,41 @@
using System; using System;
using System.IO; using System.IO;
using System.Linq; using System.Linq;
using System.Security.Cryptography; 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 = new Beatmap(); firstMap = new Beatmap();
decoder.Decode(stream, firstMap); decoder.Decode(stream, firstMap);
} }
} }
public override string[] ReadBeatmaps() public override string[] ReadBeatmaps()
@ -45,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();
} }
@ -55,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();
} }
} }
} }

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

@ -1,4 +1,4 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.IO; using System.IO;
using System.Security.Cryptography; using System.Security.Cryptography;
@ -8,82 +8,82 @@ 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; private BasicStorage storage;
public BeatmapDatabase(BasicStorage storage) public BeatmapDatabase(BasicStorage storage)
{ {
this.storage = storage; this.storage = storage;
if (connection == null) if (connection == null)
{
connection = storage.GetDatabase(@"beatmaps");
connection.CreateTable<BeatmapMetadata>();
connection.CreateTable<BaseDifficulty>();
connection.CreateTable<BeatmapSet>();
connection.CreateTable<Beatmap>();
}
}
public void AddBeatmap(string path)
{
string hash = null;
ArchiveReader reader;
if (File.Exists(path)) // Not always the case, i.e. for LegacyFilesystemReader
{
using (var md5 = MD5.Create())
using (var input = storage.GetStream(path))
{
hash = BitConverter.ToString(md5.ComputeHash(input)).Replace("-", "").ToLowerInvariant();
input.Seek(0, SeekOrigin.Begin);
var outputPath = Path.Combine(@"beatmaps", hash.Remove(1), hash.Remove(2), hash);
using (var output = storage.GetStream(outputPath, FileAccess.Write))
input.CopyTo(output);
reader = ArchiveReader.GetReader(storage, path = outputPath);
}
}
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(); connection = storage.GetDatabase(@"beatmaps");
connection.CreateTable<BeatmapMetadata>();
connection.CreateTable<BaseDifficulty>();
connection.CreateTable<BeatmapSet>();
connection.CreateTable<Beatmap>();
}
}
public void AddBeatmap(string path)
{
string hash = null;
ArchiveReader reader;
if (File.Exists(path)) // Not always the case, i.e. for LegacyFilesystemReader
{
using (var md5 = MD5.Create())
using (var input = storage.GetStream(path))
{
hash = BitConverter.ToString(md5.ComputeHash(input)).Replace("-", "").ToLowerInvariant();
input.Seek(0, SeekOrigin.Begin);
var outputPath = Path.Combine(@"beatmaps", hash.Remove(1), hash.Remove(2), hash);
using (var output = storage.GetStream(outputPath, FileAccess.Write))
input.CopyTo(output);
reader = ArchiveReader.GetReader(storage, path = outputPath);
}
}
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) foreach (var name in mapNames)
{ {
using (var stream = new StreamReader(reader.ReadFile(name))) using (var stream = new StreamReader(reader.ReadFile(name)))
@ -92,9 +92,9 @@ namespace osu.Game.Database
Beatmap beatmap = new Beatmap(); Beatmap beatmap = new Beatmap();
decoder.Decode(stream, beatmap); decoder.Decode(stream, beatmap);
beatmapSet.Beatmaps.Add(beatmap); beatmapSet.Beatmaps.Add(beatmap);
} }
} }
} }
} }
} }
} }