public bool IsReservedBy(Pawn claimant, IAttackTarget target)
{
for (int i = 0; i < reservations.Count; i++)
{
AttackTargetReservation attackTargetReservation = reservations[i];
if (attackTargetReservation.target == target && attackTargetReservation.claimant == claimant)
{
return(true);
}
}
return(false);
}
private int GetReservationsCount(IAttackTarget target, Faction faction)
{
int num = 0;
for (int i = 0; i < reservations.Count; i++)
{
AttackTargetReservation attackTargetReservation = reservations[i];
if (attackTargetReservation.target == target && attackTargetReservation.claimant.Faction == faction)
{
num++;
}
}
return(num);
}
public void Reserve(Pawn claimant, Job job, IAttackTarget target)
{
if (target == null)
{
Log.Warning(string.Concat(claimant, " tried to reserve null attack target."));
}
else if (!IsReservedBy(claimant, target))
{
AttackTargetReservation attackTargetReservation = new AttackTargetReservation();
attackTargetReservation.target = target;
attackTargetReservation.claimant = claimant;
attackTargetReservation.job = job;
reservations.Add(attackTargetReservation);
}
}
public static bool ReleaseAllClaimedBy(AttackTargetReservationManager __instance, Pawn claimant)
{
lock (reservations(__instance))
{
for (int num = reservations(__instance).Count - 1; num >= 0; num--)
{
AttackTargetReservation reservation = reservations(__instance)[num];
if (reservation != null && reservation.claimant == claimant)
{
reservations(__instance).RemoveAt(num);
}
}
}
return(false);
}
public static bool FirstReservationFor(AttackTargetReservationManager __instance, ref IAttackTarget __result, Pawn claimant)
{
List <AttackTargetReservation> snapshotReservations = reservations(__instance);
for (int i = snapshotReservations.Count - 1; i >= 0; i--)
{
AttackTargetReservation reservation = snapshotReservations[i];
if (reservation.claimant == claimant)
{
__result = reservation.target;
return(false);
}
}
__result = null;
return(false);
}
public static bool GetReservationsCount(AttackTargetReservationManager __instance, ref int __result, IAttackTarget target, Faction faction)
{
int num = 0;
List <AttackTargetReservation> snapshotReservations = __instance.reservations;
for (int i = 0; i < snapshotReservations.Count; i++)
{
AttackTargetReservation attackTargetReservation = snapshotReservations[i];
if (attackTargetReservation.target == target && attackTargetReservation.claimant.Faction == faction)
{
num++;
}
}
__result = num;
return(false);
}
public static bool IsReservedBy(AttackTargetReservationManager __instance, ref bool __result, Pawn claimant, IAttackTarget target)
{
List <AttackTargetReservation> snapshotReservations = reservations(__instance);
for (int i = 0; i < snapshotReservations.Count; i++)
{
AttackTargetReservation attackTargetReservation = snapshotReservations[i];
if (attackTargetReservation.target == target && attackTargetReservation.claimant == claimant)
{
__result = true;
return(false);
}
}
__result = false;
return(false);
}
public void Release(Pawn claimant, Job job, IAttackTarget target)
{
if (target == null)
{
Log.Warning(string.Concat(claimant, " tried to release reservation on null attack target."));
return;
}
for (int i = 0; i < reservations.Count; i++)
{
AttackTargetReservation attackTargetReservation = reservations[i];
if (attackTargetReservation.target == target && attackTargetReservation.claimant == claimant && attackTargetReservation.job == job)
{
reservations.RemoveAt(i);
return;
}
}
Log.Warning(string.Concat(claimant, " with job ", job, " tried to release reservation on target ", target, ", but it's not reserved by him."));
}
public static bool ReleaseAllClaimedBy(AttackTargetReservationManager __instance, Pawn claimant)
{
lock (RimThreaded.map_AttackTargetReservationManager_reservations_Lock)
{
List <AttackTargetReservation> snapshotReservations = __instance.reservations;
List <AttackTargetReservation> newAttackTargetReservations = new List <AttackTargetReservation>(snapshotReservations.Count);
for (int i = 0; i < snapshotReservations.Count - 1; i++)
{
AttackTargetReservation attackTargetReservation = snapshotReservations[i];
if (attackTargetReservation.claimant != claimant)
{
newAttackTargetReservations.Add(attackTargetReservation);
}
}
__instance.reservations = newAttackTargetReservations;
}
return(false);
}
private static int GetReservationsCount2(AttackTargetReservationManager __instance, IAttackTarget target, Faction faction)
{
int num = 0;
for (int i = 0; i < reservations(__instance).Count; i++)
{
AttackTargetReservation attackTargetReservation = reservations(__instance)[i];
if (attackTargetReservation != null)
{
if (attackTargetReservation.target == target && attackTargetReservation.claimant != null && attackTargetReservation.claimant.Faction == faction)
{
num++;
}
}
}
return(num);
}
public static bool ReleaseAllForTarget(AttackTargetReservationManager __instance, IAttackTarget target)
{
List <AttackTargetReservation> attackTargetReservations = reservations(__instance);
lock (attackTargetReservations)
{
for (int i = attackTargetReservations.Count - 1; i >= 0; i--)
{
AttackTargetReservation attackTargetReservation = attackTargetReservations[i];
if (attackTargetReservation != null && attackTargetReservation.target == target)
{
attackTargetReservations.RemoveAt(i);
}
}
}
return(false);
}
public static bool ReleaseAllForTarget(AttackTargetReservationManager __instance, IAttackTarget target)
{
lock (RimThreaded.map_AttackTargetReservationManager_reservations_Lock)
{
List <AttackTargetReservation> snapshotReservations = reservations(__instance);
List <AttackTargetReservation> newAttackTargetReservations = new List <AttackTargetReservation>(snapshotReservations.Count);
for (int i = 0; i < snapshotReservations.Count - 1; i++)
{
AttackTargetReservation attackTargetReservation = snapshotReservations[i];
if (attackTargetReservation.target != target)
{
newAttackTargetReservations.Add(attackTargetReservation);
}
}
reservations(__instance) = newAttackTargetReservations;
}
return(false);
}
public void Reserve(AttackTargetReservationManager __instance, Pawn claimant, Job job, IAttackTarget target)
{
bool isReservedBy = __instance.IsReservedBy(claimant, target);
if (target == null)
{
Log.Warning(claimant + " tried to reserve null attack target.");
}
else if (!isReservedBy)
{
AttackTargetReservation attackTargetReservation = new AttackTargetReservation();
attackTargetReservation.target = target;
attackTargetReservation.claimant = claimant;
attackTargetReservation.job = job;
lock (reservations(__instance))
{
reservations(__instance).Add(attackTargetReservation);
}
}
}
public void Release(Pawn claimant, Job job, IAttackTarget target)
{
if (target == null)
{
Log.Warning(claimant + " tried to release reservation on null attack target.");
}
else
{
for (int i = 0; i < this.reservations.Count; i++)
{
AttackTargetReservation attackTargetReservation = this.reservations[i];
if (attackTargetReservation.target == target && attackTargetReservation.claimant == claimant && attackTargetReservation.job == job)
{
this.reservations.RemoveAt(i);
return;
}
}
Log.Warning(claimant + " with job " + job + " tried to release reservation on target " + target + ", but it's not reserved by him.");
}
}
public static bool Reserve(AttackTargetReservationManager __instance, Pawn claimant, Job job, IAttackTarget target)
{
if (target == null)
{
Log.Warning(string.Concat(claimant, " tried to reserve null attack target."));
}
else if (!__instance.IsReservedBy(claimant, target))
{
AttackTargetReservation attackTargetReservation = new AttackTargetReservation
{
target = target,
claimant = claimant,
job = job
};
lock (RimThreaded.map_AttackTargetReservationManager_reservations_Lock)
{
__instance.reservations = new List <AttackTargetReservation>(__instance.reservations)
{
attackTargetReservation
};
}
}
return(false);
}
