C# LandData类代码示例

        /// <summary>
        /// This also updates the parcel, not for just adding a new one
        /// </summary>
        /// <param name="args"></param>
        /// <param name="regionID"></param>
        /// <param name="forSale"></param>
        /// <param name="EstateID"></param>
        /// <param name="showInSearch"></param>
        public void AddLandObject(LandData args)
        {
            //Check whether this region is just spamming add to search and stop them if they are
            if (timeBeforeNextUpdate.ContainsKey(args.InfoUUID) &&
                Util.UnixTimeSinceEpoch() < timeBeforeNextUpdate[args.InfoUUID])
                return; //Too soon to update

            //Update the time with now + the time to wait for the next update
            timeBeforeNextUpdate[args.InfoUUID] = Util.UnixTimeSinceEpoch() + (60 * minTimeBeforeNextParcelUpdate);
            
            List<object> Values = new List<object>();
            Values.Add(args.RegionID);
            Values.Add(args.GlobalID);
            Values.Add(args.LocalID);
            Values.Add(args.UserLocation.X);
            Values.Add(args.UserLocation.Y);
            Values.Add(args.UserLocation.Z);
            Values.Add(args.Name);
            Values.Add(args.Description);
            Values.Add(args.Flags);
            Values.Add(args.Dwell);
            //InfoUUID is the missing 'real' Gridwide ParcelID
            Values.Add(args.InfoUUID);
            Values.Add(((args.Flags & (uint)ParcelFlags.ForSale) == (uint)ParcelFlags.ForSale) ? 1 : 0);
            Values.Add(args.SalePrice);
            Values.Add(args.AuctionID);
            Values.Add(args.Area);
            Values.Add(0);
            Values.Add(args.Maturity);
            Values.Add(args.OwnerID);
            Values.Add(args.GroupID);
            Values.Add(((args.Flags & (uint)ParcelFlags.ShowDirectory) == (uint)ParcelFlags.ShowDirectory) ? 1 : 0);
            Values.Add(args.SnapshotID);

            List<string> Keys = new List<string>();
            Keys.Add("RegionID");
            Keys.Add("ParcelID");
            Keys.Add("LocalID");
            Keys.Add("LandingX");
            Keys.Add("LandingY");
            Keys.Add("LandingZ");
            Keys.Add("Name");
            Keys.Add("Description");
            Keys.Add("Flags");
            Keys.Add("Dwell");
            Keys.Add("InfoUUID");
            Keys.Add("ForSale");
            Keys.Add("SalePrice");
            Keys.Add("Auction");
            Keys.Add("Area");
            Keys.Add("EstateID");
            Keys.Add("Maturity");
            Keys.Add("OwnerID");
            Keys.Add("GroupID");
            Keys.Add("ShowInSearch");
            Keys.Add("SnapshotID");

            GD.Replace("searchparcel", Keys.ToArray(), Values.ToArray());
        }

 /// <summary>
 /// This also updates the parcel, not for just adding a new one
 /// </summary>
 /// <param name="args"></param>
 /// <param name="regionID"></param>
 /// <param name="forSale"></param>
 /// <param name="EstateID"></param>
 /// <param name="showInSearch"></param>
 public void AddLandObject(LandData args)
 {
     OSDMap mess = args.ToOSD ();
     mess["Method"] = "addlandobject";
     List<string> m_ServerURIs = m_registry.RequestModuleInterface<IConfigurationService>().FindValueOf("RemoteServerURI");
     foreach (string m_ServerURI in m_ServerURIs)
     {
         WebUtils.PostToService (m_ServerURI + "osd", mess, false, false);
     }
 }

        /// <summary>
        /// This also updates the parcel, not for just adding a new one
        /// </summary>
        /// <param name="args"></param>
        /// <param name="regionID"></param>
        /// <param name="forSale"></param>
        /// <param name="EstateID"></param>
        /// <param name="showInSearch"></param>
        public void AddLandObject(LandData args)
        {
            Dictionary<string, object> sendData = args.ToKeyValuePairs();

            sendData["METHOD"] = "addlandobject";

            string reqString = ServerUtils.BuildXmlResponse(sendData);

            try
            {
                SynchronousRestFormsRequester.MakeRequest("POST",
                        m_ServerURI + "/auroradata",
                        reqString);
            }
            catch (Exception e)
            {
                m_log.DebugFormat("[AuroraRemoteDirectoryServiceConnector]: Exception when contacting server: {0}", e.Message);
            }
        }

 private void SaveParcelAccessList(LandData data)
 {
     foreach (ParcelManager.ParcelAccessEntry entry in data.ParcelAccessList)
     {
         GD.Replace("parcelaccess", new string[]
         {
             "ParcelID",
             "AccessID",
             "Flags",
             "Time"
         }
         ,
         new object[]
         {
             data.GlobalID,
             entry.AgentID,
             entry.Flags,
             entry.Time.Ticks
         });
     }
 }

        /// <summary>
        /// This also updates the parcel, not for just adding a new one
        /// </summary>
        /// <param name="args"></param>
        /// <param name="regionID"></param>
        /// <param name="forSale"></param>
        /// <param name="EstateID"></param>
        /// <param name="showInSearch"></param>
        public void AddLandObject(LandData args)
        {
            Dictionary<string, object> sendData = args.ToKeyValuePairs();

            sendData["METHOD"] = "addlandobject";

            string reqString = WebUtils.BuildXmlResponse(sendData);

            try
            {
                List<string> m_ServerURIs = m_registry.RequestModuleInterface<IConfigurationService>().FindValueOf("RemoteServerURI");
                foreach (string m_ServerURI in m_ServerURIs)
                {
                    AsynchronousRestObjectRequester.MakeRequest("POST",
                           m_ServerURI,
                           reqString);
                }
            }
            catch (Exception e)
            {
                m_log.DebugFormat("[AuroraRemoteDirectoryServiceConnector]: Exception when contacting server: {0}", e.ToString());
            }
        }

 /// <summary>
 /// Save this parcel's access list 
 /// </summary>
 /// <param name="data"></param>
 private void SaveParcelAccessList(LandData data)
 {
     //Clear out all old parcel bans and access list entries
     GD.Delete("parcelaccess", new string[] { "ParcelID" }, new object[] { data.GlobalID });
     foreach (ParcelManager.ParcelAccessEntry entry in data.ParcelAccessList)
     {
         //Replace all the old ones
         GD.Replace("parcelaccess", new string[]
         {
             "ParcelID",
             "AccessID",
             "Flags",
             "Time"
         }
         ,
         new object[]
         {
             data.GlobalID,
             entry.AgentID,
             entry.Flags,
             entry.Time.Ticks
         });
     }
 }

 private void BuildParcelAccessList(LandData LandData)
 {
     List<string> Query = GD.Query("ParcelID", LandData.GlobalID, "parcelaccess", "AccessID, Flags, Time");
     int i = 0;
     int dataCount = 0;
     ParcelManager.ParcelAccessEntry entry = new ParcelManager.ParcelAccessEntry();
     foreach (string retVal in Query)
     {
         if (dataCount == 0)
             entry.AgentID = UUID.Parse(Query[i]);
         if (dataCount == 1)
             entry.Flags = (AccessList)int.Parse(Query[i]);
         if (dataCount == 2)
             entry.Time = new DateTime(long.Parse(Query[i]));
         dataCount++;
         i++;
         if (dataCount == 3)
         {
             LandData.ParcelAccessList.Add(entry);
             entry = new ParcelManager.ParcelAccessEntry();
             dataCount = 0;
         }
     }
 }

 public LandData GetParcelInfo(UUID InfoUUID)
 {
     List<string> Query = GD.Query("InfoUUID", InfoUUID, "searchparcel", "*");
     LandData LandData = new LandData();
     if (Query.Count == 0)
         return null;
     LandData.RegionID = UUID.Parse(Query[0]);
     LandData.GlobalID = UUID.Parse(Query[1]);
     LandData.LocalID = int.Parse(Query[2]);
     LandData.UserLocation = Vector3.Parse(Query[3]);
     LandData.Name = Query[6];
     LandData.Description = Query[7];
     LandData.Flags = uint.Parse(Query[8]);
     LandData.Dwell = int.Parse(Query[9]);
     LandData.InfoUUID = UUID.Parse(Query[10]);
     LandData.AuctionID = uint.Parse(Query[13]);
     LandData.Area = int.Parse(Query[14]);
     LandData.Maturity = int.Parse(Query[16]);
     LandData.OwnerID = UUID.Parse(Query[17]);
     LandData.GroupID = UUID.Parse(Query[18]);
     LandData.SnapshotID = UUID.Parse(Query[20]);
     return LandData;
 }

 public override IDataTransferable Duplicate()
 {
     LandData m = new LandData();
     m.FromOSD(ToOSD());
     return m;
 }

        /// <summary>
        /// Make a new copy of the land data
        /// </summary>
        /// <returns></returns>
        public LandData Copy()
        {
            LandData landData = new LandData();

            landData._AABBMax = _AABBMax;
            landData._AABBMin = _AABBMin;
            landData._area = _area;
            landData._auctionID = _auctionID;
            landData._authBuyerID = _authBuyerID;
            landData._category = _category;
            landData._claimDate = _claimDate;
            landData._claimPrice = _claimPrice;
            landData._globalID = _globalID;
            landData._groupID = _groupID;
            landData._isGroupOwned = _isGroupOwned;
            landData._localID = _localID;
            landData._landingType = _landingType;
            landData._mediaAutoScale = _mediaAutoScale;
            landData._mediaID = _mediaID;
            landData._mediaURL = _mediaURL;
            landData._musicURL = _musicURL;
            landData._ownerID = _ownerID;
            landData._bitmap = (byte[]) _bitmap.Clone();
            landData._description = _description;
            landData._flags = _flags;
            landData._name = _name;
            landData._status = _status;
            landData._passHours = _passHours;
            landData._passPrice = _passPrice;
            landData._salePrice = _salePrice;
            landData._snapshotID = _snapshotID;
            landData._userLocation = _userLocation;
            landData._userLookAt = _userLookAt;
            landData._otherCleanTime = _otherCleanTime;
            landData._dwell = _dwell;
            landData._mediaType = _mediaType;
            landData._mediaDescription = _mediaDescription;
            landData._mediaWidth = _mediaWidth;
            landData._mediaHeight = _mediaHeight;
            landData._mediaLoop = _mediaLoop;
            landData._MediaLoopSet = _MediaLoopSet;
            landData._obscureMusic = _obscureMusic;
            landData._obscureMedia = _obscureMedia;
            landData._regionID = _regionID;
            landData._regionHandle = _regionHandle;
            landData._infoUUID = _infoUUID;
            landData._Maturity = _Maturity;
            landData._private = _private;

            landData._parcelAccessList.Clear();
            foreach (ParcelManager.ParcelAccessEntry entry in _parcelAccessList)
            {
                ParcelManager.ParcelAccessEntry newEntry = new ParcelManager.ParcelAccessEntry();
                newEntry.AgentID = entry.AgentID;
                newEntry.Flags = entry.Flags;
                newEntry.Time = entry.Time;

                landData._parcelAccessList.Add(newEntry);
            }

            return landData;
        }

        // Issue 5 - End
        static TileData()
        {
            using (FileStream fileStream = FileManager.GetFile("tiledata.mul"))
            {
                BinaryReader bin = new BinaryReader(fileStream);

                LandData landData;
                ItemData itemData;

                if (fileStream.Length == 3188736)
                { // 7.0.9.0
                    LandData = new LandData[0x4000];

                    for (int i = 0; i < 0x4000; ++i)
                    {
                        landData = new LandData();

                        if (i == 1 || (i > 0 && (i & 0x1F) == 0))
                        {
                            bin.ReadInt32();
                        }

                        TileFlag flags = (TileFlag)bin.ReadInt64();

                        int iTextureID = bin.ReadInt16();

                        bin.BaseStream.Seek(20, SeekOrigin.Current);

                        landData.Flags = flags;
                        landData.TextureID = iTextureID;

                        LandData[i] = landData;
                    }

                    ItemData = new ItemData[0x10000];

                    for (int i = 0; i < 0x10000; ++i)
                    {
                        itemData = new ItemData();

                        if ((i & 0x1F) == 0)
                        {
                            bin.ReadInt32();
                        }

                        itemData.Flags = (TileFlag)bin.ReadInt64();
                        itemData.Weight = bin.ReadByte();
                        itemData.Quality = bin.ReadByte();

                        itemData.Unknown1 = bin.ReadByte();
                        itemData.Unknown2 = bin.ReadByte();
                        itemData.Unknown3 = bin.ReadByte();

                        itemData.Quantity = bin.ReadByte();
                        itemData.AnimID = bin.ReadInt16();

                        bin.BaseStream.Seek(2, SeekOrigin.Current); // hue?
                        itemData.Unknown4 = bin.ReadByte();

                        itemData.Value = bin.ReadByte();
                        itemData.Height = bin.ReadByte();

                        itemData.Name = ASCIIEncoding.ASCII.GetString((bin.ReadBytes(20)));
                        itemData.Name = itemData.Name.Trim('\0');
                        // binaryReader.BaseStream.Seek(20, SeekOrigin.Current);

                        // Issue 5 - Statics (bridge, stairs, etc) should be walkable - http://code.google.com/p/ultimaxna/issues/detail?id=5 - Smjert
                        if (i > 1005 && i < 7640)
                            itemData.IsStairs = !(Array.BinarySearch(m_StairsID, i) < 0);
                        // Issue 5 - End

                        ItemData[i] = itemData;
                    }
                }
                else
                {
                    LandData = new LandData[0x4000];

                    for (int i = 0; i < 0x4000; ++i)
                    {

                        landData = new LandData();

                        if ((i & 0x1F) == 0)
                        {
                            bin.ReadInt32();
                        }

                        TileFlag flags = (TileFlag)bin.ReadInt32();

                        int iTextureID = bin.ReadInt16();

                        bin.BaseStream.Seek(20, SeekOrigin.Current);

                        landData.Flags = flags;
                        landData.TextureID = iTextureID;

                        LandData[i] = landData;
                    }
//.........这里部分代码省略.........

            public void LoadModuleFromArchive(byte[] data, string filePath, TarArchiveReader.TarEntryType type, IScene scene)
            {
                if (filePath.StartsWith("parcels/"))
                {
                    if (!m_merge)
                    {
                        //Only use if we are not merging
                        LandData parcel = new LandData();
                        OSD parcelData = OSDParser.DeserializeLLSDBinary(data);
                        parcel.FromOSD((OSDMap)parcelData);
                        m_parcels.Add(parcel);
                    }
                }
                #region New Style Terrain Loading
                else if (filePath.StartsWith ("newstyleterrain/"))
                {
                    ITerrainModule terrainModule = scene.RequestModuleInterface<ITerrainModule>();
                    terrainModule.TerrainMap = ReadTerrain(data, scene);
                }
                else if (filePath.StartsWith ("newstylerevertterrain/"))
                {
                    ITerrainModule terrainModule = scene.RequestModuleInterface<ITerrainModule>();
                    terrainModule.TerrainRevertMap = ReadTerrain(data, scene);
                }
                else if (filePath.StartsWith ("newstylewater/"))
                {
                    ITerrainModule terrainModule = scene.RequestModuleInterface<ITerrainModule>();
                    terrainModule.TerrainWaterMap = ReadTerrain(data, scene);
                }
                else if (filePath.StartsWith ("newstylerevertwater/"))
                {
                    ITerrainModule terrainModule = scene.RequestModuleInterface<ITerrainModule>();
                    terrainModule.TerrainWaterRevertMap = ReadTerrain(data, scene);
                }
                #endregion
                else if (filePath.StartsWith ("terrain/"))
                {
                    ITerrainModule terrainModule = scene.RequestModuleInterface<ITerrainModule>();

                    MemoryStream ms = new MemoryStream (data);
                    terrainModule.LoadFromStream (filePath, ms, 0, 0);
                    ms.Close ();
                }
                else if (filePath.StartsWith ("revertterrain/"))
                {
                    ITerrainModule terrainModule = scene.RequestModuleInterface<ITerrainModule>();

                    MemoryStream ms = new MemoryStream (data);
                    terrainModule.LoadRevertMapFromStream (filePath, ms, 0, 0);
                    ms.Close ();
                }
                else if (filePath.StartsWith ("water/"))
                {
                    ITerrainModule terrainModule = scene.RequestModuleInterface<ITerrainModule>();

                    MemoryStream ms = new MemoryStream (data);
                    terrainModule.LoadWaterFromStream (filePath, ms, 0, 0);
                    ms.Close ();
                }
                else if (filePath.StartsWith ("revertwater/"))
                {
                    ITerrainModule terrainModule = scene.RequestModuleInterface<ITerrainModule>();

                    MemoryStream ms = new MemoryStream (data);
                    terrainModule.LoadWaterRevertMapFromStream (filePath, ms, 0, 0);
                    ms.Close ();
                }
                else if (filePath.StartsWith ("entities/"))
                {
                    MemoryStream ms = new MemoryStream (data);
                    SceneObjectGroup sceneObject = OpenSim.Region.Framework.Scenes.Serialization.SceneObjectSerializer.FromXml2Format (ref ms, scene);
                    ms.Close ();
                    ms = null;
                    data = null;
                    foreach(ISceneChildEntity part in sceneObject.ChildrenEntities())
                    {
                        if (!ResolveUserUuid (part.CreatorID))
                            part.CreatorID = m_scene.RegionInfo.EstateSettings.EstateOwner;

                        if (!ResolveUserUuid (part.OwnerID))
                            part.OwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;

                        if (!ResolveUserUuid (part.LastOwnerID))
                            part.LastOwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;

                        // Fix ownership/creator of inventory items
                        // Not doing so results in inventory items
                        // being no copy/no mod for everyone
                        lock (part.TaskInventory)
                        {
                            TaskInventoryDictionary inv = part.TaskInventory;
                            foreach (KeyValuePair<UUID, TaskInventoryItem> kvp in inv)
                            {
                                if (!ResolveUserUuid (kvp.Value.OwnerID))
                                {
                                    kvp.Value.OwnerID = scene.RegionInfo.EstateSettings.EstateOwner;
                                }
                                if (!ResolveUserUuid (kvp.Value.CreatorID))
                                {
                                    kvp.Value.CreatorID = scene.RegionInfo.EstateSettings.EstateOwner;
//.........这里部分代码省略.........

        /// <summary>
        /// Gets a parcel from the search database by Info UUID (the true cross instance parcel ID)
        /// </summary>
        /// <param name="ParcelID"></param>
        /// <returns></returns>
        public LandData GetParcelInfo(UUID InfoUUID)
        {
            //Get info about a specific parcel somewhere in the metaverse
            List<string> Query = GD.Query("InfoUUID", InfoUUID, "searchparcel", "*");
            //Cant find it, return
            if (Query.Count == 0)
                return null;

            //Parse and return
            LandData LandData = new LandData();
            LandData.RegionID = UUID.Parse(Query[0]);
            LandData.GlobalID = UUID.Parse(Query[1]);
            LandData.LocalID = int.Parse(Query[2]);
            LandData.UserLocation = new Vector3(float.Parse(Query[3]), float.Parse(Query[4]), float.Parse(Query[5]));
            LandData.Name = Query[6];
            LandData.Description = Query[7];
            LandData.Flags = uint.Parse(Query[8]);
            LandData.Dwell = int.Parse(Query[9]);
            LandData.InfoUUID = UUID.Parse(Query[10]);
            LandData.AuctionID = uint.Parse(Query[13]);
            LandData.Area = int.Parse(Query[14]);
            LandData.Maturity = int.Parse(Query[16]);
            LandData.OwnerID = UUID.Parse(Query[17]);
            LandData.GroupID = UUID.Parse(Query[18]);
            LandData.SnapshotID = UUID.Parse(Query[20]);
            return LandData;
        }

        /// <summary>
        /// Gets a parcel from the search database by Info UUID (the true cross instance parcel ID)
        /// </summary>
        /// <param name="ParcelID"></param>
        /// <returns></returns>
        public LandData GetParcelInfo(UUID InfoUUID)
        {
            //Split the InfoUUID so that we get the regions, we'll check for positions in a bit
            int RegionX, RegionY;
            uint X, Y;
            ulong RegionHandle;
            Util.ParseFakeParcelID (InfoUUID, out RegionHandle, out X, out Y);

            Util.UlongToInts (RegionHandle, out RegionX, out RegionY);

            OpenSim.Services.Interfaces.GridRegion r = m_registry.RequestModuleInterface<IGridService> ().GetRegionByPosition (UUID.Zero, (int)RegionX, (int)RegionY);
            if (r == null)
            {
                m_log.Warn("[DirectoryService]: Could not find region for ParcelID: " + InfoUUID);
                return null;
            }
            //Get info about a specific parcel somewhere in the metaverse
            List<string> Query = GD.Query("RegionID", r.RegionID, "searchparcel", "*");
            //Cant find it, return
            if (Query.Count == 0)
                return null;

            List<LandData> Lands = new List<LandData>();
            //Parse and return
            LandData LandData = new LandData();
            //Add all the parcels belonging to the owner to the list
            for (int i = 0; i < Query.Count; i += 22)
            {
                LandData.RegionID = UUID.Parse(Query[i]);
                LandData.GlobalID = UUID.Parse(Query[i + 1]);
                LandData.LocalID = int.Parse(Query[i + 2]);
                LandData.UserLocation = new Vector3(float.Parse(Query[i + 3]), float.Parse(Query[i + 4]), float.Parse(Query[i + 5]));
                LandData.Name = Query[i + 6];
                LandData.Description = Query[i + 7];
                LandData.Flags = uint.Parse(Query[i + 8]);
                LandData.Dwell = int.Parse(Query[i + 9]);
                LandData.InfoUUID = UUID.Parse(Query[i + 10]);
                LandData.AuctionID = uint.Parse(Query[i + 13]);
                LandData.Area = int.Parse(Query[i + 14]);
                LandData.Maturity = int.Parse(Query[i + 16]);
                LandData.OwnerID = UUID.Parse(Query[i + 17]);
                LandData.GroupID = UUID.Parse(Query[i + 18]);
                LandData.SnapshotID = UUID.Parse(Query[i + 20]);
                try
                {
                    LandData.Bitmap = OSDParser.DeserializeLLSDXml(Query[i + 21]);
                }
                catch
                {
                }

                Lands.Add(LandData);
                LandData = new LandData();
            }
            LandData = null;
            
            bool[,] tempConvertMap = new bool[r.RegionSizeX / 4, r.RegionSizeX / 4];
            tempConvertMap.Initialize();
            foreach (LandData land in Lands)
            {
                if (land.Bitmap == null)
                    continue;
                ConvertBytesToLandBitmap(ref tempConvertMap, land.Bitmap, r.RegionSizeX);
                if (tempConvertMap[X / 64, Y / 64])
                {
                    LandData = land;
                    break;
                }
            }
            if (LandData == null && Lands.Count != 0)
                LandData = Lands[0];
            return LandData;
        }

 public void IncomingLandObjectFromStorage(LandData data)
 {
     ILandObject new_land = new LandObject(data.OwnerID, data.IsGroupOwned, m_scene);
     new_land.LandData = data;
     new_land.SetLandBitmapFromByteArray();
     new_land.SetInfoID();
     AddLandObject(new_land);
 }