public WeatherMaps( BiomeType biome, BiomeType[][] biomeMap, ClimateType climate, ClimateType[][] climateMap, FloatRange[][] seaIceRangeMap) { XLength = biomeMap.Length; if (climateMap.Length != XLength || seaIceRangeMap.Length != XLength) { throw new ArgumentException("All X lengths must be the same"); } YLength = XLength == 0 ? 0 : biomeMap[0].Length; if (XLength != 0 && (climateMap[0].Length != YLength || seaIceRangeMap[0].Length != YLength)) { throw new ArgumentException("All Y lengths must be the same"); } Biome = biome; BiomeMap = biomeMap; Climate = climate; ClimateMap = climateMap; SeaIceRangeMap = seaIceRangeMap; }
/// <summary> /// Download the climate file based on region and climate type /// </summary> /// <param name="region">Name of region to be downloaded</param> /// <param name="climateType">Climate type that needs to be downloaded</param> /// <returns>Download status</returns> public static bool Download(Region region, ClimateType climateType) { string URL = getWebURL(region, climateType); bool isDownloaded = false; string txtData = String.Empty; try { using (var webClient = new WebClient()) { txtData = webClient.DownloadString(URL); } filename = FileDownloadHelper.getDBFileName(climateType, region); File.WriteAllText(filepath + filename, txtData); Log.Information($"{filename} got downloaded"); } catch (Exception e) { Log.Error(e, " : error"); } if (txtData != String.Empty) { isDownloaded = true; } return(isDownloaded); }
public static void spawnWater(Map map, System.Random randomGenerator) { CriticalResource water = CriticalResource.WATER; int waterHexesCount = map.hexes.Count * water.totalPercent / 100; for (int i = 0; i < waterHexesCount; i++) { int climateRoll = randomGenerator.Next(100); ClimateType randomClimate = ClimateType.TEMPERATE; if (climateRoll < water.colderClimatePercent) { randomClimate = ClimateType.COOL; } else if (climateRoll >= water.colderClimatePercent + water.averageClimatePercent) { randomClimate = ClimateType.WARM; } List <Region> climateRegions = getRegionsByClimate(map, randomClimate); Region randomRegion = climateRegions[randomGenerator.Next(climateRegions.Count)]; List <Hex> regionHexes = getRegionHexes(map, randomRegion.id); if (regionHexes.Count == 0) { continue; } List <Hex> possiblePlacementHexes = new List <Hex>(); foreach (string priorityTag in water.priorityTags) { foreach (Hex hex in regionHexes) { if (hex.hasTag(priorityTag) && !hex.hasTag(water.name)) { possiblePlacementHexes.Add(hex); } } if (possiblePlacementHexes.Count > 0) { break; } } if (possiblePlacementHexes.Count == 0) { continue; } Hex randomHex = possiblePlacementHexes[randomGenerator.Next(possiblePlacementHexes.Count)]; randomHex.addTag(water.name); randomHex.removeTag(water.adjacentHexName); List <Vector2> waterHexNeighbours = HexMathHelper.getHexNeighbours(new Vector2(randomHex.x, randomHex.y), 1); foreach (Vector2 waterHexNeighbourCoords in waterHexNeighbours) { Hex neighbourHex = getHex(waterHexNeighbourCoords.x, waterHexNeighbourCoords.y, map); if (neighbourHex != null && !neighbourHex.hasTag(water.name) && !neighbourHex.hasTag(water.adjacentHexName)) { neighbourHex.addTag(water.adjacentHexName); } } } }
/// <summary> /// Gets the part of URL based on the climate type. /// </summary> /// <param name="climateType">Enum type which contain climate tpyes are part of the project</param> /// <returns>URL part for the climate</returns> public static string getTypeURLPart(ClimateType climateType) { string climateTypeURLPart = ""; if (climateType == ClimateType.max) { climateTypeURLPart = "Tmax"; } else if (climateType == ClimateType.min) { climateTypeURLPart = "Tmin"; } else if (climateType == ClimateType.mean) { climateTypeURLPart = "Tmean"; } else if (climateType == ClimateType.rainfall) { climateTypeURLPart = "Rainfall"; } else if (climateType == ClimateType.sunshine) { climateTypeURLPart = "Sunshine"; } return(climateTypeURLPart); }
/// <summary> /// Generate URL for MetOffice data based on region and climate type. /// </summary> /// <param name="region">Name of region to be downloaded</param> /// <param name="climateType">Climate type that needs to be downloaded</param> /// <returns>URL string of the data</returns> public static string getWebURL(Region region, ClimateType climateType) { string climateTypeURL = FileDownloadHelper.getTypeURLPart(climateType); string filename = FileDownloadHelper.getSiteFileName(region); return(String.Concat(baseURL, "/" + climateTypeURL, "/date", "/" + filename)); }
public ClimateMap(ClimateType cl_type, GraphicTile.TileLandTypes baseLand, bool hasTop = false, GraphicTile.TileLandTypes secondLand = GraphicTile.TileLandTypes.ASH) { climateType = cl_type; hasTopLayer = hasTop; baseLandType = baseLand; if (hasTopLayer) { secondLandType = secondLand; } }
public static void SetClimateType(ClimateType climate, RandomMapType mapType) { switch (climate) { case ClimateType.CT_Dry: // ClearChance = 80; // PartlyCloudyChance = 10; // MostlyCloudChance = 10; // SprinkleRainChance = 0; PeEnv.SetControlRain(NO_RAIN); break; case ClimateType.CT_Temperate: // ClearChance = 60; // PartlyCloudyChance = 14; // MostlyCloudChance = 12; // SprinkleRainChance = 8; PeEnv.SetControlRain(LESS_RAIN); break; case ClimateType.CT_Wet: // ClearChance = 60; // PartlyCloudyChance = 10; // MostlyCloudChance = 5; // SprinkleRainChance = 1; PeEnv.SetControlRain(FULL_RAIN); break; case ClimateType.CT_Random: switch ((int)Time.time % 3) { case 0: SetClimateType(ClimateType.CT_Dry, mapType); break; case 1: SetClimateType(ClimateType.CT_Temperate, mapType); break; case 2: SetClimateType(ClimateType.CT_Wet, mapType); break; } return; } if (mapType == RandomMapType.Desert) { PeEnv.SetControlRain(NO_RAIN); } WeatherConfig.climate = climate; RandomMapConfig.ScenceClimate = WeatherConfig.climate; }
public string getClimateTag(ClimateType climateType) { switch (climateType) { case ClimateType.COOL: return("cool"); case ClimateType.WARM: return("warm"); case ClimateType.TEMPERATE: default: return("temperate"); } }
public Color32 getColorByClimateType(ClimateType climateType) { switch (climateType) { case ClimateType.COOL: return(Color.blue); case ClimateType.WARM: return(Color.red); case ClimateType.TEMPERATE: default: return(Color.green); } }
public static List <Region> getRegionsByClimate(Map map, ClimateType climateType) { List <Region> regionsWithClimate = new List <Region>(); foreach (Region region in map.regions) { if (region.climateType == climateType) { regionsWithClimate.Add(region); } } return(regionsWithClimate); }
// Use this for initialization void Start() { int c = Mathf.FloorToInt(Random.Range(0, 4)); // Select a random climate. selectedClimate = climates[c]; astroidCount = Random.Range(100, 500); if (Random.Range(0.0f, 1.0f) > 0.5f) { spawnAstroidBelt(astroidCount, 100, 140, gameObject.transform.position); shouldSpawnAstroids = true; } // Should we spawn an astroid belt? 50% chance. GenerateMeshL(); // Apply perlin noise to the sphere. ApplyColours(); // Give the sphere colours depending on climate. GenerateFoliage(); // Generate extras (trees, rocks, flowers, etc.) ApplyUI(); }
public static string GetClimateTypeString(ClimateType climateType) { var stringLocalizer = (IStringLocalizer <Helper>)PrismApplicationBase.Current.Container.Resolve(typeof(IStringLocalizer <Helper>)); switch (climateType) { case ClimateType.Cold: return(stringLocalizer.GetString("cold")); case ClimateType.TemperedSubtropical: return(stringLocalizer.GetString("tempered")); case ClimateType.Tropical: return(stringLocalizer.GetString("tropical")); case ClimateType.Hybrid: return(stringLocalizer.GetString("hybrid")); default: return(""); } }
public void OnSetSelection() { if (!Manager.IsAwake <GUIManager>()) { return; } switch (SubSelectionTabs.SelectedTab.ToLower()) { case "arctic": SelectedClimate = ClimateType.Arctic; break; case "temperate": default: SelectedClimate = ClimateType.Temperate; break; case "tropical coast": SelectedClimate = ClimateType.TropicalCoast; break; case "desert": SelectedClimate = ClimateType.Desert; break; case "wetlands": SelectedClimate = ClimateType.Wetland; break; case "rainforest": SelectedClimate = ClimateType.Rainforest; break; } IEnumerable <Plant> plants = Plants.Get.KnownPlants(SelectedClimate, SelectedSeasonality, SelectedAboveGround, false).AsEnumerable(); ReceiveFromParentEditor(plants); }
private void SetTerrainHeight(int terrainHeight, ClimateType scenceClimate) { if (terrainHeight < 256) { TerrainHeight = 128; VFDataRTGen.s_noiseHeight = 128; VFDataRTGen.s_seaDepth = 5; } else if (terrainHeight < 512) { TerrainHeight = 256; VFDataRTGen.s_noiseHeight = 256; VFDataRTGen.s_seaDepth = 5; } else { TerrainHeight = 512; VFDataRTGen.s_noiseHeight = 512; // if(scenceClimate==ClimateType.CT_Dry) // VFDataRTGen.s_seaDepth = 64; // else VFDataRTGen.s_seaDepth = 128; } }
/// <summary> /// Gets name of the file based on the region and climate which is stored in database. /// </summary> /// <param name="climateType">Enum type which contain climate tpyes are part of the project</param> /// <param name="region">Enum type which contain regions are part of the project</param> /// <returns>file name for the region and climate type</returns> public static string getDBFileName(ClimateType climateType, Region region) { return(getTypeURLPart(climateType) + "_" + getSiteFileName(region)); }
/// <summary> /// Gets the <see cref="BiomeType"/> associated with the given conditions. /// </summary> /// <param name="climateType">The climate type of the location.</param> /// <param name="humidityType">The humidity type of the location.</param> /// <param name="elevation">The elevation of the location above sea level.</param> /// <returns>The <see cref="BiomeType"/> associated with the given conditions.</returns> public static BiomeType GetBiomeType(ClimateType climateType, HumidityType humidityType, double elevation) { if (elevation <= 0) { return(BiomeType.Sea); } switch (climateType) { case ClimateType.Polar: return(elevation >= 0.15 ? BiomeType.Alpine : BiomeType.Polar); case ClimateType.Subpolar: return(elevation >= 0.15 ? BiomeType.Subalpine : BiomeType.Tundra); case ClimateType.Boreal: if (humidityType <= HumidityType.Arid) { return(BiomeType.LichenWoodland); } else { return(BiomeType.ConiferousForest); } case ClimateType.CoolTemperate: if (humidityType <= HumidityType.Perarid) { return(BiomeType.ColdDesert); } else if (humidityType == HumidityType.Arid) { return(BiomeType.Steppe); } else { return(BiomeType.MixedForest); } case ClimateType.WarmTemperate: if (humidityType <= HumidityType.Perarid) { return(BiomeType.HotDesert); } else if (humidityType <= HumidityType.Arid) { return(BiomeType.Shrubland); } else { return(BiomeType.DeciduousForest); } case ClimateType.Subtropical: if (humidityType <= HumidityType.Perarid) { return(BiomeType.HotDesert); } else if (humidityType == HumidityType.Arid) { return(BiomeType.Savanna); } else if (humidityType <= HumidityType.Subhumid) { return(BiomeType.MonsoonForest); } else { return(BiomeType.RainForest); } case ClimateType.Tropical: if (humidityType <= HumidityType.Perarid) { return(BiomeType.HotDesert); } else if (humidityType <= HumidityType.Semiarid) { return(BiomeType.Savanna); } else if (humidityType == HumidityType.Subhumid) { return(BiomeType.MonsoonForest); } else { return(BiomeType.RainForest); } default: return(BiomeType.HotDesert); } }
/// <summary> /// Format the weather data from text file in class object. /// </summary> /// <param name="fileName">Name of the file which needs to be formatted</param> /// <param name="ct">The climate type filter</param> /// <param name="region">The Region filter</param> /// <returns>List of data in WeatherDataEntity</returns> public static List <WeatherDataEntity> FormatWeatherData(string fileName, ClimateType ct, Region region) { IEnumerable <string> TextLines = File.ReadLines(WeatherDownload.filepath + fileName); List <WeatherDataEntity> wdeList = new List <WeatherDataEntity>(); int count = 0; foreach (var line in TextLines) { count++; if (count <= 8) { continue; } string[] lineArr = line.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries); if (Convert.ToInt32(lineArr[0]) == 2018) { WeatherDataEntity wde2018 = new WeatherDataEntity() { Year = Convert.ToInt32(lineArr[0]), January = toFloat(lineArr[1]), February = toFloat(lineArr[2]), Winter = toFloat(lineArr[3]), ClimateType = ct, Region = region, TimeStamp = DateTime.Now }; wdeList.Add(wde2018); continue; } WeatherDataEntity wde = new WeatherDataEntity() { Year = Convert.ToInt32(lineArr[0]), January = toFloat(lineArr[1]), February = toFloat(lineArr[2]), March = toFloat(lineArr[3]), April = toFloat(lineArr[4]), May = toFloat(lineArr[5]), June = toFloat(lineArr[6]), July = toFloat(lineArr[7]), August = toFloat(lineArr[8]), September = toFloat(lineArr[9]), October = toFloat(lineArr[10]), November = toFloat(lineArr[11]), December = toFloat(lineArr[12]), Winter = toFloat(lineArr[13]), Spring = toFloat(lineArr[14]), Summer = toFloat(lineArr[15]), Autumn = toFloat(lineArr[16]), Annual = toFloat(lineArr[17]), ClimateType = ct, Region = region, TimeStamp = DateTime.Now }; wdeList.Add(wde); } return(wdeList); }
public static void generateClimate(Map map, System.Random randomGenerator, MapGenerationSettings mapGenerationSettings) { ClimateType middleClimateType = ClimateType.TEMPERATE; ClimateType upperClimateType = ClimateType.COOL; ClimateType bottomClimateType = ClimateType.WARM; int minY = 100000; int maxY = -100000; foreach (Hex hex in map.hexes) { if (hex.y > maxY) { maxY = hex.y; } if (hex.y < minY) { minY = hex.y; } } int actualMapHeight = maxY - minY; int middleClimateStripeHeight = actualMapHeight * randomGenerator.Next(mapGenerationSettings.middleClimateStripeMinHeightPercent, mapGenerationSettings.middleClimateStripeMaxHeightPercent) / 100; int minMiddleClimateY = minY + (actualMapHeight - middleClimateStripeHeight) / 2; int maxMiddleClimateY = minY + (actualMapHeight + middleClimateStripeHeight) / 2; foreach (Region region in map.regions) { int topHexCount = 0; int middleHexCount = 0; int bottomHexCount = 0; List <Hex> regionHexes = getRegionHexes(map, region.id); foreach (Hex hex in regionHexes) { if (hex.y < minMiddleClimateY) { bottomHexCount++; } else if (hex.y >= minMiddleClimateY && hex.y <= maxMiddleClimateY) { middleHexCount++; } else if (hex.y > maxMiddleClimateY) { topHexCount++; } } ClimateType regionClimateType = middleClimateType; if (topHexCount >= (topHexCount + middleHexCount + bottomHexCount) * mapGenerationSettings.marginalClimateThreshold / 100) { regionClimateType = upperClimateType; } else if (bottomHexCount >= (topHexCount + middleHexCount + bottomHexCount) * mapGenerationSettings.marginalClimateThreshold / 100) { regionClimateType = bottomClimateType; } region.climateType = regionClimateType; foreach (Hex hex in regionHexes) { hex.climateType = regionClimateType; hex.addTag(getClimateTag(regionClimateType)); } } }
/// <summary> /// Initializes a new instance of <see cref="WeatherMaps"/>. /// </summary> /// <param name="planet">The planet being mapped.</param> /// <param name="elevationMap">An elevation map.</param> /// <param name="winterTemperatureMap">A winter temperature map.</param> /// <param name="summerTemperatureMap">A summer temperature map.</param> /// <param name="precipitationMap">A precipitation map.</param> /// <param name="resolution">The intended vertical resolution of the maps.</param> /// <param name="options"> /// The map projection options to use. All the map images must have been generated using /// these same options, or thew results will not be accurate. /// </param> public WeatherMaps( Planetoid planet, Image <L16> elevationMap, Image <L16> winterTemperatureMap, Image <L16> summerTemperatureMap, Image <L16> precipitationMap, int resolution, MapProjectionOptions?options = null) { var projection = options ?? MapProjectionOptions.Default; XLength = (int)Math.Floor(projection.AspectRatio * resolution); YLength = resolution; BiomeMap = new BiomeType[XLength][]; ClimateMap = new ClimateType[XLength][]; var humidityMap = new HumidityType[XLength][]; SeaIceRangeMap = new FloatRange[XLength][]; for (var x = 0; x < XLength; x++) { BiomeMap[x] = new BiomeType[YLength]; ClimateMap[x] = new ClimateType[YLength]; humidityMap[x] = new HumidityType[YLength]; SeaIceRangeMap[x] = new FloatRange[YLength]; } var scale = SurfaceMap.GetScale(resolution, projection.Range); var stretch = scale / projection.ScaleFactor; var elevationScale = SurfaceMap.GetScale(elevationMap.Height, projection.Range); var winterScale = winterTemperatureMap.Height == elevationMap.Height ? elevationScale : SurfaceMap.GetScale(winterTemperatureMap.Height, projection.Range); var summerScale = summerTemperatureMap.Height == elevationMap.Height ? elevationScale : SurfaceMap.GetScale(summerTemperatureMap.Height, projection.Range); var precipitationScale = precipitationMap.Height == elevationMap.Height ? elevationScale : SurfaceMap.GetScale(precipitationMap.Height, projection.Range); var totalElevation = 0.0; var minTemperature = 5000.0f; var maxTemperature = 0.0f; var totalTemperature = 0.0f; var totalPrecipiation = 0.0; var xToEX = new Dictionary <int, int>(); var xToWX = new Dictionary <int, int>(); var xToSX = new Dictionary <int, int>(); var xToPX = new Dictionary <int, int>(); for (var y = 0; y < YLength; y++) { var latitude = projection.EqualArea ? SurfaceMap.GetLatitudeOfCylindricalEqualAreaProjection(y, resolution, scale, projection) : SurfaceMap.GetLatitudeOfEquirectangularProjection(y, resolution, scale, projection); var elevationY = projection.EqualArea ? SurfaceMap.GetCylindricalEqualAreaYFromLatWithScale(latitude, elevationMap.Height, elevationScale, projection) : SurfaceMap.GetEquirectangularYFromLatWithScale(latitude, elevationMap.Height, elevationScale, projection); var elevationSpan = elevationMap.GetPixelRowSpan(elevationY); int winterY; if (winterTemperatureMap.Height == elevationMap.Height) { winterY = elevationY; } else if (projection.EqualArea) { winterY = SurfaceMap.GetCylindricalEqualAreaYFromLatWithScale(latitude, winterTemperatureMap.Height, winterScale, projection); } else { winterY = SurfaceMap.GetEquirectangularYFromLatWithScale(latitude, winterTemperatureMap.Height, winterScale, projection); } var winterSpan = winterTemperatureMap.GetPixelRowSpan(winterY); int summerY; if (summerTemperatureMap.Height == elevationMap.Height) { summerY = elevationY; } else if (projection.EqualArea) { summerY = SurfaceMap.GetCylindricalEqualAreaYFromLatWithScale(latitude, summerTemperatureMap.Height, summerScale, projection); } else { summerY = SurfaceMap.GetEquirectangularYFromLatWithScale(latitude, summerTemperatureMap.Height, summerScale, projection); } var summerSpan = summerTemperatureMap.GetPixelRowSpan(summerY); int precipitationY; if (precipitationMap.Height == elevationMap.Height) { precipitationY = elevationY; } else if (projection.EqualArea) { precipitationY = SurfaceMap.GetCylindricalEqualAreaYFromLatWithScale(latitude, precipitationMap.Height, precipitationScale, projection); } else { precipitationY = SurfaceMap.GetEquirectangularYFromLatWithScale(latitude, precipitationMap.Height, precipitationScale, projection); } var precipitationSpan = precipitationMap.GetPixelRowSpan(precipitationY); for (var x = 0; x < XLength; x++) { if (!xToEX.TryGetValue(x, out var elevationX)) { var longitude = projection.EqualArea ? SurfaceMap.GetLongitudeOfCylindricalEqualAreaProjection(x, XLength, scale, projection) : SurfaceMap.GetLongitudeOfEquirectangularProjection(x, XLength, stretch, projection); elevationX = projection.EqualArea ? SurfaceMap.GetCylindricalEqualAreaXFromLonWithScale(longitude, elevationMap.Width, elevationScale, projection) : SurfaceMap.GetEquirectangularXFromLonWithScale(longitude, elevationMap.Width, elevationScale, projection); int wX; if (winterTemperatureMap.Width == elevationMap.Width) { wX = elevationX; } else if (projection.EqualArea) { wX = SurfaceMap.GetCylindricalEqualAreaXFromLonWithScale(longitude, winterTemperatureMap.Width, winterScale, projection); } else { wX = SurfaceMap.GetEquirectangularXFromLonWithScale(longitude, winterTemperatureMap.Width, winterScale, projection); } int sX; if (summerTemperatureMap.Width == elevationMap.Width) { sX = elevationX; } else if (projection.EqualArea) { sX = SurfaceMap.GetCylindricalEqualAreaXFromLonWithScale(longitude, summerTemperatureMap.Width, summerScale, projection); } else { sX = SurfaceMap.GetEquirectangularXFromLonWithScale(longitude, summerTemperatureMap.Width, summerScale, projection); } int pX; if (precipitationMap.Width == elevationMap.Width) { pX = elevationX; } else if (projection.EqualArea) { pX = SurfaceMap.GetCylindricalEqualAreaXFromLonWithScale(longitude, precipitationMap.Width, precipitationScale, projection); } else { pX = SurfaceMap.GetEquirectangularXFromLonWithScale(longitude, precipitationMap.Width, precipitationScale, projection); } xToEX.Add(x, elevationX); xToWX.Add(x, wX); xToSX.Add(x, sX); xToPX.Add(x, pX); } var winterX = xToWX[x]; var summerX = xToSX[x]; var precipitationX = xToPX[x]; var normalizedElevation = elevationSpan[elevationX].GetValueFromPixel_PosNeg() - planet.NormalizedSeaLevel; totalElevation += normalizedElevation; var winterTemperature = (float)(winterSpan[winterX].GetValueFromPixel_Pos() * SurfaceMapImage.TemperatureScaleFactor); var summerTemperature = (float)(summerSpan[summerX].GetValueFromPixel_Pos() * SurfaceMapImage.TemperatureScaleFactor); minTemperature = Math.Min(minTemperature, Math.Min(winterTemperature, summerTemperature)); maxTemperature = Math.Max(maxTemperature, Math.Max(winterTemperature, summerTemperature)); totalTemperature += (minTemperature + maxTemperature) / 2; var precipValue = precipitationSpan[precipitationX].GetValueFromPixel_Pos(); var precipitation = precipValue * planet.Atmosphere.MaxPrecipitation; totalPrecipiation += precipValue; ClimateMap[x][y] = Universe.Climate.Climate.GetClimateType(new FloatRange( Math.Min(winterTemperature, summerTemperature), Math.Max(winterTemperature, summerTemperature))); humidityMap[x][y] = Universe.Climate.Climate.GetHumidityType(precipitation); BiomeMap[x][y] = Universe.Climate.Climate.GetBiomeType(ClimateMap[x][y], humidityMap[x][y], normalizedElevation); if (normalizedElevation > 0 || (summerTemperature >= Substances.All.Seawater.MeltingPoint && winterTemperature >= Substances.All.Seawater.MeltingPoint)) { continue; } if (summerTemperature < Substances.All.Seawater.MeltingPoint && winterTemperature < Substances.All.Seawater.MeltingPoint) { SeaIceRangeMap[x][y] = FloatRange.ZeroToOne; continue; } var freezeProportion = ((summerTemperature >= winterTemperature ? winterTemperature.InverseLerp(summerTemperature, (float)(Substances.All.Seawater.MeltingPoint ?? 0)) : summerTemperature.InverseLerp(winterTemperature, (float)(Substances.All.Seawater.MeltingPoint ?? 0))) * 0.8f) - 0.1f; if (freezeProportion <= 0 || float.IsNaN(freezeProportion)) { continue; } var freezeStart = 1 - (freezeProportion / 4); var iceMeltFinish = freezeProportion * 3 / 4; if (latitude < 0) { freezeStart += 0.5f; if (freezeStart > 1) { freezeStart--; } iceMeltFinish += 0.5f; if (iceMeltFinish > 1) { iceMeltFinish--; } } SeaIceRangeMap[x][y] = new FloatRange(freezeStart, iceMeltFinish); } } Climate = Universe.Climate.Climate.GetClimateType(new FloatRange(minTemperature, totalTemperature / (XLength * YLength), maxTemperature)); var humidity = Universe.Climate.Climate.GetHumidityType(totalPrecipiation / (XLength * YLength) * planet.Atmosphere.MaxPrecipitation); Biome = Universe.Climate.Climate.GetBiomeType(Climate, humidity, totalElevation / (XLength * YLength) * planet.MaxElevation); }