// Token: 0x06001042 RID: 4162 RVA: 0x0007BEDC File Offset: 0x0007A2DC
        public override void Generate(Map map, GenStepParams parms)
        {
            List <Pawn> list = new List <Pawn>();

            foreach (Pawn pawn in map.mapPawns.AllPawns)
            {
                if (!pawn.NonHumanlikeOrWildMan())
                {
                    list.Add(pawn);
                }
            }
            foreach (Pawn pawn in list)
            {
                //pawn.Kill(new DamageInfo(DamageDefOf.Bite, 7000));
                Thing zombie = GenSpawn.Spawn(ZombiefiedMod.GenerateZombieFromSource(pawn), pawn.Position, map, pawn.Rotation);
                pawn.Destroy();
                //ZombiefiedMod.ReanimateDeath(pawn.Corpse);
            }
        }
        protected override Job TryGiveJob(Pawn pawn)
        {
            if (!(pawn is Pawn_Zombiefied))
            {
                return(null);
            }
            bool nextMoveOrderIsWait = pawn.mindState.nextMoveOrderIsWait;

            pawn.mindState.nextMoveOrderIsWait = !pawn.mindState.nextMoveOrderIsWait;
            if (nextMoveOrderIsWait)
            {
                //pawn.mindState.canFleeIndividual = false;
                return(new Job(JobDefOf.Wait)
                {
                    expiryInterval = 33
                });
            }

            if (!((Pawn_Zombiefied)pawn).attracted)
            {
                IntVec3 thing2 = ZombiefiedMod.BestNoisyLocation(pawn);
                if (thing2 != IntVec3.Invalid)
                {
                    ((Pawn_Zombiefied)pawn).attracted = true;

                    bool found = false;
                    using (PawnPath pawnPath = pawn.Map.pathFinder.FindPath(pawn.Position, thing2, TraverseParms.For(pawn, Danger.Deadly, TraverseMode.PassDoors, false), PathEndMode.OnCell))
                    {
                        if (pawnPath.Found)
                        {
                            found = true;
                            IntVec3 loc;
                            IntVec3 randomCell;

                            int iNodesReversed = 0;

                            if (pawnPath.TryFindLastCellBeforeBlockingDoor(pawn, out loc))
                            {
                                for (int i = 0; i < pawnPath.NodesReversed.Count; i++)
                                {
                                    if (pawnPath.NodesReversed[i].Equals(loc))
                                    {
                                        iNodesReversed = i;
                                    }
                                }
                            }

                            int wanderLength = Rand.RangeSeeded(10, 17, Find.TickManager.TicksAbs + pawn.thingIDNumber);
                            if (pawnPath.NodesReversed.Count - iNodesReversed > wanderLength)
                            {
                                randomCell = pawnPath.NodesReversed[pawnPath.NodesReversed.Count - wanderLength];


                                return(new Job(ZombiefiedMod.zombieMove, randomCell)
                                {
                                    //expiryInterval = 777
                                });
                            }
                        }
                    }
                    if (!found)
                    {
                        using (PawnPath pawnPath = pawn.Map.pathFinder.FindPath(pawn.Position, thing2, TraverseParms.For(pawn, Danger.Deadly, TraverseMode.PassAllDestroyableThings, false), PathEndMode.OnCell))
                        {
                            if (pawnPath.Found)
                            {
                                found = true;
                                IntVec3 loc;
                                IntVec3 randomCell;

                                int iNodesReversed = 0;

                                if (pawnPath.TryFindLastCellBeforeBlockingDoor(pawn, out loc))
                                {
                                    for (int i = 0; i < pawnPath.NodesReversed.Count; i++)
                                    {
                                        if (pawnPath.NodesReversed[i].Equals(loc))
                                        {
                                            iNodesReversed = i;
                                        }
                                    }
                                }

                                int wanderLength = Rand.RangeSeeded(10, 17, Find.TickManager.TicksAbs + pawn.thingIDNumber);
                                if (pawnPath.NodesReversed.Count - iNodesReversed > wanderLength)
                                {
                                    randomCell = pawnPath.NodesReversed[pawnPath.NodesReversed.Count - wanderLength];

                                    ((Pawn_Zombiefied)pawn).attracted = true;
                                    return(new Job(ZombiefiedMod.zombieMove, randomCell)
                                    {
                                        //expiryInterval = 777
                                    });
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                ((Pawn_Zombiefied)pawn).attracted = false;
                IntVec3 exactWanderDestAttracted = RCellFinder.RandomWanderDestFor(pawn, pawn.Position, 4, this.wanderDestValidator, Danger.Deadly);
                if (exactWanderDestAttracted.IsValid)
                {
                    Job jobAttracted = new Job(ZombiefiedMod.zombieMove, exactWanderDestAttracted);
                    //pawn.Map.pawnDestinationReservationManager.Reserve(pawn, jobAttracted, exactWanderDestAttracted);
                    jobAttracted.locomotionUrgency = this.locomotionUrgency;
                    return(jobAttracted);
                }
            }

            if (!((Pawn_Zombiefied)pawn).fired)
            {
                if (!pawn.IsBurning() && pawn.Map.weatherManager.RainRate < 0.1f)
                {
                    foreach (Thing thing in pawn.Position.GetRegion(pawn.Map, RegionType.Set_Passable).ListerThings.AllThings)
                    {
                        //if (vec.ContainsStaticFire(pawn.Map))
                        if (thing is Fire && ((Fire)thing).fireSize > 1.37f && (pawn.Position - thing.Position).LengthHorizontal < 3.1f)
                        {
                            ((Pawn_Zombiefied)pawn).fired = true;
                            return(new Job(ZombiefiedMod.zombieMove, thing.Position));
                        }
                    }
                }
            }
            else
            {
                pawn.TryAttachFire(0.37f);
                ((Pawn_Zombiefied)pawn).fired = false;
            }

            IntVec3 exactWanderDest = this.GetExactWanderDest(pawn);

            if (!exactWanderDest.IsValid)
            {
                pawn.mindState.nextMoveOrderIsWait = false;
                return(null);
            }
            Job job = new Job(ZombiefiedMod.zombieMove, exactWanderDest);

            //pawn.Map.pawnDestinationReservationManager.Reserve(pawn, job, exactWanderDest);
            job.locomotionUrgency = this.locomotionUrgency;
            return(job);
        }
Beispiel #3
0
        // Token: 0x06000D17 RID: 3351 RVA: 0x00061114 File Offset: 0x0005F514
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            Map map = (Map)parms.target;

            ResolveRaidPoints(parms);

            if (!TryResolveRaidFaction(parms))
            {
                return(false);
            }

            IntVec3 intVec;

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

            PawnGroupKindDef    combat = PawnGroupKindDefOf.Combat;
            PawnGroupMakerParms defaultPawnGroupMakerParms = IncidentParmsUtility.GetDefaultPawnGroupMakerParms(combat, parms, false);

            List <Pawn> list = PawnGroupMakerUtility.GeneratePawns(defaultPawnGroupMakerParms, true).ToList <Pawn>();

            if (list.Count < 1)
            {
                Log.Error("Got no pawns spawning raid from parms " + parms, false);
                return(false);
            }
            else
            {
                for (int i = 0; i < list.Count; i++)
                {
                    Pawn pawn = list[i];
                    list[i] = ZombiefiedMod.GenerateZombieFromSource(list[i]);
                    pawn.Destroy(DestroyMode.Vanish);
                }
            }

            Rot4 rot = Rot4.FromAngleFlat((map.Center - intVec).AngleFlat);

            Faction zFaction = Faction.OfInsects;

            foreach (Faction faction in Find.FactionManager.AllFactionsListForReading)
            {
                if (faction.def.defName == "Zombie")
                {
                    zFaction = faction;
                }
            }

            for (int i = 0; i < list.Count; i++)
            {
                Pawn    pawn = list[i];
                IntVec3 loc  = CellFinder.RandomClosewalkCellNear(intVec, map, 10, null);
                pawn.SetFactionDirect(zFaction);
                pawn.apparel.DestroyAll();
                Pawn_Zombiefied zomb = (Pawn_Zombiefied)GenSpawn.Spawn(pawn, loc, map, rot);
                if (zomb != null)
                {
                    zomb.FixZombie();
                }
            }

            if (ZombiefiedMod.zombieRaidNotifications)
            {
                Find.LetterStack.ReceiveLetter("Zombies", "Some zombies walked into your territory. You might want to deal with them before they deal with you."
                                               , LetterDefOf.NeutralEvent, list[0], null);
                Find.TickManager.slower.SignalForceNormalSpeedShort();
            }
            LessonAutoActivator.TeachOpportunity(ConceptDefOf.ForbiddingDoors, OpportunityType.Critical);
            LessonAutoActivator.TeachOpportunity(ConceptDefOf.AllowedAreas, OpportunityType.Important);
            return(true);
        }