Separate files by module, class, interface, and enum

Assets/NewFolder1.meta → Assets/CustomStructure.meta

 fileFormatVersion: 2
-guid: 8e735ca2f8a25aa49a7719128cd95047
+guid: 563107224bc30a84ca8f844d28d618a8
 folderAsset: yes
-timeCreated: 1517593123
+timeCreated: 1517759154
 licenseType: Free
 DefaultImporter:
   externalObjects: {}

Assets/CustomStructure/MultiDictionary.cs

+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace CustomStructure
+{
+    public class MultiDictionary<TKey, TValue> : IEnumerable<KeyValuePair<TKey, List<TValue>>>
+    {
+        private Dictionary<TKey, List<TValue>> dictionary = new Dictionary<TKey, List<TValue>>();
+
+        public List<TValue> this[TKey key]
+        {
+            get
+            {
+                List<TValue> list;
+                if (!dictionary.TryGetValue(key, out list))
+                {
+                    list = new List<TValue>();
+                    dictionary[key] = list;
+                }
+
+                return list;
+            }
+            set
+            {
+                List<TValue> list;
+                if (!dictionary.TryGetValue(key, out list))
+                    dictionary[key] = value;
+                else
+                    dictionary[key] = list.Concat(value).ToList();
+            }
+        }
+
+        public
+            bool
+            TryGetValue(
+                TKey key,
+                out List<TValue> value)
+        {
+            return dictionary.TryGetValue(key, out value);
+        }
+
+        public
+            IEnumerator<KeyValuePair<TKey, List<TValue>>>
+            GetEnumerator()
+        {
+            return dictionary.GetEnumerator();
+        }
+
+        IEnumerator
+        IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public
+            bool
+            Remove(
+                TKey key)
+        {
+            return dictionary.Remove(key);
+        }
+    }
+
+}
\ No newline at end of file

Assets/CustomStructure/MultiDictionary.cs.meta

+fileFormatVersion: 2
+guid: 2b424a4f9faa07747b547cc35ba10cec
+timeCreated: 1517759154
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Script/KinectModule.meta → Assets/KinectModule.meta

 fileFormatVersion: 2
-guid: d5629aaa548340d48a6877356736e5a6
+guid: eaf70e8d777b12b498a6b906f4d62aac
 folderAsset: yes
-timeCreated: 1517593124
+timeCreated: 1517759154
 licenseType: Free
 DefaultImporter:
   externalObjects: {}

Assets/MotionAnalysis.meta

+fileFormatVersion: 2
+guid: e1ee830ff5364b84fb8a01beee96b7ea
+folderAsset: yes
+timeCreated: 1517759154
+licenseType: Free
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MotionAnalysis/DistItvExtractor.cs.meta

+fileFormatVersion: 2
+guid: bf6d9bb3b03fd3348b285d71f07ef6fa
+timeCreated: 1517759155
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MotionAnalysis/MotionDiscriminator.cs.meta

+fileFormatVersion: 2
+guid: 052f8d7cf1dc4a64ab0cecf8fcc2eb80
+timeCreated: 1517759154
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MotionAnalysis/MotionState.cs.meta

+fileFormatVersion: 2
+guid: 5c40b7216106456498a7216bdde9038f
+timeCreated: 1517759154
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Script/GameManager.cs

-using System.Collections;
-using System.Collections.Generic;
+using System.Collections.Generic;
+using TrackAnalysis;
 using UnityEngine;
 using UnityEngine.SceneManagement;
 

Assets/Script/JudgeManager.cs

-using System;
-using System.Collections;
+using StatusConvert;
 using System.Collections.Generic;
 using System.Linq;
 using UnityEngine;

Assets/Script/TrackInfoHolder.cs

-using System.Collections;
-using System.Collections.Generic;
+using TrackAnalysis;
 using UnityEngine;
 using UnityEngine.UI;
 
-public class TrackInfoHolder : MonoBehaviour {
+public class TrackInfoHolder : MonoBehaviour
+{
     public TrackInfo trackInfo;
 
 	// Use this for initialization
-	void Start () {
+	void Start ()
+    {
         gameObject.name = trackInfo.Title;
         gameObject.GetComponentInChildren<Text>().text = trackInfo.Title;
 	}
-	
-	// Update is called once per frame
-	void Update () {
-		
-	}
 }

Assets/Script/TrackManager.cs

 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using TrackAnalysis;
 using UnityEngine;
 using UnityEngine.UI;
 
-public class TrackManager : MonoBehaviour {
+public class TrackManager : MonoBehaviour
+{
     [SerializeField]
     GameObject trackList;
 
@@ -21,7 +23,7 @@ public class TrackManager : MonoBehaviour {
     Texture2D[] backgrounds;
     private int textureID = 0;
 
-    Texture buffer;
+    Texture     buffer;
 
     public Text Artist;
     public Text BPM;

Assets/StatusConvert.meta

+fileFormatVersion: 2
+guid: 5298a89c29ad48d41b762fe2d0ab5595
+folderAsset: yes
+timeCreated: 1517759154
+licenseType: Free
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/StatusConvert/ButtonStatusGetter.cs.meta

+fileFormatVersion: 2
+guid: 80c0267e119acbf45a7e4a2f7da153c0
+timeCreated: 1517759155
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/StatusConvert/InputStatus.cs.meta

+fileFormatVersion: 2
+guid: 8765ec0e006bff24ab0e4ef5eddecf0c
+timeCreated: 1517759155
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/StatusConvert/MotionStatus.cs.meta

+fileFormatVersion: 2
+guid: ce6c8969ad7f38844a7b18dc0c90a4a7
+timeCreated: 1517759155
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/StatusConvert/MotionStatusExtractor.cs.meta

+fileFormatVersion: 2
+guid: d2e126a5d9bca1a44850620bcfaeeb68
+timeCreated: 1517759155
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TrackAnalysis.meta

+fileFormatVersion: 2
+guid: a4db35caa52c92c4bb6ef37b078300f7
+folderAsset: yes
+timeCreated: 1517759154
+licenseType: Free
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TrackAnalysis/ButtonNoteMaker.cs

+namespace TrackAnalysis
+{
+    public class ButtonNoteMaker : NoteMakerBase
+    {
+        override protected
+            bool
+            NotValidType(
+                string type)
+        {
+            return type.Substring(1) != "BT";
+        }
+
+        override protected
+            Note
+            MakeShort(
+                string code,
+                string type,
+                float timing)
+        {
+            return new Note(code, type, timing);
+        }
+
+        override protected
+            Note
+            MakeLong(
+                string code,
+                string type,
+                float timing)
+        {
+            float start = Timing.Value;
+            Timing = null;
+
+            return new Note(code, type, start, timing);
+        }
+    }
+}
\ No newline at end of file

Assets/TrackAnalysis/ButtonNoteMaker.cs.meta

+fileFormatVersion: 2
+guid: a621bf6f6f8b0ea49a3dc7dde224ecc2
+timeCreated: 1517759155
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TrackAnalysis/MotionNoteMaker.cs

+using System;
+
+namespace TrackAnalysis
+{
+    public class MotionNoteMaker : NoteMakerBase
+    {
+        override protected
+            bool
+            NotValidType(
+                string type)
+        {
+            Type motionType;
+            return type.Substring(1) != "MO" ||
+                !MotionNote.keymap.TryGetValue(type, out motionType);
+        }
+
+        override protected
+            Note
+            MakeShort(
+                string code,
+                string type,
+                float timing)
+        {
+            return (MotionNote)Activator.CreateInstance
+                (MotionNote.keymap[type], code, timing);
+        }
+
+        override protected
+            Note
+            MakeLong(
+                string code,
+                string type,
+                float timing)
+        {
+            float start = Timing.Value;
+            Timing = null;
+
+            return (MotionNote)Activator.CreateInstance
+                (MotionNote.keymap[type], code, start, timing);
+        }
+    }
+}

Assets/TrackAnalysis/MotionNoteMaker.cs.meta

+fileFormatVersion: 2
+guid: 461870a9e607c4b42bd9bc43c5856ac7
+timeCreated: 1517759154
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TrackAnalysis/NoteMaker.cs

+namespace TrackAnalysis
+{
+    public class NoteMaker
+    {
+        ButtonNoteMaker buttonNoteMaker = new ButtonNoteMaker();
+        MotionNoteMaker motionNoteMaker = new MotionNoteMaker();
+
+        public
+            Note
+            Make(
+                string code,
+                string type,
+                float timing)
+        {
+            return motionNoteMaker.Make(code, type, timing) ??
+                   buttonNoteMaker.Make(code, type, timing);
+        }
+    }
+}
\ No newline at end of file

Assets/TrackAnalysis/NoteMaker.cs.meta

+fileFormatVersion: 2
+guid: f6f9896f46a3b3e4a9beb2a0b68909e3
+timeCreated: 1517759155
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TrackAnalysis/NoteMakerBase.cs

+namespace TrackAnalysis
+{
+    public abstract class NoteMakerBase
+    {
+        protected float? Timing = null;
+
+        public
+            Note
+            Make(
+                string code,
+                string type,
+                float timing)
+        {
+            if (NotValidType(type))
+                return null;
+            if (IsShort(type))
+                return MakeShort(code, type, timing);
+            if (IsLongEnd(type))
+                return MakeLong(code, type, timing);
+
+            RegisterTiming(timing);
+
+            return null;
+        }
+
+        private
+            bool
+            IsShort(
+                string type)
+        {
+            return type[0] == 'S';
+        }
+
+        private
+            bool
+            IsLongEnd(
+                string type)
+        {
+            return type[0] == 'L' && Timing != null;
+        }
+
+        private
+            void
+            RegisterTiming(
+                float timing)
+        {
+            Timing = timing;
+        }
+
+        abstract protected
+            bool
+            NotValidType(
+                string type);
+        abstract protected
+            Note
+            MakeShort(
+                string code,
+                string type,
+                float timing);
+        abstract protected
+            Note
+            MakeLong(
+                string code,
+                string type,
+                float timing);
+    }
+}
\ No newline at end of file

Assets/TrackAnalysis/NoteMakerBase.cs.meta

+fileFormatVersion: 2
+guid: cd07a88cc8fd5984e990ba3e2e656d8d
+timeCreated: 1517759155
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TrackAnalysis/NoteSignGenerator.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace TrackAnalysis
+{
+    public class NoteSignGenerator
+    {
+        public static
+            IEnumerable<Note>
+            SignToNotes(
+                string sign,
+                string signType,
+                float interval,
+                NoteMaker noteMaker)
+        {
+            return GenerateNoteSequence(Enumerable.Range(0, sign.Length / 2),
+                             x => CurrentCode(x, sign),
+                             x => ComputeTiming(int.Parse(signType.Substring(1, 3)), x, sign.Length / 2, interval),
+                             (code, timing) => MakeNote(noteMaker, code, signType.Substring(4, 3), timing));
+        }
+
+        private static
+            string
+            CurrentCode(
+                int location,
+                string sign)
+        {
+            return sign.Substring(location * 2, 2);
+        }
+
+        private static
+            float
+            ComputeTiming(
+                float measure,
+                int location,
+                int sequenceSize,
+                float interval)
+        {
+            return (measure + (float)location / sequenceSize) * interval;
+        }
+
+        private static
+            Note
+            MakeNote(
+                NoteMaker noteMaker,
+                string code,
+                string type,
+                float timing)
+        {
+            return noteMaker.Make(code, type, timing);
+        }
+
+        private static
+            IEnumerable<Note>
+            GenerateNoteSequence(
+                IEnumerable<int> range,
+                Func<int, string> currentCode,
+                Func<int, float> calcTiming,
+                Func<string, float, Note> concreteNote)
+        {
+            return DiscreteRange(range, x => currentCode(x))
+            .Select(x => concreteNote(currentCode(x), calcTiming(x)))
+            .Where(x => x != null);
+        }
+
+        private static
+            IEnumerable<int>
+            DiscreteRange(
+                IEnumerable<int> range,
+                Func<int, string> currentCode)
+        {
+            return range.Where(x => currentCode(x).Equals("00"));
+        }
+    }
+}
\ No newline at end of file

Assets/TrackAnalysis/NoteSignGenerator.cs.meta

+fileFormatVersion: 2
+guid: 47f6ae5dade649c47ab15ec231bbe4b4
+timeCreated: 1517759154
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TrackAnalysis/TrackHeader.cs

+using CustomStructure;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace TrackAnalysis
+{
+    public class TrackHeader
+    {
+        public string Title { get; private set; }
+        public string Artist { get; private set; }
+        public string Genre { get; private set; }
+        public float BPM { get; private set; }
+        public int Level { get; private set; }
+        public string BGM { get; private set; }
+        public List<string> TrackList { get; private set; }
+
+        public
+            void
+            ExtractHeader(
+                MultiDictionary<string, string> parseResult)
+        {
+            Title = ExtractMetaString(
+                            parseResult,
+                            "#TITLE");
+            Artist = ExtractMetaString(
+                            parseResult,
+                            "#ARTIST");
+            Genre = ExtractMetaString(
+                            parseResult,
+                            "#GENRE");
+            BPM = ExtractBPM(
+                            parseResult);
+            Level = ExtractLevel(
+                            parseResult);
+            TrackList = ExtractMetaList(
+                            parseResult,
+                            "#TRACKLIST");
+            BGM = ExtractMetaString(
+                            parseResult,
+                            "#WAV");
+        }
+
+        private
+            List<string>
+            ExtractMetaList(
+                MultiDictionary<string, string> parseResult,
+                string key)
+        {
+            List<string> list;
+
+            if (parseResult.TryGetValue(key, out list))
+            {
+                parseResult.Remove(key);
+                return list;
+            }
+
+            return Enumerable.Empty<string>().ToList();
+        }
+
+        private
+            string
+            ExtractMetaString(
+                MultiDictionary<string, string> parseResult,
+                string key)
+        {
+            List<string> list = ExtractMetaList(parseResult, key);
+
+            return list.Count() == 0 ? null : list[0];
+        }
+
+        private
+            float
+            ExtractBPM(
+                MultiDictionary<string, string> parseResult)
+        {
+            string str = ExtractMetaString(parseResult, "#BPM");
+
+            float outBPM;
+            if (float.TryParse(str, out outBPM))
+                return outBPM;
+            else
+                return 0;
+        }
+
+        private
+            int
+            ExtractLevel(
+                MultiDictionary<string, string> parseResult)
+        {
+            string str = ExtractMetaString(parseResult, "#PLAYLEVEL");
+
+            int outLevel;
+            if (int.TryParse(str, out outLevel))
+                return outLevel;
+            else
+                return 0;
+        }
+    }
+}
\ No newline at end of file

Assets/TrackAnalysis/TrackHeader.cs.meta

+fileFormatVersion: 2
+guid: e4c9e300e55ee0245b0c91384db72484
+timeCreated: 1517759155
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TrackAnalysis/TrackInfo.cs

+using CustomStructure;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace TrackAnalysis
+{
+    public class TrackInfo
+    {
+        public string Title { get; private set; }
+        public string Artist { get; private set; }
+        public string Genre { get; private set; }
+        public float BPM { get; private set; }
+        public int Level { get; private set; }
+
+        public float BeatInterval
+        { get { return 4 * 60 * 1000f / BPM; } }
+
+        public string BGM { get; private set; }
+
+        public List<string> TrackList { get; private set; }
+
+        public List<Note> Notes { get; private set; }
+
+        public
+            TrackInfo(
+                string path)
+            : this(
+                new FileInfo(
+                    path))
+        { }
+
+        public
+            TrackInfo(
+                FileInfo file)
+        {
+            MultiDictionary<string, string> parseResult = ParseBPE(file);
+
+            ExtractTrackHeader(parseResult);
+
+            TrackNotes notes = new TrackNotes();
+            notes.ExtractNotes(parseResult, BeatInterval);
+            Notes = notes.Notes.ToList();
+        }
+
+        private
+            MultiDictionary<string, string>
+            ParseBPE(
+                FileInfo file)
+        {
+            MultiDictionary<string, string> result = new MultiDictionary<string, string>();
+
+            using (StreamReader reader
+                = new StreamReader(new BufferedStream(file.OpenRead())))
+            {
+                string line;
+                while ((line = reader.ReadLine()) != null)
+                {
+                    if (line == "" || line[0] != '#')
+                        continue;
+
+                    string[] token = line.Split(new char[] { ' ' }, 2);
+
+                    result[token[0]] = new List<string> { token[1].Trim() };
+                }
+            }
+
+            return result;
+        }
+
+        private
+            void
+            ExtractTrackHeader(
+                MultiDictionary<string, string> parseResult)
+        {
+            TrackHeader header = new TrackHeader();
+            header.ExtractHeader(parseResult);
+
+            Title = header.Title;
+            Artist = header.Artist;
+            Genre = header.Genre;
+            BPM = header.BPM;
+            Level = header.Level;
+            TrackList = header.TrackList;
+            BGM = header.BGM;
+        }
+    }
+}

Assets/TrackAnalysis/TrackNotes.cs

+using CustomStructure;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace TrackAnalysis
+{
+    public class TrackNotes
+    {
+        public IEnumerable<Note> Notes
+        { get; private set; }
+
+        public
+            void
+            ExtractNotes(
+                MultiDictionary<string, string> parseResult,
+                float interval)
+        {
+            var validSigns = ExtractValidSigns(parseResult);
+            CreateNotes(validSigns, interval);
+            CreateBeatLines(ExtractEnd(validSigns), interval);
+        }
+
+        private
+            IEnumerable<KeyValuePair<string, List<string>>>
+            ExtractValidSigns(
+                MultiDictionary<string, string> parseResult)
+        {
+            return parseResult.Where(x => IsValidSignType(x.Key));
+        }
+
+        private
+            bool
+            IsValidSignType(
+                string signType)
+        {
+            int measure;
+
+            return signType.Length == 7 &&
+                   int.TryParse(signType.Substring(1, 3), out measure) &&
+                   Enumerable.Contains(new List<string> { "SBT", "LBT", "SMO", "LMO" },
+                                       signType.Substring(4, 3));
+        }
+
+        private
+            int
+            ExtractEnd(
+                IEnumerable<KeyValuePair<string, List<string>>> validSigns)
+        {
+            return validSigns.Select(x => int.Parse(x.Key.Substring(1, 3))).Max();
+        }
+
+        private
+            void
+            CreateBeatLines(
+                int end,
+                float interval)
+        {
+            Notes = Notes.Concat(Enumerable.Range(1, (end + 1) * 4)
+                                           .Select(x => new Note(NoteType.BeatLine, (x / 4.0f) * interval)))
+                                           .ToList();
+        }
+
+        private
+            void
+            CreateNotes(
+                IEnumerable<KeyValuePair<string, List<string>>> validSigns,
+                float interval)
+        {
+            Notes = Enumerable.Empty<Note>();
+            var noteMaker = new NoteMaker();
+
+            validSigns.ToList().ForEach(x => AddNoteSign(x, interval, noteMaker));
+        }
+
+        private
+            void
+            AddNoteSign(
+                KeyValuePair<string, List<string>> parsedItem,
+                float interval,
+                NoteMaker noteMaker)
+        {
+            parsedItem.Value.ForEach(x => Notes = Notes.Concat(NoteSignGenerator.SignToNotes(x, parsedItem.Key, interval, noteMaker)));
+        }
+    }
+}
\ No newline at end of file

Assets/TrackAnalysis/TrackNotes.cs.meta

+fileFormatVersion: 2
+guid: d6d91b2b0c59333459b0ff8c4f588593
+timeCreated: 1517759155
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: