protected override void OnLoad(ConfigNode configNode)
        {
            base.OnLoad(configNode);

            foreach (ConfigNode child in configNode.GetNodes("KERBAL_DETAIL"))
            {
                // Read all the orbit data
                KerbalData kd = new KerbalData();
                kd.body        = ConfigNodeUtil.ParseValue <CelestialBody>(child, "body");
                kd.latitude    = ConfigNodeUtil.ParseValue <double>(child, "lat");
                kd.longitude   = ConfigNodeUtil.ParseValue <double>(child, "lon");
                kd.altitude    = ConfigNodeUtil.ParseValue <double?>(child, "alt", (double?)null);
                kd.landed      = ConfigNodeUtil.ParseValue <bool>(child, "landed");
                kd.owned       = ConfigNodeUtil.ParseValue <bool>(child, "owned");
                kd.addToRoster = ConfigNodeUtil.ParseValue <bool>(child, "addToRoster");

                if (child.HasNode("ORBIT"))
                {
                    kd.orbit = new OrbitSnapshot(child.GetNode("ORBIT")).Load();
                }

                // Load the kerbal
                kd.kerbal = Kerbal.Load(child);
                kerbals.Add(kd);
            }
        }
            public void SelectKerbal()
            {
                if (kerbalSelected)
                {
                    return;
                }
                kerbalSelected = true;

                // First, try to get a Kerbal that matches the name
                if (!string.IsNullOrEmpty(characterName))
                {
                    kerbal = HighLogic.CurrentGame.CrewRoster.AllKerbals().Where(pcm => pcm.name == characterName).FirstOrDefault();
                }
                // Now grab from the active vessel
                else if (kerbal == null && FlightGlobals.ActiveVessel != null)
                {
                    kerbal = FlightGlobals.ActiveVessel.GetVesselCrew().Where(pcm => !excludeName.Contains(pcm.name)).ElementAtOrDefault(crewIndex);

                    if (kerbal != null)
                    {
                        characterName = kerbal.name;
                    }
                }

                if (kerbal == null && string.IsNullOrEmpty(characterName))
                {
                    System.Random r = new System.Random();
                    gender        = r.Next(2) == 0 ? ProtoCrewMember.Gender.Male : ProtoCrewMember.Gender.Female;
                    characterName = Kerbal.KerbalName(gender);
                }
            }
示例#3
0
 internal static bool InActiveCrew(Kerbal crew, bool checkName = false)
 {
     if (!checkName)
     {
         for (int i = 0; i < KerbalPortraitGallery.Instance.ActiveCrew.Count; ++i)
         {
             if (KerbalPortraitGallery.Instance.ActiveCrew[i] == crew)
             {
                 return(true);
             }
         }
         return(false);
     }
     else
     {
         for (int i = 0; i < KerbalPortraitGallery.Instance.ActiveCrew.Count; ++i)
         {
             if (KerbalPortraitGallery.Instance.ActiveCrew[i].crewMemberName == crew.crewMemberName)
             {
                 return(true);
             }
         }
         return(false);
     }
 }
示例#4
0
 internal static bool HasPortrait(Kerbal crew, bool checkName = false)
 {
     if (!checkName)
     {
         for (int i = 0; i < KerbalPortraitGallery.Instance.Portraits.Count; ++i)
         {
             if (KerbalPortraitGallery.Instance.Portraits[i].crewMember == crew)
             {
                 return(true);
             }
         }
         return(false);
     }
     else
     {
         for (int i = 0; i < KerbalPortraitGallery.Instance.Portraits.Count; ++i)
         {
             if (KerbalPortraitGallery.Instance.Portraits[i].crewMemberName == crew.crewMemberName)
             {
                 return(true);
             }
         }
         return(false);
     }
 }
示例#5
0
        public void Start(KerbalInfo kerbalInfo)
        {
            Kerbal        kerbal        = kerbalInfo.Kerbal;
            CameraManager cameraManager = CameraManager.Instance;

            cameraManager.SetCameraIVA(kerbal, true);
        }
示例#6
0
        protected override void OnParameterLoad(ConfigNode node)
        {
            try
            {
                base.OnParameterLoad(node);
                trait         = ConfigNodeUtil.ParseValue <string>(node, "trait", (string)null);
                minExperience = Convert.ToInt32(node.GetValue("minExperience"));
                maxExperience = Convert.ToInt32(node.GetValue("maxExperience"));
                minCrew       = Convert.ToInt32(node.GetValue("minCrew"));
                maxCrew       = Convert.ToInt32(node.GetValue("maxCrew"));

                foreach (ConfigNode kerbalNode in node.GetNodes("KERBAL"))
                {
                    kerbals.Add(Kerbal.Load(kerbalNode));
                }
                foreach (ConfigNode kerbalNode in node.GetNodes("KERBAL_EXCLUDE"))
                {
                    excludeKerbals.Add(Kerbal.Load(kerbalNode));
                }

                CreateDelegates();
            }
            finally
            {
                ParameterDelegate <Vessel> .OnDelegateContainerLoad(node);
            }
        }
示例#7
0
        void UpdateCamera()
        {
            if (HighLogic.LoadedSceneIsFlight)
            {
                if (CameraManager.Instance && CameraManager.Instance.currentCameraMode == CameraManager.CameraMode.IVA && part.vessel.isActiveVessel)
                {
                    Kerbal camKerbal = InternalCamera.Instance.transform.parent.parent.GetComponent <Kerbal>();
                    if (camKerbal && camKerbal.InPart == part)
                    {
                        InternalCamera.Instance.maxPitch = maxPitch;
                        InternalCamera.Instance.minPitch = minPitch;
                        InternalCamera.Instance.maxRot   = maxRot;
                        hasResetCamRanges = false;

                        float   camYaw     = Vector3.Angle(Vector3.ProjectOnPlane(InternalCamera.Instance.transform.forward, internalProp.transform.up), -internalProp.transform.forward);
                        float   sign       = Mathf.Sign(Vector3.Dot(InternalCamera.Instance.transform.forward, -internalProp.transform.right));
                        Vector3 lp         = InternalCamera.Instance.transform.parent.localPosition;
                        float   normYaw    = Mathf.Clamp((camYaw / 160), -1, 1);
                        float   worldScale = InternalCamera.Instance.transform.parent.InverseTransformVector(InternalCamera.Instance.transform.parent.right).x;
                        InternalCamera.Instance.transform.parent.localPosition = new Vector3(sign * normYaw * normYaw * (0.28f * worldScale), lp.y, lp.z);
                    }
                    else if (!hasResetCamRanges)
                    {
                        ResetCamRanges();
                    }
                }
                else if (!hasResetCamRanges)
                {
                    ResetCamRanges();
                }
            }
        }
示例#8
0
        public KerbalTrait(Kerbal k, KerbalPortrait p)
        {
            portrait  = p;
            crew      = k;
            protoCrew = k.protoCrewMember;

            if (PortraitStats.ctiOk)
            {
                trait     = CTIWrapper.CTI.getTrait(protoCrew.experienceTrait.Config.Name);
                iconColor = (trait.Color != null) ? (Color)trait.Color : XKCDColors.White;
            }

            GameObject hover = p.hoverObjectsContainer;
            GameObject role  = hover.transform.GetChild(2).gameObject;

            setupGameObjects(role, hover, protoCrew);
            addEVAListener();

            if (protoCrew.experienceTrait.Config.Name == "Tourist")
            {
                touristUpdate();
            }

            cachedTooltip = portrait.tooltip.descriptionString;
        }
示例#9
0
        public void EVAClick()
        {
            Kerbal thatKerbal = part.FindCurrentKerbal();

            if (thatKerbal != null && HighLogic.CurrentGame.Parameters.Flight.CanEVA)
            {
                activeKerbal = thatKerbal;
                if (intAnim != null)
                {
                    intAnim.enabled = true;
                    intAnim[internalAnimation].speed = 1;
                    intAnim.Play();
                    intAnimStarted = true;
                }
                else
                {
                    GoEva();
                }
                JUtil.LogMessage(this, "{0} has opened the internal EVA hatch.", thatKerbal.name);
            }
            else
            {
                JUtil.LogMessage(this, "Could not open the internal EVA hatch, not sure why.");
            }
        }
示例#10
0
        protected override void OnParameterLoad(ConfigNode node)
        {
            try
            {
                base.OnParameterLoad(node);
                index = Convert.ToInt32(node.GetValue("index"));
                count = Convert.ToInt32(node.GetValue("count"));

                // Legacy support from Contract Configurator 1.8.3
                if (node.HasValue("passenger"))
                {
                    passengers = ConfigNodeUtil.ParseValue <List <string> >(node, "passenger", new List <string>()).Select(
                        name => new Kerbal(name)
                        ).ToList();
                }
                else
                {
                    foreach (ConfigNode kerbalNode in node.GetNodes("KERBAL"))
                    {
                        passengers.Add(Kerbal.Load(kerbalNode));
                    }
                }

                CreateDelegates();
            }
            finally
            {
                ParameterDelegate <Vessel> .OnDelegateContainerLoad(node);
            }
        }
示例#11
0
 public KerbalInfo(KerbalInfo other)
 {
     EVA    = other.EVA;
     IsEVA  = other.IsEVA;
     Kerbal = other.Kerbal;
     Vessel = other.Vessel;
 }
示例#12
0
        /// <summary>
        /// Ejects the Kerbal from the capsule
        /// </summary>
        private void GoEject()
        {
            print("Go eject...");
            InternalSeat commandSeat = part.internalModel.seats[0];

            if (commandSeat.taken == true)
            {
                activeKerbal = commandSeat.kerbalRef;
                commandSeat.DespawnCrew();
                FlightEVA.SpawnEVA(activeKerbal);

                bool test = FlightGlobals.ActiveVessel;

                currentKerbalEVA = FlightGlobals.ActiveVessel.GetComponent <KerbalEVA>();
                print("OK...");

                if (currentKerbalEVA.OnALadder)
                {
                    print("On ladder...");
                    currentKerbalEVA.OnVesselGoOffRails(FlightGlobals.ActiveVessel);
                }

                CameraManager.Instance.SetCameraFlight();
                activeKerbal = null;
            }
        }
示例#13
0
        private void LateUpdate()
        {
            if (!FlightGlobals.ready)
            {
                return;
            }

            if (FlightGlobals.ActiveVessel == null)
            {
                return;
            }

            if (FlightGlobals.ActiveVessel.isEVA)
            {
                return;
            }

            if (reload)
            {
                reload = false;

                var crew = KerbalPortraitGallery.Instance.Portraits;

                for (int i = 0; i < crew.Count; i++)
                {
                    KerbalPortrait p = crew[i];

                    if (p == null)
                    {
                        continue;
                    }

                    Kerbal k = p.crewMember;

                    if (k == null)
                    {
                        return;
                    }

                    if (currentCrew.Contains(p.crewMemberName))
                    {
                        continue;
                    }

                    if (k.state == Kerbal.States.DEAD)
                    {
                        continue;
                    }

                    KerbalTrait K = new KerbalTrait(k, p);

                    if (K == null)
                    {
                        continue;
                    }

                    currentCrew.Add(p.crewMemberName, K);
                }
            }
        }
示例#14
0
        void Start()
        {
            Settings = new BeKerbalSettings()
            {
                EVA_EyeOffset       = Vector3.back * 0.0f,//0.1f,
                EVA_HeadLocation    = Vector3.up * 0.35f,
                EVA_MaxPitch        = 25.0f,
                EVA_MinPitch        = -25.0f,
                EVA_MaxYaw          = 45.0f,
                EVA_MinYaw          = -45.0f,
                EVA_LookSentivity   = 1.0f,
                EVA_ViewTurnPercent = 0.25f,
                EVA_RagdollComponentReferenceName = "helmetCollider",
                EVA_HiddenComponentsName          = new string[] { "headMesh", "eyeball", "upTeeth", "pupil", },
                EVA_HelmetColliderComponentName   = "helmetCollider",
                EVA_HelmetColliderRadiusFactor    = 1.5f,
                EVA_NearClip = 0.01f,

                IVA_GoToEVAKeyCode = KeyCode.Backspace,

                MapControl_LockID = "BeKerbal_MapControlID",
            };

            CurrentKerbal = null;
        }
        protected override void OnParameterLoad(ConfigNode node)
        {
            try
            {
                count = ConfigNodeUtil.ParseValue <int>(node, "count");
                index = ConfigNodeUtil.ParseValue <int>(node, "index");

                foreach (ConfigNode kerbalNode in node.GetNodes("KERBAL"))
                {
                    // Legacy support for Contract Configurator 1.8.3
                    if (kerbalNode.HasValue("kerbal"))
                    {
                        kerbalNode.AddValue("name", kerbalNode.GetValue("kerbal"));
                    }

                    kerbals.Add(Kerbal.Load(kerbalNode));
                    recovered[kerbals.Last().name] = ConfigNodeUtil.ParseValue <bool>(kerbalNode, "recovered");
                }

                CreateDelegates();
            }
            finally
            {
                ParameterDelegate <string> .OnDelegateContainerLoad(node);
            }
        }
示例#16
0
 public void OnMouseDown()
 {
     if (part != null)
     {
         Kerbal k = part.FindCurrentKerbal();
         if (k != null)
         {
             // Disallow tourists using props
             if (k.protoCrewMember.type == ProtoCrewMember.KerbalType.Tourist)
             {
                 if (UnityEngine.Random.Range(0, 10) > 8)
                 {
                     ScreenMessages.PostScreenMessage(string.Format("Stop touching buttons, {0}!", k.name), 4.0f, ScreenMessageStyle.UPPER_CENTER);
                 }
                 else
                 {
                     ScreenMessages.PostScreenMessage(string.Format("Tourist {0} may not operate equipment.", k.name), 4.0f, ScreenMessageStyle.UPPER_CENTER);
                 }
                 return;
             }
         }
     }
     foreach (PageTriggerSet monitor in pageTriggers)
     {
         monitor.ShowNext();
     }
     foreach (HandlerID consumer in clickHandlersID)
     {
         consumer.function(consumer.idValue);
     }
     foreach (Action clickHandler in clickHandlers)
     {
         clickHandler();
     }
 }
        protected override void OnAccepted()
        {
            // Create all the passengers
            for (int i = 0; i < count; i++)
            {
                // Create the ProtoCrewMember
                ProtoCrewMember crewMember = null;

                // Try to get existing passenger
                if (kerbals.Count > i)
                {
                    crewMember = HighLogic.CurrentGame.CrewRoster.AllKerbals().Where(pcm => pcm.name == kerbals[i].name).FirstOrDefault();
                    if (crewMember != null)
                    {
                        crewMember.hasToured = false;
                    }
                }
                if (crewMember == null)
                {
                    // Generate the ProtoCrewMember
                    Kerbal kerbal = (i < kerbals.Count()) ? kerbals.ElementAt(i) : new Kerbal();
                    if (i >= kerbals.Count())
                    {
                        kerbal.kerbalType = ProtoCrewMember.KerbalType.Tourist;
                    }
                    kerbal.GenerateKerbal();
                    crewMember = kerbal.pcm;
                }

                passengers[crewMember] = false;
            }

            kerbals.Clear();
        }
        public void EVAClick()
        {
            Kerbal thatKerbal = part.FindCurrentKerbal();

            float acLevel = ScenarioUpgradeableFacilities.GetFacilityLevel(SpaceCenterFacility.AstronautComplex);
            bool evaUnlocked = GameVariables.Instance.UnlockedEVA(acLevel);
            bool evaPossible = GameVariables.Instance.EVAIsPossible(evaUnlocked, vessel);
            if (evaPossible && thatKerbal != null && HighLogic.CurrentGame.Parameters.Flight.CanEVA)
            {
                activeKerbal = thatKerbal;
                if (intAnim != null)
                {
                    intAnim.enabled = true;
                    intAnim[internalAnimation].speed = 1;
                    intAnim.Play();
                    intAnimStarted = true;
                }
                else
                {
                    GoEva();
                }
                JUtil.LogMessage(this, "{0} has opened the internal EVA hatch.", thatKerbal.name);
            }
            else
            {
                if (evaPossible)
                {
                    JUtil.LogMessage(this, "Could not open the internal EVA hatch, not sure why.");
                }
                else
                {
                    JUtil.LogMessage(this, "EVA hatches can not be opened - is the astronaut complex upgraded yet?");
                }
            }
        }
示例#19
0
 bool KerbalIsOnVessel(Vessel vessel, Kerbal kerbal)
 {
     if (kerbal == null)
     {
         return(false);
     }
     return(vessel.GetVesselCrew().Contains(kerbal.protoCrewMember));
 }
		private void GoEva()
		{
			if (activeKerbal != null) {
				FlightEVA.SpawnEVA(activeKerbal);
				CameraManager.Instance.SetCameraFlight();
				activeKerbal = null;
			}
		}
示例#21
0
 public void SyncKerbal()
 {
     Kerbal.ChangeName(Name);
     Kerbal.stupidity = Stupidity;
     Kerbal.courage   = Courage;
     Kerbal.isBadass  = Badass;
     Kerbal.gender    = Gender;
     Kerbal.type      = Type;
 }
        protected override void OnLoad(ConfigNode node)
        {
            base.OnLoad(node);

            foreach (ConfigNode kerbalNode in node.GetNodes("KERBAL"))
            {
                kerbals.Add(Kerbal.Load(kerbalNode));
            }
        }
示例#23
0
 private void GoEva()
 {
     if (activeKerbal != null)
     {
         FlightEVA.SpawnEVA(activeKerbal);
         CameraManager.Instance.SetCameraFlight();
         activeKerbal = null;
     }
 }
 private void RemoveKerbals()
 {
     LoggingUtil.LogVerbose(this, "Removing kerbals");
     foreach (ProtoCrewMember kerbal in passengers.Keys)
     {
         Kerbal.RemoveKerbal(kerbal);
     }
     passengers.Clear();
 }
        private void RemoveKerbals()
        {
            LoggingUtil.LogDebug(this, "Removing kerbals...");

            foreach (Kerbal kerbal in kerbals)
            {
                Kerbal.RemoveKerbal(kerbal);
            }
            kerbals.Clear();
        }
示例#26
0
        // Select the good kerbal on IVA after an EVA
        void OnCrewBoardVessel(GameEvents.FromToAction <Part, Part> part)
        {
            ProtoCrewMember _pcrew = part.to.protoModuleCrew.Find(item => item.KerbalRef.crewMemberName == part.from.vessel.vesselName);

            if (_pcrew != null)
            {
                EVAKerbal = _pcrew.KerbalRef;
            }
            Log("OnCrewBoardVessel", "QIVA");
        }
示例#27
0
 //utility methods
 private void SetHelmet(bool value)
 {
     foreach (var rend in Kerbal.GetComponentsInChildren <Renderer>())
     {
         if (rend.name == "helmet" || rend.name == "visor" || rend.name == "flare1" || rend.name == "flare2")
         {
             rend.enabled = value;
         }
     }
     _hasHelmet = value;
 }
 internal static bool InActiveCrew(Kerbal crew)
 {
     for (int i = 0; i < KerbalPortraitGallery.Instance.ActiveCrew.Count; ++i)
     {
         if (KerbalPortraitGallery.Instance.ActiveCrew[i] == crew)
         {
             return(true);
         }
     }
     return(false);
 }
示例#29
0
 public KerbalEditorForm( )
 {
     InitializeComponent( );
     this.editing = false;
     cmb_kerbal_select.Items.AddRange(roster.GetNames( ).ToArray( ));
     cmb_role.Items.AddRange(Professions);
     cmb_state.Items.AddRange(States);
     currentKerbal = roster.GetKerbal(0);
     ToggleControls( );
     UpdateDisplay( );
 }
 internal static bool InActiveCrew(Kerbal crew, bool checkName = false)
 {
     if (!checkName)
     {
         return KerbalPortraitGallery.Instance.ActiveCrew.Any(p => p == crew);
     }
     else
     {
         return KerbalPortraitGallery.Instance.ActiveCrew.Any(p => p.crewMemberName == crew.crewMemberName);
     }
 }
 internal static bool HasPortrait(Kerbal crew, bool checkName = false)
 {
     if (!checkName)
     {
         return KerbalPortraitGallery.Instance.Portraits.Any(p => p.crewMember == crew);
     }
     else
     {
         return KerbalPortraitGallery.Instance.Portraits.Any(p => p.crewMemberName == crew.crewMemberName);
     }
 }
示例#32
0
        private void IVA(Vessel vessel)
        {
            if (!HighLogic.CurrentGame.Parameters.Flight.CanIVA || !FlightGlobals.ready)
            {
                return;
            }

            if (vessel.GetCrewCount() > 0)
            {
                bool   _VesselhasOnlyPlaceholder;
                Kerbal _IVAKerbal;
                if (VesselHasSeatTaken(vessel, out _IVAKerbal, out _VesselhasOnlyPlaceholder))
                {
                    if (EVAKerbal != null)
                    {
                        if (vessel.GetVesselCrew().Contains(EVAKerbal.protoCrewMember))
                        {
                            _IVAKerbal = EVAKerbal;
                        }
                        else
                        {
                            EVAKerbal = null;
                        }
                    }
                    if (_IVAKerbal != null)
                    {
                        if (KerbalIsOnVessel(vessel, _IVAKerbal))
                        {
                            isGoneIVA = CameraManager.Instance.SetCameraIVA(_IVAKerbal, true);
                        }
                        else
                        {
                            isGoneIVA = CameraManager.Instance.SetCameraIVA();
                        }
                    }
                    else
                    {
                        isGoneIVA = CameraManager.Instance.SetCameraIVA();
                    }
                }
                else if (_VesselhasOnlyPlaceholder)
                {
                    return;
                }
            }
            else
            {
                return;
            }
            if (isGoneIVA)
            {
                EVAKerbal = null;
            }
        }
示例#33
0
        /// <summary>
        /// Begins the EVA for the active kerbal. Based on Mihara's Internal Module code for EVA.
        /// https://github.com/Mihara/RasterPropMonitor/blob/master/RasterPropMonitor/Auxiliary%20modules/JSIInternalEVAHatch.cs
        /// </summary>
        private void GoEva()
        {
            InternalSeat commandSeat = part.internalModel.seats[0];

            if (commandSeat.taken == true)
            {
                activeKerbal = commandSeat.kerbalRef;
                commandSeat.DespawnCrew();
                FlightEVA.SpawnEVA(activeKerbal);
                CameraManager.Instance.SetCameraFlight();
                activeKerbal = null;
            }
        }
示例#34
0
 // AutoHide UI and Kerbal Info
 void OnIVACameraKerbalChange(Kerbal kerbal)
 {
     if (kerbal != null)
     {
         Log(string.Format("IVA switch to {0}({1}) experienceTrait: {2}, partName: ({3}){4}", kerbal.crewMemberName, kerbal.protoCrewMember.seatIdx, kerbal.protoCrewMember.experienceTrait.Title, kerbal.protoCrewMember.seat.part.partInfo.category, kerbal.protoCrewMember.seat.part.name));
         ScrMsg(false, kerbal);
         StartCoroutine(WaitToHideUI());
     }
     else
     {
         Log("Can't find the current Kerbal", "QIVA");
     }
 }
		public void EVAClick()
		{
			Kerbal thatKerbal = part.FindCurrentKerbal();
			if (thatKerbal != null && HighLogic.CurrentGame.Parameters.Flight.CanEVA) {
				activeKerbal = thatKerbal;
				if (intAnim != null) {
					intAnim.enabled = true;
					intAnim[internalAnimation].speed = 1;
					intAnim.Play();
					intAnimStarted = true;
				} else {
					GoEva();
				}
				JUtil.LogMessage(this, "{0} has opened the internal EVA hatch.", thatKerbal.name);
			} else
				JUtil.LogMessage(this, "Could not open the internal EVA hatch, not sure why.");
		}
 /// <summary>
 /// Destroy Portraits for a kerbal and Unregisters them from the KerbalPortraitGallery
 /// </summary>
 /// <param name="kerbal">the Kerbal we want to delete portraits for</param>
 internal static void DestroyPortrait(Kerbal kerbal)
 {
     // set the kerbal InPart to null - this should stop their portrait from re-spawning.
     kerbal.InPart = null;
     //Set them visible in portrait to false
     kerbal.SetVisibleInPortrait(false);
     kerbal.state = Kerbal.States.NO_SIGNAL;
     //Loop through the ActiveCrew portrait List
     for (int i = KerbalPortraitGallery.Instance.ActiveCrew.Count - 1; i >= 0; i--)
     {
         //If we find an ActiveCrew entry where the crewMemberName is equal to our kerbal's
         if (KerbalPortraitGallery.Instance.ActiveCrew[i].crewMemberName == kerbal.crewMemberName)
         {
             //we Remove them from the list.
             KerbalPortraitGallery.Instance.ActiveCrew.RemoveAt(i);
         }
     }
     //Portraits List clean-up.
     DespawnInactivePortraits(); //Despawn any portraits where CrewMember == null
     DespawnPortrait(kerbal); //Despawn our Kerbal's portrait
     UIControlsUpdate(); //Update UI controls
 }
 /// <summary>
 /// Restore the Portrait for a kerbal and register them to the KerbalPortraitGallery
 /// </summary>
 /// <param name="kerbal">the kerbal we want restored</param>
 /// <param name="part">the part the kerbal is in</param>
 internal static void RestorePortrait(Part part, Kerbal kerbal)
 {
     //We don't process DEAD, Unowned kerbals - Compatibility with DeepFreeze Mod.
     if (kerbal.rosterStatus != ProtoCrewMember.RosterStatus.Dead &&
         kerbal.protoCrewMember.type != ProtoCrewMember.KerbalType.Unowned)
     {
         //Set the Kerbals InPart back to their part.
         kerbal.InPart = part;
         //Set their portrait state to ALIVE and set their portrait back to visible.
         kerbal.state = Kerbal.States.ALIVE;
         kerbal.SetVisibleInPortrait(true);
         //Find an ActiveCrew entry and Portraits entry for our kerbal?
         //If they aren't in ActiveCrew and don't have a Portrait them via the kerbal.Start method.
         if (!InActiveCrew(kerbal) && !HasPortrait(kerbal))
         {
             kerbal.staticOverlayDuration = 1f;
             kerbal.randomizeOnStartup = false;
             kerbal.Start();
         }
         kerbal.state = Kerbal.States.ALIVE;
     }
 }
 public KerbalTrait(Kerbal k)
 {
     protoCrew = k.protoCrewMember;
     traitPos = crewType(k.protoCrewMember.experienceTrait);
     levelPos = levelRect(k.protoCrewMember.experienceLevel);
 }
示例#39
0
        /**
         * Personalise Kerbals in an internal space of a vessel. Used by IvaModule.
         */
        public void personaliseIva(Kerbal kerbal)
        {
            bool needsSuit = !isHelmetRemovalEnabled || !isSituationSafe(kerbal.InVessel);

              personaliseKerbal(kerbal, kerbal.protoCrewMember, kerbal.InPart, needsSuit);
        }
 /// <summary>
 /// Callback when the player switches IVA camera.
 /// 
 /// BUG: The callback's parameter tells me who the
 /// previous Kerbal was, not who the new Kerbal is.
 /// </summary>
 /// <param name="newKerbal"></param>
 private void OnIVACameraChange(Kerbal newKerbal)
 {
     // Unfortunately, the callback is telling me who the previous Kerbal was,
     // not who the new Kerbal is.
     Kerbal activeKerbal = part.FindCurrentKerbal();
     if (activeKerbal != null)
     {
         int seatID = activeKerbal.protoCrewMember.seatIdx;
         if (seatID != oldSeat)
         {
             UpdateCameras(seatID, activeKerbal);
         }
     }
 }
        /// <summary>
        /// Take care of updating everything.
        /// </summary>
        /// <param name="seatID"></param>
        /// <param name="activeKerbal"></param>
        private void UpdateCameras(int seatID, Kerbal activeKerbal)
        {
            InternalCamera.Instance.SetFOV(seats[seatID].fov);
            InternalCamera.Instance.maxRot = seats[seatID].maxRot;
            InternalCamera.Instance.maxPitch = seats[seatID].maxPitch;
            InternalCamera.Instance.minPitch = seats[seatID].minPitch;

            RPMVesselComputer comp = null;
            if (RPMVesselComputer.TryGetInstance(vessel, ref comp))
            {
                comp.SetKerbalVisible(activeKerbal, seats[seatID].hideKerbal);
            }

            oldSeat = seatID;
        }
 private void TexReplacerPersonaliseKerbal(Kerbal kerbal)
 {
     //This will re-personalise a kerbal who has been personalised using Texture replacer mod.
     try
     {
          Utilities.Log_Debug("Texture Replacer installed. Re-PersonliseKerbal");
         if (TRWrapper.APIReady && TRWrapper.InstanceExists)
         {
             TRWrapper.TexRepPersonaliser.personaliseIva(kerbal);
         }
         else
         {
             Debug.Log("DeepFreeze has been unable to connect to Texture Replacer mod. API is not ready. Report this error on the Forum Thread.");
         }
     }
     catch (Exception ex)
     {
         Debug.Log("Exception attempting to restore Kerbals Texture Replacer mod customisations. Report this error on the Forum Thread.");
         Debug.Log("Err: " + ex);
     }
 }
 internal void checkPortraitRegistered(Kerbal kerbal)
 {
     if (!DFPortraits.HasPortrait(kerbal, true))
     {
         vessel.DespawnCrew();
         base.StartCoroutine(CallbackUtil.DelayedCallback(3, new Callback(this.delayedSpawnCrew)));
     }
 }
示例#44
0
 private void OnIVACameraKerbalChange(Kerbal kerbal)
 {
     activatedAt = DateTime.Now;
 }
示例#45
0
 /// <summary>
 /// Personalise IVA textures of a kerbal
 /// </summary>
 /// <param name="kerbal">The Kerbal reference</param>
 /// <returns>Success of call</returns>
 internal void personaliseIva(Kerbal kerbal)
 {
     try
     {
         personaliseIvaMethod.Invoke(APIactualTRPersonaliser, new Object[] { kerbal });
     }
     catch (Exception ex)
     {
         LogFormatted("Unable to invoke Texture Replacer personaliseIva Method");
         LogFormatted("Exception: {0}", ex);
         //throw;
     }
 }
 //reflecting protected methods inside a public class. Until KSP 1.1.x can rectify the situation.
 internal static void DespawnPortrait(Kerbal kerbal)
 {
     MethodInfo DespawnPortraitMethod = typeof(KerbalPortraitGallery).GetMethod("DespawnPortrait", eFlags, Type.DefaultBinder, new Type[] { typeof(Kerbal) }, null);
     DespawnPortraitMethod.Invoke(KerbalPortraitGallery.Instance, new object[] { kerbal });
 }