C# Pawn.CanReserveAndReach方法代码示例

 public static Thing FindFreeSupplyShipCryptosleepBay(Pawn rescuer)
 {
     List<Thing> leftBaysList = Find.ListerThings.ThingsOfDef(OG_Util.SupplyShipCryptosleepBayLeftDef);
     for (int bayIndex = 0; bayIndex < leftBaysList.Count; bayIndex++)
     {
         Thing potentialBay = leftBaysList[bayIndex];
         if ((potentialBay.Faction != null)
             && (potentialBay.Faction == rescuer.Faction))
         {
             Building_SupplyShipCryptosleepBay bay = potentialBay as Building_SupplyShipCryptosleepBay;
             if ((bay.GetContainer().Count == 0)
                 && (rescuer.CanReserveAndReach(bay, PathEndMode.InteractionCell, Danger.Deadly)))
             {
                 return bay;
             }
         }
     }
     List<Thing> rightBaysList = Find.ListerThings.ThingsOfDef(OG_Util.SupplyShipCryptosleepBayRightDef);
     for (int bayIndex = 0; bayIndex < rightBaysList.Count; bayIndex++)
     {
         Thing potentialBay = rightBaysList[bayIndex];
         if ((potentialBay.Faction != null)
             && (potentialBay.Faction == rescuer.Faction))
         {
             Building_SupplyShipCryptosleepBay bay = potentialBay as Building_SupplyShipCryptosleepBay;
             if ((bay.GetContainer().Count == 0)
                 && (rescuer.CanReserveAndReach(bay, PathEndMode.InteractionCell, Danger.Deadly)))
             {
                 return bay;
             }
         }
     }
     return null;
 }

        public override bool HasJobOnThing( Pawn pawn, Thing t )
        {
#if DEBUG_WORKGIVER
            Log.Message("Checking " + t.LabelCap + " for job.");
            Log.Message("ManagerStation" + ((t as Building_ManagerStation) != null));
            Log.Message("Comp" + (t.TryGetComp<Comp_ManagerStation>() != null));
            Log.Message("Incap" + (!pawn.Dead && !pawn.Downed && !pawn.IsBurning() && !t.IsBurning()));
            Log.Message("CanReserve and reach" + (pawn.CanReserveAndReach(t, PathEndMode, Danger.Some)));
            CompPowerTrader powera = t.TryGetComp<CompPowerTrader>();
            Log.Message("Power" + (powera == null || powera.PowerOn));
            Log.Message("Job" + (Manager.Get.JobStack.NextJob != null));
#endif
            if ( !( t is Building_ManagerStation ) )
            {
                return false;
            }

            if ( t.TryGetComp<Comp_ManagerStation>() == null )
            {
                return false;
            }

            if ( pawn.Dead ||
                 pawn.Downed ||
                 pawn.IsBurning() ||
                 t.IsBurning() )
            {
                return false;
            }

            if ( !pawn.CanReserveAndReach( t, PathEndMode, Danger.Some ) )
            {
                return false;
            }

            CompPowerTrader power = t.TryGetComp<CompPowerTrader>();
            if ( power != null &&
                 !power.PowerOn )
            {
                return false;
            }

            if ( Manager.Get.JobStack.NextJob != null )
            {
                return true;
            }

            return false;
        }

 public override IEnumerable<Thing> PotentialWorkThingsGlobal( Pawn Pawn )
 {
     // Find all doors which want to be locked or unlocked and their cool-down has expired
     var doors = Find.ListerBuildings.allBuildingsColonist.Where( (t) =>
     {
         var door = t as Building_RestrictedDoor;
         if( door == null )
         {   // Not an appropriate door
             return false;
         }
         var compLock = door.TryGetComp<CompLockable>();
         if( compLock == null )
         {   // Door is missing comp
             return false;
         }
         if(
             ( !compLock.IssueLockToggleJob )||
             ( Find.TickManager.TicksGame < compLock.changeStateAfterTick )
         )
         {   // Door doesn't want lock toggle or cool down hasn't expired
             return false;
         }
         if( !Pawn.CanReserveAndReach( door, PathEndMode.Touch, Pawn.NormalMaxDanger(), 1 ) )
         {   // Pawn can't reach door
             return false;
         }
         // This door want's it's lock status changed
         return true;
     } );
     foreach( var door in doors )
     {
         yield return door;
     }
 }

		public override bool HasJobOnThing(Pawn pawn, Thing t)
		{
            if ((t is Building_AquacultureBasin) == false)
            {
                return false;
            }
            Building_AquacultureBasin aquacultureBasin = t as Building_AquacultureBasin;

            if (pawn.Dead
                || pawn.Downed
                || pawn.IsBurning())
            {
                return false;
            }
            if (pawn.CanReserveAndReach(aquacultureBasin, this.PathEndMode, Danger.Some) == false)
            {
                return false;
            }

            if (aquacultureBasin.breedingIsFinished)
            {
                return true;
            }
            return false;
		}

        public static Building_MAD FindMADFor(Pawn sleeper, Pawn traveler, bool sleeperWillBePrisoner, bool checkSocialProperness, bool forceCheckMedBed = false)
        {
            Predicate<Thing> MADValidator = delegate(Thing t)
            {
                if (!traveler.CanReserveAndReach(t, PathEndMode.OnCell, Danger.Some, 1))
                {
                    return false;
                }

                Building_MAD Building_MAD3 = (Building_MAD)t;

                if (Building_MAD3.HasAnyContents)
                {
                    return false;
                }
                else
                {
                    if (Building_MAD3.Faction != traveler.Faction)
                    {
                        return false;
                    }
                }
                return (!Building_MAD3.IsForbidden(traveler) && !Building_MAD3.IsBurning());
            };
            Predicate<Thing> validator = (Thing b) => MADValidator(b);

            Building_MAD building_MAD = (Building_MAD)GenClosest.ClosestThingReachable(sleeper.Position, ThingRequest.ForDef(DefDatabase<ThingDef>.GetNamed("MindAlteringDevice")), PathEndMode.OnCell, TraverseParms.For(traveler, Danger.Deadly, TraverseMode.ByPawn, false), 9999f, validator, null, -1, false);

            if (building_MAD != null)
            {
                return building_MAD;
            }

            return null;
        }

        public static void DebugWriteHaulingPawn(Pawn pawn)
        {
            Trace.AppendLine(pawn.LabelCap + " Report: Cart " + ToolsForHaulUtility.Cart().Count + " Job: " + ((pawn.CurJob != null) ? pawn.CurJob.def.defName : "No Job")
                + " Backpack: " + ((ToolsForHaulUtility.TryGetBackpack(pawn) != null) ? "True" : "False")
                + " lastGivenWorkType: " + pawn.mindState.lastGivenWorkType);
            foreach (Pawn other in Find.ListerPawns.FreeColonistsSpawned)
            {
                //Vanilla haul or Haul with backpack
                if (other.CurJob != null && (other.CurJob.def == JobDefOf.HaulToCell || other.CurJob.def == DefDatabase<JobDef>.GetNamed("HaulWithBackpack")))
                    Trace.AppendLine(other.LabelCap + " Job: " + other.CurJob.def.defName
                        + " Backpack: " + ((ToolsForHaulUtility.TryGetBackpack(other) != null) ? "True" : "False")
                        + " lastGivenWorkType: " + other.mindState.lastGivenWorkType);
            }
            foreach (Vehicle_Cart cart in ToolsForHaulUtility.Cart())
            {
                string driver = ((cart.mountableComp.IsMounted) ? cart.mountableComp.Driver.LabelCap : "No Driver");
                string state = "";
                if (cart.IsForbidden(pawn.Faction))
                    state = string.Concat(state, "Forbidden ");
                if (pawn.CanReserveAndReach(cart, PathEndMode.Touch, Danger.Some))
                    state = string.Concat(state, "CanReserveAndReach ");
                if (ToolsForHaulUtility.AvailableCart(cart, pawn))
                    state = string.Concat(state, "AvailableCart ");
                if (ToolsForHaulUtility.AvailableAnimalCart(cart))
                    state = string.Concat(state, "AvailableAnimalCart ");
                Pawn reserver = Find.Reservations.FirstReserverOf(cart, Faction.OfColony);
                if (reserver != null)
                    state = string.Concat(state, reserver.LabelCap, " Job: ", reserver.CurJob.def.defName);
                Trace.AppendLine(cart.LabelCap + "- " + driver + ": " + state);

            }
            Trace.LogMessage();
        }

		public override bool HasJobOnThing(Pawn pawn, Thing t)
		{

            if ((t is Building_LaserFencePylon) == false)
            {
                return false;
            }
            if (pawn.CanReserveAndReach(t, PathEndMode.Touch, Danger.Deadly) == false)
            {
                return false;
            }

            Building_LaserFencePylon pylon = t as Building_LaserFencePylon;
            
            if (pawn.Dead
                || pawn.Downed
                || pawn.IsBurning())
            {
                return false;
            }
            if (pylon.manualSwitchIsPending)
            {
                return true;
            }
            return false;
		}

        public override Job JobOnThing( Pawn pawn, Thing t )
        {
            if( !pawn.CanReserveAndReach( ( TargetInfo )t.Position, PathEndMode.Touch, DangerUtility.NormalMaxDanger( pawn ), 1 ) )
            {
                return (Job) null;
            }

            var hopperSgp = t as ISlotGroupParent;
            if( hopperSgp == null )
            {
                return (Job) null;
            }

            var resource = HopperGetCurrentResource( t.Position, hopperSgp );
            if(
                ( resource == null )||
                ( resource.stackCount <= ( resource.def.stackLimit / 2 ) )
            )
            {
                return WorkGiver_FillHopper.HopperFillJob( pawn, hopperSgp, resource );
            }

            JobFailReason.Is( "AlreadyFilledLower".Translate() );
            return (Job) null;
        }

 // search things throught designations is faster than searching designations through all things
 public static List<TargetInfo> AvailableTargets(Pawn pawn)
 {
     return Find.ListerThings.AllThings.FindAll(thing => thing is Frame)
         .Where(thing => thing.Faction == pawn.Faction && GenConstruct.CanConstruct(thing, pawn) &&
                         (thing as Frame).MaterialsNeeded().Count == 0 &&
                         pawn.CanReserveAndReach(thing, PathEndMode.Touch, pawn.NormalMaxDanger())).Select(thing => new TargetInfo(thing)).ToList();
 }

 public override bool HasJobOnThing(Pawn pawn, Thing t)
 {
     Pawn pawn2 = t as Pawn;
     if (pawn2 == null) return false;
     bool casket = Building_CryptosleepCasket.FindCryptosleepCasketFor(pawn2, pawn) != null;
     return pawn2 != null && casket && pawn2.RaceProps.Animal && pawn2.CasualInterruptibleNow() && pawn.CanReserveAndReach(pawn2, PathEndMode.Touch, Danger.Deadly);
 }

 private Thing FindRestraints( Pawn warden, BodyPartGroupDef bodyPartGroupDef )
 {
     // Is the warden carrying a restraint already?
     var restraint = warden.inventory.container.FirstOrDefault( thing => (
         ( thing.IsRestraints() )&&
         ( thing.def.apparel.bodyPartGroups.Contains( bodyPartGroupDef ) )
     ) );
     if( restraint == null )
     {   // Nope, find one in the colony
         var restraints = Data.AllRestraintsOfColony( bodyPartGroupDef );
         if( restraints == null )
         {
             return null;
         }
         restraint = restraints.Find( thing => (
             ( !thing.IsForbidden( Faction.OfPlayer ) )&&
             ( warden.CanReserveAndReach(
                 thing,
                 PathEndMode.ClosestTouch,
                 warden.NormalMaxDanger(),
                 1 )
             )
         ) );
     }
     return restraint;
 }

        public override bool HasJobOnThing( Pawn pawn, Thing thing )
        {
            if ( thing.Faction != pawn.Faction )
                return false;

            if ( pawn.Faction == Faction.OfColony && !Find.AreaHome[thing.Position] )
                return false;

            if ( thing.IsBurning() )
                return false;

            if ( Find.DesignationManager.DesignationOn( thing, DesignationDefOf.Deconstruct ) != null )
                return false;

            ThingWithComps twc = thing as ThingWithComps;
            if ( twc == null )
                return false;

            var comp = twc.TryGetComp<CompBreakdownable>();
            if ( comp == null )
                return false;

            if ( !MapComponent_Durability.RequiresMaintenance( comp ) )
                return false;

            if ( !pawn.CanReserveAndReach( thing, PathEndMode.Touch, pawn.NormalMaxDanger() ) )
                return false;

            return true;
        }

 public static Job HopperFillFoodJob(Pawn pawn, ISlotGroupParent hopperSgp)
 {
     Building building = hopperSgp as Building;
     if (!pawn.CanReserveAndReach(building.Position, PathEndMode.Touch, pawn.NormalMaxDanger(), 1))
     {
         return null;
     }
     ThingDef thingDef = null;
     Thing firstItem = building.Position.GetFirstItem();
     if (firstItem != null)
     {
         if (Building_AquacultureBasin.IsAcceptableFeedstock(firstItem.def))
         {
             thingDef = firstItem.def;
         }
         else
         {
             if (firstItem.IsForbidden(pawn))
             {
                 return null;
             }
             return HaulAIUtility.HaulAsideJobFor(pawn, firstItem);
         }
     }
     List<Thing> list;
     if (thingDef == null)
     {
         list = Find.Map.listerThings.ThingsInGroup(ThingRequestGroup.FoodSourceNotPlantOrTree);
     }
     else
     {
         list = Find.Map.listerThings.ThingsOfDef(thingDef);
     }
     for (int i = 0; i < list.Count; i++)
     {
         Thing thing = list[i];
         if (thing.def.IsNutritionGivingIngestible)
         {
             if (thing.def.ingestible.preferability == FoodPreferability.RawBad || thing.def.ingestible.preferability == FoodPreferability.RawTasty)
             {
                 if (HaulAIUtility.PawnCanAutomaticallyHaul(pawn, thing))
                 {
                     if (Find.SlotGroupManager.SlotGroupAt(building.Position).Settings.AllowedToAccept(thing))
                     {
                         StoragePriority storagePriority = HaulAIUtility.StoragePriorityAtFor(thing.Position, thing);
                         if (storagePriority < hopperSgp.GetSlotGroup().Settings.Priority)
                         {
                             Job job = HaulAIUtility.HaulMaxNumToCellJob(pawn, thing, building.Position, true);
                             if (job != null)
                             {
                                 return job;
                             }
                         }
                     }
                 }
             }
         }
     }
     return null;
 }

 protected override IntVec3 GetExactWanderDest(Pawn pawn)
 {
     Area outpostArea = OG_Util.FindOutpostArea();
     if ((outpostArea != null)
         && outpostArea.ActiveCells.Contains(pawn.Position))
     {
         return RCellFinder.RandomWanderDestFor(pawn, pawn.Position, this.wanderRadius, this.wanderDestValidator, PawnUtility.ResolveMaxDanger(pawn, this.maxDanger));
     }
     else
     {
         Building_OutpostCommandConsole console = OG_Util.FindOutpostCommandConsole(OG_Util.FactionOfMiningCo);
         if (console != null)
         {
             IntVec3 cell1 = WanderUtility.BestCloseWanderRoot(console.Position, pawn);
             return cell1;
         }
         else
         {
             for (int cellIndex = 0; cellIndex < 50; cellIndex++)
             {
                 IntVec3 cell2 = outpostArea.ActiveCells.RandomElement();
                 if (pawn.CanReserveAndReach(cell2, PathEndMode.Touch, Danger.Some))
                 {
                     return cell2;
                 }
             }
             IntVec3 cell3 = WanderUtility.BestCloseWanderRoot(pawn.Position, pawn);
             return cell3;
         }
     }
 }

 // search things throught designations is faster than searching designations through all things
 public static List<TargetInfo> AvailableTargets(Pawn pawn)
 {
     return Find.DesignationManager.allDesignations.FindAll(designation =>
         designation.def == DefDatabase<DesignationDef>.GetNamed("ChopWood"))
         .Select(designation => designation.target)
         .Where(target => !target.IsBurning() &&
                          pawn.CanReserveAndReach(target, PathEndMode.Touch, pawn.NormalMaxDanger())).ToList();
 }