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) { }