예제 #1
0
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            Map     map = (Map)parms.target;
            IntVec3 intVec;

            if (!RCellFinder.TryFindRandomPawnEntryCell(out intVec, map, CellFinder.EdgeRoadChance_Animal, null))
            {
                return(false);
            }
            PawnKindDef pawnKindDef;

            if (!(from x in DefDatabase <PawnKindDef> .AllDefs
                  where x.RaceProps.Animal && x.RaceProps.wildness < 0.35f && map.mapTemperature.SeasonAndOutdoorTemperatureAcceptableFor(x.race)
                  select x).TryRandomElementByWeight((PawnKindDef k) => 0.420000017f - k.RaceProps.wildness, out pawnKindDef))
            {
                return(false);
            }
            int num = Mathf.Clamp(GenMath.RoundRandom(2.5f / pawnKindDef.RaceProps.baseBodySize), 2, 10);

            for (int i = 0; i < num; i++)
            {
                IntVec3 loc  = CellFinder.RandomClosewalkCellNear(intVec, map, 12, null);
                Pawn    pawn = PawnGenerator.GeneratePawn(pawnKindDef, null);
                GenSpawn.Spawn(pawn, loc, map, Rot4.Random, false);
                pawn.SetFaction(Faction.OfPlayer, null);
            }
            Find.LetterStack.ReceiveLetter("LetterLabelFarmAnimalsWanderIn".Translate(new object[]
            {
                pawnKindDef.GetLabelPlural(-1)
            }).CapitalizeFirst(), "LetterFarmAnimalsWanderIn".Translate(new object[]
            {
                pawnKindDef.GetLabelPlural(-1)
            }), LetterDefOf.PositiveEvent, new TargetInfo(intVec, map, false), null);
            return(true);
        }
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            Map     map = (Map)parms.target;
            IntVec3 intVec;

            if (!RCellFinder.TryFindRandomPawnEntryCell(out intVec, map, CellFinder.EdgeRoadChance_Animal, false, null))
            {
                return(false);
            }
            PawnKindDef pawnKindDef;

            if (!this.TryFindRandomPawnKind(map, out pawnKindDef))
            {
                return(false);
            }
            int num = Mathf.Clamp(GenMath.RoundRandom(2.5f / pawnKindDef.RaceProps.baseBodySize), 2, 10);

            for (int i = 0; i < num; i++)
            {
                IntVec3 loc  = CellFinder.RandomClosewalkCellNear(intVec, map, 12, null);
                Pawn    pawn = PawnGenerator.GeneratePawn(pawnKindDef, null);
                GenSpawn.Spawn(pawn, loc, map, Rot4.Random, WipeMode.Vanish, false);
                pawn.SetFaction(Faction.OfPlayer, null);
            }
            Find.LetterStack.ReceiveLetter("LetterLabelFarmAnimalsWanderIn".Translate(pawnKindDef.GetLabelPlural(-1)).CapitalizeFirst(), "LetterFarmAnimalsWanderIn".Translate(pawnKindDef.GetLabelPlural(-1)), LetterDefOf.PositiveEvent, new TargetInfo(intVec, map, false), null, null);
            return(true);
        }
예제 #3
0
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            Map         map         = (Map)parms.target;
            PawnKindDef alphabeaver = PawnKindDefOf.Alphabeaver;
            IntVec3     intVec;

            if (!RCellFinder.TryFindRandomPawnEntryCell(out intVec, map, CellFinder.EdgeRoadChance_Animal, false, null))
            {
                return(false);
            }
            int   freeColonistsCount = map.mapPawns.FreeColonistsCount;
            float randomInRange      = IncidentWorker_Alphabeavers.CountPerColonistRange.RandomInRange;
            float f   = (float)freeColonistsCount * randomInRange;
            int   num = Mathf.Clamp(GenMath.RoundRandom(f), 1, 10);

            for (int i = 0; i < num; i++)
            {
                IntVec3 loc      = CellFinder.RandomClosewalkCellNear(intVec, map, 10, null);
                Pawn    newThing = PawnGenerator.GeneratePawn(alphabeaver, null);
                Pawn    pawn     = (Pawn)GenSpawn.Spawn(newThing, loc, map, WipeMode.Vanish);
                pawn.needs.food.CurLevelPercentage = 1f;
            }
            Find.LetterStack.ReceiveLetter("LetterLabelBeaversArrived".Translate(), "BeaversArrived".Translate(), LetterDefOf.ThreatSmall, new TargetInfo(intVec, map, false), null, null);
            return(true);
        }
예제 #4
0
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            Map         map = (Map)parms.target;
            PawnKindDef pawnKindDef;

            if (!ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(parms.points, map.Tile, out pawnKindDef))
            {
                return(false);
            }
            IntVec3 intVec;

            if (!RCellFinder.TryFindRandomPawnEntryCell(out intVec, map, CellFinder.EdgeRoadChance_Animal, null))
            {
                return(false);
            }
            List <Pawn> list = ManhunterPackIncidentUtility.GenerateAnimals(pawnKindDef, map.Tile, parms.points * 1f);
            Rot4        rot  = Rot4.FromAngleFlat((map.Center - intVec).AngleFlat);

            for (int i = 0; i < list.Count; i++)
            {
                Pawn    pawn = list[i];
                IntVec3 loc  = CellFinder.RandomClosewalkCellNear(intVec, map, 10, null);
                GenSpawn.Spawn(pawn, loc, map, rot, WipeMode.Vanish, false);
                pawn.mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.ManhunterPermanent, null, false, false, null, false);
                pawn.mindState.exitMapAfterTick = Find.TickManager.TicksGame + Rand.Range(60000, 120000);
            }
            Find.LetterStack.ReceiveLetter("LetterLabelManhunterPackArrived".Translate(), "ManhunterPackArrived".Translate(new object[]
            {
                pawnKindDef.GetLabelPlural(-1)
            }), LetterDefOf.ThreatBig, list[0], null, null);
            Find.TickManager.slower.SignalForceNormalSpeedShort();
            LessonAutoActivator.TeachOpportunity(ConceptDefOf.ForbiddingDoors, OpportunityType.Critical);
            LessonAutoActivator.TeachOpportunity(ConceptDefOf.AllowedAreas, OpportunityType.Important);
            return(true);
        }
예제 #5
0
        private bool TryFindStartAndEndCells(Map map, out IntVec3 start, out IntVec3 end)
        {
            if (!RCellFinder.TryFindRandomPawnEntryCell(out start, map, CellFinder.EdgeRoadChance_Animal, (Predicate <IntVec3>)null))
            {
                end = IntVec3.Invalid;
                return(false);
            }
            end = IntVec3.Invalid;
            int num = 0;

            while (num < 8)
            {
                IntVec3 startLocal = start;
                IntVec3 intVec     = default(IntVec3);
                if (CellFinder.TryFindRandomEdgeCellWith((Predicate <IntVec3>)((IntVec3 x) => map.reachability.CanReach(startLocal, x, PathEndMode.OnCell, TraverseMode.NoPassClosedDoors, Danger.Deadly)), map, CellFinder.EdgeRoadChance_Ignore, out intVec))
                {
                    if (!end.IsValid || intVec.DistanceToSquared(start) > end.DistanceToSquared(start))
                    {
                        end = intVec;
                    }
                    num++;
                    continue;
                }
                break;
            }
            return(end.IsValid);
        }
예제 #6
0
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            Map         map        = (Map)parms.target;
            PawnKindDef animalKind = parms.pawnKind;

            if ((animalKind == null && !ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(parms.points, map.Tile, out animalKind)) || ManhunterPackIncidentUtility.GetAnimalsCount(animalKind, parms.points) == 0)
            {
                return(false);
            }
            IntVec3 result = parms.spawnCenter;

            if (!result.IsValid && !RCellFinder.TryFindRandomPawnEntryCell(out result, map, CellFinder.EdgeRoadChance_Animal))
            {
                return(false);
            }
            List <Pawn> list = ManhunterPackIncidentUtility.GenerateAnimals_NewTmp(animalKind, map.Tile, parms.points * 1f, parms.pawnCount);
            Rot4        rot  = Rot4.FromAngleFlat((map.Center - result).AngleFlat);

            for (int i = 0; i < list.Count; i++)
            {
                Pawn    pawn = list[i];
                IntVec3 loc  = CellFinder.RandomClosewalkCellNear(result, map, 10);
                QuestUtility.AddQuestTag(GenSpawn.Spawn(pawn, loc, map, rot), parms.questTag);
                pawn.health.AddHediff(HediffDefOf.Scaria);
                pawn.mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.ManhunterPermanent);
                pawn.mindState.exitMapAfterTick = Find.TickManager.TicksGame + Rand.Range(60000, 120000);
            }
            SendStandardLetter("LetterLabelManhunterPackArrived".Translate(), "ManhunterPackArrived".Translate(animalKind.GetLabelPlural()), LetterDefOf.ThreatBig, parms, list[0]);
            Find.TickManager.slower.SignalForceNormalSpeedShort();
            LessonAutoActivator.TeachOpportunity(ConceptDefOf.ForbiddingDoors, OpportunityType.Critical);
            LessonAutoActivator.TeachOpportunity(ConceptDefOf.AllowedAreas, OpportunityType.Important);
            return(true);
        }
        private bool TryFindStartAndEndCells(Map map, out IntVec3 start, out IntVec3 end)
        {
            bool result;

            if (!RCellFinder.TryFindRandomPawnEntryCell(out start, map, CellFinder.EdgeRoadChance_Animal, null))
            {
                end    = IntVec3.Invalid;
                result = false;
            }
            else
            {
                end = IntVec3.Invalid;
                for (int i = 0; i < 8; i++)
                {
                    IntVec3 startLocal = start;
                    IntVec3 intVec;
                    if (!CellFinder.TryFindRandomEdgeCellWith((IntVec3 x) => map.reachability.CanReach(startLocal, x, PathEndMode.OnCell, TraverseMode.NoPassClosedDoors, Danger.Deadly), map, CellFinder.EdgeRoadChance_Ignore, out intVec))
                    {
                        break;
                    }
                    if (!end.IsValid || intVec.DistanceToSquared(start) > end.DistanceToSquared(start))
                    {
                        end = intVec;
                    }
                }
                result = end.IsValid;
            }
            return(result);
        }
예제 #8
0
        public static bool TryFindBestExitSpot(Pawn pawn, out IntVec3 spot, TraverseMode mode = TraverseMode.ByPawn)
        {
            if (mode == TraverseMode.PassAllDestroyableThings && !pawn.Map.reachability.CanReachMapEdge(pawn.Position, TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, true)))
            {
                return(RCellFinder.TryFindRandomPawnEntryCell(out spot, pawn.Map, 0f, true, delegate(IntVec3 x)
                {
                    Pawn pawn2 = pawn;
                    LocalTargetInfo dest = x;
                    PathEndMode peMode = PathEndMode.OnCell;
                    Danger maxDanger = Danger.Deadly;
                    TraverseMode mode2 = mode;
                    return pawn2.CanReach(dest, peMode, maxDanger, false, mode2);
                }));
            }
            int     num  = 0;
            int     num2 = 0;
            IntVec3 intVec2;

            while (true)
            {
                num2++;
                if (num2 > 30)
                {
                    break;
                }
                IntVec3 intVec;
                bool    flag = CellFinder.TryFindRandomCellNear(pawn.Position, pawn.Map, num, null, out intVec, -1);
                num += 4;
                if (flag)
                {
                    int num3 = intVec.x;
                    intVec2 = new IntVec3(0, 0, intVec.z);
                    if (pawn.Map.Size.z - intVec.z < num3)
                    {
                        num3    = pawn.Map.Size.z - intVec.z;
                        intVec2 = new IntVec3(intVec.x, 0, pawn.Map.Size.z - 1);
                    }
                    if (pawn.Map.Size.x - intVec.x < num3)
                    {
                        num3    = pawn.Map.Size.x - intVec.x;
                        intVec2 = new IntVec3(pawn.Map.Size.x - 1, 0, intVec.z);
                    }
                    if (intVec.z < num3)
                    {
                        intVec2 = new IntVec3(intVec.x, 0, 0);
                    }
                    if (intVec2.Standable(pawn.Map) && pawn.CanReach(intVec2, PathEndMode.OnCell, Danger.Deadly, true, mode))
                    {
                        goto Block_9;
                    }
                }
            }
            spot = pawn.Position;
            return(false);

Block_9:
            spot = intVec2;
            return(true);
        }
예제 #9
0
        protected override bool CanFireNowSub(IncidentParms parms)
        {
            if (!base.CanFireNowSub(parms))
            {
                return(false);
            }
            Map     map = (Map)parms.target;
            IntVec3 intVec;

            return(RCellFinder.TryFindRandomPawnEntryCell(out intVec, map, CellFinder.EdgeRoadChance_Animal, false, null));
        }
        public override bool TryResolveRaidSpawnCenter(IncidentParms parms)
        {
            Map map = (Map)parms.target;

            if (!parms.spawnCenter.IsValid && !RCellFinder.TryFindRandomPawnEntryCell(out parms.spawnCenter, map, CellFinder.EdgeRoadChance_Hostile, null))
            {
                return(false);
            }
            parms.spawnRotation = Rot4.FromAngleFlat((map.Center - parms.spawnCenter).AngleFlat);
            return(true);
        }
예제 #11
0
        protected override bool CanFireNowSub(IncidentParms parms)
        {
            if (!base.CanFireNowSub(parms))
            {
                return(false);
            }
            Map         map = (Map)parms.target;
            IntVec3     result;
            PawnKindDef kind;

            return(RCellFinder.TryFindRandomPawnEntryCell(out result, map, CellFinder.EdgeRoadChance_Animal) && TryFindRandomPawnKind(map, out kind));
        }
예제 #12
0
        protected virtual bool TryResolveParmsGeneral(IncidentParms parms)
        {
            Map map = (Map)parms.target;

            if (!parms.spawnCenter.IsValid && !RCellFinder.TryFindRandomPawnEntryCell(out parms.spawnCenter, map, CellFinder.EdgeRoadChance_Neutral))
            {
                return(false);
            }
            if (parms.faction == null && !CandidateFactions(map).TryRandomElement(out parms.faction) && !CandidateFactions(map, desperate: true).TryRandomElement(out parms.faction))
            {
                return(false);
            }
            return(true);
        }
예제 #13
0
        protected override bool CanFireNowSub(IncidentParms parms)
        {
            if (!base.CanFireNowSub(parms))
            {
                return(false);
            }
            Map     map = (Map)parms.target;
            IntVec3 result;

            if (ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(parms.points, map.Tile, out var _))
            {
                return(RCellFinder.TryFindRandomPawnEntryCell(out result, map, CellFinder.EdgeRoadChance_Animal));
            }
            return(false);
        }
        protected override bool CanFireNowSub(IncidentParms parms)
        {
            bool result;

            if (!base.CanFireNowSub(parms))
            {
                result = false;
            }
            else
            {
                Map     map = (Map)parms.target;
                IntVec3 intVec;
                result = RCellFinder.TryFindRandomPawnEntryCell(out intVec, map, CellFinder.EdgeRoadChance_Animal, null);
            }
            return(result);
        }
예제 #15
0
 public void WildAnimalSpawnerTick()
 {
     if (Find.TickManager.TicksGame % 1210 == 0)
     {
         if (!this.AnimalEcosystemFull)
         {
             if (Rand.Value < 0.0268888883f * this.DesiredAnimalDensity)
             {
                 IntVec3 loc;
                 if (RCellFinder.TryFindRandomPawnEntryCell(out loc, this.map, CellFinder.EdgeRoadChance_Animal, null))
                 {
                     this.SpawnRandomWildAnimalAt(loc);
                 }
             }
         }
     }
 }
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            Map     map = (Map)parms.target;
            IntVec3 intVec;

            if (!RCellFinder.TryFindRandomPawnEntryCell(out intVec, map, CellFinder.EdgeRoadChance_Animal + 0.2f, null))
            {
                return(false);
            }
            PawnKindDef thrumbo = PawnKindDefOf.Thrumbo;
            float       points  = StorytellerUtility.DefaultParmsNow(Find.Storyteller.def, IncidentCategory.ThreatBig, map).points;
            int         num     = GenMath.RoundRandom(points / thrumbo.combatPower);
            int         max     = Rand.RangeInclusive(2, 4);

            num = Mathf.Clamp(num, 1, max);
            int     num2    = Rand.RangeInclusive(90000, 150000);
            IntVec3 invalid = IntVec3.Invalid;

            if (!RCellFinder.TryFindRandomCellOutsideColonyNearTheCenterOfTheMap(intVec, map, 10f, out invalid))
            {
                invalid = IntVec3.Invalid;
            }
            Pawn pawn = null;

            for (int i = 0; i < num; i++)
            {
                IntVec3 loc = CellFinder.RandomClosewalkCellNear(intVec, map, 10, null);
                pawn = PawnGenerator.GeneratePawn(thrumbo, null);
                GenSpawn.Spawn(pawn, loc, map, Rot4.Random, false);
                pawn.mindState.exitMapAfterTick = Find.TickManager.TicksGame + num2;
                if (invalid.IsValid)
                {
                    pawn.mindState.forcedGotoPosition = CellFinder.RandomClosewalkCellNear(invalid, map, 10, null);
                }
            }
            Find.LetterStack.ReceiveLetter("LetterLabelThrumboPasses".Translate(new object[]
            {
                thrumbo.label
            }).CapitalizeFirst(), "LetterThrumboPasses".Translate(new object[]
            {
                thrumbo.label
            }), LetterDefOf.PositiveEvent, pawn, null);
            return(true);
        }
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            Map         map         = (Map)parms.target;
            PawnKindDef alphabeaver = PawnKindDefOf.Alphabeaver;
            IntVec3     intVec;

            if (!RCellFinder.TryFindRandomPawnEntryCell(out intVec, map, CellFinder.EdgeRoadChance_Animal, null))
            {
                return(false);
            }
            int num = Rand.RangeInclusive(6, 12);

            for (int i = 0; i < num; i++)
            {
                IntVec3 loc      = CellFinder.RandomClosewalkCellNear(intVec, map, 10, null);
                Pawn    newThing = PawnGenerator.GeneratePawn(alphabeaver, null);
                GenSpawn.Spawn(newThing, loc, map);
            }
            Find.LetterStack.ReceiveLetter("LetterLabelBeaversArrived".Translate(), "BeaversArrived".Translate(), LetterDefOf.ThreatSmall, new TargetInfo(intVec, map, false), null);
            return(true);
        }
예제 #18
0
        protected virtual bool ResolveRaidSpawnCenter(IncidentParms parms)
        {
            Map map = (Map)parms.target;

            if (parms.spawnCenter.IsValid)
            {
                return(true);
            }
            if (parms.raidArrivalMode == PawnsArriveMode.CenterDrop || parms.raidArrivalMode == PawnsArriveMode.EdgeDrop)
            {
                if (parms.raidArrivalMode == PawnsArriveMode.CenterDrop)
                {
                    parms.raidPodOpenDelay = 520;
                    parms.spawnRotation    = Rot4.Random;
                    if (Rand.Value < 0.40000000596046448 && map.listerBuildings.ColonistsHaveBuildingWithPowerOn(ThingDefOf.OrbitalTradeBeacon))
                    {
                        parms.spawnCenter = DropCellFinder.TradeDropSpot(map);
                    }
                    else if (!DropCellFinder.TryFindRaidDropCenterClose(out parms.spawnCenter, map))
                    {
                        parms.raidArrivalMode = PawnsArriveMode.EdgeDrop;
                    }
                }
                if (parms.raidArrivalMode == PawnsArriveMode.EdgeDrop)
                {
                    parms.raidPodOpenDelay = 140;
                    parms.spawnCenter      = DropCellFinder.FindRaidDropCenterDistant(map);
                    parms.spawnRotation    = Rot4.Random;
                }
            }
            else
            {
                if (!RCellFinder.TryFindRandomPawnEntryCell(out parms.spawnCenter, map, CellFinder.EdgeRoadChance_Hostile, (Predicate <IntVec3>)null))
                {
                    return(false);
                }
                parms.spawnRotation = Rot4.FromAngleFlat((map.Center - parms.spawnCenter).AngleFlat);
            }
            return(true);
        }
        private static IntVec3 FindNewMapEdgeGroupCenter(Map map, List <Pair <List <Pawn>, IntVec3> > groups, bool arriveInPods)
        {
            IntVec3 result = IntVec3.Invalid;
            float   num    = 0f;

            for (int i = 0; i < 4; i++)
            {
                IntVec3 intVec;
                if (arriveInPods)
                {
                    intVec = DropCellFinder.FindRaidDropCenterDistant(map);
                }
                else if (!RCellFinder.TryFindRandomPawnEntryCell(out intVec, map, CellFinder.EdgeRoadChance_Hostile, null))
                {
                    intVec = DropCellFinder.FindRaidDropCenterDistant(map);
                }
                if (!groups.Any <Pair <List <Pawn>, IntVec3> >())
                {
                    result = intVec;
                    break;
                }
                float num2 = float.MaxValue;
                for (int j = 0; j < groups.Count; j++)
                {
                    float num3 = (float)intVec.DistanceToSquared(groups[j].Second);
                    if (num3 < num2)
                    {
                        num2 = num3;
                    }
                }
                if (!result.IsValid || num2 > num)
                {
                    num    = num2;
                    result = intVec;
                }
            }
            return(result);
        }
 private bool TryFindEntryCell(Map map, out IntVec3 cell)
 {
     return(RCellFinder.TryFindRandomPawnEntryCell(out cell, map, CellFinder.EdgeRoadChance_Animal + 0.2f, null));
 }
예제 #21
0
        public void WildSpawnerTick()
        {
            IntVec3 loc;

            if (Find.TickManager.TicksGame % 1210 == 0 && !this.AnimalEcosystemFull && Rand.Value < 0.0268888883f * this.DesiredAnimalDensity && RCellFinder.TryFindRandomPawnEntryCell(out loc, this.map, CellFinder.EdgeRoadChance_Animal, null))
            {
                this.SpawnRandomWildAnimalAt(loc);
            }
            float num = this.map.gameConditionManager.AggregatePlantDensityFactor();

            if (num > 0.0001f)
            {
                int   num2 = this.map.Size.x * 2 + this.map.Size.z * 2;
                float num3 = 650f / ((float)num2 / 100f);
                int   num4 = (int)(num3 / num);
                if (num4 <= 0 || Find.TickManager.TicksGame % num4 == 0)
                {
                    this.TrySpawnPlantFromMapEdge();
                }
            }
            int num5 = (int)(3600000f / ((float)this.map.Area / 10000f));

            if (num5 <= 0 || Find.TickManager.TicksGame % num5 == 0)
            {
                this.TrySpawnCavePlant();
            }
        }
예제 #22
0
        protected virtual bool TryResolveParmsGeneral(IncidentParms parms)
        {
            Map map = (Map)parms.target;

            return((parms.spawnCenter.IsValid || RCellFinder.TryFindRandomPawnEntryCell(out parms.spawnCenter, map, CellFinder.EdgeRoadChance_Neutral, null)) && (parms.faction != null || base.CandidateFactions(map, false).TryRandomElement(out parms.faction) || base.CandidateFactions(map, true).TryRandomElement(out parms.faction)));
        }
예제 #23
0
        protected override bool CanFireNowSub(IncidentParms parms)
        {
            if (!base.CanFireNowSub(parms))
            {
                return(false);
            }
            Map         map = (Map)parms.target;
            PawnKindDef pawnKindDef;
            IntVec3     intVec;

            return(ManhunterPackIncidentUtility.TryFindManhunterAnimalKind(parms.points, map.Tile, out pawnKindDef) && RCellFinder.TryFindRandomPawnEntryCell(out intVec, map, CellFinder.EdgeRoadChance_Animal, null));
        }
예제 #24
0
        public void WildSpawnerTick()
        {
            IntVec3 loc = default(IntVec3);

            if (Find.TickManager.TicksGame % 1210 == 0 && !this.AnimalEcosystemFull && Rand.Value < 0.026888888329267502 * this.DesiredAnimalDensity && RCellFinder.TryFindRandomPawnEntryCell(out loc, this.map, CellFinder.EdgeRoadChance_Animal, (Predicate <IntVec3>)null))
            {
                this.SpawnRandomWildAnimalAt(loc);
            }
            float num = this.map.gameConditionManager.AggregatePlantDensityFactor();

            if (num > 9.9999997473787516E-05)
            {
                IntVec3 size  = this.map.Size;
                int     num2  = size.x * 2;
                IntVec3 size2 = this.map.Size;
                int     num3  = num2 + size2.z * 2;
                float   num4  = (float)(650.0 / ((float)num3 / 100.0));
                int     num5  = (int)(num4 / num);
                if (num5 <= 0 || Find.TickManager.TicksGame % num5 == 0)
                {
                    this.TrySpawnPlantFromMapEdge();
                }
            }
            int num6 = (int)(3600000.0 / ((float)this.map.Area / 10000.0));

            if (num6 > 0 && Find.TickManager.TicksGame % num6 != 0)
            {
                return;
            }
            this.TrySpawnCavePlant();
        }
예제 #25
0
        public void WildAnimalSpawnerTick()
        {
            IntVec3 loc;

            if (Find.TickManager.TicksGame % 1213 == 0 && !this.AnimalEcosystemFull && Rand.Chance(0.0269555561f * this.DesiredAnimalDensity) && RCellFinder.TryFindRandomPawnEntryCell(out loc, this.map, CellFinder.EdgeRoadChance_Animal, true, null))
            {
                this.SpawnRandomWildAnimalAt(loc);
            }
        }