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);
}
