void Update()
        {
            if (ADJUST_LOOK.GetKeyDown())
            {
                adjustLook = true;
            }
            if (ADJUST_LOOK.GetKeyUp())
            {
                adjustLook = false;
            }


            if (InternalCamera.Instance != null && InternalCamera.Instance.isActive)  //checking if camera is IVA
            {
                if (!isIVA)
                {
                    isIVA = true;
                }
            }
            else
            {
                if (isIVA)
                {
                    isIVA = false;
                }
            }

            #region Chase(locked) mode
            if (FlightCamera.fetch.mode == FlightCamera.Modes.LOCKED && !MapView.MapIsEnabled && !FlightGlobals.ActiveVessel.isEVA)
            {
                Vector3 lookVector = Quaternion.Inverse(FlightGlobals.ActiveVessel.transform.rotation) * FlightGlobals.ActiveVessel.GetSrfVelocity();
                //lookvector X is left/right velocity, Y is forward velocity, Z is up/down velocity

                Vector3    forwardVector = new Vector3(0f, 1f, 0f);
                Quaternion pitchAngleQ   = Quaternion.FromToRotation(forwardVector, lookVector);
                //float lerpRate = Mathf.Clamp((float) FlightGlobals.ActiveVessel.srf_velocity.magnitude / 50f, 0f, 1f);
                float lerpRate;
                if (Time.time - timeCheck < 2)
                {
                    lerpRate = 0.1f;
                }
                else
                {
                    lerpRate = 1;
                }

                if (adjustLook)
                {
                    snapHeading = FlightCamera.fetch.camHdg - (0 - pitchAngleQ.Roll());
                    snapPitch   = FlightCamera.fetch.camPitch - (0 + pitchAngleQ.Pitch());
                }

                if (defaultOn && defaultFiredMode != "CHASE")
                {
                    enableChase      = true;
                    defaultFiredMode = "CHASE";

                    ScreenMessages.RemoveMessage(chaseOn);
                    ScreenMessages.RemoveMessage(chaseOff);
                    ScreenMessages.RemoveMessage(freeChaseOn);
                    ScreenMessages.RemoveMessage(freeChaseOff);

                    ScreenMessages.PostScreenMessage(chaseOn);
                    timeCheck   = Time.time;
                    snapHeading = 0;
                    snapPitch   = defaultAngle * Mathf.Deg2Rad;
                    //FlightCamera.fetch.SetFoV(setFov);
                }

                if (ENABLE_CHASE.GetKeyDown())
                {
                    if (enableChase)
                    {
                        ScreenMessages.RemoveMessage(chaseOn);
                        ScreenMessages.RemoveMessage(chaseOff);
                        ScreenMessages.RemoveMessage(freeChaseOn);
                        ScreenMessages.RemoveMessage(freeChaseOff);

                        ScreenMessages.PostScreenMessage(chaseOff);
                        FlightCamera.fetch.SetFoV(FlightCamera.fetch.fovDefault);
                    }
                    if (!enableChase)
                    {
                        ScreenMessages.RemoveMessage(chaseOn);
                        ScreenMessages.RemoveMessage(chaseOff);
                        ScreenMessages.RemoveMessage(freeChaseOn);
                        ScreenMessages.RemoveMessage(freeChaseOff);

                        ScreenMessages.PostScreenMessage(chaseOn);
                        timeCheck   = Time.time;
                        snapHeading = 0;
                        snapPitch   = defaultAngle * Mathf.Deg2Rad;
                        //FlightCamera.fetch.SetFoV(setFov);
                    }
                    enableChase = !enableChase;
                }

                if (enableChase && FlightGlobals.ActiveVessel != null && !adjustLook) //runs continuously while in chase cam on an active vessel when not adjusting look angle
                {
                    if (FlightGlobals.ActiveVessel.srf_velocity.magnitude > 0.5)
                    {
                        targetPitch = (0 + pitchAngleQ.Pitch() + snapPitch);
                        FlightCamera.fetch.camPitch = Mathf.Lerp(FlightCamera.fetch.camPitch, targetPitch, lerpRate);
                        targetHeading             = (0 - pitchAngleQ.Roll() + snapHeading);
                        FlightCamera.fetch.camHdg = Mathf.Lerp(FlightCamera.fetch.camHdg, targetHeading, lerpRate);
                    }
                }
            }
            if (FlightCamera.fetch.mode != FlightCamera.Modes.LOCKED && enableChase) //runs once on switching out of chase cam
            {
                //setCam = false;
                enableChase = false;
            }
            #endregion



            #region Free chase mode
            if (FlightCamera.fetch.mode == FlightCamera.Modes.FREE && !MapView.MapIsEnabled && !FlightGlobals.ActiveVessel.isEVA)
            {
                Vessel     v           = FlightGlobals.ActiveVessel;
                Quaternion vesselRot   = getSrfRotation(v);
                float      headingRads = vesselRot.eulerAngles.y * Mathf.Deg2Rad;
                float      pitchRads   = ((vesselRot.eulerAngles.x > 180f) ? (360.0f - vesselRot.eulerAngles.x) : -vesselRot.eulerAngles.x) * Mathf.Deg2Rad; //cred to r4m0n
                float      rollDegrees = ((vesselRot.eulerAngles.z > 180f) ? (vesselRot.eulerAngles.z - 360.0f) : vesselRot.eulerAngles.z);

                Vector3 lookVector = Quaternion.Inverse(FlightGlobals.ActiveVessel.transform.rotation) * FlightGlobals.ActiveVessel.GetSrfVelocity();
                //lookvector X is left/right velocity, Y is forward velocity, Z is up/down velocity
                Vector3    forwardVector = new Vector3(0f, 1f, 0f);
                Quaternion rollAdjust    = Quaternion.AngleAxis(rollDegrees, forwardVector);
                lookVector = rollAdjust * lookVector;

                Quaternion viewAngleQ = Quaternion.FromToRotation(forwardVector, lookVector);



                if (defaultOn && defaultFiredMode != "FREE")
                {
                    enableFreeChase  = true;
                    defaultFiredMode = "FREE";

                    ScreenMessages.RemoveMessage(chaseOn);
                    ScreenMessages.RemoveMessage(chaseOff);
                    ScreenMessages.RemoveMessage(freeChaseOn);
                    ScreenMessages.RemoveMessage(freeChaseOff);

                    ScreenMessages.PostScreenMessage(freeChaseOn);
                    snapHeading = 0;
                    snapPitch   = defaultAngle * Mathf.Deg2Rad;
                    //FlightCamera.fetch.SetFoV(setFov);
                    timeCheck = Time.time;
                }

                if (ENABLE_CHASE.GetKeyDown())
                {
                    if (enableFreeChase)
                    {
                        ScreenMessages.RemoveMessage(chaseOn);
                        ScreenMessages.RemoveMessage(chaseOff);
                        ScreenMessages.RemoveMessage(freeChaseOn);
                        ScreenMessages.RemoveMessage(freeChaseOff);

                        ScreenMessages.PostScreenMessage(freeChaseOff);
                        FlightCamera.fetch.SetFoV(FlightCamera.fetch.fovDefault);
                    }
                    if (!enableFreeChase)
                    {
                        ScreenMessages.RemoveMessage(chaseOn);
                        ScreenMessages.RemoveMessage(chaseOff);
                        ScreenMessages.RemoveMessage(freeChaseOn);
                        ScreenMessages.RemoveMessage(freeChaseOff);

                        ScreenMessages.PostScreenMessage(freeChaseOn);
                        snapHeading = 0;
                        snapPitch   = defaultAngle * Mathf.Deg2Rad;
                        //FlightCamera.fetch.SetFoV(setFov);
                        timeCheck = Time.time;
                    }
                    enableFreeChase = !enableFreeChase;
                }


                if (adjustLook)
                {
                    if (!autoSnap)
                    {
                        if (!vtolMode)
                        {
                            snapPitch   = FlightCamera.fetch.camPitch - (0 - pitchRads + (1f * viewAngleQ.Pitch())); //adjusted
                            snapHeading = FlightCamera.fetch.camHdg - (headingRads - (1f * viewAngleQ.Roll()));      //adjusted
                        }
                        else
                        {
                            snapPitch   = FlightCamera.fetch.camPitch - (0 + Mathf.Clamp(viewAngleQ.Pitch() / 10, 0, 90f));
                            snapHeading = FlightCamera.fetch.camHdg - (headingRads - (viewAngleQ.Roll() / 10));
                        }
                        if (Mathf.Abs(snapHeading) < 5 * Mathf.Deg2Rad)  //snap heading straight if close enough
                        {
                            snapHeading = 0;
                        }
                    }
                    else
                    {
                        snapHeading = 0;
                        snapPitch   = defaultAngle * Mathf.Deg2Rad;
                        timeCheck   = Time.time;
                    }
                }

                float lerpRate;
                if (Time.time - timeCheck < 1 || v.srfSpeed < 90)
                {
                    lerpRate = 0.1f;
                }
                else
                {
                    lerpRate = 1;
                }

                if (enableFreeChase && FlightGlobals.ActiveVessel != null && !adjustLook)
                {
                    if (FlightGlobals.ActiveVessel.srf_velocity.magnitude > 0.5)
                    {
                        if (lookVector.y < 35 && FlightGlobals.ActiveVessel.srfSpeed < 50)//vtol mode when fwd velocity is less than 50m/s
                        {
                            if (!vtolMode)
                            {
                                vtolMode = true;
                            }
                            lerpRate = 0.1f;
                            FlightCamera.fetch.camPitch = Mathf.LerpAngle(FlightCamera.fetch.camPitch, (0 + Mathf.Clamp(viewAngleQ.Pitch() / 10, 0, 90f) + snapPitch), lerpRate);
                            FlightCamera.fetch.camHdg   = (Mathf.LerpAngle(FlightCamera.fetch.camHdg * Mathf.Rad2Deg, ((headingRads - (viewAngleQ.Roll() / 10) + snapHeading) * Mathf.Rad2Deg), lerpRate)) * Mathf.Deg2Rad;
                        }
                        else
                        {
                            if (vtolMode)
                            {
                                vtolMode = false;
                            }
                            FlightCamera.fetch.camPitch = Mathf.LerpAngle(FlightCamera.fetch.camPitch, 0 - pitchRads + viewAngleQ.Pitch() + snapPitch, lerpRate);  //doesn't really need to be LerpAngle unless converted to degrees.
                            FlightCamera.fetch.camHdg   = (Mathf.LerpAngle(FlightCamera.fetch.camHdg * Mathf.Rad2Deg, (headingRads - viewAngleQ.Roll() + snapHeading) * Mathf.Rad2Deg, lerpRate)) * Mathf.Deg2Rad;
                        }
                    }
                }
            }



            if (FlightCamera.fetch.mode != FlightCamera.Modes.FREE && enableFreeChase)
            {
                enableFreeChase = false;
            }
            #endregion

            if (FlightCamera.fetch.mode == FlightCamera.Modes.AUTO)
            {
                if (disableAuto)
                {
                    FlightCamera.fetch.setMode(FlightCamera.GetAutoModeForVessel(FlightGlobals.ActiveVessel));
                    if (defaultOn && FlightCamera.fetch.mode == FlightCamera.Modes.FREE)
                    {
                        enableFreeChase = true;
                    }
                    snapHeading = 0;
                    snapPitch   = defaultAngle * Mathf.Deg2Rad;
                }



                if (defaultFiredMode != "AUTO")
                {
                    ScreenMessages.RemoveMessage(chaseOn);
                    ScreenMessages.RemoveMessage(chaseOff);
                    ScreenMessages.RemoveMessage(freeChaseOn);
                    ScreenMessages.RemoveMessage(freeChaseOff);
                }
            }

            #region IVA

            /*
             *          if(isIVA && !MapView.MapIsEnabled)
             *          {
             *                  if(enableIVASnap)
             *                  {
             *                          adjustLookIVA = InternalCamera.Instance.mouseLocked;
             *                          if(adjustLookIVA)
             *                          {
             *                                  if(SET_IVA_SNAP.GetKeyDown())
             *                                  {
             *                                          snapIVARotation = InternalCamera.Instance.camera.transform.localRotation;
             *                                  }
             *                                  if(ADJUST_LOOK.GetKeyUp())
             *                                  {
             *                                          InternalCamera.Instance.UnlockMouse();
             *                                  }
             *                          }
             *                          else
             *                          {
             *                                  InternalCamera.Instance.camera.transform.localRotation = snapIVARotation;
             *                          }
             *                  }
             *          }
             */
            #endregion
        }
예제 #2
0
        public override void OnUpdate()
        {
            // Do nothing unless this KerbalEVA is the active vessel in flight, in vessel view, and positioned to enter an airlock
            if (tgtAirlockPart == null || !HighLogic.LoadedSceneIsFlight || !vessel.isActiveVessel || inMap)
            {
                return;
            }

            // HACK: re-enable KerbalEVA one frame after blocking stock boarding from registering alongside auto boarding
            if (autoBoardingFull)
            {
                keva.enabled     = true;
                autoBoardingFull = false;
            }

            if (manualBoarding)
            {
                // Not checking for input locks in here, we should be holding the lock on all but camera controls at this juncture

                // Use GetKeyUp instead of GetKey/GetKeyDown prevents triggering game pause immediately upon releasing input lock
                if (Input.GetKeyUp(KeyCode.Escape))
                {
                    BoardManualCxl();
                    return;
                }

                if (lastHovered != Mouse.HoveredPart)
                {
                    if (lastHovered != null && highlightParts.ContainsKey(lastHovered.flightID))
                    {
                        lastHovered.highlighter.ConstantOnImmediate(SpaceAvail(lastHovered) ? COLOR_AVAIL : COLOR_FULL);
                    }
                    lastHovered = Mouse.HoveredPart;
                    if (lastHovered != null && highlightParts.ContainsKey(lastHovered.flightID))
                    {
                        lastHovered.highlighter.ConstantOnImmediate(SpaceAvail(lastHovered) ? COLOR_AVAIL_OVR : COLOR_FULL_OVR);
                    }
                }

                if (Mouse.CheckButtons(Mouse.GetAllMouseButtonsDown(), Mouse.Buttons.Left) && lastHovered != null)
                {
                    BoardManualSel();
                }
            }
            else
            {
                if (Input.GetKey(KeyCode.LeftShift) && boardkey.GetKeyUp())
                {
                    if (InputLockManager.IsAllLocked(ControlTypes.KEYBOARDINPUT))
                    {
                        Debug.Log("[AirlockPlus|BoardingPass] INFO: shift+board detected, but input lock is active.");
                        Debug.Log(InputLockManager.PrintLockStack());
                    }
                    else
                    {
                        _BoardAuto();
                    }
                }
                if (Input.GetKey(KeyCode.LeftControl) && boardkey.GetKeyUp())
                {
                    if (InputLockManager.IsAllLocked(ControlTypes.KEYBOARDINPUT))
                    {
                        Debug.Log("[AirlockPlus|BoardingPass] INFO: ctrl+board detected, but input lock is active.");
                        Debug.Log(InputLockManager.PrintLockStack());
                    }
                    else
                    {
                        BoardManual();
                    }
                }
            }
        }