Beispiel #1
0
        private void FillPageMain(Listing_Standard listing)
        {
            if (listing.DoTextButton("PSI.Settings.IconSet".Translate() + PSI.Settings.iconSet))
            {
                var options = PSI.IconSets.Select(setname => new FloatMenuOption(setname, () =>
                {
                    PSI.Settings.iconSet = setname;
                    PSI.Materials        = new Materials(setname);
                    PSI.Materials.ReloadTextures(true);
                })).ToList();
                Find.WindowStack.Add(new FloatMenu(options));
            }

            if (listing.DoTextButton("PSI.Settings.LoadPresetButton".Translate()))
            {
                var strArray = new string[0];
                var path     = _modPath + "/Presets/Complete/";
                if (Directory.Exists(path))
                {
                    strArray = Directory.GetFiles(path, "*.cfg");
                }
                var options = strArray.Select(setname => new FloatMenuOption(Path.GetFileNameWithoutExtension(setname), () =>
                {
                    try
                    {
                        PSI.Settings = XmlLoader.ItemFromXmlFile <ModSettings>(setname);
                        PSI.SaveSettings();
                        PSI.Reinit();
                    }
                    catch (IOException)
                    {
                        Log.Error("PSI.Settings.LoadPreset.UnableToLoad".Translate() + setname);
                    }
                })).ToList();
                Find.WindowStack.Add(new FloatMenu(options));
            }

            listing.DoGap();

            DoHeading(listing, "PSI.Settings.Advanced");

            if (listing.DoTextButton("PSI.Settings.VisibilityButton".Translate()))
            {
                Page = "showhide";
            }

            if (listing.DoTextButton("PSI.Settings.ArrangementButton".Translate()))
            {
                Page = "arrange";
            }

            if (!listing.DoTextButton("PSI.Settings.SensitivityButton".Translate()))
            {
                return;
            }

            Page = "limits";
        }
    protected void fillPageMain(Listing_Standard listing)
    {        
        //listing.DoHeading("General settings");

        if (listing.DoTextButton( Translator.Translate("PSI.Settings.IconSet") + PSI.settings.iconSet))
        {
            List<FloatMenuOption> options = new List<FloatMenuOption>();
            foreach (string setname in PSI.iconSets)
            {
                options.Add(new FloatMenuOption(setname, () =>
                {
                    PSI.settings.iconSet = setname;                    
                    PSI.materials = new Materials(setname);
                    PSI.materials.reloadTextures(true);
                }));
            }
            Find.LayerStack.Add((Layer)new Layer_FloatMenu(options, false));
        }

        if (listing.DoTextButton(Translator.Translate("PSI.Settings.LoadPresetButton")))
        {
            string[] presetList = {};            
            String path2 = GenFilePaths.CoreModsFolderPath + "/Pawn State Icons/Presets/Complete/";
            if (Directory.Exists(path2)) presetList = Directory.GetFiles(path2, "*.cfg");            

            List<FloatMenuOption> options = new List<FloatMenuOption>();
            foreach (string setname in presetList)
            {
                options.Add(new FloatMenuOption(Path.GetFileNameWithoutExtension(setname), () =>
                {
                    try
                    {
                        PSI.settings = XmlLoader.ItemFromXmlFile<ModSettings>(setname, true);
                        PSI.saveSettings();
                        PSI.reinit();
                    }
                    catch (IOException) { Log.Error(Translator.Translate("PSI.Settings.LoadPreset.UnableToLoad") + setname); }
                }));
            }
            Find.LayerStack.Add((Layer)new Layer_FloatMenu(options, false));
        }

        listing.DoGap();        
        DoHeading(listing,"PSI.Settings.Advanced");

        if (listing.DoTextButton(Translator.Translate("PSI.Settings.VisibilityButton"))) page = "showhide";
        if (listing.DoTextButton(Translator.Translate("PSI.Settings.ArrangementButton"))) page = "arrange";
        if (listing.DoTextButton(Translator.Translate("PSI.Settings.SensitivityButton"))) page = "limits";
        
    }
Beispiel #3
0
        private void FillPageShowHide(Listing_Standard listing)
        {
            listing.OverrideColumnWidth = 230f;
            DoHeading(listing, "PSI.Settings.Visibility.Header");
            listing.OverrideColumnWidth = 125f;
            listing.DoLabelCheckbox("PSI.Settings.Visibility.TargetPoint".Translate(), ref PSI.Settings.show_TargetPoint);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Aggressive".Translate(), ref PSI.Settings.show_Aggressive);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Dazed".Translate(), ref PSI.Settings.show_Dazed);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Leave".Translate(), ref PSI.Settings.show_Leave);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Draft".Translate(), ref PSI.Settings.show_Draft);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Idle".Translate(), ref PSI.Settings.show_Idle);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Unarmed".Translate(), ref PSI.Settings.show_Unarmed);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Hungry".Translate(), ref PSI.Settings.show_Hungry);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Sad".Translate(), ref PSI.Settings.show_Sad);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Tired".Translate(), ref PSI.Settings.show_Tired);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Disease".Translate(), ref PSI.Settings.show_Disease);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.NightOwl".Translate(), ref PSI.Settings.show_NightOwl);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Greedy".Translate(), ref PSI.Settings.show_Greedy);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.DeadColonists".Translate(), ref PSI.Settings.show_DeadColonists);

            listing.OverrideColumnWidth = 230f;
            if (listing.DoTextButton("PSI.Settings.ReturnButton".Translate()))
            {
                Page = "main";
            }
            listing.OverrideColumnWidth = 125f;
            listing.NewColumn();
            DoHeading(listing, " ", false);
            DoHeading(listing, " ", false);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Injury".Translate(), ref PSI.Settings.show_Effectiveness);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Bloodloss".Translate(), ref PSI.Settings.show_Bloodloss);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Hot".Translate(), ref PSI.Settings.show_Hot);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Cold".Translate(), ref PSI.Settings.show_Cold);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Naked".Translate(), ref PSI.Settings.show_Naked);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Drunk".Translate(), ref PSI.Settings.show_Drunk);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.ApparelHealth".Translate(), ref PSI.Settings.show_ApparelHealth);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Pacific".Translate(), ref PSI.Settings.show_Pacific);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Jealous".Translate(), ref PSI.Settings.show_Jealous);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Lovers".Translate(), ref PSI.Settings.show_Lovers);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Prosthophile".Translate(), ref PSI.Settings.show_Prosthophile);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.Prosthophobe".Translate(), ref PSI.Settings.show_Prosthophobe);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.RoomStatus".Translate(), ref PSI.Settings.show_RoomStatus);
            listing.DoLabelCheckbox("PSI.Settings.Visibility.LeftUnburied".Translate(), ref PSI.Settings.show_LeftUnburied);
        }
Beispiel #4
0
        protected void fillPageShowHide(Listing_Standard listing)
        {
            listing.OverrideColumnWidth = 230;
            DoHeading(listing, "PSI.Settings.Visibility.Header");
            listing.OverrideColumnWidth = 95;

            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.TargetPoint"), ref PSI.settings.showTargetPoint);
            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Aggressive"), ref PSI.settings.showAggressive);
            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Dazed"), ref PSI.settings.showDazed);
            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Leave"), ref PSI.settings.showLeave);
            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Draft"), ref PSI.settings.showDraft);
            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Idle"), ref PSI.settings.showIdle);
            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Unarmed"), ref PSI.settings.showUnarmed);
            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Hungry"), ref PSI.settings.showHungry);
            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Sad"), ref PSI.settings.showSad);
            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Tired"), ref PSI.settings.showTired);
            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Disease"), ref PSI.settings.showDisease);

            listing.OverrideColumnWidth = 230;

            if (listing.DoTextButton(Translator.Translate("PSI.Settings.ReturnButton")))
            {
                page = "main";
            }
            listing.OverrideColumnWidth = 95;
            listing.NewColumn();

            DoHeading(listing, " ", false);
            DoHeading(listing, " ", false);

            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Injury"), ref PSI.settings.showEffectiveness);
            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Bloodloss"), ref PSI.settings.showBloodloss);
            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Hot"), ref PSI.settings.showHot);
            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Cold"), ref PSI.settings.showCold);
            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Naked"), ref PSI.settings.showNaked);

            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Drunk"), ref PSI.settings.showDrunk);
            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.ApparelHealth"), ref PSI.settings.showApparelHealth);
            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Pacific"), ref PSI.settings.showPacific);
        }
Beispiel #5
0
        protected void fillPageLimits(Listing_Standard listing)
        {
            DoHeading(listing, "PSI.Settings.Sensitivity.Header");

            if (listing.DoTextButton(Translator.Translate("PSI.Settings.LoadPresetButton")))
            {
                string[] presetList = { };
                String   path2      = GenFilePaths.CoreModsFolderPath + "/Pawn State Icons/Presets/Sensitivity/";
                if (Directory.Exists(path2))
                {
                    presetList = Directory.GetFiles(path2, "*.cfg");
                }

                List <FloatMenuOption> options = new List <FloatMenuOption>();
                foreach (string setname in presetList)
                {
                    options.Add(new FloatMenuOption(Path.GetFileNameWithoutExtension(setname), () =>
                    {
                        try
                        {
                            ModSettings settings                 = XmlLoader.ItemFromXmlFile <ModSettings>(setname, true);
                            PSI.settings.limit_bleedMult         = settings.limit_bleedMult;
                            PSI.settings.limit_diseaseLess       = settings.limit_diseaseLess;
                            PSI.settings.limit_EfficiencyLess    = settings.limit_EfficiencyLess;
                            PSI.settings.limit_FoodLess          = settings.limit_FoodLess;
                            PSI.settings.limit_MoodLess          = settings.limit_MoodLess;
                            PSI.settings.limit_RestLess          = settings.limit_RestLess;
                            PSI.settings.limit_apparelHealthLess = settings.limit_apparelHealthLess;
                            PSI.settings.limit_tempComfortOffset = settings.limit_tempComfortOffset;
                        }
                        catch (IOException) { Log.Error(Translator.Translate("PSI.Settings.LoadPreset.UnableToLoad") + setname); }
                    }));
                }
                Find.LayerStack.Add((Layer) new Layer_FloatMenu(options, false));
            }

            listing.DoGap();

            listing.DoLabel(Translator.Translate("PSI.Settings.Sensitivity.Bleeding") + Translator.Translate("PSI.Settings.Sensitivity.Bleeding." + Math.Round(PSI.settings.limit_bleedMult - 0.25)));
            PSI.settings.limit_bleedMult = listing.DoSlider(PSI.settings.limit_bleedMult, 0.5f, 5.0f);

            listing.DoLabel(Translator.Translate("PSI.Settings.Sensitivity.Injured") + ((int)(PSI.settings.limit_EfficiencyLess * 100)) + "%");
            PSI.settings.limit_EfficiencyLess = listing.DoSlider(PSI.settings.limit_EfficiencyLess, 0.01f, 0.99f);

            listing.DoLabel(Translator.Translate("PSI.Settings.Sensitivity.Food") + ((int)(PSI.settings.limit_FoodLess * 100)) + "%");
            PSI.settings.limit_FoodLess = listing.DoSlider(PSI.settings.limit_FoodLess, 0.01f, 0.99f);

            listing.DoLabel(Translator.Translate("PSI.Settings.Sensitivity.Mood") + ((int)(PSI.settings.limit_MoodLess * 100)) + "%");
            PSI.settings.limit_MoodLess = listing.DoSlider(PSI.settings.limit_MoodLess, 0.01f, 0.99f);

            listing.DoLabel(Translator.Translate("PSI.Settings.Sensitivity.Rest") + ((int)(PSI.settings.limit_RestLess * 100)) + "%");
            PSI.settings.limit_RestLess = listing.DoSlider(PSI.settings.limit_RestLess, 0.01f, 0.99f);

            listing.DoLabel(Translator.Translate("PSI.Settings.Sensitivity.ApparelHealth") + ((int)(PSI.settings.limit_apparelHealthLess * 100)) + "%");
            PSI.settings.limit_apparelHealthLess = listing.DoSlider(PSI.settings.limit_apparelHealthLess, 0.01f, 0.99f);

            listing.DoLabel(Translator.Translate("PSI.Settings.Sensitivity.Temperature") + ((int)(PSI.settings.limit_tempComfortOffset)) + "C");
            PSI.settings.limit_tempComfortOffset = listing.DoSlider(PSI.settings.limit_tempComfortOffset, -10f, 10f);

            if (listing.DoTextButton(Translator.Translate("PSI.Settings.ReturnButton")))
            {
                page = "main";
            }
        }
Beispiel #6
0
        protected void fillPageMain(Listing_Standard listing)
        {
            //listing.DoHeading("General settings");

            if (listing.DoTextButton(Translator.Translate("PSI.Settings.IconSet") + PSI.settings.iconSet))
            {
                List <FloatMenuOption> options = new List <FloatMenuOption>();
                foreach (string setname in PSI.iconSets)
                {
                    options.Add(new FloatMenuOption(setname, () =>
                    {
                        PSI.settings.iconSet = setname;
                        PSI.materials        = new Materials(setname);
                        PSI.materials.reloadTextures(true);
                    }));
                }
                Find.LayerStack.Add((Layer) new Layer_FloatMenu(options, false));
            }

            if (listing.DoTextButton(Translator.Translate("PSI.Settings.LoadPresetButton")))
            {
                string[] presetList = {};
                String   path2      = GenFilePaths.CoreModsFolderPath + "/Pawn State Icons/Presets/Complete/";
                if (Directory.Exists(path2))
                {
                    presetList = Directory.GetFiles(path2, "*.cfg");
                }

                List <FloatMenuOption> options = new List <FloatMenuOption>();
                foreach (string setname in presetList)
                {
                    options.Add(new FloatMenuOption(Path.GetFileNameWithoutExtension(setname), () =>
                    {
                        try
                        {
                            PSI.settings = XmlLoader.ItemFromXmlFile <ModSettings>(setname, true);
                            PSI.saveSettings();
                            PSI.reinit();
                        }
                        catch (IOException) { Log.Error(Translator.Translate("PSI.Settings.LoadPreset.UnableToLoad") + setname); }
                    }));
                }
                Find.LayerStack.Add((Layer) new Layer_FloatMenu(options, false));
            }

            listing.DoGap();
            DoHeading(listing, "PSI.Settings.Advanced");

            if (listing.DoTextButton(Translator.Translate("PSI.Settings.VisibilityButton")))
            {
                page = "showhide";
            }
            if (listing.DoTextButton(Translator.Translate("PSI.Settings.ArrangementButton")))
            {
                page = "arrange";
            }
            if (listing.DoTextButton(Translator.Translate("PSI.Settings.SensitivityButton")))
            {
                page = "limits";
            }
        }
Beispiel #7
0
        protected void fillPageArrangement(Listing_Standard listing)
        {
            DoHeading(listing, "PSI.Settings.Arrangement.Header");

            if (listing.DoTextButton(Translator.Translate("PSI.Settings.LoadPresetButton")))
            {
                string[] presetList = { };
                String   path2      = GenFilePaths.CoreModsFolderPath + "/Pawn State Icons/Presets/Position/";
                if (Directory.Exists(path2))
                {
                    presetList = Directory.GetFiles(path2, "*.cfg");
                }

                List <FloatMenuOption> options = new List <FloatMenuOption>();
                foreach (string setname in presetList)
                {
                    options.Add(new FloatMenuOption(Path.GetFileNameWithoutExtension(setname), () =>
                    {
                        try
                        {
                            ModSettings settings          = XmlLoader.ItemFromXmlFile <ModSettings>(setname, true);
                            PSI.settings.iconDistanceX    = settings.iconDistanceX;
                            PSI.settings.iconDistanceY    = settings.iconDistanceY;
                            PSI.settings.iconOffsetX      = settings.iconOffsetX;
                            PSI.settings.iconOffsetY      = settings.iconOffsetY;
                            PSI.settings.iconsHorizontal  = settings.iconsHorizontal;
                            PSI.settings.iconsScreenScale = settings.iconsScreenScale;
                            PSI.settings.iconsInColumn    = settings.iconsInColumn;
                            PSI.settings.iconSize         = settings.iconSize;
                        }
                        catch (IOException) { Log.Error(Translator.Translate("PSI.Settings.LoadPreset.UnableToLoad") + setname); }
                    }));
                }
                Find.LayerStack.Add((Layer) new Layer_FloatMenu(options, false));
            }

            int labelNum = (int)(PSI.settings.iconSize * 4.5f);

            if (labelNum > 8)
            {
                labelNum = 8;
            }
            else if (labelNum < 0)
            {
                labelNum = 0;
            }

            listing.DoLabel(Translator.Translate("PSI.Settings.Arrangement.IconSize") + Translator.Translate("PSI.Settings.SizeLabel." + labelNum));
            PSI.settings.iconSize = listing.DoSlider(PSI.settings.iconSize, 0.5f, 2.0f);

            listing.DoLabel(Translator.Translate("PSI.Settings.Arrangement.IconPosition") + (int)(PSI.settings.iconDistanceX * 100) + " , " + (int)(PSI.settings.iconDistanceY * 100));
            PSI.settings.iconDistanceX = listing.DoSlider(PSI.settings.iconDistanceX, -2.0f, 2.0f);
            PSI.settings.iconDistanceY = listing.DoSlider(PSI.settings.iconDistanceY, -2.0f, 2.0f);

            listing.DoLabel(Translator.Translate("PSI.Settings.Arrangement.IconOffset") + (int)(PSI.settings.iconOffsetX * 100) + " , " + (int)(PSI.settings.iconOffsetY * 100));
            PSI.settings.iconOffsetX = listing.DoSlider(PSI.settings.iconOffsetX, -2.0f, 2.0f);
            PSI.settings.iconOffsetY = listing.DoSlider(PSI.settings.iconOffsetY, -2.0f, 2.0f);
            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Arrangement.Horizontal"), ref PSI.settings.iconsHorizontal);
            listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Arrangement.ScreenScale"), ref PSI.settings.iconsScreenScale);

            listing.DoLabel(Translator.Translate("PSI.Settings.Arrangement.IconsPerColumn") + PSI.settings.iconsInColumn);
            PSI.settings.iconsInColumn = (int)listing.DoSlider(PSI.settings.iconsInColumn, 1.0f, 9.0f);

            if (listing.DoTextButton(Translator.Translate("PSI.Settings.ReturnButton")))
            {
                page = "main";
            }
        }
Beispiel #8
0
 public override void DrawThresholdConfig(ref Listing_Standard listing)
 {
     // target threshold
     listing.DoGap();
     listing.DoLabel("FMP.Threshold".Translate() + ":");
     listing.DoLabel("FMP.ThresholdCount".Translate(CurCount, Count));
     // TODO: implement trade screen sliders - they're so pretty! :D
     Count = Mathf.RoundToInt(listing.DoSlider(Count, 0, MaxUpperThreshold));
     listing.DoGap(6f);
     if (listing.DoTextButton("FMP.ThresholdDetails".Translate()))
     {
         Find.WindowStack.Add(DetailsWindow);
     }
 }
    protected void fillPageLimits(Listing_Standard listing)
    {
        DoHeading(listing, "PSI.Settings.Sensitivity.Header");

        if (listing.DoTextButton(Translator.Translate("PSI.Settings.LoadPresetButton")))
        {
            string[] presetList = { };
            String path2 = GenFilePaths.CoreModsFolderPath + "/Pawn State Icons/Presets/Sensitivity/";
            if (Directory.Exists(path2)) presetList = Directory.GetFiles(path2, "*.cfg"); 

            List<FloatMenuOption> options = new List<FloatMenuOption>();
            foreach (string setname in presetList)
            {
                options.Add(new FloatMenuOption(Path.GetFileNameWithoutExtension(setname), () =>
                {
                    try
                    {
                        ModSettings settings = XmlLoader.ItemFromXmlFile<ModSettings>(setname, true);
                        PSI.settings.limit_bleedMult = settings.limit_bleedMult;
                        PSI.settings.limit_diseaseLess = settings.limit_diseaseLess;
                        PSI.settings.limit_EfficiencyLess = settings.limit_EfficiencyLess;
                        PSI.settings.limit_FoodLess = settings.limit_FoodLess;
                        PSI.settings.limit_MoodLess = settings.limit_MoodLess;
                        PSI.settings.limit_RestLess = settings.limit_RestLess;
                        PSI.settings.limit_apparelHealthLess = settings.limit_apparelHealthLess;
                        PSI.settings.limit_tempComfortOffset = settings.limit_tempComfortOffset;                        
                    }
                    catch (IOException) { Log.Error(Translator.Translate("PSI.Settings.LoadPreset.UnableToLoad") + setname); }
                }));
            }
            Find.LayerStack.Add((Layer)new Layer_FloatMenu(options, false));
        }

        listing.DoGap();

        listing.DoLabel(Translator.Translate("PSI.Settings.Sensitivity.Bleeding") + Translator.Translate("PSI.Settings.Sensitivity.Bleeding." + Math.Round( PSI.settings.limit_bleedMult - 0.25 )));
        PSI.settings.limit_bleedMult = listing.DoSlider(PSI.settings.limit_bleedMult, 0.5f, 5.0f);

        listing.DoLabel(Translator.Translate("PSI.Settings.Sensitivity.Injured") + ((int)(PSI.settings.limit_EfficiencyLess * 100)) + "%");
        PSI.settings.limit_EfficiencyLess = listing.DoSlider(PSI.settings.limit_EfficiencyLess, 0.01f, 0.99f);

        listing.DoLabel(Translator.Translate("PSI.Settings.Sensitivity.Food") + ((int)(PSI.settings.limit_FoodLess * 100)) + "%");
        PSI.settings.limit_FoodLess = listing.DoSlider(PSI.settings.limit_FoodLess, 0.01f, 0.99f);

        listing.DoLabel(Translator.Translate("PSI.Settings.Sensitivity.Mood") + ((int)(PSI.settings.limit_MoodLess * 100)) + "%");
        PSI.settings.limit_MoodLess = listing.DoSlider(PSI.settings.limit_MoodLess, 0.01f, 0.99f);

        listing.DoLabel(Translator.Translate("PSI.Settings.Sensitivity.Rest") + ((int)(PSI.settings.limit_RestLess * 100)) + "%");
        PSI.settings.limit_RestLess = listing.DoSlider(PSI.settings.limit_RestLess, 0.01f, 0.99f);

        listing.DoLabel(Translator.Translate("PSI.Settings.Sensitivity.ApparelHealth") + ((int)(PSI.settings.limit_apparelHealthLess * 100)) + "%");
        PSI.settings.limit_apparelHealthLess = listing.DoSlider(PSI.settings.limit_apparelHealthLess, 0.01f, 0.99f);

        listing.DoLabel(Translator.Translate("PSI.Settings.Sensitivity.Temperature") + ((int)(PSI.settings.limit_tempComfortOffset)) + "C");
        PSI.settings.limit_tempComfortOffset = listing.DoSlider(PSI.settings.limit_tempComfortOffset, -10f, 10f);

        if (listing.DoTextButton(Translator.Translate("PSI.Settings.ReturnButton"))) page = "main";
    }
    protected void fillPageArrangement(Listing_Standard listing)
    {
        DoHeading(listing, "PSI.Settings.Arrangement.Header");

        if (listing.DoTextButton(Translator.Translate("PSI.Settings.LoadPresetButton")))
        {
            string[] presetList = { };
            String path2 = GenFilePaths.CoreModsFolderPath + "/Pawn State Icons/Presets/Position/";
            if (Directory.Exists(path2)) presetList = Directory.GetFiles(path2, "*.cfg"); 

            List<FloatMenuOption> options = new List<FloatMenuOption>();
            foreach (string setname in presetList)
            {
                options.Add(new FloatMenuOption(Path.GetFileNameWithoutExtension(setname), () =>
                {
                    try
                    {
                        ModSettings settings = XmlLoader.ItemFromXmlFile<ModSettings>(setname, true);
                        PSI.settings.iconDistanceX = settings.iconDistanceX;
                        PSI.settings.iconDistanceY = settings.iconDistanceY;
                        PSI.settings.iconOffsetX = settings.iconOffsetX;
                        PSI.settings.iconOffsetY = settings.iconOffsetY;
                        PSI.settings.iconsHorizontal = settings.iconsHorizontal;
                        PSI.settings.iconsScreenScale = settings.iconsScreenScale;
                        PSI.settings.iconsInColumn = settings.iconsInColumn;
                        PSI.settings.iconSize = settings.iconSize;                        
                    }
                    catch (IOException) { Log.Error(Translator.Translate("PSI.Settings.LoadPreset.UnableToLoad") + setname); }
                }));
            }
            Find.LayerStack.Add((Layer)new Layer_FloatMenu(options, false));
        }

        int labelNum = (int)(PSI.settings.iconSize * 4.5f);
        if (labelNum > 8) labelNum = 8;
        else if (labelNum < 0) labelNum = 0;

        listing.DoLabel(Translator.Translate("PSI.Settings.Arrangement.IconSize") + Translator.Translate("PSI.Settings.SizeLabel."+labelNum));
        PSI.settings.iconSize = listing.DoSlider(PSI.settings.iconSize, 0.5f, 2.0f);

        listing.DoLabel(Translator.Translate("PSI.Settings.Arrangement.IconPosition") + (int)(PSI.settings.iconDistanceX * 100) + " , " + (int)(PSI.settings.iconDistanceY * 100));
        PSI.settings.iconDistanceX = listing.DoSlider(PSI.settings.iconDistanceX, -2.0f, 2.0f);
        PSI.settings.iconDistanceY = listing.DoSlider(PSI.settings.iconDistanceY, -2.0f, 2.0f);

        listing.DoLabel(Translator.Translate("PSI.Settings.Arrangement.IconOffset") + (int)(PSI.settings.iconOffsetX * 100) + " , " + (int)(PSI.settings.iconOffsetY * 100));
        PSI.settings.iconOffsetX = listing.DoSlider(PSI.settings.iconOffsetX, -2.0f, 2.0f);
        PSI.settings.iconOffsetY = listing.DoSlider(PSI.settings.iconOffsetY, -2.0f, 2.0f);
        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Arrangement.Horizontal"), ref PSI.settings.iconsHorizontal);
        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Arrangement.ScreenScale"), ref PSI.settings.iconsScreenScale);

        listing.DoLabel(Translator.Translate("PSI.Settings.Arrangement.IconsPerColumn") + PSI.settings.iconsInColumn);
        PSI.settings.iconsInColumn = (int)listing.DoSlider(PSI.settings.iconsInColumn, 1.0f, 9.0f);

        if (listing.DoTextButton(Translator.Translate("PSI.Settings.ReturnButton"))) page = "main";
    }
    protected void fillPageShowHide(Listing_Standard listing)
    {

        listing.OverrideColumnWidth = 230;
        DoHeading(listing, "PSI.Settings.Visibility.Header");
        listing.OverrideColumnWidth = 95;

        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.TargetPoint"), ref PSI.settings.showTargetPoint);
        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Aggressive"), ref PSI.settings.showAggressive);
        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Dazed"), ref PSI.settings.showDazed);
        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Leave"), ref PSI.settings.showLeave);
        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Draft"), ref PSI.settings.showDraft);
        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Idle"), ref PSI.settings.showIdle);
        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Unarmed"), ref PSI.settings.showUnarmed);
        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Hungry"), ref PSI.settings.showHungry);      
        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Sad"), ref PSI.settings.showSad);
        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Tired"), ref PSI.settings.showTired);
        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Disease"), ref PSI.settings.showDisease);

        listing.OverrideColumnWidth = 230;

        if (listing.DoTextButton(Translator.Translate("PSI.Settings.ReturnButton"))) page = "main";
        listing.OverrideColumnWidth = 95;
        listing.NewColumn();

        DoHeading(listing, " ", false);
        DoHeading(listing, " ", false);

        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Injury"), ref PSI.settings.showEffectiveness);
        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Bloodloss"), ref PSI.settings.showBloodloss);
        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Hot"), ref PSI.settings.showHot);
        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Cold"), ref PSI.settings.showCold);
        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Naked"), ref PSI.settings.showNaked);

        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Drunk"), ref PSI.settings.showDrunk);
        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.ApparelHealth"), ref PSI.settings.showApparelHealth);
        listing.DoLabelCheckbox(Translator.Translate("PSI.Settings.Visibility.Pacific"), ref PSI.settings.showPacific);
        
    }
        public void DoContent(Rect canvas)
        {
            Widgets.DrawMenuSection(canvas);

            if (Job != null)
            {
                // leave some space for bottom buttons.
                float bottomButtonsHeight = 30f;
                float bottomButtonsGap = 6f;
                canvas.height = canvas.height - bottomButtonsHeight - bottomButtonsGap;

                // bottom buttons
                Rect bottomButtons = new Rect(canvas.xMin, canvas.height + bottomButtonsGap, canvas.width, bottomButtonsHeight);
                GUI.BeginGroup(bottomButtons);

                // add / remove to the stack
                Rect add = new Rect(bottomButtons.width * .75f, 0f, bottomButtons.width / 4f - 6f, bottomButtons.height);
                if (Source == SourceOptions.Current)
                {
                    if (Widgets.TextButton(add, "FM.Delete".Translate()))
                    {
                        Manager.JobStack.Delete(Job);
                        Job = null;
                        RefreshSourceList();
                        return; // hopefully that'll just skip to the next tick without any further errors?
                    }
                    TooltipHandler.TipRegion(add, "FMP.DeleteBillTooltip".Translate());
                }
                else
                {
                    if (Job.Trigger.IsValid)
                    {
                        if (Widgets.TextButton(add, "FM.Manage".Translate()))
                        {
                            Manager.JobStack.Add(Job);

                            Source = SourceOptions.Current;
                            RefreshSourceList();
                            SourceFilter = "";
                        }
                        TooltipHandler.TipRegion(add, "FMP.ManageBillTooltip".Translate());
                    } else
                    {
                        TextAnchor oldAnchor = Text.Anchor;
                        Color oldColor = GUI.color;
                        Text.Anchor = TextAnchor.MiddleCenter;
                        GUI.color = new Color(.6f, .6f, .6f);
                        Widgets.DrawBox(add);
                        GUI.Label(add, "FMP.NoThreshold".Translate());
                        Text.Anchor = oldAnchor;
                        GUI.color = oldColor;
                        TooltipHandler.TipRegion(add, "FMP.NoThresholdTooltip".Translate());
                    }
                }

                GUI.EndGroup();

                GUI.BeginGroup(canvas);
                Text.Anchor = TextAnchor.MiddleCenter;
                Text.Font = GameFont.Medium;
                Rect recta = new Rect(0f, 0f, canvas.width, 50f);
                Widgets.Label(recta, Job.Bill.LabelCap);
                Text.Anchor = TextAnchor.UpperLeft;
                Text.Font = GameFont.Small;
                Rect rect2 = new Rect(6f, 50f, canvas.width * .3f, canvas.height - 50f);
                Listing_Standard listingStandard = new Listing_Standard(rect2);
                if (Job.Bill.suspended)
                {
                    if (listingStandard.DoTextButton("Suspended".Translate()))
                    {
                        Job.Bill.suspended = false;
                    }
                }
                else if (listingStandard.DoTextButton("NotSuspended".Translate()))
                {
                    Job.Bill.suspended = true;
                }
                string billStoreModeLabel = ("BillStoreMode_" + Job.Bill.storeMode).Translate();
                if (listingStandard.DoTextButton(billStoreModeLabel))
                {
                    List<FloatMenuOption> list = (from BillStoreMode mode in Enum.GetValues(typeof (BillStoreMode)) select new FloatMenuOption(("BillStoreMode_" + mode).Translate(), delegate { Job.Bill.storeMode = mode; })).ToList();
                    Find.WindowStack.Add(new FloatMenu(list));
                }

                // other stuff
                listingStandard.DoGap();
                listingStandard.DoLabel("IngredientSearchRadius".Translate() + ": " + Job.Bill.ingredientSearchRadius.ToString("#####0"));
                Job.Bill.ingredientSearchRadius = Mathf.RoundToInt(listingStandard.DoSlider(Job.Bill.ingredientSearchRadius, 0f, 250f));

                if (Job.Bill.recipe.workSkill != null)
                {
                    listingStandard.DoLabel("MinimumSkillLevel".Translate(Job.Bill.recipe.workSkill.label.ToLower()) + ": " + Job.Bill.minSkillLevel.ToString("#####0"));
                    Job.Bill.minSkillLevel = Mathf.RoundToInt(listingStandard.DoSlider(Job.Bill.minSkillLevel, 0f, 20f));
                }

                // draw threshold config
                Job.Trigger.DrawThresholdConfig(ref listingStandard);
                Job.BillGivers.DrawBillGiverConfig(ref listingStandard);
                listingStandard.End();

                // ingredient picker
                Rect rect3 = new Rect(rect2.xMax + 6f, 50f, canvas.width * .4f, canvas.height - 50f);
                ThingFilterUI.DoThingFilterConfigWindow(rect3, ref BillScrollPosition, Job.Bill.ingredientFilter, Job.Bill.recipe.fixedIngredientFilter, 4);

                // description
                Rect rect4 = new Rect(rect3.xMax + 6f, rect3.y + 30f, canvas.width - rect3.xMax - 12f, canvas.height - 50f);
                StringBuilder stringBuilder = new StringBuilder();

                // add mainproduct line
                stringBuilder.AppendLine("FMP.MainProduct".Translate(Job.MainProduct.Label, Job.MainProduct.Count));
                stringBuilder.AppendLine();

                if (Job.Bill.recipe.description != null)
                {
                    stringBuilder.AppendLine(Job.Bill.recipe.description);
                    stringBuilder.AppendLine();
                }
                stringBuilder.AppendLine("WorkAmount".Translate() + ": " + Job.Bill.recipe.WorkAmountTotal(null).ToStringWorkAmount());
                stringBuilder.AppendLine();
                foreach (IngredientCount ingredientCount in Job.Bill.recipe.ingredients)
                {
                    if (!ingredientCount.filter.Summary.NullOrEmpty())
                    {
                        stringBuilder.AppendLine(Job.Bill.recipe.IngredientValueGetter.BillRequirementsDescription(ingredientCount));
                    }
                }
                stringBuilder.AppendLine();
                string text4 = Job.Bill.recipe.IngredientValueGetter.ExtraDescriptionLine();
                if (text4 != null)
                {
                    stringBuilder.AppendLine(text4);
                    stringBuilder.AppendLine();
                }
                stringBuilder.AppendLine("MinimumSkills".Translate());
                stringBuilder.AppendLine(Job.Bill.recipe.MinSkillString);
                Text.Font = GameFont.Small;
                string text5 = stringBuilder.ToString();
                if (Text.CalcHeight(text5, rect4.width) > rect4.height)
                {
                    Text.Font = GameFont.Tiny;
                }
                Widgets.Label(rect4, text5);
                Text.Font = GameFont.Small;
                if (Job.Bill.recipe.products.Count == 1)
                {
                    Widgets.InfoCardButton(rect4.x, rect3.y, Job.Bill.recipe.products[0].thingDef);
                }
            }
            GUI.EndGroup();
        }
Beispiel #13
0
        public void DrawBillGiverConfig(ref Listing_Standard listing)
        {
            listing.DoGap();

            // workstation info
            listing.DoLabel("FMP.BillGivers".Translate());
            listing.DoLabel("FMP.BillGiversCount".Translate(GetPotentialBillGivers.Count, GetAssignedBillGivers.Count));

            string potentialString = String.Join("\n", GetPotentialBillGivers.Select(b => b.LabelCap).ToArray());
            string assignedString = String.Join("\n", GetAssignedBillGivers.Select(b => b.LabelCap).ToArray());
            string stationsTooltip = "FMP.BillGiversTooltip".Translate(potentialString, assignedString);
            // todo, fix that tooltip. Possible?
            // TooltipHandler.TipRegion(stations, stationsTooltip);

            // workstation selector
            if (listing.DoTextButton("FMP.BillGiversDetails".Translate()))
            {
                Find.WindowStack.Add(DetailsWindow);
            }
        }
Beispiel #14
0
        private void FillPageLimits(Listing_Standard listing)
        {
            DoHeading(listing, "PSI.Settings.Sensitivity.Header");
            if (listing.DoTextButton("PSI.Settings.LoadPresetButton".Translate()))
            {
                var strArray = new string[0];
                var path     = _modPath + "/Presets/Sensitivity/";
                Log.Message(path);
                if (Directory.Exists(path))
                {
                    strArray = Directory.GetFiles(path, "*.cfg");
                }
                var options = strArray.Select(setname => new FloatMenuOption(Path.GetFileNameWithoutExtension(setname), () =>
                {
                    try
                    {
                        var settings = XmlLoader.ItemFromXmlFile <ModSettings>(setname);
                        PSI.Settings.limit_BleedMult         = settings.limit_BleedMult;
                        PSI.Settings.limit_DiseaseLess       = settings.limit_DiseaseLess;
                        PSI.Settings.limit_EfficiencyLess    = settings.limit_EfficiencyLess;
                        PSI.Settings.limit_FoodLess          = settings.limit_FoodLess;
                        PSI.Settings.limit_MoodLess          = settings.limit_MoodLess;
                        PSI.Settings.limit_RestLess          = settings.limit_RestLess;
                        PSI.Settings.limit_ApparelHealthLess = settings.limit_ApparelHealthLess;
                        PSI.Settings.limit_TempComfortOffset = settings.limit_TempComfortOffset;
                    }
                    catch (IOException)
                    {
                        Log.Error("PSI.Settings.LoadPreset.UnableToLoad".Translate() + setname);
                    }
                })).ToList();

                Find.WindowStack.Add(new FloatMenu(options));
            }

            listing.DoGap();

            listing.DoLabel("PSI.Settings.Sensitivity.Bleeding".Translate() + ("PSI.Settings.Sensitivity.Bleeding." + Math.Round(PSI.Settings.limit_BleedMult - 0.25)).Translate());
            PSI.Settings.limit_BleedMult = listing.DoSlider(PSI.Settings.limit_BleedMult, 0.5f, 5f);

            listing.DoLabel("PSI.Settings.Sensitivity.Injured".Translate() + (int)(PSI.Settings.limit_EfficiencyLess * 100.0) + "%");
            PSI.Settings.limit_EfficiencyLess = listing.DoSlider(PSI.Settings.limit_EfficiencyLess, 0.01f, 0.99f);

            listing.DoLabel("PSI.Settings.Sensitivity.Food".Translate() + (int)(PSI.Settings.limit_FoodLess * 100.0) + "%");
            PSI.Settings.limit_FoodLess = listing.DoSlider(PSI.Settings.limit_FoodLess, 0.01f, 0.99f);

            listing.DoLabel("PSI.Settings.Sensitivity.Mood".Translate() + (int)(PSI.Settings.limit_MoodLess * 100.0) + "%");
            PSI.Settings.limit_MoodLess = listing.DoSlider(PSI.Settings.limit_MoodLess, 0.01f, 0.99f);

            listing.DoLabel("PSI.Settings.Sensitivity.Rest".Translate() + (int)(PSI.Settings.limit_RestLess * 100.0) + "%");
            PSI.Settings.limit_RestLess = listing.DoSlider(PSI.Settings.limit_RestLess, 0.01f, 0.99f);

            listing.DoLabel("PSI.Settings.Sensitivity.ApparelHealth".Translate() + (int)(PSI.Settings.limit_ApparelHealthLess * 100.0) + "%");
            PSI.Settings.limit_ApparelHealthLess = listing.DoSlider(PSI.Settings.limit_ApparelHealthLess, 0.01f, 0.99f);

            listing.DoLabel("PSI.Settings.Sensitivity.Temperature".Translate() + (int)PSI.Settings.limit_TempComfortOffset + "C");
            PSI.Settings.limit_TempComfortOffset = listing.DoSlider(PSI.Settings.limit_TempComfortOffset, -10f, 10f);

            if (!listing.DoTextButton("PSI.Settings.ReturnButton".Translate()))
            {
                return;
            }

            Page = "main";
        }
Beispiel #15
0
        private void FillPageArrangement(Listing_Standard listing)
        {
            DoHeading(listing, "PSI.Settings.Arrangement.Header");

            if (listing.DoTextButton("PSI.Settings.LoadPresetButton".Translate()))
            {
                var strArray = new string[0];
                var path     = _modPath + "/Presets/Position/";
                if (Directory.Exists(path))
                {
                    strArray = Directory.GetFiles(path, "*.cfg");
                }
                var options = strArray.Select(setname => new FloatMenuOption(Path.GetFileNameWithoutExtension(setname), () =>
                {
                    try
                    {
                        var settings = XmlLoader.ItemFromXmlFile <ModSettings>(setname);
                        PSI.Settings.iconDistanceX    = settings.iconDistanceX;
                        PSI.Settings.iconDistanceY    = settings.iconDistanceY;
                        PSI.Settings.iconOffsetX      = settings.iconOffsetX;
                        PSI.Settings.iconOffsetY      = settings.iconOffsetY;
                        PSI.Settings.iconsHorizontal  = settings.iconsHorizontal;
                        PSI.Settings.iconsScreenScale = settings.iconsScreenScale;
                        PSI.Settings.iconsInColumn    = settings.iconsInColumn;
                        PSI.Settings.iconSize         = settings.iconSize;
                    }
                    catch (IOException)
                    {
                        Log.Error("PSI.Settings.LoadPreset.UnableToLoad".Translate() + setname);
                    }
                })).ToList();
                Find.WindowStack.Add(new FloatMenu(options));
            }

            var num = (int)(PSI.Settings.iconSize * 4.5);

            if (num > 8)
            {
                num = 8;
            }
            else if (num < 0)
            {
                num = 0;
            }

            listing.DoLabel("PSI.Settings.Arrangement.IconSize".Translate() + ("PSI.Settings.SizeLabel." + num).Translate());
            PSI.Settings.iconSize = listing.DoSlider(PSI.Settings.iconSize, 0.5f, 2f);

            listing.DoLabel(string.Concat("PSI.Settings.Arrangement.IconPosition".Translate(), (int)(PSI.Settings.iconDistanceX * 100.0), " , ", (int)(PSI.Settings.iconDistanceY * 100.0)));
            PSI.Settings.iconDistanceX = listing.DoSlider(PSI.Settings.iconDistanceX, -2f, 2f);
            PSI.Settings.iconDistanceY = listing.DoSlider(PSI.Settings.iconDistanceY, -2f, 2f);

            listing.DoLabel(string.Concat("PSI.Settings.Arrangement.IconOffset".Translate(), (int)(PSI.Settings.iconOffsetX * 100.0), " , ", (int)(PSI.Settings.iconOffsetY * 100.0)));
            PSI.Settings.iconOffsetX = listing.DoSlider(PSI.Settings.iconOffsetX, -2f, 2f);
            PSI.Settings.iconOffsetY = listing.DoSlider(PSI.Settings.iconOffsetY, -2f, 2f);

            listing.DoLabelCheckbox("PSI.Settings.Arrangement.Horizontal".Translate(), ref PSI.Settings.iconsHorizontal);

            listing.DoLabelCheckbox("PSI.Settings.Arrangement.ScreenScale".Translate(), ref PSI.Settings.iconsScreenScale);

            listing.DoLabel("PSI.Settings.Arrangement.IconsPerColumn".Translate() + PSI.Settings.iconsInColumn);

            PSI.Settings.iconsInColumn = (int)listing.DoSlider(PSI.Settings.iconsInColumn, 1f, 9f);

            if (!listing.DoTextButton("PSI.Settings.ReturnButton".Translate()))
            {
                return;
            }

            Page = "main";
        }