示例#1
0
        private static void HerdBehaviorCallback()
        {
            try
            {
                using (BaseWorldReversion reversion = new BaseWorldReversion())
                {
                    PetPool pool;
                    if (!PetPoolManager.TryGetPetPool(PetPoolType.WildHorse, out pool))
                    {
                        return;
                    }

                    WildHorsePool ths = pool as WildHorsePool;

                    ths.HerdBehaviorCallback();
                }
            }
            catch (ResetException)
            {
                throw;
            }
            catch (Exception e)
            {
                Common.Exception("HerdBehaviorCallback", e);
            }
        }
示例#2
0
        private static void SpawnAlarmCallBack()
        {
            try
            {
                if (Household.ActiveHousehold == null)
                {
                    return;
                }

                UnicornPool.sSpawnAlarm = AlarmHandle.kInvalidHandle;
                if (RandomUtil.RandomChance01(UnicornPool.kChanceOfSpawningUnicorn))
                {
                    using (BaseWorldReversion reversion = new BaseWorldReversion())
                    {
                        UnicornPool.SpawnNPCUnicorn(false);
                    }
                }
            }
            catch (Exception e)
            {
                Common.Exception("SpawnAlarmCallBack", e);
            }
        }
示例#3
0
        public void Dispose()
        {
            try
            {
                mSim.AssignedRole = mRole;

                mSim.IsNeverSelectable = mNeverSelectable;

                if (mSim.CelebrityManager != null)
                {
                    mSim.CelebrityManager.ScheduleOpportunityCallIfNecessary();
                }

                if (mOpportunities != null)
                {
                    mOpportunities.Dispose();
                }

                if ((mSchool != null) && (mSim.CareerManager != null))
                {
                    mSim.CareerManager.mSchool = mSchool;
                }

                if ((mCareer != null) && (mSim.CareerManager != null) && (mSim.Occupation == null))
                {
                    mSim.CareerManager.mJob = mCareer;

                    if (mSim.Occupation != null)
                    {
                        using (BaseWorldReversion reversion = new BaseWorldReversion())
                        {
                            if ((mFlags & Flag.LoadFixup) == Flag.LoadFixup)
                            {
                                mSim.Occupation.OnLoadFixup(false);
                            }

                            if (((mFlags & Flag.Selectable) == Flag.Selectable) && (SimTypes.IsSelectable(mSim)))
                            {
                                using (StoryProgressionServiceEx.SuppressCreateHousehold suppress = new StoryProgressionServiceEx.SuppressCreateHousehold())
                                {
                                    bool careerLoc = true;
                                    if (mSim.Occupation is Career)
                                    {
                                        careerLoc = (mSim.Occupation.CareerLoc != null);
                                    }

                                    if (careerLoc)
                                    {
                                        Corrections.FixCareer(mSim.Occupation, false, null);

                                        mSim.Occupation.OnOwnerBecameSelectable();
                                    }
                                }
                            }
                            else if ((mFlags & Flag.Unselectable) == Flag.Unselectable)
                            {
                                using (StoryProgressionServiceEx.SuppressCreateHousehold suppress = new StoryProgressionServiceEx.SuppressCreateHousehold())
                                {
                                    // fix for script error in GhostHunter:ApplyCareerSpecificModifiersToXp where
                                    // ownersim is not null checked and breaks when this is ran during age up.
                                    ActiveCareerLevelStaticData data = null;
                                    int         experience           = 0;
                                    GhostHunter hunter = null;
                                    try
                                    {
                                        hunter = mSim.Occupation as GhostHunter;
                                        if (hunter != null)
                                        {
                                            data = hunter.GetCurrentLevelStaticDataForActiveCareer();
                                            if (data != null)
                                            {
                                                experience = data.DailyPerfectJobBonusExperience;
                                                data.DailyPerfectJobBonusExperience = 0;
                                            }
                                        }

                                        mSim.Occupation.OnOwnerBecameUnselectable();
                                    }
                                    catch (Exception e)
                                    {
                                        Common.Exception(mSim, e);
                                    }
                                    finally
                                    {
                                        if (hunter != null && data != null)
                                        {
                                            data.DailyPerfectJobBonusExperience = experience;
                                        }
                                    }
                                }
                            }
                        }

                        mSim.CareerManager.UpdateCareerUI();
                    }
                }
            }
            catch (Exception e)
            {
                Common.Exception(mSim, e);
            }
        }
示例#4
0
            protected override bool OnPerform()
            {
                if ((HudController.Instance != null) && (GameUtils.IsOnVacation()))
                {
                    HudModel model = HudController.Instance.mHudModel as HudModel;
                    if (model != null)
                    {
                        if (model.MinuteChanged != null)
                        {
                            foreach (Delegate del in model.MinuteChanged.GetInvocationList())
                            {
                                TimeControl control = del.Target as TimeControl;
                                if (control != null)
                                {
                                    TimeControlEx.sThs = control;

                                    model.MinuteChanged -= TimeControlEx.sThs.OnMinuteChanged;
                                    model.MinuteChanged -= TimeControlEx.OnMinuteChanged;
                                    model.MinuteChanged += TimeControlEx.OnMinuteChanged;

                                    break;
                                }
                            }
                        }
                    }
                }

                InventoryPanel inventory = InventoryPanel.sInstance;

                if ((inventory != null) && (inventory.Visible))
                {
                    if (inventory.mTimeAlmanacButton != null)
                    {
                        if (GameUtils.IsFutureWorld())
                        {
                            inventory.mTimeAlmanacButton.Visible = (GameStates.TravelHousehold == Household.ActiveHousehold);
                        }

                        if (inventory.mTimeAlmanacButton.Visible)
                        {
                            inventory.mTimeAlmanacButton.Click -= inventory.OnClickTimeAlmanac;
                            inventory.mTimeAlmanacButton.Click -= FutureDescendantServiceEx.OnClickTimeAlmanac;
                            inventory.mTimeAlmanacButton.Click += FutureDescendantServiceEx.OnClickTimeAlmanac;
                        }
                    }
                }

                EditTownPuck puck = EditTownPuck.Instance;

                if (puck != null)
                {
                    if (puck.mReturnToLiveButton != null)
                    {
                        puck.mReturnToLiveButton.Click -= puck.OnReturnToLive;
                        puck.mReturnToLiveButton.Click -= OnReturnToLive;
                        puck.mReturnToLiveButton.Click += OnReturnToLive;
                    }
                }

                EditTownInfoPanel panel = EditTownInfoPanel.Instance;

                if (panel != null)
                {
                    if ((panel.mActionButtons != null) && (panel.mActionButtons.Length > 8) && (panel.mActionButtons[0x8] != null))
                    {
                        panel.mActionButtons[0x8].Click -= panel.OnChangeTypeClick;
                        panel.mActionButtons[0x8].Click -= OnChangeTypeClick;
                        panel.mActionButtons[0x8].Click += OnChangeTypeClick;
                    }
                }

                OptionsDialog options = OptionsDialog.sDialog;

                if (options != null)
                {
                    if (GameUtils.IsInstalled(ProductVersion.EP8))
                    {
                        Button testButton = options.mSeasonWindow.GetChildByID(0xdf085c3, true) as Button;
                        if ((testButton != null) && (!testButton.Enabled))
                        {
                            using (BaseWorldReversion reversion = new BaseWorldReversion())
                            {
                                foreach (Button weather in options.mEnabledWeatherButtons.Values)
                                {
                                    weather.Enabled = true;
                                }

                                if (options.mFahrenheitRadio != null)
                                {
                                    options.mFahrenheitRadio.Enabled = true;
                                }

                                if (options.mCelciusRadio != null)
                                {
                                    options.mCelciusRadio.Enabled = true;
                                }

                                options.SetupSeasonControls(false, ref options.mOldSeasonData);
                            }
                        }
                    }
                }

                FutureDescendantService instance = FutureDescendantServiceEx.GetInstance();

                if (Sims3.UI.Responder.Instance.InLiveMode && Traveler.Settings.mDisableDescendants && instance.mEventListeners.Count > 0)
                {
                    instance.CleanUpEventListeners();
                }

                return(true);
            }
示例#5
0
        public void Dispose()
        {
            try
            {
                mSim.AssignedRole = mRole;

                mSim.IsNeverSelectable = mNeverSelectable;

                if (mSim.CelebrityManager != null)
                {
                    mSim.CelebrityManager.ScheduleOpportunityCallIfNecessary();
                }

                if (mOpportunities != null)
                {
                    mOpportunities.Dispose();
                }

                if ((mSchool != null) && (mSim.CareerManager != null))
                {
                    mSim.CareerManager.mSchool = mSchool;
                }

                if ((mCareer != null) && (mSim.CareerManager != null) && (mSim.Occupation == null))
                {
                    mSim.CareerManager.mJob = mCareer;

                    if (mSim.Occupation != null)
                    {
                        using (BaseWorldReversion reversion = new BaseWorldReversion())
                        {
                            if ((mFlags & Flag.LoadFixup) == Flag.LoadFixup)
                            {
                                mSim.Occupation.OnLoadFixup(false);
                            }

                            if (((mFlags & Flag.Selectable) == Flag.Selectable) && (SimTypes.IsSelectable(mSim)))
                            {
                                using (StoryProgressionServiceEx.SuppressCreateHousehold suppress = new StoryProgressionServiceEx.SuppressCreateHousehold())
                                {
                                    bool careerLoc = true;
                                    if (mSim.Occupation is Career)
                                    {
                                        careerLoc = (mSim.Occupation.CareerLoc != null);
                                    }

                                    if (careerLoc)
                                    {
                                        Corrections.FixCareer(mSim.Occupation, false, null);

                                        mSim.Occupation.OnOwnerBecameSelectable();
                                    }
                                }
                            }
                            else if ((mFlags & Flag.Unselectable) == Flag.Unselectable)
                            {
                                using (StoryProgressionServiceEx.SuppressCreateHousehold suppress = new StoryProgressionServiceEx.SuppressCreateHousehold())
                                {
                                    mSim.Occupation.OnOwnerBecameUnselectable();
                                }
                            }
                        }

                        mSim.CareerManager.UpdateCareerUI();
                    }
                }
            }
            catch (Exception e)
            {
                Common.Exception(mSim, e);
            }
        }
示例#6
0
        public override void Startup()
        {
            Common.StringBuilder msg = new Common.StringBuilder("InWorldStateEx:Startup");
            Traveler.InsanityWriteLog(msg);

            try
            {
                // StateMachineState:Startup()
                mBaseCallFlag |= BaseCallFlag.kStartup;
                //base.Startup();

                msg += Common.NewLine + "A";
                Traveler.InsanityWriteLog(msg);

                Sims3.Gameplay.UI.Responder.GameStartup();

                mEnteredFromTravelling = GameStates.IsTravelling;

                bool flag = false;

                try
                {
                    ModalDialog.EnableModalDialogs = false;

                    if (World.IsEditInGameFromWBMode())
                    {
                        Sims3.Gameplay.Autonomy.Autonomy.DisableMoodContributors = true;
                    }

                    msg += Common.NewLine + "B";
                    Traveler.InsanityWriteLog(msg);

                    mStateMachine    = StateMachine.Create(0x1, "InWorld");
                    mSubStates[0]    = new LiveModeStateEx(GameStates.IsMovingWorlds); // Custom
                    mSubStates[1]    = new BuildModeState();
                    mSubStates[2]    = new BuyModeState();
                    mSubStates[12]   = new ShoppingModeState();
                    mSubStates[3]    = new CASFullModeState();
                    mSubStates[4]    = new CASDresserModeState();
                    mSubStates[5]    = new CASMirrorModeState();
                    mSubStates[6]    = new CASTattooModeState();
                    mSubStates[7]    = new CASStylistModeState();
                    mSubStates[8]    = new CASTackModeState();
                    mSubStates[9]    = new CASCollarModeState();
                    mSubStates[10]   = new CASSurgeryFaceModeState();
                    mSubStates[11]   = new CASSurgeryBodyModeState();
                    mSubStates[15]   = new PlayFlowStateEx(); // Custom
                    mSubStates[14]   = new EditTownStateEx(); // Custom
                    mSubStates[16]   = new BlueprintModeState();
                    mSubStates[17]   = new CASMermaidModeState();
                    mSubStates[0x12] = new CABModeState();
                    mSubStates[0x13] = new CABModeEditState();

                    foreach (InWorldSubState state in mSubStates)
                    {
                        mStateMachine.AddState(state);
                    }

                    msg += Common.NewLine + "C";
                    Traveler.InsanityWriteLog(msg);

                    StateMachineManager.AddMachine(mStateMachine);
                    if (GameStates.IsTravelling || GameStates.IsEditingOtherTown)
                    {
                        try
                        {
                            Sims3.Gameplay.WorldBuilderUtil.CharacterImportOnGameLoad.RemapSimDescriptionIds();
                        }
                        catch (Exception e)
                        {
                            Common.DebugException("RemapSimDescriptionIds", e);
                        }
                    }
                    else
                    {
                        CrossWorldControl.sRetention.RestoreHouseholds();
                    }

                    msg += Common.NewLine + "D";
                    Traveler.InsanityWriteLog(msg);

                    if (GameStates.IsTravelling)
                    {
                        msg += Common.NewLine + "E1";
                        Traveler.InsanityWriteLog(msg);

                        bool fail = false;
                        if (!GameStatesEx.ImportTravellingHousehold())
                        {
                            msg += Common.NewLine + "E3";

                            fail = true;
                        }

                        if ((GameStates.TravelHousehold == null) && (GameStates.sTravelData.mState == GameStates.TravelData.TravelState.StartVacation))
                        {
                            msg += Common.NewLine + "E4";

                            fail = true;
                        }

                        if (fail)
                        {
                            msg += Common.NewLine + "E5";
                            Traveler.InsanityWriteLog(msg);

                            GameStates.sStartupState = SubState.EditTown;

                            GameStates.ClearTravelStatics();

                            WorldData.SetVacationWorld(true, true);
                        }
                    }
                    else if ((!GameStates.IsEditingOtherTown) && (GameStates.HasTravelData) && (GameStates.TravelHousehold == null))
                    {
                        switch (GameUtils.GetCurrentWorldType())
                        {
                        case WorldType.Base:
                        case WorldType.Downtown:
                            msg += Common.NewLine + "E2";
                            Traveler.InsanityWriteLog(msg);

                            GameStates.ClearTravelStatics();
                            break;
                        }
                    }

                    // Custom
                    if (GameStates.sMovingWorldData != null)
                    {
                        Household.IsTravelImport = true;
                    }

                    msg += Common.NewLine + "F1";
                    Traveler.InsanityWriteLog(msg);

                    List <Household> households = new List <Household>(Household.sHouseholdList);
                    foreach (Household a in households)
                    {
                        if ((a.LotHome != null) && (a.LotHome.Household == null))
                        {
                            a.LotHome.mHousehold = a;
                        }

                        foreach (SimDescription simA in Households.All(a))
                        {
                            // Must be validated prior to SimDescription:PostLoadFixup()
                            if (simA.GameObjectRelationships != null)
                            {
                                for (int index = simA.GameObjectRelationships.Count - 1; index >= 0; index--)
                                {
                                    if ((simA.GameObjectRelationships[index] == null) ||
                                        (simA.GameObjectRelationships[index].GameObjectDescription == null) ||
                                        (simA.GameObjectRelationships[index].GameObjectDescription.GameObject == null) ||
                                        (!Objects.IsValid(simA.GameObjectRelationships[index].GameObjectDescription.GameObject.ObjectId)))
                                    {
                                        simA.GameObjectRelationships.RemoveAt(index);
                                    }
                                }
                            }

                            foreach (Household b in households)
                            {
                                if (a == b)
                                {
                                    continue;
                                }

                                if (!b.Contains(simA))
                                {
                                    continue;
                                }

                                if (b.NumMembers == 1)
                                {
                                    continue;
                                }

                                try
                                {
                                    b.Remove(simA, false);

                                    msg += Common.NewLine + "Duplicate: " + simA.FullName;
                                }
                                catch (Exception e)
                                {
                                    Common.Exception(simA, e);
                                }
                            }
                        }
                    }

                    msg += Common.NewLine + "F2";
                    Traveler.InsanityWriteLog(msg);

                    // Required to ensure that all homeworld specific data is fixed up properly (specifically careers)
                    using (BaseWorldReversion reversion = new BaseWorldReversion())
                    {
                        // Reset this, to allow the Seasons Manager to activate properly
                        SeasonsManager.sSeasonsValidForWorld = SeasonsManager.Validity.Undetermined;

                        try
                        {
                            mPostWorldInitializers = new Initializers("PostWorldInitializers", this);

                            using (CareerStore store = new CareerStore())
                            {
                                //InitializersEx.Initialize(mPostWorldInitializers);
                                mPostWorldInitializers.Initialize();
                            }
                        }
                        catch (Exception e)
                        {
                            Traveler.InsanityException(msg, e);
                        }
                    }

                    msg += Common.NewLine + "G1";
                    Traveler.InsanityWriteLog(msg);

                    try
                    {
                        if (GameStates.TravelHousehold != null)
                        {
                            LinkToTravelHousehold();

                            WorldName worldName = GameUtils.GetCurrentWorld();

                            switch (worldName)
                            {
                            case WorldName.China:
                            case WorldName.Egypt:
                            case WorldName.France:
                                break;

                            default:
                                foreach (SimDescription sim in Households.All(GameStates.TravelHousehold))
                                {
                                    if (sim.VisaManager == null)
                                    {
                                        continue;
                                    }

                                    WorldData.OnLoadFixup(sim.VisaManager);

                                    sim.VisaManager.SetVisaLevel(worldName, 3);
                                }
                                break;
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        Traveler.InsanityException(msg, e);
                    }

                    msg += Common.NewLine + "G2";
                    Traveler.InsanityWriteLog(msg);

                    List <SimDescription> dyingSims = null;
                    if (GameStates.IsTravelling)
                    {
                        dyingSims = GameStatesEx.PostTravelingFixUp();
                    }

                    msg += Common.NewLine + "H";
                    Traveler.InsanityWriteLog(msg);

                    if (GameStates.IsEditingOtherTown)
                    {
                        GameStates.PostLoadEditTownFixup();
                    }

                    msg += Common.NewLine + "I";
                    Traveler.InsanityWriteLog(msg);

                    // We must stop the travel actions from running if the homeworld is an EA vacation world
                    WorldData.SetVacationWorld(true, false);

                    GameStates.NullEditTownDataDataIfEditingOriginalStartingWorld();
                    try
                    {
                        if (GameUtils.IsAnyTravelBasedWorld())
                        {
                            if ((dyingSims != null) && (AgingManager.NumberAgingYearsElapsed != -1f))
                            {
                                float yearsGone = GameStates.NumberAgingYearsElapsed - AgingManager.NumberAgingYearsElapsed;

                                // Custom function
                                FixUpAfterTravel(yearsGone, dyingSims);
                            }
                            AgingManager.NumberAgingYearsElapsed = GameStates.NumberAgingYearsElapsed;
                        }
                    }
                    catch (Exception e)
                    {
                        Traveler.InsanityException(msg, e);
                    }

                    msg += Common.NewLine + "J";
                    Traveler.InsanityWriteLog(msg);

                    Sims3.Gameplay.Gameflow.GameSpeed pause = Sims3.Gameplay.Gameflow.GameSpeed.Pause;

                    if (GameStates.StartupState == SubState.LiveMode)
                    {
                        flag = !GameStates.IsEditingOtherTown && (((GameStates.ForceStateChange || !PlayFlowModel.Singleton.GameEntryLive) || (PlumbBob.SelectedActor != null)) || GameStates.IsTravelling);
                        if (flag)
                        {
                            if (Sims3.Gameplay.Gameflow.sGameLoadedFromWorldFile)
                            {
                                pause = Sims3.SimIFace.Gameflow.GameSpeed.Normal;
                            }
                            else
                            {
                                pause = Sims3.Gameplay.Gameflow.sPersistedGameSpeed;
                            }
                        }
                    }

                    msg += Common.NewLine + "K";
                    Traveler.InsanityWriteLog(msg);

                    Sims3.Gameplay.Gameflow.sGameLoadedFromWorldFile = false;
                    string s = CommandLine.FindSwitch("speed");
                    if (s != null)
                    {
                        int num2;
                        if (int.TryParse(s, out num2))
                        {
                            pause = (Sims3.Gameplay.Gameflow.GameSpeed)num2;
                        }
                        else
                        {
                            ParserFunctions.TryParseEnum <Sims3.Gameplay.Gameflow.GameSpeed>(s, out pause, Sims3.Gameplay.Gameflow.GameSpeed.Normal);
                        }
                    }

                    msg += Common.NewLine + "L";
                    Traveler.InsanityWriteLog(msg);

                    Sims3.Gameplay.Gameflow.SetGameSpeed(pause, Sims3.Gameplay.Gameflow.SetGameSpeedContext.GameStates);
                    NotificationManager.Load();
                    MainMenu.TriggerPendingFsiWorldNotifications();
                }
                finally
                {
                    ModalDialog.EnableModalDialogs = true;
                }

                if (SocialFeatures.Accounts.IsLoggedIn())
                {
                    Notify(0, 0, 0L);
                }

                switch (GameStates.StartupState)
                {
                case SubState.EditTown:
                    msg += Common.NewLine + "StartupState: EditTown";

                    GameUtils.EnableSceneDraw(true);
                    LoadingScreenController.Unload();
                    GotoEditTown();
                    break;

                case SubState.PlayFlow:
                    if (World.IsEditInGameFromWBMode())
                    {
                        msg += Common.NewLine + "StartupState: PlayFlow (A)";

                        GameUtils.EnableSceneDraw(true);
                        LoadingScreenController.Unload();
                        GotoLiveMode();
                    }
                    else if (!PlayFlowModel.PlayFlowEnabled || !PlayFlowModel.Singleton.GameEntryLive)
                    {
                        msg += Common.NewLine + "StartupState: PlayFlow (B)";

                        GameUtils.EnableSceneDraw(true);
                        LoadingScreenController.Unload();
                        GotoLiveMode();
                    }
                    else
                    {
                        msg += Common.NewLine + "StartupState: PlayFlow (C)";

                        GotoPlayFlow();
                    }
                    break;

                case SubState.LiveMode:
                    // Custom
                    if (((!GameUtils.IsOnVacation() && !GameUtils.IsFutureWorld()) || EditTownModel.IsAnyLotBaseCampStatic() || EditTownModelEx.IsAnyUnoccupiedLotStatic()) && flag)
                    {
                        bool directToGame = false;
                        if (!GameStates.IsTravelling)
                        {
                            // Entering an existing save
                            directToGame = true;
                        }
                        else if (EditTownModel.IsAnyLotBaseCampStatic())
                        {
                            // Normal transition to base camp
                            directToGame = true;
                        }
                        else if (!GameUtils.IsInstalled(ProductVersion.EP9))
                        {
                            // Use custom household selection
                            directToGame = true;
                        }

                        // Custom
                        if ((flag) && (directToGame))
                        {
                            msg += Common.NewLine + "StartupState: LiveMode (A)";

                            GotoLiveMode();
                            break;
                        }
                        else
                        {
                            msg += Common.NewLine + "StartupState: LiveMode (C)";

                            GameUtils.EnableSceneDraw(true);
                            LoadingScreenController.Unload();
                            GotoPlayFlow();
                            break;
                        }
                    }

                    msg += Common.NewLine + "StartupState: LiveMode (B)";

                    GameUtils.EnableSceneDraw(true);
                    LoadingScreenController.Unload();
                    GotoEditTown();
                    break;
                }

                msg += Common.NewLine + "M";
                Traveler.InsanityWriteLog(msg);

                if (Sims3.Gameplay.Gameflow.sShowObjectReplacedWarning)
                {
                    SimpleMessageDialog.Show(Common.LocalizeEAString("Ui/Warning/LoadGame:Warning"), Common.LocalizeEAString("Ui/Warning/LoadGame:ReplacedObjects"), ModalDialog.PauseMode.PauseSimulator);
                    Sims3.Gameplay.Gameflow.sShowObjectReplacedWarning = false;
                }
            }
            catch (Exception e)
            {
                Traveler.InsanityException(msg, e);
            }
            finally
            {
                //Common.WriteLog(msg);
            }
        }