Exemple #1
0
        public override void OnFixedUpdate()
        {
            if (isupgraded)
            {
                double power_returned = CheatOptions.InfiniteElectricity
                    ? upgradedMegajouleRate
                    : consumeFNResource(upgradedMegajouleRate * TimeWarp.fixedDeltaTime, FNResourceManager.FNRESOURCE_MEGAJOULES) / TimeWarp.fixedDeltaTime;

                electrical_power_ratio = power_returned / upgradedMegajouleRate;
                double altitude_multiplier = vessel.altitude / vessel.mainBody.Radius;
                altitude_multiplier = Math.Max(altitude_multiplier, 1);

                var scienceMultiplier = PluginHelper.getScienceMultiplier(vessel);

                science_rate_f = (float)(baseScienceRate * scienceMultiplier / GameConstants.KEBRIN_DAY_SECONDS * power_returned / upgradedMegajouleRate / Math.Sqrt(altitude_multiplier));

                if (ResearchAndDevelopment.Instance != null && !double.IsInfinity(science_rate_f) && !double.IsNaN(science_rate_f))
                {
                    science_to_add += science_rate_f * TimeWarp.fixedDeltaTime;
                }
            }
            //else
            //{
            //    if (moduleCommand != null)
            //    {
            //        var fixedNeededPower = megajouleRate * TimeWarp.fixedDeltaTime;
            //        float power_returned = consumeFNResource(fixedNeededPower, FNResourceManager.FNRESOURCE_MEGAJOULES) / TimeWarp.fixedDeltaTime;
            //        var electrical_power_ratio = Math.Round(power_returned / megajouleRate, 1);
            //        moduleCommand.enabled = electrical_power_ratio == 1;
            //    }
            //}

            last_active_time = (float)Planetarium.GetUniversalTime();
        }
        public override void OnUpdate()
        {
            base.OnUpdate();

            if (_moduleDataTransmitter != null)
            {
                _moduleDataTransmitter.antennaPower = IsEnabled && IsPowered ? activeAIControlDistance : inactiveAIControlDistance;
            }

            if (ResearchAndDevelopment.Instance != null)
            {
                _retrofitCoreEvent.active = !isupgraded && ResearchAndDevelopment.Instance.Science >= upgradeCost;
            }
            else
            {
                _retrofitCoreEvent.active = false;
            }

            var isUpgradedOrNoActiveScience = isupgraded || !PluginHelper.TechnologyIsInUse;

            _isEnabledField.guiActive      = isUpgradedOrNoActiveScience;
            _upgradeCostStrField.guiActive = !isupgraded;
            _nameStrField.guiActive        = isUpgradedOrNoActiveScience;
            _scienceRateField.guiActive    = isUpgradedOrNoActiveScience;
            _isPoweredField.guiActive      = isUpgradedOrNoActiveScience;

            var science = _scienceRateF * GameConstants.KEBRIN_DAY_SECONDS * PluginHelper.getScienceMultiplier(vessel);

            scienceRate = science.ToString("0.000") + "/ Day";

            if (ResearchAndDevelopment.Instance != null)
            {
                upgradeCostStr = ResearchAndDevelopment.Instance.Science + "/" + upgradeCost.ToString("0") + " Science";//
            }
        }
Exemple #3
0
        protected override bool generateScienceData()
        {
            ScienceExperiment experiment = ResearchAndDevelopment.GetExperiment(experimentID);

            if (experiment == null)
            {
                return(false);
            }

            if (science_to_add > 0)
            {
                result_title = experiment.experimentTitle;
                //result_string = "Science experiments were conducted in the vicinity of " + vessel.mainBody.name + ".";

                result_string = this.nameStr + " " + getRandomExperimentResult();

                transmit_value = science_to_add;
                recovery_value = science_to_add;
                data_size      = science_to_add * 1.25f;
                xmit_scalar    = 1;

                ScienceSubject subject = ResearchAndDevelopment.GetExperimentSubject(experiment, ScienceUtil.GetExperimentSituation(vessel), vessel.mainBody, "");

                subject.scienceCap = 167 * PluginHelper.getScienceMultiplier(vessel.mainBody.flightGlobalsIndex, false);
                ref_value          = subject.scienceCap;

                science_data = new ScienceData(science_to_add, 1, 0, subject.id, "Science Lab Data");

                return(true);
            }
            return(false);
        }
Exemple #4
0
        public override void OnFixedUpdate()
        {
            if (!isupgraded)
            {
                float power_returned = consumeFNResource(megajouleRate * TimeWarp.fixedDeltaTime, FNResourceManager.FNRESOURCE_MEGAJOULES);
            }
            else
            {
                if (ResearchAndDevelopment.Instance != null)
                {
                    if (!double.IsNaN(science_awaiting_addition) && !double.IsInfinity(science_awaiting_addition) && science_awaiting_addition > 0)
                    {
                        ResearchAndDevelopment.Instance.Science = ResearchAndDevelopment.Instance.Science + (float)science_awaiting_addition;
                        ScreenMessages.PostScreenMessage(science_awaiting_addition.ToString("0") + " science has been added to the R&D centre.", 2.5f, ScreenMessageStyle.UPPER_CENTER);
                        science_awaiting_addition = 0;
                    }
                }

                float power_returned = consumeFNResource(upgradedMegajouleRate * TimeWarp.fixedDeltaTime, FNResourceManager.FNRESOURCE_MEGAJOULES) / TimeWarp.fixedDeltaTime;
                electrical_power_ratio = power_returned / upgradedMegajouleRate;
                float altitude_multiplier = (float)(vessel.altitude / (vessel.mainBody.Radius));
                altitude_multiplier = Math.Max(altitude_multiplier, 1);
                science_rate_f      = baseScienceRate * PluginHelper.getScienceMultiplier(vessel.mainBody.flightGlobalsIndex, vessel.LandedOrSplashed) / 86400 * power_returned / upgradedMegajouleRate / ((float)Math.Sqrt(altitude_multiplier));
                //part.RequestResource("Science", -science_rate_f * TimeWarp.fixedDeltaTime);
                if (ResearchAndDevelopment.Instance != null)
                {
                    ResearchAndDevelopment.Instance.Science = ResearchAndDevelopment.Instance.Science + science_rate_f * TimeWarp.fixedDeltaTime;
                }
            }
            last_active_time = (float)Planetarium.GetUniversalTime();
        }
Exemple #5
0
        protected override bool generateScienceData()
        {
            ScienceExperiment experiment = ResearchAndDevelopment.GetExperiment(experimentID);
            if (experiment == null)
                return false;

            if (science_to_add > 0)
            {
                ScienceSubject subject = ResearchAndDevelopment.GetExperimentSubject(experiment, ScienceUtil.GetExperimentSituation(vessel), vessel.mainBody, "", "");
                if (subject == null)
                    return false;
                subject.subjectValue = PluginHelper.getScienceMultiplier(vessel);
                subject.scienceCap = 167 * subject.subjectValue; 
                subject.dataScale = 1.25f;

                double remaining_base_science = (subject.scienceCap - subject.science) / subject.subjectValue;
                science_to_add = Math.Min(science_to_add, remaining_base_science);

                // transmission of zero data breaks the experiment result dialog box
                data_size = Math.Max(float.Epsilon, science_to_add * subject.dataScale);
                science_data = new ScienceData((float)data_size, 1, 0, subject.id, "Science Lab Data");

                result_title = experiment.experimentTitle;
                result_string = this.nameStr + " " + getRandomExperimentResult();

                recovery_value = science_to_add;
                transmit_value = recovery_value;
                xmit_scalar = 1;
                ref_value = subject.scienceCap;

                return true;
            }
            return false;
        }
        protected override bool generateScienceData()
        {
            ScienceExperiment experiment = ResearchAndDevelopment.GetExperiment("ExpInterstellarTelescope");

            if (experiment == null)
            {
                return(false);
            }

            if (science_awaiting_addition > 0)
            {
                result_title  = "Infrared Telescope Experiment";
                result_string = "Infrared telescope observations were recovered from the vicinity of " + vessel.mainBody.name + ".";

                transmit_value = science_awaiting_addition;
                recovery_value = science_awaiting_addition;
                data_size      = science_awaiting_addition * 1.25f;
                xmit_scalar    = 1;

                ScienceSubject subject = ResearchAndDevelopment.GetExperimentSubject(experiment, ExperimentSituations.InSpaceHigh, vessel.mainBody, "");
                subject.scienceCap = 167 * PluginHelper.getScienceMultiplier(vessel.mainBody.flightGlobalsIndex, false);
                ref_value          = subject.scienceCap;

                science_data = new ScienceData(science_awaiting_addition, 1, 0, subject.id, "Infrared Telescope Data");

                return(true);
            }
            return(false);
        }
        // Public Overrides
        public override void OnStart(StartState state)
        {
            string[] resourcesToSupply = { ResourceSettings.Config.ThermalPowerInMegawatt, ResourceSettings.Config.ChargedParticleInMegawatt, ResourceSettings.Config.ElectricPowerInMegawatt, ResourceSettings.Config.WasteHeatInMegawatt };
            this.resources_to_supply = resourcesToSupply;

            _isEnabledField      = Fields[nameof(IsEnabled)];
            _isPoweredField      = Fields[nameof(IsPowered)];
            _upgradeCostStrField = Fields[nameof(upgradeCostStr)];
            _retrofitCoreEvent   = Events[nameof(RetrofitCore)];
            _nameStrField        = Fields[nameof(nameStr)];
            _scienceRateField    = Fields[nameof(scienceRate)];

            if (state == StartState.Editor)
            {
                if (!this.HasTechsRequiredToUpgrade())
                {
                    return;
                }

                isupgraded = true;
                upgradePartModule();
                return;
            }

            Debug.Log("[KSPI]: ComputerCore on " + part.name + " was Force Activated");
            part.force_activate();

            _moduleDataTransmitter = part.FindModuleImplementing <ModuleDataTransmitter>();
            _moduleCommand         = part.FindModuleImplementing <ModuleCommand>();
            _moduleAIHome          = part.FindModuleImplementing <AIHome>();

            if (isupgraded || !PluginHelper.TechnologyIsInUse)
            {
                upgradePartModule();
            }
            else
            {
                computercoreType = originalName;
            }

            if (IsEnabled)
            {
                var timeDifference     = Planetarium.GetUniversalTime() - last_active_time;
                var altitudeMultiplier = vessel.altitude / vessel.mainBody.Radius;
                altitudeMultiplier = Math.Max(altitudeMultiplier, 1);

                var scienceMultiplier = PluginHelper.getScienceMultiplier(vessel);

                var scienceToIncrement = baseScienceRate * timeDifference / GameConstants.KEBRIN_DAY_SECONDS * electrical_power_ratio * scienceMultiplier / (Math.Sqrt(altitudeMultiplier));
                scienceToIncrement = (double.IsNaN(scienceToIncrement) || double.IsInfinity(scienceToIncrement)) ? 0 : scienceToIncrement;
                science_to_add    += scienceToIncrement;
            }

            _effectivePowerRequirement = (isupgraded ? upgradedMegajouleRate : megajouleRate) * powerReqMult;
        }
        public override void OnFixedUpdate()
        {
            base.OnFixedUpdate();

            if (isupgraded && IsEnabled)
            {
                double power_returned = CheatOptions.InfiniteElectricity
                    ? upgradedMegajouleRate
                    : consumeFNResourcePerSecond(effectivePowerRequirement, ResourceManager.FNRESOURCE_MEGAJOULES);

                electrical_power_ratio = power_returned / effectivePowerRequirement;
                IsPowered = electrical_power_ratio > 0.99;

                if (IsPowered)
                {
                    double altitude_multiplier = vessel.altitude / vessel.mainBody.Radius;
                    altitude_multiplier = Math.Max(altitude_multiplier, 1);

                    var scienceMultiplier = PluginHelper.getScienceMultiplier(vessel);

                    science_rate_f = baseScienceRate * scienceMultiplier / GameConstants.KEBRIN_DAY_SECONDS * power_returned / effectivePowerRequirement / Math.Sqrt(altitude_multiplier);

                    if (ResearchAndDevelopment.Instance != null && !double.IsInfinity(science_rate_f) && !double.IsNaN(science_rate_f))
                    {
                        science_to_add += science_rate_f * TimeWarp.fixedDeltaTime;
                    }
                }
                else
                {
                    // return any unused power
                    part.RequestResource(ResourceManager.FNRESOURCE_MEGAJOULES, -power_returned * TimeWarp.fixedDeltaTime);
                }
            }
            else
            {
                IsPowered              = false;
                science_rate_f         = 0;
                electrical_power_ratio = 0;
                science_to_add         = 0;
            }

            //else
            //{
            //    if (moduleCommand != null)
            //    {
            //        var fixedNeededPower = megajouleRate * TimeWarp.fixedDeltaTime;
            //        float power_returned = consumeFNResource(fixedNeededPower, ResourceManager.FNRESOURCE_MEGAJOULES) / TimeWarp.fixedDeltaTime;
            //        var electrical_power_ratio = Math.Round(power_returned / megajouleRate, 1);
            //        moduleCommand.enabled = electrical_power_ratio == 1;
            //    }
            //}

            last_active_time = Planetarium.GetUniversalTime();
        }
        // Public Overrides
        public override void OnStart(PartModule.StartState state)
        {
            String[] resources_to_supply = { ResourceManager.FNRESOURCE_THERMALPOWER, ResourceManager.FNRESOURCE_CHARGED_PARTICLES, ResourceManager.FNRESOURCE_MEGAJOULES, ResourceManager.FNRESOURCE_WASTEHEAT, };
            this.resources_to_supply = resources_to_supply;

            _isEnabledField      = Fields["IsEnabled"];
            _isPoweredField      = Fields["IsPowered"];
            _upgradeCostStrField = Fields["upgradeCostStr"];
            _retrofitCoreEvent   = Events["RetrofitCore"];
            _nameStrField        = Fields["nameStr"];
            _scienceRateField    = Fields["scienceRate"];

            if (state == StartState.Editor)
            {
                if (this.HasTechsRequiredToUpgrade())
                {
                    isupgraded = true;
                    upgradePartModule();
                }
                return;
            }

            UnityEngine.Debug.Log("[KSPI]: ComputerCore on " + part.name + " was Force Activated");
            this.part.force_activate();

            _moduleDataTransmitter = part.FindModuleImplementing <ModuleDataTransmitter>();
            moduleCommand          = part.FindModuleImplementing <ModuleCommand>();

            if (isupgraded || !PluginHelper.TechnologyIsInUse)
            {
                upgradePartModule();
            }
            else
            {
                computercoreType = originalName;
            }

            if (IsEnabled)
            {
                double time_diff           = Planetarium.GetUniversalTime() - last_active_time;
                double altitude_multiplier = vessel.altitude / vessel.mainBody.Radius;
                altitude_multiplier = Math.Max(altitude_multiplier, 1);

                var scienceMultiplier = PluginHelper.getScienceMultiplier(vessel);

                double science_to_increment = baseScienceRate * time_diff / GameConstants.KEBRIN_DAY_SECONDS * electrical_power_ratio * scienceMultiplier / (Math.Sqrt(altitude_multiplier));
                science_to_increment = (double.IsNaN(science_to_increment) || double.IsInfinity(science_to_increment)) ? 0 : science_to_increment;
                science_to_add      += science_to_increment;
            }

            effectivePowerRequirement = (isupgraded ? upgradedMegajouleRate : megajouleRate) * powerReqMult;
        }
        public override void OnStart(PartModule.StartState state)
        {
            String[] resources_to_supply = { ResourceManager.FNRESOURCE_MEGAJOULES };
            this.resources_to_supply = resources_to_supply;

            if (state == StartState.Editor)
            {
                if (this.HasTechsRequiredToUpgrade())
                {
                    isupgraded = true;
                    upgradePartModule();
                }
                return;
            }

            this.part.force_activate();

            _moduleDataTransmitter = part.FindModuleImplementing <ModuleDataTransmitter>();
            moduleCommand          = part.FindModuleImplementing <ModuleCommand>();

            Fields["IsEnabled"].guiActive       = isupgraded;
            Fields["IsEnabled"].guiActiveEditor = isupgraded;

            if ((isupgraded || !PluginHelper.TechnologyIsInUse) && IsEnabled)
            {
                upgradePartModule();

                double now                 = Planetarium.GetUniversalTime();
                double time_diff           = now - last_active_time;
                double altitude_multiplier = vessel.altitude / vessel.mainBody.Radius;
                altitude_multiplier = Math.Max(altitude_multiplier, 1);

                var scienceMultiplier = PluginHelper.getScienceMultiplier(vessel);

                double science_to_increment = baseScienceRate * time_diff / GameConstants.KEBRIN_DAY_SECONDS * electrical_power_ratio * scienceMultiplier / (Math.Sqrt(altitude_multiplier));
                science_to_increment = (double.IsNaN(science_to_increment) || double.IsInfinity(science_to_increment)) ? 0 : science_to_increment;
                science_to_add      += science_to_increment;

                //var curReaction = this.part.Modules["ModuleReactionWheel"] as ModuleReactionWheel;
                //curReaction.PitchTorque = 5;
                //curReaction.RollTorque = 5;
                //curReaction.YawTorque = 5;
            }
            else
            {
                computercoreType = originalName;
            }

            effectivePowerRequirement = (isupgraded ? upgradedMegajouleRate : megajouleRate) * powerReqMult;
        }
        public override void OnUpdate()
        {
            if (vessel.IsInAtmosphere())
            {
                telescopeIsEnabled = false;
            }

            Events["beginOberservations"].active = !vessel.IsInAtmosphere() && !telescopeIsEnabled;
            Events["stopOberservations"].active  = telescopeIsEnabled;
            Fields["sciencePerDay"].guiActive    = telescopeIsEnabled;
            performPcnt   = (perform_factor_d * 100).ToString("0.0") + "%";
            sciencePerDay = (science_rate * 28800 * PluginHelper.getScienceMultiplier(vessel)).ToString("0.00") + " " + Localizer.Format("#LOC_KSPIE_Telescope_ScienceperDa");//Science/Day

            double current_au = Vector3d.Distance(vessel.transform.position, LocalStar.position) / Vector3d.Distance(Homeworld.position, LocalStar.position);

            List <ITelescopeController> telescope_controllers = vessel.FindPartModulesImplementing <ITelescopeController>();

            if (telescope_controllers.Any(tscp => tscp.CanProvideTelescopeControl))
            {
                if (current_au >= 548 && !vessel.IsInAtmosphere())
                {
                    if (vessel.orbit.eccentricity < 0.8)
                    {
                        Events["beginOberservations2"].active = true;
                        gLensStr = (telescopeIsEnabled && dpo) ? Localizer.Format("#LOC_KSPIE_Telescope_Glensstatu1") : Localizer.Format("#LOC_KSPIE_Telescope_Glensstatu2");//"Ongoing.""Available"
                    }
                    else
                    {
                        Events["beginOberservations2"].active = false;
                        gLensStr = Localizer.Format("#LOC_KSPIE_Telescope_Glensstatu3", vessel.orbit.eccentricity.ToString("0.0"));//"Eccentricity: " +  + "; < 0.8 Required"
                    }
                }
                else
                {
                    Events["beginOberservations2"].active = false;
                    gLensStr = Localizer.Format("#LOC_KSPIE_Telescope_Glensstatu4", current_au.ToString("0.0"));// + " AU; Required 548 AU"
                }
            }
            else
            {
                Events["beginOberservations2"].active = false;
                gLensStr = Localizer.Format("#LOC_KSPIE_Telescope_Glensstatu5");//"Science Lab/Computer Core required"
            }

            if (helium_time_scale <= 0)
            {
                performPcnt = Localizer.Format("#LOC_KSPIE_Telescope_Glensstatu6");                        //"Helium Coolant Deprived."
            }
        }
        public override void OnFixedUpdate()
        {
            base.OnFixedUpdate();

            //

            if (isupgraded && IsEnabled)
            {
                var power_returned = CheatOptions.InfiniteElectricity
                    ? effectivePowerRequirement
                    : consumeFNResourcePerSecond(effectivePowerRequirement, ResourceManager.FNRESOURCE_MEGAJOULES);

                electrical_power_ratio = power_returned / effectivePowerRequirement;
                IsPowered = electrical_power_ratio > 0.99;

                if (IsPowered)
                {
                    HighLogic.CurrentGame.Parameters.CustomParams <CommNetParams>().requireSignalForControl = false;

                    double altitude_multiplier = Math.Max(vessel.altitude / vessel.mainBody.Radius, 1);

                    var scienceMultiplier = PluginHelper.getScienceMultiplier(vessel);

                    science_rate_f = baseScienceRate * scienceMultiplier / GameConstants.KEBRIN_DAY_SECONDS * power_returned / effectivePowerRequirement / Math.Sqrt(altitude_multiplier);

                    if (ResearchAndDevelopment.Instance != null && !double.IsInfinity(science_rate_f) && !double.IsNaN(science_rate_f))
                    {
                        science_to_add += science_rate_f * TimeWarp.fixedDeltaTime;
                    }
                }
                else
                {
                    HighLogic.CurrentGame.Parameters.CustomParams <CommNetParams>().requireSignalForControl = true;

                    // return any unused power
                    part.RequestResource(ResourceManager.FNRESOURCE_MEGAJOULES, -power_returned * TimeWarp.fixedDeltaTime);
                }
            }
            else
            {
                IsPowered              = false;
                science_rate_f         = 0;
                electrical_power_ratio = 0;
                science_to_add         = 0;
            }

            last_active_time = Planetarium.GetUniversalTime();
        }
        public override void OnUpdate()
        {
            if (vessel.IsInAtmosphere())
            {
                telescopeIsEnabled = false;
            }

            Events["beginOberservations"].active = !vessel.IsInAtmosphere() && !telescopeIsEnabled;
            Events["stopOberservations"].active  = telescopeIsEnabled;
            Fields["sciencePerDay"].guiActive    = telescopeIsEnabled;
            performPcnt   = (perform_factor_d * 100).ToString("0.0") + "%";
            sciencePerDay = (science_rate * 28800 * PluginHelper.getScienceMultiplier(vessel)).ToString("0.00") + " Science/Day";
            double current_au = Vector3d.Distance(vessel.transform.position, FlightGlobals.Bodies[PluginHelper.REF_BODY_KERBOL].transform.position) / Vector3d.Distance(FlightGlobals.Bodies[PluginHelper.REF_BODY_KERBIN].transform.position, FlightGlobals.Bodies[PluginHelper.REF_BODY_KERBOL].transform.position);
            List <ITelescopeController> telescope_controllers = vessel.FindPartModulesImplementing <ITelescopeController>();

            if (telescope_controllers.Any(tscp => tscp.CanProvideTelescopeControl))
            {
                if (current_au >= 548 && !vessel.IsInAtmosphere())
                {
                    if (vessel.orbit.eccentricity < 0.8)
                    {
                        Events["beginOberservations2"].active = true;
                        gLensStr = (telescopeIsEnabled && dpo) ? "Ongoing." : "Available";
                    }
                    else
                    {
                        Events["beginOberservations2"].active = false;
                        gLensStr = "Eccentricity: " + vessel.orbit.eccentricity.ToString("0.0") + "; < 0.8 Required";
                    }
                }
                else
                {
                    Events["beginOberservations2"].active = false;
                    gLensStr = current_au.ToString("0.0") + " AU; Required 548 AU";
                }
            }
            else
            {
                Events["beginOberservations2"].active = false;
                gLensStr = "Science Lab/Computer Core required";
            }

            if (helium_time_scale <= 0)
            {
                performPcnt = "Helium Coolant Deprived.";
            }
        }
Exemple #14
0
        public override void OnStart(PartModule.StartState state)
        {
            if (state == StartState.Editor)
            {
                if (this.HasTechsRequiredToUpgrade())
                {
                    isupgraded = true;
                    upgradePartModule();
                }
                return;
            }

            moduleCommand = part.FindModuleImplementing <ModuleCommand>();

            if (isupgraded || !PluginHelper.TechnologyIsInUse)
            {
                upgradePartModule();

                double now                 = Planetarium.GetUniversalTime();
                double time_diff           = now - last_active_time;
                float  altitude_multiplier = (float)(vessel.altitude / (vessel.mainBody.Radius));
                altitude_multiplier = Math.Max(altitude_multiplier, 1);

                //var scienceMultiplier = PluginHelper.getScienceMultiplier(vessel.mainBody.flightGlobalsIndex, vessel.LandedOrSplashed);
                var scienceMultiplier = PluginHelper.getScienceMultiplier(vessel);

                double science_to_increment = baseScienceRate * time_diff / GameConstants.KEBRIN_DAY_SECONDS * electrical_power_ratio * scienceMultiplier / ((float)Math.Sqrt(altitude_multiplier));
                science_to_increment = (double.IsNaN(science_to_increment) || double.IsInfinity(science_to_increment)) ? 0 : science_to_increment;
                science_to_add      += (float)science_to_increment;

                //var curReaction = this.part.Modules["ModuleReactionWheel"] as ModuleReactionWheel;
                //curReaction.PitchTorque = 5;
                //curReaction.RollTorque = 5;
                //curReaction.YawTorque = 5;
            }
            else
            {
                computercoreType = originalName;
            }

            this.part.force_activate();
        }
Exemple #15
0
 public override void OnFixedUpdate()
 {
     if (!isupgraded)
     {
         float power_returned = consumeFNResource(megajouleRate * TimeWarp.fixedDeltaTime, FNResourceManager.FNRESOURCE_MEGAJOULES);
     }
     else
     {
         float power_returned = consumeFNResource(upgradedMegajouleRate * TimeWarp.fixedDeltaTime, FNResourceManager.FNRESOURCE_MEGAJOULES) / TimeWarp.fixedDeltaTime;
         electrical_power_ratio = power_returned / upgradedMegajouleRate;
         float altitude_multiplier = (float)(vessel.altitude / (vessel.mainBody.Radius));
         altitude_multiplier = Math.Max(altitude_multiplier, 1);
         science_rate_f      = (float)(baseScienceRate * PluginHelper.getScienceMultiplier(vessel.mainBody.flightGlobalsIndex, vessel.LandedOrSplashed) / GameConstants.KEBRIN_DAY_SECONDS * power_returned / upgradedMegajouleRate / Math.Sqrt(altitude_multiplier));
         if (ResearchAndDevelopment.Instance != null && !double.IsInfinity(science_rate_f) && !double.IsNaN(science_rate_f))
         {
             science_to_add += science_rate_f * TimeWarp.fixedDeltaTime;
         }
     }
     last_active_time = (float)Planetarium.GetUniversalTime();
 }
        protected override bool generateScienceData()
        {
            ScienceExperiment experiment = ResearchAndDevelopment.GetExperiment(experimentID);

            if (experiment == null)
            {
                return(false);
            }

            if (science_to_add > 0)
            {
                ScienceSubject subject = ResearchAndDevelopment.GetExperimentSubject(experiment, ScienceUtil.GetExperimentSituation(vessel), vessel.mainBody, "", "");
                if (subject == null)
                {
                    return(false);
                }
                subject.subjectValue = PluginHelper.getScienceMultiplier(vessel);
                subject.scienceCap   = 167 * subject.subjectValue; ///PluginHelper.getScienceMultiplier(vessel.mainBody.flightGlobalsIndex, false);
                subject.dataScale    = 1.25f;

                float remaining_base_science = (subject.scienceCap - subject.science) / subject.subjectValue;
                science_to_add = Math.Min(science_to_add, remaining_base_science);

                // transmission of zero data breaks the experiment result dialog box
                data_size    = Math.Max(float.Epsilon, science_to_add * subject.dataScale);
                science_data = new ScienceData((float)data_size, 1, 0, subject.id, "Science Lab Data");

                result_title  = experiment.experimentTitle;
                result_string = "Science experiments were conducted in the vicinity of " + vessel.mainBody.name + ".";

                recovery_value = science_to_add;
                transmit_value = recovery_value;
                xmit_scalar    = 1;

                ref_value = subject.scienceCap;

                return(true);
            }
            return(false);
        }
        protected override bool generateScienceData()
        {
            ScienceExperiment experiment = ResearchAndDevelopment.GetExperiment("ExpInterstellarTelescope");

            if (experiment == null)
            {
                return(false);
            }

            if (science_awaiting_addition > 0)
            {
                ScienceSubject subject = ResearchAndDevelopment.GetExperimentSubject(experiment, ExperimentSituations.InSpaceHigh, vessel.mainBody, "", "");
                if (subject == null)
                {
                    return(false);
                }

                subject.subjectValue = PluginHelper.getScienceMultiplier(vessel);
                subject.scienceCap   = 167 * subject.subjectValue; //PluginHelper.getScienceMultiplier(vessel.mainBody.flightGlobalsIndex,false);
                subject.dataScale    = 1.25f;

                float remaining_base_science = (subject.scienceCap - subject.science) / subject.subjectValue;
                science_awaiting_addition = Math.Min(science_awaiting_addition, remaining_base_science);

                // transmission of zero data breaks the experiment result dialog box
                data_size    = Math.Max(float.Epsilon, science_awaiting_addition * subject.dataScale);
                science_data = new ScienceData((float)data_size, 1, 0, subject.id, "Infrared Telescope Data");

                result_title  = Localizer.Format("#LOC_KSPIE_Telescope_Resulttitle");                     //"Infrared Telescope Experiment"
                result_string = Localizer.Format("#LOC_KSPIE_Telescope_Resultmsg", vessel.mainBody.name); //"Infrared telescope observations were recovered from the vicinity of " +  + "."

                recovery_value = science_awaiting_addition;
                transmit_value = recovery_value;
                xmit_scalar    = 1;
                ref_value      = subject.scienceCap;

                return(true);
            }
            return(false);
        }
Exemple #18
0
        public override void OnFixedUpdate()
        {
            float global_rate_multipliers = 1;

            crew_capacity_ratio     = ((float)part.protoModuleCrew.Count) / ((float)part.CrewCapacity);
            global_rate_multipliers = global_rate_multipliers * crew_capacity_ratio;

            if (!IsEnabled)
            {
                return;
            }

            if (active_mode == 0)  // Research
            {
                double electrical_power_provided = consumeFNResource(powerReqMult * PluginHelper.BasePowerConsumption * TimeWarp.fixedDeltaTime, FNResourceManager.FNRESOURCE_MEGAJOULES);
                electrical_power_ratio  = (float)(electrical_power_provided / TimeWarp.fixedDeltaTime / PluginHelper.BasePowerConsumption / powerReqMult);
                global_rate_multipliers = global_rate_multipliers * electrical_power_ratio;

                float kerbalScienceSkillFactor = part.protoModuleCrew.Sum(proto_crew_member => GetKerbalScienceFactor(proto_crew_member) / 2f);
                float altitude_multiplier      = Math.Max((float)(vessel.altitude / (vessel.mainBody.Radius)), 1);

                science_rate_f = (float)(kerbalScienceSkillFactor * GameConstants.baseScienceRate * PluginHelper.getScienceMultiplier(vessel) //PluginHelper.getScienceMultiplier(vessel.mainBody.flightGlobalsIndex, vessel.LandedOrSplashed)
                                         / GameConstants.EARH_DAY_SECONDS * global_rate_multipliers
                                         / (Mathf.Sqrt(altitude_multiplier)));

                if (ResearchAndDevelopment.Instance != null && !double.IsNaN(science_rate_f) && !double.IsInfinity(science_rate_f))
                {
                    //ResearchAndDevelopment.Instance.Science = ResearchAndDevelopment.Instance.Science + science_rate_f * TimeWarp.fixedDeltaTime;
                    science_to_add += science_rate_f * TimeWarp.fixedDeltaTime;
                }
            }
            else if (active_mode == 1) // Fuel Reprocessing
            {
                double electrical_power_provided = consumeFNResource(powerReqMult * PluginHelper.BasePowerConsumption * TimeWarp.fixedDeltaTime, FNResourceManager.FNRESOURCE_MEGAJOULES);
                electrical_power_ratio  = (float)(electrical_power_provided / TimeWarp.fixedDeltaTime / PluginHelper.BasePowerConsumption / powerReqMult);
                global_rate_multipliers = global_rate_multipliers * electrical_power_ratio;
                reprocessor.UpdateFrame(global_rate_multipliers, true);

                if (reprocessor.getActinidesRemovedPerHour() > 0)
                {
                    reprocessing_rate_f = (float)(reprocessor.getRemainingAmountToReprocess() / reprocessor.getActinidesRemovedPerHour());
                }
                else
                {
                    IsEnabled = false;
                }
            }
            else if (active_mode == 2) //Antimatter
            {
                double electrical_power_provided = consumeFNResource(powerReqMult * PluginHelper.BaseAMFPowerConsumption * TimeWarp.fixedDeltaTime, FNResourceManager.FNRESOURCE_MEGAJOULES);
                electrical_power_ratio  = (float)(electrical_power_provided / TimeWarp.fixedDeltaTime / PluginHelper.BaseAMFPowerConsumption / powerReqMult);
                global_rate_multipliers = crew_capacity_ratio * electrical_power_ratio;
                anti_factory.produceAntimatterFrame(global_rate_multipliers);
                antimatter_rate_f = (float)anti_factory.getAntimatterProductionRate();
            }
            else if (active_mode == 3)
            {
                IsEnabled = false;
            }
            else if (active_mode == 4) // Centrifuge
            {
                if (vessel.Splashed)
                {
                    float electrical_power_provided = consumeFNResource(powerReqMult * PluginHelper.BaseCentriPowerConsumption * TimeWarp.fixedDeltaTime, FNResourceManager.FNRESOURCE_MEGAJOULES);
                    electrical_power_ratio  = (float)(electrical_power_provided / TimeWarp.fixedDeltaTime / PluginHelper.BaseCentriPowerConsumption / powerReqMult);
                    global_rate_multipliers = global_rate_multipliers * electrical_power_ratio;
                    float deut_produced = (float)(global_rate_multipliers * GameConstants.deuterium_timescale * GameConstants.deuterium_abudance * 1000.0f);
                    deut_rate_f = -ORSHelper.fixedRequestResource(part, InterstellarResourcesConfiguration.Instance.Deuterium, -deut_produced * TimeWarp.fixedDeltaTime) / TimeWarp.fixedDeltaTime;
                }
                else
                {
                    ScreenMessages.PostScreenMessage("You must be splashed down to perform this activity.", 5.0f, ScreenMessageStyle.UPPER_CENTER);
                    IsEnabled = false;
                }
            }

            if (electrical_power_ratio <= 0)
            {
                deut_rate_f         = 0;
                electrolysis_rate_f = 0;
                science_rate_f      = 0;
                antimatter_rate_f   = 0;
                reprocessing_rate_f = 0;
            }

            last_active_time = (float)Planetarium.GetUniversalTime();
        }
Exemple #19
0
        public override void OnStart(PartModule.StartState state)
        {
            if (state == StartState.Editor)
            {
                return;
            }

            bool manual_upgrade = false;

            if (HighLogic.CurrentGame.Mode == Game.Modes.CAREER)
            {
                if (upgradeTechReq != null)
                {
                    if (PluginHelper.hasTech(upgradeTechReq))
                    {
                        hasrequiredupgrade = true;
                    }
                    else if (upgradeTechReq == "none")
                    {
                        manual_upgrade = true;
                    }
                }
                else
                {
                    manual_upgrade = true;
                }
            }
            else
            {
                hasrequiredupgrade = true;
            }

            if (coreInit == false)
            {
                coreInit = true;
                if (hasrequiredupgrade)
                {
                    isupgraded = true;
                }
            }

            if (manual_upgrade)
            {
                hasrequiredupgrade = true;
            }

            if (isupgraded)
            {
                computercoreType = upgradedName;
                if (nameStr == "")
                {
                    ConfigNode[] namelist = ComputerCore.getNames();
                    Random       rands    = new Random();
                    ConfigNode   myName   = namelist[rands.Next(0, namelist.Length)];
                    nameStr = myName.GetValue("name");
                }

                double now                 = Planetarium.GetUniversalTime();
                double time_diff           = now - last_active_time;
                float  altitude_multiplier = (float)(vessel.altitude / (vessel.mainBody.Radius));
                altitude_multiplier = Math.Max(altitude_multiplier, 1);

                double science_to_add = baseScienceRate * time_diff / 86400 * electrical_power_ratio * PluginHelper.getScienceMultiplier(vessel.mainBody.flightGlobalsIndex, vessel.LandedOrSplashed) / ((float)Math.Sqrt(altitude_multiplier));
                science_awaiting_addition = science_to_add;

                var curReaction = this.part.Modules["ModuleReactionWheel"] as ModuleReactionWheel;
                curReaction.PitchTorque = 5;
                curReaction.RollTorque  = 5;
                curReaction.YawTorque   = 5;
            }
            else
            {
                computercoreType = originalName;
            }


            this.part.force_activate();
        }
        public override void OnFixedUpdate()
        {
            base.OnFixedUpdate();

            if (isupgraded && IsEnabled)
            {
                var powerReturned = CheatOptions.InfiniteElectricity
                    ? _effectivePowerRequirement
                    : consumeFNResourcePerSecond(_effectivePowerRequirement, ResourceSettings.Config.ElectricPowerInMegawatt);

                electrical_power_ratio = powerReturned / _effectivePowerRequirement;
                IsPowered = electrical_power_ratio > 0.99;

                if (IsPowered)
                {
                    part.isControlSource = Vessel.ControlLevel.FULL;

                    if (vessel != null && vessel.connection != null)
                    {
                        vessel.connection.RegisterCommandSource(this);

                        part.isControlSource = Vessel.ControlLevel.FULL;

                        if (vessel.connection.Comm != null)
                        {
                            vessel.connection.Comm.isHome          = true;
                            vessel.connection.Comm.isControlSource = true;
                        }
                    }

                    var altitudeMultiplier = Math.Max(vessel.altitude / vessel.mainBody.Radius, 1);

                    var scienceMultiplier = PluginHelper.getScienceMultiplier(vessel);

                    _scienceRateF = baseScienceRate * scienceMultiplier / GameConstants.KEBRIN_DAY_SECONDS * powerReturned / _effectivePowerRequirement / Math.Sqrt(altitudeMultiplier);

                    if (ResearchAndDevelopment.Instance != null && !double.IsInfinity(_scienceRateF) && !double.IsNaN(_scienceRateF))
                    {
                        science_to_add += _scienceRateF * TimeWarp.fixedDeltaTime;
                    }
                }
                else
                {
                    if (vessel != null && vessel.connection != null)
                    {
                        vessel.connection.UnregisterCommandSource(this);

                        part.isControlSource = Vessel.ControlLevel.NONE;

                        if (vessel.connection.Comm != null)
                        {
                            vessel.connection.Comm.isHome          = false;
                            vessel.connection.Comm.isControlSource = false;
                        }
                    }

                    part.RequestResource(ResourceSettings.Config.ElectricPowerInMegawatt, -powerReturned * TimeWarp.fixedDeltaTime);
                }
            }
            else
            {
                IsPowered              = false;
                _scienceRateF          = 0;
                electrical_power_ratio = 0;
                science_to_add         = 0;
            }

            last_active_time = Planetarium.GetUniversalTime();
        }
Exemple #21
0
        public override void OnUpdate()
        {
            base.OnUpdate();

            if (ResearchAndDevelopment.Instance != null)
            {
                Events["RetrofitCore"].active = !isupgraded && ResearchAndDevelopment.Instance.Science >= upgradeCost;
            }
            else
            {
                Events["RetrofitCore"].active = false;
            }

            Fields["upgradeCostStr"].guiActive = !isupgraded;
            Fields["nameStr"].guiActive        = isupgraded;
            Fields["scienceRate"].guiActive    = isupgraded;

            float scienceratetmp = (float)(science_rate_f * GameConstants.KEBRIN_DAY_SECONDS) * PluginHelper.getScienceMultiplier(vessel);

            scienceRate = scienceratetmp.ToString("0.000") + "/Day";

            if (ResearchAndDevelopment.Instance != null)
            {
                upgradeCostStr = ResearchAndDevelopment.Instance.Science + "/" + upgradeCost.ToString("0") + " Science";
            }
        }
        public override void OnUpdate()
        {
            base.OnUpdate();

            if (_moduleDataTransmitter != null)
            {
                _moduleDataTransmitter.antennaPower = IsEnabled && IsPowered ? 5e+17 : 50000;
            }

            if (ResearchAndDevelopment.Instance != null)
            {
                Events["RetrofitCore"].active = !isupgraded && ResearchAndDevelopment.Instance.Science >= upgradeCost;
            }
            else
            {
                Events["RetrofitCore"].active = false;
            }

            Fields["upgradeCostStr"].guiActive = !isupgraded;
            Fields["nameStr"].guiActive        = isupgraded;
            Fields["scienceRate"].guiActive    = isupgraded;

            double scienceratetmp = science_rate_f * GameConstants.KEBRIN_DAY_SECONDS * PluginHelper.getScienceMultiplier(vessel);

            scienceRate = scienceratetmp.ToString("0.000") + "/Day";

            if (ResearchAndDevelopment.Instance != null)
            {
                upgradeCostStr = ResearchAndDevelopment.Instance.Science + "/" + upgradeCost.ToString("0") + " Science";
            }
        }
        public override void OnFixedUpdate()
        {
            double global_rate_multipliers = 1;

            crew_capacity_ratio     = ((float)part.protoModuleCrew.Count) / ((float)part.CrewCapacity);
            global_rate_multipliers = global_rate_multipliers * crew_capacity_ratio;

            if (!IsEnabled)
            {
                return;
            }

            if (active_mode == 0)  // Research
            {
                var powerRequest = powerReqMult * PluginHelper.BasePowerConsumption * TimeWarp.fixedDeltaTime;

                double electrical_power_provided = CheatOptions.InfiniteElectricity
                    ? powerRequest
                    : consumeFNResource(powerRequest, ResourceManager.FNRESOURCE_MEGAJOULES);

                electrical_power_ratio  = electrical_power_provided / TimeWarp.fixedDeltaTime / PluginHelper.BasePowerConsumption / powerReqMult;
                global_rate_multipliers = global_rate_multipliers * electrical_power_ratio;

                double kerbalScienceSkillFactor = part.protoModuleCrew.Sum(proto_crew_member => GetKerbalScienceFactor(proto_crew_member) / 2f);
                double altitude_multiplier      = Math.Max(vessel.altitude / (vessel.mainBody.Radius), 1);

                science_rate_f = (kerbalScienceSkillFactor * GameConstants.baseScienceRate * PluginHelper.getScienceMultiplier(vessel)
                                  / PluginHelper.SecondsInDay * global_rate_multipliers
                                  / (Math.Sqrt(altitude_multiplier)));

                if (ResearchAndDevelopment.Instance != null && !double.IsNaN(science_rate_f) && !double.IsInfinity(science_rate_f))
                {
                    science_to_add += science_rate_f * TimeWarp.fixedDeltaTime;
                }
            }
            else if (active_mode == 1) // Fuel Reprocessing
            {
                var powerRequest = powerReqMult * PluginHelper.BasePowerConsumption * TimeWarp.fixedDeltaTime;

                double electrical_power_provided = CheatOptions.InfiniteElectricity
                    ? powerRequest
                    : consumeFNResource(powerRequest, ResourceManager.FNRESOURCE_MEGAJOULES);

                electrical_power_ratio = electrical_power_provided / TimeWarp.fixedDeltaTime / PluginHelper.BasePowerConsumption / powerReqMult;

                var productionModifier = global_rate_multipliers;
                global_rate_multipliers = global_rate_multipliers * electrical_power_ratio;
                reprocessor.UpdateFrame(global_rate_multipliers, electrical_power_ratio, productionModifier, true, TimeWarp.fixedDeltaTime);

                if (reprocessor.getActinidesRemovedPerHour() > 0)
                {
                    reprocessing_rate_f = reprocessor.getRemainingAmountToReprocess() / reprocessor.getActinidesRemovedPerHour();
                }
                else
                {
                    IsEnabled = false;
                }
            }
            else if (active_mode == 2) //Antimatter
            {
                var powerRequestInMegajoules = powerReqMult * PluginHelper.BaseAMFPowerConsumption * TimeWarp.fixedDeltaTime;

                var energy_provided_in_megajoules = CheatOptions.InfiniteElectricity
                    ? powerRequestInMegajoules
                    : consumeFNResource(powerRequestInMegajoules, ResourceManager.FNRESOURCE_MEGAJOULES);

                electrical_power_ratio = powerRequestInMegajoules > 0 ? energy_provided_in_megajoules / powerRequestInMegajoules : 0;
                antimatterGenerator.Produce(energy_provided_in_megajoules * global_rate_multipliers);
                antimatter_rate_f = antimatterGenerator.ProductionRate;
            }
            else if (active_mode == 3)
            {
                IsEnabled = false;
            }
            else if (active_mode == 4) // Centrifuge
            {
                if (vessel.Splashed)
                {
                    var powerRequest = powerReqMult * PluginHelper.BaseCentriPowerConsumption * TimeWarp.fixedDeltaTime;

                    double electrical_power_provided = CheatOptions.InfiniteElectricity
                        ? powerRequest
                        : consumeFNResource(powerRequest, ResourceManager.FNRESOURCE_MEGAJOULES);

                    electrical_power_ratio  = electrical_power_provided / TimeWarp.fixedDeltaTime / PluginHelper.BaseCentriPowerConsumption / powerReqMult;
                    global_rate_multipliers = global_rate_multipliers * electrical_power_ratio;
                    double deut_produced = global_rate_multipliers * GameConstants.deuterium_timescale * GameConstants.deuterium_abudance * 1000.0f;
                    deut_rate_f = -part.RequestResource(InterstellarResourcesConfiguration.Instance.LqdDeuterium, -deut_produced * TimeWarp.fixedDeltaTime) / TimeWarp.fixedDeltaTime;
                }
                else
                {
                    ScreenMessages.PostScreenMessage("You must be splashed down to perform this activity.", 5.0f, ScreenMessageStyle.UPPER_CENTER);
                    IsEnabled = false;
                }
            }

            if (electrical_power_ratio <= 0)
            {
                deut_rate_f         = 0;
                electrolysis_rate_f = 0;
                science_rate_f      = 0;
                antimatter_rate_f   = 0;
                reprocessing_rate_f = 0;
            }

            last_active_time = Planetarium.GetUniversalTime();
        }
        public override void OnUpdate()
        {
            base.OnUpdate();
            Events["BeginResearch"].active        = isupgraded && !IsEnabled;
            Events["ReprocessFuel"].active        = !IsEnabled;
            Events["ActivateFactory"].active      = isupgraded && !IsEnabled;
            Events["ActivateElectrolysis"].active = false;
            Events["ActivateCentrifuge"].active   = isupgraded && !IsEnabled && vessel.Splashed;
            Events["StopActivity"].active         = isupgraded && IsEnabled;
            Fields["statusTitle"].guiActive       = isupgraded;

            // only show retrofit btoon if we can actualy upgrade
            Events["RetrofitEngine"].active = ResearchAndDevelopment.Instance == null ? false : !isupgraded && ResearchAndDevelopment.Instance.Science >= upgradeCost && hasrequiredupgrade;

            if (IsEnabled)
            {
                //anim [animName1].normalizedTime = 1f;
                statusTitle = modes[active_mode] + "...";
                Fields["scienceRate"].guiActive = false;

                Fields["collectedScience"].guiActive = false;
                Fields["reprocessingRate"].guiActive = false;
                Fields["antimatterRate"].guiActive   = false;
                Fields["electrolysisRate"].guiActive = false;
                Fields["centrifugeRate"].guiActive   = false;
                Fields["antimatterProductionEfficiency"].guiActive = false;
                Fields["powerStr"].guiActive = true;

                double currentpowertmp = electrical_power_ratio * PluginHelper.BasePowerConsumption * powerReqMult;
                powerStr = currentpowertmp.ToString("0.0000") + "MW / " + (powerReqMult * PluginHelper.BasePowerConsumption).ToString("0.0000") + "MW";
                if (active_mode == 0) // Research
                {
                    Fields["scienceRate"].guiActive      = true;
                    Fields["collectedScience"].guiActive = true;
                    double scienceratetmp = science_rate_f * PluginHelper.SecondsInDay * PluginHelper.getScienceMultiplier(vessel);
                    scienceRate      = scienceratetmp.ToString("0.0000") + "/Day";
                    collectedScience = science_to_add.ToString("0.000000");
                }
                else if (active_mode == 1) // Fuel Reprocessing
                {
                    Fields["reprocessingRate"].guiActive = true;
                    reprocessingRate = reprocessing_rate_f.ToString("0.0") + " Hours Remaining";
                }
                else if (active_mode == 2) // Antimatter
                {
                    currentpowertmp = electrical_power_ratio * PluginHelper.BaseAMFPowerConsumption * powerReqMult;
                    Fields["antimatterRate"].guiActive = true;
                    Fields["antimatterProductionEfficiency"].guiActive = true;
                    powerStr = currentpowertmp.ToString("0.00") + "MW / " + (powerReqMult * PluginHelper.BaseAMFPowerConsumption).ToString("0.00") + "MW";
                    antimatterProductionEfficiency = (antimatterGenerator.Efficiency * 100).ToString("0.0000") + "%";
                    double antimatter_rate_per_day = antimatter_rate_f * PluginHelper.SecondsInDay;

                    if (antimatter_rate_per_day > 0.1)
                    {
                        antimatterRate = (antimatter_rate_per_day).ToString("0.0000") + " mg/day";
                    }
                    else
                    {
                        if (antimatter_rate_per_day > 0.1e-3)
                        {
                            antimatterRate = (antimatter_rate_per_day * 1e3).ToString("0.0000") + " ug/day";
                        }
                        else
                        {
                            antimatterRate = (antimatter_rate_per_day * 1e6).ToString("0.0000") + " ng/day";
                        }
                    }
                }
                else if (active_mode == 3) // Electrolysis
                {
                    currentpowertmp = electrical_power_ratio * PluginHelper.BaseELCPowerConsumption * powerReqMult;
                    Fields["electrolysisRate"].guiActive = true;
                    double electrolysisratetmp = -electrolysis_rate_f * PluginHelper.SecondsInDay;
                    electrolysisRate = electrolysisratetmp.ToString("0.0") + "mT/day";
                    powerStr         = currentpowertmp.ToString("0.00") + "MW / " + (powerReqMult * PluginHelper.BaseELCPowerConsumption).ToString("0.00") + "MW";
                }
                else if (active_mode == 4) // Centrifuge
                {
                    currentpowertmp = electrical_power_ratio * PluginHelper.BaseCentriPowerConsumption * powerReqMult;
                    Fields["centrifugeRate"].guiActive = true;
                    powerStr = currentpowertmp.ToString("0.00") + "MW / " + (powerReqMult * PluginHelper.BaseCentriPowerConsumption).ToString("0.00") + "MW";
                    double deut_per_hour = deut_rate_f * 3600;
                    centrifugeRate = deut_per_hour.ToString("0.00") + " Kg Deuterium/Hour";
                }
                else
                {
                    // nothing
                }
            }
            else
            {
                if (play_down)
                {
                    anim[animName1].speed          = -1;
                    anim[animName1].normalizedTime = 1;
                    anim.Blend(animName1, 2);
                    anim2[animName2].speed          = -1;
                    anim2[animName2].normalizedTime = 1;
                    anim2.Blend(animName2, 2);
                    play_down = false;
                }

                //anim [animName1].normalizedTime = 0;
                Fields["scienceRate"].guiActive      = false;
                Fields["collectedScience"].guiActive = false;
                Fields["reprocessingRate"].guiActive = false;
                Fields["antimatterRate"].guiActive   = false;
                Fields["powerStr"].guiActive         = false;
                Fields["centrifugeRate"].guiActive   = false;
                Fields["electrolysisRate"].guiActive = false;
                Fields["antimatterProductionEfficiency"].guiActive = false;

                if (crew_capacity_ratio > 0)
                {
                    statusTitle = "Idle";
                }
                else
                {
                    statusTitle = "Not enough crew";
                }
            }
        }
        public override void OnStart(PartModule.StartState state)
        {
            if (state == StartState.Editor)
            {
                if (this.HasTechsRequiredToUpgrade())
                {
                    isupgraded = true;
                    upgradePartModule();
                }
                return;
            }

            if (isupgraded)
            {
                upgradePartModule();
            }
            else
            {
                if (this.HasTechsRequiredToUpgrade())
                {
                    hasrequiredupgrade = true;
                }
            }

            // update gui names
            Events["BeginResearch"].guiName = beginResearchName;

            reprocessor = new NuclearFuelReprocessor();
            reprocessor.Initialize(part);
            antimatterGenerator = new AntimatterGenerator(part, 1, PartResourceLibrary.Instance.GetDefinition(InterstellarResourcesConfiguration.Instance.Antimatter));

            part.force_activate();

            anim  = part.FindModelAnimators(animName1).FirstOrDefault();
            anim2 = part.FindModelAnimators(animName2).FirstOrDefault();
            if (anim != null && anim2 != null)
            {
                anim[animName1].layer  = 1;
                anim2[animName2].layer = 1;
                if (IsEnabled)
                {
                    //anim [animName1].normalizedTime = 1f;
                    //anim2 [animName2].normalizedTime = 1f;
                    //anim [animName1].speed = -1f;
                    //anim2 [animName2].speed = -1f;
                    anim.Blend(animName1, 1, 0);
                    anim2.Blend(animName2, 1, 0);
                }
                else
                {
                    //anim [animName1].normalizedTime = 0f;
                    //anim2 [animName2].normalizedTime = 0f;
                    //anim [animName1].speed = 1f;
                    //anim2 [animName2].speed = 1f;
                    //anim.Blend (animName1, 0, 0);global_rate_multipliers
                    //anim2.Blend (animName2, 0, 0);
                    play_down = false;
                }
                //anim.Play ();
                //anim2.Play ();
            }

            if (IsEnabled && last_active_time != 0)
            {
                double global_rate_multipliers = 1;
                crew_capacity_ratio     = ((float)(part.protoModuleCrew.Count)) / ((float)part.CrewCapacity);
                global_rate_multipliers = global_rate_multipliers * crew_capacity_ratio;

                if (active_mode == 0) // Science persistence
                {
                    var time_diff                 = Planetarium.GetUniversalTime() - last_active_time;
                    var altitude_multiplier       = Math.Max((vessel.altitude / (vessel.mainBody.Radius)), 1);
                    var kerbalResearchSkillFactor = part.protoModuleCrew.Sum(proto_crew_member => GetKerbalScienceFactor(proto_crew_member) / 2f);

                    double science_to_increment = kerbalResearchSkillFactor * GameConstants.baseScienceRate * time_diff
                                                  / PluginHelper.SecondsInDay * electrical_power_ratio * global_rate_multipliers * PluginHelper.getScienceMultiplier(vessel)
                                                  / (Math.Sqrt(altitude_multiplier));

                    science_to_increment = (double.IsNaN(science_to_increment) || double.IsInfinity(science_to_increment)) ? 0 : science_to_increment;
                    science_to_add      += science_to_increment;
                }
                else if (active_mode == 2) // Antimatter persistence
                {
                    var deltaTime = Planetarium.GetUniversalTime() - last_active_time;

                    var electrical_power_provided_in_Megajoules = electrical_power_ratio * global_rate_multipliers * powerReqMult * PluginHelper.BaseAMFPowerConsumption * deltaTime;

                    antimatterGenerator.Produce(electrical_power_provided_in_Megajoules);
                }
            }
        }
        protected override bool generateScienceData()
        {
            ScienceExperiment experiment = ResearchAndDevelopment.GetExperiment("FNSeismicProbeExperiment");

            if (experiment == null)
            {
                return(false);
            }
            //ScienceSubject subject = ResearchAndDevelopment.GetExperimentSubject(experiment, ExperimentSituations.SrfLanded, vessel.mainBody, "surface");
            //if (subject == null) {
            //    return false;
            //}
            //subject.scientificValue = 1;
            //subject.scienceCap = float.MaxValue;
            //subject.science = 1;
            //subject.subjectValue = 1;
            result_title   = "Impactor Experiment";
            result_string  = "No useful seismic data has been recorded.";
            transmit_value = 0;
            recovery_value = 0;
            data_size      = 0;
            xmit_scalar    = 1;
            ref_value      = 1;

            // science_data = new ScienceData(0, 1, 0, subject.id, "data");

            ConfigNode config = PluginHelper.getPluginSaveFile();

            if (config.HasNode("SEISMIC_SCIENCE_" + vessel.mainBody.name.ToUpper()))
            {
                ConfigNode planet_data = config.GetNode("SEISMIC_SCIENCE_" + vessel.mainBody.name.ToUpper());
                foreach (ConfigNode probe_data in planet_data.nodes)
                {
                    if (probe_data.name.Contains("IMPACT_"))
                    {
                        science_vess_ref = probe_data.name;
                        bool   transmitted         = false;
                        string vessel_name         = "";
                        float  distribution_factor = 0;

                        if (probe_data.HasValue("transmitted"))
                        {
                            transmitted = bool.Parse(probe_data.GetValue("transmitted"));
                        }
                        if (probe_data.HasValue("vesselname"))
                        {
                            vessel_name = probe_data.GetValue("vesselname");
                        }
                        if (probe_data.HasValue("distribution_factor"))
                        {
                            distribution_factor = float.Parse(probe_data.GetValue("distribution_factor"));
                        }

                        if (!transmitted)
                        {
                            ScienceSubject subject = ResearchAndDevelopment.GetExperimentSubject(experiment, ExperimentSituations.SrfLanded, vessel.mainBody, vessel.mainBody.name + "'s surface.");
                            if (subject == null)
                            {
                                return(false);
                            }
                            subject.subjectValue = PluginHelper.getScienceMultiplier(vessel);
                            subject.scienceCap   = 10 * experiment.baseValue * subject.subjectValue;

                            float base_science = experiment.baseValue * distribution_factor;
                            data_size    = base_science * subject.dataScale;
                            science_data = new ScienceData((float)data_size, 1f, 0f, subject.id, "Impactor Data");

                            result_string = vessel_name + " impacted into " + vessel.mainBody.name + " producing seismic activity.  From this data, information on the structure of " + vessel.mainBody.name + "'s crust can be determined.";

                            float science_amount = base_science * subject.subjectValue;
                            recovery_value = science_amount * subject.scientificValue;
                            transmit_value = recovery_value;
                            ref_value      = subject.scienceCap;

                            return(true);
                        }
                    }
                }
            }
            return(false);
        }
        public void onVesselAboutToBeDestroyed(EventReport report)
        {
            Debug.Log("[KSP Interstellar] Handling Impactor");

            ConfigNode config;
            ConfigNode science_node;

            Vessel vessel = report.origin.vessel;
            float  vesselMass;
            int    science_experiment_number = 0;

            string vessel_impact_node_string  = string.Concat("IMPACT_", vessel.id.ToString());
            string vessel_seismic_node_string = string.Concat("SEISMIC_SCIENCE_", vessel.mainBody.name.ToUpper());

            // Do nothing if we don't have a vessel.  This seems improbable, but who knows.
            if (vessel == null)
            {
                Debug.Log("[KSP Interstellar] Impactor: Ignored because the vessel is undefined.");
                return;
            }

            // Do nothing if we have recorded an impact less than 10 physics updates ago.  This probably means this call
            // is a duplicate of a previous call.
            if (Planetarium.GetUniversalTime() - this.lastImpactTime < TimeWarp.fixedDeltaTime * 10f)
            {
                Debug.Log("[KSP Interstellar] Impactor: Ignored because we've just recorded an impact.");
                return;
            }

            // Do nothing if we are a debris item less than ten physics-updates old.  That probably means we were
            // generated by a recently-recorded impact.
            if (vessel.vesselType == VesselType.Debris && vessel.missionTime < Time.fixedDeltaTime * 10f)
            {
                Debug.Log("[KSP Interstellar] Impactor: Ignored due to vessel being brand-new debris.");
                return;
            }

            vesselMass = vessel.GetTotalMass();

            // Do nothing if we aren't very near the terrain.  Note that using heightFromTerrain probably allows
            // impactors against the ocean floor... good luck.
            float vesselDimension = vessel.MOI.magnitude / vesselMass;

            if (vessel.heightFromSurface > Mathf.Max(vesselDimension, 0.75f))
            {
                Debug.Log("[KSP Interstellar] Impactor: Ignored due to vessel altitude being too high.");
                return;
            }

            // Do nothing if we aren't impacting the surface.
            if (!(
                    report.other.ToLower().Contains(string.Intern("surface")) ||
                    report.other.ToLower().Contains(string.Intern("terrain")) ||
                    report.other.ToLower().Contains(vessel.mainBody.name.ToLower())
                    ))
            {
                Debug.Log("[KSP Interstellar] Impactor: Ignored due to not impacting the surface.");
                return;
            }

            /*
             * NOTE: This is a deviation from current KSPI behavior.  KSPI currently registers an impact over 40 m/s
             * regardless of its mass; this means that trivially light impactors (single instruments, even) could
             * trigger the experiment.
             *
             * The guard below requires that the impactor have at least as much vertical impact energy as a 1 Mg
             * object traveling at 40 m/s.  This means that nearly-tangential impacts or very light impactors will need
             * to be much faster, but that heavier impactors may be slower.
             *
             * */
            if ((Math.Pow(vessel.verticalSpeed, 2d) * vesselMass / 2d < 800d) && vessel.verticalSpeed > 20d)
            {
                Debug.Log("[KSP Interstellar] Impactor: Ignored due to vessel imparting too little impact energy.");
                return;
            }

            config = PluginHelper.getPluginSaveFile();
            if (config.HasNode(vessel_seismic_node_string))
            {
                science_node = config.GetNode(vessel_seismic_node_string);
                science_experiment_number = science_node.nodes.Count;

                if (science_node.HasNode(vessel_impact_node_string))
                {
                    Debug.Log("[KSP Interstellar] Impactor: Ignored because this vessel's impact has already been recorded.");
                    return;
                }
            }
            else
            {
                science_node = config.AddNode(vessel_seismic_node_string);
                science_node.AddValue("name", "interstellarseismicarchive");
            }

            int      body            = vessel.mainBody.flightGlobalsIndex;
            Vector3d net_vector      = Vector3d.zero;
            bool     first           = true;
            double   net_science     = 0;
            double   initial_science = 0;

            foreach (Vessel conf_vess in FlightGlobals.Vessels)
            {
                String vessel_probe_node_string = string.Concat("VESSEL_SEISMIC_PROBE_", conf_vess.id.ToString());

                if (config.HasNode(vessel_probe_node_string))
                {
                    ConfigNode probe_node = config.GetNode(vessel_probe_node_string);

                    // If the seismometer is inactive, skip it.
                    bool is_active = false;
                    if (probe_node.HasValue("is_active"))
                    {
                        bool.TryParse(probe_node.GetValue("is_active"), out is_active);
                        if (!is_active)
                        {
                            continue;
                        }
                    }

                    // If the seismometer is on another planet, skip it.
                    int planet = -1;
                    if (probe_node.HasValue("celestial_body"))
                    {
                        int.TryParse(probe_node.GetValue("celestial_body"), out planet);
                        if (planet != body)
                        {
                            continue;
                        }
                    }

                    // do sciency stuff
                    Vector3d surface_vector = (conf_vess.transform.position - FlightGlobals.Bodies[body].transform.position);
                    surface_vector = surface_vector.normalized;
                    if (first)
                    {
                        first           = false;
                        net_vector      = surface_vector;
                        net_science     = 50 * PluginHelper.getScienceMultiplier(vessel); //PluginHelper.getImpactorScienceMultiplier(body);
                        initial_science = net_science;
                    }
                    else
                    {
                        net_science += (1.0 - Vector3d.Dot(surface_vector, net_vector.normalized)) * 50 * PluginHelper.getScienceMultiplier(vessel);  //PluginHelper.getImpactorScienceMultiplier(body);
                        net_vector   = net_vector + surface_vector;
                    }
                }
            }

            net_science = Math.Min(net_science, initial_science * 3.5); // no more than 3.5x boost to science by using multiple detectors
            if (net_science > 0 && !double.IsInfinity(net_science) && !double.IsNaN(net_science))
            {
                double science_coeff = -science_experiment_number / 2.0;
                net_science = net_science * Math.Exp(science_coeff);
                ScreenMessages.PostScreenMessage("Impact Recorded, science report can now be accessed from one of your accelerometers deployed on this body.", 5f, ScreenMessageStyle.UPPER_CENTER);
                this.lastImpactTime = Planetarium.GetUniversalTime();
                Debug.Log("[KSP Interstellar] Impactor: Impact registered!");

                ConfigNode impact_node = new ConfigNode(vessel_impact_node_string);
                impact_node.AddValue(string.Intern("transmitted"), bool.FalseString);
                impact_node.AddValue(string.Intern("vesselname"), vessel.vesselName);
                impact_node.AddValue(string.Intern("science"), net_science);
                impact_node.AddValue(string.Intern("number"), (science_experiment_number + 1).ToString("0"));
                science_node.AddNode(impact_node);

                config.Save(PluginHelper.PluginSaveFilePath);
            }
        }
        public override void OnFixedUpdate()
        {
            float global_rate_multipliers = 1;

            crew_capacity_ratio     = ((float)part.protoModuleCrew.Count) / ((float)part.CrewCapacity);
            global_rate_multipliers = global_rate_multipliers * crew_capacity_ratio;

            if (ResearchAndDevelopment.Instance != null)
            {
                if (!double.IsNaN(science_awaiting_addition) && !double.IsInfinity(science_awaiting_addition) && science_awaiting_addition > 0)
                {
                    ResearchAndDevelopment.Instance.Science = ResearchAndDevelopment.Instance.Science + (float)science_awaiting_addition;
                    ScreenMessages.PostScreenMessage(science_awaiting_addition.ToString("0") + " science has been added to the R&D centre.", 2.5f, ScreenMessageStyle.UPPER_CENTER);
                    science_awaiting_addition = 0;
                }
            }

            if (IsEnabled)
            {
                if (active_mode == 0)   // Research
                {
                    double electrical_power_provided = consumeFNResource(GameConstants.basePowerConsumption * TimeWarp.fixedDeltaTime, FNResourceManager.FNRESOURCE_MEGAJOULES);
                    electrical_power_ratio  = (float)(electrical_power_provided / TimeWarp.fixedDeltaTime / GameConstants.basePowerConsumption);
                    global_rate_multipliers = global_rate_multipliers * electrical_power_ratio;
                    float stupidity = 0;
                    foreach (ProtoCrewMember proto_crew_member in part.protoModuleCrew)
                    {
                        stupidity += proto_crew_member.stupidity;
                    }
                    stupidity = 1.5f - stupidity / 2.0f;
                    float altitude_multiplier = (float)(vessel.altitude / (vessel.mainBody.Radius));
                    altitude_multiplier = Math.Max(altitude_multiplier, 1);
                    science_rate_f      = (float)(GameConstants.baseScienceRate * PluginHelper.getScienceMultiplier(vessel.mainBody.flightGlobalsIndex, vessel.LandedOrSplashed) / 86400.0f * global_rate_multipliers * stupidity / (Mathf.Sqrt(altitude_multiplier)));
                    if (ResearchAndDevelopment.Instance != null)
                    {
                        if (!double.IsNaN(science_rate_f) && !double.IsInfinity(science_rate_f))
                        {
                            ResearchAndDevelopment.Instance.Science = ResearchAndDevelopment.Instance.Science + science_rate_f * TimeWarp.fixedDeltaTime;
                        }
                    }
                }
                else if (active_mode == 1)     // Fuel Reprocessing
                {
                    double electrical_power_provided = consumeFNResource(GameConstants.basePowerConsumption * TimeWarp.fixedDeltaTime, FNResourceManager.FNRESOURCE_MEGAJOULES);
                    electrical_power_ratio  = (float)(electrical_power_provided / TimeWarp.fixedDeltaTime / GameConstants.basePowerConsumption);
                    global_rate_multipliers = global_rate_multipliers * electrical_power_ratio;
                    reprocessor.performReprocessingFrame(global_rate_multipliers);
                    if (reprocessor.getActinidesRemovedPerHour() > 0)
                    {
                        reprocessing_rate_f = (float)(reprocessor.getRemainingAmountToReprocess() / reprocessor.getActinidesRemovedPerHour());
                    }
                    else
                    {
                        IsEnabled = false;
                    }
                }
                else if (active_mode == 2)     //Antimatter
                {
                    double electrical_power_provided = consumeFNResource(GameConstants.baseAMFPowerConsumption * TimeWarp.fixedDeltaTime, FNResourceManager.FNRESOURCE_MEGAJOULES);
                    electrical_power_ratio  = (float)(electrical_power_provided / TimeWarp.fixedDeltaTime / GameConstants.baseAMFPowerConsumption);
                    global_rate_multipliers = crew_capacity_ratio * electrical_power_ratio;
                    anti_factory.produceAntimatterFrame(global_rate_multipliers);
                    antimatter_rate_f = (float)anti_factory.getAntimatterProductionRate();
                }
                else if (active_mode == 3)
                {
                    IsEnabled = false;
                }
                else if (active_mode == 4)     // Centrifuge
                {
                    if (vessel.Splashed)
                    {
                        float electrical_power_provided = consumeFNResource(GameConstants.baseCentriPowerConsumption * TimeWarp.fixedDeltaTime, FNResourceManager.FNRESOURCE_MEGAJOULES);
                        electrical_power_ratio  = (float)(electrical_power_provided / TimeWarp.fixedDeltaTime / GameConstants.baseCentriPowerConsumption);
                        global_rate_multipliers = global_rate_multipliers * electrical_power_ratio;
                        float deut_produced = (float)(global_rate_multipliers * GameConstants.deuterium_timescale * GameConstants.deuterium_abudance * 1000.0f);
                        deut_rate_f = -ORSHelper.fixedRequestResource(part, "Deuterium", -deut_produced * TimeWarp.fixedDeltaTime) / TimeWarp.fixedDeltaTime;
                    }
                    else
                    {
                        ScreenMessages.PostScreenMessage("You must be splashed down to perform this activity.", 5.0f, ScreenMessageStyle.UPPER_CENTER);
                        IsEnabled = false;
                    }
                }

                if (electrical_power_ratio <= 0)
                {
                    deut_rate_f         = 0;
                    electrolysis_rate_f = 0;
                    science_rate_f      = 0;
                    antimatter_rate_f   = 0;
                    reprocessing_rate_f = 0;
                }

                last_active_time = (float)Planetarium.GetUniversalTime();
            }
            else
            {
            }
        }
        public override void OnStart(PartModule.StartState state)
        {
            if (state == StartState.Editor)
            {
                return;
            }
            reprocessor  = new FuelReprocessor(part);
            anti_factory = new AntimatterFactory(part);
            ConfigNode config = PluginHelper.getPluginSaveFile();

            part.force_activate();

            anim  = part.FindModelAnimators(animName1).FirstOrDefault();
            anim2 = part.FindModelAnimators(animName2).FirstOrDefault();
            if (anim != null && anim2 != null)
            {
                anim[animName1].layer  = 1;
                anim2[animName2].layer = 1;
                if (IsEnabled)
                {
                    //anim [animName1].normalizedTime = 1f;
                    //anim2 [animName2].normalizedTime = 1f;
                    //anim [animName1].speed = -1f;
                    //anim2 [animName2].speed = -1f;
                    anim.Blend(animName1, 1, 0);
                    anim2.Blend(animName2, 1, 0);
                }
                else
                {
                    //anim [animName1].normalizedTime = 0f;
                    //anim2 [animName2].normalizedTime = 0f;
                    //anim [animName1].speed = 1f;
                    //anim2 [animName2].speed = 1f;
                    //anim.Blend (animName1, 0, 0);
                    //anim2.Blend (animName2, 0, 0);
                    play_down = false;
                }
                //anim.Play ();
                //anim2.Play ();
            }

            if (IsEnabled && last_active_time != 0)
            {
                float global_rate_multipliers = 1;
                crew_capacity_ratio     = ((float)part.protoModuleCrew.Count) / ((float)part.CrewCapacity);
                global_rate_multipliers = global_rate_multipliers * crew_capacity_ratio;

                if (active_mode == 0)   // Science persistence
                {
                    double now                 = Planetarium.GetUniversalTime();
                    double time_diff           = now - last_active_time;
                    float  altitude_multiplier = (float)(vessel.altitude / (vessel.mainBody.Radius));
                    altitude_multiplier = Math.Max(altitude_multiplier, 1);
                    float stupidity = 0;
                    foreach (ProtoCrewMember proto_crew_member in part.protoModuleCrew)
                    {
                        stupidity += proto_crew_member.stupidity;
                    }
                    stupidity = 1.5f - stupidity / 2.0f;
                    double science_to_add = GameConstants.baseScienceRate * time_diff / 86400 * electrical_power_ratio * stupidity * global_rate_multipliers * PluginHelper.getScienceMultiplier(vessel.mainBody.flightGlobalsIndex, vessel.LandedOrSplashed) / ((float)Math.Sqrt(altitude_multiplier));
                    //part.RequestResource ("Science", -science_to_add);
                    science_awaiting_addition = science_to_add;
                }
                else if (active_mode == 2)     // Antimatter persistence
                {
                    double now       = Planetarium.GetUniversalTime();
                    double time_diff = now - last_active_time;

                    List <PartResource> partresources = new List <PartResource>();
                    part.GetConnectedResources(PartResourceLibrary.Instance.GetDefinition("Antimatter").id, partresources);
                    float currentAntimatter_missing = 0;
                    foreach (PartResource partresource in partresources)
                    {
                        currentAntimatter_missing += (float)(partresource.maxAmount - partresource.amount);
                    }



                    float  total_electrical_power_provided = (float)(electrical_power_ratio * (GameConstants.baseAMFPowerConsumption + GameConstants.basePowerConsumption) * 1E6);
                    double antimatter_mass = total_electrical_power_provided / GameConstants.warpspeed / GameConstants.warpspeed * 1E6 / 20000.0;
                    float  antimatter_peristence_to_add = (float)-Math.Min(currentAntimatter_missing, antimatter_mass * time_diff);
                    part.RequestResource("Antimatter", antimatter_peristence_to_add);
                }
            }
        }
Exemple #30
0
        public override void OnStart(PartModule.StartState state)
        {
            if (state == StartState.Editor)
            {
                if (this.HasTechsRequiredToUpgrade())
                {
                    isupgraded = true;
                    upgradePartModule();
                }
                return;
            }

            if (isupgraded)
            {
                upgradePartModule();
            }
            else
            {
                if (this.HasTechsRequiredToUpgrade())
                {
                    hasrequiredupgrade = true;
                }
            }

            // update gui names
            Events["BeginResearch"].guiName = beginResearchName;

            reprocessor  = new NuclearFuelReprocessor(part);
            anti_factory = new AntimatterFactory(part);
            ConfigNode config = PluginHelper.getPluginSaveFile();

            part.force_activate();

            anim  = part.FindModelAnimators(animName1).FirstOrDefault();
            anim2 = part.FindModelAnimators(animName2).FirstOrDefault();
            if (anim != null && anim2 != null)
            {
                anim[animName1].layer  = 1;
                anim2[animName2].layer = 1;
                if (IsEnabled)
                {
                    //anim [animName1].normalizedTime = 1f;
                    //anim2 [animName2].normalizedTime = 1f;
                    //anim [animName1].speed = -1f;
                    //anim2 [animName2].speed = -1f;
                    anim.Blend(animName1, 1, 0);
                    anim2.Blend(animName2, 1, 0);
                }
                else
                {
                    //anim [animName1].normalizedTime = 0f;
                    //anim2 [animName2].normalizedTime = 0f;
                    //anim [animName1].speed = 1f;
                    //anim2 [animName2].speed = 1f;
                    //anim.Blend (animName1, 0, 0);global_rate_multipliers
                    //anim2.Blend (animName2, 0, 0);
                    play_down = false;
                }
                //anim.Play ();
                //anim2.Play ();
            }

            if (IsEnabled && last_active_time != 0)
            {
                float global_rate_multipliers = 1;
                crew_capacity_ratio     = ((float)part.protoModuleCrew.Count) / ((float)part.CrewCapacity);
                global_rate_multipliers = global_rate_multipliers * crew_capacity_ratio;

                if (active_mode == 0) // Science persistence
                {
                    double time_diff                 = Planetarium.GetUniversalTime() - last_active_time;
                    float  altitude_multiplier       = Math.Max((float)(vessel.altitude / (vessel.mainBody.Radius)), 1);
                    float  kerbalResearchSkillFactor = part.protoModuleCrew.Sum(proto_crew_member => GetKerbalScienceFactor(proto_crew_member) / 2f);

                    double science_to_increment = kerbalResearchSkillFactor * GameConstants.baseScienceRate * time_diff
                                                  / GameConstants.EARH_DAY_SECONDS * electrical_power_ratio * global_rate_multipliers * PluginHelper.getScienceMultiplier(vessel) //PluginHelper.getScienceMultiplier(vessel.mainBody.flightGlobalsIndex, vessel.LandedOrSplashed)
                                                  / ((float)Math.Sqrt(altitude_multiplier));

                    science_to_increment = (double.IsNaN(science_to_increment) || double.IsInfinity(science_to_increment)) ? 0 : science_to_increment;
                    science_to_add      += (float)science_to_increment;
                }
                else if (active_mode == 2) // Antimatter persistence
                {
                    double time_diff = Planetarium.GetUniversalTime() - last_active_time;

                    List <PartResource> antimatter_resources = part.GetConnectedResources(InterstellarResourcesConfiguration.Instance.Antimatter).ToList();
                    float currentAntimatter_missing          = (float)antimatter_resources.Sum(ar => ar.maxAmount - ar.amount);

                    float  total_electrical_power_provided = (float)(electrical_power_ratio * (PluginHelper.BaseAMFPowerConsumption + PluginHelper.BasePowerConsumption) * 1E6);
                    double antimatter_mass = total_electrical_power_provided / GameConstants.warpspeed / GameConstants.warpspeed * 1E6 / 20000.0;
                    float  antimatter_peristence_to_add = (float)-Math.Min(currentAntimatter_missing, antimatter_mass * time_diff);
                    part.RequestResource("Antimatter", antimatter_peristence_to_add);
                }
            }
        }