예제 #1
0
        public string SituationList()
        {
            Vessel.Situations first  = situation.First();
            Vessel.Situations last   = situation.Last();
            string            result = ReachSituation.GetTitleStringShort(first);

            foreach (Vessel.Situations sit in situation.Where(s => s != first && s != last))
            {
                result += ", " + ReachSituation.GetTitleStringShort(sit);
            }
            if (last != first)
            {
                result += " or " + ReachSituation.GetTitleStringShort(last);
            }
            return(result);
        }
        protected void CreateDelegates()
        {
            // Filter for celestial bodies
            if (targetBody != null)
            {
                AddParameter(new ParameterDelegate <Vessel>("Destination: " + targetBody.CleanDisplayName(),
                                                            v => v.mainBody == targetBody, true));
            }

            // Filter for situation
            if (orbit == null)
            {
                AddParameter(new ParameterDelegate <Vessel>("Situation: " + ReachSituation.GetTitleStringShort(situation),
                                                            v => v.situation == situation, true));
            }

            // Filter for altitude
            if (minAltitude != 0.0 || maxAltitude != double.MaxValue)
            {
                string output = "Altitude: ";
                if (minAltitude == 0.0)
                {
                    output += "Below " + maxAltitude.ToString("N0") + " m";
                }
                else if (maxAltitude == double.MaxValue)
                {
                    output += "Above " + minAltitude.ToString("N0") + " m";
                }
                else
                {
                    output += "Between " + minAltitude.ToString("N0") + " m and " + maxAltitude.ToString("N0") + " m";
                }

                AddParameter(new ParameterDelegate <Vessel>(output, v => v.orbit.PeA >= minAltitude && v.orbit.ApA <= maxAltitude));
            }

            // Filter for apoapsis
            if (minApoapsis != 0.0 || maxApoapsis != double.MaxValue)
            {
                string output = "Apoapsis: ";
                if (minApoapsis == 0.0)
                {
                    output += "Below " + maxApoapsis.ToString("N0") + " m";
                }
                else if (maxApoapsis == double.MaxValue)
                {
                    output += "Above " + minApoapsis.ToString("N0") + " m";
                }
                else
                {
                    output += "Between " + minApoapsis.ToString("N0") + " m and " + maxApoapsis.ToString("N0") + " m";
                }

                AddParameter(new ParameterDelegate <Vessel>(output, v => v.orbit.ApA >= minApoapsis && v.orbit.ApA <= maxApoapsis));
            }

            // Filter for periapsis
            if (minPeriapsis != 0.0 || maxPeriapsis != double.MaxValue)
            {
                string output = "Periapsis: ";
                if (minPeriapsis == 0.0)
                {
                    output += "Below " + maxPeriapsis.ToString("N0") + " m";
                }
                else if (maxPeriapsis == double.MaxValue)
                {
                    output += "Above " + minPeriapsis.ToString("N0") + " m";
                }
                else
                {
                    output += "Between " + minPeriapsis.ToString("N0") + " m and " + maxPeriapsis.ToString("N0") + " m";
                }

                AddParameter(new ParameterDelegate <Vessel>(output, v => v.orbit.PeA >= minPeriapsis && v.orbit.PeA <= maxPeriapsis));
            }

            // Filter for eccentricity
            if (minEccentricity != 0.0 || maxEccentricity != double.MaxValue)
            {
                string output = "Eccentricity: ";
                if (minEccentricity == 0.0)
                {
                    output += "Below " + maxEccentricity.ToString("F4");
                }
                else if (maxEccentricity == double.MaxValue)
                {
                    output += "Above " + minEccentricity.ToString("F4");
                }
                else
                {
                    output += "Between " + minEccentricity.ToString("F4") + " and " + maxEccentricity.ToString("F4");
                }

                AddParameter(new ParameterDelegate <Vessel>(output, v => v.orbit.eccentricity >= minEccentricity && v.orbit.eccentricity <= maxEccentricity));
            }

            // Filter for inclination
            if (minInclination != 0.0 || maxInclination != 180.0)
            {
                string output = "Inclination: ";
                if (minInclination == 0.0)
                {
                    output += "Below " + maxInclination.ToString("F1") + "°";
                }
                else if (maxInclination == 180.0)
                {
                    output += "Above " + minInclination.ToString("F1") + "°";
                }
                else
                {
                    output += "Between " + minInclination.ToString("F1") + "° and " + maxInclination.ToString("F1") + "°";
                }

                AddParameter(new ParameterDelegate <Vessel>(output, CheckInclination));
            }

            // Filter for argument of periapsis
            if (minArgumentOfPeriapsis != 0.0 || !(Mathf.Approximately((float)maxArgumentOfPeriapsis, 360.0f) || Mathf.Approximately((float)maxArgumentOfPeriapsis, 0.0f)))
            {
                string output = "Argument of Periapsis: Between " +
                                minArgumentOfPeriapsis.ToString("F1") + "° and " + maxArgumentOfPeriapsis.ToString("F1") + "°";

                AddParameter(new ParameterDelegate <Vessel>(output, CheckAoP));
            }

            // Filter for orbital period
            if (minPeriod != 0.0 || maxPeriod != double.MaxValue)
            {
                string output = "Period: ";
                if (minPeriod == 0.0)
                {
                    output += "Below " + DurationUtil.StringValue(maxPeriod, false);
                }
                else if (maxPeriod == double.MaxValue)
                {
                    output += "Above " + DurationUtil.StringValue(minPeriod, false);
                }
                else
                {
                    output += "Between " + DurationUtil.StringValue(minPeriod, false) + " and " + DurationUtil.StringValue(maxPeriod, false);
                }

                AddParameter(new ParameterDelegate <Vessel>(output, v => v.orbit.period >= minPeriod && v.orbit.period <= maxPeriod));
            }

            // Filter for specific orbit
            if (orbit != null)
            {
                string output = "Reach the specified orbit";
                AddParameter(new ParameterDelegate <Vessel>(output, v => VesselUtilities.VesselAtOrbit(orbit, deviationWindow, v)));
            }
        }
        protected void CreateDelegates()
        {
            // Filter for celestial bodies
            if (targetBody != null)
            {
                AddParameter(new ParameterDelegate <Vessel>("Destination: " + targetBody.PrintName(),
                                                            v => v.mainBody == targetBody, true));
            }

            // Filter for biome
            if (!string.IsNullOrEmpty(biome))
            {
                AddParameter(new ParameterDelegate <Vessel>("Biome: " + biome, CheckBiome));
            }

            // Filter for situation
            if (situation != null)
            {
                AddParameter(new ParameterDelegate <Vessel>("Situation: " + ReachSituation.GetTitleStringShort(situation.Value),
                                                            v => v.situation == situation.Value));
            }

            // Filter for altitude
            if (minAltitude != 0.0f || maxAltitude != float.MaxValue)
            {
                string output = "Altitude: ";
                if (minAltitude == 0.0f)
                {
                    output += "Below " + maxAltitude.ToString("N0") + " m";
                }
                else if (maxAltitude == float.MaxValue)
                {
                    output += "Above " + minAltitude.ToString("N0") + " m";
                }
                else
                {
                    output += "Between " + minAltitude.ToString("N0") + " m and " + maxAltitude.ToString("N0") + " m";
                }

                AddParameter(new ParameterDelegate <Vessel>(output, v => v.altitude >= minAltitude && v.altitude <= maxAltitude));
            }

            // Filter for speed
            if (minSpeed != 0.0 || maxSpeed != double.MaxValue)
            {
                string output = "Speed: ";
                if (minSpeed == 0.0)
                {
                    output += "Less than " + maxSpeed.ToString("N0") + " m/s";
                }
                else if (maxSpeed == double.MaxValue)
                {
                    output += "Greater than " + minSpeed.ToString("N0") + " m/s";
                }
                else
                {
                    output += "Between " + minSpeed.ToString("N0") + " m/s and " + maxSpeed.ToString("N0") + " m/s";
                }

                AddParameter(new ParameterDelegate <Vessel>(output, CheckVesselSpeed));
            }
        }
 public ReachSituationCustom(Vessel.Situations situation, string title)
     : base()
 {
     this.title     = title != null ? title : "Situation: " + ReachSituation.GetTitleStringShort(situation);
     this.situation = situation;
 }
예제 #5
0
        public void touristUpdate()
        {
            if (ContractSystem.Instance == null)
            {
                return;
            }

            if (ContractSystem.Instance.GetActiveContractCount() <= 0)
            {
                return;
            }

            Contract[] currentContracts = ContractSystem.Instance.GetCurrentActiveContracts <TourismContract>();

            for (int i = 0; i < currentContracts.Length; i++)
            {
                Contract c = currentContracts[i];

                if (c == null)
                {
                    continue;
                }

                if (c.ContractState != Contract.State.Active)
                {
                    continue;
                }

                var activeParams = c.AllParameters.Where(a => a.GetType() == typeof(KerbalTourParameter) && a.State == ParameterState.Incomplete).ToList();

                int l = activeParams.Count;

                for (int j = 0; j < l; j++)
                {
                    KerbalTourParameter p = activeParams[j] as KerbalTourParameter;

                    if (p == null)
                    {
                        continue;
                    }

                    if (p.State != ParameterState.Incomplete)
                    {
                        continue;
                    }

                    if (p.kerbalName != protoCrew.name)
                    {
                        continue;
                    }

                    var destinationParams = p.AllParameters.Where(a => a.GetType() == typeof(KerbalDestinationParameter) && a.State == ParameterState.Incomplete).ToList();

                    int e = destinationParams.Count;

                    for (int k = 0; k < e; k++)
                    {
                        KerbalDestinationParameter d = destinationParams[k] as KerbalDestinationParameter;

                        if (d == null)
                        {
                            continue;
                        }

                        if (d.State != ParameterState.Incomplete)
                        {
                            continue;
                        }

                        if (d.kerbalName != protoCrew.name)
                        {
                            continue;
                        }

                        touristParams.Add(d.Title);
                    }
                }

                var geeParams = c.AllParameters.Where(a => a.GetType() == typeof(KerbalGeeAdventureParameter) && a.State == ParameterState.Incomplete).ToList();

                l = geeParams.Count;

                for (int j = 0; j < l; j++)
                {
                    KerbalGeeAdventureParameter g = geeParams[j] as KerbalGeeAdventureParameter;

                    if (g == null)
                    {
                        continue;
                    }

                    if (g.State != ParameterState.Incomplete)
                    {
                        continue;
                    }

                    if (g.kerbalName != protoCrew.name)
                    {
                        continue;
                    }

                    ReachDestination destination = g.GetParameter <ReachDestination>();

                    if (destination == null)
                    {
                        continue;
                    }

                    if (destination.Destination == null)
                    {
                        continue;
                    }

                    ReachSituation situation = g.GetParameter <ReachSituation>();

                    if (situation == null)
                    {
                        continue;
                    }

                    string article = getArticle(situation.Situation);

                    touristParams.Add(string.Format("Pass out from gee forces {0}\n{1} at {2}", article, ReachSituation.GetTitleStringShort(situation.Situation), Localizer.Format("<<1>>", destination.Destination.displayName)));
                }
            }
        }
예제 #6
0
 public string SituationList()
 {
     return(LocalizationUtil.LocalizeList <Vessel.Situations>(LocalizationUtil.Conjunction.OR, situation, sit => ReachSituation.GetTitleStringShort(sit)));
 }
        protected void CreateDelegates()
        {
            // Filter for celestial bodies
            if (targetBody != null)
            {
                AddParameter(new ParameterDelegate <Vessel>(Localizer.Format("#cc.param.CollectScience.destination", targetBody.displayName),
                                                            v => v.mainBody == targetBody, true));
            }

            // Filter for situation
            if (orbit == null)
            {
                AddParameter(new ParameterDelegate <Vessel>(Localizer.Format("#cc.param.CollectScience.situation", ReachSituation.GetTitleStringShort(situation)),
                                                            v => v.situation == situation, true));
            }

            // Filter for altitude
            if (minAltitude != 0.0 || maxAltitude != double.MaxValue)
            {
                string output;
                if (minAltitude == 0.0)
                {
                    output = Localizer.Format("#cc.param.Orbit.below.meters", Localizer.GetStringByTag("#cc.altitude"), maxAltitude.ToString("N0"));
                }
                else if (maxAltitude == double.MaxValue)
                {
                    output = Localizer.Format("#cc.param.Orbit.above.meters", Localizer.GetStringByTag("#cc.altitude"), minAltitude.ToString("N0"));
                }
                else
                {
                    output = Localizer.Format("#cc.param.Orbit.between.meters", Localizer.GetStringByTag("#cc.altitude"), minAltitude.ToString("N0"), maxAltitude.ToString("N0"));
                }

                AddParameter(new ParameterDelegate <Vessel>(output, v => v.orbit.PeA >= minAltitude && v.orbit.ApA <= maxAltitude));
            }

            // Filter for apoapsis
            if (minApoapsis != 0.0 || maxApoapsis != double.MaxValue)
            {
                string output;
                if (minApoapsis == 0.0)
                {
                    output = Localizer.Format("#cc.param.Orbit.below.meters", Localizer.GetStringByTag("#cc.apoapsis"), maxApoapsis.ToString("N0"));
                }
                else if (maxApoapsis == double.MaxValue)
                {
                    output = Localizer.Format("#cc.param.Orbit.above.meters", Localizer.GetStringByTag("#cc.apoapsis"), minApoapsis.ToString("N0"));
                }
                else
                {
                    output = Localizer.Format("#cc.param.Orbit.between.meters", Localizer.GetStringByTag("#cc.apoapsis"), minApoapsis.ToString("N0"), maxApoapsis.ToString("N0"));
                }

                AddParameter(new ParameterDelegate <Vessel>(output, v => v.orbit.ApA >= minApoapsis && v.orbit.ApA <= maxApoapsis));
            }

            // Filter for periapsis
            if (minPeriapsis != 0.0 || maxPeriapsis != double.MaxValue)
            {
                string output;
                if (minPeriapsis == 0.0)
                {
                    output = Localizer.Format("#cc.param.Orbit.below.meters", Localizer.GetStringByTag("#cc.periapsis"), maxPeriapsis.ToString("N0"));
                }
                else if (maxPeriapsis == double.MaxValue)
                {
                    output = Localizer.Format("#cc.param.Orbit.above.meters", Localizer.GetStringByTag("#cc.periapsis"), minPeriapsis.ToString("N0"));
                }
                else
                {
                    output = Localizer.Format("#cc.param.Orbit.between.meters", Localizer.GetStringByTag("#cc.periapsis"), minPeriapsis.ToString("N0"), maxPeriapsis.ToString("N0"));
                }

                AddParameter(new ParameterDelegate <Vessel>(output, v => v.orbit.PeA >= minPeriapsis && v.orbit.PeA <= maxPeriapsis));
            }

            // Filter for eccentricity
            if (minEccentricity != 0.0 || maxEccentricity != double.MaxValue)
            {
                string output;
                if (minEccentricity == 0.0)
                {
                    output = Localizer.Format("#cc.param.Orbit.below.nounits", Localizer.GetStringByTag("#cc.eccentricity"), maxEccentricity.ToString("F4"));
                }
                else if (maxEccentricity == double.MaxValue)
                {
                    output = Localizer.Format("#cc.param.Orbit.above.nounits", Localizer.GetStringByTag("#cc.eccentricity"), minEccentricity.ToString("F4"));
                }
                else
                {
                    output = Localizer.Format("#cc.param.Orbit.between.nounits", Localizer.GetStringByTag("#cc.eccentricity"), minEccentricity.ToString("F4"), maxEccentricity.ToString("F4"));
                }

                AddParameter(new ParameterDelegate <Vessel>(output, v => v.orbit.eccentricity >= minEccentricity && v.orbit.eccentricity <= maxEccentricity));
            }

            // Filter for inclination
            if (minInclination != 0.0 || maxInclination != 180.0)
            {
                string output;
                if (minInclination == 0.0)
                {
                    output = Localizer.Format("#cc.param.Orbit.below.degrees", Localizer.GetStringByTag("#cc.inclination"), maxInclination.ToString("F1"));
                }
                else if (maxInclination == 180.0)
                {
                    output = Localizer.Format("#cc.param.Orbit.above.degrees", Localizer.GetStringByTag("#cc.inclination"), minInclination.ToString("F1"));
                }
                else
                {
                    output = Localizer.Format("#cc.param.Orbit.between.degrees", Localizer.GetStringByTag("#cc.inclination"), minInclination.ToString("F1"), maxInclination.ToString("F1"));
                }

                AddParameter(new ParameterDelegate <Vessel>(output, CheckInclination));
            }

            // Filter for argument of periapsis
            if (minArgumentOfPeriapsis != 0.0 || !(Mathf.Approximately((float)maxArgumentOfPeriapsis, 360.0f) || Mathf.Approximately((float)maxArgumentOfPeriapsis, 0.0f)))
            {
                string output = Localizer.Format("#cc.param.Orbit.between.degrees", Localizer.GetStringByTag("#autoLOC_6005020"), minArgumentOfPeriapsis.ToString("F1"), maxArgumentOfPeriapsis.ToString("F1"));
                AddParameter(new ParameterDelegate <Vessel>(output, CheckAoP));
            }

            // Filter for orbital period
            if (minPeriod != 0.0 || maxPeriod != double.MaxValue)
            {
                string output;
                if (minPeriod == 0.0)
                {
                    output = Localizer.Format("#cc.param.Orbit.below.nounits", Localizer.GetStringByTag("#autoLOC_6005032"), DurationUtil.StringValue(maxPeriod, false));
                }
                else if (maxPeriod == double.MaxValue)
                {
                    output = Localizer.Format("#cc.param.Orbit.above.nounits", Localizer.GetStringByTag("#autoLOC_6005032"), DurationUtil.StringValue(minPeriod, false));
                }
                else
                {
                    output = Localizer.Format("#cc.param.Orbit.between.nounits", Localizer.GetStringByTag("#autoLOC_6005032"), DurationUtil.StringValue(minPeriod, false), DurationUtil.StringValue(maxPeriod, false));
                }

                AddParameter(new ParameterDelegate <Vessel>(output, v => v.orbit.period >= minPeriod && v.orbit.period <= maxPeriod));
            }

            // Filter for specific orbit
            if (orbit != null)
            {
                AddParameter(new ParameterDelegate <Vessel>(Localizer.GetStringByTag("#cc.param.Orbit.specified"), v => VesselUtilities.VesselAtOrbit(orbit, deviationWindow, v)));
            }
        }
예제 #8
0
        protected void CreateDelegates()
        {
            // Filter for celestial bodies
            if (targetBody != null)
            {
                AddParameter(new ParameterDelegate <Vessel>("Destination: " + targetBody.theName,
                                                            v => v.mainBody == targetBody, true));
            }

            // Filter for situation
            AddParameter(new ParameterDelegate <Vessel>("Situation: " + ReachSituation.GetTitleStringShort(situation),
                                                        v => v.situation == situation, true));

            // Filter for altitude
            if (minAltitude != 0.0 || maxAltitude != double.MaxValue)
            {
                string output = "Altitude: ";
                if (minAltitude == 0.0)
                {
                    output += "Below " + maxAltitude.ToString("N0") + " m";
                }
                else if (maxAltitude == double.MaxValue)
                {
                    output += "Above " + minAltitude.ToString("N0") + " m";
                }
                else
                {
                    output += "Between " + minAltitude.ToString("N0") + " m and " + maxAltitude.ToString("N0") + " m";
                }

                AddParameter(new ParameterDelegate <Vessel>(output, v => v.orbit.PeA >= minAltitude && v.orbit.ApA <= maxAltitude));
            }

            // Filter for apoapsis
            if (minApoapsis != 0.0 || maxApoapsis != double.MaxValue)
            {
                string output = "Apoapsis: ";
                if (minApoapsis == 0.0)
                {
                    output += "Below " + maxApoapsis.ToString("N0") + " m";
                }
                else if (maxApoapsis == double.MaxValue)
                {
                    output += "Above " + minApoapsis.ToString("N0") + " m";
                }
                else
                {
                    output += "Between " + minApoapsis.ToString("N0") + " m and " + maxApoapsis.ToString("N0") + " m";
                }

                AddParameter(new ParameterDelegate <Vessel>(output, v => v.orbit.ApA >= minApoapsis && v.orbit.ApA <= maxApoapsis));
            }

            // Filter for periapsis
            if (minPeriapsis != 0.0 || maxPeriapsis != double.MaxValue)
            {
                string output = "Periapsis: ";
                if (minPeriapsis == 0.0)
                {
                    output += "Below " + maxPeriapsis.ToString("N0") + " m";
                }
                else if (maxPeriapsis == double.MaxValue)
                {
                    output += "Above " + minPeriapsis.ToString("N0") + " m";
                }
                else
                {
                    output += "Between " + minPeriapsis.ToString("N0") + " m and " + maxPeriapsis.ToString("N0") + " m";
                }

                AddParameter(new ParameterDelegate <Vessel>(output, v => v.orbit.PeA >= minPeriapsis && v.orbit.PeA <= maxPeriapsis));
            }

            // Filter for eccentricity
            if (minEccentricity != 0.0 || maxEccentricity != double.MaxValue)
            {
                string output = "Eccentricity: ";
                if (minEccentricity == 0.0)
                {
                    output += "Below " + maxEccentricity.ToString("F4");
                }
                else if (maxEccentricity == double.MaxValue)
                {
                    output += "Above " + minEccentricity.ToString("F4");
                }
                else
                {
                    output += "Between " + minEccentricity.ToString("F4") + " and " + maxEccentricity.ToString("F4");
                }

                AddParameter(new ParameterDelegate <Vessel>(output, v => v.orbit.eccentricity >= minEccentricity && v.orbit.eccentricity <= maxEccentricity));
            }

            // Filter for inclination
            if (minInclination != 0.0 || maxInclination != 180.0)
            {
                string output = "Inclination: ";
                if (minInclination == 0.0)
                {
                    output += "Below " + maxInclination.ToString("F1") + "°";
                }
                else if (maxInclination == 180.0)
                {
                    output += "Above " + minInclination.ToString("F1") + "°";
                }
                else
                {
                    output += "Between " + minInclination.ToString("F1") + "° and " + maxInclination.ToString("F1") + "°";
                }

                AddParameter(new ParameterDelegate <Vessel>(output, CheckInclination));
            }

            // Filter for orbital period
            if (minPeriod != 0.0 || maxPeriod != double.MaxValue)
            {
                string output = "Period: ";
                if (minPeriod == 0.0)
                {
                    output += "Below " + DurationUtil.StringValue(maxPeriod, false);
                }
                else if (maxPeriod == double.MaxValue)
                {
                    output += "Above " + DurationUtil.StringValue(minPeriod, false);
                }
                else
                {
                    output += "Between " + DurationUtil.StringValue(minPeriod, false) + " and " + DurationUtil.StringValue(maxPeriod, false);
                }

                AddParameter(new ParameterDelegate <Vessel>(output, v => v.orbit.period >= minPeriod && v.orbit.period <= maxPeriod));
            }
        }