コード例 #1
0
        public static void Enroll(List <SimDescription> sims)
        {
            bool promptShown = false;

            foreach (SimDescription sim in sims)
            {
                if (sim.Occupation != null)
                {
                    sim.Occupation.LeaveJob(false, Career.LeaveJobReason.kJobBecameInvalid);
                }

                AcademicCareer.EnrollSimInAcademicCareer(sim, sim.CareerManager.DegreeManager.EnrollmentAcademicDegreeName, sim.CareerManager.DegreeManager.EnrollmentCouseLoad);
                if (!promptShown)
                {
                    string becameAStudentTnsText = sim.OccupationAsAcademicCareer.GetBecameAStudentTnsText();
                    if (!string.IsNullOrEmpty(becameAStudentTnsText))
                    {
                        sim.Occupation.ShowOccupationTNS(becameAStudentTnsText, false);
                    }
                    promptShown = true;
                }

                CustomAcademicDegrees.AdjustCustomAcademics(sim);
            }
        }
コード例 #2
0
ファイル: AssignAcademic.cs プロジェクト: yakoder/NRaas
        protected override OptionResult RunAll(List <IMiniSimDescription> sims)
        {
            List <SimDescription> trueSims = new List <SimDescription>();

            foreach (IMiniSimDescription miniSim in sims)
            {
                SimDescription trueSim = miniSim as SimDescription;
                if (trueSim == null)
                {
                    continue;
                }

                trueSims.Add(trueSim);
            }

            int termLen   = 0;
            int totalCost = 0;

            List <IEnrollmentData> list = EnrollmentDialogEx.Show(trueSims[0], trueSims, true, out termLen, out totalCost);

            if ((list != null) && (list.Count > 0))
            {
                AcademicCareer.GlobalTermLength = (AcademicCareer.TermLength)termLen;

                foreach (IEnrollmentData data in list)
                {
                    SimDescription enrollingSimDesc = data.EnrollingSimDesc as SimDescription;
                    if ((enrollingSimDesc != null) &&
                        (enrollingSimDesc.CareerManager != null) &&
                        (enrollingSimDesc.CareerManager.DegreeManager != null))
                    {
                        enrollingSimDesc.CareerManager.DegreeManager.SetEnrollmentData(data);

                        if (enrollingSimDesc.CreatedSim != null)
                        {
                            EventTracker.SendEvent(new AcademicEvent(EventTypeId.kEnrolledInUniversity, enrollingSimDesc.CreatedSim, (AcademicDegreeNames)data.AcademicDegreeName));
                        }

                        AcademicCareer.EnrollSimInAcademicCareer(enrollingSimDesc, (AcademicDegreeNames)data.AcademicDegreeName, data.CourseLoad);

                        CustomAcademicDegrees.AdjustCustomAcademics(enrollingSimDesc);
                    }
                }
            }

            return(OptionResult.SuccessRetain);
        }
コード例 #3
0
ファイル: ChooseCareerOption.cs プロジェクト: yakoder/NRaas
        protected static bool AcquireOccupation(CareerManager ths, AcquireOccupationParameters occupationParameters, bool prompt)
        {
            CareerLocation  location   = occupationParameters.Location;
            OccupationNames newJobGuid = occupationParameters.TargetJob;

            if ((ths.mJob != null) && (location != null) && (ths.mJob.Guid == location.Career.Guid) && (ths.mJob.CareerLoc != location))
            {
                Career mJob = ths.mJob as Career;
                return((mJob != null) && mJob.TransferBetweenCareerLocations(location, false));
            }

            Occupation occupation = null;

            if (!ths.TryGetNewCareer(newJobGuid, out occupation))
            {
                return(false);
            }

            if (occupation is Career)
            {
                if (location == null)
                {
                    return(false);
                }
            }

            Sim createdSim = ths.mSimDescription.CreatedSim;

            if (ths.mJob != null)
            {
                if (prompt)
                {
                    string newJobName = string.Empty;
                    if (!occupation.TryDisplayingGetHiredUi(location, ref occupationParameters, out newJobName))
                    {
                        return(false);
                    }

                    if (!Occupation.ShowYesNoCareerOptionDialog(Common.LocalizeEAString(ths.mSimDescription.IsFemale, "Gameplay/Careers/Career:ConfirmLeavingOldCareer", new object[] { ths.mSimDescription, occupation.CareerName, ths.mJob.CareerName })))
                    {
                        return(false);
                    }
                }

                if (createdSim != null)
                {
                    EventTracker.SendEvent(new TransferCareerEvent(createdSim, ths.mJob, occupation));
                }
                ths.mJob.LeaveJob(false, Career.LeaveJobReason.kTransfered);
            }

            if (newJobGuid == OccupationNames.AcademicCareer)
            {
                AcademicCareer.EnrollSimInAcademicCareer(ths.mSimDescription, ths.DegreeManager.EnrollmentAcademicDegreeName, ths.DegreeManager.EnrollmentCouseLoad);
            }
            else
            {
                EventTracker.SendEvent(EventTypeId.kCareerNewJob, createdSim);
                occupation.OwnerDescription        = ths.mSimDescription;
                occupation.mDateHired              = SimClock.CurrentTime();
                occupation.mAgeWhenJobFirstStarted = ths.mSimDescription.Age;

                occupation.SetAttributesForNewJob(location, occupationParameters.LotId, occupationParameters.CharacterImportRequest);

                EventTracker.SendEvent(new CareerEvent(EventTypeId.kEventCareerHired, occupation));
                EventTracker.SendEvent(new CareerEvent(EventTypeId.kEventCareerChanged, occupation));
                EventTracker.SendEvent(new CareerEvent(EventTypeId.kCareerDataChanged, occupation));
            }

            occupation.RefreshMapTagForOccupation();
            ths.UpdateCareerUI();

            if ((createdSim != null) && createdSim.IsActiveSim)
            {
                HudController.SetInfoState(InfoState.Career);
            }

            return(true);
        }
コード例 #4
0
        protected override bool PrivateUpdate(ScenarioFrame frame)
        {
            Common.StringBuilder       msg = new Common.StringBuilder();
            List <AcademicDegreeNames> degreesThatNeedProfessors = new List <AcademicDegreeNames>();

            foreach (AcademicDegreeNames degree in Enum.GetValues(typeof(AcademicDegreeNames)))
            {
                if (degree == AcademicDegreeNames.Undefined || degree == AcademicDegreeNames.MaxDegreeNames)
                {
                    continue;
                }

                if (AcademicCareer.sProfessors != null)
                {
                    if (AcademicCareer.sProfessors.ContainsKey(degree) && SimDescription.Find(AcademicCareer.sProfessors[degree]) != null)
                    {
                        continue;
                    }
                }

                msg += "DegreesThatNeedProfessors: " + degree + Common.NewLine;
                degreesThatNeedProfessors.Add(degree);
            }

            if (degreesThatNeedProfessors.Count == 0)
            {
                Common.DebugNotify("No professors needed");
                return(false);
            }

            List <SimDescription>      possibleProfessors    = new List <SimDescription>();
            List <AcademicDegreeNames> degreesWithEnrollment = new List <AcademicDegreeNames>();

            // Sims who have completed X degree

            foreach (SimDescription sim in Sims.Humans)
            {
                msg += Common.NewLine + "Sim: " + sim.FullName;
                if (sim.CareerManager == null)
                {
                    msg += Common.NewLine + "CareerManager null";
                    continue;
                }

                if (sim.ChildOrBelow)
                {
                    msg += Common.NewLine + "ChildOrBelow";
                    continue;
                }

                if (SimTypes.IsSpecial(sim))
                {
                    msg += Common.NewLine + "IsSpecial";
                    continue;
                }

                if (sim.Occupation != null)
                {
                    msg += Common.NewLine + "Employed";
                    if (sim.CareerManager.Occupation is StoryProgressionSpace.Careers.Retired && !GetValue <AllowRetiredElder, bool>())
                    {
                        msg += Common.NewLine + "Retire skip";
                        continue;
                    }

                    if (sim.OccupationAsAcademicCareer == null && !GetValue <AllowQuitOccupation, bool>())
                    {
                        msg += Common.NewLine + "AllowQuitOccupation skip";
                        continue;
                    }

                    AcademicCareer career = sim.OccupationAsAcademicCareer;
                    if (career != null && career.Level == 2)
                    {
                        msg += Common.NewLine + "AlreadyProfessor";
                        continue;
                    }

                    if (career != null && career.DegreeInformation != null && degreesThatNeedProfessors.Contains(career.DegreeInformation.AcademicDegreeName))
                    {
                        if (!degreesWithEnrollment.Contains(career.DegreeInformation.AcademicDegreeName))
                        {
                            // note this isn't added to unless it needs a professor
                            msg += Common.NewLine + "DegreesWithEnrollment: " + career.DegreeInformation.AcademicDegreeName;
                            degreesWithEnrollment.Add(career.DegreeInformation.AcademicDegreeName);
                        }
                    }
                }
                else
                {
                    msg += Common.NewLine + "Unemployed";
                }

                if (sim.Teen || !GetValue <AllowBeProfessorOption, bool>(sim))
                {
                    msg += Common.NewLine + "Teen or !AllowBeProfessor";
                    continue;
                }

                if (!Careers.AllowFindJob(this, sim))
                {
                    msg += Common.NewLine + "!AllowFindJob";
                    continue;
                }

                if (!Careers.TestCareer(this, sim, OccupationNames.AcademicCareer))
                {
                    msg += Common.NewLine + "!TestCareer";
                    continue;
                }

                if (sim.Household != null && sim.Household != Household.ActiveHousehold)
                {
                    msg += Common.NewLine + "PossibleProfessor: " + sim.FullName;
                    possibleProfessors.Add(sim);
                }
            }

            RandomUtil.RandomizeListOfObjects <SimDescription>(possibleProfessors);

            if (degreesWithEnrollment.Count == 0)
            {
                msg += Common.NewLine + "degreesWithEnrollment = 0";
                Common.DebugWriteLog(msg);
                return(false);
            }

            if (possibleProfessors.Count == 0)
            {
                msg += Common.NewLine + "possibleProfessors = 0";
                Common.DebugWriteLog(msg);
                return(false);
            }

            List <SimDescription> preferredProfessors = new List <SimDescription>();

            foreach (SimDescription pSim in new List <SimDescription>(possibleProfessors))
            {
                msg += Common.NewLine + "Promote loop: " + pSim.FullName;
                foreach (AcademicDegreeNames name in new List <AcademicDegreeNames>(degreesWithEnrollment))
                {
                    // checked because it can get removed
                    if (degreesWithEnrollment.Contains(name))
                    {
                        msg += Common.NewLine + "Degree: " + name;
                        if (pSim.OccupationAsAcademicCareer != null)
                        {
                            msg += Common.NewLine + "University Student";
                            // actively enrolled but has completed the degree we need?
                            if (pSim.CareerManager.DegreeManager != null && pSim.CareerManager.DegreeManager.HasCompletedDegree(name))
                            {
                                msg += Common.NewLine + "HCD: " + name;

                                if (pSim.OccupationAsAcademicCareer.DegreeInformation != null)
                                {
                                    // quit university for professor, use existing degree
                                    if (pSim.OccupationAsAcademicCareer.DegreeInformation.AcademicDegreeName != name)
                                    {
                                        pSim.Occupation.LeaveJobNow(Career.LeaveJobReason.kQuit);

                                        if (pSim.CreatedSim != null)
                                        {
                                            pSim.CreatedSim.InteractionQueue.CancelAllInteractionsByType(WorkInRabbitHole.Singleton);
                                        }

                                        while (pSim.Occupation != null)
                                        {
                                            Common.Sleep(5);
                                        }
                                    }

                                    AcademicCareer.EnrollSimInAcademicCareer(pSim, name, AcademicCareer.ChooseRandomCoursesPerDay());
                                    degreesWithEnrollment.Remove(name);
                                    pSim.Occupation.PromoteSim();
                                    possibleProfessors.Remove(pSim);
                                    msg += Common.NewLine + "Re-enrolling";
                                    break;
                                }
                            }
                        }
                        else
                        {
                            // not active university Sim, have they completed this degree?
                            if (pSim.CareerManager.DegreeManager != null && pSim.CareerManager.DegreeManager.HasCompletedDegree(name))
                            {
                                // they have...
                                if (pSim.Occupation != null)
                                {
                                    msg += Common.NewLine + "Quit job";
                                    pSim.Occupation.LeaveJobNow(Career.LeaveJobReason.kQuit);

                                    if (pSim.CreatedSim != null)
                                    {
                                        pSim.CreatedSim.InteractionQueue.CancelAllInteractionsByType(WorkInRabbitHole.Singleton);
                                    }

                                    while (pSim.Occupation != null)
                                    {
                                        Common.Sleep(5);
                                    }
                                }

                                bool yes = AcademicCareer.EnrollSimInAcademicCareer(pSim, name, AcademicCareer.ChooseRandomCoursesPerDay());
                                Common.Notify("Success? " + yes);
                                degreesWithEnrollment.Remove(name);
                                pSim.OccupationAsAcademicCareer.PromoteSim();
                                possibleProfessors.Remove(pSim);
                                msg += Common.NewLine + "Enrolling";
                                break;
                            }
                        }
                    }
                }

                // if we got this far they aren't in uni and haven't completed any degrees...
                if (pSim.Elder && (pSim.Occupation == null || pSim.Occupation is StoryProgressionSpace.Careers.Retired))
                {
                    preferredProfessors.Add(pSim);
                }
            }

            if (degreesWithEnrollment.Count == 0)
            {
                Common.DebugWriteLog(msg);
                return(false);
            }

            if (possibleProfessors.Count == 0)
            {
                Common.DebugWriteLog(msg);
                return(false);
            }

            int loop  = 1;
            int count = degreesWithEnrollment.Count;

            msg += Common.NewLine + "Count: " + count;
            while (loop <= count)
            {
                msg += Common.NewLine + "Loop: " + loop;
                if (degreesWithEnrollment.Count == 0 || possibleProfessors.Count == 0)
                {
                    break;
                }

                SimDescription newP;
                if (preferredProfessors.Count > 0)
                {
                    newP = RandomUtil.GetRandomObjectFromList <SimDescription>(preferredProfessors);
                    preferredProfessors.Remove(newP);
                }
                else
                {
                    newP = RandomUtil.GetRandomObjectFromList <SimDescription>(possibleProfessors);
                }

                AcademicDegreeNames enroll = RandomUtil.GetRandomObjectFromList <AcademicDegreeNames>(degreesWithEnrollment);

                msg += Common.NewLine + "Professor: " + newP.FullName;
                msg += Common.NewLine + "Degree: " + enroll;

                if (newP.Occupation != null)
                {
                    msg += Common.NewLine + "Quit Job";
                    newP.Occupation.LeaveJobNow(Career.LeaveJobReason.kQuit);

                    if (newP.CreatedSim != null)
                    {
                        newP.CreatedSim.InteractionQueue.CancelAllInteractionsByType(WorkInRabbitHole.Singleton);
                    }

                    while (newP.Occupation != null)
                    {
                        Common.Sleep(5);
                    }
                }

                bool su = AcademicCareer.EnrollSimInAcademicCareer(newP, enroll, AcademicCareer.ChooseRandomCoursesPerDay());
                degreesWithEnrollment.Remove(enroll);

                newP.OccupationAsAcademicCareer.PromoteSim();
                loop++;
                possibleProfessors.Remove(newP);
                msg += Common.NewLine + "Success ? " + su;
            }

            Common.DebugWriteLog(msg);

            return(false);
        }
コード例 #5
0
ファイル: FindJobScenario.cs プロジェクト: yakoder/NRaas
        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);
            }
        }