Example #1
0
        public static float GetScaleFactor(this OverallPopulation population)
        {
            switch (population)
            {
            case OverallPopulation.AlmostNone:
                return(0.1f);

            case OverallPopulation.Little:
                return(0.4f);

            case OverallPopulation.LittleBitLess:
                return(0.7f);

            case OverallPopulation.Normal:
                return(1f);

            case OverallPopulation.LittleBitMore:
                return(1.5f);

            case OverallPopulation.High:
                return(2f);

            case OverallPopulation.VeryHigh:
                return(2.75f);

            default:
                return(1f);
            }
        }
Example #2
0
 public void Reset()
 {
     seedString     = GenText.RandomSeedString();
     planetCoverage = ((!Prefs.DevMode || !UnityData.isEditor) ? 0.3f : 0.05f);
     rainfall       = OverallRainfall.Normal;
     temperature    = OverallTemperature.Normal;
     population     = OverallPopulation.Normal;
 }
 public void Reset()
 {
     _seedString     = GenText.RandomSeedString();
     _planetCoverage = Prefs.DevMode && UnityData.isEditor ? 0.05f : 0.3f;
     _intCoverage    = Prefs.DevMode && UnityData.isEditor ? 5 : 30;
     _rainfall       = OverallRainfall.Normal;
     _temperature    = OverallTemperature.Normal;
     _population     = OverallPopulation.Normal;
 }
 public WorldPreset(string name, WorldType worldType, AxialTilt axialTilt, RainfallModifier rainfallModifier, OverallTemperature temperature, OverallPopulation population)
 {
     Name             = name ?? throw new ArgumentNullException(nameof(name));
     WorldType        = worldType;
     AxialTilt        = axialTilt;
     RainfallModifier = rainfallModifier;
     Temperature      = temperature;
     Population       = population;
 }
 public PagePreciseWorldGeneration(float planetCoverage, string seedString, OverallRainfall rainFall, OverallTemperature temperature, OverallPopulation population, Dictionary <FactionDef, int> factionCounts)
 {
     _planetCoverage = planetCoverage;
     _seedString     = seedString;
     _rainfall       = rainFall;
     _temperature    = temperature;
     _population     = population;
     _factionCounts  = factionCounts;
 }
 public void Reset()
 {
     this.seedString                 = GenText.RandomSeedString();
     this.planetCoverage             = 0.3f;
     this.CurrentWorldPreset         = "Planets.Vanilla";
     Planets_GameComponent.axialTilt = AxialTilt.Normal;
     Planets_GameComponent.worldType = WorldType.Vanilla;
     Planets_GameComponent.subcount  = 10;
     this.rainfallMod                = RainfallModifier.Normal;
     this.temperature                = OverallTemperature.Normal;
     this.population                 = OverallPopulation.Normal;
 }
        private void DoPopulationSlider(float single)
        {
            Widgets.Label(new Rect(0f, single, 200f, 30f), "PlanetPopulation".Translate());
            Rect rect            = new Rect(200f, single, 200f, 30f);
            var  populationCheck = this.population;

            this.population = (OverallPopulation)Mathf.RoundToInt(Widgets.HorizontalSlider(rect, (float)this.population, 0f, (float)(OverallPopulationUtility.EnumValuesCount - 1), true, "PlanetPopulation_Normal".Translate(), "PlanetPopulation_Low".Translate(), "PlanetPopulation_High".Translate(), 1f));
            if (this.population != populationCheck)
            {
                this.CurrentWorldPreset = "Planets.Custom";
            }
        }
        private void ApplyWorldPreset(WorldPreset worldPreset)
        {
            this.CurrentWorldPreset = worldPreset.Name;

            if (this.CurrentWorldPreset != "Planets.Custom")
            {
                Planets_GameComponent.worldType = worldPreset.WorldType;
                Planets_GameComponent.axialTilt = worldPreset.AxialTilt;
                this.rainfallMod = worldPreset.RainfallModifier;
                this.temperature = worldPreset.Temperature;
                this.population  = worldPreset.Population;
            }
        }
 public static float GetScaleFactor(this OverallPopulation population)
 {
     return(population switch
     {
         OverallPopulation.AlmostNone => 0.1f,
         OverallPopulation.Little => 0.4f,
         OverallPopulation.LittleBitLess => 0.7f,
         OverallPopulation.Normal => 1f,
         OverallPopulation.LittleBitMore => 1.5f,
         OverallPopulation.High => 2f,
         OverallPopulation.VeryHigh => 2.75f,
         _ => 1f,
     });
        public void Randomize()
        {
            this.seedString = GenText.RandomSeedString();

            Planets_GameComponent.axialTilt = Planets_Random.GetRandomAxialTilt();
            Planets_GameComponent.worldType = Planets_Random.GetRandomWorldType();
            this.rainfallMod        = Planets_Random.GetRandomRainfallModifier();
            this.temperature        = Planets_Random.GetRandomTemperature();
            this.population         = Planets_Random.GetRandomPopulation();
            this.CurrentWorldPreset = "Planets.Custom";

            Controller.Settings.randomPlanet = true;

            if (this.CanDoNext())
            {
                this.DoNext();
            }
        }
Example #11
0
        public static World GenerateWorld(float planetCoverage, string seedString, OverallRainfall overallRainfall, OverallTemperature overallTemperature, OverallPopulation population)
        {
            DeepProfiler.Start("GenerateWorld");
            Rand.PushState();
            int seed = (Rand.Seed = GetSeedFromSeedString(seedString));

            try
            {
                Current.CreatingWorld = new World();
                Current.CreatingWorld.info.seedString         = seedString;
                Current.CreatingWorld.info.planetCoverage     = planetCoverage;
                Current.CreatingWorld.info.overallRainfall    = overallRainfall;
                Current.CreatingWorld.info.overallTemperature = overallTemperature;
                Current.CreatingWorld.info.overallPopulation  = population;
                Current.CreatingWorld.info.name = NameGenerator.GenerateName(RulePackDefOf.NamerWorld);
                tmpGenSteps.Clear();
                tmpGenSteps.AddRange(GenStepsInOrder);
                for (int i = 0; i < tmpGenSteps.Count; i++)
                {
                    DeepProfiler.Start("WorldGenStep - " + tmpGenSteps[i]);
                    try
                    {
                        Rand.Seed = Gen.HashCombineInt(seed, GetSeedPart(tmpGenSteps, i));
                        tmpGenSteps[i].worldGenStep.GenerateFresh(seedString);
                    }
                    catch (Exception arg)
                    {
                        Log.Error("Error in WorldGenStep: " + arg);
                    }
                    finally
                    {
                        DeepProfiler.End();
                    }
                }
                Rand.Seed = seed;
                Current.CreatingWorld.grid.StandardizeTileData();
                Current.CreatingWorld.FinalizeInit();
                Find.Scenario.PostWorldGenerate();
                return(Current.CreatingWorld);
            }
            finally
            {
                Rand.PopState();
                DeepProfiler.End();
                Current.CreatingWorld = null;
            }
        }
 public WorldPresetBuilder Population(OverallPopulation value)
 {
     this.population = value;
     return(this);
 }
        public override void DoWindowContents(Rect rect)
        {
            DrawPageTitle(rect);
            GUI.BeginGroup(GetMainRect(rect));
            Text.Font = GameFont.Small;
            var num = 0f;

            Widgets.Label(new Rect(0f, num, 200f, 30f), "WorldSeed".Translate());
            var rect2 = new Rect(200f, num, 200f, 30f);

            _seedString = Widgets.TextField(rect2, _seedString);
            num        += 40f;
            var rect3 = new Rect(200f, num, 200f, 30f);

            if (Widgets.ButtonText(rect3, "RandomizeSeed".Translate()))
            {
                SoundDefOf.Tick_Tiny.PlayOneShotOnCamera();
                _seedString = GenText.RandomSeedString();
            }

            num += 40f;

            /*
             * Our own planet coverage
             */

            Text.Font = GameFont.Tiny;
            var textAnchorBackup = Text.Anchor;

            Text.Anchor = TextAnchor.MiddleCenter;
            Widgets.Label(new Rect(0, num, rect3.xMax, 20f), "[Prepare Landing] Precise World Generation %");
            Text.Font   = GameFont.Small;
            Text.Anchor = textAnchorBackup;

            num += 20f;
            Widgets.Label(new Rect(0f, num, 200f, 30f), $"{"PlanetCoverage".Translate()} [1,100]%");
            var rect4 = new Rect(200f, num, 200f, 30f);

            TextFieldNumericCoverage(rect4.LeftHalf());
            ButtonCoverage(rect4.RightHalf());

            // end of specific private code

            TooltipHandler.TipRegion(new Rect(0f, num, rect4.xMax, rect4.height), "PlanetCoverageTip".Translate());

            num += 40f;
            Widgets.Label(new Rect(0f, num, 200f, 30f), "PlanetRainfall".Translate());
            var rect5 = new Rect(200f, num, 200f, 30f);

            _rainfall = (OverallRainfall)Mathf.RoundToInt(Widgets.HorizontalSlider(rect5, (float)_rainfall, 0f,
                                                                                   OverallRainfallUtility.EnumValuesCount - 1, true, "PlanetRainfall_Normal".Translate(),
                                                                                   "PlanetRainfall_Low".Translate(), "PlanetRainfall_High".Translate(), 1f));

            num += 40f;
            Widgets.Label(new Rect(0f, num, 200f, 30f), "PlanetTemperature".Translate());
            var rect6 = new Rect(200f, num, 200f, 30f);

            _temperature = (OverallTemperature)Mathf.RoundToInt(Widgets.HorizontalSlider(rect6, (float)_temperature,
                                                                                         0f, OverallTemperatureUtility.EnumValuesCount - 1, true, "PlanetTemperature_Normal".Translate(),
                                                                                         "PlanetTemperature_Low".Translate(), "PlanetTemperature_High".Translate(), 1f));

            num += 40f;
            Widgets.Label(new Rect(0f, num, 200f, 30f), "PlanetPopulation".Translate());
            var rect7 = new Rect(200f, num, 200f, 30f);

            _population = (OverallPopulation)Mathf.RoundToInt(Widgets.HorizontalSlider(rect7, (float)_population, 0f,
                                                                                       (float)(OverallPopulationUtility.EnumValuesCount - 1), true, "PlanetPopulation_Normal".Translate(),
                                                                                       "PlanetPopulation_Low".Translate(), "PlanetPopulation_High".Translate(), 1f));

            GUI.EndGroup();
            DoBottomButtons(rect, "WorldGenerate".Translate(), "Reset".Translate(), Reset);
        }
Example #14
0
        public override void DoWindowContents(Rect rect)
        {
            DrawPageTitle(rect);
            GUI.BeginGroup(GetMainRect(rect));
            Text.Font = GameFont.Small;
            float num = 0f;

            Widgets.Label(new Rect(0f, num, 200f, 30f), "WorldSeed".Translate());
            Rect rect2 = new Rect(200f, num, 200f, 30f);

            seedString = Widgets.TextField(rect2, seedString);
            num       += 40f;
            if (Widgets.ButtonText(new Rect(200f, num, 200f, 30f), "RandomizeSeed".Translate()))
            {
                SoundDefOf.Tick_Tiny.PlayOneShotOnCamera();
                seedString = GenText.RandomSeedString();
            }
            num += 40f;
            Widgets.Label(new Rect(0f, num, 200f, 30f), "PlanetCoverage".Translate());
            Rect rect3 = new Rect(200f, num, 200f, 30f);

            if (Widgets.ButtonText(rect3, planetCoverage.ToStringPercent()))
            {
                List <FloatMenuOption> list = new List <FloatMenuOption>();
                float[] array = Prefs.DevMode ? PlanetCoveragesDev : PlanetCoverages;
                foreach (float coverage in array)
                {
                    string text = coverage.ToStringPercent();
                    if (coverage <= 0.1f)
                    {
                        text += " (dev)";
                    }
                    FloatMenuOption item = new FloatMenuOption(text, delegate
                    {
                        if (planetCoverage != coverage)
                        {
                            planetCoverage = coverage;
                            if (planetCoverage == 1f)
                            {
                                Messages.Message("MessageMaxPlanetCoveragePerformanceWarning".Translate(), MessageTypeDefOf.CautionInput, historical: false);
                            }
                        }
                    });
                    list.Add(item);
                }
                Find.WindowStack.Add(new FloatMenu(list));
            }
            TooltipHandler.TipRegionByKey(new Rect(0f, num, rect3.xMax, rect3.height), "PlanetCoverageTip");
            num += 40f;
            Widgets.Label(new Rect(0f, num, 200f, 30f), "PlanetRainfall".Translate());
            Rect rect4 = new Rect(200f, num, 200f, 30f);

            rainfall = (OverallRainfall)Mathf.RoundToInt(Widgets.HorizontalSlider(rect4, (float)rainfall, 0f, OverallRainfallUtility.EnumValuesCount - 1, middleAlignment: true, "PlanetRainfall_Normal".Translate(), "PlanetRainfall_Low".Translate(), "PlanetRainfall_High".Translate(), 1f));
            num     += 40f;
            Widgets.Label(new Rect(0f, num, 200f, 30f), "PlanetTemperature".Translate());
            Rect rect5 = new Rect(200f, num, 200f, 30f);

            temperature = (OverallTemperature)Mathf.RoundToInt(Widgets.HorizontalSlider(rect5, (float)temperature, 0f, OverallTemperatureUtility.EnumValuesCount - 1, middleAlignment: true, "PlanetTemperature_Normal".Translate(), "PlanetTemperature_Low".Translate(), "PlanetTemperature_High".Translate(), 1f));
            num        += 40f;
            Widgets.Label(new Rect(0f, num, 200f, 30f), "PlanetPopulation".Translate());
            Rect rect6 = new Rect(200f, num, 200f, 30f);

            population = (OverallPopulation)Mathf.RoundToInt(Widgets.HorizontalSlider(rect6, (float)population, 0f, OverallPopulationUtility.EnumValuesCount - 1, middleAlignment: true, "PlanetPopulation_Normal".Translate(), "PlanetPopulation_Low".Translate(), "PlanetPopulation_High".Translate(), 1f));
            num       += 40f;
            Widgets.Label(new Rect(0f, num, 200f, 30f), "AAAA".Translate());
            Rect rect7 = new Rect(200f, num, 200f, 30f);

            GUI.EndGroup();
            DoBottomButtons(rect, "WorldGenerate".Translate(), "Reset".Translate(), Reset);
        }
        public override void DoWindowContents(Rect rect)
        {
            base.DrawPageTitle(rect);
            GUI.BeginGroup(base.GetMainRect(rect, 0f, false));
            Text.Font = GameFont.Small;
            //
            // PLANET SEED
            //
            float single = 0f;

            Widgets.Label(new Rect(0f, single, 200f, 30f), "WorldSeed".Translate());
            Rect rect1 = new Rect(200f, single, 200f, 30f);

            this.seedString = Widgets.TextField(rect1, this.seedString);
            single         += 40f;
            Rect rect2 = new Rect(200f, single, 200f, 30f);

            if (Widgets.ButtonText(rect2, "RandomizeSeed".Translate(), true, false, true))
            {
                SoundDefOf.Tick_Tiny.PlayOneShotOnCamera(null);
                this.seedString = GenText.RandomSeedString();
            }
            //
            // PLANET SIZE (IF "MY LITTLE PLANET" IS IN USE)
            //
            if (ModsConfig.ActiveModsInLoadOrder.Any(mod => mod.Name.Contains("My Little Planet")))
            {
                single += 80f;
                Widgets.Label(new Rect(0f, single, 200f, 30f), "MLPWorldPlanetSize".Translate());
                Rect rect7 = new Rect(200f, single, 200f, 30f);
                Planets_GameComponent.subcount = Mathf.RoundToInt(Widgets.HorizontalSlider(rect7, Planets_GameComponent.subcount, 6f, 10f, true, null, "MLPWorldTiny".Translate(), "MLPWorldDefault".Translate(), 1f));
            }
            //
            // PLANET COVERAGE
            //
            single += 80f;
            Widgets.Label(new Rect(0f, single, 200f, 30f), "PlanetCoverage".Translate());
            Rect rect3 = new Rect(200f, single, 200f, 30f);

            if (Widgets.ButtonText(rect3, this.planetCoverage.ToStringPercent(), true, false, true))
            {
                List <FloatMenuOption> floatMenuOptions = new List <FloatMenuOption>();
                float[] singleArray = Planets_CreateWorldParams.PlanetCoverages;
                for (int i = 0; i < (int)singleArray.Length; i++)
                {
                    float           single1         = singleArray[i];
                    string          stringPercent   = single1.ToStringPercent();
                    FloatMenuOption floatMenuOption = new FloatMenuOption(stringPercent, () => {
                        if (this.planetCoverage != single1)
                        {
                            this.planetCoverage = single1;
                            if (this.planetCoverage < 0.15f)
                            {
                                Messages.Message("Planets.MessageLowPlanetCoverageWarning".Translate(), MessageTypeDefOf.CautionInput, false);
                            }
                            if (this.planetCoverage > 0.7f)
                            {
                                Messages.Message("MessageMaxPlanetCoveragePerformanceWarning".Translate(), MessageTypeDefOf.CautionInput, false);
                            }
                        }
                    }, MenuOptionPriority.Default, null, null, 0f, null, null);
                    floatMenuOptions.Add(floatMenuOption);
                }
                Find.WindowStack.Add(new FloatMenu(floatMenuOptions));
            }
            TooltipHandler.TipRegion(new Rect(0f, single, rect3.xMax, rect3.height), "PlanetCoverageTip".Translate());
            //
            // WORLD TYPE PRESETS
            //
            single += 80f;
            Widgets.Label(new Rect(0f, single, 200f, 30f), "Planets.WorldPresets".Translate());
            Rect rect8 = new Rect(200f, single, 200f, 30f);

            if (Widgets.ButtonText(rect8, this.WorldPreset.Translate(), true, false, true))
            {
                List <FloatMenuOption> floatMenuOptions = new List <FloatMenuOption>();
                string[] singleArray = Planets_CreateWorldParams.WorldPresets;
                for (int i = 0; i < (int)singleArray.Length; i++)
                {
                    string          single1           = singleArray[i];
                    string          single1Translated = single1.Translate();
                    FloatMenuOption floatMenuOption   = new FloatMenuOption(single1Translated, () => {
                        if (this.WorldPreset != single1)
                        {
                            this.WorldPreset = single1;
                            #region Presets
                            if (this.WorldPreset == "Planets.Vanilla")
                            {
                                Planets_GameComponent.worldType = WorldType.Vanilla;
                                Planets_GameComponent.axialTilt = AxialTilt.Normal;
                                this.rainfallMod = RainfallModifier.Normal;
                                this.temperature = OverallTemperature.Normal;
                                this.population  = OverallPopulation.Normal;
                            }
                            else if (this.WorldPreset == "Planets.Desert")
                            {
                                Planets_GameComponent.worldType = WorldType.Dry;
                                Planets_GameComponent.axialTilt = AxialTilt.Normal;
                                this.rainfallMod = RainfallModifier.LittleBitLess;
                                this.temperature = OverallTemperature.LittleBitWarmer;
                                this.population  = OverallPopulation.LittleBitLess;
                            }
                            else if (this.WorldPreset == "Planets.Frozen")
                            {
                                Planets_GameComponent.worldType = WorldType.VeryDry;
                                Planets_GameComponent.axialTilt = AxialTilt.Normal;
                                this.rainfallMod = RainfallModifier.LittleBitLess;
                                this.temperature = OverallTemperature.Cold;
                                this.population  = OverallPopulation.LittleBitLess;
                            }
                            else if (this.WorldPreset == "Planets.Earthlike")
                            {
                                Planets_GameComponent.worldType = WorldType.Earthlike;
                                Planets_GameComponent.axialTilt = AxialTilt.Normal;
                                this.rainfallMod = RainfallModifier.Normal;
                                this.temperature = OverallTemperature.Normal;
                                this.population  = OverallPopulation.Normal;
                            }
                            else if (this.WorldPreset == "Planets.Forest")
                            {
                                Planets_GameComponent.worldType = WorldType.Vanilla;
                                Planets_GameComponent.axialTilt = AxialTilt.Normal;
                                this.rainfallMod = RainfallModifier.LittleBitMore;
                                this.temperature = OverallTemperature.LittleBitColder;
                                this.population  = OverallPopulation.LittleBitMore;
                            }
                            else if (this.WorldPreset == "Planets.Iceball")
                            {
                                Planets_GameComponent.worldType = WorldType.Vanilla;
                                Planets_GameComponent.axialTilt = AxialTilt.Normal;
                                this.rainfallMod = RainfallModifier.Normal;
                                this.temperature = OverallTemperature.VeryCold;
                                this.population  = OverallPopulation.Little;
                            }
                            else if (this.WorldPreset == "Planets.Jungle")
                            {
                                Planets_GameComponent.worldType = WorldType.Earthlike;
                                Planets_GameComponent.axialTilt = AxialTilt.Normal;
                                this.rainfallMod = RainfallModifier.LittleBitMore;
                                this.temperature = OverallTemperature.LittleBitWarmer;
                                this.population  = OverallPopulation.High;
                            }
                            else if (this.WorldPreset == "Planets.Ocean")
                            {
                                Planets_GameComponent.worldType = WorldType.Waterworld;
                                Planets_GameComponent.axialTilt = AxialTilt.Normal;
                                this.rainfallMod = RainfallModifier.Normal;
                                this.temperature = OverallTemperature.Normal;
                                this.population  = OverallPopulation.AlmostNone;
                            }
                            else
                            {
                            }
                            #endregion
                        }
                    }, MenuOptionPriority.Default, null, null, 0f, null, null);
                    floatMenuOptions.Add(floatMenuOption);
                }
                Find.WindowStack.Add(new FloatMenu(floatMenuOptions));
            }
            TooltipHandler.TipRegion(new Rect(0f, single, rect8.xMax, rect8.height), "Planets.WorldPresetsTip".Translate());

            {
                single += 80f;
                DoSeaLevelSlider(single);

                single += 40f;
                DoRainfallSlider(single);

                single += 40f;
                DoTemperatureSlider(single);

                single += 40f;
                DoAxialTiltSlider(single);

                // Faction Control will override population, so disable this slider if Faction Control is enabled
                if (Controller.FactionControlSettingsMI == null)
                {
                    single += 40f;
                    DoPopulationSlider(single);
                }
            }
            GUI.EndGroup();

            //
            // BOTTOM BUTTONS
            //
            if (Controller.FactionControlSettingsMI != null)
            {
                Text.Font = GameFont.Small;
                if (Widgets.ButtonText(new Rect(0, rect.yMax - 78f, 150, 32), "RFC.FactionControlName".Translate()))
                {
                    Controller.FactionControlSettingsMI.Invoke(null, null);
                }
            }
            base.DoBottomButtons(rect, "WorldGenerate".Translate(), "Planets.Random".Translate(), new Action(this.Randomize), true, true);
        }