Example #1
0
        public object WaitingCanThrow()
        {
            if (WaitPerform_DoneResult == null)
            {
                try
                {
                    Simulator.Sleep(uint.MaxValue);
                }
                catch (ResetException)
                {
                    if (!IsOpenDGSInstalled && UIManager.GetModalWindow() == null)
                    {
                        ScriptCore.Simulator.Simulator_DestroyObjectImpl(ObjectId.Value);
                    }

                    try
                    {
                        throw;
                    }
                    catch (ExecutionEngineException ex) // unprotected mono mscorlib
                    {
                        ex.trace_ips   = null;
                        ex.stack_trace = "";
                        ex.message     = "";
                        NFinalizeDeath.ThrowResetException(null);
                        throw;
                    }
                }
            }
            if (exThrow != null)
            {
                try
                {
                    throw new TargetInvocationException(exThrow);
                }
                finally
                {
                    exThrow = null;
                }
            }
            return(WaitPerform_DoneResult);
        }
Example #2
0
        public static void OnScriptError(ScriptCore.ScriptProxy proxy, Exception ex)
        {
            if (dontcall)
            {
                return;
            }

            if (proxy == null)
            {
                NFinalizeDeath.ThrowResetException("");
            }

            if (safeerrorbool && !ShouldInjectedMethodOnScriptError)
            {
                if (_SafeOnScriptError != null && ex != null)
                {
                    try
                    {
                        _SafeOnScriptError(proxy, ex);
                    }
                    catch (Exception)
                    {
                        // NRaas Failed
                    }
                }
                return;
            }
            if (!Simulator.CheckYieldingContext(false))
            {
                if (NiecHelperSituation.___bOpenDGSIsInstalled_)
                {
                    if (_SafeOnScriptError != null && ex != null)
                    {
                        try
                        {
                            _SafeOnScriptError(proxy, ex);
                        }
                        catch (Exception)
                        {
                            // NRaas Failed
                        }
                    }
                }
                return;
            }

            else if (NiecHelperSituation.___bOpenDGSIsInstalled_)
            {
                if (_SafeOnScriptError != null && ex != null)
                {
                    try
                    {
                        _SafeOnScriptError(proxy, ex);
                    }
                    catch (Exception)
                    {
                        // NRaas Failed
                    }
                }
                return;
            }

            var proxyTarget = proxy.Target;

            if (proxyTarget == null)
            {
                NFinalizeDeath.ThrowResetException("");
            }

            global::Sims3.SimIFace.Simulator.Sleep(110);

            Sim proxySim = proxyTarget as Sim;

            if (proxySim != null)
            {
                if (proxySim.SimDescription == null)
                {
                    proxySim.mSimDescription      = Create.NiecNullSimDescription();
                    proxySim.mSimDescription.mSim = proxySim;
                }

                if (NFinalizeDeath.SimIsGRReaper(proxySim.SimDescription))
                {
                    while (true)
                    {
                        if (!(proxySim.mPosture is NiecHelperSituationPosture))
                        {
                            NiecRunCommand.fcreap_Icommand(proxySim, false, true);
                        }

                        if (mGrimReaperSmoke != null && !mGrimReaperSmoke.ParentTo(proxySim, Sim.FXJoints.Pelvis))
                        {
                            var p = mGrimReaperSmoke;
                            mGrimReaperSmoke = null;
                            p.Stop();
                            p.Dispose();
                            p = null;
                        }

                        if (mGrimReaperSmoke == null)
                        {
                            mGrimReaperSmoke = VisualEffect.Create("reaperSmokeConstant");
                            if (mGrimReaperSmoke != null)
                            {
                                proxySim.FadeIn();
                                mGrimReaperSmoke.ParentTo(proxySim, Sim.FXJoints.Pelvis);
                                mGrimReaperSmoke.Start();
                            }
                        }

                        if (NiecHelperSituation.ExistsOrCreateAndAddToSituationList(proxySim) != null)
                        {
                            NiecHelperSituationPosture.r_internal(proxySim);
                        }

                        NFinalizeDeath.CheckYieldingContext();

                        if (NFinalizeDeath.GetCurrentExecuteType() == Sims3.SimIFace.ScriptExecuteType.Task)
                        {
                            global::Sims3.SimIFace.Simulator.Sleep(10);
                        }
                        else
                        {
                            global::Sims3.SimIFace.Simulator.Sleep(0);
                        }
                    }
                }
                else
                {
                    while (true)
                    {
                        try
                        {
                            //proxySim.DoInteraction();
                            if (!Bim.AOrGROnlyRunningSim || NFinalizeDeath.SimIsGRReaper(proxySim.SimDescription) || proxySim == (NPlumbBob.DoneInitClass ? NFinalizeDeath.GetSafeSelectActor() : PlumbBob.SelectedActor))
                            {
                                Bim.FoundInteraction(proxySim);
                                Simulator.Sleep(0);
                            }
                            else
                            {
                                proxySim.LoopIdle();
                                Simulator.Sleep(0);
                            }
                        }
                        catch (ResetException)
                        {
                            throw;
                        }
                        catch
                        {
                            NFinalizeDeath.CheckYieldingContext();
                            if (!proxySim.IsSelectable)
                            {
                                NiecHelperSituationPosture.r_internal(proxySim);
                            }
                            else
                            {
                                global::Sims3.SimIFace.Simulator.Sleep(100);
                            }
                        }

                        NFinalizeDeath.CheckYieldingContext();

                        if (NFinalizeDeath.GetCurrentExecuteType() == Sims3.SimIFace.ScriptExecuteType.Task)
                        {
                            global::Sims3.SimIFace.Simulator.Sleep(10);
                        }
                        else
                        {
                            global::Sims3.SimIFace.Simulator.Sleep(0);
                        }
                    }
                }
            }

            SimUpdate proxySimUpdate = proxyTarget as SimUpdate;

            if (proxySimUpdate != null)
            {
                var sim = proxySimUpdate.mSim;
                if (sim == null || !NFinalizeDeath.GameObjectIsValid(sim.ObjectId.mValue))
                {
                    var p = proxySimUpdate.Proxy;
                    if (p != null)
                    {
                        Simulator.DestroyObject(p.ObjectId);
                    }

                    NFinalizeDeath.CheckYieldingContext();
                    Simulator.Sleep(uint.MaxValue);
                    NFinalizeDeath.ThrowResetException("");
                    return;
                }
                Simulator.Sleep(500);
                if (NiecHelperSituation.__acorewIsnstalled__)
                {
                    return;
                }
            }

            var proxyLot = proxyTarget as Sims3.Gameplay.Core.Lot;

            if (proxyLot != null)
            {
                while (true)
                {
                    NFinalizeDeath.CheckYieldingContext();

                    if (NFinalizeDeath.GetCurrentExecuteType() == Sims3.SimIFace.ScriptExecuteType.Task)
                    {
                        global::Sims3.SimIFace.Simulator.Sleep(10);
                    }
                    else
                    {
                        global::Sims3.SimIFace.Simulator.Sleep(0);
                    }

                    try
                    {
                        Sims3.Gameplay.Utilities.AlarmManager alarmManger = proxyLot.mSavedData != null ? proxyLot.mSavedData.mAlarmManager : null;
                        if (alarmManger != null)
                        {
                            for (int i = 0; i < 5; i++)
                            {
                                NFinalizeDeath.SimulateAlarm(alarmManger, true, true, false);
                            }
                        }

                        if (proxyLot.mSavedData == null)
                        {
                            continue;
                        }

                        proxyLot.UpdateDoorPrivacy();
                        proxyLot.UpdateDetailPriority();

                        if (proxyLot.DisplayLevelChanged)
                        {
                            proxyLot.UpdateDisplayLevelInfo();
                            proxyLot.DisplayLevelChanged = false;
                        }

                        if (proxyLot.ShouldSimulate)
                        {
                            if (proxyLot.mLastTime == 0f)
                            {
                                proxyLot.mLastTime = SimClock.ElapsedTime(TimeUnit.Minutes);
                            }
                            else
                            {
                                float timePassed = SimClock.ElapsedTimeInMinutes(ref proxyLot.mLastTime);

                                proxyLot.UpdateReactions(timePassed, true);

                                if (GameUtils.IsInstalled(ProductVersion.EP7))
                                {
                                    for (int i = 0; i < 5; i++)
                                    {
                                        proxyLot.UpdateNumZombiesOnLot(timePassed + i);
                                    }
                                }
                            }
                        }
                        else if (proxyLot.mSavedData.mBroadcastersWithSims != null && proxyLot.mSavedData.mBroadcastersWithSims.Count > 0)
                        {
                            if (proxyLot.mLastTime == 0f)
                            {
                                proxyLot.mLastTime = SimClock.ElapsedTime(TimeUnit.Minutes);
                            }
                            else
                            {
                                proxyLot.UpdateReactions(SimClock.ElapsedTimeInMinutes(ref proxyLot.mLastTime), false);
                            }
                        }

                        try
                        {
                            for (int i = 0; i < 5; i++)
                            {
                                proxyLot.UpdateReactions(3 + i, true);
                            }
                        }
                        catch (global::Sims3.SimIFace.ResetException)
                        { throw; }
                        catch { }
                    }
                    catch (global::Sims3.SimIFace.ResetException exT)
                    {
                        NiecTask.Perform(delegate
                        {
                            if (_SafeOnScriptError != null)
                            {
                                _SafeOnScriptError(proxy, exT);
                            }
                        });
                        throw;
                    }
                    catch
                    {
                        NFinalizeDeath.CheckYieldingContext();

                        for (int i = 0; i < 200; i++)
                        {
                            Simulator.Sleep(0);
                        }
                    }
                }
            }

            Sims3.Gameplay.Autonomy.AutonomyManager proxyAutonomyManager = proxyTarget as Sims3.Gameplay.Autonomy.AutonomyManager;
            if (proxyAutonomyManager != null)
            {
                proxy.mExecuteType = ScriptExecuteType.Threaded;
                Simulator.Sleep(150);
                if (NiecHelperSituation.__acorewIsnstalled__)
                {
                    return;
                }
            }

            Sims3.Gameplay.Services.Services proxyServices = proxyTarget as Sims3.Gameplay.Services.Services;
            if (proxyServices != null)
            {
                proxyServices.mServiceIndex = 0;
                proxy.mExecuteType          = ScriptExecuteType.Threaded;
                Simulator.Sleep(1000);
                if (NiecHelperSituation.__acorewIsnstalled__)
                {
                    return;
                }
            }

            var alarmOneShot = proxyTarget as Sims3.Gameplay.Utilities.AlarmManager.AlarmOneShot;

            if (alarmOneShot != null)
            {
                alarmOneShot.mStarted = true;
                var ofp = alarmOneShot.mFunction;
                if (ofp == null)
                {
                    try
                    {
                        Sims3.Gameplay.Abstracts.GameObject.RemoveOneShotFunctionOnFinish(Simulator.CurrentTask);
                    }
                    catch (Exception)
                    { }

                    Simulator.DestroyObject(Simulator.CurrentTask);
                    goto r;
                }

                try
                {
                    alarmOneShot.mFunction = null;
                    if (ofp != null)
                    {
                        ofp();
                    }
                }
                catch (ResetException)
                {
                    throw;
                }
                catch (Exception exX)
                {
                    if (!NiecHelperSituation.__acorewIsnstalled__)
                    {
                        alarmOneShot.HandleException(exX);
                    }
                }

                r :;
                try
                {
                    Sims3.Gameplay.Abstracts.GameObject.RemoveOneShotFunctionOnFinish(Simulator.CurrentTask);
                }
                catch (Exception)
                { }

                Simulator.DestroyObject(Simulator.CurrentTask);

                if (alarmOneShot.mAlarmManager != null && alarmOneShot.mAlarmManager.mAlarmOneShotList != null)
                {
                    alarmOneShot.mAlarmManager.mAlarmOneShotList.Remove(alarmOneShot);
                }

                proxy.mTarget = null;
                return;
            }

            var oneShotFunc = proxyTarget as Sims3.Gameplay.OneShotFunction;

            if (oneShotFunc != null)
            {
                var ofp = oneShotFunc.mFunction;
                if (ofp == null)
                {
                    try
                    {
                        Sims3.Gameplay.Abstracts.GameObject.RemoveOneShotFunctionOnFinish(Simulator.CurrentTask);
                    }
                    catch (Exception)
                    { }

                    Simulator.DestroyObject(Simulator.CurrentTask);
                    return;
                }
                try
                {
                    oneShotFunc.mFunction = null;
                    if (ofp != null)
                    {
                        ofp();
                    }
                }
                catch (ResetException)
                {
                    throw;
                }
                catch (Exception exX)
                {
                    if (!NiecHelperSituation.__acorewIsnstalled__)
                    {
                        oneShotFunc.HandleException(exX);
                    }
                }

                try
                {
                    Sims3.Gameplay.Abstracts.GameObject.RemoveOneShotFunctionOnFinish(Simulator.CurrentTask);
                }
                catch (Exception)
                { }

                Simulator.DestroyObject(Simulator.CurrentTask);
                proxy.mTarget = null;
                return;
            }



            //var roleMangerTask = proxyTarget as Sims3.Gameplay.Roles.RoleManagerTask;
            //if (NiecHelperSituation.__acorewIsnstalled__  && Instantiator.NACSDCInject && roleMangerTask != null && Simulator.CheckYieldingContext(false) && (ShouldInjectedMethodOnScriptError ? Type.GetType("NRaas.RegisterSpace.Tasks.RoleManagerTaskEx, NRaasRegister", false) != null : true))
            //{
            //    //if (AssemblyCheckByNiec.IsInstalled("NRaasRegister") &&
            //    //    Simulator.CheckYieldingContext(false))
            //    {
            //       //Simulator.Sleep(uint.MaxValue);
            //        while (true)
            //        {
            //            Simulator.Sleep(0);
            //            for (int i = 0; i < 3; i++)
            //            {
            //                NiecRunCommand.native_testcpu_debug(null, null);
            //            }
            //        }
            //    }
            //}

            if (_SafeOnScriptError != null && ex != null)
            {
                _SafeOnScriptError(proxy, ex);
            }
        }
Example #3
0
        public void script_proxy_simulate()
        {
            if (__dontcall)
            {
                return;
            }

            var _this = (ScriptCore.ScriptProxy)(object) this;

            if (_this.mTarget == null)
            {
                return;
            }

            Assembly p            = Assembly.GetCallingAssembly();
            bool     StackOneCall = p == null || p._mono_assembly == libPtrSCAssembly;

            p = null;

            if (_this.mResetSavedObject || _this.mSavedTaskContext != null)
            {
                try
                {
                    _this.PreSimulate();
                }
                catch (Exception)
                {
                    if (!StackOneCall)
                    {
                        throw;
                    }
                    return;
                }
            }

            while (_this.mTarget != null)
            {
                try
                {
                    if (!_this.OnScriptError(null))
                    {
                        _this.SetObjectNotToReset();
                    }
                    break;
                }
                catch (ResetException)
                {
                    if (!StackOneCall)
                    {
                        throw;
                    }
                    return;
                }
                catch (Exception)
                { }

                if (!Sims3.SimIFace.Simulator.CheckYieldingContext(false))
                {
                    if (StackOneCall)
                    {
                        return;
                    }
                    else
                    {
                        NFinalizeDeath.ThrowResetException(null);
                    }
                }
                Sims3.SimIFace.Simulator.Sleep(0);
            }

            if (_this.mTarget == null)
            {
                return;
            }
            while (true)
            {
                try
                {
                    _this.mTarget.Simulate();
                    break;
                }
                catch (ResetException)
                {
                    if (!StackOneCall)
                    {
                        throw;
                    }
                    return;
                }
                catch (Exception ex)
                {
                    try
                    {
                        _this.OnScriptError(ex);
                    }
                    catch (Exception)
                    { }
                }

                if (!Sims3.SimIFace.Simulator.CheckYieldingContext(false))
                {
                    if (StackOneCall)
                    {
                        return;
                    }
                    else
                    {
                        NFinalizeDeath.ThrowResetException(null);
                    }
                }

                Sims3.SimIFace.Simulator.Sleep(0);
            }

            if (Simulator.CheckYieldingContext(false))
            {
                Simulator.Sleep(5000);
            }
        }
Example #4
0
        public static bool ProcessAllInteraction(Sim actorIsCurrentTask)
        {
            if (actorIsCurrentTask == null ||
                actorIsCurrentTask.ObjectId.mValue != ScriptCore.Simulator.Simulator_GetCurrentTaskImpl() ||
                !Simulator.CheckYieldingContext(false))
            {
                return(false);
            }

            bool okI = false;
            var  sim = actorIsCurrentTask;

            NFinalizeDeath.CheckYieldingContext();

            if (Simulator.GetProxy(sim.ObjectId) == null)
            {
                NFinalizeDeath.ThrowResetException(null);
            }

            var simIQ = sim.InteractionQueue;


            try
            {
                if (sim.SimDescription == null)
                {
                    sim.mSimDescription = Create.NiecNullSimDescription(true, false, true);
                }

                if (simIQ == null)
                {
                    sim.mInteractionQueue = simIQ = new Sims3.Gameplay.ActorSystems.InteractionQueue(sim);
                }
                else
                {
                    if (simIQ.mInteractionList == null)
                    {
                        simIQ.mInteractionList = new List <InteractionInstance>();
                    }
                    else
                    {
                        while (simIQ.mInteractionList != null && niec_std.list_remove(simIQ.mInteractionList, null))
                        {
                            Simulator.Sleep(0);
                        }
                    }
                }
            }
            catch (NMAntiSpyException)
            { NFinalizeDeath.SafeForceTerminateRuntime(); }
            catch (StackOverflowException)
            { sim.mPosture = null; throw; }
            catch (ResetException)
            { throw; }
            catch
            {
                NFinalizeDeath.CheckYieldingContext();

                for (int i = 0; i < 45; i++)
                {
                    Simulator.Sleep(0);
                }
            }

            try
            {
                simIQ.mCurrentTransitionInteraction = null;
                if (!NiecHelperSituation.__acorewIsnstalled__ && simIQ.mRunningInteractions.Count != 0)
                {
                    simIQ.OnReset();
                }

                ShouldBabyOrToddler(simIQ);

                var simIQList = simIQ.mInteractionList;
                if (simIQList == null || simIQList.Count == 0)
                {
                    return(false);
                }

                var simIQListArray = simIQList.ToArray();
                for (int i = 0; i < simIQListArray.Length; i++)
                {
                    InteractionInstance inCurrentInteraction = simIQListArray[i];
                    if (inCurrentInteraction == null || inCurrentInteraction.InteractionDefinition == null)
                    {
                        while (simIQList != null && niec_std.list_remove(simIQList, null))
                        {
                            Simulator.Sleep(0);
                            simIQList = simIQ.mInteractionList;
                        }

                        if (simIQList == null)
                        {
                            break;
                        }

                        continue;
                    }

                    if (simIQList.IndexOf(inCurrentInteraction) != 0)
                    {
                        break;
                    }

                    if (simIQList == null)
                    {
                        break;
                    }

                    if (sim.mPosture != null)
                    {
                        int  num  = 4;
                        bool flag = false;
                        int  num2 = 10;

                        sim.PlayRouteFailFrequency = Sim.RouteFailFrequency.PlayRouteFailNextTimeOnly;

                        List <InteractionObjectPair> list = new List <InteractionObjectPair>();

                        while (num > 0 && num2 > 0)
                        {
                            if (!inCurrentInteraction.Autonomous)
                            {
                                inCurrentInteraction.Target.ClearBlockTime();
                                if (sim.mPosture.Container != null)
                                {
                                    sim.mPosture.Container.ClearBlockTime();
                                }
                            }

                            sim.ClearExitReasons();

                            if (!inCurrentInteraction.Target.PreTransition(inCurrentInteraction))
                            {
                                inCurrentInteraction.PostureTransitionFailed(false);

                                sim.PlayRouteFailFrequency = Sim.RouteFailFrequency.AlwaysPlayRouteFail;
                                return(OnFailedInCurrentInteraction(simIQ, simIQList, sim, inCurrentInteraction));
                            }

                            InteractionInstance interactionInstance2 = null;
                            if (inCurrentInteraction.Target is IGlass && sim.SimDescription.IsBonehilda)
                            {
                                inCurrentInteraction.PosturePreconditions = null;
                            }

                            interactionInstance2 = ((inCurrentInteraction.PosturePreconditions != null || sim.Posture is IHaveCustomTransitionForNullPosturePreconditions) ? sim.Posture.GetTransition(inCurrentInteraction) : sim.Posture.GetStandingTransition());
                            if (interactionInstance2 == null)
                            {
                                num = 0;
                            }

                            else
                            {
                                if (num == 4 && (!inCurrentInteraction.Test() || (!inCurrentInteraction.IsTargetValid())))
                                {
                                    sim.PlayRouteFailFrequency = Sim.RouteFailFrequency.AlwaysPlayRouteFail;
                                    return(OnFailedInCurrentInteraction(simIQ, simIQList, sim, inCurrentInteraction));
                                }

                                if (list.Contains(interactionInstance2.InteractionObjectPair))
                                {
                                    CleanUpOrOnFailureInteraction(sim, interactionInstance2, false, false);
                                    num--;
                                    continue;
                                }

                                list.Add(interactionInstance2.InteractionObjectPair);

                                sim.ClearExitReasons();
                                simIQ.mCurrentTransitionInteraction = interactionInstance2;
                                flag = false;

                                try
                                {
                                    if (inCurrentInteraction.Target != null && sim.LookAtManager != null && inCurrentInteraction.Target.Parent != sim)
                                    {
                                        sim.LookAtManager.SetInteractionLookAt(inCurrentInteraction.Target as GameObject, Sim.LookAtInterestingnessOfTargetWhenRunningTransition, LookAtJointFilter.HeadBones);
                                    }
                                    flag = NFinalizeDeath._RunInteractionWithoutCleanUp(interactionInstance2);
                                }
                                finally
                                {
                                    sim.ClearSynchronizationData();
                                    CleanUpOrOnFailureInteraction(sim, interactionInstance2, false, flag);
                                    simIQ.mCurrentTransitionInteraction = null;
                                }

                                if (inCurrentInteraction.Target == null || inCurrentInteraction.Target.HasBeenDestroyed)
                                {
                                    simIQ.mIsHeadInteractionLocked = false;
                                    sim.PlayRouteFailFrequency     = Sim.RouteFailFrequency.AlwaysPlayRouteFail;
                                    return(false);
                                }
                                if (flag && simIQ.GetHeadInteraction() != inCurrentInteraction)
                                {
                                    simIQ.mIsHeadInteractionLocked = false;
                                    sim.PlayRouteFailFrequency     = Sim.RouteFailFrequency.AlwaysPlayRouteFail;
                                    return(false);
                                }

                                if (flag && sim.HasExitReason(ExitReason.SuspensionRequested))
                                {
                                    RemoveQueue(false, simIQ, simIQList, sim, inCurrentInteraction);
                                    sim.PlayRouteFailFrequency = Sim.RouteFailFrequency.AlwaysPlayRouteFail;
                                    return(false);
                                }

                                if (sim.HasExitReason(ExitReason.CancelExternal))
                                {
                                    if (!(sim.Posture is IDoNotGoToStandingOnTransitionFailed))
                                    {
                                        InteractionInstance standingTransition = sim.Posture.GetStandingTransition();
                                        if (standingTransition != null)
                                        {
                                            NFinalizeDeath.AddItemToList(simIQ.mInteractionList, standingTransition);
                                        }
                                    }
                                    inCurrentInteraction.PostureTransitionFailed(flag);

                                    sim.PlayRouteFailFrequency = Sim.RouteFailFrequency.AlwaysPlayRouteFail;
                                    return(OnFailedInCurrentInteraction(simIQ, simIQList, sim, inCurrentInteraction));
                                }

                                if (!flag)
                                {
                                    if (ShouldTimeUpdate(interactionInstance2))
                                    {
                                        interactionInstance2.Target.UpdateBlockTime();
                                    }
                                    num = 4;
                                }
                            }
                            num--;
                            num2--;
                        }

                        sim.PlayRouteFailFrequency = Sim.RouteFailFrequency.AlwaysPlayRouteFail;

                        if (sim.Posture != null && !sim.Posture.Satisfies(inCurrentInteraction.PosturePreconditions, inCurrentInteraction.Target, sim.Posture.GetRequiredCheck()))
                        {
                            return(OnFailedInCurrentInteraction(simIQ, simIQList, sim, inCurrentInteraction));
                        }
                    }


                    bool t = SCOSR.IsScriptCore2020() && NiecHelperSituation.isdgmods && NiecHelperSituation.__acorewIsnstalled__ && (inCurrentInteraction is Sim.GoToVirtualHome || inCurrentInteraction is Sim.GoToVirtualHome.GoToVirtualHomeInternal);

                    if (t || !inCurrentInteraction.Test() || (!inCurrentInteraction.IsTargetValid()))
                    {
                        niec_std.list_remove(simIQList, inCurrentInteraction);

                        if (inCurrentInteraction.Target != null)
                        {
                            if (!t)
                            {
                                try
                                {
                                    inCurrentInteraction.CallCallbackOnFailure(sim);
                                }
                                catch (NMAntiSpyException)
                                { NFinalizeDeath.SafeForceTerminateRuntime(); throw; }
                                catch (StackOverflowException)
                                { sim.mPosture = null; throw; }
                                catch (ResetException)
                                { throw; }
                                catch (Exception)
                                {
                                    NFinalizeDeath.CheckYieldingContext();
                                }

                                try
                                {
                                    inCurrentInteraction.Cleanup();
                                }
                                catch (NMAntiSpyException)
                                { NFinalizeDeath.SafeForceTerminateRuntime(); throw; }
                                catch (StackOverflowException)
                                { sim.mPosture = null; throw; }
                                catch (ResetException)
                                { throw; }
                                catch (Exception)
                                {
                                    NFinalizeDeath.CheckYieldingContext();
                                }
                            }
                            else
                            {
                                inCurrentInteraction.mbOnStartCalled = true;
                                inCurrentInteraction.mbOnStopCalled  = true;
                            }
                        }

                        if (sim.IsSelectable)
                        {
                            simIQ.FireQueueChanged();
                        }

                        continue;
                    }

                    if (inCurrentInteraction.InteractionObjectPair == null)
                    {
                        continue;
                    }

                    simIQ.mIsHeadInteractionLocked = true;

                    var runningInList = simIQ.mRunningInteractions;
                    if (runningInList != null)
                    {
                        runningInList.Push(inCurrentInteraction);
                    }

                    try
                    {
                        inCurrentInteraction.CallCallbackOnStart(sim);
                    }
                    catch (NMAntiSpyException)
                    { NFinalizeDeath.SafeForceTerminateRuntime(); throw; }
                    catch (StackOverflowException)
                    { sim.mPosture = null; throw; }
                    catch (ResetException)
                    { throw; }
                    catch
                    {
                        NFinalizeDeath.CheckYieldingContext();
                    }

                    simIQ.mIsHeadInteractionActive = true;

                    try
                    {
                        if (inCurrentInteraction != null && inCurrentInteraction.Autonomous && sim.mAutonomy != null && sim.mAutonomy.IsRunningLocalAutonomy && !sim.IsActiveSim && (sim.IsSelectable || RandomUtil.GetFloat(100f) < Sim.AutonomyThoughtBalloonPercentageChance) && inCurrentInteraction.InteractionObjectPair.Tradeoff != null)
                        {
                            CommodityKind physicalOrTraitMotive = sim.Motives.GetPhysicalOrTraitMotive(inCurrentInteraction.InteractionObjectPair.Tradeoff);
                            sim.ShowBalloonForMotive(ThoughtBalloonTypes.kThoughtBalloon, ThoughtBalloonPriority.Low, ThoughtBalloonDuration.Short, ThoughtBalloonCooldown.None, ThoughtBalloonAxis.kNeutral, physicalOrTraitMotive, inCurrentInteraction.Target);
                        }
                    }
                    catch (NMAntiSpyException)
                    { NFinalizeDeath.SafeForceTerminateRuntime(); throw; }
                    catch (StackOverflowException)
                    { sim.mPosture = null; throw; }
                    catch (ResetException)
                    { throw; }
                    catch
                    {
                        NFinalizeDeath.CheckYieldingContext();
                    }

                    sim.ClearExitReasons();

                    try
                    {
                        okI = NFinalizeDeath._RunInteractionWithoutCleanUp(inCurrentInteraction);
                        if (okI)
                        {
                            inCurrentInteraction.CallCallbackOnCompletion(sim);
                        }
                        else
                        {
                            inCurrentInteraction.CallCallbackOnFailure(sim);
                        }
                    }
                    catch (NMAntiSpyException)
                    { NFinalizeDeath.SafeForceTerminateRuntime(); throw; }
                    catch (StackOverflowException)
                    {
                        NFinalizeDeath.ThrowResetException(null);
                        throw;
                    }
                    catch (ResetException)
                    { throw; }
                    catch
                    {
                        NFinalizeDeath.CheckYieldingContext();
                    }


                    sim.ClearSynchronizationData();
                    NFinalizeDeath.CheckYieldingContext();

                    if (sim.HasExitReason(ExitReason.CancelledByPosture) && !sim.Posture.HasBeenCanceled)
                    {
                        sim.Posture.CancelPosture(sim);
                    }

                    if (!inCurrentInteraction.WasInUse && sim.OnlyHasExitReason(ExitReason.ObjectInUse))
                    {
                        inCurrentInteraction.WasInUse = true;
                    }

                    if (!okI && inCurrentInteraction.Target != null && ShouldTimeUpdate(inCurrentInteraction))
                    {
                        inCurrentInteraction.Target.UpdateBlockTime();
                    }

                    if (okI && inCurrentInteraction.Target != null && sim.IsSelectable)
                    {
                        EventTracker.SendEvent(new InteractionSuccessEvent(EventTypeId.kInteractionSuccess, sim, inCurrentInteraction.Target, inCurrentInteraction.InteractionObjectPair));
                    }

                    RemoveQueue(okI, simIQ, simIQList, sim, inCurrentInteraction);

                    if (inCurrentInteraction.ShouldReenque)
                    {
                        simIQ.ConsiderReenqueing(inCurrentInteraction);
                    }

                    if (Simulator.CheckYieldingContext(false))
                    {
                        simIQ.PutDownCarriedObjects(inCurrentInteraction);
                    }

                    NFinalizeDeath.CheckYieldingContext();

                    niec_std.list_remove(simIQList, inCurrentInteraction);
                    inCurrentInteraction.Cleanup();

                    NFinalizeDeath.CheckYieldingContext();

                    while (simIQList != null && niec_std.list_remove(simIQList, null))
                    {
                        NFinalizeDeath.CheckYieldingContext();
                        Simulator.Sleep(0);
                        simIQList = simIQ.mInteractionList;
                    }

                    if (simIQList == null)
                    {
                        break;
                    }

                    if (sim.IsSelectable)
                    {
                        simIQ.FireQueueChanged();
                    }

                    if (okI)
                    {
                        break;
                    }
                }
            }
            catch (NMAntiSpyException)
            { NFinalizeDeath.SafeForceTerminateRuntime(); throw; }
            catch (StackOverflowException)
            { sim.mPosture = null; throw; }

            if (simIQ.mInteractionList != null && simIQ.mInteractionList.Count == 0)
            {
                sim.QueueIdleLogic();
            }

            return(okI);
        }
Example #5
0
        internal static void r_internal(Sim Actor)
        {
            NiecHelperSituationPosture nhsp = null;

            if (Actor != null && !NFinalizeDeath.GameObjectIsValid(Actor.ObjectId.mValue)) //NFinalizeDeath.GetObject_internalFastO(Actor.ObjectId.mValue) == null)
            {
                nhsp           = (Actor.Posture as NiecHelperSituationPosture);
                Actor.mPosture = null;
                if (nhsp != null)
                {
                    nhsp._Actor = null;
                    nhsp.PBack  = null;
                }
            }

            if (Actor == null || Actor.ObjectId.mValue != ScriptCore.Simulator.Simulator_GetCurrentTaskImpl() || !Simulator.CheckYieldingContext(false))
            {
                return;
            }

            var     sim          = Actor;
            bool    bNeedMaxMood = false;
            Posture pBackUp      = null;

            if (sim.Posture is NiecHelperSituationPosture)
            {
                nhsp         = (sim.Posture as NiecHelperSituationPosture);
                pBackUp      = nhsp.PBack;
                bNeedMaxMood = nhsp.NeedMaxMood;
                nhsp._Actor  = null;
                if (sim.Standing is NiecHelperSituationPosture)
                {
                    sim.Standing = null;
                    sim.mPosture = null;
                    if (sim.mSimDescription != null)
                    {
                        if (sim.mSimDescription.IsPet)
                        {
                            PetStandingPosture dr = new PetStandingPosture(sim);
                            sim.PetSittingOnGround = new PetSittingOnGroundPosture(sim);
                            sim.Standing           = dr;
                            sim.Posture            = null;
                        }
                        else
                        {
                            Sim.StandingPosture dre = new Sim.StandingPosture(sim);
                            sim.Standing = dre;
                            sim.Posture  = null;
                        }
                    }
                }
                else if (nhsp.PBack != null)
                {
                    sim.mPosture = nhsp.PBack;//sim.Standing;
                }
                else
                {
                    sim.mPosture = sim.Standing;
                }

                nhsp.PBack = null;
            }

            if (Disallowr_internal || (NiecHelperSituation.ExAA && sim == (NPlumbBob.DoneInitClass ? NFinalizeDeath.GetSafeSelectActor() : PlumbBob.SelectedActor)))
            {
                return;
            }

            if (!TestDEBUGMyMod && !SCOSR.IsScriptCore2020() && !IsOpenDGSInstalled &&
                NFinalizeDeath.baCheckACoreThrowNRaasErrorTrap &&
                NiecHelperSituation.__acorewIsnstalled__ &&
                NFinalizeDeath.IsSTAwesomeMod02Fast <Sim>()
                )
            {
                if (nhsp != null)
                {
                    NiecTask.Perform(delegate {
                        Simulator.Sleep(450);
                        var p = sim.mPosture;
                        if (p is NiecHelperSituationPosture)
                        {
                            return;
                        }

                        //NFinalizeDeath.Assert(nhsp != null, "r_internal(): nhsp failed!");

                        if (p != null && p == p.PreviousPosture)
                        {
                            p.PreviousPosture = null;
                        }

                        sim.mPosture = p = nhsp;
                        nhsp.PBack   = pBackUp;
                        nhsp._Actor  = sim;

                        if (p != null && p == p.PreviousPosture)
                        {
                            p.PreviousPosture = null;
                        }
                    });
                }

                NFinalizeDeath.AntiSpy_ThrowDefault();
            }

            var lookm = Actor.LookAtManager;

            if (lookm != null)
            {
                lookm.DisableLookAts();
            }


            lookm   = null; // i know Saving TaskContext Failed. From OnSavingGame()
            nhsp    = null; //
            pBackUp = null; //


            //using(SafeSimUpdate.Run(sim)) {
            while (true)
            {
                NFinalizeDeath.CheckYieldingContext();


                if (NiecHelperSituation.__acorewIsnstalled__ &&
                    !NiecHelperSituation.___bOpenDGSIsInstalled_)
                {
                    var iV = ScriptCore.Queries.Query_CountObjects(typeof(Sim));
                    if (iV >= 2)
                    {
                        NiecRunCommand.native_testcpu_debug(null, null);
                    }
                    else if (iV == 1)
                    {
                        for (int i = 0; i < 3; i++)
                        {
                            NiecRunCommand.native_testcpu_debug(null, null);
                        }
                    }
                }

                if (!IsOpenDGSInstalled && NFinalizeDeath.GetCurrentExecuteType() == ScriptExecuteType.Task)
                {
                    Simulator.Sleep(20);
                }
                else
                {
                    Simulator.Sleep(IsOpenDGSInstalled ? 15u:0u);
                }

                if (NiecHelperSituation.__acorewIsnstalled__ &&
                    !NiecHelperSituation.___bOpenDGSIsInstalled_)
                {
                    var iV = ScriptCore.Queries.Query_CountObjects(typeof(Sim));
                    if (iV >= 2)
                    {
                        NiecRunCommand.native_testcpu_debug(null, null);
                    }
                    else if (iV == 1)
                    {
                        for (int i = 0; i < 3; i++)
                        {
                            NiecRunCommand.native_testcpu_debug(null, null);
                        }
                    }
                }

                if (!NFinalizeDeath.SimIsNiecHelperSituation(sim))
                {
                    continue;
                }
                if (Simulator.GetProxy(sim.ObjectId) == null)
                {
                    break;
                }
                if (Disallowr_internal || (NiecHelperSituation.ExAA && sim == (NPlumbBob.DoneInitClass ? NFinalizeDeath.GetSafeSelectActor() : PlumbBob.SelectedActor)))
                {
                    break;
                }

                var simIQ = sim.InteractionQueue;

                try
                {
                    if (IsOpenDGSInstalled)
                    {
                        if (sim.SimDescription == null)
                        {
                            break;
                        }
                        if (simIQ == null)
                        {
                            break;
                        }
                    }
                    else
                    {
                        if (sim.SimDescription == null)
                        {
                            sim.mSimDescription = Create.NiecNullSimDescription(true, false, true);
                        }

                        if (NFinalizeDeath.SimIsGRReaper(sim.SimDescription))
                        {
                            NiecHelperSituation.ExistsOrCreateAndAddToSituationList(sim);
                        }

                        if (simIQ == null)
                        {
                            sim.mInteractionQueue = simIQ = new Sims3.Gameplay.ActorSystems.InteractionQueue(sim);
                        }
                        else
                        {
                            if (simIQ.mInteractionList == null)
                            {
                                simIQ.mInteractionList = new List <InteractionInstance>();
                            }
                            else
                            {
                                while (simIQ.mInteractionList != null && niec_std.list_remove(simIQ.mInteractionList, null)) //simIQ.mInteractionList.Remove(null))
                                {
                                    Simulator.Sleep(0);
                                }
                            }
                        }
                    }
                }
                catch (NMAntiSpyException)
                { NFinalizeDeath.SafeForceTerminateRuntime(); }
                catch (StackOverflowException)
                { sim.mPosture = null; throw; }
                catch (ResetException)
                { throw; }
                catch
                {
                    NFinalizeDeath.CheckYieldingContext();

                    if (IsOpenDGSInstalled)
                    {
                        throw;
                    }
                    else
                    {
                        for (int i = 0; i < 45; i++)
                        {
                            Simulator.Sleep(0);
                        }
                        continue;
                    }
                }

                if (bNeedMaxMood)
                {
                    try
                    {
                        NFinalizeDeath.Sim_MaxMood(sim);
                    }
                    catch (NMAntiSpyException)
                    { NFinalizeDeath.SafeForceTerminateRuntime(); }
                    catch (StackOverflowException)
                    { if (!IsOpenDGSInstalled)
                      {
                          NFinalizeDeath.ThrowResetException(null);
                      }
                      throw; }
                    catch (ResetException)
                    { throw; }
                    catch
                    {
                        NFinalizeDeath.CheckYieldingContext();

                        if (IsOpenDGSInstalled)
                        {
                            throw;
                        }
                        else
                        {
                            for (int i = 0; i < 45; i++)
                            {
                                Simulator.Sleep(0);
                            }
                            continue;
                        }
                    }
                }
                try
                {
                    if (!IsOpenDGSInstalled && sim.mAutonomy != null)
                    {
                        //var sg = sim.mAutonomy;
                        try
                        {
                            AutonomyManager.Add(sim.mAutonomy);
                        }
                        catch (NMAntiSpyException)
                        { NFinalizeDeath.SafeForceTerminateRuntime(); }
                        catch (StackOverflowException)
                        { if (!IsOpenDGSInstalled)
                          {
                              NFinalizeDeath.ThrowResetException(null);
                          }
                          throw; }
                        catch (ResetException)
                        { throw; }
                        catch { }
                    }
                    var simIQList = simIQ.mInteractionList;
                    if (simIQList == null || simIQList.Count == 0)
                    {
                        continue;
                    }

                    var simIQListArray = simIQList.ToArray();
                    for (int i = 0; i < simIQListArray.Length; i++)
                    {
                        InteractionInstance inCurrentInteraction = simIQListArray[i];
                        if (inCurrentInteraction == null || inCurrentInteraction.InteractionDefinition == null)
                        {
                            while (simIQList != null && niec_std.list_remove(simIQList, null))//simIQList.Remove(null))
                            {
                                Simulator.Sleep(0);
                                simIQList = simIQ.mInteractionList;
                            }

                            if (simIQList == null)
                            {
                                break;
                            }

                            continue;
                        }

                        if (IsOpenDGSInstalled)
                        {
                            if (simIQList.IndexOf(inCurrentInteraction) != 0)
                            {
                                break;
                            }
                        }
                        else if (i != 0)
                        {
                            break;
                        }

                        if (simIQList == null)
                        {
                            break;
                        }

                        if (!NFinalizeDeath.InteractionIsNiecHelperSituationPosture_internal(sim, inCurrentInteraction))
                        {
                            //simIQList.Remove(inCurrentInteraction);
                            niec_std.list_remove(simIQList, inCurrentInteraction);
                            if (IsOpenDGSInstalled)
                            {
                                try
                                {
                                    inCurrentInteraction.CallCallbackOnFailure(sim);
                                    inCurrentInteraction.Cleanup();
                                }
                                catch (NMAntiSpyException)
                                { NFinalizeDeath.SafeForceTerminateRuntime(); }
                                catch (StackOverflowException)
                                { sim.mPosture = null; throw; }
                                catch (ResetException)
                                { throw; }
                                catch (Exception)
                                {
                                    NFinalizeDeath.CheckYieldingContext();
                                    if (IsOpenDGSInstalled)
                                    {
                                        throw;
                                    }
                                }
                            }
                            else
                            {
                                if (inCurrentInteraction.Target is Sim)
                                {
                                    inCurrentInteraction.mInstanceActor = inCurrentInteraction.Target;
                                }
                            }

                            if (sim.IsSelectable)
                            {
                                simIQ.FireQueueChanged();
                            }

                            break;
                        }

                        if (!Bim.TestInteractionEx(inCurrentInteraction) || (IsOpenDGSInstalled && !inCurrentInteraction.IsTargetValid()))
                        {
                            // simIQList.Remove(inCurrentInteraction);
                            niec_std.list_remove(simIQList, inCurrentInteraction);
                            try
                            {
                                inCurrentInteraction.CallCallbackOnFailure(sim);
                                inCurrentInteraction.Cleanup();
                            }
                            catch (NMAntiSpyException)
                            { NFinalizeDeath.SafeForceTerminateRuntime(); }
                            catch (StackOverflowException)
                            { sim.mPosture = null; throw; }
                            catch (ResetException)
                            { throw; }
                            catch (Exception)
                            {
                                NFinalizeDeath.CheckYieldingContext();
                                if (IsOpenDGSInstalled)
                                {
                                    throw;
                                }
                            }

                            //if (IsOpenDGSInstalled)
                            //    simIQ.DeQueue(false);

                            if (sim.IsSelectable)
                            {
                                simIQ.FireQueueChanged();
                            }

                            continue;
                        }

                        simIQ.mIsHeadInteractionLocked = true;

                        var runningInList = simIQ.mRunningInteractions;
                        if (runningInList != null)
                        {
                            runningInList.Push(inCurrentInteraction);
                        }

                        try
                        {
                            inCurrentInteraction.CallCallbackOnStart(sim);
                        }
                        catch (NMAntiSpyException)
                        { NFinalizeDeath.SafeForceTerminateRuntime(); }
                        catch (StackOverflowException)
                        { sim.mPosture = null; throw; }
                        catch (ResetException)
                        { throw; }
                        catch
                        {
                            NFinalizeDeath.CheckYieldingContext();
                            if (IsOpenDGSInstalled)
                            {
                                throw;
                            }
                        }


                        simIQ.mIsHeadInteractionActive = true;

                        bool okI = false;

                        try
                        {
                            okI = NFinalizeDeath._RunInteractionWithoutCleanUp(inCurrentInteraction);
                            if (okI)
                            {
                                inCurrentInteraction.CallCallbackOnCompletion(sim);
                            }
                            else
                            {
                                inCurrentInteraction.CallCallbackOnFailure(sim);
                            }
                        }
                        catch (NMAntiSpyException)
                        { NFinalizeDeath.SafeForceTerminateRuntime(); }
                        catch (StackOverflowException)
                        {
                            if (!IsOpenDGSInstalled)
                            {
                                try
                                {
                                    NiecTask.Perform(inCurrentInteraction.Cleanup);
                                }
                                catch (StackOverflowException)
                                {}

                                NFinalizeDeath.ThrowResetException(null);
                            }
                            throw;
                        }
                        catch (ResetException)
                        { throw; }
                        catch
                        {
                            NFinalizeDeath.CheckYieldingContext();
                            if (IsOpenDGSInstalled)
                            {
                                throw;
                            }
                        }


                        if (IsOpenDGSInstalled && Simulator.CheckYieldingContext(false))
                        {
                            simIQ.PutDownCarriedObjects(inCurrentInteraction);
                        }

                        simIQ = sim.InteractionQueue;
                        if (simIQ == null)
                        {
                            inCurrentInteraction.Cleanup();
                            break;
                        }

                        NFinalizeDeath.CheckYieldingContext();

                        if (IsOpenDGSInstalled)
                        {
                            simIQ.PutDownCarriedObjects(inCurrentInteraction);
                        }

                        simIQ.mIsHeadInteractionActive = false;
                        simIQ.mIsHeadInteractionLocked = false;

                        //if (IsOpenDGSInstalled)
                        //    simIQ.DeQueue(okI);

                        if (runningInList != null && runningInList.Count > 0)
                        {
                            runningInList.Pop();
                        }

                        simIQList = simIQ.mInteractionList;
                        if (simIQList == null)
                        {
                            inCurrentInteraction.Cleanup();
                            break;
                        }

                        NFinalizeDeath.CheckYieldingContext();

                        //simIQList.Remove(inCurrentInteraction);
                        niec_std.list_remove(simIQList, inCurrentInteraction);
                        inCurrentInteraction.Cleanup();

                        NFinalizeDeath.CheckYieldingContext();

                        while (simIQList != null && niec_std.list_remove(simIQList, null))
                        {
                            Simulator.Sleep(0);
                            simIQList = simIQ.mInteractionList;
                        }

                        if (simIQList == null)
                        {
                            break;
                        }

                        if (sim.IsSelectable)
                        {
                            simIQ.FireQueueChanged();
                        }
                    }
                }
                catch (NMAntiSpyException)
                { NFinalizeDeath.SafeForceTerminateRuntime(); }
                catch (StackOverflowException)
                { sim.mPosture = null; throw; }
                catch (ResetException)
                { throw; }
                catch
                {
                    NFinalizeDeath.CheckYieldingContext();

                    if (IsOpenDGSInstalled)
                    {
                        throw;
                    }
                    else
                    {
                        for (int i = 0; i < 45; i++)
                        {
                            Simulator.Sleep(0);
                        }
                        continue;
                    }
                }
            }//}
             //NFinalizeDeath.M();
        }