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); }