Ejemplo n.º 1
0
 public void ApplyInjuriesOrIllnessToTeam(Map map, List <Pawn> teamPawns)
 {
     if ((map.Biome == BiomeDefOf.TropicalRainforest) ||
         (map.Biome == BiomeDef.Named("TropicalSwamp")))
     {
         // Apply malaria/sleeping sickness to all team pawns in tropical or swamp biomes.
         HediffDef illness = null;
         if (Rand.Value < 0.5f)
         {
             illness = HediffDef.Named("SleepingSickness");
         }
         else
         {
             illness = HediffDefOf.Malaria;
         }
         foreach (Pawn pawn in teamPawns)
         {
             pawn.health.AddHediff(illness);
         }
     }
     else
     {
         // Randomly damage some pawns.
         int injuredPawnsNumber = Mathf.RoundToInt(Rand.Range(0.25f, 0.5f) * teamPawns.Count);
         injuredPawnsNumber = Mathf.Clamp(injuredPawnsNumber, 1, teamPawns.Count - 1);
         for (int pawnIndex = 0; pawnIndex < injuredPawnsNumber; pawnIndex++)
         {
             Expedition.RandomlyDamagePawn(teamPawns[pawnIndex], Rand.Range(1, 2), Rand.Range(12, 20));
         }
     }
 }
Ejemplo n.º 2
0
        private ESItem[] GetItems(ThingDef _ItemType, BiomeDef _biome)
        {
            // Variables
            ESItem[] aESI         = new ESItem[0];
            string   strThingDef  = _ItemType.defName;
            float    floBasePrice = _ItemType.BaseMarketValue;
            int      intAmount    = 0;

            switch (strThingDef)
            {
            case "HerbalMedicine":
                intAmount    = 3;
                floBasePrice = floBasePrice * GetPlantPriceInflate(_biome);
                break;

            case "Beer":
                intAmount    = 3;
                floBasePrice = floBasePrice * GetPlantPriceInflate(_biome);
                break;

            case "Ambrosia":
                intAmount    = 1;
                floBasePrice = floBasePrice * GetPlantPriceInflate(_biome);
                break;

            default:
                intAmount    = 1;
                floBasePrice = floBasePrice * GetPlantPriceInflate(_biome);
                break;
            }

            aESI = aESI.Concat(new ESItem[] { new ESItem(_ItemType.defName, intAmount, floBasePrice * intAmount) }).ToArray();

            return(aESI);
        }
Ejemplo n.º 3
0
        public static void PushState(Map map)
        {
            var world = Current.Game != null ? Current.Game.World : null;

            if (world == null)
            {
                RimRPC.prsnc.details = "Main Menu";
            }
            else
            {
                float latitude  = (map == null) ? 0f : Find.WorldGrid.LongLatOf(map.Tile).y;
                float longitude = (map == null) ? 0f : Find.WorldGrid.LongLatOf(map.Tile).x;
                colonyname     = GetColonyName();
                years          = days / 60;
                days           = GenDate.DaysPassed;
                dayhour        = GenDate.HourOfDay(Find.TickManager.TicksAbs, longitude);
                colonistnumber = (float)PawnsFinder.AllMapsCaravansAndTravelingTransportPods_Alive_FreeColonists.Count <Pawn>();
                //Season season = GenDate.Season(Find.TickManager.TicksAbs, latitude, longitude);
                //Quadrum updates seem enough.
                Quadrum quadrum = GenDate.Quadrum(Find.TickManager.TicksAbs, longitude);

                BiomeDef biome = Find.WorldGrid[map.uniqueID].biome;
                RimRPC.prsnc.state          = "Year " + years + " Day " + days + " (" + dayhour + "h) | " + quadrum;
                RimRPC.prsnc.details        = colonyname + ", " + colonistnumber + " Colonists";
                RimRPC.prsnc.largeImageText = "RimWorld";
                RimRPC.prsnc.smallImageKey  = "inmap";
                RimRPC.prsnc.smallImageText = "Playing!";
            }
            DiscordRPC.UpdatePresence(ref RimRPC.prsnc);
            //Log.Message("[RichPressence] Pushed presence update to RPC."); commented to remove log spam
        }
Ejemplo n.º 4
0
        public static float GetBiomeFishSpawnRateFactor(Map map)
        {
            float biomeFactor = 1f;

            if (map.Biome == BiomeDefOf.BorealForest)
            {
                biomeFactor = 1.2f;
            }
            else if ((map.Biome == BiomeDefOf.Tundra) ||
                     (map.Biome == BiomeDefOf.AridShrubland))
            {
                biomeFactor = 1.4f;
            }
            else if ((map.Biome == BiomeDefOf.IceSheet) ||
                     (map.Biome == BiomeDefOf.Desert))
            {
                biomeFactor = 1.6f;
            }
            else if ((map.Biome == BiomeDefOf.SeaIce) ||
                     (map.Biome == BiomeDef.Named("ExtremeDesert")))
            {
                biomeFactor = 1.8f;
            }
            return(biomeFactor);
        }
Ejemplo n.º 5
0
        public static string GetSpeciesInZoneText(BiomeDef biome, int oceanCellsCount, int riverCellsCount, int marshCellsCount)
        {
            StringBuilder speciesInZone = new StringBuilder();

            foreach (PawnKindDef_FishSpecies species in Util_FishIndustry.GetFishSpeciesList(biome))
            {
                if ((oceanCellsCount > 0) &&
                    (species.livesInOcean))
                {
                    speciesInZone.AppendWithComma(species.label);
                }
                else if ((riverCellsCount > 0) &&
                         (species.livesInRiver))
                {
                    speciesInZone.AppendWithComma(species.label);
                }
                else if ((marshCellsCount > 0) &&
                         (species.livesInMarsh))
                {
                    speciesInZone.AppendWithComma(species.label);
                }
            }
            if (speciesInZone.Length == 0)
            {
                speciesInZone.Append("none");
            }
            return(speciesInZone.ToString());
        }
 public static int RandomSettlementTileFor_WoodElves(Faction faction, bool mustBeAutoChoosable = false)
 {
     for (int i = 0; i < 500; i++)
     {
         int num;
         if ((from _ in Enumerable.Range(0, 100)
              select Rand.Range(0, Find.WorldGrid.TilesCount)).TryRandomElementByWeight(delegate(int x)
         {
             Tile tile = Find.WorldGrid[x];
             if (!tile.biome.canBuildBase || tile.hilliness == Hilliness.Impassable)
             {
                 return(0f);
             }
             if (tile.biome == BiomeDef.Named("LotRE_MallornForest"))
             {
                 return(1000f);
             }
             return(0f);     //tile.biome.settlementSelectionWeight;
         }, out num))
         {
             if (TileFinder.IsValidTileForNewSettlement(num, null))
             {
                 return(num);
             }
         }
     }
     Log.Error("Failed to find faction base tile for " + faction);
     return(0);
 }
Ejemplo n.º 7
0
        public static float GetBiomeMaxFishStockFactor(BiomeDef biome)
        {
            float biomeFactor = 1f;

            if (biome == BiomeDefOf.BorealForest)
            {
                biomeFactor = 0.8f;
            }
            else if ((biome == BiomeDefOf.Tundra) ||
                     (biome == BiomeDefOf.AridShrubland))
            {
                biomeFactor = 0.6f;
            }
            else if ((biome == BiomeDefOf.SeaIce) ||
                     (biome == BiomeDefOf.Desert))
            {
                biomeFactor = 0.4f;
            }
            else if ((biome == BiomeDefOf.IceSheet) ||
                     (biome == BiomeDef.Named("ExtremeDesert")))
            {
                biomeFactor = 0.2f;
            }
            return(biomeFactor);
        }
Ejemplo n.º 8
0
        public static bool get_LowestWildAndCavePlantOrder(BiomeDef __instance, ref float __result)
        {
            if (!cachedLowestWildPlantOrder(__instance).HasValue)
            {
                cachedLowestWildPlantOrder(__instance) = 2.14748365E+09f;
                List <ThingDef> allWildPlants = __instance.AllWildPlants;
                for (int i = 0; i < allWildPlants.Count; i++)
                {
                    ThingDef wildPlant = allWildPlants[i];
                    if (null != wildPlant)
                    {
                        cachedLowestWildPlantOrder(__instance) = Mathf.Min(cachedLowestWildPlantOrder(__instance).Value, wildPlant.plant.wildOrder);
                    }
                }

                List <ThingDef> allDefsListForReading = DefDatabase <ThingDef> .AllDefsListForReading;
                for (int j = 0; j < allDefsListForReading.Count; j++)
                {
                    if (allDefsListForReading[j].category == ThingCategory.Plant && allDefsListForReading[j].plant.cavePlant)
                    {
                        cachedLowestWildPlantOrder(__instance) = Mathf.Min(cachedLowestWildPlantOrder(__instance).Value, allDefsListForReading[j].plant.wildOrder);
                    }
                }
            }

            __result = cachedLowestWildPlantOrder(__instance).Value;
            return(false);
        }
Ejemplo n.º 9
0
        /// <summary>
        ///     Initializes the weather data from the given <see cref="ModSettingsPack" /> settings
        ///     and <see cref="WeatherDef" />, creating our settings in the process.
        /// </summary>
        /// <param name="settings">The setting pack to use</param>
        /// <param name="biome">The biome to use</param>
        /// <param name="weather">The weather to base this off of</param>
        /// <param name="visibilityFunc">Function which returns if we should display this now</param>
        public WeatherData(ModSettingsPack settings, BiomeDef biome, WeatherDef weather,
                           SettingHandle.ShouldDisplay visibilityFunc)
        {
            this.weather = weather;
            var curCommonality =
                biome.baseWeatherCommonalities.FirstOrDefault(wc => wc.weather == weather)?.commonality ?? 0f;

            // Init our settings...
            SpacerDrawer.GenerateSpacer(GenText.ToTitleCaseSmart(weather.label), settings, visibilityFunc);

            commonality = settings.GetHandle($"weather_{biome.defName}_{weather.defName}",
                                             "    " + "ColdDesertNights_BiomeWeather".Translate(),
                                             "ColdDesertNights_BiomeWeather_Desc".Translate(curCommonality), curCommonality,
                                             Validators.FloatRangeValidator(0f, float.MaxValue));

            allowRepeating = settings.GetHandle($"weather_{biome.defName}_{weather.defName}_repeating",
                                                "    " + "ColdDesertNights_BiomeWeatherRepeating".Translate(),
                                                "ColdDesertNights_BiomeWeatherRepeating_Desc".Translate(
                                                    (weather.repeatable ? "ColdDesertNights_Checked" : "ColdDesertNights_Unchecked").Translate()),
                                                weather.repeatable);

            allowEarly = settings.GetHandle($"weather_{biome.defName}_{weather.defName}_early",
                                            "    " + "ColdDesertNights_BiomeWeatherEarly".Translate(),
                                            "ColdDesertNights_BiomeWeatherEarly_Desc".Translate(
                                                (Favorability.Neutral <= weather.favorability
                        ? "ColdDesertNights_Checked"
                        : "ColdDesertNights_Unchecked").Translate()),
                                            Favorability.Neutral <= weather.favorability);

            // And set our visibility predicates...
            commonality.VisibilityPredicate
                    = allowRepeating.VisibilityPredicate
                    = allowEarly.VisibilityPredicate
                    = visibilityFunc;
        }
Ejemplo n.º 10
0
        public static bool Prefix(World __instance, ref bool __result, int tile)
        {
            BiomeDef biome = __instance.grid[tile].biome;
            // Set via modext caves
            ModExt_Biome_GenStep_BetterCaves extCaves = biome.GetModExtension <ModExt_Biome_GenStep_BetterCaves>();

            if (extCaves != null)
            {
                __result = true;
                return(false);
            }
            // Set via modext feature control
            ModExt_Biome_FeatureControl extFtControl = biome.GetModExtension <ModExt_Biome_FeatureControl>();

            if (extFtControl != null)
            {
                if (extFtControl.overwriteCaves == GenFeatureTristate.Add)
                {
                    __result = true;
                    return(false);
                }
                if (extFtControl.overwriteCaves == GenFeatureTristate.Remove)
                {
                    __result = false;
                    return(false);
                }
            }
            return(true);
        }
Ejemplo n.º 11
0
        public static ZoneType GetRandomZoneTypeExteriorZone(OG_OutpostData outpostData)
        {
            List <ZoneTypeWithWeight> exteriorZonesList = new List <ZoneTypeWithWeight>();

            if (outpostData.isMilitary)
            {
                exteriorZonesList.Add(new ZoneTypeWithWeight(ZoneType.WaterPool, 5f));
                exteriorZonesList.Add(new ZoneTypeWithWeight(ZoneType.Cemetery, 4f));
                exteriorZonesList.Add(new ZoneTypeWithWeight(ZoneType.ExteriorRecRoom, 2f));
                exteriorZonesList.Add(new ZoneTypeWithWeight(ZoneType.ShootingRange, 7f));
                exteriorZonesList.Add(new ZoneTypeWithWeight(ZoneType.MortarBay, 5f));
                exteriorZonesList.Add(new ZoneTypeWithWeight(ZoneType.Empty, 2f));
            }
            else
            {
                exteriorZonesList.Add(new ZoneTypeWithWeight(ZoneType.WaterPool, 4f));
                if ((Find.Map.Biome != BiomeDef.Named("ExtremeDesert")) &&
                    (Find.Map.Biome != BiomeDef.Named("IceSheet")))
                {
                    exteriorZonesList.Add(new ZoneTypeWithWeight(ZoneType.Farm, 5f));
                }
                exteriorZonesList.Add(new ZoneTypeWithWeight(ZoneType.Cemetery, 3f));
                exteriorZonesList.Add(new ZoneTypeWithWeight(ZoneType.ExteriorRecRoom, 5f));
                exteriorZonesList.Add(new ZoneTypeWithWeight(ZoneType.ShootingRange, 1f));
                exteriorZonesList.Add(new ZoneTypeWithWeight(ZoneType.MortarBay, 1f));
                exteriorZonesList.Add(new ZoneTypeWithWeight(ZoneType.Empty, 1f));
            }

            ZoneType exteriorZoneType = GetRandomZoneTypeByWeight(exteriorZonesList);

            return(exteriorZoneType);
        }
Ejemplo n.º 12
0
        public static bool CachePlantCommonalitiesIfShould(BiomeDef __instance)
        {
            if (cachedPlantCommonalities(__instance) != null)
            {
                return(false);
            }

            cachedPlantCommonalities(__instance) = new Dictionary <ThingDef, float>();
            for (int i = 0; i < wildPlants(__instance).Count; i++)
            {
                if (wildPlants(__instance)[i].plant != null)
                {
                    cachedPlantCommonalities(__instance)[wildPlants(__instance)[i].plant] = wildPlants(__instance)[i].commonality;
                }
            }

            foreach (ThingDef allDef in DefDatabase <ThingDef> .AllDefs)
            {
                if (allDef.plant != null && allDef.plant.wildBiomes != null)
                {
                    for (int j = 0; j < allDef.plant.wildBiomes.Count; j++)
                    {
                        if (allDef.plant.wildBiomes[j].biome == __instance)
                        {
                            cachedPlantCommonalities(__instance).Add(allDef, allDef.plant.wildBiomes[j].commonality);
                        }
                    }
                }
            }
            cachedPlantCommonalitiesSum(__instance) = cachedPlantCommonalities(__instance).Sum((KeyValuePair <ThingDef, float> x) => x.Value);
            return(false);
        }
Ejemplo n.º 13
0
        /// <summary>
        ///     Initialize weather specific settings
        /// </summary>
        /// <param name="settings">The settings instance to use</param>
        /// <param name="biome">The biome we're working with</param>
        /// <param name="key">The key to use</param>
        /// <param name="weathers">The weathers to iterate through</param>
        /// <param name="visibilityFunc">Our base visibility function</param>
        private void InitWeatherSettings(ModSettingsPack settings, BiomeDef biome, string key,
                                         List <WeatherDef> weathers,
                                         SettingHandle.ShouldDisplay visibilityFunc)
        {
            // Per-biome rain and snowfall multipliers
            foreach (var weather in weathers)
            {
                weatherCommonalities[weather] = new WeatherData(settings, biome, weather, visibilityFunc);
            }

            SpacerDrawer.GenerateSpacer("ColdDesertNights_WeatherMiscSettings".Translate(), settings, visibilityFunc);

            // If we're allowed to bypass the rain limits
            settingIgnoreRainLimit = settings.GetHandle(
                $"ignore_rain_limit_{key}",
                "    " + "ColdDesertNights_IgnoreRainLimit".Translate(),
                "ColdDesertNights_IgnoreRainLimit_Desc".Translate(), false);

            // Force weather into the given range
            minWeatherTemperature = settings.GetHandle(
                $"weather_temp_min_{key}",
                "    " + "ColdDesertNights_WeatherTempMin".Translate(),
                "ColdDesertNights_WeatherTempMin_Desc".Translate(), -999f);
            maxWeatherTemperature = settings.GetHandle(
                $"weather_temp_max_{key}",
                "    " + "ColdDesertNights_WeatherTempMax".Translate(),
                "ColdDesertNights_WeatherTempMax_Desc".Translate(), 999f);

            // Set our visibility predicates:
            settingIgnoreRainLimit.VisibilityPredicate        =
                minWeatherTemperature.VisibilityPredicate     =
                    maxWeatherTemperature.VisibilityPredicate =
                        visibilityFunc;
        }
        private static float ExpectedAnimalCount(PawnKindDef k, BiomeDef b)
        {
            float num = b.CommonalityOfAnimal(k);
            float result;

            if (num == 0f)
            {
                result = 0f;
            }
            else
            {
                float num2 = DefDatabase <PawnKindDef> .AllDefs.Sum((PawnKindDef ki) => b.CommonalityOfAnimal(ki));

                float num3             = num / num2;
                float num4             = 10000f / b.animalDensity;
                float num5             = 62500f / num4;
                float totalCommonality = DefDatabase <PawnKindDef> .AllDefs.Sum((PawnKindDef ki) => b.CommonalityOfAnimal(ki));

                float num6 = DefDatabase <PawnKindDef> .AllDefs.Sum((PawnKindDef ki) => k.ecoSystemWeight *(b.CommonalityOfAnimal(ki) / totalCommonality));

                float num7 = num5 / num6;
                float num8 = num7 * num3;
                result = num8;
            }
            return(result);
        }
Ejemplo n.º 15
0
        public static void PushState(Map map)
        {
            var world = Current.Game != null ? Current.Game.World : null;

            if (world == null)
            {
                RimRPC.prsnc.details = "Main Menu";
            }
            else
            {
                float latitude  = (map == null) ? 0f : Find.WorldGrid.LongLatOf(map.Tile).y;
                float longitude = (map == null) ? 0f : Find.WorldGrid.LongLatOf(map.Tile).x;
                colonyname     = GetColonyName();
                years          = days / 60;
                colonistnumber = (float)PawnsFinder.AllMapsCaravansAndTravelingTransportPods_Alive_FreeColonists.Count <Pawn>();
                days           = GenDate.DaysPassed;
                dayhour        = GenDate.HourOfDay(Find.TickManager.TicksAbs, longitude);
                quadrum        = GenDate.Quadrum(Find.TickManager.TicksAbs, longitude);

                BiomeDef biome = Find.WorldGrid[map.uniqueID].biome;
                RimRPC.prsnc.state          = BuildString("state");
                RimRPC.prsnc.details        = BuildString("details");
                RimRPC.prsnc.largeImageText = "RimWorld";
                RimRPC.prsnc.smallImageKey  = "inmap";
                RimRPC.prsnc.smallImageText = "Playing!";
                if (RWRPCMod.settings.RPC_Time)
                {
                    RimRPC.prsnc.startTimestamp = RimRPC.started;
                }
            }
            DiscordRPC.UpdatePresence(ref RimRPC.prsnc);
        }
        public void SpreadPurityFromPoint(int start)
        {
            HashSet <int> toConvert = new HashSet <int>();
            HashSet <int> neighbors = new HashSet <int>();

            toConvert.Add(start);

            List <int> tmpTiles = new List <int>();

            for (int i = 0; i <= 12; i++)
            {
                foreach (int t in toConvert)
                {
                    Find.WorldGrid.GetTileNeighbors(t, tmpTiles);
                    //neighbors.UnionWith(tmpTiles);
                    //neighbors.Add(tmpTiles.RandomElement());

                    neighbors.AddRange(tmpTiles.TakeRandom(2));
                }

                toConvert.UnionWith(neighbors);
            }

            foreach (int t in toConvert)
            {
                Tile tile = Find.WorldGrid[t];
                tile.biome = BiomeDef.Named(cache[t].originalBiome);
                PurifyTile(t);
            }
        }
Ejemplo n.º 17
0
        internal static float _CommonalityOfPlant(this BiomeDef _this, ThingDef plantDef)
        {
            var cachedPlantCommonalities = _this.cachedPlantCommonalities();

            if (cachedPlantCommonalities == null)
            {
                cachedPlantCommonalities = new Dictionary <ThingDef, float>();
                for (int i = 0; i < _this.wildPlants().Count; i++)
                {
                    cachedPlantCommonalities.Add(_this.wildPlants()[i].plant, _this.wildPlants()[i].commonality);
                }
                foreach (ThingDef current in DefDatabase <ThingDef> .AllDefs)
                {
                    if (current.plant != null && current.plant.wildBiomes != null)
                    {
                        for (int index = 0; index < current.plant.wildBiomes.Count; ++index)
                        {
                            if (current.plant.wildBiomes[index].biome.defName == _this.defName)
                            {
                                cachedPlantCommonalities.Add(current.plant.wildBiomes[index].plant, current.plant.wildBiomes[index].commonality);
                            }
                        }
                    }
                }
                _this.cachedPlantCommonalitiesSet(cachedPlantCommonalities);
            }
            float result;

            if (cachedPlantCommonalities.TryGetValue(plantDef, out result))
            {
                return(result);
            }
            return(0f);
        }
Ejemplo n.º 18
0
        public static void PushState(Map map)
        {
            var world = Current.Game != null ? Current.Game.World : null;

            if (world == null)
            {
                RimRPC.prsnc.details = "Main Menu";
            }
            else
            {
                float latitude  = (map == null) ? 0f : Find.WorldGrid.LongLatOf(map.Tile).y;
                float longitude = (map == null) ? 0f : Find.WorldGrid.LongLatOf(map.Tile).x;
                colonyname = GetColonyName();
                days       = GenDate.DaysPassed;
                dayhour    = GenDate.HourOfDay(Find.TickManager.TicksAbs, longitude);
                //Season season = GenDate.Season(Find.TickManager.TicksAbs, latitude, longitude);
                //Quadrum updates seem enough.
                Quadrum quadrum = GenDate.Quadrum(Find.TickManager.TicksAbs, longitude);

                BiomeDef biome = Find.WorldGrid[map.uniqueID].biome;
                RimRPC.prsnc.state          = "Day " + days + " (" + dayhour + "h) | " + quadrum;
                RimRPC.prsnc.details        = colonyname;
                RimRPC.prsnc.largeImageText = "RimWorld";
                RimRPC.prsnc.smallImageKey  = "inmap";
                RimRPC.prsnc.smallImageText = "Playing!";
            }
            DiscordRPC.UpdatePresence(ref RimRPC.prsnc);
            Log.Message("[RichPressence] Pushed presence update to RPC.");
        }
Ejemplo n.º 19
0
        internal static float _CommonalityOfAnimal(this BiomeDef _this, PawnKindDef animalDef)
        {
            var cachedAnimalCommonalities = _this.cachedAnimalCommonalities();

            if (cachedAnimalCommonalities == null)
            {
                cachedAnimalCommonalities = new Dictionary <PawnKindDef, float>();
                for (int index = 0; index < _this.wildAnimals().Count; ++index)
                {
                    cachedAnimalCommonalities.Add(_this.wildAnimals()[index].animal, _this.wildAnimals()[index].commonality);
                }
                foreach (PawnKindDef current in DefDatabase <PawnKindDef> .AllDefs)
                {
                    if (current.RaceProps.wildBiomes != null)
                    {
                        for (int index = 0; index < current.RaceProps.wildBiomes.Count; ++index)
                        {
                            if (current.RaceProps.wildBiomes[index].biome.defName == _this.defName)
                            {
                                cachedAnimalCommonalities.Add(current.RaceProps.wildBiomes[index].animal, current.RaceProps.wildBiomes[index].commonality);
                            }
                        }
                    }
                }
                _this.cachedAnimalCommonalitiesSet(cachedAnimalCommonalities);
            }
            float num;

            if (cachedAnimalCommonalities.TryGetValue(animalDef, out num))
            {
                return(num);
            }
            return(0.0f);
        }
        public static void Postfix(ref TerrainDef __result, IntVec3 c, Map map)
        {
            BiomeDef biome = map.Biome;
            // General cell terrain replcement
            ModExt_Biome_Replacement extReplacement = biome.GetModExtension <ModExt_Biome_Replacement>() ?? ModExt_Biome_Replacement.Default;

            // Replace sand (mostly from beach)
            if (__result == RimWorld.TerrainDefOf.Sand)
            {
                __result = extReplacement.sandReplacement;
            }
            // Replace gravel
            if (__result == RimWorld.TerrainDefOf.Gravel)
            {
                __result = extReplacement.gravelReplacement;
            }

            // Addtitional island terrainPatchMaker by fertility
            if (biome.HasModExtension <ModExt_Biome_GenStep_Islands>())
            {
                TerrainDef newTerrain = IslandNoises.TerrainAtFromTerrainPatchMakerByFertility(c, map, __result);
                if (newTerrain != null)
                {
                    __result = newTerrain;
                }
            }

            // Post-terrain-gen terrain replacement
            // Replace filler stone
            if (__result == TerrainDefOf.FillerStone)
            {
                __result = GenStep_RocksFromGrid.RockDefAt(c).building.naturalTerrain;
            }
        }
Ejemplo n.º 21
0
        internal static float _MTBDaysOfDisease(this BiomeDef _this, IncidentDef diseaseInc)
        {
            var cachedDiseaseCommonalities = _this.cachedDiseaseCommonalities();

            if (cachedDiseaseCommonalities == null)
            {
                cachedDiseaseCommonalities = new Dictionary <IncidentDef, float>();
                for (int i = 0; i < _this.diseases().Count; i++)
                {
                    cachedDiseaseCommonalities.Add(_this.diseases()[i].diseaseInc, _this.diseases()[i].mtbDays);
                }
                foreach (IncidentDef current in DefDatabase <IncidentDef> .AllDefs)
                {
                    if (current.diseaseBiomeRecords != null)
                    {
                        for (int index = 0; index < current.diseaseBiomeRecords.Count; ++index)
                        {
                            if (current.diseaseBiomeRecords[index].biome.defName == _this.defName)
                            {
                                cachedDiseaseCommonalities.Add(current.diseaseBiomeRecords[index].diseaseInc, current.diseaseBiomeRecords[index].mtbDays);
                            }
                        }
                    }
                }
                _this.cachedDiseaseCommonalitiesSet(cachedDiseaseCommonalities);
            }
            float result;

            if (cachedDiseaseCommonalities.TryGetValue(diseaseInc, out result))
            {
                return(result);
            }
            return(9999999f);
        }
Ejemplo n.º 22
0
        private float GetPlantPriceInflate(BiomeDef _biome)
        {
            switch (_biome.defName)
            {
            case "IceSheet":
                return(1.9f);

            case "ExtremeDesert":
                return(1.9f);

            case "SeaIce":
                return(1.9f);

            case "Desert":
                return(1.7f);

            case "Tundra":
                return(1.8f);

            case "AridShrubland":
                return(1.4f);

            case "BorealForest":
                return(1.3f);

            case "TemperateForest":
                return(1.1f);

            case "TropicalRainforest":
                return(1f);

            default:
                return(1.9f);
            }
        }
 public static void getPocketDimensionBiome(Map __instance, ref BiomeDef __result)
 {
     if (__instance.info?.parent != null && __instance.info.parent is MapParent_PocketDimension)
     {
         __result = PocketDimensionDefOf.CM_PocketDimensionBiome;
     }
 }
Ejemplo n.º 24
0
 internal static Dictionary <IncidentDef, float> cachedDiseaseCommonalities(this BiomeDef obj)
 {
     if (_cachedDiseaseCommonalities == null)
     {
         _cachedDiseaseCommonalities = typeof(BiomeDef).GetField("cachedDiseaseCommonalities", BindingFlags.Instance | BindingFlags.NonPublic);
     }
     return((Dictionary <IncidentDef, float>)_cachedDiseaseCommonalities.GetValue(obj));
 }
Ejemplo n.º 25
0
 internal static List <BiomeDiseaseRecord> diseases(this BiomeDef obj)
 {
     if (_diseases == null)
     {
         _diseases = typeof(BiomeDef).GetField("diseases", BindingFlags.Instance | BindingFlags.NonPublic);
     }
     return((List <BiomeDiseaseRecord>)_diseases.GetValue(obj));
 }
Ejemplo n.º 26
0
 internal static List <BiomePlantRecord> wildPlants(this BiomeDef obj)
 {
     if (_wildPlants == null)
     {
         _wildPlants = typeof(BiomeDef).GetField("wildPlants", BindingFlags.Instance | BindingFlags.NonPublic);
     }
     return((List <BiomePlantRecord>)_wildPlants.GetValue(obj));
 }
Ejemplo n.º 27
0
 public static List <PawnKindDef_FishSpecies> GetFishSpeciesList(BiomeDef biome)
 {
     if (fishSpeciesListDico.ContainsKey(biome) == false)
     {
         fishSpeciesListDico.Add(biome, BuildFishSpeciesListForMap(biome));
     }
     return(fishSpeciesListDico.TryGetValue(biome));
 }
Ejemplo n.º 28
0
 internal static void cachedDiseaseCommonalitiesSet(this BiomeDef obj, Dictionary <IncidentDef, float> value)
 {
     if (_cachedDiseaseCommonalities == null)
     {
         _cachedDiseaseCommonalities = typeof(BiomeDef).GetField("cachedDiseaseCommonalities", BindingFlags.Instance | BindingFlags.NonPublic);
     }
     _cachedDiseaseCommonalities.SetValue(obj, value);
 }
Ejemplo n.º 29
0
        /// <summary>
        /// Обновить указанный слой посредством дополнения (небольшая нагрузка)
        /// </summary>
        /// <param name="layer">Слой</param>
        /// <param name="material">Материал для поиска подслоя</param>
        /// <param name="subMeshes">Список подслоев</param>
        /// <param name="b">Биом</param>
        public void UpdateLayer(WorldLayer layer, Material material, List <LayerSubMesh> subMeshes, BiomeDef b)
        {
            int          subMeshIndex;
            LayerSubMesh subMesh = GetSubMesh(material, subMeshes, out subMeshIndex);

            List <int>  tileIds = new List <int>();
            List <Tile> tiles   = Find.WorldGrid.tiles.Where(tile => tile.biome == b).ToList();

            for (int i3 = 0; i3 < Find.WorldGrid.TilesCount; i3++)
            {
                Tile temp = Find.WorldGrid[i3];
                if (tiles.Contains(temp))
                {
                    tileIds.Add(i3);
                }
            }

            World          world = Find.World;
            WorldGrid      grid  = world.grid;
            List <int>     tileIDToVerts_offsets = grid.tileIDToVerts_offsets;
            List <Vector3> verts = grid.verts;

            List <List <int> > triangleIndexToTileID = new List <List <int> >();

            List <Vector3> elevationValues = new List <Vector3>();

            triangleIndexToTileID.Clear();

            subMesh.Clear(MeshParts.All);
            foreach (int tileID in tileIds)
            {
                int      colorsAndUVsIndex = 0;
                Tile     tile  = tiles[tileID];
                BiomeDef biome = tile.biome;
                while (subMeshIndex >= triangleIndexToTileID.Count)
                {
                    triangleIndexToTileID.Add(new List <int>());
                }
                int count = subMesh.verts.Count;
                int num   = 0;
                int num2  = (tileID + 1 >= tileIDToVerts_offsets.Count) ? verts.Count : tileIDToVerts_offsets[tileID + 1];
                for (int j = tileIDToVerts_offsets[tileID]; j < num2; j++)
                {
                    subMesh.verts.Add(verts[j]);
                    subMesh.uvs.Add(elevationValues[colorsAndUVsIndex]);
                    colorsAndUVsIndex++;
                    if (j < num2 - 2)
                    {
                        subMesh.tris.Add(count + num + 2);
                        subMesh.tris.Add(count + num + 1);
                        subMesh.tris.Add(count);
                        triangleIndexToTileID[subMeshIndex].Add(tileID);
                    }
                    num++;
                }
            }
            FinalizeMesh(MeshParts.All, subMesh);
        }
Ejemplo n.º 30
0
        private static void MapBiomePostfix(Map __instance, ref BiomeDef __result)
        {
            bool flag = __instance.ParentHolder is DeepRim.UndergroundMapParent;

            if (flag)
            {
                __result = DefDatabase <BiomeDef> .GetNamed("Cave", true);
            }
        }