public new void FixedUpdate()
        {
            base.FixedUpdate();

            if (IsRTBroken || !RTCore.Instance) {
                return;
            }

            switch (TrackingMode) {
                case TrackingModes.Tracking:
                    if (IsRTPowered) {
                        mPivot1.RotToTarget(new DynamicTarget(RTAntennaTargetGuid));
                        mPivot2.RotToTarget(new DynamicTarget(RTAntennaTargetGuid));
                    }
                    break;
                case TrackingModes.Extending:
                    if (!Animation.IsPlaying(AnimationName))
                        TrackingMode = TrackingModes.Tracking;
                    break;
                case TrackingModes.Retracting:
                    if (!Animation.IsPlaying(AnimationName))
                        TrackingMode = TrackingModes.Retracted;
                    break;
                case TrackingModes.Resetting:
                    if (IsRTPowered && mPivot1.RotToOrigin() & mPivot2.RotToOrigin()) {
                        TrackingMode = TrackingModes.Retracting;
                        base.SetState(false);
                    }
                    break;
            }
        }
示例#2
0
        public void SetMode1()
        {
            if (broken)
            {
                return;
            }

            if (mode == TrackingModes.RESETTING)
            {
                mode = TrackingModes.TRACKING;
            }
            else
            {
                anim[Animation].speed = Mathf.Abs(anim[Animation].speed);

                anim.Play(Animation);
                mode = TrackingModes.EXTENDING;

                if (anim[Animation].normalizedTime == 1)
                {
                    anim[Animation].normalizedTime = 0;
                }
            }
            animState = 1;

            if (this.MaximumDrag > 0)
            {
                part.minimum_drag = this.MinimumDrag + Dragmodifier;
                part.maximum_drag = this.MaximumDrag + Dragmodifier;
            }

            SetRange1();
        }
        public new void FixedUpdate()
        {
            base.FixedUpdate();

            if (IsRTBroken || !RTCore.Instance) {
                return;
            }

            switch (TrackingMode) {
                case TrackingModes.Tracking:
                    if (IsRTPowered) {
                        mPivot1.RotToTarget(new DynamicTarget(RTAntennaTargetGuid));
                        mPivot2.RotToTarget(new DynamicTarget(RTAntennaTargetGuid));
                    }
                    break;
                case TrackingModes.Extending:
                    if (!Animation.IsPlaying(AnimationName))
                        TrackingMode = TrackingModes.Tracking;
                    break;
                case TrackingModes.Retracting:
                    if (!Animation.IsPlaying(AnimationName))
                        TrackingMode = TrackingModes.Retracted;
                    break;
                case TrackingModes.Resetting:
                    if (IsRTPowered && mPivot1.RotToOrigin() & mPivot2.RotToOrigin()) {
                        Animation[AnimationName].speed = -Mathf.Abs(Animation[AnimationName].speed);
                        Animation.Play(AnimationName);
                        if (Animation[AnimationName].normalizedTime == 0) {
                            Animation[AnimationName].normalizedTime = 1;
                        }
                        TrackingMode = TrackingModes.Retracting;
                    }
                    break;
            }
        }
示例#4
0
        public override void OnStart(StartState state)
        {
            if (!String.IsNullOrEmpty(Pivot1Name) && !String.IsNullOrEmpty(Pivot2Name))
            {
                ForceTransform = part.FindModelTransform(Pivot2Name);
                BreakTransform = part.FindModelTransform(Pivot1Name);
            }
            else
            {
                RTUtil.Log("ModuleRTAntennaAnimated: Pivot error");
                enabled = false;
                return;
            }

            if (IsRTBroken)
            {
                TrackingMode = TrackingModes.Broken;
            }

            base.OnStart(state);

            if (RTCore.Instance != null)
            {
                mPivot1 = new Pivot(BreakTransform, Pivot1Speed, Pivot1Range);
                mPivot2 = new Pivot(ForceTransform, Pivot2Speed, Pivot2Range);

                if (IsRTActive)
                {
                    TrackingMode = TrackingModes.Tracking;
                    mPivot1.SnapToTarget(new DynamicTarget(RTAntennaTargetGuid));
                    mPivot2.SnapToTarget(new DynamicTarget(RTAntennaTargetGuid));
                }
            }
        }
        /// <summary>
        /// Sets the scope's current tracking mode.
        /// </summary>
        /// <param name="trackingMode"></param>
        public void SetTrackingMode(TrackingModes trackingMode)
        {
            _log.LogVerbose($"Setting scope tracking mode to {(int)trackingMode}.");

            string cmd = "T";
            string res = _helper.DoCommand(cmd + (int)trackingMode);
        }
示例#6
0
 public override void SetState(bool state)
 {
     if (IsRTActive)
     {
         if (AnimationOneShot)
         {
             return;
         }
         if (TrackingMode == TrackingModes.Tracking)
         {
             TrackingMode = TrackingModes.Resetting;
         }
         else
         {
             TrackingMode = TrackingModes.Retracting;
             base.SetState(state);
         }
     }
     else
     {
         if (TrackingMode == TrackingModes.Resetting)
         {
             TrackingMode = TrackingModes.Tracking;
         }
         else
         {
             TrackingMode = TrackingModes.Extending;
             base.SetState(state);
         }
     }
 }
示例#7
0
        public override void UpdateInteraction(FVRViveHand hand)
        {
            base.UpdateInteraction(hand);

            if (hand.Input.TouchpadDown && hand.Input.TouchpadAxes.magnitude > 0.25f && MeatTrak != null)
            {
                Vector2 touchpadAxes = hand.Input.TouchpadAxes;

                if (Vector2.Angle(hand.Input.TouchpadAxes, Vector2.up) <= 45f)
                {
                    if (m_waitingForConfirmation)
                    {
                        MeatTrak.NumberTarget = 0;

                        if (Aud_ClearComplete.Clips.Count > 0)
                        {
                            SM.PlayCoreSound(FVRPooledAudioType.UIChirp, Aud_ClearComplete, this.transform.position);
                        }
                    }
                    else
                    {
                        if (Aud_ClearRequestConfirmation.Clips.Count > 0)
                        {
                            SM.PlayCoreSound(FVRPooledAudioType.UIChirp, Aud_ClearRequestConfirmation, this.transform.position);
                        }
                    }

                    m_waitingForConfirmation = !m_waitingForConfirmation;
                }

                if (Vector2.Angle(hand.Input.TouchpadAxes, Vector2.left) <= 45f || Vector2.Angle(hand.Input.TouchpadAxes, Vector2.right) <= 45f)
                {
                    int direction = (int)Mathf.Sign(touchpadAxes.x);
                    TrackingMode = (TrackingModes)Mathf.Repeat((float)TrackingMode + direction, ModeSprites.Length);

                    UpdateMode();

                    if (Aud_ModeSwitch.Clips.Count > 0)
                    {
                        SM.PlayCoreSound(FVRPooledAudioType.UIChirp, Aud_ModeSwitch, this.transform.position);
                    }
                }
            }
        }
示例#8
0
        public void SetMode0()
        {
            if (broken)
            {
                return;
            }

            mode = TrackingModes.RESETTING;

            animState = 0;

            if (this.MaximumDrag > 0)
            {
                part.minimum_drag = this.MinimumDrag;
                part.maximum_drag = this.MaximumDrag;
            }

            SetRange0();
        }
示例#9
0
        public new void FixedUpdate()
        {
            base.FixedUpdate();

            if (IsRTBroken || !RTCore.Instance)
            {
                return;
            }

            switch (TrackingMode)
            {
            case TrackingModes.Tracking:
                if (IsRTPowered)
                {
                    mPivot1.RotToTarget(new DynamicTarget(RTAntennaTargetGuid));
                    mPivot2.RotToTarget(new DynamicTarget(RTAntennaTargetGuid));
                }
                break;

            case TrackingModes.Extending:
                if (!Animation.IsPlaying(AnimationName))
                {
                    TrackingMode = TrackingModes.Tracking;
                }
                break;

            case TrackingModes.Retracting:
                if (!Animation.IsPlaying(AnimationName))
                {
                    TrackingMode = TrackingModes.Retracted;
                }
                break;

            case TrackingModes.Resetting:
                if (IsRTPowered && mPivot1.RotToOrigin() & mPivot2.RotToOrigin())
                {
                    TrackingMode = TrackingModes.Retracting;
                    base.SetState(false);
                }
                break;
            }
        }
        public void SetMode1()
        {
            if (broken) return;

            if (mode == TrackingModes.RESETTING)
            {
                mode = TrackingModes.TRACKING;
            }
            else
            {
                anim[Animation].speed = Mathf.Abs(anim[Animation].speed);

                anim.Play(Animation);
                mode = TrackingModes.EXTENDING;

                if (anim[Animation].normalizedTime == 1)
                    anim[Animation].normalizedTime = 0;
            }
            animState = 1;

            if (this.MaximumDrag > 0)
            {
                part.minimum_drag = this.MinimumDrag + Dragmodifier;
                part.maximum_drag = this.MaximumDrag + Dragmodifier;
            }

            SetRange1();
        }
        public void SetMode0()
        {
            if (broken) return;

            mode = TrackingModes.RESETTING;

            animState = 0;

            if (this.MaximumDrag > 0)
            {
                part.minimum_drag = this.MinimumDrag;
                part.maximum_drag = this.MaximumDrag;
            }

            SetRange0();
        }
        public override void OnUpdate()
        {
            if (!flightStarted) return;

            switch (mode)
            {
                case TrackingModes.BROKEN:
                    return;
                case TrackingModes.TRACKING:
                    if (target.isTarget && powered)
                    {
                        pivot1.RotToTarget(target.position);
                        pivot2.RotToTarget(target.position);
                    }
                    break;
                case TrackingModes.EXTENDING:
                    if (!anim.IsPlaying(Animation))
                        mode = TrackingModes.TRACKING;
                    break;
                case TrackingModes.RETRACTING:
                    if (!anim.IsPlaying(Animation))
                        mode = TrackingModes.RETRACTED;
                    break;
                case TrackingModes.RESETTING:
                    if (pivot1.RotToOrigin() & pivot2.RotToOrigin())
                    {
                        anim[Animation].speed = -Mathf.Abs(anim[Animation].speed);

                        anim.Play(Animation);

                        if (anim[Animation].normalizedTime == 0)
                            anim[Animation].normalizedTime = 1;
                        mode = TrackingModes.RETRACTING;
                    }
                    break;
            }

            if (EnergyDrain1 > 0)
                RequestPower();

            if (vessel != null && RTUtils.PhysicsActive)
            {
                if (willWakeInPanic && animState == 0 && !InControl && !anim.IsPlaying(Animation))
                {
                    SetMode1();
                    UpdateGUI();
                }

                if (MaxQ > 0 && mode != TrackingModes.RETRACTED && vessel.atmDensity > 0 && (Math.Pow(RTUtils.DirectionalSpeed(Pivot2Dir.up, vessel.srf_velocity), 2) * vessel.atmDensity * 0.5) > MaxQ)
                {
                    broken = true;
                    mode = TrackingModes.BROKEN;
                    List<Transform> toRemove = new List<Transform>();
                    RTUtils.findTransformsWithCollider(part.FindModelTransform(Pivot1Name), ref toRemove);

                    foreach (Transform t in toRemove)
                    {
                        Rigidbody rb = t.gameObject.AddComponent<Rigidbody>();

                        rb.angularDrag = 0;
                        rb.angularVelocity = part.rigidbody.angularVelocity;
                        rb.drag = 0;
                        rb.mass = t.collider.bounds.size.x * t.collider.bounds.size.y * t.collider.bounds.size.z * ShrapnelDensity;
                        rb.velocity = part.rigidbody.velocity;
                        rb.isKinematic = false;
                        t.parent = null;
                        rb.AddForce(UnityEngine.Random.Range(-5, 5), UnityEngine.Random.Range(-5, 5), UnityEngine.Random.Range(-5, 5));
                        rb.AddTorque(UnityEngine.Random.Range(-20, 20), UnityEngine.Random.Range(-20, 20), UnityEngine.Random.Range(-20, 20));

                        DragModel dm = t.gameObject.AddComponent<DragModel>();
                        dm.enabled = true;
                        dm.tf = t;
                        dm.rb = rb;
                        dm.dc = ShrapnelDragCoeff;
                        dm.mb = vessel.mainBody;
                    }

                    if (this.MaximumDrag > 0)
                    {
                        part.minimum_drag = this.MinimumDrag;
                        part.maximum_drag = this.MaximumDrag;
                    }

                    EnergyDrain = antennaRange = dishRange = 0;
                    part.SendMessage("UpdateGUI");
                    UpdatePA();
                    RTGlobals.network = new RelayNetwork();
                }
            }
        }
        public override void OnStart(PartModule.StartState state)
        {
            if (broken)
            {
                mode = TrackingModes.BROKEN;
                List<Transform> toRemove = new List<Transform>();
                RTUtils.findTransformsWithCollider(part.FindModelTransform(Pivot1Name), ref toRemove);
                foreach (Transform t in toRemove)
                    Destroy(t.gameObject);

                if (this.MaximumDrag > 0)
                {
                    part.minimum_drag = this.MinimumDrag;
                    part.maximum_drag = this.MaximumDrag;
                }

                EnergyDrain = antennaRange = dishRange = 0;
                part.SendMessage("UpdateGUI");
                UpdatePA();
                RTGlobals.network = new RelayNetwork();
                return;
            }

            Actions["Mode1Action"].guiName = Events["Mode1Event"].guiName = Mode1Name;
            Actions["Mode0Action"].guiName = Events["Mode0Event"].guiName = Mode0Name;
            Actions["ActionToggle"].guiName = ToggleName;

            Events["OverrideMode1Event"].guiName = "Override " + Mode1Name;
            Events["OverrideMode0Event"].guiName = "Override " + Mode0Name;

            if (fixAnimLayers)
            {
                int i = 0;
                foreach (AnimationState s in anim)
                {
                    s.layer = i;
                    i++;
                }
            }

            if (animState == 1)
            {
                act1();

                anim[Animation].speed = Mathf.Abs(anim[Animation].speed);

                mode = TrackingModes.TRACKING;

                anim.Play(Animation);
            }
            else
            {
                act0();

                anim[Animation].speed = -Mathf.Abs(anim[Animation].speed);

                mode = TrackingModes.RETRACTED;

                anim.Play(Animation);
            }

            anim[Animation].wrapMode = WrapMode.Clamp;

            base.OnStart(state);

            if (state != StartState.Editor)
            {
                Pivot2Dir = part.FindModelTransform(Pivot2Name);

                pivot1 = new Pivot(part.FindModelTransform(Pivot1Name), Pivot1Speed, Pivot1Range);
                pivot2 = new Pivot(Pivot2Dir, Pivot2Speed, Pivot2Range);

                if (animState == 1)
                {
                    mode = TrackingModes.TRACKING;
                    if (target.isTarget)
                    {
                        pivot1.SnapToTarget(target.position);
                        pivot2.SnapToTarget(target.position);
                    }
                }
            }

            anim[Animation].normalizedTime = animState;
        }
        public override void OnStart(StartState state)
        {
            if (!String.IsNullOrEmpty(Pivot1Name) && !String.IsNullOrEmpty(Pivot2Name)) {
                ForceTransform = part.FindModelTransform(Pivot2Name);
                BreakTransform = part.FindModelTransform(Pivot1Name);
            } else {
                RTUtil.Log("ModuleRTAntennaAnimated: Pivot error");
                enabled = false;
                return;
            }

            if (IsRTBroken) {
                TrackingMode = TrackingModes.Broken;
            }

            base.OnStart(state);

            if (RTCore.Instance != null) {
                mPivot1 = new Pivot(BreakTransform, Pivot1Speed, Pivot1Range);
                mPivot2 = new Pivot(ForceTransform, Pivot2Speed, Pivot2Range);

                if (IsRTActive) {
                    TrackingMode = TrackingModes.Tracking;
                    mPivot1.SnapToTarget(new DynamicTarget(RTAntennaTargetGuid));
                    mPivot2.SnapToTarget(new DynamicTarget(RTAntennaTargetGuid));
                }
            }
        }
        public override void SetState(bool state)
        {
            base.SetState(state);

            if (IsRTActive) {
                if (TrackingMode == TrackingModes.Resetting)
                    TrackingMode = TrackingModes.Tracking;
                else {
                    TrackingMode = TrackingModes.Extending;
                    Animation[AnimationName].speed = Math.Abs(Animation[AnimationName].speed);
                    Animation.Play(AnimationName);
                }
            } else {
                if (TrackingMode == TrackingModes.Tracking)
                    TrackingMode = TrackingModes.Resetting;
                else {
                    TrackingMode = TrackingModes.Retracting;
                    Animation[AnimationName].speed = -Math.Abs(Animation[AnimationName].speed);
                    Animation.Play(AnimationName);
                }
            }
        }
示例#16
0
        public override void OnStart(PartModule.StartState state)
        {
            if (broken)
            {
                mode = TrackingModes.BROKEN;
                List <Transform> toRemove = new List <Transform>();
                RTUtils.findTransformsWithCollider(part.FindModelTransform(Pivot1Name), ref toRemove);
                foreach (Transform t in toRemove)
                {
                    Destroy(t.gameObject);
                }

                if (this.MaximumDrag > 0)
                {
                    part.minimum_drag = this.MinimumDrag;
                    part.maximum_drag = this.MaximumDrag;
                }

                EnergyDrain = antennaRange = dishRange = 0;
                part.SendMessage("UpdateGUI");
                UpdatePA();
                RTGlobals.network = new RelayNetwork();
                return;
            }

            Actions["Mode1Action"].guiName  = Events["Mode1Event"].guiName = Mode1Name;
            Actions["Mode0Action"].guiName  = Events["Mode0Event"].guiName = Mode0Name;
            Actions["ActionToggle"].guiName = ToggleName;

            Events["OverrideMode1Event"].guiName = "Override " + Mode1Name;
            Events["OverrideMode0Event"].guiName = "Override " + Mode0Name;

            if (fixAnimLayers)
            {
                int i = 0;
                foreach (AnimationState s in anim)
                {
                    s.layer = i;
                    i++;
                }
            }

            if (animState == 1)
            {
                act1();

                anim[Animation].speed = Mathf.Abs(anim[Animation].speed);

                mode = TrackingModes.TRACKING;

                anim.Play(Animation);
            }
            else
            {
                act0();

                anim[Animation].speed = -Mathf.Abs(anim[Animation].speed);

                mode = TrackingModes.RETRACTED;

                anim.Play(Animation);
            }

            anim[Animation].wrapMode = WrapMode.Clamp;

            base.OnStart(state);

            if (state != StartState.Editor)
            {
                Pivot2Dir = part.FindModelTransform(Pivot2Name);

                pivot1 = new Pivot(part.FindModelTransform(Pivot1Name), Pivot1Speed, Pivot1Range);
                pivot2 = new Pivot(Pivot2Dir, Pivot2Speed, Pivot2Range);

                if (animState == 1)
                {
                    mode = TrackingModes.TRACKING;
                    if (target.isTarget)
                    {
                        pivot1.SnapToTarget(target.position);
                        pivot2.SnapToTarget(target.position);
                    }
                }
            }

            anim[Animation].normalizedTime = animState;
        }
示例#17
0
        public override void OnUpdate()
        {
            if (!flightStarted)
            {
                return;
            }

            switch (mode)
            {
            case TrackingModes.BROKEN:
                return;

            case TrackingModes.TRACKING:
                if (target.isTarget && powered)
                {
                    pivot1.RotToTarget(target.position);
                    pivot2.RotToTarget(target.position);
                }
                break;

            case TrackingModes.EXTENDING:
                if (!anim.IsPlaying(Animation))
                {
                    mode = TrackingModes.TRACKING;
                }
                break;

            case TrackingModes.RETRACTING:
                if (!anim.IsPlaying(Animation))
                {
                    mode = TrackingModes.RETRACTED;
                }
                break;

            case TrackingModes.RESETTING:
                if (pivot1.RotToOrigin() & pivot2.RotToOrigin())
                {
                    anim[Animation].speed = -Mathf.Abs(anim[Animation].speed);

                    anim.Play(Animation);

                    if (anim[Animation].normalizedTime == 0)
                    {
                        anim[Animation].normalizedTime = 1;
                    }
                    mode = TrackingModes.RETRACTING;
                }
                break;
            }

            if (EnergyDrain1 > 0)
            {
                RequestPower();
            }

            if (vessel != null && RTUtils.PhysicsActive)
            {
                if (willWakeInPanic && animState == 0 && !InControl && !anim.IsPlaying(Animation))
                {
                    SetMode1();
                    UpdateGUI();
                }


                if (MaxQ > 0 && mode != TrackingModes.RETRACTED && vessel.atmDensity > 0 && (Math.Pow(RTUtils.DirectionalSpeed(Pivot2Dir.up, vessel.srf_velocity), 2) * vessel.atmDensity * 0.5) > MaxQ)
                {
                    broken = true;
                    mode   = TrackingModes.BROKEN;
                    List <Transform> toRemove = new List <Transform>();
                    RTUtils.findTransformsWithCollider(part.FindModelTransform(Pivot1Name), ref toRemove);

                    foreach (Transform t in toRemove)
                    {
                        Rigidbody rb = t.gameObject.AddComponent <Rigidbody>();

                        rb.angularDrag     = 0;
                        rb.angularVelocity = part.rigidbody.angularVelocity;
                        rb.drag            = 0;
                        rb.mass            = t.collider.bounds.size.x * t.collider.bounds.size.y * t.collider.bounds.size.z * ShrapnelDensity;
                        rb.velocity        = part.rigidbody.velocity;
                        rb.isKinematic     = false;
                        t.parent           = null;
                        rb.AddForce(UnityEngine.Random.Range(-5, 5), UnityEngine.Random.Range(-5, 5), UnityEngine.Random.Range(-5, 5));
                        rb.AddTorque(UnityEngine.Random.Range(-20, 20), UnityEngine.Random.Range(-20, 20), UnityEngine.Random.Range(-20, 20));

                        DragModel dm = t.gameObject.AddComponent <DragModel>();
                        dm.enabled = true;
                        dm.tf      = t;
                        dm.rb      = rb;
                        dm.dc      = ShrapnelDragCoeff;
                        dm.mb      = vessel.mainBody;
                    }

                    if (this.MaximumDrag > 0)
                    {
                        part.minimum_drag = this.MinimumDrag;
                        part.maximum_drag = this.MaximumDrag;
                    }

                    EnergyDrain = antennaRange = dishRange = 0;
                    part.SendMessage("UpdateGUI");
                    UpdatePA();
                    RTGlobals.network = new RelayNetwork();
                }
            }
        }
 public override void SetState(bool state)
 {
     if (IsRTActive) {
         if (AnimationOneShot) return;
         if (TrackingMode == TrackingModes.Tracking)
             TrackingMode = TrackingModes.Resetting;
         else {
             TrackingMode = TrackingModes.Retracting;
             base.SetState(state);
         }
     } else {
         if (TrackingMode == TrackingModes.Resetting)
             TrackingMode = TrackingModes.Tracking;
         else {
             TrackingMode = TrackingModes.Extending;
             base.SetState(state);
         }
     }
 }