public void OnWorldLoadFinished()
{
try
{
Managers.ManagerCareer.RetiredLocation = null;
Career staticCareer = CareerManager.GetStaticCareer(CareerGuid);
if (staticCareer == null)
{
return;
}
foreach (RabbitHole hole in RabbitHole.GetRabbitHolesOfType(RabbitHoleType.CityHall))
{
CareerLocation location = new CareerLocation(hole, staticCareer);
if (!hole.CareerLocations.ContainsKey((ulong)staticCareer.Guid))
{
hole.CareerLocations.Add((ulong)staticCareer.Guid, location);
if (location.Career != null)
{
Managers.ManagerCareer.RetiredLocation = location;
}
}
}
}
catch (Exception exception)
{
Common.Exception("Retired WorldLoadFinished", exception);
}
}
public void SetDefaults(OccupationNames name)
{
Career career = CareerManager.GetStaticCareer(name);
if (career != null)
{
foreach (string branch in career.CareerLevels.Keys)
{
if (branch != mBranch)
{
continue;
}
foreach (KeyValuePair <int, CareerLevel> level in career.CareerLevels[branch])
{
if (level.Key == mLevel)
{
CareerLevelSettings settings = new CareerLevelSettings();
settings.mBranch = mBranch;
settings.mLevel = mLevel;
settings.mPayPerHourBase = level.Value.PayPerHourBase;
settings.mCarpoolType = level.Value.CarpoolType;
mDefaults = settings;
}
}
}
}
}
// this could be further broken down into another class (IntegerSettingOption) but not right now
protected override OptionResult Run(GameHitParameters <GameObject> parameters)
{
OptionResult result = base.Run(parameters);
if (result != OptionResult.Failure)
{
foreach (OccupationNames name in base.mPicks)
{
string defaultText = string.Empty;
if (name != OccupationNames.Any)
{
NRaas.CareerSpace.PersistedSettings.CareerSettings settings = NRaas.Careers.Settings.GetCareerSettings(name, true);
defaultText = settings.mMaxCoworkers.ToString();
}
string text = StringInputDialog.Show(Name, Common.Localize(GetTitlePrefix() + ":Prompt", false), defaultText);
if (string.IsNullOrEmpty(text))
{
return(OptionResult.Failure);
}
int value;
if (!int.TryParse(text, out value))
{
SimpleMessageDialog.Show(Name, Common.Localize("InputError:Numeric"));
return(OptionResult.Failure);
}
if (name == OccupationNames.Any)
{
foreach (Career career in CareerManager.CareerList)
{
PersistedSettings.CareerSettings settings = NRaas.Careers.Settings.GetCareerSettings(career.Guid, true);
settings.mMaxCoworkers = value;
NRaas.Careers.Settings.SetCareerData(settings);
}
Common.Notify(GetTitlePrefix() + " " + Common.Localize("Selection:All") + " " + value);
}
else
{
PersistedSettings.CareerSettings settings = NRaas.Careers.Settings.GetCareerSettings(name, true);
settings.mMaxCoworkers = value;
NRaas.Careers.Settings.SetCareerData(settings);
Common.Notify(GetTitlePrefix() + " " + CareerManager.GetStaticCareer(name).Name + " " + value);
}
}
Common.Notify(Common.Localize("Generic:Success"));
return(OptionResult.SuccessLevelDown);
}
return(result);
}
protected CareerLocation FindClosestCareerLocation(SimDescription s, OccupationNames careerName)
{
if (s.Household == null)
{
IncStat("No Household");
return(null);
}
Career staticCareer = CareerManager.GetStaticCareer(careerName);
if (staticCareer == null)
{
IncStat("Career Fail");
return(null);
}
Lot lotHome = s.Household.LotHome;
if (lotHome == null)
{
if (staticCareer.Locations.Count > 0x0)
{
return(RandomUtil.GetRandomObjectFromList <CareerLocation>(staticCareer.Locations));
}
else
{
IncStat("No Lot Home");
return(null);
}
}
CareerLocation location = null;
float bestDistance = float.MaxValue;
float distanceToObject = 0f;
foreach (CareerLocation location2 in staticCareer.Locations)
{
if (!GetLotOptions(location2.Owner.LotCurrent).AllowCastes(this, s))
{
continue;
}
distanceToObject = lotHome.GetDistanceToObject(location2.Owner.RabbitHoleProxy);
if (distanceToObject < bestDistance)
{
location = location2;
bestDistance = distanceToObject;
}
}
return(location);
}
public override void OnStartup()
{
base.OnStartup();
if (mOriginalLevelData == null)
{
Unemployed staticCareer = CareerManager.GetStaticCareer(Guid) as Unemployed;
if (staticCareer != null)
{
mOriginalLevelData = staticCareer.mOriginalLevelData;
}
}
UpdateName(mName);
}
public void SetDefaults()
{
Career career = CareerManager.GetStaticCareer(mName);
if (career != null)
{
CareerSettings settings = new CareerSettings();
settings.mName = mName;
settings.mMinCoworkers = career.SharedData.MinCoworkers;
settings.mMaxCoworkers = career.SharedData.MaxCoworkers;
mDefaults = settings;
}
}
public void SetCareerData(CareerSettings settings)
{
if (settings != null)
{
if (settings.mName == OccupationNames.Any)
{
foreach (Career career in CareerManager.CareerList)
{
career.SharedData.MinCoworkers = settings.mMinCoworkers;
career.SharedData.MaxCoworkers = settings.mMaxCoworkers;
}
}
else
{
Career career = CareerManager.GetStaticCareer(settings.mName);
if (career != null)
{
career.SharedData.MinCoworkers = settings.mMinCoworkers;
career.SharedData.MaxCoworkers = settings.mMaxCoworkers;
foreach (string branch in career.CareerLevels.Keys)
{
foreach (KeyValuePair <int, Sims3.Gameplay.Careers.CareerLevel> levelData in career.CareerLevels[branch])
{
CareerLevelSettings levelSettings = settings.GetSettingsForLevel(branch, levelData.Key, false);
if (levelSettings != null)
{
levelData.Value.PayPerHourBase = levelSettings.mPayPerHourBase;
levelData.Value.CarpoolType = levelSettings.mCarpoolType;
}
}
}
}
}
foreach (Sim sim in LotManager.Actors)
{
if (sim.Occupation != null)
{
sim.Occupation.RescheduleCarpool();
}
}
}
}
public override bool OnLoadFixup(bool isQuitCareer)
{
try
{
SchoolElementaryEx staticCareer = CareerManager.GetStaticCareer(Guid) as SchoolElementaryEx;
if (staticCareer != null)
{
mOther = staticCareer.mOther;
}
return(base.OnLoadFixup(isQuitCareer));
}
catch (Exception e)
{
Common.Exception(OwnerDescription, e);
return(false);
}
}
public void OnPreLoad()
{
try
{
Career music = CareerManager.GetStaticCareer(OccupationNames.Music);
if (music == null)
{
return;
}
BooterLogger.AddTrace("Replace Metric Music Skill");
foreach (Dictionary <int, CareerLevel> value in music.CareerLevels.Values)
{
foreach (CareerLevel level in value.Values)
{
List <PerfMetric> metrics = new List <PerfMetric>(level.Metrics);
foreach (PerfMetric metric in metrics)
{
MetricSkillX skillMetric = metric as MetricSkillX;
if (skillMetric == null)
{
continue;
}
if (skillMetric.SkillGuid == SkillNames.Guitar)
{
BooterLogger.AddTrace("Metric Replaced: " + level.BranchName + " " + level.Level);
level.Metrics.Remove(metric);
level.Metrics.Add(new MetricMusicSkill(skillMetric));
}
}
}
}
}
catch (Exception e)
{
Common.Exception("OnPreLoad", e);
}
}
public void RevertToDefault()
{
if (mDefaults != null)
{
Career career = CareerManager.GetStaticCareer(mName);
if (career != null)
{
career.SharedData.MinCoworkers = mDefaults.mMinCoworkers;
career.SharedData.MaxCoworkers = mDefaults.mMaxCoworkers;
}
foreach (KeyValuePair <string, Dictionary <int, CareerLevelSettings> > settings in mLevelSettings)
{
foreach (KeyValuePair <int, CareerLevelSettings> settings2 in settings.Value)
{
settings2.Value.RevertToDefaults(mName);
}
}
}
}
public void OnWorldLoadFinished()
{
foreach (CareerBooterElement element in sCareers)
{
Career staticCareer = CareerManager.GetStaticCareer(element.mCareer);
if (staticCareer == null)
{
continue;
}
string lotDesignator = null;
ILotDesignator lotDesignatorClass = staticCareer as ILotDesignator;
if (lotDesignatorClass != null)
{
lotDesignator = lotDesignatorClass.LotDesignator;
}
foreach (RabbitHole hole in RabbitHole.GetRabbitHolesOfType(element.mType))
{
if (!string.IsNullOrEmpty(lotDesignator))
{
if (hole.LotCurrent == null)
{
continue;
}
if (!hole.LotCurrent.Name.Contains(lotDesignator))
{
continue;
}
}
CareerLocation location = new CareerLocation(hole, staticCareer);
if (!hole.CareerLocations.ContainsKey((ulong)staticCareer.Guid))
{
hole.CareerLocations.Add((ulong)staticCareer.Guid, location);
}
}
}
}
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 List <CareerLevelItem> GetLevelOptions(OccupationNames career)
{
List <CareerLevelItem> results = new List <CareerLevelItem>();
Career career2 = CareerManager.GetStaticCareer(career);
if (career2 == null)
{
return(results);
}
results.Add(new CareerLevelItem(new LevelData(career, string.Empty, -1), Common.Localize("Selection:All"), ThumbnailKey.kInvalidThumbnailKey));
foreach (KeyValuePair <string, Dictionary <int, Sims3.Gameplay.Careers.CareerLevel> > staticData in career2.CareerLevels)
{
foreach (KeyValuePair <int, Sims3.Gameplay.Careers.CareerLevel> levelStaticData in staticData.Value)
{
results.Add(new CareerLevelItem(new LevelData(career, staticData.Key, levelStaticData.Key), career2.Name + " - " + levelStaticData.Value.BranchName + " - " + Common.LocalizeEAString(false, levelStaticData.Value.mName) + " (" + EAText.GetNumberString(levelStaticData.Key) + ")", new ThumbnailKey(ResourceKey.CreatePNGKey(career2.CareerIconColored, ResourceUtils.ProductVersionToGroupId(ProductVersion.BaseGame)), ThumbnailSize.Medium)));
}
}
return(results);
}
public void SetCareerData(CareerSettings settings)
{
if (settings != null)
{
if (settings.mName == OccupationNames.Any)
{
foreach (Career career in CareerManager.CareerList)
{
career.SharedData.MinCoworkers = settings.minCoworkers;
career.SharedData.MaxCoworkers = settings.maxCoworkers;
}
}
else
{
Career career = CareerManager.GetStaticCareer(settings.mName);
if (career != null)
{
career.SharedData.MinCoworkers = settings.minCoworkers;
career.SharedData.MaxCoworkers = settings.maxCoworkers;
}
}
}
}
public void RevertToDefaults(OccupationNames name)
{
Career career = CareerManager.GetStaticCareer(name);
if (career != null && mDefaults != null)
{
foreach (string branch in career.CareerLevels.Keys)
{
if (branch != mBranch)
{
continue;
}
foreach (KeyValuePair <int, CareerLevel> level in career.CareerLevels[branch])
{
if (level.Key == mLevel)
{
level.Value.PayPerHourBase = mDefaults.mPayPerHourBase;
level.Value.CarpoolType = mDefaults.mCarpoolType;
}
}
}
}
}
// this could be further broken down into another class (IntegerSettingOption) but not right now
protected override OptionResult Run(GameHitParameters <GameObject> parameters)
{
OptionResult result = base.Run(parameters);
if (result != OptionResult.Failure)
{
string defaultPay = string.Empty;
if (base.mPicks.Count == 1)
{
CareerLevelSettingOption.LevelData data = base.mPicks[0];
if (data.mLevel != -1)
{
Career career = CareerManager.GetStaticCareer(data.mCareer);
if (career != null)
{
defaultPay = career.CareerLevels[data.mBranchName][data.mLevel].PayPerHourBase.ToString();
}
}
}
string text = StringInputDialog.Show(Name, Common.Localize(GetTitlePrefix() + ":Prompt", false), defaultPay); // def
if (string.IsNullOrEmpty(text))
{
return(OptionResult.Failure);
}
int value;
if (!int.TryParse(text, out value))
{
SimpleMessageDialog.Show(Name, Common.Localize("InputError:Numeric"));
return(OptionResult.Failure);
}
foreach (CareerLevelSettingOption.LevelData level in base.mPicks)
{
if (level.mLevel == -1)
{
foreach (Career career in CareerManager.CareerList)
{
foreach (string branch in career.CareerLevels.Keys)
{
foreach (KeyValuePair <int, Sims3.Gameplay.Careers.CareerLevel> levelData in career.CareerLevels[branch])
{
PersistedSettings.CareerSettings settings = NRaas.Careers.Settings.GetCareerSettings(level.mCareer, true);
PersistedSettings.CareerLevelSettings levelSettings = settings.GetSettingsForLevel(level.mBranchName, level.mLevel, true);
levelSettings.mPayPerHourBase = value;
levelData.Value.PayPerHourBase = value;
}
}
}
}
else
{
PersistedSettings.CareerSettings settings = NRaas.Careers.Settings.GetCareerSettings(level.mCareer, true);
PersistedSettings.CareerLevelSettings levelSettings = settings.GetSettingsForLevel(level.mBranchName, level.mLevel, true);
levelSettings.mPayPerHourBase = value;
NRaas.Careers.Settings.SetCareerData(settings);
}
}
Common.Notify(Common.Localize("Generic:Success"));
return(OptionResult.SuccessLevelDown);
}
return(result);
}
protected override bool Allow(OccupationNames value)
{
School school = CareerManager.GetStaticCareer(value) as School;
return(school != null);
}
protected override bool PrivateUpdate(ScenarioFrame frame)
{
if (Sim.AssignedRole != null)
{
if (ManagerCareer.IsRegisterInstalled())
{
if ((Sim.LotHome == null) && (Sim.Occupation == null))
{
IncStat("Registered Retiremenet");
GetData <CareerSimData>(Sim).Retire();
}
}
return(true);
}
else if (SimTypes.IsSpecial(Sim))
{
IncStat("Special");
return(false);
}
bool enroll = false;
if (GameUtils.IsUniversityWorld())
{
enroll = true;
}
else if (Careers.TestCareer(this, Sim, OccupationNames.AcademicCareer))
{
if (Careers.AllowHomeworldUniversity(Sim))
{
AcademicDegreeManager degreeManager = Sim.CareerManager.DegreeManager;
if (degreeManager != null)
{
if (!degreeManager.HasCompletedAnyDegree())
{
enroll = true;
}
}
}
}
if (!mForce)
{
if (GetValue <ManualCareerOption, bool>(Sim))
{
IncStat("Manual");
return(false);
}
}
List <OccupationNames> careers = new List <OccupationNames>();
bool dream = Careers.GetPotentialCareers(this, Sim, careers, mCheckQuit);
bool partTime = false;
if (Sim.Teen)
{
bool scoreSuccess = true;
if (mForce)
{
if (AddScoring("FindJob", Sim) < 0)
{
scoreSuccess = false;
}
}
else
{
if (AddScoring("ChanceFindJob", Sim) < 0)
{
scoreSuccess = false;
}
}
if ((!scoreSuccess) && (!GetValue <ForceTeensOption, bool>()))
{
IncStat("Score Fail");
return(false);
}
partTime = true;
}
if (partTime)
{
List <OccupationNames> partTimeList = new List <OccupationNames>();
AddStat(Sim.Age + ": Part-time Choices", careers.Count);
foreach (OccupationNames career in careers)
{
Career staticCareer = CareerManager.GetStaticCareer(career);
if (staticCareer == null)
{
continue;
}
if (staticCareer is School)
{
continue;
}
CareerLocation location = Career.FindClosestCareerLocation(Sim, staticCareer.Guid);
if (location == null)
{
continue;
}
if (!AllowStandalone(location))
{
continue;
}
foreach (CareerLocation loc in location.Owner.CareerLocations.Values)
{
Career possible = loc.Career;
if (!possible.IsPartTime)
{
continue;
}
if (ManagerCareer.IsPlaceholderCareer(possible))
{
continue;
}
partTimeList.Add(possible.Guid);
}
}
careers = partTimeList;
AddStat(Sim.Age + ": Part-time Final", careers.Count);
}
else
{
AddStat(Sim.Age + ": Full-time Final", careers.Count);
}
if ((!mForce) && (!dream) && (Sim.Occupation != null) && (!(Sim.Occupation is Retired)))
{
IncStat("Non-Dream Employed");
return(false);
}
if (enroll)
{
AcademicDegreeNames degreeName = AcademicDegreeNames.Undefined;
foreach (DreamJob job in ManagerCareer.GetDreamJob(Sim))
{
if (job == null)
{
continue;
}
foreach (AcademicDegreeStaticData data in AcademicDegreeManager.sDictionary.Values)
{
if (data.AssociatedOccupations.Contains(job.mCareer))
{
degreeName = data.AcademicDegreeName;
break;
}
}
}
if (degreeName == AcademicDegreeNames.Undefined)
{
degreeName = AcademicDegreeManager.ChooseWeightRandomSuitableDegree(Sim);
}
if (!Careers.IsDegreeAllowed(Manager, Sim, degreeName))
{
degreeName = Careers.GetAllowedDegree(Manager, Sim);
}
if (degreeName != AcademicDegreeNames.Undefined)
{
if (AcademicCareer.GlobalTermLength == AcademicCareer.TermLength.kInvalid)
{
AcademicCareer.GlobalTermLength = AcademicCareer.TermLength.kOneWeek;
}
AcademicCareer.EnrollSimInAcademicCareer(Sim, degreeName, AcademicCareer.ChooseRandomCoursesPerDay());
return(true);
}
}
bool promptForJob = GetValue <ChooseCareerOption, bool>();
if ((promptForJob) && (!Careers.MatchesAlertLevel(Sim)))
{
promptForJob = false;
}
if (careers.Count > 0)
{
if ((Sim.Occupation != null) && (careers.Contains(Sim.Occupation.Guid)))
{
IncStat("Already Has Choice");
return(false);
}
if (!promptForJob)
{
if (AskForJob(Sim, RandomUtil.GetRandomObjectFromList(careers)))
{
return(true);
}
}
}
if ((!mForce) && (Sim.Occupation != null))
{
IncStat("Already Employed");
return(false);
}
List <Occupation> allCareers = null;
if (careers.Count > 0)
{
allCareers = new List <Occupation>();
foreach (Career career in CareerManager.CareerList)
{
if (careers.Contains(career.Guid))
{
allCareers.Add(career);
}
}
}
if ((allCareers == null) || (allCareers.Count == 0))
{
if (Sim.LifetimeWish == (uint)LifetimeWant.JackOfAllTrades)
{
allCareers = GetChoices(true);
}
}
if ((allCareers == null) || (allCareers.Count == 0))
{
allCareers = GetChoices(false);
}
if (allCareers.Count > 0)
{
AddStat("Random Choices", allCareers.Count);
if ((promptForJob) && (AcceptCancelDialog.Show(ManagerSim.GetPersonalInfo(Sim, Common.Localize("ChooseCareer:Prompt", Sim.IsFemale)))))
{
List <JobItem> jobs = new List <JobItem>();
foreach (Occupation career in GetChoices(false))
{
jobs.Add(new JobItem(career, allCareers.Contains(career)));
}
bool okayed;
JobItem choice = new CommonSelection <JobItem>(Common.Localize("ChooseCareer:Header", Sim.IsFemale), Sim.FullName, jobs, new JobPreferenceColumn()).SelectSingle(out okayed);
if (!okayed)
{
return(false);
}
if (choice != null)
{
allCareers.Clear();
allCareers.Add(choice.Value);
SetValue <ManualCareerOption, bool>(Sim, true);
}
}
while (allCareers.Count > 0)
{
Occupation choice = RandomUtil.GetRandomObjectFromList(allCareers);
allCareers.Remove(choice);
if (choice != null)
{
if (AskForJob(Sim, choice))
{
return(true);
}
}
}
IncStat("Ask Failure");
return(false);
}
else
{
if (promptForJob)
{
Common.Notify(Common.Localize("ChooseCareer:PromptFailure", Sim.IsFemale, new object[] { Sim }));
}
IncStat("No Applicable");
return(false);
}
}
public static void OnAccepted(Sim actor, Sim target, string interaction, ActiveTopic topic, InteractionInstance i)
{
try
{
OccupationNames careerName = actor.Occupation.Guid;
bool success = false;
if (target.Occupation == null)
{
Career career = CareerManager.GetStaticCareer(careerName);
if (career == null)
{
return;
}
string branch = actor.Occupation.CurLevelBranchName;
CareerLocation location = Career.FindClosestCareerLocation(target.SimDescription, careerName);
if (location == null)
{
return;
}
if (target.SimDescription.AcquireOccupation(new AcquireOccupationParameters(location, false, false)))
{
success = true;
}
}
else
{
int level = 1;
if (target.Occupation.Guid == actor.Occupation.Guid)
{
Career actorCareer = actor.Occupation as Career;
CareerLevel curLevel = actorCareer.CurLevel;
while (curLevel.LastLevel != null)
{
curLevel = curLevel.LastLevel;
if (curLevel.NextLevels.Count > 1)
{
break;
}
}
if (curLevel != null)
{
level = curLevel.Level;
}
}
Career staticCareer = CareerManager.GetStaticCareer(careerName);
if ((target.Occupation != null) && (careerName != OccupationNames.Undefined) && (actor.Occupation.CurLevelBranchName != null) && (staticCareer != null))
{
target.Occupation.LeaveJob(Career.LeaveJobReason.kTransfered);
CareerLocation location = Career.FindClosestCareerLocation(target.SimDescription, staticCareer.Guid);
if (location != null)
{
CareerLevel careerLevel = null;
if (actor.Occupation.CurLevelBranchName != null)
{
Dictionary <int, CareerLevel> dictionary = null;
if (staticCareer.CareerLevels.TryGetValue(actor.Occupation.CurLevelBranchName, out dictionary))
{
dictionary.TryGetValue(level, out careerLevel);
}
}
if (careerLevel == null)
{
foreach (Dictionary <int, CareerLevel> dictionary2 in staticCareer.CareerLevels.Values)
{
if (dictionary2.TryGetValue(level, out careerLevel))
{
break;
}
}
}
if (careerLevel != null)
{
Occupation staticOccupation = CareerManager.GetStaticOccupation(actor.Occupation.Guid);
if (staticOccupation != null)
{
staticOccupation.DoTransferOfOccupation(target.SimDescription, careerLevel.BranchName, careerLevel.Level);
success = true;
}
}
}
}
}
if (success)
{
OmniCareer job = actor.Occupation as OmniCareer;
if (job != null)
{
job.AddToRecruits();
}
}
}
catch (Exception e)
{
Common.Exception(actor, target, e);
}
}
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"));
}
}
}
protected override List <CareerLocation> GetPotentials()
{
List <OccupationNames> careers = new List <OccupationNames>();
bool dream = Careers.GetPotentialCareers(this, Sim, careers, false);
List <CareerLocation> dreamSchools = new List <CareerLocation>();
foreach (OccupationNames career in careers)
{
Career staticJob = CareerManager.GetStaticCareer(career);
if (staticJob == null)
{
continue;
}
CareerLocation jobLocation = FindClosestCareerLocation(Sim, staticJob.Guid);
if (jobLocation == null)
{
continue;
}
if (jobLocation.Owner == null)
{
continue;
}
if (jobLocation.Owner.CareerLocations == null)
{
continue;
}
foreach (CareerLocation schoolLoc in jobLocation.Owner.CareerLocations.Values)
{
School staticSchool = schoolLoc.Career as School;
if (staticSchool == null)
{
continue;
}
if (HasValue <DisallowCareerOption, OccupationNames>(Sim, staticSchool.Guid))
{
continue;
}
if (HasValue <PublicAssignSchoolScenario.ConsiderPublicOption, OccupationNames>(staticSchool.Guid))
{
continue;
}
// Disallow home schooling at this point
if ((staticSchool.Level1 == null) || (staticSchool.Level1.DayLength == 0))
{
continue;
}
if (staticSchool is SchoolHigh)
{
if (career == OccupationNames.SchoolHigh)
{
continue;
}
if (!Sim.Teen)
{
continue;
}
}
else if (staticSchool is SchoolElementary)
{
if (career == OccupationNames.SchoolElementary)
{
continue;
}
if (!Sim.Child)
{
continue;
}
}
else
{
if (!staticJob.CareerAgeTest(Sim))
{
continue;
}
}
CareerLocation location = FindClosestCareerLocation(Sim, staticSchool.Guid);
if (location == null)
{
continue;
}
dreamSchools.Add(location);
}
}
AddStat("Dream Schools", dreamSchools.Count);
if ((GetValue <PromptToAssignSchoolOption, bool>()) && (Careers.MatchesAlertLevel(Sim)))
{
List <FindJobScenario.JobItem> items = new List <FindJobScenario.JobItem>();
bool found = false;
foreach (Career career in CareerManager.CareerList)
{
if (career is SchoolHigh)
{
if (!Sim.Teen)
{
continue;
}
if (career.Guid != OccupationNames.SchoolHigh)
{
found = true;
}
}
else if (career is SchoolElementary)
{
if (!Sim.Child)
{
continue;
}
if (career.Guid != OccupationNames.SchoolElementary)
{
found = true;
}
}
else if (career is School)
{
if (!career.CareerAgeTest(Sim))
{
continue;
}
if ((career.Level1 != null) && (career.Level1.DayLength != 0))
{
found = true;
}
}
else
{
continue;
}
if (HasValue <DisallowCareerOption, OccupationNames>(Sim, career.Guid))
{
continue;
}
if (HasValue <PublicAssignSchoolScenario.ConsiderPublicOption, OccupationNames>(career.Guid))
{
continue;
}
CareerLocation location = FindClosestCareerLocation(Sim, career.Guid);
if (location == null)
{
continue;
}
items.Add(new FindJobScenario.JobItem(location.Career, dreamSchools.Contains(location)));
}
FindJobScenario.JobItem choice = null;
if ((items.Count > 1) && (found))
{
if (AcceptCancelDialog.Show(ManagerSim.GetPersonalInfo(Sim, Common.Localize("RichAssignSchool:Prompt", Sim.IsFemale))))
{
choice = new CommonSelection <FindJobScenario.JobItem>(Common.Localize("ChooseCareer:Header", Sim.IsFemale), Sim.FullName, items, new FindJobScenario.JobPreferenceColumn()).SelectSingle();
}
}
else if (items.Count == 1)
{
Career career = items[0].Value as Career;
// Do not auto-enroll sims in home-schooling
if ((career.Level1 != null) && (career.Level1.DayLength != 0))
{
choice = items[0];
}
}
if (choice != null)
{
SetValue <ManualSchoolOption, bool>(Sim, true);
dreamSchools.Clear();
CareerLocation location = FindClosestCareerLocation(Sim, choice.Value.Guid);
if (location != null)
{
dreamSchools.Add(location);
}
}
}
if (dreamSchools.Count == 0)
{
IncStat("Random");
foreach (Career career in CareerManager.CareerList)
{
if (career is SchoolHigh)
{
if (!Sim.Teen)
{
continue;
}
}
else if (career is SchoolElementary)
{
if (!Sim.Child)
{
continue;
}
}
else
{
continue;
}
if (HasValue <DisallowCareerOption, OccupationNames>(Sim, career.Guid))
{
continue;
}
if (HasValue <PublicAssignSchoolScenario.ConsiderPublicOption, OccupationNames>(career.Guid))
{
continue;
}
CareerLocation location = FindClosestCareerLocation(Sim, career.Guid);
if (location == null)
{
continue;
}
if (location.Owner == null)
{
continue;
}
dreamSchools.Add(location);
}
/*
* if (dreamSchools.Count < 4)
* {
* IncStat("Too Few");
*
* dreamSchools.Clear();
* }*/
}
return(dreamSchools);
}
