protected override IEnumerable <Toil> MakeNewToils()
{
ZLogger.Message(pawn + " 1 ZUtils.ZTracker.jobTracker[pawn].dest: " + ZUtils.ZTracker.jobTracker[pawn].dest);
foreach (var toil in Toils_ZLevels.GoToMap(GetActor(), ZUtils.ZTracker.jobTracker[pawn].dest, this))
{
ZLogger.Message(pawn + " 2 ZUtils.ZTracker.jobTracker[pawn].dest: " + ZUtils.ZTracker.jobTracker[pawn].dest);
yield return(toil);
}
}
public override void SpawnSetup(Map map, bool respawningAfterLoad)
{
base.SpawnSetup(map, respawningAfterLoad);
var ZTracker = ZUtils.ZTracker;
ZTracker.totalStairsUp = new HashSet <Building_Stairs>();
ZTracker.stairsUp = new Dictionary <Map, List <Building_Stairs> >();
//if (ZTracker.totalStairsUp == null)
// ZTracker.totalStairsUp = new HashSet<Building_Stairs>();
//ZTracker.totalStairsUp.Add(this);
//
//foreach (var stairsPair in ZTracker.stairsUp)
//{
// if (stairsPair.Key != map && stairsPair.Value.Contains(this))
// {
// ZTracker.stairsUp[stairsPair.Key].Remove(this);
// }
//}
//
//if (!ZTracker.stairsUp.ContainsKey(this.Map))
//{
// ZTracker.stairsUp[this.Map] = new List<Building_Stairs>();
//}
//if (!ZTracker.stairsUp[this.Map].Contains(this))
//{
// ZTracker.stairsUp[this.Map].Add(this);
//}
if (!respawningAfterLoad)
{
if (this.Position.GetTerrain(this.Map) == ZLevelsDefOf.ZL_OutsideTerrain)
{
this.Map.terrainGrid.SetTerrain(this.Position, ZLevelsDefOf.ZL_OutsideTerrainTwo);
}
Map mapUpper = ZTracker.GetUpperLevel(this.Map.Tile, this.Map);
if (mapUpper != null && mapUpper != this.Map)
{
if (Position.GetThingList(mapUpper).Count(x => x.def == ZLevelsDefOf.ZL_StairsDown) != 0)
{
return;
}
mapUpper.terrainGrid.SetTerrain(this.Position, ZLevelsDefOf.ZL_OutsideTerrainTwo);
var stairsToSpawn = ThingMaker.MakeThing(ZLevelsDefOf.ZL_StairsDown, this.Stuff);
GenPlace.TryPlaceThing(stairsToSpawn, this.Position, mapUpper, ThingPlaceMode.Direct);
stairsToSpawn.SetFaction(this.Faction);
}
else if (mapUpper == this.Map)
{
Log.Error("There was a mismatch of ZLevels indices. This is a serious error, report it to the mod developers");
foreach (var map2 in ZTracker.GetAllMaps(this.Map.Tile))
{
ZLogger.Message("Index: " + ZTracker.GetMapInfo(map2));
}
}
}
}
private static bool SpawnAnimalPrefix(WildAnimalSpawner __instance, ref IntVec3 loc,
ref bool __result, Map ___map)
{
if (ZLevelsMod.settings.allowZLevelsInfestation)
{
try
{
bool result = false;
var comp = ZUtils.GetMapComponentZLevel(___map);
var ZTracker = ZUtils.ZTracker;
if (___map.Parent is MapParent_ZLevel && comp != null &&
ZTracker.GetUpperLevel(___map.Tile, ___map) != null &&
!ZUtils.GetMapComponentZLevel(ZTracker.GetUpperLevel(___map.Tile, ___map))
.hasCavesBelow.GetValueOrDefault(false))
{
result = false;
}
else
{
PawnKindDef pawnKindDef = (from a in ___map.Biome.AllWildAnimals
where ___map.mapTemperature.SeasonAcceptableFor(a.race)
select a)
.RandomElementByWeight((PawnKindDef def) =>
___map.Biome.CommonalityOfAnimal(def) / def.wildGroupSize.Average);
if (pawnKindDef == null)
{
Log.Error("No spawnable animals right now.");
result = false;
}
else
{
ZLogger.Message("Spawning animal: " + pawnKindDef + " in biome: " + ___map.Biome);
int randomInRange = pawnKindDef.wildGroupSize.RandomInRange;
int radius = Mathf.CeilToInt(Mathf.Sqrt((float)pawnKindDef.wildGroupSize.max));
if (___map.Parent is MapParent_ZLevel && !loc.Walkable(___map))
{
loc = CellFinderLoose.RandomCellWith((IntVec3 sq) => sq.Walkable(___map), ___map);
}
for (int i = 0; i < randomInRange; i++)
{
IntVec3 loc2 = CellFinder.RandomClosewalkCellNear(loc, ___map, radius, null);
GenSpawn.Spawn(PawnGenerator.GeneratePawn(pawnKindDef, null), loc2, ___map, WipeMode.Vanish);
}
result = true;
}
}
__result = result;
}
catch (Exception ex)
{
Log.Error("[Z-Levels] SpawnAnimalPrefix patch produced an error. That should not happen and will break things. Send a Hugslib log to the Z-Levels developers. Error message: " + ex);
}
return(false);
}
return(true);
}
public override IEnumerable <Toil> MakeNewToils()
{
this.FailOn(() => ZUtils.ZTracker.jobTracker.ContainsKey(pawn) && ZUtils.ZTracker.jobTracker[pawn].failIfTargetMapIsNotDest &&
ZUtils.ZTracker.jobTracker[pawn].target.Map != ZUtils.ZTracker.jobTracker[pawn].targetDest.Map);
ZLogger.Message($"JobDriver GoToMap About to call findRouteWithStairs, with pawn {GetActor()}, dest { ZUtils.ZTracker.jobTracker[pawn].targetDest}, instance {this}");
foreach (var toil in Toils_ZLevels.GoToMap(GetActor(), ZUtils.ZTracker.jobTracker[pawn].targetDest.Map, this))
{
yield return(toil);
}
}
public override void SpawnSetup(Map map, bool respawningAfterLoad)
{
base.SpawnSetup(map, respawningAfterLoad);
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
if (!ZTracker.stairsDown.ContainsKey(this.Map))
{
ZTracker.stairsDown[this.Map] = new List <Thing>();
}
if (!ZTracker.stairsDown[this.Map].Contains(this))
{
ZTracker.stairsDown[this.Map].Add(this);
}
if (!respawningAfterLoad)
{
if (this.Position.GetTerrain(this.Map) == ZLevelsDefOf.ZL_OutsideTerrain)
{
this.Map.terrainGrid.SetTerrain(this.Position, ZLevelsDefOf.ZL_OutsideTerrainTwo);
}
Map mapBelow = ZTracker.GetLowerLevel(this.Map.Tile, this.Map);
if (mapBelow != null && mapBelow != this.Map && this.def.defName == "FC_StairsDown")
{
for (int i = mapBelow.thingGrid.ThingsListAt(this.Position).Count - 1; i >= 0; i--)
{
Thing thing = mapBelow.thingGrid.ThingsListAt(this.Position)[i];
if (thing is Mineable)
{
if (thing.Spawned)
{
thing.DeSpawn(DestroyMode.WillReplace);
}
}
}
if (this.Position.GetThingList(mapBelow).Where(x => x.def == ZLevelsDefOf.ZL_StairsUp).Count() == 0)
{
var stairsToSpawn = ThingMaker.MakeThing(ZLevelsDefOf.ZL_StairsUp, this.Stuff);
mapBelow.terrainGrid.SetTerrain(this.Position, ZLevelsDefOf.ZL_OutsideTerrainTwo);
GenPlace.TryPlaceThing(stairsToSpawn, this.Position, mapBelow, ThingPlaceMode.Direct);
stairsToSpawn.SetFaction(this.Faction);
}
FloodFillerFog.FloodUnfog(this.Position, mapBelow);
AccessTools.Method(typeof(FogGrid), "FloodUnfogAdjacent").Invoke(mapBelow.fogGrid, new object[]
{ this.Position });
}
else if (mapBelow == this.Map)
{
Log.Error("There was a mismatch of ZLevels indices. This is a serious error, report it to the mod developers");
foreach (var map2 in ZTracker.GetAllMaps(this.Map.Tile))
{
ZLogger.Message("Index: " + ZTracker.GetMapInfo(map2));
}
}
}
}
public List <ZPathfinder.DijkstraGraph.Node> GetRoute(TargetInfo targetInfo)
{
if (nodeList == null)
{
ZLogger.Message($"pawn map: {pawn.Map}", debugLevel: DebugLevel.Pathfinding);
nodeList = ZPathfinder.Instance.FindRoute(pawn.Position, targetInfo.Cell, pawn.Map, targetInfo.Map,
out float routeCost);
curIndex = 1;
curMap = pawn.Map;
}
return(nodeList);
}
public override void MapGenerated()
{
base.MapGenerated();
if (Rand.Chance(0.5f) && (Find.WorldGrid[map.Tile].hilliness == Hilliness.SmallHills ||
Find.WorldGrid[map.Tile].hilliness == Hilliness.LargeHills ||
Find.WorldGrid[map.Tile].hilliness == Hilliness.Mountainous ||
Find.WorldGrid[map.Tile].hilliness == Hilliness.Impassable))
{
ZLogger.Message("The map has caves below now");
this.hasCavesBelow = true;
}
}
public static Toil ExtractNextTargetFromQueue(TargetIndex ind, bool failIfCountFromQueueTooBig = true)
{
Toil toil = new Toil();
toil.initAction = delegate
{
Pawn actor = toil.actor;
Job curJob = actor.jobs.curJob;
try
{
ZLogger.Message("--------------------------");
for (int i = curJob.targetQueueB.Count - 1; i >= 0; i--)
{
var target = curJob.targetQueueB[i];
ZLogger.Message("4 job.targetQueueB: " + target.Thing);
ZLogger.Message("4 job.targetQueueB.Map: " + target.Thing.Map);
ZLogger.Message("4 job.targetQueueB.stackCount: " + target.Thing.stackCount);
ZLogger.Message("4 job.targetQueueB.countQueue: " + curJob.countQueue[i]);
}
}
catch { }
List <LocalTargetInfo> targetQueue = curJob.GetTargetQueue(ind);
if (!targetQueue.NullOrEmpty())
{
if (failIfCountFromQueueTooBig && !curJob.countQueue.NullOrEmpty() && targetQueue[0].HasThing &&
curJob.countQueue[0] > targetQueue[0].Thing.stackCount)
{
Log.Message("targetQueue[0].Thing: " + targetQueue[0].Thing, true);
Log.Message("failIfCountFromQueueTooBig: " + failIfCountFromQueueTooBig, true);
Log.Message("!curJob.countQueue.NullOrEmpty(): " + (!curJob.countQueue.NullOrEmpty()).ToString(), true);
Log.Message("targetQueue[0].HasThing: " + (targetQueue[0].HasThing).ToString(), true);
Log.Message("curJob.countQueue[0] > targetQueue[0].Thing.stackCount: " + (curJob.countQueue[0] > targetQueue[0].Thing.stackCount).ToString(), true);
Log.Message("targetQueue[0].Thing.stackCount: " + (targetQueue[0].Thing.stackCount).ToString(), true);
Log.Message("curJob.countQueue[0]: " + (curJob.countQueue[0]).ToString(), true);
ZLogger.Pause("Stack count of thing is lesser than countQueue");
actor.jobs.curDriver.EndJobWith(JobCondition.Incompletable);
}
else
{
curJob.SetTarget(ind, targetQueue[0]);
targetQueue.RemoveAt(0);
if (!curJob.countQueue.NullOrEmpty())
{
curJob.count = curJob.countQueue[0];
curJob.countQueue.RemoveAt(0);
}
}
}
};
return(toil);
}
private static bool PreFix(ref bool __result, IncidentParms parms)
{
if (ZLevelsMod.settings.allowZLevelsInfestation)
{
try
{
Map map = (Map)parms.target;
var comp = ZUtils.GetMapComponentZLevel(map);
if (comp.hasCavesBelow.HasValue && comp.hasCavesBelow.Value)
{
var foods = map.listerThings.AllThings.Where(x => !(x is Plant) && !(x is Pawn) &&
x.GetStatValue(StatDefOf.Nutrition, true) > 0.1f);
if (foods != null && foods.Any())
{
List <PawnKindDef> infestators = new List <PawnKindDef>
{
ZLevelsDefOf.ZL_UndegroundBiome.AllWildAnimals.RandomElement()
};
var infestationPlace = foods.RandomElement().Position;
var infestationData = new InfestationData(infestators, parms.points, infestationPlace);
if (comp.ActiveInfestations == null)
{
comp.ActiveInfestations = new List <InfestationData>();
}
comp.ActiveInfestations.Add(infestationData);
if (comp.TotalInfestations == null)
{
comp.TotalInfestations = new List <InfestationData>();
}
comp.TotalInfestations.Add(infestationData);
var naturalHole = (Building_StairsDown)ThingMaker.MakeThing(ZLevelsDefOf.ZL_NaturalHole);
naturalHole.infestationData = infestationData;
GenSpawn.Spawn(naturalHole, infestationPlace, map, WipeMode.Vanish);
Find.LetterStack.ReceiveLetter("ZLevelInfestation"
.Translate(infestators.RandomElement().race.label), "ZLevelInfestationDesc".Translate(),
LetterDefOf.ThreatBig, naturalHole);
}
}
else
{
ZLogger.Message("The map has no caves below to generate infestation");
}
__result = false;
}
catch (Exception ex)
{
Log.Error("[Z-Levels] Patch_Infestation_TryExecuteWorker patch produced an error. That should not happen and will break things. Send a Hugslib log to the Z-Levels developers. Error message: " + ex);
}
return(false);
}
return(true);
}
public override IEnumerable <Toil> MakeNewToils()
{
//have pawn, and destination.
//Check that pawn can reach destination with Dijkstra.
//yield break if not.
//Otherwise, calculate toils to go, then toils to destination and return them one at a time.
ZLogger.Message($"JobDriver GoToLocation About to call findRouteWithStairs, with pawn {pawn}, dest { TargetA.ToTargetInfo(pawn.Map)}, instance {this}");
foreach (var v in Toils_ZLevels.FindRouteWithStairs(pawn, TargetA.ToTargetInfo(pawn.Map), this))
{
yield return(v);
}
}
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 override void PostApplyDamage(DamageInfo dinfo, float totalDamageDealt)
{
base.PostApplyDamage(dinfo, totalDamageDealt);
Map lowerLevel = ZUtils.ZTracker.GetLowerLevel(this.Map.Tile, this.Map);
if (giveDamage && lowerLevel != null && lowerLevel.listerThings.ThingsOfDef(ZLevelsDefOf.ZL_StairsUp)
.Where(x => x.Position == this.Position).FirstOrDefault() is Building_StairsUp stairsUp)
{
ZLogger.Message(stairsUp + ".HitPoints -= " + (int)totalDamageDealt);
stairsUp.giveDamage = false;
stairsUp.TakeDamage(dinfo);
stairsUp.giveDamage = true;
}
}
public static bool IsVoidsEverywhereInShootingLineInBackWard(ShootLine resultingLine, Map map, Thing caster, Thing target)
{
var points = resultingLine.Points().ToList();
if (points.Count > 2)
{
for (int i = points.Count - 1; i >= 0; i--)
{
if (IntVec3Utility.DistanceTo(target.Position, points[i]) >= 2)
{
if (i < points.Count - 1 && points[i].GetTerrain(map) != ZLevelsDefOf.ZL_OutsideTerrain)
{
//ZLogger.Message("6: " + caster + " - " + " - " + i + " - " + points.Count + " - " + points[i] + " - " + points[i].GetTerrain(map) + " - " + map, true);
return(false);
}
else if (i == points.Count - 1 && points[i].GetCover(map)?.def?.Fillage == FillCategory.Full)
{
ZLogger.Message("7: " + caster + " - " + i + " - " + points.Count + " - " + points[i] + " - " + points[i].GetCover(map) + " - " + map, true);
return(false);
}
}
}
if (resultingLine.dest.GetCover(map)?.def?.Fillage == FillCategory.Full)
{
ZLogger.Message("8: " + caster + " - " + resultingLine.dest + " - " + resultingLine.dest.GetCover(map) + " - " + map, true);
return(false);
}
}
else
{
for (int i = points.Count - 1; i >= 0; i--)
{
if (points[i] != resultingLine.Dest)
{
if (points[i].GetTerrain(map) != ZLevelsDefOf.ZL_OutsideTerrain)
{
ZLogger.Message("9: " + caster + " - " + i + " - " + points.Count + " - " + points[i] + " - " + points[i].GetTerrain(map) + " - " + map, true);
return(false);
}
}
}
if (resultingLine.dest.GetCover(map)?.def?.Fillage == FillCategory.Full)
{
ZLogger.Message("10: " + caster + " - " + resultingLine.dest + " - " + resultingLine.dest.GetCover(map) + " - " + map, true);
return(false);
}
}
return(true);
}
public override void MapComponentUpdate()
{
base.MapComponentUpdate();
//if (this.DoGeneration && path.Length > 0)
//{
// SettlementGeneration.DoSettlementGeneration(this.map, this.path, this.map.ParentFaction, false);
// this.DoGeneration = false;
//}
if (this.ReFog)
{
ZLogger.Message("Refog" + this.map);
FloodFillerFog.DebugRefogMap(this.map);
this.ReFog = false;
}
}
public override void PostApplyDamage(DamageInfo dinfo, float totalDamageDealt)
{
if (syncDamage)
{
Building_Stairs matchingStair = GetMatchingStair();
if (matchingStair != null)
{
ZLogger.Message(matchingStair + ".HitPoints -= " + (int)totalDamageDealt, true);
matchingStair.syncDamage = false;
matchingStair.TakeDamage(new DamageInfo(dinfo.Def, dinfo.Amount));
matchingStair.syncDamage = true;
}
}
base.PostApplyDamage(dinfo, totalDamageDealt);
}
public override void Generate(Map map, GenStepParams parms)
{
int num = 0;
var mapParent = map.Parent as MapParent_ZLevel;
if (mapParent.hasCaves)
{
int infestationCount = 0;
if (mapParent.TotalInfestations != null && mapParent.TotalInfestations.Count > 0)
{
infestationCount = mapParent.TotalInfestations.Count;
}
var index = 0;
while (true)
{
if (!map.wildAnimalSpawner.AnimalEcosystemFull)
{
num++;
if (num >= 10000)
{
break;
}
IntVec3 loc = IntVec3.Invalid;
if (infestationCount > 0 && index < infestationCount && CellFinder.TryFindRandomCellNear
(mapParent.TotalInfestations[index].infestationPlace, map, 100,
(IntVec3 c) => c.Walkable(map), out loc))
{
ZLogger.Message("Found loc: " + loc
+ " origin place: " + mapParent.TotalInfestations[index].infestationPlace);
index++;
}
else
{
loc = RCellFinder.RandomAnimalSpawnCell_MapGen(map);
}
if (!map.wildAnimalSpawner.SpawnRandomWildAnimalAt(loc))
{
ZLogger.Message("Spawning in loc: " + loc);
return;
}
ZLogger.Message("Spawning in loc: " + loc);
continue;
}
return;
}
Log.Error("Too many iterations.");
}
}
public static bool IsVoidsEverywhereInShootingLine(ShootLine resultingLine, Map map, Thing caster, Thing target)
{
var points = resultingLine.Points().ToList();
if (points.Count > 2)
{
for (int i = 0; i < points.Count; i++)
{
if (IntVec3Utility.DistanceTo(caster.Position, points[i]) >= 2)
{
if (points[i].GetTerrain(map) != ZLevelsDefOf.ZL_OutsideTerrain)
{
ZLogger.Message("1: " + caster + " - " + i + " - " + points[i] + " - " + points[i].GetTerrain(map) + " - " + map, true);
return(false);
}
}
}
if (resultingLine.dest.GetCover(map)?.def?.Fillage == FillCategory.Full)
{
ZLogger.Message("3: " + caster + " - " + resultingLine.dest + " - " + resultingLine.dest.GetCover(map) + " - " + map, true);
return(false);
}
}
else
{
for (int i = 0; i < points.Count; i++)
{
if (points[i] != resultingLine.Source)
{
if (points[i].GetTerrain(map) != ZLevelsDefOf.ZL_OutsideTerrain)
{
ZLogger.Message("4: " + caster + " - " + i + " - " + points[i] + " - " + points[i].GetTerrain(map) + " - " + map, true);
return(false);
}
}
}
if (resultingLine.dest.GetCover(map)?.def?.Fillage == FillCategory.Full)
{
ZLogger.Message("5: " + caster + " - " + resultingLine.dest + " - " + resultingLine.dest.GetCover(map) + " - " + map, true);
return(false);
}
}
return(true);
}
private static void Postfix(WeatherManager __instance, WeatherDef newWeather)
{
try
{
Map map = Traverse.Create(__instance).Field("map").GetValue <Map>();
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
if (ZTracker.ZLevelsTracker != null && ZTracker.ZLevelsTracker.ContainsKey(map.Tile))
{
ZLogger.Message("2 Weather decider: " + newWeather + " - " + ZTracker.GetMapInfo(map));
if (ZTracker.GetZIndexFor(map) == 0)
{
foreach (var map2 in ZTracker.GetAllMaps(map.Tile))
{
if (ZTracker.GetZIndexFor(map2) > 0)
{
map2.weatherManager.lastWeather = __instance.curWeather;
map2.weatherManager.curWeather = newWeather;
map2.weatherManager.curWeatherAge = map.weatherManager.curWeatherAge;
ZLogger.Message("1.2 - " + ZTracker.GetMapInfo(map2) + " transitioting to " + newWeather);
}
}
}
else if (ZTracker.GetZIndexFor(map) > 0)
{
Map playerMap = ZTracker.GetMapByIndex(map.Tile, 0);
__instance.lastWeather = playerMap.weatherManager.lastWeather;
__instance.curWeather = playerMap.weatherManager.curWeather;
__instance.curWeatherAge = playerMap.weatherManager.curWeatherAge;
ZLogger.Message("2.2 - " + ZTracker.GetMapInfo(map) + " transitioting to " + map.weatherManager.curWeather);
}
else if (ZTracker.GetZIndexFor(map) < 0)
{
__instance.lastWeather = __instance.curWeather;
__instance.curWeather = WeatherDefOf.Clear;
__instance.curWeatherAge = 0;
ZLogger.Message("3.2 - " + ZTracker.GetMapInfo(map) + " transitioting to " + WeatherDefOf.Clear);
}
}
}
catch (Exception ex)
{
Log.Error("[Z-Levels] Patch_TransitionTo patch produced an error. That should not happen and will break things. Send a Hugslib log to the Z-Levels developers. Error message: " + ex, true);
}
}
private static void Prefix(RoofGrid __instance, ref IntVec3 c, ref RoofDef def)
{
try
{
if (def != null && !def.isNatural)
{
Map map = Traverse.Create(__instance).Field("map").GetValue <Map>();
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
var upperMap = ZTracker.GetUpperLevel(map.Tile, map);
if (upperMap != null && upperMap.terrainGrid.TerrainAt(c) == ZLevelsDefOf.ZL_OutsideTerrain)
{
upperMap.terrainGrid.SetTerrain(c, ZLevelsDefOf.ZL_RoofTerrain);
}
}
else if (def == null)
{
Map map = Traverse.Create(__instance).Field("map").GetValue <Map>();
if (c.GetRoof(map) == RoofDefOf.RoofConstructed)
{
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
Map upperMap = ZTracker.GetUpperLevel(map.Tile, map);
if (upperMap != null)
{
upperMap.terrainGrid.SetTerrain(c, ZLevelsDefOf.ZL_OutsideTerrain);
var thingList = c.GetThingList(upperMap);
for (int i = thingList.Count - 1; i >= 0; i--)
{
if (!(thingList[i] is Mineable || thingList[i] is Blueprint || thingList[i] is Frame))
{
//Log.Message(thingList[i] + " going down 3");
ZTracker.SimpleTeleportThing(thingList[i], c, map, false, 10);
}
}
ZLogger.Message("Removing roof " + c.GetRoof(map), true);
}
}
}
}
catch (Exception ex)
{
//Log.Error("Error in Patch_SetRoof: " + ex);
};
}
private static void Postfix(WeatherDecider __instance, WeatherDef __result)
{
try
{
Map map = Traverse.Create(__instance).Field("map").GetValue <Map>();
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
if (ZTracker.ZLevelsTracker != null && ZTracker.ZLevelsTracker.ContainsKey(map.Tile))
{
ZLogger.Message("Weather decider: " + __result + " - " + ZTracker.GetMapInfo(map));
if (ZTracker.GetZIndexFor(map) == 0)
{
foreach (var map2 in ZTracker.GetAllMaps(map.Tile))
{
if (ZTracker.GetZIndexFor(map2) > 0)
{
ZLogger.Message("1 - " + ZTracker.GetMapInfo(map2) + " transitioting to " + __result);
map2.weatherManager.TransitionTo(__result);
map2.weatherManager.curWeatherAge = map.weatherManager.curWeatherAge;
}
}
}
else if (ZTracker.GetZIndexFor(map) > 0)
{
__result = map.weatherManager.curWeather;
ZLogger.Message("2 - " + ZTracker.GetMapInfo(map) + " transitioting to " + __result);
map.weatherManager.TransitionTo(__result);
}
else if (ZTracker.GetZIndexFor(map) < 0)
{
__result = WeatherDefOf.Clear;
ZLogger.Message("3 - " + ZTracker.GetMapInfo(map) + " transitioting to " + __result);
map.weatherManager.TransitionTo(__result);
}
ZLogger.Message("Changed weather for " + ZTracker.GetMapInfo(map) + " - " + __result);
}
}
catch (Exception ex)
{
Log.Error("[Z-Levels] Patch_ChooseNextWeather patch produced an error. That should not happen and will break things. Send a Hugslib log to the Z-Levels developers. Error message: " + ex, true);
}
}
private static void Postfix(WeatherDecider __instance, ref WeatherDef __result, Map ___map)
{
try
{
var ZTracker = ZUtils.ZTracker;
if (ZTracker.ZLevelsTracker != null && ZTracker.ZLevelsTracker.ContainsKey(___map.Tile))
{
ZLogger.Message("Weather decider: " + __result + " - " + ZTracker.GetMapInfo(___map));
if (ZTracker.GetZIndexFor(___map) == 0)
{
foreach (var map2 in ZTracker.GetAllMaps(___map.Tile))
{
if (ZTracker.GetZIndexFor(map2) > 0)
{
ZLogger.Message("1 - " + ZTracker.GetMapInfo(map2) + " transitioting to " + __result);
map2.weatherManager.TransitionTo(__result);
map2.weatherManager.curWeatherAge = ___map.weatherManager.curWeatherAge;
}
}
}
else if (ZTracker.GetZIndexFor(___map) > 0)
{
__result = ___map.weatherManager.curWeather;
ZLogger.Message("2 - " + ZTracker.GetMapInfo(___map) + " transitioting to " + __result);
___map.weatherManager.TransitionTo(__result);
}
else if (ZTracker.GetZIndexFor(___map) < 0)
{
__result = WeatherDefOf.Clear;
ZLogger.Message("3 - " + ZTracker.GetMapInfo(___map) + " transitioting to " + __result);
___map.weatherManager.TransitionTo(__result);
}
ZLogger.Message("Changed weather for " + ZTracker.GetMapInfo(___map) + " - " + __result);
}
}
catch (Exception ex)
{
Log.Error("[Z-Levels] Patch_ChooseNextWeather patch produced an error. That should not happen and will break things. Send a Hugslib log to the Z-Levels developers. Error message: " + ex, true);
}
}
public override void SpawnSetup(Map map, bool respawningAfterLoad)
{
base.SpawnSetup(map, respawningAfterLoad);
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
if (!ZTracker.stairsUp.ContainsKey(this.Map))
{
ZTracker.stairsUp[this.Map] = new List <Thing>();
}
if (!ZTracker.stairsUp[this.Map].Contains(this))
{
ZTracker.stairsUp[this.Map].Add(this);
}
if (!respawningAfterLoad)
{
if (this.Position.GetTerrain(this.Map) == ZLevelsDefOf.ZL_OutsideTerrain)
{
this.Map.terrainGrid.SetTerrain(this.Position, ZLevelsDefOf.ZL_OutsideTerrainTwo);
}
Map mapUpper = ZTracker.GetUpperLevel(this.Map.Tile, this.Map);
if (mapUpper != null && mapUpper != this.Map)
{
if (this.Position.GetThingList(mapUpper).Where(x => x.def == ZLevelsDefOf.ZL_StairsDown).Count() == 0)
{
mapUpper.terrainGrid.SetTerrain(this.Position, ZLevelsDefOf.ZL_OutsideTerrainTwo);
var stairsToSpawn = ThingMaker.MakeThing(ZLevelsDefOf.ZL_StairsDown, this.Stuff);
GenPlace.TryPlaceThing(stairsToSpawn, this.Position, mapUpper, ThingPlaceMode.Direct);
stairsToSpawn.SetFaction(this.Faction);
}
}
else if (mapUpper == this.Map)
{
Log.Error("There was a mismatch of ZLevels indices. This is a serious error, report it to the mod developers");
foreach (var map2 in ZTracker.GetAllMaps(this.Map.Tile))
{
ZLogger.Message("Index: " + ZTracker.GetMapInfo(map2));
}
}
}
}
private static void Prefix(RoofGrid __instance, ref IntVec3 c, ref RoofDef def, Map ___map)
{
try
{
if (def != null && !def.isNatural)
{
var ZTracker = ZUtils.ZTracker;
var upperMap = ZTracker.GetUpperLevel(___map.Tile, ___map);
if (upperMap != null && upperMap.terrainGrid.TerrainAt(c) == ZLevelsDefOf.ZL_OutsideTerrain)
{
upperMap.terrainGrid.SetTerrain(c, ZLevelsDefOf.ZL_RoofTerrain);
}
}
else if (def == null)
{
if (c.GetRoof(___map) == RoofDefOf.RoofConstructed)
{
var ZTracker = ZUtils.ZTracker;
Map upperMap = ZTracker.GetUpperLevel(___map.Tile, ___map);
if (upperMap != null)
{
upperMap.terrainGrid.SetTerrain(c, ZLevelsDefOf.ZL_OutsideTerrain);
var thingList = c.GetThingList(upperMap);
for (int i = thingList.Count - 1; i >= 0; i--)
{
if (thingList[i].IsAllowedToSpawnBelow())
{
ZTracker.TeleportThing(thingList[i], c, ___map, false, 10);
}
}
ZLogger.Message("Removing roof " + c.GetRoof(___map));
}
}
}
}
catch (Exception ex)
{
//Log.Error("Error in Patch_SetRoof: " + ex);
};
}
private static void JobGiver_AIGotoNearestHostilePostfix(JobGiver_AIGotoNearestHostile __instance, ref Job __result, Pawn pawn)
{
ZLogger.Message(pawn + " got response 4: " + __result, true);
if (__result == null && !recursiveTrap)
{
recursiveTrap = true;
CombatPatches_BestAttackTarget_Patch.multiMapSearch = true;
var job = __instance.TryGiveJob(pawn);
if (job != null)
{
ZLogger.Message("Second block: " + job, true);
if (job.targetA.Thing?.Map != null && job.targetA.Thing.Map != pawn.Map)
{
ZUtils.ZTracker.ResetJobTrackerFor(pawn);
ZUtils.ZTracker.BuildJobListFor(pawn, job.targetA.Thing.Map, __result);
ZUtils.ZTracker.jobTracker[pawn].targetDest = new TargetInfo(job.targetA.Thing);
ZUtils.ZTracker.jobTracker[pawn].forceGoToDestMap = true;
__result = ZUtils.ZTracker.jobTracker[pawn].activeJobs[0];
ZUtils.ZTracker.jobTracker[pawn].activeJobs.RemoveAt(0);
}
else
{
__result = job;
}
}
recursiveTrap = false;
CombatPatches_BestAttackTarget_Patch.multiMapSearch = false;
}
else if (__result != null && __result.targetA.Thing?.Map != null && __result.targetA.Thing.Map != pawn.Map)
{
ZLogger.Message("Second block: " + __result, true);
ZUtils.ZTracker.ResetJobTrackerFor(pawn);
ZUtils.ZTracker.BuildJobListFor(pawn, __result.targetA.Thing.Map, __result);
ZUtils.ZTracker.jobTracker[pawn].targetDest = new TargetInfo(__result.targetA.Thing);
ZUtils.ZTracker.jobTracker[pawn].forceGoToDestMap = true;
__result = ZUtils.ZTracker.jobTracker[pawn].activeJobs[0];
ZUtils.ZTracker.jobTracker[pawn].activeJobs.RemoveAt(0);
}
ZLogger.Message(pawn + " got result 4: " + __result + " in " + pawn.Map + " - " + __result?.targetA.Thing?.Map + " - mind enemy: " + pawn.mindState.enemyTarget, true);
}
//public void DoForcedGeneration(bool disableFog)
//{
// SettlementGeneration.DoSettlementGeneration(this.map, this.path, this.map.ParentFaction, disableFog);
// this.DoGeneration = false;
//}
public override void FinalizeInit()
{
base.FinalizeInit();
if (!this.hasCavesBelow.HasValue)
{
if (Rand.Chance(0.5f) && (Find.WorldGrid[map.Tile].hilliness == Hilliness.SmallHills ||
Find.WorldGrid[map.Tile].hilliness == Hilliness.LargeHills ||
Find.WorldGrid[map.Tile].hilliness == Hilliness.Mountainous ||
Find.WorldGrid[map.Tile].hilliness == Hilliness.Impassable))
{
ZLogger.Message("The map has caves below now");
this.hasCavesBelow = true;
}
}
var ZTracker = ZUtils.ZTracker;
if (ZTracker.ZLevelsTracker == null)
{
ZLogger.Message("1 Resetting ZLevelsTracker");
ZTracker.ZLevelsTracker = new Dictionary <int, ZLevelData>();
}
foreach (var tile in ZTracker.ZLevelsTracker)
{
foreach (var zData in ZTracker.ZLevelsTracker[tile.Key].ZLevels)
{
ZLogger.Message("2 Tile: " + tile.Key + " - Map: " + ZTracker.GetMapInfo(zData.Value));
ZLogger.Message("Map null: " + (zData.Value == null).ToString());
ZLogger.Message("Map.Pawns null: " + (zData.Value.mapPawns == null).ToString());
ZLogger.Message("2 Map.Pawns null: " + (this.map.mapPawns == null).ToString());
}
}
if (!ZTracker.ZLevelsTracker.ContainsKey(this.map.Tile) && ZTracker.TryRegisterMap(this.map, 0))
{
this.Z_LevelIndex = 0;
}
}
private static void Postfix(ref Skyfaller __result, ThingDef skyfaller, IEnumerable <Thing> things, IntVec3 pos, Map map)
{
ZLogger.Message("Spawning " + __result);
if (pos.Roofed(map))
{
var ZTracker = ZUtils.ZTracker;
var upperMap = ZTracker.ZLevelsTracker[map.Tile]
.ZLevels.Values.Where(x => !pos.Roofed(x) &&
pos.GetTerrain(x) != ZLevelsDefOf.ZL_OutsideTerrain)
.OrderByDescending(x => ZTracker.GetZIndexFor(x)).FirstOrDefault();
if (upperMap != null)
{
ZTracker.TeleportThing(__result, pos, upperMap);
ZLogger.Message("Skyfaller: " + __result + " spawning in " + ZTracker.GetMapInfo(upperMap));
}
else
{
ZLogger.Message("Cant find unroofed map for " + __result);
}
ZLogger.Message("Roofed");
}
}
private static void JobGiver_ConfigurableHostilityResponsePostfix(JobGiver_ConfigurableHostilityResponse __instance, ref Job __result, Pawn pawn)
{
if (__result == null && !recursiveTrap)
{
recursiveTrap = true;
CombatPatches_BestAttackTarget_Patch.multiMapSearch = true;
var job = __instance.TryGiveJob(pawn);
if (job != null)
{
ZLogger.Message("Second block: " + job);
if (job.targetA.Thing?.Map != null && job.targetA.Thing.Map != pawn.Map)
{
ZUtils.ZTracker.ResetJobTrackerFor(pawn);
ZUtils.ZTracker.BuildJobListFor(pawn, job.targetA.Thing.Map, __result);
ZUtils.ZTracker.jobTracker[pawn].targetDest = new TargetInfo(job.targetA.Thing);
ZUtils.ZTracker.jobTracker[pawn].forceGoToDestMap = true;
__result = ZUtils.ZTracker.jobTracker[pawn].activeJobs[0];
ZUtils.ZTracker.jobTracker[pawn].activeJobs.RemoveAt(0);
}
else
{
__result = job;
}
}
recursiveTrap = false;
CombatPatches_BestAttackTarget_Patch.multiMapSearch = false;
}
else if (__result != null && __result.targetA.Thing?.Map != null && __result.targetA.Thing.Map != pawn.Map)
{
ZLogger.Message("Second block: " + __result);
ZUtils.ZTracker.ResetJobTrackerFor(pawn);
ZUtils.ZTracker.BuildJobListFor(pawn, __result.targetA.Thing.Map, __result);
ZUtils.ZTracker.jobTracker[pawn].targetDest = new TargetInfo(__result.targetA.Thing);
ZUtils.ZTracker.jobTracker[pawn].forceGoToDestMap = true;
__result = ZUtils.ZTracker.jobTracker[pawn].activeJobs[0];
ZUtils.ZTracker.jobTracker[pawn].activeJobs.RemoveAt(0);
}
}
private static void Postfix(Skyfaller __result, ThingDef skyfaller, Thing innerThing, IntVec3 pos, Map map)
{
ZLogger.Message("Spawning " + __result);
if (pos.Roofed(map))
{
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
var upperMap = ZTracker.ZLevelsTracker[map.Tile]
.ZLevels.Values.Where(x => !pos.Roofed(x) &&
pos.GetTerrain(x) != ZLevelsDefOf.ZL_OutsideTerrain)
.OrderByDescending(x => ZTracker.GetZIndexFor(x)).FirstOrDefault();
if (upperMap != null)
{
ZTracker.SimpleTeleportThing(__result, pos, upperMap);
ZLogger.Message("Skyfaller: " + __result + " spawning in " + ZTracker.GetMapInfo(upperMap));
}
else
{
ZLogger.Message("Cant find unroofed map for " + __result);
}
ZLogger.Message("Roofed");
}
}
private static void Postfix(FloatMenuOption __instance, bool colonistOrdering, FloatMenu floatMenu)
{
bool goDown = __instance.Label != "GoDown".Translate();
if (goDown && __instance.Label != "GoUP".Translate())
{
return;
}
if (Find.Selector.SelectedObjects.Count(x => x is Pawn) > 1)
{
foreach (var pawn in Find.Selector.SelectedObjects.Where(x => x is Pawn))
{
Thing thing;
if (goDown)
{
thing = GenClosest.ClosestThing_Global_Reachable(UI.MouseMapPosition().ToIntVec3()
, ((Pawn)pawn).Map, ((Pawn)pawn).Map.listerThings.AllThings
.Where(x => x is Building_StairsDown), PathEndMode.OnCell,
TraverseParms.For(TraverseMode.ByPawn, Danger.Deadly, false), 9999f);
Job job = JobMaker.MakeJob(ZLevelsDefOf.ZL_GoToStairs, thing);
((Pawn)pawn).jobs.StartJob(job, JobCondition.InterruptForced);
}
else
{
thing = GenClosest.ClosestThing_Global_Reachable(UI.MouseMapPosition().ToIntVec3()
, ((Pawn)pawn).Map, ((Pawn)pawn).Map.listerThings.AllThings
.Where(x => x is Building_StairsUp), PathEndMode.OnCell,
TraverseParms.For(TraverseMode.ByPawn, Danger.Deadly, false), 9999f);
Job job = JobMaker.MakeJob(ZLevelsDefOf.ZL_GoToStairs, thing);
((Pawn)pawn).jobs.StartJob(job, JobCondition.InterruptForced);
}
}
ZLogger.Message("Chosen");
}
}
public override bool TryMakePreToilReservations(bool errorOnFailed)
{
try
{
ZLogger.Message("--------------------------");
for (int i = job.targetQueueB.Count - 1; i >= 0; i--)
{
var target = job.targetQueueB[i];
ZLogger.Message("-2 job.targetQueueB: " + target.Thing);
ZLogger.Message("-2 job.targetQueueB.Map: " + target.Thing.Map);
ZLogger.Message("-2 job.targetQueueB.stackCount: " + target.Thing.stackCount);
ZLogger.Message("-2 job.targetQueueB.countQueue: " + job.countQueue[i]);
}
}
catch { }
if (!pawn.Reserve(job.GetTarget(TargetIndex.A), job, 1, -1, null, errorOnFailed))
{
return(false);
}
pawn.ReserveAsManyAsPossible(job.GetTargetQueue(TargetIndex.B), job);
return(true);
}
