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);
}
}
private static void Postfix(Reachability __instance, ref bool __result, IntVec3 start, LocalTargetInfo dest, PathEndMode peMode, TraverseParms traverseParams, bool __state)
{
if (__state && traverseParams.pawn != null)
{
ZUtils.TeleportThing(traverseParams.pawn, oldMap, oldPosition);
}
}
public static void Prefix(Verb_LaunchProjectile __instance, List <IntVec3> ___tempLeanShootSources, List <IntVec3> ___tempDestList, LocalTargetInfo ___currentTarget, ref bool __result)
{
//ZLogger.Message("__instance.caster: " + __instance.caster, true);
//ZLogger.Message("__instance.caster.Map: " + __instance.caster.Map, true);
//ZLogger.Message("__instance.caster.Map.Tile: " + __instance.caster.Map.Tile, true);
//
//ZLogger.Message("___currentTarget.Thing: " + ___currentTarget.Thing, true);
//ZLogger.Message("___currentTarget.Thing?.Map: " + ___currentTarget.Thing?.Map, true);
//ZLogger.Message("___currentTarget.Thing?.Map.Tile: " + ___currentTarget.Thing?.Map.Tile, true);
if (__instance.caster.Map != ___currentTarget.Thing?.Map && __instance.caster.Map.Tile == ___currentTarget.Thing?.Map?.Tile)
{
var ind1 = ZUtils.ZTracker.GetZIndexFor(__instance.caster.Map);
var ind2 = ZUtils.ZTracker.GetZIndexFor(___currentTarget.Thing.Map);
if (ind1 > ind2)
{
teleportBack = true;
targetOldMap = ___currentTarget.Thing.Map;
ZUtils.TeleportThing(___currentTarget.Thing, __instance.caster.Map, ___currentTarget.Thing.Position);
RoofAndFloorPatches.Patch_SpawnSetup.doTeleport = false;
}
else if (ind1 < ind2)
{
teleportBack = true;
casterOldMap = __instance.caster.Map;
ZUtils.TeleportThing(__instance.caster, ___currentTarget.Thing.Map, __instance.caster.Position);
RoofAndFloorPatches.Patch_SpawnSetup.doTeleport = false;
}
}
}
private static bool Prefix(ref bool __result, Reachability __instance, IntVec3 start, LocalTargetInfo dest, PathEndMode peMode, TraverseParms traverseParams, out bool __state)
{
__state = false;
var pawn = traverseParams.pawn;
if (pawn != null)
{
if (pawn.RaceProps.Humanlike)
{
if (dest.HasThing && dest.thingInt.Map != null && dest.thingInt.Map != pawn.Map)
{
var cell = ZUtils.GetCellToTeleportFrom(pawn.Map, pawn.Position, dest.thingInt.Map);
if (cell.IsValid)
{
__state = true;
oldMap = pawn.Map;
oldPosition = pawn.Position;
ZUtils.TeleportThing(pawn, dest.thingInt.Map, cell);
if (dest.thingInt.Map != __instance.map)
{
__result = dest.thingInt.Map.reachability.CanReach(start, dest, peMode, traverseParams);
ZLogger.Message($"CanReach: Used other's map reachability: pawn: {pawn}, thing: {dest.thingInt}, pawn.Map: {pawn.Map}, thing.Map: {dest.thingInt.Map}, result: {__result}");
return(false);
}
}
else
{
ZLogger.Pause($"CanReach: Detected reachability disfunction: pawn: {pawn}, thing: {dest.thingInt}, pawn.Map: {pawn.Map}, thing.Map: {dest.thingInt.Map}");
}
}
}
}
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);
}
public static void Postfix(Verb __instance, IntVec3 root, LocalTargetInfo targ, ref ShootLine resultingLine, ref bool __result)
{
if (teleportBack)
{
if (oldMap1 != null)
{
ZUtils.TeleportThing(targ.Thing, oldMap1, targ.Thing.Position);
oldMap1 = null;
}
else if (oldMap2 != null)
{
ZUtils.TeleportThing(__instance.caster, oldMap2, __instance.caster.Position);
oldMap2 = null;
}
if (__result)
{
if (ind1 > ind2 && !IsVoidsEverywhereInShootingLine(resultingLine, __instance.caster.Map, __instance.caster, targ.Thing))
{
__result = false;
}
else if (ind1 < ind2 && !IsVoidsEverywhereInShootingLineInBackWard(resultingLine, targ.Thing.Map, __instance.caster, targ.Thing))
{
__result = false;
}
}
ind1 = 0;
ind2 = 0;
teleportBack = false;
}
}
public static bool Prefix(ref IAttackTarget __result, IAttackTargetSearcher searcher,
TargetScanFlags flags, Predicate <Thing> validator = null, float minDist = 0f,
float maxDist = 9999f, IntVec3 locus = default(IntVec3),
float maxTravelRadiusFromLocus = 3.40282347E+38f, bool canBash = false,
bool canTakeTargetsCloserThanEffectiveMinRange = true)
{
bool result = true;
if (!recursiveTrap)
{
recursiveTrap = true;
Map oldMap = searcher.Thing.Map;
IntVec3 oldPosition = searcher.Thing.Position;
foreach (var map in ZUtils.GetAllMapsInClosestOrder(searcher.Thing, oldMap, oldPosition))
{
var target = AttackTargetFinder.BestAttackTarget(searcher, flags, validator, minDist,
maxDist, locus, maxTravelRadiusFromLocus, canBash, canTakeTargetsCloserThanEffectiveMinRange);
Log.Message(ZUtils.ZTracker.GetMapInfo(searcher.Thing.Map) + " - result: " + target);
if (target != null)
{
__result = target;
result = false;
break;
}
}
ZUtils.TeleportThing(searcher.Thing, oldMap, oldPosition);
recursiveTrap = false;
}
return(result);
}
private static bool Prefix(ref JobGiver_AIFightEnemy __instance, ref Job __result, ref Pawn pawn)
{
bool result = true;
if (!recursiveTrap)
{
recursiveTrap = true;
Map oldMap = pawn.Map;
IntVec3 oldPosition = pawn.Position;
foreach (var map in ZUtils.GetAllMapsInClosestOrder(pawn, oldMap, oldPosition))
{
var job = Traverse.Create(__instance).Method("TryGiveJob", new object[]
{
pawn
}).GetValue <Job>();
Log.Message("2: " + ZUtils.ZTracker.GetMapInfo(pawn.Map) + " - result: " + job);
if (job != null)
{
__result = job;
result = false;
break;
}
}
ZUtils.TeleportThing(pawn, oldMap, oldPosition);
recursiveTrap = false;
}
Log.Message(pawn + " - 4 TEST: " + __result);
return(result);
}
public static FloatMenuOption AddCaptureOption(Pawn pawn, Pawn victim)
{
var floatOption = FloatMenuUtility.DecoratePrioritizedTask(new FloatMenuOption("Capture".Translate
(victim.LabelCap, victim), delegate()
{
var ZTracker = ZUtils.ZTracker;
var oldMap = pawn.Map;
var oldPosition1 = pawn.Position;
var oldPosition2 = victim.Position;
bool select = Find.Selector.SelectedObjects.Contains(pawn);
Building building_Bed = null;
foreach (var otherMap in ZUtils.GetAllMapsInClosestOrderForTwoThings(pawn, oldMap, oldPosition1,
victim, oldMap, oldPosition2))
{
building_Bed = RestUtility.FindBedFor(victim, pawn, true, false, false);
if (building_Bed == null)
{
building_Bed = RestUtility.FindBedFor(victim, pawn, true, false, true);
}
if (building_Bed != null)
{
break;
}
}
ZUtils.TeleportThing(pawn, oldMap, oldPosition1);
ZUtils.TeleportThing(victim, oldMap, oldPosition2);
if (select)
{
Find.Selector.Select(pawn);
}
if (building_Bed == null)
{
Messages.Message("CannotCapture".Translate() + ": " + "NoPrisonerBed".Translate(), victim,
MessageTypeDefOf.RejectInput, false);
return;
}
Job job = JobMaker.MakeJob(JobDefOf.Capture, victim, building_Bed);
job.count = 1;
ZTracker.BuildJobListFor(pawn, pawn.Map, job);
ZLogger.Message(pawn + " taking first job 3");
pawn.jobs.EndCurrentJob(JobCondition.InterruptForced, false);
PlayerKnowledgeDatabase.KnowledgeDemonstrated(ConceptDefOf.Capturing, KnowledgeAmount.Total);
if (victim.Faction != null && victim.Faction != Faction.OfPlayer &&
!victim.Faction.def.hidden && !victim.Faction.HostileTo(Faction.OfPlayer) &&
!victim.IsPrisonerOfColony)
{
Messages.Message("MessageCapturingWillAngerFaction".Translate(victim.Named("PAWN"))
.AdjustedFor(victim, "PAWN", true), victim, MessageTypeDefOf.CautionInput, false);
}
}, MenuOptionPriority.RescueOrCapture, null, victim, 0f, null, null), pawn, victim, "ReservedBy");
return(floatOption);
}
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;
}
}
private static void Postfix(Reachability __instance, ref bool __result, IntVec3 start, LocalTargetInfo dest, PathEndMode peMode, TraverseParms traverseParams, bool __state)
{
if (__state && traverseParams.pawn != null)
{
//Log.Message("Postfix: dest: " + dest + " - dest.thingInt.Map: " + dest.thingInt?.Map + " - pawn.Map: " + traverseParams.pawn.Map + " - __instance: " + __instance.map);
ZUtils.TeleportThing(traverseParams.pawn, oldMap, oldPosition);
}
//if (dest.HasThing)
//{
// Log.Message($"{pawn} can reach {dest}: {__result}, {pawn.Map} - {dest.Thing.Map}");
//}
}
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)
{
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);
ZLogger.Message($"Teleporting claimaint {claimant} to {target.thingInt.Map}");
__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);
ZLogger.Message($"3 Teleporting claimaint {claimant} to {mapDest}");
__result = claimant.CanReserve(target, maxPawns, stackCount, layer, ignoreOtherReservations);
return(false);
}
}
//else
//{
// if (ZUtils.ZTracker.jobTracker.TryGetValue(claimant, out var job))
// {
// }
// ZLogger.Pause($"2 Unsupported target (most likely cell), claimant: {claimant}, target {target}");
//}
}
}
return(true);
}
public static bool Prefix(ref IAttackTarget __result, List <IAttackTarget> ___tmpTargets, List <Pair <IAttackTarget, float> > ___availableShootingTargets,
List <float> ___tmpTargetScores, List <bool> ___tmpCanShootAtTarget, List <IntVec3> ___tempDestList, List <IntVec3> ___tempSourceList,
IAttackTargetSearcher searcher, TargetScanFlags flags, Predicate <Thing> validator = null, float minDist = 0f,
float maxDist = 9999f, IntVec3 locus = default(IntVec3), float maxTravelRadiusFromLocus = 3.40282347E+38f, bool canBash = false,
bool canTakeTargetsCloserThanEffectiveMinRange = true)
{
bool result = true;
if (!recursiveTrap && multiMapSearch)
{
recursiveTrap = true;
Map oldMap = searcher.Thing.Map;
IntVec3 oldPosition = searcher.Thing.Position;
bool dontCheckForStairs = searcher.Thing is Building;
foreach (var map in ZUtils.GetAllMapsInClosestOrder(searcher.Thing, oldMap, oldPosition, dontCheckForStairs: dontCheckForStairs))
{
if (ZUtils.ZTracker.GetZIndexFor(map) < ZUtils.ZTracker.GetZIndexFor(oldMap))
{
CanBeSeenOverFast_Patch.checkLevels = true;
CanBeSeenOverFast_Patch.upperMap = oldMap;
CanBeSeenOverFast_Patch.lowerMap = map;
CanBeSeenOverFast_Patch.caster = searcher.Thing;
}
var target = AttackTargetFinder.BestAttackTarget(searcher, flags, validator, minDist,
maxDist, locus, maxTravelRadiusFromLocus, canBash, canTakeTargetsCloserThanEffectiveMinRange);
//ZLogger.Message(searcher.Thing + " - 1: " + ZUtils.ZTracker.GetMapInfo(searcher.Thing.Map) + " - result: " + target);
if (target != null)
{
__result = target;
result = false;
break;
}
}
//ZLogger.Message("1 Trying to get " + searcher.Thing + " back to " + oldMap + " - " + oldPosition, true);
ZUtils.TeleportThing(searcher.Thing, oldMap, oldPosition);
recursiveTrap = false;
CanBeSeenOverFast_Patch.checkLevels = false;
CanBeSeenOverFast_Patch.upperMap = null;
CanBeSeenOverFast_Patch.lowerMap = null;
CanBeSeenOverFast_Patch.caster = null;
}
//else if (!multiMapSearch)
//{
// ZLogger.Message("BestAttackTarget: multiMapSearch: " + multiMapSearch, true);
//}
return(result);
}
public static void Postfix(Verb_LaunchProjectile __instance, List <IntVec3> ___tempLeanShootSources, List <IntVec3> ___tempDestList, LocalTargetInfo ___currentTarget, ref bool __result)
{
if (teleportBack)
{
if (targetOldMap != null)
{
ZUtils.TeleportThing(___currentTarget.Thing, targetOldMap, ___currentTarget.Thing.Position);
targetOldMap = null;
RoofAndFloorPatches.Patch_SpawnSetup.doTeleport = true;
}
else if (casterOldMap != null)
{
ZUtils.TeleportThing(__instance.caster, casterOldMap, __instance.caster.Position);
casterOldMap = null;
RoofAndFloorPatches.Patch_SpawnSetup.doTeleport = true;
}
}
}
public static void Prefix(Verb __instance, IntVec3 root, LocalTargetInfo targ, ref ShootLine resultingLine, ref bool __result)
{
if (__instance.caster?.Map != targ.Thing?.Map && __instance.caster?.Map?.Tile == targ.Thing?.Map?.Tile)
{
ind1 = ZUtils.ZTracker.GetZIndexFor(__instance.caster.Map);
ind2 = ZUtils.ZTracker.GetZIndexFor(targ.Thing.Map);
if (ind1 > ind2)
{
teleportBack = true;
oldMap1 = targ.Thing.Map;
ZUtils.TeleportThing(targ.Thing, __instance.caster.Map, targ.Thing.Position);
}
else if (ind1 < ind2)
{
teleportBack = true;
oldMap2 = __instance.caster.Map;
ZUtils.TeleportThing(__instance.caster, targ.Thing.Map, __instance.caster.Position);
}
}
}
private static void Postfix(Pawn ___pawn, ref IEnumerable <Thing> __result, Pawn playerNegotiator)
{
var result = __result.ToList();
Map oldMap = ___pawn.Map;
IntVec3 oldPosition = playerNegotiator.Position;
bool select = false;
if (Find.Selector.SelectedObjects.Contains(___pawn))
{
select = true;
}
foreach (var map in ZUtils.GetAllMapsInClosestOrder(___pawn, oldMap, oldPosition))
{
if (map != oldMap)
{
IEnumerable <Thing> enumerable = ___pawn.Map.listerThings.AllThings.Where((Thing x)
=> x.def.category == ThingCategory.Item && TradeUtility.PlayerSellableNow(x, ___pawn) &&
!x.Position.Fogged(x.Map) && (___pawn.Map.areaManager.Home[x.Position] ||
x.IsInAnyStorage()) && ReachableForTrade(x, ___pawn));
foreach (Thing item in enumerable)
{
result.Add(item);
}
if (___pawn.GetLord() != null)
{
foreach (Pawn item2 in from x in TradeUtility.AllSellableColonyPawns(___pawn.Map)
where !x.Downed && ReachableForTrade(x, ___pawn)
select x)
{
result.Add(item2);
}
}
}
}
ZUtils.TeleportThing(___pawn, oldMap, oldPosition);
if (select)
{
Find.Selector.Select(___pawn);
}
__result = result;
}
public static FloatMenuOption AddRescueOption(Pawn pawn, Pawn victim)
{
var floatOption = FloatMenuUtility.DecoratePrioritizedTask(new FloatMenuOption("Rescue".Translate
(victim.LabelCap, victim), delegate()
{
var ZTracker = ZUtils.ZTracker;
var oldMap = pawn.Map;
var oldPosition1 = pawn.Position;
var oldPosition2 = victim.Position;
bool select = false;
if (Find.Selector.SelectedObjects.Contains(pawn))
{
select = true;
}
Building building_Bed = null;
foreach (var otherMap in ZUtils.GetAllMapsInClosestOrderForTwoThings(pawn, oldMap, oldPosition1,
victim, oldMap, oldPosition2))
{
ZLogger.Message("Searching rest job for " + pawn + " in " + ZTracker.GetMapInfo(otherMap)
+ " for " + ZTracker.GetMapInfo(oldMap));
building_Bed = RestUtility.FindBedFor(victim, pawn, sleeperWillBePrisoner: false,
checkSocialProperness: false);
if (building_Bed == null)
{
building_Bed = RestUtility.FindBedFor(victim, pawn, sleeperWillBePrisoner: false,
checkSocialProperness: false, ignoreOtherReservations: true);
}
if (building_Bed != null)
{
break;
}
}
if (select)
{
Find.Selector.Select(pawn);
}
ZUtils.TeleportThing(pawn, oldMap, oldPosition1);
ZUtils.TeleportThing(victim, oldMap, oldPosition2);
if (building_Bed == null)
{
string t3 = (!victim.RaceProps.Animal)
? ((string)"NoNonPrisonerBed".Translate())
: ((string)"NoAnimalBed".Translate());
Messages.Message("CannotRescue".Translate() + ": " + t3, victim,
MessageTypeDefOf.RejectInput, historical: false);
}
else
{
Job job = JobMaker.MakeJob(JobDefOf.Rescue, victim, building_Bed);
job.count = 1;
ZTracker.BuildJobListFor(pawn, pawn.Map, job);
Log.Message(pawn + " taking first job 2");
pawn.jobs.EndCurrentJob(JobCondition.InterruptForced, false);
PlayerKnowledgeDatabase.KnowledgeDemonstrated(ConceptDefOf.Rescuing, KnowledgeAmount.Total);
}
}, MenuOptionPriority.RescueOrCapture, null, victim, 0f, null, null), pawn, victim, "ReservedBy");
return(floatOption);
}
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 FloatMenuOption AddArrestOption(Pawn pawn, Pawn victim)
{
if (!pawn.CanReach(victim, PathEndMode.OnCell, Danger.Deadly))
{
return(new FloatMenuOption(
"CannotArrest".Translate() + ": " + "NoPath".Translate().CapitalizeFirst(), null));
}
else
{
Pawn pTarg2 = victim;
Action action = delegate
{
var ZTracker = ZUtils.ZTracker;
var oldMap = pawn.Map;
var oldPosition1 = pawn.Position;
var oldPosition2 = victim.Position;
bool select = false;
if (Find.Selector.SelectedObjects.Contains(pawn))
{
select = true;
}
Building building_Bed3 = null;
foreach (var otherMap in ZUtils.GetAllMapsInClosestOrderForTwoThings(pawn, oldMap,
oldPosition1, victim, oldMap, oldPosition2))
{
building_Bed3 = RestUtility.FindBedFor(pTarg2, pawn, sleeperWillBePrisoner: true,
checkSocialProperness: false);
if (building_Bed3 == null)
{
building_Bed3 = RestUtility.FindBedFor(pTarg2, pawn, sleeperWillBePrisoner: true,
checkSocialProperness: false, ignoreOtherReservations: true);
}
if (building_Bed3 != null)
{
break;
}
}
ZUtils.TeleportThing(pawn, oldMap, oldPosition1);
ZUtils.TeleportThing(victim, oldMap, oldPosition2);
if (select)
{
Find.Selector.Select(pawn);
}
if (building_Bed3 == null)
{
Messages.Message("CannotArrest".Translate() + ": " + "NoPrisonerBed".Translate(),
pTarg2, MessageTypeDefOf.RejectInput, historical: false);
}
else
{
Job job = JobMaker.MakeJob(JobDefOf.Arrest, pTarg2, building_Bed3);
job.count = 1;
ZTracker.BuildJobListFor(pawn, pawn.Map, job);
ZLogger.Message(pawn + " taking first job 3");
pawn.jobs.EndCurrentJob(JobCondition.InterruptForced, false);
if (pTarg2.Faction != null &&
((pTarg2.Faction != Faction.OfPlayer && !pTarg2.Faction.def.hidden) ||
pTarg2.IsQuestLodger()))
{
TutorUtility.DoModalDialogIfNotKnown(ConceptDefOf.ArrestingCreatesEnemies);
}
}
};
return(FloatMenuUtility.DecoratePrioritizedTask(
new FloatMenuOption(
"TryToArrest".Translate(victim.LabelCap, victim,
pTarg2.GetAcceptArrestChance(pawn).ToStringPercent()), action,
MenuOptionPriority.High, null, victim), pawn, pTarg2));
}
}
private static bool Prefix(ref bool __result, Reachability __instance, IntVec3 start, LocalTargetInfo dest, PathEndMode peMode, TraverseParms traverseParams, out bool __state)
{
__state = false;
var pawn = traverseParams.pawn;
if (pawn != null && pawn.Map != null)
{
if (dest.HasThing && dest.thingInt.Map != null)
{
if (dest.thingInt.Map != pawn.Map)
{
var cellToTeleport = ZUtils.GetCellToTeleportFrom(pawn.Map, pawn.Position, dest.thingInt.Map);
var cell = cellToTeleport.IsValid ? cellToTeleport : pawn.Position;
__state = true;
oldMap = pawn.Map;
oldPosition = pawn.Position;
ZUtils.TeleportThing(pawn, dest.thingInt.Map, cell);
if (dest.thingInt.Map != __instance.map)
{
__result = dest.thingInt.Map.reachability.CanReach(start, dest, peMode, traverseParams);
ZLogger.Message($"1 CanReach: Used dest thing map reachability: __instance.map: {__instance.map}, pawn: {pawn}, thing: {dest.thingInt}, pawn.Map: {pawn.Map}, thing.Map: {dest.thingInt.Map}, result: {__result}");
return(false);
}
}
else if (dest.thingInt.Map != __instance.map)
{
__result = dest.thingInt.Map.reachability.CanReach(start, dest, peMode, traverseParams);
ZLogger.Message($"2 CanReach: Used dest thing map reachability: __instance.map: {__instance.map}, pawn: {pawn}, thing: {dest.thingInt}, pawn.Map: {pawn.Map}, thing.Map: {dest.thingInt.Map}, result: {__result}");
return(false);
}
}
else if (ZUtils.ZTracker.jobTracker.TryGetValue(pawn, out var jobTracker) && jobTracker.lookedAtLocalCellMap != null &&
jobTracker.lookedAtLocalCellMap.TryGetValue(dest.cellInt, out var mapDest) && mapDest != null)
{
if (mapDest != pawn.Map)
{
var cellToTeleport = ZUtils.GetCellToTeleportFrom(pawn.Map, pawn.Position, mapDest);
var cell = cellToTeleport.IsValid ? cellToTeleport : pawn.Position;
__state = true;
oldMap = pawn.Map;
oldPosition = pawn.Position;
ZUtils.TeleportThing(pawn, mapDest, cell);
if (mapDest != __instance.map)
{
__result = mapDest.reachability.CanReach(start, dest, peMode, traverseParams);
ZLogger.Message($"3 CanReach: Used mapDest map reachability: __instance.map: {__instance.map}, pawn: {pawn}, mapDest: {mapDest}, pawn.Map: {pawn.Map}, result: {__result}");
return(false);
}
}
else if (mapDest != __instance.map)
{
__result = mapDest.reachability.CanReach(start, dest, peMode, traverseParams);
ZLogger.Message($"4 CanReach: Used mapDest map reachability: __instance.map: {__instance.map}, pawn: {pawn}, mapDest: {mapDest}, pawn.Map: {pawn.Map}, result: {__result}");
return(false);
}
}
}
return(true);
}
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}");
// }
// }
// }
// }
//}
}
}
