C# Framework.LandUpdateArgs类代码示例

 public void ParcelPropsHook(LandUpdateArgs args, int local_id, IClientAPI remote_client)
 {
     this.Stale = true;
 }

        public void UpdateLandProperties(LandUpdateArgs args, IClientAPI remote_client)
        {
            if (m_scene.Permissions.CanEditParcel(remote_client.AgentId, this) &&
                m_scene.RegionInfo.EstateSettings.AllowParcelChanges)
            {
                try
                {
                    bool snap_selection = false;
                    LandData newData = LandData.Copy();

                    if (args.AuthBuyerID != newData.AuthBuyerID || args.SalePrice != newData.SalePrice)
                    {
                        if (m_scene.Permissions.CanSellParcel(remote_client.AgentId, this) &&
                            m_scene.RegionInfo.RegionSettings.AllowLandResell)
                        {
                            newData.AuthBuyerID = args.AuthBuyerID;
                            newData.SalePrice = args.SalePrice;
                            snap_selection = true;
                        }
                        else
                            remote_client.SendAlertMessage("Permissions: You cannot set this parcel for sale");
                    }

                    if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.LandSetSale))
                    {
                        if (!LandData.IsGroupOwned)
                        {
                            newData.GroupID = args.GroupID;
                        }
                    }

                    if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.FindPlaces))
                    {
                        newData.Category = args.Category;
                    }

                    if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.ChangeMedia))
                    {
                        newData.MediaAutoScale = args.MediaAutoScale;
                        newData.MediaID = args.MediaID;
                        newData.MediaURL = args.MediaURL;
                        newData.MusicURL = args.MusicURL;
                        newData.MediaType = args.MediaType;
                        newData.MediaDescription = args.MediaDescription;
                        newData.MediaWidth = args.MediaWidth;
                        newData.MediaHeight = args.MediaHeight;
                        newData.MediaLoop = args.MediaLoop;
                        newData.ObscureMusic = args.ObscureMusic;
                        newData.ObscureMedia = args.ObscureMedia;
                    }

                    if (m_scene.RegionInfo.RegionSettings.BlockFly &&
                        ((args.ParcelFlags & (uint)ParcelFlags.AllowFly) == (uint)ParcelFlags.AllowFly))
                        //Vanquish flying as per estate settings!
                        args.ParcelFlags &= ~(uint)ParcelFlags.AllowFly;

                    if (m_scene.RegionInfo.RegionSettings.RestrictPushing &&
                        ((args.ParcelFlags & (uint)ParcelFlags.RestrictPushObject) == (uint)ParcelFlags.RestrictPushObject))
                        //Vanquish pushing as per estate settings!
                        args.ParcelFlags &= ~(uint)ParcelFlags.RestrictPushObject;

                    if (!m_scene.RegionInfo.EstateSettings.AllowLandmark &&
                        ((args.ParcelFlags & (uint)ParcelFlags.AllowLandmark) == (uint)ParcelFlags.AllowLandmark))
                        //Vanquish landmarks as per estate settings!
                        args.ParcelFlags &= ~(uint)ParcelFlags.AllowLandmark;

                    if (m_scene.RegionInfo.RegionSettings.BlockShowInSearch &&
                        ((args.ParcelFlags & (uint)ParcelFlags.ShowDirectory) == (uint)ParcelFlags.ShowDirectory))
                        //Vanquish show in search as per estate settings!
                        args.ParcelFlags &= ~(uint)ParcelFlags.ShowDirectory;

                    if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.SetLandingPoint))
                    {
                        newData.LandingType = args.LandingType;
                        newData.UserLocation = args.UserLocation;
                        newData.UserLookAt = args.UserLookAt;
                    }

                    if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.LandChangeIdentity))
                    {
                        newData.Description = args.Desc;
                        newData.Name = args.Name;
                        newData.SnapshotID = args.SnapshotID;
                    }

                    if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.LandManagePasses))
                    {
                        newData.PassHours = args.PassHours;
                        newData.PassPrice = args.PassPrice;
                    }

                    newData.Flags = args.ParcelFlags;

                    m_parcelManagementModule.UpdateLandObject(LandData.LocalID, newData);

                    SendLandUpdateToAvatarsOverMe(snap_selection);
                }
                catch(Exception ex)
                {
                    m_log.Warn("[LAND]: Error updating land object " + this.LandData.Name + " in region " + this.m_scene.RegionInfo.RegionName + " : " + ex.ToString());
//.........这里部分代码省略.........

 public void TriggerOnParcelPropertiesUpdateRequest(LandUpdateArgs args,
                 int local_id, IClientAPI remote_client)
 {
     ParcelPropertiesUpdateRequest handler = OnParcelPropertiesUpdateRequest;
     if (handler != null)
     {
         foreach (ParcelPropertiesUpdateRequest d in handler.GetInvocationList())
         {
             try
             {
                 d(args, local_id, remote_client);
             }
             catch (Exception e)
             {
                 m_log.ErrorFormat(
                     "[EVENT MANAGER]: Delegate for TriggerOnSceneObjectPartCopy failed - continuing.  {0} {1}", 
                     e.Message, e.StackTrace);
             }
         }
     }
 }

        public void UpdateLandProperties(LandUpdateArgs args, IClientAPI remote_client)
        {
            if (m_scene.Permissions.CanEditParcel(remote_client.AgentId,this))
            {
                //Needs later group support
                bool snap_selection = false;
                LandData newData = LandData.Copy();

                if (args.AuthBuyerID != newData.AuthBuyerID || args.SalePrice != newData.SalePrice)
                {
                    if (m_scene.Permissions.CanSellParcel(remote_client.AgentId, this))
                    {
                        newData.AuthBuyerID = args.AuthBuyerID;
                        newData.SalePrice = args.SalePrice;
                        snap_selection = true;
                    }
                }
                newData.Category = args.Category;
                newData.Description = args.Desc;
                newData.GroupID = args.GroupID;
                newData.LandingType = args.LandingType;
                newData.MediaAutoScale = args.MediaAutoScale;
                newData.MediaID = args.MediaID;
                newData.MediaURL = args.MediaURL;
                newData.MusicURL = args.MusicURL;
                newData.Name = args.Name;
                newData.Flags = args.ParcelFlags;
                newData.PassHours = args.PassHours;
                newData.PassPrice = args.PassPrice;
                newData.SnapshotID = args.SnapshotID;
                newData.UserLocation = args.UserLocation;
                newData.UserLookAt = args.UserLookAt;
                newData.MediaType = args.MediaType;
                newData.MediaDescription = args.MediaDescription;
                newData.MediaWidth = args.MediaWidth;
                newData.MediaHeight = args.MediaHeight;
                newData.MediaLoop = args.MediaLoop;
                newData.ObscureMusic = args.ObscureMusic;
                newData.ObscureMedia = args.ObscureMedia;

                m_scene.LandChannel.UpdateLandObject(LandData.LocalID, newData);

                SendLandUpdateToAvatarsOverMe(snap_selection);
            }
        }

        public void UpdateLandProperties(LandUpdateArgs args, IClientAPI remote_client)
        {
            //Needs later group support
            bool snap_selection = false;
            LandData newData = LandData.Copy();

            uint allowedDelta = 0;

            // These two are always blocked as no client can set them anyway
            // ParcelFlags.ForSaleObjects
            // ParcelFlags.LindenHome

            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.LandOptions))
            {
                allowedDelta |= (uint)(ParcelFlags.AllowLandmark |
                        ParcelFlags.AllowTerraform |
                        ParcelFlags.AllowDamage |
                        ParcelFlags.CreateObjects |
                        ParcelFlags.RestrictPushObject |
                        ParcelFlags.AllowOtherScripts |
                        ParcelFlags.AllowGroupScripts |
                        ParcelFlags.CreateGroupObjects |
                        ParcelFlags.AllowAPrimitiveEntry |
                        ParcelFlags.AllowGroupObjectEntry);
            }

            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.LandSetSale))
            {
                if (args.AuthBuyerID != newData.AuthBuyerID ||
                    args.SalePrice != newData.SalePrice)
                {
                    snap_selection = true;
                }

                newData.AuthBuyerID = args.AuthBuyerID;
                newData.SalePrice = args.SalePrice;

                if (!LandData.IsGroupOwned)
                {
                    newData.GroupID = args.GroupID;

                    allowedDelta |= (uint)(ParcelFlags.AllowDeedToGroup |
                            ParcelFlags.ContributeWithDeed |
                            ParcelFlags.SellParcelObjects);
                }

                allowedDelta |= (uint)ParcelFlags.ForSale;
            }

            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId,this, GroupPowers.FindPlaces))
            {
                newData.Category = args.Category;

                allowedDelta |= (uint)(ParcelFlags.ShowDirectory |
                        ParcelFlags.AllowPublish |
                        ParcelFlags.MaturePublish);
            }

            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId,this, GroupPowers.LandChangeIdentity))
            {
                newData.Description = args.Desc;
                newData.Name = args.Name;
                newData.SnapshotID = args.SnapshotID;
            }

            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId,this, GroupPowers.SetLandingPoint))
            {
                newData.LandingType = args.LandingType;
                newData.UserLocation = args.UserLocation;
                newData.UserLookAt = args.UserLookAt;
            }

            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId,this, GroupPowers.ChangeMedia))
            {
                newData.MediaAutoScale = args.MediaAutoScale;
                newData.MediaID = args.MediaID;
                newData.MediaURL = args.MediaURL;
                newData.MusicURL = args.MusicURL;
                newData.MediaType = args.MediaType;
                newData.MediaDescription = args.MediaDescription;
                newData.MediaWidth = args.MediaWidth;
                newData.MediaHeight = args.MediaHeight;
                newData.MediaLoop = args.MediaLoop;
                newData.ObscureMusic = args.ObscureMusic;
                newData.ObscureMedia = args.ObscureMedia;

                allowedDelta |= (uint)(ParcelFlags.SoundLocal |
                        ParcelFlags.UrlWebPage |
                        ParcelFlags.UrlRawHtml |
                        ParcelFlags.AllowVoiceChat |
                        ParcelFlags.UseEstateVoiceChan);
            }

            if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId,this, GroupPowers.LandManagePasses))
            {
                newData.PassHours = args.PassHours;
                newData.PassPrice = args.PassPrice;

                allowedDelta |= (uint)ParcelFlags.UsePassList;
            }
//.........这里部分代码省略.........

        public void ClientOnParcelPropertiesUpdateRequest(LandUpdateArgs args, int localID, IClientAPI remote_client)
        {
            ILandObject land;
            lock (m_landList)
            {
                m_landList.TryGetValue(localID, out land);
            }

            if (land != null)
            {
                land.UpdateLandProperties(args, remote_client);
                m_scene.EventManager.TriggerOnParcelPropertiesUpdateRequest(args, localID, remote_client);
            }
        }

        private string ProcessPropertiesUpdate(string request, string path, string param, UUID agentID, Caps caps)
        {
            IClientAPI client;
            if (!m_scene.TryGetClient(agentID, out client)) 
            {
                m_log.WarnFormat("[LAND MANAGEMENT MODULE]: Unable to retrieve IClientAPI for {0}", agentID);
                return LLSDHelpers.SerialiseLLSDReply(new LLSDEmpty());
            }

            ParcelPropertiesUpdateMessage properties = new ParcelPropertiesUpdateMessage();
            OpenMetaverse.StructuredData.OSDMap args = (OpenMetaverse.StructuredData.OSDMap) OSDParser.DeserializeLLSDXml(request);

            properties.Deserialize(args);

            LandUpdateArgs land_update = new LandUpdateArgs();
            int parcelID = properties.LocalID;
            land_update.AuthBuyerID = properties.AuthBuyerID;
            land_update.Category = properties.Category;
            land_update.Desc = properties.Desc;
            land_update.GroupID = properties.GroupID;
            land_update.LandingType = (byte) properties.Landing;
            land_update.MediaAutoScale = (byte) Convert.ToInt32(properties.MediaAutoScale);
            land_update.MediaID = properties.MediaID;
            land_update.MediaURL = properties.MediaURL;
            land_update.MusicURL = properties.MusicURL;
            land_update.Name = properties.Name;
            land_update.ParcelFlags = (uint) properties.ParcelFlags;
            land_update.PassHours = (int) properties.PassHours;
            land_update.PassPrice = (int) properties.PassPrice;
            land_update.SalePrice = (int) properties.SalePrice;
            land_update.SnapshotID = properties.SnapshotID;
            land_update.UserLocation = properties.UserLocation;
            land_update.UserLookAt = properties.UserLookAt;
            land_update.MediaDescription = properties.MediaDesc;
            land_update.MediaType = properties.MediaType;
            land_update.MediaWidth = properties.MediaWidth;
            land_update.MediaHeight = properties.MediaHeight;
            land_update.MediaLoop = properties.MediaLoop;
            land_update.ObscureMusic = properties.ObscureMusic;
            land_update.ObscureMedia = properties.ObscureMedia;

            ILandObject land;
            lock (m_landList)
            {
                m_landList.TryGetValue(parcelID, out land);
            }

            if (land != null)
            {
                land.UpdateLandProperties(land_update, client);
                m_scene.EventManager.TriggerOnParcelPropertiesUpdateRequest(land_update, parcelID, client);
            }
            else
            {
                m_log.WarnFormat("[LAND MANAGEMENT MODULE]: Unable to find parcelID {0}", parcelID);
            }
            return LLSDHelpers.SerialiseLLSDReply(new LLSDEmpty());
        }

        public void UpdateLandProperties(ILandObject land, LandUpdateArgs args, IClientAPI remote_client)
        {
            bool snap_selection = false;
            bool needOverlay = false;
            if (land.UpdateLandProperties(args, remote_client, out snap_selection, out needOverlay))
            {
                UUID parcelID = land.LandData.GlobalID;
                m_scene.ForEachScenePresence(delegate(ScenePresence avatar)
                {
                    if (avatar.IsDeleted || avatar.isNPC)
                        return;

                    IClientAPI client = avatar.ControllingClient;
                    if (needOverlay)
                        SendParcelOverlay(client);

                    if (avatar.IsChildAgent)
                    {
                        if(client == remote_client)
                            land.SendLandProperties(-10000, false, LandChannel.LAND_RESULT_SINGLE, client);
                        return;
                    }

                    ILandObject aland = GetLandObject(avatar.AbsolutePosition.X, avatar.AbsolutePosition.Y);
                    if (aland != null)
                    {
                        if(client == remote_client && land != aland)
                            land.SendLandProperties(-10000, false, LandChannel.LAND_RESULT_SINGLE, client);
                        else if (land == aland)
                             aland.SendLandProperties(0, false, LandChannel.LAND_RESULT_SINGLE, client);
                    }
                    if (avatar.currentParcelUUID == parcelID)
                        avatar.currentParcelUUID = parcelID; // force parcel flags review
                });
            }
        }

 public void FireUpdateParcel(LandUpdateArgs args, int LocalID)
 {
 }

        public void updateLandProperties(LandUpdateArgs args, IClientAPI remote_client)
        {
            //Needs later group support
            LandData newData = landData.Copy();

            uint allowedDelta = 0;
            bool snap_selection = false;
            bool needsInspect = false;

            // These two are always blocked as no client can set them anyway
            // ParcelFlags.ForSaleObjects
            // ParcelFlags.LindenHome

            if (m_scene.Permissions.CanEditParcel(remote_client.AgentId, this, GroupPowers.LandOptions))
            {
                allowedDelta |= (uint)(
                        ParcelFlags.AllowFly |
                        ParcelFlags.AllowLandmark |
                        ParcelFlags.AllowTerraform |
                        ParcelFlags.AllowDamage |
                        ParcelFlags.CreateObjects |
                        ParcelFlags.RestrictPushObject |
                        ParcelFlags.AllowOtherScripts |
                        ParcelFlags.AllowGroupScripts |
                        ParcelFlags.CreateGroupObjects |
                        ParcelFlags.AllowAPrimitiveEntry |
                        ParcelFlags.AllowGroupObjectEntry);
            }

            if (m_scene.Permissions.CanEditParcel(remote_client.AgentId, this, GroupPowers.LandSetSale))
            {
                if (m_scene.RegionInfo.AllowOwners != ProductRulesWho.OnlyEO)
                {
                    bool ownerTransfer = false;
                    if (args.AuthBuyerID != newData.AuthBuyerID || args.SalePrice != newData.SalePrice)
                    {
                        ownerTransfer = true;
                        snap_selection = true;
                    }

                    if (m_scene.RegionInfo.AllowSales)
                    {
                        newData.AuthBuyerID = args.AuthBuyerID;
                        newData.SalePrice = args.SalePrice;
                        allowedDelta |= (uint)ParcelFlags.ForSale;
                    }
                    else
                    if (ownerTransfer)
                    {
                        newData.ClearSaleInfo();    // SalePrice, AuthBuyerID and sale-related Flags
                        remote_client.SendAgentAlertMessage("This parcel cannot be set for sale.", false);
                    }
                }

                if (m_scene.RegionInfo.AllowGroupTags && !landData.IsGroupOwned)
                {
                    if (newData.GroupID != args.GroupID)
                    {
                        // Group tag change
                        if (m_scene.RegionInfo.AllowGroupTags || (args.GroupID == UUID.Zero))
                        {
                            newData.GroupID = args.GroupID;
                            needsInspect = true;
                        }
                        else
                            remote_client.SendAgentAlertMessage("This parcel cannot be tagged with a group.", false);
                    }

                    if (newData.GroupID != UUID.Zero)
                    {
                        allowedDelta |= (uint) ParcelFlags.SellParcelObjects;
                        if (m_scene.RegionInfo.AllowDeeding && !landData.IsGroupOwned)
                            allowedDelta |= (uint)(ParcelFlags.AllowDeedToGroup | ParcelFlags.ContributeWithDeed);
                    }
                }
            }

            if (m_scene.Permissions.CanEditParcel(remote_client.AgentId, this, GroupPowers.FindPlaces))
            {
                newData.Category = args.Category;

                allowedDelta |= (uint)(ParcelFlags.ShowDirectory |
                        ParcelFlags.AllowPublish |
                        ParcelFlags.MaturePublish);
            }

            if (m_scene.Permissions.CanEditParcel(remote_client.AgentId, this, GroupPowers.LandChangeIdentity))
            {
                newData.Description = args.Desc;
                newData.Name = args.Name;
                newData.SnapshotID = args.SnapshotID;
            }

            if (m_scene.Permissions.CanEditParcel(remote_client.AgentId, this, GroupPowers.SetLandingPoint))
            {
                newData.LandingType = args.LandingType;
                newData.UserLocation = args.UserLocation;
                newData.UserLookAt = args.UserLookAt;
            }

//.........这里部分代码省略.........

        public void handleParcelPropertiesUpdateRequest(LandUpdateArgs args, int localID, IClientAPI remote_client)
        {
            ILandObject land;
            lock (m_landList)
            {
                m_landList.TryGetValue(localID, out land);
            }

            if (land != null)
            {
                land.updateLandProperties(args, remote_client);
                parcelInfoCache.Invalidate(land.landData.GlobalID.ToString());
            }
        }

        public void updateLandProperties(LandUpdateArgs args, IClientAPI remote_client)
        {
            if (m_scene.Permissions.CanEditParcel(remote_client.AgentId,this))
            {
                //Needs later group support
                LandData newData = landData.Copy();

                if (args.AuthBuyerID != newData.AuthBuyerID || args.SalePrice != newData.SalePrice)
                {
                    if (m_scene.Permissions.CanSellParcel(remote_client.AgentId, this))
                    {
                        newData.AuthBuyerID = args.AuthBuyerID;
                        newData.SalePrice = args.SalePrice;
                    }
                }
                newData.Category = args.Category;
                newData.Description = args.Desc;
                newData.GroupID = args.GroupID;
                newData.LandingType = args.LandingType;
                newData.MediaAutoScale = args.MediaAutoScale;
                newData.MediaID = args.MediaID;
                newData.MediaURL = args.MediaURL;
                newData.MusicURL = args.MusicURL;
                newData.Name = args.Name;
                newData.Flags = args.ParcelFlags;
                newData.PassHours = args.PassHours;
                newData.PassPrice = args.PassPrice;
                newData.SnapshotID = args.SnapshotID;
                newData.UserLocation = args.UserLocation;
                newData.UserLookAt = args.UserLookAt;

                m_scene.LandChannel.UpdateLandObject(landData.LocalID, newData);

                sendLandUpdateToAvatarsOverMe();
            }
        }

        public void UpdateLandProperties(LandUpdateArgs args, IClientAPI remote_client)
        {
            if (m_scene.Permissions.CanEditParcel(remote_client.AgentId, this) &&
                m_scene.RegionInfo.EstateSettings.AllowParcelChanges)
            {
                try
                {
                    bool snap_selection = false;

                    if (args.AuthBuyerID != LandData.AuthBuyerID || args.SalePrice != LandData.SalePrice)
                    {
                        if (m_scene.Permissions.CanSellParcel(remote_client.AgentId, this) &&
                            m_scene.RegionInfo.RegionSettings.AllowLandResell)
                        {
                            LandData.AuthBuyerID = args.AuthBuyerID;
                            LandData.SalePrice = args.SalePrice;
                            snap_selection = true;
                        }
                        else
                        {
                            remote_client.SendAlertMessage("Permissions: You cannot set this parcel for sale");
                            args.ParcelFlags &= ~(uint) ParcelFlags.ForSale;
                            args.ParcelFlags &= ~(uint) ParcelFlags.ForSaleObjects;
                            args.ParcelFlags &= ~(uint) ParcelFlags.SellParcelObjects;
                        }
                    }

                    if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.LandSetSale))
                    {
                        if (!LandData.IsGroupOwned)
                        {
                            LandData.GroupID = args.GroupID;
                        }
                    }

                    if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.FindPlaces))
                        LandData.Category = args.Category;

                    if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this, GroupPowers.ChangeMedia))
                    {
                        LandData.MediaAutoScale = args.MediaAutoScale;
                        LandData.MediaID = args.MediaID;
                        LandData.MediaURL = args.MediaURL;
                        LandData.MusicURL = args.MusicURL;
                        LandData.MediaType = args.MediaType;
                        LandData.MediaDescription = args.MediaDescription;
                        LandData.MediaWidth = args.MediaWidth;
                        LandData.MediaHeight = args.MediaHeight;
                        LandData.MediaLoop = args.MediaLoop;
                        LandData.ObscureMusic = args.ObscureMusic;
                        LandData.ObscureMedia = args.ObscureMedia;
                    }

                    if (m_scene.RegionInfo.RegionSettings.BlockFly &&
                        ((args.ParcelFlags & (uint) ParcelFlags.AllowFly) == (uint) ParcelFlags.AllowFly))
                        //Vanquish flying as per estate settings!
                        args.ParcelFlags &= ~(uint) ParcelFlags.AllowFly;

                    if (m_scene.RegionInfo.RegionSettings.RestrictPushing &&
                        ((args.ParcelFlags & (uint) ParcelFlags.RestrictPushObject) ==
                         (uint) ParcelFlags.RestrictPushObject))
                        //Vanquish pushing as per estate settings!
                        args.ParcelFlags &= ~(uint) ParcelFlags.RestrictPushObject;

                    if (!m_scene.RegionInfo.EstateSettings.AllowLandmark &&
                        ((args.ParcelFlags & (uint) ParcelFlags.AllowLandmark) == (uint) ParcelFlags.AllowLandmark))
                        //Vanquish landmarks as per estate settings!
                        args.ParcelFlags &= ~(uint) ParcelFlags.AllowLandmark;

                    if (m_scene.RegionInfo.RegionSettings.BlockShowInSearch &&
                        ((args.ParcelFlags & (uint) ParcelFlags.ShowDirectory) == (uint) ParcelFlags.ShowDirectory))
                        //Vanquish show in search as per estate settings!
                        args.ParcelFlags &= ~(uint) ParcelFlags.ShowDirectory;

                    if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this,
                                                                    GroupPowers.SetLandingPoint))
                    {
                        LandData.LandingType = args.LandingType;
                        LandData.UserLocation = args.UserLocation;
                        LandData.UserLookAt = args.UserLookAt;
                    }

                    if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this,
                                                                    GroupPowers.LandChangeIdentity))
                    {
                        LandData.Description = args.Desc;
                        LandData.Name = args.Name;
                        LandData.SnapshotID = args.SnapshotID;
                        LandData.Private = args.Privacy;
                    }

                    if (m_scene.Permissions.CanEditParcelProperties(remote_client.AgentId, this,
                                                                    GroupPowers.LandManagePasses))
                    {
                        LandData.PassHours = args.PassHours;
                        LandData.PassPrice = args.PassPrice;
                    }

                    if ((args.ParcelFlags & (uint) ParcelFlags.ShowDirectory) == (uint) ParcelFlags.ShowDirectory &&
                        (LandData.Flags & (uint) ParcelFlags.ShowDirectory) != (uint) ParcelFlags.ShowDirectory)
//.........这里部分代码省略.........

        public void handleParcelPropertiesUpdateRequest(LandUpdateArgs args, int localID, IClientAPI remote_client)
        {
            ILandObject land;
            lock (m_landList)
            {
                m_landList.TryGetValue(localID, out land);
            }

            if (land != null) land.updateLandProperties(args, remote_client);
        }

        public void ClientOnParcelPropertiesUpdateRequest(LandUpdateArgs args, int localID, IClientAPI remote_client)
        {
            ILandObject land;
            m_landListRwLock.AcquireReaderLock(-1);
            try
            {
                m_landList.TryGetValue(localID, out land);
            }
            finally
            {
                m_landListRwLock.ReleaseReaderLock();
            }

            if (land != null)
            {
                land.UpdateLandProperties(args, remote_client);
                m_scene.EventManager.TriggerOnParcelPropertiesUpdateRequest(args, localID, remote_client);
            }
        }