static bool Prefix(ref Thing thing, ref StatDef stat, ref float __result)
        {
            Pawn_Zombiefied zomb = thing as Pawn_Zombiefied;

            if (zomb != null)
            {
                if (stat.defName.Equals("ArmorRating_Sharp"))
                {
                    if (zomb.armorRating_Sharp > 0f)
                    {
                        __result = zomb.armorRating_Sharp;
                        return(false);
                    }
                }

                if (stat.defName.Equals("ArmorRating_Blunt"))
                {
                    if (zomb.armorRating_Blunt > 0f)
                    {
                        __result = zomb.armorRating_Blunt;
                        return(false);
                    }
                }

                if (stat.defName.Equals("ArmorRating_Heat"))
                {
                    if (zomb.armorRating_Heat > 0f)
                    {
                        __result = zomb.armorRating_Heat;
                        return(false);
                    }
                }
            }
            return(true);
        }
Example #2
0
        public bool IsAcceptablePreyFor(Pawn predator, Pawn prey, float distance)
        {
            Pawn_Zombiefied preyZ = prey as Pawn_Zombiefied;

            if (preyZ != null)
            {
                return(false);
            }
            if (ZombiefiedMod.disableZombiesAttackingAnimals && !prey.RaceProps.Humanlike)
            {
                return(false);
            }
            if (!prey.RaceProps.IsFlesh)
            {
                return(false);
            }
            float lengthHorizontal = -GetPreyScoreFor(predator, prey);

            if (lengthHorizontal > distance)
            {
                return(false);
            }

            return(true);
        }
Example #3
0
        public override void DrawAt(Vector3 drawLoc, bool flip = false)
        {
            Building building = this.StoringThing() as Building;

            if (building != null && building.def == ThingDefOf.Grave)
            {
                return;
            }

            Pawn_Zombiefied pawnZ = InnerPawn as Pawn_Zombiefied;

            if (pawnZ != null)
            {
                if (pawnZ.def.defName != "Zombie")
                {
                    base.DrawAt(drawLoc, flip);
                }
                else if (pawnZ.drawerZ != null)
                {
                    pawnZ.drawerZ.renderer.RenderPawnAt(drawLoc);
                }
                else
                {
                    pawnZ.newGraphics();
                }
            }
            else
            {
                base.DrawAt(drawLoc, flip);
            }
        }
        private Pawn BestPawnToWander(Pawn_Zombiefied pawn)
        {
            if (pawn.Map == null)
            {
                return(null);
            }

            List <Pawn> allPawnsSpawned = pawn.Map.mapPawns.AllPawnsSpawned;
            //List<Thing> allThingsRegion = pawn.GetRegion().ListerThings.AllThings;

            Pawn  pawnToReturn = null;
            float num          = 0f;

            pawn.distanceToEdge = pawn.Position.DistanceToEdge(pawn.Map);
            bool closeToEdge = pawn.distanceToEdge < Rand.RangeSeeded(17, 57, Find.TickManager.TicksAbs + pawn.thingIDNumber);

            for (int i = 0; i < allPawnsSpawned.Count; i++)
            //for (int i = 0; i < allThingsRegion.Count; i++)
            {
                Pawn_Zombiefied pawn2 = allPawnsSpawned[i] as Pawn_Zombiefied;
                if (pawn2 != null && pawn != pawn2)
                {
                    float score = GetPreyScoreFor(pawn, pawn2);
                    if (score > -37f)
                    {
                        if (pawn2.CurJob != null && pawn2.CurJob.def.Equals(ZombiefiedMod.zombieHunt))
                        {
                            score       += 27f;
                            pawn.hunting = true;
                        }
                        if (pawn2.hunting)
                        {
                            score += 23f;
                        }
                        if (closeToEdge && pawn.distanceToEdge < pawn2.distanceToEdge)
                        {
                            score += 3f;
                        }
                        if (Rand.RangeSeeded(0f, 1f, Find.TickManager.TicksAbs + pawn2.thingIDNumber) > 0.5f)
                        {
                            score += 7f;
                        }
                        float lengthHorizontal = (pawn.Position - pawn2.Position).LengthHorizontal;
                        score -= lengthHorizontal;

                        if (pawnToReturn == null || score > num)
                        {
                            pawnToReturn = pawn2;
                            num          = score;
                        }
                    }
                }
            }

            return(pawnToReturn);
        }
Example #5
0
        // Token: 0x06000D17 RID: 3351 RVA: 0x00061114 File Offset: 0x0005F514
        protected override bool TryExecuteWorker(IncidentParms parms)
        {
            Faction zFaction = Faction.OfInsects;

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

            ResolveRaidPoints(parms);

            Map         map = (Map)parms.target;
            PawnKindDef pawnKindDef;

            if (!TryFindAnimalKind(parms.points, map.Tile, out pawnKindDef))
            {
                return(false);
            }

            IntVec3 intVec;

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

            //List<Pawn> list = ManhunterPackIncidentUtility.GenerateAnimals(pawnKindDef, map.Tile, parms.points);
            Rot4 rot = Rot4.FromAngleFlat((map.Center - intVec).AngleFlat);

            Pawn reference = null;

            int num = (int)(parms.points / 100f);

            if (num < 2)
            {
                num = 2;
            }
            for (int i = 0; i < num; i++)
            {
                TryFindAnimalKind(parms.points, map.Tile, out pawnKindDef);

                Pawn    pawn = PawnGenerator.GeneratePawn(pawnKindDef, zFaction);
                IntVec3 loc  = CellFinder.RandomClosewalkCellNear(intVec, map, 10, null);
                pawn.apparel.DestroyAll();
                //pawn.SetFactionDirect(zFaction);

                Pawn_Zombiefied zomb = (Pawn_Zombiefied)GenSpawn.Spawn(pawn, loc, map, rot, WipeMode.Vanish, false);
                if (zomb != null)
                {
                    zomb.FixZombie();
                }
                reference = pawn;
            }
            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, reference, null);
                Find.TickManager.slower.SignalForceNormalSpeedShort();
            }
            LessonAutoActivator.TeachOpportunity(ConceptDefOf.ForbiddingDoors, OpportunityType.Critical);
            LessonAutoActivator.TeachOpportunity(ConceptDefOf.AllowedAreas, OpportunityType.Important);
            return(true);
        }
        private Pawn BestPawnToWander(Pawn predator)
        {
            if (predator.Map == null)
            {
                return(null);
            }

            List <Pawn> allPawnsSpawned = predator.Map.mapPawns.AllPawnsSpawned;
            Pawn        pawn            = null;

            float num     = 0f;
            bool  hunting = false;

            for (int i = 0; i < allPawnsSpawned.Count; i++)
            {
                Pawn pawn2 = allPawnsSpawned[i];
                if (pawn2 != null)
                {
                    if (predator != pawn2)
                    {
                        Pawn_Zombiefied pawnZ2 = pawn2 as Pawn_Zombiefied;
                        if (pawnZ2 != null)
                        {
                            if (IsAcceptableWanderFor(predator, pawn2, 10f))
                            {
                                float score = 0f;
                                if (pawn2.CurJob != null && pawn2.CurJob.def.Equals(ZombiefiedMod.zombieHunt))
                                {
                                    score  += 17f;
                                    hunting = true;
                                }
                                if (pawnZ2.hunting)
                                {
                                    score += 13f;
                                }
                                if (Rand.RangeSeeded(0f, 1f, Find.TickManager.TicksAbs) > 0.5f)
                                {
                                    score += 7f;
                                }
                                float lengthHorizontal = (predator.Position - pawn2.Position).LengthHorizontal;
                                score -= lengthHorizontal;

                                if (pawn == null || score > num)
                                {
                                    pawn = pawn2;
                                    num  = score;
                                }
                            }
                        }
                    }
                }
                if (allPawnsSpawned.Count > 77)
                {
                    i++;
                    //skip every other pawn if theres a lot
                    if (allPawnsSpawned.Count > 133)
                    {
                        i++;
                        //skip 2 pawns if theres a lot
                        if (allPawnsSpawned.Count > 233)
                        {
                            i++;
                            //skip 3 pawns if theres a lot
                        }
                    }
                }
            }
            Pawn_Zombiefied pawnZ = pawn as Pawn_Zombiefied;

            if (pawnZ != null)
            {
                pawnZ.hunting = hunting;
            }
            return(pawn);
        }
Example #7
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);
        }