public void ExposeData()
{
Scribe_Collections.Look <ReservationManager.Reservation>(ref this.reservations, "reservations", LookMode.Deep, new object[0]);
if (Scribe.mode == LoadSaveMode.PostLoadInit)
{
for (int i = this.reservations.Count - 1; i >= 0; i--)
{
ReservationManager.Reservation reservation = this.reservations[i];
if (reservation.Target.Thing != null && reservation.Target.Thing.Destroyed)
{
Log.Error("Loaded reservation with destroyed target: " + reservation + ". Deleting it...", false);
this.reservations.Remove(reservation);
}
if (reservation.Claimant != null && reservation.Claimant.Destroyed)
{
Log.Error("Loaded reservation with destroyed claimant: " + reservation + ". Deleting it...", false);
this.reservations.Remove(reservation);
}
if (reservation.Claimant == null)
{
Log.Error("Loaded reservation with null claimant: " + reservation + ". Deleting it...", false);
this.reservations.Remove(reservation);
}
if (reservation.Job == null)
{
Log.Error("Loaded reservation with null job: " + reservation + ". Deleting it...", false);
this.reservations.Remove(reservation);
}
}
}
}
internal void DebugDrawReservations()
{
for (int i = 0; i < this.reservations.Count; i++)
{
ReservationManager.Reservation reservation = this.reservations[i];
if (reservation.Target.Thing != null)
{
if (reservation.Target.Thing.Spawned)
{
Thing thing = reservation.Target.Thing;
Vector3 s = new Vector3((float)thing.RotatedSize.x, 1f, (float)thing.RotatedSize.z);
Matrix4x4 matrix = default(Matrix4x4);
matrix.SetTRS(thing.DrawPos + Vector3.up * 0.1f, Quaternion.identity, s);
Graphics.DrawMesh(MeshPool.plane10, matrix, ReservationManager.DebugReservedThingIcon, 0);
GenDraw.DrawLineBetween(reservation.Claimant.DrawPos, reservation.Target.Thing.DrawPos);
}
else
{
Graphics.DrawMesh(MeshPool.plane03, reservation.Claimant.DrawPos + Vector3.up + new Vector3(0.5f, 0f, 0.5f), Quaternion.identity, ReservationManager.DebugReservedThingIcon, 0);
}
}
else
{
Graphics.DrawMesh(MeshPool.plane10, reservation.Target.Cell.ToVector3ShiftedWithAltitude(AltitudeLayer.MetaOverlays), Quaternion.identity, ReservationManager.DebugReservedThingIcon, 0);
GenDraw.DrawLineBetween(reservation.Claimant.DrawPos, reservation.Target.Cell.ToVector3ShiftedWithAltitude(AltitudeLayer.MetaOverlays));
}
}
}
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 bool ReservedBy <TDriver>(LocalTargetInfo target, Pawn claimant, LocalTargetInfo?targetAIsNot = null, LocalTargetInfo?targetBIsNot = null, LocalTargetInfo?targetCIsNot = null)
{
if (!target.IsValid)
{
return(false);
}
for (int i = 0; i < this.reservations.Count; i++)
{
ReservationManager.Reservation reservation = this.reservations[i];
if (reservation.Target == target && reservation.Claimant == claimant && reservation.Job != null && reservation.Job.GetCachedDriver(claimant) is TDriver && (!targetAIsNot.HasValue || reservation.Job.targetA != targetAIsNot) && (!targetBIsNot.HasValue || reservation.Job.targetB != targetBIsNot) && (!targetCIsNot.HasValue || reservation.Job.targetC != targetCIsNot))
{
return(true);
}
}
return(false);
}
public bool ReservedBy(LocalTargetInfo target, Pawn claimant, Job job = null)
{
if (!target.IsValid)
{
return(false);
}
for (int i = 0; i < this.reservations.Count; i++)
{
ReservationManager.Reservation reservation = this.reservations[i];
if (reservation.Target == target && reservation.Claimant == claimant && (job == null || reservation.Job == job))
{
return(true);
}
}
return(false);
}
public Pawn FirstRespectedReserver(LocalTargetInfo target, Pawn claimant)
{
if (!target.IsValid)
{
return(null);
}
for (int i = 0; i < this.reservations.Count; i++)
{
ReservationManager.Reservation reservation = this.reservations[i];
if (reservation.Target == target && ReservationManager.RespectsReservationsOf(claimant, reservation.Claimant))
{
return(reservation.Claimant);
}
}
return(null);
}
public bool IsReservedByAnyoneOf(LocalTargetInfo target, Faction faction)
{
if (!target.IsValid)
{
return(false);
}
for (int i = 0; i < this.reservations.Count; i++)
{
ReservationManager.Reservation reservation = this.reservations[i];
if (reservation.Target == target && reservation.Claimant.Faction == faction)
{
return(true);
}
}
return(false);
}
public void Release(LocalTargetInfo target, Pawn claimant, Job job)
{
if (target.ThingDestroyed)
{
Log.Warning(string.Concat(new object[]
{
"Releasing destroyed thing ",
target,
" for ",
claimant
}), false);
}
ReservationManager.Reservation reservation = null;
for (int i = 0; i < this.reservations.Count; i++)
{
ReservationManager.Reservation reservation2 = this.reservations[i];
if (reservation2.Target == target && reservation2.Claimant == claimant && reservation2.Job == job)
{
reservation = reservation2;
break;
}
}
if (reservation == null && !target.ThingDestroyed)
{
Log.Error(string.Concat(new object[]
{
"Tried to release ",
target,
" that wasn't reserved by ",
claimant,
"."
}), false);
return;
}
this.reservations.Remove(reservation);
}
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);
}
private static Thing <AllReservedThings> m__0(ReservationManager.Reservation res)
{
return(res.Target.Thing);
}
