Fix #759 (Request: possibility to only set roll / pitch / heading - not all at once)

KSP-TaxiService · KSP-TaxiService · commit 27e7ecd3dc97 · 2020-08-01T22:58:56.000+08:00
diff --git a/GameData/RemoteTech/Localization/en-us.cfg b/GameData/RemoteTech/Localization/en-us.cfg
@@ -293,12 +293,18 @@ Localization
         #RT_AttitudeFragment_RadialMinus_desc = Orient to Anti-radial.
         #RT_AttitudeFragment_NormalMinus = NRM\n-
         #RT_AttitudeFragment_NormalMinus_desc = Orient to Anti-normal.
-        #RT_AttitudeFragment_PIT = PIT:
+        #RT_AttitudeFragment_PIT = PIT
         #RT_AttitudeFragment_PIT_desc = Sets pitch.
-        #RT_AttitudeFragment_HDG = HDG:
+        #RT_AttitudeFragment_HDG = HDG
         #RT_AttitudeFragment_HDG_desc = Sets heading.
-        #RT_AttitudeFragment_RLL = RLL:
+        #RT_AttitudeFragment_RLL = RLL
         #RT_AttitudeFragment_RLL_desc = Sets roll.
+        #RT_AttitudeFragment_IgnorePit = IGN\nPIT
+        #RT_AttitudeFragment_IgnorePit_desc = Ignore pitch control.
+        #RT_AttitudeFragment_IgnoreHdr = IGN\nHDR
+        #RT_AttitudeFragment_IgnoreHdr_desc = Ignore heading control.
+        #RT_AttitudeFragment_IgnoreRll = IGN\nRLL
+        #RT_AttitudeFragment_IgnoreRll_desc = Ignore roll control.
         #RT_AttitudeFragment_Throttle = Throttle:
         #RT_AttitudeFragment_BURN = BURN
         #RT_AttitudeFragment_BURN_desc = Example: 125, 125s, 5m20s, 1d6h20m10s, 123m/s.
diff --git a/GameData/RemoteTech/Localization/zh-cn.cfg b/GameData/RemoteTech/Localization/zh-cn.cfg
@@ -292,12 +292,18 @@ Localization
         #RT_AttitudeFragment_RadialMinus_desc = 朝向径向向下.
         #RT_AttitudeFragment_NormalMinus = 反法向
         #RT_AttitudeFragment_NormalMinus_desc = 朝向反法线方向.
-        #RT_AttitudeFragment_PIT = PIT:
+        #RT_AttitudeFragment_PIT = PIT
         #RT_AttitudeFragment_PIT_desc = 设定俯仰角.
-        #RT_AttitudeFragment_HDG = HDG:
+        #RT_AttitudeFragment_HDG = HDG
         #RT_AttitudeFragment_HDG_desc = 设定偏航角.
-        #RT_AttitudeFragment_RLL = RLL:
+        #RT_AttitudeFragment_RLL = RLL
         #RT_AttitudeFragment_RLL_desc = 设定滚转角.
+        #RT_AttitudeFragment_IgnorePit = IGN\nPIT
+        #RT_AttitudeFragment_IgnorePit_desc = Ignore pitch control.
+        #RT_AttitudeFragment_IgnoreHdr = IGN\nHDR
+        #RT_AttitudeFragment_IgnoreHdr_desc = Ignore heading control.
+        #RT_AttitudeFragment_IgnoreRll = IGN\nRLL
+        #RT_AttitudeFragment_IgnoreRll_desc = Ignore roll control.
         #RT_AttitudeFragment_Throttle = 节流阀:
         #RT_AttitudeFragment_BURN = 点火
         #RT_AttitudeFragment_BURN_desc = 例如: 125, 125s, 5m20s, 1d6h20m10s, 123m/s.
diff --git a/src/RemoteTech/FlightComputer/Commands/AbstractCommand.cs b/src/RemoteTech/FlightComputer/Commands/AbstractCommand.cs
@@ -129,6 +129,7 @@ public static ICommand LoadCommand(ConfigNode n, FlightComputer fc)
                 case "HibernationCommand":    { command = new HibernationCommand(); break; }
                 case "AxisGroupCommand":      { command = new AxisGroupCommand(); break; }
                 case "PIDCommand":            { command = new PIDCommand(); break; }
+                case "FlightControlCommand":  { command = new FlightControlCommand(); break; }
             }
 
             if (command != null)
diff --git a/src/RemoteTech/FlightComputer/Commands/FlightControlCommand.cs b/src/RemoteTech/FlightComputer/Commands/FlightControlCommand.cs
@@ -0,0 +1,100 @@
+﻿using System;
+
+namespace RemoteTech.FlightComputer.Commands
+{
+    public class FlightControlCommand : AbstractCommand
+    {
+        [Persistent] public bool ignorePitchOutput;
+        [Persistent] public bool ignoreHeadingOutput;
+        [Persistent] public bool ignoreRollOutput;
+
+        private bool mAbort;
+        private string stringReady = "";
+
+        public override string ShortName
+        {
+            get
+            {
+                return "Pitch, Heading and Roll controls";
+            }
+        }
+
+        public override string Description
+        {
+            get
+            {
+                return ShortName + ":" + Environment.NewLine + stringReady + base.Description;
+            }
+        }
+
+        public static FlightControlCommand WithPHR(bool ignore_pitch, bool ignore_heading, bool ignore_roll)
+        {
+            return new FlightControlCommand()
+            {
+                ignorePitchOutput = ignore_pitch,
+                ignoreHeadingOutput = ignore_heading,
+                ignoreRollOutput = ignore_roll,
+                TimeStamp = RTUtil.GameTime,
+            };
+        }
+
+        public override bool Pop(FlightComputer fc)
+        {
+            if (fc != null)
+            {
+                //remove active command if existing
+                var activeCommand = FlightControlCommand.findActiveControlCmd(fc);
+                if(activeCommand != null && activeCommand.CmdGuid != this.CmdGuid)
+                {
+                    activeCommand.Abort();
+                }
+
+                //build custom string
+                var list = new string[3];
+                var count = 0;
+                if (ignorePitchOutput) { list[count++] = "Pitch ignored"; }
+                if (ignoreHeadingOutput) { list[count++] = "Heading ignored"; }
+                if (ignoreRollOutput) { list[count++] = "Roll ignored"; }
+
+                for(int i=0; i<count;i++)
+                {
+                    stringReady += list[i];
+                    if (i < count -1) { stringReady += ", "; }
+                }
+                if (stringReady.Length > 0) { stringReady += Environment.NewLine; }
+
+                return true;
+            }
+            return false;
+        }
+
+        public override bool Execute(FlightComputer fc, FlightCtrlState ctrlState)
+        {
+            SteeringHelper.FlightOutputControlMask = 0; //blank off
+
+            if (mAbort || (!ignorePitchOutput && !ignoreHeadingOutput && !ignoreRollOutput)) { return true; }
+
+            if (ignorePitchOutput) { SteeringHelper.FlightOutputControlMask |= SteeringHelper.FlightControlOutput.IgnorePitch; }
+            if (ignoreHeadingOutput) { SteeringHelper.FlightOutputControlMask |= SteeringHelper.FlightControlOutput.IgnoreHeading; }
+            if (ignoreRollOutput) { SteeringHelper.FlightOutputControlMask |= SteeringHelper.FlightControlOutput.IgnoreRoll; }
+
+            return false;
+        }
+
+        public static FlightControlCommand findActiveControlCmd(FlightComputer fc)
+        {
+            var cmdItr = fc.ActiveCommands.GetEnumerator();
+            while (cmdItr.MoveNext())
+            {
+                if (cmdItr.Current is FlightControlCommand)
+                {
+                    return cmdItr.Current as FlightControlCommand;
+                }
+            }
+
+            return null;
+        }
+
+        public override void Abort() { mAbort = true; }
+    }
+}
diff --git a/src/RemoteTech/FlightComputer/FlightCore.cs b/src/RemoteTech/FlightComputer/FlightCore.cs
@@ -123,10 +123,10 @@ public static void HoldAttitude(FlightCtrlState fs, FlightComputer f, ReferenceF
         /// <summary>
         /// Single entry point of all Flight Computer orientation holding, including maneuver node.
         /// </summary>
-        public static void HoldOrientation(FlightCtrlState fs, FlightComputer f, Quaternion target, bool ignoreRoll = false)
+        public static void HoldOrientation(FlightCtrlState fs, FlightComputer f, Quaternion target, bool ignoreRoll = false, bool ignorePitch = false, bool ignoreHeading = false)
         {
             f.Vessel.ActionGroups.SetGroup(KSPActionGroup.SAS, false);
-            SteeringHelper.SteerShipToward(target, fs, f, ignoreRoll);
+            SteeringHelper.SteerShipToward(target, fs, f, ignoreRoll, ignorePitch, ignoreHeading);
         }
 
         /// <summary>
@@ -176,9 +176,23 @@ public static double GetTotalThrust(Vessel v)
 
     public static class SteeringHelper
     {
+        public enum FlightControlOutput
+        {
+            IgnorePitch = 1,
+            IgnoreHeading = 2,
+            IgnoreRoll = 4,
+        }
+
         private const double outputDeadband = 0.001;
         private const float driveLimit = 1.0f;
 
+        private static FlightControlOutput outputControlMask = 0;
+        public static FlightControlOutput FlightOutputControlMask
+        {
+            get { return outputControlMask; }
+            set { outputControlMask = value; }
+        }
+
         /* MechJeb2 torque variables */
         private static Vector6 torqueReactionWheel = new Vector6();
         private static Vector6 torqueGimbal = new Vector6();
@@ -206,7 +220,7 @@ public static Vector3d TorqueReactionSpeed
         /// <param name="c">The FlightCtrlState for the current vessel.</param>
         /// <param name="fc">The flight computer carrying out the slew</param>
         /// <param name="ignoreRoll">[optional] to ignore the roll</param>
-        public static void SteerShipToward(Quaternion target, FlightCtrlState c, FlightComputer fc, bool ignoreRoll)
+        public static void SteerShipToward(Quaternion target, FlightCtrlState c, FlightComputer fc, bool ignoreRoll, bool ignorePitch, bool ignoreHeading)
         {
             var actuation = fc.PIDController.GetActuation(target);
 
@@ -216,9 +230,9 @@ public static void SteerShipToward(Quaternion target, FlightCtrlState c, FlightC
             actuation.z = Math.Abs(actuation.z) >= outputDeadband ? actuation.z : 0.0;
 
             // update the flight controls
-            c.pitch = Mathf.Clamp((float) actuation.x, -driveLimit, driveLimit);
-            c.roll = !ignoreRoll ? Mathf.Clamp((float) actuation.y, -driveLimit, driveLimit) : 0.0f;
-            c.yaw = Mathf.Clamp((float) actuation.z, -driveLimit, driveLimit);
+            c.pitch = (ignorePitch || (FlightOutputControlMask & FlightControlOutput.IgnorePitch) == FlightControlOutput.IgnorePitch) ? 0.0f : Mathf.Clamp((float) actuation.x, -driveLimit, driveLimit);
+            c.roll = (ignoreRoll || (FlightOutputControlMask & FlightControlOutput.IgnoreRoll) == FlightControlOutput.IgnoreRoll) ? 0.0f : Mathf.Clamp((float) actuation.y, -driveLimit, driveLimit);
+            c.yaw = (ignoreHeading || (FlightOutputControlMask & FlightControlOutput.IgnoreHeading) == FlightControlOutput.IgnoreHeading) ? 0.0f : Mathf.Clamp((float) actuation.z, -driveLimit, driveLimit);
         }
 
         /// <summary>
diff --git a/src/RemoteTech/RemoteTech.csproj b/src/RemoteTech/RemoteTech.csproj
@@ -120,6 +120,7 @@
     <Compile Include="FlightComputer\Commands\CancelCommand.cs" />
     <Compile Include="FlightComputer\Commands\DriveCommand.cs" />
     <Compile Include="FlightComputer\Commands\HibernationCommand.cs" />
+    <Compile Include="FlightComputer\Commands\FlightControlCommand.cs" />
     <Compile Include="FlightComputer\Commands\ManeuverCommand.cs" />
     <Compile Include="FlightComputer\Commands\PartActionCommand.cs" />
     <Compile Include="FlightComputer\Commands\PIDCommand.cs" />
diff --git a/src/RemoteTech/UI/AttitudeFragment.cs b/src/RemoteTech/UI/AttitudeFragment.cs
@@ -3,6 +3,8 @@
 using RemoteTech.FlightComputer.Commands;
 using UnityEngine;
 using KSP.Localization;
+using static RemoteTech.FlightComputer.SteeringHelper;
+using RemoteTech.FlightComputer;
 
 namespace RemoteTech.UI
 {
@@ -82,14 +84,13 @@ private double DeltaV
             }
         }
 
-        private FlightAttitude Attitude { get { return mAttitude; } }
-
         private FlightComputer.FlightComputer mFlightComputer;
         private Action mOnClickQueue;
 
         private ComputerMode mMode;
         private FlightAttitude mAttitude;
         private float mThrottle;
+        private FlightControlOutput mControlOutputMask = 0;
 
         private String mPitch = "90";
         private String mRoll = "90";
@@ -190,6 +191,16 @@ public void Draw()
                     RTUtil.MouseWheelTriggerField(ref mRoll, "rt_phr3", () => { Roll++; }, () => { Roll--; }, GUILayout.Width(width3));
                 }
                 GUILayout.EndHorizontal();
+                GUILayout.Space(5);
+
+                GUILayout.BeginHorizontal();
+                {
+                    RTUtil.FakeStateButton(new GUIContent(Localizer.Format("#RT_AttitudeFragment_IgnorePit"), Localizer.Format("#RT_AttitudeFragment_IgnorePit_desc")), () => RTCore.Instance.StartCoroutine(OnControlClick(FlightControlOutput.IgnorePitch)), (int)(mControlOutputMask & FlightControlOutput.IgnorePitch), (int)FlightControlOutput.IgnorePitch, GUILayout.Width(width3));//"IGN\nPIT", "Ignore pitch control."
+                    RTUtil.FakeStateButton(new GUIContent(Localizer.Format("#RT_AttitudeFragment_IgnoreHdr"), Localizer.Format("#RT_AttitudeFragment_IgnoreHdr_desc")), () => RTCore.Instance.StartCoroutine(OnControlClick(FlightControlOutput.IgnoreHeading)), (int)(mControlOutputMask & FlightControlOutput.IgnoreHeading), (int)FlightControlOutput.IgnoreHeading, GUILayout.Width(width3));//"IGN\nHDR", "Ignore heading control."
+                    RTUtil.FakeStateButton(new GUIContent(Localizer.Format("#RT_AttitudeFragment_IgnoreRll"), Localizer.Format("#RT_AttitudeFragment_IgnoreRll_desc")), () => RTCore.Instance.StartCoroutine(OnControlClick(FlightControlOutput.IgnoreRoll)), (int)(mControlOutputMask & FlightControlOutput.IgnoreRoll), (int)FlightControlOutput.IgnoreRoll, GUILayout.Width(width3));//"IGN\nRLL", "Ignore roll control."
+                }
+                GUILayout.EndHorizontal();
+                GUILayout.Space(5);
 
                 GUILayout.BeginHorizontal();
                 {
@@ -243,6 +254,43 @@ private IEnumerator OnAttitudeClick(FlightAttitude state)
             }
         }
 
+        private IEnumerator OnControlClick(FlightControlOutput output)
+        {
+            yield return null;
+            if (mFlightComputer.InputAllowed)
+            {
+                switch(output)
+                {
+                    case FlightControlOutput.IgnorePitch:
+                        if ((mControlOutputMask & FlightControlOutput.IgnorePitch) == FlightControlOutput.IgnorePitch)
+                            mControlOutputMask &= ~FlightControlOutput.IgnorePitch;
+                        else
+                            mControlOutputMask |= FlightControlOutput.IgnorePitch;
+                        break;
+
+                    case FlightControlOutput.IgnoreHeading:
+                        if ((mControlOutputMask & FlightControlOutput.IgnoreHeading) == FlightControlOutput.IgnoreHeading)
+                            mControlOutputMask &= ~FlightControlOutput.IgnoreHeading;
+                        else
+                            mControlOutputMask |= FlightControlOutput.IgnoreHeading;
+                        break;
+
+                    case FlightControlOutput.IgnoreRoll:
+                        if ((mControlOutputMask & FlightControlOutput.IgnoreRoll) == FlightControlOutput.IgnoreRoll)
+                            mControlOutputMask &= ~FlightControlOutput.IgnoreRoll;
+                        else
+                            mControlOutputMask |= FlightControlOutput.IgnoreRoll;
+                        break;
+                }
+
+                bool pitch = (mControlOutputMask & FlightControlOutput.IgnorePitch) == FlightControlOutput.IgnorePitch,
+                     heading = (mControlOutputMask & FlightControlOutput.IgnoreHeading) == FlightControlOutput.IgnoreHeading,
+                     roll = (mControlOutputMask & FlightControlOutput.IgnoreRoll) == FlightControlOutput.IgnoreRoll;
+
+                mFlightComputer.Enqueue(FlightControlCommand.WithPHR(pitch, heading, roll));
+            }
+        }
+
         private void Confirm()
         {
             ICommand newCommand;
@@ -264,22 +312,22 @@ private void Confirm()
                 case ComputerMode.TargetPos:
                     mAttitude = (mAttitude == FlightAttitude.Null) ? FlightAttitude.Prograde : mAttitude;
                     newCommand =
-                        AttitudeCommand.WithAttitude(Attitude, ReferenceFrame.TargetParallel);
+                        AttitudeCommand.WithAttitude(mAttitude, ReferenceFrame.TargetParallel);
                     break;
                 case ComputerMode.Orbital:
                     mAttitude = (mAttitude == FlightAttitude.Null) ? FlightAttitude.Prograde : mAttitude;
                     newCommand =
-                        AttitudeCommand.WithAttitude(Attitude, ReferenceFrame.Orbit);
+                        AttitudeCommand.WithAttitude(mAttitude, ReferenceFrame.Orbit);
                     break;
                 case ComputerMode.Surface:
                     mAttitude = (mAttitude == FlightAttitude.Null) ? FlightAttitude.Prograde : mAttitude;
                     newCommand =
-                        AttitudeCommand.WithAttitude(Attitude, ReferenceFrame.Surface);
+                        AttitudeCommand.WithAttitude(mAttitude, ReferenceFrame.Surface);
                     break;
                 case ComputerMode.TargetVel:
                     mAttitude = (mAttitude == FlightAttitude.Null) ? FlightAttitude.Prograde : mAttitude;
                     newCommand =
-                        AttitudeCommand.WithAttitude(Attitude, ReferenceFrame.TargetVelocity);
+                        AttitudeCommand.WithAttitude(mAttitude, ReferenceFrame.TargetVelocity);
                     break;
                 case ComputerMode.Custom:
                     mAttitude = FlightAttitude.Null;
@@ -344,6 +392,15 @@ public void getActiveFlightMode()
 
             if(mMode == ComputerMode.Orbital || mMode == ComputerMode.Surface || mMode == ComputerMode.TargetPos || mMode == ComputerMode.TargetVel)
                 mAttitude = mappedCommand.computerAttitude;
+
+            var activeIgnoreCmd = FlightControlCommand.findActiveControlCmd(mFlightComputer);
+            if (activeIgnoreCmd != null)
+            {
+                mControlOutputMask = 0;
+                if (activeIgnoreCmd.ignorePitchOutput) { mControlOutputMask |= FlightControlOutput.IgnorePitch; }
+                if (activeIgnoreCmd.ignoreHeadingOutput) { mControlOutputMask |= FlightControlOutput.IgnoreHeading; }
+                if (activeIgnoreCmd.ignoreRollOutput) { mControlOutputMask |= FlightControlOutput.IgnoreRoll; }
+            }
         }
 
         /// <summary>
@@ -354,6 +411,7 @@ public void Reset()
             // get active command
             mMode = ComputerMode.Off;
             mAttitude = FlightAttitude.Null;
+            mControlOutputMask = 0;
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -129,6 +129,7 @@ public static ICommand LoadCommand(ConfigNode n, FlightComputer fc)`
`129`	`129`	`case "HibernationCommand": { command = new HibernationCommand(); break; }`
`130`	`130`	`case "AxisGroupCommand": { command = new AxisGroupCommand(); break; }`
`131`	`131`	`case "PIDCommand": { command = new PIDCommand(); break; }`
	`132`	`+ case "FlightControlCommand": { command = new FlightControlCommand(); break; }`
`132`	`133`	`}`
`133`	`134`
`134`	`135`	`if (command != null)`