public OrbitGenerator(OrbitGenerator orig, Contract contract)
            : base()
        {
            foreach (OrbitData old in orig.orbits)
            {
                for (int i = 0; i < old.count; i++)
                {
                    // Copy orbit data
                    orbits.Add(new OrbitData(old, contract));
                }
            }

            System.Random random = new System.Random(contract.MissionSeed);

            // Find/add the AlwaysTrue parameter
            AlwaysTrue alwaysTrue = AlwaysTrue.FetchOrAdd(contract);

            int index = 0;

            foreach (OrbitData obData in orbits)
            {
                // Do type specific handling
                if (obData.type == "RANDOM_ORBIT")
                {
                    if (!ValidateOrbitType(obData, null))
                    {
                    }

                    obData.orbit = OrbitUtilities.GenerateOrbit(contract.MissionSeed + index++, obData.targetBody, obData.orbitType,
                                                                obData.altitudeFactor, obData.inclinationFactor, obData.eccentricity);
                }
                else
                {
                    obData.orbit.referenceBody = obData.targetBody;
                }

                obData.SetupRenderer();
            }
        }
        protected override bool Generate()
        {
            DMReconContract[] reconContracts = ContractSystem.Instance.GetCurrentContracts <DMReconContract>();
            int offers    = 0;
            int active    = 0;
            int maxOffers = DMContractDefs.DMRecon.maxOffers;
            int maxActive = DMContractDefs.DMRecon.maxActive;

            for (int i = 0; i < reconContracts.Length; i++)
            {
                DMReconContract r = reconContracts[i];
                if (r.ContractState == State.Offered)
                {
                    offers++;
                }
                else if (r.ContractState == State.Active)
                {
                    active++;
                }
            }

            if (offers >= maxOffers)
            {
                return(false);
            }
            if (active >= maxActive)
            {
                return(false);
            }

            List <CelestialBody> customReachedBodies = new List <CelestialBody>();

            switch (prestige)
            {
            case ContractPrestige.Trivial:
                Func <CelestialBody, bool> cb = delegate(CelestialBody b)
                {
                    if (b == Planetarium.fetch.Sun)
                    {
                        return(false);
                    }

                    if (b.pqsController == null)
                    {
                        return(false);
                    }

                    return(true);
                };
                customReachedBodies.AddRange(ProgressUtilities.GetBodiesProgress(ProgressType.ORBIT, true, cb));
                customReachedBodies.AddRange(ProgressUtilities.GetNextUnreached(2, cb));
                var activeBodies = ContractSystem.Instance.GetCurrentActiveContracts <DMReconContract>().Select(r => r.body).ToList();
                customReachedBodies.RemoveAll(a => activeBodies.Contains(a));
                var completedBodies = ContractSystem.Instance.GetCompletedContracts <DMReconContract>().Select(r => r.body).ToList();
                customReachedBodies.RemoveAll(a => completedBodies.Contains(a));
                break;

            case ContractPrestige.Significant:
                customReachedBodies = ContractSystem.Instance.GetCompletedContracts <DMReconContract>().Where(r => r.prestige == ContractPrestige.Trivial).Select(r => r.body).ToList();
                var activeSigBodies = ContractSystem.Instance.GetCurrentActiveContracts <DMReconContract>().Where(r => r.prestige == ContractPrestige.Significant).Select(r => r.body).ToList();
                customReachedBodies.RemoveAll(a => activeSigBodies.Contains(a));
                var completedSigBodies = ContractSystem.Instance.GetCompletedContracts <DMReconContract>().Where(r => r.prestige == ContractPrestige.Significant).Select(r => r.body).ToList();
                customReachedBodies.RemoveAll(a => completedSigBodies.Contains(a));
                break;

            case ContractPrestige.Exceptional:
                customReachedBodies = ContractSystem.Instance.GetCompletedContracts <DMReconContract>().Where(r => r.prestige == ContractPrestige.Significant).Select(r => r.body).ToList();
                var activeExcBodies = ContractSystem.Instance.GetCurrentActiveContracts <DMReconContract>().Where(r => r.prestige == ContractPrestige.Exceptional).Select(r => r.body).ToList();
                customReachedBodies.RemoveAll(a => activeExcBodies.Contains(a));
                var completedExcBodies = ContractSystem.Instance.GetCompletedContracts <DMReconContract>().Where(r => r.prestige == ContractPrestige.Exceptional).Select(r => r.body).ToList();
                customReachedBodies.RemoveAll(a => completedExcBodies.Contains(a));
                break;
            }

            if (customReachedBodies.Count <= 0)
            {
                return(false);
            }

            body = customReachedBodies[rand.Next(0, customReachedBodies.Count)];

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

            double time = 0;

            OrbitType orbitType = OrbitType.POLAR;

            DictionaryValueList <int, List <string> > parts = new DictionaryValueList <int, List <string> >();
            Orbit o = new Orbit();

            double incMod  = (rand.NextDouble() * 10) - 5;
            double timeMod = 1080000;

            if (!DMUtils.availableScience.ContainsKey("All"))
            {
                return(false);
            }

            DMScienceContainer container = null;

            switch (prestige)
            {
            case ContractPrestige.Trivial:
                if (!DMUtils.partAvailable(DMContractDefs.DMRecon.reconTrivialParts))
                {
                    return(false);
                }

                parts.Add(0, DMContractDefs.DMRecon.reconTrivialParts);

                if (!DMUtils.availableScience["All"].ContainsKey(DMContractDefs.DMRecon.trivialExperimentTitle))
                {
                    return(false);
                }

                container = DMUtils.availableScience["All"][DMContractDefs.DMRecon.trivialExperimentTitle];

                o = OrbitUtilities.GenerateOrbit(this.MissionSeed, body, orbitType, 0.15, ContractDefs.Satellite.TrivialInclinationDifficulty);

                double st = o.semiMajorAxis - o.referenceBody.Radius;

                double mt = o.referenceBody.scienceValues.spaceAltitudeThreshold * 5 * .95;

                if (st > mt)
                {
                    o.semiMajorAxis = (mt * Math.Max(0.4, rand.NextDouble())) + o.referenceBody.Radius;
                }

                timeMod = DMContractDefs.DMRecon.trivialTimeModifier * 6 * 3600;
                break;

            case ContractPrestige.Significant:
                if (!DMUtils.partAvailable(DMContractDefs.DMRecon.reconSignificantParts))
                {
                    return(false);
                }

                parts.Add(0, DMContractDefs.DMRecon.reconSignificantParts);

                if (!DMUtils.availableScience["All"].ContainsKey(DMContractDefs.DMRecon.significantExperimentTitle))
                {
                    return(false);
                }

                container = DMUtils.availableScience["All"][DMContractDefs.DMRecon.significantExperimentTitle];

                if (SystemUtilities.CoinFlip(rand))
                {
                    if (CelestialUtilities.CanBodyBeKolniya(body))
                    {
                        orbitType = OrbitType.KOLNIYA;
                    }
                    else if (CelestialUtilities.CanBodyBeTundra(body))
                    {
                        orbitType = OrbitType.TUNDRA;
                    }
                    else
                    {
                        orbitType = OrbitType.POLAR;
                    }
                }
                else
                {
                    if (CelestialUtilities.CanBodyBeTundra(body))
                    {
                        orbitType = OrbitType.TUNDRA;
                    }
                    else if (CelestialUtilities.CanBodyBeKolniya(body))
                    {
                        orbitType = OrbitType.KOLNIYA;
                    }
                    else
                    {
                        orbitType = OrbitType.POLAR;
                    }
                }
                o       = OrbitUtilities.GenerateOrbit(this.MissionSeed, body, orbitType, 0.5, ContractDefs.Satellite.TrivialInclinationDifficulty);
                timeMod = DMContractDefs.DMRecon.significantTimeModifier * 6 * 3600;
                incMod  = 0;
                break;

            case ContractPrestige.Exceptional:
                if (!DMUtils.partAvailable(DMContractDefs.DMRecon.reconExceptionalParts))
                {
                    return(false);
                }

                parts.Add(0, DMContractDefs.DMRecon.reconExceptionalParts);

                if (!DMUtils.availableScience["All"].ContainsKey(DMContractDefs.DMRecon.exceptionalExperimentTitle))
                {
                    return(false);
                }

                container = DMUtils.availableScience["All"][DMContractDefs.DMRecon.exceptionalExperimentTitle];

                o = OrbitUtilities.GenerateOrbit(this.MissionSeed, body, orbitType, 0.15, ContractDefs.Satellite.TrivialInclinationDifficulty);

                double se = o.semiMajorAxis - o.referenceBody.Radius;

                double me = o.referenceBody.scienceValues.spaceAltitudeThreshold * 5 * .95;

                if (se > me)
                {
                    o.semiMajorAxis = (me * Math.Max(0.4, rand.NextDouble())) + o.referenceBody.Radius;
                }

                timeMod = DMContractDefs.DMRecon.exceptionalTimeModifier * 6 * 3600;
                break;
            }

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

            time           = timeMod * ((double)rand.Next(6, 17) / 10d);
            o.inclination += incMod;

            DMLongOrbitParameter     longOrbit   = new DMLongOrbitParameter(time);
            DMPartRequestParameter   partRequest = new DMPartRequestParameter(parts, DMContractDefs.DMRecon.useVesselWaypoints, body);
            DMSpecificOrbitParameter reconParam  = new DMSpecificOrbitParameter(orbitType, o.inclination, o.eccentricity, o.semiMajorAxis, o.LAN, o.argumentOfPeriapsis, o.meanAnomalyAtEpoch, o.epoch, body, ContractDefs.Satellite.SignificantDeviation, longOrbit);

            this.AddParameter(longOrbit);
            longOrbit.AddParameter(reconParam);
            longOrbit.AddParameter(partRequest);
            longOrbit.setPartRequest(partRequest);

            sciParams[0] = DMCollectContractGenerator.fetchScienceContract(body, ExperimentSituations.InSpaceLow, "SouthernHemisphere", container);
            sciParams[1] = DMCollectContractGenerator.fetchScienceContract(body, ExperimentSituations.InSpaceLow, "NorthernHemisphere", container);

            //Add the science collection parent parameter
            DMCompleteParameter DMcp = new DMCompleteParameter(1, 0);

            this.AddParameter(DMcp);

            foreach (DMCollectScience DMCS in sciParams)
            {
                if (DMCS == null)
                {
                    return(false);
                }
                else
                {
                    if (DMCS.Container == null)
                    {
                        continue;
                    }

                    float modifier = ((float)rand.Next(85, 116) / 100f);
                    DMcp.addToSubParams(DMCS);
                    DMCS.SetFunds(DMContractDefs.DMRecon.Funds.ParamReward * modifier, DMContractDefs.DMRecon.Funds.ParamFailure * modifier, body);
                    DMCS.SetScience(DMContractDefs.DMRecon.Science.ParamReward * DMUtils.fixSubjectVal(DMCS.Situation, 1f, body), null);
                    DMCS.SetReputation(DMContractDefs.DMRecon.Reputation.ParamReward * modifier, DMContractDefs.DMRecon.Reputation.ParamFailure * modifier, null);
                }
            }

            if (this.ParameterCount == 0)
            {
                return(false);
            }

            float primaryModifier = ((float)rand.Next(80, 121) / 100f);
            float diffModifier    = 1 + ((float)this.Prestige * 0.5f);

            float Mod = primaryModifier * diffModifier;

            int t = rand.Next(0, 4);

            if (t == 0)
            {
                this.agent = AgentList.Instance.GetAgent("DMagic");
            }
            else
            {
                this.agent = AgentList.Instance.GetAgentRandom();
            }

            if (this.agent == null)
            {
                this.agent = AgentList.Instance.GetAgentRandom();
            }

            base.SetExpiry(DMContractDefs.DMRecon.Expire.MinimumExpireDays, DMContractDefs.DMRecon.Expire.MaximumExpireDays);
            base.SetDeadlineDays((float)(time / 3600) * DMContractDefs.DMRecon.Expire.DeadlineModifier * (this.GetDestinationWeight(body) / 1.4f) * primaryModifier, null);
            base.SetReputation(DMContractDefs.DMRecon.Reputation.BaseReward * Mod, DMContractDefs.DMRecon.Reputation.BaseFailure * Mod, null);
            base.SetFunds(DMContractDefs.DMRecon.Funds.BaseAdvance * Mod, DMContractDefs.DMRecon.Funds.BaseReward * Mod, DMContractDefs.DMRecon.Funds.BaseFailure * Mod, body);
            base.SetScience(DMContractDefs.DMRecon.Science.BaseReward * Mod, body);
            return(true);
        }