Replay loading via drag-drop huzzah!

osu.Game/Database/BeatmapDatabase.cs

@@ -7,6 +7,7 @@ using System.IO;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Security.Cryptography;
+using osu.Framework.Extensions;
 using osu.Framework.Logging;
 using osu.Framework.Platform;
 using osu.Game.Beatmaps;
@@ -162,7 +163,7 @@ namespace osu.Game.Database
         /// <param name="path">Location on disk</param>
         public void Import(string path)
         {
-            Import(new [] { path });
+            Import(new[] { path });
         }
 
         /// <summary>
@@ -181,10 +182,9 @@ namespace osu.Game.Database
 
             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();
+                    hash = input.GetMd5Hash();
                     input.Seek(0, SeekOrigin.Begin);
                     path = Path.Combine(@"beatmaps", hash.Remove(1), hash.Remove(2), hash);
                     if (!storage.Exists(path))
@@ -216,22 +216,29 @@ namespace osu.Game.Database
                 Metadata = metadata
             };
 
-            using (var reader = ArchiveReader.GetReader(storage, path))
+            using (var archive = ArchiveReader.GetReader(storage, path))
             {
-                string[] mapNames = reader.BeatmapFilenames;
+                string[] mapNames = archive.BeatmapFilenames;
                 foreach (var name in mapNames)
-                    using (var stream = new StreamReader(reader.GetStream(name)))
+                    using (var raw = archive.GetStream(name))
+                    using (var ms = new MemoryStream()) //we need a memory stream so we can seek and shit
+                    using (var sr = new StreamReader(ms))
                     {
-                        var decoder = BeatmapDecoder.GetDecoder(stream);
-                        Beatmap beatmap = decoder.Decode(stream);
+                        raw.CopyTo(ms);
+                        ms.Position = 0;
+
+                        var decoder = BeatmapDecoder.GetDecoder(sr);
+                        Beatmap beatmap = decoder.Decode(sr);
+
                         beatmap.BeatmapInfo.Path = name;
+                        beatmap.BeatmapInfo.Hash = ms.GetMd5Hash();
 
                         // TODO: Diff beatmap metadata with set metadata and leave it here if necessary
                         beatmap.BeatmapInfo.Metadata = null;
 
                         beatmapSet.Beatmaps.Add(beatmap.BeatmapInfo);
                     }
-                beatmapSet.StoryboardFile = reader.StoryboardFilename;
+                beatmapSet.StoryboardFile = archive.StoryboardFilename;
             }
 
             return beatmapSet;

osu.Game/Database/BeatmapInfo.cs

@@ -39,6 +39,8 @@ namespace osu.Game.Database
 
         public string Path { get; set; }
 
+        public string Hash { get; set; }
+
         // General
         public int AudioLeadIn { get; set; }
         public bool Countdown { get; set; }
@@ -64,6 +66,7 @@ namespace osu.Game.Database
                 StoredBookmarks = string.Join(",", value);
             }
         }
+
         public double DistanceSpacing { get; set; }
         public int BeatDivisor { get; set; }
         public int GridSize { get; set; }

osu.Game/Database/ScoreDatabase.cs

@@ -0,0 +1,110 @@
+// 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 System.IO;
+using osu.Framework.Platform;
+using osu.Game.IO.Legacy;
+using osu.Game.IPC;
+using osu.Game.Modes;
+using SharpCompress.Compressors.LZMA;
+
+namespace osu.Game.Database
+{
+    public class ScoreDatabase
+    {
+        private readonly Storage storage;
+        private readonly BeatmapDatabase beatmaps;
+
+        private const string replay_folder = @"replays";
+
+        private ScoreIPCChannel ipc;
+
+        public ScoreDatabase(Storage storage, IIpcHost importHost = null, BeatmapDatabase beatmaps = null)
+        {
+            this.storage = storage;
+            this.beatmaps = beatmaps;
+
+            if (importHost != null)
+                ipc = new ScoreIPCChannel(importHost, this);
+        }
+
+        public Score ReadReplayFile(string replayFilename)
+        {
+            Score score;
+
+            using (Stream s = storage.GetStream(Path.Combine(replay_folder, replayFilename)))
+            using (SerializationReader sr = new SerializationReader(s))
+            {
+                var ruleset = Ruleset.GetRuleset((PlayMode)sr.ReadByte());
+                var processor = ruleset.CreateScoreProcessor();
+
+                score = processor.GetScore();
+
+                /* score.Pass = true;*/
+                var version = sr.ReadInt32();
+                /* score.FileChecksum = */
+                var beatmapHash = sr.ReadString();
+                score.Beatmap = beatmaps.Query<BeatmapInfo>().Where(b => b.Hash == beatmapHash).FirstOrDefault();
+                /* score.PlayerName = */
+                sr.ReadString();
+                /* var localScoreChecksum = */
+                sr.ReadString();
+                /* score.Count300 = */
+                sr.ReadUInt16();
+                /* score.Count100 = */
+                sr.ReadUInt16();
+                /* score.Count50 = */
+                sr.ReadUInt16();
+                /* score.CountGeki = */
+                sr.ReadUInt16();
+                /* score.CountKatu = */
+                sr.ReadUInt16();
+                /* score.CountMiss = */
+                sr.ReadUInt16();
+                score.TotalScore = sr.ReadInt32();
+                score.MaxCombo = sr.ReadUInt16();
+                /* score.Perfect = */
+                sr.ReadBoolean();
+                /* score.EnabledMods = (Mods)*/
+                sr.ReadInt32();
+                /* score.HpGraphString = */
+                sr.ReadString();
+                /* score.Date = */
+                sr.ReadDateTime();
+
+                var compressedReplay = sr.ReadByteArray();
+
+                if (version >= 20140721)
+                    /*OnlineId =*/
+                    sr.ReadInt64();
+                else if (version >= 20121008)
+                    /*OnlineId =*/
+                    sr.ReadInt32();
+
+                using (var replayInStream = new MemoryStream(compressedReplay))
+                {
+                    byte[] properties = new byte[5];
+                    if (replayInStream.Read(properties, 0, 5) != 5)
+                        throw (new Exception("input .lzma is too short"));
+                    long outSize = 0;
+                    for (int i = 0; i < 8; i++)
+                    {
+                        int v = replayInStream.ReadByte();
+                        if (v < 0)
+                            throw (new Exception("Can't Read 1"));
+                        outSize |= ((long)(byte)v) << (8 * i);
+                    }
+
+                    long compressedSize = replayInStream.Length - replayInStream.Position;
+
+                    using (var lzma = new LzmaStream(properties, replayInStream, compressedSize, outSize))
+                    using (var reader = new StreamReader(lzma))
+                        score.Replay = new LegacyReplay(reader);
+                }
+            }
+            
+            return score;
+        }
+    }
+}