Miko/libremetaverse
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
3d4005dd4fccbf90a9e8c19e56f104bfa908c8c0
libremetaverse/OpenMetaverse/Messages/LindenMessages.cs
Drake Arconis 82fd0133ad Use correct folder type ids instead of asset ids for inventory folders 
This corrects a severe error where as AssetTypes were being reused for
the Folder FolderType id resulting in invalid ids for various system
folder types causing inventory validation issues from within the SL
viewer.
2015-08-07 17:26:35 +02:00

5377 lines
204 KiB
C#
Raw Blame History

/*
* Copyright (c) 2006-2014, openmetaverse.org
* All rights reserved.
*
* - Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* - Neither the name of the openmetaverse.org nor the names
* of its contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Net;
using System.IO;
using ComponentAce.Compression.Libs.zlib;
using OpenMetaverse.StructuredData;
using OpenMetaverse.Interfaces;
namespace OpenMetaverse.Messages.Linden
{
#region Teleport/Region/Movement Messages
/// <summary>
/// Sent to the client to indicate a teleport request has completed
/// </summary>
public class TeleportFinishMessage : IMessage
{
/// <summary>The <see cref="UUID"/> of the agent</summary>
public UUID AgentID;
/// <summary></summary>
public int LocationID;
/// <summary>The simulators handle the agent teleported to</summary>
public ulong RegionHandle;
/// <summary>A Uri which contains a list of Capabilities the simulator supports</summary>
public Uri SeedCapability;
/// <summary>Indicates the level of access required
/// to access the simulator, or the content rating, or the simulators
/// map status</summary>
public SimAccess SimAccess;
/// <summary>The IP Address of the simulator</summary>
public IPAddress IP;
/// <summary>The UDP Port the simulator will listen for UDP traffic on</summary>
public int Port;
/// <summary>Status flags indicating the state of the Agent upon arrival, Flying, etc.</summary>
public TeleportFlags Flags;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(1);
OSDArray infoArray = new OSDArray(1);
OSDMap info = new OSDMap(8);
info.Add("AgentID", OSD.FromUUID(AgentID));
info.Add("LocationID", OSD.FromInteger(LocationID)); // Unused by the client
info.Add("RegionHandle", OSD.FromULong(RegionHandle));
info.Add("SeedCapability", OSD.FromUri(SeedCapability));
info.Add("SimAccess", OSD.FromInteger((byte)SimAccess));
info.Add("SimIP", MessageUtils.FromIP(IP));
info.Add("SimPort", OSD.FromInteger(Port));
info.Add("TeleportFlags", OSD.FromUInteger((uint)Flags));
infoArray.Add(info);
map.Add("Info", infoArray);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
OSDArray array = (OSDArray)map["Info"];
OSDMap blockMap = (OSDMap)array[0];
AgentID = blockMap["AgentID"].AsUUID();
LocationID = blockMap["LocationID"].AsInteger();
RegionHandle = blockMap["RegionHandle"].AsULong();
SeedCapability = blockMap["SeedCapability"].AsUri();
SimAccess = (SimAccess)blockMap["SimAccess"].AsInteger();
IP = MessageUtils.ToIP(blockMap["SimIP"]);
Port = blockMap["SimPort"].AsInteger();
Flags = (TeleportFlags)blockMap["TeleportFlags"].AsUInteger();
}
}
/// <summary>
/// Sent to the viewer when a neighboring simulator is requesting the agent make a connection to it.
/// </summary>
public class EstablishAgentCommunicationMessage : IMessage
{
public UUID AgentID;
public IPAddress Address;
public int Port;
public Uri SeedCapability;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(3);
map["agent-id"] = OSD.FromUUID(AgentID);
map["sim-ip-and-port"] = OSD.FromString(String.Format("{0}:{1}", Address, Port));
map["seed-capability"] = OSD.FromUri(SeedCapability);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
string ipAndPort = map["sim-ip-and-port"].AsString();
int i = ipAndPort.IndexOf(':');
AgentID = map["agent-id"].AsUUID();
Address = IPAddress.Parse(ipAndPort.Substring(0, i));
Port = Int32.Parse(ipAndPort.Substring(i + 1));
SeedCapability = map["seed-capability"].AsUri();
}
}
public class CrossedRegionMessage : IMessage
{
public Vector3 LookAt;
public Vector3 Position;
public UUID AgentID;
public UUID SessionID;
public ulong RegionHandle;
public Uri SeedCapability;
public IPAddress IP;
public int Port;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(3);
OSDArray infoArray = new OSDArray(1);
OSDMap infoMap = new OSDMap(2);
infoMap["LookAt"] = OSD.FromVector3(LookAt);
infoMap["Position"] = OSD.FromVector3(Position);
infoArray.Add(infoMap);
map["Info"] = infoArray;
OSDArray agentDataArray = new OSDArray(1);
OSDMap agentDataMap = new OSDMap(2);
agentDataMap["AgentID"] = OSD.FromUUID(AgentID);
agentDataMap["SessionID"] = OSD.FromUUID(SessionID);
agentDataArray.Add(agentDataMap);
map["AgentData"] = agentDataArray;
OSDArray regionDataArray = new OSDArray(1);
OSDMap regionDataMap = new OSDMap(4);
regionDataMap["RegionHandle"] = OSD.FromULong(RegionHandle);
regionDataMap["SeedCapability"] = OSD.FromUri(SeedCapability);
regionDataMap["SimIP"] = MessageUtils.FromIP(IP);
regionDataMap["SimPort"] = OSD.FromInteger(Port);
regionDataArray.Add(regionDataMap);
map["RegionData"] = regionDataArray;
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
OSDMap infoMap = (OSDMap)((OSDArray)map["Info"])[0];
LookAt = infoMap["LookAt"].AsVector3();
Position = infoMap["Position"].AsVector3();
OSDMap agentDataMap = (OSDMap)((OSDArray)map["AgentData"])[0];
AgentID = agentDataMap["AgentID"].AsUUID();
SessionID = agentDataMap["SessionID"].AsUUID();
OSDMap regionDataMap = (OSDMap)((OSDArray)map["RegionData"])[0];
RegionHandle = regionDataMap["RegionHandle"].AsULong();
SeedCapability = regionDataMap["SeedCapability"].AsUri();
IP = MessageUtils.ToIP(regionDataMap["SimIP"]);
Port = regionDataMap["SimPort"].AsInteger();
}
}
public class EnableSimulatorMessage : IMessage
{
public class SimulatorInfoBlock
{
public ulong RegionHandle;
public IPAddress IP;
public int Port;
}
public SimulatorInfoBlock[] Simulators;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(1);
OSDArray array = new OSDArray(Simulators.Length);
for (int i = 0; i < Simulators.Length; i++)
{
SimulatorInfoBlock block = Simulators[i];
OSDMap blockMap = new OSDMap(3);
blockMap["Handle"] = OSD.FromULong(block.RegionHandle);
blockMap["IP"] = MessageUtils.FromIP(block.IP);
blockMap["Port"] = OSD.FromInteger(block.Port);
array.Add(blockMap);
}
map["SimulatorInfo"] = array;
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
OSDArray array = (OSDArray)map["SimulatorInfo"];
Simulators = new SimulatorInfoBlock[array.Count];
for (int i = 0; i < array.Count; i++)
{
OSDMap blockMap = (OSDMap)array[i];
SimulatorInfoBlock block = new SimulatorInfoBlock();
block.RegionHandle = blockMap["Handle"].AsULong();
block.IP = MessageUtils.ToIP(blockMap["IP"]);
block.Port = blockMap["Port"].AsInteger();
Simulators[i] = block;
}
}
}
/// <summary>
/// A message sent to the client which indicates a teleport request has failed
/// and contains some information on why it failed
/// </summary>
public class TeleportFailedMessage : IMessage
{
/// <summary></summary>
public string ExtraParams;
/// <summary>A string key of the reason the teleport failed e.g. CouldntTPCloser
/// Which could be used to look up a value in a dictionary or enum</summary>
public string MessageKey;
/// <summary>The <see cref="UUID"/> of the Agent</summary>
public UUID AgentID;
/// <summary>A string human readable message containing the reason </summary>
/// <remarks>An example: Could not teleport closer to destination</remarks>
public string Reason;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(2);
OSDMap alertInfoMap = new OSDMap(2);
alertInfoMap["ExtraParams"] = OSD.FromString(ExtraParams);
alertInfoMap["Message"] = OSD.FromString(MessageKey);
OSDArray alertArray = new OSDArray();
alertArray.Add(alertInfoMap);
map["AlertInfo"] = alertArray;
OSDMap infoMap = new OSDMap(2);
infoMap["AgentID"] = OSD.FromUUID(AgentID);
infoMap["Reason"] = OSD.FromString(Reason);
OSDArray infoArray = new OSDArray();
infoArray.Add(infoMap);
map["Info"] = infoArray;
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
OSDArray alertInfoArray = (OSDArray)map["AlertInfo"];
OSDMap alertInfoMap = (OSDMap)alertInfoArray[0];
ExtraParams = alertInfoMap["ExtraParams"].AsString();
MessageKey = alertInfoMap["Message"].AsString();
OSDArray infoArray = (OSDArray)map["Info"];
OSDMap infoMap = (OSDMap)infoArray[0];
AgentID = infoMap["AgentID"].AsUUID();
Reason = infoMap["Reason"].AsString();
}
}
public class LandStatReplyMessage : IMessage
{
public uint ReportType;
public uint RequestFlags;
public uint TotalObjectCount;
public class ReportDataBlock
{
public Vector3 Location;
public string OwnerName;
public float Score;
public UUID TaskID;
public uint TaskLocalID;
public string TaskName;
public float MonoScore;
public DateTime TimeStamp;
}
public ReportDataBlock[] ReportDataBlocks;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(3);
OSDMap requestDataMap = new OSDMap(3);
requestDataMap["ReportType"] = OSD.FromUInteger(this.ReportType);
requestDataMap["RequestFlags"] = OSD.FromUInteger(this.RequestFlags);
requestDataMap["TotalObjectCount"] = OSD.FromUInteger(this.TotalObjectCount);
OSDArray requestDatArray = new OSDArray();
requestDatArray.Add(requestDataMap);
map["RequestData"] = requestDatArray;
OSDArray reportDataArray = new OSDArray();
OSDArray dataExtendedArray = new OSDArray();
for (int i = 0; i < ReportDataBlocks.Length; i++)
{
OSDMap reportMap = new OSDMap(8);
reportMap["LocationX"] = OSD.FromReal(ReportDataBlocks[i].Location.X);
reportMap["LocationY"] = OSD.FromReal(ReportDataBlocks[i].Location.Y);
reportMap["LocationZ"] = OSD.FromReal(ReportDataBlocks[i].Location.Z);
reportMap["OwnerName"] = OSD.FromString(ReportDataBlocks[i].OwnerName);
reportMap["Score"] = OSD.FromReal(ReportDataBlocks[i].Score);
reportMap["TaskID"] = OSD.FromUUID(ReportDataBlocks[i].TaskID);
reportMap["TaskLocalID"] = OSD.FromReal(ReportDataBlocks[i].TaskLocalID);
reportMap["TaskName"] = OSD.FromString(ReportDataBlocks[i].TaskName);
reportDataArray.Add(reportMap);
OSDMap extendedMap = new OSDMap(2);
extendedMap["MonoScore"] = OSD.FromReal(ReportDataBlocks[i].MonoScore);
extendedMap["TimeStamp"] = OSD.FromDate(ReportDataBlocks[i].TimeStamp);
dataExtendedArray.Add(extendedMap);
}
map["ReportData"] = reportDataArray;
map["DataExtended"] = dataExtendedArray;
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
OSDArray requestDataArray = (OSDArray)map["RequestData"];
OSDMap requestMap = (OSDMap)requestDataArray[0];
this.ReportType = requestMap["ReportType"].AsUInteger();
this.RequestFlags = requestMap["RequestFlags"].AsUInteger();
this.TotalObjectCount = requestMap["TotalObjectCount"].AsUInteger();
if (TotalObjectCount < 1)
{
ReportDataBlocks = new ReportDataBlock[0];
return;
}
OSDArray dataArray = (OSDArray)map["ReportData"];
OSDArray dataExtendedArray = (OSDArray)map["DataExtended"];
ReportDataBlocks = new ReportDataBlock[dataArray.Count];
for (int i = 0; i < dataArray.Count; i++)
{
OSDMap blockMap = (OSDMap)dataArray[i];
OSDMap extMap = (OSDMap)dataExtendedArray[i];
ReportDataBlock block = new ReportDataBlock();
block.Location = new Vector3(
(float)blockMap["LocationX"].AsReal(),
(float)blockMap["LocationY"].AsReal(),
(float)blockMap["LocationZ"].AsReal());
block.OwnerName = blockMap["OwnerName"].AsString();
block.Score = (float)blockMap["Score"].AsReal();
block.TaskID = blockMap["TaskID"].AsUUID();
block.TaskLocalID = blockMap["TaskLocalID"].AsUInteger();
block.TaskName = blockMap["TaskName"].AsString();
block.MonoScore = (float)extMap["MonoScore"].AsReal();
block.TimeStamp = Utils.UnixTimeToDateTime(extMap["TimeStamp"].AsUInteger());
ReportDataBlocks[i] = block;
}
}
}
#endregion
#region Parcel Messages
/// <summary>
/// Contains a list of prim owner information for a specific parcel in a simulator
/// </summary>
/// <remarks>
/// A Simulator will always return at least 1 entry
/// If agent does not have proper permission the OwnerID will be UUID.Zero
/// If agent does not have proper permission OR there are no primitives on parcel
/// the DataBlocksExtended map will not be sent from the simulator
/// </remarks>
public class ParcelObjectOwnersReplyMessage : IMessage
{
/// <summary>
/// Prim ownership information for a specified owner on a single parcel
/// </summary>
public class PrimOwner
{
/// <summary>The <see cref="UUID"/> of the prim owner,
/// UUID.Zero if agent has no permission to view prim owner information</summary>
public UUID OwnerID;
/// <summary>The total number of prims</summary>
public int Count;
/// <summary>True if the OwnerID is a <see cref="Group"/></summary>
public bool IsGroupOwned;
/// <summary>True if the owner is online
/// <remarks>This is no longer used by the LL Simulators</remarks></summary>
public bool OnlineStatus;
/// <summary>The date the most recent prim was rezzed</summary>
public DateTime TimeStamp;
}
/// <summary>An Array of <see cref="PrimOwner"/> objects</summary>
public PrimOwner[] PrimOwnersBlock;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDArray dataArray = new OSDArray(PrimOwnersBlock.Length);
OSDArray dataExtendedArray = new OSDArray();
for (int i = 0; i < PrimOwnersBlock.Length; i++)
{
OSDMap dataMap = new OSDMap(4);
dataMap["OwnerID"] = OSD.FromUUID(PrimOwnersBlock[i].OwnerID);
dataMap["Count"] = OSD.FromInteger(PrimOwnersBlock[i].Count);
dataMap["IsGroupOwned"] = OSD.FromBoolean(PrimOwnersBlock[i].IsGroupOwned);
dataMap["OnlineStatus"] = OSD.FromBoolean(PrimOwnersBlock[i].OnlineStatus);
dataArray.Add(dataMap);
OSDMap dataExtendedMap = new OSDMap(1);
dataExtendedMap["TimeStamp"] = OSD.FromDate(PrimOwnersBlock[i].TimeStamp);
dataExtendedArray.Add(dataExtendedMap);
}
OSDMap map = new OSDMap();
map.Add("Data", dataArray);
if (dataExtendedArray.Count > 0)
map.Add("DataExtended", dataExtendedArray);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
OSDArray dataArray = (OSDArray)map["Data"];
// DataExtended is optional, will not exist of parcel contains zero prims
OSDArray dataExtendedArray;
if (map.ContainsKey("DataExtended"))
{
dataExtendedArray = (OSDArray)map["DataExtended"];
}
else
{
dataExtendedArray = new OSDArray();
}
PrimOwnersBlock = new PrimOwner[dataArray.Count];
for (int i = 0; i < dataArray.Count; i++)
{
OSDMap dataMap = (OSDMap)dataArray[i];
PrimOwner block = new PrimOwner();
block.OwnerID = dataMap["OwnerID"].AsUUID();
block.Count = dataMap["Count"].AsInteger();
block.IsGroupOwned = dataMap["IsGroupOwned"].AsBoolean();
block.OnlineStatus = dataMap["OnlineStatus"].AsBoolean(); // deprecated
/* if the agent has no permissions, or there are no prims, the counts
* should not match up, so we don't decode the DataExtended map */
if (dataExtendedArray.Count == dataArray.Count)
{
OSDMap dataExtendedMap = (OSDMap)dataExtendedArray[i];
block.TimeStamp = Utils.UnixTimeToDateTime(dataExtendedMap["TimeStamp"].AsUInteger());
}
PrimOwnersBlock[i] = block;
}
}
}
/// <summary>
/// The details of a single parcel in a region, also contains some regionwide globals
/// </summary>
[Serializable]
public class ParcelPropertiesMessage : IMessage
{
/// <summary>Simulator-local ID of this parcel</summary>
public int LocalID;
/// <summary>Maximum corner of the axis-aligned bounding box for this
/// parcel</summary>
public Vector3 AABBMax;
/// <summary>Minimum corner of the axis-aligned bounding box for this
/// parcel</summary>
public Vector3 AABBMin;
/// <summary>Total parcel land area</summary>
public int Area;
/// <summary></summary>
public uint AuctionID;
/// <summary>Key of authorized buyer</summary>
public UUID AuthBuyerID;
/// <summary>Bitmap describing land layout in 4x4m squares across the
/// entire region</summary>
public byte[] Bitmap;
/// <summary></summary>
public ParcelCategory Category;
/// <summary>Date land was claimed</summary>
public DateTime ClaimDate;
/// <summary>Appears to always be zero</summary>
public int ClaimPrice;
/// <summary>Parcel Description</summary>
public string Desc;
/// <summary></summary>
public ParcelFlags ParcelFlags;
/// <summary></summary>
public UUID GroupID;
/// <summary>Total number of primitives owned by the parcel group on
/// this parcel</summary>
public int GroupPrims;
/// <summary>Whether the land is deeded to a group or not</summary>
public bool IsGroupOwned;
/// <summary></summary>
public LandingType LandingType;
/// <summary>Maximum number of primitives this parcel supports</summary>
public int MaxPrims;
/// <summary>The Asset UUID of the Texture which when applied to a
/// primitive will display the media</summary>
public UUID MediaID;
/// <summary>A URL which points to any Quicktime supported media type</summary>
public string MediaURL;
/// <summary>A byte, if 0x1 viewer should auto scale media to fit object</summary>
public bool MediaAutoScale;
/// <summary>URL For Music Stream</summary>
public string MusicURL;
/// <summary>Parcel Name</summary>
public string Name;
/// <summary>Autoreturn value in minutes for others' objects</summary>
public int OtherCleanTime;
/// <summary></summary>
public int OtherCount;
/// <summary>Total number of other primitives on this parcel</summary>
public int OtherPrims;
/// <summary>UUID of the owner of this parcel</summary>
public UUID OwnerID;
/// <summary>Total number of primitives owned by the parcel owner on
/// this parcel</summary>
public int OwnerPrims;
/// <summary></summary>
public float ParcelPrimBonus;
/// <summary>How long is pass valid for</summary>
public float PassHours;
/// <summary>Price for a temporary pass</summary>
public int PassPrice;
/// <summary></summary>
public int PublicCount;
/// <summary>Disallows people outside the parcel from being able to see in</summary>
public bool Privacy;
/// <summary></summary>
public bool RegionDenyAnonymous;
/// <summary></summary>
public bool RegionDenyIdentified;
/// <summary></summary>
public bool RegionDenyTransacted;
/// <summary>True if the region denies access to age unverified users</summary>
public bool RegionDenyAgeUnverified;
/// <summary></summary>
public bool RegionPushOverride;
/// <summary>This field is no longer used</summary>
public int RentPrice;
/// The result of a request for parcel properties
public ParcelResult RequestResult;
/// <summary>Sale price of the parcel, only useful if ForSale is set</summary>
/// <remarks>The SalePrice will remain the same after an ownership
/// transfer (sale), so it can be used to see the purchase price after
/// a sale if the new owner has not changed it</remarks>
public int SalePrice;
/// <summary>
/// Number of primitives your avatar is currently
/// selecting and sitting on in this parcel
/// </summary>
public int SelectedPrims;
/// <summary></summary>
public int SelfCount;
/// <summary>
/// A number which increments by 1, starting at 0 for each ParcelProperties request.
/// Can be overriden by specifying the sequenceID with the ParcelPropertiesRequest being sent.
/// a Negative number indicates the action in <seealso cref="ParcelPropertiesStatus"/> has occurred.
/// </summary>
public int SequenceID;
/// <summary>Maximum primitives across the entire simulator</summary>
public int SimWideMaxPrims;
/// <summary>Total primitives across the entire simulator</summary>
public int SimWideTotalPrims;
/// <summary></summary>
public bool SnapSelection;
/// <summary>Key of parcel snapshot</summary>
public UUID SnapshotID;
/// <summary>Parcel ownership status</summary>
public ParcelStatus Status;
/// <summary>Total number of primitives on this parcel</summary>
public int TotalPrims;
/// <summary></summary>
public Vector3 UserLocation;
/// <summary></summary>
public Vector3 UserLookAt;
/// <summary>A description of the media</summary>
public string MediaDesc;
/// <summary>An Integer which represents the height of the media</summary>
public int MediaHeight;
/// <summary>An integer which represents the width of the media</summary>
public int MediaWidth;
/// <summary>A boolean, if true the viewer should loop the media</summary>
public bool MediaLoop;
/// <summary>A string which contains the mime type of the media</summary>
public string MediaType;
/// <summary>true to obscure (hide) media url</summary>
public bool ObscureMedia;
/// <summary>true to obscure (hide) music url</summary>
public bool ObscureMusic;
/// <summary> true if avatars in this parcel should be invisible to people outside</summary>
public bool SeeAVs;
/// <summary> true if avatars outside can hear any sounds avatars inside play</summary>
public bool AnyAVSounds;
/// <summary> true if group members outside can hear any sounds avatars inside play</summary>
public bool GroupAVSounds;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(3);
OSDArray dataArray = new OSDArray(1);
OSDMap parcelDataMap = new OSDMap(47);
parcelDataMap["LocalID"] = OSD.FromInteger(LocalID);
parcelDataMap["AABBMax"] = OSD.FromVector3(AABBMax);
parcelDataMap["AABBMin"] = OSD.FromVector3(AABBMin);
parcelDataMap["Area"] = OSD.FromInteger(Area);
parcelDataMap["AuctionID"] = OSD.FromInteger(AuctionID);
parcelDataMap["AuthBuyerID"] = OSD.FromUUID(AuthBuyerID);
parcelDataMap["Bitmap"] = OSD.FromBinary(Bitmap);
parcelDataMap["Category"] = OSD.FromInteger((int)Category);
parcelDataMap["ClaimDate"] = OSD.FromDate(ClaimDate);
parcelDataMap["ClaimPrice"] = OSD.FromInteger(ClaimPrice);
parcelDataMap["Desc"] = OSD.FromString(Desc);
parcelDataMap["ParcelFlags"] = OSD.FromUInteger((uint)ParcelFlags);
parcelDataMap["GroupID"] = OSD.FromUUID(GroupID);
parcelDataMap["GroupPrims"] = OSD.FromInteger(GroupPrims);
parcelDataMap["IsGroupOwned"] = OSD.FromBoolean(IsGroupOwned);
parcelDataMap["LandingType"] = OSD.FromInteger((int)LandingType);
parcelDataMap["MaxPrims"] = OSD.FromInteger(MaxPrims);
parcelDataMap["MediaID"] = OSD.FromUUID(MediaID);
parcelDataMap["MediaURL"] = OSD.FromString(MediaURL);
parcelDataMap["MediaAutoScale"] = OSD.FromBoolean(MediaAutoScale);
parcelDataMap["MusicURL"] = OSD.FromString(MusicURL);
parcelDataMap["Name"] = OSD.FromString(Name);
parcelDataMap["OtherCleanTime"] = OSD.FromInteger(OtherCleanTime);
parcelDataMap["OtherCount"] = OSD.FromInteger(OtherCount);
parcelDataMap["OtherPrims"] = OSD.FromInteger(OtherPrims);
parcelDataMap["OwnerID"] = OSD.FromUUID(OwnerID);
parcelDataMap["OwnerPrims"] = OSD.FromInteger(OwnerPrims);
parcelDataMap["ParcelPrimBonus"] = OSD.FromReal((float)ParcelPrimBonus);
parcelDataMap["PassHours"] = OSD.FromReal((float)PassHours);
parcelDataMap["PassPrice"] = OSD.FromInteger(PassPrice);
parcelDataMap["PublicCount"] = OSD.FromInteger(PublicCount);
parcelDataMap["Privacy"] = OSD.FromBoolean(Privacy);
parcelDataMap["RegionDenyAnonymous"] = OSD.FromBoolean(RegionDenyAnonymous);
parcelDataMap["RegionDenyIdentified"] = OSD.FromBoolean(RegionDenyIdentified);
parcelDataMap["RegionDenyTransacted"] = OSD.FromBoolean(RegionDenyTransacted);
parcelDataMap["RegionPushOverride"] = OSD.FromBoolean(RegionPushOverride);
parcelDataMap["RentPrice"] = OSD.FromInteger(RentPrice);
parcelDataMap["RequestResult"] = OSD.FromInteger((int)RequestResult);
parcelDataMap["SalePrice"] = OSD.FromInteger(SalePrice);
parcelDataMap["SelectedPrims"] = OSD.FromInteger(SelectedPrims);
parcelDataMap["SelfCount"] = OSD.FromInteger(SelfCount);
parcelDataMap["SequenceID"] = OSD.FromInteger(SequenceID);
parcelDataMap["SimWideMaxPrims"] = OSD.FromInteger(SimWideMaxPrims);
parcelDataMap["SimWideTotalPrims"] = OSD.FromInteger(SimWideTotalPrims);
parcelDataMap["SnapSelection"] = OSD.FromBoolean(SnapSelection);
parcelDataMap["SnapshotID"] = OSD.FromUUID(SnapshotID);
parcelDataMap["Status"] = OSD.FromInteger((int)Status);
parcelDataMap["TotalPrims"] = OSD.FromInteger(TotalPrims);
parcelDataMap["UserLocation"] = OSD.FromVector3(UserLocation);
parcelDataMap["UserLookAt"] = OSD.FromVector3(UserLookAt);
parcelDataMap["SeeAVs"] = OSD.FromBoolean(SeeAVs);
parcelDataMap["AnyAVSounds"] = OSD.FromBoolean(AnyAVSounds);
parcelDataMap["GroupAVSounds"] = OSD.FromBoolean(GroupAVSounds);
dataArray.Add(parcelDataMap);
map["ParcelData"] = dataArray;
OSDArray mediaDataArray = new OSDArray(1);
OSDMap mediaDataMap = new OSDMap(7);
mediaDataMap["MediaDesc"] = OSD.FromString(MediaDesc);
mediaDataMap["MediaHeight"] = OSD.FromInteger(MediaHeight);
mediaDataMap["MediaWidth"] = OSD.FromInteger(MediaWidth);
mediaDataMap["MediaLoop"] = OSD.FromBoolean(MediaLoop);
mediaDataMap["MediaType"] = OSD.FromString(MediaType);
mediaDataMap["ObscureMedia"] = OSD.FromBoolean(ObscureMedia);
mediaDataMap["ObscureMusic"] = OSD.FromBoolean(ObscureMusic);
mediaDataArray.Add(mediaDataMap);
map["MediaData"] = mediaDataArray;
OSDArray ageVerificationBlockArray = new OSDArray(1);
OSDMap ageVerificationBlockMap = new OSDMap(1);
ageVerificationBlockMap["RegionDenyAgeUnverified"] = OSD.FromBoolean(RegionDenyAgeUnverified);
ageVerificationBlockArray.Add(ageVerificationBlockMap);
map["AgeVerificationBlock"] = ageVerificationBlockArray;
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
OSDMap parcelDataMap = (OSDMap)((OSDArray)map["ParcelData"])[0];
LocalID = parcelDataMap["LocalID"].AsInteger();
AABBMax = parcelDataMap["AABBMax"].AsVector3();
AABBMin = parcelDataMap["AABBMin"].AsVector3();
Area = parcelDataMap["Area"].AsInteger();
AuctionID = (uint)parcelDataMap["AuctionID"].AsInteger();
AuthBuyerID = parcelDataMap["AuthBuyerID"].AsUUID();
Bitmap = parcelDataMap["Bitmap"].AsBinary();
Category = (ParcelCategory)parcelDataMap["Category"].AsInteger();
ClaimDate = Utils.UnixTimeToDateTime((uint)parcelDataMap["ClaimDate"].AsInteger());
ClaimPrice = parcelDataMap["ClaimPrice"].AsInteger();
Desc = parcelDataMap["Desc"].AsString();
// LL sends this as binary, we'll convert it here
if (parcelDataMap["ParcelFlags"].Type == OSDType.Binary)
{
byte[] bytes = parcelDataMap["ParcelFlags"].AsBinary();
if (BitConverter.IsLittleEndian)
Array.Reverse(bytes);
ParcelFlags = (ParcelFlags)BitConverter.ToUInt32(bytes, 0);
}
else
{
ParcelFlags = (ParcelFlags)parcelDataMap["ParcelFlags"].AsUInteger();
}
GroupID = parcelDataMap["GroupID"].AsUUID();
GroupPrims = parcelDataMap["GroupPrims"].AsInteger();
IsGroupOwned = parcelDataMap["IsGroupOwned"].AsBoolean();
LandingType = (LandingType)parcelDataMap["LandingType"].AsInteger();
MaxPrims = parcelDataMap["MaxPrims"].AsInteger();
MediaID = parcelDataMap["MediaID"].AsUUID();
MediaURL = parcelDataMap["MediaURL"].AsString();
MediaAutoScale = parcelDataMap["MediaAutoScale"].AsBoolean(); // 0x1 = yes
MusicURL = parcelDataMap["MusicURL"].AsString();
Name = parcelDataMap["Name"].AsString();
OtherCleanTime = parcelDataMap["OtherCleanTime"].AsInteger();
OtherCount = parcelDataMap["OtherCount"].AsInteger();
OtherPrims = parcelDataMap["OtherPrims"].AsInteger();
OwnerID = parcelDataMap["OwnerID"].AsUUID();
OwnerPrims = parcelDataMap["OwnerPrims"].AsInteger();
ParcelPrimBonus = (float)parcelDataMap["ParcelPrimBonus"].AsReal();
PassHours = (float)parcelDataMap["PassHours"].AsReal();
PassPrice = parcelDataMap["PassPrice"].AsInteger();
PublicCount = parcelDataMap["PublicCount"].AsInteger();
Privacy = parcelDataMap["Privacy"].AsBoolean();
RegionDenyAnonymous = parcelDataMap["RegionDenyAnonymous"].AsBoolean();
RegionDenyIdentified = parcelDataMap["RegionDenyIdentified"].AsBoolean();
RegionDenyTransacted = parcelDataMap["RegionDenyTransacted"].AsBoolean();
RegionPushOverride = parcelDataMap["RegionPushOverride"].AsBoolean();
RentPrice = parcelDataMap["RentPrice"].AsInteger();
RequestResult = (ParcelResult)parcelDataMap["RequestResult"].AsInteger();
SalePrice = parcelDataMap["SalePrice"].AsInteger();
SelectedPrims = parcelDataMap["SelectedPrims"].AsInteger();
SelfCount = parcelDataMap["SelfCount"].AsInteger();
SequenceID = parcelDataMap["SequenceID"].AsInteger();
SimWideMaxPrims = parcelDataMap["SimWideMaxPrims"].AsInteger();
SimWideTotalPrims = parcelDataMap["SimWideTotalPrims"].AsInteger();
SnapSelection = parcelDataMap["SnapSelection"].AsBoolean();
SnapshotID = parcelDataMap["SnapshotID"].AsUUID();
Status = (ParcelStatus)parcelDataMap["Status"].AsInteger();
TotalPrims = parcelDataMap["TotalPrims"].AsInteger();
UserLocation = parcelDataMap["UserLocation"].AsVector3();
UserLookAt = parcelDataMap["UserLookAt"].AsVector3();
SeeAVs = parcelDataMap["SeeAVs"].AsBoolean();
AnyAVSounds = parcelDataMap["AnyAVSounds"].AsBoolean();
GroupAVSounds = parcelDataMap["GroupAVSounds"].AsBoolean();
if (map.ContainsKey("MediaData")) // temporary, OpenSim doesn't send this block
{
OSDMap mediaDataMap = (OSDMap)((OSDArray)map["MediaData"])[0];
MediaDesc = mediaDataMap["MediaDesc"].AsString();
MediaHeight = mediaDataMap["MediaHeight"].AsInteger();
MediaWidth = mediaDataMap["MediaWidth"].AsInteger();
MediaLoop = mediaDataMap["MediaLoop"].AsBoolean();
MediaType = mediaDataMap["MediaType"].AsString();
ObscureMedia = mediaDataMap["ObscureMedia"].AsBoolean();
ObscureMusic = mediaDataMap["ObscureMusic"].AsBoolean();
}
OSDMap ageVerificationBlockMap = (OSDMap)((OSDArray)map["AgeVerificationBlock"])[0];
RegionDenyAgeUnverified = ageVerificationBlockMap["RegionDenyAgeUnverified"].AsBoolean();
}
}
/// <summary>A message sent from the viewer to the simulator to updated a specific parcels settings</summary>
public class ParcelPropertiesUpdateMessage : IMessage
{
/// <summary>The <seealso cref="UUID"/> of the agent authorized to purchase this
/// parcel of land or a NULL <seealso cref="UUID"/> if the sale is authorized to anyone</summary>
public UUID AuthBuyerID;
/// <summary>true to enable auto scaling of the parcel media</summary>
public bool MediaAutoScale;
/// <summary>The category of this parcel used when search is enabled to restrict
/// search results</summary>
public ParcelCategory Category;
/// <summary>A string containing the description to set</summary>
public string Desc;
/// <summary>The <seealso cref="UUID"/> of the <seealso cref="Group"/> which allows for additional
/// powers and restrictions.</summary>
public UUID GroupID;
/// <summary>The <seealso cref="LandingType"/> which specifies how avatars which teleport
/// to this parcel are handled</summary>
public LandingType Landing;
/// <summary>The LocalID of the parcel to update settings on</summary>
public int LocalID;
/// <summary>A string containing the description of the media which can be played
/// to visitors</summary>
public string MediaDesc;
/// <summary></summary>
public int MediaHeight;
/// <summary></summary>
public bool MediaLoop;
/// <summary></summary>
public UUID MediaID;
/// <summary></summary>
public string MediaType;
/// <summary></summary>
public string MediaURL;
/// <summary></summary>
public int MediaWidth;
/// <summary></summary>
public string MusicURL;
/// <summary></summary>
public string Name;
/// <summary></summary>
public bool ObscureMedia;
/// <summary></summary>
public bool ObscureMusic;
/// <summary></summary>
public ParcelFlags ParcelFlags;
/// <summary></summary>
public float PassHours;
/// <summary></summary>
public uint PassPrice;
/// <summary></summary>
public bool Privacy;
/// <summary></summary>
public uint SalePrice;
/// <summary></summary>
public UUID SnapshotID;
/// <summary></summary>
public Vector3 UserLocation;
/// <summary></summary>
public Vector3 UserLookAt;
/// <summary> true if avatars in this parcel should be invisible to people outside</summary>
public bool SeeAVs;
/// <summary> true if avatars outside can hear any sounds avatars inside play</summary>
public bool AnyAVSounds;
/// <summary> true if group members outside can hear any sounds avatars inside play</summary>
public bool GroupAVSounds;
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
AuthBuyerID = map["auth_buyer_id"].AsUUID();
MediaAutoScale = map["auto_scale"].AsBoolean();
Category = (ParcelCategory)map["category"].AsInteger();
Desc = map["description"].AsString();
GroupID = map["group_id"].AsUUID();
Landing = (LandingType)map["landing_type"].AsUInteger();
LocalID = map["local_id"].AsInteger();
MediaDesc = map["media_desc"].AsString();
MediaHeight = map["media_height"].AsInteger();
MediaLoop = map["media_loop"].AsBoolean();
MediaID = map["media_id"].AsUUID();
MediaType = map["media_type"].AsString();
MediaURL = map["media_url"].AsString();
MediaWidth = map["media_width"].AsInteger();
MusicURL = map["music_url"].AsString();
Name = map["name"].AsString();
ObscureMedia = map["obscure_media"].AsBoolean();
ObscureMusic = map["obscure_music"].AsBoolean();
ParcelFlags = (ParcelFlags)map["parcel_flags"].AsUInteger();
PassHours = (float)map["pass_hours"].AsReal();
PassPrice = map["pass_price"].AsUInteger();
Privacy = map["privacy"].AsBoolean();
SalePrice = map["sale_price"].AsUInteger();
SnapshotID = map["snapshot_id"].AsUUID();
UserLocation = map["user_location"].AsVector3();
UserLookAt = map["user_look_at"].AsVector3();
if (map.ContainsKey("see_avs"))
{
SeeAVs = map["see_avs"].AsBoolean();
AnyAVSounds = map["any_av_sounds"].AsBoolean();
GroupAVSounds = map["group_av_sounds"].AsBoolean();
}
else
{
SeeAVs = true;
AnyAVSounds = true;
GroupAVSounds = true;
}
}
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap();
map["auth_buyer_id"] = OSD.FromUUID(AuthBuyerID);
map["auto_scale"] = OSD.FromBoolean(MediaAutoScale);
map["category"] = OSD.FromInteger((byte)Category);
map["description"] = OSD.FromString(Desc);
map["flags"] = OSD.FromBinary(Utils.EmptyBytes);
map["group_id"] = OSD.FromUUID(GroupID);
map["landing_type"] = OSD.FromInteger((byte)Landing);
map["local_id"] = OSD.FromInteger(LocalID);
map["media_desc"] = OSD.FromString(MediaDesc);
map["media_height"] = OSD.FromInteger(MediaHeight);
map["media_id"] = OSD.FromUUID(MediaID);
map["media_loop"] = OSD.FromBoolean(MediaLoop);
map["media_type"] = OSD.FromString(MediaType);
map["media_url"] = OSD.FromString(MediaURL);
map["media_width"] = OSD.FromInteger(MediaWidth);
map["music_url"] = OSD.FromString(MusicURL);
map["name"] = OSD.FromString(Name);
map["obscure_media"] = OSD.FromBoolean(ObscureMedia);
map["obscure_music"] = OSD.FromBoolean(ObscureMusic);
map["parcel_flags"] = OSD.FromUInteger((uint)ParcelFlags);
map["pass_hours"] = OSD.FromReal(PassHours);
map["privacy"] = OSD.FromBoolean(Privacy);
map["pass_price"] = OSD.FromInteger(PassPrice);
map["sale_price"] = OSD.FromInteger(SalePrice);
map["snapshot_id"] = OSD.FromUUID(SnapshotID);
map["user_location"] = OSD.FromVector3(UserLocation);
map["user_look_at"] = OSD.FromVector3(UserLookAt);
map["see_avs"] = OSD.FromBoolean(SeeAVs);
map["any_av_sounds"] = OSD.FromBoolean(AnyAVSounds);
map["group_av_sounds"] = OSD.FromBoolean(GroupAVSounds);
return map;
}
}
/// <summary>Base class used for the RemoteParcelRequest message</summary>
[Serializable]
public abstract class RemoteParcelRequestBlock
{
public abstract OSDMap Serialize();
public abstract void Deserialize(OSDMap map);
}
/// <summary>
/// A message sent from the viewer to the simulator to request information
/// on a remote parcel
/// </summary>
public class RemoteParcelRequestRequest : RemoteParcelRequestBlock
{
/// <summary>Local sim position of the parcel we are looking up</summary>
public Vector3 Location;
/// <summary>Region handle of the parcel we are looking up</summary>
public ulong RegionHandle;
/// <summary>Region <see cref="UUID"/> of the parcel we are looking up</summary>
public UUID RegionID;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(3);
map["location"] = OSD.FromVector3(Location);
map["region_handle"] = OSD.FromULong(RegionHandle);
map["region_id"] = OSD.FromUUID(RegionID);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public override void Deserialize(OSDMap map)
{
Location = map["location"].AsVector3();
RegionHandle = map["region_handle"].AsULong();
RegionID = map["region_id"].AsUUID();
}
}
/// <summary>
/// A message sent from the simulator to the viewer in response to a <see cref="RemoteParcelRequestRequest"/>
/// which will contain parcel information
/// </summary>
[Serializable]
public class RemoteParcelRequestReply : RemoteParcelRequestBlock
{
/// <summary>The grid-wide unique parcel ID</summary>
public UUID ParcelID;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(1);
map["parcel_id"] = OSD.FromUUID(ParcelID);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public override void Deserialize(OSDMap map)
{
if (map == null || !map.ContainsKey("parcel_id"))
ParcelID = UUID.Zero;
else
ParcelID = map["parcel_id"].AsUUID();
}
}
/// <summary>
/// A message containing a request for a remote parcel from a viewer, or a response
/// from the simulator to that request
/// </summary>
[Serializable]
public class RemoteParcelRequestMessage : IMessage
{
/// <summary>The request or response details block</summary>
public RemoteParcelRequestBlock Request;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
return Request.Serialize();
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
if (map.ContainsKey("parcel_id"))
Request = new RemoteParcelRequestReply();
else if (map.ContainsKey("location"))
Request = new RemoteParcelRequestRequest();
else
Logger.Log("Unable to deserialize RemoteParcelRequest: No message handler exists for method: " + map.AsString(), Helpers.LogLevel.Warning);
if (Request != null)
Request.Deserialize(map);
}
}
#endregion
#region Inventory Messages
public class NewFileAgentInventoryMessage : IMessage
{
public UUID FolderID;
public AssetType AssetType;
public InventoryType InventoryType;
public string Name;
public string Description;
public PermissionMask EveryoneMask;
public PermissionMask GroupMask;
public PermissionMask NextOwnerMask;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(5);
map["folder_id"] = OSD.FromUUID(FolderID);
map["asset_type"] = OSD.FromString(Utils.AssetTypeToString(AssetType));
map["inventory_type"] = OSD.FromString(Utils.InventoryTypeToString(InventoryType));
map["name"] = OSD.FromString(Name);
map["description"] = OSD.FromString(Description);
map["everyone_mask"] = OSD.FromInteger((int)EveryoneMask);
map["group_mask"] = OSD.FromInteger((int)GroupMask);
map["next_owner_mask"] = OSD.FromInteger((int)NextOwnerMask);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
FolderID = map["folder_id"].AsUUID();
AssetType = Utils.StringToAssetType(map["asset_type"].AsString());
InventoryType = Utils.StringToInventoryType(map["inventory_type"].AsString());
Name = map["name"].AsString();
Description = map["description"].AsString();
EveryoneMask = (PermissionMask)map["everyone_mask"].AsInteger();
GroupMask = (PermissionMask)map["group_mask"].AsInteger();
NextOwnerMask = (PermissionMask)map["next_owner_mask"].AsInteger();
}
}
public class NewFileAgentInventoryReplyMessage : IMessage
{
public string State;
public Uri Uploader;
public NewFileAgentInventoryReplyMessage()
{
State = "upload";
}
public OSDMap Serialize()
{
OSDMap map = new OSDMap();
map["state"] = OSD.FromString(State);
map["uploader"] = OSD.FromUri(Uploader);
return map;
}
public void Deserialize(OSDMap map)
{
State = map["state"].AsString();
Uploader = map["uploader"].AsUri();
}
}
public class NewFileAgentInventoryVariablePriceMessage : IMessage
{
public UUID FolderID;
public AssetType AssetType;
public InventoryType InventoryType;
public string Name;
public string Description;
public PermissionMask EveryoneMask;
public PermissionMask GroupMask;
public PermissionMask NextOwnerMask;
// TODO: asset_resources?
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap();
map["folder_id"] = OSD.FromUUID(FolderID);
map["asset_type"] = OSD.FromString(Utils.AssetTypeToString(AssetType));
map["inventory_type"] = OSD.FromString(Utils.InventoryTypeToString(InventoryType));
map["name"] = OSD.FromString(Name);
map["description"] = OSD.FromString(Description);
map["everyone_mask"] = OSD.FromInteger((int)EveryoneMask);
map["group_mask"] = OSD.FromInteger((int)GroupMask);
map["next_owner_mask"] = OSD.FromInteger((int)NextOwnerMask);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
FolderID = map["folder_id"].AsUUID();
AssetType = Utils.StringToAssetType(map["asset_type"].AsString());
InventoryType = Utils.StringToInventoryType(map["inventory_type"].AsString());
Name = map["name"].AsString();
Description = map["description"].AsString();
EveryoneMask = (PermissionMask)map["everyone_mask"].AsInteger();
GroupMask = (PermissionMask)map["group_mask"].AsInteger();
NextOwnerMask = (PermissionMask)map["next_owner_mask"].AsInteger();
}
}
public class NewFileAgentInventoryVariablePriceReplyMessage : IMessage
{
public int ResourceCost;
public string State;
public int UploadPrice;
public Uri Rsvp;
public NewFileAgentInventoryVariablePriceReplyMessage()
{
State = "confirm_upload";
}
public OSDMap Serialize()
{
OSDMap map = new OSDMap();
map["resource_cost"] = OSD.FromInteger(ResourceCost);
map["state"] = OSD.FromString(State);
map["upload_price"] = OSD.FromInteger(UploadPrice);
map["rsvp"] = OSD.FromUri(Rsvp);
return map;
}
public void Deserialize(OSDMap map)
{
ResourceCost = map["resource_cost"].AsInteger();
State = map["state"].AsString();
UploadPrice = map["upload_price"].AsInteger();
Rsvp = map["rsvp"].AsUri();
}
}
public class NewFileAgentInventoryUploadReplyMessage : IMessage
{
public UUID NewInventoryItem;
public UUID NewAsset;
public string State;
public PermissionMask NewBaseMask;
public PermissionMask NewEveryoneMask;
public PermissionMask NewOwnerMask;
public PermissionMask NewNextOwnerMask;
public NewFileAgentInventoryUploadReplyMessage()
{
State = "complete";
}
public OSDMap Serialize()
{
OSDMap map = new OSDMap();
map["new_inventory_item"] = OSD.FromUUID(NewInventoryItem);
map["new_asset"] = OSD.FromUUID(NewAsset);
map["state"] = OSD.FromString(State);
map["new_base_mask"] = OSD.FromInteger((int)NewBaseMask);
map["new_everyone_mask"] = OSD.FromInteger((int)NewEveryoneMask);
map["new_owner_mask"] = OSD.FromInteger((int)NewOwnerMask);
map["new_next_owner_mask"] = OSD.FromInteger((int)NewNextOwnerMask);
return map;
}
public void Deserialize(OSDMap map)
{
NewInventoryItem = map["new_inventory_item"].AsUUID();
NewAsset = map["new_asset"].AsUUID();
State = map["state"].AsString();
NewBaseMask = (PermissionMask)map["new_base_mask"].AsInteger();
NewEveryoneMask = (PermissionMask)map["new_everyone_mask"].AsInteger();
NewOwnerMask = (PermissionMask)map["new_owner_mask"].AsInteger();
NewNextOwnerMask = (PermissionMask)map["new_next_owner_mask"].AsInteger();
}
}
public class BulkUpdateInventoryMessage : IMessage
{
public class FolderDataInfo
{
public UUID FolderID;
public UUID ParentID;
public string Name;
public FolderType Type;
public static FolderDataInfo FromOSD(OSD data)
{
FolderDataInfo ret = new FolderDataInfo();
if (!(data is OSDMap)) return ret;
OSDMap map = (OSDMap)data;
ret.FolderID = map["FolderID"];
ret.ParentID = map["ParentID"];
ret.Name = map["Name"];
ret.Type = (FolderType)map["Type"].AsInteger();
return ret;
}
}
public class ItemDataInfo
{
public UUID ItemID;
public uint CallbackID;
public UUID FolderID;
public UUID CreatorID;
public UUID OwnerID;
public UUID GroupID;
public PermissionMask BaseMask;
public PermissionMask OwnerMask;
public PermissionMask GroupMask;
public PermissionMask EveryoneMask;
public PermissionMask NextOwnerMask;
public bool GroupOwned;
public UUID AssetID;
public AssetType Type;
public InventoryType InvType;
public uint Flags;
public SaleType SaleType;
public int SalePrice;
public string Name;
public string Description;
public DateTime CreationDate;
public uint CRC;
public static ItemDataInfo FromOSD(OSD data)
{
ItemDataInfo ret = new ItemDataInfo();
if (!(data is OSDMap)) return ret;
OSDMap map = (OSDMap)data;
ret.ItemID = map["ItemID"];
ret.CallbackID = map["CallbackID"];
ret.FolderID = map["FolderID"];
ret.CreatorID = map["CreatorID"];
ret.OwnerID = map["OwnerID"];
ret.GroupID = map["GroupID"];
ret.BaseMask = (PermissionMask)map["BaseMask"].AsUInteger();
ret.OwnerMask = (PermissionMask)map["OwnerMask"].AsUInteger();
ret.GroupMask = (PermissionMask)map["GroupMask"].AsUInteger();
ret.EveryoneMask = (PermissionMask)map["EveryoneMask"].AsUInteger();
ret.NextOwnerMask = (PermissionMask)map["NextOwnerMask"].AsUInteger();
ret.GroupOwned = map["GroupOwned"];
ret.AssetID = map["AssetID"];
ret.Type = (AssetType)map["Type"].AsInteger();
ret.InvType = (InventoryType)map["InvType"].AsInteger();
ret.Flags = map["Flags"];
ret.SaleType = (SaleType)map["SaleType"].AsInteger();
ret.SalePrice = map["SaleType"];
ret.Name = map["Name"];
ret.Description = map["Description"];
ret.CreationDate = Utils.UnixTimeToDateTime(map["CreationDate"]);
ret.CRC = map["CRC"];
return ret;
}
}
public UUID AgentID;
public UUID TransactionID;
public FolderDataInfo[] FolderData;
public ItemDataInfo[] ItemData;
public OSDMap Serialize()
{
throw new NotImplementedException();
}
public void Deserialize(OSDMap map)
{
if (map["AgentData"] is OSDArray)
{
OSDArray array = (OSDArray)map["AgentData"];
if (array.Count > 0)
{
OSDMap adata = (OSDMap)array[0];
AgentID = adata["AgentID"];
TransactionID = adata["TransactionID"];
}
}
if (map["FolderData"] is OSDArray)
{
OSDArray array = (OSDArray)map["FolderData"];
FolderData = new FolderDataInfo[array.Count];
for (int i = 0; i < array.Count; i++)
{
FolderData[i] = FolderDataInfo.FromOSD(array[i]);
}
}
else
{
FolderData = new FolderDataInfo[0];
}
if (map["ItemData"] is OSDArray)
{
OSDArray array = (OSDArray)map["ItemData"];
ItemData = new ItemDataInfo[array.Count];
for (int i = 0; i < array.Count; i++)
{
ItemData[i] = ItemDataInfo.FromOSD(array[i]);
}
}
else
{
ItemData = new ItemDataInfo[0];
}
}
}
#endregion
#region Agent Messages
/// <summary>
/// A message sent from the simulator to an agent which contains
/// the groups the agent is in
/// </summary>
public class AgentGroupDataUpdateMessage : IMessage
{
/// <summary>The Agent receiving the message</summary>
public UUID AgentID;
/// <summary>Group Details specific to the agent</summary>
public class GroupData
{
/// <summary>true of the agent accepts group notices</summary>
public bool AcceptNotices;
/// <summary>The agents tier contribution to the group</summary>
public int Contribution;
/// <summary>The Groups <seealso cref="UUID"/></summary>
public UUID GroupID;
/// <summary>The <seealso cref="UUID"/> of the groups insignia</summary>
public UUID GroupInsigniaID;
/// <summary>The name of the group</summary>
public string GroupName;
/// <summary>The aggregate permissions the agent has in the group for all roles the agent
/// is assigned</summary>
public GroupPowers GroupPowers;
}
/// <summary>An optional block containing additional agent specific information</summary>
public class NewGroupData
{
/// <summary>true of the agent allows this group to be
/// listed in their profile</summary>
public bool ListInProfile;
}
/// <summary>An array containing <seealso cref="GroupData"/> information
/// for each <see cref="Group"/> the agent is a member of</summary>
public GroupData[] GroupDataBlock;
/// <summary>An array containing <seealso cref="NewGroupData"/> information
/// for each <see cref="Group"/> the agent is a member of</summary>
public NewGroupData[] NewGroupDataBlock;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(3);
OSDMap agent = new OSDMap(1);
agent["AgentID"] = OSD.FromUUID(AgentID);
OSDArray agentArray = new OSDArray();
agentArray.Add(agent);
map["AgentData"] = agentArray;
OSDArray groupDataArray = new OSDArray(GroupDataBlock.Length);
for (int i = 0; i < GroupDataBlock.Length; i++)
{
OSDMap group = new OSDMap(6);
group["AcceptNotices"] = OSD.FromBoolean(GroupDataBlock[i].AcceptNotices);
group["Contribution"] = OSD.FromInteger(GroupDataBlock[i].Contribution);
group["GroupID"] = OSD.FromUUID(GroupDataBlock[i].GroupID);
group["GroupInsigniaID"] = OSD.FromUUID(GroupDataBlock[i].GroupInsigniaID);
group["GroupName"] = OSD.FromString(GroupDataBlock[i].GroupName);
group["GroupPowers"] = OSD.FromLong((long)GroupDataBlock[i].GroupPowers);
groupDataArray.Add(group);
}
map["GroupData"] = groupDataArray;
OSDArray newGroupDataArray = new OSDArray(NewGroupDataBlock.Length);
for (int i = 0; i < NewGroupDataBlock.Length; i++)
{
OSDMap group = new OSDMap(1);
group["ListInProfile"] = OSD.FromBoolean(NewGroupDataBlock[i].ListInProfile);
newGroupDataArray.Add(group);
}
map["NewGroupData"] = newGroupDataArray;
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
OSDArray agentArray = (OSDArray)map["AgentData"];
OSDMap agentMap = (OSDMap)agentArray[0];
AgentID = agentMap["AgentID"].AsUUID();
OSDArray groupArray = (OSDArray)map["GroupData"];
GroupDataBlock = new GroupData[groupArray.Count];
for (int i = 0; i < groupArray.Count; i++)
{
OSDMap groupMap = (OSDMap)groupArray[i];
GroupData groupData = new GroupData();
groupData.GroupID = groupMap["GroupID"].AsUUID();
groupData.Contribution = groupMap["Contribution"].AsInteger();
groupData.GroupInsigniaID = groupMap["GroupInsigniaID"].AsUUID();
groupData.GroupName = groupMap["GroupName"].AsString();
groupData.GroupPowers = (GroupPowers)groupMap["GroupPowers"].AsLong();
groupData.AcceptNotices = groupMap["AcceptNotices"].AsBoolean();
GroupDataBlock[i] = groupData;
}
// If request for current groups came very close to login
// the Linden sim will not include the NewGroupData block, but
// it will instead set all ListInProfile fields to false
if (map.ContainsKey("NewGroupData"))
{
OSDArray newGroupArray = (OSDArray)map["NewGroupData"];
NewGroupDataBlock = new NewGroupData[newGroupArray.Count];
for (int i = 0; i < newGroupArray.Count; i++)
{
OSDMap newGroupMap = (OSDMap)newGroupArray[i];
NewGroupData newGroupData = new NewGroupData();
newGroupData.ListInProfile = newGroupMap["ListInProfile"].AsBoolean();
NewGroupDataBlock[i] = newGroupData;
}
}
else
{
NewGroupDataBlock = new NewGroupData[GroupDataBlock.Length];
for (int i = 0; i < NewGroupDataBlock.Length; i++)
{
NewGroupData newGroupData = new NewGroupData();
newGroupData.ListInProfile = false;
NewGroupDataBlock[i] = newGroupData;
}
}
}
}
/// <summary>
/// A message sent from the viewer to the simulator which
/// specifies the language and permissions for others to detect
/// the language specified
/// </summary>
public class UpdateAgentLanguageMessage : IMessage
{
/// <summary>A string containng the default language
/// to use for the agent</summary>
public string Language;
/// <summary>true of others are allowed to
/// know the language setting</summary>
public bool LanguagePublic;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(2);
map["language"] = OSD.FromString(Language);
map["language_is_public"] = OSD.FromBoolean(LanguagePublic);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
LanguagePublic = map["language_is_public"].AsBoolean();
Language = map["language"].AsString();
}
}
/// <summary>
/// An EventQueue message sent from the simulator to an agent when the agent
/// leaves a group
/// </summary>
public class AgentDropGroupMessage : IMessage
{
/// <summary>An object containing the Agents UUID, and the Groups UUID</summary>
public class AgentData
{
/// <summary>The ID of the Agent leaving the group</summary>
public UUID AgentID;
/// <summary>The GroupID the Agent is leaving</summary>
public UUID GroupID;
}
/// <summary>
/// An Array containing the AgentID and GroupID
/// </summary>
public AgentData[] AgentDataBlock;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(1);
OSDArray agentDataArray = new OSDArray(AgentDataBlock.Length);
for (int i = 0; i < AgentDataBlock.Length; i++)
{
OSDMap agentMap = new OSDMap(2);
agentMap["AgentID"] = OSD.FromUUID(AgentDataBlock[i].AgentID);
agentMap["GroupID"] = OSD.FromUUID(AgentDataBlock[i].GroupID);
agentDataArray.Add(agentMap);
}
map["AgentData"] = agentDataArray;
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
OSDArray agentDataArray = (OSDArray)map["AgentData"];
AgentDataBlock = new AgentData[agentDataArray.Count];
for (int i = 0; i < agentDataArray.Count; i++)
{
OSDMap agentMap = (OSDMap)agentDataArray[i];
AgentData agentData = new AgentData();
agentData.AgentID = agentMap["AgentID"].AsUUID();
agentData.GroupID = agentMap["GroupID"].AsUUID();
AgentDataBlock[i] = agentData;
}
}
}
public class AgentStateUpdateMessage : IMessage
{
public OSDMap RawData;
public bool CanModifyNavmesh;
public bool HasModifiedNavmesh;
public string MaxAccess; // PG, M, A
public bool AlterNavmeshObjects;
public bool AlterPermanentObjects;
public int GodLevel;
public string Language;
public bool LanguageIsPublic;
public void Deserialize(OSDMap map)
{
RawData = map;
CanModifyNavmesh = map["can_modify_navmesh"];
HasModifiedNavmesh = map["has_modified_navmesh"];
if (map["preferences"] is OSDMap)
{
OSDMap prefs = (OSDMap)map["preferences"];
AlterNavmeshObjects = prefs["alter_navmesh_objects"];
AlterPermanentObjects = prefs["alter_permanent_objects"];
GodLevel = prefs["god_level"];
Language = prefs["language"];
LanguageIsPublic = prefs["language_is_public"];
if (prefs["access_prefs"] is OSDMap)
{
OSDMap access = (OSDMap)prefs["access_prefs"];
MaxAccess = access["max"];
}
}
}
public OSDMap Serialize()
{
RawData = new OSDMap();
RawData["can_modify_navmesh"] = CanModifyNavmesh;
RawData["has_modified_navmesh"] = HasModifiedNavmesh;
OSDMap prefs = new OSDMap();
{
OSDMap access = new OSDMap();
{
access["max"] = MaxAccess;
}
prefs["access_prefs"] = access;
prefs["alter_navmesh_objects"] = AlterNavmeshObjects;
prefs["alter_permanent_objects"] = AlterPermanentObjects;
prefs["god_level"] = GodLevel;
prefs["language"] = Language;
prefs["language_is_public"] = LanguageIsPublic;
}
RawData["preferences"] = prefs;
return RawData;
}
}
/// <summary>Base class for Asset uploads/results via Capabilities</summary>
public abstract class AssetUploaderBlock
{
/// <summary>
/// The request state
/// </summary>
public string State;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public abstract OSDMap Serialize();
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public abstract void Deserialize(OSDMap map);
}
/// <summary>
/// A message sent from the viewer to the simulator to request a temporary upload capability
/// which allows an asset to be uploaded
/// </summary>
public class UploaderRequestUpload : AssetUploaderBlock
{
/// <summary>The Capability URL sent by the simulator to upload the baked texture to</summary>
public Uri Url;
public UploaderRequestUpload()
{
State = "upload";
}
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(2);
map["state"] = OSD.FromString(State);
map["uploader"] = OSD.FromUri(Url);
return map;
}
public override void Deserialize(OSDMap map)
{
Url = map["uploader"].AsUri();
State = map["state"].AsString();
}
}
/// <summary>
/// A message sent from the simulator that will inform the agent the upload is complete,
/// and the UUID of the uploaded asset
/// </summary>
public class UploaderRequestComplete : AssetUploaderBlock
{
/// <summary>The uploaded texture asset ID</summary>
public UUID AssetID;
public UploaderRequestComplete()
{
State = "complete";
}
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(2);
map["state"] = OSD.FromString(State);
map["new_asset"] = OSD.FromUUID(AssetID);
return map;
}
public override void Deserialize(OSDMap map)
{
AssetID = map["new_asset"].AsUUID();
State = map["state"].AsString();
}
}
/// <summary>
/// A message sent from the viewer to the simulator to request a temporary
/// capability URI which is used to upload an agents baked appearance textures
/// </summary>
public class UploadBakedTextureMessage : IMessage
{
/// <summary>Object containing request or response</summary>
public AssetUploaderBlock Request;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
return Request.Serialize();
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
if (map.ContainsKey("state") && map["state"].AsString().Equals("upload"))
Request = new UploaderRequestUpload();
else if (map.ContainsKey("state") && map["state"].AsString().Equals("complete"))
Request = new UploaderRequestComplete();
else
Logger.Log("Unable to deserialize UploadBakedTexture: No message handler exists for state " + map["state"].AsString(), Helpers.LogLevel.Warning);
if (Request != null)
Request.Deserialize(map);
}
}
#endregion
#region Voice Messages
/// <summary>
/// A message sent from the simulator which indicates the minimum version required for
/// using voice chat
/// </summary>
public class RequiredVoiceVersionMessage : IMessage
{
/// <summary>Major Version Required</summary>
public int MajorVersion;
/// <summary>Minor version required</summary>
public int MinorVersion;
/// <summary>The name of the region sending the version requrements</summary>
public string RegionName;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(4);
map["major_version"] = OSD.FromInteger(MajorVersion);
map["minor_version"] = OSD.FromInteger(MinorVersion);
map["region_name"] = OSD.FromString(RegionName);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
MajorVersion = map["major_version"].AsInteger();
MinorVersion = map["minor_version"].AsInteger();
RegionName = map["region_name"].AsString();
}
}
/// <summary>
/// A message sent from the simulator to the viewer containing the
/// voice server URI
/// </summary>
public class ParcelVoiceInfoRequestMessage : IMessage
{
/// <summary>The Parcel ID which the voice server URI applies</summary>
public int ParcelID;
/// <summary>The name of the region</summary>
public string RegionName;
/// <summary>A uri containing the server/channel information
/// which the viewer can utilize to participate in voice conversations</summary>
public Uri SipChannelUri;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(3);
map["parcel_local_id"] = OSD.FromInteger(ParcelID);
map["region_name"] = OSD.FromString(RegionName);
OSDMap vcMap = new OSDMap(1);
vcMap["channel_uri"] = OSD.FromUri(SipChannelUri);
map["voice_credentials"] = vcMap;
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
ParcelID = map["parcel_local_id"].AsInteger();
RegionName = map["region_name"].AsString();
OSDMap vcMap = (OSDMap)map["voice_credentials"];
SipChannelUri = vcMap["channel_uri"].AsUri();
}
}
/// <summary>
///
/// </summary>
public class ProvisionVoiceAccountRequestMessage : IMessage
{
/// <summary></summary>
public string Password;
/// <summary></summary>
public string Username;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(2);
map["username"] = OSD.FromString(Username);
map["password"] = OSD.FromString(Password);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
Username = map["username"].AsString();
Password = map["password"].AsString();
}
}
#endregion
#region Script/Notecards Messages
/// <summary>
/// A message sent by the viewer to the simulator to request a temporary
/// capability for a script contained with in a Tasks inventory to be updated
/// </summary>
public class UploadScriptTaskMessage : IMessage
{
/// <summary>Object containing request or response</summary>
public AssetUploaderBlock Request;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
return Request.Serialize();
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
if (map.ContainsKey("state") && map["state"].Equals("upload"))
Request = new UploaderRequestUpload();
else if (map.ContainsKey("state") && map["state"].Equals("complete"))
Request = new UploaderRequestComplete();
else
Logger.Log("Unable to deserialize UploadScriptTask: No message handler exists for state " + map["state"].AsString(), Helpers.LogLevel.Warning);
Request.Deserialize(map);
}
}
/// <summary>
/// A message sent from the simulator to the viewer to indicate
/// a Tasks scripts status.
/// </summary>
public class ScriptRunningReplyMessage : IMessage
{
/// <summary>The Asset ID of the script</summary>
public UUID ItemID;
/// <summary>True of the script is compiled/ran using the mono interpreter, false indicates it
/// uses the older less efficient lsl2 interprter</summary>
public bool Mono;
/// <summary>The Task containing the scripts <seealso cref="UUID"/></summary>
public UUID ObjectID;
/// <summary>true of the script is in a running state</summary>
public bool Running;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(2);
OSDMap scriptMap = new OSDMap(4);
scriptMap["ItemID"] = OSD.FromUUID(ItemID);
scriptMap["Mono"] = OSD.FromBoolean(Mono);
scriptMap["ObjectID"] = OSD.FromUUID(ObjectID);
scriptMap["Running"] = OSD.FromBoolean(Running);
OSDArray scriptArray = new OSDArray(1);
scriptArray.Add((OSD)scriptMap);
map["Script"] = scriptArray;
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
OSDArray scriptArray = (OSDArray)map["Script"];
OSDMap scriptMap = (OSDMap)scriptArray[0];
ItemID = scriptMap["ItemID"].AsUUID();
Mono = scriptMap["Mono"].AsBoolean();
ObjectID = scriptMap["ObjectID"].AsUUID();
Running = scriptMap["Running"].AsBoolean();
}
}
/// <summary>
/// A message containing the request/response used for updating a gesture
/// contained with an agents inventory
/// </summary>
public class UpdateGestureAgentInventoryMessage : IMessage
{
/// <summary>Object containing request or response</summary>
public AssetUploaderBlock Request;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
return Request.Serialize();
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
if (map.ContainsKey("item_id"))
Request = new UpdateAgentInventoryRequestMessage();
else if (map.ContainsKey("state") && map["state"].AsString().Equals("upload"))
Request = new UploaderRequestUpload();
else if (map.ContainsKey("state") && map["state"].AsString().Equals("complete"))
Request = new UploaderRequestComplete();
else
Logger.Log("Unable to deserialize UpdateGestureAgentInventory: No message handler exists: " + map.AsString(), Helpers.LogLevel.Warning);
if (Request != null)
Request.Deserialize(map);
}
}
/// <summary>
/// A message request/response which is used to update a notecard contained within
/// a tasks inventory
/// </summary>
public class UpdateNotecardTaskInventoryMessage : IMessage
{
/// <summary>The <seealso cref="UUID"/> of the Task containing the notecard asset to update</summary>
public UUID TaskID;
/// <summary>The notecard assets <seealso cref="UUID"/> contained in the tasks inventory</summary>
public UUID ItemID;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(1);
map["task_id"] = OSD.FromUUID(TaskID);
map["item_id"] = OSD.FromUUID(ItemID);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
TaskID = map["task_id"].AsUUID();
ItemID = map["item_id"].AsUUID();
}
}
// TODO: Add Test
/// <summary>
/// A reusable class containing a message sent from the viewer to the simulator to request a temporary uploader capability
/// which is used to update an asset in an agents inventory
/// </summary>
public class UpdateAgentInventoryRequestMessage : AssetUploaderBlock
{
/// <summary>
/// The Notecard AssetID to replace
/// </summary>
public UUID ItemID;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(1);
map["item_id"] = OSD.FromUUID(ItemID);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public override void Deserialize(OSDMap map)
{
ItemID = map["item_id"].AsUUID();
}
}
/// <summary>
/// A message containing the request/response used for updating a notecard
/// contained with an agents inventory
/// </summary>
public class UpdateNotecardAgentInventoryMessage : IMessage
{
/// <summary>Object containing request or response</summary>
public AssetUploaderBlock Request;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
return Request.Serialize();
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
if (map.ContainsKey("item_id"))
Request = new UpdateAgentInventoryRequestMessage();
else if (map.ContainsKey("state") && map["state"].AsString().Equals("upload"))
Request = new UploaderRequestUpload();
else if (map.ContainsKey("state") && map["state"].AsString().Equals("complete"))
Request = new UploaderRequestComplete();
else
Logger.Log("Unable to deserialize UpdateNotecardAgentInventory: No message handler exists for state " + map["state"].AsString(), Helpers.LogLevel.Warning);
if (Request != null)
Request.Deserialize(map);
}
}
public class CopyInventoryFromNotecardMessage : IMessage
{
public int CallbackID;
public UUID FolderID;
public UUID ItemID;
public UUID NotecardID;
public UUID ObjectID;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(5);
map["callback-id"] = OSD.FromInteger(CallbackID);
map["folder-id"] = OSD.FromUUID(FolderID);
map["item-id"] = OSD.FromUUID(ItemID);
map["notecard-id"] = OSD.FromUUID(NotecardID);
map["object-id"] = OSD.FromUUID(ObjectID);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
CallbackID = map["callback-id"].AsInteger();
FolderID = map["folder-id"].AsUUID();
ItemID = map["item-id"].AsUUID();
NotecardID = map["notecard-id"].AsUUID();
ObjectID = map["object-id"].AsUUID();
}
}
/// <summary>
/// A message sent from the simulator to the viewer which indicates
/// an error occurred while attempting to update a script in an agents or tasks
/// inventory
/// </summary>
public class UploaderScriptRequestError : AssetUploaderBlock
{
/// <summary>true of the script was successfully compiled by the simulator</summary>
public bool Compiled;
/// <summary>A string containing the error which occured while trying
/// to update the script</summary>
public string Error;
/// <summary>A new AssetID assigned to the script</summary>
public UUID AssetID;
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(4);
map["state"] = OSD.FromString(State);
map["new_asset"] = OSD.FromUUID(AssetID);
map["compiled"] = OSD.FromBoolean(Compiled);
OSDArray errorsArray = new OSDArray();
errorsArray.Add(Error);
map["errors"] = errorsArray;
return map;
}
public override void Deserialize(OSDMap map)
{
AssetID = map["new_asset"].AsUUID();
Compiled = map["compiled"].AsBoolean();
State = map["state"].AsString();
OSDArray errorsArray = (OSDArray)map["errors"];
Error = errorsArray[0].AsString();
}
}
/// <summary>
/// A message sent from the viewer to the simulator
/// requesting the update of an existing script contained
/// within a tasks inventory
/// </summary>
public class UpdateScriptTaskUpdateMessage : AssetUploaderBlock
{
/// <summary>if true, set the script mode to running</summary>
public bool ScriptRunning;
/// <summary>The scripts InventoryItem ItemID to update</summary>
public UUID ItemID;
/// <summary>A lowercase string containing either "mono" or "lsl2" which
/// specifies the script is compiled and ran on the mono runtime, or the older
/// lsl runtime</summary>
public string Target; // mono or lsl2
/// <summary>The tasks <see cref="UUID"/> which contains the script to update</summary>
public UUID TaskID;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(4);
map["is_script_running"] = OSD.FromBoolean(ScriptRunning);
map["item_id"] = OSD.FromUUID(ItemID);
map["target"] = OSD.FromString(Target);
map["task_id"] = OSD.FromUUID(TaskID);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public override void Deserialize(OSDMap map)
{
ScriptRunning = map["is_script_running"].AsBoolean();
ItemID = map["item_id"].AsUUID();
Target = map["target"].AsString();
TaskID = map["task_id"].AsUUID();
}
}
/// <summary>
/// A message containing either the request or response used in updating a script inside
/// a tasks inventory
/// </summary>
public class UpdateScriptTaskMessage : IMessage
{
/// <summary>Object containing request or response</summary>
public AssetUploaderBlock Request;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
return Request.Serialize();
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
if (map.ContainsKey("task_id"))
Request = new UpdateScriptTaskUpdateMessage();
else if (map.ContainsKey("state") && map["state"].AsString().Equals("upload"))
Request = new UploaderRequestUpload();
else if (map.ContainsKey("state") && map["state"].AsString().Equals("complete")
&& map.ContainsKey("errors"))
Request = new UploaderScriptRequestError();
else if (map.ContainsKey("state") && map["state"].AsString().Equals("complete"))
Request = new UploaderRequestScriptComplete();
else
Logger.Log("Unable to deserialize UpdateScriptTaskMessage: No message handler exists for state " + map["state"].AsString(), Helpers.LogLevel.Warning);
if (Request != null)
Request.Deserialize(map);
}
}
/// <summary>
/// Response from the simulator to notify the viewer the upload is completed, and
/// the UUID of the script asset and its compiled status
/// </summary>
public class UploaderRequestScriptComplete : AssetUploaderBlock
{
/// <summary>The uploaded texture asset ID</summary>
public UUID AssetID;
/// <summary>true of the script was compiled successfully</summary>
public bool Compiled;
public UploaderRequestScriptComplete()
{
State = "complete";
}
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(2);
map["state"] = OSD.FromString(State);
map["new_asset"] = OSD.FromUUID(AssetID);
map["compiled"] = OSD.FromBoolean(Compiled);
return map;
}
public override void Deserialize(OSDMap map)
{
AssetID = map["new_asset"].AsUUID();
Compiled = map["compiled"].AsBoolean();
}
}
/// <summary>
/// A message sent from a viewer to the simulator requesting a temporary uploader capability
/// used to update a script contained in an agents inventory
/// </summary>
public class UpdateScriptAgentRequestMessage : AssetUploaderBlock
{
/// <summary>The existing asset if of the script in the agents inventory to replace</summary>
public UUID ItemID;
/// <summary>The language of the script</summary>
/// <remarks>Defaults to lsl version 2, "mono" might be another possible option</remarks>
public string Target = "lsl2"; // lsl2
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(2);
map["item_id"] = OSD.FromUUID(ItemID);
map["target"] = OSD.FromString(Target);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public override void Deserialize(OSDMap map)
{
ItemID = map["item_id"].AsUUID();
Target = map["target"].AsString();
}
}
/// <summary>
/// A message containing either the request or response used in updating a script inside
/// an agents inventory
/// </summary>
public class UpdateScriptAgentMessage : IMessage
{
/// <summary>Object containing request or response</summary>
public AssetUploaderBlock Request;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
return Request.Serialize();
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
if (map.ContainsKey("item_id"))
Request = new UpdateScriptAgentRequestMessage();
else if (map.ContainsKey("errors"))
Request = new UploaderScriptRequestError();
else if (map.ContainsKey("state") && map["state"].AsString().Equals("upload"))
Request = new UploaderRequestUpload();
else if (map.ContainsKey("state") && map["state"].AsString().Equals("complete"))
Request = new UploaderRequestScriptComplete();
else
Logger.Log("Unable to deserialize UpdateScriptAgent: No message handler exists for state " + map["state"].AsString(), Helpers.LogLevel.Warning);
if (Request != null)
Request.Deserialize(map);
}
}
public class SendPostcardMessage : IMessage
{
public string FromEmail;
public string Message;
public string FromName;
public Vector3 GlobalPosition;
public string Subject;
public string ToEmail;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(6);
map["from"] = OSD.FromString(FromEmail);
map["msg"] = OSD.FromString(Message);
map["name"] = OSD.FromString(FromName);
map["pos-global"] = OSD.FromVector3(GlobalPosition);
map["subject"] = OSD.FromString(Subject);
map["to"] = OSD.FromString(ToEmail);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
FromEmail = map["from"].AsString();
Message = map["msg"].AsString();
FromName = map["name"].AsString();
GlobalPosition = map["pos-global"].AsVector3();
Subject = map["subject"].AsString();
ToEmail = map["to"].AsString();
}
}
#endregion
#region Grid/Maps
/// <summary>Base class for Map Layers via Capabilities</summary>
public abstract class MapLayerMessageBase
{
/// <summary></summary>
public int Flags;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public abstract OSDMap Serialize();
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public abstract void Deserialize(OSDMap map);
}
/// <summary>
/// Sent by an agent to the capabilities server to request map layers
/// </summary>
public class MapLayerRequestVariant : MapLayerMessageBase
{
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(1);
map["Flags"] = OSD.FromInteger(Flags);
return map;
}
public override void Deserialize(OSDMap map)
{
Flags = map["Flags"].AsInteger();
}
}
/// <summary>
/// A message sent from the simulator to the viewer which contains an array of map images and their grid coordinates
/// </summary>
public class MapLayerReplyVariant : MapLayerMessageBase
{
/// <summary>
/// An object containing map location details
/// </summary>
public class LayerData
{
/// <summary>The Asset ID of the regions tile overlay</summary>
public UUID ImageID;
/// <summary>The grid location of the southern border of the map tile</summary>
public int Bottom;
/// <summary>The grid location of the western border of the map tile</summary>
public int Left;
/// <summary>The grid location of the eastern border of the map tile</summary>
public int Right;
/// <summary>The grid location of the northern border of the map tile</summary>
public int Top;
}
/// <summary>An array containing LayerData items</summary>
public LayerData[] LayerDataBlocks;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(2);
OSDMap agentMap = new OSDMap(1);
agentMap["Flags"] = OSD.FromInteger(Flags);
map["AgentData"] = agentMap;
OSDArray layerArray = new OSDArray(LayerDataBlocks.Length);
for (int i = 0; i < LayerDataBlocks.Length; i++)
{
OSDMap layerMap = new OSDMap(5);
layerMap["ImageID"] = OSD.FromUUID(LayerDataBlocks[i].ImageID);
layerMap["Bottom"] = OSD.FromInteger(LayerDataBlocks[i].Bottom);
layerMap["Left"] = OSD.FromInteger(LayerDataBlocks[i].Left);
layerMap["Top"] = OSD.FromInteger(LayerDataBlocks[i].Top);
layerMap["Right"] = OSD.FromInteger(LayerDataBlocks[i].Right);
layerArray.Add(layerMap);
}
map["LayerData"] = layerArray;
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public override void Deserialize(OSDMap map)
{
OSDMap agentMap = (OSDMap)map["AgentData"];
Flags = agentMap["Flags"].AsInteger();
OSDArray layerArray = (OSDArray)map["LayerData"];
LayerDataBlocks = new LayerData[layerArray.Count];
for (int i = 0; i < LayerDataBlocks.Length; i++)
{
OSDMap layerMap = (OSDMap)layerArray[i];
LayerData layer = new LayerData();
layer.ImageID = layerMap["ImageID"].AsUUID();
layer.Top = layerMap["Top"].AsInteger();
layer.Right = layerMap["Right"].AsInteger();
layer.Left = layerMap["Left"].AsInteger();
layer.Bottom = layerMap["Bottom"].AsInteger();
LayerDataBlocks[i] = layer;
}
}
}
public class MapLayerMessage : IMessage
{
/// <summary>Object containing request or response</summary>
public MapLayerMessageBase Request;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
return Request.Serialize();
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
if (map.ContainsKey("LayerData"))
Request = new MapLayerReplyVariant();
else if (map.ContainsKey("Flags"))
Request = new MapLayerRequestVariant();
else
Logger.Log("Unable to deserialize MapLayerMessage: No message handler exists", Helpers.LogLevel.Warning);
if (Request != null)
Request.Deserialize(map);
}
}
#endregion
#region Session/Communication
/// <summary>
/// New as of 1.23 RC1, no details yet.
/// </summary>
public class ProductInfoRequestMessage : IMessage
{
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
throw new NotImplementedException();
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
throw new NotImplementedException();
}
}
#region ChatSessionRequestMessage
public abstract class SearchStatRequestBlock
{
public abstract OSDMap Serialize();
public abstract void Deserialize(OSDMap map);
}
// variant A - the request to the simulator
public class SearchStatRequestRequest : SearchStatRequestBlock
{
public UUID ClassifiedID;
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(1);
map["classified_id"] = OSD.FromUUID(ClassifiedID);
return map;
}
public override void Deserialize(OSDMap map)
{
ClassifiedID = map["classified_id"].AsUUID();
}
}
public class SearchStatRequestReply : SearchStatRequestBlock
{
public int MapClicks;
public int ProfileClicks;
public int SearchMapClicks;
public int SearchProfileClicks;
public int SearchTeleportClicks;
public int TeleportClicks;
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(6);
map["map_clicks"] = OSD.FromInteger(MapClicks);
map["profile_clicks"] = OSD.FromInteger(ProfileClicks);
map["search_map_clicks"] = OSD.FromInteger(SearchMapClicks);
map["search_profile_clicks"] = OSD.FromInteger(SearchProfileClicks);
map["search_teleport_clicks"] = OSD.FromInteger(SearchTeleportClicks);
map["teleport_clicks"] = OSD.FromInteger(TeleportClicks);
return map;
}
public override void Deserialize(OSDMap map)
{
MapClicks = map["map_clicks"].AsInteger();
ProfileClicks = map["profile_clicks"].AsInteger();
SearchMapClicks = map["search_map_clicks"].AsInteger();
SearchProfileClicks = map["search_profile_clicks"].AsInteger();
SearchTeleportClicks = map["search_teleport_clicks"].AsInteger();
TeleportClicks = map["teleport_clicks"].AsInteger();
}
}
public class SearchStatRequestMessage : IMessage
{
public SearchStatRequestBlock Request;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
return Request.Serialize();
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
if (map.ContainsKey("map_clicks"))
Request = new SearchStatRequestReply();
else if (map.ContainsKey("classified_id"))
Request = new SearchStatRequestRequest();
else
Logger.Log("Unable to deserialize SearchStatRequest: No message handler exists for method " + map["method"].AsString(), Helpers.LogLevel.Warning);
Request.Deserialize(map);
}
}
public abstract class ChatSessionRequestBlock
{
/// <summary>A string containing the method used</summary>
public string Method;
public abstract OSDMap Serialize();
public abstract void Deserialize(OSDMap map);
}
/// <summary>
/// A request sent from an agent to the Simulator to begin a new conference.
/// Contains a list of Agents which will be included in the conference
/// </summary>
public class ChatSessionRequestStartConference : ChatSessionRequestBlock
{
/// <summary>An array containing the <see cref="UUID"/> of the agents invited to this conference</summary>
public UUID[] AgentsBlock;
/// <summary>The conferences Session ID</summary>
public UUID SessionID;
public ChatSessionRequestStartConference()
{
Method = "start conference";
}
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(3);
map["method"] = OSD.FromString(Method);
OSDArray agentsArray = new OSDArray();
for (int i = 0; i < AgentsBlock.Length; i++)
{
agentsArray.Add(OSD.FromUUID(AgentsBlock[i]));
}
map["params"] = agentsArray;
map["session-id"] = OSD.FromUUID(SessionID);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public override void Deserialize(OSDMap map)
{
Method = map["method"].AsString();
OSDArray agentsArray = (OSDArray)map["params"];
AgentsBlock = new UUID[agentsArray.Count];
for (int i = 0; i < agentsArray.Count; i++)
{
AgentsBlock[i] = agentsArray[i].AsUUID();
}
SessionID = map["session-id"].AsUUID();
}
}
/// <summary>
/// A moderation request sent from a conference moderator
/// Contains an agent and an optional action to take
/// </summary>
public class ChatSessionRequestMuteUpdate : ChatSessionRequestBlock
{
/// <summary>The Session ID</summary>
public UUID SessionID;
/// <summary></summary>
public UUID AgentID;
/// <summary>A list containing Key/Value pairs, known valid values:
/// key: text value: true/false - allow/disallow specified agents ability to use text in session
/// key: voice value: true/false - allow/disallow specified agents ability to use voice in session
/// </summary>
/// <remarks>"text" or "voice"</remarks>
public string RequestKey;
/// <summary></summary>
public bool RequestValue;
public ChatSessionRequestMuteUpdate()
{
Method = "mute update";
}
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(3);
map["method"] = OSD.FromString(Method);
OSDMap muteMap = new OSDMap(1);
muteMap[RequestKey] = OSD.FromBoolean(RequestValue);
OSDMap paramMap = new OSDMap(2);
paramMap["agent_id"] = OSD.FromUUID(AgentID);
paramMap["mute_info"] = muteMap;
map["params"] = paramMap;
map["session-id"] = OSD.FromUUID(SessionID);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public override void Deserialize(OSDMap map)
{
Method = map["method"].AsString();
SessionID = map["session-id"].AsUUID();
OSDMap paramsMap = (OSDMap)map["params"];
OSDMap muteMap = (OSDMap)paramsMap["mute_info"];
AgentID = paramsMap["agent_id"].AsUUID();
if (muteMap.ContainsKey("text"))
RequestKey = "text";
else if (muteMap.ContainsKey("voice"))
RequestKey = "voice";
RequestValue = muteMap[RequestKey].AsBoolean();
}
}
/// <summary>
/// A message sent from the agent to the simulator which tells the
/// simulator we've accepted a conference invitation
/// </summary>
public class ChatSessionAcceptInvitation : ChatSessionRequestBlock
{
/// <summary>The conference SessionID</summary>
public UUID SessionID;
public ChatSessionAcceptInvitation()
{
Method = "accept invitation";
}
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(2);
map["method"] = OSD.FromString(Method);
map["session-id"] = OSD.FromUUID(SessionID);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public override void Deserialize(OSDMap map)
{
Method = map["method"].AsString();
SessionID = map["session-id"].AsUUID();
}
}
public class ChatSessionRequestMessage : IMessage
{
public ChatSessionRequestBlock Request;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
return Request.Serialize();
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
if (map.ContainsKey("method") && map["method"].AsString().Equals("start conference"))
Request = new ChatSessionRequestStartConference();
else if (map.ContainsKey("method") && map["method"].AsString().Equals("mute update"))
Request = new ChatSessionRequestMuteUpdate();
else if (map.ContainsKey("method") && map["method"].AsString().Equals("accept invitation"))
Request = new ChatSessionAcceptInvitation();
else
Logger.Log("Unable to deserialize ChatSessionRequest: No message handler exists for method " + map["method"].AsString(), Helpers.LogLevel.Warning);
Request.Deserialize(map);
}
}
#endregion
public class ChatterboxSessionEventReplyMessage : IMessage
{
public UUID SessionID;
public bool Success;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(2);
map["success"] = OSD.FromBoolean(Success);
map["session_id"] = OSD.FromUUID(SessionID); // FIXME: Verify this is correct map name
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
Success = map["success"].AsBoolean();
SessionID = map["session_id"].AsUUID();
}
}
public class ChatterBoxSessionStartReplyMessage : IMessage
{
public UUID SessionID;
public UUID TempSessionID;
public bool Success;
public string SessionName;
// FIXME: Replace int with an enum
public int Type;
public bool VoiceEnabled;
public bool ModeratedVoice;
/* Is Text moderation possible? */
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap moderatedMap = new OSDMap(1);
moderatedMap["voice"] = OSD.FromBoolean(ModeratedVoice);
OSDMap sessionMap = new OSDMap(4);
sessionMap["type"] = OSD.FromInteger(Type);
sessionMap["session_name"] = OSD.FromString(SessionName);
sessionMap["voice_enabled"] = OSD.FromBoolean(VoiceEnabled);
sessionMap["moderated_mode"] = moderatedMap;
OSDMap map = new OSDMap(4);
map["session_id"] = OSD.FromUUID(SessionID);
map["temp_session_id"] = OSD.FromUUID(TempSessionID);
map["success"] = OSD.FromBoolean(Success);
map["session_info"] = sessionMap;
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
SessionID = map["session_id"].AsUUID();
TempSessionID = map["temp_session_id"].AsUUID();
Success = map["success"].AsBoolean();
if (Success)
{
OSDMap sessionMap = (OSDMap)map["session_info"];
SessionName = sessionMap["session_name"].AsString();
Type = sessionMap["type"].AsInteger();
VoiceEnabled = sessionMap["voice_enabled"].AsBoolean();
OSDMap moderatedModeMap = (OSDMap)sessionMap["moderated_mode"];
ModeratedVoice = moderatedModeMap["voice"].AsBoolean();
}
}
}
public class ChatterBoxInvitationMessage : IMessage
{
/// <summary>Key of sender</summary>
public UUID FromAgentID;
/// <summary>Name of sender</summary>
public string FromAgentName;
/// <summary>Key of destination avatar</summary>
public UUID ToAgentID;
/// <summary>ID of originating estate</summary>
public uint ParentEstateID;
/// <summary>Key of originating region</summary>
public UUID RegionID;
/// <summary>Coordinates in originating region</summary>
public Vector3 Position;
/// <summary>Instant message type</summary>
public InstantMessageDialog Dialog;
/// <summary>Group IM session toggle</summary>
public bool GroupIM;
/// <summary>Key of IM session, for Group Messages, the groups UUID</summary>
public UUID IMSessionID;
/// <summary>Timestamp of the instant message</summary>
public DateTime Timestamp;
/// <summary>Instant message text</summary>
public string Message;
/// <summary>Whether this message is held for offline avatars</summary>
public InstantMessageOnline Offline;
/// <summary>Context specific packed data</summary>
public byte[] BinaryBucket;
/// <summary>Is this invitation for voice group/conference chat</summary>
public bool Voice;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap dataMap = new OSDMap(3);
dataMap["timestamp"] = OSD.FromDate(Timestamp);
dataMap["type"] = OSD.FromInteger((uint)Dialog);
dataMap["binary_bucket"] = OSD.FromBinary(BinaryBucket);
OSDMap paramsMap = new OSDMap(11);
paramsMap["from_id"] = OSD.FromUUID(FromAgentID);
paramsMap["from_name"] = OSD.FromString(FromAgentName);
paramsMap["to_id"] = OSD.FromUUID(ToAgentID);
paramsMap["parent_estate_id"] = OSD.FromInteger(ParentEstateID);
paramsMap["region_id"] = OSD.FromUUID(RegionID);
paramsMap["position"] = OSD.FromVector3(Position);
paramsMap["from_group"] = OSD.FromBoolean(GroupIM);
paramsMap["id"] = OSD.FromUUID(IMSessionID);
paramsMap["message"] = OSD.FromString(Message);
paramsMap["offline"] = OSD.FromInteger((uint)Offline);
paramsMap["data"] = dataMap;
OSDMap imMap = new OSDMap(1);
imMap["message_params"] = paramsMap;
OSDMap map = new OSDMap(1);
map["instantmessage"] = imMap;
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
if (map.ContainsKey("voice"))
{
FromAgentID = map["from_id"].AsUUID();
FromAgentName = map["from_name"].AsString();
IMSessionID = map["session_id"].AsUUID();
BinaryBucket = Utils.StringToBytes(map["session_name"].AsString());
Voice = true;
}
else
{
OSDMap im = (OSDMap)map["instantmessage"];
OSDMap msg = (OSDMap)im["message_params"];
OSDMap msgdata = (OSDMap)msg["data"];
FromAgentID = msg["from_id"].AsUUID();
FromAgentName = msg["from_name"].AsString();
ToAgentID = msg["to_id"].AsUUID();
ParentEstateID = (uint)msg["parent_estate_id"].AsInteger();
RegionID = msg["region_id"].AsUUID();
Position = msg["position"].AsVector3();
GroupIM = msg["from_group"].AsBoolean();
IMSessionID = msg["id"].AsUUID();
Message = msg["message"].AsString();
Offline = (InstantMessageOnline)msg["offline"].AsInteger();
Dialog = (InstantMessageDialog)msgdata["type"].AsInteger();
BinaryBucket = msgdata["binary_bucket"].AsBinary();
Timestamp = msgdata["timestamp"].AsDate();
Voice = false;
}
}
}
public class RegionInfoMessage : IMessage
{
public int ParcelLocalID;
public string RegionName;
public string ChannelUri;
#region IMessage Members
public OSDMap Serialize()
{
OSDMap map = new OSDMap(3);
map["parcel_local_id"] = OSD.FromInteger(ParcelLocalID);
map["region_name"] = OSD.FromString(RegionName);
OSDMap voiceMap = new OSDMap(1);
voiceMap["channel_uri"] = OSD.FromString(ChannelUri);
map["voice_credentials"] = voiceMap;
return map;
}
public void Deserialize(OSDMap map)
{
this.ParcelLocalID = map["parcel_local_id"].AsInteger();
this.RegionName = map["region_name"].AsString();
OSDMap voiceMap = (OSDMap)map["voice_credentials"];
this.ChannelUri = voiceMap["channel_uri"].AsString();
}
#endregion
}
/// <summary>
/// Sent from the simulator to the viewer.
///
/// When an agent initially joins a session the AgentUpdatesBlock object will contain a list of session members including
/// a boolean indicating they can use voice chat in this session, a boolean indicating they are allowed to moderate
/// this session, and lastly a string which indicates another agent is entering the session with the Transition set to "ENTER"
///
/// During the session lifetime updates on individuals are sent. During the update the booleans sent during the initial join are
/// excluded with the exception of the Transition field. This indicates a new user entering or exiting the session with
/// the string "ENTER" or "LEAVE" respectively.
/// </summary>
public class ChatterBoxSessionAgentListUpdatesMessage : IMessage
{
// initial when agent joins session
// <llsd><map><key>events</key><array><map><key>body</key><map><key>agent_updates</key><map><key>32939971-a520-4b52-8ca5-6085d0e39933</key><map><key>info</key><map><key>can_voice_chat</key><boolean>1</boolean><key>is_moderator</key><boolean>1</boolean></map><key>transition</key><string>ENTER</string></map><key>ca00e3e1-0fdb-4136-8ed4-0aab739b29e8</key><map><key>info</key><map><key>can_voice_chat</key><boolean>1</boolean><key>is_moderator</key><boolean>0</boolean></map><key>transition</key><string>ENTER</string></map></map><key>session_id</key><string>be7a1def-bd8a-5043-5d5b-49e3805adf6b</string><key>updates</key><map><key>32939971-a520-4b52-8ca5-6085d0e39933</key><string>ENTER</string><key>ca00e3e1-0fdb-4136-8ed4-0aab739b29e8</key><string>ENTER</string></map></map><key>message</key><string>ChatterBoxSessionAgentListUpdates</string></map><map><key>body</key><map><key>agent_updates</key><map><key>32939971-a520-4b52-8ca5-6085d0e39933</key><map><key>info</key><map><key>can_voice_chat</key><boolean>1</boolean><key>is_moderator</key><boolean>1</boolean></map></map></map><key>session_id</key><string>be7a1def-bd8a-5043-5d5b-49e3805adf6b</string><key>updates</key><map /></map><key>message</key><string>ChatterBoxSessionAgentListUpdates</string></map></array><key>id</key><integer>5</integer></map></llsd>
// a message containing only moderator updates
// <llsd><map><key>events</key><array><map><key>body</key><map><key>agent_updates</key><map><key>ca00e3e1-0fdb-4136-8ed4-0aab739b29e8</key><map><key>info</key><map><key>mutes</key><map><key>text</key><boolean>1</boolean></map></map></map></map><key>session_id</key><string>be7a1def-bd8a-5043-5d5b-49e3805adf6b</string><key>updates</key><map /></map><key>message</key><string>ChatterBoxSessionAgentListUpdates</string></map></array><key>id</key><integer>7</integer></map></llsd>
public UUID SessionID;
public class AgentUpdatesBlock
{
public UUID AgentID;
public bool CanVoiceChat;
public bool IsModerator;
// transition "transition" = "ENTER" or "LEAVE"
public string Transition; // TODO: switch to an enum "ENTER" or "LEAVE"
public bool MuteText;
public bool MuteVoice;
}
public AgentUpdatesBlock[] Updates;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap();
OSDMap agent_updatesMap = new OSDMap(1);
for (int i = 0; i < Updates.Length; i++)
{
OSDMap mutesMap = new OSDMap(2);
mutesMap["text"] = OSD.FromBoolean(Updates[i].MuteText);
mutesMap["voice"] = OSD.FromBoolean(Updates[i].MuteVoice);
OSDMap infoMap = new OSDMap(4);
infoMap["can_voice_chat"] = OSD.FromBoolean((bool)Updates[i].CanVoiceChat);
infoMap["is_moderator"] = OSD.FromBoolean((bool)Updates[i].IsModerator);
infoMap["mutes"] = mutesMap;
OSDMap imap = new OSDMap(1);
imap["info"] = infoMap;
imap["transition"] = OSD.FromString(Updates[i].Transition);
agent_updatesMap.Add(Updates[i].AgentID.ToString(), imap);
}
map.Add("agent_updates", agent_updatesMap);
map["session_id"] = OSD.FromUUID(SessionID);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
OSDMap agent_updates = (OSDMap)map["agent_updates"];
SessionID = map["session_id"].AsUUID();
List<AgentUpdatesBlock> updatesList = new List<AgentUpdatesBlock>();
foreach (KeyValuePair<string, OSD> kvp in agent_updates)
{
if (kvp.Key == "updates")
{
// This appears to be redundant and duplicated by the info block, more dumps will confirm this
/* <key>32939971-a520-4b52-8ca5-6085d0e39933</key>
<string>ENTER</string> */
}
else if (kvp.Key == "session_id")
{
// I am making the assumption that each osdmap will contain the information for a
// single session. This is how the map appears to read however more dumps should be taken
// to confirm this.
/* <key>session_id</key>
<string>984f6a1e-4ceb-6366-8d5e-a18c6819c6f7</string> */
}
else // key is an agent uuid (we hope!)
{
// should be the agents uuid as the key, and "info" as the datablock
/* <key>32939971-a520-4b52-8ca5-6085d0e39933</key>
<map>
<key>info</key>
<map>
<key>can_voice_chat</key>
<boolean>1</boolean>
<key>is_moderator</key>
<boolean>1</boolean>
</map>
<key>transition</key>
<string>ENTER</string>
</map>*/
AgentUpdatesBlock block = new AgentUpdatesBlock();
block.AgentID = UUID.Parse(kvp.Key);
OSDMap infoMap = (OSDMap)agent_updates[kvp.Key];
OSDMap agentPermsMap = (OSDMap)infoMap["info"];
block.CanVoiceChat = agentPermsMap["can_voice_chat"].AsBoolean();
block.IsModerator = agentPermsMap["is_moderator"].AsBoolean();
block.Transition = infoMap["transition"].AsString();
if (agentPermsMap.ContainsKey("mutes"))
{
OSDMap mutesMap = (OSDMap)agentPermsMap["mutes"];
block.MuteText = mutesMap["text"].AsBoolean();
block.MuteVoice = mutesMap["voice"].AsBoolean();
}
updatesList.Add(block);
}
}
Updates = new AgentUpdatesBlock[updatesList.Count];
for (int i = 0; i < updatesList.Count; i++)
{
AgentUpdatesBlock block = new AgentUpdatesBlock();
block.AgentID = updatesList[i].AgentID;
block.CanVoiceChat = updatesList[i].CanVoiceChat;
block.IsModerator = updatesList[i].IsModerator;
block.MuteText = updatesList[i].MuteText;
block.MuteVoice = updatesList[i].MuteVoice;
block.Transition = updatesList[i].Transition;
Updates[i] = block;
}
}
}
/// <summary>
/// An EventQueue message sent when the agent is forcibly removed from a chatterbox session
/// </summary>
public class ForceCloseChatterBoxSessionMessage : IMessage
{
/// <summary>
/// A string containing the reason the agent was removed
/// </summary>
public string Reason;
/// <summary>
/// The ChatterBoxSession's SessionID
/// </summary>
public UUID SessionID;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(2);
map["reason"] = OSD.FromString(Reason);
map["session_id"] = OSD.FromUUID(SessionID);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
Reason = map["reason"].AsString();
SessionID = map["session_id"].AsUUID();
}
}
#endregion
#region EventQueue
public abstract class EventMessageBlock
{
public abstract OSDMap Serialize();
public abstract void Deserialize(OSDMap map);
}
public class EventQueueAck : EventMessageBlock
{
public int AckID;
public bool Done;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public override OSDMap Serialize()
{
OSDMap map = new OSDMap();
map["ack"] = OSD.FromInteger(AckID);
map["done"] = OSD.FromBoolean(Done);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public override void Deserialize(OSDMap map)
{
AckID = map["ack"].AsInteger();
Done = map["done"].AsBoolean();
}
}
public class EventQueueEvent : EventMessageBlock
{
public class QueueEvent
{
public IMessage EventMessage;
public string MessageKey;
}
public int Sequence;
public QueueEvent[] MessageEvents;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(1);
OSDArray eventsArray = new OSDArray();
for (int i = 0; i < MessageEvents.Length; i++)
{
OSDMap eventMap = new OSDMap(2);
eventMap["body"] = MessageEvents[i].EventMessage.Serialize();
eventMap["message"] = OSD.FromString(MessageEvents[i].MessageKey);
eventsArray.Add(eventMap);
}
map["events"] = eventsArray;
map["id"] = OSD.FromInteger(Sequence);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public override void Deserialize(OSDMap map)
{
Sequence = map["id"].AsInteger();
OSDArray arrayEvents = (OSDArray)map["events"];
MessageEvents = new QueueEvent[arrayEvents.Count];
for (int i = 0; i < arrayEvents.Count; i++)
{
OSDMap eventMap = (OSDMap)arrayEvents[i];
QueueEvent ev = new QueueEvent();
ev.MessageKey = eventMap["message"].AsString();
ev.EventMessage = MessageUtils.DecodeEvent(ev.MessageKey, (OSDMap)eventMap["body"]);
MessageEvents[i] = ev;
}
}
}
public class EventQueueGetMessage : IMessage
{
public EventMessageBlock Messages;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
return Messages.Serialize();
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
if (map.ContainsKey("ack"))
Messages = new EventQueueAck();
else if (map.ContainsKey("events"))
Messages = new EventQueueEvent();
else
Logger.Log("Unable to deserialize EventQueueGetMessage: No message handler exists for event", Helpers.LogLevel.Warning);
Messages.Deserialize(map);
}
}
#endregion
#region Stats Messages
public class ViewerStatsMessage : IMessage
{
public int AgentsInView;
public float AgentFPS;
public string AgentLanguage;
public float AgentMemoryUsed;
public float MetersTraveled;
public float AgentPing;
public int RegionsVisited;
public float AgentRuntime;
public float SimulatorFPS;
public DateTime AgentStartTime;
public string AgentVersion;
public float object_kbytes;
public float texture_kbytes;
public float world_kbytes;
public float MiscVersion;
public bool VertexBuffersEnabled;
public UUID SessionID;
public int StatsDropped;
public int StatsFailedResends;
public int FailuresInvalid;
public int FailuresOffCircuit;
public int FailuresResent;
public int FailuresSendPacket;
public int MiscInt1;
public int MiscInt2;
public string MiscString1;
public int InCompressedPackets;
public float InKbytes;
public float InPackets;
public float InSavings;
public int OutCompressedPackets;
public float OutKbytes;
public float OutPackets;
public float OutSavings;
public string SystemCPU;
public string SystemGPU;
public int SystemGPUClass;
public string SystemGPUVendor;
public string SystemGPUVersion;
public string SystemOS;
public int SystemInstalledRam;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(5);
map["session_id"] = OSD.FromUUID(SessionID);
OSDMap agentMap = new OSDMap(11);
agentMap["agents_in_view"] = OSD.FromInteger(AgentsInView);
agentMap["fps"] = OSD.FromReal(AgentFPS);
agentMap["language"] = OSD.FromString(AgentLanguage);
agentMap["mem_use"] = OSD.FromReal(AgentMemoryUsed);
agentMap["meters_traveled"] = OSD.FromReal(MetersTraveled);
agentMap["ping"] = OSD.FromReal(AgentPing);
agentMap["regions_visited"] = OSD.FromInteger(RegionsVisited);
agentMap["run_time"] = OSD.FromReal(AgentRuntime);
agentMap["sim_fps"] = OSD.FromReal(SimulatorFPS);
agentMap["start_time"] = OSD.FromUInteger(Utils.DateTimeToUnixTime(AgentStartTime));
agentMap["version"] = OSD.FromString(AgentVersion);
map["agent"] = agentMap;
OSDMap downloadsMap = new OSDMap(3); // downloads
downloadsMap["object_kbytes"] = OSD.FromReal(object_kbytes);
downloadsMap["texture_kbytes"] = OSD.FromReal(texture_kbytes);
downloadsMap["world_kbytes"] = OSD.FromReal(world_kbytes);
map["downloads"] = downloadsMap;
OSDMap miscMap = new OSDMap(2);
miscMap["Version"] = OSD.FromReal(MiscVersion);
miscMap["Vertex Buffers Enabled"] = OSD.FromBoolean(VertexBuffersEnabled);
map["misc"] = miscMap;
OSDMap statsMap = new OSDMap(2);
OSDMap failuresMap = new OSDMap(6);
failuresMap["dropped"] = OSD.FromInteger(StatsDropped);
failuresMap["failed_resends"] = OSD.FromInteger(StatsFailedResends);
failuresMap["invalid"] = OSD.FromInteger(FailuresInvalid);
failuresMap["off_circuit"] = OSD.FromInteger(FailuresOffCircuit);
failuresMap["resent"] = OSD.FromInteger(FailuresResent);
failuresMap["send_packet"] = OSD.FromInteger(FailuresSendPacket);
statsMap["failures"] = failuresMap;
OSDMap statsMiscMap = new OSDMap(3);
statsMiscMap["int_1"] = OSD.FromInteger(MiscInt1);
statsMiscMap["int_2"] = OSD.FromInteger(MiscInt2);
statsMiscMap["string_1"] = OSD.FromString(MiscString1);
statsMap["misc"] = statsMiscMap;
OSDMap netMap = new OSDMap(3);
// in
OSDMap netInMap = new OSDMap(4);
netInMap["compressed_packets"] = OSD.FromInteger(InCompressedPackets);
netInMap["kbytes"] = OSD.FromReal(InKbytes);
netInMap["packets"] = OSD.FromReal(InPackets);
netInMap["savings"] = OSD.FromReal(InSavings);
netMap["in"] = netInMap;
// out
OSDMap netOutMap = new OSDMap(4);
netOutMap["compressed_packets"] = OSD.FromInteger(OutCompressedPackets);
netOutMap["kbytes"] = OSD.FromReal(OutKbytes);
netOutMap["packets"] = OSD.FromReal(OutPackets);
netOutMap["savings"] = OSD.FromReal(OutSavings);
netMap["out"] = netOutMap;
statsMap["net"] = netMap;
//system
OSDMap systemStatsMap = new OSDMap(7);
systemStatsMap["cpu"] = OSD.FromString(SystemCPU);
systemStatsMap["gpu"] = OSD.FromString(SystemGPU);
systemStatsMap["gpu_class"] = OSD.FromInteger(SystemGPUClass);
systemStatsMap["gpu_vendor"] = OSD.FromString(SystemGPUVendor);
systemStatsMap["gpu_version"] = OSD.FromString(SystemGPUVersion);
systemStatsMap["os"] = OSD.FromString(SystemOS);
systemStatsMap["ram"] = OSD.FromInteger(SystemInstalledRam);
map["system"] = systemStatsMap;
map["stats"] = statsMap;
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
SessionID = map["session_id"].AsUUID();
OSDMap agentMap = (OSDMap)map["agent"];
AgentsInView = agentMap["agents_in_view"].AsInteger();
AgentFPS = (float)agentMap["fps"].AsReal();
AgentLanguage = agentMap["language"].AsString();
AgentMemoryUsed = (float)agentMap["mem_use"].AsReal();
MetersTraveled = agentMap["meters_traveled"].AsInteger();
AgentPing = (float)agentMap["ping"].AsReal();
RegionsVisited = agentMap["regions_visited"].AsInteger();
AgentRuntime = (float)agentMap["run_time"].AsReal();
SimulatorFPS = (float)agentMap["sim_fps"].AsReal();
AgentStartTime = Utils.UnixTimeToDateTime(agentMap["start_time"].AsUInteger());
AgentVersion = agentMap["version"].AsString();
OSDMap downloadsMap = (OSDMap)map["downloads"];
object_kbytes = (float)downloadsMap["object_kbytes"].AsReal();
texture_kbytes = (float)downloadsMap["texture_kbytes"].AsReal();
world_kbytes = (float)downloadsMap["world_kbytes"].AsReal();
OSDMap miscMap = (OSDMap)map["misc"];
MiscVersion = (float)miscMap["Version"].AsReal();
VertexBuffersEnabled = miscMap["Vertex Buffers Enabled"].AsBoolean();
OSDMap statsMap = (OSDMap)map["stats"];
OSDMap failuresMap = (OSDMap)statsMap["failures"];
StatsDropped = failuresMap["dropped"].AsInteger();
StatsFailedResends = failuresMap["failed_resends"].AsInteger();
FailuresInvalid = failuresMap["invalid"].AsInteger();
FailuresOffCircuit = failuresMap["off_circuit"].AsInteger();
FailuresResent = failuresMap["resent"].AsInteger();
FailuresSendPacket = failuresMap["send_packet"].AsInteger();
OSDMap statsMiscMap = (OSDMap)statsMap["misc"];
MiscInt1 = statsMiscMap["int_1"].AsInteger();
MiscInt2 = statsMiscMap["int_2"].AsInteger();
MiscString1 = statsMiscMap["string_1"].AsString();
OSDMap netMap = (OSDMap)statsMap["net"];
// in
OSDMap netInMap = (OSDMap)netMap["in"];
InCompressedPackets = netInMap["compressed_packets"].AsInteger();
InKbytes = netInMap["kbytes"].AsInteger();
InPackets = netInMap["packets"].AsInteger();
InSavings = netInMap["savings"].AsInteger();
// out
OSDMap netOutMap = (OSDMap)netMap["out"];
OutCompressedPackets = netOutMap["compressed_packets"].AsInteger();
OutKbytes = netOutMap["kbytes"].AsInteger();
OutPackets = netOutMap["packets"].AsInteger();
OutSavings = netOutMap["savings"].AsInteger();
//system
OSDMap systemStatsMap = (OSDMap)map["system"];
SystemCPU = systemStatsMap["cpu"].AsString();
SystemGPU = systemStatsMap["gpu"].AsString();
SystemGPUClass = systemStatsMap["gpu_class"].AsInteger();
SystemGPUVendor = systemStatsMap["gpu_vendor"].AsString();
SystemGPUVersion = systemStatsMap["gpu_version"].AsString();
SystemOS = systemStatsMap["os"].AsString();
SystemInstalledRam = systemStatsMap["ram"].AsInteger();
}
}
/// <summary>
///
/// </summary>
public class PlacesReplyMessage : IMessage
{
public UUID AgentID;
public UUID QueryID;
public UUID TransactionID;
public class QueryData
{
public int ActualArea;
public int BillableArea;
public string Description;
public float Dwell;
public int Flags;
public float GlobalX;
public float GlobalY;
public float GlobalZ;
public string Name;
public UUID OwnerID;
public string SimName;
public UUID SnapShotID;
public string ProductSku;
public int Price;
}
public QueryData[] QueryDataBlocks;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(3);
// add the AgentData map
OSDMap agentIDmap = new OSDMap(2);
agentIDmap["AgentID"] = OSD.FromUUID(AgentID);
agentIDmap["QueryID"] = OSD.FromUUID(QueryID);
OSDArray agentDataArray = new OSDArray();
agentDataArray.Add(agentIDmap);
map["AgentData"] = agentDataArray;
// add the QueryData map
OSDArray dataBlocksArray = new OSDArray(QueryDataBlocks.Length);
for (int i = 0; i < QueryDataBlocks.Length; i++)
{
OSDMap queryDataMap = new OSDMap(14);
queryDataMap["ActualArea"] = OSD.FromInteger(QueryDataBlocks[i].ActualArea);
queryDataMap["BillableArea"] = OSD.FromInteger(QueryDataBlocks[i].BillableArea);
queryDataMap["Desc"] = OSD.FromString(QueryDataBlocks[i].Description);
queryDataMap["Dwell"] = OSD.FromReal(QueryDataBlocks[i].Dwell);
queryDataMap["Flags"] = OSD.FromInteger(QueryDataBlocks[i].Flags);
queryDataMap["GlobalX"] = OSD.FromReal(QueryDataBlocks[i].GlobalX);
queryDataMap["GlobalY"] = OSD.FromReal(QueryDataBlocks[i].GlobalY);
queryDataMap["GlobalZ"] = OSD.FromReal(QueryDataBlocks[i].GlobalZ);
queryDataMap["Name"] = OSD.FromString(QueryDataBlocks[i].Name);
queryDataMap["OwnerID"] = OSD.FromUUID(QueryDataBlocks[i].OwnerID);
queryDataMap["Price"] = OSD.FromInteger(QueryDataBlocks[i].Price);
queryDataMap["SimName"] = OSD.FromString(QueryDataBlocks[i].SimName);
queryDataMap["SnapshotID"] = OSD.FromUUID(QueryDataBlocks[i].SnapShotID);
queryDataMap["ProductSKU"] = OSD.FromString(QueryDataBlocks[i].ProductSku);
dataBlocksArray.Add(queryDataMap);
}
map["QueryData"] = dataBlocksArray;
// add the TransactionData map
OSDMap transMap = new OSDMap(1);
transMap["TransactionID"] = OSD.FromUUID(TransactionID);
OSDArray transArray = new OSDArray();
transArray.Add(transMap);
map["TransactionData"] = transArray;
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
OSDArray agentDataArray = (OSDArray)map["AgentData"];
OSDMap agentDataMap = (OSDMap)agentDataArray[0];
AgentID = agentDataMap["AgentID"].AsUUID();
QueryID = agentDataMap["QueryID"].AsUUID();
OSDArray dataBlocksArray = (OSDArray)map["QueryData"];
QueryDataBlocks = new QueryData[dataBlocksArray.Count];
for (int i = 0; i < dataBlocksArray.Count; i++)
{
OSDMap dataMap = (OSDMap)dataBlocksArray[i];
QueryData data = new QueryData();
data.ActualArea = dataMap["ActualArea"].AsInteger();
data.BillableArea = dataMap["BillableArea"].AsInteger();
data.Description = dataMap["Desc"].AsString();
data.Dwell = (float)dataMap["Dwell"].AsReal();
data.Flags = dataMap["Flags"].AsInteger();
data.GlobalX = (float)dataMap["GlobalX"].AsReal();
data.GlobalY = (float)dataMap["GlobalY"].AsReal();
data.GlobalZ = (float)dataMap["GlobalZ"].AsReal();
data.Name = dataMap["Name"].AsString();
data.OwnerID = dataMap["OwnerID"].AsUUID();
data.Price = dataMap["Price"].AsInteger();
data.SimName = dataMap["SimName"].AsString();
data.SnapShotID = dataMap["SnapshotID"].AsUUID();
data.ProductSku = dataMap["ProductSKU"].AsString();
QueryDataBlocks[i] = data;
}
OSDArray transactionArray = (OSDArray)map["TransactionData"];
OSDMap transactionDataMap = (OSDMap)transactionArray[0];
TransactionID = transactionDataMap["TransactionID"].AsUUID();
}
}
public class UpdateAgentInformationMessage : IMessage
{
public string MaxAccess; // PG, A, or M
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(1);
OSDMap prefsMap = new OSDMap(1);
prefsMap["max"] = OSD.FromString(MaxAccess);
map["access_prefs"] = prefsMap;
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
OSDMap prefsMap = (OSDMap)map["access_prefs"];
MaxAccess = prefsMap["max"].AsString();
}
}
[Serializable]
public class DirLandReplyMessage : IMessage
{
public UUID AgentID;
public UUID QueryID;
[Serializable]
public class QueryReply
{
public int ActualArea;
public bool Auction;
public bool ForSale;
public string Name;
public UUID ParcelID;
public string ProductSku;
public int SalePrice;
}
public QueryReply[] QueryReplies;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(3);
OSDMap agentMap = new OSDMap(1);
agentMap["AgentID"] = OSD.FromUUID(AgentID);
OSDArray agentDataArray = new OSDArray(1);
agentDataArray.Add(agentMap);
map["AgentData"] = agentDataArray;
OSDMap queryMap = new OSDMap(1);
queryMap["QueryID"] = OSD.FromUUID(QueryID);
OSDArray queryDataArray = new OSDArray(1);
queryDataArray.Add(queryMap);
map["QueryData"] = queryDataArray;
OSDArray queryReplyArray = new OSDArray();
for (int i = 0; i < QueryReplies.Length; i++)
{
OSDMap queryReply = new OSDMap(100);
queryReply["ActualArea"] = OSD.FromInteger(QueryReplies[i].ActualArea);
queryReply["Auction"] = OSD.FromBoolean(QueryReplies[i].Auction);
queryReply["ForSale"] = OSD.FromBoolean(QueryReplies[i].ForSale);
queryReply["Name"] = OSD.FromString(QueryReplies[i].Name);
queryReply["ParcelID"] = OSD.FromUUID(QueryReplies[i].ParcelID);
queryReply["ProductSKU"] = OSD.FromString(QueryReplies[i].ProductSku);
queryReply["SalePrice"] = OSD.FromInteger(QueryReplies[i].SalePrice);
queryReplyArray.Add(queryReply);
}
map["QueryReplies"] = queryReplyArray;
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
OSDArray agentDataArray = (OSDArray)map["AgentData"];
OSDMap agentDataMap = (OSDMap)agentDataArray[0];
AgentID = agentDataMap["AgentID"].AsUUID();
OSDArray queryDataArray = (OSDArray)map["QueryData"];
OSDMap queryDataMap = (OSDMap)queryDataArray[0];
QueryID = queryDataMap["QueryID"].AsUUID();
OSDArray queryRepliesArray = (OSDArray)map["QueryReplies"];
QueryReplies = new QueryReply[queryRepliesArray.Count];
for (int i = 0; i < queryRepliesArray.Count; i++)
{
QueryReply reply = new QueryReply();
OSDMap replyMap = (OSDMap)queryRepliesArray[i];
reply.ActualArea = replyMap["ActualArea"].AsInteger();
reply.Auction = replyMap["Auction"].AsBoolean();
reply.ForSale = replyMap["ForSale"].AsBoolean();
reply.Name = replyMap["Name"].AsString();
reply.ParcelID = replyMap["ParcelID"].AsUUID();
reply.ProductSku = replyMap["ProductSKU"].AsString();
reply.SalePrice = replyMap["SalePrice"].AsInteger();
QueryReplies[i] = reply;
}
}
}
#endregion
#region Object Messages
public class UploadObjectAssetMessage : IMessage
{
public class Object
{
public class Face
{
public Bumpiness Bump;
public Color4 Color;
public bool Fullbright;
public float Glow;
public UUID ImageID;
public float ImageRot;
public int MediaFlags;
public float OffsetS;
public float OffsetT;
public float ScaleS;
public float ScaleT;
public OSDMap Serialize()
{
OSDMap map = new OSDMap();
map["bump"] = OSD.FromInteger((int)Bump);
map["colors"] = OSD.FromColor4(Color);
map["fullbright"] = OSD.FromBoolean(Fullbright);
map["glow"] = OSD.FromReal(Glow);
map["imageid"] = OSD.FromUUID(ImageID);
map["imagerot"] = OSD.FromReal(ImageRot);
map["media_flags"] = OSD.FromInteger(MediaFlags);
map["offsets"] = OSD.FromReal(OffsetS);
map["offsett"] = OSD.FromReal(OffsetT);
map["scales"] = OSD.FromReal(ScaleS);
map["scalet"] = OSD.FromReal(ScaleT);
return map;
}
public void Deserialize(OSDMap map)
{
Bump = (Bumpiness)map["bump"].AsInteger();
Color = map["colors"].AsColor4();
Fullbright = map["fullbright"].AsBoolean();
Glow = (float)map["glow"].AsReal();
ImageID = map["imageid"].AsUUID();
ImageRot = (float)map["imagerot"].AsReal();
MediaFlags = map["media_flags"].AsInteger();
OffsetS = (float)map["offsets"].AsReal();
OffsetT = (float)map["offsett"].AsReal();
ScaleS = (float)map["scales"].AsReal();
ScaleT = (float)map["scalet"].AsReal();
}
}
public class ExtraParam
{
public ExtraParamType Type;
public byte[] ExtraParamData;
public OSDMap Serialize()
{
OSDMap map = new OSDMap();
map["extra_parameter"] = OSD.FromInteger((int)Type);
map["param_data"] = OSD.FromBinary(ExtraParamData);
return map;
}
public void Deserialize(OSDMap map)
{
Type = (ExtraParamType)map["extra_parameter"].AsInteger();
ExtraParamData = map["param_data"].AsBinary();
}
}
public Face[] Faces;
public ExtraParam[] ExtraParams;
public UUID GroupID;
public Material Material;
public string Name;
public Vector3 Position;
public Quaternion Rotation;
public Vector3 Scale;
public float PathBegin;
public int PathCurve;
public float PathEnd;
public float RadiusOffset;
public float Revolutions;
public float ScaleX;
public float ScaleY;
public float ShearX;
public float ShearY;
public float Skew;
public float TaperX;
public float TaperY;
public float Twist;
public float TwistBegin;
public float ProfileBegin;
public int ProfileCurve;
public float ProfileEnd;
public float ProfileHollow;
public UUID SculptID;
public SculptType SculptType;
public OSDMap Serialize()
{
OSDMap map = new OSDMap();
map["group-id"] = OSD.FromUUID(GroupID);
map["material"] = OSD.FromInteger((int)Material);
map["name"] = OSD.FromString(Name);
map["pos"] = OSD.FromVector3(Position);
map["rotation"] = OSD.FromQuaternion(Rotation);
map["scale"] = OSD.FromVector3(Scale);
// Extra params
OSDArray extraParams = new OSDArray();
if (ExtraParams != null)
{
for (int i = 0; i < ExtraParams.Length; i++)
extraParams.Add(ExtraParams[i].Serialize());
}
map["extra_parameters"] = extraParams;
// Faces
OSDArray faces = new OSDArray();
if (Faces != null)
{
for (int i = 0; i < Faces.Length; i++)
faces.Add(Faces[i].Serialize());
}
map["facelist"] = faces;
// Shape
OSDMap shape = new OSDMap();
OSDMap path = new OSDMap();
path["begin"] = OSD.FromReal(PathBegin);
path["curve"] = OSD.FromInteger(PathCurve);
path["end"] = OSD.FromReal(PathEnd);
path["radius_offset"] = OSD.FromReal(RadiusOffset);
path["revolutions"] = OSD.FromReal(Revolutions);
path["scale_x"] = OSD.FromReal(ScaleX);
path["scale_y"] = OSD.FromReal(ScaleY);
path["shear_x"] = OSD.FromReal(ShearX);
path["shear_y"] = OSD.FromReal(ShearY);
path["skew"] = OSD.FromReal(Skew);
path["taper_x"] = OSD.FromReal(TaperX);
path["taper_y"] = OSD.FromReal(TaperY);
path["twist"] = OSD.FromReal(Twist);
path["twist_begin"] = OSD.FromReal(TwistBegin);
shape["path"] = path;
OSDMap profile = new OSDMap();
profile["begin"] = OSD.FromReal(ProfileBegin);
profile["curve"] = OSD.FromInteger(ProfileCurve);
profile["end"] = OSD.FromReal(ProfileEnd);
profile["hollow"] = OSD.FromReal(ProfileHollow);
shape["profile"] = profile;
OSDMap sculpt = new OSDMap();
sculpt["id"] = OSD.FromUUID(SculptID);
sculpt["type"] = OSD.FromInteger((int)SculptType);
shape["sculpt"] = sculpt;
map["shape"] = shape;
return map;
}
public void Deserialize(OSDMap map)
{
GroupID = map["group-id"].AsUUID();
Material = (Material)map["material"].AsInteger();
Name = map["name"].AsString();
Position = map["pos"].AsVector3();
Rotation = map["rotation"].AsQuaternion();
Scale = map["scale"].AsVector3();
// Extra params
OSDArray extraParams = map["extra_parameters"] as OSDArray;
if (extraParams != null)
{
ExtraParams = new ExtraParam[extraParams.Count];
for (int i = 0; i < extraParams.Count; i++)
{
ExtraParam extraParam = new ExtraParam();
extraParam.Deserialize(extraParams[i] as OSDMap);
ExtraParams[i] = extraParam;
}
}
else
{
ExtraParams = new ExtraParam[0];
}
// Faces
OSDArray faces = map["facelist"] as OSDArray;
if (faces != null)
{
Faces = new Face[faces.Count];
for (int i = 0; i < faces.Count; i++)
{
Face face = new Face();
face.Deserialize(faces[i] as OSDMap);
Faces[i] = face;
}
}
else
{
Faces = new Face[0];
}
// Shape
OSDMap shape = map["shape"] as OSDMap;
OSDMap path = shape["path"] as OSDMap;
PathBegin = (float)path["begin"].AsReal();
PathCurve = path["curve"].AsInteger();
PathEnd = (float)path["end"].AsReal();
RadiusOffset = (float)path["radius_offset"].AsReal();
Revolutions = (float)path["revolutions"].AsReal();
ScaleX = (float)path["scale_x"].AsReal();
ScaleY = (float)path["scale_y"].AsReal();
ShearX = (float)path["shear_x"].AsReal();
ShearY = (float)path["shear_y"].AsReal();
Skew = (float)path["skew"].AsReal();
TaperX = (float)path["taper_x"].AsReal();
TaperY = (float)path["taper_y"].AsReal();
Twist = (float)path["twist"].AsReal();
TwistBegin = (float)path["twist_begin"].AsReal();
OSDMap profile = shape["profile"] as OSDMap;
ProfileBegin = (float)profile["begin"].AsReal();
ProfileCurve = profile["curve"].AsInteger();
ProfileEnd = (float)profile["end"].AsReal();
ProfileHollow = (float)profile["hollow"].AsReal();
OSDMap sculpt = shape["sculpt"] as OSDMap;
if (sculpt != null)
{
SculptID = sculpt["id"].AsUUID();
SculptType = (SculptType)sculpt["type"].AsInteger();
}
else
{
SculptID = UUID.Zero;
SculptType = 0;
}
}
}
public Object[] Objects;
public OSDMap Serialize()
{
OSDMap map = new OSDMap();
OSDArray array = new OSDArray();
if (Objects != null)
{
for (int i = 0; i < Objects.Length; i++)
array.Add(Objects[i].Serialize());
}
map["objects"] = array;
return map;
}
public void Deserialize(OSDMap map)
{
OSDArray array = map["objects"] as OSDArray;
if (array != null)
{
Objects = new Object[array.Count];
for (int i = 0; i < array.Count; i++)
{
Object obj = new Object();
OSDMap objMap = array[i] as OSDMap;
if (objMap != null)
obj.Deserialize(objMap);
Objects[i] = obj;
}
}
else
{
Objects = new Object[0];
}
}
}
/// <summary>
/// Event Queue message describing physics engine attributes of a list of objects
/// Sim sends these when object is selected
/// </summary>
public class ObjectPhysicsPropertiesMessage : IMessage
{
/// <summary> Array with the list of physics properties</summary>
public Primitive.PhysicsProperties[] ObjectPhysicsProperties;
/// <summary>
/// Serializes the message
/// </summary>
/// <returns>Serialized OSD</returns>
public OSDMap Serialize()
{
OSDMap ret = new OSDMap();
OSDArray array = new OSDArray();
for (int i = 0; i < ObjectPhysicsProperties.Length; i++)
{
array.Add(ObjectPhysicsProperties[i].GetOSD());
}
ret["ObjectData"] = array;
return ret;
}
/// <summary>
/// Deserializes the message
/// </summary>
/// <param name="map">Incoming data to deserialize</param>
public void Deserialize(OSDMap map)
{
OSDArray array = map["ObjectData"] as OSDArray;
if (array != null)
{
ObjectPhysicsProperties = new Primitive.PhysicsProperties[array.Count];
for (int i = 0; i < array.Count; i++)
{
ObjectPhysicsProperties[i] = Primitive.PhysicsProperties.FromOSD(array[i]);
}
}
else
{
ObjectPhysicsProperties = new Primitive.PhysicsProperties[0];
}
}
}
public class RenderMaterialsMessage : IMessage
{
public OSD MaterialData;
/// <summary>
/// Deserializes the message
/// </summary>
/// <param name="map">Incoming data to deserialize</param>
public void Deserialize(OSDMap map)
{
try
{
using (MemoryStream input = new MemoryStream(map["Zipped"].AsBinary()))
{
using (MemoryStream output = new MemoryStream())
{
using (ZOutputStream zout = new ZOutputStream(output))
{
byte[] buffer = new byte[2048];
int len;
while ((len = input.Read(buffer, 0, buffer.Length)) > 0)
{
zout.Write(buffer, 0, len);
}
zout.Flush();
output.Seek(0, SeekOrigin.Begin);
MaterialData = OSDParser.DeserializeLLSDBinary(output);
}
}
}
}
catch (Exception ex)
{
Logger.Log("Failed to decode RenderMaterials message:", Helpers.LogLevel.Warning, ex);
MaterialData = new OSDMap();
}
}
/// <summary>
/// Serializes the message
/// </summary>
/// <returns>Serialized OSD</returns>
public OSDMap Serialize()
{
return new OSDMap();
}
}
public class GetObjectCostRequest : IMessage
{
/// <summary> Object IDs for which to request cost information
public UUID[] ObjectIDs;
/// <summary>
/// Deserializes the message
/// </summary>
/// <param name="map">Incoming data to deserialize</param>
public void Deserialize(OSDMap map)
{
OSDArray array = map["object_ids"] as OSDArray;
if (array != null)
{
ObjectIDs = new UUID[array.Count];
for (int i = 0; i < array.Count; i++)
{
ObjectIDs[i] = array[i].AsUUID();
}
}
else
{
ObjectIDs = new UUID[0];
}
}
/// <summary>
/// Serializes the message
/// </summary>
/// <returns>Serialized OSD</returns>
public OSDMap Serialize()
{
OSDMap ret = new OSDMap();
OSDArray array = new OSDArray();
for (int i = 0; i < ObjectIDs.Length; i++)
{
array.Add(OSD.FromUUID(ObjectIDs[i]));
}
ret["object_ids"] = array;
return ret;
}
}
public class GetObjectCostMessage : IMessage
{
public UUID object_id;
public double link_cost;
public double object_cost;
public double physics_cost;
public double link_physics_cost;
/// <summary>
/// Deserializes the message
/// </summary>
/// <param name="map">Incoming data to deserialize</param>
public void Deserialize(OSDMap map)
{
if (map.Count != 1)
Logger.Log("GetObjectCostMessage returned values for more than one object! Function needs to be fixed for that!", Helpers.LogLevel.Error);
foreach (string key in map.Keys)
{
UUID.TryParse(key, out object_id);
OSDMap values = (OSDMap)map[key];
link_cost = values["linked_set_resource_cost"].AsReal();
object_cost = values["resource_cost"].AsReal();
physics_cost = values["physics_cost"].AsReal();
link_physics_cost = values["linked_set_physics_cost"].AsReal();
// value["resource_limiting_type"].AsString();
return;
}
}
/// <summary>
/// Serializes the message
/// </summary>
/// <returns>Serialized OSD</returns>
public OSDMap Serialize()
{
OSDMap values = new OSDMap(4);
values.Add("linked_set_resource_cost", OSD.FromReal(link_cost));
values.Add("resource_cost", OSD.FromReal(object_cost));
values.Add("physics_cost", OSD.FromReal(physics_cost));
values.Add("linked_set_physics_cost", OSD.FromReal(link_physics_cost));
OSDMap map = new OSDMap(1);
map.Add(OSD.FromUUID(object_id), values);
return map;
}
/// <summary>
/// Detects which class handles deserialization of this message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
/// <returns>Object capable of decoding this message</returns>
public static IMessage GetMessageHandler(OSDMap map)
{
if (map == null)
{
return null;
}
else if (map.ContainsKey("object_ids"))
{
return new GetObjectCostRequest();
}
else
{
return new GetObjectCostMessage();
}
}
}
#endregion Object Messages
#region Object Media Messages
/// <summary>
/// A message sent from the viewer to the simulator which
/// specifies that the user has changed current URL
/// of the specific media on a prim face
/// </summary>
public class ObjectMediaNavigateMessage : IMessage
{
/// <summary>
/// New URL
/// </summary>
public string URL;
/// <summary>
/// Prim UUID where navigation occured
/// </summary>
public UUID PrimID;
/// <summary>
/// Face index
/// </summary>
public int Face;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(3);
map["current_url"] = OSD.FromString(URL);
map["object_id"] = OSD.FromUUID(PrimID);
map["texture_index"] = OSD.FromInteger(Face);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
URL = map["current_url"].AsString();
PrimID = map["object_id"].AsUUID();
Face = map["texture_index"].AsInteger();
}
}
/// <summary>Base class used for the ObjectMedia message</summary>
[Serializable]
public abstract class ObjectMediaBlock
{
public abstract OSDMap Serialize();
public abstract void Deserialize(OSDMap map);
}
/// <summary>
/// Message used to retrive prim media data
/// </summary>
public class ObjectMediaRequest : ObjectMediaBlock
{
/// <summary>
/// Prim UUID
/// </summary>
public UUID PrimID;
/// <summary>
/// Requested operation, either GET or UPDATE
/// </summary>
public string Verb = "GET"; // "GET" or "UPDATE"
/// <summary>
/// Serialize object
/// </summary>
/// <returns>Serialized object as OSDMap</returns>
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(2);
map["object_id"] = OSD.FromUUID(PrimID);
map["verb"] = OSD.FromString(Verb);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public override void Deserialize(OSDMap map)
{
PrimID = map["object_id"].AsUUID();
Verb = map["verb"].AsString();
}
}
/// <summary>
/// Message used to update prim media data
/// </summary>
public class ObjectMediaResponse : ObjectMediaBlock
{
/// <summary>
/// Prim UUID
/// </summary>
public UUID PrimID;
/// <summary>
/// Array of media entries indexed by face number
/// </summary>
public MediaEntry[] FaceMedia;
/// <summary>
/// Media version string
/// </summary>
public string Version; // String in this format: x-mv:0000000016/00000000-0000-0000-0000-000000000000
/// <summary>
/// Serialize object
/// </summary>
/// <returns>Serialized object as OSDMap</returns>
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(2);
map["object_id"] = OSD.FromUUID(PrimID);
if (FaceMedia == null)
{
map["object_media_data"] = new OSDArray();
}
else
{
OSDArray mediaData = new OSDArray(FaceMedia.Length);
for (int i = 0; i < FaceMedia.Length; i++)
{
if (FaceMedia[i] == null)
mediaData.Add(new OSD());
else
mediaData.Add(FaceMedia[i].GetOSD());
}
map["object_media_data"] = mediaData;
}
map["object_media_version"] = OSD.FromString(Version);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public override void Deserialize(OSDMap map)
{
PrimID = map["object_id"].AsUUID();
if (map["object_media_data"].Type == OSDType.Array)
{
OSDArray mediaData = (OSDArray)map["object_media_data"];
if (mediaData.Count > 0)
{
FaceMedia = new MediaEntry[mediaData.Count];
for (int i = 0; i < mediaData.Count; i++)
{
if (mediaData[i].Type == OSDType.Map)
{
FaceMedia[i] = MediaEntry.FromOSD(mediaData[i]);
}
}
}
}
Version = map["object_media_version"].AsString();
}
}
/// <summary>
/// Message used to update prim media data
/// </summary>
public class ObjectMediaUpdate : ObjectMediaBlock
{
/// <summary>
/// Prim UUID
/// </summary>
public UUID PrimID;
/// <summary>
/// Array of media entries indexed by face number
/// </summary>
public MediaEntry[] FaceMedia;
/// <summary>
/// Requested operation, either GET or UPDATE
/// </summary>
public string Verb = "UPDATE"; // "GET" or "UPDATE"
/// <summary>
/// Serialize object
/// </summary>
/// <returns>Serialized object as OSDMap</returns>
public override OSDMap Serialize()
{
OSDMap map = new OSDMap(2);
map["object_id"] = OSD.FromUUID(PrimID);
if (FaceMedia == null)
{
map["object_media_data"] = new OSDArray();
}
else
{
OSDArray mediaData = new OSDArray(FaceMedia.Length);
for (int i = 0; i < FaceMedia.Length; i++)
{
if (FaceMedia[i] == null)
mediaData.Add(new OSD());
else
mediaData.Add(FaceMedia[i].GetOSD());
}
map["object_media_data"] = mediaData;
}
map["verb"] = OSD.FromString(Verb);
return map;
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public override void Deserialize(OSDMap map)
{
PrimID = map["object_id"].AsUUID();
if (map["object_media_data"].Type == OSDType.Array)
{
OSDArray mediaData = (OSDArray)map["object_media_data"];
if (mediaData.Count > 0)
{
FaceMedia = new MediaEntry[mediaData.Count];
for (int i = 0; i < mediaData.Count; i++)
{
if (mediaData[i].Type == OSDType.Map)
{
FaceMedia[i] = MediaEntry.FromOSD(mediaData[i]);
}
}
}
}
Verb = map["verb"].AsString();
}
}
/// <summary>
/// Message for setting or getting per face MediaEntry
/// </summary>
[Serializable]
public class ObjectMediaMessage : IMessage
{
/// <summary>The request or response details block</summary>
public ObjectMediaBlock Request;
/// <summary>
/// Serialize the object
/// </summary>
/// <returns>An <see cref="OSDMap"/> containing the objects data</returns>
public OSDMap Serialize()
{
return Request.Serialize();
}
/// <summary>
/// Deserialize the message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
if (map.ContainsKey("verb"))
{
if (map["verb"].AsString() == "GET")
Request = new ObjectMediaRequest();
else if (map["verb"].AsString() == "UPDATE")
Request = new ObjectMediaUpdate();
}
else if (map.ContainsKey("object_media_version"))
Request = new ObjectMediaResponse();
else
Logger.Log("Unable to deserialize ObjectMedia: No message handler exists for method: " + map.AsString(), Helpers.LogLevel.Warning);
if (Request != null)
Request.Deserialize(map);
}
}
#endregion Object Media Messages
#region Resource usage
/// <summary>Details about object resource usage</summary>
public class ObjectResourcesDetail
{
/// <summary>Object UUID</summary>
public UUID ID;
/// <summary>Object name</summary>
public string Name;
/// <summary>Indicates if object is group owned</summary>
public bool GroupOwned;
/// <summary>Locatio of the object</summary>
public Vector3d Location;
/// <summary>Object owner</summary>
public UUID OwnerID;
/// <summary>Resource usage, keys are resource names, values are resource usage for that specific resource</summary>
public Dictionary<string, int> Resources;
/// <summary>
/// Deserializes object from OSD
/// </summary>
/// <param name="obj">An <see cref="OSDMap"/> containing the data</param>
public virtual void Deserialize(OSDMap obj)
{
ID = obj["id"].AsUUID();
Name = obj["name"].AsString();
Location = obj["location"].AsVector3d();
GroupOwned = obj["is_group_owned"].AsBoolean();
OwnerID = obj["owner_id"].AsUUID();
OSDMap resources = (OSDMap)obj["resources"];
Resources = new Dictionary<string, int>(resources.Keys.Count);
foreach (KeyValuePair<string, OSD> kvp in resources)
{
Resources.Add(kvp.Key, kvp.Value.AsInteger());
}
}
/// <summary>
/// Makes an instance based on deserialized data
/// </summary>
/// <param name="osd"><see cref="OSD"/> serialized data</param>
/// <returns>Instance containg deserialized data</returns>
public static ObjectResourcesDetail FromOSD(OSD osd)
{
ObjectResourcesDetail res = new ObjectResourcesDetail();
res.Deserialize((OSDMap)osd);
return res;
}
}
/// <summary>Details about parcel resource usage</summary>
public class ParcelResourcesDetail
{
/// <summary>Parcel UUID</summary>
public UUID ID;
/// <summary>Parcel local ID</summary>
public int LocalID;
/// <summary>Parcel name</summary>
public string Name;
/// <summary>Indicates if parcel is group owned</summary>
public bool GroupOwned;
/// <summary>Parcel owner</summary>
public UUID OwnerID;
/// <summary>Array of <see cref="ObjectResourcesDetail"/> containing per object resource usage</summary>
public ObjectResourcesDetail[] Objects;
/// <summary>
/// Deserializes object from OSD
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public virtual void Deserialize(OSDMap map)
{
ID = map["id"].AsUUID();
LocalID = map["local_id"].AsInteger();
Name = map["name"].AsString();
GroupOwned = map["is_group_owned"].AsBoolean();
OwnerID = map["owner_id"].AsUUID();
OSDArray objectsOSD = (OSDArray)map["objects"];
Objects = new ObjectResourcesDetail[objectsOSD.Count];
for (int i = 0; i < objectsOSD.Count; i++)
{
Objects[i] = ObjectResourcesDetail.FromOSD(objectsOSD[i]);
}
}
/// <summary>
/// Makes an instance based on deserialized data
/// </summary>
/// <param name="osd"><see cref="OSD"/> serialized data</param>
/// <returns>Instance containg deserialized data</returns>
public static ParcelResourcesDetail FromOSD(OSD osd)
{
ParcelResourcesDetail res = new ParcelResourcesDetail();
res.Deserialize((OSDMap)osd);
return res;
}
}
/// <summary>Resource usage base class, both agent and parcel resource
/// usage contains summary information</summary>
public abstract class BaseResourcesInfo : IMessage
{
/// <summary>Summary of available resources, keys are resource names,
/// values are resource usage for that specific resource</summary>
public Dictionary<string, int> SummaryAvailable;
/// <summary>Summary resource usage, keys are resource names,
/// values are resource usage for that specific resource</summary>
public Dictionary<string, int> SummaryUsed;
/// <summary>
/// Serializes object
/// </summary>
/// <returns><see cref="OSDMap"/> serialized data</returns>
public virtual OSDMap Serialize()
{
throw new NotImplementedException();
}
/// <summary>
/// Deserializes object from OSD
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public virtual void Deserialize(OSDMap map)
{
SummaryAvailable = new Dictionary<string, int>();
SummaryUsed = new Dictionary<string, int>();
OSDMap summary = (OSDMap)map["summary"];
OSDArray available = (OSDArray)summary["available"];
OSDArray used = (OSDArray)summary["used"];
for (int i = 0; i < available.Count; i++)
{
OSDMap limit = (OSDMap)available[i];
SummaryAvailable.Add(limit["type"].AsString(), limit["amount"].AsInteger());
}
for (int i = 0; i < used.Count; i++)
{
OSDMap limit = (OSDMap)used[i];
SummaryUsed.Add(limit["type"].AsString(), limit["amount"].AsInteger());
}
}
}
/// <summary>Agent resource usage</summary>
public class AttachmentResourcesMessage : BaseResourcesInfo
{
/// <summary>Per attachment point object resource usage</summary>
public Dictionary<AttachmentPoint, ObjectResourcesDetail[]> Attachments;
/// <summary>
/// Deserializes object from OSD
/// </summary>
/// <param name="osd">An <see cref="OSDMap"/> containing the data</param>
public override void Deserialize(OSDMap osd)
{
base.Deserialize(osd);
OSDArray attachments = (OSDArray)((OSDMap)osd)["attachments"];
Attachments = new Dictionary<AttachmentPoint, ObjectResourcesDetail[]>();
for (int i = 0; i < attachments.Count; i++)
{
OSDMap attachment = (OSDMap)attachments[i];
AttachmentPoint pt = Utils.StringToAttachmentPoint(attachment["location"].AsString());
OSDArray objectsOSD = (OSDArray)attachment["objects"];
ObjectResourcesDetail[] objects = new ObjectResourcesDetail[objectsOSD.Count];
for (int j = 0; j < objects.Length; j++)
{
objects[j] = ObjectResourcesDetail.FromOSD(objectsOSD[j]);
}
Attachments.Add(pt, objects);
}
}
/// <summary>
/// Makes an instance based on deserialized data
/// </summary>
/// <param name="osd"><see cref="OSD"/> serialized data</param>
/// <returns>Instance containg deserialized data</returns>
public static AttachmentResourcesMessage FromOSD(OSD osd)
{
AttachmentResourcesMessage res = new AttachmentResourcesMessage();
res.Deserialize((OSDMap)osd);
return res;
}
/// <summary>
/// Detects which class handles deserialization of this message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
/// <returns>Object capable of decoding this message</returns>
public static IMessage GetMessageHandler(OSDMap map)
{
if (map == null)
{
return null;
}
else
{
return new AttachmentResourcesMessage();
}
}
}
/// <summary>Request message for parcel resource usage</summary>
public class LandResourcesRequest : IMessage
{
/// <summary>UUID of the parel to request resource usage info</summary>
public UUID ParcelID;
/// <summary>
/// Serializes object
/// </summary>
/// <returns><see cref="OSDMap"/> serialized data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(1);
map["parcel_id"] = OSD.FromUUID(ParcelID);
return map;
}
/// <summary>
/// Deserializes object from OSD
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
ParcelID = map["parcel_id"].AsUUID();
}
}
/// <summary>Response message for parcel resource usage</summary>
public class LandResourcesMessage : IMessage
{
/// <summary>URL where parcel resource usage details can be retrieved</summary>
public Uri ScriptResourceDetails;
/// <summary>URL where parcel resource usage summary can be retrieved</summary>
public Uri ScriptResourceSummary;
/// <summary>
/// Serializes object
/// </summary>
/// <returns><see cref="OSDMap"/> serialized data</returns>
public OSDMap Serialize()
{
OSDMap map = new OSDMap(1);
if (ScriptResourceSummary != null)
{
map["ScriptResourceSummary"] = OSD.FromString(ScriptResourceSummary.ToString());
}
if (ScriptResourceDetails != null)
{
map["ScriptResourceDetails"] = OSD.FromString(ScriptResourceDetails.ToString());
}
return map;
}
/// <summary>
/// Deserializes object from OSD
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public void Deserialize(OSDMap map)
{
if (map.ContainsKey("ScriptResourceSummary"))
{
ScriptResourceSummary = new Uri(map["ScriptResourceSummary"].AsString());
}
if (map.ContainsKey("ScriptResourceDetails"))
{
ScriptResourceDetails = new Uri(map["ScriptResourceDetails"].AsString());
}
}
/// <summary>
/// Detects which class handles deserialization of this message
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
/// <returns>Object capable of decoding this message</returns>
public static IMessage GetMessageHandler(OSDMap map)
{
if (map.ContainsKey("parcel_id"))
{
return new LandResourcesRequest();
}
else if (map.ContainsKey("ScriptResourceSummary"))
{
return new LandResourcesMessage();
}
return null;
}
}
/// <summary>Parcel resource usage</summary>
public class LandResourcesInfo : BaseResourcesInfo
{
/// <summary>Array of <see cref="ParcelResourcesDetail"/> containing per percal resource usage</summary>
public ParcelResourcesDetail[] Parcels;
/// <summary>
/// Deserializes object from OSD
/// </summary>
/// <param name="map">An <see cref="OSDMap"/> containing the data</param>
public override void Deserialize(OSDMap map)
{
if (map.ContainsKey("summary"))
{
base.Deserialize(map);
}
else if (map.ContainsKey("parcels"))
{
OSDArray parcelsOSD = (OSDArray)map["parcels"];
Parcels = new ParcelResourcesDetail[parcelsOSD.Count];
for (int i = 0; i < parcelsOSD.Count; i++)
{
Parcels[i] = ParcelResourcesDetail.FromOSD(parcelsOSD[i]);
}
}
}
}
#endregion Resource usage
#region Display names
/// <summary>
/// Reply to request for bunch if display names
/// </summary>
public class GetDisplayNamesMessage : IMessage
{
/// <summary> Current display name </summary>
public AgentDisplayName[] Agents = new AgentDisplayName[0];
/// <summary> Following UUIDs failed to return a valid display name </summary>
public UUID[] BadIDs = new UUID[0];
/// <summary>
/// Serializes the message
/// </summary>
/// <returns>OSD containting the messaage</returns>
public OSDMap Serialize()
{
OSDArray agents = new OSDArray();
if (Agents != null && Agents.Length > 0)
{
for (int i = 0; i < Agents.Length; i++)
{
agents.Add(Agents[i].GetOSD());
}
}
OSDArray badIDs = new OSDArray();
if (BadIDs != null && BadIDs.Length > 0)
{
for (int i = 0; i < BadIDs.Length; i++)
{
badIDs.Add(new OSDUUID(BadIDs[i]));
}
}
OSDMap ret = new OSDMap();
ret["agents"] = agents;
ret["bad_ids"] = badIDs;
return ret;
}
public void Deserialize(OSDMap map)
{
if (map["agents"].Type == OSDType.Array)
{
OSDArray osdAgents = (OSDArray)map["agents"];
if (osdAgents.Count > 0)
{
Agents = new AgentDisplayName[osdAgents.Count];
for (int i = 0; i < osdAgents.Count; i++)
{
Agents[i] = AgentDisplayName.FromOSD(osdAgents[i]);
}
}
}
if (map["bad_ids"].Type == OSDType.Array)
{
OSDArray osdBadIDs = (OSDArray)map["bad_ids"];
if (osdBadIDs.Count > 0)
{
BadIDs = new UUID[osdBadIDs.Count];
for (int i = 0; i < osdBadIDs.Count; i++)
{
BadIDs[i] = osdBadIDs[i];
}
}
}
}
}
/// <summary>
/// Message sent when requesting change of the display name
/// </summary>
public class SetDisplayNameMessage : IMessage
{
/// <summary> Current display name </summary>
public string OldDisplayName;
/// <summary> Desired new display name </summary>
public string NewDisplayName;
/// <summary>
/// Serializes the message
/// </summary>
/// <returns>OSD containting the messaage</returns>
public OSDMap Serialize()
{
OSDArray names = new OSDArray(2);
names.Add(OldDisplayName);
names.Add(NewDisplayName);
OSDMap name = new OSDMap();
name["display_name"] = names;
return name;
}
public void Deserialize(OSDMap map)
{
OSDArray names = (OSDArray)map["display_name"];
OldDisplayName = names[0];
NewDisplayName = names[1];
}
}
/// <summary>
/// Message recieved in response to request to change display name
/// </summary>
public class SetDisplayNameReplyMessage : IMessage
{
/// <summary> New display name </summary>
public AgentDisplayName DisplayName;
/// <summary> String message indicating the result of the operation </summary>
public string Reason;
/// <summary> Numerical code of the result, 200 indicates success </summary>
public int Status;
/// <summary>
/// Serializes the message
/// </summary>
/// <returns>OSD containting the messaage</returns>
public OSDMap Serialize()
{
OSDMap agent = (OSDMap)DisplayName.GetOSD();
OSDMap ret = new OSDMap();
ret["content"] = agent;
ret["reason"] = Reason;
ret["status"] = Status;
return ret;
}
public void Deserialize(OSDMap map)
{
OSDMap agent = (OSDMap)map["content"];
DisplayName = AgentDisplayName.FromOSD(agent);
Reason = map["reason"];
Status = map["status"];
}
}
/// <summary>
/// Message recieved when someone nearby changes their display name
/// </summary>
public class DisplayNameUpdateMessage : IMessage
{
/// <summary> Previous display name, empty string if default </summary>
public string OldDisplayName;
/// <summary> New display name </summary>
public AgentDisplayName DisplayName;
/// <summary>
/// Serializes the message
/// </summary>
/// <returns>OSD containting the messaage</returns>
public OSDMap Serialize()
{
OSDMap agent = (OSDMap)DisplayName.GetOSD();
agent["old_display_name"] = OldDisplayName;
OSDMap ret = new OSDMap();
ret["agent"] = agent;
return ret;
}
public void Deserialize(OSDMap map)
{
OSDMap agent = (OSDMap)map["agent"];
DisplayName = AgentDisplayName.FromOSD(agent);
OldDisplayName = agent["old_display_name"];
}
}
#endregion Display names
}
Reference in New Issue View Git Blame Copy Permalink