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));
}
