Optimize scripts.

Mogoson · Mogoson · commit 527e9e0e3665 · 2019-01-03T00:53:40.000+08:00
diff --git a/Assets/MGS-Machinery/Scripts/Crank/FreeCrank.cs b/Assets/MGS-Machinery/Scripts/Crank/FreeCrank.cs
@@ -30,21 +30,22 @@ protected override void DriveCrank(float velocity, DriveType type = DriveType.Ig
         {
             triggerRecord = Angle;
             Angle += velocity * Time.deltaTime;
-            DriveCrank();
+            RotateCrank(Angle);
 
             if (CheckTriggers())
             {
                 Angle = triggerRecord;
-                DriveCrank();
+                RotateCrank(Angle);
             }
         }
 
         /// <summary>
         /// Rotate crank.
         /// </summary>
-        protected void DriveCrank()
+        /// <param name="angle">Current rotate angle of crank.</param>
+        protected void RotateCrank(float angle)
         {
-            transform.localRotation = Quaternion.Euler(StartAngles + new Vector3(0, 0, Angle));
+            transform.localRotation = Quaternion.Euler(StartAngles + new Vector3(0, 0, angle));
             DriveRockers();
         }
         #endregion
diff --git a/Assets/MGS-Machinery/Scripts/Crank/GearCrank.cs b/Assets/MGS-Machinery/Scripts/Crank/GearCrank.cs
@@ -36,17 +36,17 @@ public class GearCrank : FreeCrank
         protected override void DriveCrank(float velocity, DriveType type = DriveType.Ignore)
         {
             triggerRecord = Angle;
-
             if (type == DriveType.Linear)
+            {
                 velocity *= Mathf.Rad2Deg / radius;
-
+            }
             Angle += velocity * Time.deltaTime;
-            DriveCrank();
+            RotateCrank(Angle);
 
             if (CheckTriggers())
             {
                 Angle = triggerRecord;
-                DriveCrank();
+                RotateCrank(Angle);
             }
         }
         #endregion
diff --git a/Assets/MGS-Machinery/Scripts/Crank/LimitCrank.cs b/Assets/MGS-Machinery/Scripts/Crank/LimitCrank.cs
@@ -38,12 +38,12 @@ protected override void DriveCrank(float velocity, DriveType type = DriveType.Ig
             triggerRecord = Angle;
             Angle += velocity * Time.deltaTime;
             Angle = Mathf.Clamp(Angle, range.min, range.max);
-            DriveCrank();
+            RotateCrank(Angle);
 
             if (CheckTriggers())
             {
                 Angle = triggerRecord;
-                DriveCrank();
+                RotateCrank(Angle);
             }
         }
         #endregion
diff --git a/Assets/MGS-Machinery/Scripts/Hinge/CrankRocker.cs b/Assets/MGS-Machinery/Scripts/Hinge/CrankRocker.cs
@@ -90,20 +90,28 @@ protected override void DriveLinkJoints()
             IsLock = false;
             var vector = Vector.Zero;
             if (vectors.Count == 1)
+            {
                 vector = vectors[0];
+            }
             else
             {
                 //Adapt restrict and intertia.
                 var rID = restrict ? 1 : 0;
                 if (inertia)
+                {
                     vector = vectors[rID];
+                }
                 else
                 {
                     var isVectorTop = vectors[0].y - vectors[1].y >= 0;
                     if (isVectorTop == isTop)
+                    {
                         vector = vectors[rID];
+                    }
                     else
+                    {
                         vector = vectors[1 - rID];
+                    }
                 }
             }
 
diff --git a/Assets/MGS-Machinery/Scripts/Hinge/CrankSlider.cs b/Assets/MGS-Machinery/Scripts/Hinge/CrankSlider.cs
@@ -69,9 +69,13 @@ protected override void DriveLinkJoints()
             IsLock = false;
             var vector = Vector.Zero;
             if (vectors.Count == 1)
+            {
                 vector = vectors[0];
+            }
             else
+            {
                 vector = isRight ? vectors[0] : vectors[1];
+            }
 
             slider.localPosition = new Vector3((float)vector.x, (float)vector.y);
             link.Drive(0, DriveType.Ignore);
@@ -96,7 +100,9 @@ protected Vector3 ProjectDirection(Vector3 direction)
         {
             var project = Vector3.ProjectOnPlane(direction, transform.forward);
             if (project == Vector3.zero)
+            {
                 project = transform.right;
+            }
             return project;
         }
         #endregion
diff --git a/Assets/MGS-Machinery/Scripts/Mechanism/Mechanism.cs b/Assets/MGS-Machinery/Scripts/Mechanism/Mechanism.cs
@@ -113,7 +113,9 @@ protected bool CheckTriggers()
             foreach (var trigger in triggers)
             {
                 if (trigger.IsTriggered)
+                {
                     return true;
+                }
             }
             return false;
         }
@@ -141,7 +143,9 @@ public override void Initialize()
             {
                 var trigger = rocker.GetComponent<TriggerMechanism>();
                 if (trigger)
+                {
                     triggers.Add(trigger);
+                }
             }
         }
         #endregion
@@ -244,14 +248,18 @@ public abstract class CrankLinkMechanism : Mechanism
         protected override void Awake()
         {
             if (IsIntact)
+            {
                 Initialize();
+            }
         }
 
 #if UNITY_EDITOR
         protected virtual void Update()
         {
             if (Application.isPlaying)
+            {
                 return;
+            }
 
             if (IsIntact)
             {
@@ -263,7 +271,9 @@ protected virtual void Update()
                 DriveLinkJoints();
             }
             else
+            {
                 isInitialized = false;
+            }
         }
 #endif
         /// <summary>
@@ -322,13 +332,17 @@ public override void Drive(float velocity, DriveType type)
             if (velocity >= 0)
             {
                 if (IsLock && isPositive)
+                {
                     return;
+                }
                 isPositive = true;
             }
             else
             {
                 if (IsLock && !isPositive)
+                {
                     return;
+                }
                 isPositive = false;
             }
             crank.Drive(velocity, type);
@@ -354,7 +368,9 @@ public abstract class RockerMechanism : Mechanism
         protected virtual void Update()
         {
             if (!Application.isPlaying && joint)
+            {
                 Drive(0, DriveType.Ignore);
+            }
         }
 #endif
         #endregion
@@ -392,12 +408,16 @@ public TelescopicState State
         {
             get
             {
+                var state = TelescopicState.Between;
                 if (Displacement <= stroke.min)
-                    return TelescopicState.Minimum;
+                {
+                    state = TelescopicState.Minimum;
+                }
                 else if (Displacement >= stroke.max)
-                    return TelescopicState.Maximum;
-                else
-                    return TelescopicState.Between;
+                {
+                    state = TelescopicState.Maximum;
+                }
+                return state;
             }
         }
 
diff --git a/Assets/MGS-Machinery/Scripts/Slider/Slider.cs b/Assets/MGS-Machinery/Scripts/Slider/Slider.cs
@@ -28,10 +28,12 @@ protected Vector3 Aixs
         {
             get
             {
+                var axis = transform.forward;
                 if (transform.parent)
-                    return transform.parent.InverseTransformDirection(transform.forward);
-                else
-                    return transform.forward;
+                {
+                    axis = transform.parent.InverseTransformDirection(axis);
+                }
+                return axis;
             }
         }
         #endregion
@@ -46,21 +48,22 @@ protected override void DriveSlider(float velocity)
             triggerRecord = Displacement;
             Displacement += velocity * Time.deltaTime;
             Displacement = Mathf.Clamp(Displacement, stroke.min, stroke.max);
-            DriveSlider();
+            MoveSlider(Displacement);
 
             if (CheckTriggers())
             {
                 Displacement = triggerRecord;
-                DriveSlider();
+                MoveSlider(Displacement);
             }
         }
 
         /// <summary>
         /// Move slider.
         /// </summary>
-        protected virtual void DriveSlider()
+        /// <param name="displacement">Displacement of slider.</param>
+        protected void MoveSlider(float displacement)
         {
-            transform.localPosition = StartPosition + Aixs * Displacement;
+            transform.localPosition = StartPosition + Aixs * displacement;
             DriveRockers();
         }
         #endregion
diff --git a/Assets/MGS-Machinery/Scripts/Slider/SliderArm.cs b/Assets/MGS-Machinery/Scripts/Slider/SliderArm.cs
@@ -37,18 +37,20 @@ public override void Drive(float velocity, DriveType type = DriveType.Ignore)
         {
             var currentJoint = sliders[sliderIndex];
             currentJoint.Drive(velocity, DriveType.Ignore);
-
             if (velocity >= 0)
             {
                 if (currentJoint.State == TelescopicState.Maximum)
+                {
                     sliderIndex++;
+                }
             }
             else
             {
                 if (currentJoint.State == TelescopicState.Minimum)
+                {
                     sliderIndex--;
+                }
             }
-
             sliderIndex = ClampIndex(sliderIndex);
         }
         #endregion

Original file line number	Diff line number	Diff line change
`@@ -30,21 +30,22 @@ protected override void DriveCrank(float velocity, DriveType type = DriveType.Ig`
`30`	`30`	`{`
`31`	`31`	`triggerRecord = Angle;`
`32`	`32`	`Angle += velocity * Time.deltaTime;`
`33`		`- DriveCrank();`
	`33`	`+ RotateCrank(Angle);`
`34`	`34`
`35`	`35`	`if (CheckTriggers())`
`36`	`36`	`{`
`37`	`37`	`Angle = triggerRecord;`
`38`		`- DriveCrank();`
	`38`	`+ RotateCrank(Angle);`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`/// <summary>`
`43`	`43`	`/// Rotate crank.`
`44`	`44`	`/// </summary>`
`45`		`- protected void DriveCrank()`
	`45`	`+ /// <param name="angle">Current rotate angle of crank.</param>`
	`46`	`+ protected void RotateCrank(float angle)`
`46`	`47`	`{`
`47`		`- transform.localRotation = Quaternion.Euler(StartAngles + new Vector3(0, 0, Angle));`
	`48`	`+ transform.localRotation = Quaternion.Euler(StartAngles + new Vector3(0, 0, angle));`
`48`	`49`	`DriveRockers();`
`49`	`50`	`}`
`50`	`51`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -36,17 +36,17 @@ public class GearCrank : FreeCrank`
`36`	`36`	`protected override void DriveCrank(float velocity, DriveType type = DriveType.Ignore)`
`37`	`37`	`{`
`38`	`38`	`triggerRecord = Angle;`
`39`		`-`
`40`	`39`	`if (type == DriveType.Linear)`
	`40`	`+ {`
`41`	`41`	`velocity *= Mathf.Rad2Deg / radius;`
`42`		`-`
	`42`	`+ }`
`43`	`43`	`Angle += velocity * Time.deltaTime;`
`44`		`- DriveCrank();`
	`44`	`+ RotateCrank(Angle);`
`45`	`45`
`46`	`46`	`if (CheckTriggers())`
`47`	`47`	`{`
`48`	`48`	`Angle = triggerRecord;`
`49`		`- DriveCrank();`
	`49`	`+ RotateCrank(Angle);`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -38,12 +38,12 @@ protected override void DriveCrank(float velocity, DriveType type = DriveType.Ig`
`38`	`38`	`triggerRecord = Angle;`
`39`	`39`	`Angle += velocity * Time.deltaTime;`
`40`	`40`	`Angle = Mathf.Clamp(Angle, range.min, range.max);`
`41`		`- DriveCrank();`
	`41`	`+ RotateCrank(Angle);`
`42`	`42`
`43`	`43`	`if (CheckTriggers())`
`44`	`44`	`{`
`45`	`45`	`Angle = triggerRecord;`
`46`		`- DriveCrank();`
	`46`	`+ RotateCrank(Angle);`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,9 @@ protected bool CheckTriggers()`
`113`	`113`	`foreach (var trigger in triggers)`
`114`	`114`	`{`
`115`	`115`	`if (trigger.IsTriggered)`
	`116`	`+ {`
`116`	`117`	`return true;`
	`118`	`+ }`
`117`	`119`	`}`
`118`	`120`	`return false;`
`119`	`121`	`}`
`@@ -141,7 +143,9 @@ public override void Initialize()`
`141`	`143`	`{`
`142`	`144`	`var trigger = rocker.GetComponent<TriggerMechanism>();`
`143`	`145`	`if (trigger)`
	`146`	`+ {`
`144`	`147`	`triggers.Add(trigger);`
	`148`	`+ }`
`145`	`149`	`}`
`146`	`150`	`}`
`147`	`151`	`#endregion`
`@@ -244,14 +248,18 @@ public abstract class CrankLinkMechanism : Mechanism`
`244`	`248`	`protected override void Awake()`
`245`	`249`	`{`
`246`	`250`	`if (IsIntact)`
	`251`	`+ {`
`247`	`252`	`Initialize();`
	`253`	`+ }`
`248`	`254`	`}`
`249`	`255`
`250`	`256`	`#if UNITY_EDITOR`
`251`	`257`	`protected virtual void Update()`
`252`	`258`	`{`
`253`	`259`	`if (Application.isPlaying)`
	`260`	`+ {`
`254`	`261`	`return;`
	`262`	`+ }`
`255`	`263`
`256`	`264`	`if (IsIntact)`
`257`	`265`	`{`
`@@ -263,7 +271,9 @@ protected virtual void Update()`
`263`	`271`	`DriveLinkJoints();`
`264`	`272`	`}`
`265`	`273`	`else`
	`274`	`+ {`
`266`	`275`	`isInitialized = false;`
	`276`	`+ }`
`267`	`277`	`}`
`268`	`278`	`#endif`
`269`	`279`	`/// <summary>`
`@@ -322,13 +332,17 @@ public override void Drive(float velocity, DriveType type)`
`322`	`332`	`if (velocity >= 0)`
`323`	`333`	`{`
`324`	`334`	`if (IsLock && isPositive)`
	`335`	`+ {`
`325`	`336`	`return;`
	`337`	`+ }`
`326`	`338`	`isPositive = true;`
`327`	`339`	`}`
`328`	`340`	`else`
`329`	`341`	`{`
`330`	`342`	`if (IsLock && !isPositive)`
	`343`	`+ {`
`331`	`344`	`return;`
	`345`	`+ }`
`332`	`346`	`isPositive = false;`
`333`	`347`	`}`
`334`	`348`	`crank.Drive(velocity, type);`
`@@ -354,7 +368,9 @@ public abstract class RockerMechanism : Mechanism`
`354`	`368`	`protected virtual void Update()`
`355`	`369`	`{`
`356`	`370`	`if (!Application.isPlaying && joint)`
	`371`	`+ {`
`357`	`372`	`Drive(0, DriveType.Ignore);`
	`373`	`+ }`
`358`	`374`	`}`
`359`	`375`	`#endif`
`360`	`376`	`#endregion`
`@@ -392,12 +408,16 @@ public TelescopicState State`
`392`	`408`	`{`
`393`	`409`	`get`
`394`	`410`	`{`
	`411`	`+ var state = TelescopicState.Between;`
`395`	`412`	`if (Displacement <= stroke.min)`
`396`		`- return TelescopicState.Minimum;`
	`413`	`+ {`
	`414`	`+ state = TelescopicState.Minimum;`
	`415`	`+ }`
`397`	`416`	`else if (Displacement >= stroke.max)`
`398`		`- return TelescopicState.Maximum;`
`399`		`- else`
`400`		`- return TelescopicState.Between;`
	`417`	`+ {`
	`418`	`+ state = TelescopicState.Maximum;`
	`419`	`+ }`
	`420`	`+ return state;`
`401`	`421`	`}`
`402`	`422`	`}`
`403`	`423`
Original file line number	Diff line number	Diff line change
`@@ -28,10 +28,12 @@ protected Vector3 Aixs`
`28`	`28`	`{`
`29`	`29`	`get`
`30`	`30`	`{`
	`31`	`+ var axis = transform.forward;`
`31`	`32`	`if (transform.parent)`
`32`		`- return transform.parent.InverseTransformDirection(transform.forward);`
`33`		`- else`
`34`		`- return transform.forward;`
	`33`	`+ {`
	`34`	`+ axis = transform.parent.InverseTransformDirection(axis);`
	`35`	`+ }`
	`36`	`+ return axis;`
`35`	`37`	`}`
`36`	`38`	`}`
`37`	`39`	`#endregion`
`@@ -46,21 +48,22 @@ protected override void DriveSlider(float velocity)`
`46`	`48`	`triggerRecord = Displacement;`
`47`	`49`	`Displacement += velocity * Time.deltaTime;`
`48`	`50`	`Displacement = Mathf.Clamp(Displacement, stroke.min, stroke.max);`
`49`		`- DriveSlider();`
	`51`	`+ MoveSlider(Displacement);`
`50`	`52`
`51`	`53`	`if (CheckTriggers())`
`52`	`54`	`{`
`53`	`55`	`Displacement = triggerRecord;`
`54`		`- DriveSlider();`
	`56`	`+ MoveSlider(Displacement);`
`55`	`57`	`}`
`56`	`58`	`}`
`57`	`59`
`58`	`60`	`/// <summary>`
`59`	`61`	`/// Move slider.`
`60`	`62`	`/// </summary>`
`61`		`- protected virtual void DriveSlider()`
	`63`	`+ /// <param name="displacement">Displacement of slider.</param>`
	`64`	`+ protected void MoveSlider(float displacement)`
`62`	`65`	`{`
`63`		`- transform.localPosition = StartPosition + Aixs * Displacement;`
	`66`	`+ transform.localPosition = StartPosition + Aixs * displacement;`
`64`	`67`	`DriveRockers();`
`65`	`68`	`}`
`66`	`69`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -37,18 +37,20 @@ public override void Drive(float velocity, DriveType type = DriveType.Ignore)`
`37`	`37`	`{`
`38`	`38`	`var currentJoint = sliders[sliderIndex];`
`39`	`39`	`currentJoint.Drive(velocity, DriveType.Ignore);`
`40`		`-`
`41`	`40`	`if (velocity >= 0)`
`42`	`41`	`{`
`43`	`42`	`if (currentJoint.State == TelescopicState.Maximum)`
	`43`	`+ {`
`44`	`44`	`sliderIndex++;`
	`45`	`+ }`
`45`	`46`	`}`
`46`	`47`	`else`
`47`	`48`	`{`
`48`	`49`	`if (currentJoint.State == TelescopicState.Minimum)`
	`50`	`+ {`
`49`	`51`	`sliderIndex--;`
	`52`	`+ }`
`50`	`53`	`}`
`51`		`-`
`52`	`54`	`sliderIndex = ClampIndex(sliderIndex);`
`53`	`55`	`}`
`54`	`56`	`#endregion`