public void SetActive(Vessel.ActiveResource resource) { try { ResourceData res = Array.Find(rs, t => t.name == resource.info.name); res.stage = (float)resource.amount; res.stagemax = (float)resource.maxAmount; } catch (Exception e) { JUtil.LogErrorMessage(this, "Error SetActive {0}: {1}", resource.info.name, e); } }
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); }
protected float calculateRepairCost() { float repairUnits = repairAmount; if (FlightGlobals.ActiveVessel.isEVA == false) { return(-1.0f); //Should not get to here as the event is set up for EVA only. } //Anybody can repair the scope, but the right skill can reduce the cost by as much as 60% Experience.ExperienceTrait experience = FlightGlobals.ActiveVessel.GetVesselCrew()[0].experienceTrait; if (experience.TypeName == repairSkill) { repairUnits = repairUnits * (0.9f - (experience.CrewMemberExperienceLevel() * 0.1f)); } //Now make sure the kerbal has enough resources to conduct repairs. //Get the resource definition PartResourceDefinition definition = ResourceHelper.DefinitionForResource(repairResource); if (definition == null) { return(-1.0f); } //make sure the ship has enough of the resource Vessel.ActiveResource activeResource = FlightGlobals.ActiveVessel.GetActiveResource(definition); if (activeResource == null) { return(-1.0f); } if (activeResource.amount < repairUnits) { return(-1.0f); } return(repairUnits); }
public void SetActive(Vessel.ActiveResource resource) { data[resource.info.id].stage = resource.amount; data[resource.info.id].stagemax = resource.maxAmount; }
protected override bool canAffordReconfigure(string templateName) { if (HighLogic.LoadedSceneIsFlight == false) { return(true); } if (!payForReconfigure) { return(true); } string value; bool canAffordCost = false; requriredResource = templatesModel[templateName].GetValue("rocketParts"); if (string.IsNullOrEmpty(requriredResource) == false) { float reconfigureAmount = float.Parse(requriredResource); PartResourceDefinition definition = ResourceHelper.DefinitionForResource("RocketParts"); Vessel.ActiveResource resource = this.part.vessel.GetActiveResource(definition); //An inflatable part that hasn't been inflated yet is an automatic pass. if (isInflatable && !isDeployed) { return(true); } //Get the current template's rocket part cost. value = CurrentTemplate.GetValue("rocketParts"); if (string.IsNullOrEmpty(value) == false) { float recycleAmount = float.Parse(value); //calculate the amount of parts that we can recycle. recycleAmount *= calculateRecycleAmount(); //Now recalculate rocketPartCost, accounting for the parts we can recycle. //A negative value means we'll get parts back, a positive number means we pay additional parts. //Ex: current configuration takes 1200 parts. new configuration takes 900. //We recycle 90% of the current configuration (1080 parts). //The reconfigure cost is: 900 - 1080 = -180 parts //If we reverse the numbers so new configuration takes 1200: 1200 - (900 * .9) = 390 reconfigureCost = reconfigureAmount - recycleAmount; } //now check to make sure the vessel has enough parts. if (resource == null) { canAffordCost = false; } else if (resource.amount < reconfigureCost) { canAffordCost = false; } else { canAffordCost = true; } } if (!canAffordCost) { string notEnoughPartsMsg = string.Format(kInsufficientParts, reconfigureCost, "RocketParts"); ScreenMessages.PostScreenMessage(notEnoughPartsMsg, 5.0f, ScreenMessageStyle.UPPER_CENTER); return(false); } return(true); }
public override void ToggleInflation() { PartResourceDefinition definition = ResourceHelper.DefinitionForResource("RocketParts"); Vessel.ActiveResource resource = this.part.vessel.GetActiveResource(definition); string parts = CurrentTemplate.GetValue("rocketParts"); if (string.IsNullOrEmpty(parts)) { base.ToggleInflation(); return; } float partCost = float.Parse(parts); calculateRemodelCostModifier(); float adjustedPartCost = partCost; if (reconfigureCostModifier > 0f) { adjustedPartCost *= reconfigureCostModifier; } //Do we pay for resources? If so, either pay the resources if we're deploying the module, or refund the recycled parts if (payForReconfigure) { //If we aren't deployed then see if we can afford to pay the resource cost. if (!isDeployed) { //Can we afford it? if (resource == null || resource.amount < adjustedPartCost) { notEnoughParts(); string notEnoughPartsMsg = string.Format("Insufficient resources to assemble the module. You need a total of {0:f2} RocketParts to assemble.", partCost); ScreenMessages.PostScreenMessage(notEnoughPartsMsg, 5.0f, ScreenMessageStyle.UPPER_CENTER); return; } //Yup, we can afford it //Pay the reconfigure cost reconfigureCost = adjustedPartCost; payPartsCost(); // Toggle after payment. base.ToggleInflation(); } //We are deployed, calculate the amount of parts that can be refunded. else { // Toggle first in case deflate confirmation is needed, we'll check the state after the toggle. base.ToggleInflation(); // deflateConfirmed's logic seems backward. if (!HasResources() || (HasResources() && deflateConfirmed == false)) { // The part came from the factory configured which represents an additional resource cost. If reconfigured in the field, the difference was paid at // that time. Deflating doesn't remove any functionality, so no refund beyond the original adjusted part cost. float recycleAmount = adjustedPartCost; //Do we have sufficient space in the vessel to store the recycled parts? float availableStorage = (float)(resource.maxAmount - resource.amount); if (availableStorage < recycleAmount) { float amountLost = recycleAmount - availableStorage; ScreenMessages.PostScreenMessage(string.Format("Module deflated, {0:f2} {1:s} lost due to insufficient storage.", amountLost, "RocketParts"), 5.0f, ScreenMessageStyle.UPPER_CENTER); //We'll only recycle what we have room to store. recycleAmount = availableStorage; } //Yup, we have the space reconfigureCost = -recycleAmount; payPartsCost(); } } } // Not paying for reconfiguration, check for skill requirements else { if (checkForSkill) { if (hasSufficientSkill(CurrentTemplateName)) { base.ToggleInflation(); } else { return; } } else { base.ToggleInflation(); } } }
public ActiveResourceValue(Vessel.ActiveResource activeResource, SharedObjects shared) { this.activeResource = activeResource; this.shared = shared; InitializeActiveResourceSuffixes(); }
public ActiveResourceValue(Vessel.ActiveResource activeResource, SharedObjects shared) { this.activeResource = activeResource; this.shared = shared; InitializeActiveResourceSuffixes(); }