Coding style enforcement

LewisJohnson · LewisJohnson · commit 4baa2c6f50fa · 2017-09-23T12:31:05.000+02:00
diff --git a/Assets/Common/Cameras/Scripts/GroundCam.cs b/Assets/Common/Cameras/Scripts/GroundCam.cs
@@ -2,144 +2,159 @@
 using UnityEngine;
 
 namespace Assets.Common.Cameras.Scripts {
+
     [AddComponentMenu("Scripts/Cameras/GroundCam")]
     public class GroundCam : MonoBehaviour {
-        private Transform _mChildCameraTransform;
-        private Vector2 _mInput;
-        private bool _mIsMoving;
-        private Vector3 _mMoveDir = Vector3.zero;
         public float MBoostSpeed = 10f;
         public float MMoveSpeed = 1f;
 
         [SerializeField]
         public MouseLook MouseLook;
 
-        // Use this for initialization
-        private void Start() {
-            _mChildCameraTransform = transform.GetChild(0);
-            MouseLook.Init(transform, _mChildCameraTransform);
-        }
+        private Transform childCameraTransform;
+        private Vector2 input;
+        private Vector3 moveDir = Vector3.zero;
 
         private void FixedUpdate() {
             float speed;
             GetInput(out speed);
 
             // always move along the camera forward as it is the direction that it being aimed at
-            Vector3 desiredMove = transform.forward * _mInput.y + transform.right * _mInput.x;
+            Vector3 desiredMove = (transform.forward * input.y) + (transform.right * input.x);
 
             // get a normal for the surface that is being touched to move along it
-            _mMoveDir.x = desiredMove.x * speed;
-            _mMoveDir.z = desiredMove.z * speed;
+            moveDir.x = desiredMove.x * speed;
+            moveDir.z = desiredMove.z * speed;
 
             Vector3 pos = transform.position;
-            pos.x += _mMoveDir.x;
-            pos.z += _mMoveDir.z;
+            pos.x += moveDir.x;
+            pos.z += moveDir.z;
             transform.position = pos;
             MouseLook.UpdateCursorLock();
             RotateView();
         }
 
-        private void RotateView() {
-            MouseLook.LookRotation(transform, _mChildCameraTransform);
-        }
-
         private void GetInput(out float speed) {
             // Read input
             float horizontal = Input.GetAxis("Horizontal");
             float vertical = Input.GetAxis("Vertical");
 
             speed = Input.GetKey(KeyCode.LeftShift) ? MBoostSpeed : MMoveSpeed;
-            _mInput = new Vector2(horizontal, vertical);
+            input = new Vector2(horizontal, vertical);
+
+            if (input.sqrMagnitude > 1) {
+                input.Normalize();
+            }
+        }
 
-            if (_mInput.sqrMagnitude > 1) _mInput.Normalize();
+        private void RotateView() {
+            MouseLook.LookRotation(transform, childCameraTransform);
+        }
+
+        // Use this for initialization
+        private void Start() {
+            childCameraTransform = transform.GetChild(0);
+            MouseLook.Init(transform, childCameraTransform);
         }
     }
 
     [Serializable]
     public class MouseLook {
-        private bool _mCursorIsLocked = true;
         public bool ClampVerticalRotation = true;
         public bool LockCursor = true;
-        private Quaternion m_CameraTargetRot;
-
-        private Quaternion m_CharacterTargetRot;
         public float MaximumX = 90F;
         public float MinimumX = -90F;
         public bool Smooth;
         public float SmoothTime = 5f;
         public float XSensitivity = 2f;
         public float YSensitivity = 2f;
+        private Quaternion cameraTargetRot;
+
+        private Quaternion characterTargetRot;
+        private bool cursorIsLocked = true;
 
         public void Init(Transform character, Transform camera) {
-            m_CharacterTargetRot = character.localRotation;
-            m_CameraTargetRot = camera.localRotation;
+            characterTargetRot = character.localRotation;
+            cameraTargetRot = camera.localRotation;
         }
 
-
         public void LookRotation(Transform character, Transform camera, float yRotOptional = 0f) {
             float yRot = Input.GetAxis("Mouse X") * XSensitivity;
             float xRot = Input.GetAxis("Mouse Y") * YSensitivity;
 
-            if (yRotOptional != 0f) m_CharacterTargetRot *= Quaternion.Euler(0f, yRotOptional, 0f);
-            else m_CharacterTargetRot *= Quaternion.Euler(0f, yRot, 0f);
+            if (yRotOptional != 0f) {
+                characterTargetRot *= Quaternion.Euler(0f, yRotOptional, 0f);
+            } else {
+                characterTargetRot *= Quaternion.Euler(0f, yRot, 0f);
+            }
 
-            m_CameraTargetRot *= Quaternion.Euler(-xRot, 0f, 0f);
+            cameraTargetRot *= Quaternion.Euler(-xRot, 0f, 0f);
 
-            if (ClampVerticalRotation)
-                m_CameraTargetRot = ClampRotationAroundXAxis(m_CameraTargetRot);
+            if (ClampVerticalRotation) {
+                cameraTargetRot = ClampRotationAroundXAxis(cameraTargetRot);
+            }
 
             if (Smooth) {
-                character.localRotation = Quaternion.Slerp(character.localRotation, m_CharacterTargetRot,
+                character.localRotation = Quaternion.Slerp(
+                    character.localRotation,
+                    characterTargetRot,
                     SmoothTime * Time.deltaTime);
-                camera.localRotation = Quaternion.Slerp(camera.localRotation, m_CameraTargetRot,
+                camera.localRotation = Quaternion.Slerp(
+                    camera.localRotation,
+                    cameraTargetRot,
                     SmoothTime * Time.deltaTime);
             } else {
-                character.localRotation = m_CharacterTargetRot;
-                camera.localRotation = m_CameraTargetRot;
+                character.localRotation = characterTargetRot;
+                camera.localRotation = cameraTargetRot;
             }
 
             UpdateCursorLock();
         }
 
         public void SetCursorLock(bool value) {
             LockCursor = value;
-            if (!LockCursor) {
-                Cursor.lockState = CursorLockMode.None;
-                Cursor.visible = true;
+            if (LockCursor) {
+                return;
             }
-        }
 
-        public void UpdateCursorLock() {
-            if (LockCursor) InternalLockUpdate();
+            Cursor.lockState = CursorLockMode.None;
+            Cursor.visible = true;
         }
 
-        private void InternalLockUpdate() {
-            if (Input.GetKeyUp(KeyCode.Escape)) _mCursorIsLocked = false;
-            else if (Input.GetMouseButtonUp(0)) _mCursorIsLocked = true;
-
-            if (_mCursorIsLocked) {
-                Cursor.lockState = CursorLockMode.Locked;
-                Cursor.visible = false;
-            } else if (!_mCursorIsLocked) {
-                Cursor.lockState = CursorLockMode.None;
-                Cursor.visible = true;
+        public void UpdateCursorLock() {
+            if (LockCursor) {
+                InternalLockUpdate();
             }
         }
 
-
         private Quaternion ClampRotationAroundXAxis(Quaternion q) {
             q.x /= q.w;
             q.y /= q.w;
             q.z /= q.w;
             q.w = 1.0f;
 
             float angleX = 2.0f * Mathf.Rad2Deg * Mathf.Atan(q.x);
-
             angleX = Mathf.Clamp(angleX, MinimumX, MaximumX);
-
             q.x = Mathf.Tan(0.5f * Mathf.Deg2Rad * angleX);
 
             return q;
         }
+
+        private void InternalLockUpdate() {
+            if (Input.GetKeyUp(KeyCode.Escape)) {
+                cursorIsLocked = false;
+            } else if (Input.GetMouseButtonUp(0)) {
+                cursorIsLocked = true;
+            }
+
+            if (cursorIsLocked) {
+                Cursor.lockState = CursorLockMode.Locked;
+                Cursor.visible = false;
+            } else if (!cursorIsLocked) {
+                Cursor.lockState = CursorLockMode.None;
+                Cursor.visible = true;
+            }
+        }
     }
+
 }
diff --git a/Assets/Common/Scripts/BindTextToAnotherTextElement.cs b/Assets/Common/Scripts/BindTextToAnotherTextElement.cs
@@ -22,7 +22,6 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 
-using UnityEditor;
 using UnityEngine;
 using UnityEngine.UI;
 
@@ -34,9 +33,10 @@ namespace Assets.Common.Scripts {
     public class BindTextToAnotherTextElement : MonoBehaviour {
 
         public Text TargetText;
-        [MenuItem("MyMenu/Do Something")]
-        void Update() {
-            this.GetComponent<Text>().text = TargetText.text;
+
+        public void Update() {
+            GetComponent<Text>().text = TargetText.text;
         }
     }
-}
+
+}
diff --git a/Assets/Common/Scripts/ExtentionMethods.cs b/Assets/Common/Scripts/ExtentionMethods.cs
@@ -28,21 +28,20 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 
 namespace Assets.Common.Scripts {
 
-    [AddComponentMenu("Scripts/Common/ExtentionMethods")]
+    [AddComponentMenu("Scripts/Common/Extention Methods")]
     public static class ExtentionMethods {
-        public static int RoundToTenth(this int i) {
-            return ((int)Math.Round(i / 10.0)) * 10;
-        }
 
         public static IEnumerable<IList<T>> Chunks<T>(this IEnumerable<T> xs, int size) {
             List<T> curr = new List<T>(size);
 
             foreach (T x in xs) {
                 curr.Add(x);
-                if (curr.Count == size) {
-                    yield return curr;
-                    curr = new List<T>(size);
+                if (curr.Count != size) {
+                    continue;
                 }
+
+                yield return curr;
+                curr = new List<T>(size);
             }
         }
 
@@ -54,11 +53,18 @@ public static IEnumerable<T[]> ChunksAsArray<T>(this IEnumerable<T> xs, int size
             foreach (T x in xs) {
                 curr[i % size] = x;
 
-                if (++i % size == 0) {
-                    yield return curr;
-                    curr = new T[size];
+                if (++i % size != 0) {
+                    continue;
                 }
+
+                yield return curr;
+                curr = new T[size];
             }
         }
+
+        public static int RoundToTenth(this int i) {
+            return (int)Math.Round(i / 10.0) * 10;
+        }
     }
-}
+
+}
diff --git a/Assets/Common/StandardAssets/Cameras/Scripts/HandHeldCam.cs b/Assets/Common/StandardAssets/Cameras/Scripts/HandHeldCam.cs
@@ -1,6 +1,4 @@
-#if UNITY_EDITOR
 using UnityEngine;
-#endif
 
 namespace Assets.Common.StandardAssets.Cameras.Scripts {
     [AddComponentMenu("Scripts/Cameras/HandHeldCam")]
diff --git a/Assets/Common/StandardAssets/CrossPlatformInput/Scripts/MobileControlRig.cs b/Assets/Common/StandardAssets/CrossPlatformInput/Scripts/MobileControlRig.cs
@@ -1,4 +1,6 @@
+#if UNITY_EDITOR
 using UnityEditor;
+#endif
 
 using UnityEngine;
 using UnityEngine.EventSystems;
diff --git a/Assets/Common/StandardAssets/Editor/CrossPlatformInput/CrossPlatformInputInitialize.cs b/Assets/Common/StandardAssets/Editor/CrossPlatformInput/CrossPlatformInputInitialize.cs
@@ -1,5 +1,7 @@
 using System.Collections.Generic;
+#if UNITY_EDITOR
 using UnityEditor;
+#endif
 
 namespace Assets.Common.StandardAssets.Editor.CrossPlatformInput
 {
diff --git a/Assets/Common/StandardAssets/Utility/AutoMobileShaderSwitch.cs b/Assets/Common/StandardAssets/Utility/AutoMobileShaderSwitch.cs
@@ -1,6 +1,7 @@
 using System;
-using System.Collections.Generic;
+#if UNITY_EDITOR
 using UnityEditor;
+#endif
 using UnityEngine;
 
 namespace Assets.Common.StandardAssets.Utility
diff --git a/Assets/Common/StandardAssets/Utility/PlatformSpecificContent.cs b/Assets/Common/StandardAssets/Utility/PlatformSpecificContent.cs
@@ -1,8 +1,7 @@
-using UnityEditor;
-using UnityEngine;
 #if UNITY_EDITOR
-
+using UnityEditor;
 #endif
+using UnityEngine;
 
 namespace Assets.Common.StandardAssets.Utility
 {
diff --git a/Assets/Common/StandardAssets/Utility/TimedObjectActivator.cs b/Assets/Common/StandardAssets/Utility/TimedObjectActivator.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Collections;
+#if UNITY_EDITOR
 using UnityEditor;
+#endif
 using UnityEngine;
 using UnityEngine.SceneManagement;
 
diff --git a/Assets/Common/StandardAssets/Utility/WaypointCircuit.cs b/Assets/Common/StandardAssets/Utility/WaypointCircuit.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Collections;
+#if UNITY_EDITOR
 using UnityEditor;
+#endif
 using UnityEngine;
 
 namespace Assets.Common.StandardAssets.Utility
diff --git a/unity-ui-examples.sln.DotSettings b/unity-ui-examples.sln.DotSettings
@@ -7,4 +7,6 @@
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_FOREACH/@EntryValue">Required</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_IFELSE/@EntryValue">Required</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_WHILE/@EntryValue">Required</s:String>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_REDUNDANT/@EntryValue">False</s:Boolean></wpf:ResourceDictionary>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_REDUNDANT/@EntryValue">False</s:Boolean>
+	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/BLANK_LINES_AROUND_FIELD/@EntryValue">0</s:Int64>
+	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/BLANK_LINES_INSIDE_REGION/@EntryValue">0</s:Int64></wpf:ResourceDictionary>

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,7 @@`
`1`	`1`	`using System.Collections.Generic;`
	`2`	`+#if UNITY_EDITOR`
`2`	`3`	`using UnityEditor;`
	`4`	`+#endif`
`3`	`5`
`4`	`6`	`namespace Assets.Common.StandardAssets.Editor.CrossPlatformInput`
`5`	`7`	`{`