public string DebugOutputFor(IExposable saveable)
{
if (Scribe.mode != LoadSaveMode.Inactive)
{
Log.Error("DebugOutput needs current mode to be Inactive", false);
return(string.Empty);
}
string result;
try
{
using (StringWriter stringWriter = new StringWriter())
{
XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
xmlWriterSettings.Indent = true;
xmlWriterSettings.IndentChars = " ";
xmlWriterSettings.OmitXmlDeclaration = true;
try
{
using (this.writer = XmlWriter.Create(stringWriter, xmlWriterSettings))
{
Scribe.mode = LoadSaveMode.Saving;
this.savingForDebug = true;
Scribe_Deep.Look <IExposable>(ref saveable, "saveable", new object[0]);
result = stringWriter.ToString();
}
}
finally
{
this.ForceStop();
}
}
}
catch (Exception arg)
{
Log.Error("Exception while getting debug output: " + arg, false);
this.ForceStop();
result = string.Empty;
}
return(result);
}
public string DebugOutputFor(IExposable saveable)
{
if (Scribe.mode != 0)
{
Log.Error("DebugOutput needs current mode to be Inactive");
return("");
}
try
{
using (StringWriter stringWriter = new StringWriter())
{
XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
xmlWriterSettings.Indent = true;
xmlWriterSettings.IndentChars = " ";
xmlWriterSettings.OmitXmlDeclaration = true;
try
{
using (writer = XmlWriter.Create(stringWriter, xmlWriterSettings))
{
Scribe.mode = LoadSaveMode.Saving;
savingForDebug = true;
Scribe_Deep.Look(ref saveable, "saveable");
}
return(stringWriter.ToString());
}
finally
{
ForceStop();
}
}
}
catch (Exception arg)
{
Log.Error("Exception while getting debug output: " + arg);
ForceStop();
return("");
}
}
public override void PostExposeData()
{
base.PostExposeData();
Scribe_Deep.Look(ref verbTracker, "verbTracker", this);
}
public void ExposeData()
{
Scribe_Values.Look(ref uniqueID, "uniqueID", -1);
Scribe_Values.Look(ref generationTick, "generationTick", 0);
Scribe_Deep.Look(ref info, "mapInfo");
if (Scribe.mode == LoadSaveMode.Saving)
{
compressor = new MapFileCompressor(this);
compressor.BuildCompressedString();
ExposeComponents();
compressor.ExposeData();
HashSet <string> hashSet = new HashSet <string>();
if (Scribe.EnterNode("things"))
{
try
{
foreach (Thing allThing in listerThings.AllThings)
{
try
{
if (allThing.def.isSaveable && !allThing.IsSaveCompressible())
{
if (hashSet.Contains(allThing.ThingID))
{
Log.Error("Saving Thing with already-used ID " + allThing.ThingID);
}
else
{
hashSet.Add(allThing.ThingID);
}
Thing target = allThing;
Scribe_Deep.Look(ref target, "thing");
}
}
catch (OutOfMemoryException)
{
throw;
}
catch (Exception ex2)
{
Log.Error(string.Concat("Exception saving ", allThing, ": ", ex2));
}
}
}
finally
{
Scribe.ExitNode();
}
}
else
{
Log.Error("Could not enter the things node while saving.");
}
compressor = null;
}
else
{
if (Scribe.mode == LoadSaveMode.LoadingVars)
{
ConstructComponents();
regionAndRoomUpdater.Enabled = false;
compressor = new MapFileCompressor(this);
}
ExposeComponents();
DeepProfiler.Start("Load compressed things");
compressor.ExposeData();
DeepProfiler.End();
DeepProfiler.Start("Load non-compressed things");
Scribe_Collections.Look(ref loadedFullThings, "things", LookMode.Deep);
DeepProfiler.End();
}
}
public static void Look <T>(ref T target, string label, params object[] ctorArgs)
{
Scribe_Deep.Look <T>(ref target, false, label, ctorArgs);
}
public void ExposeData()
{
Scribe_Deep.Look(ref innerContainer, "innerContainer", this);
}
public static void Look <T>(ref List <T> list, bool saveDestroyedThings, string label, LookMode lookMode = LookMode.Undefined, params object[] ctorArgs)
{
if (lookMode == LookMode.Undefined)
{
if (ParseHelper.HandlesType(typeof(T)))
{
lookMode = LookMode.Value;
}
else if (typeof(T) == typeof(LocalTargetInfo))
{
lookMode = LookMode.LocalTargetInfo;
}
else if (typeof(T) == typeof(TargetInfo))
{
lookMode = LookMode.TargetInfo;
}
else if (typeof(T) == typeof(GlobalTargetInfo))
{
lookMode = LookMode.GlobalTargetInfo;
}
else if (typeof(Def).IsAssignableFrom(typeof(T)))
{
lookMode = LookMode.Def;
}
else if (typeof(T) == typeof(BodyPartRecord))
{
lookMode = LookMode.BodyPart;
}
else
{
if (!typeof(IExposable).IsAssignableFrom(typeof(T)) || typeof(ILoadReferenceable).IsAssignableFrom(typeof(T)))
{
Log.Error("LookList call with a list of " + typeof(T) + " must have lookMode set explicitly.", false);
return;
}
lookMode = LookMode.Deep;
}
}
if (Scribe.EnterNode(label))
{
try
{
if (Scribe.mode == LoadSaveMode.Saving)
{
if (list == null)
{
Scribe.saver.WriteAttribute("IsNull", "True");
}
else
{
foreach (T current in list)
{
if (lookMode == LookMode.Value)
{
T t = current;
Scribe_Values.Look <T>(ref t, "li", default(T), true);
}
else if (lookMode == LookMode.LocalTargetInfo)
{
LocalTargetInfo localTargetInfo = (LocalTargetInfo)((object)current);
Scribe_TargetInfo.Look(ref localTargetInfo, saveDestroyedThings, "li");
}
else if (lookMode == LookMode.TargetInfo)
{
TargetInfo targetInfo = (TargetInfo)((object)current);
Scribe_TargetInfo.Look(ref targetInfo, saveDestroyedThings, "li");
}
else if (lookMode == LookMode.GlobalTargetInfo)
{
GlobalTargetInfo globalTargetInfo = (GlobalTargetInfo)((object)current);
Scribe_TargetInfo.Look(ref globalTargetInfo, saveDestroyedThings, "li");
}
else if (lookMode == LookMode.Def)
{
Def def = (Def)((object)current);
Scribe_Defs.Look <Def>(ref def, "li");
}
else if (lookMode == LookMode.BodyPart)
{
BodyPartRecord bodyPartRecord = (BodyPartRecord)((object)current);
Scribe_BodyParts.Look(ref bodyPartRecord, "li", null);
}
else if (lookMode == LookMode.Deep)
{
T t2 = current;
Scribe_Deep.Look <T>(ref t2, saveDestroyedThings, "li", ctorArgs);
}
else if (lookMode == LookMode.Reference)
{
ILoadReferenceable loadReferenceable = (ILoadReferenceable)((object)current);
Scribe_References.Look <ILoadReferenceable>(ref loadReferenceable, "li", saveDestroyedThings);
}
}
}
}
else if (Scribe.mode == LoadSaveMode.LoadingVars)
{
XmlNode curXmlParent = Scribe.loader.curXmlParent;
XmlAttribute xmlAttribute = curXmlParent.Attributes["IsNull"];
if (xmlAttribute != null && xmlAttribute.Value.ToLower() == "true")
{
list = null;
}
else if (lookMode == LookMode.Value)
{
list = new List <T>(curXmlParent.ChildNodes.Count);
foreach (XmlNode subNode in curXmlParent.ChildNodes)
{
T item = ScribeExtractor.ValueFromNode <T>(subNode, default(T));
list.Add(item);
}
}
else if (lookMode == LookMode.Deep)
{
list = new List <T>(curXmlParent.ChildNodes.Count);
foreach (XmlNode subNode2 in curXmlParent.ChildNodes)
{
T item2 = ScribeExtractor.SaveableFromNode <T>(subNode2, ctorArgs);
list.Add(item2);
}
}
else if (lookMode == LookMode.Def)
{
list = new List <T>(curXmlParent.ChildNodes.Count);
foreach (XmlNode subNode3 in curXmlParent.ChildNodes)
{
T item3 = ScribeExtractor.DefFromNodeUnsafe <T>(subNode3);
list.Add(item3);
}
}
else if (lookMode == LookMode.BodyPart)
{
list = new List <T>(curXmlParent.ChildNodes.Count);
int num = 0;
foreach (XmlNode node in curXmlParent.ChildNodes)
{
T item4 = (T)((object)ScribeExtractor.BodyPartFromNode(node, num.ToString(), null));
list.Add(item4);
num++;
}
}
else if (lookMode == LookMode.LocalTargetInfo)
{
list = new List <T>(curXmlParent.ChildNodes.Count);
int num2 = 0;
foreach (XmlNode node2 in curXmlParent.ChildNodes)
{
LocalTargetInfo localTargetInfo2 = ScribeExtractor.LocalTargetInfoFromNode(node2, num2.ToString(), LocalTargetInfo.Invalid);
T item5 = (T)((object)localTargetInfo2);
list.Add(item5);
num2++;
}
}
else if (lookMode == LookMode.TargetInfo)
{
list = new List <T>(curXmlParent.ChildNodes.Count);
int num3 = 0;
foreach (XmlNode node3 in curXmlParent.ChildNodes)
{
TargetInfo targetInfo2 = ScribeExtractor.TargetInfoFromNode(node3, num3.ToString(), TargetInfo.Invalid);
T item6 = (T)((object)targetInfo2);
list.Add(item6);
num3++;
}
}
else if (lookMode == LookMode.GlobalTargetInfo)
{
list = new List <T>(curXmlParent.ChildNodes.Count);
int num4 = 0;
foreach (XmlNode node4 in curXmlParent.ChildNodes)
{
GlobalTargetInfo globalTargetInfo2 = ScribeExtractor.GlobalTargetInfoFromNode(node4, num4.ToString(), GlobalTargetInfo.Invalid);
T item7 = (T)((object)globalTargetInfo2);
list.Add(item7);
num4++;
}
}
else if (lookMode == LookMode.Reference)
{
List <string> list2 = new List <string>(curXmlParent.ChildNodes.Count);
foreach (XmlNode xmlNode in curXmlParent.ChildNodes)
{
list2.Add(xmlNode.InnerText);
}
Scribe.loader.crossRefs.loadIDs.RegisterLoadIDListReadFromXml(list2, string.Empty);
}
}
else if (Scribe.mode == LoadSaveMode.ResolvingCrossRefs)
{
if (lookMode == LookMode.Reference)
{
list = Scribe.loader.crossRefs.TakeResolvedRefList <T>(string.Empty);
}
else if (lookMode == LookMode.LocalTargetInfo)
{
if (list != null)
{
for (int i = 0; i < list.Count; i++)
{
list[i] = (T)((object)ScribeExtractor.ResolveLocalTargetInfo((LocalTargetInfo)((object)list[i]), i.ToString()));
}
}
}
else if (lookMode == LookMode.TargetInfo)
{
if (list != null)
{
for (int j = 0; j < list.Count; j++)
{
list[j] = (T)((object)ScribeExtractor.ResolveTargetInfo((TargetInfo)((object)list[j]), j.ToString()));
}
}
}
else if (lookMode == LookMode.GlobalTargetInfo && list != null)
{
for (int k = 0; k < list.Count; k++)
{
list[k] = (T)((object)ScribeExtractor.ResolveGlobalTargetInfo((GlobalTargetInfo)((object)list[k]), k.ToString()));
}
}
}
}
finally
{
Scribe.ExitNode();
}
}
else if (Scribe.mode == LoadSaveMode.LoadingVars)
{
if (lookMode == LookMode.Reference)
{
Scribe.loader.crossRefs.loadIDs.RegisterLoadIDListReadFromXml(null, label);
}
list = null;
}
}
public virtual void ExposeData()
{
Scribe_Values.Look(ref ID, "ID", -1);
Scribe_Deep.Look(ref innerGrid, "innerGrid");
}
public static void Look <T>(ref List <T> list, bool saveDestroyedThings, string label, LookMode lookMode = LookMode.Undefined, params object[] ctorArgs)
{
if (lookMode == LookMode.Undefined && !Scribe_Universal.TryResolveLookMode(typeof(T), out lookMode))
{
Log.Error("LookList call with a list of " + typeof(T) + " must have lookMode set explicitly.");
}
else if (Scribe.EnterNode(label))
{
try
{
if (Scribe.mode == LoadSaveMode.Saving)
{
if (list == null)
{
Scribe.saver.WriteAttribute("IsNull", "True");
}
else
{
foreach (T item8 in list)
{
switch (lookMode)
{
case LookMode.Value:
{
T value5 = item8;
Scribe_Values.Look(ref value5, "li", default(T), forceSave: true);
break;
}
case LookMode.LocalTargetInfo:
{
LocalTargetInfo value4 = (LocalTargetInfo)(object)item8;
Scribe_TargetInfo.Look(ref value4, saveDestroyedThings, "li");
break;
}
case LookMode.TargetInfo:
{
TargetInfo value3 = (TargetInfo)(object)item8;
Scribe_TargetInfo.Look(ref value3, saveDestroyedThings, "li");
break;
}
case LookMode.GlobalTargetInfo:
{
GlobalTargetInfo value2 = (GlobalTargetInfo)(object)item8;
Scribe_TargetInfo.Look(ref value2, saveDestroyedThings, "li");
break;
}
case LookMode.Def:
{
Def value = (Def)(object)item8;
Scribe_Defs.Look(ref value, "li");
break;
}
case LookMode.BodyPart:
{
BodyPartRecord part = (BodyPartRecord)(object)item8;
Scribe_BodyParts.Look(ref part, "li");
break;
}
case LookMode.Deep:
{
T target = item8;
Scribe_Deep.Look(ref target, saveDestroyedThings, "li", ctorArgs);
break;
}
case LookMode.Reference:
{
ILoadReferenceable refee = (ILoadReferenceable)(object)item8;
Scribe_References.Look(ref refee, "li", saveDestroyedThings);
break;
}
}
}
}
}
else if (Scribe.mode == LoadSaveMode.LoadingVars)
{
XmlNode curXmlParent = Scribe.loader.curXmlParent;
XmlAttribute xmlAttribute = curXmlParent.Attributes["IsNull"];
if (xmlAttribute != null && xmlAttribute.Value.ToLower() == "true")
{
if (lookMode == LookMode.Reference)
{
Scribe.loader.crossRefs.loadIDs.RegisterLoadIDListReadFromXml(null, null);
}
list = null;
}
else
{
switch (lookMode)
{
case LookMode.Value:
list = new List <T>(curXmlParent.ChildNodes.Count);
foreach (XmlNode childNode in curXmlParent.ChildNodes)
{
T item = ScribeExtractor.ValueFromNode(childNode, default(T));
list.Add(item);
}
break;
case LookMode.Deep:
list = new List <T>(curXmlParent.ChildNodes.Count);
foreach (XmlNode childNode2 in curXmlParent.ChildNodes)
{
T item7 = ScribeExtractor.SaveableFromNode <T>(childNode2, ctorArgs);
list.Add(item7);
}
break;
case LookMode.Def:
list = new List <T>(curXmlParent.ChildNodes.Count);
foreach (XmlNode childNode3 in curXmlParent.ChildNodes)
{
T item6 = ScribeExtractor.DefFromNodeUnsafe <T>(childNode3);
list.Add(item6);
}
break;
case LookMode.BodyPart:
{
list = new List <T>(curXmlParent.ChildNodes.Count);
int num4 = 0;
foreach (XmlNode childNode4 in curXmlParent.ChildNodes)
{
T item5 = (T)(object)ScribeExtractor.BodyPartFromNode(childNode4, num4.ToString(), null);
list.Add(item5);
num4++;
}
break;
}
case LookMode.LocalTargetInfo:
{
list = new List <T>(curXmlParent.ChildNodes.Count);
int num3 = 0;
foreach (XmlNode childNode5 in curXmlParent.ChildNodes)
{
T item4 = (T)(object)ScribeExtractor.LocalTargetInfoFromNode(childNode5, num3.ToString(), LocalTargetInfo.Invalid);
list.Add(item4);
num3++;
}
break;
}
case LookMode.TargetInfo:
{
list = new List <T>(curXmlParent.ChildNodes.Count);
int num2 = 0;
foreach (XmlNode childNode6 in curXmlParent.ChildNodes)
{
T item3 = (T)(object)ScribeExtractor.TargetInfoFromNode(childNode6, num2.ToString(), TargetInfo.Invalid);
list.Add(item3);
num2++;
}
break;
}
case LookMode.GlobalTargetInfo:
{
list = new List <T>(curXmlParent.ChildNodes.Count);
int num = 0;
foreach (XmlNode childNode7 in curXmlParent.ChildNodes)
{
T item2 = (T)(object)ScribeExtractor.GlobalTargetInfoFromNode(childNode7, num.ToString(), GlobalTargetInfo.Invalid);
list.Add(item2);
num++;
}
break;
}
case LookMode.Reference:
{
List <string> list2 = new List <string>(curXmlParent.ChildNodes.Count);
foreach (XmlNode childNode8 in curXmlParent.ChildNodes)
{
list2.Add(childNode8.InnerText);
}
Scribe.loader.crossRefs.loadIDs.RegisterLoadIDListReadFromXml(list2, "");
break;
}
}
}
}
else if (Scribe.mode == LoadSaveMode.ResolvingCrossRefs)
{
switch (lookMode)
{
case LookMode.Reference:
list = Scribe.loader.crossRefs.TakeResolvedRefList <T>("");
break;
case LookMode.LocalTargetInfo:
if (list != null)
{
for (int j = 0; j < list.Count; j++)
{
list[j] = (T)(object)ScribeExtractor.ResolveLocalTargetInfo((LocalTargetInfo)(object)list[j], j.ToString());
}
}
break;
case LookMode.TargetInfo:
if (list != null)
{
for (int k = 0; k < list.Count; k++)
{
list[k] = (T)(object)ScribeExtractor.ResolveTargetInfo((TargetInfo)(object)list[k], k.ToString());
}
}
break;
case LookMode.GlobalTargetInfo:
if (list != null)
{
for (int i = 0; i < list.Count; i++)
{
list[i] = (T)(object)ScribeExtractor.ResolveGlobalTargetInfo((GlobalTargetInfo)(object)list[i], i.ToString());
}
}
break;
}
}
}
finally
{
Scribe.ExitNode();
}
}
else if (Scribe.mode == LoadSaveMode.LoadingVars)
{
if (lookMode == LookMode.Reference)
{
Scribe.loader.crossRefs.loadIDs.RegisterLoadIDListReadFromXml(null, label);
}
list = null;
}
}
public override void PostExposeData(object obj)
{
if (Scribe.mode == LoadSaveMode.PostLoadInit)
{
Map map = obj as Map;
if (map != null)
{
if (map.retainedCaravanData == null)
{
map.retainedCaravanData = new RetainedCaravanData(map);
}
if (map.wildAnimalSpawner == null)
{
map.wildAnimalSpawner = new WildAnimalSpawner(map);
}
if (map.wildPlantSpawner == null)
{
map.wildPlantSpawner = new WildPlantSpawner(map);
}
}
Thing thing = obj as Thing;
if (thing != null && thing.def.useHitPoints && thing.MaxHitPoints != thing.HitPoints && Mathf.Abs((float)thing.HitPoints / (float)thing.MaxHitPoints - 0.617f) < 0.02f && thing.Stuff == ThingDefOf.WoodLog)
{
thing.HitPoints = thing.MaxHitPoints;
}
Pawn pawn = obj as Pawn;
if (pawn != null && !pawn.Destroyed && !pawn.Dead && pawn.needs == null)
{
Log.Error(pawn.ToStringSafe() + " has null needs tracker even though he's not dead. Fixing...");
pawn.needs = new Pawn_NeedsTracker(pawn);
pawn.needs.SetInitialLevels();
}
History history = obj as History;
if (history != null && history.archive == null)
{
history.archive = new Archive();
}
WorldInfo worldInfo = obj as WorldInfo;
if (worldInfo != null && worldInfo.persistentRandomValue == 0)
{
worldInfo.persistentRandomValue = Rand.Int;
}
Caravan caravan = obj as Caravan;
if (caravan != null)
{
if (caravan.forage == null)
{
caravan.forage = new Caravan_ForageTracker(caravan);
}
if (caravan.needs == null)
{
caravan.needs = new Caravan_NeedsTracker(caravan);
}
if (caravan.carryTracker == null)
{
caravan.carryTracker = new Caravan_CarryTracker(caravan);
}
if (caravan.beds == null)
{
caravan.beds = new Caravan_BedsTracker(caravan);
}
}
PlaySettings playSettings = obj as PlaySettings;
if (playSettings != null)
{
playSettings.defaultCareForColonyHumanlike = MedicalCareCategory.Best;
playSettings.defaultCareForColonyAnimal = MedicalCareCategory.HerbalOrWorse;
playSettings.defaultCareForColonyPrisoner = MedicalCareCategory.HerbalOrWorse;
playSettings.defaultCareForNeutralFaction = MedicalCareCategory.HerbalOrWorse;
playSettings.defaultCareForNeutralAnimal = MedicalCareCategory.HerbalOrWorse;
playSettings.defaultCareForHostileFaction = MedicalCareCategory.HerbalOrWorse;
}
}
if (Scribe.mode == LoadSaveMode.LoadingVars)
{
Hediff hediff = obj as Hediff;
if (hediff != null)
{
Scribe_Values.Look(ref hediff.temp_partIndexToSetLater, "partIndex", -1);
}
Bill_Medical bill_Medical = obj as Bill_Medical;
if (bill_Medical != null)
{
Scribe_Values.Look(ref bill_Medical.temp_partIndexToSetLater, "partIndex", -1);
}
FactionRelation factionRelation = obj as FactionRelation;
if (factionRelation != null)
{
bool value = false;
Scribe_Values.Look(ref value, "hostile", defaultValue: false);
if (value || factionRelation.goodwill <= -75)
{
factionRelation.kind = FactionRelationKind.Hostile;
}
else if (factionRelation.goodwill >= 75)
{
factionRelation.kind = FactionRelationKind.Ally;
}
}
HediffComp_GetsPermanent hediffComp_GetsPermanent = obj as HediffComp_GetsPermanent;
if (hediffComp_GetsPermanent != null)
{
bool value2 = false;
Scribe_Values.Look(ref value2, "isOld", defaultValue: false);
if (value2)
{
hediffComp_GetsPermanent.isPermanentInt = true;
}
}
if (obj is World)
{
UniqueIDsManager target = null;
Scribe_Deep.Look(ref target, "uniqueIDsManager");
if (target != null)
{
Current.Game.uniqueIDsManager = target;
}
}
WorldFeature worldFeature = obj as WorldFeature;
if (worldFeature != null && worldFeature.maxDrawSizeInTiles == 0f)
{
Vector2 value3 = Vector2.zero;
Scribe_Values.Look(ref value3, "maxDrawSizeInTiles");
worldFeature.maxDrawSizeInTiles = value3.x;
}
}
if (Scribe.mode != LoadSaveMode.ResolvingCrossRefs)
{
return;
}
Hediff hediff2 = obj as Hediff;
if (hediff2 != null && hediff2.temp_partIndexToSetLater >= 0 && hediff2.pawn != null)
{
if (hediff2.temp_partIndexToSetLater == 0)
{
hediff2.Part = hediff2.pawn.RaceProps.body.GetPartAtIndex(hediff2.temp_partIndexToSetLater);
}
else
{
hediff2.pawn.health.hediffSet.hediffs.Remove(hediff2);
}
hediff2.temp_partIndexToSetLater = -1;
}
Bill_Medical bill_Medical2 = obj as Bill_Medical;
if (bill_Medical2 != null)
{
if (bill_Medical2.temp_partIndexToSetLater == 0)
{
bill_Medical2.Part = bill_Medical2.GiverPawn.RaceProps.body.GetPartAtIndex(bill_Medical2.temp_partIndexToSetLater);
}
else
{
bill_Medical2.GiverPawn.BillStack.Bills.Remove(bill_Medical2);
}
bill_Medical2.temp_partIndexToSetLater = -1;
}
}
public static void Look <T>(ref List <T> list, bool saveDestroyedThings, string label, LookMode lookMode = LookMode.Undefined, params object[] ctorArgs)
{
if (lookMode == LookMode.Undefined)
{
if (ParseHelper.HandlesType(typeof(T)))
{
lookMode = LookMode.Value;
}
else if (typeof(T) == typeof(LocalTargetInfo))
{
lookMode = LookMode.LocalTargetInfo;
}
else if (typeof(T) == typeof(TargetInfo))
{
lookMode = LookMode.TargetInfo;
}
else if (typeof(T) == typeof(GlobalTargetInfo))
{
lookMode = LookMode.GlobalTargetInfo;
}
else if (typeof(Def).IsAssignableFrom(typeof(T)))
{
lookMode = LookMode.Def;
}
else if (typeof(T) == typeof(BodyPartRecord))
{
lookMode = LookMode.BodyPart;
}
else
{
if (!typeof(IExposable).IsAssignableFrom(typeof(T)) || typeof(ILoadReferenceable).IsAssignableFrom(typeof(T)))
{
Log.Error("LookList call with a list of " + typeof(T) + " must have lookMode set explicitly.");
return;
}
lookMode = LookMode.Deep;
}
}
if (Scribe.EnterNode(label))
{
try
{
if (Scribe.mode == LoadSaveMode.Saving)
{
if (list == null)
{
Scribe.saver.WriteAttribute("IsNull", "True");
}
else
{
foreach (T item8 in list)
{
switch (lookMode)
{
case LookMode.Value:
{
T value5 = item8;
Scribe_Values.Look(ref value5, "li", default(T), forceSave: true);
break;
}
case LookMode.LocalTargetInfo:
{
LocalTargetInfo value4 = (LocalTargetInfo)(object)item8;
Scribe_TargetInfo.Look(ref value4, saveDestroyedThings, "li");
break;
}
case LookMode.TargetInfo:
{
TargetInfo value3 = (TargetInfo)(object)item8;
Scribe_TargetInfo.Look(ref value3, saveDestroyedThings, "li");
break;
}
case LookMode.GlobalTargetInfo:
{
GlobalTargetInfo value2 = (GlobalTargetInfo)(object)item8;
Scribe_TargetInfo.Look(ref value2, saveDestroyedThings, "li");
break;
}
case LookMode.Def:
{
Def value = (Def)(object)item8;
Scribe_Defs.Look(ref value, "li");
break;
}
case LookMode.BodyPart:
{
BodyPartRecord part = (BodyPartRecord)(object)item8;
Scribe_BodyParts.Look(ref part, "li");
break;
}
case LookMode.Deep:
{
T target = item8;
Scribe_Deep.Look(ref target, saveDestroyedThings, "li", ctorArgs);
break;
}
case LookMode.Reference:
{
ILoadReferenceable refee = (ILoadReferenceable)(object)item8;
Scribe_References.Look(ref refee, "li", saveDestroyedThings);
break;
}
}
}
}
}
else if (Scribe.mode == LoadSaveMode.LoadingVars)
{
XmlNode curXmlParent = Scribe.loader.curXmlParent;
XmlAttribute xmlAttribute = curXmlParent.Attributes["IsNull"];
if (xmlAttribute == null || !(xmlAttribute.Value.ToLower() == "true"))
{
switch (lookMode)
{
case LookMode.Value:
{
list = new List <T>(curXmlParent.ChildNodes.Count);
IEnumerator enumerator3 = curXmlParent.ChildNodes.GetEnumerator();
try
{
while (enumerator3.MoveNext())
{
XmlNode subNode = (XmlNode)enumerator3.Current;
T item = ScribeExtractor.ValueFromNode(subNode, default(T));
list.Add(item);
}
}
finally
{
IDisposable disposable2;
if ((disposable2 = (enumerator3 as IDisposable)) != null)
{
disposable2.Dispose();
}
}
break;
}
case LookMode.Deep:
{
list = new List <T>(curXmlParent.ChildNodes.Count);
IEnumerator enumerator9 = curXmlParent.ChildNodes.GetEnumerator();
try
{
while (enumerator9.MoveNext())
{
XmlNode subNode3 = (XmlNode)enumerator9.Current;
T item7 = ScribeExtractor.SaveableFromNode <T>(subNode3, ctorArgs);
list.Add(item7);
}
}
finally
{
IDisposable disposable8;
if ((disposable8 = (enumerator9 as IDisposable)) != null)
{
disposable8.Dispose();
}
}
break;
}
case LookMode.Def:
{
list = new List <T>(curXmlParent.ChildNodes.Count);
IEnumerator enumerator8 = curXmlParent.ChildNodes.GetEnumerator();
try
{
while (enumerator8.MoveNext())
{
XmlNode subNode2 = (XmlNode)enumerator8.Current;
T item6 = ScribeExtractor.DefFromNodeUnsafe <T>(subNode2);
list.Add(item6);
}
}
finally
{
IDisposable disposable7;
if ((disposable7 = (enumerator8 as IDisposable)) != null)
{
disposable7.Dispose();
}
}
break;
}
case LookMode.BodyPart:
{
list = new List <T>(curXmlParent.ChildNodes.Count);
int num4 = 0;
IEnumerator enumerator7 = curXmlParent.ChildNodes.GetEnumerator();
try
{
while (enumerator7.MoveNext())
{
XmlNode node4 = (XmlNode)enumerator7.Current;
T item5 = (T)(object)ScribeExtractor.BodyPartFromNode(node4, num4.ToString(), null);
list.Add(item5);
num4++;
}
}
finally
{
IDisposable disposable6;
if ((disposable6 = (enumerator7 as IDisposable)) != null)
{
disposable6.Dispose();
}
}
break;
}
case LookMode.LocalTargetInfo:
{
list = new List <T>(curXmlParent.ChildNodes.Count);
int num3 = 0;
IEnumerator enumerator6 = curXmlParent.ChildNodes.GetEnumerator();
try
{
while (enumerator6.MoveNext())
{
XmlNode node3 = (XmlNode)enumerator6.Current;
LocalTargetInfo localTargetInfo = ScribeExtractor.LocalTargetInfoFromNode(node3, num3.ToString(), LocalTargetInfo.Invalid);
T item4 = (T)(object)localTargetInfo;
list.Add(item4);
num3++;
}
}
finally
{
IDisposable disposable5;
if ((disposable5 = (enumerator6 as IDisposable)) != null)
{
disposable5.Dispose();
}
}
break;
}
case LookMode.TargetInfo:
{
list = new List <T>(curXmlParent.ChildNodes.Count);
int num2 = 0;
IEnumerator enumerator5 = curXmlParent.ChildNodes.GetEnumerator();
try
{
while (enumerator5.MoveNext())
{
XmlNode node2 = (XmlNode)enumerator5.Current;
TargetInfo targetInfo = ScribeExtractor.TargetInfoFromNode(node2, num2.ToString(), TargetInfo.Invalid);
T item3 = (T)(object)targetInfo;
list.Add(item3);
num2++;
}
}
finally
{
IDisposable disposable4;
if ((disposable4 = (enumerator5 as IDisposable)) != null)
{
disposable4.Dispose();
}
}
break;
}
case LookMode.GlobalTargetInfo:
{
list = new List <T>(curXmlParent.ChildNodes.Count);
int num = 0;
IEnumerator enumerator4 = curXmlParent.ChildNodes.GetEnumerator();
try
{
while (enumerator4.MoveNext())
{
XmlNode node = (XmlNode)enumerator4.Current;
GlobalTargetInfo globalTargetInfo = ScribeExtractor.GlobalTargetInfoFromNode(node, num.ToString(), GlobalTargetInfo.Invalid);
T item2 = (T)(object)globalTargetInfo;
list.Add(item2);
num++;
}
}
finally
{
IDisposable disposable3;
if ((disposable3 = (enumerator4 as IDisposable)) != null)
{
disposable3.Dispose();
}
}
break;
}
case LookMode.Reference:
{
List <string> list2 = new List <string>(curXmlParent.ChildNodes.Count);
IEnumerator enumerator2 = curXmlParent.ChildNodes.GetEnumerator();
try
{
while (enumerator2.MoveNext())
{
XmlNode xmlNode = (XmlNode)enumerator2.Current;
list2.Add(xmlNode.InnerText);
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator2 as IDisposable)) != null)
{
disposable.Dispose();
}
}
Scribe.loader.crossRefs.loadIDs.RegisterLoadIDListReadFromXml(list2, string.Empty);
break;
}
}
}
else
{
list = null;
}
}
else if (Scribe.mode == LoadSaveMode.ResolvingCrossRefs)
{
switch (lookMode)
{
case LookMode.Reference:
list = Scribe.loader.crossRefs.TakeResolvedRefList <T>(string.Empty);
break;
case LookMode.LocalTargetInfo:
if (list != null)
{
for (int j = 0; j < list.Count; j++)
{
list[j] = (T)(object)ScribeExtractor.ResolveLocalTargetInfo((LocalTargetInfo)(object)list[j], j.ToString());
}
}
break;
case LookMode.TargetInfo:
if (list != null)
{
for (int k = 0; k < list.Count; k++)
{
list[k] = (T)(object)ScribeExtractor.ResolveTargetInfo((TargetInfo)(object)list[k], k.ToString());
}
}
break;
case LookMode.GlobalTargetInfo:
if (list != null)
{
for (int i = 0; i < list.Count; i++)
{
list[i] = (T)(object)ScribeExtractor.ResolveGlobalTargetInfo((GlobalTargetInfo)(object)list[i], i.ToString());
}
}
break;
}
}
}
finally
{
Scribe.ExitNode();
}
}
else if (Scribe.mode == LoadSaveMode.LoadingVars)
{
if (lookMode == LookMode.Reference)
{
Scribe.loader.crossRefs.loadIDs.RegisterLoadIDListReadFromXml(null, label);
}
list = null;
}
}
public static void WriteModSettings(string modIdentifier, string modHandleName, ModSettings settings)
{
Scribe.saver.InitSaving(LoadedModManager.GetSettingsFilename(modIdentifier, modHandleName), "SettingsBlock");
Scribe_Deep.Look <ModSettings>(ref settings, "ModSettings", new object[0]);
Scribe.saver.FinalizeSaving();
}
public void ExposeData()
{
Scribe_Collections.Look(ref itemsNotForSale, "itemsNotForSale", LookMode.Reference);
Scribe_Deep.Look(ref innerContainer, "innerContainer", this);
Scribe_Values.Look(ref unloadEverything, "unloadEverything", defaultValue: false);
}
public void ExposeData()
{
Scribe_Values.Look <int>(ref this.uniqueID, "uniqueID", -1, false);
Scribe_Deep.Look <MapInfo>(ref this.info, "mapInfo", new object[0]);
if (Scribe.mode == LoadSaveMode.Saving)
{
this.compressor = new MapFileCompressor(this);
this.compressor.BuildCompressedString();
this.ExposeComponents();
this.compressor.ExposeData();
HashSet <string> hashSet = new HashSet <string>();
if (Scribe.EnterNode("things"))
{
try
{
foreach (Thing thing in this.listerThings.AllThings)
{
try
{
if (thing.def.isSaveable && !thing.IsSaveCompressible())
{
if (hashSet.Contains(thing.ThingID))
{
Log.Error("Saving Thing with already-used ID " + thing.ThingID, false);
}
else
{
hashSet.Add(thing.ThingID);
}
Thing thing2 = thing;
Scribe_Deep.Look <Thing>(ref thing2, "thing", new object[0]);
}
}
catch (Exception ex)
{
Log.Error(string.Concat(new object[]
{
"Exception saving ",
thing,
": ",
ex
}), false);
}
}
}
finally
{
Scribe.ExitNode();
}
}
else
{
Log.Error("Could not enter the things node while saving.", false);
}
this.compressor = null;
}
else
{
if (Scribe.mode == LoadSaveMode.LoadingVars)
{
this.ConstructComponents();
this.regionAndRoomUpdater.Enabled = false;
this.compressor = new MapFileCompressor(this);
}
this.ExposeComponents();
DeepProfiler.Start("Load compressed things");
this.compressor.ExposeData();
DeepProfiler.End();
DeepProfiler.Start("Load non-compressed things");
Scribe_Collections.Look <Thing>(ref this.loadedFullThings, "things", LookMode.Deep, new object[0]);
DeepProfiler.End();
}
}
public virtual void ExposeData()
{
Scribe_Values.Look <int>(ref this.ID, "ID", -1, false);
Scribe_Deep.Look <BoolGrid>(ref this.innerGrid, "innerGrid", new object[0]);
}
private void ExposeComponents()
{
Scribe_Deep.Look <WeatherManager>(ref this.weatherManager, "weatherManager", new object[]
{
this
});
Scribe_Deep.Look <ReservationManager>(ref this.reservationManager, "reservationManager", new object[]
{
this
});
Scribe_Deep.Look <PhysicalInteractionReservationManager>(ref this.physicalInteractionReservationManager, "physicalInteractionReservationManager", new object[0]);
Scribe_Deep.Look <DesignationManager>(ref this.designationManager, "designationManager", new object[]
{
this
});
Scribe_Deep.Look <PawnDestinationReservationManager>(ref this.pawnDestinationReservationManager, "pawnDestinationReservationManager", new object[0]);
Scribe_Deep.Look <LordManager>(ref this.lordManager, "lordManager", new object[]
{
this
});
Scribe_Deep.Look <PassingShipManager>(ref this.passingShipManager, "visitorManager", new object[]
{
this
});
Scribe_Deep.Look <GameConditionManager>(ref this.gameConditionManager, "gameConditionManager", new object[]
{
this
});
Scribe_Deep.Look <FogGrid>(ref this.fogGrid, "fogGrid", new object[]
{
this
});
Scribe_Deep.Look <RoofGrid>(ref this.roofGrid, "roofGrid", new object[]
{
this
});
Scribe_Deep.Look <TerrainGrid>(ref this.terrainGrid, "terrainGrid", new object[]
{
this
});
Scribe_Deep.Look <ZoneManager>(ref this.zoneManager, "zoneManager", new object[]
{
this
});
Scribe_Deep.Look <TemperatureCache>(ref this.temperatureCache, "temperatureCache", new object[]
{
this
});
Scribe_Deep.Look <SnowGrid>(ref this.snowGrid, "snowGrid", new object[]
{
this
});
Scribe_Deep.Look <AreaManager>(ref this.areaManager, "areaManager", new object[]
{
this
});
Scribe_Deep.Look <VoluntarilyJoinableLordsStarter>(ref this.lordsStarter, "lordsStarter", new object[]
{
this
});
Scribe_Deep.Look <AttackTargetReservationManager>(ref this.attackTargetReservationManager, "attackTargetReservationManager", new object[]
{
this
});
Scribe_Deep.Look <DeepResourceGrid>(ref this.deepResourceGrid, "deepResourceGrid", new object[]
{
this
});
Scribe_Deep.Look <WeatherDecider>(ref this.weatherDecider, "weatherDecider", new object[]
{
this
});
Scribe_Deep.Look <DamageWatcher>(ref this.damageWatcher, "damageWatcher", new object[0]);
Scribe_Deep.Look <RememberedCameraPos>(ref this.rememberedCameraPos, "rememberedCameraPos", new object[]
{
this
});
Scribe_Deep.Look <MineStrikeManager>(ref this.mineStrikeManager, "mineStrikeManager", new object[0]);
Scribe_Deep.Look <RetainedCaravanData>(ref this.retainedCaravanData, "retainedCaravanData", new object[]
{
this
});
Scribe_Deep.Look <StoryState>(ref this.storyState, "storyState", new object[]
{
this
});
Scribe_Deep.Look <WildPlantSpawner>(ref this.wildPlantSpawner, "wildPlantSpawner", new object[]
{
this
});
Scribe_Collections.Look <MapComponent>(ref this.components, "components", LookMode.Deep, new object[]
{
this
});
this.FillComponents();
if (Scribe.mode == LoadSaveMode.PostLoadInit)
{
BackCompatibility.MapPostLoadInit(this);
}
}
internal void <> m__0()
{
ScribeMetaHeaderUtility.WriteMetaHeader();
Scribe_Deep.Look <Scenario>(ref this.scen, "scenario", new object[0]);
}
