Пример #1
0
        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);
            }
        }
Пример #2
0
        protected override bool PrivateUpdate(ScenarioFrame frame)
        {
            int totalFunds = Sim.FamilyFunds - MinimumWealth;

            AddStat("Total Funds", totalFunds);

            List <OccupationNames> careers = new List <OccupationNames>();

            Careers.GetPotentialCareers(this, Sim, careers, false);

            List <RabbitHole> choices = new List <RabbitHole>();

            foreach (RabbitHole hole in mHoles)
            {
                if (totalFunds < hole.RabbitHoleTuning.kInvestCost)
                {
                    IncStat("Hole Too Expensive");
                    continue;
                }

                if (Sim.Household.RealEstateManager.FindProperty(hole) != null)
                {
                    IncStat("Hole Already Owned");
                    continue;
                }

                choices.Add(hole);
            }

            if (choices.Count > 0)
            {
                AddStat("Hole Choices", choices.Count);

                mRabbitHole = RandomUtil.GetRandomObjectFromList(choices);
                return(true);
            }

            List <Lot> lots = new List <Lot>();

            foreach (Lot lot in mLots)
            {
                if (totalFunds < RealEstateData.GetVenuePurchaseCost(lot))
                {
                    IncStat("Venue Too Expensive");
                    continue;
                }

                if (Sim.Household.RealEstateManager.FindProperty(lot) != null)
                {
                    IncStat("Venue Already Owned");
                    continue;
                }

                lots.Add(lot);
            }

            if (lots.Count > 0)
            {
                AddStat("Venue Choices", lots.Count);

                mLot = RandomUtil.GetRandomObjectFromList(lots);
                return(true);
            }

            IncStat("No Choices");
            return(false);
        }
Пример #3
0
        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);
        }