C# Lot.GetObjects方法代码示例

		public void OnExitBuildBuy(Lot lot)
		{
			foreach(ComboRabbitHole comboRH in lot.GetObjects<ComboRabbitHole>())
			{
				AddContainedRabbitHolesToLot (comboRH);
			}
		}

 public void OnExitBuildBuy(Lot lot)
 {
     foreach (ISprinkler sprinkler in lot.GetObjects<ISprinkler>())
     {
         this.SetSprinklerAlarm(sprinkler);
     }
 }

 public void OnExitBuildBuy(Lot lot)
 {
     foreach (ShowStage stage in lot.GetObjects<ShowStage>())
     {
         ShowStageEx.StoreChanges(stage, Overwatch.Log);
     }
 }

 public void OnExitBuildBuy(Lot lot)
 {
     foreach (AncientPortal portal in lot.GetObjects<AncientPortal>())
     {
         if (portal.PortalComponent == null)
         {
             ObjectComponents.AddComponent<AncientPortalComponent>(portal, new object[0]);
         }
     }
 }

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

            if (!ApplyAll)
            {
                string text = StringInputDialog.Show(Name, Common.Localize("DepreciateHouse:Prompt"), "0", 256, StringInputDialog.Validation.None);
                if ((text == null) || (text == "")) return OptionResult.Failure;

                mValue = 0;
                if (!int.TryParse(text, out mValue))
                {
                    SimpleMessageDialog.Show(Name, Common.Localize("Numeric:Error"));
                    return OptionResult.Failure;
                }
            }

            if ((lot != null) && (lot.IsResidentialLot))
            {
                int oldCost = lot.CalculateFurnitureWorth ();

                int baseCost = lot.Cost - oldCost;

                Dictionary<string,int> objects = new Dictionary<string,int>();

                foreach (GameObject obj in lot.GetObjects<GameObject> ())
                {
                    if (obj is AbstractArtObject) continue;
                    
                    if (obj is Fireplace) continue;
                    
                    if (obj is ImageObject) continue;

                    if (obj is Terrarium) continue;

                    obj.ValueModifier -= (int) (obj.PurchasedPrice * (mValue / 100f));

                    if (!objects.ContainsKey(obj.CatalogName))
                    {
                        objects.Add(obj.CatalogName, 1);
                    }
                    else
                    {
                        objects[obj.CatalogName]++;
                    }
                }

                int newCost = lot.CalculateFurnitureWorth();

                Common.Notify(Common.Localize("DepreciateHouse:Success", false, new object[] { lot.Name, baseCost + oldCost, baseCost + newCost }));
            }

            return OptionResult.SuccessClose;
        }

        protected override OptionResult Run(Lot lot, Household house)
        {
            NRaas.MasterControllerSpace.Helpers.SortInventory.Item item = NRaas.MasterControllerSpace.Helpers.SortInventory.GetSortType(Name);
            if (item == null) return OptionResult.Failure;

            foreach (GameObject obj in lot.GetObjects<GameObject>())
            {
                NRaas.MasterControllerSpace.Helpers.SortInventory.Perform(obj.Inventory, item);
            }

            return OptionResult.SuccessClose;
        }

        public HomeInspection(Lot lot)
        {
            foreach (GameObject obj in lot.GetObjects<GameObject>())
            {
                if (obj is IBedDouble)
                {
                    IBedDouble bed = obj as IBedDouble;
                    if (bed.NumberOfSpots() > 1)
                    {
                        mDoubleBeds++;
                    }
                }
                else if (obj is IBedSingle)
                {
                    IBedSingle bed = obj as IBedSingle;

                    mSingleBeds += bed.NumberOfSpots();
                }
                else if (obj is ICrib)
                {
                    mCribs++;
                }
                else if ((obj is IFridge) || (obj is IFutureFoodSynthesizer))
                {
                    mFridges++;
                }
                else if (obj is IBoxStall)
                {
                    mStalls++;
                }
                else if ((obj is IPetBed) || (obj is IPetHouse))
                {
                    mPetBeds++;
                }
                else if (obj is FairyHouse)
                {
                    mFairyHouses++;
                }
                else if (obj is IBotBed)
                {
                    mBotBeds++;
                }
                else if ((obj is IMailbox) || (obj is IResidentialTrashCan))
                {
                    continue;
                }

                mEmpty = false;
            }
        }

        protected static bool IsValidLot(Lot lot, FoodTruckBase truck)
        {
            if (lot == null) return false;

            FoodTruckBase existing = TruckController.GetTruck(lot);
            if (existing != null)
            {
                if (existing != truck) return false;
            }

            if (lot.StreetParking == null) return false;

            if (lot.IsWorldLot) return false;

            if (Traffic.Settings.mRequireFoodParkingSpace)
            {
                List<FoodTruckBase> trucks = new List<FoodTruckBase>(lot.GetObjects<FoodTruckBase>());
                trucks.Remove(truck);

                if ((lot.CountObjects<WideParkingSpace>() == 0x0) || (trucks.Count > 0x0))
                {
                    return false;
                }
            }

            if (lot.IsCommunityLot)
            {
                float openHour = 0f;
                float closingHour = 0f;
                if ((Bartending.TryGetHoursOfOperation(lot, ref openHour, ref closingHour)) && (!SimClock.IsTimeBetweenTimes(SimClock.HoursPassedOfDay, openHour, closingHour)))
                {
                    return false;
                }
            }
            else
            {
                if (lot.Household == null) return false;

                if (!Traffic.Settings.mAllowFoodTruckResidential) return false;

                if (lot.Household.IsActive)
                {
                    if (!Traffic.Settings.mAllowFoodTruckActiveLot) return false;
                }
            }

            return true;
        }

        public static int GetUnfurnishedCost(Lot lot)
        {
            int cost = lot.Cost;

            foreach (GameObject obj2 in lot.GetObjects<GameObject>())
            {
                if ((!obj2.StaysAfterEvict() && !obj2.IsInPublicResidentialRoom) && !obj2.IsInHiddenResidentialRoom)
                {
                    try
                    {
                        cost -= obj2.Value;
                    }
                    catch (Exception e)
                    {
                        Common.DebugException(lot, e);
                    }
                }
            }

            return cost;
        }

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

            foreach (GameObject obj in lot.GetObjects<GameObject>())
            {
                if ((obj.InUse) || (!obj.InWorld)) continue;

                if (obj.Charred)
                {
                    obj.Charred = false;
                    if (obj is Windows)
                    {
                        RepairableComponent.CreateReplaceObject(obj);
                    }
                }

                RepairableComponent repairable = obj.Repairable;
                if ((repairable != null) && (repairable.Broken))
                {
                    repairable.ForceRepaired(Sim.ActiveActor);
                }
            }

            LotLocation[] burntTiles = World.GetBurntTiles(lot.LotId, LotLocation.Invalid);
            if (burntTiles.Length > 0x0)
            {
                foreach (LotLocation burnt in burntTiles)
                {
                    if ((lot.LotLocationIsPublicResidential(burnt)) && ((lot.TombRoomManager == null) || !lot.TombRoomManager.IsObjectInATombRoom(burnt)))
                    {
                        World.SetBurnt(lot.LotId, burnt, false);
                    }
                }
            }

            return OptionResult.SuccessClose;
        }

 public void OnExitBuildBuy(Lot lot)
 {
     foreach (ISprinkler sprinkler in lot.GetObjects<ISprinkler>())
     {
         RemoveEAAlarms(sprinkler);
     }
 }

 public void OnExitBuildBuy(Lot lot)
 {
     Door[] doors = lot.GetObjects<Door>();
     foreach (Door door in doors)
     {
         ReplaceComponent(door);
     }
 }

        protected override bool PrivateSatisfies(ManagerCareer manager, SimDescription sim, Lot newLot, bool inspecting)
        {
            if (!inspecting)
            {
                if (!manager.GetValue<ManagerCareer.AssignSelfEmployedOption, bool>()) return false;
            }

            if ((mRequiredObjects == null) || (mRequiredObjects.Count == 0)) return true;

            if (newLot != null)
            {
                foreach (GameObject obj in newLot.GetObjects<GameObject>())
                {
                    if (Matches(obj.GetType())) return true;
                }
            }

            return false;
        }

        public static string GetDetails(Lot lot, Household me)
        {
            string msg = null;
            if (me != null)
            {
                msg += Common.Localize("StatusHouse:HouseName", false, new object[] { me.Name });
            }

            if (lot != null)
            {
                msg += Common.Localize("StatusHouse:LotName", false, new object[] { lot.Name });
            }

            if (me != null)
            {
                msg += Common.Localize("StatusHouse:Funds", false, new object[] { me.FamilyFunds });

                if (me.RealEstateManager != null)
                {
                    int realEstate = 0;
                    foreach (PropertyData data in me.RealEstateManager.AllProperties)
                    {
                        realEstate += data.TotalValue;
                    }

                    msg += Common.Localize("StatusHouse:RealEstate", false, new object[] { realEstate });
                }


                if (lot != null)
                {
                    int taxes, savings, vacationHome;
                    GetTaxes(me, out taxes, out savings, out vacationHome);
                    msg += Common.Localize("StatusHouse:Taxes", false, new object[] { (taxes - vacationHome) + savings, vacationHome, savings, taxes });
                }
            }

            if (lot == null)
            {
                msg += Common.Localize("StatusHouse:Homeless");
            }
            else
            {
                msg += Common.Localize("StatusHouse:Address", false, new object[] { lot.Address, Lots.GetUnfurnishedCost(lot), lot.Cost - lot.GetUnfurnishedCost(), lot.Cost });

                int iFridges = 0, iCribs = 0, iSingleBeds = 0, iDoubleBeds = 0;

                List<IGameObject> lotObjects = new List<IGameObject>(lot.GetObjects<IGameObject>());
                foreach (IGameObject obj in lotObjects)
                {
                    if (obj is Sims3.Gameplay.Objects.Appliances.Fridge)
                    {
                        iFridges++;
                    }
                    else if (obj is ICrib)
                    {
                        iCribs++;
                    }
                    else if (obj is IBedDouble)
                    {
                        iDoubleBeds++;
                    }
                    else if (obj is IBedSingle)
                    {
                        iSingleBeds++;
                    }
                }

                msg += Common.Localize("StatusHouse:Objects", false, new object[] { iFridges, iCribs, iDoubleBeds, iSingleBeds });
            }

            if ((me != null) && (!SimTypes.IsService(me)))
            {
                int count = 0;
                string occupants = null;

                foreach (SimDescription sim in CommonSpace.Helpers.Households.All(me))
                {
                    occupants += Common.NewLine + sim.FullName;

                    count++;
                    if (count >= 24) break;
                }

                msg += Common.Localize("StatusHouse:Occupants", false, new object[] { occupants });
            }

            return msg;
        }

        private static bool ChangeLotTypeHelper(Lot lot, bool deleteInvalidObjects, LotType newType, CommercialLotSubType commercialSubType, ResidentialLotSubType residentialSubType)
        {
            List<GameObject> objects = null;

            if (newType == LotType.Commercial)
            {
                // Custom
                //objects = lot.GetObjects<GameObject>(new Predicate<GameObject>(EditTownModel.IsNotValidCommunityLotObject));

                if (commercialSubType == CommercialLotSubType.kEP10_Resort)
                {
                    foreach (RabbitHole hole in lot.GetObjects<RabbitHole>(new Predicate<RabbitHole>(EditTownModel.IsInvestable)))
                    {
                        objects.Add(hole);
                    }

                    if (lot.ResortManager == null)
                    {
                        lot.ResortManager = new ResortManager(lot);
                    }
                }
            }
            else
            {
                // Custom
                //objects = lot.GetObjects<GameObject>(new Predicate<GameObject>(EditTownModel.IsNotValidResidentialLotObject));
            }

            if ((objects != null) && (objects.Count > 0))
            {
                if (!deleteInvalidObjects)
                {
                    return false;
                }

                foreach (GameObject obj2 in objects)
                {
                    int num = 0;
                    bool flag = false;
                    while (obj2.ActorsUsingMe.Count > num)
                    {
                        Sim sim = obj2.ActorsUsingMe[num];
                        if (sim != null)
                        {
                            sim.SetObjectToReset();
                            sim.InteractionQueue.PurgeInteractions(obj2);
                            flag = true;
                        }
                        num++;
                    }
                    if (flag)
                    {
                        SpeedTrap.Sleep(0);
                    }
                    lot.RemoveObjectFromLot(obj2.ObjectId, true);
                    obj2.Destroy();
                }

                ThumbnailKey key = new ThumbnailKey(new ResourceKey(lot.LotId, 0x436fee4c, 0), ThumbnailSize.Large);
                ThumbnailManager.InvalidateThumbnail(key);
                EditTownModel.UpdateDirtyLotThumbnailsTask(true);
            }

            if (lot.CommercialLotSubType == CommercialLotSubType.kEP10_Resort)
            {
                foreach (IResortBuffetTable table in lot.GetObjects<IResortBuffetTable>())
                {
                    table.ClearTable();
                }
            }

            if (GameStates.IsEditTownState)
            {
                BinCommon.KickSimsOffLot(lot, true);
            }

            return true;
        }