public static void Look <T>(ref T value, string label, T defaultValue = default(T), bool forceSave = false)
{
if (Scribe.mode == LoadSaveMode.Saving)
{
if (typeof(T) == typeof(TargetInfo))
{
Log.Error("Saving a TargetInfo " + label + " with Scribe_Values. TargetInfos must be saved with Scribe_TargetInfo.");
}
else if (typeof(Thing).IsAssignableFrom(typeof(T)))
{
Log.Error("Using Scribe_Values with a Thing reference " + label + ". Use Scribe_References or Scribe_Deep instead.");
}
else if (typeof(IExposable).IsAssignableFrom(typeof(T)))
{
Log.Error("Using Scribe_Values with a IExposable reference " + label + ". Use Scribe_References or Scribe_Deep instead.");
}
else if (typeof(Def).IsAssignableFrom(typeof(T)))
{
Log.Error("Using Scribe_Values with a Def " + label + ". Use Scribe_Defs instead.");
}
else
{
if (!forceSave && (value != null || defaultValue == null))
{
if (value == null)
{
return;
}
if (value.Equals(defaultValue))
{
return;
}
}
Scribe.saver.WriteElement(label, value.ToString());
}
}
else if (Scribe.mode == LoadSaveMode.LoadingVars)
{
value = ScribeExtractor.ValueFromNode(Scribe.loader.curXmlParent[label], defaultValue);
}
}
public static void Postfix(StorageSettings __instance)
{
if (Scribe.mode == LoadSaveMode.Saving)
{
var limit = __instance.GetStacklimit();
if (limit >= 0)
{
Scribe.saver.WriteElement("stacklimit", limit.ToString());
}
var refillpercent = __instance.GetRefillPercent();
if (refillpercent < 100)
{
Scribe.saver.WriteElement("refillpercent", refillpercent.ToString());
}
}
else if (Scribe.mode == LoadSaveMode.LoadingVars)
{
__instance.SetStacklimit(ScribeExtractor.ValueFromNode(Scribe.loader.curXmlParent["stacklimit"], -1));
__instance.SetRefillPercent(ScribeExtractor.ValueFromNode(Scribe.loader.curXmlParent["refillpercent"], 100));
}
}
private Pawn MakePawnWithRawXml(string xml)
{
try {
XmlDocument document = new XmlDocument();
document.LoadXml(xml);
//Debug.Message("Pawn xml: {0}", xml);
XmlNode root = document.FirstChild;
string pawnKind = root.SelectSingleNode("kind").InnerText;
PawnKindDef kindDef = PawnKindDef.Named(pawnKind);
if (kindDef == null)
{
kindDef = PawnKindDefOf.AncientSoldier;
}
Pawn p = PawnGenerator.GeneratePawn(kindDef, rp.faction);
// ==== NAME AND AGE ====
Name name = null;
var nameNode = root.SelectSingleNode("name");
var attrFirst = nameNode.Attributes.GetNamedItem("first");
var attrLast = nameNode.Attributes.GetNamedItem("last");
var attrNick = nameNode.Attributes.GetNamedItem("nick");
if (attrFirst != null && attrLast != null)
{
name = new NameTriple(attrFirst.Value, attrNick?.Value ?? "", attrLast.Value);
}
else
{
name = new NameSingle(attrFirst?.Value ?? "Unknown");
}
p.Name = name;
//Debug.Message("got name");
string gender = root.SelectSingleNode("gender")?.InnerText;
if (gender == "Male")
{
p.gender = Gender.Male;
}
else if (gender == "Female")
{
p.gender = Gender.Female;
}
string bioAgeString = root.SelectSingleNode("biologicalAge")?.InnerText;
string chronoAgeString = root.SelectSingleNode("chronologicalAge")?.InnerText;
if (bioAgeString != null && chronoAgeString != null)
{
long result = 0;
Int64.TryParse(bioAgeString, out result);
p.ageTracker.AgeBiologicalTicks = result;
Int64.TryParse(chronoAgeString, out result);
p.ageTracker.AgeChronologicalTicks = result + 3600000 * (-blueprint.dateShift); //+dateShift for dates, -dateShift for ages
}
//Debug.Message("got age");
// ==== STORY AND APPEARANCE ====
var storyNode = root.SelectSingleNode("saveable[@Class='Pawn_StoryTracker']");
if (storyNode != null)
{
Backstory bs = null;
string childhoodDef = storyNode.SelectSingleNode("childhood")?.InnerText;
if (BackstoryDatabase.TryGetWithIdentifier(childhoodDef, out bs))
{
p.story.childhood = bs;
}
string adulthoodDef = storyNode.SelectSingleNode("adulthood")?.InnerText;
if (BackstoryDatabase.TryGetWithIdentifier(adulthoodDef, out bs))
{
p.story.adulthood = bs;
}
string bodyTypeDefName = storyNode.SelectSingleNode("bodyType")?.InnerText;
if (bodyTypeDefName != null)
{
BodyTypeDef def = DefDatabase <BodyTypeDef> .GetNamedSilentFail(bodyTypeDefName);
if (def != null)
{
p.story.bodyType = def;
}
try {
string crownTypeName = storyNode.SelectSingleNode("crownType")?.InnerText;
p.story.crownType = (CrownType)Enum.Parse(typeof(CrownType), crownTypeName);
} catch (Exception) { }
string hairDefName = storyNode.SelectSingleNode("hairDef")?.InnerText;
HairDef hairDef = DefDatabase <HairDef> .GetNamedSilentFail(hairDefName);
if (hairDef != null)
{
p.story.hairDef = hairDef;
}
float melanin = 0;
if (float.TryParse(storyNode.SelectSingleNode("melanin")?.InnerText, out melanin))
{
p.story.melanin = melanin;
}
string hairColorString = storyNode.SelectSingleNode("hairColor")?.InnerText;
Color hairColor = (Color)ParseHelper.FromString(hairColorString, typeof(Color));
if (hairColor != null)
{
p.story.hairColor = hairColor;
}
}
XmlNodeList traitsList = storyNode.SelectNodes("traits/allTraits/li");
if (traitsList != null)
{
p.story.traits.allTraits.RemoveAll(_ => true);
foreach (XmlNode traitNode in traitsList)
{
string traitDefName = traitNode.SelectSingleNode("def")?.InnerText;
int traitDegree = 0;
int.TryParse(traitNode.SelectSingleNode("degree")?.InnerText, out traitDegree);
TraitDef traitDef = DefDatabase <TraitDef> .GetNamedSilentFail(traitDefName);
if (traitDef == null)
{
continue;
}
Trait t = new Trait(traitDef, traitDegree);
if (t == null)
{
continue;
}
p.story.traits.allTraits.Add(t);
}
}
}
// ==== SKILLS ====
var skills = root.SelectSingleNode("saveable[@Class='Pawn_SkillTracker']");
if (skills != null)
{
XmlNodeList skillsList = storyNode.SelectNodes("skills/li");
foreach (XmlNode skillNode in skillsList)
{
string skillDefName = skillNode.SelectSingleNode("def")?.InnerText;
int level = 0;
int.TryParse(skillNode.SelectSingleNode("level")?.InnerText, out level);
float xp = 0;
float.TryParse(skillNode.SelectSingleNode("xpSinceLastLevel")?.InnerText, out xp);
SkillDef skillDef = DefDatabase <SkillDef> .GetNamedSilentFail(skillDefName);
if (skillDef == null)
{
continue;
}
SkillRecord skillRecord = p.skills.GetSkill(skillDef);
if (skillRecord == null)
{
skillRecord = new SkillRecord(p, skillDef);
}
skillRecord.Level = level;
skillRecord.xpSinceLastLevel = xp;
try {
string passionTypeName = skillNode.SelectSingleNode("passion")?.InnerText;
if (passionTypeName != null)
{
skillRecord.passion = (Passion)Enum.Parse(typeof(Passion), passionTypeName);
}
} catch (Exception) { }
}
}
//Debug.Message("got traits and skills");
// ==== HEALTH ====
var healthNode = root.SelectSingleNode("saveable[@Class='Pawn_HealthTracker']");
if (healthNode != null)
{
XmlNode healthState = healthNode.SelectSingleNode("healthState");
if (healthState?.InnerText == "Dead")
{
p.health.SetDead();
}
XmlNodeList hediffsList = healthNode.SelectNodes("hediffSet/hediffs/li");
if (hediffsList != null)
{
Scribe.mode = LoadSaveMode.LoadingVars;
p.health?.hediffSet?.hediffs?.RemoveAll(_ => true);
//probably should pre-analyze hediffs prior to instantiating
foreach (XmlNode hediffNode in hediffsList)
{
var sourceNode = hediffNode.SelectSingleNode("source");
var source = sourceNode?.InnerText;
//Debug.Message("Source is {0} in hediff {1}", source, hediffNode.OuterXml);
if (source != null)
{
ThingDef sourceThingDef = DefDatabase <ThingDef> .GetNamedSilentFail(source);
//Debug.Message("Found non-null source node: {0}. Def: {1}", sourceNode.OuterXml, sourceThingDef);
if (sourceThingDef == null)
{
hediffNode.RemoveChild(sourceNode);
//Debug.Message("def not found, removing node, result: {0}", hediffNode.OuterXml);
//continue; //skip hediffs with unknown source
//} else {
//Debug.Message("def found: {0}", sourceThingDef);
}
}
try {
Hediff hediff = ScribeExtractor.SaveableFromNode <Hediff>(hediffNode, null);
if (hediff != null)
{
if (hediff.source != null && hediff.Part != null)
{
p.health.AddHediff(hediff);
}
}
} catch (Exception) {
}
}
Scribe.mode = LoadSaveMode.Inactive;
}
}
//Debug.Message("got health");
// ==== APPAREL ====
var apparelNode = root.SelectSingleNode("apparel");
if (apparelNode != null)
{
XmlNodeList apparelList = apparelNode.SelectNodes("item");
foreach (XmlNode item in apparelList)
{
string defName = item.Attributes?.GetNamedItem("def")?.Value;
string stuffDefName = item.Attributes?.GetNamedItem("stuffDef")?.Value;
ThingDef stuffDef = null;
ThingDef thingDef = DefDatabase <ThingDef> .GetNamedSilentFail(defName);
if (stuffDefName != null)
{
stuffDef = DefDatabase <ThingDef> .GetNamedSilentFail(stuffDefName);
}
if (thingDef != null)
{
Apparel apparel = (Apparel)ThingMaker.MakeThing(thingDef, stuffDef);
apparel.HitPoints = Rand.Range(1, (int)(apparel.MaxHitPoints * 0.6));
if (apparel is Apparel)
{
p.apparel.Wear(apparel, false);
}
}
}
}
return(p);
} catch (Exception e) {
return(PawnGenerator.GeneratePawn(PawnKindDefOf.AncientSoldier, rp.faction));
}
}
public static void Look <T>(ref ThreadSafeLinkedList <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(string.Concat("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");
return;
}
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;
return;
}
switch (lookMode)
{
case LookMode.Value:
list = new ThreadSafeLinkedList <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 ThreadSafeLinkedList <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 ThreadSafeLinkedList <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 ThreadSafeLinkedList <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 ThreadSafeLinkedList <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 ThreadSafeLinkedList <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 ThreadSafeLinkedList <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)
{
return;
}
switch (lookMode)
{
case LookMode.Reference:
list = TakeResolvedRefList <T>(Scribe.loader.crossRefs, "");
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;
}
return;
}
}
finally
{
Scribe.ExitNode();
}
}
else if (Scribe.mode == LoadSaveMode.LoadingVars)
{
if (lookMode == LookMode.Reference)
{
Scribe.loader.crossRefs.loadIDs.RegisterLoadIDListReadFromXml(null, label);
}
list = null;
}
}
