/// <summary>
        /// Gets a fit planetary definition which should be smaller than maximum size, if all mandatory planets have been used.
        /// Mandatory planet will always fit. If no definition could be found after 10000 tries, it will disregard the restrictions
        /// </summary>
        /// <param name="maximumSize">Maximum size of the planet</param>
        /// <param name="ignoreMandatory">Whether to ignore mandatory planets</param>
        /// <returns>The MyPlanetGeneratorDefinition of the planet</returns>
        private MyPlanetGeneratorDefinition GetPlanetDefinition(float maximumSize, bool ignoreMandatory = false)
        {
            int   tries = 0;
            float size;
            MyPlanetGeneratorDefinition def;

            if (MandatoryPlanets.Count > 0 && !ignoreMandatory)
            {
                def = MandatoryPlanets[0];
                MandatoryPlanets.RemoveAt(0);
            }
            else
            {
                do
                {
                    def  = AvailablePlanets[MyRandom.Instance.Next(0, AvailablePlanets.Count)];
                    size = SizeByGravity(def.SurfaceGravity);
                    tries++;
                } while (size > maximumSize && tries < 10000);
            }


            if (SettingsSession.Static.Settings.GeneratorSettings.PlanetsOnlyOnce && !m_usedAllPlanets)
            {
                AvailablePlanets.Remove(def);
                if (AvailablePlanets.Count <= 0)
                {
                    AvailablePlanets = PlanetDefinitions;
                    m_usedAllPlanets = true;
                }
            }

            return(def);
        }
        /// <summary>
        /// Filters all planetary definitions based on settings set in the Plugin settings file and puts them in their respective lists.
        /// </summary>
        private void FilterDefinitions()
        {
            List <MyPlanetGeneratorDefinition> toRemovePlanets = new List <MyPlanetGeneratorDefinition>();

            foreach (var p in PlanetDefinitions)
            {
                if (p.Id.SubtypeId.String.Contains("Tutorial") || p.Id.SubtypeId.String.Contains("TestMap") || p.Id.SubtypeId.String.Contains("ModExample"))
                {
                    toRemovePlanets.Add(p);
                    continue;
                }
                if (!SettingsSession.Static.Settings.GeneratorSettings.UseVanillaPlanets && vanilla_planets.Contains(p.Id.SubtypeId.String))
                {
                    toRemovePlanets.Add(p);
                    continue;
                }
                if (SettingsSession.Static.Settings.GeneratorSettings.PlanetSettings.BlacklistedPlanets.Contains(p.Id.SubtypeId.String))
                {
                    toRemovePlanets.Add(p);
                }
                if (SettingsSession.Static.Settings.GeneratorSettings.PlanetSettings.Moons.Contains(p.Id.SubtypeId.String))
                {
                    toRemovePlanets.Add(p);
                    m_moonDefinitions.Add(p);
                    AvailableMoons.Add(p);
                }
                if (SettingsSession.Static.Settings.GeneratorSettings.PlanetSettings.MandatoryPlanets.Contains(p.Id.SubtypeId.String) || SettingsSession.Static.Settings.GeneratorSettings.SemiRandomizedGeneration)
                {
                    MandatoryPlanets.Add(p);
                }
                if (SettingsSession.Static.Settings.GeneratorSettings.PlanetSettings.GasGiants.Contains(p.Id.SubtypeId.String))
                {
                    GasGiants.Add(p);
                }
            }

            foreach (var r in toRemovePlanets)
            {
                PlanetDefinitions.Remove(r);
            }

            foreach (var p in PlanetDefinitions)
            {
                AvailablePlanets.Add(p);
            }

            ShuffleMandatoryPlanets();
        }