public Pawn FirstRespectedReserver(LocalTargetInfo target, Pawn claimant)
{
int count = this.reservations.Count;
for (int i = 0; i < count; i++)
{
Reservation reservation = this.reservations[i];
if (reservation.Target == target && ReservationManager.RespectsReservationsOf(claimant, reservation.Claimant))
{
return(reservation.Claimant);
}
}
return(null);
}
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);
}
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 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, false);
}
if (job == null)
{
Log.Warning(claimant.ToStringSafe <Pawn>() + " tried to reserve thing " + target.ToStringSafe <LocalTargetInfo>() + " without a valid job", false);
return(false);
}
int num = (!target.HasThing) ? 1 : target.Thing.stackCount;
int num2 = (stackCount != -1) ? stackCount : num;
for (int i = 0; i < this.reservations.Count; i++)
{
ReservationManager.Reservation reservation = this.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 (this.CanReserve(claimant, target, maxPawns, stackCount, layer, false))
{
this.reservations.Add(new ReservationManager.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 ReservationManager.Reservation(claimant, job, maxPawns, stackCount, target, layer));
foreach (ReservationManager.Reservation current in this.reservations.ToList <ReservationManager.Reservation>())
{
if (current.Target == target && current.Claimant != claimant && current.Layer == layer && ReservationManager.RespectsReservationsOf(claimant, current.Claimant))
{
current.Claimant.jobs.EndCurrentOrQueuedJob(current.Job, JobCondition.InterruptForced);
}
}
return(true);
}
if (errorOnFailed)
{
this.LogCouldNotReserveError(claimant, job, target, maxPawns, stackCount, layer);
}
return(false);
}
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", false);
return(0);
}
if (!claimant.Spawned || claimant.Map != this.map)
{
return(0);
}
if (!target.IsValid || target.ThingDestroyed)
{
return(0);
}
if (target.HasThing && target.Thing.SpawnedOrAnyParentSpawned && target.Thing.MapHeld != this.map)
{
return(0);
}
int num = (!target.HasThing) ? 1 : target.Thing.stackCount;
int num2 = 0;
if (!ignoreOtherReservations)
{
if (this.map.physicalInteractionReservationManager.IsReserved(target) && !this.map.physicalInteractionReservationManager.IsReservedBy(claimant, target))
{
return(0);
}
int num3 = 0;
for (int i = 0; i < this.reservations.Count; i++)
{
ReservationManager.Reservation reservation = this.reservations[i];
if (!(reservation.Target != target) && reservation.Layer == layer)
{
if (reservation.Claimant != claimant)
{
if (ReservationManager.RespectsReservationsOf(claimant, reservation.Claimant))
{
if (reservation.MaxPawns != maxPawns)
{
return(0);
}
num3++;
if (reservation.StackCount == -1)
{
num2 += num;
}
else
{
num2 += reservation.StackCount;
}
if (num3 >= maxPawns || num2 >= num)
{
return(0);
}
}
}
}
}
}
return(Mathf.Max(num - num2, 0));
}
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 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, false);
}
bool result;
if (!target.IsValid)
{
result = false;
}
else if (this.ReservedBy(target, claimant, job))
{
result = true;
}
else if (target.ThingDestroyed)
{
result = false;
}
else if (job == null)
{
Log.Warning(claimant.ToStringSafe <Pawn>() + " tried to reserve thing " + target.ToStringSafe <LocalTargetInfo>() + " without a valid job", false);
result = false;
}
else if (!this.CanReserve(claimant, target, maxPawns, stackCount, layer, false))
{
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 reservation in new List <Reservation>(this.reservations))
{
if (reservation.Target == target && reservation.Claimant != claimant && reservation.Layer == layer && ReservationManager.RespectsReservationsOf(claimant, reservation.Claimant))
{
reservation.Claimant.jobs.EndJob(reservation.Job, JobCondition.InterruptForced);
}
}
result = true;
}
else
{
this.LogCouldNotReserveError(claimant, job, target, maxPawns, stackCount, layer);
result = false;
}
}
else
{
this.reservations.Add(new Reservation(claimant, job, maxPawns, stackCount, target, layer));
result = true;
}
return(result);
}
