// Token: 0x06000018 RID: 24 RVA: 0x00002A7B File Offset: 0x00000C7B public override void Generate(Map map, GenStepParams parms) { DeepProfiler.Start("RebuildAllRegions"); map.regionAndRoomUpdater.RebuildAllRegionsAndRooms(); DeepProfiler.End(); MapGenerator.PlayerStartSpot = ((UndergroundMapParent)map.info.parent).holeLocation; }
public override void Generate(Map map, GenStepParams parms) { DeepProfiler.Start("RebuildAllRegions"); map.regionAndRoomUpdater.RebuildAllRegionsAndRooms(); DeepProfiler.End(); MapGenerator.PlayerStartSpot = map.Center + new IntVec3(0, 0, 1); }
public static bool PreFLoadGameFromSaveFile(string fileName) { string str = GenText.ToCommaList(from mod in LoadedModManager.RunningMods select mod.ToString(), true); Log.Message("Loading game from file " + fileName + " with mods " + str); DeepProfiler.Start("Loading game from file " + fileName); Current.Game = new Game(); DeepProfiler.Start("InitLoading (read file)"); Scribe.loader.InitLoading(GenFilePaths.FilePathForSavedGame(fileName)); DeepProfiler.End(); ScribeMetaHeaderUtility.LoadGameDataHeader(ScribeMetaHeaderUtility.ScribeHeaderMode.Map, true); bool flag = !Scribe.EnterNode("Κgame"); bool result; if (flag) { Log.Error("Could not find DTMG XML node."); Scribe.ForceStop(); GenScene.GoToMainMenu(); Messages.Message("Game MUST be created with 'Don't Tempt Me!' loaded. Please select a 'Don't Tempt Me!' save game file.", MessageTypeDefOf.RejectInput); result = false; } else { Current.Game = new Game(); Current.Game.LoadGame(); PermadeathModeUtility.CheckUpdatePermadeathModeUniqueNameOnGameLoad(fileName); DeepProfiler.End(); result = false; } return(result); }
protected KAnimControllerBase() { KAnim.Anim.Frame invalidFrame = KAnim.Anim.Frame.InvalidFrame; curAnimFrameIdx = invalidFrame.idx; KAnim.Anim.Frame invalidFrame2 = KAnim.Anim.Frame.InvalidFrame; prevAnimFrame = invalidFrame2.idx; eventManagerHandle = HandleVector <int> .InvalidHandle; overrideAnimFiles = new List <OverrideAnimFileData>(); DeepProfiler = new DeepProfiler(false); playSpeed = 1f; mode = KAnim.PlayMode.Once; stopped = true; animHeight = 1f; animWidth = 1f; _enabled = true; hiddenSymbols = new List <KAnimHashedString>(); anims = new Dictionary <HashedString, AnimLookupData>(); overrideAnims = new Dictionary <HashedString, AnimLookupData>(); animQueue = new Queue <AnimData>(); fgLayer = Grid.SceneLayer.NoLayer; base._002Ector(); previousFrame = -1; currentFrame = -1; PlaySpeedMultiplier = 1f; synchronizer = new KAnimSynchronizer(this); layering = new KAnimLayering(this, fgLayer); isVisible = true; }
public static void AddModCheckPatching(List <LoadableXmlAsset> __result) { DeepProfiler.Start("Loading ModCheckPatches"); Memory.Instance.LoadModCheckPatches(); if (Memory.Instance.getModCheckPatches().Count > 0) { int iLength = __result.Count; Memory.Instance.resetPatchCount(); foreach (PatchOperation current2 in Memory.Instance.getModCheckPatches()) { // always measure time. The cost overhead is less than measuring conditionally. Memory.startPatchingWithTimer(); for (int i = 0; i < iLength; ++i) { Memory.Instance.setModAndFile(__result[i].mod.Name, __result[i].name, false); current2.Apply(__result[i].xmlDoc); } Memory.endPatchingWithTimer(); } } DeepProfiler.End(); }
public override void Generate(Map map, GenStepParams parms) { DeepProfiler.Start("RebuildAllRegions"); map.regionAndRoomUpdater.RebuildAllRegionsAndRooms(); DeepProfiler.End(); MapGenerator.PlayerStartSpot = ((MapParent_ZLevel)map.Parent).PlayerStartSpot; }
public static bool ExecuteToExecuteWhenFinished() { if (toExecuteWhenFinished2.Count > 0) { DeepProfiler.Start("ExecuteToExecuteWhenFinished()"); } Action action; while (toExecuteWhenFinished2.TryDequeue(out action)) { DeepProfiler.Start(action.Method.DeclaringType.ToString() + " -> " + action.Method.ToString()); try { action(); } catch (Exception arg) { Log.Error("Could not execute post-long-event action. Exception: " + arg); } finally { DeepProfiler.End(); } } if (toExecuteWhenFinished2.Count > 0) { DeepProfiler.End(); } toExecuteWhenFinished.Clear(); return(false); }
public override void Generate(Map map, GenStepParams parms) { DeepProfiler.Start("RebuildAllRegions"); map.regionAndRoomUpdater.RebuildAllRegionsAndRooms(); DeepProfiler.End(); MapGenerator.PlayerStartSpot = CellFinderLoose.TryFindCentralCell(map, 7, 10, (IntVec3 x) => !x.Roofed(map)); }
public override void Generate(Map map, GenStepParams parms) { List <NeededRoad> neededRoads = CalculateNeededRoads(map); if (neededRoads.Count == 0) { return; } List <DrawCommand> list = new List <DrawCommand>(); DeepProfiler.Start("RebuildAllRegions"); map.regionAndRoomUpdater.RebuildAllRegionsAndRooms(); DeepProfiler.End(); TerrainDef rockDef = BaseGenUtility.RegionalRockTerrainDef(map.Tile, beautiful: false); IntVec3 centerpoint = CellFinderLoose.TryFindCentralCell(map, 3, 10); RoadDef bestRoadType = DefDatabase <RoadDef> .AllDefs.Where((RoadDef rd) => neededRoads.Count((NeededRoad nr) => nr.road == rd) >= 2).MaxByWithFallback((RoadDef rd) => rd.priority); DrawCommand item; if (bestRoadType != null) { NeededRoad neededRoad = neededRoads[neededRoads.FindIndex((NeededRoad nr) => nr.road == bestRoadType)]; neededRoads.RemoveAt(neededRoads.FindIndex((NeededRoad nr) => nr.road == bestRoadType)); NeededRoad neededRoad2 = neededRoads[neededRoads.FindIndex((NeededRoad nr) => nr.road == bestRoadType)]; neededRoads.RemoveAt(neededRoads.FindIndex((NeededRoad nr) => nr.road == bestRoadType)); RoadPathingDef pathingDef = neededRoad.road.pathingMode; IntVec3 intVec = FindRoadExitCell(map, neededRoad.angle, centerpoint, ref pathingDef); IntVec3 end = FindRoadExitCell(map, neededRoad2.angle, intVec, ref pathingDef); Action action = PrepDrawRoad(map, rockDef, intVec, end, neededRoad.road, pathingDef, out centerpoint); item = new DrawCommand { action = action, roadDef = bestRoadType }; list.Add(item); } foreach (NeededRoad item2 in neededRoads) { RoadPathingDef pathingDef2 = item2.road.pathingMode; IntVec3 intVec2 = FindRoadExitCell(map, item2.angle, centerpoint, ref pathingDef2); if (!(intVec2 == IntVec3.Invalid)) { item = new DrawCommand { action = PrepDrawRoad(map, rockDef, centerpoint, intVec2, item2.road, pathingDef2), roadDef = item2.road }; list.Add(item); } } foreach (DrawCommand item3 in list.OrderBy((DrawCommand dc) => dc.roadDef.priority)) { if (item3.action != null) { item3.action(); } } }
public override void Generate(Map map) { List <GenStep_Roads.NeededRoad> neededRoads = this.CalculateNeededRoads(map); if (neededRoads.Count == 0) { return; } List <GenStep_Roads.DrawCommand> list = new List <GenStep_Roads.DrawCommand>(); DeepProfiler.Start("RebuildAllRegions"); map.regionAndRoomUpdater.RebuildAllRegionsAndRooms(); DeepProfiler.End(); TerrainDef rockDef = BaseGenUtility.RegionalRockTerrainDef(map.Tile, false); IntVec3 intVec = CellFinderLoose.TryFindCentralCell(map, 3, 10, null); RoadDef bestRoadType = (from rd in DefDatabase <RoadDef> .AllDefs where neededRoads.Count((GenStep_Roads.NeededRoad nr) => nr.road == rd) >= 2 select rd).MaxByWithFallback((RoadDef rd) => rd.priority, null); if (bestRoadType != null) { GenStep_Roads.NeededRoad neededRoad = neededRoads[neededRoads.FindIndex((GenStep_Roads.NeededRoad nr) => nr.road == bestRoadType)]; neededRoads.RemoveAt(neededRoads.FindIndex((GenStep_Roads.NeededRoad nr) => nr.road == bestRoadType)); GenStep_Roads.NeededRoad neededRoad2 = neededRoads[neededRoads.FindIndex((GenStep_Roads.NeededRoad nr) => nr.road == bestRoadType)]; neededRoads.RemoveAt(neededRoads.FindIndex((GenStep_Roads.NeededRoad nr) => nr.road == bestRoadType)); RoadPathingDef pathingMode = neededRoad.road.pathingMode; IntVec3 intVec2 = this.FindRoadExitCell(map, neededRoad.angle, intVec, ref pathingMode); IntVec3 end = this.FindRoadExitCell(map, neededRoad2.angle, intVec2, ref pathingMode); Action action = this.PrepDrawRoad(map, rockDef, intVec2, end, neededRoad.road, pathingMode, out intVec); list.Add(new GenStep_Roads.DrawCommand { action = action, roadDef = bestRoadType }); } foreach (GenStep_Roads.NeededRoad current in neededRoads) { RoadPathingDef pathingMode2 = current.road.pathingMode; IntVec3 intVec3 = this.FindRoadExitCell(map, current.angle, intVec, ref pathingMode2); if (!(intVec3 == IntVec3.Invalid)) { list.Add(new GenStep_Roads.DrawCommand { action = this.PrepDrawRoad(map, rockDef, intVec, intVec3, current.road, pathingMode2), roadDef = current.road }); } } foreach (GenStep_Roads.DrawCommand current2 in from dc in list orderby dc.roadDef.priority select dc) { if (current2.action != null) { current2.action(); } } }
public static bool ExecuteToExecuteWhenFinished() { if (executingToExecuteWhenFinished) { //Log.Warning("Already executing."); //return false; } executingToExecuteWhenFinished = true; if (toExecuteWhenFinished2.Count > 0) { DeepProfiler.Start("ExecuteToExecuteWhenFinished()"); } Action action; //for (int i = 0; i < toExecuteWhenFinished.Count; i++) while (toExecuteWhenFinished2.TryDequeue(out action)) { /* * try * { * action = toExecuteWhenFinished[i]; * } * catch (ArgumentOutOfRangeException) * { * break; * } */ DeepProfiler.Start(action.Method.DeclaringType.ToString() + " -> " + action.Method.ToString()); try { action(); } catch (Exception arg) { Log.Error("Could not execute post-long-event action. Exception: " + arg); } finally { DeepProfiler.End(); } } if (toExecuteWhenFinished2.Count > 0) { DeepProfiler.End(); } // toExecuteWhenFinished.Clear(); executingToExecuteWhenFinished = false; return(false); }
private void DoGlobalWork() { // priority settings on worktables. DeepProfiler.Start("Global work for production manager"); // TODO: Fix global work for production jobs. // ManagerJob_Production.GlobalWork(); DeepProfiler.End(); // clear turbine cells. DeepProfiler.Start("Global work for forestry manager"); DeepProfiler.End(); }
public override void Generate(Map map, GenStepParams parms) { DeepProfiler.Start("GenerateInitialFogGrid"); map.fogGrid.SetAllFogged(); FloodFillerFog.FloodUnfog(MapGenerator.PlayerStartSpot, map); List <IntVec3> rootsToUnfog = MapGenerator.rootsToUnfog; for (int i = 0; i < rootsToUnfog.Count; i++) { FloodFillerFog.FloodUnfog(rootsToUnfog[i], map); } DeepProfiler.End(); }
public static World GenerateWorld(float planetCoverage, string seedString, OverallRainfall overallRainfall, OverallTemperature overallTemperature) { DeepProfiler.Start("GenerateWorld"); Rand.PushState(); int seedFromSeedString = WorldGenerator.GetSeedFromSeedString(seedString); Rand.Seed = seedFromSeedString; World creatingWorld; try { Current.CreatingWorld = new World(); Current.CreatingWorld.info.seedString = seedString; Current.CreatingWorld.info.planetCoverage = planetCoverage; Current.CreatingWorld.info.overallRainfall = overallRainfall; Current.CreatingWorld.info.overallTemperature = overallTemperature; Current.CreatingWorld.info.name = NameGenerator.GenerateName(RulePackDefOf.NamerWorld, null, false, null, null); WorldGenerator.tmpGenSteps.Clear(); WorldGenerator.tmpGenSteps.AddRange(WorldGenerator.GenStepsInOrder); for (int i = 0; i < WorldGenerator.tmpGenSteps.Count; i++) { DeepProfiler.Start("WorldGenStep - " + WorldGenerator.tmpGenSteps[i]); try { Rand.Seed = Gen.HashCombineInt(seedFromSeedString, WorldGenerator.GetSeedPart(WorldGenerator.tmpGenSteps, i)); WorldGenerator.tmpGenSteps[i].worldGenStep.GenerateFresh(seedString); } catch (Exception arg) { Log.Error("Error in WorldGenStep: " + arg, false); } finally { DeepProfiler.End(); } } Rand.Seed = seedFromSeedString; Current.CreatingWorld.grid.StandardizeTileData(); Current.CreatingWorld.FinalizeInit(); Find.Scenario.PostWorldGenerate(); creatingWorld = Current.CreatingWorld; } finally { Rand.PopState(); DeepProfiler.End(); Current.CreatingWorld = null; } return(creatingWorld); }
public static bool Prefix(Map map) { ModExt_Biome_FeatureControl extFtControl = map.Biome.GetModExtension <ModExt_Biome_FeatureControl>(); if (extFtControl == null || extFtControl.overwriteRoof != RoofOverwriteType.FullStable) { return(true); } DeepProfiler.Start("RebuildAllRegions"); map.regionAndRoomUpdater.RebuildAllRegionsAndRooms(); DeepProfiler.End(); MapGenerator.PlayerStartSpot = CellFinderLoose.TryFindCentralCell(map, 7, MinRoomCellCount, (IntVec3 x) => x.CloseToEdge(map, MaxDistanceToEdge)); return(false); }
public static bool ExecuteToExecuteWhenFinished() { if (executingToExecuteWhenFinished) { Log.Warning("Already executing.", false); return(false); } executingToExecuteWhenFinished = true; if (toExecuteWhenFinished.Count > 0) { DeepProfiler.Start("ExecuteToExecuteWhenFinished()"); } Action action; for (int i = 0; i < toExecuteWhenFinished.Count; i++) { action = null; try { action = toExecuteWhenFinished[i]; } catch (ArgumentOutOfRangeException) { break; } if (null == action) { break; } DeepProfiler.Start(action.Method.DeclaringType.ToString() + " -> " + action.Method.ToString()); try { action(); } catch (Exception arg) { Log.Error("Could not execute post-long-event action. Exception: " + arg, false); } finally { DeepProfiler.End(); } } if (toExecuteWhenFinished.Count > 0) { DeepProfiler.End(); } toExecuteWhenFinished.Clear(); executingToExecuteWhenFinished = false; return(false); }
static bool Prefix(Dictionary <XmlNode, LoadableXmlAsset> assetlookup) { DeepProfiler.Start("Applying Patches"); // setup table of patch ownership if (!Memory.Instance.init()) { // failure tells no patches were found // if this is the case, return false to avoid the index crash related to iterting an empty list in ApplyPatches return(false); } // Blank the current mod/file since it's not present for vanilla patching. Memory.Instance.setModAndFile("", "", true); Memory.Instance.setassetlookup(assetlookup); return(true); }
private static void ApplySaveGamePatches() { DeepProfiler.Start("Patching Save Game"); LoadGameFromSaveFilePatch.LoadSaveGamePatches(); LoadGameFromSaveFilePatch.LoadNotPresentPatches(); Log.Message(string.Format("Applying {0:d} SaveGamePatches", SaveGamePatches.patches.Count)); foreach (PatchOperation patch in SaveGamePatches.patches) { patch.Apply(Scribe.loader.curXmlParent.OwnerDocument); } Log.Message(string.Format("Applying {0:d} NotPresent Patches", SaveGamePatches.notPresentPatches.Count)); foreach (PatchOperation patch in SaveGamePatches.notPresentPatches) { patch.Apply(Scribe.loader.curXmlParent.OwnerDocument); } DeepProfiler.End(); }
public void Run() { if (DeepProfiler.enabled) { DeepProfiler.Start(ToString()); } try { RunInt(); } catch (Exception ex) { Log.Error("Exception running " + GetType().Name + ": " + ex + "\n\nSlate vars:\n" + QuestGen.slate.ToString()); } if (DeepProfiler.enabled) { DeepProfiler.End(); } }
public void Run() { if (DeepProfiler.enabled) { DeepProfiler.Start(ToString()); } try { RunInt(); } catch (Exception ex) { Log.Error(string.Concat("Exception running ", GetType().Name, ": ", ex, "\n\nSlate vars:\n", QuestGen.slate.ToString())); } if (DeepProfiler.enabled) { DeepProfiler.End(); } }
//static void Prefix(IEnumerable<GenStepWithParams> genStepDefs, Map map, int seed) static bool Prefix(Map map, int seed) { if (!map.Biome.defName.Equals("Ocean")) { return(true); } //based on MapGenerator.GenerateMap //MapGenerator.data.Clear(); Rand.PushState(); try { Rand.Seed = seed; RockNoises.Init(map); //OceanGenSteps.Clear(); //OceanGenSteps.AddRange((IEnumerable<GenStepWithParams>)genStepDefs.OrderBy<GenStepWithParams, float>((Func<GenStepWithParams, float>)(x => x.def.order)).ThenBy<GenStepWithParams, ushort>((Func<GenStepWithParams, ushort>)(x => x.def.index))); for (int index = 0; index < WaterGenerator.oceanGenSteps.Count; ++index) { DeepProfiler.Start("GenStep - " + (object)WaterGenerator.oceanGenSteps[index].def); try { //Rand.Seed = Gen.HashCombineInt(seed, MapGenerator.GetSeedPart(OceanGenSteps, index)); WaterGenerator.oceanGenSteps[index].def.genStep.Generate(map, WaterGenerator.oceanGenSteps[index].parms); } catch (Exception ex) { Log.Error("Error in GenStep: " + (object)ex, false); } finally { DeepProfiler.End(); } } } finally { Rand.PopState(); RockNoises.Reset(); //MapGenerator.data.Clear(); } return(false); }
public void LoadModCheckPatches() { DeepProfiler.Start("Loading all ModCheck patches"); this.patches = new List <PatchOperation>(); int modIndex = -1; foreach (ModContentPack mod in LoadedModManager.RunningMods) { ++modIndex; List <LoadableXmlAsset> list = DirectXmlLoader.XmlAssetsInModFolder(mod, "ModCheckPatches/").ToList <LoadableXmlAsset>(); for (int i = 0; i < list.Count; i++) { XmlElement documentElement = list[i].xmlDoc.DocumentElement; if (documentElement.Name != "Patch") { Log.Error(string.Format("Unexpected document element in patch XML; got {0}, expected 'Patch'", documentElement.Name), false); } else { for (int j = 0; j < documentElement.ChildNodes.Count; j++) { XmlNode xmlNode = documentElement.ChildNodes[j]; if (xmlNode.NodeType == XmlNodeType.Element) { if (xmlNode.Name != "Operation") { Log.Error(string.Format("Unexpected element in patch XML; got {0}, expected 'Operation'", documentElement.ChildNodes[j].Name), false); } else { PatchOperation patchOperation = DirectXmlToObject.ObjectFromXml <PatchOperation>(xmlNode, false); patchOperation.sourceFile = list[i].FullFilePath; this.patches.Add(patchOperation); PatchMemory.Add(new PatchMemoryModule(modIndex, mod.Name, patchOperation, true)); } } } } } } DeepProfiler.End(); }
public static void LoadInMainThread(TempGameData gameData) { DeepProfiler.Start("Multiplayer LoadInMainThread"); ClearState(); MemoryUtility.ClearAllMapsAndWorld(); LoadPatch.gameToLoad = gameData; CancelRootPlayStartLongEvents.cancel = true; Find.Root.Start(); CancelRootPlayStartLongEvents.cancel = false; // SaveCompression enabled in the patch SavedGameLoaderNow.LoadGameFromSaveFileNow(null); Log.Message($"loading stack {FactionContext.stack.Count}"); DeepProfiler.End(); }
public static void load(ref List <Thing> thingsToLoad, string fileLocation, Thing currentSource) { Log.Message("ScribeINIT, loding from:" + fileLocation); Scribe.loader.InitLoading(fileLocation); //Scribe.EnterNode("Stargate"); Log.Message("DeepProfiler.Start()"); DeepProfiler.Start("Load non-compressed things"); // List<Thing> list2 = (List<Thing>)null; Log.Message("Scribe_Collections.LookList"); Scribe_Collections.Look <Thing>(ref thingsToLoad, "things", LookMode.Deep); Log.Message("List1Count:" + thingsToLoad.Count); Log.Message("DeepProfiler.End()"); DeepProfiler.End(); //Scribe.ExitNode(); Scribe.mode = LoadSaveMode.Inactive; //Log.Message("list: " + thingsToLoad.Count.ToString()); Log.Message("Exit Node"); //Scribe.ExitNode(); Log.Message("ResolveAllCrossReferences"); //CrossRefHandler var c = new CrossRefHandler(); c.ResolveAllCrossReferences(); Log.Message("DoAllPostLoadInits"); var p = new PostLoadIniter(); p.DoAllPostLoadInits(); Log.Message("Return"); }
static bool Prefix(Verse.ModContentPack __instance) { DeepProfiler.Start("Loading all patches"); List <PatchOperation> lst = new List <PatchOperation>(); typeof(ModContentPack).GetField("patches", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance) .SetValue(__instance, lst); List <LoadableXmlAsset> list = DirectXmlLoader.XmlAssetsInModFolder(__instance, "Patches/").ToList <LoadableXmlAsset>(); for (int i = 0; i < list.Count; i++) { XmlElement documentElement = list[i].xmlDoc.DocumentElement; if (documentElement.Name != "Patch") { Log.Error(string.Format("Unexpected document element in patch XML; got {0}, expected 'Patch'", documentElement.Name), false); } else { foreach (XmlNode xmlNode in documentElement.ChildNodes) { if (xmlNode.NodeType == XmlNodeType.Element) { if (xmlNode.Name != "Operation") { Log.Error(string.Format("Unexpected element in patch XML; got {0}, expected 'Operation'", xmlNode.Name), false); } else { PatchOperation patchOperation = DirectXmlToObject.ObjectFromXml <PatchOperation>(xmlNode, false); patchOperation.sourceFile = list[i].FullFilePath; lst.Add(patchOperation); } } } } } DeepProfiler.End(); return(false); }
public static void ReloadAllBackstories() { foreach (Backstory item in DirectXmlLoader.LoadXmlDataInResourcesFolder <Backstory>("Backstories/Shuffled")) { DeepProfiler.Start("Backstory.PostLoad"); try { item.PostLoad(); } finally { DeepProfiler.End(); } DeepProfiler.Start("Backstory.ResolveReferences"); try { item.ResolveReferences(); } finally { DeepProfiler.End(); } foreach (string item2 in item.ConfigErrors(ignoreNoSpawnCategories: false)) { Log.Error(item.title + ": " + item2); } DeepProfiler.Start("AddBackstory"); try { AddBackstory(item); } finally { DeepProfiler.End(); } } SolidBioDatabase.LoadAllBios(); }
public static World GenerateWorld(float planetCoverage, string seedString, OverallRainfall overallRainfall, OverallTemperature overallTemperature) { DeepProfiler.Start("GenerateWorld"); Rand.Seed = (GenText.StableStringHash(seedString) ^ 4323276); Current.CreatingWorld = new World(); Current.CreatingWorld.info.planetCoverage = planetCoverage; Current.CreatingWorld.info.seedString = seedString; Current.CreatingWorld.info.overallRainfall = overallRainfall; Current.CreatingWorld.info.overallTemperature = overallTemperature; Current.CreatingWorld.info.name = NameGenerator.GenerateName(RulePackDefOf.NamerWorld, null, false, null); foreach (WorldGenStepDef current in from gs in DefDatabase <WorldGenStepDef> .AllDefs orderby gs.order select gs) { DeepProfiler.Start("WorldGenStep - " + current); try { current.worldGenStep.GenerateFresh(seedString); } catch (Exception arg) { Log.Error("Error in WorldGenStep: " + arg); } finally { DeepProfiler.End(); } } Current.CreatingWorld.grid.StandardizeTileData(); Current.CreatingWorld.FinalizeInit(); Find.Scenario.PostWorldGenerate(); World creatingWorld = Current.CreatingWorld; Current.CreatingWorld = null; DeepProfiler.End(); return(creatingWorld); }
/// <summary> /// Generate a minimal map with elevation and fertility grids /// </summary> private static MapGridSet GenerateMapGrids(int mapTile, int mapSize, bool revealCaves) { DeepProfiler.Start("generateMapPreviewGrids"); try { Rand.PushState(); var mapGeneratorData = (Dictionary <string, object>)ReflectionCache.MapGenerator_Data.GetValue(null); mapGeneratorData.Clear(); var map = CreateMapStub(mapSize, mapTile); MapGenerator.mapBeingGenerated = map; var mapSeed = Gen.HashCombineInt(Find.World.info.Seed, map.Tile); Rand.Seed = mapSeed; RockNoises.Init(map); var elevationFertilityGenstep = new GenStep_ElevationFertility(); Rand.Seed = Gen.HashCombineInt(mapSeed, elevationFertilityGenstep.SeedPart); elevationFertilityGenstep.Generate(map, new GenStepParams()); if (revealCaves) { var cavesGenstep = new GenStep_Caves(); Rand.Seed = Gen.HashCombineInt(mapSeed, cavesGenstep.SeedPart); cavesGenstep.Generate(map, new GenStepParams()); } var result = new MapGridSet(MapGenerator.Elevation, MapGenerator.Fertility, MapGenerator.Caves, map); mapGeneratorData.Clear(); return(result); } finally { DeepProfiler.End(); MapGenerator.mapBeingGenerated = null; Rand.PopState(); } }
static bool Prefix() { foreach (Type type in GenTypes.AllTypesWithAttribute <StaticConstructorOnStartup>()) { DeepProfiler.Start($"Static ctor: {type.FullName}"); try { RuntimeHelpers.RunClassConstructor(type.TypeHandle); } catch (Exception ex) { Log.Error(string.Concat("Error in static constructor of ", type, ": ", ex)); } finally { DeepProfiler.End(); } } StaticConstructorOnStartupUtility.coreStaticAssetsLoaded = true; return(false); }
public static Quest Generate(QuestScriptDef root, Slate initialVars) { if (DeepProfiler.enabled) { DeepProfiler.Start("Generate quest"); } Quest result = null; try { if (working) { throw new Exception("Called Generate() while already working."); } working = true; QuestGen.root = root; slate.Reset(); slate.SetAll(initialVars); quest = Quest.MakeRaw(); quest.ticksUntilAcceptanceExpiry = (int)(root.expireDaysRange.RandomInRange * 60000f); if (root.defaultChallengeRating > 0) { quest.challengeRating = root.defaultChallengeRating; } quest.root = root; quest.hidden = root.defaultHidden; slate.SetIfNone("inSignal", quest.InitiateSignal); root.Run(); try { QuestNode_ResolveQuestName.Resolve(); } catch (Exception arg) { Log.Error("Error while generating quest name: " + arg); } try { QuestNode_ResolveQuestDescription.Resolve(); } catch (Exception arg2) { Log.Error("Error while generating quest description: " + arg2); } try { QuestNode_ResolveTextRequests.Resolve(); } catch (Exception arg3) { Log.Error("Error while resolving text requests: " + arg3); } AddSlateQuestTags(); bool flag = root.autoAccept; if (flag) { List <QuestPart> partsListForReading = quest.PartsListForReading; for (int i = 0; i < partsListForReading.Count; i++) { if (partsListForReading[i].PreventsAutoAccept) { flag = false; break; } } } if (flag) { quest.SetInitiallyAccepted(); } result = quest; return(result); } catch (Exception arg4) { Log.Error("Error in QuestGen: " + arg4); return(result); } finally { if (DeepProfiler.enabled) { DeepProfiler.End(); } quest = null; QuestGen.root = null; working = false; generatedPawns.Clear(); textRequests.Clear(); slate.Reset(); questDescriptionRules.Clear(); questDescriptionConstants.Clear(); questNameRules.Clear(); questNameConstants.Clear(); questContentRules.Clear(); slateQuestTagsToAddWhenFinished.Clear(); ResetIdCounters(); } }