public override bool HasJobOnThing(Pawn pawn, Thing t, bool forced = false)
{
Pawn pawn2 = t as Pawn;
if (pawn2 == null || pawn2 == pawn)
{
return(false);
}
if (def.feedHumanlikesOnly && !pawn2.RaceProps.Humanlike)
{
return(false);
}
if (def.feedAnimalsOnly && !pawn2.RaceProps.Animal)
{
return(false);
}
if (!FeedPatientUtility.IsHungry(pawn2))
{
return(false);
}
if (!FeedPatientUtility.ShouldBeFed(pawn2))
{
return(false);
}
if (!pawn.CanReserve(t, 1, -1, null, forced))
{
return(false);
}
if (!FoodUtility.TryFindBestFoodSourceFor(pawn, pawn2, pawn2.needs.food.CurCategory == HungerCategory.Starving, out Thing _, out ThingDef _, canRefillDispenser: false))
{
JobFailReason.Is("NoFood".Translate());
return(false);
}
return(true);
}
private Job InstallJob(Pawn pawn, Blueprint_Install install)
{
Thing miniToInstallOrBuildingToReinstall = install.MiniToInstallOrBuildingToReinstall;
if (miniToInstallOrBuildingToReinstall.IsForbidden(pawn))
{
JobFailReason.Is(WorkGiver_ConstructDeliverResources.ForbiddenLowerTranslated, null);
return(null);
}
if (!pawn.CanReach(miniToInstallOrBuildingToReinstall, PathEndMode.ClosestTouch, pawn.NormalMaxDanger(), false, TraverseMode.ByPawn))
{
JobFailReason.Is(WorkGiver_ConstructDeliverResources.NoPathTranslated, null);
return(null);
}
if (!pawn.CanReserve(miniToInstallOrBuildingToReinstall, 1, -1, null, false))
{
Pawn pawn2 = pawn.Map.reservationManager.FirstRespectedReserver(miniToInstallOrBuildingToReinstall, pawn);
if (pawn2 != null)
{
JobFailReason.Is("ReservedBy".Translate(new object[]
{
pawn2.LabelShort
}), null);
}
return(null);
}
return(new Job(JobDefOf.HaulToContainer)
{
targetA = miniToInstallOrBuildingToReinstall,
targetB = install,
count = 1,
haulMode = HaulMode.ToContainer
});
}
public virtual bool PawnAllowedToStartAnew(Pawn p)
{
if (this.pawnRestriction != null)
{
return(this.pawnRestriction == p);
}
if (this.recipe.workSkill != null)
{
int level = p.skills.GetSkill(this.recipe.workSkill).Level;
if (level < this.allowedSkillRange.min)
{
JobFailReason.Is("UnderAllowedSkill".Translate(new object[]
{
this.allowedSkillRange.min
}), this.Label);
return(false);
}
if (level > this.allowedSkillRange.max)
{
JobFailReason.Is("AboveAllowedSkill".Translate(new object[]
{
this.allowedSkillRange.max
}), this.Label);
return(false);
}
}
return(true);
}
private Job StartOrResumeBillJob(Pawn pawn, IBillGiver giver)
{
for (int i = 0; i < giver.BillStack.Count; i++)
{
Bill bill = giver.BillStack [i];
if (Find.TickManager.TicksGame >= bill.lastIngredientSearchFailTicks + ReCheckFailedBillTicksRange.RandomInRange ||
FloatMenuMakerMap.making)
{
if (bill.ShouldDoNow())
{
if (bill.PawnAllowedToStartAnew(pawn))
{
if (!bill.recipe.PawnSatisfiesSkillRequirements(pawn))
{
JobFailReason.Is(MissingSkillTranslated);
}
else
{
Thing chosen;
if (TryFindBestBillIngredients(bill, pawn, (Thing)giver, ignoreHitPoints, out chosen))
{
return(TryStartNewDoBillJob(pawn, bill, giver, chosen));
}
}
}
}
}
}
return(null);
}
public static bool Prefix(Pawn pawn, Thing t)
{
if (pawn.Faction != null && pawn.Faction.IsPlayer && pawn.RaceProps.Humanlike && pawn.TryGetComp <CompKnowledge>() != null)
{
if (t.Faction != pawn.Faction)
{
return(true);
}
Frame frame = t as Frame;
if (frame == null)
{
return(true);
}
if (frame.MaterialsNeeded().Count > 0)
{
return(true);
}
var requisites = t.def.entityDefToBuild.researchPrerequisites;
if (!requisites.NullOrEmpty())
{
bool result = requisites.All(x => x.IsKnownBy(pawn));
if (!result)
{
var missing = requisites.Where(x => !x.IsKnownBy(pawn));
string preReqText = (missing.Count() > 1) ? missing.Select(x => x.label).ToStringSafeEnumerable() : missing.FirstOrDefault().label;
JobFailReason.Is("DoesntKnowHowToBuild".Translate(pawn, t.def.entityDefToBuild.label, preReqText));
}
//return pawn.TryGetComp<CompKnowledge>().expertise.Any(x => requisites.Contains(x.Key) && x.Value >= 1f);
return(result);
}
}
return(true);
}
public override bool HasJobOnThing(Pawn pawn, Thing t, bool forced = false)
{
Building_FermentingOniWineBarrel building_FermentingOniWineBarrel = t as Building_FermentingOniWineBarrel;
if (building_FermentingOniWineBarrel == null || building_FermentingOniWineBarrel.Fermented || building_FermentingOniWineBarrel.SpaceLeftForDemonBreathWort <= 0)
{
return(false);
}
float ambientTemperature = building_FermentingOniWineBarrel.AmbientTemperature;
CompProperties_TemperatureRuinable compProperties = building_FermentingOniWineBarrel.def.GetCompProperties <CompProperties_TemperatureRuinable>();
if (ambientTemperature < compProperties.minSafeTemperature + 2f || ambientTemperature > compProperties.maxSafeTemperature - 2f)
{
JobFailReason.Is(WorkGiver_FillFermentingOniWineBarrel.TemperatureTrans, null);
return(false);
}
if (t.IsForbidden(pawn) || !pawn.CanReserve(t, 1, -1, null, forced))
{
return(false);
}
if (pawn.Map.designationManager.DesignationOn(t, DesignationDefOf.Deconstruct) != null)
{
return(false);
}
if (this.FindDemonBreathWort(pawn, building_FermentingOniWineBarrel) == null)
{
JobFailReason.Is(WorkGiver_FillFermentingOniWineBarrel.NoDemonBreathWortTrans, null);
return(false);
}
return(!t.IsBurning());
}
public override bool HasJobOnThing(Pawn pawn, Thing t, bool forced = false)
{
Building_ItemProcessor building_processor = t as Building_ItemProcessor;
if (building_processor == null || building_processor.GetComp <CompItemProcessor>().Props.isCompletelyAutoMachine || building_processor.processorStage != ProcessorStage.ExpectingIngredients || building_processor.secondIngredientComplete || building_processor.secondItem == "")
{
return(false);
}
if (!t.IsForbidden(pawn))
{
LocalTargetInfo target = t;
if (pawn.CanReserve(target, 1, 1, null, forced))
{
if (pawn.Map.designationManager.DesignationOn(t, DesignationDefOf.Deconstruct) != null)
{
return(false);
}
if (this.FindIngredient(pawn, building_processor.firstItem, building_processor) == null)
{
JobFailReason.Is(WorkGiver_InsertProcessorSecond.NoIngredientFound, null);
return(false);
}
return(!t.IsBurning());
}
}
return(false);
}
private static bool AllowToolHaulUrgentlyJobOnThing_PreFix(ref Job __result, Pawn pawn, Thing t, bool forced = false)
{
if (ModCompatibilityCheck.AllowToolIsActive)
{
//allowTool HaulUrgently
CompHauledToInventory takenToInventory = pawn.TryGetComp <CompHauledToInventory>();
if (pawn.RaceProps.Humanlike &&
pawn.Faction == Faction.OfPlayer &&
t is Corpse == false &&
takenToInventory != null &&
!(t.def.defName.Contains("Chunk")) //most of the time we don't have space for it
)
{
StoragePriority currentPriority = HaulAIUtility.StoragePriorityAtFor(t.Position, t);
if (!StoreUtility.TryFindBestBetterStoreCellFor(t, pawn, pawn.Map, currentPriority, pawn.Faction, out IntVec3 storeCell, true))
{
JobFailReason.Is("NoEmptyPlaceLower".Translate());
return(false);
}
Job haul = new Job(PickUpAndHaulJobDefOf.HaulToInventory, t)
{
count = t.stackCount
};
__result = haul;
return(false);
}
}
return(true);
}
public override bool HasJobOnThing(Pawn pawn, Thing t, bool forced = false)
{
if (!(t is Building_BeaconUnlit building))
{
return(false);
}
if (!building.ToBeLit)
{
return(false);
}
if (t.Faction != pawn.Faction)
{
return(false);
}
if (pawn.Faction == Faction.OfPlayer && !pawn.Map.areaManager.Home[t.Position])
{
JobFailReason.Is(WorkGiver_FixBrokenDownBuilding.NotInHomeAreaTrans);
return(false);
}
if (!pawn.CanReserve(t))
{
return(false); // pawn.Map.reservationManager.IsReserved(t, pawn.Faction)) return false;
}
return(true);
}
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);
}
// Token: 0x06000006 RID: 6 RVA: 0x000021DC File Offset: 0x000003DC
public static Job HaulOuttaHereJobFor(Pawn p, Thing t)
{
Job result;
if (!CanHaulOuttaHere(p, t, out var c))
{
JobFailReason.Is("Can't clear: No place to clear to.");
result = null;
}
else
{
var haulMode = HaulMode.ToCellNonStorage;
if (c.GetSlotGroup(p.Map) != null)
{
haulMode = HaulMode.ToCellStorage;
}
result = new Job(JobDefOf.HaulToCell, t, c)
{
count = 99999,
haulOpportunisticDuplicates = false,
haulMode = haulMode,
ignoreDesignations = true
};
}
return(result);
}
//Copied from vanilla to prevent it from being broken by other mods. HaulExplicitly for instance would break this otherwise.
private static bool PawnCanAutomaticallyHaulFast(Pawn p, Thing t, bool forced)
{
UnfinishedThing unfinishedThing = t as UnfinishedThing;
if (unfinishedThing != null && unfinishedThing.BoundBill != null)
{
return(false);
}
if (!p.CanReach(t, PathEndMode.ClosestTouch, p.NormalMaxDanger(), false, TraverseMode.ByPawn))
{
return(false);
}
LocalTargetInfo target = t;
if (!p.CanReserve(target, 1, -1, null, forced))
{
return(false);
}
if (t.def.IsNutritionGivingIngestible && t.def.ingestible.HumanEdible && !t.IsSociallyProper(p, false, true))
{
JobFailReason.Is(Traverse.Create(typeof(HaulAIUtility)).Field("ReservedForPrisonersTrans").GetValue <string>(), null);
return(false);
}
if (t.IsBurning())
{
JobFailReason.Is(Traverse.Create(typeof(HaulAIUtility)).Field("BurningLowerTrans").GetValue <string>(), null);
return(false);
}
return(true);
}
public override Job JobOnThing(Pawn pawn, Thing t, bool forced = false)
{
Pawn pawn2 = t as Pawn;
if (pawn2 == null || !TameUtility.CanTame(pawn2))
{
return(null);
}
if (pawn.Map.designationManager.DesignationOn(t, DesignationDefOf.Tame) == null)
{
return(null);
}
if (TameUtility.TriedToTameTooRecently(pawn2))
{
JobFailReason.Is(WorkGiver_InteractAnimal.AnimalInteractedTooRecentlyTrans);
return(null);
}
if (!CanInteractWithAnimal(pawn, pawn2, forced))
{
return(null);
}
if (pawn2.RaceProps.EatsFood && !HasFoodToInteractAnimal(pawn, pawn2))
{
Job job = TakeFoodForAnimalInteractJob(pawn, pawn2);
if (job == null)
{
JobFailReason.Is(WorkGiver_InteractAnimal.NoUsableFoodTrans);
}
return(job);
}
return(new Job(JobDefOf.Tame, t));
}
private static bool CanRefuel(Pawn pawn, Thing t, bool forced)
{
CompRefuelable compRefuelable = t.TryGetComp <CompRefuelable>();
if (compRefuelable == null || compRefuelable.IsFull || !compRefuelable.allowAutoRefuel || !compRefuelable.ShouldAutoRefuelNow)
{
return(false);
}
if (t.IsForbiddenForPrisoner(pawn) || !pawn.CanReserveAndReach(t, PathEndMode.ClosestTouch, pawn.NormalMaxDanger(), 1, -1, null, forced))
{
return(false);
}
if (Traverse.Create(typeof(RefuelWorkGiverUtility)).Method("FindBestFuel", new[] { pawn, t }).GetValue <Thing>() == null)
{
ThingFilter fuelFilter = t.TryGetComp <CompRefuelable>().Props.fuelFilter;
JobFailReason.Is("NoFuelToRefuel".Translate(fuelFilter.Summary));
return(false);
}
if (t.TryGetComp <CompRefuelable>().Props.atomicFueling&& Traverse.Create(typeof(RefuelWorkGiverUtility)).Method("FindAllFuel", new[] { pawn, t }).GetValue <List <Thing> >() == null)
{
ThingFilter fuelFilter2 = t.TryGetComp <CompRefuelable>().Props.fuelFilter;
JobFailReason.Is("NoFuelToRefuel".Translate(fuelFilter2.Summary));
return(false);
}
return(true);
}
public override bool HasJobOnThing(Pawn pawn, Thing thing, bool forced = false)
{
Building_Processing building = thing as Building_Processing;
if (building == null || building.Completed || building.SpaceLeft <= 0)
{
return(false);
}
float ambientTemperature = building.AmbientTemperature;
CompProperties_TemperatureRuinable compProperties = building.def.GetCompProperties <CompProperties_TemperatureRuinable>();
if (compProperties != null && (ambientTemperature < compProperties.minSafeTemperature + 2f || ambientTemperature > compProperties.maxSafeTemperature - 2f))
{
JobFailReason.Is(TemperatureTrans);
return(false);
}
if (thing.IsForbidden(pawn) || !pawn.CanReserve(thing, 1, -1, null, forced))
{
return(false);
}
if (pawn.Map.designationManager.DesignationOn(thing, DesignationDefOf.Deconstruct) != null)
{
return(false);
}
if (FindIngredient(pawn, building) == null)
{
JobFailReason.Is(NoIngredientTrans);
return(false);
}
return(!thing.IsBurning());
}
public static bool CanMakeBed(Pawn pawn, Building_Bed t, bool forced = false)
{
CompMakeableBed CompMakeableBed = t.TryGetComp <CompMakeableBed>();
if (CompMakeableBed == null || CompMakeableBed.Loaded)
{
return(false);
}
if (!t.IsForbidden(pawn))
{
LocalTargetInfo target = t;
if (pawn.CanReserve(target, 1, -1, null, forced))
{
if (t.Faction != pawn.Faction)
{
return(false);
}
if (FindBestBedding(pawn, t) == null)
{
ThingFilter beddingFilter = new ThingFilter();
beddingFilter.SetAllow(t.TryGetComp <CompMakeableBed>().allowedBedding, true);
JobFailReason.Is("NoSuitableBedding".Translate(beddingFilter.Summary), null);
return(false);
}
return(true);
}
}
return(false);
}
private Job InstallJob(Pawn pawn, Blueprint_Install install)
{
Thing miniToInstallOrBuildingToReinstall = install.MiniToInstallOrBuildingToReinstall;
if (miniToInstallOrBuildingToReinstall.IsForbidden(pawn))
{
JobFailReason.Is(ForbiddenLowerTranslated);
return(null);
}
if (!pawn.CanReach(miniToInstallOrBuildingToReinstall, PathEndMode.ClosestTouch, pawn.NormalMaxDanger()))
{
JobFailReason.Is(NoPathTranslated);
return(null);
}
if (!pawn.CanReserve(miniToInstallOrBuildingToReinstall))
{
Pawn pawn2 = pawn.Map.reservationManager.FirstRespectedReserver(miniToInstallOrBuildingToReinstall, pawn);
if (pawn2 != null)
{
JobFailReason.Is("ReservedBy".Translate(pawn2.LabelShort, pawn2));
}
return(null);
}
Job job = new Job(JobDefOf.HaulToContainer);
job.targetA = miniToInstallOrBuildingToReinstall;
job.targetB = install;
job.count = 1;
job.haulMode = HaulMode.ToContainer;
return(job);
}
public override bool HasJobOnThing(Pawn pawn, Thing t, bool forced = false)
{
Building_Composter composter = t as Building_Composter;
if (t == null)
{
return(false);
}
if (t.IsForbidden(pawn))
{
return(false);
}
if (t.IsBurning())
{
return(false);
}
if (pawn.Map.designationManager.DesignationOn(t, DesignationDefOf.Deconstruct) != null)
{
return(false);
}
if (!composter.ProcessComplete)
{
JobFailReason.Is(string.Format("twComposter_Incomplete".Translate(), t.Label, composter.Progress.ToStringPercent("0")));
return(false);
}
return(pawn.CanReserveAndReach(t, PathEndMode.Touch, pawn.NormalMaxDanger(), 1));
}
public static bool CanConstruct(Thing t, Pawn p, bool checkSkills = true, bool forced = false)
{
if (FirstBlockingThing(t, p) != null)
{
return(false);
}
if (!p.CanReserveAndReach(t, PathEndMode.Touch, forced ? Danger.Deadly : p.NormalMaxDanger(), 1, -1, null, forced))
{
return(false);
}
if (t.IsBurning())
{
return(false);
}
if (checkSkills && p.skills.GetSkill(SkillDefOf.Construction).Level < t.def.constructionSkillPrerequisite)
{
JobFailReason.Is(SkillTooLowTrans.Formatted(SkillDefOf.Construction.LabelCap));
return(false);
}
if (checkSkills && p.skills.GetSkill(SkillDefOf.Artistic).Level < t.def.artisticSkillPrerequisite)
{
JobFailReason.Is(SkillTooLowTrans.Formatted(SkillDefOf.Artistic.LabelCap));
return(false);
}
return(true);
}
public override bool HasJobOnThing(Pawn pawn, Thing t, bool forced = false)
{
Building building = t as Building;
if (building == null)
{
return(false);
}
if (!pawn.Map.listerBuildingsRepairable.Contains(pawn.Faction, building))
{
return(false);
}
if (!building.def.building.repairable)
{
return(false);
}
if (t.Faction != pawn.Faction)
{
return(false);
}
if (pawn.Faction == Faction.OfPlayer && !pawn.Map.areaManager.Home[t.Position])
{
JobFailReason.Is(WorkGiver_FixBrokenDownBuilding.NotInHomeAreaTrans);
return(false);
}
if (!t.def.useHitPoints || t.HitPoints == t.MaxHitPoints)
{
return(false);
}
LocalTargetInfo target = building;
return(pawn.CanReserve(target, 1, -1, null, forced) && building.Map.designationManager.DesignationOn(building, DesignationDefOf.Deconstruct) == null && !building.IsBurning());
}
public static void Postfix(ref Job __result, Pawn __0)
{
if (__result == null || !Settings.DisableNotToolWork || !ToolsFramework.Dictionaries.jobToolType.TryGetValue(__result.def, out var toolType) || !Dictionaries.SurvivalToolTypes[toolType] || !__0.CanUseTools(out var tracker))
{
return;
}
if (tracker.UsedHandler.BestTool[toolType] != null)
{
return;
}
var map = __0.MapHeld;
if (map != null)
{
var reservation = map.reservationManager;
var faction = __0.Faction;
var assignmentFilter = tracker.ToolAssignment.filter;
if (__0.MapHeld.GetMapToolTracker().StoredToolInfos.Any(t => t.comp.CompProp.ToolTypes.Contains(toolType) && !t.tool.IsForbidden(__0) && assignmentFilter.Allows(t.tool) &&
(reservation.ReservedBy(t.tool, __0) || !reservation.IsReservedByAnyoneOf(t.tool, faction))))
{
return;
}
}
#if DEBUG
Log.Message($"Test 1.2: No tools for {pawn} : {__result.def}");
JobFailReason.Is($"{pawn} lacks {toolType} for {__result.def}");
// JobFailReason.Is("ST_NoToolForJob3".Translate(pawn, toolType, __result.def));
#else
JobFailReason.Is($"Lacks {toolType} for job");
// JobFailReason.Is("ST_NoToolForJob1".Translate(toolType));
#endif
__result = null;
}
public override Job JobOnThing(Pawn pawn, Thing thing, bool forced = false)
{
ISlotGroupParent slotGroupParent = thing as ISlotGroupParent;
if (slotGroupParent == null)
{
return(null);
}
if (!pawn.CanReserve(thing.Position, 1, -1, null, false))
{
return(null);
}
int num = 0;
List <Thing> list = pawn.Map.thingGrid.ThingsListAt(thing.Position);
for (int i = 0; i < list.Count; i++)
{
Thing thing2 = list[i];
if (Building_NutrientPasteDispenser.IsAcceptableFeedstock(thing2.def))
{
num += thing2.stackCount;
}
}
if (num > 25)
{
JobFailReason.Is("AlreadyFilledLower".Translate());
return(null);
}
return(WorkGiver_CookFillHopper.HopperFillFoodJob(pawn, slotGroupParent));
}
public override bool WorkGiverChecks(Pawn pawn, Thing t, bool forced = false)
{
Pawn target = t as Pawn;
if (!xxx.is_animal(target))
{
return(false);
}
Building_Bed bed = pawn.ownership.OwnedBed;
if (bed == null)
{
if (RJWSettings.DevMode)
{
JobFailReason.Is("pawn has no bed");
}
return(false);
}
if (!target.CanReach(bed, PathEndMode.OnCell, Danger.Some) || target.Downed)
{
if (RJWSettings.DevMode)
{
JobFailReason.Is("target cant reach bed");
}
return(false);
}
return(true);
}
public override bool HasJobOnThing(Pawn pawn, Thing t, bool forced = false)
{
if (CompMachineChargingStation.cachedChargingStationsDict.TryGetValue(t, out CompMachineChargingStation comp))
{
if (comp == null || comp.turretToInstall == null)
{
return(false);
}
Pawn myPawn = comp.myPawn;
if (myPawn == null || myPawn.Dead || !myPawn.Spawned)
{
JobFailReason.Is("VFEMechNoTurret".Translate());
return(false);
}
List <ThingDefCountClass> products = comp.turretToInstall.costList;
foreach (ThingDefCountClass thingNeeded in products)
{
if (!pawn.Map.itemAvailability.ThingsAvailableAnywhere(thingNeeded, pawn))
{
JobFailReason.Is("VFEMechNoResources".Translate());
return(false);
}
}
return(pawn.CanReserveAndReach(t, PathEndMode.OnCell, Danger.Deadly, ignoreOtherReservations: forced));
}
return(false);
}
public static bool CanConstruct(Thing t, Pawn p, bool forced = false)
{
if (GenConstruct.FirstBlockingThing(t, p) != null)
{
return(false);
}
LocalTargetInfo target = t;
PathEndMode peMode = PathEndMode.Touch;
Danger maxDanger = (!forced) ? p.NormalMaxDanger() : Danger.Deadly;
if (!p.CanReserveAndReach(target, peMode, maxDanger, 1, -1, null, forced))
{
return(false);
}
if (t.IsBurning())
{
return(false);
}
if (p.skills.GetSkill(SkillDefOf.Construction).Level < t.def.constructionSkillPrerequisite)
{
JobFailReason.Is(GenConstruct.ConstructionSkillTooLowTrans);
return(false);
}
return(true);
}
private bool ValidateChosenWeapons(Bill bill, Pawn pawn, IBillGiver giver)
{
if ((bool)BestIngredientsInfo.Invoke(this, new object[] { bill, pawn, giver, chosenIngThings }))
{
var studyWeapons = StudyWeapons(bill, pawn);
chosenIngThings.RemoveAll(x => !studyWeapons.Contains(x.Thing.def));
if (chosenIngThings.Any())
{
if (!JobFailReason.HaveReason)
{
JobFailReason.Is("NoWeaponToLearn".Translate(pawn), null);
}
return(studyWeapons.Any());
}
}
if (!JobFailReason.HaveReason)
{
JobFailReason.Is("NoWeaponsFoundToLearn".Translate(pawn), null);
}
if (FloatMenuMakerMap.makingFor != pawn)
{
bill.lastIngredientSearchFailTicks = Find.TickManager.TicksGame;
}
return(false);
}
public static bool CanRefuel(Pawn pawn, Thing t, bool forced = false)
{
CompRefuelable compRefuelable = t.TryGetComp <CompRefuelable>();
if (compRefuelable == null || compRefuelable.IsFull || (!forced && !compRefuelable.allowAutoRefuel))
{
return(false);
}
if (!forced && !compRefuelable.ShouldAutoRefuelNow)
{
return(false);
}
if (t.IsForbidden(pawn) || !pawn.CanReserve(t, 1, -1, null, forced))
{
return(false);
}
if (t.Faction != pawn.Faction)
{
return(false);
}
if (FindBestFuel(pawn, t) == null)
{
ThingFilter fuelFilter = t.TryGetComp <CompRefuelable>().Props.fuelFilter;
JobFailReason.Is("NoFuelToRefuel".Translate(fuelFilter.Summary));
return(false);
}
if (t.TryGetComp <CompRefuelable>().Props.atomicFueling&& FindAllFuel(pawn, t) == null)
{
ThingFilter fuelFilter2 = t.TryGetComp <CompRefuelable>().Props.fuelFilter;
JobFailReason.Is("NoFuelToRefuel".Translate(fuelFilter2.Summary));
return(false);
}
return(true);
}
public static void Postfix(object __instance, Pawn pawn, ThingDef ___wantedPlantDef, ref Job __result)
{
if (pawn.TechBound())
{
var requisites = ___wantedPlantDef.plant?.sowResearchPrerequisites;
if (!requisites.NullOrEmpty())
{
var knownPlants = pawn.TryGetComp <CompKnowledge>().knownPlants;
if (Prefs.LogVerbose)
{
Log.Warning("[HumanResources] " + pawn + "'s plant knowledge: " + knownPlants);
}
bool flag = false;
if (!knownPlants.EnumerableNullOrEmpty())
{
flag = knownPlants.Contains(___wantedPlantDef);
}
if (!flag)
{
var missing = requisites.Where(x => !x.IsKnownBy(pawn));
string preReqText = (missing.Count() > 1) ? missing.Select(x => x.label).ToStringSafeEnumerable() : missing.FirstOrDefault().label;
JobFailReason.Is("DoesntKnowThisPlant".Translate(pawn, ___wantedPlantDef, preReqText));
__result = null;
}
}
}
}
protected override bool ValidateChosenWeapons(Bill bill, Pawn pawn, IBillGiver giver)
{
if ((bool)BestIngredientsInfo.Invoke(this, new object[] { bill, pawn, giver, chosenIngThings }))
{
var studyWeapons = StudyWeapons(bill, pawn);
chosenIngThings.RemoveAll(x => !studyWeapons.Contains(x.Thing.def));
if (chosenIngThings.Any())
{
if (!JobFailReason.HaveReason)
{
JobFailReason.Is("NoWeaponToLearn".Translate(pawn), null);
}
return(studyWeapons.Any());
}
var traumas = pawn.TryGetComp <CompKnowledge>().fearedWeapons;
if (!traumas.NullOrEmpty() && chosenIngThings.All(x => traumas.Contains(x.Thing.def)))
{
JobFailReason.Is("FearedWeapon".Translate(pawn));
}
}
if (!JobFailReason.HaveReason)
{
JobFailReason.Is("NoWeaponsFoundToLearn".Translate(pawn), null);
}
if (FloatMenuMakerMap.makingFor != pawn)
{
bill.lastIngredientSearchFailTicks = Find.TickManager.TicksGame;
}
return(false);
}
public void AssignHomework(IEnumerable <ResearchProjectDef> studyMaterial)
{
if (Prefs.LogVerbose)
{
Log.Message("Assigning homework for " + pawn + ", faction is " + pawn.Faction.IsPlayer + ", received " + studyMaterial.Count() + "projects, homework count is " + HomeWork.Count());
}
if (pawn.Faction.IsPlayer)
{
var expertiseKeys = from x in expertise
where x.Value >= 1f
select x.Key;
var available = studyMaterial.Except(expertiseKeys).Except(HomeWork);
if (!available.Any())
{
JobFailReason.Is("AlreadyKnowsTheWholeLibrary".Translate(pawn), null);
return;
}
if (Prefs.LogVerbose)
{
Log.Message("...Available projects: " + available.ToStringSafeEnumerable());
}
var derived = available.Where(t => t.prerequisites != null && t.prerequisites.All(r => expertise.Keys.Contains(r)));
var starters = available.Where(t => t.prerequisites.NullOrEmpty());
if (!starters.Any() && !derived.Any())
{
JobFailReason.Is("LacksFundamentalKnowledge".Translate(pawn), null);
return;
}
HomeWork.AddRange(starters.Concat(derived));
}
}
