protected override void Perform(BooterHelper.BootFile file, XmlDbRow row)
{
TagStaticData data = new TagStaticData();
string name = row.GetString("TypeName");
string icon = row.GetString("Icon");
string color = row.GetString("ColorHEX");
bool business = row.GetBool("isBusinessType");
try
{
data.SetGUID(name);
}
catch (ArgumentException e)
{
Common.Exception("", e);
}
if (!data.Valid)
{
return;
}
data.name = name;
data.icon = icon;
data.isBusinessType = business;
data.SetColorHex(color);
if (!Tagger.staticData.ContainsKey(data.GUID))
{
Tagger.staticData.Add(data.GUID, data);
EnumInjection.InjectEnums<CommercialLotSubType>(new string[] { name }, new object[] { data.GUID }, false);
}
}
public override bool Parse(XmlDbRow row, ref string error)
{
mName = new WeightOption.NameOption(row);
mInjuredStory = row.GetString("InjuredStory");
if (!ParserFunctions.TryParseEnum<SimDescription.DeathType>(row.GetString("Type"), out mType, SimDescription.DeathType.None))
{
error = "Type not valid";
return false;
}
if (mType == SimDescription.DeathType.None)
{
error = "Type cannot be None";
return false;
}
mSuccess = new WeightScenarioHelper(Origin.FromWatchingSimSuffer);
if (!mSuccess.Parse(row, Manager, this, "Success", ref error))
{
return false;
}
return base.Parse(row, ref error);
}
public ScoringStage(XmlDbRow row)
: base(row)
{
if (BooterLogger.Exists(row, "Scoring", Name))
{
mScoring = row.GetString("Scoring");
if (string.IsNullOrEmpty(mScoring))
{
BooterLogger.AddError(Name + " Empty Scoring");
}
else if (ScoringLookup.GetScoring(mScoring) == null)
{
BooterLogger.AddError(Name + " Invalid Scoring: " + mScoring);
}
}
if (row.GetString("Minimum") == "Strength")
{
mMinimum = int.MinValue;
}
else
{
mMinimum = row.GetInt("Minimum", int.MinValue);
}
mMinMutation = row.GetString("MinMutation");
}
protected override void Perform(BooterHelper.BootFile file, XmlDbRow row)
{
WeatherProfile profile = GetProfile(row);
if (profile == null) return;
profile.ParseTemperature(row);
}
protected override void Perform(BooterHelper.BootFile file, XmlDbRow row)
{
BooterHelper.DataBootFile dataFile = file as BooterHelper.DataBootFile;
if (dataFile == null) return;
ParseSkillData(dataFile.Data, row, true);
}
protected override void Perform(BooterHelper.BootFile file, XmlDbRow row)
{
BooterHelper.DataBootFile careerFile = new BooterHelper.DataBootFile(file.ToString(), row.GetString("Careers"), false);
if (!careerFile.IsValid)
{
BooterLogger.AddError(file.ToString() + ": Unknown Careers File " + row.GetString("Careers"));
return;
}
BooterHelper.DataBootFile careerEventsFile = new BooterHelper.DataBootFile(careerFile.ToString(), row.GetString("CareerEvents"), false);
if (careerEventsFile.IsValid)
{
foreach (Career career in CareerManager.CareerList)
{
XmlDbTable table3 = careerEventsFile.GetTable(career.Guid.ToString ());
if (table3 != null)
{
LoadCareerEvents(career, careerEventsFile, table3);
}
}
}
BooterHelper.DataBootTable table = new BooterHelper.DataBootTable(careerFile, "CareerList");
if (!table.IsValid)
{
BooterLogger.AddError(file.ToString() + ": No CareerList " + careerFile.ToString());
return;
}
table.Load(new CareerLoader(careerEventsFile).LoadCareer);
}
public override void Parse(XmlDbRow row)
{
base.Parse(row);
mMinIntensityDuration = row.GetFloat("MinIntensityDuration", 0);
mTransitionTime.First = row.GetFloat("MinTransitionTime", 0);
mTransitionTime.Second = row.GetFloat("MaxTransitionTime", 0);
mIntensityWeights = new List<int>();
mIntensityWeights.Add(row.GetInt("LightWeight", 0));
mIntensityWeights.Add(row.GetInt("ModerateWeight", 0));
mIntensityWeights.Add(row.GetInt("HeavyWeight", 0));
mIntensityChangeWeights = new List<int>();
foreach (string strValue in row.GetStringList("NumIntensityChangeWeights", ','))
{
float value;
if (float.TryParse(strValue, out value))
{
mIntensityChangeWeights.Add((int)value);
}
else
{
mIntensityChangeWeights.Add(0);
}
}
}
public override bool Parse(XmlDbRow row, string prefix, bool firstPass, ref string error)
{
mDelta = row.GetInt(prefix + "PropagateDelta", mDelta);
if (row.Exists(prefix + "PropagateFriend"))
{
if (!ParserFunctions.TryParseEnum<WhichSim>(row.GetString(prefix + "PropagateFriend"), out mFriendSim, WhichSim.Actor))
{
error = prefix + "PropagateFriend unknown";
return false;
}
}
SimScenarioFilter.RelationshipLevel relationLevel;
if (ParserFunctions.TryParseEnum<SimScenarioFilter.RelationshipLevel>(row.GetString(prefix + "PropagateRelationshipGate"), out relationLevel, SimScenarioFilter.RelationshipLevel.Neutral))
{
mRelationshipGate = (int)relationLevel;
}
else
{
mRelationshipGate = row.GetInt(prefix + "PropagateRelationshipGate", mRelationshipGate);
}
return base.Parse(row, prefix, firstPass, ref error);
}
public MoodletSymptom(XmlDbRow row)
: base(row)
{
if (BooterLogger.Exists(row, "BuffName", Guid))
{
if (!row.TryGetEnum<BuffNames>("BuffName", out mBuff, BuffNames.Undefined))
{
mBuff = (BuffNames)row.GetUlong("BuffName", 0);
if (mBuff == 0)
{
mBuff = (BuffNames)ResourceUtils.HashString64(row.GetString("BuffName"));
}
if (!BuffManager.BuffDictionary.ContainsKey((ulong)mBuff))
{
BooterLogger.AddError(Guid + " Unknown BuffName: " + row.GetString("BuffName"));
}
}
}
mMoodValue = row.GetInt("MoodValue", 0);
mDuration = row.GetInt("Duration", 30);
if (mDuration <= 0)
{
mDuration = -1;
}
mOrigin = (Origin)row.GetUlong("Origin", 0);
if (mOrigin == Origin.None)
{
mOrigin = (Origin)ResourceUtils.HashString64(row.GetString("Origin"));
}
}
public OccultSymptom(XmlDbRow row)
: base(row)
{
if (BooterLogger.Exists(row, "Occult", Guid))
{
if (!row.TryGetEnum<OccultTypes>("Occult", out mOccult, OccultTypes.None))
{
BooterLogger.AddError(" Unknown Occult: " + row.GetString("Occult"));
}
}
if (BooterLogger.Exists(row, "Remove", Guid))
{
mRemove = row.GetBool("Remove");
}
if (BooterLogger.Exists(row, "DropOthers", Guid))
{
mDropOthers = row.GetBool("DropOthers");
}
if (BooterLogger.Exists(row, "AllowIfOthers", Guid))
{
mAllowIfOthers = row.GetBool("AllowIfOthers");
}
}
protected override void Perform(BooterHelper.BootFile file, XmlDbRow row)
{
string toneName = row.GetString("ToneName");
if (string.IsNullOrEmpty(toneName))
{
BooterLogger.AddError("Tone found with no name");
return;
}
Type classType = row.GetClassType("FullClassName");
if (classType == null)
{
BooterLogger.AddError("Tone: " + toneName + " FullClassName no match");
return;
}
string guid = row.GetString("CareerGuid");
OccupationNames careerGuid = OccupationNames.Undefined;
ParserFunctions.TryParseEnum<OccupationNames>(guid, out careerGuid, OccupationNames.Undefined);
if (careerGuid == OccupationNames.Undefined)
{
careerGuid = unchecked((OccupationNames)ResourceUtils.HashString64(guid));
}
Career staticCareer = CareerManager.GetStaticCareer (careerGuid);
if (staticCareer == null)
{
BooterLogger.AddError("Tone: " + toneName + " CareerGuid no match");
return;
}
staticCareer.SharedData.ToneDefinitions.Add(new CareerBooterToneDefinition(row, classType));
}
public bool Parse(XmlDbRow row, StoryProgressionObject manager, IUpdateManager updater, string prefix, ref string error)
{
if ((!string.IsNullOrEmpty(prefix)) && (!Parse(row, manager, updater, null, ref error)))
{
return false;
}
if (row.Exists(prefix + "RecruitAllowSteal"))
{
mAllowSteal = row.GetBool(prefix + "RecruitAllowSteal");
}
if (mActorRecruit == null)
{
mActorRecruit = new SimScenarioFilter();
}
if (!mActorRecruit.Parse(row, manager, updater, prefix + "RecruitActor", false, ref error))
{
return false;
}
if (mTargetRecruit == null)
{
mTargetRecruit = new SimScenarioFilter();
}
if (!mTargetRecruit.Parse(row, manager, updater, prefix + "RecruitTarget", false, ref error))
{
return false;
}
return true;
}
public TestSettingStage(XmlDbRow row)
: base(row)
{
if (BooterLogger.Exists(row, "Setting", Name))
{
mSetting = row.GetString("Setting");
}
}
public virtual void Parse(XmlDbRow row)
{
mWeight = row.GetInt("Weight", 0);
mLength.First = row.GetFloat("MinLength", 0);
mLength.Second = row.GetFloat("MaxLength", 0);
mTemp.First = row.GetFloat("MinTemp", 0);
mTemp.Second = row.GetFloat("MaxTemp", 0);
}
public SimpleStage(XmlDbRow row)
: base(row)
{
if (BooterLogger.Exists(row, "NextStage", Name))
{
mNextStage.First = row.GetString("NextStage");
}
}
public CounterStage(XmlDbRow row)
: base(row)
{
if (BooterLogger.Exists(row, "Counter", Name))
{
mCounter = row.GetString("Counter");
}
}
// Methods
public MetricSkillX(XmlDbRow row, int metricNumber)
: base(row, metricNumber)
{
if (SkillGuid == SkillNames.None)
{
SkillGuid = unchecked((SkillNames)ResourceUtils.HashString64(row.GetString("Args" + metricNumber)));
}
}
public FirestarterSymptom(XmlDbRow row)
: base(row)
{
if (BooterLogger.Exists(row, "Maximum", Guid))
{
mMaximum = row.GetInt("Maximum");
}
}
public override bool Parse(XmlDbRow row, SimPersonality personality, ref string error)
{
if (!base.Parse(row, personality, ref error)) return false;
if (!row.Exists("Name"))
{
error = "Name missing";
return false;
}
else if (!row.Exists("Default"))
{
error = "Default missing";
return false;
}
else
{
CASAgeGenderFlags ageGender;
if (!ParserFunctions.TryParseEnum<CASAgeGenderFlags>(row.GetString("AgeGender"), out ageGender, CASAgeGenderFlags.None))
{
error = "Unknown AgeGender " + row.GetString("AgeGender");
return false;
}
mAge = ageGender & CASAgeGenderFlags.AgeMask;
if (mAge == CASAgeGenderFlags.None)
{
mAge = CASAgeGenderFlags.AgeMask;
}
mGender = ageGender & CASAgeGenderFlags.GenderMask;
if (mGender == CASAgeGenderFlags.None)
{
mGender = CASAgeGenderFlags.GenderMask;
}
StringToSpeciesList converter = new StringToSpeciesList();
mSpecies = converter.Convert(row.GetString("Species"));
if (mSpecies == null)
{
error = converter.mError;
return false;
}
if (mSpecies.Count == 0)
{
mSpecies.Add(CASAgeGenderFlags.Human);
}
}
mName = row.GetString("Name");
SetValue (row.GetBool("Default"));
return true;
}
public EventChoice(XmlDbRow row, Dictionary<string, Dictionary<int, CareerLevel>> careerLevels, string careerName)
: base(row, careerLevels, careerName)
{
mYesRewardsList = OpportunityBooter.ParseRewards(row, sYesRewardColumns, kNumRewards);
mYesLoseRewardsList = OpportunityBooter.ParseRewards(row, sYesLoseRewardColumns, kNumRewards);
mNoRewardsList = OpportunityBooter.ParseRewards(row, sNoRewardColumns, kNumRewards);
}
public IncrementalStage(XmlDbRow row)
: base(row)
{
if (BooterLogger.Exists(row, "Maximum", Name))
{
mMaximum = row.GetInt("Maximum", 0);
}
mMaxMutation = row.GetString("MaxMutation");
}
protected override void Perform(BooterHelper.BootFile file, XmlDbRow row)
{
BooterHelper.DataBootFile dataFile = file as BooterHelper.DataBootFile;
if (dataFile == null) return;
mIndex++;
string personalityName = row.GetString("Name");
if (string.IsNullOrEmpty(personalityName))
{
BooterLogger.AddError(file + " : Method " + mIndex + " Unnamed");
return;
}
BooterLogger.AddTrace("Found " + personalityName);
if (GetPersonality(personalityName) != null)
{
BooterLogger.AddError(personalityName + " Name already in use");
return;
}
Type classType = row.GetClassType("FullClassName");
if (classType == null)
{
BooterLogger.AddError(personalityName + " No Class");
return;
}
SimPersonality personality = null;
try
{
personality = classType.GetConstructor(new Type[0]).Invoke(new object[0]) as SimPersonality;
}
catch
{ }
if (personality == null)
{
BooterLogger.AddError(personalityName + ": Constructor Fail " + row.GetString("FullClassName"));
}
else
{
XmlDbTable optionTable = dataFile.GetTable(personalityName);
if (personality.Parse(row, optionTable))
{
sLookup.Add(personalityName.ToLower(), personality);
}
else
{
BooterLogger.AddError(personalityName + ": Parsing Fail");
}
}
}
protected WeatherSettings GetSeason(XmlDbRow row)
{
Season season = row.GetEnum<Season>("Season", Season.Spring | Season.Summer | Season.Fall | Season.Winter);
if (season == (Season.Spring | Season.Summer | Season.Fall | Season.Winter))
{
BooterLogger.AddError("Unknown Season: " + row.GetString("Season"));
return null;
}
return Tempest.Settings.GetWeather(season, false);
}
public SchoolElementaryEx(XmlDbRow myRow, XmlDbTable levelTable, XmlDbTable eventDataTable)
: base(myRow, levelTable, eventDataTable)
{
try
{
mOther.Parse(myRow, levelTable);
}
catch (Exception e)
{
Common.Exception(Name, e);
}
}
public override bool Parse(XmlDbRow row, ref string error)
{
mName = new WeightOption.NameOption(row);
mSuccess = new WeightScenarioHelper(Origin.FromBreakingUp);
if (!mSuccess.Parse(row, Manager, this, "Success", ref error))
{
return false;
}
return base.Parse(row, ref error);
}
public CancelInteractionSymptom(XmlDbRow row)
: base(row)
{
if (BooterLogger.Exists(row, "All", Guid))
{
mAll = row.GetBool("All");
}
if (BooterLogger.Exists(row, "AffectSleep", Guid))
{
mAffectSleep = row.GetBool("AffectSleep");
}
}
public HitMissStage(XmlDbRow row)
: base(row)
{
if (BooterLogger.Exists(row, "SuccessStage", Name))
{
mSuccessStage.First = row.GetString("SuccessStage");
}
if (BooterLogger.Exists(row, "FailureStage", Name))
{
mFailureStage.First = row.GetString("FailureStage");
}
}
protected override void Perform(BooterHelper.BootFile file, XmlDbRow row)
{
SkillNames skill;
if (!ParserFunctions.TryParseEnum<SkillNames>(row.GetString("Skill"), out skill, SkillNames.None))
{
BooterLogger.AddError("Invalid Skill: " + row.GetString("Skill"));
return;
}
sData.Add(skill, true);
BooterLogger.AddTrace(" Child Skill: " + row.GetString("Skill"));
}
protected override void Perform(BooterHelper.BootFile file, XmlDbRow row)
{
Type type = row.GetClassType("Type");
if (type == null)
{
BooterLogger.AddError("Invalid Type: " + row.GetString("Type"));
return;
}
sData.Add(type, true);
BooterLogger.AddTrace(" Discount Type: " + row.GetString("Type"));
}
protected override void Perform(BooterHelper.BootFile file, XmlDbRow row)
{
BuffNames buff;
if (!ParserFunctions.TryParseEnum<BuffNames>(row.GetString("Moodlet"), out buff, BuffNames.Undefined))
{
BooterLogger.AddError("Invalid Moodlet: " + row.GetString("Moodlet"));
return;
}
sData.Add(buff, true);
BooterLogger.AddTrace(" Good Lot Moodlet: " + row.GetString("Moodlet"));
}
public MoodletResistance(XmlDbRow row)
: base(row, new MoodletTest(row))
{
}
public TestNewStrainStage(XmlDbRow row)
: base(row)
{
}
public PlayPrankOnCoworker(XmlDbRow row, Dictionary <string, Dictionary <int, CareerLevel> > careerLevels, string careerName) : base(row, careerLevels, Career.Event.DisplayTypes.TNS)
{
}
public override void SetField(FieldInfo field, XmlDbRow row)
{
field.SetValue(null, row.GetString("Value"));
}
public WeightEqualizationSymptom(XmlDbRow row)
: base(row)
{
}
// Methods
public MetricRecruitment(XmlDbRow row, int metricNumber)
: base(row, metricNumber)
{
}
public MoodletInstigator(XmlDbRow row)
: base(row, new MoodletTest(row))
{
}
public Retired(XmlDbRow myRow, XmlDbTable levelTable, XmlDbTable eventDataTable)
: base(myRow, levelTable, eventDataTable)
{
mCareerGuid = CareerGuid;
}
public override bool Parse(XmlDbRow row, ref string error)
{
if (!row.Exists("AgeGender"))
{
error = "AgeGender missing";
return(false);
}
else if (!row.Exists("OtherAgeGender"))
{
error = "OtherAgeGender missing";
return(false);
}
else if (!ParserFunctions.TryParseEnum <CASAgeGenderFlags>(row.GetString("AgeGender"), out mAgeGender, CASAgeGenderFlags.None))
{
error = "Unknown AgeGender " + row.GetString("AgeGender");
return(false);
}
else if (!ParserFunctions.TryParseEnum <CASAgeGenderFlags>(row.GetString("OtherAgeGender"), out mOtherAgeGender, CASAgeGenderFlags.None))
{
error = "Unknown OtherAgeGender " + row.GetString("OtherAgeGender");
return(false);
}
StringToSpeciesList converter = new StringToSpeciesList();
mSpecies = converter.Convert(row.GetString("Species"));
if (mSpecies == null)
{
error = converter.mError;
return(false);
}
if (mSpecies.Count == 0)
{
mSpecies.Add(CASAgeGenderFlags.Human);
}
mOtherSpecies = converter.Convert(row.GetString("OtherSpecies"));
if (mOtherSpecies == null)
{
error = converter.mError;
return(false);
}
if (mOtherSpecies.Count == 0)
{
mOtherSpecies.Add(CASAgeGenderFlags.Human);
}
if ((mAgeGender & CASAgeGenderFlags.AgeMask) == CASAgeGenderFlags.None)
{
mAgeGender |= CASAgeGenderFlags.AgeMask;
}
if ((mAgeGender & CASAgeGenderFlags.GenderMask) == CASAgeGenderFlags.None)
{
mAgeGender |= CASAgeGenderFlags.GenderMask;
}
if ((mOtherAgeGender & CASAgeGenderFlags.AgeMask) == CASAgeGenderFlags.None)
{
mOtherAgeGender |= CASAgeGenderFlags.AgeMask;
}
if ((mOtherAgeGender & CASAgeGenderFlags.GenderMask) == CASAgeGenderFlags.None)
{
mOtherAgeGender |= CASAgeGenderFlags.GenderMask;
}
return(base.Parse(row, ref error));
}
public override bool Parse(XmlDbRow row, ref string error)
{
mName = new WeightOption.NameOption(row);
mFight = new FightScenarioHelper(Origin.FromWatchingSimSuffer, SimDescription.DeathType.OldAge);
if (!mFight.Parse(row, Manager, this, ref error))
{
return(false);
}
mTraitReasons = new Dictionary <TraitNames, string>();
int index = 0;
while (true)
{
if (!row.Exists("ReasonTrait" + index))
{
break;
}
TraitNames trait;
if (!ParserFunctions.TryParseEnum <TraitNames>(row.GetString("ReasonTrait" + index), out trait, TraitNames.Unknown))
{
error = "ReasonTrait" + index + " unknown";
return(false);
}
if (mTraitReasons.ContainsKey(trait))
{
error = "ReasonTrait " + trait + " already found";
return(false);
}
if (!row.Exists("ReasonTraitName" + index))
{
error = "ReasonTraitName" + index + " missing";
return(false);
}
string text = row.GetString("ReasonTraitName" + index);
mTraitReasons.Add(trait, text);
index++;
}
mAgeGenderReasons = new Dictionary <CASAgeGenderFlags, string>();
index = 0;
while (true)
{
if (!row.Exists("ReasonAgeGender" + index))
{
break;
}
CASAgeGenderFlags ageGender;
if (!ParserFunctions.TryParseEnum <CASAgeGenderFlags>(row.GetString("ReasonAgeGender" + index), out ageGender, CASAgeGenderFlags.None))
{
error = "ReasonAgeGender" + index + " unknown";
return(false);
}
if (mAgeGenderReasons.ContainsKey(ageGender))
{
error = "ReasonAgeGender " + ageGender + " already found";
return(false);
}
if (!row.Exists("ReasonAgeGenderName" + index))
{
error = "ReasonAgeGenderName" + index + " missing";
return(false);
}
string text = row.GetString("ReasonAgeGenderName" + index);
mAgeGenderReasons.Add(ageGender, text);
index++;
}
if ((mTraitReasons.Count == 0) && (mAgeGenderReasons.Count == 0))
{
error = "No Reasons found";
return(false);
}
return(base.Parse(row, ref error));
}
public MetricShakedown(XmlDbRow row, int metricNumber)
: base(row, metricNumber)
{
}
public override bool Parse(XmlDbRow row, ref string error)
{
error = "Combined invalid";
return(false);
}
public WeightSymptom(XmlDbRow row)
: base(row)
{
}
private static void ParseSkillData(XmlDbData data, XmlDbRow row, bool bStore)
{
ProductVersion version;
bool flag = false;
SkillNames guid = SkillNames.None;
string skillHex = row.GetString("Hex");
try
{
guid = (SkillNames)SkillManager.GetGuid(ref skillHex, bStore);
}
catch
{ }
if (guid == SkillNames.None)
{
flag = true;
BooterLogger.AddError("GUID Fail " + skillHex);
}
if (!row.TryGetEnum <ProductVersion>("CodeVersion", out version, ProductVersion.BaseGame))
{
flag = true;
BooterLogger.AddError("CodeVersion Fail " + version);
}
else if (!GameUtils.IsInstalled(version))
{
flag = true;
BooterLogger.AddError("Install Fail " + version);
}
if (!flag)
{
Skill skill = null;
string typeName = row.GetString("CustomClassName");
bool flag2 = typeName.Length > 0x0;
if (flag2)
{
Type type = null;
/*
* if (bStore)
* {
* string[] strArray = typeName.Split(new char[] { ',' });
* if (strArray.Length < 0x2)
* {
* flag = true;
* }
* else
* {
* type = Type.GetType(strArray[0x0] + ",Sims3StoreObjects");
* }
* }
*/
if (type == null)
{
type = Type.GetType(typeName);
}
if (type == null)
{
flag = true;
BooterLogger.AddError("CustomClassName Not Found " + typeName);
}
else
{
object[] args = new object[] { guid };
ConstructorInfo constructor = type.GetConstructor(Type.GetTypeArray(args));
if (constructor == null)
{
flag = true;
BooterLogger.AddError("Constructor Missing " + typeName);
}
else
{
try
{
skill = constructor.Invoke(args) as Skill;
}
catch (Exception e)
{
Common.Exception(skillHex, e);
}
if (skill == null)
{
flag = true;
BooterLogger.AddError("Constructor Fail " + typeName);
}
}
}
}
else
{
skill = new Skill(guid);
BooterLogger.AddTrace("Generic Skill Used " + skillHex);
}
if (!flag)
{
Skill.NonPersistableSkillData data2 = new Skill.NonPersistableSkillData();
skill.NonPersistableData = data2;
uint group = ResourceUtils.ProductVersionToGroupId(version);
data2.SkillProductVersion = version;
data2.Name = "Gameplay/Excel/Skills/SkillList:" + row.GetString("SkillName");
if (!bStore || Localization.HasLocalizationString(data2.Name))
{
data2.Description = "Gameplay/Excel/Skills/SkillList:" + row.GetString("SkillDescription");
data2.MaxSkillLevel = row.GetInt("MaxSkillLevel", 0x0);
//skill.Guid = (SkillNames)(uint)guid; // Performed by the constructor, don't do it again here
data2.ThoughtBalloonTopicString = row.GetString("ThoughtBalloonTopic");
data2.IconKey = ResourceKey.CreatePNGKey(row.GetString("IconKey"), group);
data2.SkillUIIconKey = ResourceKey.CreatePNGKey(row.GetString("SkillUIIcon"), group);
string str3 = row.GetString("Commodity");
CommodityKind commodity = CommodityKind.None;
try
{
commodity = (CommodityKind)Enum.Parse(typeof(CommodityKind), str3);
}
catch
{ }
if (commodity == CommodityKind.None)
{
commodity = unchecked ((CommodityKind)ResourceUtils.HashString64(str3));
}
data2.Commodity = commodity;
SkillManager.SkillCommodityMap.Add(commodity, guid);
double num = 0;
if (bStore)
{
string versionStr = row.GetString("Version");
if (!string.IsNullOrEmpty(versionStr))
{
num = Convert.ToDouble(versionStr);
}
}
data2.SkillVersion = num;
if (row.GetBool("Physical"))
{
skill.AddCategoryToSkill(SkillCategory.Physical);
}
if (row.GetBool("Mental"))
{
skill.AddCategoryToSkill(SkillCategory.Mental);
}
if (row.GetBool("Musical"))
{
skill.AddCategoryToSkill(SkillCategory.Musical);
}
if (row.GetBool("Creative"))
{
skill.AddCategoryToSkill(SkillCategory.Creative);
}
if (row.GetBool("Artistic"))
{
skill.AddCategoryToSkill(SkillCategory.Artistic);
}
if (row.GetBool("Hidden"))
{
skill.AddCategoryToSkill(SkillCategory.Hidden);
}
if (row.GetBool("Certificate"))
{
skill.AddCategoryToSkill(SkillCategory.Certificate);
}
if ((row.Exists("HiddenWithSkillProgress") && row.GetBool("HiddenWithSkillProgress")) && skill.HasCategory(SkillCategory.Hidden))
{
skill.AddCategoryToSkill(SkillCategory.HiddenWithSkillProgress);
}
int[] numArray = new int[skill.MaxSkillLevel];
int num3 = 0x0;
for (int i = 0x1; i <= skill.MaxSkillLevel; i++)
{
string column = "Level_" + i.ToString();
num3 += row.GetInt(column, 0x0);
numArray[i - 0x1] = num3;
}
data2.PointsForNextLevel = numArray;
data2.AlwaysDisplayLevelUpTns = row.GetBool("AlwaysDisplayTNS");
string[] strArray2 = new string[skill.MaxSkillLevel + 0x1];
for (int j = 0x2; j <= skill.MaxSkillLevel; j++)
{
string str6 = "Level_" + j.ToString() + "_Text";
strArray2[j - 0x1] = row.GetString(str6);
if (strArray2[j - 0x1] != string.Empty)
{
strArray2[j - 0x1] = "Gameplay/Excel/Skills/SkillList:" + strArray2[j - 0x1];
}
}
strArray2[skill.MaxSkillLevel] = row.GetString("Level_10_Text_Alternate");
if (strArray2[skill.MaxSkillLevel] != string.Empty)
{
strArray2[skill.MaxSkillLevel] = "Gameplay/Excel/Skills/SkillList:" + strArray2[skill.MaxSkillLevel];
}
data2.LevelUpStrings = strArray2;
if (flag2)
{
XmlDbTable table2 = null;
string key = row.GetString("CustomDataSheet");
data.Tables.TryGetValue(key, out table2);
if ((table2 == null) && (key.Length > 0x0))
{
flag = true;
skill = null;
}
else if (!skill.ParseSkillData(table2))
{
flag = true;
skill = null;
}
}
data2.AvailableAgeSpecies = ParserFunctions.ParseAllowableAgeSpecies(row, "AvailableAgeSpecies");
data2.DreamsAndPromisesIcon = row.GetString("DreamsAndPromisesIcon");
data2.DreamsAndPromisesIconKey = ResourceKey.CreatePNGKey(data2.DreamsAndPromisesIcon, group);
data2.LogicSkillBoost = row.GetBool("LogicSkillBoost");
if (!flag)
{
GenericManager <SkillNames, Skill, Skill> .sDictionary.Add((uint)guid, skill);
SkillManager.sSkillEnumValues.AddNewEnumValue(skillHex, skill.Guid);
BooterLogger.AddTrace("Loaded " + skill.Name + " (" + skill.Guid + ")");
}
}
}
}
}
public bool Parse(XmlDbRow row, StoryProgressionObject manager, IUpdateManager updater, string prefix, ref string error)
{
if (!string.IsNullOrEmpty(prefix))
{
if (!Parse(row, manager, updater, null, ref error))
{
return(false);
}
mTestBeforehand = row.GetBool(prefix + "TestBeforehand");
mDelta = new HitMissResult <SimDescription, SimScoringParameters>(row, prefix + "Delta", ref error);
bool deltaSet = string.IsNullOrEmpty(error);
if (!deltaSet)
{
error = null;
}
string scenario = row.GetString(prefix + "Scenario");
if (!string.IsNullOrEmpty(scenario))
{
WeightOption scenarioWeight = manager.GetOption <WeightOption>(scenario);
if (scenarioWeight == null)
{
error = prefix + "Scenario weight " + scenario + " missing";
return(false);
}
mScenario = scenarioWeight.GetScenario();
if (mScenario == null)
{
error = prefix + "Scenario " + scenario + " invalid";
return(false);
}
if (deltaSet)
{
IDeltaScenario deltaScenario = mScenario as IDeltaScenario;
if (deltaScenario != null)
{
deltaScenario.IDelta = mDelta;
}
}
}
mRecruit = new SimRecruitFilter();
if (!mRecruit.Parse(row, manager, updater, prefix, ref error))
{
return(false);
}
mPropagate = new PropagationScenarioHelper();
if (!mPropagate.Parse(row, mOrigin, prefix, ref error))
{
return(false);
}
mActorBuffs = new Dictionary <BuffNames, Origin>();
if (!ParseBuffs(row, prefix, "Actor", mActorBuffs, ref error))
{
return(false);
}
mTargetBuffs = new Dictionary <BuffNames, Origin>();
if (!ParseBuffs(row, prefix, "Target", mTargetBuffs, ref error))
{
return(false);
}
}
if (row.Exists(prefix + "ScenarioActor"))
{
if (!row.TryGetEnum <PropagateBuffScenario.WhichSim>(prefix + "ScenarioActor", out mScenarioActor, PropagateBuffScenario.WhichSim.Unset))
{
error = prefix + "ScenarioActor Unknown " + row.GetString(prefix + "ScenarioActor");
return(false);
}
}
if (row.Exists(prefix + "ScenarioTarget"))
{
if (!row.TryGetEnum <PropagateBuffScenario.WhichSim>(prefix + "ScenarioTarget", out mScenarioTarget, PropagateBuffScenario.WhichSim.Unset))
{
error = prefix + "ScenarioTarget Unknown " + row.GetString(prefix + "ScenarioTarget");
return(false);
}
}
mActorCelebrity = row.GetInt(prefix + "ActorCelebrity", mActorCelebrity);
mTargetCelebrity = row.GetInt(prefix + "TargetCelebrity", mTargetCelebrity);
if (!ParseAccumulator(row, prefix + "AccumulateValue", mAccumulators, ref error))
{
return(false);
}
if (!ParseAccumulator(row, prefix + "GatheringFailureValue", mGatheringFailAccumulators, ref error))
{
return(false);
}
updater.AddUpdater(this);
return(true);
}
public GenericResistance(XmlDbRow row)
: base(row, new GenericTest(row))
{
}
protected override void Perform(BooterHelper.BootFile file, XmlDbRow row)
{
string guid = row.GetString("Guid");
if (string.IsNullOrEmpty(guid))
{
BooterLogger.AddError(file + ": Guid empty");
return;
}
AfterschoolActivityType type = unchecked ((AfterschoolActivityType)ResourceUtils.HashString64(guid));
AfterschoolActivityData data = new AfterschoolActivityData();
data.mActivity = new AfterschoolActivity(type);
List <string> skills = row.GetStringList("Skills", ',');
if (skills != null)
{
foreach (string skillStr in skills)
{
SkillNames skill = SkillManager.sSkillEnumValues.ParseEnumValue(skillStr);
if (skill == SkillNames.None)
{
BooterLogger.AddError(file + ": " + guid + " Unknown skill " + skillStr);
return;
}
else
{
data.mActivity.ActivitySkillNameList.Add(skill);
}
}
}
if (data.mActivity.ActivitySkillNameList.Count == 0)
{
BooterLogger.AddError(file + ": " + guid + " Activity Must Have a Skill");
return;
}
DaysOfTheWeek days;
if (!row.TryGetEnum <DaysOfTheWeek>("DaysOfTheWeek", out days, DaysOfTheWeek.All))
{
BooterLogger.AddError(file + ": " + guid + " Unknown DaysOfTheWeek " + row.GetString("DaysOfTheWeek"));
return;
}
data.mActivity.DaysForActivity = days;
CASAgeGenderFlags genders;
if (!row.TryGetEnum <CASAgeGenderFlags>("Genders", out genders, CASAgeGenderFlags.GenderMask))
{
BooterLogger.AddError(file + ": " + guid + " Unknown Genders " + row.GetString("Genders"));
return;
}
data.mGenders = genders;
CASAgeGenderFlags ages;
if (!row.TryGetEnum <CASAgeGenderFlags>("Ages", out ages, CASAgeGenderFlags.AgeMask))
{
BooterLogger.AddError(file + ": " + guid + " Unknown Ages " + row.GetString("Ages"));
return;
}
data.mAges = ages;
if (row.Exists("PreLoop"))
{
data.mPreLoop = new Common.MethodStore(row.GetString("PreLoop"), new Type[] { typeof(GoToSchoolInRabbitHole), typeof(AfterschoolActivity) }).Method;
if (data.mPreLoop == null)
{
BooterLogger.AddError(file + ": " + guid + " Missing PreLoop " + row.GetString("PreLoop"));
return;
}
}
if (row.Exists("Loop"))
{
data.mLoop = new Common.MethodStore(row.GetString("Loop"), new Type[] { typeof(GoToSchoolInRabbitHole), typeof(AfterschoolActivity) }).Method;
if (data.mLoop == null)
{
BooterLogger.AddError(file + ": " + guid + " Missing Loop " + row.GetString("Loop"));
return;
}
}
if (row.Exists("PostLoop"))
{
data.mPostLoop = new Common.MethodStore(row.GetString("PostLoop"), new Type[] { typeof(GoToSchoolInRabbitHole), typeof(AfterschoolActivity) }).Method;
if (data.mPostLoop == null)
{
BooterLogger.AddError(file + ": " + guid + " Missing PostLoop " + row.GetString("PostLoop"));
return;
}
}
Activities.Add(type, data);
BooterLogger.AddTrace(file + ": " + guid + " Loaded");
}
public override bool Parse(XmlDbRow row, XmlDbTable table)
{
mCycleRetention = row.GetInt("CycleRetention", mCycleRetention);
return(base.Parse(row, table));
}
public override bool Parse(XmlDbRow row, ref string error)
{
mAdditional = row.GetInt("Additional", mAdditional);
return(base.Parse(row, ref error));
}
// Methods
public MetricStoriesAndReviews(XmlDbRow row, int metricNumber)
: base(row, metricNumber)
{
}
// Methods
public MetricRelPartner(XmlDbRow row, int metricNumber)
: base(row, metricNumber)
{
}
// Methods
public MetricMeetingsHeld(XmlDbRow row, int metricNumber)
: base(row, metricNumber)
{
}
public Data(XmlDbRow row)
{
mGuid = row.GetString("GUID");
}
public void LoadCareer(BooterHelper.BootFile file, XmlDbRow row)
{
BooterHelper.DataBootFile dataFile = file as BooterHelper.DataBootFile;
if (dataFile == null)
{
return;
}
string careerName = row.GetString("CareerName");
if (careerName == null)
{
BooterLogger.AddError(file.ToString() + ": No CareerName");
}
else
{
Type classType = row.GetClassType("FullClassName");
if (classType != null)
{
string key = row.GetString("TableName");
XmlDbTable levelTable = dataFile.GetTable(key);
if (levelTable != null)
{
foreach (XmlDbRow levelRow in levelTable.Rows)
{
XmlDbData.XmlDbRowFast level = levelRow as XmlDbData.XmlDbRowFast;
if (level == null)
{
continue;
}
if (!level.Exists("DowntownWakeupTime"))
{
level.mData.Add("DowntownWakeupTime", level.GetString("WakeupTime"));
}
if (!level.Exists("DowntownStartTime"))
{
level.mData.Add("DowntownStartTime", level.GetString("StartTime"));
}
if (!level.Exists("DowntownDayLength"))
{
level.mData.Add("DowntownDayLength", level.GetString("DayLength"));
}
}
Type[] types = new Type[] { typeof(XmlDbRow), typeof(XmlDbTable), typeof(XmlDbTable) };
Career career = null;
try
{
career = classType.GetConstructor(types).Invoke(new object[] { row, levelTable, null }) as Career;
}
catch (Exception e)
{
BooterLogger.AddError(careerName + ": Constructor Fail " + row.GetString("FullClassName"));
Common.Exception(careerName + ": Constructor Fail " + row.GetString("FullClassName"), e);
return;
}
if (career != null)
{
if (mCareerEventsFile.IsValid)
{
XmlDbTable table3 = mCareerEventsFile.GetTable(key);
if (table3 != null)
{
LoadCareerEvents(career, mCareerEventsFile, table3);
}
}
career.mCareerGuid = unchecked ((OccupationNames)ResourceUtils.HashString64(row.GetString("AltGuid")));
if (career.Guid == OccupationNames.Undefined)
{
BooterLogger.AddError(careerName + ": No AltGuid");
}
else if (CareerManager.GetStaticCareer(career.mCareerGuid) != null)
{
BooterLogger.AddError(careerName + ": Duplicate GUID");
}
else
{
RabbitHoleType type = RabbitHoleType.None;
ParserFunctions.TryParseEnum <RabbitHoleType>(row.GetString("RabbitholeType"), out type, RabbitHoleType.None);
if (type != RabbitHoleType.None)
{
sCareers.Add(new CareerBooterElement(career.Guid, type));
CareerManager.AddStaticOccupation(career);
BooterLogger.AddTrace(careerName + ": Added to Rabbithole " + type);
}
else
{
BooterLogger.AddError(careerName + ": Unknown Rabbithole");
}
}
}
else
{
BooterLogger.AddError(careerName + ": Constructor Fail " + row.GetString("FullClassName"));
}
}
else
{
BooterLogger.AddError(careerName + ": No TableName");
}
}
else
{
BooterLogger.AddError(careerName + ": Invalid FullClassName " + row.GetString("FullClassName"));
}
}
}
public MetricReadingsPerformed(XmlDbRow row, int metricNumber)
: base(row, metricNumber)
{
}
public virtual bool Parse(XmlDbRow myRow, XmlDbTable table)
{
mName = myRow.GetString("Name");
string error = null;
if (!Parse(myRow, ref error))
{
BooterLogger.AddError(Name + " : " + error);
return(false);
}
if ((table == null) || (table.Rows == null) || (table.Rows.Count == 0))
{
BooterLogger.AddError(Name + ": Missing Table");
return(false);
}
else
{
List <IScoring <T, SubSP> > rawScoring = new List <IScoring <T, SubSP> >();
int index = 1;
foreach (XmlDbRow row in table.Rows)
{
Type classType = row.GetClassType("FullClassName");
if (classType == null)
{
BooterLogger.AddError(Name + ": Unknown FullClassName " + row.GetString("FullClassName"));
continue;
}
IScoring <T, SubSP> scoring = null;
try
{
scoring = classType.GetConstructor(new Type[0]).Invoke(new object[0]) as IScoring <T, SubSP>;
}
catch
{ }
if (scoring == null)
{
BooterLogger.AddError(Name + " (" + index + "): Constructor Fail " + row.GetString("FullClassName") + " as " + typeof(IScoring <T, SubSP>));
}
else
{
error = null;
if (scoring.Parse(row, ref error))
{
rawScoring.Add(scoring);
}
else
{
if (!string.IsNullOrEmpty(error))
{
BooterLogger.AddError(Name + " index " + index + " : " + error);
}
else
{
BooterLogger.AddTrace(Name + " index " + index + " : <Warning>");
}
}
}
index++;
}
List <ICombinedScoring <T, SubSP> > combinedList = Common.DerivativeSearch.Find <ICombinedScoring <T, SubSP> >(Common.DerivativeSearch.Caching.NoCache);
foreach (ICombinedScoring <T, SubSP> combined in combinedList)
{
IScoring <T, SubSP> scoring = combined as IScoring <T, SubSP>;
if (scoring == null)
{
continue;
}
if (combined.Combine(rawScoring))
{
rawScoring.Add(scoring);
}
}
List <IScoring <T, SubSP> > scoringList = new List <IScoring <T, SubSP> >(rawScoring);
rawScoring.Clear();
foreach (IScoring <T, SubSP> scoring in scoringList)
{
if (scoring.IsConsumed)
{
continue;
}
rawScoring.Add(scoring);
}
if (rawScoring.Count > 0)
{
mHelper.SetRawScoring(rawScoring);
return(true);
}
else
{
BooterLogger.AddError(Name + ": No valid scoring");
return(false);
}
}
}
public PartTimeJob(XmlDbRow myRow, XmlDbTable levelTable, XmlDbTable eventDataTable)
: base(myRow, levelTable, eventDataTable)
{
}
public CareerBooterToneDefinition(XmlDbRow row, Type tone)
: base(row.GetString("ToneName"))
{
mRow = row;
mTone = tone;
}
public override bool Parse(XmlDbRow row, ref string error)
{
return(true);
}
public HomeSchooling(XmlDbRow myRow, XmlDbTable levelTable, XmlDbTable eventDataTable)
: base(myRow, levelTable, eventDataTable)
{
}
