public override void RemoveOutcome(Vessel vessel) { ProtoCrewMember[] astronauts = null; AstronautData astronautData = null; //Get the crew manifest if (vessel.loaded) { astronauts = vessel.GetVesselCrew().ToArray(); } else { astronauts = vessel.protoVessel.GetVesselCrew().ToArray(); } //Go through each kerbal and set their condition for (int index = 0; index < astronauts.Length; index++) { astronautData = SnacksScenario.Instance.GetAstronautData(astronauts[index]); //If the vessel is loaded then restore skills if (vessel.loaded) { SnacksScenario.Instance.RestoreSkillsIfNeeded(astronauts[index]); } astronautData.ClearCondition(conditionName); } //Call base class base.RemoveOutcome(vessel); }
public void SetAstronautData(AstronautData data) { if (crewData.Contains(data.name)) { crewData[data.name] = data; } }
public void UnregisterCrew(AstronautData data) { if (crewData.Contains(data.name)) { crewData.Remove(data.name); } }
private static double calculateExtraSnacksRequired(List <ProtoCrewMember> crew) { if (SnacksProperties.EnableRandomSnacking == false) { return(0); } double extra = 0; foreach (ProtoCrewMember pc in crew) { AstronautData data = SnacksScenario.Instance.GetAstronautData(pc); if (data.isExempt) { continue; } if (getRandomChance(pc.courage / 2.0)) { extra += SnacksProperties.SnacksPerMeal; } if (getRandomChance(pc.stupidity / 2.0)) { extra -= SnacksProperties.SnacksPerMeal; } if (pc.isBadass && getRandomChance(.2)) { extra -= SnacksProperties.SnacksPerMeal; } } return(extra); }
protected void setKeyValue(AstronautData astronautData) { int value = 0; //Strings before ints if (!string.IsNullOrEmpty(stringValue)) { if (!astronautData.keyValuePairs.ContainsKey(keyValueName)) { astronautData.keyValuePairs.Add(keyValueName, stringValue); } else { astronautData.keyValuePairs[keyValueName] = stringValue; } } //Add ints before ints else if (addIntValue != 0) { if (!astronautData.keyValuePairs.ContainsKey(keyValueName)) { astronautData.keyValuePairs.Add(keyValueName, addIntValue.ToString()); } else { if (int.TryParse(astronautData.keyValuePairs[keyValueName], out value)) { value += addIntValue; astronautData.keyValuePairs[keyValueName] = value.ToString(); } } } else { if (!astronautData.keyValuePairs.ContainsKey(keyValueName)) { astronautData.keyValuePairs.Add(keyValueName, intValue.ToString()); } else { astronautData.keyValuePairs[keyValueName] = intValue.ToString(); } } SnacksScenario.Instance.SetAstronautData(astronautData); //Player message if (!string.IsNullOrEmpty(playerMessage)) { string message = playerMessage; } }
protected void applyOutcome(Vessel vessel, ProtoCrewMember astronaut, AstronautData astronautData) { if (string.IsNullOrEmpty(resourceName)) { causeFainting(vessel, astronaut, astronautData); } else if (astronautData.processedResourceFailures.ContainsKey(resourceName) && astronautData.processedResourceFailures[resourceName] >= cyclesBeforeFainting) { causeFainting(vessel, astronaut, astronautData); } }
protected void causeFainting(Vessel vessel, ProtoCrewMember astronaut, AstronautData astronautData) { string message; //Apply fainting immediately if the vessel is loaded if (vessel.loaded) { astronaut.SetInactive(faintDurationSeconds, true); if (!string.IsNullOrEmpty(playerMessage)) { ScreenMessages.PostScreenMessage(astronaut.name + " " + playerMessage, 5.0f, ScreenMessageStyle.UPPER_LEFT); } } //Vessel isn't loaded, record the info we need so we can make kerbals faint when vessel is loaded. else { if (!astronautData.keyValuePairs.ContainsKey(FaintDurationKey)) { astronautData.keyValuePairs.Add(FaintDurationKey, faintDurationSeconds.ToString()); } else { //Add to existing duration float currentDuration = 0; float.TryParse(astronautData.keyValuePairs[FaintDurationKey], out currentDuration); currentDuration += faintDurationSeconds; astronautData.keyValuePairs[FaintDurationKey] = currentDuration.ToString(); } if (!astronautData.keyValuePairs.ContainsKey(FaintMessageKey)) { astronautData.keyValuePairs.Add(FaintMessageKey, astronautData.name + " " + playerMessage); } else { //Add to existing message message = astronautData.name + " " + playerMessage; if (!astronautData.keyValuePairs[FaintMessageKey].Contains(message)) { astronautData.keyValuePairs[FaintMessageKey] += (";" + message); } //Inform player string[] messages = astronautData.keyValuePairs[FaintMessageKey].Split(';'); for (int messageIndex = 0; messageIndex < messages.Length; messageIndex++) { ScreenMessages.PostScreenMessage(messages[messageIndex], 5.0f, ScreenMessageStyle.UPPER_LEFT); } } } }
public override void ApplyOutcome(Vessel vessel, SnacksProcessorResult result) { ProtoCrewMember[] astronauts = null; AstronautData astronautData = null; string message = string.Empty; //Get the crew manifest if (result.afftectedAstronauts != null) { astronauts = result.afftectedAstronauts.ToArray(); } else if (vessel.loaded) { astronauts = vessel.GetVesselCrew().ToArray(); } else { astronauts = vessel.protoVessel.GetVesselCrew().ToArray(); } //Select random crew if needed if (selectRandomCrew) { int randomIndex = UnityEngine.Random.Range(0, astronauts.Length - 1); astronauts = new ProtoCrewMember[] { astronauts[randomIndex] }; } //Go through each kerbal and set their condition for (int index = 0; index < astronauts.Length; index++) { astronautData = SnacksScenario.Instance.GetAstronautData(astronauts[index]); astronautData.SetCondition(conditionName); //If the vessel is loaded then remove skills if (vessel.loaded) { SnacksScenario.Instance.RemoveSkillsIfNeeded(astronauts[index]); } //Inform player if (!string.IsNullOrEmpty(playerMessage)) { message = vessel.vesselName + ": " + astronauts[index].name + " " + playerMessage; ScreenMessages.PostScreenMessage(message, 5.0f, ScreenMessageStyle.UPPER_LEFT); } } //Call the base class base.ApplyOutcome(vessel, result); }
private void onCrewBoardVessel(GameEvents.FromToAction <Part, Part> data) { Part evaKerbal = data.from; Part boardedPart = data.to; if (!string.IsNullOrEmpty(disqualifiedPreconditions) && boardedPart == this.part) { ProtoCrewMember astronaut = evaKerbal.vessel.GetVesselCrew()[0]; AstronautData astronautData = SnacksScenario.Instance.GetAstronautData(astronaut); //Set disqualifier astronautData.SetDisqualifier(disqualifiedPreconditions); } }
private void onCrewOnEva(GameEvents.FromToAction <Part, Part> data) { Part evaKerbal = data.to; Part partExited = data.from; if (!string.IsNullOrEmpty(disqualifiedPreconditions) && partExited == this.part) { ProtoCrewMember astronaut = evaKerbal.vessel.GetVesselCrew()[0]; AstronautData astronautData = SnacksScenario.Instance.GetAstronautData(astronaut); //Remove disqualifier astronautData.ClearDisqualifier(disqualifiedPreconditions); } }
private void onCrewTransferred(GameEvents.HostedFromToAction <ProtoCrewMember, Part> data) { ProtoCrewMember astronaut = data.host; Part fromPart = data.from; Part toPart = data.to; if (!string.IsNullOrEmpty(disqualifiedPreconditions) && toPart == this.part) { AstronautData astronautData = SnacksScenario.Instance.GetAstronautData(astronaut); //Set disqualifier astronautData.SetDisqualifier(disqualifiedPreconditions); } }
public int AddMissedMeals(ProtoCrewMember astronaut, int mealsMissed) { AstronautData data = GetAstronautData(astronaut); //Handle exemptions if (data.isExempt) { return(0); } data.mealsMissed += mealsMissed; return(data.mealsMissed); }
/// <summary> /// Handles the kerbal level up event /// </summary> /// <param name="astronaut">The ProtoCrewMember that has leveled up.</param> public virtual void onKerbalLevelUp(ProtoCrewMember astronaut) { AstronautData astronautData = SnacksScenario.Instance.GetAstronautData(astronaut); SnacksRosterResource astronautResource; if (astronautData.rosterResources.ContainsKey(resourceName)) { astronautResource = astronautData.rosterResources[resourceName]; astronautResource.amount += (astronautResource.experienceBonusAmount * astronaut.experienceTrait.CrewMemberExperienceLevel()); astronautResource.maxAmount += (astronautResource.experienceBonusMaxAmount * astronaut.experienceTrait.CrewMemberExperienceLevel()); astronautData.rosterResources[resourceName] = astronautResource; } }
public override void OnStart(StartState state) { base.OnStart(state); GameEvents.onCrewOnEva.Add(onCrewOnEva); GameEvents.onCrewBoardVessel.Add(onCrewBoardVessel); GameEvents.onCrewTransferred.Add(onCrewTransferred); GameEvents.OnVesselRecoveryRequested.Add(OnVesselRecoveryRequested); //Set disqualifier ProtoCrewMember[] astronauts = this.part.protoModuleCrew.ToArray(); for (int index = 0; index < astronauts.Length; index++) { AstronautData astronautData = SnacksScenario.Instance.GetAstronautData(astronauts[index]); astronautData.SetDisqualifier(disqualifiedPreconditions); } }
private void drawStressEstimates() { ProtoCrewMember[] astronauts = FlightGlobals.ActiveVessel.GetVesselCrew().ToArray();; AstronautData astronautData = null; //Show crew capacity GUILayout.Label(string.Format("<color=white>Estimated Crew Capacity: {0:n0}</color>", crewCapacity)); //Calculate the total space. float space = stressProcessor.CalculateSpace(activeVesselCrewCount, crewCapacity); //Get experience bonus double stressExperienceBonus = SnacksScenario.Instance.rosterResources[StressProcessor.StressResourceName].experienceBonusMaxAmount; //Show who will get stressed and who won't. SnacksRosterResource resource; double amount, maxAmount, bonusMaxStress = 0; int experienceLevel = 0; for (int index = 0; index < astronauts.Length; index++) { astronautData = SnacksScenario.Instance.GetAstronautData(astronauts[index]); if (astronautData == null) { continue; } if (!astronautData.rosterResources.ContainsKey(StressProcessor.StressResourceName)) { continue; } resource = astronautData.rosterResources[StressProcessor.StressResourceName]; experienceLevel = astronauts[index].experienceTrait.CrewMemberExperienceLevel(); bonusMaxStress = stressExperienceBonus * experienceLevel; maxAmount = space + bonusMaxStress; amount = resource.amount; if (amount > maxAmount) { GUILayout.Label("<color=white>" + astronautData.name + string.Format("\n Estimated Stress: {0:n2}/{1:n2}", amount, maxAmount) + "</color>\n<color=orange> Will likely get Stressed Out</color>"); } else { GUILayout.Label("<color=white>" + astronautData.name + string.Format("\n Estimated Stress: {0:n2}/{1:n2}", amount, maxAmount) + "</color>"); } } }
protected void updateMaxSpace(Vessel vessel) { ProtoCrewMember[] astronauts = null; AstronautData astronautData = null; //Get the crew manifest if (vessel.loaded) { astronauts = vessel.GetVesselCrew().ToArray(); } else { astronauts = vessel.protoVessel.GetVesselCrew().ToArray(); } if (astronauts.Length == 0) { return; } //Calculate how much Space the vessel has. float space = CalculateSpace(vessel); //Get experience bonus double stressExperienceBonus = SnacksScenario.Instance.rosterResources[StressResourceName].experienceBonusMaxAmount; //Go through the crew and update their max Stress. SnacksRosterResource resource; for (int index = 0; index < astronauts.Length; index++) { astronautData = SnacksScenario.Instance.GetAstronautData(astronauts[index]); if (astronautData == null) { continue; } if (!astronautData.rosterResources.ContainsKey(StressResourceName)) { continue; } resource = astronautData.rosterResources[StressResourceName]; resource.maxAmount = space + (stressExperienceBonus * astronauts[index].experienceTrait.CrewMemberExperienceLevel()); astronautData.rosterResources[StressResourceName] = resource; } }
public AstronautData GetAstronautData(ProtoCrewMember astronaut) { if (crewData.Contains(astronaut.name) == false) { AstronautData data = new AstronautData(); data.name = astronaut.name; data.mealsMissed = 0; data.experienceTrait = astronaut.experienceTrait.Title; data.lastUpdated = Planetarium.GetUniversalTime(); data.keyValuePairs = new DictionaryValueList <string, string>(); //Don't forget about exemptions crewData.Add(data.name, data); } return(crewData[astronaut.name]); }
/// <summary> /// Adds the roster resource to the kerbal if needed /// </summary> /// <param name="astronaut">The ProtoCrewMember to check.</param> public virtual void addResourceIfNeeded(ProtoCrewMember astronaut) { SnacksRosterResource resource; AstronautData astronautData = SnacksScenario.Instance.GetAstronautData(astronaut); if (!astronautData.rosterResources.ContainsKey(resourceName)) { resource = new SnacksRosterResource(); resource.displayName = displayName; resource.resourceName = resourceName; resource.showInSnapshot = showInSnapshot; resource.amount = amount; resource.maxAmount = maxAmount; astronautData.rosterResources.Add(resourceName, resource); SnacksScenario.Instance.SetAstronautData(astronautData); } }
public override void OnLoad(ConfigNode node) { base.OnLoad(node); if (node.HasValue("exemptkerbals")) { exemptKerbals = node.GetValue("exemptKerbals"); } ConfigNode[] penalties = node.GetNodes("SCIENCE_PENALTY"); foreach (ConfigNode penaltyNode in penalties) { sciencePenalties.Add(penaltyNode.GetValue("vesselID"), int.Parse(penaltyNode.GetValue("amount"))); } ConfigNode[] astronauts = node.GetNodes("ASTRONAUT"); foreach (ConfigNode astronaut in astronauts) { try { AstronautData data = new AstronautData(); data.name = astronaut.GetValue("name"); data.experienceTrait = astronaut.GetValue("experienceTrait"); data.mealsMissed = int.Parse(astronaut.GetValue("mealsMissed")); data.lastUpdated = double.Parse(astronaut.GetValue("lastUpdated")); data.isExempt = bool.Parse(astronaut.GetValue("isExempt")); data.keyValuePairs = new DictionaryValueList <string, string>(); ConfigNode[] keyValuePairs = astronaut.GetNodes("KEYVALUE"); foreach (ConfigNode keyValue in keyValuePairs) { data.keyValuePairs.Add(keyValue.GetValue("key"), keyValue.GetValue("value")); } crewData.Add(data.name, data); } catch //(Exception ex) { //Debug.Log("[Snacks] - error encountered: " + ex + " skipping kerbal."); continue; } } }
public override bool IsValid(ProtoCrewMember astronaut) { if (!base.IsValid(astronaut)) { return(false); } AstronautData astronautData = SnacksScenario.Instance.GetAstronautData(astronaut); if (astronautData == null) { return(false); } //Get the processor BaseResourceProcessor processor = null; int count = SnacksScenario.Instance.resourceProcessors.Count; for (int index = 0; index < count; index++) { processor = SnacksScenario.Instance.resourceProcessors[index]; if (resultType == CheckResultTypes.resultConsumptionFailure || resultType == CheckResultTypes.resultConsumptionSuccess) { if (processor.consumptionResults.ContainsKey(resourceName)) { break; } } else { if (processor.productionResults.ContainsKey(resourceName)) { break; } } processor = null; } if (processor == null) { return(false); } switch (resultType) { case CheckResultTypes.resultConsumptionFailure: //Processor needs at least one failure if (processor.consumptionResults[resourceName].completedSuccessfully) { return(false); } if (astronautData.processedResourceFailures.ContainsKey(resourceName)) { return(astronautData.processedResourceFailures[resourceName] >= cyclesRequired); } else { return(true); } case CheckResultTypes.resultConsumptionSuccess: //Processor needs at least one success if (!processor.consumptionResults[resourceName].completedSuccessfully) { return(false); } if (astronautData.processedResourceSuccesses.ContainsKey(resourceName)) { return(astronautData.processedResourceSuccesses[resourceName] >= cyclesRequired); } else { return(true); } case CheckResultTypes.resultProductionFailure: //Processor needs at least one failure if (processor.consumptionResults[resourceName].completedSuccessfully) { return(false); } if (astronautData.processedResourceFailures.ContainsKey(resourceName)) { return(astronautData.processedResourceFailures[resourceName] >= cyclesRequired); } else { return(true); } case CheckResultTypes.resultProductionSuccess: //Processor needs at least one success if (!processor.consumptionResults[resourceName].completedSuccessfully) { return(false); } if (astronautData.processedResourceSuccesses.ContainsKey(resourceName)) { return(astronautData.processedResourceSuccesses[resourceName] >= cyclesRequired); } else { return(true); } } return(true); }
protected void onRosterResourceUpdated(Vessel vessel, SnacksRosterResource rosterResource, AstronautData astronautData, ProtoCrewMember astronaut) { //Make sure it's a resource we're interested in. if (!rosterResource.resourceName.Contains(StressConditionName)) { return; } //If the resource has gone down below max, then remove the stress condition. if (rosterResource.amount < rosterResource.maxAmount && astronautData.conditionSummary.Contains(StressConditionName)) { astronautData.ClearCondition(StressConditionName); SnacksScenario.Instance.RestoreSkillsIfNeeded(astronaut); ScreenMessages.PostScreenMessage(astronaut.name + " " + StressRecoveryMessage, 5.0f, ScreenMessageStyle.UPPER_LEFT); } //If the resource has maxed out then add the stress condition else if (rosterResource.amount >= rosterResource.maxAmount && !astronautData.conditionSummary.Contains(StressConditionName)) { astronautData.SetCondition(StressConditionName); SnacksScenario.Instance.RemoveSkillsIfNeeded(astronaut); ScreenMessages.PostScreenMessage(vessel.vesselName + ": " + astronaut.name + " " + StressPlayerMessage, 5.0f, ScreenMessageStyle.UPPER_LEFT); } }
public override bool IsValid(ProtoCrewMember astronaut, Vessel vessel) { //Check precondition disqualifier. Some parts can disqualify the precondition. AstronautData astronautData = SnacksScenario.Instance.GetAstronautData(astronaut); if (astronautData == null) { return(true); } int count = situationsToCheck.Count; string preconditionName; for (int index = 0; index < count; index++) { preconditionName = CheckVesselStatusName + "." + situationsToCheck[index].ToString(); if (astronautData.disqualifiedPreconditions.Contains(preconditionName)) { return(false); } } //First check situation if (!situationsToCheck.Contains(vessel.situation)) { return(false); } //Now check body name if (!string.IsNullOrEmpty(bodyName)) { if (vessel.mainBody.name != bodyName) { return(false); } } //Now check altitude if (metersAltitude == double.NegativeInfinity) { switch (checkType) { case CheckValueConditionals.checkEquals: return((vessel.altitude / metersAltitude) <= 0.0001f); case CheckValueConditionals.checkNotEqual: return(vessel.altitude != metersAltitude); case CheckValueConditionals.checkGreaterOrEqual: return(vessel.altitude >= metersAltitude); case CheckValueConditionals.checkGreaterThan: return(vessel.altitude > metersAltitude); case CheckValueConditionals.checkLesserOrEqual: return(vessel.altitude <= metersAltitude); case CheckValueConditionals.checkLessThan: return(vessel.altitude < metersAltitude); } } //Ok, I guess it passes... return(true); }
/// <summary> /// Loads the astronaut data from the config node supplied. /// </summary> /// <returns>A map keyed kerbal name that contains astronaut data.</returns> /// <param name="node">The ConfigNode to read data from.</param> public static DictionaryValueList <string, AstronautData> Load(ConfigNode node) { DictionaryValueList <string, AstronautData> crewData = new DictionaryValueList <string, AstronautData>(); ConfigNode[] astronautNodess = node.GetNodes(AstronautNode); foreach (ConfigNode astronautNode in astronautNodess) { try { AstronautData astronautData = new AstronautData(); astronautData.name = astronautNode.GetValue(AstronautNodeName); astronautData.experienceTrait = astronautNode.GetValue(AstronautNodeTrait); astronautData.lastUpdated = double.Parse(astronautNode.GetValue(AstronautNodeUpdated)); astronautData.isExempt = bool.Parse(astronautNode.GetValue(AstronautNodeExempt)); if (astronautNode.HasValue(AstronautNodeCondition)) { astronautData.conditionSummary = astronautNode.GetValue(AstronautNodeCondition); } if (astronautNode.HasValue(AstronautNodeDisqualifiers)) { astronautData.disqualifiedPreconditions = astronautNode.GetValue(AstronautNodeDisqualifiers); } //Key value pairs astronautData.keyValuePairs = new DictionaryValueList <string, string>(); if (astronautNode.HasNode(KeyValueNode)) { ConfigNode[] keyValuePairs = astronautNode.GetNodes(KeyValueNode); foreach (ConfigNode keyValue in keyValuePairs) { astronautData.keyValuePairs.Add(keyValue.GetValue(KeyValuePairKey), keyValue.GetValue(KeyValuePairValue)); } } //Success/fail counters if (astronautNode.HasNode(ResourceCounterNode)) { ConfigNode[] resourceCounterNodes = astronautNode.GetNodes(ResourceCounterNode); ConfigNode counterNode; string resourceName = string.Empty; int count = 0; bool isSuccess = false; for (int index = 0; index < resourceCounterNodes.Length; index++) { counterNode = resourceCounterNodes[index]; resourceName = counterNode.GetValue(ResourceCounterName); int.TryParse(counterNode.GetValue(ResourceCounterValue), out count); isSuccess = false; bool.TryParse(counterNode.GetValue(ResourceCounterIsSuccess), out isSuccess); if (isSuccess) { astronautData.processedResourceSuccesses.Add(resourceName, count); } else { astronautData.processedResourceFailures.Add(resourceName, count); } } } //Roster resources if (astronautNode.HasNode(SnacksRosterResource.RosterResourceNode)) { astronautData.rosterResources = SnacksRosterResource.LoadFromAstronautData(astronautNode); } crewData.Add(astronautData.name, astronautData); } catch (Exception ex) { Log("error encountered: " + ex + " skipping kerbal."); continue; } } return(crewData); }
public override bool IsValid(ProtoCrewMember astronaut) { if (!base.IsValid(astronaut)) { return(false); } if (string.IsNullOrEmpty(keyValueName)) { return(false); } AstronautData astronautData = SnacksScenario.Instance.GetAstronautData(astronaut); if (astronautData == null) { return(false); } if (!astronautData.keyValuePairs.ContainsKey(keyValueName)) { return(false); } int value = 0; bool valueParsed = int.TryParse(astronautData.keyValuePairs[keyValueName], out value); switch (checkType) { case CheckValueConditionals.checkEquals: if (!string.IsNullOrEmpty(stringValue)) { return(astronautData.keyValuePairs[keyValueName] == stringValue); } else if (valueParsed) { return(value == intValue); } else { return(false); } case CheckValueConditionals.checkNotEqual: if (!string.IsNullOrEmpty(stringValue)) { return(astronautData.keyValuePairs[keyValueName] != stringValue); } else if (valueParsed) { return(value != intValue); } else { return(false); } case CheckValueConditionals.checkGreaterOrEqual: if (valueParsed) { return(value >= intValue); } else { return(false); } case CheckValueConditionals.checkGreaterThan: if (valueParsed) { return(value > intValue); } else { return(false); } case CheckValueConditionals.checkLesserOrEqual: if (valueParsed) { return(value <= intValue); } else { return(false); } case CheckValueConditionals.checkLessThan: if (valueParsed) { return(value < intValue); } else { return(false); } } return(false); }
public override bool IsValid(ProtoCrewMember astronaut) { if (!base.IsValid(astronaut)) { return(false); } if (string.IsNullOrEmpty(resourceName)) { return(false); } //Get roster resource double amount = 0; double maxAmount = 0; double percentage = 0; if (isRosterResource) { AstronautData astronautData = SnacksScenario.Instance.GetAstronautData(astronaut); if (astronautData == null) { return(false); } if (!astronautData.rosterResources.ContainsKey(resourceName)) { return(false); } SnacksRosterResource rosterResource = astronautData.rosterResources[resourceName]; amount = rosterResource.amount; maxAmount = rosterResource.maxAmount; percentage = amount / maxAmount; } //Try to get vessel resource else { if (astronaut.KerbalRef == null || astronaut.KerbalRef.InVessel == null) { return(false); } List <ProtoPartResourceSnapshot> protoPartResources = new List <ProtoPartResourceSnapshot>(); ProcessedResource.GetResourceTotals(astronaut.KerbalRef.InVessel, resourceName, out amount, out maxAmount, protoPartResources); percentage = amount / maxAmount; } //Now perform the check if (checkMaxAmount) { amount = maxAmount; } else if (checkAsPercentage) { amount = percentage; } switch (checkType) { case CheckValueConditionals.checkEquals: return(amount.Equals(valueToCheck)); case CheckValueConditionals.checkGreaterOrEqual: return(amount.Equals(valueToCheck) || amount > valueToCheck); case CheckValueConditionals.checkGreaterThan: return(amount > valueToCheck); case CheckValueConditionals.checkLesserOrEqual: return(amount.Equals(valueToCheck) || amount < valueToCheck); case CheckValueConditionals.checkLessThan: return(amount < valueToCheck); } return(false); }
public override void ProcessResources(Vessel vessel, double elapsedTime, int crewCount, int crewCapacity) { ProtoCrewMember[] astronauts = null; AstronautData astronautData = null; SnacksProcessorResult result = new SnacksProcessorResult(); bool completedSuccessfully = true; float stress = 0; remainingTime += elapsedTime; while (remainingTime >= secondsPerCycle) { //Update remaining time remainingTime -= secondsPerCycle; //Get the crew manifest if (vessel.loaded) { astronauts = vessel.GetVesselCrew().ToArray(); } else { astronauts = vessel.protoVessel.GetVesselCrew().ToArray(); } if (astronauts.Length == 0) { return; } //Setup result productionResults.Clear(); result.crewCount = crewCount; result.crewCapacity = crewCapacity; result.resourceName = StressResourceName; result.completedSuccessfully = true; //Update max space updateMaxSpace(vessel); //Now increase stress in the vessel's crew. SnacksRosterResource resource; for (int index = 0; index < astronauts.Length; index++) { //Reset flag completedSuccessfully = true; //Get astronaut data astronautData = SnacksScenario.Instance.GetAstronautData(astronauts[index]); if (astronautData == null) { continue; } if (!astronautData.rosterResources.ContainsKey(StressResourceName)) { continue; } //Get the Stress roster resource resource = astronautData.rosterResources[StressResourceName]; //Increase stress; stupidity matters stress = (1 - astronauts[index].stupidity); //Is kerbal a badass? Then reduce acquired stress if (astronauts[index].isBadass) { stress *= 0.5f; } //Account for homerworld or world with oxygen atmosphere if (vessel.mainBody.isHomeWorld && vessel.LandedOrSplashed) { stress *= 0.25f; } else if (vessel.mainBody.atmosphere && vessel.mainBody.atmosphereContainsOxygen && vessel.LandedOrSplashed) { stress *= 0.75f; } resource.amount += stress; astronautData.rosterResources[StressResourceName] = resource; //Check for failure conditions if (resource.amount >= resource.maxAmount) { //Set the flags completedSuccessfully = false; result.completedSuccessfully = false; //Incease affected kerbal count result.affectedKerbalCount += 1; //Add astronaut to the affected list if (result.afftectedAstronauts == null) { result.afftectedAstronauts = new List <ProtoCrewMember>(); } result.afftectedAstronauts.Add(astronauts[index]); } //Process results if (!completedSuccessfully) { applyFailureOutcomes(vessel, result); } else { removeFailureOutcomes(vessel); } } //Record results productionResults.Add(StressResourceName, result); } }
public override void onKerbalBoardedVessel(ProtoCrewMember astronaut, Part part) { if (part == null || part.vessel == null) { return; } ProtoCrewMember[] astronauts = null; AstronautData astronautData = null; Vessel vessel = part.vessel; SnacksProcessorResult result = new SnacksProcessorResult(); SnacksRosterResource resource; bool completedSuccessfully = true; //Get the crew manifest if (vessel.loaded) { astronauts = vessel.GetVesselCrew().ToArray(); } else { astronauts = vessel.protoVessel.GetVesselCrew().ToArray(); } if (astronauts.Length == 0) { return; } //Update max space updateMaxSpace(part.vessel); result.crewCount = astronauts.Length; result.crewCapacity = astronauts.Length; result.resourceName = StressResourceName; result.completedSuccessfully = true; //Now make sure kerbals aren't stressed out, or apply outcomes if they are. for (int index = 0; index < astronauts.Length; index++) { //Reset flag completedSuccessfully = true; //Get astronaut data astronautData = SnacksScenario.Instance.GetAstronautData(astronauts[index]); if (astronautData == null) { continue; } if (!astronautData.rosterResources.ContainsKey(StressResourceName)) { continue; } //Get the Stress roster resource resource = astronautData.rosterResources[StressResourceName]; //Check for failure conditions if (resource.amount >= resource.maxAmount) { //Set the flags completedSuccessfully = false; result.completedSuccessfully = false; //Incease affected kerbal count result.affectedKerbalCount += 1; //Add astronaut to the affected list if (result.afftectedAstronauts == null) { result.afftectedAstronauts = new List <ProtoCrewMember>(); } result.afftectedAstronauts.Add(astronauts[index]); } } //Process results if (!completedSuccessfully) { applyFailureOutcomes(vessel, result); } else { removeFailureOutcomes(vessel); } }
public int GetMealsMissed(ProtoCrewMember astronaut) { AstronautData data = GetAstronautData(astronaut); return(data.mealsMissed); }
public void SetMealsMissed(ProtoCrewMember astronaut, int mealsMissed) { AstronautData data = GetAstronautData(astronaut); data.mealsMissed = mealsMissed; }
public override bool IsValid(ProtoCrewMember astronaut, Vessel vessel) { //Check precondition disqualifier. Some parts like centrifuges //disqualify the low-gee precondition check AstronautData astronautData = SnacksScenario.Instance.GetAstronautData(astronaut); if (astronautData == null) { return(true); } string preconditionName = CheckGravityConditionName + "." + checkType.ToString(); if (astronautData.disqualifiedPreconditions.Contains(preconditionName)) { return(false); } //Get gee force double vesselGeeForce; if (vessel.loaded) { vesselGeeForce = vessel.graviticAcceleration.magnitude; } else { if (vessel.protoVessel.vesselModules.HasNode("SnacksVesselModule")) { ConfigNode node = vessel.protoVessel.vesselModules.GetNode("SnacksVesselModule"); if (node.HasValue(SnacksVesselModule.ValueGeeForce)) { double.TryParse(node.GetValue(SnacksVesselModule.ValueGeeForce), out vesselGeeForce); } else { return(false); } } else { return(false); } } //Adjust for microgravity if (vessel.situation == Vessel.Situations.ESCAPING || vessel.situation == Vessel.Situations.ORBITING || vessel.situation == Vessel.Situations.SUB_ORBITAL) { vesselGeeForce = 0; } //Now make the comparison switch (checkType) { case CheckValueConditionals.checkEquals: return(vesselGeeForce.Equals(valueToCheck)); case CheckValueConditionals.checkNotEqual: return(!vesselGeeForce.Equals(valueToCheck)); case CheckValueConditionals.checkGreaterOrEqual: return(vesselGeeForce >= valueToCheck); case CheckValueConditionals.checkGreaterThan: return(vesselGeeForce > valueToCheck); case CheckValueConditionals.checkLesserOrEqual: return(vesselGeeForce <= valueToCheck); case CheckValueConditionals.checkLessThan: return(vesselGeeForce < valueToCheck); } return(false); }