corrade-vassal – Rev 1
?pathlinks?
/*
* 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 AssetType 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 = (AssetType)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
}