示例#1
0
        public TemperatureForecastForDay(int tileId, int ticks, int hour)
        {
            TileId = tileId;
            Ticks  = ticks;
            Hour   = hour;

            var outdoorTemperature = Find.World.tileTemperatures.OutdoorTemperatureAt(tileId, Ticks);

            OutdoorTemperature = GenTemperature.CelsiusTo(outdoorTemperature, Prefs.TemperatureMode);

            var offsetFromSunCycle = GenTemperature.OffsetFromSunCycle(Ticks, TileId);

            // this is a temperature delta, so it's not a straight Celsius to another temperature unit. We use an extension method.
            OffsetFromSunCycle = TemperatureDisplayMode.Celsius.TempDelta(offsetFromSunCycle, Prefs.TemperatureMode);

            var offsetFromDailyRandomVariation =
                Find.World.tileTemperatures.OffsetFromDailyRandomVariation(TileId, Ticks);

            OffsetFromDailyRandomVariation =
                TemperatureDisplayMode.Celsius.TempDelta(offsetFromDailyRandomVariation, Prefs.TemperatureMode);

            var offsetFromSeasonCycle = GenTemperature.OffsetFromSeasonCycle(Ticks, tileId);

            OffsetFromSeasonCycle = TemperatureDisplayMode.Celsius.TempDelta(offsetFromSeasonCycle, Prefs.TemperatureMode);

            var dailyRandomVariation = Find.WorldGrid[TileId].temperature -
                                       (OffsetFromSeasonCycle + OffsetFromDailyRandomVariation + OffsetFromSunCycle);

            DailyRandomVariation = TemperatureDisplayMode.Celsius.TempDelta(dailyRandomVariation, Prefs.TemperatureMode);
        }
示例#2
0
        private void DrawTileInfo()
        {
            DrawEntryHeader("PLTFWTW_TileSpecifications".Translate(), backgroundColor: Color.magenta);

            ListingStandard.Label($"Temperature Scale: {Prefs.TemperatureMode.ToStringHuman()}",
                                  tooltip: "The scale in which are displayed all temperatures on this window."); //TODO: translate

            var vectorLongLat = Find.WorldGrid.LongLatOf(_tileId);
            var latitude      = vectorLongLat.y;
            var longitude     = vectorLongLat.x;

            ListingStandard.Label($"{"PLTFWTW_Date".Translate()}: {GenDate.DateReadoutStringAt(_dateTicks, vectorLongLat)}");
            ListingStandard.Label($"{"PLTFWTW_TileId".Translate()}: {_tileId}");

            ListingStandard.Label(
                $"{"PLTFWTW_LatLong".Translate()}: {latitude.ToStringLatitude()} - {longitude.ToStringLongitude()}");

            ListingStandard.Label($"{"PLTFWTW_EquatorialDistance".Translate()}: {Find.WorldGrid.DistanceFromEquatorNormalized(_tileId)}");

            var tileTempCelsius = Find.World.grid[_tileId].temperature;

            ListingStandard.Label(
                $"{"PLTFWTW_TileAvgTemp".Translate()}: {GenTemperature.CelsiusTo(tileTempCelsius, Prefs.TemperatureMode)} {Prefs.TemperatureMode.ToStringHuman()}");

            var seasonalShiftAmplitudeCelsius = GenTemperature.SeasonalShiftAmplitudeAt(_tileId);

            ListingStandard.Label($"{"PLTFWTW_SeasonalShiftAmplitude".Translate()}: {GenTemperature.CelsiusTo(seasonalShiftAmplitudeCelsius, Prefs.TemperatureMode)} {Prefs.TemperatureMode.ToStringHuman()}");
        }
示例#3
0
        public TemperatureForecastForTwelfth(int tileId, Twelfth twelfth)
        {
            Latitude = Find.WorldGrid.LongLatOf(tileId).y;
            Twelfth  = twelfth;

            var averageTemperatureForTwelfth = Find.World.tileTemperatures.AverageTemperatureForTwelfth(tileId, twelfth);

            AverageTemperatureForTwelfth =
                GenTemperature.CelsiusTo(averageTemperatureForTwelfth, Prefs.TemperatureMode);
        }
示例#4
0
        private void DrawTemperatureSelection()
        {
            DrawEntryHeader("Temperature", backgroundColor: ColorLibrary.RoyalPurple);

            // min and max possible temperatures, in C/F/K (depending on user preferences).
            // note that TemperatureTuning temps are in Celsius.
            var tempMinUnit = GenTemperature.CelsiusTo(TemperatureTuning.MinimumTemperature, Prefs.TemperatureMode);
            var tempMaxUnit = GenTemperature.CelsiusTo(TemperatureTuning.MaximumTemperature, Prefs.TemperatureMode);

            var averageTemperature = _gameData.GodModeData.AverageTemperature;

            _chosenAverageTemperatureString = averageTemperature.ToString("F1", CultureInfo.InvariantCulture);

            var temperatureRectSpace = ListingStandard.GetRect(DefaultElementHeight * 1.25f);

            Widgets.Label(temperatureRectSpace.LeftPart(0.8f),
                          $"{"AvgTemp".Translate()} (°{Prefs.TemperatureMode.ToStringHuman()})\n[{tempMinUnit}, {tempMaxUnit}]");
            Widgets.TextFieldNumeric(temperatureRectSpace.RightPart(0.2f), ref averageTemperature,
                                     ref _chosenAverageTemperatureString, tempMinUnit, tempMaxUnit);

            _gameData.GodModeData.AverageTemperature = averageTemperature;
        }
示例#5
0
        private void DrawTemperaturesSelection()
        {
            // min and max possible temperatures, in C/F/K (depending on user prefs).
            // note that TemperatureTuning temps are in Celsius.
            var tempMinUnit = GenTemperature.CelsiusTo(TemperatureTuning.MinimumTemperature, Prefs.TemperatureMode);
            var tempMaxUnit = GenTemperature.CelsiusTo(TemperatureTuning.MaximumTemperature, Prefs.TemperatureMode);

            DrawEntryHeader($"{"Temperature".Translate()} (°{Prefs.TemperatureMode.ToStringHuman()}) [{tempMinUnit}, {tempMaxUnit}]",
                            backgroundColor: ColorFromFilterType(typeof(TileFilterAverageTemperatures)));

            DrawUsableMinMaxNumericField(_gameData.UserData.AverageTemperature, "AvgTemp".Translate(),
                                         tempMinUnit, tempMaxUnit);

            ListingStandard.GapLine();

            DrawUsableMinMaxNumericField(_gameData.UserData.MinTemperature, "Minimum Temperature", //TODO: translate
                                         tempMinUnit, tempMaxUnit);


            ListingStandard.GapLine();

            DrawUsableMinMaxNumericField(_gameData.UserData.MaxTemperature, "Maximum Temperature", // TODO: translate
                                         tempMinUnit, tempMaxUnit);
        }
示例#6
0
        public TemperatureForecastForYear(int tileId, int ticks, int day)
        {
            Day = day;

            /*
             * Get min & max temperatures for the day
             */
            var tempsForHourOfDay = new List <float>(GenDate.HoursPerDay);

            for (var hour = 0; hour < GenDate.HoursPerDay; hour++)
            {
                var hourTicks = ticks + hour * GenDate.TicksPerHour;
                var outdoorTemperatureinCelsius = Find.World.tileTemperatures.OutdoorTemperatureAt(tileId, hourTicks);
                var outdoorTemperature          = GenTemperature.CelsiusTo(outdoorTemperatureinCelsius, Prefs.TemperatureMode);
                tempsForHourOfDay.Add(outdoorTemperature);
            }

            // get min & max from list of temperatures for the day
            MinTemp = tempsForHourOfDay.Min();
            MaxTemp = tempsForHourOfDay.Max();


            // get number of ticks for the maximum temperature
            var ticksForMaxTemp = ticks + tempsForHourOfDay.IndexOf(MaxTemp) * GenDate.TicksPerHour;

            var offsetFromSeasonCycle = GenTemperature.OffsetFromSeasonCycle(ticksForMaxTemp, tileId);

            OffsetFromSeasonCycle =
                TemperatureDisplayMode.Celsius.TempDelta(offsetFromSeasonCycle, Prefs.TemperatureMode);

            var offsetFromDailyRandomVariation =
                Find.World.tileTemperatures.OffsetFromDailyRandomVariation(tileId, ticksForMaxTemp);

            OffsetFromDailyRandomVariation =
                TemperatureDisplayMode.Celsius.TempDelta(offsetFromDailyRandomVariation, Prefs.TemperatureMode);
        }
示例#7
0
        public override void DefsLoaded()
        {
            _opacity = Settings.GetHandle(
                "opacity", "FALCHM.OverlayOpacity".Translate(),
                "FALCHM.OverlayOpacityDesc".Translate(), 30,
                Validators.IntRangeValidator(1, 100));

            _opacity.OnValueChanged = val => { _heatMap?.Reset(); };

            _updateDelay = Settings.GetHandle("updateDelay",
                                              "FALCHM.UpdateDelay".Translate(),
                                              "FALCHM.UpdateDelayDesc".Translate(),
                                              100,
                                              Validators.IntRangeValidator(1, 9999));

            _showOutdoorThermometer = Settings.GetHandle(
                "showOutdoorThermometer",
                "FALCHM.ShowOutDoorThermometer".Translate(),
                "FALCHM.ShowOutDoorThermometerDesc".Translate(),
                true);

            _outdoorThermometerOpacity = Settings.GetHandle(
                "outdoorThermometerOpacity",
                "FALCHM.ThermometerOpacity".Translate(),
                "FALCHM.ThermometerOpacityDesc".Translate(),
                30,
                Validators.IntRangeValidator(1, 100));

            _outdoorThermometerOpacity.OnValueChanged = val => { _temperatureTextureCache.Clear(); };


            _showTemperatureOverRooms = Settings.GetHandle(
                "showTemperatureOverRooms",
                "FALCHM.ShowTemperatureOverRooms".Translate(),
                "FALCHM.ShowTemperatureOverRoomsDesc".Translate(),
                true);


            _useCustomRange = Settings.GetHandle(
                "useCustomeRange",
                "FALCHM.UseCustomeRange".Translate(),
                "FALCHM.UseCustomeRangeDesc".Translate(),
                false);

            _useCustomRange.OnValueChanged = val => { ResetAll(); };


            _customRangeMin = Settings.GetHandle("customRangeMin", "Unused", "Unused", 0);
            _customRangeMax = Settings.GetHandle("customRangeMax", "Unused", "Unused", 40);

            _customRangeMin.VisibilityPredicate = () => false;
            _customRangeMax.VisibilityPredicate = () => false;


            var customRangeValidator = Validators.IntRangeValidator(
                (int)GenTemperature.CelsiusTo(-100, Prefs.TemperatureMode),
                (int)GenTemperature.CelsiusTo(100, Prefs.TemperatureMode));

            var customRangeMin = Settings.GetHandle(
                "customRangeMinPlaceholder",
                "FALCHM.CustomRangeMin".Translate(),
                $"{"FALCHM.CustomRangeMinDesc".Translate()} ({Prefs.TemperatureMode.ToStringHuman()})",
                (int)GenTemperature.CelsiusTo(_customRangeMin, Prefs.TemperatureMode),
                customRangeValidator);

            customRangeMin.Unsaved             = true;
            customRangeMin.VisibilityPredicate = () => _useCustomRange;

            var customRangeMax = Settings.GetHandle(
                "customRangeMaxPlaceholder",
                "FALCHM.CustomRangeMax".Translate(),
                $"{"FALCHM.CustomRangeMaxDesc".Translate()} ({Prefs.TemperatureMode.ToStringHuman()})",
                (int)GenTemperature.CelsiusTo(_customRangeMax, Prefs.TemperatureMode),
                customRangeValidator);

            customRangeMax.Unsaved             = true;
            customRangeMax.VisibilityPredicate = () => _useCustomRange;


            customRangeMin.OnValueChanged = val =>
            {
                if (customRangeMax <= customRangeMin)
                {
                    customRangeMax.Value = customRangeMin + 1;
                }

                _customRangeMin.Value = ConvertToCelcius(customRangeMin);
                ResetAll();
            };


            customRangeMax.OnValueChanged = val =>
            {
                if (customRangeMin >= customRangeMax)
                {
                    customRangeMin.Value = customRangeMax - 1;
                }

                _customRangeMax.Value = ConvertToCelcius(customRangeMax);
                ResetAll();
            };
        }
示例#8
0
        public override void Filter(List <int> inputList)
        {
            base.Filter(inputList);

            if (!IsFilterActive)
            {
                return;
            }

            // e.g UserData.AverageTemperature, UserData.SummerTemperature or UserData.WinterTemperature
            var temperatureItem = (UsableMinMaxNumericItem <float>)UserData.GetType().GetProperty(AttachedProperty)
                                  ?.GetValue(UserData, null);

            if (temperatureItem == null)
            {
                PrepareLanding.Instance.TileFilter.FilterInfoLogger.AppendErrorMessage(
                    $"{"PLFILT_TemperatureIsNull".Translate()} TileFilterTemperatures.Filter.", sendToLog: true);
                return;
            }

            if (!temperatureItem.IsCorrectRange)
            {
                var message =
                    $"{SubjectThingDef}: {"PLFILT_VerifyMinIsLessOrEqualMax".Translate()}: {temperatureItem.Min} <= {temperatureItem.Max}).";
                PrepareLanding.Instance.TileFilter.FilterInfoLogger.AppendErrorMessage(message);
                return;
            }

            Func <int, float> temperatureFunc;

            switch (AttachedProperty)
            {
            case nameof(UserData.AverageTemperature):
                temperatureFunc = AverageTemperatureForTile;
                break;

            case nameof(UserData.MinTemperature):
                temperatureFunc = MinTemperatureForTile;
                break;

            case nameof(UserData.MaxTemperature):
                temperatureFunc = MaxTemperatureAtTile;
                break;

            default:
                Log.Error($"[PrepareLanding] Unknown attached property in TileFilterTemperatures.Filter(): {AttachedProperty}");
                return;
            }

            foreach (var tileId in inputList)
            {
                var tileTempInC = temperatureFunc(tileId);

                var tileTemp = GenTemperature.CelsiusTo(tileTempInC, Prefs.TemperatureMode);

                if (temperatureItem.InRange(tileTemp))
                {
                    _filteredTiles.Add(tileId);
                }
            }
        }
示例#9
0
        private static string TemperatureString()
        {
            IntVec3 intVec = UI.MouseCell();
            IntVec3 c      = intVec;
            Room    room   = intVec.GetRoom(Find.CurrentMap, RegionType.Set_All);

            if (room == null)
            {
                for (int i = 0; i < 9; i++)
                {
                    IntVec3 intVec2 = intVec + GenAdj.AdjacentCellsAndInside[i];
                    if (intVec2.InBounds(Find.CurrentMap))
                    {
                        Room room2 = intVec2.GetRoom(Find.CurrentMap, RegionType.Set_All);
                        if (room2 != null && ((!room2.PsychologicallyOutdoors && !room2.UsesOutdoorTemperature) || (!room2.PsychologicallyOutdoors && (room == null || room.PsychologicallyOutdoors)) || (room2.PsychologicallyOutdoors && room == null)))
                        {
                            c    = intVec2;
                            room = room2;
                        }
                    }
                }
            }
            if (room == null && intVec.InBounds(Find.CurrentMap))
            {
                Building edifice = intVec.GetEdifice(Find.CurrentMap);
                if (edifice != null)
                {
                    foreach (IntVec3 item in edifice.OccupiedRect().ExpandedBy(1).ClipInsideMap(Find.CurrentMap))
                    {
                        room = item.GetRoom(Find.CurrentMap, RegionType.Set_All);
                        if (room != null && !room.PsychologicallyOutdoors)
                        {
                            c = item;
                            break;
                        }
                    }
                }
            }
            string text;

            if (c.InBounds(Find.CurrentMap) && !c.Fogged(Find.CurrentMap) && room != null && !room.PsychologicallyOutdoors)
            {
                if (room.OpenRoofCount == 0)
                {
                    text = "Indoors".Translate();
                }
                else
                {
                    if (indoorsUnroofedStringCachedRoofCount != room.OpenRoofCount)
                    {
                        indoorsUnroofedStringCached          = "IndoorsUnroofed".Translate() + " (" + room.OpenRoofCount.ToStringCached() + ")";
                        indoorsUnroofedStringCachedRoofCount = room.OpenRoofCount;
                    }
                    text = indoorsUnroofedStringCached;
                }
            }
            else
            {
                text = "Outdoors".Translate();
            }
            float num  = (room == null || c.Fogged(Find.CurrentMap)) ? Find.CurrentMap.mapTemperature.OutdoorTemp : room.Temperature;
            int   num2 = Mathf.RoundToInt(GenTemperature.CelsiusTo(cachedTemperatureStringForTemperature, Prefs.TemperatureMode));
            int   num3 = Mathf.RoundToInt(GenTemperature.CelsiusTo(num, Prefs.TemperatureMode));

            if (cachedTemperatureStringForLabel != text || num2 != num3)
            {
                cachedTemperatureStringForLabel       = text;
                cachedTemperatureStringForTemperature = num;
                cachedTemperatureString = text + " " + num.ToStringTemperature("F0");
            }
            return(cachedTemperatureString);
        }
示例#10
0
        private void DrawWorldRecord()
        {
            DrawEntryHeader("PLMWINF_WorldRecords".Translate(), backgroundColor: Color.yellow);

            if (_gameData.WorldData.WorldCharacteristics == null || _gameData.WorldData.WorldCharacteristics.Count == 0)
            {
                //Log.Error("[PrepareLanding] TabInfo.BuildWorldRecords: No Info");
                return;
            }

            // default line height
            const float gapLineHeight = 4f;

            // add a gap before the scroll view
            ListingStandard.Gap(gapLineHeight);

            /*
             * Calculate heights
             */

            // height of the scrollable outer Rect (visible portion of the scroll view, not the 'virtual' one)
            var maxScrollViewOuterHeight = InRect.height - ListingStandard.CurHeight - DefaultElementHeight;

            // height of the 'virtual' portion of the scroll view
            var numElements          = _gameData.WorldData.WorldCharacteristics.Count * 3; // 1 label + 2 elements  (highest + lowest) = 3
            var scrollableViewHeight = (numElements * DefaultElementHeight) + (_gameData.WorldData.WorldCharacteristics.Count * gapLineHeight);

            /*
             * Scroll view
             */
            var innerLs = ListingStandard.BeginScrollView(maxScrollViewOuterHeight, scrollableViewHeight,
                                                          ref _scrollPosWorldRecords, 16f);

            var selectedTileIndex = 0;

            foreach (var characteristicData in _gameData.WorldData.WorldCharacteristics)
            {
                var characteristicName = characteristicData.CharacteristicName;
                innerLs.Label(RichText.Bold(RichText.Color($"{characteristicName}:", Color.cyan)));

                // there might be no characteristics
                if (characteristicData.WorldTilesCharacteristics.Count == 0)
                {
                    innerLs.Label("No Info [DisableWorldData enabled]");
                    continue;
                }

                /*
                 *   lowest
                 */

                var lowestCharacteristicKvp = characteristicData.WorldTilesCharacteristics.First();

                // we need to follow user preference for temperature.
                var value = characteristicData.Characteristic == MostLeastCharacteristic.Temperature ?
                            GenTemperature.CelsiusTo(lowestCharacteristicKvp.Value, Prefs.TemperatureMode) : lowestCharacteristicKvp.Value;

                var vectorLongLat = Find.WorldGrid.LongLatOf(lowestCharacteristicKvp.Key);
                var textLowest    = $"{"PLMWINF_WorldLowest".Translate()} {characteristicName}: {value:F1} {characteristicData.CharacteristicMeasureUnit} [{lowestCharacteristicKvp.Key}; {vectorLongLat.y.ToStringLatitude()} - {vectorLongLat.x.ToStringLongitude()}]";

                var labelRect = innerLs.GetRect(DefaultElementHeight);
                var selected  = selectedTileIndex == _worldRecordSelectedTileIndex;
                if (Core.Gui.Widgets.LabelSelectable(labelRect, textLowest, ref selected, TextAnchor.MiddleLeft))
                {
                    // go to the location of the selected tile
                    _worldRecordSelectedTileIndex    = selectedTileIndex;
                    Find.WorldInterface.SelectedTile = lowestCharacteristicKvp.Key;
                    Find.WorldCameraDriver.JumpTo(Find.WorldGrid.GetTileCenter(Find.WorldInterface.SelectedTile));
                }

                selectedTileIndex++;

                /*
                 *   highest
                 */

                var highestCharacteristicKvp = characteristicData.WorldTilesCharacteristics.Last();
                // we need to follow user preference for temperature.
                value = characteristicData.Characteristic == MostLeastCharacteristic.Temperature ?
                        GenTemperature.CelsiusTo(highestCharacteristicKvp.Value, Prefs.TemperatureMode) : highestCharacteristicKvp.Value;

                vectorLongLat = Find.WorldGrid.LongLatOf(highestCharacteristicKvp.Key);
                var textHighest = $"{"PLMWINF_WorldHighest".Translate()} {characteristicName}: {value:F1} {characteristicData.CharacteristicMeasureUnit} [{highestCharacteristicKvp.Key}; {vectorLongLat.y.ToStringLatitude()} - {vectorLongLat.x.ToStringLongitude()}]";

                labelRect = innerLs.GetRect(DefaultElementHeight);
                selected  = selectedTileIndex == _worldRecordSelectedTileIndex;
                if (Core.Gui.Widgets.LabelSelectable(labelRect, textHighest, ref selected, TextAnchor.MiddleLeft))
                {
                    // go to the location of the selected tile
                    _worldRecordSelectedTileIndex    = selectedTileIndex;
                    Find.WorldInterface.SelectedTile = highestCharacteristicKvp.Key;
                    Find.WorldCameraDriver.JumpTo(Find.WorldGrid.GetTileCenter(Find.WorldInterface.SelectedTile));
                }

                selectedTileIndex++;

                // add a thin line between each label
                innerLs.GapLine(gapLineHeight);
            }

            ListingStandard.EndScrollView(innerLs);
        }
示例#11
0
        public override float           DoWindowContents(Rect rect)
        {
            #region Save State
            var originalFont = Text.Font;
            #endregion

            #region MCM Description
            var descriptionLabel  = "MountainTempMCMDescription".Translate();
            var descriptionHeight = Text.CalcHeight(descriptionLabel, rect.width);
            var descriptionRect   = new Rect(
                0,
                0,
                rect.width,
                descriptionHeight);
            DoLabel(
                descriptionRect,
                descriptionLabel
                );
            #endregion

            #region Target Label
            var targetRect = new Rect(
                0,
                descriptionRect.y + descriptionRect.height + entrySize,
                rect.width,
                entrySize);
            DoLabel(
                targetRect,
                "MountainTempMCMTarget".Translate()
                );
            #endregion

            #region Fixed Temp Radio
            var radioBool = Config.TargetMode == TemperatureMode.Fixed;
            var fixedRect = new Rect(
                0,
                targetRect.y + targetRect.height + innerPadding,
                rect.width,
                entrySize);
            DoRadio(
                fixedRect,
                ref radioBool,
                "MountainTempMCMFixed");
            if (radioBool)
            {
                Config.TargetMode = TemperatureMode.Fixed;
            }
            #endregion

            #region Fixed Temp Slider
            var sliderMin   = GenTemperature.CelsiusTo(-50f, Prefs.TemperatureMode);
            var sliderMax   = GenTemperature.CelsiusTo(50f, Prefs.TemperatureMode);
            var sliderValue = GenTemperature.CelsiusTo(Config.FixedTarget, Prefs.TemperatureMode);
            var tempRect    = new Rect(
                0,
                fixedRect.y + fixedRect.height + innerPadding,
                rect.width,
                entrySize * 2);
            DoSlider(
                tempRect,
                ref sliderValue,
                "MountainTempMCMSlider",
                sliderMin,
                sliderMax
                );
            Config.FixedTarget = GenTemperature_Extensions.CelsiusFrom(sliderValue, Prefs.TemperatureMode);
            #endregion

            #region Seasonal Temp Radio
            radioBool = Config.TargetMode == TemperatureMode.Seasonal;
            var tempStr      = Game.Mode == GameMode.MapPlaying ? string.Format("({0})", GenText.ToStringTemperature(MountainTemp.SeasonalAverage)) : "";
            var seasonalRect = new Rect(
                0,
                tempRect.y + tempRect.height + entrySize,
                rect.width,
                entrySize);
            DoRadio(
                seasonalRect,
                ref radioBool,
                "MountainTempMCMSeasonal",
                tempStr);
            if (radioBool)
            {
                Config.TargetMode = TemperatureMode.Seasonal;
            }
            #endregion

            #region Annual Temp Radio
            radioBool = Config.TargetMode == TemperatureMode.Annual;
            tempStr   = Game.Mode == GameMode.MapPlaying ? string.Format("({0})", GenText.ToStringTemperature(MountainTemp.AnnualAverage)) : "";
            var annualRect = new Rect(
                0,
                seasonalRect.y + seasonalRect.height + innerPadding,
                rect.width,
                entrySize);
            DoRadio(
                annualRect,
                ref radioBool,
                "MountainTempMCMAnnual",
                tempStr);
            if (radioBool)
            {
                Config.TargetMode = TemperatureMode.Annual;
            }
            #endregion

            #region Restore State
            Text.Font = originalFont;
            #endregion

            return(annualRect.y + annualRect.height + innerPadding);
        }