public JobGiver_WanderOwnRoom()
 {
     base.wanderRadius             = 7f;
     base.ticksBetweenWandersRange = new IntRange(300, 600);
     base.locomotionUrgency        = LocomotionUrgency.Amble;
     base.wanderDestValidator      = ((Pawn pawn, IntVec3 loc) => WanderRoomUtility.IsValidWanderDest(pawn, loc, this.GetWanderRoot(pawn)));
 }
 public JobGiver_WanderCurrentRoom()
 {
     wanderRadius             = 7f;
     ticksBetweenWandersRange = new IntRange(125, 200);
     locomotionUrgency        = LocomotionUrgency.Amble;
     wanderDestValidator      = (Pawn pawn, IntVec3 loc, IntVec3 root) => WanderRoomUtility.IsValidWanderDest(pawn, loc, root);
 }
 public JobGiver_WanderNearMaster()
 {
     wanderRadius             = 3f;
     ticksBetweenWandersRange = new IntRange(125, 200);
     wanderDestValidator      = delegate(Pawn p, IntVec3 c, IntVec3 root)
     {
         if (MustUseRootRoom(p))
         {
             Room room = root.GetRoom(p.Map);
             if (room != null && !WanderRoomUtility.IsValidWanderDest(p, c, root))
             {
                 return(false);
             }
         }
         return(true);
     };
 }
        protected override Job TryGiveJob(Pawn pawn)
        {
            if (Rand.RangeInclusive(0, 1000) > 150)
            {
                return(null);
            }
            IntVec3 exactWanderDest = this.GetWanderRoot(pawn);

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

            pawn.Map.pawnDestinationReservationManager.Reserve(pawn, job, exactWanderDest);
            job.locomotionUrgency         = LocomotionUrgency.Sprint;
            this.wanderRadius             = 5f;
            this.ticksBetweenWandersRange = new IntRange(10, 50);
            this.wanderDestValidator      = ((Pawn actor, IntVec3 loc) => WanderRoomUtility.IsValidWanderDest(actor, loc, this.GetWanderRoot(actor)));
            return(job);
        }
Beispiel #5
0
        protected override Job TryGiveJob(Pawn pawn)
        {
            if (pawn.interactions.InteractedTooRecentlyToInteract() || lastRomanceTick > Find.TickManager.TicksGame - 1000)
            {
                return(null);
            }
            Predicate <Thing> validator = delegate(Thing t)
            {
                Pawn pawn3 = (Pawn)t;
                return(pawn3 != pawn && pawn3.Spawned && !pawn3.Dead && !pawn3.Downed && pawn3.Awake() && pawn3.IsColonist);
            };
            Pawn pawn2 = (Pawn)GenClosest.ClosestThingReachable(pawn.Position, pawn.Map, ThingRequest.ForGroup(ThingRequestGroup.Pawn), PathEndMode.OnCell, TraverseParms.For(pawn, Danger.Deadly, TraverseMode.ByPawn, false), 9999f, validator);

            if (pawn2 == null)
            {
                return(null);
            }
            if (Rand.Chance(0.005f) && new InteractionWorker_RomanceAttempt().SuccessChance(pawn2, pawn) > 0f)
            {
                return(new Job(JobDefOfPsychology.MakeAdvance, pawn2));
            }
            else if (Rand.Value < 0.5f)
            {
                IntVec3 root = WanderUtility.BestCloseWanderRoot(pawn2.PositionHeld, pawn);
                Func <Pawn, IntVec3, IntVec3, bool> wanderDestValidator = delegate(Pawn p, IntVec3 c, IntVec3 wRoot)
                {
                    Room room = root.GetRoom(p.Map, RegionType.Set_Passable);
                    if (room != null && !WanderRoomUtility.IsValidWanderDest(p, c, root))
                    {
                        return(false);
                    }
                    return(true);
                };
                return(new Job(JobDefOf.Goto, RCellFinder.RandomWanderDestFor(pawn, root, 3f, wanderDestValidator, PawnUtility.ResolveMaxDanger(pawn, Danger.Deadly))));
            }
            return(null);
        }
Beispiel #6
0
 public JobGiver_WanderNearMaster()
 {
     wanderRadius             = 3f;
     ticksBetweenWandersRange = new IntRange(125, 200);
     wanderDestValidator      = (Pawn p, IntVec3 c, IntVec3 root) => (!MustUseRootRoom(p) || root.GetRoom(p.Map) == null || WanderRoomUtility.IsValidWanderDest(p, c, root)) ? true : false;
 }
        public static IEnumerable <LocalTargetInfo> AllMeditationSpotCandidates(Pawn pawn, bool allowFallbackSpots = true)
        {
            bool flag = false;

            if (pawn.royalty != null && pawn.royalty.AllTitlesInEffectForReading.Count > 0 && !pawn.IsPrisonerOfColony)
            {
                Building_Throne building_Throne = RoyalTitleUtility.FindBestUsableThrone(pawn);
                if (building_Throne != null)
                {
                    yield return(building_Throne);

                    flag = true;
                }
            }
            if (!pawn.IsPrisonerOfColony)
            {
                foreach (Building item in pawn.Map.listerBuildings.AllBuildingsColonistOfDef(ThingDefOf.MeditationSpot).Where(delegate(Building s)
                {
                    if (s.IsForbidden(pawn) || !s.Position.Standable(s.Map))
                    {
                        return(false);
                    }
                    if (s.GetAssignedPawn() != null && s.GetAssignedPawn() != pawn)
                    {
                        return(false);
                    }
                    Room room4 = s.GetRoom();
                    return((room4 == null || CanUseRoomToMeditate(room4, pawn)) && pawn.CanReserveAndReach(s, PathEndMode.OnCell, pawn.NormalMaxDanger()));
                }))
                {
                    yield return(item);

                    flag = true;
                }
            }
            if (flag || !allowFallbackSpots)
            {
                yield break;
            }
            List <Thing> list = pawn.Map.listerThings.ThingsInGroup(ThingRequestGroup.MeditationFocus);

            foreach (Thing item2 in list)
            {
                if (item2.def == ThingDefOf.Wall)
                {
                    continue;
                }
                Room room = item2.GetRoom();
                if ((room == null || CanUseRoomToMeditate(room, pawn)) && item2.GetStatValueForPawn(StatDefOf.MeditationFocusStrength, pawn) > 0f)
                {
                    LocalTargetInfo localTargetInfo = MeditationSpotForFocus(item2, pawn);
                    if (localTargetInfo.IsValid)
                    {
                        yield return(localTargetInfo);
                    }
                }
            }
            Building_Bed bed   = pawn.ownership.OwnedBed;
            Room         room2 = bed?.GetRoom();
            IntVec3      c2;

            if (room2 != null && !room2.PsychologicallyOutdoors && pawn.CanReserveAndReach(bed, PathEndMode.OnCell, pawn.NormalMaxDanger()))
            {
                foreach (LocalTargetInfo item3 in FocusSpotsInTheRoom(pawn, room2))
                {
                    yield return(item3);
                }
                c2 = RCellFinder.RandomWanderDestFor(pawn, bed.Position, WanderRadius, (Pawn p, IntVec3 c, IntVec3 r) => c.Standable(p.Map) && c.GetDoor(p.Map) == null && WanderRoomUtility.IsValidWanderDest(p, c, r), pawn.NormalMaxDanger());
                if (c2.IsValid)
                {
                    yield return(c2);
                }
            }
            if (pawn.IsPrisonerOfColony)
            {
                yield break;
            }
            IntVec3 colonyWanderRoot = WanderUtility.GetColonyWanderRoot(pawn);

            c2 = RCellFinder.RandomWanderDestFor(pawn, colonyWanderRoot, WanderRadius, delegate(Pawn p, IntVec3 c, IntVec3 r)
            {
                if (!c.Standable(p.Map) || c.GetDoor(p.Map) != null || !p.CanReserveAndReach(c, PathEndMode.OnCell, p.NormalMaxDanger()))
                {
                    return(false);
                }
                Room room3 = c.GetRoom(p.Map);
                return((room3 == null || CanUseRoomToMeditate(room3, pawn)) ? true : false);
            }, pawn.NormalMaxDanger());
            if (c2.IsValid)
            {
                yield return(c2);
            }
        }