public MemberListModel(Household household, List<User> users, bool canEditPermissions, bool canEditUser)
 {
     Household = household;
     Users = users;
     CanEditPermissions = canEditPermissions;
     CanEditUser = canEditUser;
 }

        public override void Reset()
        {
            base.Reset();

            if (SimTypes.IsDead(Sim)) return;

            mHouse = Sim.Household;

            mNetWorth = 0;
            if (mHouse != null)
            {
                if (mHouse.LotHome != null)
                {
                    if (mHouse.LotHome != mLot)
                    {
                        mLot = mHouse.LotHome;

                        mLotHomeCost = StoryProgression.Main.Lots.GetLotCost(mLot);
                    }

                    mNetWorth = mHouse.FamilyFunds + mLotHomeCost;
                }
                else
                {
                    mNetWorth = mHouse.NetWorth();

                    mLot = null;
                    mLotHomeCost = 0;
                }
            }
        }

        protected override OptionResult Run(Lot lot, Household me)
        {
            if (me == null) return OptionResult.Failure;

            string text = StringInputDialog.Show(Name, Common.Localize(GetTitlePrefix() + ":Prompt"), me.Name);
            if (string.IsNullOrEmpty(text)) return OptionResult.Failure;

            if (AcceptCancelDialog.Show(Common.Localize(GetTitlePrefix() + ":SimsPrompt", false, new object[] { me.Name, text })))
            {
                foreach (SimDescription sim in CommonSpace.Helpers.Households.All(me))
                {
                    if (sim.LastName.Trim().ToLower() == me.Name.Trim().ToLower())
                    {
                        sim.LastName = text;

                        if (me == Household.ActiveHousehold)
                        {
                            HudModel hudModel = Sims3.UI.Responder.Instance.HudModel as HudModel;
                            if (sim.CreatedSim != null)
                            {
                                Household.AddDirtyNameSimID(sim.SimDescriptionId);
                                hudModel.NotifyNameChanged(sim.CreatedSim.ObjectId);
                            }
                        }
                    }
                }
            }

            me.Name = text;
            return OptionResult.SuccessClose;
        }

        protected static void CloseHouse(Household house)
        {
            if (house != null)
            {
                if (house == Household.ActiveHousehold) return;

                Dictionary<Lot, bool> lots = new Dictionary<Lot, bool>();
                foreach (Sim sim in Households.AllSims(house))
                {
                    if (sim.LotCurrent == null) continue;

                    if (!lots.ContainsKey(sim.LotCurrent))
                    {
                        lots.Add(sim.LotCurrent, true);
                    }
                }

                foreach (Lot lot in LotManager.AllLots)
                {
                    if (lots.ContainsKey(lot)) continue;

                    if (lot.IsResidentialLot)
                    {
                        house.RemoveGreetedLotForHousehold(lot, ObjectGuid.InvalidObjectGuid);
                    }
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="interactionName"></param>
        /// <returns></returns>
        public static List<IMiniSimDescription> ShowSimSelector(Sim actor, Household currentHousehold, string interactionName)
        {
            List<IMiniSimDescription> residents = new List<IMiniSimDescription>();
            string buttonFalse = Localization.LocalizeString("Ui/Caption/ObjectPicker:Cancel", new object[0]);

            List<PhoneSimPicker.SimPickerInfo> list = new List<PhoneSimPicker.SimPickerInfo>();

            List<object> list2;

            //Create list of sims
            foreach (Sim s in currentHousehold.Sims)
            {
                list.Add(Phone.Call.CreateBasicPickerInfo(actor.SimDescription, s.SimDescription));
            }

            list2 = PhoneSimPicker.Show(true, ModalDialog.PauseMode.PauseSimulator, list, interactionName, interactionName, buttonFalse, currentHousehold.Sims.Count, false);

            if (list2 == null || list2.Count == 0)
            {
                return null;
            }
            foreach (var item in list2)
            {
                residents.Add(item as SimDescription);
            }

            return residents;
        }

        public static string Perform(Household house, bool ignorePlaceholders)
        {
            if (house.LotHome == null) return null;

            string msg = null;

            if (Households.NumSims(house) != Households.AllSims(house).Count)
            {
                List<SimDescription> sims = new List<SimDescription>(Households.All(house));
                foreach (SimDescription description in sims)
                {
                    bool flag = true;
                    foreach (Sim sim in Households.AllSims(house))
                    {
                        if (sim.SimDescription == description)
                        {
                            flag = false;
                            break;
                        }
                    }

                    if (flag)
                    {
                        FixInvisibleTask.Perform(description, false);

                        msg += RecoverMissingSimTask.Perform(description, ignorePlaceholders);
                    }
                }
            }

            return msg;
        }

        protected override OptionResult Run(Lot lot, Household me)
        {
            if (lot != null)
            {
                List<Item> allOptions = new List<Item>();

                foreach (Household house in Household.sHouseholdList)
                {
                    if (house.RealEstateManager == null) continue;

                    PropertyData data = house.RealEstateManager.FindProperty(lot);
                    if (data == null) continue;

                    allOptions.Add(new Item(house, lot, RealEstate.OwnerType.Full, data.TotalValue));
                }

                if (allOptions.Count == 0)
                {
                    SimpleMessageDialog.Show(Name, Common.Localize(GetTitlePrefix() + ":Failure"));
                    return OptionResult.Failure;
                }

                CommonSelection<Item>.Results choices = new CommonSelection<Item>(Name, allOptions).SelectMultiple();
                if ((choices == null) || (choices.Count == 0)) return OptionResult.Failure;

                foreach (Item item in choices)
                {
                    item.Perform();
                }
            }

            return OptionResult.SuccessClose;
        }

        public void OnWorldLoadFinished()
        {
            new Common.DelayedEventListener(EventTypeId.kSocialInteraction, OnSocialEvent);
            new Common.DelayedEventListener(EventTypeId.kHouseholdSelected, OnHouseSelected);

            sOldHousehold = Household.ActiveHousehold;
        }

        protected override bool Allow(Lot lot, Household me)
        {
            if (!base.Allow(lot, me)) return false;

            if (lot.IsCommunityLot) return false;

            return (new HomeInspection(lot).Satisfies(me).Count > 0);
        }

        protected override bool Allow(Lot lot, Household house)
        {
            if (!base.Allow(lot, house)) return false;

            if (lot is WorldLot) return false;

            return (lot != null);
        }

        protected override bool Allow(Lot lot, Household me)
        {
            if (!base.Allow(lot, me)) return false;

            if (lot == null) return false;

            return (true);
        }

        protected static void GetTaxes(Household me, out int owed, out int savings, out int vacationHome)
        {
            owed = (int)(me.ComputeNetWorthOfObjectsInHousehold(true) * Mailbox.kPercentageOfWealthBilled);

            vacationHome = 0;

            savings = 0;

            if (me.RealEstateManager != null)
            {
                int valueOfAllVacationHomes = me.RealEstateManager.GetValueOfAllVacationHomes();

                vacationHome = (int)Math.Round((double)(valueOfAllVacationHomes * RealEstateManager.kPercentageOfVacationHomeValueBilled));

                owed += vacationHome;
            }

            if (me.LotHome != null)
            {
                Dictionary<int, List<float>> dictionary = new Dictionary<int, List<float>>();
                foreach (IReduceBills bills in me.LotHome.GetObjects<IReduceBills>())
                {
                    List<float> list;
                    int key = bills.ReductionArrayIndex();
                    float item = bills.PercentageReduction();
                    if (dictionary.TryGetValue(key, out list))
                    {
                        list.Add(item);
                    }
                    else
                    {
                        List<float> list2 = new List<float>();
                        list2.Add((float)bills.MaxNumberContributions());
                        list2.Add(item);
                        dictionary.Add(key, list2);
                    }
                }

                foreach (KeyValuePair<int, List<float>> pair in dictionary)
                {
                    int num5 = (int)pair.Value[0];
                    pair.Value.RemoveAt(0);
                    pair.Value.Sort();
                    int count = pair.Value.Count;
                    num5 = Math.Min(num5, count);
                    float num7 = 0f;
                    for (int i = 1; i <= num5; i++)
                    {
                        num7 += pair.Value[count - i];
                    }
                    int amount = (int)(owed * num7);

                    owed -= amount;

                    savings += amount;
                }
            }
        }

        // Lacks the "greater than eight" restriction
        public static bool GhostToPlayableGhost(Urnstone ths, Household newHousehold, Vector3 ghostPosition)
        {
            SimDescription simDescription = ths.DeadSimsDescription;

            if (!simDescription.IsValidDescription)
            {
                simDescription.Fixup();
            }

            if (simDescription.Household != null)
            {
                simDescription.Household.Remove(simDescription, !simDescription.Household.IsSpecialHousehold);
            }

            if (!newHousehold.Contains(simDescription))
            {
                newHousehold.Add(simDescription);
            }

            Sim ghost = Instantiation.Perform(simDescription, ghostPosition, null, null);
            if (ghost == null) return false;

            ths.GhostSetup(ghost, true);

            ths.RemoveMourningRelatedBuffs(ghost);

            simDescription.ShowSocialsOnSim = true;
            simDescription.IsNeverSelectable = false;
            simDescription.Marryable = true;
            simDescription.Contactable = true;

            if (!simDescription.IsEP11Bot)
            {
                simDescription.AgingEnabled = true;
                simDescription.AgingState.ResetAndExtendAgingStage(0f);
                simDescription.PushAgingEnabledToAgingManager();
            }

            string failureReason;
            if (!Inventories.TryToMove(ths, ghost.Inventory, true, out failureReason))
            {
                Common.DebugNotify(failureReason);
            }
            //Inventories.TryToMove(ths, ghost);

            if (simDescription.Child || simDescription.Teen)
            {
                simDescription.AssignSchool();
            }

            if (ghost.IsSelectable)
            {
                ghost.OnBecameSelectable();
            }

            return true;
        }

 protected override bool Allow(Household house)
 {
     if (house.LotHome != null)
     {
         IncStat("Resident");
         return false;
     }
     return base.Allow(house);
 }

        public CareerStore(Household house, SafeStore.Flag flags)
        {
            mSafeStore = new Dictionary<ulong, SafeStore>();

            foreach (SimDescription sim in Households.All(house))
            {
                mSafeStore[sim.SimDescriptionId] = new SafeStore(sim, flags);
            }
        }

        protected override Scenario Handle(Event e, ref ListenerAction result)
        {
            mEvent = e as HouseholdUpdateEvent;
            if (mEvent == null) return null;

            mOldHousehold = StoryProgression.Main.Households.ActiveHousehold;

            return base.Handle(e, ref result);
        }

        protected override OptionResult PrivatePerform(Lot lot, Household me, List<IMiniSimDescription> sims)
        {
            OptionResult result = base.PrivatePerform(lot, me, sims);
            if (result == OptionResult.Failure) return OptionResult.Failure;

            SetRoommate(lot, me, sims);

            return result;
        }

        public static void AddCheck(Household house)
        {
            if (!Vector.Settings.mAllowInactivePurchases) return;

            if (SimTypes.IsSpecial(house)) return;

            if (sChecks.ContainsKey(house)) return;

            sChecks.Add(house, true);
        }

        protected override bool Allow(Lot lot, Household me)
        {
            if (!base.Allow(lot, me)) return false;

            if (me == null) return false;

            if (me.RealEstateManager == null) return false;

            return true;
        }

        protected override bool Allow(Lot lot, Household me)
        {
            if (!base.Allow(lot, me)) return false;

            if (lot == null) return false;

            if (me == Household.ActiveHousehold) return false;

            return (me != null);
        }