public static void Look <T>(ref T[] list, string label, params object[] ctorArgs) where T : IExposable { if (Scribe.EnterNode(label) == false) { return; } try { if (Scribe.mode == LoadSaveMode.Saving) { if (list == null) { Scribe.saver.WriteAttribute("IsNull", "True"); } else { foreach (var current in list) { var t2 = current; Scribe_Deep.Look <T>(ref t2, false, "li", ctorArgs); } } } else if (Scribe.mode == LoadSaveMode.LoadingVars) { var curXmlParent = Scribe.loader.curXmlParent; var xmlAttribute = curXmlParent.Attributes["IsNull"]; if (xmlAttribute != null && xmlAttribute.Value.ToLower() == "true") { list = null; } else { list = new T[curXmlParent.ChildNodes.Count]; var i = 0; foreach (var subNode2 in curXmlParent.ChildNodes) { list[i++] = ScribeExtractor.SaveableFromNode <T>((XmlNode)subNode2, ctorArgs); } } } } finally { Scribe.ExitNode(); } }
public static bool Prefix(ScribeSaver __instance, string filePath, string documentElementName) { if (!Enable) { return(true); } Loger.Log("ScribeSaver_InitSaving_Patch Start"); var that = Traverse.Create(__instance); if (Scribe.mode != 0) { Log.Error("Called InitSaving() but current mode is " + Scribe.mode); Scribe.ForceStop(); } if (that.Field("curPath").GetValue <string>() != null) { Log.Error("Current path is not null in InitSaving"); that.Field("curPath").SetValue(null); that.Field("savedNodes").GetValue <HashSet <string> >().Clear(); that.Field("nextListElementTemporaryId").SetValue(0); } try { Scribe.mode = LoadSaveMode.Saving; var saveStream = SaveData = new MemoryStream(); //var saveStream = new FileStream(filePath, FileMode.Create, FileAccess.Write, FileShare.None); File.WriteAllText(filePath, "Online save"); that.Field("saveStream").SetValue(saveStream); XmlWriterSettings xmlWriterSettings = new XmlWriterSettings(); xmlWriterSettings.Indent = true; xmlWriterSettings.IndentChars = "\t"; var writer = XmlWriter.Create(saveStream, xmlWriterSettings); that.Field("writer").SetValue(writer); writer.WriteStartDocument(); __instance.EnterNode(documentElementName); } catch (Exception ex) { Log.Error("Exception while init saving file: " + filePath + "\n" + ex); __instance.ForceStop(); throw; } Loger.Log("ScribeSaver_InitSaving_Patch End"); return(false); }
static void Main() { var scribe = new Scribe(new PersistedOptions { DirPath = "ScribedEvents", StreamSource = new FileStreamSource("ScribedEvents"), MaxTimeToWaitForFlush = TimeSpan.FromMilliseconds(200) }); var sp = Stopwatch.StartNew(); Task.Factory.StartNew(() => { while (run) { Console.WriteLine("{0:#,#} in {1:#,#} ms", count, sp.ElapsedMilliseconds); Thread.Sleep(500); } }); var data = new UserCreated { UserId = Guid.NewGuid(), Name = "Ayende" }; Parallel.For(0, 1000 * 10, i => { var tasks = new Task[1000]; for (int j = 0; j < 1000; j++) { tasks[j] = scribe.EnqueueEventAsync("users/" + j, data); Interlocked.Increment(ref count); } Task.WaitAll(tasks); }); run = false; Console.WriteLine(sp.ElapsedMilliseconds); for (int i = 124; i < 1000 * 10; i += 1293) { sp.Restart(); scribe.ReadRaw("users/" + i).Count(); Console.WriteLine(i + " " + sp.ElapsedMilliseconds); } }
private void ExposeDataSave() { bool hidden; foreach (var minimap in Controller.Data.MiniMaps) { #region Minimap Header if (!Scribe.EnterNode(minimap.SaveKey)) { continue; } #endregion hidden = minimap.Hidden; Scribe_Values.LookValue(ref hidden, "hidden", minimap.miniMapDef.hiddenByDefault, true); #region Handle all MiniMap Overlays foreach (var overlay in minimap.overlayWorkers) { #region Overlay Header var saveKey = overlay.SaveKey; if ( (string.IsNullOrEmpty(saveKey)) || (!Scribe.EnterNode(overlay.SaveKey)) ) { continue; } #endregion hidden = overlay.Hidden; Scribe_Values.LookValue(ref hidden, "hidden", overlay.overlayDef.hiddenByDefault, true); #region Finalize Overlay Scribe.ExitNode(); #endregion } #endregion #region Finalize Minimap Scribe.ExitNode(); #endregion } }
public static bool Prefix(ScribeLoader __instance, string filePath) { if (!ScribeLoader_InitLoading_Patch.Enable) { return(true); } Loger.Log("ScribeLoader_InitLoadingMetaHeaderOnly_Patch Start"); if (Scribe.mode != 0) { Log.Error("Called InitLoadingMetaHeaderOnly() but current mode is " + Scribe.mode); Scribe.ForceStop(); } try { using (var input = new MemoryStream(ScribeLoader_InitLoading_Patch.LoadData)) //using (StreamReader input = new StreamReader(filePath)) { using (XmlTextReader xmlTextReader = new XmlTextReader(input)) { if (!ScribeMetaHeaderUtility.ReadToMetaElement(xmlTextReader)) { return(false); } using (XmlReader reader = xmlTextReader.ReadSubtree()) { XmlDocument xmlDocument = new XmlDocument(); xmlDocument.Load(reader); XmlElement xmlElement = xmlDocument.CreateElement("root"); xmlElement.AppendChild(xmlDocument.DocumentElement); __instance.curXmlParent = xmlElement; } } } Scribe.mode = LoadSaveMode.LoadingVars; } catch (Exception ex) { Log.Error("Exception while init loading meta header: " + filePath + "\n" + ex); __instance.ForceStop(); throw; } Loger.Log("ScribeLoader_InitLoadingMetaHeaderOnly_Patch End"); return(false); }
public override void PostExposeData() { base.PostExposeData(); Scribe.EnterNode("CompUpgrade_" + Props.referenceId); Scribe_Values.Look(ref complete, "complete"); if (!(Scribe.mode == LoadSaveMode.Saving && complete)) { Scribe_Values.Look(ref workDone, "workDone"); Scribe_Values.Look(ref wantsWork, "wantsWork"); Scribe_Deep.Look(ref ingredients, "ingredients", this); } if (ingredients == null) { ingredients = new ThingOwner <Thing>(this); } Scribe.ExitNode(); }
static bool Prefix() { if (gameToLoad == null) { return(true); } SaveCompression.doSaveCompression = true; try { ScribeUtil.StartLoading(gameToLoad.SaveData); ScribeMetaHeaderUtility.LoadGameDataHeader(ScribeMetaHeaderUtility.ScribeHeaderMode.Map, false); Scribe.EnterNode("game"); Current.Game = new Game(); Current.Game.LoadGame(); // calls Scribe.loader.FinalizeLoading() SemiPersistent.ReadSemiPersistent(gameToLoad.SemiPersistent); } finally { SaveCompression.doSaveCompression = false; gameToLoad = null; } Log.Message("Game loaded"); if (Multiplayer.Client != null) { LongEventHandler.ExecuteWhenFinished(() => { // Inits all caches foreach (ITickable tickable in TickPatch.AllTickables.Where(t => !(t is ConstantTicker))) { tickable.Tick(); } if (!Current.Game.Maps.Any()) { MemoryUtility.UnloadUnusedUnityAssets(); Find.World.renderer.RegenerateAllLayersNow(); } }); } return(false); }
// // Static Methods // public static void SaveToFile(PrepareCarefully data, string presetName) { try { Scribe.InitWriting(PresetFiles.FilePathForSavedPreset(presetName), "preset"); string versionStringFull = "3"; Scribe_Values.LookValue <string>(ref versionStringFull, "version", null, false); bool usePoints = data.Config.pointsEnabled; int startingPoints = PrepareCarefully.Instance.StartingPoints; Scribe_Values.LookValue <bool>(ref usePoints, "usePoints", false, true); Scribe_Values.LookValue <int>(ref startingPoints, "startingPoints", 0, true); string modString = GenText.ToCommaList(Enumerable.Select <ModContentPack, string>(LoadedModManager.RunningMods, (Func <ModContentPack, string>)(mod => mod.Name)), true); Scribe_Values.LookValue <string>(ref modString, "mods", null, false); Scribe.EnterNode("colonists"); foreach (CustomPawn customPawn in data.Pawns) { SaveRecordPawnV3 pawn = new SaveRecordPawnV3(customPawn); Scribe_Deep.LookDeep <SaveRecordPawnV3>(ref pawn, "colonist"); } Scribe.ExitNode(); Scribe.EnterNode("relationships"); foreach (var r in data.RelationshipManager.ExplicitRelationships) { SaveRecordRelationshipV3 s = new SaveRecordRelationshipV3(r); Scribe_Deep.LookDeep <SaveRecordRelationshipV3>(ref s, "relationship"); } Scribe.ExitNode(); Scribe.EnterNode("equipment"); foreach (var e in data.Equipment) { SelectedEquipment customPawn = e; Scribe_Deep.LookDeep <SelectedEquipment>(ref customPawn, "equipment"); } Scribe.ExitNode(); } catch (Exception e) { Log.Error("Failed to save preset file"); throw e; } finally { Scribe.FinalizeWriting(); Scribe.mode = LoadSaveMode.Inactive; } }
public static bool Prefix(ScribeLoader __instance, string filePath) { if (!Enable) { return(true); } Loger.Log("ScribeLoader_InitLoading_Patch Start"); if (Scribe.mode != 0) { Log.Error("Called InitLoading() but current mode is " + Scribe.mode); Scribe.ForceStop(); } if (__instance.curParent != null) { Log.Error("Current parent is not null in InitLoading"); __instance.curParent = null; } if (__instance.curPathRelToParent != null) { Log.Error("Current path relative to parent is not null in InitLoading"); __instance.curPathRelToParent = null; } try { using (var input = new MemoryStream(LoadData)) //using (StreamReader input = new StreamReader(filePath)) { using (XmlTextReader reader = new XmlTextReader(input)) { XmlDocument xmlDocument = new XmlDocument(); xmlDocument.Load(reader); __instance.curXmlParent = xmlDocument.DocumentElement; } } Scribe.mode = LoadSaveMode.LoadingVars; } catch (Exception ex) { Log.Error("Exception while init loading file: " + filePath + "\n" + ex); __instance.ForceStop(); throw; } Loger.Log("ScribeLoader_InitLoading_Patch End"); return(false); }
public bool Load(PrepareCarefully loadout, Page_ConfigureStartingPawnsCarefully charMakerPage, string colonistName) { SaveRecordPawnV3 pawnRecord = new SaveRecordPawnV3(); string modString = ""; string version = ""; try { Scribe.InitLoading(ColonistFiles.FilePathForSavedColonist(colonistName)); Scribe_Values.LookValue <string>(ref version, "version", "unknown", false); Scribe_Values.LookValue <string>(ref modString, "mods", "", false); try { Scribe_Deep.LookDeep <SaveRecordPawnV3>(ref pawnRecord, "colonist", null); } catch (Exception e) { Messages.Message(modString, MessageSound.Silent); Messages.Message("EdB.ColonistLoadFailed".Translate(), MessageSound.RejectInput); Log.Warning(e.ToString()); Log.Warning("Colonist was created with the following mods: " + modString); return(false); } } catch (Exception e) { Log.Error("Failed to load preset file"); throw e; } finally { Scribe.mode = LoadSaveMode.Inactive; } PresetLoaderVersion3 loader = new PresetLoaderVersion3(); charMakerPage.AddColonist(loader.LoadPawn(pawnRecord)); if (loader.Failed) { Messages.Message(loader.ModString, MessageSound.Silent); Messages.Message("EdB.ColonistThingDefFailed".Translate(), MessageSound.SeriousAlert); Log.Warning("Preset was created with the following mods: " + modString); return(false); } return(true); }
public void Scibe_Write_Property_With_Custom_Padding_No_Char_Supplied_Writes_Values() { var expected = "ZZZ "; var fieldFormatter = new FieldFormatter(); var business = new BusinessWithPropertyThatUsesCustomerPaddingNoPaddingChar() { BusinessDBA = "ZZZ" }; using (var writer = new StringWriter()) { IScribe scribe = new Scribe(writer, fieldFormatter); scribe.Write(business); var actual = writer.ToString(); Assert.Equal(expected, actual); } }
public void Scibe_Write_Property_With_Custom_Char_Writes() { var expected = "ZZZZZXXXXX"; var fieldFormatter = new FieldFormatter(); var business = new BusinessWithPropertyThatUsesCustomPadding() { BusinessName = "ZZZZZ" }; using (var writer = new StringWriter()) { IScribe scribe = new Scribe(writer, fieldFormatter); scribe.Write(business); var actual = writer.ToString(); Assert.Equal(expected, actual); } }
public static void InitLoading(string[] filePaths) { if (Scribe.mode != LoadSaveMode.Inactive) { Log.Error("Called InitLoading() but current mode is " + Scribe.mode.ToString(), false); Scribe.ForceStop(); } try { foreach (var filePath in filePaths) { if (xmlParents.ContainsKey(filePath)) { continue; } using (var streamReader = new StreamReader(filePath)) { using (var xmlTextReader = new XmlTextReader(streamReader)) { var xmlDocument = new XmlDocument(); xmlDocument.Load(xmlTextReader); xmlParents.Add(filePath, xmlDocument.DocumentElement); } } } Scribe.mode = LoadSaveMode.LoadingVars; } catch (Exception e) { Log.Error(string.Concat(new object[] { "Exception while init loading files: ", filePaths.ToCommaList(), "\n", e }), false); throw; } }
private static void Main(string[] args) { Village nile = new Village("Nile River"); Egyptian f1 = new FarmerSlave("Pashedu", "Farmer"); Egyptian f2 = new FarmerSlave("Nykara", "Farmer"); Egyptian c1 = new Craftsmen("Nikaure", "Craftsmen"); Egyptian c2 = new Craftsmen("Djedi", "Craftsmen"); Egyptian m1 = new Merchant("Paser", "Merchant"); Egyptian scr1 = new Scribe("Pipi", "Scribe"); Egyptian sld1 = new Soldier("Qen", "Soldier"); Egyptian sld2 = new Soldier("Shoshenq", "Soldier"); Egyptian pr1 = new PriestNoblesOfficials("Wennefer", "Priest"); Egyptian pr2 = new PriestNoblesOfficials("Siese", "Treasurer"); Egyptian pr3 = new PriestNoblesOfficials("Djedptahiufankh", "Prophet"); Egyptian pharaoh = new Pharaoh("Tutankhamun", "Pharaoh"); c1.Work(); Console.WriteLine(pharaoh.ToString()); }
static ColonyLeadership() { try { Detour.Detours.TryDetourFromTo(typeof(ColonistBarColonistDrawer).GetMethod("DrawIcons", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance), typeof(Icon).GetMethod("DrawIconsModded")); } catch (Exception e) { //File.WriteAllText("logt.txt", e.Message.ToString()); } govtypes.Add(new GovType("Democracy", "DemocracyDesc", "Leader")); govtypes.Add(new GovType("Dictatorship", "DictatorshipDesc", "Dictator")); //govtypes.Add(new GovType("Monarchy", "MonarchyDesc", "Ruler")); bool flag = File.Exists(Path.Combine(GenFilePaths.SaveDataFolderPath, "ColonyLeadershipGlobal.xml")); if (flag) { try { Scribe.loader.InitLoading(Path.Combine(GenFilePaths.SaveDataFolderPath, "ColonyLeadershipGlobal.xml")); Scribe_Values.Look <String>(ref lastReadVersion, "lastReadVersion", "none", false); Scribe.loader.FinalizeLoading(); //PostLoadIniter.DoAllPostLoadInits(); } catch (Exception ex) { //File.WriteAllText("logt.txt", ex.Message.ToString()); Log.Error("Exception loading colony leadership userdata: " + ex.ToString()); Scribe.ForceStop(); } } if (ColonyLeadership.lastReadVersion != ColonyLeadership.newVersion) { DefDatabase <MainButtonDef> .GetNamed("LeaderTab").label = "(!) " + "LeadershipTab"; doUpdateNotes(); } doHelpNotes(); }
public static void SaveToFile(ref Blueprint bp, string fileName) { try { Scribe.InitWriting(BlueprintFiles.FilePathForSavedBlueprint(fileName), "blueprint"); bp.BpName = fileName; Scribe_Deep.LookDeep(ref bp, "Blueprint"); } catch (Exception e) { Log.Error("Failed to save blueprint"); throw e; } finally { Scribe.FinalizeWriting(); Scribe.mode = LoadSaveMode.Inactive; } }
public override void PostExposeData() { base.PostExposeData(); if (Scribe.EnterNode("animalGenetics")) { Scribe_References.Look(ref GeneticInformation, "geneticInformation"); GenesRecord legacyGenesRecord = null; Scribe_Collections.Look(ref legacyGenesRecord, "geneRecords"); if (legacyGenesRecord != null) { LegacyGenesRecords[this] = legacyGenesRecord; } if (Scribe.mode == LoadSaveMode.PostLoadInit) { if (GeneticInformation == null) { if (LegacyGenesRecords.ContainsKey(this)) { Log.Message("Migrating Legacy Genetic Information for " + parent.ToString()); GeneticInformation = new GeneticInformation(LegacyGenesRecords[this]); LegacyGenesRecords.Remove(this); } else { Log.Message("Generating Genetic Information for " + parent.ToString()); GeneticInformation = new GeneticInformation(null); } GeneticCalculator.EnsureAllGenesExist(GeneticInformation.GeneRecords, null, null); } else { GeneticCalculator.EnsureAllGenesExist(GeneticInformation.GeneRecords, GeneticInformation.Mother, GeneticInformation.Father); } } Scribe.ExitNode(); } }
public T FromXml <T>(string dataXML) where T : new() { XmlDocument xmlDocument = new XmlDocument(); xmlDocument.LoadXml(dataXML); Scribe.loader.curXmlParent = xmlDocument.DocumentElement; Scribe.mode = LoadSaveMode.LoadingVars; try { Scribe.EnterNode(rootElementName); var thing = new T(); Scribe_Deep.Look <T>(ref thing, "saveable", new object[0]); return(thing); } finally { //Finish() Scribe.loader.FinalizeLoading(); } }
// // Static Methods // public static void SaveToFile(PrepareCarefully loadout, Page_ConfigureStartingPawnsCarefully page, string colonistName) { try { Scribe.InitWriting(ColonistFiles.FilePathForSavedColonist(colonistName), "colonist"); string versionStringFull = "3"; Scribe_Values.LookValue <string>(ref versionStringFull, "version", null, false); string modString = GenText.ToCommaList(Enumerable.Select <ModContentPack, string>(LoadedModManager.RunningMods, (Func <ModContentPack, string>)(mod => mod.Name)), true); Scribe_Values.LookValue <string>(ref modString, "mods", null, false); SaveRecordPawnV3 pawn = new SaveRecordPawnV3(page.SelectedPawn); Scribe_Deep.LookDeep <SaveRecordPawnV3>(ref pawn, "colonist"); } catch (Exception e) { Log.Error("Failed to save preset file"); throw e; } finally { Scribe.FinalizeWriting(); Scribe.mode = LoadSaveMode.Inactive; } }
public static bool HasPossibleSameWorldName(string[] names, string filePath) { var worldName = ""; Scribe.loader.InitLoading(filePath); if (Scribe.EnterNode("game")) { if (Scribe.EnterNode("world")) { if (Scribe.EnterNode("info")) { Scribe_Values.Look <string>(ref worldName, "name"); } } } Scribe.loader.ForceStop(); return(names.Any(name => worldName.EqualsIgnoreCase(name))); }
public T FromXml <T>(string dataXML) where T : new() { lock (SuncObj) { XmlDocument xmlDocument = new XmlDocument(); xmlDocument.LoadXml(dataXML); Scribe.loader.curXmlParent = xmlDocument.DocumentElement; Scribe.mode = LoadSaveMode.LoadingVars; try { /* * bool flag = typeof(T).IsValueType || typeof(Name).IsAssignableFrom(typeof(T)); * if (!flag) * { * Scribe.loader.crossRefs.RegisterForCrossRefResolve(exposable); * }*/ FromXmlIsActive = true; Scribe.EnterNode(rootElementName); var thing = new T(); Scribe_Deep.Look <T>(ref thing, "saveable", new object[0]); // Scribe.loader.crossRefs.ResolveAllCrossReferences() return(thing); } finally { try { //Finish() Scribe.loader.FinalizeLoading(); } finally { FromXmlIsActive = false; } } } }
public void Scribe_Write_Class_Writes_Properties_To_String_Value() { var expected = "12345000000000000000BusinessName 5555555555 4567890000000000000000000000000000010000"; var fieldFormatter = new FieldFormatter(); var business = new SimpleBusiness() { BusinessId = 12345, BusinessName = "BusinessName", BusinessTelephoneNumber = "5555555555", TaxId = "456789", CashOnHand = "10000" }; using (var writer = new StringWriter()) { IScribe scribe = new Scribe(writer, fieldFormatter); scribe.Write(business); var actual = writer.ToString(); Assert.Equal(expected, actual); } }
public void Scribe_Write_Only_Writes_Public_Properties_Of_Classes() { var expected = "12345000000000000000BusinessName 5555555555 45678900000000000000"; var fieldFormatter = new FieldFormatter(); var business = new BusinessWithPrivateProperty() { BusinessId = 12345, BusinessName = "BusinessName", BusinessTelephoneNumber = "5555555555", TaxId = "456789", }; using (var writer = new StringWriter()) { IScribe scribe = new Scribe(writer, fieldFormatter); scribe.Write(business); var actual = writer.ToString(); Assert.Equal(expected, actual); } }
public override void ExposeData() { if (Verse.Scribe.mode == LoadSaveMode.Saving) { BackwardsCompatData = new Dictionary <Thing, StatGroup>(); _Things = new List <Thing>(); _StatGroups = new List <StatGroup>(); System.GC.Collect(); foreach (GeneticInformation gi in GeneticInformation.Instances) { BackwardsCompatData[gi.parent] = new StatGroup(gi); } } Scribe_Collections.Look(ref BackwardsCompatData, "data", LookMode.Reference, LookMode.Deep, ref _Things, ref _StatGroups); if (Scribe.EnterNode("settings")) { Settings.ExposeData(); Scribe.ExitNode(); } }
public static bool LoadFromFile(PrepareCarefully loadout, string presetName) { string version = ""; bool result = false; try { Scribe.InitLoading(PresetFiles.FilePathForSavedPreset(presetName)); Scribe_Values.LookValue <string>(ref version, "version", "unknown", false); } catch (Exception e) { Log.Error("Failed to load preset file"); throw e; } finally { Scribe.mode = LoadSaveMode.Inactive; } if ("1".Equals(version)) { Messages.Message("EdB.PrepareCarefully.PresetVersionNotSupported".Translate(), MessageSound.SeriousAlert); return(false); } else if ("2".Equals(version)) { Messages.Message("EdB.PrepareCarefully.PresetVersionNotSupported".Translate(), MessageSound.SeriousAlert); return(false); } else if ("3".Equals(version)) { result = new PresetLoaderVersion3().Load(loadout, presetName); } else { throw new Exception("Invalid preset version"); } return(result); }
internal static void _CheckVersionAndLoad(string path, ScribeMetaHeaderUtility.ScribeHeaderMode mode, Action loadAct) { bool mismatchWarnings; try { try { Scribe.InitLoadingMetaHeaderOnly(path); } catch (Exception ex) { Log.Warning(string.Concat(new object[4] { (object)"Exception loading ", (object)path, (object)": ", (object)ex })); } ScribeMetaHeaderUtility.LoadGameDataHeader(mode, false); mismatchWarnings = ScribeMetaHeaderUtility.TryCreateDialogsForVersionMismatchWarnings(loadAct); CrossRefResolver.ResolveAllCrossReferences(); PostLoadInitter.DoAllPostLoadInits(); } catch { CrossRefResolver.Clear(); PostLoadInitter.Clear(); throw; } Controller.Data.ResetInjectionSubController(); if (mismatchWarnings) { return; } loadAct(); }
internal static Blueprint LoadFromXML(SaveFileInfo file) { // set up empty blueprint Blueprint blueprint = new Blueprint(); #if DEBUG Log.Message("Attempting to load from: " + file.FileInfo.FullName); #endif // load stuff try { Scribe.InitLoading(BlueprintSaveLocation + "/" + file.FileInfo.Name); ScribeMetaHeaderUtility.LoadGameDataHeader(ScribeMetaHeaderUtility.ScribeHeaderMode.Map, true); Scribe.EnterNode("Blueprint"); blueprint.ExposeData(); Scribe.ExitNode(); } catch (Exception e) { Log.Error("Exception while loading blueprint: " + e); } finally { // done loading Scribe.FinalizeLoading(); Scribe.mode = LoadSaveMode.Inactive; } // if a def used in the blueprint doesn't exist, exposeData will throw an error, // which is fine. in addition, it'll set the field to null - which may result in problems down the road. // Make sure each item in the blueprint has a def set, if not - remove it. // This check itself will throw another error, which is also fine. User will have to resolve the issue manually. blueprint.contents = blueprint.contents.Where(item => item.BuildableDef != null).ToList(); // return blueprint. return(blueprint); }
public static void FinalizeLoading() { if (Scribe.mode != LoadSaveMode.LoadingVars) { Log.Error("Called FinalizeLoading() but current mode is " + Scribe.mode, false); return; } try { Scribe.ExitNode(); Scribe.loader.curXmlParent = null; Scribe.loader.curParent = null; Scribe.loader.curPathRelToParent = null; Scribe.mode = LoadSaveMode.Inactive; ResolveAllCrossReferences(); //Scribe.loader.crossRefs.ResolveAllCrossReferences(); Scribe.loader.initer.DoAllPostLoadInits(); } catch (Exception arg) { Log.Error("Exception in FinalizeLoading(): " + arg, false); Scribe.loader.ForceStop(); throw; } }
public static void load(ref List <Thing> thingsToLoad, string fileLocation, Thing currentSource) { Log.Message("ScribeINIT, loding from:" + fileLocation); Scribe.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.LookList <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"); CrossRefResolver.ResolveAllCrossReferences(); Log.Message("DoAllPostLoadInits"); PostLoadInitter.DoAllPostLoadInits(); Log.Message("Return"); }
// Performs the setup needed to begin a scribe loading operation, similar to ScribeLoader.InitLoad(), but // uses a StringReader instead of reading from a file. private static void InitLoadFromString(String value) { if (Scribe.mode != LoadSaveMode.Inactive) { Logger.Error("Called InitLoading() but current mode is " + Scribe.mode); Scribe.ForceStop(); } if (Scribe.loader.curParent != null) { Logger.Error("Current parent is not null in InitLoading"); Scribe.loader.curParent = null; } if (Scribe.loader.curPathRelToParent != null) { Logger.Error("Current path relative to parent is not null in InitLoading"); Scribe.loader.curPathRelToParent = null; } try { using (TextReader textReader = new StringReader(value)) { using (XmlTextReader xmlTextReader = new XmlTextReader(textReader)) { XmlDocument xmlDocument = new XmlDocument(); xmlDocument.Load(xmlTextReader); Scribe.loader.curXmlParent = xmlDocument.DocumentElement; } } Scribe.mode = LoadSaveMode.LoadingVars; } catch (Exception ex) { Logger.Error(string.Concat(new object[] { "Exception while unmarshalling XML", "\n", ex })); Scribe.loader.ForceStop(); throw; } }