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(" Parent Skill: " + row.GetString("Skill"));
}
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 Child Moodlet: " + row.GetString("Moodlet"));
}
protected override void Perform(BooterHelper.BootFile file, XmlDbRow row)
{
string guid = row.GetString("GUID");
if (string.IsNullOrEmpty(guid))
{
BooterLogger.AddError("Invalid GUID: " + guid);
return;
}
else if (sVectors.ContainsKey(guid))
{
BooterLogger.AddError("Duplicate GUID: " + guid);
return;
}
sVectors.Add(guid, new Data(guid, file, row));
}
protected override void Perform(BooterHelper.BootFile file, XmlDbRow row)
{
string name = row.GetString("Name");
if (string.IsNullOrEmpty(name))
{
BooterLogger.AddError("Name missing");
return;
}
if (ActionData.Get(name) == null)
{
BooterLogger.AddError("ActionData missing: " + name);
return;
}
Add(ParseKey(row), new SeasonSettings.ActionDataSetting(name, row));
}
protected override void PerformFile(BooterHelper.BootFile file)
{
BooterHelper.DataBootFile dataFile = file as BooterHelper.DataBootFile;
if (dataFile == null)
{
return;
}
sDelayedSkillBooks.Add(dataFile.Data);
BookData.LoadBookData(dataFile.Data, "BookGeneral", BookData.BookType.General);
BookData.LoadBookData(dataFile.Data, "BookRecipe", BookData.BookType.Recipe);
BookData.LoadBookData(dataFile.Data, "MedicalJournal", BookData.BookType.MedicalJournal);
BookData.LoadBookData(dataFile.Data, "SheetMusic", BookData.BookType.SheetMusic);
BookData.LoadBookData(dataFile.Data, "BookToddler", BookData.BookType.Toddler);
BookData.LoadBookData(dataFile.Data, "BookAlchemyRecipe", BookData.BookType.AlchemyRecipe);
LoadWrittenBookTitles(dataFile.Data);
LoadWrittenBookMaterials(dataFile.Data);
BookData.LoadBookData(dataFile.Data, "BookFish", BookData.BookType.FishBook);
XmlDbTable table = dataFile.GetTable("OmniJournal");
if (table != null)
{
BooterLogger.AddTrace(file.ToString() + ": Found OmniJournal = " + table.Rows.Count.ToString());
int rowIndex = 0;
foreach (XmlDbRow row in table.Rows)
{
new OmniJournalData(row, rowIndex);
rowIndex++;
}
}
else
{
BooterLogger.AddTrace(file.ToString() + ": No OmniJournal");
}
Bookstore.mItemDictionary.Clear();
Bookstore.LoadData();
}
protected override void Perform(BooterHelper.BootFile file, XmlDbRow row)
{
Homemaker.StipendValue key;
if (!ParserFunctions.TryParseEnum <Homemaker.StipendValue>(row.GetString("Key"), out key, Homemaker.StipendValue.Undefined))
{
BooterLogger.AddError("Stipend Key Missing: " + row.GetString("Key"));
return;
}
int maximum = row.GetInt("Maximum");
int factor = row.GetInt("Factor");
bool positive = row.GetBool("Positive");
sData.Add(key, new Data(maximum, factor, positive));
BooterLogger.AddTrace(" Stipend Loaded: " + row.GetString("Key"));
}
protected override void Perform(BooterHelper.BootFile file, XmlDbRow row)
{
string interactionName = row.GetString("InteractionName");
if (string.IsNullOrEmpty(interactionName))
{
BooterLogger.AddError("InteractionName missing");
return;
}
string objectName = row.GetString("ObjectName");
if (string.IsNullOrEmpty(objectName))
{
BooterLogger.AddError("ObjectName missing");
return;
}
Add(ParseKey(row), new SeasonSettings.ITUNSettings(Retuner.TuningName(objectName, interactionName), row));
}
protected override void Perform(BooterHelper.BootFile file, XmlDbRow row)
{
string guid = row.GetString("GUID");
if (string.IsNullOrEmpty(guid))
{
BooterLogger.AddError("Invalid GUID: " + guid);
return;
}
else if (sInstigators.ContainsKey(guid))
{
BooterLogger.AddError("Duplicate GUID: " + guid);
return;
}
Type type = row.GetClassType("FullClassName");
if (type == null)
{
BooterLogger.AddError(guid + " Invalid FullClassName: " + row.GetString("FullClassName"));
return;
}
Data symptom = null;
try
{
symptom = type.GetConstructor(new Type[] { typeof(XmlDbRow) }).Invoke(new object[] { row }) as Data;
}
catch (Exception e)
{
BooterLogger.AddError("Contructor Fail: " + row.GetString("FullClassName"));
Common.Exception(guid + Common.NewLine + row.GetString("FullClassName") + " Fail", e);
}
if (symptom != null)
{
sInstigators.Add(guid, symptom);
}
}
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");
int openHour = row.GetInt("OpenHour");
int closeHour = row.GetInt("CloseHour");
try
{
data.SetGUID(name);
}
catch (ArgumentException e)
{
Common.Exception("", e);
}
if (!data.Valid)
{
return;
}
data.name = name;
data.icon = icon;
data.isBusinessType = business;
data.openHour = openHour;
data.closeHour = closeHour;
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);
EnumInjection.InjectEnums <Lot.MetaAutonomyType>(new string[] { name }, new object[] { data.GUID }, false);
EnumInjection.InjectEnums <MetaAutonomyVenueType>(new string[] { name }, new object[] { data.GUID }, false);
}
}
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));
}
protected override void PerformFile(BooterHelper.BootFile paramFile)
{
BooterHelper.DataBootFile file = paramFile as BooterHelper.DataBootFile;
XmlDbTable jobsTable = file.GetTable("Jobs");
if (jobsTable == null)
{
if (file.mPrimary)
{
BooterLogger.AddTrace(file + ": No Jobs Table");
}
else
{
BooterLogger.AddError(file + ": No Jobs Table");
}
return;
}
Dictionary <ulong, Dictionary <uint, JobStaticData> > careerToJobStaticDataMap = GenerateOccupationToJobStaticDataMap(jobsTable);
BooterLogger.AddTrace("Jobs: " + careerToJobStaticDataMap.Count);
foreach (KeyValuePair <ulong, Dictionary <uint, JobStaticData> > occupationPair in careerToJobStaticDataMap)
{
OccupationStaticData data;
if (!Occupation.sOccupationStaticDataMap.TryGetValue(occupationPair.Key, out data))
{
continue;
}
foreach (KeyValuePair <uint, JobStaticData> jobPair in occupationPair.Value)
{
data.JobStaticDataMap[jobPair.Key] = jobPair.Value;
}
}
}
protected override void PerformFile(BooterHelper.BootFile file)
{
BooterHelper.DataBootFile dataFile = file as BooterHelper.DataBootFile;
if (dataFile == null)
{
return;
}
if (dataFile.GetTable("TraitList") == null && dataFile.GetTable("Traits") == null)
{
return;
}
try
{
TraitManager.ParseTraitData(dataFile.Data, true);
}
catch (Exception e)
{
Common.Exception(file.ToString(), e);
BooterLogger.AddError(file + ": ParseTraitData Error");
}
}
// From AcademicDegreeManager:CreateAcademicDegreeTable
protected override void Perform(BooterHelper.BootFile file, XmlDbRow row)
{
AcademicDegreeNames academicDegree = AcademicDegreeNames.Undefined;
if (!row.TryGetEnum <AcademicDegreeNames>("AcademicDegreeEnum", out academicDegree, AcademicDegreeNames.Undefined))
{
academicDegree = unchecked ((AcademicDegreeNames)ResourceUtils.HashString64(row.GetString("AcademicDegreeEnum")));
}
BooterLogger.AddTrace("AcademicDegreeEnum: " + row.GetString("AcademicDegreeEnum"));
string degreeNameKey = row.GetString("AcademicDegreeName");
string degreeDescKey = row.GetString("AcademicDegreeDesc");
string degreeIcon = row.GetString("AcademicDegreeIcon");
int degreeCreditHours = row.GetInt("AcademicDegreeRequiredCreditHours");
float degreeCostPerCredit = row.GetFloat("AcademicDegreeCostPerCredit");
string degreeResponsibilitiesKey = row.GetString("ResponsibilityTooltipKey");
JobId academicDefaultCourseID;
if (!row.TryGetEnum <JobId>("AcademicDefaultCourseID", out academicDefaultCourseID, JobId.AcademicsGenericRabbitHoleCourse))
{
// Custom
academicDefaultCourseID = unchecked ((JobId)ResourceUtils.HashString64(row.GetString("AcademicDefaultCourseID")));
}
JobId academicDefaultLectureID;
if (!row.TryGetEnum <JobId>("AcademicDefaultLectureID", out academicDefaultLectureID, JobId.Invalid))
{
// Custom
academicDefaultLectureID = unchecked ((JobId)ResourceUtils.HashString64(row.GetString("AcademicDefaultLectureID")));
}
JobId academicDefaultLabID;
if (!row.TryGetEnum <JobId>("AcademicDefaultLabID", out academicDefaultLabID, JobId.Invalid))
{
// Custom
academicDefaultLabID = unchecked ((JobId)ResourceUtils.HashString64(row.GetString("AcademicDefaultLabID")));
}
List <OccupationNames> associatedOccupations = new List <OccupationNames>();
List <string> list2 = row.GetStringList("AssociatedOccupationNameEnum", ',', true);
for (int i = 0x0; i < list2.Count; i++)
{
OccupationNames occupation;
if (!ParserFunctions.TryParseEnum <OccupationNames>(list2[i], out occupation, OccupationNames.Undefined))
{
occupation = unchecked ((OccupationNames)ResourceUtils.HashString64(row.GetString(list2[i])));
}
if (occupation != OccupationNames.Undefined)
{
associatedOccupations.Add(occupation);
}
}
OccupationNames grantedOccupation;
if (!ParserFunctions.TryParseEnum <OccupationNames>("GrantedOccupationNameEnum", out grantedOccupation, OccupationNames.Undefined))
{
// Custom
grantedOccupation = unchecked ((OccupationNames)ResourceUtils.HashString64(row.GetString("GrantedOccupationNameEnum")));
}
List <TraitNames> beneficialTraits;
List <TraitNames> detrimentalTraits;
List <TraitNames> suggestedTraits;
ParserFunctions.TryParseCommaSeparatedList <TraitNames>(row["BeneficialTraits"], out beneficialTraits, TraitNames.Unknown);
ParserFunctions.TryParseCommaSeparatedList <TraitNames>(row["DetrimentalTraits"], out detrimentalTraits, TraitNames.Unknown);
ParserFunctions.TryParseCommaSeparatedList <TraitNames>(row["SuggestedTraits"], out suggestedTraits, TraitNames.Unknown);
AcademicDegreeStaticData staticData = null;
if (!AcademicDegreeManager.sDictionary.TryGetValue((ulong)academicDegree, out staticData))
{
staticData = new AcademicDegreeStaticData(academicDegree, degreeNameKey, degreeDescKey, degreeResponsibilitiesKey, degreeIcon, degreeCreditHours, degreeCostPerCredit, academicDefaultCourseID, academicDefaultLectureID, academicDefaultLabID, associatedOccupations, grantedOccupation, beneficialTraits, detrimentalTraits, suggestedTraits);
}
else
{
staticData.BeneficialTraits.AddRange(beneficialTraits);
staticData.DetrimentalTraits.AddRange(detrimentalTraits);
staticData.SuggestedTraits.AddRange(suggestedTraits);
staticData.AssociatedOccupations.AddRange(associatedOccupations);
}
string skillsThatGrantXP = row.GetString("SkillsThatGrantXP");
if (!string.IsNullOrEmpty(skillsThatGrantXP))
{
foreach (string str6 in skillsThatGrantXP.Split(new char[] { ';' }))
{
string[] strArray2 = str6.Split(new char[] { ',' });
if (strArray2.Length != 0x2)
{
continue;
}
float num4 = ParserFunctions.ParseFloat(strArray2[0x1], -1234123f);
if (num4 == -1234123f)
{
continue;
}
// Custom
SkillNames skillName = SkillManager.sSkillEnumValues.ParseEnumValue(strArray2[0x0]);
if (skillName == SkillNames.None)
{
continue;
}
staticData.AddSkill(skillName, num4);
}
}
AcademicDegreeManager.sDictionary[(ulong)academicDegree] = staticData;
}
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 Data(string guid, BooterHelper.BootFile file, XmlDbRow row)
{
mGuid = guid;
if (BooterLogger.Exists(row, "InitialStrength", guid))
{
mInitialStrength = row.GetInt("InitialStrength", 0);
}
mInfectionScoring = row.GetString("InfectionScoring");
if (string.IsNullOrEmpty(mInfectionScoring))
{
BooterLogger.AddError(Guid + " Missing InfectionScoring: " + mInfectionScoring);
}
else if (ScoringLookup.GetScoring(mInfectionScoring) == null)
{
BooterLogger.AddError(Guid + " Missing InfectionScoring: " + mInfectionScoring);
}
mInfectionMinimum = row.GetInt("InfectionMinimum", 0);
VectorStageTable table = new VectorStageTable(file as BooterHelper.DataBootFile, guid);
if (!table.IsValid)
{
BooterLogger.AddError(Guid + " Missing Stages: " + guid);
}
else
{
Dictionary <string, int> namesToStages = new Dictionary <string, int>();
for (int i = 0; i < table.Stages.Count; i++)
{
if (namesToStages.ContainsKey(table.Stages[i].Name))
{
BooterLogger.AddError(Guid + " Stage " + i + ": Duplicate Name " + table.Stages[i].Name);
continue;
}
namesToStages.Add(table.Stages[i].Name, i);
}
for (int i = 0; i < table.Stages.Count; i++)
{
BooterLogger.AddTrace("Stage " + i);
table.Stages[i].ValidateStages(namesToStages);
}
}
mStages = table.Stages;
mInoculationRating = row.GetInt("InoculationRating", 10);
mInoculationCost = row.GetInt("InoculationCost", 0);
mResistanceCost = row.GetInt("ResistanceCost", 0);
mCanOutbreak = row.GetBool("CanOutbreak");
mHighProtectionCost = row.GetInt("HighProtectionCost", 0);
mLowProtectionCost = row.GetInt("LowProtectionCost", 0);
mMinimumStrainDifference = row.GetInt("MinimumStrainDifference", 0);
mStrainMutationRate = row.GetInt("StrainMutationRate", -1);
int numInstigators = row.GetInt("NumInstigators", 0) + 1;
for (int i = 1; i <= numInstigators; i++)
{
if (i == numInstigators)
{
if (row.Exists("Instigator" + i))
{
BooterLogger.AddError(Guid + " More Instigator then NumInstigators");
}
break;
}
mInstigators.Add(InstigatorBooter.GetInstigator(row.GetString("Instigator" + i)));
}
}
protected override void PerformFile(BooterHelper.BootFile file)
{
BooterHelper.DataBootFile dataFile = file as BooterHelper.DataBootFile;
if (dataFile == null)
{
return;
}
XmlDbTable table = dataFile.GetTable("SkillBasedCareers");
if (table == null)
{
if (file.mPrimary)
{
BooterLogger.AddTrace(file + ": No SkillBasedCareers table");
}
else
{
BooterLogger.AddError(file + ": No SkillBasedCareers table");
}
return;
}
XmlDbTable table2 = dataFile.GetTable("CareerLevels");
if (table2 == null)
{
BooterLogger.AddError(file + ": No CareerLevels table");
return;
}
BooterLogger.AddTrace(file + ": Found Setup = " + table.Rows.Count.ToString());
if (Occupation.sOccupationStaticDataMap == null)
{
Occupation.sOccupationStaticDataMap = new Dictionary <ulong, OccupationStaticData>();
}
Dictionary <ulong, List <XmlDbRow> > dictionary = GenerateCareerToCareerLevelXmlDataMap(table2, "SkilledProfession", "SkillBasedCareers");
foreach (XmlDbRow row in table.Rows)
{
string guid = row.GetString("SkilledProfession");
OccupationNames names;
if (!row.TryGetEnum <OccupationNames>("SkilledProfession", out names, OccupationNames.Undefined))
{
names = unchecked ((OccupationNames)ResourceUtils.HashString64(guid));
}
if (Occupation.sOccupationStaticDataMap.ContainsKey((ulong)names))
{
BooterLogger.AddError(file + ": Exists " + guid);
continue;
}
string str = row.GetString("Skill_Name");
SkillNames skillName = SkillNames.None;
try
{
skillName = GenericManager <SkillNames, Skill, Skill> .ParseGuid(str);
}
catch
{ }
if (skillName == SkillNames.None)
{
skillName = unchecked ((SkillNames)ResourceUtils.HashString64(str));
}
int minimumLevel = row.GetInt("Minimum_Skill_Level", -1);
float gainMultiplier = row.GetFloat("XP_Gain_Multiplier", 0f);
int highestLevel = row.GetInt("Highest_Level", 0x0);
string speechBalloonIcon = row.GetString("Speech_Balloon_Image");
string hudIcon = row.GetString("HUD_Icon");
string dreamsAndPromisesIcon = row.GetString("Wishes_Icon");
string careerDescriptionLocalizationKey = "Gameplay/Excel/SkillBasedCareers/SkillBasedCareers:" + row.GetString("Description_Text");
string careerOfferLocalizationKey = "Gameplay/Excel/SkillBasedCareers/SkillBasedCareers:" + row.GetString("Offer_Text");
List <string> careerResponsibilityLocalizationKeys = new List <string>();
for (int i = 0x1; i <= 0x3; i++)
{
string str7 = row.GetString("Career_Responsibility_" + i);
if (string.IsNullOrEmpty(str7))
{
break;
}
careerResponsibilityLocalizationKeys.Add("Gameplay/Excel/SkillBasedCareers/SkillBasedCareers:" + str7);
}
List <string> careerResponsibilityShortLocalizationKeys = new List <string>();
for (int i = 0x1; i <= 0x3; i++)
{
string str10 = row.GetString("Career_Responsibility_Short_" + i);
if (string.IsNullOrEmpty(str10))
{
break;
}
careerResponsibilityShortLocalizationKeys.Add("Gameplay/Excel/SkillBasedCareers/SkillBasedCareers:" + str10);
}
List <string> careerResponsibilityIcons = new List <string>();
for (int j = 0x1; j <= 0x3; j++)
{
string str11 = row.GetString("Career_Responsibility_Icon_" + j);
if (string.IsNullOrEmpty(str11))
{
break;
}
careerResponsibilityIcons.Add(str11);
}
List <XmlDbRow> list3;
if (dictionary.TryGetValue((ulong)names, out list3))
{
Dictionary <int, OccupationLevelStaticData> levelStaticDataMap = SkillBasedCareer.GenerateCareerLevelToStaticLevelDataMap(names, list3);
Type type = row.GetClassType("FullClassName");
if (type == null)
{
type = Type.GetType("Sims3.Gameplay.Careers.SkillBasedCareer, Sims3GameplaySystems");
}
Type[] types = new Type[] { typeof(OccupationNames) };
SkillBasedCareer career = (SkillBasedCareer)type.GetConstructor(types).Invoke(new object[] { names });
if (career == null)
{
BooterLogger.AddError(file.ToString() + ": Constructor Fail " + guid);
continue;
}
Dictionary <uint, JobStaticData> jobStaticDataMap = new Dictionary <uint, JobStaticData>();
Dictionary <uint, TaskStaticData> taskStaticDataMap = new Dictionary <uint, TaskStaticData>();
Dictionary <string, TrackedAsStaticData> trackedAsMappingsStaticDataMap = new Dictionary <string, TrackedAsStaticData>();
SkillBasedCareerStaticData data2 = new SkillBasedCareerStaticData(skillName, minimumLevel, gainMultiplier, highestLevel, speechBalloonIcon, hudIcon, dreamsAndPromisesIcon, careerDescriptionLocalizationKey, careerOfferLocalizationKey, careerResponsibilityLocalizationKeys, careerResponsibilityShortLocalizationKeys, careerResponsibilityIcons, levelStaticDataMap, jobStaticDataMap, taskStaticDataMap, trackedAsMappingsStaticDataMap);
if (Occupation.sOccupationStaticDataMap == null)
{
Occupation.sOccupationStaticDataMap = new Dictionary <ulong, OccupationStaticData>();
}
Occupation.sOccupationStaticDataMap.Add((ulong)names, data2);
CareerManager.AddStaticOccupation(career);
}
else
{
BooterLogger.AddError(file.ToString() + ": No Levels " + guid);
}
}
}
protected override void Perform(BooterHelper.BootFile file, XmlDbRow row)
{
sNames.Load(row);
}
protected static void LoadCareerEvents(Career career, BooterHelper.BootFile eventsFile, XmlDbTable eventDataTable)
{
if (eventDataTable == null)
{
return;
}
BooterLogger.AddTrace(eventsFile + ": Found " + career.Name + " Events = " + eventDataTable.Rows.Count);
foreach (XmlDbRow row in eventDataTable.Rows)
{
ProductVersion version;
row.TryGetEnum <ProductVersion>("ProductVersion", out version, ProductVersion.BaseGame);
if (GameUtils.IsInstalled(version))
{
string str3 = row.GetString("EventName");
string str4 = row.GetString("OpportunityName");
bool flag = row.GetInt("SureShotEvent") == 1;
Type classType;
if ((str4 != string.Empty) && (str3 == string.Empty))
{
classType = typeof(Career.EventOpportunity);
}
else
{
classType = row.GetClassType("EventName");
}
Type[] types = new Type[] { typeof(XmlDbRow), typeof(Dictionary <string, Dictionary <int, CareerLevel> >), typeof(string) };
object obj = null;
try
{
obj = classType.GetConstructor(types).Invoke(new object[] { row, career.SharedData.CareerLevels, eventDataTable.Name });
}
catch (Exception e)
{
BooterLogger.AddError(eventsFile + ": Constructor Fail " + row.GetString("EventName"));
Common.Exception(eventsFile + ": Constructor Fail " + row.GetString("EventName"), e);
}
if (obj == null)
{
BooterLogger.AddError(eventsFile + ": Bad Class " + row.GetString("EventName"));
}
else
{
Career.EventOpportunity opportunityEvent = obj as Career.EventOpportunity;
// new Code
if ((opportunityEvent != null) && (opportunityEvent.mOpportunity == OpportunityNames.Undefined))
{
opportunityEvent.mOpportunity = unchecked ((OpportunityNames)ResourceUtils.HashString64(str4));
}
Career.EventDaily dailyEvent = obj as Career.EventDaily;
if (dailyEvent != null)
{
if (dailyEvent.AvailableLevels(career).Count == 0)
{
BooterLogger.AddError(eventsFile + ": No AvailableLevels " + row.GetString("EventType"));
}
else
{
// new Code
if (dailyEvent.mEventType == Career.CareerEventType.None)
{
dailyEvent.mEventType = unchecked ((Career.CareerEventType)ResourceUtils.HashString64(row.GetString("EventType")));
}
if (career.SharedData == null)
{
BooterLogger.AddError(eventsFile + ": Career SharedData missing " + career.mCareerGuid);
}
else
{
if (flag)
{
career.SharedData.SureShotEvent = dailyEvent;
}
else
{
career.SharedData.CareerEventList.Add(dailyEvent);
try
{
CareerEventManager.sAllEvents.Add(dailyEvent.EventType, dailyEvent);
}
catch
{
BooterLogger.AddError(eventsFile + ": Duplicate Event " + row.GetString("EventType"));
}
}
}
}
}
else
{
BooterLogger.AddError(eventsFile + ": Not EventDaily " + row.GetString("EventType"));
}
}
}
}
}
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"));
}
}
}
