// Amount < 0 signifies use existing amount if exists, or create with max amount
public static PartResource AddOrCreateResource(this Part part, PartResourceDefinition info, float maxAmount, float amount)
{
if (amount > maxAmount)
{
part.LogWarning($"Cannot add resource '{info.name}' with amount > maxAmount, will use maxAmount (amount = {amount}, maxAmount = {maxAmount})");
amount = maxAmount;
}
PartResource resource = part.Resources[info.name];
if (resource == null)
{
if (amount < 0f)
amount = maxAmount;
resource = part.AddResource(info, maxAmount, amount);
}
else
{
resource.maxAmount = maxAmount;
if (amount >= 0f)
resource.amount = amount;
}
return resource;
}
public static double IsResourceAvailable(this Part part, PartResourceDefinition resource, double demand)
{
if (resource == null)
{
Debug.LogError("Tac.PartExtensions.IsResourceAvailable: resource is null");
return 0.0;
}
switch (resource.resourceFlowMode)
{
case ResourceFlowMode.NO_FLOW:
return IsResourceAvailable_NoFlow(part, resource, demand);
case ResourceFlowMode.ALL_VESSEL:
return IsResourceAvailable_AllVessel(part, resource, demand);
case ResourceFlowMode.STACK_PRIORITY_SEARCH:
return IsResourceAvailable_StackPriority(part, resource, demand);
/*case ResourceFlowMode.EVEN_FLOW:
Debug.LogWarning("Tac.PartExtensions.IsResourceAvailable: ResourceFlowMode.EVEN_FLOW is not supported yet.");
return IsResourceAvailable_AllVessel(part, resource, demand);
*/
default:
Debug.LogWarning("Tac.PartExtensions.IsResourceAvailable: Unknown ResourceFlowMode = " + resource.resourceFlowMode.ToString());
return IsResourceAvailable_AllVessel(part, resource, demand);
}
}
public ResourceInfo(ConfigNode node)
{
node.TryGetValue("name", ref this.name);
resource = PartResourceLibrary.Instance.GetDefinition(this.Name);
node.TryGetValue("realName", ref this.realName);
node.TryGetValue("colour", ref this.colour);
}
// Constructor
PersistentPropellant(Propellant p)
{
propellant = p;
definition = PartResourceLibrary.Instance.GetDefinition(propellant.name);
density = definition.density;
ratio = propellant.ratio;
}
public AggregateResourceValue(PartResourceDefinition definition, SharedObjects shared)
{
name = definition.name;
density = definition.density;
this.shared = shared;
resources = new List<PartResource>();
InitializeAggregateResourceSuffixes();
}
public float getResourceVolume(String name, PartResourceDefinition def)
{
float val = 0;
if (!resourceVolumes.TryGetValue(name, out val))
{
val = def == null ? 5.0f : def.volume;
}
return val;
}
public void Load(ConfigNode node)
{
int resourceID = node.GetValue("name").GetHashCode();
if (PartResourceLibrary.Instance.resourceDefinitions.Any(rd => rd.id == resourceID))
{
resource = PartResourceLibrary.Instance.resourceDefinitions[resourceID];
float.TryParse(node.GetValue("ratio"), out ratio);
}
}
public void Load(ConfigNode node)
{
string resourceID = node.GetValue("name");
if (PartResourceLibrary.Instance.resourceDefinitions.Contains(resourceID))
{
resource = PartResourceLibrary.Instance.resourceDefinitions[resourceID];
float.TryParse(node.GetValue("ratio"), out ratio);
}
}
public override void OnStart(PartModule.StartState state)
{
Transform intakeTransform = part.FindModelTransform(intakeTransformName);
if (intakeTransform == null)
Debug.Log("[KSPI] AtmosphericIntake unable to get intake transform for " + part.name);
_intake_direction = intakeTransform != null ? intakeTransform.forward.normalized : Vector3.forward;
_resourceAtmosphere = PartResourceLibrary.Instance.GetDefinition(InterstellarResourcesConfiguration.Instance.IntakeAtmosphere);
// ToDo: connect with atmospheric intake to readout updated area
// ToDo: change density of air to
}
public override bool Load(ConfigNode configNode)
{
// Load base class
bool valid = base.Load(configNode);
valid &= ConfigNodeUtil.ParseValue<double>(configNode, "minRate", x => minRate = x, this, double.MinValue);
valid &= ConfigNodeUtil.ParseValue<double>(configNode, "maxRate", x => maxRate = x, this, double.MaxValue);
valid &= ConfigNodeUtil.ParseValue<PartResourceDefinition>(configNode, "resource", x => resource = x, this);
return valid;
}
public override string GetInfo()
{
var info = base.GetInfo();
var mass_flow = ConversionRate*EnergyConsumption*RatesMultiplier;
info += string.Format("Mass Extraction: {0}/sec\n", Utils.formatMass(mass_flow));
resource = PartResourceLibrary.Instance.GetDefinition(OutputResource);
if(resource != null)
info += string.Format("Produces {0}: {1}/sec",
OutputResource, Utils.formatUnits(mass_flow*Efficiency/resource.density));
return info;
}
public ResourceTransferValue(TransferManager transferManager, PartResourceDefinition resourceInfo, object transferTo, object transferFrom)
{
this.transferManager = transferManager;
this.resourceInfo = resourceInfo;
this.transferTo = transferTo;
this.transferFrom = transferFrom;
DetermineTypes();
InitializeSuffixes();
Status = TransferManager.TransferStatus.Inactive; // Last because the setter for Status prints some of the values calculated above to the log
}
ResourceTransfer (Part fromPart, Part toPart, PartResourceDefinition resource, float amount)
{
internalFromPart = fromPart;
internalToPart = toPart;
internalResource = resource;
FromPart = new Parts.Part (fromPart);
ToPart = new Parts.Part (toPart);
Resource = resource.name;
TotalAmount = amount;
// Compute the transfer rate (in units/sec) as one tenth the size of the destination tank (determined experimentally from the KSP transfer UI)
var totalStorage = (float)toPart.Resources.Get (resource.id).maxAmount;
transferRate = 0.1f * totalStorage;
ResourceTransferAddon.AddTransfer (this);
}
public static PartResource AddResource(this Part part, PartResourceDefinition info, float maxAmount, float amount)
{
PartResource resource = new PartResource(part);
resource.SetInfo(info);
resource.maxAmount = maxAmount;
resource.amount = amount;
resource.flowState = true;
resource.isTweakable = info.isTweakable;
resource.isVisible = info.isVisible;
resource.hideFlow = false;
resource.flowMode = PartResource.FlowMode.Both;
part.Resources.dict.Add(info.name.GetHashCode(), resource);
return resource;
}
public ResourceConsumption(double minRate, double maxRate, PartResourceDefinition resource, string title = null)
: base(title)
{
if (minRate < 0 && maxRate < 0 && maxRate < minRate)
{
this.minRate = maxRate;
this.maxRate = minRate;
}
else
{
this.minRate = minRate;
this.maxRate = maxRate;
}
this.resource = resource;
}
public void Load (ConfigNode node)
{
string name = node.GetValue ("name");
res_def = PartResourceLibrary.Instance.GetDefinition (name);
if (node.HasValue ("isMineable")) {
bool.TryParse (node.GetValue ("isMineable"), out isMineable);
}
if (node.HasValue ("isHullResource")) {
bool.TryParse (node.GetValue ("isHullResource"),
out isHullResource);
}
if (node.HasValue ("volume")) {
float.TryParse (node.GetValue ("volume"), out volume);
}
}
public ResourceItem(ConfigNode data, string resource, string body, string type, System.Random random)
{
DefaultResource defaultResource = DefaultLibrary.GetDefault(MapGenerator.DefaultName).GetBody(body).GetResourceOfType(resource, type);
this.resource = PartResourceLibrary.Instance.GetDefinition(data.GetValue("name"));
this.type = KRESUtils.GetResourceType(type);
this.map = null;
if (!data.TryGetValue("actualDensity", ref actualDensity))
{
actualDensity = KRESUtils.Clamp01(defaultResource.Density * (0.97d + (random.NextDouble() * 0.06d)));
}
if (!data.TryGetValue("actualError", ref actualError))
{
actualError = (random.NextDouble() * 2d) - 1d;
data.AddValue("actualError", actualError);
}
}
private static double GetResourceMass(List <ProtoPartResourceSnapshot> resources)
{
double mass = 0;
//Loop through the available resources
foreach (ProtoPartResourceSnapshot resource in resources)
{
//Extract the amount information
double amount = resource.amount;
//Using the name of the resource, find it in the PartResourceLibrary
PartResourceDefinition RD = PartResourceLibrary.Instance.GetDefinition(resource.resourceName);
//The mass of that resource is the amount times the density
mass += amount * RD.density;
}
//Return the total mass
return(mass);
}
protected bool canAffordReconfigure()
{
if (HighLogic.LoadedSceneIsFlight == false)
{
return(true);
}
if (!payForReconfigure)
{
return(true);
}
bool canAffordCost = false;
string notEnoughPartsMsg;
PartResourceDefinition definition = ResourceHelper.DefinitionForResource(resourceRequired);
Vessel.ActiveResource resource = this.part.vessel.GetActiveResource(definition);
calculateRemodelCostModifier();
double amount = resourceCost * (1.0 - reconfigureCostModifier);
//An inflatable part that hasn't been inflated yet is an automatic pass.
if (switcher.isInflatable && !switcher.isDeployed)
{
return(true);
}
//now check to make sure the vessel has enough parts.
if (resource == null)
{
canAffordCost = false;
}
else if (resource.amount < amount)
{
canAffordCost = false;
}
if (!canAffordCost)
{
notEnoughPartsMsg = string.Format(kInsufficientParts, amount, resourceRequired);
ScreenMessages.PostScreenMessage(notEnoughPartsMsg, 5.0f, ScreenMessageStyle.UPPER_CENTER);
return(false);
}
return(true);
}
public bool UpdateLode()
{
if (HighLogic.LoadedSceneIsFlight == false)
{
return(false);
}
//If we aren't landed then we're done.
if (this.part.vessel.situation != Vessel.Situations.PRELAUNCH && this.part.vessel.situation != Vessel.Situations.LANDED)
{
//Inform player
lodeStatus = Localizer.Format(statusNoNearbyName);
return(false);
}
//Find the nearest node
findNearestLode();
if (nearestLode == null)
{
//Inform player
lodeStatus = Localizer.Format(statusNoNearbyName);
return(false);
}
//Check units remaining
if (nearestLode.amountRemaining == 0)
{
//Inform player
debugLog("Converter stopped. Lode is depleted.");
ScreenMessages.PostScreenMessage(string.Format(depletedMessage, nearestLode.resourceName), kMessageDisplayTime, ScreenMessageStyle.UPPER_CENTER);
return(false);
}
//Ok, we've got a valid lode, we're in harvest range, there are units remaining, it's dark, and we're wearing sunglasses.
//Hit it!
//Find the resource definition for the output resource
outputDef = ResourceHelper.DefinitionForResource(nearestLode.resourceName);
if (outputDef == null)
{
debugLog("No definition for " + nearestLode.resourceName);
StopResourceConverter();
return(false);
}
return(true);
}
public override void OnStart(PartModule.StartState state)
{
Debug.Log("[KSPI]: AtmosphericIntake OnStart Reading PluginHelper Upgrades");
JetUpgradeTech1 = PluginHelper.JetUpgradeTech1;
JetUpgradeTech2 = PluginHelper.JetUpgradeTech2;
JetUpgradeTech3 = PluginHelper.JetUpgradeTech3;
JetUpgradeTech4 = PluginHelper.JetUpgradeTech4;
JetUpgradeTech5 = PluginHelper.JetUpgradeTech5;
hasJetUpgradeTech1 = PluginHelper.HasTechRequirementOrEmpty(PluginHelper.JetUpgradeTech1);
hasJetUpgradeTech2 = PluginHelper.HasTechRequirementOrEmpty(PluginHelper.JetUpgradeTech2);
hasJetUpgradeTech3 = PluginHelper.HasTechRequirementOrEmpty(PluginHelper.JetUpgradeTech3);
hasJetUpgradeTech4 = PluginHelper.HasTechRequirementOrEmpty(PluginHelper.JetUpgradeTech4);
hasJetUpgradeTech5 = PluginHelper.HasTechRequirementOrEmpty(PluginHelper.JetUpgradeTech5);
var jetTech = Convert.ToInt32(hasJetUpgradeTech1) * 1.2f + 1.44f * Convert.ToInt32(hasJetUpgradeTech2) + 1.728f * Convert.ToInt32(hasJetUpgradeTech3) + 2.0736f * Convert.ToInt32(hasJetUpgradeTech4) + 2.48832f * Convert.ToInt32(hasJetUpgradeTech5);
jetTechBonus = 5 * (1 + (jetTech / 9.92992f));
_moduleResourceIntake = this.part.FindModulesImplementing <ModuleResourceIntake>().FirstOrDefault(m => m.resourceName == InterstellarResourcesConfiguration._INTAKE_AIR);
_resourceAtmosphereDefinition = PartResourceLibrary.Instance.GetDefinition(InterstellarResourcesConfiguration.Instance.IntakeAtmosphere);
if (_moduleResourceIntake == null)
{
Debug.LogWarning("[KSPI]: ModuleResourceIntake with IntakeAir is missing on " + part.partInfo.title);
}
var field = Fields["intakeOpen"];
var flightToggle = field.uiControlFlight as UI_Toggle;
var editorToggle = field.uiControlEditor as UI_Toggle;
flightToggle.onFieldChanged = IntakeOpenChanged;
editorToggle.onFieldChanged = IntakeOpenChanged;
UpdateResourceIntakeConfiguration();
if (state == StartState.Editor)
{
return; // don't do any of this stuff in editor
}
resourceBuffers = new ResourceBuffers();
resourceBuffers.AddConfiguration(new ResourceBuffers.TimeBasedConfig(InterstellarResourcesConfiguration.Instance.IntakeAtmosphere, 300, area * unitScalar * 100));
resourceBuffers.Init(this.part);
}
public override void TestStartUp()
{
base.TestStartUp();
part.partInfo = new AvailablePart(); // So that it thinks it's loading from a save
module.baseVolume = 1;
resourceDef1 = new PartResourceDefinition("resource1");
resourceDef2 = new PartResourceDefinition("resource2");
resourceDef3 = new PartResourceDefinition("resource3");
TankResource tankResource1 = new TankResource();
tankResource1.resourceDefinition = resourceDef1;
TankResource tankResource2 = new TankResource();
tankResource2.resourceDefinition = resourceDef1;
TankResource tankResource3 = new TankResource();
tankResource3.resourceDefinition = resourceDef2;
TankType tankType1 = new TankType();
tankType1.resources.Add(tankResource1);
TankType tankType2 = new TankType();
tankType2.resources.Add(tankResource2);
tankType2.resources.Add(tankResource3);
subtype1 = new PartSubtype();
subtype1.subtypeName = "subtype1";
subtype1.tankType = tankType1;
module.subtypes.Add(subtype1);
subtype2 = new PartSubtype();
subtype2.subtypeName = "subtype2";
subtype2.tankType = tankType2;
module.subtypes.Add(subtype2);
subtype3 = new PartSubtype();
subtype3.subtypeName = "subtype3";
subtype3.tankType = B9TankSettings.StructuralTankType;
module.subtypes.Add(subtype3);
}
private double?GetResourceOfCurrentStage(string resourceName)
{
PartResourceDefinition resourceDef = PartResourceLibrary.Instance.resourceDefinitions.FirstOrDefault(pr => string.Equals(pr.name, resourceName, StringComparison.CurrentCultureIgnoreCase));
if (resourceDef == null)
{
throw new KOSInvalidArgumentException("STAGE", resourceName, "The resource definition could not be found");
}
var list = new List <PartResource>();
if (resourceDef.resourceFlowMode == ResourceFlowMode.STACK_PRIORITY_SEARCH)
{
var engines = VesselUtils.GetListOfActivatedEngines(shared.Vessel);
foreach (var engine in engines)
{
engine.GetConnectedResources(resourceDef.id, resourceDef.resourceFlowMode, list);
}
}
else if (resourceDef.resourceFlowMode == ResourceFlowMode.NO_FLOW)
{
var engines = VesselUtils.GetListOfActivatedEngines(shared.Vessel);
foreach (var engine in engines)
{
list.AddRange(engine.Resources.GetAll(resourceDef.id));
}
}
else
{
shared.Vessel.rootPart.GetConnectedResources(resourceDef.id, resourceDef.resourceFlowMode, list);
}
if (list.Count == 0)
{
return(null);
}
double available = 0.0;
double capacity = 0.0;
foreach (var resource in list)
{
available += resource.amount;
capacity += resource.maxAmount;
}
return(Math.Round(available, 2));
}
private SnackConfiguration()
{
PartResourceDefinition snacksResource = PartResourceLibrary.Instance.GetDefinition("Snacks");
snackResourceId = snacksResource.id;
//PartResourceDefinition soilResource = PartResourceLibrary.Instance.GetDefinition("Soil");
//soilResourceId = soilResource.id;
string file = IOUtils.GetFilePathFor(this.GetType(), "snacks.cfg");
Debug.Log("loading file:" + file);
node = ConfigNode.Load(file).GetNode("SNACKS");
snacksPerMeal = double.Parse(node.GetValue("snacksPerMeal"));
lossPerDayPerKerbal = double.Parse(node.GetValue("repLossPercent"));
mealsPerDay = int.Parse(node.GetValue("mealsPerDay"));
delayedReaction = double.Parse(node.GetValue("delayedReaction"));
kerbalDeath = bool.Parse(node.GetValue("kerbalDeath"));
Debug.Log("snacksPerMeal:" + snacksPerMeal + "mealsPerDay:" + mealsPerDay);
}
public static PartResource AddResource(this Part part, PartResourceDefinition info, float maxAmount, float amount)
{
PartResource resource = new PartResource(part);
resource.SetInfo(info);
resource.maxAmount = maxAmount;
resource.amount = amount;
resource.flowState = true;
resource.isTweakable = info.isTweakable;
resource.isVisible = info.isVisible;
resource.hideFlow = false;
resource.flowMode = PartResource.FlowMode.Both;
part.Resources.dict.Add(info.name.GetHashCode(), resource);
GameEvents.onPartResourceListChange.Fire(part);
return(resource);
}
private double GetResourceOfCurrentStage(string resourceName)
{
PartResourceDefinition resourceDef = PartResourceLibrary.Instance.resourceDefinitions[resourceName];
double total = 0;
double capacity = 0;
if (resourceDef == null)
{
throw new KOSInvalidArgumentException("STAGE", resourceName, "The resource definition could not be found");
}
CreatePartSet();
partSet.GetConnectedResourceTotals(resourceDef.id, out total, out capacity, true);
return(total);
}
void Update()
{
if (planet != FlightGlobals.currentMainBody)
{
planet = FlightGlobals.currentMainBody;
if (planet.ocean)
{
PartResourceDefinition ballast = PartResourceLibrary.Instance.GetDefinition("Ballast");
var cfg = new ConfigNode();
ballast.Save(cfg);
cfg.RemoveValues("density");
cfg.AddValue("density", planet.oceanDensity * 0.001);
ballast.Load(cfg);
}
}
}
public static PartResourceDefinition ParseResource(string resourceName)
{
var resourceDefs = PartResourceLibrary.Instance.resourceDefinitions;
PartResourceDefinition resourceInfo = null;
// PartResourceDefinitionList's array index accessor uses the resource id
// instead of as a list index, so we need to use an enumerator.
foreach (var def in resourceDefs)
{
// loop through definitions looking for a case insensitive name match,
// return true if a match is found
if (def.name.Equals(resourceName, StringComparison.OrdinalIgnoreCase))
{
resourceInfo = def;
}
}
return(resourceInfo);
}
/// <summary>
/// Gets the quantity of the given resource for the vessel.
/// </summary>
/// <param name="vessel">Vessel to check</param>
/// <param name="resource">Resource to check for</param>
/// <returns></returns>
public static double ResourceQuantity(this Vessel vessel, PartResourceDefinition resource)
{
if (vessel == null)
{
return 0.0;
}
double quantity = 0.0;
foreach (Part part in vessel.Parts)
{
PartResource pr = part.Resources[resource.name];
if (pr != null)
{
quantity += pr.amount;
}
}
return quantity;
}
public static string GetRequirements(ConfigNode node)
{
StringBuilder requirements = new StringBuilder();
PartResourceDefinition resourceDef = null;
PartResourceDefinitionList definitions = PartResourceLibrary.Instance.resourceDefinitions;
string resourceName = string.Empty;
string displayName;
double amount;
if (node.HasValue(kResourceName))
{
resourceName = node.GetValue(kResourceName);
if (resourceName != kTimeResourceName)
{
resourceDef = definitions[resourceName];
displayName = resourceDef.displayName;
}
else
{
displayName = kTimeResourceDisplayName;
}
requirements.Append(displayName);
requirements.Append(": ");
}
if (node.HasValue(kRequiredAmount))
{
double.TryParse(node.GetValue(kRequiredAmount), out amount);
if (resourceName != kTimeResourceName)
{
requirements.Append(string.Format("{0:n1}", amount));
}
else
{
requirements.Append(KSPUtil.dateTimeFormatter.PrintTimeLong(amount));
}
}
return(requirements.ToString());
}
//------------------- IConfigNode implementation
public void Load(ConfigNode node)
{
if (!(node.name.Equals("TANK") && node.HasValue("name")))
{
return;
}
ConfigNode.LoadObjectFromConfig(this, node);
if (node.HasValue("efficiency") && !node.HasValue("utilization"))
{
float.TryParse(node.GetValue("efficiency"), out utilization);
}
amountExpression = node.GetValue("amount") ?? amountExpression;
maxAmountExpression = node.GetValue("maxAmount") ?? maxAmountExpression;
resourceAvailable = PartResourceLibrary.Instance.GetDefinition(name) != null;
MFSSettings.resourceVsps.TryGetValue(name, out vsp);
MFSSettings.resourceConductivities.TryGetValue(name, out resourceConductivity);
if (node.HasValue("wallThickness"))
{
double.TryParse(node.GetValue("wallThickness"), out wallThickness);
}
if (node.HasValue("wallConduction"))
{
double.TryParse(node.GetValue("wallConduction"), out wallConduction);
}
if (node.HasValue("insulationThickness"))
{
double.TryParse(node.GetValue("insulationThickness"), out insulationThickness);
}
if (node.HasValue("insulationConduction"))
{
double.TryParse(node.GetValue("insulationConduction"), out insulationConduction);
}
if (node.HasValue("boiloffProduct"))
{
boiloffProductResource = PartResourceLibrary.Instance.GetDefinition(node.GetValue("boiloffProduct"));
}
GetDensity();
}
public override void OnStart(StartState state)
{
enabled = true;
boiloffResourceName = boiloffPrefix + resourceName + boiloffPostfix;
coolingResourceName = "_" + resourceName + coolingPostfix;
heatingResourceName = "_" + resourceName + heatingPostfix;
_electricChargeDefinition = PartResourceLibrary.Instance.GetDefinition(StockResourceElectricCharge);
// compensate for stock solar initialization heating issues
part.temperature = storedTemp;
requiresPower = powerReqKW > 0;
isDisabledField = Fields[nameof(isDisabled)];
boiloffStrField = Fields[nameof(boiloffStr)];
powerStatusStrField = Fields[nameof(powerStatusStr)];
externalTemperatureField = Fields[nameof(externalTemperature)];
if (state == StartState.Editor)
{
return;
}
part.temperature = storedTemp;
part.skinTemperature = storedTemp;
// if electricCharge buffer is missing, add it.
if (!part.Resources.Contains(StockResourceElectricCharge))
{
ConfigNode node = new ConfigNode("RESOURCE");
node.AddValue("name", StockResourceElectricCharge);
node.AddValue("maxAmount", powerReqKW > 0 ? powerReqKW / 50 : 1);
node.AddValue("amount", powerReqKW > 0 ? powerReqKW / 50 : 1);
part.AddResource(node);
}
var cryostatResource = part.Resources[resourceName];
if (cryostatResource != null && Kerbalism.IsLoaded)
{
AddKerbalismVariables();
}
}
private IEnumerator registerWheel()
{
if (wheelRef == null)
{
yield break;
}
yield return(null);
dischargeResources = new List <ResourceConsumer>();
dummyRCS = part.Modules.GetModule <MomentumDischargeThruster>();
if (dummyRCS != null)
{
dischargeRate = dummyRCS.thrusterPower;
double ISP = dummyRCS.atmosphereCurve.Evaluate(0);
double totalPropellantMassRatio = dummyRCS.propellants.Sum(r => r.ratio * PartResourceLibrary.Instance.resourceDefinitions[r.id].density);
double totalMassRate = dummyRCS.thrusterPower * saturationLimit / (ISP * dummyRCS.G);
foreach (Propellant p in dummyRCS.propellants)
{
PartResourceDefinition res = PartResourceLibrary.Instance.resourceDefinitions[p.id];
double propellantRate = p.ratio * totalMassRate / totalPropellantMassRatio;
dischargeResources.Add(new ResourceConsumer(res.id, propellantRate, res.resourceFlowMode));
}
if (dischargeResources.Any(rc => rc.Rate > 0))
{
canForceDischarge = true;
}
}
for (int i = 0; i < 10; i++)
{
yield return(null);
}
VesselInfo partVesselInfo = Window.Instance.Vessels.Find(x => x.vessel == vessel);
if (partVesselInfo == null)
{
partVesselInfo = new VesselInfo(vessel, wheelRef.State == ModuleReactionWheel.WheelState.Active);
Window.Instance.Vessels.Add(partVesselInfo);
}
partVesselInfo.wheels.Add(this);
}
public override void OnStart(StartState state)
{
base.OnStart(state);
GameEvents.onVesselChange.Add(new EventData<Vessel>.OnEvent(this.OnVesselChange));
if (state == StartState.Editor)
{
Events["paintEvent"].active = false;
return;
}
_paintResource = PartResourceLibrary.Instance.GetDefinition("SpacePaint");
_paint = this.part.Resources.Get(_paintResource.id);
setPaintState();
if (Global.Debug3) Utils.Log("paint resource id: {0}", _paintResource);
if (Global.Debug3) Utils.Log("paint: {0}/{1}", _paint.amount, _paint.maxAmount);
}
/// <summary>
/// Gets the quantity of the given resource for the vessel.
/// </summary>
/// <param name="vessel">Vessel to check</param>
/// <param name="resource">Resource to check for</param>
/// <returns></returns>
public static double ResourceQuantity(this Vessel vessel, PartResourceDefinition resource)
{
if (vessel == null)
{
return(0.0);
}
double quantity = 0.0;
foreach (Part part in vessel.Parts)
{
PartResource pr = part.Resources[resource.name];
if (pr != null)
{
quantity += pr.amount;
}
}
return(quantity);
}
public FreeReactant(PartResource res, Vector3d worldPosition, Vector3d worldVelocity)
{
this.resource = res.info;
this.resourceMass = res.amount * resource.density;
//assume amount is in L, aka 0.001 m^3
this.volume = res.amount * 0.001;
this.effectiveRadius = volume * 0.75 / Math.PI;
this.effectiveRadius = Math.Pow(effectiveRadius, (1.0 / 3.0));
this.worldPosition = worldPosition;
this.worldVelocity = worldVelocity;
timeAlive = 0.0;
expired = false;
//Debug.Log("[Blastwave]: Created a free reactant of type " + res.resourceName + " with " + this.resourceMass + " t of mass and " + this.effectiveRadius + " size bubble");
}
public override void OnStart(StartState state)
{
Debug.Log("[KSPI]: AtmosphericIntake OnStart Reading PluginHelper Upgrades");
JetUpgradeTech1 = PluginSettings.Config.JetUpgradeTech1;
JetUpgradeTech2 = PluginSettings.Config.JetUpgradeTech2;
JetUpgradeTech3 = PluginSettings.Config.JetUpgradeTech3;
JetUpgradeTech4 = PluginSettings.Config.JetUpgradeTech4;
JetUpgradeTech5 = PluginSettings.Config.JetUpgradeTech5;
hasJetUpgradeTech1 = PluginHelper.HasTechRequirementOrEmpty(PluginSettings.Config.JetUpgradeTech1);
hasJetUpgradeTech2 = PluginHelper.HasTechRequirementOrEmpty(PluginSettings.Config.JetUpgradeTech2);
hasJetUpgradeTech3 = PluginHelper.HasTechRequirementOrEmpty(PluginSettings.Config.JetUpgradeTech3);
hasJetUpgradeTech4 = PluginHelper.HasTechRequirementOrEmpty(PluginSettings.Config.JetUpgradeTech4);
hasJetUpgradeTech5 = PluginHelper.HasTechRequirementOrEmpty(PluginSettings.Config.JetUpgradeTech5);
var jetTech = Convert.ToInt32(hasJetUpgradeTech1) * 1.2f + 1.44f * Convert.ToInt32(hasJetUpgradeTech2) + 1.728f * Convert.ToInt32(hasJetUpgradeTech3) + 2.0736f * Convert.ToInt32(hasJetUpgradeTech4) + 2.48832f * Convert.ToInt32(hasJetUpgradeTech5);
jetTechBonus = 5 * (1 + (jetTech / 9.92992f));
_moduleResourceIntake = part.FindModulesImplementing <ModuleResourceIntake>().FirstOrDefault(m => m.resourceName == KITResourceSettings.IntakeOxygenAir);
_resourceAtmosphereDefinition = PartResourceLibrary.Instance.GetDefinition(KITResourceSettings.IntakeAtmosphere);
if (_moduleResourceIntake == null)
{
Debug.LogWarning("[KSPI]: ModuleResourceIntake with IntakeAir is missing on " + part.partInfo.title);
}
var field = Fields[nameof(intakeOpen)];
if (field.uiControlFlight is UI_Toggle flightToggle)
{
flightToggle.onFieldChanged = IntakeOpenChanged;
}
if (field.uiControlEditor is UI_Toggle editorToggle)
{
editorToggle.onFieldChanged = IntakeOpenChanged;
}
UpdateResourceIntakeConfiguration();
// if (state == StartState.Editor) return; // don't do any of this stuff in editor
}
private static List <Resource> ResourceList(AvailablePart p)
{
if (p == null)
{
return(null);
}
List <Resource> resources = new List <Resource>();
foreach (PartResource r in p.partPrefab.Resources)
{
PartResourceDefinition resource = PartResourceLibrary.Instance.resourceDefinitions.Where(prd => prd.name == r.resourceName).FirstOrDefault();
if (resource != null)
{
resources.Add(new Resource(resource));
}
}
return(resources);
}
void AddTank_GUI(PartResourceDefinition res)
{
if (GUILayout.Button("Add"))
{
double vol = (volume - resourceVolume) * 1000;
double maxAmount = vol / res.volume;
double amount = maxAmount;
if (!res.isTweakable)
{
amount = 0;
}
AddTank(res.name, amount, maxAmount);
for (int i = counterparts.Length; i-- > 0;)
{
var c = (ContainerResource)counterparts[i];
c.AddTank(res.name, amount, maxAmount);
}
}
}
public override void OnStart(StartState state)
{
base.OnStart(state);
try
{
PartResourceDefinitionList definitions = PartResourceLibrary.Instance.resourceDefinitions;
PartResourceDefinition resourceDef = definitions[refuelResource];
totalFuelCost = resourceDef.unitCost * this.part.Resources[refuelResource].maxAmount;
fuelDistanceMeters = fuelIncreaseDistance * 1000f;
Events["BuyResource"].guiName = "Buy " + refuelResource;
}
catch (Exception ex)
{
Debug.Log("[WBIGasStation] error during OnStart: " + ex);
}
}
/// <summary>
/// Override to the normal config parser, so we can load the resources
/// </summary>
/// <param name="cfgNode"></param>
/// <returns></returns>
internal override KKFacility ParseConfig(ConfigNode cfgNode)
{
base.ParseConfig(cfgNode);
tradedResByID = new Dictionary <int, TradedResource>();
tradedResources = new Dictionary <string, TradedResource>();
string resourceName = null;
PartResourceDefinition foundResource = null;
TradedResource tradedResource = null;
foreach (ConfigNode resourceNode in cfgNode.GetNodes("TradedResource"))
{
resourceName = resourceNode.GetValue("ResourceName");
foundResource = PartResourceLibrary.Instance.GetDefinition(resourceName);
if (foundResource == null)
{
Log.UserWarning("Resource not found: " + resourceName);
}
else
{
double multiplierBuy;
double multiplierSell;
bool canBeBought;
bool canBeSold;
double.TryParse(resourceNode.GetValue("MultiplierBuy"), out multiplierBuy);
double.TryParse(resourceNode.GetValue("MultiplierSell"), out multiplierSell);
bool.TryParse(resourceNode.GetValue("CanBeBought"), out canBeBought);
bool.TryParse(resourceNode.GetValue("CanBeSold"), out canBeSold);
tradedResource = new TradedResource()
{
resource = foundResource,
multiplierBuy = multiplierSell,
multiplierSell = multiplierSell,
canBeBought = canBeBought,
canBeSold = canBeSold
};
AddResource(tradedResource);
}
}
return(this);
}
public void Load(ConfigNode node)
{
string name = node.GetValue("name");
res_def = PartResourceLibrary.Instance.GetDefinition(name);
if (node.HasValue("isMineable"))
{
bool.TryParse(node.GetValue("isMineable"), out isMineable);
}
if (node.HasValue("isHullResource"))
{
bool.TryParse(node.GetValue("isHullResource"),
out isHullResource);
}
if (node.HasValue("volume"))
{
float.TryParse(node.GetValue("volume"), out volume);
}
}
private static double IsResourceAvailable_AllVessel(Part part, PartResourceDefinition resource, double demand)
{
var allPartResources = part.vessel.parts.Where(p => p.Resources.Contains(resource.id) &&
p.Resources.Get(resource.id).flowState == true &&
p.Resources.Get(resource.id).flowMode != PartResource.FlowMode.None
).Select(p => p.Resources.Get(resource.id));
if (demand >= 0.0)
{
double amountAvailable = 0.0;
var allNonInPartResources = allPartResources.Where(p => p.flowMode != PartResource.FlowMode.In);
foreach (PartResource partResource in allNonInPartResources)
{
amountAvailable += partResource.amount;
if (amountAvailable >= demand)
{
return(demand);
}
}
return(amountAvailable);
}
else
{
double availableSpace = 0.0;
var allNonOutPartResources = allPartResources.Where(p => p.flowMode != PartResource.FlowMode.Out);
foreach (PartResource partResource in allNonOutPartResources)
{
availableSpace += (partResource.maxAmount - partResource.amount);
if (availableSpace >= -demand)
{
return(demand);
}
}
return(-availableSpace);
}
}
static Resources()
{
Log.Info("defining resources");
try
{
LoadResources();
Log.Info("defining stock resources");
LIQUID_FUEL = resources[Constants.RESOURCE_NAME_LIQUID_FUEL];
XENON_GAS = resources[Constants.RESOURCE_NAME_XENON_GAS];
SOLID_FUEL = resources[Constants.RESOURCE_NAME_SOLID_FUEL];
ELECTRIC_CHARGE = resources[Constants.RESOURCE_NAME_ELECTRIC_CHARGE];
INTAKE_AIR = resources[Constants.RESOURCE_NAME_INTAKE_AIR];
OXIDIZER = resources[Constants.RESOURCE_NAME_OXIDIZER];
MONOPROPELLANT = resources[Constants.RESOURCE_NAME_MONOPROPELLANT];
EVA_PROPELLANT = resources[Constants.RESOURCE_NAME_EVA_PROPELLANT];
ABLATOR = resources[Constants.RESOURCE_NAME_ABLATOR];
ORE = resources[Constants.RESOURCE_NAME_ORE];
Log.Info("defining TAC life support resources");
FOOD = OptionalResource(Constants.RESOURCE_NAME_FOOD);
WATER = OptionalResource(Constants.RESOURCE_NAME_WATER);
CARBONDIOXIDE = OptionalResource(Constants.RESOURCE_NAME_CARBONDIOXIDE);
WASTE = OptionalResource(Constants.RESOURCE_NAME_WASTE);
WASTEWATER = OptionalResource(Constants.RESOURCE_NAME_WASTEWATER);
OXYGEN = OptionalResource(Constants.RESOURCE_NAME_OXYGEN);
Log.Info("defining Khetane resources");
KETHANE = OptionalResource(Constants.RESOURCE_NAME_KETHANE);
KINTAKE_AIR = OptionalResource(Constants.RESOURCE_NAME_KINTAKE_AIR);
Log.Info("defining Deadly Reentry resources");
ABLATIVE_SHIELDING = OptionalResource(Constants.RESOURCE_NAME_ABLATIVE_SHIELDING);
Log.Info("defining Real Fuels resources");
KARBONITE = OptionalResource(Constants.RESOURCE_NAME_KARBONITE);
Log.Info("defining Kerbalism resources");
CRAP = OptionalResource(Constants.RESOURCE_NAME_CRAP);
CO2 = OptionalResource(Constants.RESOURCE_NAME_CO2);
Log.Info("resources completely defined");
}
catch
{
Log.Error("defining resources failed");
throw;
}
}
public override void OnStart(StartState state)
{
base.OnStart(state);
//ModuleActiveRadiator
activeRadiator = this.part.FindModuleImplementing <ModuleActiveRadiator>();
//Get the resource definition for electric charge.
electricChargeDef = definitions["ElectricCharge"];
//Set cooling mode. For now, default is closed.
coolingCycleMode = CoolingCycleModes.closed;
Events["ToggleCoolingMode"].guiName = "Cooling Mode (closed)";
//Dig into the proto part and find the coolant resource nodes.
getCoolantNodes();
//Load the sound effects
LoadSoundFX();
}
public override void OnStart(StartState state)
{
base.OnStart(state);
//Get the resource definition for electric charge.
electricChargeDef = definitions["ElectricCharge"];
//Since we are based upon the ModuleDeployableSolarPanel, hide its gui
Fields["sunAOA"].guiActive = false;
Fields["flowRate"].guiActive = false;
//Set cooling mode. For now, default is closed.
coolingCycleMode = CoolingCycleModes.closed;
Events["ToggleCoolingMode"].guiName = "Cooling Mode (closed)";
//Dig into the proto part and find the coolant resource nodes.
getCoolantNodes();
this.part.OnJustAboutToBeDestroyed = OnAboutToBeDestroyed;
}
public override void OnStart(PartModule.StartState state)
{
antimatter_def = PartResourceLibrary.Instance.GetDefinition(InterstellarResourcesConfiguration.Instance.Antimatter);
if (state == StartState.Editor)
{
return;
}
if (last_active_time != 0 && vessel.orbit.eccentricity < 1)
{
double lat = vessel.mainBody.GetLatitude(vessel.transform.position);
double vessel_avg_alt = (vessel.orbit.ApR + vessel.orbit.PeR) / 2;
double vessel_inclination = vessel.orbit.inclination;
double flux = collectionMultiplier * 0.5 * (vessel.mainBody.GetBeltAntiparticles(vessel_avg_alt, vessel_inclination) + vessel.mainBody.GetBeltAntiparticles(vessel_avg_alt, 0.0));
double time_diff = Planetarium.GetUniversalTime() - last_active_time;
double antimatter_to_add = time_diff * flux;
part.RequestResource(antimatter_def.id, -antimatter_to_add, ResourceFlowMode.STACK_PRIORITY_SEARCH);
}
}
private double GetAmountOfResourceSpace(Vessel v, PartResourceDefinition resource)
{
var maxAmount = 0d;
var curAmount = 0d;
var count = v.parts.Count;
for (int i = 0; i < count; ++i)
{
var p = v.parts[i];
if (!p.Resources.Contains(resource.name))
{
continue;
}
var rr = p.Resources[resource.name];
maxAmount += rr.maxAmount;
curAmount += rr.amount;
}
return(maxAmount - curAmount);
}
// Gets connected resources to a part. Note fuel lines are NOT reversible! Add flow going TO the constructing part!
// Safe to pass any string for name - if specified resource does not exist, a Partresource with amount 0 will be returned
public static List <PartResource> GetConnectedResources(Part part, String resourceName)
{
var resources = new List <PartResource>();
// Only check for connected resources if a Resource Definition for that resource exists
if (PartResourceLibrary.Instance.resourceDefinitions.Contains(resourceName) == true)
{
PartResourceDefinition res = PartResourceLibrary.Instance.GetDefinition(resourceName);
part.GetConnectedResources(res.id, resources);
}
// Do not return an empty list - if none of the resource found, create resource item and set amount to 0
if (resources.Count < 1)
{
PartResource p = new PartResource();
p.resourceName = resourceName;
p.amount = (double)0;
resources.Add(p);
}
return(resources);
}
public TransferableResource(PartResourceDefinition r)
{
resource = r;
name = resource.name;
mode = resource.resourceTransferMode;
switch (name)
{
case "LiquidFuel":
icon = EVATransfer_Startup.lfIcon;
color = XKCDColors.LightRed;
break;
case "Oxidizer":
icon = EVATransfer_Startup.loxIcon;
color = XKCDColors.OrangeyYellow;
break;
case "MonoPropellant":
icon = EVATransfer_Startup.monoIcon;
color = Color.white;
break;
case "XenonGas":
icon = EVATransfer_Startup.xenonIcon;
color = XKCDColors.AquaBlue;
break;
case "ElectricCharge":
icon = EVATransfer_Startup.ecIcon;
color = XKCDColors.SunnyYellow;
break;
case "Ore":
icon = EVATransfer_Startup.oreIcon;
color = XKCDColors.Purple_Pink;
break;
default:
icon = null;
color = Color.white;
break;
}
if (icon != null)
primary = true;
}
public static double IsResourceAvailable(this Part part, PartResourceDefinition resource, double demand)
{
if (resource == null)
{
Debug.LogError("USI.PartExtensions.IsResourceAvailable: resource is null");
return 0.0;
}
switch (resource.resourceFlowMode)
{
case ResourceFlowMode.NO_FLOW:
return IsResourceAvailable_NoFlow(part, resource, demand);
default:
return IsResourceAvailable_AllVessel(part, resource, demand);
//case ResourceFlowMode.STACK_PRIORITY_SEARCH:
// return IsResourceAvailable_StackPriority(part, resource, demand);
//default:
// Debug.LogWarning("USI.PartExtensions.IsResourceAvailable: Unknown ResourceFlowMode = " + resource.resourceFlowMode.ToString());
// return IsResourceAvailable_AllVessel(part, resource, demand);
}
}
public ResourceItem(ConfigNode data, string resource, string body, System.Random random)
{
DefaultResource defaultResource = DefaultLibrary.GetDefault(MapGenerator.DefaultName).GetBody(body).GetResourceOfType(resource, "ore");
this.resource = PartResourceLibrary.Instance.GetDefinition(resource);
this.type = ResourceType.ORE;
double density = defaultResource.Density;
this.map = new ResourceMap(defaultResource, body);
if (!data.TryGetValue("actualDensity", ref actualDensity))
{
Texture2D texture = Map.GetTexture();
actualDensity = texture.GetPixels().Count(p => p.a > 0) / mapResolution;
Texture2D.Destroy(texture);
data.AddValue("actualDensity", actualDensity);
}
if (!data.TryGetValue("actualError", ref actualError))
{
actualError = (random.NextDouble() * 2d) - 1d;
data.AddValue("actualError", actualError);
}
}
private static double TakeResource_StackPriority(Part part, PartResourceDefinition resource, double demand)
{
// FIXME finish implementing
return part.RequestResource(resource.id, demand);
}
private static double TakeResource_NoFlow(Part part, PartResourceDefinition resource, double demand)
{
// ignoring PartResourceDefinition.ResourceTransferMode
PartResource partResource = part.Resources.Get(resource.id);
if (partResource != null)
{
if (partResource.flowMode == PartResource.FlowMode.None)
{
Debug.LogWarning("Tac.PartExtensions.TakeResource_NoFlow: cannot take resource from a part where FlowMode is None.");
return 0.0;
}
else if (!partResource.flowState)
{
// Resource flow was shut off -- no warning needed
return 0.0;
}
else if (demand >= 0.0)
{
if (partResource.flowMode == PartResource.FlowMode.In)
{
Debug.LogWarning("Tac.PartExtensions.TakeResource_NoFlow: cannot take resource from a part where FlowMode is In.");
return 0.0;
}
double taken = Math.Min(partResource.amount, demand);
partResource.amount -= taken;
return taken;
}
else
{
if (partResource.flowMode == PartResource.FlowMode.Out)
{
Debug.LogWarning("Tac.PartExtensions.TakeResource_NoFlow: cannot give resource to a part where FlowMode is Out.");
return 0.0;
}
double given = Math.Min(partResource.maxAmount - partResource.amount, -demand);
partResource.amount += given;
return -given;
}
}
else
{
return 0.0;
}
}
private static double TakeResource_AllVessel(Part part, PartResourceDefinition resource, double demand)
{
if (demand >= 0.0)
{
double leftOver = demand;
// Takes an equal percentage from each part (rather than an equal amount from each part)
List<PartResource> partResources = GetAllPartResources(part.vessel, resource, true);
double totalAmount = 0.0;
foreach (PartResource partResource in partResources)
{
totalAmount += partResource.amount;
}
if (totalAmount > 0.0)
{
double percentage = Math.Min(leftOver / totalAmount, 1.0);
foreach (PartResource partResource in partResources)
{
double taken = partResource.amount * percentage;
partResource.amount -= taken;
leftOver -= taken;
}
}
return demand - leftOver;
}
else
{
double leftOver = -demand;
List<PartResource> partResources = GetAllPartResources(part.vessel, resource, false);
double totalSpace = 0.0;
foreach (PartResource partResource in partResources)
{
totalSpace += partResource.maxAmount - partResource.amount;
}
if (totalSpace > 0.0)
{
double percentage = Math.Min(leftOver / totalSpace, 1.0);
foreach (PartResource partResource in partResources)
{
double space = partResource.maxAmount - partResource.amount;
double given = space * percentage;
partResource.amount += given;
leftOver -= given;
}
}
return demand + leftOver;
}
}
private static double IsResourceAvailable_StackPriority(Part part, PartResourceDefinition resource, double demand)
{
// FIXME finish implementing
return IsResourceAvailable_AllVessel(part, resource, demand);
}
private static double IsResourceAvailable_NoFlow(Part part, PartResourceDefinition resource, double demand)
{
PartResource partResource = part.Resources.Get(resource.id);
if (partResource != null)
{
if (partResource.flowMode == PartResource.FlowMode.None || partResource.flowState == false)
{
return 0.0;
}
else if (demand > 0.0)
{
if (partResource.flowMode != PartResource.FlowMode.In)
{
return Math.Min(partResource.amount, demand);
}
}
else
{
if (partResource.flowMode != PartResource.FlowMode.Out)
{
return -Math.Min((partResource.maxAmount - partResource.amount), -demand);
}
}
}
return 0.0;
}
private static double IsResourceAvailable_AllVessel(Part part, PartResourceDefinition resource, double demand)
{
if (demand >= 0.0)
{
double amountAvailable = 0.0;
foreach (Part p in part.vessel.parts)
{
PartResource partResource = p.Resources.Get(resource.id);
if (partResource != null)
{
if (partResource.flowState && partResource.flowMode != PartResource.FlowMode.None && partResource.flowMode != PartResource.FlowMode.In)
{
amountAvailable += partResource.amount;
if (amountAvailable >= demand)
{
return demand;
}
}
}
}
return amountAvailable;
}
else
{
double availableSpace = 0.0;
double demandedSpace = -demand;
foreach (Part p in part.vessel.parts)
{
PartResource partResource = p.Resources.Get(resource.id);
if (partResource != null)
{
if (partResource.flowState && partResource.flowMode != PartResource.FlowMode.None && partResource.flowMode != PartResource.FlowMode.Out)
{
availableSpace += (partResource.maxAmount - partResource.amount);
if (availableSpace >= demandedSpace)
{
return demand;
}
}
}
}
return -availableSpace;
}
}
private static List<PartResource> GetAllPartResources(Vessel vessel, PartResourceDefinition resource, bool consuming)
{
// ignoring PartResourceDefinition.ResourceTransferMode
List<PartResource> resources = new List<PartResource>();
foreach (Part p in vessel.parts)
{
PartResource partResource = p.Resources.Get(resource.id);
if (partResource != null)
{
if (partResource.flowState && partResource.flowMode != PartResource.FlowMode.None)
{
if (consuming)
{
if (partResource.flowMode != PartResource.FlowMode.In && partResource.amount > 0.0)
{
resources.Add(partResource);
}
}
else
{
if (partResource.flowMode != PartResource.FlowMode.Out && partResource.amount < partResource.maxAmount)
{
resources.Add(partResource);
}
}
}
}
}
return resources;
}
private void init()
{
if (initialized) { return; }
initialized = true;
if (HighLogic.LoadedSceneIsEditor || HighLogic.LoadedSceneIsFlight)
{
updateCrewCapacity(inflated ? inflatedCrew : deflatedCrew);
}
animation = SSTUAnimateControlled.locateAnimationController(part, animationID, onAnimStateChange);
if (animation != null)
{
AnimState state = inflated ? AnimState.STOPPED_END : AnimState.STOPPED_START;
animation.setToState(state);
}
BaseEvent evt = Events["inflateEvent"];
evt.guiActive = evt.guiActiveEditor = !inflated;
evt = Events["deflateEvent"];
evt.guiActiveEditor = inflated;
evt.guiActive = inflated && (HighLogic.LoadedSceneIsEditor || canDeflate);
resourceDef = PartResourceLibrary.Instance.GetDefinition(resourceName);
if (resourceDef == null)
{
MonoBehaviour.print("ERROR: Could not locate resource for name: " + resourceName + " for " + this.name);
}
updateRequiredMass();
}
