Example #1
0
//		public static string LocalizeString(string name, params object[] parameters)
//		{
//			return Localization.LocalizeString("Gameplay/Objects/Electronics/Computer/LeaveBookClub:" + name, parameters);
//		}

        public override bool Run()
        {
            base.StandardEntry();
            if (!base.Target.StartComputing(this, SurfaceHeight.Table, true))
            {
                base.StandardExit();
                return(false);
            }
            base.Target.StartVideo(Computer.VideoType.Browse);
            base.BeginCommodityUpdates();
            base.AnimateSim("WorkTyping");
            if (TwoButtonDialog.Show(Localization.LocalizeString("Lyralei/Localized/LeavePatternClubDesc:InteractionName", new object[0]), Localization.LocalizeString("Lyralei/Localized/LeavePatternClubYES:InteractionName", new object[0]), Localization.LocalizeString("Lyralei/Localized/LeavePatternClubNO:InteractionName", new object[0])))
            {
                SimDescription ActorDesc = base.Actor.SimDescription;
                if (GlobalOptionsSewingTable.retrieveData.whoIsInPatternClub.ContainsKey(ActorDesc.mSimDescriptionId))
                {
                    GlobalOptionsSewingTable.retrieveData.whoIsInPatternClub.Remove(ActorDesc.mSimDescriptionId);
                }
                Mailbox mailbox = Mailbox.GetMailboxOnLot(base.Actor.LotHome);
                mailbox.RemoveAlarm(GlobalOptionsSewingTable.mPatternClubAlarm);
                GlobalOptionsSewingTable.mPatternClubAlarm = AlarmHandle.kInvalidHandle;
            }
            base.Target.StopComputing(this, Computer.StopComputingAction.TurnOff, false);
            base.EndCommodityUpdates(true);
            base.StandardExit();
            return(true);
        }
Example #2
0
        public override bool Run()
        {
            base.StandardEntry();
            if (!base.Target.StartComputing(this, SurfaceHeight.Table, true))
            {
                base.StandardExit();
                return(false);
            }
            mActor = Actor;
            base.Target.StartVideo(Computer.VideoType.Browse);
            base.BeginCommodityUpdates();
            base.AnimateSim("WorkTyping");
            bool flag = TwoButtonDialog.Show(Localization.LocalizeString("Lyralei/Localized/BuyClothingPatternDialog:InteractionName"), Localization.LocalizeString("Ui/Caption/Global:Yes", new object[0]), Localization.LocalizeString("Ui/Caption/Global:No", new object[0]));

            if (flag)
            {
                if (base.Actor.FamilyFunds >= kCost)
                {
                    base.Actor.ModifyFunds(-kCost);
                }
                else if (!GameUtils.IsFutureWorld())
                {
                    //base.Actor.UnpaidBills += kCost;
                    StyledNotification.Format format = new StyledNotification.Format(Localization.LocalizeString("Lyralei/Localized/NotEnoughMoney:Test", new object[0]), base.Actor.ObjectId, base.Target.ObjectId, StyledNotification.NotificationStyle.kGameMessageNegative);
                    StyledNotification.Show(format);
                }
                Pattern        pattern   = Pattern.GetRandomClothingPattern(base.Actor);
                SimDescription ActorDesc = Actor.SimDescription;
                base.Actor.ShowTNSIfSelectable(Localization.LocalizeString("Lyralei/Localized/GotPattern:InteractionName", new object[0]) + pattern.mPatternInfo.Name, StyledNotification.NotificationStyle.kGameMessagePositive);
            }
            base.Target.StopComputing(this, Computer.StopComputingAction.TurnOff, false);
            base.EndCommodityUpdates(flag);
            base.StandardExit();
            return(true);
        }
Example #3
0
        public static bool Run(AlienUtils.ReturnAlienBaby ths)
        {
            bool flag = TwoButtonDialog.Show(
                Localization.LocalizeString("Duglarogg/Abductor/Interactions/ReturnAlienBabyEx:Dialogue"),
                Localization.LocalizeString("Duglarogg/Abductor/Interactions/ReturnAlienBabyEx:DialogueAccept"),
                Localization.LocalizeString("Duglarogg/Abductor/Interactions/ReturnAlineBabyEx:DialogueReject"));

            if (flag)
            {
                SimDescription description = ths.Target.SimDescription;
                ths.Target.DisableInteractions();
                ths.Target.InteractionQueue.CancelAllInteractions();
                ths.mEffect = VisualEffect.Create("ep8BabyTeleportFx");
                ths.mEffect.SetPosAndOrient(ths.Target.Position, ths.Target.ForwardVector, ths.Target.UpVector);
                ths.mEffect.Start();
                ths.Target.FadeOut(true);
                List <IGenealogy> list = new List <IGenealogy>(description.Genealogy.IParents);
                list.AddRange(description.Genealogy.ISiblings);

                foreach (IGenealogy current in list)
                {
                    description.Genealogy.RemoveDirectRelation(current);
                }

                ths.Actor.Household.Remove(description);
                description.Dispose();
                Simulator.Sleep(30u);
            }

            return(true);
        }
Example #4
0
        public override bool Run()
        {
            bool flag = TwoButtonDialog.Show(
                Common.Localize("ReturnAlienBabyEx:Dialogue", Actor.IsFemale, new object[] { Actor }),
                Common.Localize("ReturnAlienBabyEx:DialogueAccept"),
                Common.Localize("ReturnAlienBabyEx:DialogueReject"));

            if (flag)
            {
                Target.DisableInteractions();
                Target.InteractionQueue.CancelAllInteractions();
                mEffect = VisualEffect.Create("ep8BabyTeleportFx");
                mEffect.SetPosAndOrient(Target.Position, Target.ForwardVector, Target.UpVector);
                mEffect.Start();
                Target.FadeOut(true);
                List <IGenealogy> list = new List <IGenealogy>(Target.SimDescription.Genealogy.IParents);
                list.AddRange(Target.SimDescription.Genealogy.ISiblings);

                foreach (IGenealogy current in list)
                {
                    Target.SimDescription.Genealogy.RemoveDirectRelation(current);
                }

                Actor.Household.Remove(Target.SimDescription);
                Target.SimDescription.Dispose();
                Simulator.Sleep(30u);
            }

            return(flag);
        }
Example #5
0
        public static bool Run(AlienUtils.ReturnAlienBaby returnBaby)
        {
            Common.DebugNotify("ReturnAlienBabyEx" + Common.NewLine
                               + " - Actor:" + returnBaby.Actor.FullName + Common.NewLine
                               + " - Target: " + returnBaby.Target.FullName);

            bool flag = TwoButtonDialog.Show(
                Common.Localize("ReturnAlienBabyEx:Dialogue"),
                Common.Localize("ReturnAlienBabyEx:DialogueAccept"),
                Common.Localize("ReturnAlienBabyEx:DialogueReject"));

            if (flag)
            {
                AgingManager.Singleton.CancelAgingAlarmsForSim(returnBaby.Target.SimDescription.AgingState);
                returnBaby.Target.DisableInteractions();
                returnBaby.Target.InteractionQueue.CancelAllInteractions();
                returnBaby.mEffect = VisualEffect.Create("ep8BabyTeleportFx");
                returnBaby.mEffect.SetPosAndOrient(returnBaby.Target.Position, returnBaby.Target.ForwardVector, returnBaby.Target.UpVector);
                returnBaby.mEffect.Start();
                returnBaby.Target.FadeOut(true);
                List <IGenealogy> list = new List <IGenealogy>(returnBaby.Target.Genealogy.IParents);
                list.AddRange(returnBaby.Target.Genealogy.ISiblings);

                foreach (IGenealogy current in list)
                {
                    returnBaby.Target.Genealogy.RemoveDirectRelation(current);
                }

                returnBaby.Actor.Household.Remove(returnBaby.Target.SimDescription);
                returnBaby.Target.SimDescription.Dispose();
                Simulator.Sleep(30u);
            }

            return(true);
        }
Example #6
0
        public override bool Run()
        {
            try
            {
                if (!Target.StartComputing(this, SurfaceHeight.Table, true))
                {
                    return(false);
                }

                if (!UIUtils.IsOkayToStartModalDialog())
                {
                    return(false);
                }

                Target.StartVideo(Computer.VideoType.Browse);
                AnimateSim("GenericTyping");

                string failReason = null;
                if (((Actor.Household == Household.ActiveHousehold) && !MovingSituation.MovingInProgress) && InWorldSubState.IsEditTownValid(Actor.LotHome, ref failReason))
                {
                    Definition interactionDefinition = InteractionDefinition as Definition;
                    if (interactionDefinition.LocalMove)
                    {
                        if (!Household.ActiveHousehold.LotHome.IsApartmentLot && (Household.ActiveHousehold.GetNumberOfRoommates() > 0))
                        {
                            if (!TwoButtonDialog.Show(Localization.LocalizeString("Ui/Caption/Roommates:MovingDismissConfirmation", new object[0]), LocalizationHelper.Yes, LocalizationHelper.No))
                            {
                                Target.StopComputing(this, Computer.StopComputingAction.TurnOff, false);
                                return(true);
                            }

                            Household.RoommateManager.StopAcceptingRoommates(true);
                        }

                        MovingDialogEx.Show(new GameplayMovingModelEx(Actor));
                    }
                    else
                    {
                        MovingWorldsModel model = new MovingWorldsModel(Actor);
                        MovingWorldDialog.Show(model);
                        if ((model.WorldName != null) && MovingWorldUtil.VerifyWorldMove())
                        {
                            Common.FunctionTask.Perform(model.TriggerSaveAndTravel);
                        }
                    }
                }

                Target.StopComputing(this, Computer.StopComputingAction.TurnOff, false);
                return(true);
            }
            catch (ResetException)
            {
                throw;
            }
            catch (Exception e)
            {
                Common.Exception(Actor, Target, e);
                return(false);
            }
        }
Example #7
0
        public Menu()
        {
            InitializeComponent();

            vm         = DataContext as MenuViewModel;
            parentView = Application.Current.MainWindow as Shell;

            Messenger.Instance[MessengerType.NewVersionFound].GetEvent <PubSubEvent <string> >().Subscribe(x =>
            {
                Runner runner = Service.Provider.GetService <Runner>();
                if (runner.IsProcessing == false)
                {
                    NewVersionFound(x);
                }
            });

            Messenger.Instance[MessengerType.ReadSettingFile].GetEvent <PubSubEvent <string> >().Subscribe(async x =>
            {
                var dialog = new TwoButtonDialog(
                    Properties.Resources.Dialog_DropSettingFile_Title,
                    Properties.Resources.Dialog_DropSettingFile_Message,
                    Properties.Resources.Common_Yes,
                    Properties.Resources.Common_No);
                var result = await parentView.dialogHostMain.ShowDialog(dialog) as Selected?;
                if (result == Selected.Negative)
                {
                    return;
                }

                vm.ReadSettingFile(x);
            });
        }
Example #8
0
        async void Page_Drop(object sender, DragEventArgs e)
        {
            var element = e.Source as FrameworkElement;

            if (element?.Name.Contains("DropAllowedControl") ?? false)
            {
                // ignore since the handler of the child control is being executed
                return;
            }

            var dialog = new TwoButtonDialog(
                Properties.Resources.Dialog_DropSettingFile_Title,
                Properties.Resources.Dialog_DropSettingFile_Message,
                Properties.Resources.Common_Yes,
                Properties.Resources.Common_No);
            var result = await parentView.dialogHostMain.ShowDialog(dialog) as Selected?;

            if (result == Selected.Negative)
            {
                return;
            }

            var dropFileList = (e.Data.GetData(DataFormats.FileDrop) as string[]).ToList();

            vm.LoadSetting(dropFileList.FirstOrDefault());
        }
Example #9
0
        public static bool PreTimeTravel1(InteractionInstance ths)
        {
            if (!UIUtils.IsOkayToStartModalDialog())
            {
                return(false);
            }

            Sim actor = ths.InstanceActor as Sim;

            TravelUtil.PlayerMadeTravelRequest = true;
            OpportunityNames guid = CheckOpportunities(actor);

            string prompt;

            if (GameUtils.IsFutureWorld())
            {
                prompt = TimePortal.LocalizeString("ConfirmReturn", new object[0x0]);
            }
            else if (guid != OpportunityNames.Undefined)
            {
                prompt = TimePortal.LocalizeString("ConfirmWarningTravel", new object[0x0]);
            }
            else
            {
                prompt = TimePortal.LocalizeString("ConfirmTravel", new object[0x0]);
            }
            if (!TwoButtonDialog.Show(prompt, Localization.LocalizeString("Ui/Caption/Global:Accept", new object[0x0]), Localization.LocalizeString("Ui/Caption/Global:Cancel", new object[0x0])))
            {
                TravelUtil.PlayerMadeTravelRequest = false;
                return(false);
            }

            //Sims3.Gameplay.Gameflow.Singleton.DisableSave(this, "Ui/Caption/HUD/DisasterSaveError:Traveling");
            ths.CancellableByPlayer = false;
            if ((guid != OpportunityNames.Undefined) && (actor.OpportunityManager != null))
            {
                actor.OpportunityManager.CancelOpportunity(guid);
            }

            if (actor.OpportunityManager != null)
            {
                if (actor.OpportunityManager.HasOpportunity(OpportunityNames.EP11_HelpingTheTimeTraveler01))
                {
                    actor.OpportunityManager.CancelOpportunity(OpportunityNames.EP11_HelpingTheTimeTraveler01);
                }

                if (actor.OpportunityManager.HasOpportunity(OpportunityNames.EP11_HelpingTheTimeTraveler02))
                {
                    actor.OpportunityManager.CancelOpportunity(OpportunityNames.EP11_HelpingTheTimeTraveler02);
                }

                if (GameUtils.IsFutureWorld() && actor.OpportunityManager.HasOpportunity(OpportunityNames.EP11_RecalibrateDefenseGrid))
                {
                    actor.OpportunityManager.CancelOpportunity(OpportunityNames.EP11_RecalibrateDefenseGrid);
                }
            }

            return(true);
        }
Example #10
0
        public override void GetNewBorns()
        {
            mNewborns = new List <Sim>();
            Sims3.Gameplay.Gameflow.Singleton.DisableSave(this, "Gameplay/ActorSystems/Pregnancy:DisableSave");
            bool keepBaby = false;

            //if (Actor.Household.NumActorMembersCountingPregnancy < 0x8)
            {
                // Custom
                if (SimTypes.IsSelectable(Actor))
                {
                    keepBaby = TwoButtonDialog.Show(AlienUtils.LocalizeString("MalePregnancyConfirmationDialog", new object[] { Actor }), AlienUtils.LocalizeString("MalePregnancyConfirmationDialogAccept", new object[0x0]), AlienUtils.LocalizeString("MalePregnancyConfirmationDialogReject", new object[0x0]));
                }
                else
                {
                    keepBaby = true;
                }
            }

            /*else
             * {
             *  Actor.ShowTNSIfSelectable(AlienUtils.LocalizeString("MalePregnancyHouseholdFullTNS", new object[] { Actor }), StyledNotification.NotificationStyle.kGameMessagePositive, ObjectGuid.InvalidObjectGuid, Actor.ObjectId);
             * }*/

            CASAgeGenderFlags gender       = RandomUtil.CoinFlip() ? CASAgeGenderFlags.Male : CASAgeGenderFlags.Female;
            SimDescription    description2 = SimDescription.Find(this.AlienParentID);
            SimDescription    newSim       = Genetics.MakeAlien(CASAgeGenderFlags.Baby, gender, GameUtils.GetCurrentWorld(), 1f, false);

            newSim.LastName = Actor.LastName;
            if ((keepBaby) && (SimTypes.IsSelectable(Actor)))
            {
                newSim.FirstName = string.Empty;
            }

            Genetics.AssignTraits(newSim, null, Actor.SimDescription, (keepBaby) && (SimTypes.IsSelectable(Actor)), (float)Actor.MoodManager.MoodValue, new Random());
            Actor.Genealogy.AddChild(newSim.Genealogy);
            if (description2 != null)
            {
                description2.Genealogy.AddChild(newSim.Genealogy);
            }

            if (keepBaby)
            {
                Actor.Household.Add(newSim);
            }
            else
            {
                Household.AlienHousehold.Add(newSim);
            }

            Sim babyToHide = newSim.Instantiate(Vector3.Empty);

            babyToHide.GreetSimOnLot(Actor.LotCurrent);
            babyToHide.SetPosition(Actor.Position);
            Pregnancy.TotallyHideBaby(babyToHide);
            mNewborns.Add(babyToHide);
        }
Example #11
0
        public static bool AdoptFrankenSim(Sim creator, Sim frankenSim)
        {
            //if (creator.Household.CanAddSpeciesToHousehold(CASAgeGenderFlags.Human))
            {
                string         str   = "AdoptFrankenSim";
                InventingSkill skill = creator.SkillManager.GetSkill <InventingSkill>(SkillNames.Inventing);
                if ((skill != null) && skill.OppKnowFrankensimRecipeCompleted)
                {
                    str = "AdoptFrankenSimAgain";
                }

                SimDescription simDescription = frankenSim.SimDescription;
                if (TwoButtonDialog.Show(Localization.LocalizeString("Gameplay/Objects/HobbiesSkills/Inventing/InventionWorkbench:" + str, new object[] { creator }), Localization.LocalizeString("Gameplay/Objects/HobbiesSkills/Inventing/InventionWorkbench:AdoptFrankenSimYes", new object[0x0]), Localization.LocalizeString("Gameplay/Objects/HobbiesSkills/Inventing/InventionWorkbench:AdoptFrankenSimNo", new object[0x0])))
                {
                    VisitSituation situation = VisitSituation.FindVisitSituationInvolvingGuest(frankenSim);
                    if (situation != null)
                    {
                        situation.Exit();
                    }

                    Household.NpcHousehold.Remove(simDescription);
                    creator.Household.Add(simDescription);
                    string str2 = StringInputDialog.Show(Localization.LocalizeString("Gameplay/Objects/HobbiesSkills/Inventing/InventionWorkbench:AdoptFrankenSimNameTitle", new object[0x0]), Localization.LocalizeString("Gameplay/Objects/HobbiesSkills/Inventing/InventionWorkbench:AdoptFrankenSimNamePrompt", new object[] { creator }), frankenSim.FirstName);
                    if (!string.IsNullOrEmpty(str2))
                    {
                        simDescription.FirstName = str2;
                    }

                    frankenSim.OnBecameSelectable();
                    return(true);
                }

                Household.NpcHousehold.Remove(simDescription);
                Household household = Household.Create();
                household.Name = simDescription.LastName;
                household.Add(simDescription);
                household.FindSuitableVirtualHome();
                creator.ShowTNSIfSelectable(Localization.LocalizeString("Gameplay/Objects/HobbiesSkills/Inventing/InventionWorkbench:SimBotNotAdopted", new object[] { creator }), StyledNotification.NotificationStyle.kGameMessagePositive, frankenSim.ObjectId);
                Sim.MakeSimGoHome(frankenSim, false);
                return(false);
            }

            /*
             * string message = Localization.LocalizeString("Gameplay/Objects/HobbiesSkills/Inventing/InventionWorkbench:AdoptFrankenFullHousehold", new object[] { creator });
             * creator.ShowTNSIfSelectable(message, StyledNotification.NotificationStyle.kGameMessageNegative);
             * Sim.MakeSimGoHome(frankenSim, false);
             * return false;
             */
        }
Example #12
0
        async void StartButton_Click(object sender, RoutedEventArgs e)
        {
            // Working directory is empty
            if (string.IsNullOrEmpty(vm.WorkingDirectory))
            {
                var overwriteDialog = new OneButtonDialog(Properties.Resources.Dialog_DirectoryEmpty_Title, Properties.Resources.Dialog_DirectoryEmpty_Message_WorkingDirectory);
                await parentView.dialogHostMain.ShowDialog(overwriteDialog);

                return;
            }

            // Output file is empty
            if (string.IsNullOrEmpty(vm.OutputFile))
            {
                var overwriteDialog = new OneButtonDialog(Properties.Resources.Dialog_FileNameEmpty_Title, Properties.Resources.Dialog_FileNameEmpty_Message_OutputFile);
                await parentView.dialogHostMain.ShowDialog(overwriteDialog);

                return;
            }

            // Output file already exists
            if (File.Exists(vm.OutputFile))
            {
                var overwriteDialog = new TwoButtonDialog(
                    Properties.Resources.Dialog_FileExists_Title,
                    Path.GetFileName(vm.OutputFile) + " " + Properties.Resources.Dialog_FileExists_Message + Environment.NewLine + Properties.Resources.Dialog_FileExists_Message_Overwrite,
                    Properties.Resources.Common_Yes,
                    Properties.Resources.Common_No);
                var result = await parentView.dialogHostMain.ShowDialog(overwriteDialog) as Selected?;

                if (result == Selected.Negative)
                {
                    return;
                }
            }

            // Start
            var processingDialog = new ProcessingDialogDetail(Properties.Resources.Dialog_Processing_Title, Properties.Resources.Dialog_Processing_Started);
            var re = parentView.dialogHostMain.ShowDialog(processingDialog, async(object s, DialogOpenedEventArgs args) =>
            {
                processingDialog.Button.IsEnabled = false;
                processingDialog.Button.IsEnabled = false;
                await vm.StartAsync();

                processingDialog.Message.Content             = Properties.Resources.Dialog_Processing_Completed;
                processingDialog.ProgressBar.IsIndeterminate = false;
                processingDialog.Button.IsEnabled            = true;
            });
        }
Example #13
0
        public static void OnCloseClick(WindowBase sender, UIButtonClickEventArgs eventArgs)
        {
            try
            {
                CASPuck ths = CASPuck.gSingleton;
                if (ths == null)
                {
                    return;
                }

                //Common.DebugNotify(delegate { return "UiBusy: " + ths.mUiBusy + Common.NewLine + "LeaveCAS: " + ths.mLeaveCAS; });

                //if (!ths.UiBusy && !ths.mLeaveCAS)
                {
                    ths.UiBusy = true;
                    Simulator.AddObject(new Sims3.UI.OneShotFunctionTask(delegate
                    {
                        string entryKey = (Responder.Instance.CASModel.CASMode == CASMode.Full) ? "Ui/Caption/CAS/ExitDialog:Prompt" : "Ui/Caption/CAS/ExitDialog:AlternatePrompt";
                        if (TwoButtonDialog.Show(Common.LocalizeEAString(entryKey), Common.LocalizeEAString("Ui/Caption/Global:Yes"), Common.LocalizeEAString("Ui/Caption/Global:No")))
                        {
                            CASController singleton = CASController.Singleton;
                            singleton.AllowCameraMovement(false);

                            ICASModel cASModel = Responder.Instance.CASModel;
                            while (cASModel.IsProcessing())
                            {
                                SpeedTrap.Sleep();
                            }

                            Sims.CASBase.sWasCanceled = true;

                            sender.Enabled = false;
                            cASModel.RequestClearChangeReport();
                            singleton.SetCurrentState(CASState.None);
                        }
                        else
                        {
                            ths.UiBusy = false;
                        }
                    }));
                    eventArgs.Handled = true;
                }
            }
            catch (Exception e)
            {
                Common.Exception("OnCloseClick", e);
            }
        }
Example #14
0
        public override Phone.Call.ConversationBehavior OnCallConnected()
        {
            try
            {
                if (UIUtils.IsOkayToStartModalDialog())
                {
                    string failReason = null;
                    if (((Actor.Household == Household.ActiveHousehold) && !MovingSituation.MovingInProgress) && InWorldSubState.IsEditTownValid(Actor.LotHome, ref failReason))
                    {
                        Definition interactionDefinition = InteractionDefinition as Definition;
                        if (interactionDefinition.LocalMove)
                        {
                            if (!Household.ActiveHousehold.LotHome.IsApartmentLot && (Household.ActiveHousehold.GetNumberOfRoommates() > 0))
                            {
                                if (!TwoButtonDialog.Show(Localization.LocalizeString("Ui/Caption/Roommates:MovingDismissConfirmation", new object[0]), LocalizationHelper.Yes, LocalizationHelper.No))
                                {
                                    return(Phone.Call.ConversationBehavior.JustHangUp);
                                }

                                Household.RoommateManager.StopAcceptingRoommates(true);
                            }

                            MovingDialogEx.Show(new GameplayMovingModelEx(Actor));
                        }
                        else
                        {
                            MovingWorldsModel model = new MovingWorldsModel(Actor);
                            MovingWorldDialog.Show(model);
                            if ((model.WorldName != null) && MovingWorldUtil.VerifyWorldMove())
                            {
                                Common.FunctionTask.Perform(model.TriggerSaveAndTravel);
                            }
                        }
                    }
                }
            }
            catch (ResetException)
            {
                throw;
            }
            catch (Exception e)
            {
                Common.Exception(Actor, Target, e);
            }
            return(Phone.Call.ConversationBehavior.JustHangUp);
        }
Example #15
0
        async void Page_Drop(object sender, DragEventArgs e)
        {
            var dialog = new TwoButtonDialog(
                Properties.Resources.Dialog_DropSettingFile_Title,
                Properties.Resources.Dialog_DropSettingFile_Message,
                Properties.Resources.Common_Yes,
                Properties.Resources.Common_No);
            var result = await parentView.dialogHostMain.ShowDialog(dialog) as Selected?;

            if (result == Selected.Negative)
            {
                return;
            }

            var dropFileList = (e.Data.GetData(DataFormats.FileDrop) as string[]).ToList();

            vm.ReadSettingFile(dropFileList.FirstOrDefault());
        }
Example #16
0
                public override PhoneCall.QueryResponse GetQueryResponse(Sim sim)
                {
                    if (mInvitationKeys == null)
                    {
                        HouseParty.PartyInvitationKeys kDefaultPartyKeys = HouseParty.kDefaultPartyKeys;
                    }
                    SimDescription description = ManagerSim.Find(mHostDescriptionId);
                    Sim            sim2        = (description != null) ? description.CreatedSim : null;

                    if (sim2 == null)
                    {
                        return(PhoneCall.QueryResponse.JustHangUp);
                    }
                    if (!TwoButtonDialog.Show(Common.LocalizeEAString(sim.IsFemale, mInvitationKeys.InvitationKey, new object[] { sim, sim2, mStartTime }), Common.LocalizeEAString(mInvitationKeys.AcceptKey), Common.LocalizeEAString(mInvitationKeys.RejectKey)))
                    {
                        return(PhoneCall.QueryResponse.RespondNegatively);
                    }
                    return(PhoneCall.QueryResponse.RespondPositively);
                }
Example #17
0
        async void SaveButton_Click(object sender, RoutedEventArgs e)
        {
            var dialog = new CommonOpenFileDialog
            {
                Title            = Properties.Resources.Common_OpenFileDialog_Title_SaveSetting,
                IsFolderPicker   = false,
                InitialDirectory = startupPath,
                DefaultDirectory = startupPath,
            };

            dialog.Filters.Add(new CommonFileDialogFilter(Properties.Resources.Common_OpenFileDialog_FileType_Json, "*.json"));
            dialog.Filters.Add(new CommonFileDialogFilter(Properties.Resources.Common_OpenFileDialog_FileType_All, "*.*"));

            if (vm.WorkingDirectory != string.Empty)
            {
                dialog.InitialDirectory = vm.WorkingDirectory;
            }

            if (dialog.ShowDialog() != CommonFileDialogResult.Ok)
            {
                return;
            }

            // The setting file already exists
            if (File.Exists(dialog.FileName))
            {
                var overwriteDialog = new TwoButtonDialog(
                    Properties.Resources.Dialog_FileExists_Title,
                    Path.GetFileName(dialog.FileName) + " " + Properties.Resources.Dialog_FileExists_Message + Environment.NewLine + Properties.Resources.Dialog_FileExists_Message_Overwrite,
                    Properties.Resources.Common_Yes,
                    Properties.Resources.Common_No);
                var result = await parentView.dialogHostMain.ShowDialog(overwriteDialog) as Selected?;

                if (result == Selected.Negative)
                {
                    return;
                }
            }

            vm.SaveSetting(dialog.FileName);
        }
Example #18
0
        protected override bool Run(SimDescription me, bool singleSelection)
        {
            if (!ApplyAll)
            {
                string text = StringInputDialog.Show(Name, Common.Localize(GetTitlePrefix() + ":Prompt", me.IsFemale, new object[] { me }), "0");
                if (string.IsNullOrEmpty(text))
                {
                    return(false);
                }

                if (!int.TryParse(text, out mRange))
                {
                    SimpleMessageDialog.Show(Name, Common.Localize("Numeric:Error"));
                    return(false);
                }

                if (mRange <= 0)
                {
                    return(false);
                }

                mAdd = false;

                if (TwoButtonDialog.Show(
                        Common.Localize(GetTitlePrefix() + ":AddPrompt", me.IsFemale, new object[] { me, mRange }),
                        Common.Localize(GetTitlePrefix() + ":Add"),
                        Common.Localize(GetTitlePrefix() + ":Reroll")
                        ))
                {
                    mAdd = true;
                }
            }

            float maximum = MasterController.Settings.mSliderMultiple;

            Vector2 range = new Vector2(-mRange / 256f, mRange / 256f);

            FacialBlends.RandomizeBlends(null, me, range, mAdd, range, true, false);

            return(true);
        }
Example #19
0
            public static void GoToLotSuccessEx(Sim sim, float f)
            {
                if (sim.LotCurrent == null)
                {
                    return;
                }

                ServiceData    data   = KamaSimtra.Settings.FindServiceDataInvolvingProfessionalAndLot(sim.SimDescription.SimDescriptionId, sim.LotCurrent.LotId);
                SimDescription client = SimDescription.Find(data.mRequester);

                if (data != null && client != null && client.CreatedSim != null)
                {
                    Relationship relationship = Relationship.Get(client, sim.SimDescription, true);
                    if (relationship != null)
                    {
                        relationship.STC.Set(client.CreatedSim, sim, CommodityTypes.Amorous, 500f);
                        client.CreatedSim.InteractionQueue.CancelAllInteractions();
                        while (client.CreatedSim.CurrentInteraction != null)
                        {
                            Common.Sleep(0);
                        }

                        data.SetupAlarm();
                        data.DisableAutonomy();

                        client.CreatedSim.GreetSimOnMyLotIfPossible(sim);
                        CommonWoohoo.WoohooStyle style = CommonWoohoo.WoohooStyle.Safe;
                        if (!Woohooer.Settings.ReplaceWithRisky && TwoButtonDialog.Show(Woohooer.Localize("FriskyConfirm:Prompt", sim.IsFemale, new object[] { sim, client.CreatedSim }), Woohooer.Localize("FriskyConfirm:Yes", sim.IsFemale, new object[] { sim, client.CreatedSim }), Woohooer.Localize("FriskyConfirm:No", sim.IsFemale, new object[] { sim, client.CreatedSim })))
                        {
                            style = CommonWoohoo.WoohooStyle.Risky;
                        }
                        data.mStyle = style;
                        KamaSimtra.Settings.SetServiceData(data.mRequester, data);

                        new CommonWoohoo.PushWoohoo(sim, client.CreatedSim, false, style);

                        StyledNotification.Format format = new StyledNotification.Format(Common.Localize("OrderServices:Arrived", sim.IsFemale), sim.ObjectId, client.CreatedSim.ObjectId, StyledNotification.NotificationStyle.kSimTalking);
                        StyledNotification.Show(format);
                    }
                }
            }
Example #20
0
            public override bool Perform(Household house)
            {
                int purchase = 0;

                if (mType == OwnerType.NotOwned)
                {
                    purchase = mHole.RabbitHoleTuning.kInvestCost;
                }
                else
                {
                    if (mType == OwnerType.Partial)
                    {
                        if (TwoButtonDialog.Show(
                                Common.Localize("RealEstate:BuyPrompt", false, new object[] { house.Name, mHole.CatalogName }),
                                Common.Localize("RealEstate:Full"),
                                Common.Localize("RealEstate:Sell")
                                ))
                        {
                            purchase = mHole.RabbitHoleTuning.kBuyoutCost;
                        }
                    }
                }

                if (purchase > 0)
                {
                    if (purchase > house.FamilyFunds)
                    {
                        return(false);
                    }

                    house.RealEstateManager.PurchaseorUpgradeRabbitHole(mHole);
                    return(true);
                }
                else
                {
                    house.RealEstateManager.SellProperty(house.RealEstateManager.FindProperty(mHole), false);
                    return(true);
                }
            }
Example #21
0
        public override bool Run()
        {
            base.StandardEntry();
            if (!base.Target.StartComputing(this, SurfaceHeight.Table, true))
            {
                base.StandardExit();
                return(false);
            }
            //mActor = Actor;
            base.Target.StartVideo(Computer.VideoType.Browse);
            base.BeginCommodityUpdates();
            base.AnimateSim("WorkTyping");
            bool flag = TwoButtonDialog.Show(Localization.LocalizeString("Lyralei/Localized/JoinPatternClubDesc:InteractionName", new object[0]) + kCost.ToString(), Localization.LocalizeString("Lyralei/Localized/JoinPatternClubYES:InteractionName", new object[0]), Localization.LocalizeString("Lyralei/Localized/JoinPatternClubNO:InteractionName", new object[0]));

            if (flag)
            {
                if (base.Actor.FamilyFunds >= kCost)
                {
                    base.Actor.ModifyFunds(-kCost);
                }
                else if (!GameUtils.IsFutureWorld())
                {
                    //base.Actor.UnpaidBills += kCost;
                    StyledNotification.Format format = new StyledNotification.Format(Localization.LocalizeString("Lyralei/Localized/NotEnoughMoney:Test", new object[0]), base.Actor.ObjectId, base.Target.ObjectId, StyledNotification.NotificationStyle.kGameMessageNegative);
                    StyledNotification.Show(format);
                }
                Mailbox mailbox = Mailbox.GetMailboxOnLot(base.Actor.LotHome);

                mailbox.AddAlarmDay(1f, DaysOfTheWeek.Thursday, GlobalOptionsSewingTable.SendPatterns, "Mailbox:  Pattern club " + base.Actor.mSimDescription.mSimDescriptionId.ToString(), AlarmType.AlwaysPersisted);
                GlobalOptionsSewingTable.retrieveData.whoIsInPatternClub.Add(Actor.SimDescription.mSimDescriptionId, true);
                base.Actor.ShowTNSIfSelectable(Localization.LocalizeString("Lyralei/Localized/JoinedPatternClub:InteractionName", new object[0]), StyledNotification.NotificationStyle.kGameMessagePositive);
            }
            base.Target.StopComputing(this, Computer.StopComputingAction.TurnOff, false);
            base.EndCommodityUpdates(flag);
            base.StandardExit();
            return(true);
        }
Example #22
0
        public void GoToLotSuccessEx(Sim sim, float f)
        {
            if (base.Actor != null)
            {
                Relationship relationship = Relationship.Get(base.Actor.SimDescription, base.mOtherSimDesc as SimDescription, false);
                if (relationship != null)
                {
                    relationship.STC.Set(base.Actor, sim, CommodityTypes.Amorous, 500f);
                    base.Actor.InteractionQueue.CancelAllInteractions();
                    while (base.Actor.CurrentInteraction != null)
                    {
                        Common.Sleep(5);
                    }

                    base.Actor.GreetSimOnMyLotIfPossible(sim);
                    CommonWoohoo.WoohooStyle style = CommonWoohoo.WoohooStyle.Safe;
                    if (!Woohooer.Settings.ReplaceWithRisky && TwoButtonDialog.Show(Woohooer.Localize("FriskyConfirm:Prompt", sim.IsFemale, new object[] { sim, base.Actor }), Woohooer.Localize("FriskyConfirm:Yes", sim.IsFemale, new object[] { sim, base.Actor }), Woohooer.Localize("FriskyConfirm:No", sim.IsFemale, new object[] { sim, base.Actor })))
                    {
                        style = CommonWoohoo.WoohooStyle.Risky;
                    }
                    new CommonWoohoo.PushWoohoo(base.Actor, sim, base.Autonomous, style);
                }
            }
        }
Example #23
0
        public override bool Run()
        {
            string msg = "Run";

            checked
            {
                try
                {
                    if (AcceptCancelDialog.Show("Force Select Actor?"))
                    {
                        msg = "Accept";
                        var         definition   = base.InteractionDefinition as Definition;
                        LotLocation lotLocation  = default(LotLocation);
                        ulong       lotLocation2 = World.GetLotLocation(this.Hit.mPoint, ref lotLocation);
                        Lot         lot          = LotManager.GetLot(lotLocation2);
                        if ((definition.Age & (CASAgeGenderFlags.Baby | CASAgeGenderFlags.Toddler | CASAgeGenderFlags.Child)) != CASAgeGenderFlags.None)
                        {
                            bool flag = false;
                            if (lot != null && lot.Household != null)
                            {
                                foreach (SimDescription simDescription in lot.Household.SimDescriptions)
                                {
                                    if (simDescription.TeenOrAbove)
                                    {
                                        flag = true;
                                        break;
                                    }
                                }
                            }
                            if (!flag)
                            {
                                if (AssemblyCheckByNiec.IsInstalled("DGSCore") && TwoButtonDialog.Show("DGSCore" + NiecMod.Nra.NiecException.NewLine + "Found Childern Sims in Household Without Adult" + NiecMod.Nra.NiecException.NewLine + "Note: Social Worker Catch Remove Sims" + NiecMod.Nra.NiecException.NewLine + "Are you sure?!", "Yea It Create " + definition.Age, "No Create YoungAdult"))
                                {
                                    msg = "Accept if not flag";
                                    Sim simnocheck = DGSMakeRandomSimNoCheck(Hit.mPoint, definition.Age, definition.Gender, definition.WorldName);
                                    if (simnocheck != null)
                                    {
                                        if (simnocheck.IsSelectable)
                                        {
                                            PlumbBob.SelectActor(simnocheck);
                                        }
                                        else
                                        {
                                            simnocheck.SimDescription.IsNeverSelectable = false;
                                            PlumbBob.ForceSelectActor(simnocheck);
                                        }
                                        try
                                        {
                                            GlobalFunctions.PlaceAtGoodLocation(simnocheck, new World.FindGoodLocationParams(Hit.mPoint), false);
                                            if (simnocheck.SimDescription.TraitManager.HasElement(TraitNames.Evil))
                                            {
                                                simnocheck.SimDescription.TraitManager.RemoveElement(TraitNames.Evil);
                                                simnocheck.SimDescription.TraitManager.AddElement(TraitNames.Good);
                                            }
                                        }
                                        catch
                                        { }

                                        try
                                        {
                                            if (simnocheck.SimDescription.Household.mName == null)
                                            {
                                                simnocheck.SimDescription.Household.SetName(simnocheck.SimDescription.LastName);
                                            }
                                        }
                                        catch (Exception ex2)
                                        {
                                            NiecMod.Nra.NiecException.WriteLog(msg + " SetName: " + NiecMod.Nra.NiecException.NewLine + NiecMod.Nra.NiecException.LogException(ex2), true, true);
                                        }
                                    }
                                    else
                                    {
                                        //return false;
                                        msg = "MakeSim Failed! if flag";
                                        goto backif;
                                    }
                                    return(true);
                                }
backif:
                                Sim sim = DGSMakeRandomSim(this.Hit.mPoint, CASAgeGenderFlags.YoungAdult, CASAgeGenderFlags.Male, definition.WorldName);
                                msg     = "Terraininstance";
                                if (sim != null)
                                {
                                    Sitoat    = true;
                                    mSima     = sim;
                                    mSimaStat = sim.SimDescription;
                                    sim.FadeOut();
                                    var terraininstance = new Terrain.TeleportMeHere.Definition(false).CreateInstance(Terrain.Singleton, sim, new InteractionPriority((InteractionPriorityLevel)8195), base.Autonomous, base.CancellableByPlayer) as TerrainInteraction;

                                    try
                                    {
                                        if (sim.SimDescription.TraitManager.HasElement(TraitNames.Evil))
                                        {
                                            sim.SimDescription.TraitManager.RemoveElement(TraitNames.Evil);
                                            sim.SimDescription.TraitManager.AddElement(TraitNames.Good);
                                        }
                                    }
                                    catch
                                    { }

                                    if (terraininstance != null)
                                    {
                                        terraininstance.Hidden  = true;
                                        terraininstance.MustRun = true;
                                        //Vector3 vector2;
                                        Lot loty = sim.SimDescription.LotHome;
                                        if (loty == null)
                                        {
                                            loty = sim.SimDescription.VirtualLotHome;
                                        }
                                        //World.FindGoodLocationParams fglParams = new World.FindGoodLocationParams(Helper.Create.GetPositionInRandomLot(loty));

                                        /*
                                         * fglParams.BooleanConstraints |= FindGoodLocationBooleans.StayInRoom;
                                         * fglParams.InitialSearchDirection = RandomUtil.GetInt(0x0, 0x7);
                                         */
                                        //lot.Household.Add(sim.SimDescription);
                                        terraininstance.Destination = Helpers.Create.GetPositionInRandomLot(loty);
                                        sim.InteractionQueue.Add(terraininstance);
                                    }
                                }
                                else
                                {
                                    return(false);
                                }
                                try
                                {
                                    //sim.SimDescription.Household.SetName(/* "E3Lesa is Good" */ "Good Household");
                                    sim.SimDescription.Household.SetName(sim.SimDescription.LastName);
                                }
                                catch (Exception ex2)
                                {
                                    NiecMod.Nra.NiecException.WriteLog(msg + " SetName: " + NiecMod.Nra.NiecException.NewLine + NiecMod.Nra.NiecException.LogException(ex2), true, true);
                                }
                            }
                        }

                        //lot.MoveIn(lot.Household);
                        //FixFoxNonStaticDGSMakeRandomSim = true;
                        Sim sim2 = DGSMakeRandomSim(this.Hit.mPoint, definition.Age, definition.Gender, definition.WorldName);
                        if (sim2 != null)
                        {
                            PlumbBob.ForceSelectActor(sim2);
                            if (mSima != null && Sitoat)
                            {
                                var followchildsim = Sims3.Gameplay.Actors.Sim.FollowParent.Singleton.CreateInstance(sim2, mSima, new InteractionPriority((InteractionPriorityLevel)8195), base.Autonomous, base.CancellableByPlayer) as Sims3.Gameplay.Actors.Sim.FollowParent;
                                followchildsim.Hidden  = true;
                                followchildsim.MustRun = true;
                                if (mSima.InteractionQueue.AddNextIfPossibleAfterCheckingForDuplicates(followchildsim))
                                {
                                    Sim.ForceSocial(mSima, sim2, "Chat", (InteractionPriorityLevel)8195, true);
                                }

                                //sim2.SimDescription.TraitManager.RemoveAllElements();
                                try
                                {
                                    if (sim2.SimDescription.TraitManager.HasElement(TraitNames.Evil))
                                    {
                                        sim2.SimDescription.TraitManager.RemoveElement(TraitNames.Evil);
                                        sim2.SimDescription.TraitManager.AddElement(TraitNames.Good);
                                    }
                                }
                                catch
                                { }
                            }
                        }
                    }



                    else
                    {
                        msg = "Cancel";
                        var definition = base.InteractionDefinition as Definition;
                        Sim sim3       = DGSMakeRandomSim(this.Hit.mPoint, definition.Age, definition.Gender, definition.WorldName);
                        if (sim3 == null)
                        {
                            msg = "Sim3 is Null";
                            Sim sim4 = DGSMakeRandomSim(this.Hit.mPoint, CASAgeGenderFlags.YoungAdult, CASAgeGenderFlags.Male, definition.WorldName);
                            if (sim4 != null)
                            {
                                msg = "Sim4 is Keep";


                                if (!sim4.IsInActiveHousehold)
                                {
                                    try
                                    {
                                        if (sim4.SimDescription.Household.NameUnlocalized == "Good Household")
                                        {
                                            sim4.SimDescription.Household.SetName("Evil Household");
                                        }
                                        else
                                        {
                                            sim4.SimDescription.Household.SetName(sim4.LastName);
                                        }
                                        sim4.SimDescription.TraitManager.RemoveAllElements();
                                        sim4.SimDescription.TraitManager.AddElement(TraitNames.Daredevil);
                                        sim4.SimDescription.TraitManager.AddElement(TraitNames.Evil);
                                        sim4.SimDescription.TraitManager.AddElement(TraitNames.MeanSpirited);
                                        sim4.SimDescription.TraitManager.AddElement(TraitNames.Loser);
                                        sim4.SimDescription.TraitManager.AddElement(TraitNames.Adventurous);
                                    }
                                    catch
                                    { }
                                }
                                else
                                {
                                    try
                                    {
                                        if (sim4.SimDescription.TraitManager.HasElement(TraitNames.Evil))
                                        {
                                            sim4.SimDescription.TraitManager.RemoveElement(TraitNames.Evil);
                                            sim4.SimDescription.TraitManager.AddElement(TraitNames.Good);
                                        }
                                    }
                                    catch
                                    { }

                                    if (sim4.SimDescription.Household.NameUnlocalized == "Evil Household")
                                    {
                                        sim4.SimDescription.Household.SetName("Good Household");
                                    }
                                    else
                                    {
                                        sim4.SimDescription.Household.SetName(sim4.LastName);
                                    }
                                }



                                Sim sim5 = DGSMakeRandomSim(this.Hit.mPoint, definition.Age, definition.Gender, definition.WorldName);
                                if (sim5 != null)
                                {
                                    msg = "Sim5 is Keep";
                                    GlobalFunctions.PlaceAtGoodLocation(sim5, new World.FindGoodLocationParams(Hit.mPoint), false);

                                    if (!sim5.IsInActiveHousehold)
                                    {
                                        try
                                        {
                                            if (sim5.SimDescription.Household.NameUnlocalized == "Good Household")
                                            {
                                                sim5.SimDescription.Household.SetName("Evil Household");
                                            }
                                            else
                                            {
                                                sim5.SimDescription.Household.SetName(sim5.LastName);
                                            }
                                            if (definition.Gender == CASAgeGenderFlags.Child)
                                            {
                                                sim5.SimDescription.TraitManager.RemoveAllElements();
                                                sim5.SimDescription.TraitManager.AddElement(TraitNames.Evil);
                                                sim5.SimDescription.TraitManager.AddElement(TraitNames.MeanSpirited);
                                                sim5.SimDescription.TraitManager.AddElement(TraitNames.Loser);
                                            }
                                            else
                                            {
                                                sim5.SimDescription.TraitManager.RemoveAllElements();
                                                sim5.SimDescription.TraitManager.AddElement(TraitNames.Daredevil);
                                                sim5.SimDescription.TraitManager.AddElement(TraitNames.Evil);
                                                sim5.SimDescription.TraitManager.AddElement(TraitNames.MeanSpirited);
                                                sim5.SimDescription.TraitManager.AddElement(TraitNames.Loser);
                                                sim5.SimDescription.TraitManager.AddElement(TraitNames.Adventurous);
                                            }
                                        }
                                        catch
                                        { }
                                    }
                                    else
                                    {
                                        try
                                        {
                                            if (sim5.SimDescription.TraitManager.HasElement(TraitNames.Evil))
                                            {
                                                sim5.SimDescription.TraitManager.RemoveElement(TraitNames.Evil);
                                                sim5.SimDescription.TraitManager.AddElement(TraitNames.Good);
                                            }
                                        }
                                        catch
                                        { }


                                        if (sim5.SimDescription.Household.NameUnlocalized == "Evil Household")
                                        {
                                            sim5.SimDescription.Household.SetName("Good Household");
                                        }
                                        else
                                        {
                                            sim5.SimDescription.Household.SetName(sim5.LastName);
                                        }
                                    }
                                }
                                else
                                {
                                    return(false);
                                }
                            }
                            else
                            {
                                return(false);
                            }
                        }
                        else
                        {
                            if (!sim3.IsInActiveHousehold)
                            {
                                try
                                {
                                    if (sim3.SimDescription.Household.NameUnlocalized == "Good Household")
                                    {
                                        sim3.SimDescription.Household.SetName("Evil Household");
                                    }

                                    else
                                    {
                                        sim3.SimDescription.Household.SetName(sim3.LastName);
                                    }

                                    if (definition.Gender == CASAgeGenderFlags.Child)
                                    {
                                        sim3.SimDescription.TraitManager.RemoveAllElements();
                                        sim3.SimDescription.TraitManager.AddElement(TraitNames.Evil);
                                        sim3.SimDescription.TraitManager.AddElement(TraitNames.MeanSpirited);
                                        sim3.SimDescription.TraitManager.AddElement(TraitNames.Loser);
                                    }
                                    else
                                    {
                                        sim3.SimDescription.TraitManager.RemoveAllElements();
                                        sim3.SimDescription.TraitManager.AddElement(TraitNames.Daredevil);
                                        sim3.SimDescription.TraitManager.AddElement(TraitNames.Evil);
                                        sim3.SimDescription.TraitManager.AddElement(TraitNames.MeanSpirited);
                                        sim3.SimDescription.TraitManager.AddElement(TraitNames.Loser);
                                        sim3.SimDescription.TraitManager.AddElement(TraitNames.Adventurous);
                                    }
                                }
                                catch
                                { }
                            }
                            else
                            {
                                try
                                {
                                    if (sim3.SimDescription.TraitManager.HasElement(TraitNames.Evil))
                                    {
                                        sim3.SimDescription.TraitManager.RemoveElement(TraitNames.Evil);
                                        sim3.SimDescription.TraitManager.AddElement(TraitNames.Good);
                                    }
                                }
                                catch
                                { }


                                if (sim3.SimDescription.Household.NameUnlocalized == "Evil Household")
                                {
                                    sim3.SimDescription.Household.SetName("Good Household");
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    NiecMod.Nra.NiecException.WriteLog(msg + " DGSMakeSim: " + NiecMod.Nra.NiecException.NewLine + NiecMod.Nra.NiecException.LogException(ex), true, true);
                    return(false);
                }
            }

            return(true);
        }
        public void OnKeyboardDown(MagecrawlKey key, Map map, GameWindow window, IGameEngine engine)
        {
            // TODO - This switch is unfortunate and too large...
            switch (key)
            {
                case MagecrawlKey.LessThan:
                {
                    HandleStairs(m_engine.Actions.MoveUpStairs);
                    break;
                }
                case MagecrawlKey.GreaterThan:
                {
                    HandleStairs(m_engine.Actions.MoveDownStairs);
                    break;
                }
                case MagecrawlKey.Q:
                {
                    string text = "Quitting the game will delete your current character. To stop playing now and continue your adventure later, use save instead.";
                    TwoButtonDialog d = new TwoButtonDialog(window, text);
                    d.Closed += (o, e) =>
                    {
                        if (((TwoButtonDialog)o).DialogResult == true)
                        {
                            // Do quit here? How do you quit SL? go back to main menu?
                        }
                    };

                    d.Show();
                    break;
                }
                case MagecrawlKey.S:
                {
                    string text = "Saving the game will end your current session and allow you to pickup playing later.";
                    TwoButtonDialog d = new TwoButtonDialog(window, text);
                    d.Closed += (o, e) =>
                    {
                        if (((TwoButtonDialog)o).DialogResult == true)
                        {
                            m_engine.Save();
                            // Do quit here? How do you quit SL? go back to main menu?
                        }
                    };

                    d.Show();
                    break;
                }
                case MagecrawlKey.a:
                {
                    if (m_engine.Player.CurrentWeapon.IsRanged && !m_engine.Player.CurrentWeapon.IsLoaded)
                    {
                        m_engine.Actions.ReloadWeapon();
                        window.MessageBox.AddMessage(string.Format("{0} reloads the {1}.", m_engine.Player.Name, m_engine.Player.CurrentWeapon.DisplayName));
                    }
                    else
                    {
                        List<EffectivePoint> targetPoints = m_engine.GameState.CalculateTargetablePointsForEquippedWeapon();
                        OnTargetSelect selectionDelegate = (w, e, p) => 
                        {
                            if (p != m_engine.Player.Position)
                                m_engine.Actions.Attack(p);
                        };
                        TargettingModeKeyboardHandler handler = new TargettingModeKeyboardHandler(TargettingModeKeyboardHandler.TargettingType.Monster, engine, m_map, selectionDelegate, targetPoints);
                        window.SetKeyboardHandler(handler.OnKeyboardDown);
                    }
                    break;
                }
                case MagecrawlKey.o:
                {
                    List<EffectivePoint> operatePoints = CalculateOperatePoints();
                    TargettingModeKeyboardHandler handler = new TargettingModeKeyboardHandler(TargettingModeKeyboardHandler.TargettingType.Operatable, engine, m_map, (w,e,p) => m_engine.Actions.Operate(p), operatePoints);
                    window.SetKeyboardHandler(handler.OnKeyboardDown);
                    break;
                }
                case MagecrawlKey.v:
                {
                    TargettingModeKeyboardHandler handler = new TargettingModeKeyboardHandler(TargettingModeKeyboardHandler.TargettingType.None, engine, m_map, null);
                    m_map.UseViewCursor = true;                    
                    window.SetKeyboardHandler(handler.OnKeyboardDown);
                    break;
                }
                case MagecrawlKey.A:
                {
                    TargettingModeKeyboardHandler handler = new TargettingModeKeyboardHandler(TargettingModeKeyboardHandler.TargettingType.None, engine, m_map, OnRunTargetSelected, null);
                    window.SetKeyboardHandler(handler.OnKeyboardDown);
                    break;
                }
                case MagecrawlKey.i:
                {
                    ListSelection listSelection = new ListSelection(window, engine.Player.Items.OfType<INamedItem>(), "Inventory");
                    listSelection.SelectionDelegate = i =>
                    {
                        ItemSelection.OnSelection onItemSelection = (item, option) =>
                        {
                            TargetingInfo targetInfo = m_engine.Targetting.GetTargettingTypeForInventoryItem(item, option);
                            HandleInvoke(targetInfo, p => m_engine.Actions.SelectedItemOption(item, option, p), item);
                        };

                        ItemSelection selection = new ItemSelection(engine, (IItem)i, onItemSelection);
                        selection.ParentWindow = listSelection;
                        selection.Show();
                    };
                    listSelection.DismissOnSelection = false;
                    listSelection.Show();
                    break;
                }
                case MagecrawlKey.z:
                {
                    ListSelection listSelection = new ListSelection(window, engine.Player.Spells.OfType<INamedItem>(), "Spellbook");
                    listSelection.SelectionDelegate = s =>
                    {
                        TargetingInfo targetInfo = ((ISpell)s).Targeting;
                        HandleInvoke(targetInfo, p => m_engine.Actions.CastSpell((ISpell)s, p), s);
                    };

                    listSelection.Show();
                    break;
                }
                case MagecrawlKey.E:
                {
                    ListSelection listSelection = new ListSelection(window, engine.Player.StatusEffects.OfType<INamedItem>(), "Dismiss Effect");
                    listSelection.SelectionDelegate = i => engine.Actions.DismissEffect(i.DisplayName);
                    listSelection.Show();
                    break;
                }
                case MagecrawlKey.Comma:
                {
                    List<INamedItem> itemsAtLocation = engine.Map.Items.Where(i => i.Second == engine.Player.Position).Select(i => i.First).OfType<INamedItem>().ToList();
                    if (itemsAtLocation.Count > 1)
                    {
                        ListSelection listSelection = new ListSelection(window, itemsAtLocation, "Pickup Item");
                        listSelection.SelectionDelegate = i => engine.Actions.GetItem((IItem)i);
                        listSelection.Show();
                    }
                    else
                    {
                        engine.Actions.GetItem();
                        window.UpdateWorld();
                    }
                    break;
                }
                case MagecrawlKey.Backquote:
                {
                    engine.Actions.SwapPrimarySecondaryWeapons();
                    window.UpdateWorld();
                    break;
                }
                case MagecrawlKey.Period:
                {
                    engine.Actions.Wait();
                    window.UpdateWorld();
                    break;
                }
                case MagecrawlKey.PageUp:
                {
                    window.MessageBox.PageUp();
                    break;
                }
                case MagecrawlKey.PageDown:
                {
                    window.MessageBox.PageDown();
                    break;
                }
                case MagecrawlKey.Backspace:
                {
                    window.MessageBox.Clear();
                    break;
                }
                case MagecrawlKey.Left:
                    HandleDirection(Direction.West, m_map, window, engine);
                    break;
                case MagecrawlKey.Right:
                    HandleDirection(Direction.East, m_map, window, engine);
                    break;
                case MagecrawlKey.Down:
                    HandleDirection(Direction.South, m_map, window, engine);
                    break;
                case MagecrawlKey.Up:
                    HandleDirection(Direction.North, m_map, window, engine);
                    break;
                case MagecrawlKey.Insert:
                    HandleDirection(Direction.Northwest, m_map, window, engine);
                    break;
                case MagecrawlKey.Delete:
                    HandleDirection(Direction.Southwest, m_map, window, engine);
                    break;
                case MagecrawlKey.Home:
                    HandleDirection(Direction.Northeast, m_map, window, engine);
                    break;
                case MagecrawlKey.End:
                    HandleDirection(Direction.Southeast, m_map, window, engine);
                    break;
            }
        }
Example #25
0
        public static bool PreTimeTravel1(InteractionInstance ths, ITravelWith travelWith, List <Sim> travelers)
        {
            Sim actor = ths.InstanceActor as Sim;

            if (!UIUtils.IsOkayToStartModalDialog())
            {
                return(false);
            }

            if (GameUtils.IsFutureWorld())
            {
                foreach (Sim sim in actor.Household.Sims)
                {
                    if (sim != actor)
                    {
                        GreyedOutTooltipCallback callback = null;
                        if (TravelerSpace.Helpers.TravelUtilEx.CanSimTriggerTravelToFutureWorld(sim, true, ref callback))
                        {
                            Lazy.Add <List <Sim>, Sim>(ref travelers, sim);
                        }
                    }
                }
            }
            else
            {
                travelers.AddRange(ths.GetSelectedObjectsAsSims());
            }

            if (travelers.Count == 0)
            {
                return(false);
            }

            if ((actor.OpportunityManager != null) && actor.OpportunityManager.HasOpportunity(OpportunityNames.EP11_HelpingTheTimeTraveler01))
            {
                return(false);
            }

            string portal;

            TravelUtil.PlayerMadeTravelRequest = true;
            Dictionary <Sim, OpportunityNames> dictionary = CheckOpportunities(actor, travelers);

            if (GameUtils.IsFutureWorld())
            {
                portal = TimePortal.LocalizeString("ConfirmReturnWith", new object[0x0]);
            }
            else if (dictionary.Count > 0x0)
            {
                portal = TimePortal.LocalizeString("ConfirmTravelWith", new object[0x0]) + TimePortal.LocalizeString("ConfirmWarningTravelWith", new object[0x0]);
            }
            else
            {
                portal = TimePortal.LocalizeString("ConfirmTravelWith", new object[0x0]);
            }

            if (!TwoButtonDialog.Show(portal, Localization.LocalizeString("Ui/Caption/Global:Accept", new object[0x0]), Localization.LocalizeString("Ui/Caption/Global:Cancel", new object[0x0])))
            {
                return(false);
            }

            ths.CancellableByPlayer = false;
            //Sims3.Gameplay.Gameflow.Singleton.DisableSave(this, "Ui/Caption/HUD/DisasterSaveError:Traveling");
            if (dictionary.Count > 0x0)
            {
                foreach (Sim sim2 in dictionary.Keys)
                {
                    if (sim2.OpportunityManager != null)
                    {
                        sim2.OpportunityManager.CancelOpportunity(dictionary[sim2]);
                    }
                }
            }

            if ((GameUtils.IsFutureWorld() && (actor.OpportunityManager != null)) && actor.OpportunityManager.HasOpportunity(OpportunityNames.EP11_RecalibrateDefenseGrid))
            {
                actor.OpportunityManager.CancelOpportunity(OpportunityNames.EP11_RecalibrateDefenseGrid);
            }

            foreach (Sim sim3 in travelers)
            {
                travelWith.AddFollower(sim3);
            }

            return(true);
        }
Example #26
0
        public SimSelection.UpdateResult Update(IMiniSimDescription actor, IEnumerable <SimSelection.ICriteria> criteria, List <IMiniSimDescription> allSims, bool secondStage, bool silent, bool promptForMatchAll)
        {
            if (secondStage)
            {
                return(SimSelection.UpdateResult.Success);
            }

            bool fullFamily = false;

            foreach (SimSelection.ICriteria crit in criteria)
            {
                if (crit is FullFamily)
                {
                    fullFamily = true;
                    break;
                }
            }

            if ((mOptions == null) || (mOptions.Count == 0))
            {
                List <IMiniSimDescription> actors = new List <IMiniSimDescription>();

                if (fullFamily)
                {
                    SimDescription trueActor = actor as SimDescription;
                    if ((trueActor != null) && (trueActor.Household != null) && (!SimTypes.IsSpecial(trueActor)))
                    {
                        foreach (SimDescription member in CommonSpace.Helpers.Households.All(trueActor.Household))
                        {
                            actors.Add(member);
                        }
                    }
                }
                else
                {
                    actors.Add(actor);
                }

                List <TOption> allOptions = new List <TOption>();
                GetOptions(actors, allSims, allOptions);

                if (allOptions.Count == 0)
                {
                    return(SimSelection.UpdateResult.Failure);
                }

                if (allOptions.Count == 1 || silent)
                {
                    mOptions = allOptions;
                }
                else
                {
                    mOptions = new List <TOption>(new CommonSelection <TOption>(Name, allOptions, Auxillary).SelectMultiple());
                }
            }

            if ((mOptions != null) && (mOptions.Count > 0))
            {
                for (int i = allSims.Count - 1; i >= 0; i--)
                {
                    if (!Test(allSims[i], fullFamily, actor))
                    {
                        allSims.RemoveAt(i);
                    }
                }

                if (promptForMatchAll)
                {
                    if (TwoButtonDialog.Show(MasterController.Localize("CriteriaMatchAll:Prompt"), MasterController.Localize("CriteriaMatchAll:Yes"), MasterController.Localize("CriteriaMatchAll:No")))
                    {
                        mMatchAll = true;
                    }
                }

                return(SimSelection.UpdateResult.Success);
            }
            else
            {
                return(SimSelection.UpdateResult.Failure);
            }
        }
Example #27
0
 public bool CancelTutorial()
 {
     return(TwoButtonDialog.Show(Localization.LocalizeString("Gameplay/Tutorial:AreYouSure", new object[0]), Localization.LocalizeString("Gameplay/Tutorial:End", new object[0]), Localization.LocalizeString("Gameplay/Tutorial:Continue", new object[0]), true));
 }
Example #28
0
        protected override OptionResult Run(GameHitParameters <GameObject> parameters)
        {
            Overwatch.Log("DropInvalidVactionHomes");

            WorldName        currentWorld = GameUtils.GetCurrentWorld();
            List <WorldName> found        = new List <WorldName>();

            foreach (MiniSimDescription desc in MiniSimDescription.sMiniSims.Values)
            {
                if (desc.HomeWorld != WorldName.UserCreated && desc.HomeWorld != currentWorld && !found.Contains(desc.HomeWorld))
                {
                    found.Add(desc.HomeWorld);
                }
            }

            if (Household.ActiveHousehold == null || Household.ActiveHousehold.RealEstateManager == null)
            {
                Common.Notify("Fail");
            }

            foreach (PropertyData data in Household.ActiveHousehold.RealEstateManager.AllProperties)
            {
                if (data.PropertyType != RealEstatePropertyType.VacationHome)
                {
                    continue;
                }

                if (found.Contains(data.World))
                {
                    Overwatch.Log("Skipping " + data.World);
                    continue;
                }

                string na  = null;
                string msg = data.World == WorldName.UserCreated ? "Unhandable PropertyData found" : "Possible invalid PropertyData found";

                if (TwoButtonDialog.Show(msg + ": PropertyName: " + (data.LocalizedName != string.Empty ? data.LocalizedName : "N/A") + " Value: " + data.StoredValue + " World: " + Sims3.Gameplay.Objects.HobbiesSkills.Photograph.GameUtilsGetLocalizedWorldName(data.World, ref na), "Yes", "No"))
                {
                    try
                    {
                        data.Owner.SellProperty(data, false);

                        LocationHomeDeed[] deeds = Sims3.Gameplay.Queries.GetObjects <LocationHomeDeed>();
                        foreach (LocationHomeDeed deed in deeds)
                        {
                            if (deed.LotId == data.LotId && deed.World == data.World)
                            {
                                Sim owner = deed.ItemComp.InventoryParent.Owner as Sim;
                                if (owner != null)
                                {
                                    owner.Inventory.RemoveByForce(deed);
                                }
                                deed.Destroy();
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        Common.Exception("", e);
                    }
                }
            }

            return(OptionResult.SuccessRetain);
        }
Example #29
0
        public static void PlaceLotWizardCheck(InWorldSubState ths)
        {
            try
            {
                if ((GameStates.IsNewGame) && (GameStates.HasTravelData) && (!WorldData.IsPreviousWorld()))
                {
                    WorldData.SetPreviousWorld();

                    WorldName currentWorld = GameUtils.GetCurrentWorld();

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

                    default:
                        if ((GameStates.sSingleton != null) && (GameStates.sSingleton.mInWorldState != null) && (GameStates.sSingleton.mInWorldState.mSubStates[0xb] != null))
                        {
                            bool isChangingWorlds = GameStates.sIsChangingWorlds;

                            WorldType currentWorldType = GameUtils.GetCurrentWorldType();

                            try
                            {
                                GameUtils.WorldNameToType.Remove(currentWorld);
                                GameUtils.WorldNameToType.Add(currentWorld, WorldType.Base);

                                GameStates.sIsChangingWorlds = false;

                                BinModel.Singleton.PopulateExportBin();

                                EditTownModel.ClearPlaceLotsWizardFlags();

                                Dictionary <CommercialLotSubType, string> lotTypesToPrompt = EditTownModel.LotTypesToPrompt;

                                if (lotTypesToPrompt.Count != 0x0)
                                {
                                    if (BinModel.Singleton.IsClear())
                                    {
                                        BinModel.Singleton.PopulateExportBin();
                                    }

                                    string promptText = Common.LocalizeEAString("Ui/Caption/GameEntry/PlaceEPLotsWizard:EnterPrompt") + '\n';

                                    try
                                    {
                                        InWorldSubState.AutoVenuPlacementData.Parse();

                                        foreach (KeyValuePair <CommercialLotSubType, string> pair in lotTypesToPrompt)
                                        {
                                            promptText = promptText + '\n' + pair.Value;
                                            if (InWorldSubState.AutoVenuPlacementData.HasPlacementDataForWorldName(World.GetWorldFileName()))
                                            {
                                                UIBinInfo                 lotToPlaceInfo    = null;
                                                UIBinInfo                 targetLotInfo     = null;
                                                LotRotationAngle          kLotRotateAuto    = LotRotationAngle.kLotRotateAuto;
                                                List <IExportBinContents> exportBinContents = BinModel.Singleton.ExportBinContents;
                                                if (ths.FindRequiredEPVenuePlacementInfo(pair.Key, exportBinContents, out lotToPlaceInfo, out targetLotInfo, out kLotRotateAuto))
                                                {
                                                    EditTownModel.AddForcedLocationLotToPlace(pair.Key, lotToPlaceInfo, targetLotInfo, kLotRotateAuto);
                                                }
                                            }
                                        }
                                    }
                                    finally
                                    {
                                        InWorldSubState.AutoVenuPlacementData.Shutdown();
                                    }

                                    if (TwoButtonDialog.Show(promptText, Common.LocalizeEAString("Ui/Caption/GameEntry/PlaceEPLotsWizard:Accept"), Common.LocalizeEAString("Ui/Caption/GameEntry/PlaceEPLotsWizard:Decline")))
                                    {
                                        GameStates.sSingleton.mInWorldState.mSubStates[0xb].PlaceRequiredEPVenues();
                                    }
                                }
                            }
                            finally
                            {
                                GameStates.sIsChangingWorlds = isChangingWorlds;

                                GameUtils.WorldNameToType.Remove(currentWorld);
                                GameUtils.WorldNameToType.Add(currentWorld, currentWorldType);
                            }
                        }
                        break;
                    }
                }
                else
                {
                    ths.PlaceLotWizardCheck();
                }
            }
            catch (Exception e)
            {
                Common.Exception("PlaceLotWizardCheck", e);
            }
        }
 private void HandleStairs(StairMovement s)
 {
     StairMovmentType stairMovement = m_engine.GameState.IsStairMovementSpecial(s == m_engine.Actions.MoveUpStairs);
     switch (stairMovement)
     {
         case StairMovmentType.QuitGame:
         {
             string text = "Leaving the dungeon will end the game early and delete your current character. To stop playing now and continue your adventure later, use save instead.";
             TwoButtonDialog d = new TwoButtonDialog(m_window, text);
             d.Closed += (o, e) =>
             {
                 if (((TwoButtonDialog)o).DialogResult == true)
                 {
                     // Do quit here? How do you quit SL? go back to main menu?
                 }
             };
             d.Show();
             break;
         }
         case StairMovmentType.WinGame:
         {
             // Don't save if player closes window with dialog up.
             // m_gameInstance.ShouldSaveOnClose = false;
             string text = "Congratulations, you have completed the magecrawl tech demo! " + m_engine.Player.Name + " continues on without you in search of further treasure and fame. Consider telling your story to others, including the creator.";
             OneButtonDialog d = new OneButtonDialog(m_window, text);
             d.Closed += (o, e) =>
             {
                 // Do quit here? How do you quit SL? go back to main menu?
             };
             d.Show();
             break;
         }
         case StairMovmentType.None:
         {
             s();
             m_window.UpdateWorld();
             return;
         }
     }
 }
Example #31
0
        public static void ShowTimeAlmanacDialog()
        {
            if (!Responder.Instance.IsGameStatePending || !Responder.Instance.IsGameStateShuttingDown)
            {
                ICauseEffectUiData                causeEffectData         = null;
                List <ITimeStatueUiData>          timeStatueData          = null;
                List <IDescendantHouseholdUiData> descendantHouseholdInfo = null;
                CauseEffectService                instance = CauseEffectService.GetInstance();
                if (instance != null)
                {
                    causeEffectData = instance.GetTimeAlmanacCauseEffectData();
                    timeStatueData  = instance.GetTimeAlmanacTimeStatueData();
                }
                FutureDescendantService service2 = GetInstance();
                if (service2 != null)
                {
                    // custom
                    descendantHouseholdInfo = GetTimeAlamanacDescendantHouseholdData(service2);
                }
                Sim currentSim = PlumbBob.SelectedActor;
                TimeAlmanacDialog.TimeAlmanacResult result = TimeAlmanacDialog.Show(currentSim.ObjectId, causeEffectData, descendantHouseholdInfo, timeStatueData);
                bool flag  = currentSim.OpportunityManager.HasOpportunity(OpportunityCategory.Special);
                bool flag2 = result != TimeAlmanacDialog.TimeAlmanacResult.DoNothing;
                if (flag2 && flag)
                {
                    string promptText  = Localization.LocalizeString(currentSim.IsFemale, "Ui/Caption/TimeAlmanac:ChangeEventPrompt", new object[] { currentSim, currentSim.OpportunityManager.GetActiveOpportunity(OpportunityCategory.Special).Name });
                    string buttonTrue  = Localization.LocalizeString("Ui/Caption/Global:Yes", new object[0]);
                    string buttonFalse = Localization.LocalizeString("Ui/Caption/Global:No", new object[0]);
                    flag2 = TwoButtonDialog.Show(promptText, buttonTrue, buttonFalse);
                    if (flag2)
                    {
                        currentSim.OpportunityManager.CancelOpportunityByCategory(OpportunityCategory.Special);
                    }
                }
                if (flag2)
                {
                    switch (result)
                    {
                    case TimeAlmanacDialog.TimeAlmanacResult.DoNothing:
                        break;

                    case TimeAlmanacDialog.TimeAlmanacResult.TrashOpportunity:
                        currentSim.OpportunityManager.ClearLastOpportunity(OpportunityCategory.Special);
                        currentSim.OpportunityManager.AddOpportunityNow(OpportunityNames.EP11_Trigger_DystopiaFuture, true, false);
                        return;

                    case TimeAlmanacDialog.TimeAlmanacResult.MeteorOpportunity:
                        if (CauseEffectWorldState.kUtopiaState != instance.GetCurrentCauseEffectWorldState())
                        {
                            if (CauseEffectWorldState.kDystopiaState == instance.GetCurrentCauseEffectWorldState())
                            {
                                currentSim.OpportunityManager.ClearLastOpportunity(OpportunityCategory.Special);
                                currentSim.OpportunityManager.AddOpportunityNow(OpportunityNames.EP11_Undo_DystopiaFuture, true, false);
                                return;
                            }
                            break;
                        }
                        currentSim.OpportunityManager.ClearLastOpportunity(OpportunityCategory.Special);
                        unchecked
                        {
                            currentSim.OpportunityManager.AddOpportunityNow((OpportunityNames)(-5928144135704983787L), true, false);
                        }
                        return;

                    case TimeAlmanacDialog.TimeAlmanacResult.RainbowOpportunity:
                        currentSim.OpportunityManager.ClearLastOpportunity(OpportunityCategory.Special);
                        currentSim.OpportunityManager.AddOpportunityNow(OpportunityNames.EP11_Trigger_UtopiaFuture, true, false);
                        break;

                    default:
                        return;
                    }
                }
            }
        }
Example #32
0
            protected override void OnPerform()
            {
                Dictionary <Sim, Vector3> lastOnLotPositions = new Dictionary <Sim, Vector3>();

                CaregiverRoutingMonitor monitor = new CaregiverRoutingMonitor(mHouse, mHouse.LotHome);

                bool stopMonitoring;
                Sim  arbitraryChild;
                int  caregiverCount;

                if (mHouse.LotHome == null)
                {
                    return;
                }
                else if (CaregiverRoutingMonitor.EnoughCaregiversRemain(mHouse, mHouse.LotHome, lastOnLotPositions, true, out stopMonitoring, out caregiverCount, out arbitraryChild))
                {
                    return;
                }
                else
                {
                    foreach (IBonehildaCoffin coffin in mHouse.LotHome.GetObjects <IBonehildaCoffin>())
                    {
                        if (coffin.isActiveAndNoBonehilda())
                        {
                            coffin.ForceSpawn();
                            return;
                        }
                    }

                    //Common.DebugNotify(delegate { return mHouse.Name + " " + caregiverCount; });

                    bool flag2      = CaregiverRoutingMonitor.IsLotHomeOrDaycareForHousehold(mHouse, mHouse.LotHome);
                    Sim  closestSim = null;

                    List <Sim> list = new List <Sim>(mHouse.Sims);
                    DaycareWorkdaySituation daycareWorkdaySituationForLot = DaycareWorkdaySituation.GetDaycareWorkdaySituationForLot(mHouse.LotHome);
                    if ((daycareWorkdaySituationForLot != null) && daycareWorkdaySituationForLot.IsServingHousehold(mHouse))
                    {
                        list.AddRange(daycareWorkdaySituationForLot.Daycare.OwnerDescription.Household.Sims);
                    }

                    float minDistance = float.MaxValue;

                    foreach (Sim sim3 in list)
                    {
                        if (sim3.SimDescription.TeenOrAbove)
                        {
                            Vector3 vector;
                            if (monitor.IsReturningToLotInQuestion(sim3, arbitraryChild))
                            {
                                return;
                            }

                            if (sim3.IsRouting && lastOnLotPositions.TryGetValue(sim3, out vector))
                            {
                                float distance = (sim3.Position - vector).LengthSqr();
                                if (distance < minDistance)
                                {
                                    minDistance = distance;
                                    closestSim  = sim3;
                                }
                            }
                        }
                    }

                    if (closestSim == null)
                    {
                        foreach (Sim sim4 in list)
                        {
                            if (sim4.SimDescription.TeenOrAbove)
                            {
                                float distance = (sim4.Position - arbitraryChild.Position).LengthSqr();
                                if (distance < minDistance)
                                {
                                    minDistance = distance;
                                    closestSim  = sim4;
                                }
                            }
                        }
                    }

                    bool flag3;
                    bool flag4;
                    bool flag5;
                    if (closestSim != null)
                    {
                        flag3 = false;
                        flag4 = false;
                        InteractionInstance headInteraction = closestSim.InteractionQueue.GetHeadInteraction();
                        if (headInteraction != null)
                        {
                            flag4 = !headInteraction.CancellableByPlayer;
                        }

                        flag5 = true;
                        foreach (Sim sim5 in mHouse.Sims)
                        {
                            if ((sim5.LotCurrent == mHouse.LotHome) && (sim5.SimDescription.ToddlerOrBelow) && (sim5.CurrentInteraction is AgeUp))
                            {
                                flag5 = false;
                                break;
                            }
                        }
                    }
                    else
                    {
                        return;
                    }

                    if (flag5)
                    {
                        if ((!GoHere.Settings.mInactiveChildrenAsActive) && (closestSim.IsNPC || CaregiverRoutingMonitor.TreatPlayerSimsLikeNPCs))
                        {
                            if ((caregiverCount == 0x0) && (!GoHere.Settings.mAllowChildHomeAlone))
                            {
                                Common.FunctionTask.Perform(monitor.DematerializeChildren);
                            }

                            return;
                        }
                        else if (!GoHere.Settings.mAllowChildHomeAlone)
                        {
                            if ((mHouse != Household.ActiveHousehold) || mHouse.AutoBabysitter || flag4)
                            {
                                flag3 = true;

                                if (mHouse == Household.ActiveHousehold)
                                {
                                    string str;
                                    if (flag2)
                                    {
                                        str = ChildUtils.Localize(arbitraryChild.SimDescription.IsFemale, "AutoNannyTns", new object[] { arbitraryChild });
                                    }
                                    else
                                    {
                                        str = ChildUtils.Localize(arbitraryChild.SimDescription.IsFemale, "AutoNannyAwayFromHomeTns", new object[] { arbitraryChild });
                                    }

                                    StyledNotification.Format format = new StyledNotification.Format(str, closestSim.ObjectId, arbitraryChild.ObjectId, StyledNotification.NotificationStyle.kSimTalking);
                                    StyledNotification.Show(format);
                                }
                            }
                            else
                            {
                                string str2;
                                if (flag2)
                                {
                                    str2 = ChildUtils.Localize(arbitraryChild.SimDescription.IsFemale, "NeedNannyDialogMessage", new object[] { arbitraryChild });
                                }
                                else
                                {
                                    str2 = ChildUtils.Localize(arbitraryChild.SimDescription.IsFemale, "NeedNannyAwayFromHomeDialogMessage", new object[] { arbitraryChild });
                                }

                                flag3 = TwoButtonDialog.Show(str2, ChildUtils.Localize(arbitraryChild.SimDescription.IsFemale, "NeedNannyDialogYes", new object[0x0]), ChildUtils.Localize(arbitraryChild.SimDescription.IsFemale, "NeedNannyDialogNo", new object[0x0]));
                            }
                        }
                        else
                        {
                            flag3 = true;
                            flag5 = true;
                            flag2 = true;
                        }
                    }

                    if (!flag5 || !flag3)
                    {
                        Vector3 position;
                        if (!lastOnLotPositions.TryGetValue(closestSim, out position))
                        {
                            position = Vector3.Invalid;
                        }
                        monitor.PushGoBackIfNeeded(closestSim, position);
                    }
                    else
                    {
                        if (!flag2)
                        {
                            foreach (Sim sim6 in mHouse.LotHome.GetSims())
                            {
                                if (sim6.SimDescription.TeenOrAbove && !sim6.IsRouting)
                                {
                                    flag3 = false;
                                    break;
                                }
                            }
                        }

                        if ((GoHere.Settings.mInactiveChildrenAsActive) || ((flag3 && !closestSim.IsNPC) && !CaregiverRoutingMonitor.TreatPlayerSimsLikeNPCs))
                        {
                            InitiateCaregiving(mHouse);
                        }
                    }
                }
            }