public override IValue SerializeEQG()
        {
            var llsd = new MapType
            {
                ["AgentData"] = new AnArray
                {
                    new MapType
                    {
                        ["AgentID"]   = AgentID,
                        ["SessionID"] = SessionID
                    }
                }
            };
            var folderDataArray = new AnArray();

            foreach (var folder in FolderData)
            {
                folderDataArray.Add(new MapType
                {
                    ["FolderID"] = folder,
                    ["AgentID"]  = AgentID
                });
            }
            llsd.Add("FolderData", folderDataArray);

            return(llsd);
        }
Esempio n. 2
0
        public override IValue SerializeEQG()
        {
            var llsd = new MapType
            {
                ["AgentData"] = new AnArray
                {
                    new MapType
                    {
                        ["AgentID"]   = AgentID,
                        ["SessionID"] = SessionID
                    }
                }
            };
            var itemDataArray = new AnArray();

            foreach (UUID itemID in InventoryData)
            {
                var itemData = new MapType
                {
                    ["ItemID"]  = itemID,
                    ["AgentID"] = AgentID
                };
                itemDataArray.Add(itemData);
            }
            llsd.Add("InventoryData", itemDataArray);

            return(llsd);
        }
Esempio n. 3
0
        public static Message DeserializeEQG(IValue value)
        {
            MapType mapType = (MapType)value;
            AnArray array   = (AnArray)mapType["AgentData"];
            MapType dataMap = (MapType)array[0];

            return(new AgentDropGroup
            {
                AgentID = dataMap["AgentID"].AsUUID,
                GroupID = dataMap["GroupID"].AsUUID
            });
        }
Esempio n. 4
0
        public override IValue SerializeEQG()
        {
            var agentDataMap = new MapType
            {
                ["AgentID"] = AgentID,
                ["GroupID"] = GroupID
            };
            var agentDataArray = new AnArray
            {
                agentDataMap
            };

            return(new MapType
            {
                ["AgentData"] = agentDataArray
            });
        }
Esempio n. 5
0
        public override IValue SerializeEQG()
        {
            var agentDataMap = new MapType
            {
                ["AgentID"] = AgentID
            };
            var agentDataArray = new AnArray
            {
                agentDataMap
            };
            var body = new MapType
            {
                ["AgentData"] = agentDataArray
            };
            var groupDataArray    = new AnArray();
            var newGroupDataArray = new AnArray();

            foreach (GroupDataEntry e in GroupData)
            {
                byte[] groupPowers = BitConverter.GetBytes((ulong)e.GroupPowers);
                if (BitConverter.IsLittleEndian)
                {
                    Array.Reverse(groupPowers);
                }
                groupDataArray.Add(new MapType
                {
                    { "GroupID", e.GroupID },
                    { "GroupInsigniaID", e.GroupInsigniaID },
                    { "Contribution", e.Contribution },
                    { "GroupPowers", new BinaryData(groupPowers) },
                    { "GroupName", e.GroupName },
                    { "AcceptNotices", e.AcceptNotices }
                });
                newGroupDataArray.Add(new MapType
                {
                    { "ListInProfile", e.ListInProfile },
                });
            }
            body.Add("GroupData", groupDataArray);
            body.Add("NewGroupData", newGroupDataArray);

            return(body);
        }
Esempio n. 6
0
        public override IValue SerializeEQG()
        {
            var agentDataArray = new AnArray
            {
                new MapType
                {
                    ["AgentID"]  = AgentID,
                    ["AvatarID"] = AvatarID
                }
            };

            var llsd = new MapType
            {
                ["AgentData"] = agentDataArray
            };
            var groupDataArray    = new AnArray();
            var newGroupDataArray = new AnArray();

            foreach (GroupDataEntry e in GroupData)
            {
                groupDataArray.Add(new MapType
                {
                    { "GroupPowers", ((ulong)e.GroupPowers).ToString() },
                    { "AcceptNotices", e.AcceptNotices },
                    { "GroupTitle", e.GroupTitle },
                    { "GroupID", e.GroupID },
                    { "GroupName", e.GroupName },
                    { "GroupInsigniaID", e.GroupInsigniaID }
                });
                newGroupDataArray.Add(new MapType
                {
                    { "ListInProfile", e.ListInProfile }
                });
            }
            llsd.Add("GroupData", groupDataArray);
            llsd.Add("NewGroupData", newGroupDataArray);

            return(llsd);
        }
Esempio n. 7
0
        public override IValue SerializeEQG()
        {
            var m = new MapType();

            byte[] parcelFlags = BitConverter.GetBytes((uint)ParcelFlags);
            if (BitConverter.IsLittleEndian)
            {
                Array.Reverse(parcelFlags);
            }
            m.Add("ParcelData", new AnArray
            {
                new MapType
                {
                    { "LocalID", LocalID },
                    { "AABBMax", AABBMax },
                    { "AABBMin", AABBMin },
                    { "Area", Area },
                    { "AuctionID", (int)AuctionID },
                    { "AuthBuyerID", AuthBuyerID },
                    { "Bitmap", new BinaryData(Bitmap) },
                    { "Category", (int)Category },
                    { "ClaimDate", ClaimDate },
                    { "ClaimPrice", ClaimPrice },
                    { "Desc", Description },
                    { "ParcelFlags", new BinaryData(parcelFlags) },
                    { "GroupID", GroupID },
                    { "GroupPrims", GroupPrims },
                    { "IsGroupOwned", IsGroupOwned },
                    { "LandingType", (int)LandingType },
                    { "MaxPrims", MaxPrims },
                    { "MediaID", MediaID },
                    { "MediaURL", MediaURL },
                    { "MediaAutoScale", MediaAutoScale },
                    { "MusicURL", MusicURL },
                    { "Name", Name },
                    { "OtherCleanTime", OtherCleanTime },
                    { "OtherCount", OtherCount },
                    { "OtherPrims", OtherPrims },
                    { "OwnerID", OwnerID },
                    { "OwnerPrims", OwnerPrims },
                    { "ParcelPrimBonus", ParcelPrimBonus },
                    { "PassHours", PassHours },
                    { "PassPrice", PassPrice },
                    { "PublicCount", PublicCount },
                    { "Privacy", Privacy },
                    { "RegionDenyAnonymous", RegionDenyAnonymous },
                    { "RegionDenyIdentified", RegionDenyIdentified },
                    { "RegionDenyTransacted", RegionDenyTransacted },
                    { "RegionPushOverride", RegionPushOverride },
                    { "RentPrice", RentPrice },
                    { "RequestResult", (int)RequestResult },
                    { "SalePrice", SalePrice },
                    { "SelectedPrims", SelectedPrims },
                    { "SelfCount", SelfCount },
                    { "SequenceID", SequenceID },
                    { "SimWideMaxPrims", SimWideMaxPrims },
                    { "SimWideTotalPrims", SimWideTotalPrims },
                    { "SnapSelection", SnapSelection },
                    { "SnapshotID", SnapshotID },
                    { "Status", (int)Status },
                    { "TotalPrims", TotalPrims },
                    { "UserLocation", UserLocation },
                    { "UserLookAt", UserLookAt },
                    { "SeeAVs", SeeAVs },
                    { "AnyAVSounds", AnyAVSounds },
                    { "GroupAVSounds", GroupAVSounds }
                }
            });
            m.Add("MediaData", new AnArray
            {
                new MapType
                {
                    { "MediaDesc", MediaDesc },
                    { "MediaHeight", MediaHeight },
                    { "MediaWidth", MediaWidth },
                    { "MediaLoop", MediaLoop },
                    { "MediaType", MediaType },
                    { "ObscureMedia", ObscureMedia },
                    { "ObscureMusic", ObscureMusic }
                }
            });
            m.Add("AgeVerificationBlock", new AnArray
            {
                new MapType
                {
                    { "RegionDenyAgeUnverified", RegionDenyAgeUnverified }
                }
            });
            m.Add("RegionAllowAccessBlock", new AnArray
            {
                new MapType
                {
                    { "RegionAllowAccessOverride", RegionAllowAccessOverride }
                }
            });

            return(m);
        }
Esempio n. 8
0
        public override IValue SerializeEQG()
        {
            var agentDataArray = new AnArray
            {
                new MapType
                {
                    ["AgentID"]       = AgentID,
                    ["TransactionID"] = TransactionID
                }
            };
            var llsd = new MapType
            {
                ["AgentData"] = agentDataArray
            };
            var folderDataArray = new AnArray();

            foreach (var folder in FolderData)
            {
                folderDataArray.Add(new MapType
                {
                    { "FolderID", folder.FolderID },
                    { "AgentID", AgentID },
                    { "ParentID", folder.ParentID },
                    { "Type", (int)folder.DefaultType },
                    { "Name", folder.Name }
                });
            }
            llsd.Add("FolderData", folderDataArray);

            var itemDataArray = new AnArray();

            foreach (var item in ItemData)
            {
                itemDataArray.Add(new MapType
                {
                    { "ItemID", item.ItemID },
                    { "FolderID", item.FolderID },
                    { "CreatorID", item.CreatorID },
                    { "OwnerID", item.OwnerID },
                    { "GroupID", item.GroupID },
                    { "BaseMask", EncodeU32ToBinary((uint)item.BaseMask) },
                    { "OwnerMask", EncodeU32ToBinary((uint)item.OwnerMask) },
                    { "GroupMask", EncodeU32ToBinary((uint)item.GroupMask) },
                    { "EveryoneMask", EncodeU32ToBinary((uint)item.EveryoneMask) },
                    { "NextOwnerMask", EncodeU32ToBinary((uint)item.NextOwnerMask) },
                    { "GroupOwned", item.IsGroupOwned },
                    { "AssetID", item.AssetID },
                    { "Type", (int)item.Type },
                    { "InvType", (int)item.InvType },
                    { "Flags", EncodeU32ToBinary((uint)item.Flags) },
                    { "SaleType", (int)item.SaleType },
                    { "SalePrice", item.SalePrice },
                    { "Name", item.Name },
                    { "Description", item.Description },
                    { "CreationDate", (int)item.CreationDate },
                    { "CRC", EncodeU32ToBinary(item.Checksum) },
                    { "CallbackID", EncodeU32ToBinary(item.CallbackID) }
                });
            }
            llsd.Add("ItemData", itemDataArray);

            return(llsd);
        }