public static void ReserveAsManyAsPossible(this Pawn p, List <LocalTargetInfo> target, Job job, int maxPawns = 1, int stackCount = -1, ReservationLayerDef layer = null) { if (!p.Spawned) { return; } for (int i = 0; i < target.Count; i++) { p.Map.reservationManager.Reserve(p, job, target[i], maxPawns, stackCount, layer, false); } }
public Reservation(Pawn claimant, Job job, int maxPawns, int stackCount, LocalTargetInfo target, ReservationLayerDef layer) { this.claimant = claimant; this.job = job; this.maxPawns = maxPawns; this.stackCount = stackCount; this.target = target; this.layer = layer; }
public static bool CanReserveAndReach(this Pawn p, LocalTargetInfo target, PathEndMode peMode, Danger maxDanger, int maxPawns = 1, int stackCount = -1, ReservationLayerDef layer = null, bool ignoreOtherReservations = false) { return(p.Spawned && p.CanReach(target, peMode, maxDanger, false, TraverseMode.ByPawn) && p.Map.reservationManager.CanReserve(p, target, maxPawns, stackCount, layer, ignoreOtherReservations)); }
public static Toil Reserve(TargetIndex ind, int maxPawns = 1, int stackCount = -1, ReservationLayerDef layer = null) { Toil toil = new Toil(); toil.initAction = delegate { if (!toil.actor.Reserve(toil.actor.jobs.curJob.GetTarget(ind), toil.actor.CurJob, maxPawns, stackCount, layer)) { toil.actor.jobs.EndCurrentJob(JobCondition.Incompletable, true); } }; toil.defaultCompleteMode = ToilCompleteMode.Instant; toil.atomicWithPrevious = true; return(toil); }
public int CanReserveStack(Pawn claimant, LocalTargetInfo target, int maxPawns = 1, ReservationLayerDef layer = null, bool ignoreOtherReservations = false) { if (claimant == null) { Log.Error("CanReserve with null claimant"); return(0); } if (!claimant.Spawned || claimant.Map != map) { return(0); } if (!target.IsValid || target.ThingDestroyed) { return(0); } if (target.HasThing && target.Thing.SpawnedOrAnyParentSpawned && target.Thing.MapHeld != map) { return(0); } int num = (!target.HasThing) ? 1 : target.Thing.stackCount; int num2 = 0; if (!ignoreOtherReservations) { if (map.physicalInteractionReservationManager.IsReserved(target) && !map.physicalInteractionReservationManager.IsReservedBy(claimant, target)) { return(0); } int num3 = 0; for (int i = 0; i < reservations.Count; i++) { Reservation reservation = reservations[i]; if (!(reservation.Target != target) && reservation.Layer == layer && reservation.Claimant != claimant && RespectsReservationsOf(claimant, reservation.Claimant)) { if (reservation.MaxPawns != maxPawns) { return(0); } num3++; num2 = ((reservation.StackCount != -1) ? (num2 + reservation.StackCount) : (num2 + num)); if (num3 >= maxPawns || num2 >= num) { return(0); } } } } return(Mathf.Max(num - num2, 0)); }
public bool Reserve(Pawn claimant, Job job, LocalTargetInfo target, int maxPawns = 1, int stackCount = -1, ReservationLayerDef layer = null) { if (maxPawns > 1 && stackCount == -1) { Log.ErrorOnce("Reserving with maxPawns > 1 and stackCount = All; this will not have a useful effect (suppressing future warnings)", 83269); } if (!target.IsValid) { return(false); } if (this.ReservedBy(target, claimant, job)) { return(true); } if (target.ThingDestroyed) { return(false); } if (job == null) { Log.Warning(string.Concat(new object[] { claimant, " tried to reserve thing ", target, " without a valid job" })); return(false); } if (this.CanReserve(claimant, target, maxPawns, stackCount, layer, false)) { this.reservations.Add(new Reservation(claimant, job, maxPawns, stackCount, target, layer)); return(true); } if (job != null && job.playerForced && this.CanReserve(claimant, target, maxPawns, stackCount, layer, true)) { this.reservations.Add(new Reservation(claimant, job, maxPawns, stackCount, target, layer)); foreach (Reservation current in new List <Reservation>(this.reservations)) { if (current.Target == target && current.Claimant != claimant && current.Layer == layer && ReservationManager.RespectsReservationsOf(claimant, current.Claimant)) { current.Claimant.jobs.EndJob(current.Job, JobCondition.InterruptForced); } } return(true); } this.LogCouldNotReserveError(claimant, job, target, maxPawns, stackCount, layer); return(false); }
public bool CanReserve(Pawn claimant, LocalTargetInfo target, int maxPawns = 1, int stackCount = -1, ReservationLayerDef layer = null, bool ignoreOtherReservations = false) { if (claimant == null) { Log.Error("CanReserve with claimant==null"); return(false); } if (!target.IsValid || (target.HasThing && target.Thing.Destroyed)) { return(false); } if (!claimant.Spawned || claimant.Map != this.map) { return(false); } if (target.HasThing && target.Thing.Spawned && target.Thing.Map != this.map) { return(false); } int num = 1; if (target.HasThing) { num = target.Thing.stackCount; } if (stackCount == -1) { stackCount = num; } if (stackCount > num) { return(false); } if (ignoreOtherReservations) { return(true); } if (this.map.physicalInteractionReservationManager.IsReserved(target) && !this.map.physicalInteractionReservationManager.IsReservedBy(claimant, target)) { return(false); } int num2 = 0; int count = this.reservations.Count; int num3 = 0; for (int i = 0; i < count; i++) { Reservation reservation = this.reservations[i]; if (!(reservation.Target != target)) { if (reservation.Layer == layer) { if (ReservationManager.RespectsReservationsOf(claimant, reservation.Claimant)) { if (reservation.Claimant == claimant) { return(true); } if (reservation.MaxPawns != maxPawns) { return(false); } num2++; if (reservation.StackCount == -1) { num3 = num; } else { num3 += reservation.StackCount; } if (num2 >= maxPawns || num3 + stackCount > num) { return(false); } } } } } return(true); }
private void LogCouldNotReserveError(Pawn claimant, Job job, LocalTargetInfo target, int maxPawns, int stackCount, ReservationLayerDef layer) { Job curJob = claimant.CurJob; string text = "null"; int num = -1; if (curJob != null) { text = curJob.ToString(); if (claimant.jobs.curDriver != null) { num = claimant.jobs.curDriver.CurToilIndex; } } string text2; if (target.HasThing && target.Thing.def.stackLimit != 1) { text2 = "(current stack count: " + target.Thing.stackCount + ")"; } else { text2 = string.Empty; } string text3 = string.Concat(new object[] { "Could not reserve ", target.ToStringSafe <LocalTargetInfo>(), text2, " (layer: ", layer.ToStringSafe <ReservationLayerDef>(), ") for ", claimant.ToStringSafe <Pawn>(), " for job ", job.ToStringSafe <Job>(), " (now doing job ", text, "(curToil=", num, ")) for maxPawns ", maxPawns, " and stackCount ", stackCount, "." }); Pawn pawn = this.FirstRespectedReserver(target, claimant); if (pawn != null) { string text4 = "null"; int num2 = -1; Job curJob2 = pawn.CurJob; if (curJob2 != null) { text4 = curJob2.ToStringSafe <Job>(); if (pawn.jobs.curDriver != null) { num2 = pawn.jobs.curDriver.CurToilIndex; } } string text5 = text3; text3 = string.Concat(new object[] { text5, " Existing reserver: ", pawn.ToStringSafe <Pawn>(), " doing job ", text4, " (toilIndex=", num2, ")" }); } else { text3 += " No existing reserver."; } Pawn pawn2 = this.map.physicalInteractionReservationManager.FirstReserverOf(target); if (pawn2 != null) { text3 = text3 + " Physical interaction reserver: " + pawn2.ToStringSafe <Pawn>(); } Log.Error(text3, false); }
private static bool Prefix(ref bool __result, ReservationManager __instance, Pawn claimant, LocalTargetInfo target, out bool __state, int maxPawns = 1, int stackCount = -1, ReservationLayerDef layer = null, bool ignoreOtherReservations = false) { __state = false; if (claimant.RaceProps.Humanlike && claimant.Map != null) { if (target.HasThing) { if (target.thingInt.Map != null && target.thingInt.Map != claimant.Map) { var cellToTeleport = ZUtils.GetCellToTeleportFrom(claimant.Map, claimant.Position, target.thingInt.Map); var cell = cellToTeleport.IsValid ? cellToTeleport : claimant.Position; __state = true; oldMap = claimant.Map; oldPosition = claimant.Position; ZUtils.TeleportThing(claimant, target.thingInt.Map, cell); __result = claimant.CanReserve(target, maxPawns, stackCount, layer, ignoreOtherReservations); return(false); } } else { if (ZUtils.ZTracker.jobTracker.TryGetValue(claimant, out var jobTracker) && jobTracker.lookedAtLocalCellMap != null && jobTracker.lookedAtLocalCellMap.TryGetValue(target.cellInt, out var mapDest)) { if (mapDest != null && mapDest != claimant.Map) { var cellToTeleport = ZUtils.GetCellToTeleportFrom(claimant.Map, claimant.Position, mapDest); var cell = cellToTeleport.IsValid ? cellToTeleport : claimant.Position; __state = true; oldMap = claimant.Map; oldPosition = claimant.Position; ZUtils.TeleportThing(claimant, mapDest, cell); __result = claimant.CanReserve(target, maxPawns, stackCount, layer, ignoreOtherReservations); return(false); } } } } return(true); }
public static bool Reserve(ReservationManager __instance, ref bool __result, Pawn claimant, Job job, LocalTargetInfo target, int maxPawns = 1, int stackCount = -1, ReservationLayerDef layer = null, bool errorOnFailed = true) { lock (__instance) { if (maxPawns > 1 && stackCount == -1) { Log.ErrorOnce("Reserving with maxPawns > 1 and stackCount = All; this will not have a useful effect (suppressing future warnings)", 83269); } if (job == null) { Log.Warning(claimant.ToStringSafe() + " tried to reserve thing " + target.ToStringSafe() + " without a valid job"); __result = false; return(false); } int num1 = (!target.HasThing) ? 1 : target.Thing.stackCount; int num2 = stackCount == -1 ? num1 : stackCount; List <Reservation> reservationTargetList = getReservationTargetList(__instance, target); foreach (Reservation reservation1 in reservationTargetList) { if (reservation1.Claimant == claimant && reservation1.Job == job && reservation1.Layer == layer) { if (reservation1.StackCount == -1 || reservation1.StackCount >= num2) { __result = true; return(false); } Log.Warning("Debug reservation"); } } if (!target.IsValid || target.ThingDestroyed) //TODO reservation should be removed when thing is destroyed { __result = false; return(false); } bool canReserveResult = __instance.CanReserve(claimant, target, maxPawns, stackCount, layer); Reservation reservation; Dictionary <LocalTargetInfo, List <Reservation> > reservationTargetDict; Dictionary <Pawn, List <Reservation> > reservationClaimantDict; Thing haulableThing; if (!canReserveResult) { if (job.playerForced && __instance.CanReserve(claimant, target, maxPawns, stackCount, layer, true)) { reservation = new Reservation(claimant, job, maxPawns, stackCount, target, layer); List <Reservation> claimantReservations; reservationTargetDict = getReservationTargetDict(__instance); //newReservationTargetList = new List<Reservation>(getReservationTargetList(reservationTargetDict, target)) //{ // reservation //}; getReservationTargetList(reservationTargetDict, target).Add(reservation); reservationClaimantDict = getReservationClaimantDict(__instance); //newReservationClaimantList = // new List<Reservation>(getReservationClaimantList(reservationClaimantDict, claimant)) // { // reservation // }; claimantReservations = getReservationClaimantList(reservationClaimantDict, claimant); claimantReservations.Add(reservation); foreach (Reservation reservation2 in claimantReservations) { if (reservation2.Claimant != claimant && (reservation2.Layer == layer && RespectsReservationsOf(claimant, reservation2.Claimant))) { reservation2.Claimant.jobs.EndCurrentOrQueuedJob(reservation2.Job, JobCondition.InterruptForced); } } haulableThing = target.Thing; if (haulableThing != null && haulableThing.def.EverHaulable && haulableThing.Map != null) { //Log.Message("DeregisterHaulableItem " + haulableThing.ToString()); HaulingCache.DeregisterHaulableItem(haulableThing); } __result = true; return(false); } //HACK - Probably because Reserve is no longer valid after CanReserve time delay with multiple threads. if (errorOnFailed) { //LogCouldNotReserveError(__instance, claimant, job, target, maxPawns, stackCount, layer); Log.Warning("ReservationManager.Reserve cannot reserve. This is likely because reservation is no longer valid after CanReserve was called due to time delay with multiple threads."); } __result = false; return(false); } reservation = new Reservation(claimant, job, maxPawns, stackCount, target, layer); reservationTargetDict = getReservationTargetDict(__instance); //newReservationTargetList = new List<Reservation>(getReservationTargetList(reservationTargetDict, target)) // { // reservation // }; getReservationTargetList(reservationTargetDict, target).Add(reservation); reservationClaimantDict = getReservationClaimantDict(__instance); //newReservationClaimantList = new List<Reservation>(getReservationClaimantList(reservationClaimantDict, claimant)) // { // reservation // }; getReservationClaimantList(reservationClaimantDict, claimant).Add(reservation); haulableThing = target.Thing; if (haulableThing != null && haulableThing.def.EverHaulable && haulableThing.Map != null) { //Log.Message("DeregisterHaulableItem " + haulableThing.ToString()); HaulingCache.DeregisterHaulableItem(haulableThing); } } __result = true; return(false); }
public bool CanReserve(Pawn claimant, LocalTargetInfo target, int maxPawns = 1, int stackCount = -1, ReservationLayerDef layer = null, bool ignoreOtherReservations = false) { if (claimant == null) { Log.Error("CanReserve with null claimant", false); return(false); } if (!claimant.Spawned || claimant.Map != this.map) { return(false); } if (!target.IsValid || target.ThingDestroyed) { return(false); } if (target.HasThing && target.Thing.SpawnedOrAnyParentSpawned && target.Thing.MapHeld != this.map) { return(false); } int num = (!target.HasThing) ? 1 : target.Thing.stackCount; int num2 = (stackCount != -1) ? stackCount : num; if (num2 > num) { return(false); } if (!ignoreOtherReservations) { if (this.map.physicalInteractionReservationManager.IsReserved(target) && !this.map.physicalInteractionReservationManager.IsReservedBy(claimant, target)) { return(false); } for (int i = 0; i < this.reservations.Count; i++) { ReservationManager.Reservation reservation = this.reservations[i]; if (reservation.Target == target && reservation.Layer == layer && reservation.Claimant == claimant && (reservation.StackCount == -1 || reservation.StackCount >= num2)) { return(true); } } int num3 = 0; int num4 = 0; for (int j = 0; j < this.reservations.Count; j++) { ReservationManager.Reservation reservation2 = this.reservations[j]; if (!(reservation2.Target != target) && reservation2.Layer == layer) { if (reservation2.Claimant != claimant) { if (ReservationManager.RespectsReservationsOf(claimant, reservation2.Claimant)) { if (reservation2.MaxPawns != maxPawns) { return(false); } num3++; if (reservation2.StackCount == -1) { num4 += num; } else { num4 += reservation2.StackCount; } if (num3 >= maxPawns || num2 + num4 > num) { return(false); } } } } } } return(true); }
public static bool CanReserveStack(ReservationManager __instance, ref int __result, Pawn claimant, LocalTargetInfo target, int maxPawns = 1, ReservationLayerDef layer = null, bool ignoreOtherReservations = false) { Map mapInstance = __instance.map; if (claimant == null) { Log.Error("CanReserve with null claimant"); __result = 0; return(false); } if (!claimant.Spawned || claimant.Map != mapInstance) { __result = 0; return(false); } if (!target.IsValid || target.ThingDestroyed) { __result = 0; return(false); } if (target.HasThing && target.Thing.SpawnedOrAnyParentSpawned && target.Thing.MapHeld != mapInstance) { __result = 0; return(false); } int num = (!target.HasThing) ? 1 : target.Thing.stackCount; int num2 = 0; if (!ignoreOtherReservations) { if (mapInstance.physicalInteractionReservationManager.IsReserved(target) && !mapInstance.physicalInteractionReservationManager.IsReservedBy(claimant, target)) { __result = 0; return(false); } int num3 = 0; List <Reservation> reservationTargetList = getReservationTargetList(__instance, target); foreach (Reservation reservation in reservationTargetList) { if (reservation.Layer == layer && reservation.Claimant != claimant && RespectsReservationsOf(claimant, reservation.Claimant)) { if (reservation.MaxPawns != maxPawns) { __result = 0; return(false); } num3++; num2 = ((reservation.StackCount != -1) ? (num2 + reservation.StackCount) : (num2 + num)); if (num3 >= maxPawns || num2 >= num) { __result = 0; return(false); } } } } __result = Mathf.Max(num - num2, 0); return(false); }
static void Postfix(ref bool __result, ReservationManager __instance, Pawn claimant, LocalTargetInfo target, int maxPawns, int stackCount, ReservationLayerDef layer, bool ignoreOtherReservations) { if (mapFI == null) { mapFI = typeof(ReservationManager).GetField("map", BindingFlags.NonPublic | BindingFlags.Instance); } #if DEBUG Log.Warning("\nCanReserve original result: " + __result); #endif if (!__result && mapFI != null && (target.Thing == null || target.Thing.def.defName.Equals("ChangeDresser"))) { Map m = (Map)mapFI.GetValue(__instance); if (m != null) { IEnumerable <Thing> things = m.thingGrid.ThingsAt(target.Cell); if (things != null) { #if DEBUG Log.Warning("CanReserve - Found things"); #endif foreach (Thing t in things) { #if DEBUG Log.Warning("CanReserve - def " + t.def.defName); #endif if (t.def.defName.Equals("ChangeDresser")) { #if DEBUG Log.Warning("CanReserve is now true\n"); #endif __result = true; } } } } } }
public static bool CanReserve(this Pawn p, LocalTargetInfo target, int maxPawns = 1, int stackCount = -1, ReservationLayerDef layer = null, bool ignoreOtherReservations = false) { return(p.Spawned && p.Map.reservationManager.CanReserve(p, target, maxPawns, stackCount, layer, ignoreOtherReservations)); }
public static bool CanReserveStack(ReservationManager __instance, ref int __result, Pawn claimant, LocalTargetInfo target, int maxPawns = 1, ReservationLayerDef layer = null, bool ignoreOtherReservations = false) { if (claimant == null) { Log.Error("CanReserve with null claimant"); __result = 0; return(false); } if (!claimant.Spawned || claimant.Map != map(__instance)) { __result = 0; return(false); } if (!target.IsValid || target.ThingDestroyed) { __result = 0; return(false); } if (target.HasThing && target.Thing.SpawnedOrAnyParentSpawned && target.Thing.MapHeld != map(__instance)) { __result = 0; return(false); } int num = (!target.HasThing) ? 1 : target.Thing.stackCount; int num2 = 0; if (!ignoreOtherReservations) { if (map(__instance).physicalInteractionReservationManager.IsReserved(target) && !map(__instance).physicalInteractionReservationManager.IsReservedBy(claimant, target)) { __result = 0; return(false); } int num3 = 0; Reservation reservation; for (int i = 0; i < reservations(__instance).Count; i++) { try { reservation = reservations(__instance)[i]; } catch (ArgumentOutOfRangeException) { break; } if (null != reservation) { if (!(reservation.Target != target) && reservation.Layer == layer && reservation.Claimant != claimant && RespectsReservationsOf(claimant, reservation.Claimant)) { if (reservation.MaxPawns != maxPawns) { __result = 0; return(false); } num3++; num2 = ((reservation.StackCount != -1) ? (num2 + reservation.StackCount) : (num2 + num)); if (num3 >= maxPawns || num2 >= num) { __result = 0; return(false); } } } } } __result = Mathf.Max(num - num2, 0); return(false); }
private static void Postfix(ref bool __result, Pawn claimant, LocalTargetInfo target, bool __state, int maxPawns = 1, int stackCount = -1, ReservationLayerDef layer = null, bool ignoreOtherReservations = false) { if (__state) { ZUtils.TeleportThing(claimant, oldMap, oldPosition); } if (__result) { var ZTracker = ZUtils.ZTracker; if (claimant.RaceProps.Humanlike && ZTracker.jobTracker != null) { var thing = target.thingInt; if (thing != null) { foreach (var data in ZTracker.jobTracker) { var otherPawn = data.Key; var otherPawnJobTracker = data.Value; if (otherPawn != claimant && otherPawnJobTracker.reservedThings != null) { foreach (var reservation in otherPawnJobTracker.reservedThings) { if (reservation.thingInt == target.thingInt) { var shouldChangeResult = !(otherPawn.jobs?.curDriver is JobDriver_TakeToBed);// || !(data.Key.jobs?.curDriver is JobDriver_LayDown)); if (shouldChangeResult) { try { ZLogger.Message("reservation.thingInt: " + reservation.thingInt + " - target.thingInt: " + target.thingInt); ZLogger.Message(data.Key + " - 1 data.Value.mainJob: " + data.Value.mainJob); ZLogger.Message(data.Key + " - 1 data.Key.CurJob: " + data.Key.CurJob); ZLogger.Message(data.Key + " - 1 thing.Map.reservationManager.reservations.Any(x => x.Target.thingInt == thing && x.claimant == data.Key): " + thing.Map.reservationManager.reservations.Any(x => x.Target.thingInt == thing && x.claimant == data.Key)); } catch { } if (otherPawn.Map == thing.Map && !thing.Map.reservationManager.reservations.Any(x => x.Target.thingInt == thing && x.claimant == otherPawn)) { ZLogger.Message($"PREVENTED ZTRACKER reservation disfunction: claimant: {claimant}, pawn: {data.Key}, thing: {thing}"); continue; } __result = false; ZLogger.Message($"shouldChangeResult Detected ZTRACKER reservation disfunction: claimant: {claimant}, pawn: {data.Key}, thing: {thing}"); return; } } //Log.Message($"ZTracker reservation: map: Reservation: {data.Key}, target: {reservation}, {data.Key.Map} - {reservation.Thing?.Map}"); } } } } else if (ZTracker.jobTracker.TryGetValue(claimant, out var jobTracker) && jobTracker.lookedAtLocalCellMap.TryGetValue(target.cellInt, out var mapDest) && mapDest != null) { var cell = target.cellInt; foreach (var data in ZTracker.jobTracker) { var otherPawn = data.Key; var otherPawnJobTracker = data.Value; if (otherPawn != claimant && otherPawnJobTracker.reservedCells != null) { foreach (var reservation in otherPawnJobTracker.reservedCells) { if (reservation.cellInt == cell && otherPawnJobTracker.mapDest == jobTracker.mapDest) { try { ZLogger.Message("claimant: " + claimant + " - " + otherPawn + " - 2 data.Value.mainJob: " + data.Value.mainJob); ZLogger.Message("claimant: " + claimant + " - " + otherPawn + " - 2 data.Key.CurJob: " + data.Key.CurJob); ZLogger.Message("claimant: " + claimant + " - " + otherPawn + " - 2 jobTracker.lookedAtMap.reservationManager.reservations.Any(x => !x.Target.HasThing && x.Target.cellInt == cell && x.claimant == data.Key)): " + jobTracker.mapDest.reservationManager.reservations.Any(x => !x.Target.HasThing && x.Target.cellInt == cell && x.claimant == data.Key)); } catch { } if (otherPawn.Map == jobTracker.mapDest && !jobTracker.mapDest.reservationManager.reservations.Any(x => !x.Target.HasThing && x.Target.cellInt == cell && x.claimant == otherPawn)) { ZLogger.Message($"2 PREVENTED ZTRACKER reservation disfunction: claimant: {claimant}, pawn: {data.Key}, cell: {cell}"); continue; } __result = false; ZLogger.Message($"reservation.cellInt == cell 2 Detected ZTRACKER reservation disfunction: claimant: {claimant}, pawn: {data.Key}, cell: {cell}"); return; } } } } } } } if (ZLogger.DebugEnabled) { if (!__result) { ZLogger.Error($"claimant {claimant} can't reserve target: {target}"); } } }
public static bool CanReserve(ReservationManager __instance, ref bool __result, Pawn claimant, LocalTargetInfo target, int maxPawns = 1, int stackCount = -1, ReservationLayerDef layer = null, bool ignoreOtherReservations = false) { if (claimant == null) { Log.Error("CanReserve with null claimant"); return(false); } if (!claimant.Spawned || claimant.Map != map(__instance)) { return(false); } if (!target.IsValid || target.ThingDestroyed) { return(false); } if (target.HasThing && target.Thing.SpawnedOrAnyParentSpawned && target.Thing.MapHeld != map(__instance)) { return(false); } int num = (!target.HasThing) ? 1 : target.Thing.stackCount; int num2 = (stackCount == -1) ? num : stackCount; if (num2 > num) { return(false); } if (!ignoreOtherReservations) { if (map(__instance).physicalInteractionReservationManager.IsReserved(target) && !map(__instance).physicalInteractionReservationManager.IsReservedBy(claimant, target)) { return(false); } for (int i = 0; i < reservations(__instance).Count; i++) { Reservation reservation; try { reservation = reservations(__instance)[i]; } catch (ArgumentOutOfRangeException) { break; } if (reservation != null && reservation.Target == target && reservation.Layer == layer && reservation.Claimant == claimant && (reservation.StackCount == -1 || reservation.StackCount >= num2)) { return(true); } } int num3 = 0; int num4 = 0; for (int j = 0; j < reservations(__instance).Count; j++) { Reservation reservation2; try { reservation2 = reservations(__instance)[j]; } catch (ArgumentOutOfRangeException) { break; } if (reservation2 != null && !(reservation2.Target != target) && reservation2.Layer == layer && reservation2.Claimant != claimant && RespectsReservationsOf(claimant, reservation2.Claimant)) { if (reservation2.MaxPawns != maxPawns) { return(false); } num3++; num4 = ((reservation2.StackCount != -1) ? (num4 + reservation2.StackCount) : (num4 + num)); if (num3 >= maxPawns || num2 + num4 > num) { return(false); } } } } return(true); }
private static bool Prefix(ref bool __result, ReservationManager __instance, Pawn claimant, LocalTargetInfo target, out bool __state, int maxPawns = 1, int stackCount = -1, ReservationLayerDef layer = null, bool ignoreOtherReservations = false) { __state = false; if (claimant.RaceProps.Humanlike) { if (target.HasThing && target.thingInt.Map != null && target.thingInt.Map != claimant.Map) { var cell = ZUtils.GetCellToTeleportFrom(claimant.Map, claimant.Position, target.thingInt.Map); if (cell.IsValid) { __state = true; oldMap = claimant.Map; oldPosition = claimant.Position; ZUtils.TeleportThing(claimant, target.thingInt.Map, cell); ZLogger.Message($"Teleporting claimaint {claimant} to {target.thingInt.Map}"); __result = claimant.CanReserve(target, maxPawns, stackCount, layer, ignoreOtherReservations); return(false); } else { ZLogger.Pause($"CanReserve: Detected reservation disfunction: pawn: {claimant}, thing: {target.thingInt}, pawn.Map: {claimant.Map}, thing.Map: {target.thingInt.Map}"); } } } return(true); }
private void LogCouldNotReserveError(Pawn claimant, Job job, LocalTargetInfo target, int maxPawns, int stackCount, ReservationLayerDef layer) { Job curJob = claimant.CurJob; string text = "null"; int num = -1; if (curJob != null) { text = curJob.ToString(); if (claimant.jobs.curDriver != null) { num = claimant.jobs.curDriver.CurToilIndex; } } Pawn pawn = this.FirstRespectedReserver(target, claimant); string text2 = "null"; int num2 = -1; if (pawn != null) { Job curJob2 = pawn.CurJob; if (curJob2 != null) { text2 = curJob2.ToString(); if (pawn.jobs.curDriver != null) { num2 = pawn.jobs.curDriver.CurToilIndex; } } } Log.Error(string.Concat(new object[] { "Could not reserve ", target, "/", layer, " for ", claimant, " for job ", job.ToStringSafe <Job>(), " (now doing job ", text, "(curToil=", num, ")) for maxPawns ", maxPawns, " and stackCount ", stackCount, ". Existing reserver: ", pawn, " doing job ", text2, "(curToil=", num2, ")" })); }
private static void Postfix(ref bool __result, Pawn claimant, LocalTargetInfo target, bool __state, int maxPawns = 1, int stackCount = -1, ReservationLayerDef layer = null, bool ignoreOtherReservations = false) { if (__state) { ZUtils.TeleportThing(claimant, oldMap, oldPosition); } if (__result) { var thing = target.Thing; if (thing != null) { if (claimant.RaceProps.Humanlike && target.HasThing) { var ZTracker = ZUtils.ZTracker; //foreach (var map in ZTracker.GetAllMaps(claimant.Map.Tile)) //{ // foreach (var reservation in map.reservationManager.reservations) // { // Log.Message($"map: {map}, Reservation: {reservation.claimant}, target: {reservation.target}, {reservation.claimant.Map} - {reservation.target.Thing?.Map}"); // } //} if (ZTracker.jobTracker != null) { foreach (var data in ZTracker.jobTracker) { if (data.Key != claimant && data.Value.reservedThings != null) { foreach (var reservation in data.Value.reservedThings) { if (reservation.HasThing && reservation.thingInt == target.thingInt) { var shouldChangeResult = !((data.Key.jobs?.curDriver is JobDriver_TakeToBed) || (data.Key.jobs?.curDriver is JobDriver_LayDown)); if (shouldChangeResult) { Log.Message(data.Key + " - data.Value.mainJob: " + data.Value.mainJob); Log.Message(data.Key + " - data.Key.CurJob: " + data.Key.CurJob); Log.Message(data.Key + " - thing.Map.reservationManager.reservations.Any(x => x.Target.thingInt == thing && x.claimant == data.Key): " + thing.Map.reservationManager.reservations.Any(x => x.Target.thingInt == thing && x.claimant == data.Key)); if (data.Key.Map == thing.Map && !thing.Map.reservationManager.reservations.Any(x => x.Target.thingInt == thing && x.claimant == data.Key)) { ZLogger.Error($"PREVENTED ZTRACKER reservation disfunction: claimant: {claimant}, pawn: {data.Key}, thing: {thing}"); continue; } __result = false; ZLogger.Message($"Detected ZTRACKER reservation disfunction: claimant: {claimant}, pawn: {data.Key}, thing: {thing}"); return; } } //Log.Message($"ZTracker reservation: map: Reservation: {data.Key}, target: {reservation}, {data.Key.Map} - {reservation.Thing?.Map}"); } } } } //Log.Message($"---------------------"); } //Log.Message($"{claimant} can reserve {target}: {__result}, {claimant.Map} - {target.Thing?.Map}"); //if (claimant.Map != thing.Map) //{ // ZLogger.Pause($"CanReserve: {__result}, Detected reservation disfunction: claimant.Map != thing.Map, claimant: {claimant}, thing: {thing}"); // var ZTracker = ZUtils.ZTracker; // foreach (var map in ZTracker.GetAllMaps(thing.Map.Tile)) // { // var pawn = map.reservationManager.FirstRespectedReserver(target, claimant); // if (pawn != null && pawn != claimant) // { // ZLogger.Pause($"CanReserve: {__result}, Detected reservation disfunction: claimant: {claimant}, pawn: {pawn}, thing: {thing}"); // } // } //} //else //{ // var ZTracker = ZUtils.ZTracker; // foreach (var map in ZTracker.GetAllMaps(thing.Map.Tile)) // { // var pawn = map.reservationManager.FirstRespectedReserver(target, claimant); // if (pawn != null && pawn != claimant) // { // ZLogger.Pause($"CanReserve: {__result}, Detected other claimant: first claimant: {claimant}, second claimant: {pawn}, thing: {thing}"); // } // } //} } } else if (ZLogger.DebugEnabled) { ZLogger.Message($"claimant {claimant} can't reserve target: {target}"); //var ZTracker = ZUtils.ZTracker; //if (target.HasThing) //{ // foreach (var map in ZTracker.GetAllMaps(claimant.Map.Tile)) // { // foreach (var reservation in map.reservationManager.reservations) // { // Log.Message($"Vanilla reservation: map: {map}, Reservation: {reservation.claimant}, target: {reservation.target}, {reservation.claimant.Map} - {reservation.target.Thing?.Map}"); // } // } // if (ZTracker.jobTracker != null) // { // foreach (var data in ZTracker.jobTracker) // { // if (data.Value.reservedThings != null) // { // foreach (var reservation in data.Value.reservedThings) // { // Log.Message($"ZTracker reservation: map: Reservation: {data.Key}, target: {reservation}, {data.Key.Map} - {reservation.Thing?.Map}"); // } // } // } // } //} } }
public static Toil ReserveQueue(TargetIndex ind, int maxPawns = 1, int stackCount = -1, ReservationLayerDef layer = null) { Toil toil = new Toil(); toil.initAction = delegate { List <LocalTargetInfo> targetQueue = toil.actor.jobs.curJob.GetTargetQueue(ind); if (targetQueue != null) { for (int i = 0; i < targetQueue.Count; i++) { if (!toil.actor.Reserve(targetQueue[i], toil.actor.CurJob, maxPawns, stackCount, layer)) { toil.actor.jobs.EndCurrentJob(JobCondition.Incompletable, true); } } } }; toil.defaultCompleteMode = ToilCompleteMode.Instant; toil.atomicWithPrevious = true; return(toil); }
private static void Prefix(ref int __result, ReservationManager __instance, Pawn claimant, LocalTargetInfo target, ref bool __state, int maxPawns = 1, ReservationLayerDef layer = null, bool ignoreOtherReservations = false) { if (target.HasThing && target.Thing.Map != claimant.Map) { oldMap = claimant.Map; ZUtils.TeleportThing(claimant, target.Thing.Map, claimant.Position); __state = true; } }
public static bool CanReserve(ref bool __result, Pawn p, LocalTargetInfo target, int maxPawns = 1, int stackCount = -1, ReservationLayerDef layer = null, bool ignoreOtherReservations = false) { if (!p.Spawned) { __result = false; return(false); } Map map = p.Map; ReservationManager reservationManager = map.reservationManager; __result = false; if (reservationManager != null) { __result = reservationManager.CanReserve( p, target, maxPawns, stackCount, layer, ignoreOtherReservations); } return(false); }
private static void Postfix(ReservationManager __instance, Pawn claimant, LocalTargetInfo target, ref bool __state, int maxPawns = 1, ReservationLayerDef layer = null, bool ignoreOtherReservations = false) { if (__state) { ZUtils.TeleportThing(claimant, oldMap, claimant.Position); } }
public bool Reserve(Pawn claimant, Job job, LocalTargetInfo target, int maxPawns = 1, int stackCount = -1, ReservationLayerDef layer = null, bool errorOnFailed = true) { if (maxPawns > 1 && stackCount == -1) { Log.ErrorOnce("Reserving with maxPawns > 1 and stackCount = All; this will not have a useful effect (suppressing future warnings)", 83269); } if (job == null) { Log.Warning(claimant.ToStringSafe() + " tried to reserve thing " + target.ToStringSafe() + " without a valid job"); return(false); } int num = (!target.HasThing) ? 1 : target.Thing.stackCount; int num2 = (stackCount != -1) ? stackCount : num; for (int i = 0; i < reservations.Count; i++) { Reservation reservation = reservations[i]; if (reservation.Target == target && reservation.Claimant == claimant && reservation.Job == job && reservation.Layer == layer && (reservation.StackCount == -1 || reservation.StackCount >= num2)) { return(true); } } if (!target.IsValid || target.ThingDestroyed) { return(false); } if (!CanReserve(claimant, target, maxPawns, stackCount, layer)) { if (job != null && job.playerForced && CanReserve(claimant, target, maxPawns, stackCount, layer, ignoreOtherReservations: true)) { reservations.Add(new Reservation(claimant, job, maxPawns, stackCount, target, layer)); foreach (Reservation item in reservations.ToList()) { if (item.Target == target && item.Claimant != claimant && item.Layer == layer && RespectsReservationsOf(claimant, item.Claimant)) { item.Claimant.jobs.EndCurrentOrQueuedJob(item.Job, JobCondition.InterruptForced); } } return(true); } if (errorOnFailed) { LogCouldNotReserveError(claimant, job, target, maxPawns, stackCount, layer); } return(false); } reservations.Add(new Reservation(claimant, job, maxPawns, stackCount, target, layer)); return(true); }
private void LogCouldNotReserveError(Pawn claimant, Job job, LocalTargetInfo target, int maxPawns, int stackCount, ReservationLayerDef layer) { Job curJob = claimant.CurJob; string text = "null"; int num = -1; if (curJob != null) { text = curJob.ToString(); if (claimant.jobs.curDriver != null) { num = claimant.jobs.curDriver.CurToilIndex; } } Pawn pawn = this.FirstRespectedReserver(target, claimant); string text2 = "null"; int num2 = -1; if (pawn != null) { Job curJob2 = pawn.CurJob; if (curJob2 != null) { text2 = curJob2.ToString(); if (pawn.jobs.curDriver != null) { num2 = pawn.jobs.curDriver.CurToilIndex; } } } Log.Error("Could not reserve " + target + "/" + layer + " for " + claimant + " for job " + job.ToStringSafe() + " (now doing job " + text + "(curToil=" + num + ")) for maxPawns " + maxPawns + " and stackCount " + stackCount + ". Existing reserver: " + pawn + " doing job " + text2 + "(curToil=" + num2 + ")"); }
private void LogCouldNotReserveError(Pawn claimant, Job job, LocalTargetInfo target, int maxPawns, int stackCount, ReservationLayerDef layer) { Job curJob = claimant.CurJob; string text = "null"; int num = -1; if (curJob != null) { text = curJob.ToString(); if (claimant.jobs.curDriver != null) { num = claimant.jobs.curDriver.CurToilIndex; } } string text2 = (!target.HasThing || target.Thing.def.stackLimit == 1) ? string.Empty : ("(current stack count: " + target.Thing.stackCount + ")"); string text3 = "Could not reserve " + target.ToStringSafe() + text2 + " (layer: " + layer.ToStringSafe() + ") for " + claimant.ToStringSafe() + " for job " + job.ToStringSafe() + " (now doing job " + text + "(curToil=" + num + ")) for maxPawns " + maxPawns + " and stackCount " + stackCount + "."; Pawn pawn = FirstRespectedReserver(target, claimant); if (pawn != null) { string text4 = "null"; int num2 = -1; Job curJob2 = pawn.CurJob; if (curJob2 != null) { text4 = curJob2.ToStringSafe(); if (pawn.jobs.curDriver != null) { num2 = pawn.jobs.curDriver.CurToilIndex; } } string text5 = text3; text3 = text5 + " Existing reserver: " + pawn.ToStringSafe() + " doing job " + text4 + " (toilIndex=" + num2 + ")"; } else { text3 += " No existing reserver."; } Pawn pawn2 = map.physicalInteractionReservationManager.FirstReserverOf(target); if (pawn2 != null) { text3 = text3 + " Physical interaction reserver: " + pawn2.ToStringSafe(); } Log.Error(text3); }
public static bool Reserve(ReservationManager __instance, ref bool __result, Pawn claimant, Job job, LocalTargetInfo target, int maxPawns = 1, int stackCount = -1, ReservationLayerDef layer = null, bool errorOnFailed = true) { if (maxPawns > 1 && stackCount == -1) { Log.ErrorOnce("Reserving with maxPawns > 1 and stackCount = All; this will not have a useful effect (suppressing future warnings)", 83269, false); } if (job == null) { Log.Warning(claimant.ToStringSafe() + " tried to reserve thing " + target.ToStringSafe() + " without a valid job"); __result = false; return(false); } int num1 = (!target.HasThing) ? 1 : target.Thing.stackCount; int num2 = stackCount == -1 ? num1 : stackCount; lock (reservations(__instance)) { for (int index = 0; index < reservations(__instance).Count; ++index) { Reservation reservation1; try { reservation1 = reservations(__instance)[index]; } catch (ArgumentOutOfRangeException) { break; } if (reservation1 != null && reservation1.Target == target && reservation1.Claimant == claimant && reservation1.Job == job && reservation1.Layer == layer && (reservation1.StackCount == -1 || reservation1.StackCount >= num2)) { __result = true; return(false); } } if (!target.IsValid || target.ThingDestroyed) { __result = false; return(false); } bool canReserveResult = __instance.CanReserve(claimant, target, maxPawns, stackCount, layer); if (!canReserveResult) { //bool canReserveResult2 = __instance.CanReserve(claimant, target, maxPawns, stackCount, layer); if (job != null && job.playerForced && __instance.CanReserve(claimant, target, maxPawns, stackCount, layer)) { reservations(__instance).Add(new Reservation(claimant, job, maxPawns, stackCount, target, layer)); //foreach (ReservationManager.Reservation reservation in reservations(__instance).ToList<ReservationManager.Reservation>()) Reservation reservation2; for (int index = 0; index < reservations(__instance).Count; index++) { try { reservation2 = reservations(__instance)[index]; } catch (ArgumentOutOfRangeException) { break; } if (reservation2.Target == target && reservation2.Claimant != claimant && (reservation2.Layer == layer && RespectsReservationsOf(claimant, reservation2.Claimant))) { reservation2.Claimant.jobs.EndCurrentOrQueuedJob(reservation2.Job, JobCondition.InterruptForced); } } __result = true; return(false); } //HACK - Probably because Reserve is no longer valid after CanReserve time delay with multiple threads. if (errorOnFailed) { //LogCouldNotReserveError(__instance, claimant, job, target, maxPawns, stackCount, layer); Log.Warning("ReservationManager.Reserve cannot reserve. This is likely because reservation is no longer valid after CanReserve was called due to time delay with multiple threads."); } __result = false; return(false); } reservations(__instance).Add(new ReservationManager.Reservation(claimant, job, maxPawns, stackCount, target, layer)); } __result = true; return(false); }
public static bool Reserve(this Pawn p, LocalTargetInfo target, Job job, int maxPawns = 1, int stackCount = -1, ReservationLayerDef layer = null) { return(p.Spawned && p.Map.reservationManager.Reserve(p, job, target, maxPawns, stackCount, layer)); }
public static bool ShouldReserve(Pawn p, LocalTargetInfo target, int maxPawns = 1, int stackCount = -1, ReservationLayerDef layer = null, bool ignoreOtherReservations = false) { if (p.TryGetComp <CompKnowledge>().knownWeapons.Contains(target.Thing.def)) { return(false); } return(p.CanReserve(target, maxPawns, stackCount, layer, ignoreOtherReservations)); }