Separate files by module, class, interface, and enum

Assets/NewFolder1.meta

+fileFormatVersion: 2
+guid: 8e735ca2f8a25aa49a7719128cd95047
+folderAsset: yes
+timeCreated: 1517593123
+licenseType: Free
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Script/EndGame.cs

-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
+using UnityEngine;
 
-public class EndGame : MonoBehaviour {
-
-	// Use this for initialization
-	void Start () {
-		
-	}
-	
-	// Update is called once per frame
-	void Update () {
+public class EndGame : MonoBehaviour
+{    
+	void Update ()
+    {
 		if(Input.GetKeyDown(KeyCode.P))
         {
             Destroy(this);

Assets/Script/JudgeManager.cs

@@ -304,8 +304,8 @@ public class JudgeManager : MonoBehaviour
             if (note is MotionNote)
                 return new Dictionary<string, InputStatus>
                 {
-                    { "short", manager.ShortMotionToInput((note as MotionNote).MotionName) },
-                    { "long",  manager.LongMotionToInput((note as MotionNote).MotionName)  }
+                    { "short", manager.MotionToInput((note as MotionNote).MotionName, "short") },
+                    { "long",  manager.MotionToInput((note as MotionNote).MotionName, "long")  }
                 };
             return new Dictionary<string, InputStatus>
             {

Assets/Script/KinectModule.meta

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

Assets/Script/KinectModule/IBody.cs.meta

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

Assets/Script/KinectModule/IBodyFrame.cs.meta

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

Assets/Script/KinectModule/IBodyIndexFrame.cs.meta

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

Assets/Script/KinectModule/IColorFrame.cs.meta

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

Assets/Script/KinectModule/IDepthFrame.cs.meta

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

Assets/Script/KinectModule/IJoint.cs.meta

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

Assets/Script/KinectModule/IMultiSourceFrame.cs.meta

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

Assets/Script/KinectModule/KinectAccessManager.cs.meta

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

Assets/Script/KinectModule/KinectConstants.cs.meta

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

Assets/Script/KinectModule/RealBody.cs.meta

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

Assets/Script/KinectModule/RealBodyFrame.cs.meta

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

Assets/Script/KinectModule/RealBodyIndexFrame.cs.meta

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

Assets/Script/KinectModule/RealColorFrame.cs.meta

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

Assets/Script/KinectModule/RealDepthFrame.cs.meta

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

Assets/Script/KinectModule/RealJoint.cs.meta

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

Assets/Script/KinectModule/RealMultiSourceFrame.cs.meta

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

Assets/Script/KinectModule/SourceBuffer.cs.meta

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

Assets/Script/MotionAnalysis/DistItvExtractor.cs

+using UnityEngine;
+using Windows.Kinect;
+
+namespace MotionAnalysis
+{
+    public class DistItvExtractor
+    {
+        private CameraSpacePoint Head,
+                                 HandLeft,
+                                 HandRight,
+                                 SpineShoulder,
+                                 SpineMid,
+                                 ElbowLeft,
+                                 ElbowRight,
+                                 KneeLeft,
+                                 KneeRight,
+                                 SpineMidRecent,
+                                 HandLeftRecent,
+                                 HandRightRecent;
+    
+        private float            Table;
+    
+        public float DistHandBaseSpineShoulder
+        { get; private set; }
+        public float DistHand
+        { get; private set; }
+        public float DistSpine
+        { get; private set; }
+        public float DistHandBaseHead
+        { get; private set; }
+        public float DistHandLeft
+        { get; private set; }
+        public float DistHandRight
+        { get; private set; }
+        public float DistHandBaseElbow_Left
+        { get; private set; }
+        public float DistHandBaseElbow_Right
+        { get; private set; }
+        public float DistHandBaseHead_Left
+        { get; private set; }
+        public float DistHandBaseHead_Right
+        { get; private set; }
+        public float DistHandBaseSpineMid_Left
+        { get; private set; }
+        public float DistHandBaseSpineMid_Right
+        { get; private set; }
+        public float DistKneeBaseTable
+        { get; private set; }
+        public float ItvElbowBaseSpineMid_Left
+        { get; private set; }
+        public float ItvElbowBaseSpineMid_Right
+        { get; private set; }
+        public float ItvHandBaseHead
+        { get; private set; }
+        public float ItvHandBaseHead_LeftEar
+        { get; private set; }
+        public float ItvHandBaseHead_RightEar
+        { get; private set; }
+        public float ItvHandBaseHead_LeftDepth
+        { get; private set; }
+        public float ItvHandBaseHead_RightDepth
+        { get; private set; }
+    
+        public DistItvExtractor(float table)
+        {
+            Table = table;
+        }
+    
+        public void Extract(KinectModule.IBody body)
+        {
+            UpdatePosition(body);
+            UpdateDistItv();
+            SaveRecent();
+        }
+    
+        private void UpdatePosition(KinectModule.IBody body)
+        {
+            Head          = body.Joints[JointType.Head]         .Position;
+            HandLeft      = body.Joints[JointType.HandLeft]     .Position;
+            HandRight     = body.Joints[JointType.HandRight]    .Position;
+            SpineShoulder = body.Joints[JointType.SpineShoulder].Position;
+            SpineMid      = body.Joints[JointType.SpineMid]     .Position;
+            ElbowLeft     = body.Joints[JointType.ElbowLeft]    .Position;
+            ElbowRight    = body.Joints[JointType.ElbowRight]   .Position;
+            KneeLeft      = body.Joints[JointType.KneeLeft]     .Position;
+            KneeRight     = body.Joints[JointType.KneeRight]    .Position;
+        }
+        
+        private void SaveRecent()
+        {
+            SpineMidRecent  = SpineMid;
+            HandLeftRecent  = HandLeft;
+            HandRightRecent = HandRight;
+        }
+        
+        private void UpdateDistItv()
+        {
+            ComputeClap();
+            ComputeJump();
+            ComputeHurray();
+            ComputeHandMove();
+            ComputeGuardBase();
+            ComputeHandUp();
+            ComputeHandDown();
+            ComputeOnTheTable();
+            ComputeJesus();
+            ComputeHeadphone();
+        }
+
+        private void ComputeClap()
+        {
+            DistHandBaseSpineShoulder = Mathf.Min(HandLeft.Y, HandRight.Y) - SpineShoulder.Y;
+
+            DistHand                  = Distance(HandLeft, HandRight);
+        }
+
+        private void ComputeJump()
+        {
+            DistSpine = SpineMid.Y - SpineMidRecent.Y;
+        }
+
+        private void ComputeHurray()
+        {
+            DistHandBaseHead = Mathf.Min(HandLeft.Y, HandRight.Y) - Head.Y;
+        }
+
+        private void ComputeHandMove()
+        {
+            DistHandLeft  = HandLeft.Y  - HandLeftRecent.Y;
+            DistHandRight = HandRight.Y - HandRightRecent.Y;
+        }
+
+        private void ComputeGuardBase()
+        {
+            DistHandBaseElbow_Left     = HandLeft.Y  - ElbowLeft.Y;
+            DistHandBaseElbow_Right    = HandRight.Y - ElbowRight.Y;
+
+            ItvElbowBaseSpineMid_Left  = Mathf.Abs(ElbowLeft.X  - SpineMid.X);
+            ItvElbowBaseSpineMid_Right = Mathf.Abs(ElbowRight.X - SpineMid.X);
+        }
+
+        private void ComputeHandUp()
+        {
+            DistHandBaseHead_Left  = HandLeft.Y  - Head.Y;
+            DistHandBaseHead_Right = HandRight.Y - Head.Y;
+        }
+
+        private void ComputeHandDown()
+        {
+            DistHandBaseSpineMid_Left  = HandLeft.Y  - SpineMid.Y;
+            DistHandBaseSpineMid_Right = HandRight.Y - SpineMid.Y;
+        }
+
+        private void ComputeOnTheTable()
+        {
+            DistKneeBaseTable = Mathf.Min(KneeLeft.Y, KneeRight.Y) - Table;
+        }
+
+        private void ComputeJesus()
+        {
+            ItvHandBaseHead = Mathf.Min(Mathf.Abs(HandLeft.X - Head.X),
+                                        Mathf.Abs(HandRight.X - Head.X));
+        }
+
+        private void ComputeHeadphone()
+        {
+            ItvHandBaseHead_LeftEar    = Mathf.Abs(HandLeft.X  - Head.X);
+            ItvHandBaseHead_RightEar   = Mathf.Abs(HandRight.X - Head.X);
+            ItvHandBaseHead_LeftDepth  = Mathf.Abs(HandLeft.Z  - Head.Z);
+            ItvHandBaseHead_RightDepth = Mathf.Abs(HandRight.Z - Head.Z);
+        }
+
+        private float Distance(CameraSpacePoint a, CameraSpacePoint b)
+        {
+            return Mathf.Sqrt(Mathf.Pow(a.X - b.X, 2.0f) +
+                              Mathf.Pow(a.Y - b.Y, 2.0f) +
+                              Mathf.Pow(a.Z - b.Z, 2.0f));
+        }
+    }
+}
\ No newline at end of file

Assets/Script/MotionAnalysis/MotionDiscriminator.cs

+using System.Collections.Generic;
+using System.Linq;
+using Windows.Kinect;
+
+namespace MotionAnalysis
+{
+    public class MotionDiscriminator
+    {
+        private DistItvExtractor Extractor;
+
+        public MotionState Motion
+        { get; private set; }
+        public bool        IsPreseted
+        { get; private set; }
+        
+        public void Preset(KinectModule.IBody body)
+        {
+            IsPreseted = false;
+
+            if (DoNotHaveKneeJoint(body))
+                return;
+
+            Extractor = new DistItvExtractor(ComputeKneeMean(body));
+
+            IsPreseted = true;
+
+            Init();
+        }
+
+        private bool DoNotHaveKneeJoint(KinectModule.IBody body)
+        {
+            KinectModule.IJoint left,
+                                right;
+
+            return !body.Joints.TryGetValue(JointType.KneeLeft,  out left) ||
+                   !body.Joints.TryGetValue(JointType.KneeRight, out right);
+        }
+
+        private float ComputeKneeMean(KinectModule.IBody body)
+        {
+            return body.Joints.Where(x => x.Key == JointType.KneeLeft ||
+                                          x.Key == JointType.KneeRight)
+                       .Select(x => x.Value.Position.Y)
+                       .Average();
+        }
+
+        private void Init()
+        {
+            Motion = MotionState.UNKNOWN;
+        }
+
+        public void Update(KinectModule.IBody body)
+        {
+            Extractor.Extract(body);
+
+            Init();
+            Determine();
+        }
+
+        void Determine()
+        {
+            Clap();
+            Jump();
+            Hurray();
+            HandMove();
+            GuardBase();
+            HandUp();
+            HandDown();
+            Jesus();
+            Headphone();
+            OnTheTable();
+        }
+
+        void Clap()
+        {
+            const float distPrepare = 0.3f,
+                        distDone = 0.1f;
+
+            if      (Extractor.DistHandBaseSpineShoulder <= 0.0f)
+                return;
+
+            if      (Extractor.DistHand > distPrepare)
+                Motion |= MotionState.CLAP_PREPARE;
+            else if (Extractor.DistHand < distDone)
+                Motion |= MotionState.CLAP_DONE;
+        }
+
+        void Jump()
+        {
+            const float distPrepare = 0.05f,
+                        distDone = 0.0f;
+
+            if      (Extractor.DistSpine < distPrepare)
+                Motion |= MotionState.JUMP_PREPARE;
+            else if (Extractor.DistSpine > distDone)
+                Motion |= MotionState.JUMP_DONE;
+        }
+
+        void Hurray()
+        {
+            if      (Extractor.DistHandBaseHead > 0)
+                Motion |= MotionState.HURRAY;
+        }
+
+        void HandMove()
+        {
+            if      (Extractor.DistHandLeft > 0)
+                Motion |= MotionState.HAND_MOVE_UP_LEFT;
+            else if (Extractor.DistHandLeft < 0)
+                Motion |= MotionState.HAND_MOVE_DOWN_LEFT;
+
+            if      (Extractor.DistHandRight > 0)
+                Motion |= MotionState.HAND_MOVE_UP_RIGHT;
+            else if (Extractor.DistHandRight < 0)
+                Motion |= MotionState.HAND_MOVE_DOWN_RIGHT;
+        }
+
+        void GuardBase()
+        {
+            const float distBase = 0.5f;
+
+            if      (Extractor.DistHandBaseElbow_Left > 0.0f &&
+                     Extractor.ItvElbowBaseSpineMid_Left < distBase)
+                Motion |= MotionState.GUARD_BASE_LEFT;
+
+            if      (Extractor.DistHandBaseElbow_Right > 0.0f &&
+                     Extractor.ItvElbowBaseSpineMid_Right < distBase)
+                Motion |= MotionState.GUARD_BASE_RIGHT;
+        }
+
+        void HandUp()
+        {
+            const float distUp = 0.2f;
+
+            if      (Extractor.DistHandBaseHead_Left > distUp)
+                Motion |= MotionState.HAND_UP_LEFT;
+
+            if      (Extractor.DistHandBaseHead_Right > distUp)
+                Motion |= MotionState.HAND_UP_RIGHT;
+        }
+
+        void HandDown()
+        {
+            if      (Extractor.DistHandBaseSpineMid_Left < 0.0f)
+                Motion |= MotionState.HAND_DOWN_LEFT;
+
+            if      (Extractor.DistHandBaseSpineMid_Right < 0.0f)
+                Motion |= MotionState.HAND_DOWN_RIGHT;
+        }
+
+        void Jesus()
+        {
+            const float distJesus = 0.5f;
+
+            if      (Extractor.DistHandBaseSpineShoulder > 0.0f && Extractor.ItvHandBaseHead >= distJesus)
+                Motion |= MotionState.JESUS;
+        }
+
+        void Headphone()
+        {
+            const float itvDepth = 0.2f,
+                        itvEar = 0.2f;
+
+            if      (Extractor.ItvHandBaseHead_LeftEar < itvEar &&
+                     Extractor.ItvHandBaseHead_LeftDepth < itvDepth)
+                Motion |= MotionState.HEADPHONE_LEFT;
+
+            if      (Extractor.ItvHandBaseHead_RightEar < itvEar &&
+                     Extractor.ItvHandBaseHead_RightDepth < itvDepth)
+                Motion |= MotionState.HEADPHONE_RIGHT;
+        }
+
+        void OnTheTable()
+        {
+            const float distTable = 0.5f;
+
+            if      (Extractor.DistKneeBaseTable >= distTable)
+                Motion |= MotionState.ON_THE_TABLE;
+        }
+    }
+}

Assets/Script/MotionAnalysis/MotionState.cs

+using System;
+
+namespace MotionAnalysis
+{
+    [Flags]
+    public enum MotionState : uint
+    {
+        UNKNOWN              = 0x00000,
+        CLAP_PREPARE         = 0x00001,
+        CLAP_DONE            = 0x00002,
+        JUMP_PREPARE         = 0x00004,
+        JUMP_DONE            = 0x00008,
+        HURRAY               = 0x00010,
+        HAND_MOVE_UP_LEFT    = 0x00020,
+        HAND_MOVE_DOWN_LEFT  = 0x00040,
+        HAND_MOVE_UP_RIGHT   = 0x00080,
+        HAND_MOVE_DOWN_RIGHT = 0x00100,
+        GUARD_BASE_LEFT      = 0x00200,
+        GUARD_BASE_RIGHT     = 0x00400,
+        HAND_UP_LEFT         = 0x00800,
+        HAND_DOWN_LEFT       = 0x01000,
+        HAND_UP_RIGHT        = 0x02000,
+        HAND_DOWN_RIGHT      = 0x04000,
+        JESUS                = 0x10000,
+        HEADPHONE_LEFT       = 0x20000,
+        HEADPHONE_RIGHT      = 0x40000,
+        ON_THE_TABLE         = 0x80000
+    }
+}
\ No newline at end of file

Assets/Script/MotionSampleDisplay.cs

-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
+using UnityEngine;
 
 public class MotionSampleDisplay : MonoBehaviour
 {
     [SerializeField]
-    GameObject left, right;
+    GameObject        left,
+                      right;
 
-    public Sprite sprite;
-    public float timeout;
+    public Sprite     sprite;
+    public float      timeout;
     public MotionNote caller;
 
-    private float elapsedTime;
-    private float velocity;
-    private float acceleration;
+    private float     elapsedTime;
+    private float     acceleration;
 
-    private float distance = 1.5f;
+    private float     distance = 1.5f;
+    private Vector3   localScaleLR = new Vector3(0.5f, 0.5f, 0);
+
+    private Vector3 InitialTranslateL
+    {
+        get
+        {
+            var tmp = InitialTranslateR;
+            tmp.x = -tmp.x;
+            return tmp;
+        }
+    }
+    private Vector3 InitialTranslateR
+    {
+        get
+        {
+            return new Vector3(distance, -0.8f, 0);
+        }
+    }
 
     // Use this for initialization
     void Start()
     {
         elapsedTime = 0f;
-        velocity = 0f;
         acceleration = 2 * distance / Mathf.Pow(timeout, 2);
+        
+        SetObject(left, true);
+        SetObject(right, false);
+    }
 
-        left.GetComponent<SpriteRenderer>().sprite = sprite;
-        right.GetComponent<SpriteRenderer>().sprite = sprite;
-
-        left.transform.Translate(-distance, -0.8f, 0);
-        left.transform.localScale = new Vector3(0.5f, 0.5f);
-        right.transform.Translate(distance, -0.8f, 0);
-        right.transform.localScale = new Vector3(0.5f, 0.5f);
+    void SetObject(GameObject obj, bool isLeft)
+    {
+        obj.GetComponent<SpriteRenderer>().sprite = sprite;
+        obj.transform.Translate(isLeft ? InitialTranslateL : InitialTranslateR);
+        obj.transform.localScale = localScaleLR;
     }
 
     // Update is called once per frame
     void Update()
     {
-        float delta = Time.deltaTime * 1000f;
+        var delta = Time.deltaTime * 1000f;
         elapsedTime += delta;
-        velocity = acceleration * elapsedTime;
-
         if (elapsedTime > timeout)
         {
             Destroy(gameObject);
+            return;
         }
 
-        left.transform.Translate(new Vector3(velocity * delta, 0));
-        right.transform.Translate(new Vector3(-velocity * delta, 0));
+        var velocity = acceleration * elapsedTime;
+        var movement = velocity * delta;
+        left .transform.Translate(new Vector3(movement, 0, 0));
+        right.transform.Translate(new Vector3(-movement, 0, 0));
     }
 }
\ No newline at end of file

Assets/Script/ScoreDisplayManager.cs

-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
+using UnityEngine;
 using UnityEngine.UI;
 
-public class ScoreDisplayManager : MonoBehaviour {
-
-
+public class ScoreDisplayManager : MonoBehaviour
+{
     public Text Score;
     public Text Perfect;
     public Text Good;
@@ -13,33 +10,30 @@ public class ScoreDisplayManager : MonoBehaviour {
     public Text Miss;
     public Text Combo;
 
-
     // Use this for initialization
-    void Start () {
-        Score.text = GameManager.Instance.Score.ToString();
+    void Start ()
+    {
+        Score.text   = GameManager.Instance.Score.ToString();
         Perfect.text = GameManager.Instance.JudgeCount[Judge.JudgeList[0]].ToString();
-        Good.text = GameManager.Instance.JudgeCount[Judge.JudgeList[1]].ToString();
-        Bad.text = GameManager.Instance.JudgeCount[Judge.JudgeList[2]].ToString();
-        Miss.text = GameManager.Instance.JudgeCount[Judge.JudgeList[3]].ToString();
-        Combo.text = GameManager.Instance.LongestCombo.ToString();
-
+        Good.text    = GameManager.Instance.JudgeCount[Judge.JudgeList[1]].ToString();
+        Bad.text     = GameManager.Instance.JudgeCount[Judge.JudgeList[2]].ToString();
+        Miss.text    = GameManager.Instance.JudgeCount[Judge.JudgeList[3]].ToString();
+        Combo.text   = GameManager.Instance.LongestCombo.ToString();
     }
 
     // Update is called once per frame
-    void Update () {
+    void Update ()
+    {
         if (Input.anyKey)
         {
             GameManager.Instance.Score = 0;
-            GameManager.Instance.JudgeCount[Judge.JudgeList[0]] = 0;
-            GameManager.Instance.JudgeCount[Judge.JudgeList[1]] = 0;
-            GameManager.Instance.JudgeCount[Judge.JudgeList[2]] = 0;
-            GameManager.Instance.JudgeCount[Judge.JudgeList[3]] = 0;
+            Judge.JudgeList.ForEach(x => GameManager.Instance.JudgeCount[x] = 0);
             GameManager.Instance.LongestCombo = 0;
             Destroy(this);
 
             GameManager.Instance.SceneTransition("SetSelect");
-            
-            
+
+            return;
         }
     }
 }

Assets/Script/StatusConvert/ButtonStatusGetter.cs

+using UnityEngine;
+
+namespace StatusConvert
+{
+    public static class ButtonStatusGetter
+    {
+        public static bool IsButtonDown
+        {
+            get
+            {
+                return Input.GetKey(KeyCode.Space) ||
+                       Input.GetKey(KeyCode.Joystick1Button0);
+            }
+        }
+    }
+}
\ No newline at end of file

Assets/Script/StatusConvert/InputStatus.cs

+namespace StatusConvert
+{
+    public enum InputStatus
+    {
+        Entered,
+        Continuing,
+        Stopped,
+        None
+    }
+}
\ No newline at end of file

Assets/Script/StatusConvert/MotionStatus.cs

+using System;
+
+namespace StatusConvert
+{
+    [Flags]
+    public enum MotionStatus : uint
+    {
+        Prepared = 0x1,
+        Done = 0x2,
+        None = 0x0
+    }
+}
\ No newline at end of file

Assets/Script/StatusConvert/MotionStatusExtractor.cs

+using MotionAnalysis;
+using System.Collections.Generic;
+
+namespace StatusConvert
+{
+    public static class MotionStatusExtractor
+    {
+        private static readonly Dictionary<string, Dictionary<string, MotionState>> ShortStates =
+            new Dictionary<string, Dictionary<string, MotionState>>
+            {
+                {
+                    "Clap", new Dictionary<string, MotionState>
+                    {
+                        { "prepare", MotionState.CLAP_PREPARE },
+                        { "done",    MotionState.CLAP_DONE    }
+                    }
+                },
+                {
+                    "Jump", new Dictionary<string, MotionState>
+                    {
+                        { "prepare", MotionState.JUMP_PREPARE },
+                        { "done",    MotionState.JUMP_DONE    }
+                    }
+                },
+                {
+                    "PushUpLeft", new Dictionary<string, MotionState>
+                    {
+                        { "prepare", MotionState.HURRAY &
+                                     MotionState.HAND_MOVE_UP_LEFT   },
+                        { "done",    MotionState.HURRAY &
+                                     MotionState.HAND_MOVE_DOWN_LEFT }
+                    }
+                },
+                {
+                    "PushUpRight", new Dictionary<string, MotionState>
+                    {
+                        { "prepare", MotionState.HURRAY &
+                                     MotionState.HAND_MOVE_UP_RIGHT   },
+                        { "done",    MotionState.HURRAY &
+                                     MotionState.HAND_MOVE_DOWN_RIGHT }
+                    }
+                },
+                {
+                    "JumpPushUpLeft", new Dictionary<string, MotionState>
+                    {
+                        { "prepare", MotionState.JUMP_PREPARE &
+                                     MotionState.HURRAY       &
+                                     MotionState.HAND_MOVE_UP_LEFT   },
+                        { "done",    MotionState.JUMP_DONE &
+                                     MotionState.HURRAY    &
+                                     MotionState.HAND_MOVE_DOWN_LEFT }
+                    }
+                },
+                {
+                    "JumpPushUpRight", new Dictionary<string, MotionState>
+                    {
+                        { "prepare", MotionState.JUMP_PREPARE &
+                                     MotionState.HURRAY       &
+                                     MotionState.HAND_MOVE_UP_RIGHT   },
+                        { "done",    MotionState.JUMP_DONE &
+                                     MotionState.HURRAY    &
+                                     MotionState.HAND_MOVE_DOWN_RIGHT }
+                    }
+                },
+                {
+                    "GuardLeft", new Dictionary<string, MotionState>
+                    {
+                        { "prepare", MotionState.GUARD_BASE_LEFT &
+                                     MotionState.HAND_MOVE_UP_LEFT   },
+                        { "done",    MotionState.GUARD_BASE_LEFT &
+                                     MotionState.HAND_MOVE_DOWN_LEFT }
+                    }
+                },
+                {
+                    "GuardRight", new Dictionary<string, MotionState>
+                    {
+                        { "prepare", MotionState.GUARD_BASE_RIGHT &
+                                     MotionState.HAND_MOVE_UP_RIGHT   },
+                        { "done",    MotionState.GUARD_BASE_RIGHT &
+                                     MotionState.HAND_MOVE_DOWN_RIGHT }
+                    }
+                }
+            };
+
+        private static readonly Dictionary<string, MotionState> LongStates
+            = new Dictionary<string, MotionState>
+            {
+                { "HandUpLeft",       MotionState.HAND_UP_LEFT    },
+                { "HandUpRight",      MotionState.HAND_UP_RIGHT   },
+                { "HandDownLeft",     MotionState.HAND_DOWN_LEFT  },
+                { "HandDownRight",    MotionState.HAND_DOWN_RIGHT },
+                { "Jesus",            MotionState.JESUS           },
+                { "HeadphoneLeft",    MotionState.HEADPHONE_LEFT  },
+                { "HeadphoneRight",   MotionState.HEADPHONE_RIGHT },
+                { "OnTheTable",       MotionState.ON_THE_TABLE    }
+            };
+
+        private static bool IsContain(MotionState target, MotionState motion)
+        {
+            return (target & motion) == motion;
+        }
+
+        private  static MotionStatus ExtractShort(string name, MotionState state)
+        {
+            if (IsContain(state, ShortStates[name]["prepare"]))
+                return MotionStatus.Prepared;
+            if (IsContain(state, ShortStates[name]["done"]))
+                return MotionStatus.Done;
+
+            return MotionStatus.None;
+        }
+
+        private  static MotionStatus ExtractLong(string name, MotionState state)
+        {
+            if (IsContain(state, LongStates[name]))
+                return MotionStatus.Prepared |
+                       MotionStatus.Done;
+
+            return MotionStatus.None;
+        }
+
+        public static MotionStatus Extract(string name, MotionState state)
+        {
+            if (ShortStates.ContainsKey(name))
+                return ExtractShort(name, state);
+            if (LongStates .ContainsKey(name))
+                return ExtractLong (name, state);
+
+            return MotionStatus.None;
+        }
+    }
+}
\ No newline at end of file

Assets/Script/TitleManager.cs

-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
+using UnityEngine;
 
-public class TitleManager : MonoBehaviour {
-
-	// Use this for initialization
-	void Start () {
-		
-	}
-	
+public class TitleManager : MonoBehaviour
+{
 	// Update is called once per frame
 	void Update () {
         if (Input.anyKey)
         {
             Destroy(this);
             GameManager.Instance.SceneTransition("SetSelect");
+            return;
         }
     }
 }