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